#include <stdio.h>

#include <string.h>

#include <assert.h>

#include "py/emit.h"

#include "py/nativeglue.h"

#include "py/objfun.h"

#include "py/objstr.h"

#if MICROPY_DEBUG_VERBOSE // print debugging info

#define DEBUG_PRINT (1)

#define DEBUG_printf DEBUG_printf

#else // don't print debugging info

#define DEBUG_PRINT (0)

#define DEBUG_printf(...) (void)0

#ifndef N_X64

#define N_X64 (0)

#ifndef N_X86

#define N_X86 (0)

#ifndef N_THUMB

#define N_THUMB (0)

#ifndef N_ARM

#define N_ARM (0)

#ifndef N_XTENSA

#define N_XTENSA (0)

#ifndef N_NLR_SETJMP

#define N_NLR_SETJMP (0)

#ifndef N_PRELUDE_AS_BYTES_OBJ

#define N_PRELUDE_AS_BYTES_OBJ (0)

#if N_X64 || N_X86 || N_THUMB || N_ARM || N_XTENSA || N_XTENSAWIN

#if MICROPY_DYNAMIC_COMPILER

#define SIZEOF_NLR_BUF (2 + mp_dynamic_compiler.nlr_buf_num_regs + 1) // the +1 is conservative in case MICROPY_ENABLE_PYSTACK enabled

#define SIZEOF_NLR_BUF (sizeof(nlr_buf_t) / sizeof(uintptr_t))

#define SIZEOF_CODE_STATE (sizeof(mp_code_state_native_t) / sizeof(uintptr_t))

#define OFFSETOF_CODE_STATE_STATE (offsetof(mp_code_state_native_t, state) / sizeof(uintptr_t))

#define OFFSETOF_CODE_STATE_FUN_BC (offsetof(mp_code_state_native_t, fun_bc) / sizeof(uintptr_t))

#define OFFSETOF_CODE_STATE_IP (offsetof(mp_code_state_native_t, ip) / sizeof(uintptr_t))

#define OFFSETOF_CODE_STATE_SP (offsetof(mp_code_state_native_t, sp) / sizeof(uintptr_t))

#define OFFSETOF_CODE_STATE_N_STATE (offsetof(mp_code_state_native_t, n_state) / sizeof(uintptr_t))

#define OFFSETOF_OBJ_FUN_BC_CONTEXT (offsetof(mp_obj_fun_bc_t, context) / sizeof(uintptr_t))

#define OFFSETOF_OBJ_FUN_BC_CHILD_TABLE (offsetof(mp_obj_fun_bc_t, child_table) / sizeof(uintptr_t))

#define OFFSETOF_OBJ_FUN_BC_BYTECODE (offsetof(mp_obj_fun_bc_t, bytecode) / sizeof(uintptr_t))

#define OFFSETOF_MODULE_CONTEXT_QSTR_TABLE (offsetof(mp_module_context_t, constants.qstr_table) / sizeof(uintptr_t))

#define OFFSETOF_MODULE_CONTEXT_OBJ_TABLE (offsetof(mp_module_context_t, constants.obj_table) / sizeof(uintptr_t))

#define OFFSETOF_MODULE_CONTEXT_GLOBALS (offsetof(mp_module_context_t, module.globals) / sizeof(uintptr_t))

#ifndef REG_PARENT_RET

#define REG_PARENT_RET REG_RET

#define REG_PARENT_ARG_1 REG_ARG_1

#define REG_PARENT_ARG_2 REG_ARG_2

#define REG_PARENT_ARG_3 REG_ARG_3

#define REG_PARENT_ARG_4 REG_ARG_4

#define NLR_BUF_IDX_RET_VAL (1)

#define NEED_FUN_OBJ(emit) ((emit)->scope->exc_stack_size > 0 \

|| ((emit)->scope->scope_flags & (MP_SCOPE_FLAG_REFGLOBALS | MP_SCOPE_FLAG_HASCONSTS)))

#define NEED_GLOBAL_EXC_HANDLER(emit) ((emit)->scope->exc_stack_size > 0 \

|| ((emit)->scope->scope_flags & (MP_SCOPE_FLAG_GENERATOR | MP_SCOPE_FLAG_REFGLOBALS)))

#define NEED_EXC_HANDLER_UNWIND(emit) ((emit)->scope->exc_stack_size > 0)

#define CAN_USE_REGS_FOR_LOCALS(emit) ((emit)->scope->exc_stack_size == 0 && !(emit->scope->scope_flags & MP_SCOPE_FLAG_GENERATOR))

#define LOCAL_IDX_EXC_VAL(emit) (NLR_BUF_IDX_RET_VAL)

#define LOCAL_IDX_EXC_HANDLER_PC(emit) (NLR_BUF_IDX_LOCAL_1)

#define LOCAL_IDX_EXC_HANDLER_UNWIND(emit) (SIZEOF_NLR_BUF + 1) // this needs a dedicated variable outside nlr_buf_t

#define LOCAL_IDX_RET_VAL(emit) (SIZEOF_NLR_BUF) // needed when NEED_GLOBAL_EXC_HANDLER is true

#define LOCAL_IDX_FUN_OBJ(emit) ((emit)->code_state_start + OFFSETOF_CODE_STATE_FUN_BC)

#define LOCAL_IDX_OLD_GLOBALS(emit) ((emit)->code_state_start + OFFSETOF_CODE_STATE_IP)

#define LOCAL_IDX_GEN_PC(emit) ((emit)->code_state_start + OFFSETOF_CODE_STATE_IP)

#define LOCAL_IDX_LOCAL_VAR(emit, local_num) ((emit)->stack_start + (emit)->n_state - 1 - (local_num))

#if MICROPY_PERSISTENT_CODE_SAVE

#define REG_GENERATOR_STATE (REG_LOCAL_2)

#define REG_QSTR_TABLE (REG_LOCAL_3)

#define MAX_REGS_FOR_LOCAL_VARS (2)

static const uint8_t reg_local_table[MAX_REGS_FOR_LOCAL_VARS] = {REG_LOCAL_1, REG_LOCAL_2};

#define REG_GENERATOR_STATE (REG_LOCAL_3)

#define MAX_REGS_FOR_LOCAL_VARS (3)

static const uint8_t reg_local_table[MAX_REGS_FOR_LOCAL_VARS] = {REG_LOCAL_1, REG_LOCAL_2, REG_LOCAL_3};

#define REG_LOCAL_LAST (reg_local_table[MAX_REGS_FOR_LOCAL_VARS - 1])

#define EMIT_NATIVE_VIPER_TYPE_ERROR(emit, ...) do { \

*emit->error_slot = mp_obj_new_exception_msg_varg(&mp_type_ViperTypeError, __VA_ARGS__); \

} while (0)

typedef enum {

STACK_VALUE,

STACK_REG,

STACK_IMM,

} stack_info_kind_t;

typedef enum {

VTYPE_PYOBJ = 0x00 | MP_NATIVE_TYPE_OBJ,

VTYPE_BOOL = 0x00 | MP_NATIVE_TYPE_BOOL,

VTYPE_INT = 0x00 | MP_NATIVE_TYPE_INT,

VTYPE_UINT = 0x00 | MP_NATIVE_TYPE_UINT,

VTYPE_PTR = 0x00 | MP_NATIVE_TYPE_PTR,

VTYPE_PTR8 = 0x00 | MP_NATIVE_TYPE_PTR8,

VTYPE_PTR16 = 0x00 | MP_NATIVE_TYPE_PTR16,

VTYPE_PTR32 = 0x00 | MP_NATIVE_TYPE_PTR32,

VTYPE_PTR_NONE = 0x50 | MP_NATIVE_TYPE_PTR,

VTYPE_UNBOUND = 0x60 | MP_NATIVE_TYPE_OBJ,

VTYPE_BUILTIN_CAST = 0x70 | MP_NATIVE_TYPE_OBJ,

} vtype_kind_t;

static qstr vtype_to_qstr(vtype_kind_t vtype) {

switch (vtype) {

case VTYPE_PYOBJ:

return MP_QSTR_object;

case VTYPE_BOOL:

return MP_QSTR_bool;

case VTYPE_INT:

return MP_QSTR_int;

case VTYPE_UINT:

return MP_QSTR_uint;

case VTYPE_PTR:

return MP_QSTR_ptr;

case VTYPE_PTR8:

return MP_QSTR_ptr8;

case VTYPE_PTR16:

return MP_QSTR_ptr16;

case VTYPE_PTR32:

return MP_QSTR_ptr32;

case VTYPE_PTR_NONE:

default:

return MP_QSTR_None;

}

}

typedef struct _stack_info_t {

} stack_info_t;

#define UNWIND_LABEL_UNUSED (0x7fff)

#define UNWIND_LABEL_DO_FINAL_UNWIND (0x7ffe)

typedef struct _exc_stack_entry_t {

} exc_stack_entry_t;

struct _emit_t {

};

static void emit_load_reg_with_object(emit_t *emit, int reg, mp_obj_t obj);

static void emit_native_global_exc_entry(emit_t *emit);

static void emit_native_global_exc_exit(emit_t *emit);

static void emit_native_load_const_obj(emit_t *emit, mp_obj_t obj);

emit_t *EXPORT_FUN(new)(mp_emit_common_t * emit_common, mp_obj_t *error_slot, uint *label_slot, mp_uint_t max_num_labels) {

emit_t *emit = m_new0(emit_t, 1);

emit->emit_common = emit_common;

emit->error_slot = error_slot;

emit->label_slot = label_slot;

emit->stack_info_alloc = 8;

emit->stack_info = m_new(stack_info_t, emit->stack_info_alloc);

emit->exc_stack_alloc = 8;

emit->exc_stack = m_new(exc_stack_entry_t, emit->exc_stack_alloc);

emit->as = m_new0(ASM_T, 1);

mp_asm_base_init(&emit->as->base, max_num_labels);

return emit;

}

void EXPORT_FUN(free)(emit_t * emit) {

mp_asm_base_deinit(&emit->as->base, false);

m_del_obj(ASM_T, emit->as);

m_del(exc_stack_entry_t, emit->exc_stack, emit->exc_stack_alloc);

m_del(vtype_kind_t, emit->local_vtype, emit->local_vtype_alloc);

m_del(stack_info_t, emit->stack_info, emit->stack_info_alloc);

m_del_obj(emit_t, emit);

}

static void emit_call_with_imm_arg(emit_t *emit, mp_fun_kind_t fun_kind, mp_int_t arg_val, int arg_reg);

static void emit_native_mov_reg_const(emit_t *emit, int reg_dest, int const_val) {

ASM_LOAD_REG_REG_OFFSET(emit->as, reg_dest, REG_FUN_TABLE, const_val);

}

static void emit_native_mov_state_reg(emit_t *emit, int local_num, int reg_src) {

if (emit->scope->scope_flags & MP_SCOPE_FLAG_GENERATOR) {

ASM_STORE_REG_REG_OFFSET(emit->as, reg_src, REG_GENERATOR_STATE, local_num);

} else {

ASM_MOV_LOCAL_REG(emit->as, local_num, reg_src);

}

}

static void emit_native_mov_reg_state(emit_t *emit, int reg_dest, int local_num) {

if (emit->scope->scope_flags & MP_SCOPE_FLAG_GENERATOR) {

ASM_LOAD_REG_REG_OFFSET(emit->as, reg_dest, REG_GENERATOR_STATE, local_num);

} else {

ASM_MOV_REG_LOCAL(emit->as, reg_dest, local_num);

}

}

static void emit_native_mov_reg_state_addr(emit_t *emit, int reg_dest, int local_num) {

if (emit->scope->scope_flags & MP_SCOPE_FLAG_GENERATOR) {

ASM_MOV_REG_IMM(emit->as, reg_dest, local_num * ASM_WORD_SIZE);

ASM_ADD_REG_REG(emit->as, reg_dest, REG_GENERATOR_STATE);

} else {

ASM_MOV_REG_LOCAL_ADDR(emit->as, reg_dest, local_num);

}

}

static void emit_native_mov_reg_qstr(emit_t *emit, int arg_reg, qstr qst) {

#if MICROPY_PERSISTENT_CODE_SAVE

ASM_LOAD16_REG_REG_OFFSET(emit->as, arg_reg, REG_QSTR_TABLE, mp_emit_common_use_qstr(emit->emit_common, qst));

#else

ASM_MOV_REG_IMM(emit->as, arg_reg, qst);

#endif

}

static void emit_native_mov_reg_qstr_obj(emit_t *emit, int reg_dest, qstr qst) {

#if MICROPY_PERSISTENT_CODE_SAVE

emit_load_reg_with_object(emit, reg_dest, MP_OBJ_NEW_QSTR(qst));

#else

ASM_MOV_REG_IMM(emit->as, reg_dest, (mp_uint_t)MP_OBJ_NEW_QSTR(qst));

#endif

}

#define emit_native_mov_state_imm_via(emit, local_num, imm, reg_temp) \

do { \

ASM_MOV_REG_IMM((emit)->as, (reg_temp), (imm)); \

emit_native_mov_state_reg((emit), (local_num), (reg_temp)); \

} while (false)

static void emit_native_start_pass(emit_t *emit, pass_kind_t pass, scope_t *scope) {

DEBUG_printf("start_pass(pass=%u, scope=%p)\n", pass, scope);

emit->pass = pass;

emit->do_viper_types = scope->emit_options == MP_EMIT_OPT_VIPER;

emit->stack_size = 0;

emit->scope = scope;

// allocate memory for keeping track of the types of locals

if (emit->local_vtype_alloc < scope->num_locals) {

emit->local_vtype = m_renew(vtype_kind_t, emit->local_vtype, emit->local_vtype_alloc, scope->num_locals);

emit->local_vtype_alloc = scope->num_locals;

}

// set default type for arguments

mp_uint_t num_args = emit->scope->num_pos_args + emit->scope->num_kwonly_args;

if (scope->scope_flags & MP_SCOPE_FLAG_VARARGS) {

num_args += 1;

}

if (scope->scope_flags & MP_SCOPE_FLAG_VARKEYWORDS) {

num_args += 1;

}

for (mp_uint_t i = 0; i < num_args; i++) {

emit->local_vtype[i] = VTYPE_PYOBJ;

}

// Set viper type for arguments

if (emit->do_viper_types) {

for (int i = 0; i < emit->scope->id_info_len; ++i) {

id_info_t *id = &emit->scope->id_info[i];

if (id->flags & ID_FLAG_IS_PARAM) {

assert(id->local_num < emit->local_vtype_alloc);

emit->local_vtype[id->local_num] = id->flags >> ID_FLAG_VIPER_TYPE_POS;

}

}

}

// local variables begin unbound, and have unknown type

for (mp_uint_t i = num_args; i < emit->local_vtype_alloc; i++) {

emit->local_vtype[i] = emit->do_viper_types ? VTYPE_UNBOUND : VTYPE_PYOBJ;

}

// values on stack begin unbound

for (mp_uint_t i = 0; i < emit->stack_info_alloc; i++) {

emit->stack_info[i].kind = STACK_VALUE;

emit->stack_info[i].vtype = VTYPE_UNBOUND;

}

mp_asm_base_start_pass(&emit->as->base, pass == MP_PASS_EMIT ? MP_ASM_PASS_EMIT : MP_ASM_PASS_COMPUTE);

// generate code for entry to function

// Work out start of code state (mp_code_state_native_t or reduced version for viper)

emit->code_state_start = 0;

if (NEED_GLOBAL_EXC_HANDLER(emit)) {

emit->code_state_start = SIZEOF_NLR_BUF; // for nlr_buf_t

emit->code_state_start += 1; // for return_value

if (NEED_EXC_HANDLER_UNWIND(emit)) {

emit->code_state_start += 1;

}

}

size_t fun_table_off = mp_emit_common_use_const_obj(emit->emit_common, MP_OBJ_FROM_PTR(&mp_fun_table));

if (emit->do_viper_types) {

// Work out size of state (locals plus stack)

// n_state counts all stack and locals, even those in registers

emit->n_state = scope->num_locals + scope->stack_size;

int num_locals_in_regs = 0;

if (CAN_USE_REGS_FOR_LOCALS(emit)) {

num_locals_in_regs = scope->num_locals;

if (num_locals_in_regs > MAX_REGS_FOR_LOCAL_VARS) {

num_locals_in_regs = MAX_REGS_FOR_LOCAL_VARS;

}

// Need a spot for REG_LOCAL_LAST (see below)

if (scope->num_pos_args >= MAX_REGS_FOR_LOCAL_VARS + 1) {

--num_locals_in_regs;

}

}

// Work out where the locals and Python stack start within the C stack

if (NEED_GLOBAL_EXC_HANDLER(emit)) {

// Reserve 2 words for function object and old globals

emit->stack_start = emit->code_state_start + 2;

} else if (scope->scope_flags & MP_SCOPE_FLAG_HASCONSTS) {

// Reserve 1 word for function object, to access const table

emit->stack_start = emit->code_state_start + 1;

} else {

emit->stack_start = emit->code_state_start + 0;

}

// Entry to function

ASM_ENTRY(emit->as, emit->stack_start + emit->n_state - num_locals_in_regs);

#if N_X86

asm_x86_mov_arg_to_r32(emit->as, 0, REG_PARENT_ARG_1);

#endif

// Load REG_FUN_TABLE with a pointer to mp_fun_table, found in the const_table

ASM_LOAD_REG_REG_OFFSET(emit->as, REG_FUN_TABLE, REG_PARENT_ARG_1, OFFSETOF_OBJ_FUN_BC_CONTEXT);

#if MICROPY_PERSISTENT_CODE_SAVE

ASM_LOAD_REG_REG_OFFSET(emit->as, REG_QSTR_TABLE, REG_FUN_TABLE, OFFSETOF_MODULE_CONTEXT_QSTR_TABLE);

#endif

ASM_LOAD_REG_REG_OFFSET(emit->as, REG_FUN_TABLE, REG_FUN_TABLE, OFFSETOF_MODULE_CONTEXT_OBJ_TABLE);

ASM_LOAD_REG_REG_OFFSET(emit->as, REG_FUN_TABLE, REG_FUN_TABLE, fun_table_off);

// Store function object (passed as first arg) to stack if needed

if (NEED_FUN_OBJ(emit)) {

ASM_MOV_LOCAL_REG(emit->as, LOCAL_IDX_FUN_OBJ(emit), REG_PARENT_ARG_1);

}

// Put n_args in REG_ARG_1, n_kw in REG_ARG_2, args array in REG_LOCAL_LAST

#if N_X86

asm_x86_mov_arg_to_r32(emit->as, 1, REG_ARG_1);

asm_x86_mov_arg_to_r32(emit->as, 2, REG_ARG_2);

asm_x86_mov_arg_to_r32(emit->as, 3, REG_LOCAL_LAST);

#else

ASM_MOV_REG_REG(emit->as, REG_ARG_1, REG_PARENT_ARG_2);

ASM_MOV_REG_REG(emit->as, REG_ARG_2, REG_PARENT_ARG_3);

ASM_MOV_REG_REG(emit->as, REG_LOCAL_LAST, REG_PARENT_ARG_4);

#endif

// Check number of args matches this function, and call mp_arg_check_num_sig if not

ASM_JUMP_IF_REG_NONZERO(emit->as, REG_ARG_2, *emit->label_slot + 4, true);

ASM_MOV_REG_IMM(emit->as, REG_ARG_3, scope->num_pos_args);

ASM_JUMP_IF_REG_EQ(emit->as, REG_ARG_1, REG_ARG_3, *emit->label_slot + 5);

mp_asm_base_label_assign(&emit->as->base, *emit->label_slot + 4);

ASM_MOV_REG_IMM(emit->as, REG_ARG_3, MP_OBJ_FUN_MAKE_SIG(scope->num_pos_args, scope->num_pos_args, false));

ASM_CALL_IND(emit->as, MP_F_ARG_CHECK_NUM_SIG);

mp_asm_base_label_assign(&emit->as->base, *emit->label_slot + 5);

// Store arguments into locals (reg or stack), converting to native if needed

for (int i = 0; i < emit->scope->num_pos_args; i++) {

int r = REG_ARG_1;

ASM_LOAD_REG_REG_OFFSET(emit->as, REG_ARG_1, REG_LOCAL_LAST, i);

if (emit->local_vtype[i] != VTYPE_PYOBJ) {

emit_call_with_imm_arg(emit, MP_F_CONVERT_OBJ_TO_NATIVE, emit->local_vtype[i], REG_ARG_2);

r = REG_RET;

}

// REG_LOCAL_LAST points to the args array so be sure not to overwrite it if it's still needed

if (i < MAX_REGS_FOR_LOCAL_VARS && CAN_USE_REGS_FOR_LOCALS(emit) && (i != MAX_REGS_FOR_LOCAL_VARS - 1 || emit->scope->num_pos_args == MAX_REGS_FOR_LOCAL_VARS)) {

ASM_MOV_REG_REG(emit->as, reg_local_table[i], r);

} else {

emit_native_mov_state_reg(emit, LOCAL_IDX_LOCAL_VAR(emit, i), r);

}

}

// Get local from the stack back into REG_LOCAL_LAST if this reg couldn't be written to above

if (emit->scope->num_pos_args >= MAX_REGS_FOR_LOCAL_VARS + 1 && CAN_USE_REGS_FOR_LOCALS(emit)) {

ASM_MOV_REG_LOCAL(emit->as, REG_LOCAL_LAST, LOCAL_IDX_LOCAL_VAR(emit, MAX_REGS_FOR_LOCAL_VARS - 1));

}

emit_native_global_exc_entry(emit);

} else {

// work out size of state (locals plus stack)

emit->n_state = scope->num_locals + scope->stack_size;

// Store in the first machine-word an index used to the function's prelude.

// This is used at runtime by mp_obj_fun_native_get_prelude_ptr().

mp_asm_base_data(&emit->as->base, ASM_WORD_SIZE, (uintptr_t)emit->prelude_ptr_index);

if (emit->scope->scope_flags & MP_SCOPE_FLAG_GENERATOR) {

mp_asm_base_data(&emit->as->base, ASM_WORD_SIZE, (uintptr_t)emit->start_offset);

ASM_ENTRY(emit->as, emit->code_state_start);

// Reset the state size for the state pointed to by REG_GENERATOR_STATE

emit->code_state_start = 0;

emit->stack_start = SIZEOF_CODE_STATE;

// Put address of code_state into REG_GENERATOR_STATE

#if N_X86

asm_x86_mov_arg_to_r32(emit->as, 0, REG_GENERATOR_STATE);

#else

ASM_MOV_REG_REG(emit->as, REG_GENERATOR_STATE, REG_PARENT_ARG_1);

#endif

// Put throw value into LOCAL_IDX_EXC_VAL slot, for yield/yield-from

#if N_X86

asm_x86_mov_arg_to_r32(emit->as, 1, REG_PARENT_ARG_2);

#endif

ASM_MOV_LOCAL_REG(emit->as, LOCAL_IDX_EXC_VAL(emit), REG_PARENT_ARG_2);

// Load REG_FUN_TABLE with a pointer to mp_fun_table, found in the const_table

ASM_LOAD_REG_REG_OFFSET(emit->as, REG_TEMP0, REG_GENERATOR_STATE, LOCAL_IDX_FUN_OBJ(emit));

ASM_LOAD_REG_REG_OFFSET(emit->as, REG_TEMP0, REG_TEMP0, OFFSETOF_OBJ_FUN_BC_CONTEXT);

#if MICROPY_PERSISTENT_CODE_SAVE

ASM_LOAD_REG_REG_OFFSET(emit->as, REG_QSTR_TABLE, REG_TEMP0, OFFSETOF_MODULE_CONTEXT_QSTR_TABLE);

#endif

ASM_LOAD_REG_REG_OFFSET(emit->as, REG_TEMP0, REG_TEMP0, OFFSETOF_MODULE_CONTEXT_OBJ_TABLE);

ASM_LOAD_REG_REG_OFFSET(emit->as, REG_FUN_TABLE, REG_TEMP0, fun_table_off);

} else {

// The locals and stack start after the code_state structure

emit->stack_start = emit->code_state_start + SIZEOF_CODE_STATE;

// Allocate space on C-stack for code_state structure, which includes state

ASM_ENTRY(emit->as, emit->stack_start + emit->n_state);

// Prepare incoming arguments for call to mp_setup_code_state

#if N_X86

asm_x86_mov_arg_to_r32(emit->as, 0, REG_PARENT_ARG_1);

asm_x86_mov_arg_to_r32(emit->as, 1, REG_PARENT_ARG_2);

asm_x86_mov_arg_to_r32(emit->as, 2, REG_PARENT_ARG_3);

asm_x86_mov_arg_to_r32(emit->as, 3, REG_PARENT_ARG_4);

#endif

// Load REG_FUN_TABLE with a pointer to mp_fun_table, found in the const_table

ASM_LOAD_REG_REG_OFFSET(emit->as, REG_FUN_TABLE, REG_PARENT_ARG_1, OFFSETOF_OBJ_FUN_BC_CONTEXT);

#if MICROPY_PERSISTENT_CODE_SAVE

ASM_LOAD_REG_REG_OFFSET(emit->as, REG_QSTR_TABLE, REG_FUN_TABLE, OFFSETOF_MODULE_CONTEXT_QSTR_TABLE);

#endif

ASM_LOAD_REG_REG_OFFSET(emit->as, REG_FUN_TABLE, REG_FUN_TABLE, OFFSETOF_MODULE_CONTEXT_OBJ_TABLE);

ASM_LOAD_REG_REG_OFFSET(emit->as, REG_FUN_TABLE, REG_FUN_TABLE, fun_table_off);

// Set code_state.fun_bc

ASM_MOV_LOCAL_REG(emit->as, LOCAL_IDX_FUN_OBJ(emit), REG_PARENT_ARG_1);

// Set code_state.n_state (only works on little endian targets due to n_state being uint16_t)

emit_native_mov_state_imm_via(emit, emit->code_state_start + OFFSETOF_CODE_STATE_N_STATE, emit->n_state, REG_ARG_1);

// Put address of code_state into first arg

ASM_MOV_REG_LOCAL_ADDR(emit->as, REG_ARG_1, emit->code_state_start);

// Copy next 3 args if needed

#if REG_ARG_2 != REG_PARENT_ARG_2

ASM_MOV_REG_REG(emit->as, REG_ARG_2, REG_PARENT_ARG_2);

#endif

#if REG_ARG_3 != REG_PARENT_ARG_3

ASM_MOV_REG_REG(emit->as, REG_ARG_3, REG_PARENT_ARG_3);

#endif

#if REG_ARG_4 != REG_PARENT_ARG_4

ASM_MOV_REG_REG(emit->as, REG_ARG_4, REG_PARENT_ARG_4);

#endif

// Call mp_setup_code_state to prepare code_state structure

#if N_THUMB

asm_thumb_bl_ind(emit->as, MP_F_SETUP_CODE_STATE, ASM_THUMB_REG_R4);

#elif N_ARM

asm_arm_bl_ind(emit->as, MP_F_SETUP_CODE_STATE, ASM_ARM_REG_R4);

#else

ASM_CALL_IND(emit->as, MP_F_SETUP_CODE_STATE);

#endif

}

emit_native_global_exc_entry(emit);

// cache some locals in registers, but only if no exception handlers

if (CAN_USE_REGS_FOR_LOCALS(emit)) {

for (int i = 0; i < MAX_REGS_FOR_LOCAL_VARS && i < scope->num_locals; ++i) {

ASM_MOV_REG_LOCAL(emit->as, reg_local_table[i], LOCAL_IDX_LOCAL_VAR(emit, i));

}

}

// set the type of closed over variables

for (mp_uint_t i = 0; i < scope->id_info_len; i++) {

id_info_t *id = &scope->id_info[i];

if (id->kind == ID_INFO_KIND_CELL) {

emit->local_vtype[id->local_num] = VTYPE_PYOBJ;

}

}

}

}

static inline void emit_native_write_code_info_byte(emit_t *emit, byte val) {

mp_asm_base_data(&emit->as->base, 1, val);

}

static inline void emit_native_write_code_info_qstr(emit_t *emit, qstr qst) {

mp_encode_uint(&emit->as->base, mp_asm_base_get_cur_to_write_bytes, mp_emit_common_use_qstr(emit->emit_common, qst));

}

static bool emit_native_end_pass(emit_t *emit) {

emit_native_global_exc_exit(emit);

if (!emit->do_viper_types) {

emit->prelude_offset = mp_asm_base_get_code_pos(&emit->as->base);

emit->prelude_ptr_index = emit->emit_common->ct_cur_child;

size_t n_state = emit->n_state;

size_t n_exc_stack = 0; // exc-stack not needed for native code

MP_BC_PRELUDE_SIG_ENCODE(n_state, n_exc_stack, emit->scope, emit_native_write_code_info_byte, emit);

size_t n_info = emit->n_info;

size_t n_cell = emit->n_cell;

MP_BC_PRELUDE_SIZE_ENCODE(n_info, n_cell, emit_native_write_code_info_byte, emit);

// bytecode prelude: source info (function and argument qstrs)

size_t info_start = mp_asm_base_get_code_pos(&emit->as->base);

emit_native_write_code_info_qstr(emit, emit->scope->simple_name);

for (int i = 0; i < emit->scope->num_pos_args + emit->scope->num_kwonly_args; i++) {

qstr qst = MP_QSTR__star_;

for (int j = 0; j < emit->scope->id_info_len; ++j) {

id_info_t *id = &emit->scope->id_info[j];

if ((id->flags & ID_FLAG_IS_PARAM) && id->local_num == i) {

qst = id->qst;

break;

}

}

emit_native_write_code_info_qstr(emit, qst);

}

emit->n_info = mp_asm_base_get_code_pos(&emit->as->base) - info_start;

// bytecode prelude: initialise closed over variables

size_t cell_start = mp_asm_base_get_code_pos(&emit->as->base);

for (int i = 0; i < emit->scope->id_info_len; i++) {

id_info_t *id = &emit->scope->id_info[i];

if (id->kind == ID_INFO_KIND_CELL) {

assert(id->local_num <= 255);

mp_asm_base_data(&emit->as->base, 1, id->local_num); // write the local which should be converted to a cell

}

}

emit->n_cell = mp_asm_base_get_code_pos(&emit->as->base) - cell_start;

}

ASM_END_PASS(emit->as);

// check stack is back to zero size

assert(emit->stack_size == 0);

assert(emit->exc_stack_size == 0);

if (emit->pass == MP_PASS_EMIT) {

void *f = mp_asm_base_get_code(&emit->as->base);

mp_uint_t f_len = mp_asm_base_get_code_size(&emit->as->base);

mp_raw_code_t **children = emit->emit_common->children;

if (!emit->do_viper_types) {

#if MICROPY_EMIT_NATIVE_PRELUDE_SEPARATE_FROM_MACHINE_CODE

// Executable code cannot be accessed byte-wise on this architecture, so copy

// the prelude to a separate memory region that is byte-wise readable.

void *buf = emit->as->base.code_base + emit->prelude_offset;

size_t n = emit->as->base.code_offset - emit->prelude_offset;

const uint8_t *prelude_ptr = memcpy(m_new(uint8_t, n), buf, n);

#else

// Point to the prelude directly, at the end of the machine code data.

const uint8_t *prelude_ptr = (const uint8_t *)f + emit->prelude_offset;

#endif

// Store the pointer to the prelude using the child_table.

assert(emit->prelude_ptr_index == emit->emit_common->ct_cur_child);

if (emit->prelude_ptr_index == 0) {

children = (void *)prelude_ptr;

} else {

children = m_renew(mp_raw_code_t *, children, emit->prelude_ptr_index, emit->prelude_ptr_index + 1);

children[emit->prelude_ptr_index] = (void *)prelude_ptr;

}

}

mp_emit_glue_assign_native(emit->scope->raw_code,

emit->do_viper_types ? MP_CODE_NATIVE_VIPER : MP_CODE_NATIVE_PY,

f, f_len,

children,

#if MICROPY_PERSISTENT_CODE_SAVE

emit->emit_common->ct_cur_child,

emit->prelude_offset,

#endif

emit->scope->scope_flags, 0, 0);

}

return true;

}

static void ensure_extra_stack(emit_t *emit, size_t delta) {

if (emit->stack_size + delta > emit->stack_info_alloc) {

size_t new_alloc = (emit->stack_size + delta + 8) & ~3;

emit->stack_info = m_renew(stack_info_t, emit->stack_info, emit->stack_info_alloc, new_alloc);

emit->stack_info_alloc = new_alloc;

}

}

static void adjust_stack(emit_t *emit, mp_int_t stack_size_delta) {

assert((mp_int_t)emit->stack_size + stack_size_delta >= 0);

assert((mp_int_t)emit->stack_size + stack_size_delta <= (mp_int_t)emit->stack_info_alloc);

emit->stack_size += stack_size_delta;

if (emit->pass > MP_PASS_SCOPE && emit->stack_size > emit->scope->stack_size) {

emit->scope->stack_size = emit->stack_size;

}

#if DEBUG_PRINT

DEBUG_printf(" adjust_stack; stack_size=%d+%d; stack now:", emit->stack_size - stack_size_delta, stack_size_delta);

for (int i = 0; i < emit->stack_size; i++) {

stack_info_t *si = &emit->stack_info[i];

DEBUG_printf(" (v=%d k=%d %d)", si->vtype, si->kind, si->data.u_reg);

}

DEBUG_printf("\n");

#endif

}

static void emit_native_adjust_stack_size(emit_t *emit, mp_int_t delta) {

DEBUG_printf("adjust_stack_size(" INT_FMT ")\n", delta);

if (delta > 0) {

ensure_extra_stack(emit, delta);

}

// If we are adjusting the stack in a positive direction (pushing) then we

// need to fill in values for the stack kind and vtype of the newly-pushed

// entries. These should be set to "value" (ie not reg or imm) because we

// should only need to adjust the stack due to a jump to this part in the

// code (and hence we have settled the stack before the jump).

for (mp_int_t i = 0; i < delta; i++) {

stack_info_t *si = &emit->stack_info[emit->stack_size + i];

si->kind = STACK_VALUE;

// TODO we don't know the vtype to use here. At the moment this is a

// hack to get the case of multi comparison working.

if (delta == 1) {

si->vtype = emit->saved_stack_vtype;

} else {

si->vtype = VTYPE_PYOBJ;

}

}

adjust_stack(emit, delta);

}

static void emit_native_set_source_line(emit_t *emit, mp_uint_t source_line) {

(void)emit;

(void)source_line;

}

static void emit_native_pre(emit_t *emit) {

(void)emit;

}

static stack_info_t *peek_stack(emit_t *emit, mp_uint_t depth) {

return &emit->stack_info[emit->stack_size - 1 - depth];

}

static vtype_kind_t peek_vtype(emit_t *emit, mp_uint_t depth) {

if (emit->do_viper_types) {

return peek_stack(emit, depth)->vtype;

} else {

// Type is always PYOBJ even if the intermediate stored value is not

return VTYPE_PYOBJ;

}

}

static void need_reg_single(emit_t *emit, int reg_needed, int skip_stack_pos) {

skip_stack_pos = emit->stack_size - skip_stack_pos;

for (int i = 0; i < emit->stack_size; i++) {

if (i != skip_stack_pos) {

stack_info_t *si = &emit->stack_info[i];

if (si->kind == STACK_REG && si->data.u_reg == reg_needed) {

si->kind = STACK_VALUE;

emit_native_mov_state_reg(emit, emit->stack_start + i, si->data.u_reg);

}

}

}

}

static void need_reg_all(emit_t *emit) {

for (int i = 0; i < emit->stack_size; i++) {

stack_info_t *si = &emit->stack_info[i];

if (si->kind == STACK_REG) {

DEBUG_printf(" reg(%u) to local(%u)\n", si->data.u_reg, emit->stack_start + i);

si->kind = STACK_VALUE;

emit_native_mov_state_reg(emit, emit->stack_start + i, si->data.u_reg);

}

}

}

static vtype_kind_t load_reg_stack_imm(emit_t *emit, int reg_dest, const stack_info_t *si, bool convert_to_pyobj) {

if (!convert_to_pyobj && emit->do_viper_types) {

ASM_MOV_REG_IMM(emit->as, reg_dest, si->data.u_imm);

return si->vtype;

} else {

if (si->vtype == VTYPE_PYOBJ) {

ASM_MOV_REG_IMM(emit->as, reg_dest, si->data.u_imm);

} else if (si->vtype == VTYPE_BOOL) {

emit_native_mov_reg_const(emit, reg_dest, MP_F_CONST_FALSE_OBJ + si->data.u_imm);

} else if (si->vtype == VTYPE_INT || si->vtype == VTYPE_UINT) {

ASM_MOV_REG_IMM(emit->as, reg_dest, (uintptr_t)MP_OBJ_NEW_SMALL_INT(si->data.u_imm));

} else if (si->vtype == VTYPE_PTR_NONE) {

emit_native_mov_reg_const(emit, reg_dest, MP_F_CONST_NONE_OBJ);

} else {

mp_raise_NotImplementedError(MP_ERROR_TEXT("conversion to object"));

}

return VTYPE_PYOBJ;

}

}

static void need_stack_settled(emit_t *emit) {

DEBUG_printf(" need_stack_settled; stack_size=%d\n", emit->stack_size);

need_reg_all(emit);

for (int i = 0; i < emit->stack_size; i++) {

stack_info_t *si = &emit->stack_info[i];

if (si->kind == STACK_IMM) {

DEBUG_printf(" imm(" INT_FMT ") to local(%u)\n", si->data.u_imm, emit->stack_start + i);

si->kind = STACK_VALUE;

// using REG_TEMP1 to avoid clobbering REG_TEMP0 (aka REG_RET)

si->vtype = load_reg_stack_imm(emit, REG_TEMP1, si, false);

emit_native_mov_state_reg(emit, emit->stack_start + i, REG_TEMP1);

}

}

}

static void emit_access_stack(emit_t *emit, int pos, vtype_kind_t *vtype, int reg_dest) {

need_reg_single(emit, reg_dest, pos);

stack_info_t *si = &emit->stack_info[emit->stack_size - pos];

*vtype = si->vtype;

switch (si->kind) {

case STACK_VALUE:

emit_native_mov_reg_state(emit, reg_dest, emit->stack_start + emit->stack_size - pos);

break;

case STACK_REG:

if (si->data.u_reg != reg_dest) {

ASM_MOV_REG_REG(emit->as, reg_dest, si->data.u_reg);

}

break;

case STACK_IMM:

*vtype = load_reg_stack_imm(emit, reg_dest, si, false);

break;

}

}

static void emit_fold_stack_top(emit_t *emit, int reg_dest) {

stack_info_t *si = &emit->stack_info[emit->stack_size - 2];

si[0] = si[1];

if (si->kind == STACK_VALUE) {

// if folded element was on the stack we need to put it in a register

emit_native_mov_reg_state(emit, reg_dest, emit->stack_start + emit->stack_size - 1);

si->kind = STACK_REG;

si->data.u_reg = reg_dest;

}

adjust_stack(emit, -1);

}

static void emit_pre_pop_reg_flexible(emit_t *emit, vtype_kind_t *vtype, int *reg_dest, int not_r1, int not_r2) {

stack_info_t *si = peek_stack(emit, 0);

if (si->kind == STACK_REG && si->data.u_reg != not_r1 && si->data.u_reg != not_r2) {

*vtype = si->vtype;

*reg_dest = si->data.u_reg;

need_reg_single(emit, *reg_dest, 1);

} else {

emit_access_stack(emit, 1, vtype, *reg_dest);

}

adjust_stack(emit, -1);

}

static void emit_pre_pop_discard(emit_t *emit) {

adjust_stack(emit, -1);

}

static void emit_pre_pop_reg(emit_t *emit, vtype_kind_t *vtype, int reg_dest) {

emit_access_stack(emit, 1, vtype, reg_dest);

adjust_stack(emit, -1);

}

static void emit_pre_pop_reg_reg(emit_t *emit, vtype_kind_t *vtypea, int rega, vtype_kind_t *vtypeb, int regb) {

emit_pre_pop_reg(emit, vtypea, rega);

emit_pre_pop_reg(emit, vtypeb, regb);

}

static void emit_pre_pop_reg_reg_reg(emit_t *emit, vtype_kind_t *vtypea, int rega, vtype_kind_t *vtypeb, int regb, vtype_kind_t *vtypec, int regc) {

emit_pre_pop_reg(emit, vtypea, rega);

emit_pre_pop_reg(emit, vtypeb, regb);

emit_pre_pop_reg(emit, vtypec, regc);

}

static void emit_post(emit_t *emit) {

(void)emit;

}

static void emit_post_top_set_vtype(emit_t *emit, vtype_kind_t new_vtype) {

stack_info_t *si = &emit->stack_info[emit->stack_size - 1];

si->vtype = new_vtype;

}

static void emit_post_push_reg(emit_t *emit, vtype_kind_t vtype, int reg) {

ensure_extra_stack(emit, 1);

stack_info_t *si = &emit->stack_info[emit->stack_size];

si->vtype = vtype;

si->kind = STACK_REG;

si->data.u_reg = reg;

adjust_stack(emit, 1);

}

static void emit_post_push_imm(emit_t *emit, vtype_kind_t vtype, mp_int_t imm) {

ensure_extra_stack(emit, 1);

stack_info_t *si = &emit->stack_info[emit->stack_size];

si->vtype = vtype;

si->kind = STACK_IMM;

si->data.u_imm = imm;

adjust_stack(emit, 1);

}

static void emit_post_push_reg_reg(emit_t *emit, vtype_kind_t vtypea, int rega, vtype_kind_t vtypeb, int regb) {

emit_post_push_reg(emit, vtypea, rega);

emit_post_push_reg(emit, vtypeb, regb);

}

static void emit_post_push_reg_reg_reg(emit_t *emit, vtype_kind_t vtypea, int rega, vtype_kind_t vtypeb, int regb, vtype_kind_t vtypec, int regc) {

emit_post_push_reg(emit, vtypea, rega);