Activate all x86 semantics files and add the comments for instructions that fails the tests

backend/remill/include/remill/Arch/Runtime/RemillTypes.h

@@ -61,7 +61,8 @@ typedef int16_t addr_diff_t;
 //       always explicitly specialize it inside of the `std` namespace.
 
 // Entry function of the original ELF
-typedef void (*LiftedFunc)(State *state, addr_t pc, RuntimeManager *runtime_manager);
+typedef void (*LiftedFunc)(uint8_t *arena_ptr, State *state, addr_t pc,
+                           RuntimeManager *runtime_manager);
 
 template <typename T>
 struct is_signed {

backend/remill/include/remill/Arch/X86/Runtime/Operators.h

@@ -32,48 +32,44 @@ ALWAYS_INLINE static void _Write(RuntimeManager *, Reg &reg,
   reg.IF_64BIT_ELSE(qword, dword) = val;
 }
 
-// ALWAYS_INLINE static bcd80_t _ReadBCD80(Memory *memory, Mn<bcd80_t> op) {
-//   bcd80_t bcd = {};
-//   const auto num_digit_pairs = sizeof(bcd.digit_pairs);
+ALWAYS_INLINE static bcd80_t _ReadBCD80(RuntimeManager *rt_m, Mn<bcd80_t> op) {
+  bcd80_t bcd = {};
+  const auto num_digit_pairs = sizeof(bcd.digit_pairs);
 
-//   _Pragma("unroll") for (addr_t i = 0; i < num_digit_pairs; i++) {
-//     bcd.digit_pairs[i].u8 = __remill_read_memory_8(memory, op.addr + i);
-//   }
-//   auto msb = __remill_read_memory_8(memory, op.addr + num_digit_pairs);
-//   bcd.is_negative = msb >> 7;
+  _Pragma("unroll") for (addr_t i = 0; i < num_digit_pairs; i++) {
+    bcd.digit_pairs[i].u8 = __remill_read_memory_8(rt_m, op.addr + i);
+  }
+  auto msb = __remill_read_memory_8(rt_m, op.addr + num_digit_pairs);
+  bcd.is_negative = msb >> 7;
 
-//   return bcd;
-// }
-
-// #define ReadBCD80(op) _ReadBCD80(memory, op)
-
-// ALWAYS_INLINE static Memory *_WriteBCD80(Memory *memory, MBCD80W dst, bcd80_t src) {
-//   const auto num_digit_pairs = sizeof(src.digit_pairs);
+  return bcd;
+}
 
-//   _Pragma("unroll") for (addr_t i = 0; i < num_digit_pairs; i++) {
-//     memory = __remill_write_memory_8(memory, dst.addr + i, src.digit_pairs[i].u8);
-//   }
+#define ReadBCD80(op) _ReadBCD80(rt_m, op)
 
-//   uint8_t msb = static_cast<uint8_t>(src.is_negative << 7);
-//   memory = __remill_write_memory_8(memory, dst.addr + num_digit_pairs, msb);
+ALWAYS_INLINE static void _WriteBCD80(RuntimeManager *rt_m, MBCD80W dst, bcd80_t src) {
+  const auto num_digit_pairs = sizeof(src.digit_pairs);
 
-//   return memory;
-// }
+  _Pragma("unroll") for (addr_t i = 0; i < num_digit_pairs; i++) {
+    __remill_write_memory_8(rt_m, dst.addr + i, src.digit_pairs[i].u8);
+  }
 
-// #define WriteBCD80(op, val) _WriteBCD80(memory, op, val)
+  uint8_t msb = static_cast<uint8_t>(src.is_negative << 7);
+  __remill_write_memory_8(rt_m, dst.addr + num_digit_pairs, msb);
+}
 
-// ALWAYS_INLINE static Memory *_WriteBCD80Indefinite(Memory *memory, MBCD80W dst) {
-//   const uint8_t indefinite[sizeof(bcd80_t)] = {
-//       0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc0, 0xff, 0xff,
-//   };
+#define WriteBCD80(op, val) _WriteBCD80(rt_m, op, val)
 
-//   _Pragma("unroll") for (addr_t i = 0; i < sizeof(indefinite); i++) {
-//     memory = __remill_write_memory_8(memory, dst.addr + i, indefinite[i]);
-//   }
+ALWAYS_INLINE static void _WriteBCD80Indefinite(RuntimeManager *rt_m, MBCD80W dst) {
+  const uint8_t indefinite[sizeof(bcd80_t)] = {
+      0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc0, 0xff, 0xff,
+  };
 
-//   return memory;
-// }
+  _Pragma("unroll") for (addr_t i = 0; i < sizeof(indefinite); i++) {
+    __remill_write_memory_8(rt_m, dst.addr + i, indefinite[i]);
+  }
+}
 
-// #define WriteBCD80Indefinite(op) _WriteBCD80Indefinite(memory, op)
+#define WriteBCD80Indefinite(op) _WriteBCD80Indefinite(rt_m, op)
 
 }  // namespace

backend/remill/lib/Arch/X86/Runtime/Instructions.cpp

@@ -204,35 +204,35 @@ DEF_HELPER(SquareRoot32, float32_t src_float)->float32_t {
 
 // #include "lib/Arch/X86/Semantics/AVX.cpp"
 #include "lib/Arch/X86/Semantics/BINARY.cpp"
-// #include "lib/Arch/X86/Semantics/BITBYTE.cpp"
-// #include "lib/Arch/X86/Semantics/CALL_RET.cpp"
-// #include "lib/Arch/X86/Semantics/CMOV.cpp"
-// #include "lib/Arch/X86/Semantics/COND_BR.cpp"
-// #include "lib/Arch/X86/Semantics/CONVERT.cpp"
+#include "lib/Arch/X86/Semantics/BITBYTE.cpp"
+#include "lib/Arch/X86/Semantics/CALL_RET.cpp"
+#include "lib/Arch/X86/Semantics/CMOV.cpp"
+#include "lib/Arch/X86/Semantics/COND_BR.cpp"
+#include "lib/Arch/X86/Semantics/CONVERT.cpp"
 #include "lib/Arch/X86/Semantics/DATAXFER.cpp"
-// #include "lib/Arch/X86/Semantics/DECIMAL.cpp"
-// #include "lib/Arch/X86/Semantics/FLAGOP.cpp"
-// #include "lib/Arch/X86/Semantics/FMA.cpp"
-// #include "lib/Arch/X86/Semantics/INTERRUPT.cpp"
-// #include "lib/Arch/X86/Semantics/IO.cpp"
+#include "lib/Arch/X86/Semantics/DECIMAL.cpp"
+#include "lib/Arch/X86/Semantics/FLAGOP.cpp"
+#include "lib/Arch/X86/Semantics/FMA.cpp"
+#include "lib/Arch/X86/Semantics/INTERRUPT.cpp"
+#include "lib/Arch/X86/Semantics/IO.cpp"
 #include "lib/Arch/X86/Semantics/LOGICAL.cpp"
 #include "lib/Arch/X86/Semantics/MISC.cpp"
-// #include "lib/Arch/X86/Semantics/MMX.cpp"
-// #include "lib/Arch/X86/Semantics/NOP.cpp"
-// #include "lib/Arch/X86/Semantics/POP.cpp"
-// #include "lib/Arch/X86/Semantics/PREFETCH.cpp"
-// #include "lib/Arch/X86/Semantics/PUSH.cpp"
-// #include "lib/Arch/X86/Semantics/ROTATE.cpp"
-// #include "lib/Arch/X86/Semantics/RTM.cpp"
-// #include "lib/Arch/X86/Semantics/SEMAPHORE.cpp"
-// #include "lib/Arch/X86/Semantics/SHIFT.cpp"
-// #include "lib/Arch/X86/Semantics/SSE.cpp"
-// #include "lib/Arch/X86/Semantics/STRINGOP.cpp"
-// #include "lib/Arch/X86/Semantics/SYSCALL.cpp"
-// #include "lib/Arch/X86/Semantics/SYSTEM.cpp"
-// #include "lib/Arch/X86/Semantics/UNCOND_BR.cpp"
-// #include "lib/Arch/X86/Semantics/X87.cpp"
+#include "lib/Arch/X86/Semantics/MMX.cpp"
+#include "lib/Arch/X86/Semantics/NOP.cpp"
+#include "lib/Arch/X86/Semantics/POP.cpp"
+#include "lib/Arch/X86/Semantics/PREFETCH.cpp"
+#include "lib/Arch/X86/Semantics/PUSH.cpp"
+#include "lib/Arch/X86/Semantics/ROTATE.cpp"
+#include "lib/Arch/X86/Semantics/RTM.cpp"
+#include "lib/Arch/X86/Semantics/SEMAPHORE.cpp"
+#include "lib/Arch/X86/Semantics/SHIFT.cpp"
+#include "lib/Arch/X86/Semantics/SSE.cpp"
+#include "lib/Arch/X86/Semantics/STRINGOP.cpp"
+#include "lib/Arch/X86/Semantics/SYSCALL.cpp"
+#include "lib/Arch/X86/Semantics/SYSTEM.cpp"
+#include "lib/Arch/X86/Semantics/UNCOND_BR.cpp"
+#include "lib/Arch/X86/Semantics/X87.cpp"
 // #include "lib/Arch/X86/Semantics/XOP.cpp"
-// #include "lib/Arch/X86/Semantics/XSAVE.cpp"
+#include "lib/Arch/X86/Semantics/XSAVE.cpp"
 
 // clang-format on

backend/remill/lib/Arch/X86/Semantics/AVX.cpp

@@ -25,7 +25,6 @@ DEF_SEM(DoVZEROUPPER) {
     IF_AVX512(vec.zmm.dqwords.elems[2] = 0;)
     IF_AVX512(vec.zmm.dqwords.elems[3] = 0;)
   }
-  return memory;
 }
 
 template <typename D, typename S1>
@@ -39,7 +38,6 @@ DEF_SEM(VPBROADCASTB, D dst, S1 src1) {
     dst_vec = UInsertV8(dst_vec, i, src_byte);
   }
   UWriteV8(dst, dst_vec);
-  return memory;
 }
 
 template <typename D, typename S1>
@@ -53,7 +51,6 @@ DEF_SEM(VPBROADCASTQ, D dst, S1 src1) {
     dst_vec = UInsertV64(dst_vec, i, src_val);
   }
   UWriteV64(dst, dst_vec);
-  return memory;
 }
 
 template <typename S2>
@@ -64,7 +61,6 @@ DEF_SEM(VINSERTF128, VV256W dst, V256 src1, S2 src2, I8 src3) {
   auto i = static_cast<unsigned>(src3_i8 & 1u);
   dst_vec = UInsertV128(dst_vec, i, UExtractV128(src2_vec, 0));
   UWriteV128(dst, dst_vec);
-  return memory;
 }
 
 //template<typename S2>

backend/remill/lib/Arch/X86/Semantics/CMOV.cpp

@@ -21,103 +21,86 @@ template <typename D, typename S1>
 DEF_SEM(CMOVNLE, D dst, S1 src1) {
   WriteZExt(dst, Select(__remill_compare_sgt(BAnd(BNot(FLAG_ZF), BXnor(FLAG_SF, FLAG_OF))),
                         Read(src1), TruncTo<S1>(Read(dst))));
-  return memory;
 }
 
 template <typename D, typename S1>
 DEF_SEM(CMOVNS, D dst, S1 src1) {
   WriteZExt(dst, Select(BNot(FLAG_SF), Read(src1), TruncTo<S1>(Read(dst))));
-  return memory;
 }
 
 template <typename D, typename S1>
 DEF_SEM(CMOVL, D dst, S1 src1) {
   WriteZExt(dst, Select(__remill_compare_slt(BXor(FLAG_SF, FLAG_OF)), Read(src1),
                         TruncTo<S1>(Read(dst))));
-  return memory;
 }
 
 template <typename D, typename S1>
 DEF_SEM(CMOVNP, D dst, S1 src1) {
   WriteZExt(dst, Select(BNot(FLAG_PF), Read(src1), TruncTo<S1>(Read(dst))));
-  return memory;
 }
 
 template <typename D, typename S1>
 DEF_SEM(CMOVNZ, D dst, S1 src1) {
   WriteZExt(dst, Select(__remill_compare_neq(BNot(FLAG_ZF)), Read(src1), TruncTo<S1>(Read(dst))));
-  return memory;
 }
 
 template <typename D, typename S1>
 DEF_SEM(CMOVNB, D dst, S1 src1) {
   WriteZExt(dst, Select(__remill_compare_uge(BNot(FLAG_CF)), Read(src1), TruncTo<S1>(Read(dst))));
-  return memory;
 }
 
 template <typename D, typename S1>
 DEF_SEM(CMOVNO, D dst, S1 src1) {
   WriteZExt(dst, Select(BNot(FLAG_OF), Read(src1), TruncTo<S1>(Read(dst))));
-  return memory;
 }
 
-
 template <typename D, typename S1>
 DEF_SEM(CMOVNL, D dst, S1 src1) {
   WriteZExt(dst, Select(__remill_compare_sge(BXnor(FLAG_SF, FLAG_OF)), Read(src1),
                         TruncTo<S1>(Read(dst))));
-  return memory;
 }
 
 template <typename D, typename S1>
 DEF_SEM(CMOVNBE, D dst, S1 src1) {
   WriteZExt(dst, Select(__remill_compare_ugt(BNot(BOr(FLAG_CF, FLAG_ZF))), Read(src1),
                         TruncTo<S1>(Read(dst))));
-  return memory;
 }
 
 template <typename D, typename S1>
 DEF_SEM(CMOVBE, D dst, S1 src1) {
   WriteZExt(
       dst, Select(__remill_compare_ule(BOr(FLAG_CF, FLAG_ZF)), Read(src1), TruncTo<S1>(Read(dst))));
-  return memory;
 }
 
 template <typename D, typename S1>
 DEF_SEM(CMOVZ, D dst, S1 src1) {
   WriteZExt(dst, Select(__remill_compare_eq(FLAG_ZF), Read(src1), TruncTo<S1>(Read(dst))));
-  return memory;
 }
 
 template <typename D, typename S1>
 DEF_SEM(CMOVP, D dst, S1 src1) {
   WriteZExt(dst, Select(FLAG_PF, Read(src1), TruncTo<S1>(Read(dst))));
-  return memory;
 }
 
 template <typename D, typename S1>
 DEF_SEM(CMOVS, D dst, S1 src1) {
   WriteZExt(dst, Select(FLAG_SF, Read(src1), TruncTo<S1>(Read(dst))));
-  return memory;
 }
 
 template <typename D, typename S1>
 DEF_SEM(CMOVO, D dst, S1 src1) {
   WriteZExt(dst, Select(FLAG_OF, Read(src1), TruncTo<S1>(Read(dst))));
-  return memory;
 }
 
 template <typename D, typename S1>
 DEF_SEM(CMOVB, D dst, S1 src1) {
   WriteZExt(dst, Select(__remill_compare_ult(FLAG_CF), Read(src1), TruncTo<S1>(Read(dst))));
-  return memory;
 }
 
 template <typename D, typename S1>
 DEF_SEM(CMOVLE, D dst, S1 src1) {
   WriteZExt(dst, Select(__remill_compare_sle(BOr(FLAG_ZF, BXor(FLAG_SF, FLAG_OF))), Read(src1),
                         TruncTo<S1>(Read(dst))));
-  return memory;
 }
 
 }  // namespace

backend/remill/lib/Arch/X86/Semantics/DECIMAL.cpp

@@ -45,7 +45,6 @@ DEF_SEM(AAS) {
   FLAG_ZF = __remill_undefined_8();
   FLAG_PF = __remill_undefined_8();
 
-  return memory;
 }
 
 DEF_SEM(DAA) {
@@ -92,7 +91,6 @@ DEF_SEM(DAA) {
 
   FLAG_OF = __remill_undefined_8();
 
-  return memory;
 }
 
 }  // namespace

backend/remill/lib/Arch/X86/Semantics/FLAGOP.cpp

@@ -19,32 +19,26 @@
 namespace {
 DEF_SEM(DoCLD) {
   FLAG_DF = false;
-  return memory;
 }
 
 DEF_SEM(DoSTD) {
   FLAG_DF = true;
-  return memory;
 }
 
 DEF_SEM(DoCLC) {
   FLAG_CF = false;
-  return memory;
 }
 
 DEF_SEM(DoCMC) {
   FLAG_CF = BNot(FLAG_CF);
-  return memory;
 }
 
 DEF_SEM(DoSTC) {
   FLAG_CF = true;
-  return memory;
 }
 
 DEF_SEM(DoSALC) {
   Write(REG_AL, Unsigned(FLAG_CF));
-  return memory;
 }
 
 DEF_SEM(DoSAHF) {
@@ -54,7 +48,6 @@ DEF_SEM(DoSAHF) {
   FLAG_AF = UCmpEq(1, flags.af);
   FLAG_SF = UCmpEq(1, flags.sf);
   FLAG_ZF = UCmpEq(1, flags.zf);
-  return memory;
 }
 
 DEF_SEM(DoLAHF) {
@@ -68,31 +61,22 @@ DEF_SEM(DoLAHF) {
   flags.zf = Unsigned(FLAG_ZF);
   flags.sf = Unsigned(FLAG_SF);
   Write(REG_AH, TruncTo<uint8_t>(flags.flat));
-  return memory;
 }
 
 DEF_SEM(DoCLAC) {
-  memory = __remill_sync_hyper_call(state, memory, SyncHyperCall::kAssertPrivileged);
   state.rflag.ac = false;
-  return memory;
 }
 
 DEF_SEM(DoSTAC) {
-  memory = __remill_sync_hyper_call(state, memory, SyncHyperCall::kAssertPrivileged);
   state.rflag.ac = true;
-  return memory;
 }
 
 DEF_SEM(DoCLI) {
-  memory = __remill_sync_hyper_call(state, memory, SyncHyperCall::kAssertPrivileged);
   state.rflag._if = false;
-  return memory;
 }
 
 DEF_SEM(DoSTI) {
-  memory = __remill_sync_hyper_call(state, memory, SyncHyperCall::kAssertPrivileged);
   state.rflag._if = true;
-  return memory;
 }
 }  // namespace