UImm encoding for mov operations (ruby#147)

kddnewton · web-flow · commit 79c083e08310 · 2022-02-10T12:51:33.000-05:00
diff --git a/yjit/src/asm/x86_64/mod.rs b/yjit/src/asm/x86_64/mod.rs
@@ -1201,6 +1201,33 @@ pub fn mov(cb: &mut CodeBlock, dst: X86Opnd, src: X86Opnd) {
                 cb.write_int(imm.value as u64, reg.num_bits.into());
             }
         },
+        // R + UImm
+        (X86Opnd::Reg(reg), X86Opnd::UImm(uimm)) => {
+            assert!(uimm.num_bits <= reg.num_bits);
+
+            // In case the source immediate could be zero extended to be 64
+            // bit, we can use the 32-bit operands version of the instruction.
+            // For example, we can turn mov(rax, 0x34) into the equivalent
+            // mov(eax, 0x34).
+            if (reg.num_bits == 64) && (uimm.value <= u32::MAX.into()) {
+                if dst.rex_needed() {
+                    write_rex(cb, false, 0, 0, reg.reg_no);
+                }
+                write_opcode(cb, 0xB8, reg);
+                cb.write_int(uimm.value, 32);
+            } else {
+                if reg.num_bits == 16 {
+                    cb.write_byte(0x66);
+                }
+
+                if dst.rex_needed() || reg.num_bits == 64 {
+                    write_rex(cb, reg.num_bits == 64, 0, 0, reg.reg_no);
+                }
+
+                write_opcode(cb, if reg.num_bits == 8 { 0xb0 } else { 0xb8 }, reg);
+                cb.write_int(uimm.value, reg.num_bits.into());
+            }
+        },
         // M + Imm
         (X86Opnd::Mem(mem), X86Opnd::Imm(imm)) => {
             assert!(imm.num_bits <= mem.num_bits);
diff --git a/yjit/src/asm/x86_64/tests.rs b/yjit/src/asm/x86_64/tests.rs
@@ -162,6 +162,47 @@ fn test_mov() {
     check_bytes("48c742f8f4ffffff", |cb| mov(cb, mem_opnd(64, RDX, -8), imm_opnd(-12)));
 }
 
+#[test]
+fn test_mov_unsigned() {
+    // MOV AL, moffs8
+    check_bytes("b001", |cb| mov(cb, AL, uimm_opnd(1)));
+    check_bytes("b0ff", |cb| mov(cb, AL, uimm_opnd(u8::MAX.into())));
+
+    // MOV AX, moffs16
+    check_bytes("66b80100", |cb| mov(cb, AX, uimm_opnd(1)));
+    check_bytes("66b8ffff", |cb| mov(cb, AX, uimm_opnd(u16::MAX.into())));
+
+    // MOV EAX, moffs32
+    check_bytes("b801000000", |cb| mov(cb, EAX, uimm_opnd(1)));
+    check_bytes("b8ffffffff", |cb| mov(cb, EAX, uimm_opnd(u32::MAX.into())));
+
+    // MOV RAX, moffs64, will move down into EAX since it fits into 32 bits
+    check_bytes("b801000000", |cb| mov(cb, RAX, uimm_opnd(1)));
+    check_bytes("b8ffffffff", |cb| mov(cb, RAX, uimm_opnd(u32::MAX.into())));
+
+    // MOV RAX, moffs64, will not move down into EAX since it does not fit into 32 bits
+    check_bytes("48b80000000001000000", |cb| mov(cb, RAX, uimm_opnd(u32::MAX as u64 + 1)));
+    check_bytes("48b8ffffffffffffffff", |cb| mov(cb, RAX, uimm_opnd(u64::MAX.into())));
+
+    // MOV r8, imm8
+    check_bytes("41b001", |cb| mov(cb, R8B, uimm_opnd(1)));
+    check_bytes("41b0ff", |cb| mov(cb, R8B, uimm_opnd(u8::MAX.into())));
+
+    // MOV r16, imm16
+    check_bytes("6641b80100", |cb| mov(cb, R8W, uimm_opnd(1)));
+    check_bytes("6641b8ffff", |cb| mov(cb, R8W, uimm_opnd(u16::MAX.into())));
+
+    // MOV r32, imm32
+    check_bytes("41b801000000", |cb| mov(cb, R8D, uimm_opnd(1)));
+    check_bytes("41b8ffffffff", |cb| mov(cb, R8D, uimm_opnd(u32::MAX.into())));
+
+    // MOV r64, imm64, will move down into 32 bit since it fits into 32 bits
+    check_bytes("41b801000000", |cb| mov(cb, R8, uimm_opnd(1)));
+
+    // MOV r64, imm64, will not move down into 32 bit since it does not fit into 32 bits
+    check_bytes("49b8ffffffffffffffff", |cb| mov(cb, R8, uimm_opnd(u64::MAX)));
+}
+
 #[test]
 fn test_movsx() {
     check_bytes("660fbec0", |cb| movsx(cb, AX, AL));
diff --git a/yjit/src/codegen.rs b/yjit/src/codegen.rs
@@ -437,13 +437,9 @@ fn gen_exit(exit_pc: *mut VALUE, ctx: &Context, cb: &mut CodeBlock) -> CodePtr
     pop(cb, REG_EC);
     pop(cb, REG_CFP);
 
-    //mov(cb, RAX, uimm_opnd(Qundef.into()));
+    mov(cb, RAX, uimm_opnd(Qundef.into()));
     ret(cb);
 
-
-    todo!("missing uimm");
-
-
     return code_ptr;
 }
 
@@ -1137,9 +1133,8 @@ mod tests {
     fn test_gen_exit() {
         let (_, ctx, mut cb, _) = setup_codegen();
 
-        // TODO: missing encoding of uimm operands
-        //gen_exit(0 as *mut VALUE, &ctx, &mut cb);
-        //assert!(cb.get_write_pos() > 0);
+        gen_exit(0 as *mut VALUE, &ctx, &mut cb);
+        assert!(cb.get_write_pos() > 0);
     }
 
     #[test]
