RJIT: Use lambda constants to match operands

1 files changed, 54 insertions, 12 deletions

diff --git a/test/ruby/rjit/test_assembler.rb b/test/ruby/rjit/test_assembler.rb
index d32f6676db..a1f8e9dc2a 100644
--- a/test/ruby/rjit/test_assembler.rb
+++ b/test/ruby/rjit/test_assembler.rb
@@ -111,9 +111,23 @@ module RubyVM::RJIT
 
     def test_cmp
       asm = Assembler.new
-      asm.cmp(:rax, 0)          # CMP r/m64, imm8 (Mod 11: reg)
+      asm.cmp(BytePtr[:rax, 8], 8)      # CMP r/m8, imm8 (Mod 01: [reg]+disp8)
+      asm.cmp(DwordPtr[:rax, 8], 0x100) # CMP r/m32, imm32 (Mod 01: [reg]+disp8)
+      asm.cmp([:rax, 8], 8)             # CMP r/m64, imm8 (Mod 01: [reg]+disp8)
+      asm.cmp([:rax, 0x100], 8)         # CMP r/m64, imm8 (Mod 10: [reg]+disp32)
+      asm.cmp(:rax, 8)                  # CMP r/m64, imm8 (Mod 11: reg)
+      asm.cmp(:rax, 0x100)              # CMP r/m64, imm32 (Mod 11: reg)
+      asm.cmp([:rax, 8], :rbx)          # CMP r/m64, r64 (Mod 01: [reg]+disp8)
+      asm.cmp(:rax, :rbx)               # CMP r/m64, r64 (Mod 11: reg)
       assert_compile(asm, <<~EOS)
-        0x0: cmp rax, 0
+        0x0: cmp byte ptr [rax + 8], 8
+        0x4: cmp dword ptr [rax + 8], 0x100
+        0xb: cmp qword ptr [rax + 8], 8
+        0x10: cmp qword ptr [rax + 0x100], 8
+        0x18: cmp rax, 8
+        0x1c: cmp rax, 0x100
+        0x23: cmp qword ptr [rax + 8], rbx
+        0x27: cmp rax, rbx
       EOS
     end
 
@@ -201,19 +215,45 @@ module RubyVM::RJIT
 
     def test_mov
       asm = Assembler.new
-      asm.mov(:rax, :rbx)      # MOV r64, r/m64 (Mod 00: [reg])
-      asm.mov(:rax, [:rbx, 8]) # MOV r64, r/m64 (Mod 01: [reg]+disp8)
+      asm.mov(:eax, DwordPtr[:rbx, 8])  # MOV r32 r/m32 (Mod 01: [reg]+disp8)
+      asm.mov(:eax, 0x100)              # MOV r32, imm32 (Mod 11: reg)
+      asm.mov(:rax, [:rbx])             # MOV r64, r/m64 (Mod 00: [reg])
+      asm.mov(:rax, [:rbx, 8])          # MOV r64, r/m64 (Mod 01: [reg]+disp8)
+      asm.mov(:rax, [:rbx, 0x100])      # MOV r64, r/m64 (Mod 10: [reg]+disp32)
+      asm.mov(:rax, :rbx)               # MOV r64, r/m64 (Mod 11: reg)
+      asm.mov(:rax, 0x100)              # MOV r/m64, imm32 (Mod 11: reg)
+      asm.mov(:rax, 0x100000000)        # MOV r64, imm64
+      asm.mov(DwordPtr[:rax, 8], 0x100) # MOV r/m32, imm32 (Mod 01: [reg]+disp8)
+      asm.mov([:rax], 0x100)            # MOV r/m64, imm32 (Mod 00: [reg])
+      asm.mov([:rax], :rbx)             # MOV r/m64, r64 (Mod 00: [reg])
+      asm.mov([:rax, 8], 0x100)         # MOV r/m64, imm32 (Mod 01: [reg]+disp8)
+      asm.mov([:rax, 8], :rbx)          # MOV r/m64, r64 (Mod 01: [reg]+disp8)
+      asm.mov([:rax, 0x100], 0x100)     # MOV r/m64, imm32 (Mod 10: [reg]+disp32)
+      asm.mov([:rax, 0x100], :rbx)      # MOV r/m64, r64 (Mod 10: [reg]+disp32)
       assert_compile(asm, <<~EOS)
-        0x0: mov rax, rbx
-        0x3: mov rax, qword ptr [rbx + 8]
+        0x0: mov eax, dword ptr [rbx + 8]
+        0x3: mov eax, 0x100
+        0x8: mov rax, qword ptr [rbx]
+        0xb: mov rax, qword ptr [rbx + 8]
+        0xf: mov rax, qword ptr [rbx + 0x100]
+        0x16: mov rax, rbx
+        0x19: mov rax, 0x100
+        0x20: movabs rax, 0x100000000
+        0x2a: mov dword ptr [rax + 8], 0x100
+        0x31: mov qword ptr [rax], 0x100
+        0x38: mov qword ptr [rax], rbx
+        0x3b: mov qword ptr [rax + 8], 0x100
+        0x43: mov qword ptr [rax + 8], rbx
+        0x47: mov qword ptr [rax + 0x100], 0x100
+        0x52: mov qword ptr [rax + 0x100], rbx
       EOS
     end
 
     def test_or
       asm = Assembler.new
-      asm.or(:rax, 0)          # OR r/m64, imm8 (Mod 11: reg)
-      asm.or(:rax, 0xffff)     # OR r/m64, imm32 (Mod 11: reg)
-      asm.or(:rax, [:rbx, 8])  # OR r64, r/m64 (Mod 01: [reg]+disp8)
+      asm.or(:rax, 0)         # OR r/m64, imm8 (Mod 11: reg)
+      asm.or(:rax, 0xffff)    # OR r/m64, imm32 (Mod 11: reg)
+      asm.or(:rax, [:rbx, 8]) # OR r64, r/m64 (Mod 01: [reg]+disp8)
       assert_compile(asm, <<~EOS)
         0x0: or rax, 0
         0x4: or rax, 0xffff
@@ -245,7 +285,7 @@ module RubyVM::RJIT
 
     def test_sar
       asm = Assembler.new
-      asm.sar(:rax, 0)          # SAR r/m64, imm8 (Mod 11: reg)
+      asm.sar(:rax, 0) # SAR r/m64, imm8 (Mod 11: reg)
       assert_compile(asm, <<~EOS)
         0x0: sar rax, 0
       EOS
@@ -253,9 +293,11 @@ module RubyVM::RJIT
 
     def test_sub
       asm = Assembler.new
-      asm.sub(:rax, 0)          # SUB r/m64, imm8 (Mod 11: reg)
+      asm.sub(:rax, 8)    # SUB r/m64, imm8 (Mod 11: reg)
+      asm.sub(:rax, :rbx) # SUB r/m64, r64 (Mod 11: reg)
       assert_compile(asm, <<~EOS)
-        0x0: sub rax, 0
+        0x0: sub rax, 8
+        0x4: sub rax, rbx
       EOS
     end