ZJIT: Enable or remove comments from YJIT (ruby#14214)

Author: k0kubun

zjit/src/asm/arm64/inst/branch_cond.rs

@@ -47,7 +47,6 @@ impl From<BranchCond> for [u8; 4] {
     }
 }
 
-/*
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -77,4 +76,3 @@ mod tests {
         assert_eq!(0x54800000, result);
     }
 }
-*/

zjit/src/asm/arm64/inst/conditional.rs

@@ -60,7 +60,6 @@ impl From<Conditional> for [u8; 4] {
     }
 }
 
-/*
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -72,4 +71,3 @@ mod tests {
         assert_eq!(0x9a821020, result);
     }
 }
-*/

zjit/src/asm/mod.rs

@@ -345,7 +345,6 @@ pub fn uimm_num_bits(uimm: u64) -> u8
     return 64;
 }
 
-/*
 #[cfg(test)]
 mod tests
 {
@@ -381,32 +380,5 @@ mod tests
         assert_eq!(uimm_num_bits((u32::MAX as u64) + 1), 64);
         assert_eq!(uimm_num_bits(u64::MAX), 64);
     }
-
-    #[test]
-    fn test_code_size() {
-        // Write 4 bytes in the first page
-        let mut cb = CodeBlock::new_dummy(CodeBlock::PREFERRED_CODE_PAGE_SIZE * 2);
-        cb.write_bytes(&[0, 0, 0, 0]);
-        assert_eq!(cb.code_size(), 4);
-
-        // Moving to the next page should not increase code_size
-        cb.next_page(cb.get_write_ptr(), |_, _| {});
-        assert_eq!(cb.code_size(), 4);
-
-        // Write 4 bytes in the second page
-        cb.write_bytes(&[0, 0, 0, 0]);
-        assert_eq!(cb.code_size(), 8);
-
-        // Rewrite 4 bytes in the first page
-        let old_write_pos = cb.get_write_pos();
-        cb.set_pos(0);
-        cb.write_bytes(&[1, 1, 1, 1]);
-
-        // Moving from an old page to the next page should not increase code_size
-        cb.next_page(cb.get_write_ptr(), |_, _| {});
-        cb.set_pos(old_write_pos);
-        assert_eq!(cb.code_size(), 8);
-    }
 }
 
-*/

zjit/src/asm/x86_64/mod.rs

@@ -317,34 +317,6 @@ pub fn mem_opnd_sib(num_bits: u8, base_opnd: X86Opnd, index_opnd: X86Opnd, scale
     }
 }
 
-/*
-// Struct member operand
-#define member_opnd(base_reg, struct_type, member_name) mem_opnd( \
-    8 * sizeof(((struct_type*)0)->member_name), \
-    base_reg,                                   \
-    offsetof(struct_type, member_name)          \
-)
-
-// Struct member operand with an array index
-#define member_opnd_idx(base_reg, struct_type, member_name, idx) mem_opnd( \
-    8 * sizeof(((struct_type*)0)->member_name[0]),     \
-    base_reg,                                       \
-    (offsetof(struct_type, member_name) +           \
-     sizeof(((struct_type*)0)->member_name[0]) * idx)  \
-)
-*/
-
-/*
-// TODO: this should be a method, X86Opnd.resize() or X86Opnd.subreg()
-static x86opnd_t resize_opnd(x86opnd_t opnd, uint32_t num_bits)
-{
-    assert (num_bits % 8 == 0);
-    x86opnd_t sub = opnd;
-    sub.num_bits = num_bits;
-    return sub;
-}
-*/
-
 pub fn imm_opnd(value: i64) -> X86Opnd
 {
     X86Opnd::Imm(X86Imm { num_bits: imm_num_bits(value), value })
@@ -1103,46 +1075,6 @@ pub fn movsx(cb: &mut CodeBlock, dst: X86Opnd, src: X86Opnd) {
     }
 }
 
-/*
-/// movzx - Move with zero extension (unsigned values)
-void movzx(codeblock_t *cb, x86opnd_t dst, x86opnd_t src)
-{
-    cb.writeASM("movzx", dst, src);
-
-    uint32_t dstSize;
-    if (dst.isReg)
-        dstSize = dst.reg.size;
-    else
-        assert (false, "movzx dst must be a register");
-
-    uint32_t srcSize;
-    if (src.isReg)
-        srcSize = src.reg.size;
-    else if (src.isMem)
-        srcSize = src.mem.size;
-    else
-        assert (false);
-
-    assert (
-        srcSize < dstSize,
-        "movzx: srcSize >= dstSize"
-    );
-
-    if (srcSize is 8)
-    {
-        cb.writeRMInstr!('r', 0xFF, 0x0F, 0xB6)(dstSize is 16, dstSize is 64, dst, src);
-    }
-    else if (srcSize is 16)
-    {
-        cb.writeRMInstr!('r', 0xFF, 0x0F, 0xB7)(dstSize is 16, dstSize is 64, dst, src);
-    }
-    else
-    {
-        assert (false, "invalid src operand size for movxz");
-    }
-}
-*/
-
 /// nop - Noop, one or multiple bytes long
 pub fn nop(cb: &mut CodeBlock, length: u32) {
     match length {

zjit/src/backend/arm64/mod.rs

@@ -317,7 +317,7 @@ impl Assembler
                         asm.load(opnd)
                     }
                 },
-                Opnd::None | Opnd::Value(_) /*| Opnd::Stack { .. }*/ => unreachable!()
+                Opnd::None | Opnd::Value(_) => unreachable!()
             }
         }
 
@@ -1742,21 +1742,19 @@ mod tests {
         asm.compile_with_num_regs(&mut cb, 0);
     }
 
-    /*
     #[test]
     fn test_emit_lea_label() {
         let (mut asm, mut cb) = setup_asm();
 
         let label = asm.new_label("label");
-        let opnd = asm.lea_jump_target(label);
+        let opnd = asm.lea_jump_target(label.clone());
 
         asm.write_label(label);
         asm.bake_string("Hello, world!");
         asm.store(Opnd::mem(64, SP, 0), opnd);
 
         asm.compile_with_num_regs(&mut cb, 1);
     }
-    */
 
     #[test]
     fn test_emit_load_mem_disp_fits_into_load() {
@@ -1967,48 +1965,6 @@ mod tests {
         asm.compile_with_num_regs(&mut cb, 2);
     }
 
-    /*
-    #[test]
-    fn test_bcond_straddling_code_pages() {
-        const LANDING_PAGE: usize = 65;
-        let mut asm = Assembler::new(0);
-        let mut cb = CodeBlock::new_dummy_with_freed_pages(vec![0, LANDING_PAGE]);
-
-        // Skip to near the end of the page. Room for two instructions.
-        cb.set_pos(cb.page_start_pos() + cb.page_end() - 8);
-
-        let end = asm.new_label("end");
-        // Start with a conditional jump...
-        asm.jz(end);
-
-        // A few instructions, enough to cause a page switch.
-        let sum = asm.add(399.into(), 111.into());
-        let xorred = asm.xor(sum, 859.into());
-        asm.store(Opnd::mem(64, Opnd::Reg(X2_REG), 0), xorred);
-        asm.store(Opnd::mem(64, Opnd::Reg(X0_REG), 0), xorred);
-
-        // The branch target. It should be in the landing page.
-        asm.write_label(end);
-        asm.cret(xorred);
-
-        // [Bug #19385]
-        // This used to panic with "The offset must be 19 bits or less."
-        // due to attempting to lower the `asm.jz` above to a `b.e` with an offset that's > 1 MiB.
-        let starting_pos = cb.get_write_pos();
-        asm.compile_with_num_regs(&mut cb, 2);
-        let gap = cb.get_write_pos() - starting_pos;
-        assert!(gap > 0b1111111111111111111);
-
-        let instruction_at_starting_pos: [u8; 4] = unsafe {
-            std::slice::from_raw_parts(cb.get_ptr(starting_pos).raw_ptr(&cb), 4)
-        }.try_into().unwrap();
-        assert_eq!(
-            0b000101 << 26_u32,
-            u32::from_le_bytes(instruction_at_starting_pos) & (0b111111 << 26_u32),
-            "starting instruction should be an unconditional branch to the new page (B)"
-        );
-    }
-
     #[test]
     fn test_emit_xor() {
         let (mut asm, mut cb) = setup_asm();
@@ -2018,9 +1974,9 @@ mod tests {
 
         asm.compile_with_num_regs(&mut cb, 1);
 
-        assert_disasm!(cb, "0b0001ca4b0000f8", "
-            0x0: eor x11, x0, x1
-            0x4: stur x11, [x2]
+        assert_disasm!(cb, "000001ca400000f8", "
+            0x0: eor x0, x0, x1
+            0x4: stur x0, [x2]
         ");
     }
 
@@ -2082,10 +2038,10 @@ mod tests {
         asm.mov(Opnd::Reg(TEMP_REGS[0]), out);
         asm.compile_with_num_regs(&mut cb, 2);
 
-        assert_disasm!(cb, "8b0280d20c0080d261b18c9a", {"
-            0x0: mov x11, #0x14
-            0x4: mov x12, #0
-            0x8: csel x1, x11, x12, lt
+        assert_disasm!(cb, "800280d2010080d201b0819a", {"
+            0x0: mov x0, #0x14
+            0x4: mov x1, #0
+            0x8: csel x1, x0, x1, lt
         "});
     }
 
@@ -2098,11 +2054,9 @@ mod tests {
         asm.mov(Opnd::Reg(TEMP_REGS[0]), out);
         asm.compile_with_num_regs(&mut cb, 2);
 
-        assert_disasm!(cb, "2b0500b16b0500b1e1030baa", {"
-            0x0: adds x11, x9, #1
-            0x4: adds x11, x11, #1
-            0x8: mov x1, x11
+        assert_disasm!(cb, "200500b1010400b1", {"
+            0x0: adds x0, x9, #1
+            0x4: adds x1, x0, #1
         "});
     }
-    */
 }