add x86_64 Int Num.neg support for gen_dev

compiler/gen_dev/src/generic64/aarch64.rs

@@ -446,6 +446,10 @@ impl Assembler<AArch64GeneralReg, AArch64FloatReg> for AArch64Assembler {
             unimplemented!("stack offsets over 32k are not yet implement for AArch64");
         }
     }
+    #[inline(always)]
+    fn neg_reg64_reg64(_buf: &mut Vec<'_, u8>, _dst: AArch64GeneralReg, _src: AArch64GeneralReg) {
+        unimplemented!("neg is not yet implement for AArch64");
+    }
 
     #[inline(always)]
     fn sub_reg64_reg64_imm32(

compiler/gen_dev/src/generic64/mod.rs

@@ -149,6 +149,7 @@ pub trait Assembler<GeneralReg: RegTrait, FloatReg: RegTrait> {
     fn mov_stack32_freg64(buf: &mut Vec<'_, u8>, offset: i32, src: FloatReg);
     fn mov_stack32_reg64(buf: &mut Vec<'_, u8>, offset: i32, src: GeneralReg);
 
+    fn neg_reg64_reg64(buf: &mut Vec<'_, u8>, dst: GeneralReg, src: GeneralReg);
     fn imul_reg64_reg64_reg64(
         buf: &mut Vec<'_, u8>,
         dst: GeneralReg,
@@ -786,6 +787,23 @@ impl<
         }
     }
 
+    fn build_num_neg(
+        &mut self,
+        dst: &Symbol,
+        src: &Symbol,
+        layout: &Layout<'a>,
+    ) -> Result<(), String> {
+        match layout {
+            Layout::Builtin(Builtin::Int64) => {
+                let dst_reg = self.claim_general_reg(dst)?;
+                let src_reg = self.load_to_general_reg(src)?;
+                ASM::neg_reg64_reg64(&mut self.buf, dst_reg, src_reg);
+                Ok(())
+            }
+            x => Err(format!("NumNeg: layout, {:?}, not implemented yet", x)),
+        }
+    }
+
     fn build_num_sub(
         &mut self,
         dst: &Symbol,

compiler/gen_dev/src/generic64/x86_64.rs

@@ -1053,6 +1053,11 @@ impl Assembler<X86_64GeneralReg, X86_64FloatReg> for X86_64Assembler {
         mov_base64_offset32_reg64(buf, X86_64GeneralReg::RSP, offset, src)
     }
 
+    #[inline(always)]
+    fn neg_reg64_reg64(buf: &mut Vec<'_, u8>, dst: X86_64GeneralReg, src: X86_64GeneralReg) {
+        mov_reg64_reg64(buf, dst, src);
+        neg_reg64(buf, dst);
+    }
     #[inline(always)]
     fn sub_reg64_reg64_imm32(
         buf: &mut Vec<'_, u8>,

compiler/gen_dev/src/lib.rs

@@ -368,6 +368,18 @@ where
                 );
                 self.build_num_mul(sym, &args[0], &args[1], ret_layout)
             }
+            LowLevel::NumNeg => {
+                debug_assert_eq!(
+                    1,
+                    args.len(),
+                    "NumNeg: expected to have exactly one argument"
+                );
+                debug_assert_eq!(
+                    arg_layouts[0], *ret_layout,
+                    "NumNeg: expected to have the same argument and return layout"
+                );
+                self.build_num_neg(sym, &args[0], ret_layout)
+            }
             LowLevel::NumPowInt => self.build_fn_call(
                 sym,
                 bitcode::NUM_POW_INT[IntWidth::I64].to_string(),
@@ -459,6 +471,14 @@ where
         layout: &Layout<'a>,
     ) -> Result<(), String>;
 
+    /// build_num_neg stores the negated value of src into dst.
+    fn build_num_neg(
+        &mut self,
+        dst: &Symbol,
+        src: &Symbol,
+        layout: &Layout<'a>,
+    ) -> Result<(), String>;
+
     /// build_num_sub stores the `src1 - src2` difference into dst.
     fn build_num_sub(
         &mut self,

compiler/test_gen/src/gen_num.rs

@@ -1214,7 +1214,18 @@ fn tail_call_elimination() {
 }
 
 #[test]
-#[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-wasm"))]
+#[cfg(any(feature = "gen-dev"))]
+fn int_negate_dev() {
+    // Dev backend yet to have `Num.maxInt` or `Num.minInt`.
+    // TODO Remove this test and add "gen-dev" feature the below
+    // after implementing the both.
+    assert_evals_to!("Num.neg 123", -123, i64);
+    assert_evals_to!("Num.neg -123", 123, i64);
+    assert_evals_to!("Num.neg 0", 0, i64);
+}
+
+#[test]
+#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
 fn int_negate() {
     assert_evals_to!("Num.neg 123", -123, i64);
     assert_evals_to!("Num.neg Num.maxInt", -i64::MAX, i64);