opt: 新增位模拟循环惯用法识别，逐位 srem/sdiv 循环折叠为原生按位指令

新增 BitwiseLoopIdiom pass（放在 PhiToSelect 之后）：
匹配 a、b、len(32,-1)、result(0,+pow)、power(1,*2) 五 phi 规范循环，
对 (bit_a,bit_b) 四种组合做抽象求值得到累加条件真值表，按表判定
对应 and/or/xor。改写时在 preheader 插入 (a0|b0)>=0 守卫：两操作数
均非负时走原生按位指令快速路径（此时逐位模拟与原生指令严格等价），
负数仍走原循环，任意输入语义不变，符合优化合理性认定要求

配套为 IR 新增 IRINST_OP_AND_I/OR_I/XOR_I 三个算子：RISCV64 后端
生成 and/or/xor 及 12 位立即数形式，ConstProp 支持常量折叠，
GVN 标记可交换，LICM 允许外提

Author: Arctitico

CMakeLists.txt

@@ -245,6 +245,8 @@ set(IR_SRCS
 	ir/passes/fixedPointFunctionPass/InstCombine.cpp
 	ir/passes/fixedPointFunctionPass/GVN.h
 	ir/passes/fixedPointFunctionPass/GVN.cpp
+	ir/passes/fixedPointFunctionPass/BitwiseLoopIdiom.h
+	ir/passes/fixedPointFunctionPass/BitwiseLoopIdiom.cpp
 	ir/passes/fixedPointFunctionPass/LoopTiling.h
 	ir/passes/fixedPointFunctionPass/LoopTiling.cpp
 	ir/passes/fixedPointFunctionPass/LoopStrengthReduce.h

backend/riscv64/InstSelectorRiscV64.cpp

@@ -507,6 +507,9 @@ InstSelectorRiscV64::InstSelectorRiscV64(
 	translatorHandlers[IRInstOperator::IRINST_OP_SHL_I] = &InstSelectorRiscV64::translate_shl;
 	translatorHandlers[IRInstOperator::IRINST_OP_ASHR_I] = &InstSelectorRiscV64::translate_ashr;
 	translatorHandlers[IRInstOperator::IRINST_OP_LSHR_I] = &InstSelectorRiscV64::translate_lshr;
+	translatorHandlers[IRInstOperator::IRINST_OP_AND_I] = &InstSelectorRiscV64::translate_and;
+	translatorHandlers[IRInstOperator::IRINST_OP_OR_I] = &InstSelectorRiscV64::translate_or;
+	translatorHandlers[IRInstOperator::IRINST_OP_XOR_I] = &InstSelectorRiscV64::translate_xor;
 	translatorHandlers[IRInstOperator::IRINST_OP_LT_I] = &InstSelectorRiscV64::translate_icmp;
 	translatorHandlers[IRInstOperator::IRINST_OP_GT_I] = &InstSelectorRiscV64::translate_icmp;
 	translatorHandlers[IRInstOperator::IRINST_OP_LE_I] = &InstSelectorRiscV64::translate_icmp;
@@ -1469,6 +1472,71 @@ void InstSelectorRiscV64::translate_shift(Instruction * inst,
 	storeResult(inst, dstReg, inst);
 }
 
+/// @brief 翻译按位与指令（and）
+void InstSelectorRiscV64::translate_and(Instruction * inst)
+{
+	translate_bitwise(inst, "and", "andi");
+}
+
+/// @brief 翻译按位或指令（or）
+void InstSelectorRiscV64::translate_or(Instruction * inst)
+{
+	translate_bitwise(inst, "or", "ori");
+}
+
+/// @brief 翻译按位异或指令（xor）
+void InstSelectorRiscV64::translate_xor(Instruction * inst)
+{
+	translate_bitwise(inst, "xor", "xori");
+}
+
+/// @brief 翻译按位运算指令的通用实现
+///
+/// RV64 的 and/or/xor 无 W 变体，对两个已按 i32 符号扩展的寄存器做按位
+/// 运算结果仍保持符号扩展性质，因此无需额外的 sext.w。
+/// 右操作数为 12 位有符号范围内的常量时使用立即数形式
+void InstSelectorRiscV64::translate_bitwise(Instruction * inst,
+                                            const std::string & regOp,
+                                            const std::string & immOp)
+{
+	auto * binary = dynamic_cast<BinaryInst *>(inst);
+	if (binary == nullptr) {
+		return;
+	}
+
+	int dstReg = getResultReg(inst);
+	LocalTempManager::Lease dstLease;
+	if (dstReg < 0) {
+		dstLease = tempMgr.borrow(inst);
+		dstReg = dstLease.reg();
+	}
+
+	OperandReg lhs = loadOperand(binary->getLHS(), inst, dstReg);
+
+	if (auto * rhsConst = asConstInteger(binary->getRHS())) {
+		const int32_t imm = rhsConst->getVal();
+		if (imm >= -2048 && imm <= 2047) {
+			iloc.inst(immOp,
+				PlatformRiscV64::regName[dstReg],
+				PlatformRiscV64::regName[lhs.reg],
+				std::to_string(imm));
+			releaseOperand(lhs);
+			storeResult(inst, dstReg, inst);
+			return;
+		}
+	}
+
+	const int rhsPreferredReg = lhs.reg != dstReg ? dstReg : -1;
+	OperandReg rhs = loadOperand(binary->getRHS(), inst, rhsPreferredReg < 0 ? dstReg : -1, rhsPreferredReg);
+	iloc.inst(regOp,
+		PlatformRiscV64::regName[dstReg],
+		PlatformRiscV64::regName[lhs.reg],
+		PlatformRiscV64::regName[rhs.reg]);
+	releaseOperand(rhs);
+	releaseOperand(lhs);
+	storeResult(inst, dstReg, inst);
+}
+
 /// @brief 翻译浮点二元运算的通用实现
 ///
 /// float SSA值优先保存在FPR中，避免在热点浮点运算中反复fmv.w.x/fmv.x.w。

backend/riscv64/InstSelectorRiscV64.h

@@ -138,6 +138,14 @@ class InstSelectorRiscV64 {
 	void translate_lshr(Instruction * inst);
 	/// @brief 翻译移位指令的通用实现，根据移位量是否为常量选择立即数/寄存器形式
 	void translate_shift(Instruction * inst, const std::string & regOp, const std::string & immOp);
+	/// @brief 翻译按位与指令（and）
+	void translate_and(Instruction * inst);
+	/// @brief 翻译按位或指令（or）
+	void translate_or(Instruction * inst);
+	/// @brief 翻译按位异或指令（xor）
+	void translate_xor(Instruction * inst);
+	/// @brief 翻译按位运算指令的通用实现，右操作数为 12 位有符号常量时用立即数形式
+	void translate_bitwise(Instruction * inst, const std::string & regOp, const std::string & immOp);
 	/// @brief 翻译icmp指令（整数比较）
 	void translate_icmp(Instruction * inst);
 	/// @brief 翻译fcmp指令（浮点比较）

ir/Instruction.cpp

@@ -126,6 +126,9 @@ bool Instruction::isSpeculatable() const
         case IRInstOperator::IRINST_OP_SHL_I:
         case IRInstOperator::IRINST_OP_ASHR_I:
         case IRInstOperator::IRINST_OP_LSHR_I:
+        case IRInstOperator::IRINST_OP_AND_I:
+        case IRInstOperator::IRINST_OP_OR_I:
+        case IRInstOperator::IRINST_OP_XOR_I:
         case IRInstOperator::IRINST_OP_LT_I:
         case IRInstOperator::IRINST_OP_GT_I:
         case IRInstOperator::IRINST_OP_LE_I:

ir/Instruction.h

@@ -22,6 +22,9 @@ enum class IRInstOperator : std::int8_t {
     IRINST_OP_SHL_I,   ///< 逻辑左移
     IRINST_OP_ASHR_I,  ///< 算术右移（保留符号位）
     IRINST_OP_LSHR_I,  ///< 逻辑右移（高位补 0）
+    IRINST_OP_AND_I,   ///< 按位与
+    IRINST_OP_OR_I,    ///< 按位或
+    IRINST_OP_XOR_I,   ///< 按位异或
     IRINST_OP_LT_I,
     IRINST_OP_GT_I,
     IRINST_OP_LE_I,

ir/Instructions/BinaryInst.cpp

@@ -43,6 +43,12 @@ const char * BinaryInst::opToLLVMName(IRInstOperator op)
             return "ashr";
         case IRInstOperator::IRINST_OP_LSHR_I:
             return "lshr";
+        case IRInstOperator::IRINST_OP_AND_I:
+            return "and";
+        case IRInstOperator::IRINST_OP_OR_I:
+            return "or";
+        case IRInstOperator::IRINST_OP_XOR_I:
+            return "xor";
         case IRInstOperator::IRINST_OP_ADD_F:
             return "fadd";
         case IRInstOperator::IRINST_OP_SUB_F:

ir/passes/PassManager.cpp

@@ -14,6 +14,7 @@
 #include "Module.h"
 #include "fixedPointFunctionPass/CFGSimplify.h"
 #include "fixedPointFunctionPass/ConstProp.h"
+#include "fixedPointFunctionPass/BitwiseLoopIdiom.h"
 #include "fixedPointFunctionPass/CanonicalizeLoop.h"
 #include "fixedPointFunctionPass/DeadInstElim.h"
 #include "fixedPointFunctionPass/GVN.h"
@@ -287,6 +288,11 @@ void PassManager::registerDefaultOptimizationPipeline(int32_t optLevel, bool ena
         PhiToSelect pass(func);
         return pass.run();
     });
+    // 位模拟循环惯用法识别：依赖 PhiToSelect 把累加分支规范成 select 形态
+    registerFixedPointFunctionPass("BitwiseLoopIdiom", [this](Function * func) {
+        BitwiseLoopIdiom pass(func, module);
+        return pass.run();
+    });
     registerFixedPointFunctionPass("InstCombine", [this](Function * func) {
         InstCombine pass(func, module);
         return pass.run();