diff --git a/src/main/java/org/jcnc/snow/compiler/backend/utils/IROpCodeMapper.java b/src/main/java/org/jcnc/snow/compiler/backend/utils/IROpCodeMapper.java
index 31c0033..393e8a5 100644
--- a/src/main/java/org/jcnc/snow/compiler/backend/utils/IROpCodeMapper.java
+++ b/src/main/java/org/jcnc/snow/compiler/backend/utils/IROpCodeMapper.java
@@ -82,34 +82,66 @@ public final class IROpCodeMapper {
         opcodeMap.put(IROpCode.NEG_D64, "D_NEG");
 
         // 比较运算映射
-        // 整形32位比较运算映射
-        opcodeMap.put(IROpCode.CMP_IEQ, "IC_E");   // 相等
-        opcodeMap.put(IROpCode.CMP_INE, "IC_NE");   // 不等
-        opcodeMap.put(IROpCode.CMP_ILT, "IC_L");    // 小于
-        opcodeMap.put(IROpCode.CMP_IGT, "IC_G");    // 大于
-        opcodeMap.put(IROpCode.CMP_ILE, "IC_LE");   // 小于等于
-        opcodeMap.put(IROpCode.CMP_IGE, "IC_GE");   // 大于等于
+        // 8位整数比较运算映射
+        opcodeMap.put(IROpCode.CMP_BEQ, "B_CE");    // 相等
+        opcodeMap.put(IROpCode.CMP_BNE, "B_CNE");   // 不等
+        opcodeMap.put(IROpCode.CMP_BLT, "B_CL");    // 小于
+        opcodeMap.put(IROpCode.CMP_BGT, "B_CG");    // 大于
+        opcodeMap.put(IROpCode.CMP_BLE, "B_CLE");   // 小于等于
+        opcodeMap.put(IROpCode.CMP_BGE, "B_CGE");   // 大于等于
 
-        // 整形64位比较运算映射
-        opcodeMap.put(IROpCode.CMP_LEQ, "LC_E");   // 相等
-        opcodeMap.put(IROpCode.CMP_LNE, "LC_NE");   // 不等
-        opcodeMap.put(IROpCode.CMP_LLT, "LC_L");    // 小于
-        opcodeMap.put(IROpCode.CMP_LGT, "LC_G");    // 大于
-        opcodeMap.put(IROpCode.CMP_LLE, "LC_LE");   // 小于等于
-        opcodeMap.put(IROpCode.CMP_LGE, "LC_GE");   // 大于等于
+        // 16位整数比较运算映射
+        opcodeMap.put(IROpCode.CMP_SEQ, "S_CE");    // 相等
+        opcodeMap.put(IROpCode.CMP_SNE, "S_CNE");   // 不等
+        opcodeMap.put(IROpCode.CMP_SLT, "S_CL");    // 小于
+        opcodeMap.put(IROpCode.CMP_SGT, "S_CG");    // 大于
+        opcodeMap.put(IROpCode.CMP_SLE, "S_CLE");   // 小于等于
+        opcodeMap.put(IROpCode.CMP_SGE, "S_CGE");   // 大于等于
+
+        // 32位整数比较运算映射
+        opcodeMap.put(IROpCode.CMP_IEQ, "I_CE");    // 相等
+        opcodeMap.put(IROpCode.CMP_INE, "I_CNE");   // 不等
+        opcodeMap.put(IROpCode.CMP_ILT, "I_CL");    // 小于
+        opcodeMap.put(IROpCode.CMP_IGT, "I_CG");    // 大于
+        opcodeMap.put(IROpCode.CMP_ILE, "I_CLE");   // 小于等于
+        opcodeMap.put(IROpCode.CMP_IGE, "I_CGE");   // 大于等于
+
+        // 64位整数比较运算映射
+        opcodeMap.put(IROpCode.CMP_LEQ, "L_CE");    // 相等
+        opcodeMap.put(IROpCode.CMP_LNE, "L_CNE");   // 不等
+        opcodeMap.put(IROpCode.CMP_LLT, "L_CL");    // 小于
+        opcodeMap.put(IROpCode.CMP_LGT, "L_CG");    // 大于
+        opcodeMap.put(IROpCode.CMP_LLE, "L_CLE");   // 小于等于
+        opcodeMap.put(IROpCode.CMP_LGE, "L_CGE");   // 大于等于
+
+        // 32位浮点比较运算映射
+        opcodeMap.put(IROpCode.CMP_FEQ, "F_CE");    // 相等
+        opcodeMap.put(IROpCode.CMP_FNE, "F_CNE");   // 不等
+        opcodeMap.put(IROpCode.CMP_FLT, "F_CL");    // 小于
+        opcodeMap.put(IROpCode.CMP_FGT, "F_CG");    // 大于
+        opcodeMap.put(IROpCode.CMP_FLE, "F_CLE");   // 小于等于
+        opcodeMap.put(IROpCode.CMP_FGE, "F_CGE");   // 大于等于
+
+        // 64位浮点比较运算映射
+        opcodeMap.put(IROpCode.CMP_DEQ, "D_CE");    // 相等
+        opcodeMap.put(IROpCode.CMP_DNE, "D_CNE");   // 不等
+        opcodeMap.put(IROpCode.CMP_DLT, "D_CL");    // 小于
+        opcodeMap.put(IROpCode.CMP_DGT, "D_CG");    // 大于
+        opcodeMap.put(IROpCode.CMP_DLE, "D_CLE");   // 小于等于
+        opcodeMap.put(IROpCode.CMP_DGE, "D_CGE");   // 大于等于
 
         // 加载与存储
-        opcodeMap.put(IROpCode.LOAD, "I_LOAD");  // 加载
-        opcodeMap.put(IROpCode.STORE, "I_STORE"); // 存储
-        opcodeMap.put(IROpCode.CONST, "I_PUSH");  // 常量入栈
+        opcodeMap.put(IROpCode.LOAD, "I_LOAD");     // 加载
+        opcodeMap.put(IROpCode.STORE, "I_STORE");   // 存储
+        opcodeMap.put(IROpCode.CONST, "I_PUSH");    // 常量入栈
 
         // 跳转与标签
-        opcodeMap.put(IROpCode.JUMP, "JMP");     // 无条件跳转
-        opcodeMap.put(IROpCode.LABEL, "LABEL");   // 标签
+        opcodeMap.put(IROpCode.JUMP, "JMP");        // 无条件跳转
+        opcodeMap.put(IROpCode.LABEL, "LABEL");     // 标签
 
         // 函数相关
-        opcodeMap.put(IROpCode.CALL, "CALL");    // 调用
-        opcodeMap.put(IROpCode.RET, "RET");     // 返回
+        opcodeMap.put(IROpCode.CALL, "CALL");       // 调用
+        opcodeMap.put(IROpCode.RET, "RET");         // 返回
     }
 
     /**
diff --git a/src/main/java/org/jcnc/snow/compiler/ir/core/IROpCode.java b/src/main/java/org/jcnc/snow/compiler/ir/core/IROpCode.java
index c45a454..1e6b3e7 100644
--- a/src/main/java/org/jcnc/snow/compiler/ir/core/IROpCode.java
+++ b/src/main/java/org/jcnc/snow/compiler/ir/core/IROpCode.java
@@ -66,21 +66,53 @@ public enum IROpCode {
     DIV_D64,   // 64位浮点除法
     NEG_D64,   // 64位浮点取负
 
+    /* ───── 逻辑与比较运算指令（8位整数：byte） ───── */
+    CMP_BEQ,    // 8位整数相等比较：a == b
+    CMP_BNE,    // 8位整数不等比较：a != b
+    CMP_BLT,    // 8位整数小于比较：a < b
+    CMP_BGT,    // 8位整数大于比较：a > b
+    CMP_BLE,    // 8位整数小于等于：a <= b
+    CMP_BGE,    // 8位整数大于等于：a >= b
+
+    /* ───── 逻辑与比较运算指令（16位整数：int） ───── */
+    CMP_SEQ,    // 16位整数相等比较：a == b
+    CMP_SNE,    // 16位整数不等比较：a != b
+    CMP_SLT,    // 16位整数小于比较：a < b
+    CMP_SGT,    // 16位整数大于比较：a > b
+    CMP_SLE,    // 16位整数小于等于：a <= b
+    CMP_SGE,    // 16位整数大于等于：a >= b
+
     /* ───── 逻辑与比较运算指令（32位整数：int） ───── */
-    CMP_IEQ,    // 32位相等比较：a == b
-    CMP_INE,    // 32位不等比较：a != b
-    CMP_ILT,    // 32位小于比较：a < b
-    CMP_IGT,    // 32位大于比较：a > b
-    CMP_ILE,    // 32位小于等于：a <= b
-    CMP_IGE,    // 32位大于等于：a >= b
+    CMP_IEQ,    // 32位整数相等比较：a == b
+    CMP_INE,    // 32位整数不等比较：a != b
+    CMP_ILT,    // 32位整数小于比较：a < b
+    CMP_IGT,    // 32位整数大于比较：a > b
+    CMP_ILE,    // 32位整数小于等于：a <= b
+    CMP_IGE,    // 32位整数大于等于：a >= b
 
     /* ───── 逻辑与比较运算指令（64位整数：long） ───── */
-    CMP_LEQ,    // 64位相等比较：a == b
-    CMP_LNE,    // 64位不等比较：a != b
-    CMP_LLT,    // 64位小于比较：a < b
-    CMP_LGT,    // 64位大于比较：a > b
-    CMP_LLE,    // 64位小于等于：a <= b
-    CMP_LGE,    // 64位大于等于：a >= b
+    CMP_LEQ,    // 64位整数相等比较：a == b
+    CMP_LNE,    // 64位整数不等比较：a != b
+    CMP_LLT,    // 64位整数小于比较：a < b
+    CMP_LGT,    // 64位整数大于比较：a > b
+    CMP_LLE,    // 64位整数小于等于：a <= b
+    CMP_LGE,    // 64位整数大于等于：a >= b
+
+    /* ───── 逻辑与比较运算指令（32位浮点数：float） ───── */
+    CMP_FEQ,    // 32位浮点相等比较：a == b
+    CMP_FNE,    // 32位浮点不等比较：a != b
+    CMP_FLT,    // 32位浮点小于比较：a < b
+    CMP_FGT,    // 32位浮点大于比较：a > b
+    CMP_FLE,    // 32位浮点小于等于：a <= b
+    CMP_FGE,    // 32位浮点大于等于：a >= b
+
+    /* ───── 逻辑与比较运算指令（64位浮点数：double） ───── */
+    CMP_DEQ,    // 64位浮点相等比较：a == b
+    CMP_DNE,    // 64位浮点不等比较：a != b
+    CMP_DLT,    // 64位浮点小于比较：a < b
+    CMP_DGT,    // 64位浮点大于比较：a > b
+    CMP_DLE,    // 64位浮点小于等于：a <= b
+    CMP_DGE,    // 64位浮点大于等于：a >= b
 
     /* ───── 数据访问与常量操作 ───── */
     LOAD,      // 从内存加载数据至寄存器
diff --git a/src/main/java/org/jcnc/snow/compiler/ir/core/IROpCodeMappings.java b/src/main/java/org/jcnc/snow/compiler/ir/core/IROpCodeMappings.java
index 32593d9..92677a6 100644
--- a/src/main/java/org/jcnc/snow/compiler/ir/core/IROpCodeMappings.java
+++ b/src/main/java/org/jcnc/snow/compiler/ir/core/IROpCodeMappings.java
@@ -40,6 +40,26 @@ public final class IROpCodeMappings {
     );
 
     /* ────── 比较运算符映射 ────── */
+    /** 8-bit（byte）比较 */
+    public static final Map<String, IROpCode> CMP_B8 = Map.of(
+            "==", IROpCode.CMP_BEQ,
+            "!=", IROpCode.CMP_BNE,
+            "<",  IROpCode.CMP_BLT,
+            ">",  IROpCode.CMP_BGT,
+            "<=", IROpCode.CMP_BLE,
+            ">=", IROpCode.CMP_BGE
+    );
+
+    /** 16-bit（short）比较 */
+    public static final Map<String, IROpCode> CMP_S16 = Map.of(
+            "==", IROpCode.CMP_SEQ,
+            "!=", IROpCode.CMP_SNE,
+            "<",  IROpCode.CMP_SLT,
+            ">",  IROpCode.CMP_SGT,
+            "<=", IROpCode.CMP_SLE,
+            ">=", IROpCode.CMP_SGE
+    );
+
     /** 32-bit（int）比较 */
     public static final Map<String, IROpCode> CMP_I32 = Map.of(
             "==", IROpCode.CMP_IEQ,
@@ -60,5 +80,23 @@ public final class IROpCodeMappings {
             ">=", IROpCode.CMP_LGE
     );
 
-    
+    /** 32-bit（float）比较 */
+    public static final Map<String, IROpCode> CMP_F32 = Map.of(
+            "==", IROpCode.CMP_FEQ,
+            "!=", IROpCode.CMP_FNE,
+            "<",  IROpCode.CMP_FLT,
+            ">",  IROpCode.CMP_FGT,
+            "<=", IROpCode.CMP_FLE,
+            ">=", IROpCode.CMP_FGE
+    );
+
+    /** 64-bit（double）比较 */
+    public static final Map<String, IROpCode> CMP_D64 = Map.of(
+            "==", IROpCode.CMP_DEQ,
+            "!=", IROpCode.CMP_DNE,
+            "<",  IROpCode.CMP_DLT,
+            ">",  IROpCode.CMP_DGT,
+            "<=", IROpCode.CMP_DLE,
+            ">=", IROpCode.CMP_DGE
+    );
 }