py: Implement more binary ops for viper emitter.

This included a bit of restructuring of the assembler backends. Note that the ARM backend is missing a few functions and won't compile.

Author: dpgeorge

py/asmarm.c

@@ -170,6 +170,11 @@ STATIC uint asm_arm_op_sub_imm(uint rd, uint rn, uint imm) {
  return 0x2400000 | (rn << 16) | (rd << 12) | (imm & 0xFF);
 }
 
+STATIC uint asm_arm_op_sub_reg(uint rd, uint rn, uint rm) {
+ // sub rd, rn, rm
+ return 0x0400000 | (rn << 16) | (rd << 12) | rm;
+}
+
 void asm_arm_bkpt(asm_arm_t *as) {
  // bkpt #0
  emit_al(as, 0x1200070); 
@@ -298,11 +303,16 @@ void asm_arm_less_op(asm_arm_t *as, uint rd, uint rn, uint rm) {
  emit(as, asm_arm_op_mov_imm(rd, 0) | ASM_ARM_CC_GE); // movge rd, #0
 }
 
-void asm_arm_add_reg(asm_arm_t *as, uint rd, uint rn, uint rm) {
+void asm_arm_add_reg_reg_reg(asm_arm_t *as, uint rd, uint rn, uint rm) {
  // add rd, rn, rm
  emit_al(as, asm_arm_op_add_reg(rd, rn, rm));
 }
 
+void asm_arm_sub_reg_reg_reg(asm_arm_t *as, uint rd, uint rn, uint rm) {
+ // sub rd, rn, rm
+ emit_al(as, asm_arm_op_sub_reg(rd, rn, rm));
+}
+
 void asm_arm_mov_reg_local_addr(asm_arm_t *as, uint rd, int local_num) {
  // add rd, sp, #local_num*4
  emit_al(as, asm_arm_op_add_imm(rd, ASM_ARM_REG_SP, local_num << 2));

py/asmarm.h

@@ -89,7 +89,8 @@ void asm_arm_mov_reg_local(asm_arm_t *as, uint rd, int local_num);
 void asm_arm_cmp_reg_i8(asm_arm_t *as, uint rd, int imm);
 void asm_arm_cmp_reg_reg(asm_arm_t *as, uint rd, uint rn);
 void asm_arm_less_op(asm_arm_t *as, uint rd, uint rn, uint rm);
-void asm_arm_add_reg(asm_arm_t *as, uint rd, uint rn, uint rm);
+void asm_arm_add_reg_reg_reg(asm_arm_t *as, uint rd, uint rn, uint rm);
+void asm_arm_sub_reg_reg_reg(asm_arm_t *as, uint rd, uint rn, uint rm);
 void asm_arm_mov_reg_local_addr(asm_arm_t *as, uint rd, int local_num);
 
 void asm_arm_bcc_label(asm_arm_t *as, int cond, uint label);

py/asmx64.c

@@ -54,19 +54,21 @@
 #define OPCODE_MOV_RM64_TO_R64 (0x8b)
 #define OPCODE_LEA_MEM_TO_R64 (0x8d) /* /r */
 #define OPCODE_XOR_R64_TO_RM64 (0x31) /* /r */
-#define OPCODE_ADD_R64_TO_RM64 (0x01)
+#define OPCODE_ADD_R64_TO_RM64 (0x01) /* /r */
 #define OPCODE_ADD_I32_TO_RM32 (0x81) /* /0 */
 #define OPCODE_ADD_I8_TO_RM32 (0x83) /* /0 */
 #define OPCODE_SUB_R64_FROM_RM64 (0x29)
 #define OPCODE_SUB_I32_FROM_RM64 (0x81) /* /5 */
 #define OPCODE_SUB_I8_FROM_RM64 (0x83) /* /5 */
-#define OPCODE_SHL_RM32_BY_I8 (0xc1) /* /4 */
-#define OPCODE_SHR_RM32_BY_I8 (0xc1) /* /5 */
-#define OPCODE_SAR_RM32_BY_I8 (0xc1) /* /7 */
-#define OPCODE_CMP_I32_WITH_RM32 (0x81) /* /7 */
-#define OPCODE_CMP_I8_WITH_RM32 (0x83) /* /7 */
-#define OPCODE_CMP_R64_WITH_RM64 (0x39)
-#define OPCODE_CMP_RM32_WITH_R32 (0x3b)
+//#define OPCODE_SHL_RM32_BY_I8 (0xc1) /* /4 */
+//#define OPCODE_SHR_RM32_BY_I8 (0xc1) /* /5 */
+//#define OPCODE_SAR_RM32_BY_I8 (0xc1) /* /7 */
+#define OPCODE_SHL_RM64_CL (0xd3) /* /4 */
+#define OPCODE_SAR_RM64_CL (0xd3) /* /7 */
+//#define OPCODE_CMP_I32_WITH_RM32 (0x81) /* /7 */
+//#define OPCODE_CMP_I8_WITH_RM32 (0x83) /* /7 */
+#define OPCODE_CMP_R64_WITH_RM64 (0x39) /* /r */
+//#define OPCODE_CMP_RM32_WITH_R32 (0x3b)
 #define OPCODE_TEST_R8_WITH_RM8 (0x84) /* /r */
 #define OPCODE_JMP_REL8 (0xeb)
 #define OPCODE_JMP_REL32 (0xe9)
@@ -253,6 +255,10 @@ STATIC void asm_x64_write_r64_disp(asm_x64_t *as, int r64, int disp_r64, int dis
  }
 }
 
+STATIC void asm_x64_generic_r64_r64(asm_x64_t *as, int dest_r64, int src_r64, int op) {
+ asm_x64_write_byte_3(as, REX_PREFIX | REX_W | (src_r64 < 8 ? 0 : REX_R) | (dest_r64 < 8 ? 0 : REX_B), op, MODRM_R64(src_r64) | MODRM_RM_REG | MODRM_RM_R64(dest_r64));
+}
+
 void asm_x64_nop(asm_x64_t *as) {
  asm_x64_write_byte_1(as, OPCODE_NOP);
 }
@@ -290,9 +296,8 @@ STATIC void asm_x64_ret(asm_x64_t *as) {
  asm_x64_write_byte_1(as, OPCODE_RET);
 }
 
-void asm_x64_mov_r64_to_r64(asm_x64_t *as, int src_r64, int dest_r64) {
- // use REX prefix for 64 bit operation
- asm_x64_write_byte_3(as, REX_PREFIX | REX_W | (src_r64 < 8 ? 0 : REX_R) | (dest_r64 < 8 ? 0 : REX_B), OPCODE_MOV_R64_TO_RM64, MODRM_R64(src_r64) | MODRM_RM_REG | MODRM_RM_R64(dest_r64));
+void asm_x64_mov_r64_r64(asm_x64_t *as, int dest_r64, int src_r64) {
+ asm_x64_generic_r64_r64(as, dest_r64, src_r64, OPCODE_MOV_R64_TO_RM64);
 }
 
 void asm_x64_mov_r8_to_disp(asm_x64_t *as, int src_r64, int dest_r64, int dest_disp) {
@@ -377,30 +382,24 @@ void asm_x64_mov_i64_to_r64_aligned(asm_x64_t *as, int64_t src_i64, int dest_r64
  asm_x64_mov_i64_to_r64(as, src_i64, dest_r64);
 }
 
-void asm_x64_xor_r64_to_r64(asm_x64_t *as, int src_r64, int dest_r64) {
- assert(src_r64 < 8);
- assert(dest_r64 < 8);
- asm_x64_write_byte_3(as, REX_PREFIX | REX_W, OPCODE_XOR_R64_TO_RM64, MODRM_R64(src_r64) | MODRM_RM_REG | MODRM_RM_R64(dest_r64));
+void asm_x64_xor_r64_r64(asm_x64_t *as, int dest_r64, int src_r64) {
+ asm_x64_generic_r64_r64(as, dest_r64, src_r64, OPCODE_XOR_R64_TO_RM64);
 }
 
-void asm_x64_add_r64_to_r64(asm_x64_t *as, int src_r64, int dest_r64) {
- assert(src_r64 < 8);
- assert(dest_r64 < 8);
- asm_x64_write_byte_3(as, REX_PREFIX | REX_W, OPCODE_ADD_R64_TO_RM64, MODRM_R64(src_r64) | MODRM_RM_REG | MODRM_RM_R64(dest_r64));
+void asm_x64_shl_r64_cl(asm_x64_t* as, int dest_r64) {
+ asm_x64_generic_r64_r64(as, dest_r64, 4, OPCODE_SHL_RM64_CL);
 }
 
-/*
-void asm_x64_sub_r32_from_r32(asm_x64_t *as, int src_r32, int dest_r32) {
- // defaults to 32 bit operation
- asm_x64_write_byte_2(as, OPCODE_SUB_R64_FROM_RM64, MODRM_R64(src_r32) | MODRM_RM_REG | MODRM_RM_R64(dest_r32));
+void asm_x64_sar_r64_cl(asm_x64_t* as, int dest_r64) {
+ asm_x64_generic_r64_r64(as, dest_r64, 7, OPCODE_SAR_RM64_CL);
 }
-*/
 
-void asm_x64_sub_r64_from_r64(asm_x64_t *as, int src_r64, int dest_r64) {
- // use REX prefix for 64 bit operation
- assert(src_r64 < 8);
- assert(dest_r64 < 8);
- asm_x64_write_byte_3(as, REX_PREFIX | REX_W, OPCODE_SUB_R64_FROM_RM64, MODRM_R64(src_r64) | MODRM_RM_REG | MODRM_RM_R64(dest_r64));
+void asm_x64_add_r64_r64(asm_x64_t *as, int dest_r64, int src_r64) {
+ asm_x64_generic_r64_r64(as, dest_r64, src_r64, OPCODE_ADD_R64_TO_RM64);
+}
+
+void asm_x64_sub_r64_r64(asm_x64_t *as, int dest_r64, int src_r64) {
+ asm_x64_generic_r64_r64(as, dest_r64, src_r64, OPCODE_SUB_R64_FROM_RM64);
 }
 
 /*
@@ -417,7 +416,7 @@ void asm_x64_sub_i32_from_r32(asm_x64_t *as, int src_i32, int dest_r32) {
 }
 */
 
-void asm_x64_sub_i32_from_r64(asm_x64_t *as, int src_i32, int dest_r64) {
+STATIC void asm_x64_sub_r64_i32(asm_x64_t *as, int dest_r64, int src_i32) {
  assert(dest_r64 < 8);
  if (SIGNED_FIT8(src_i32)) {
  // use REX prefix for 64 bit operation
@@ -448,9 +447,7 @@ void asm_x64_sar_r32_by_imm(asm_x64_t *as, int r32, int imm) {
 */
 
 void asm_x64_cmp_r64_with_r64(asm_x64_t *as, int src_r64_a, int src_r64_b) {
- assert(src_r64_a < 8);
- assert(src_r64_b < 8);
- asm_x64_write_byte_3(as, REX_PREFIX | REX_W, OPCODE_CMP_R64_WITH_RM64, MODRM_R64(src_r64_a) | MODRM_RM_REG | MODRM_RM_R64(src_r64_b));
+ asm_x64_generic_r64_r64(as, src_r64_b, src_r64_a, OPCODE_CMP_R64_WITH_RM64);
 }
 
 /*
@@ -541,12 +538,12 @@ void asm_x64_jcc_label(asm_x64_t *as, int jcc_type, int label) {
 
 void asm_x64_entry(asm_x64_t *as, int num_locals) {
  asm_x64_push_r64(as, ASM_X64_REG_RBP);
- asm_x64_mov_r64_to_r64(as, ASM_X64_REG_RSP, ASM_X64_REG_RBP);
+ asm_x64_mov_r64_r64(as, ASM_X64_REG_RBP, ASM_X64_REG_RSP);
  if (num_locals < 0) {
  num_locals = 0;
  }
  num_locals |= 1; // make it odd so stack is aligned on 16 byte boundary
- asm_x64_sub_i32_from_r64(as, num_locals * WORD_SIZE, ASM_X64_REG_RSP);
+ asm_x64_sub_r64_i32(as, ASM_X64_REG_RSP, num_locals * WORD_SIZE);
  asm_x64_push_r64(as, ASM_X64_REG_RBX);
  asm_x64_push_r64(as, ASM_X64_REG_R12);
  asm_x64_push_r64(as, ASM_X64_REG_R13);
@@ -587,7 +584,7 @@ void asm_x64_mov_r64_to_local(asm_x64_t *as, int src_r64, int dest_local_num) {
 void asm_x64_mov_local_addr_to_r64(asm_x64_t *as, int local_num, int dest_r64) {
  int offset = asm_x64_local_offset_from_ebp(as, local_num);
  if (offset == 0) {
- asm_x64_mov_r64_to_r64(as, ASM_X64_REG_RBP, dest_r64);
+ asm_x64_mov_r64_r64(as, dest_r64, ASM_X64_REG_RBP);
  } else {
  asm_x64_lea_disp_to_r64(as, ASM_X64_REG_RBP, offset, dest_r64);
  }
@@ -600,7 +597,7 @@ void asm_x64_push_local(asm_x64_t *as, int local_num) {
 
 void asm_x64_push_local_addr(asm_x64_t *as, int local_num, int temp_r64)
 {
- asm_x64_mov_r64_to_r64(as, ASM_X64_REG_RBP, temp_r64);
+ asm_x64_mov_r64_r64(as, temp_r64, ASM_X64_REG_RBP);
  asm_x64_add_i32_to_r32(as, asm_x64_local_offset_from_ebp(as, local_num), temp_r64);
  asm_x64_push_r64(as, temp_r64);
 }
@@ -614,7 +611,7 @@ void asm_x64_call(asm_x64_t *as, void* func)
  asm_x64_sub_i32_from_r32(as, 8, ASM_X64_REG_RSP);
  asm_x64_write_byte_1(as, OPCODE_CALL_REL32);
  asm_x64_write_word32(as, func - (void*)(as->code_cur + 4));
- asm_x64_mov_r64_to_r64(as, ASM_X64_REG_RBP, ASM_X64_REG_RSP);
+ asm_x64_mov_r64_r64(as, ASM_X64_REG_RSP, ASM_X64_REG_RBP);
 }
 
 void asm_x64_call_i1(asm_x64_t *as, void* func, int i1)
@@ -625,7 +622,7 @@ void asm_x64_call_i1(asm_x64_t *as, void* func, int i1)
  asm_x64_write_byte_1(as, OPCODE_CALL_REL32);
  asm_x64_write_word32(as, func - (void*)(as->code_cur + 4));
  asm_x64_add_i32_to_r32(as, 16, ASM_X64_REG_RSP);
- asm_x64_mov_r64_to_r64(as, ASM_X64_REG_RBP, ASM_X64_REG_RSP);
+ asm_x64_mov_r64_r64(as, ASM_X64_REG_RSP, ASM_X64_REG_RBP);
 }
 */
 

py/asmx64.h

@@ -31,6 +31,11 @@
 // - RAX, RCX, RDX, RSI, RDI, R08, R09, R10, R11 are caller-save
 // - RBX, RBP, R12, R13, R14, R15 are callee-save
 
+// In the functions below, argument order follows x86 docs and generally
+// the destination is the first argument.
+// NOTE: this is a change from the old convention used in this file and
+// some functions still use the old (reverse) convention.
+
 #define ASM_X64_PASS_COMPUTE (1)
 #define ASM_X64_PASS_EMIT (2)
 
@@ -58,6 +63,8 @@
 #define ASM_X64_CC_JNZ (0x5)
 #define ASM_X64_CC_JNE (0x5)
 #define ASM_X64_CC_JL (0xc) // less, signed
+#define ASM_X64_CC_JGE (0xd) // greater or equal, signed
+#define ASM_X64_CC_JLE (0xe) // less or equal, signed
 #define ASM_X64_CC_JG (0xf) // greater, signed
 
 typedef struct _asm_x64_t asm_x64_t;
@@ -72,15 +79,18 @@ void* asm_x64_get_code(asm_x64_t* as);
 void asm_x64_nop(asm_x64_t* as);
 void asm_x64_push_r64(asm_x64_t* as, int src_r64);
 void asm_x64_pop_r64(asm_x64_t* as, int dest_r64);
-void asm_x64_mov_r64_to_r64(asm_x64_t* as, int src_r64, int dest_r64);
+void asm_x64_mov_r64_r64(asm_x64_t* as, int dest_r64, int src_r64);
 void asm_x64_mov_i64_to_r64(asm_x64_t* as, int64_t src_i64, int dest_r64);
 void asm_x64_mov_i64_to_r64_optimised(asm_x64_t *as, int64_t src_i64, int dest_r64);
 void asm_x64_mov_i64_to_r64_aligned(asm_x64_t *as, int64_t src_i64, int dest_r64);
 void asm_x64_mov_r8_to_disp(asm_x64_t *as, int src_r64, int dest_r64, int dest_disp);
 void asm_x64_mov_r16_to_disp(asm_x64_t *as, int src_r64, int dest_r64, int dest_disp);
 void asm_x64_mov_r64_to_disp(asm_x64_t *as, int src_r64, int dest_r64, int dest_disp);
-void asm_x64_xor_r64_to_r64(asm_x64_t *as, int src_r64, int dest_r64);
-void asm_x64_add_r64_to_r64(asm_x64_t* as, int src_r64, int dest_r64);
+void asm_x64_xor_r64_r64(asm_x64_t *as, int dest_r64, int src_r64);
+void asm_x64_shl_r64_cl(asm_x64_t* as, int dest_r64);
+void asm_x64_sar_r64_cl(asm_x64_t* as, int dest_r64);
+void asm_x64_add_r64_r64(asm_x64_t* as, int dest_r64, int src_r64);
+void asm_x64_sub_r64_r64(asm_x64_t* as, int dest_r64, int src_r64);
 void asm_x64_cmp_r64_with_r64(asm_x64_t* as, int src_r64_a, int src_r64_b);
 void asm_x64_test_r8_with_r8(asm_x64_t* as, int src_r64_a, int src_r64_b);
 void asm_x64_setcc_r8(asm_x64_t* as, int jcc_type, int dest_r8);

py/asmx86.c

@@ -57,12 +57,14 @@
 #define OPCODE_ADD_R32_TO_RM32 (0x01)
 #define OPCODE_ADD_I32_TO_RM32 (0x81) /* /0 */
 #define OPCODE_ADD_I8_TO_RM32 (0x83) /* /0 */
-//#define OPCODE_SUB_R32_FROM_RM32 (0x29)
+#define OPCODE_SUB_R32_FROM_RM32 (0x29)
 #define OPCODE_SUB_I32_FROM_RM32 (0x81) /* /5 */
 #define OPCODE_SUB_I8_FROM_RM32 (0x83) /* /5 */
 //#define OPCODE_SHL_RM32_BY_I8 (0xc1) /* /4 */
 //#define OPCODE_SHR_RM32_BY_I8 (0xc1) /* /5 */
 //#define OPCODE_SAR_RM32_BY_I8 (0xc1) /* /7 */
+#define OPCODE_SHL_RM32_CL (0xd3) /* /4 */
+#define OPCODE_SAR_RM32_CL (0xd3) /* /7 */
 //#define OPCODE_CMP_I32_WITH_RM32 (0x81) /* /7 */
 //#define OPCODE_CMP_I8_WITH_RM32 (0x83) /* /7 */
 #define OPCODE_CMP_R32_WITH_RM32 (0x39)
@@ -204,6 +206,10 @@ STATIC void asm_x86_write_r32_disp(asm_x86_t *as, int r32, int disp_r32, int dis
  }
 }
 
+STATIC void asm_x86_generic_r32_r32(asm_x86_t *as, int dest_r32, int src_r32, int op) {
+ asm_x86_write_byte_2(as, op, MODRM_R32(src_r32) | MODRM_RM_REG | MODRM_RM_R32(dest_r32));
+}
+
 STATIC void asm_x86_nop(asm_x86_t *as) {
  asm_x86_write_byte_1(as, OPCODE_NOP);
 }
@@ -232,8 +238,8 @@ STATIC void asm_x86_ret(asm_x86_t *as) {
  asm_x86_write_byte_1(as, OPCODE_RET);
 }
 
-void asm_x86_mov_r32_to_r32(asm_x86_t *as, int src_r32, int dest_r32) {
- asm_x86_write_byte_2(as, OPCODE_MOV_R32_TO_RM32, MODRM_R32(src_r32) | MODRM_RM_REG | MODRM_RM_R32(dest_r32));
+void asm_x86_mov_r32_r32(asm_x86_t *as, int dest_r32, int src_r32) {
+ asm_x86_generic_r32_r32(as, dest_r32, src_r32, OPCODE_MOV_R32_TO_RM32);
 }
 
 void asm_x86_mov_r8_to_disp(asm_x86_t *as, int src_r32, int dest_r32, int dest_disp) {
@@ -281,12 +287,20 @@ void asm_x86_mov_i32_to_r32_aligned(asm_x86_t *as, int32_t src_i32, int dest_r32
  asm_x86_mov_i32_to_r32(as, src_i32, dest_r32);
 }
 
-void asm_x86_xor_r32_to_r32(asm_x86_t *as, int src_r32, int dest_r32) {
- asm_x86_write_byte_2(as, OPCODE_XOR_R32_TO_RM32, MODRM_R32(src_r32) | MODRM_RM_REG | MODRM_RM_R32(dest_r32));
+void asm_x86_xor_r32_r32(asm_x86_t *as, int dest_r32, int src_r32) {
+ asm_x86_generic_r32_r32(as, dest_r32, src_r32, OPCODE_XOR_R32_TO_RM32);
+}
+
+void asm_x86_shl_r32_cl(asm_x86_t* as, int dest_r32) {
+ asm_x86_generic_r32_r32(as, dest_r32, 4, OPCODE_SHL_RM32_CL);
 }
 
-void asm_x86_add_r32_to_r32(asm_x86_t *as, int src_r32, int dest_r32) {
- asm_x86_write_byte_2(as, OPCODE_ADD_R32_TO_RM32, MODRM_R32(src_r32) | MODRM_RM_REG | MODRM_RM_R32(dest_r32));
+void asm_x86_sar_r32_cl(asm_x86_t* as, int dest_r32) {
+ asm_x86_generic_r32_r32(as, dest_r32, 7, OPCODE_SAR_RM32_CL);
+}
+
+void asm_x86_add_r32_r32(asm_x86_t *as, int dest_r32, int src_r32) {
+ asm_x86_generic_r32_r32(as, dest_r32, src_r32, OPCODE_ADD_R32_TO_RM32);
 }
 
 void asm_x86_add_i32_to_r32(asm_x86_t *as, int src_i32, int dest_r32) {
@@ -299,13 +313,11 @@ void asm_x86_add_i32_to_r32(asm_x86_t *as, int src_i32, int dest_r32) {
  }
 }
 
-#if 0
-void asm_x86_sub_r32_from_r32(asm_x86_t *as, int src_r32, int dest_r32) {
- asm_x86_write_byte_2(as, OPCODE_SUB_R32_FROM_RM32, MODRM_R32(src_r32) | MODRM_RM_REG | MODRM_RM_R32(dest_r32));
+void asm_x86_sub_r32_r32(asm_x86_t *as, int dest_r32, int src_r32) {
+ asm_x86_generic_r32_r32(as, dest_r32, src_r32, OPCODE_SUB_R32_FROM_RM32);
 }
-#endif
 
-void asm_x86_sub_i32_from_r32(asm_x86_t *as, int src_i32, int dest_r32) {
+STATIC void asm_x86_sub_r32_i32(asm_x86_t *as, int dest_r32, int src_i32) {
  if (SIGNED_FIT8(src_i32)) {
  // defaults to 32 bit operation
  asm_x86_write_byte_2(as, OPCODE_SUB_I8_FROM_RM32, MODRM_R32(5) | MODRM_RM_REG | MODRM_RM_R32(dest_r32));
@@ -426,9 +438,9 @@ void asm_x86_jcc_label(asm_x86_t *as, mp_uint_t jcc_type, mp_uint_t label) {
 
 void asm_x86_entry(asm_x86_t *as, mp_uint_t num_locals) {
  asm_x86_push_r32(as, ASM_X86_REG_EBP);
- asm_x86_mov_r32_to_r32(as, ASM_X86_REG_ESP, ASM_X86_REG_EBP);
+ asm_x86_mov_r32_r32(as, ASM_X86_REG_EBP, ASM_X86_REG_ESP);
  if (num_locals > 0) {
- asm_x86_sub_i32_from_r32(as, num_locals * WORD_SIZE, ASM_X86_REG_ESP);
+ asm_x86_sub_r32_i32(as, ASM_X86_REG_ESP, num_locals * WORD_SIZE);
  }
  asm_x86_push_r32(as, ASM_X86_REG_EBX);
  asm_x86_push_r32(as, ASM_X86_REG_ESI);
@@ -487,7 +499,7 @@ void asm_x86_mov_r32_to_local(asm_x86_t *as, int src_r32, int dest_local_num) {
 void asm_x86_mov_local_addr_to_r32(asm_x86_t *as, int local_num, int dest_r32) {
  int offset = asm_x86_local_offset_from_ebp(as, local_num);
  if (offset == 0) {
- asm_x86_mov_r32_to_r32(as, ASM_X86_REG_EBP, dest_r32);
+ asm_x86_mov_r32_r32(as, dest_r32, ASM_X86_REG_EBP);
  } else {
  asm_x86_lea_disp_to_r32(as, ASM_X86_REG_EBP, offset, dest_r32);
  }
@@ -500,7 +512,7 @@ void asm_x86_push_local(asm_x86_t *as, int local_num) {
 
 void asm_x86_push_local_addr(asm_x86_t *as, int local_num, int temp_r32)
 {
- asm_x86_mov_r32_to_r32(as, ASM_X86_REG_EBP, temp_r32);
+ asm_x86_mov_r32_r32(as, temp_r32, ASM_X86_REG_EBP);
  asm_x86_add_i32_to_r32(as, asm_x86_local_offset_from_ebp(as, local_num), temp_r32);
  asm_x86_push_r32(as, temp_r32);
 }