py/asmthumb: Make ARMv7-M instruction use dynamically selectable.

This commit adjusts the asm_thumb_xxx functions so they can be dynamically
configured to use ARMv7-M instructions or not.  This is available when
MICROPY_DYNAMIC_COMPILER is enabled, and then controlled by the value of
mp_dynamic_compiler.native_arch.

If MICROPY_DYNAMIC_COMPILER is disabled the previous behaviour is retained:
the functions emit ARMv7-M instructions only if MICROPY_EMIT_THUMB_ARMV7M
is enabled.
Signed-off-by: Damien George <damien@micropython.org>

py/asmthumb.h

@@ -29,6 +29,7 @@
 #include <assert.h>
 #include "py/misc.h"
 #include "py/asmbase.h"
+#include "py/persistentcode.h"
 
 #define ASM_THUMB_REG_R0  (0)
 #define ASM_THUMB_REG_R1  (1)
@@ -70,6 +71,21 @@ typedef struct _asm_thumb_t {
     uint32_t stack_adjust;
 } asm_thumb_t;
 
+#if MICROPY_DYNAMIC_COMPILER
+
+static inline bool asm_thumb_allow_armv7m(asm_thumb_t *as) {
+    return MP_NATIVE_ARCH_ARMV7M <= mp_dynamic_compiler.native_arch
+           && mp_dynamic_compiler.native_arch <= MP_NATIVE_ARCH_ARMV7EMDP;
+}
+
+#else
+
+static inline bool asm_thumb_allow_armv7m(asm_thumb_t *as) {
+    return MICROPY_EMIT_THUMB_ARMV7M;
+}
+
+#endif
+
 static inline void asm_thumb_end_pass(asm_thumb_t *as) {
     (void)as;
 }
@@ -308,12 +324,7 @@ static inline void asm_thumb_sxth_rlo_rlo(asm_thumb_t *as, uint rlo_dest, uint r
 #define ASM_THUMB_OP_MOVT (0xf2c0)
 
 void asm_thumb_mov_reg_reg(asm_thumb_t *as, uint reg_dest, uint reg_src);
-
-#if MICROPY_EMIT_THUMB_ARMV7M
-size_t asm_thumb_mov_reg_i16(asm_thumb_t *as, uint mov_op, uint reg_dest, int i16_src);
-#else
-void asm_thumb_mov_rlo_i16(asm_thumb_t *as, uint rlo_dest, int i16_src);
-#endif
+void asm_thumb_mov_reg_i16(asm_thumb_t *as, uint mov_op, uint reg_dest, int i16_src);
 
 // these return true if the destination is in range, false otherwise
 bool asm_thumb_b_n_label(asm_thumb_t *as, uint label);
@@ -390,11 +401,6 @@ void asm_thumb_b_rel12(asm_thumb_t *as, int rel);
 
 #define ASM_MOV_LOCAL_REG(as, local_num, reg) asm_thumb_mov_local_reg((as), (local_num), (reg))
 #define ASM_MOV_REG_IMM(as, reg_dest, imm) asm_thumb_mov_reg_i32_optimised((as), (reg_dest), (imm))
-#if MICROPY_EMIT_THUMB_ARMV7M
-#define ASM_MOV_REG_IMM_FIX_U16(as, reg_dest, imm) asm_thumb_mov_reg_i16((as), ASM_THUMB_OP_MOVW, (reg_dest), (imm))
-#else
-#define ASM_MOV_REG_IMM_FIX_U16(as, reg_dest, imm) asm_thumb_mov_rlo_i16((as), (reg_dest), (imm))
-#endif
 #define ASM_MOV_REG_IMM_FIX_WORD(as, reg_dest, imm) asm_thumb_mov_reg_i32((as), (reg_dest), (imm))
 #define ASM_MOV_REG_LOCAL(as, reg_dest, local_num) asm_thumb_mov_reg_local((as), (reg_dest), (local_num))
 #define ASM_MOV_REG_REG(as, reg_dest, reg_src) asm_thumb_mov_reg_reg((as), (reg_dest), (reg_src))

py/emitnative.c

@@ -2421,48 +2421,48 @@ STATIC void emit_native_binary_op(emit_t *emit, mp_binary_op_t op) {
             asm_x86_setcc_r8(emit->as, ops[op_idx], REG_RET);
             #elif N_THUMB
             asm_thumb_cmp_rlo_rlo(emit->as, REG_ARG_2, reg_rhs);
-            #if MICROPY_EMIT_THUMB_ARMV7M
-            static uint16_t ops[6 + 6] = {
-                // unsigned
-                ASM_THUMB_OP_ITE_CC,
-                ASM_THUMB_OP_ITE_HI,
-                ASM_THUMB_OP_ITE_EQ,
-                ASM_THUMB_OP_ITE_LS,
-                ASM_THUMB_OP_ITE_CS,
-                ASM_THUMB_OP_ITE_NE,
-                // signed
-                ASM_THUMB_OP_ITE_LT,
-                ASM_THUMB_OP_ITE_GT,
-                ASM_THUMB_OP_ITE_EQ,
-                ASM_THUMB_OP_ITE_LE,
-                ASM_THUMB_OP_ITE_GE,
-                ASM_THUMB_OP_ITE_NE,
-            };
-            asm_thumb_op16(emit->as, ops[op_idx]);
-            asm_thumb_mov_rlo_i8(emit->as, REG_RET, 1);
-            asm_thumb_mov_rlo_i8(emit->as, REG_RET, 0);
-            #else
-            static uint16_t ops[6 + 6] = {
-                // unsigned
-                ASM_THUMB_CC_CC,
-                ASM_THUMB_CC_HI,
-                ASM_THUMB_CC_EQ,
-                ASM_THUMB_CC_LS,
-                ASM_THUMB_CC_CS,
-                ASM_THUMB_CC_NE,
-                // signed
-                ASM_THUMB_CC_LT,
-                ASM_THUMB_CC_GT,
-                ASM_THUMB_CC_EQ,
-                ASM_THUMB_CC_LE,
-                ASM_THUMB_CC_GE,
-                ASM_THUMB_CC_NE,
-            };
-            asm_thumb_bcc_rel9(emit->as, ops[op_idx], 6);
-            asm_thumb_mov_rlo_i8(emit->as, REG_RET, 0);
-            asm_thumb_b_rel12(emit->as, 4);
-            asm_thumb_mov_rlo_i8(emit->as, REG_RET, 1);
-            #endif
+            if (asm_thumb_allow_armv7m(emit->as)) {
+                static uint16_t ops[6 + 6] = {
+                    // unsigned
+                    ASM_THUMB_OP_ITE_CC,
+                    ASM_THUMB_OP_ITE_HI,
+                    ASM_THUMB_OP_ITE_EQ,
+                    ASM_THUMB_OP_ITE_LS,
+                    ASM_THUMB_OP_ITE_CS,
+                    ASM_THUMB_OP_ITE_NE,
+                    // signed
+                    ASM_THUMB_OP_ITE_LT,
+                    ASM_THUMB_OP_ITE_GT,
+                    ASM_THUMB_OP_ITE_EQ,
+                    ASM_THUMB_OP_ITE_LE,
+                    ASM_THUMB_OP_ITE_GE,
+                    ASM_THUMB_OP_ITE_NE,
+                };
+                asm_thumb_op16(emit->as, ops[op_idx]);
+                asm_thumb_mov_rlo_i8(emit->as, REG_RET, 1);
+                asm_thumb_mov_rlo_i8(emit->as, REG_RET, 0);
+            } else {
+                static uint16_t ops[6 + 6] = {
+                    // unsigned
+                    ASM_THUMB_CC_CC,
+                    ASM_THUMB_CC_HI,
+                    ASM_THUMB_CC_EQ,
+                    ASM_THUMB_CC_LS,
+                    ASM_THUMB_CC_CS,
+                    ASM_THUMB_CC_NE,
+                    // signed
+                    ASM_THUMB_CC_LT,
+                    ASM_THUMB_CC_GT,
+                    ASM_THUMB_CC_EQ,
+                    ASM_THUMB_CC_LE,
+                    ASM_THUMB_CC_GE,
+                    ASM_THUMB_CC_NE,
+                };
+                asm_thumb_bcc_rel9(emit->as, ops[op_idx], 6);
+                asm_thumb_mov_rlo_i8(emit->as, REG_RET, 0);
+                asm_thumb_b_rel12(emit->as, 4);
+                asm_thumb_mov_rlo_i8(emit->as, REG_RET, 1);
+            }
             #elif N_ARM
             asm_arm_cmp_reg_reg(emit->as, REG_ARG_2, reg_rhs);
             static uint ccs[6 + 6] = {