#include <stdio.h>

#include <string.h>

#include <assert.h>

#include "py/emit.h"

#include "py/nativeglue.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_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_t) / sizeof(uintptr_t))

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

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

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

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

#define OFFSETOF_OBJ_FUN_BC_GLOBALS (offsetof(mp_obj_fun_bc_t, globals) / sizeof(uintptr_t))

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

#define OFFSETOF_OBJ_FUN_BC_CONST_TABLE (offsetof(mp_obj_fun_bc_t, const_table) / 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 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) (NLR_BUF_IDX_LOCAL_2)

#define LOCAL_IDX_RET_VAL(emit) (NLR_BUF_IDX_LOCAL_3)

#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))

#define REG_GENERATOR_STATE (REG_LOCAL_3)

#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 const uint8_t reg_local_table[REG_LOCAL_NUM] = {REG_LOCAL_1, REG_LOCAL_2, REG_LOCAL_3};

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_obj_t * error_slot, uint *label_slot, mp_uint_t max_num_labels) {

emit_t *emit = m_new0(emit_t, 1);

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

size_t loc = ASM_MOV_REG_IMM_FIX_U16(emit->as, arg_reg, qst);

size_t link_idx = emit->qstr_link_cur++;

if (emit->pass == MP_PASS_EMIT) {

emit->qstr_link[link_idx].off = loc << 2 | 1;

emit->qstr_link[link_idx].qst = 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

size_t loc = ASM_MOV_REG_IMM_FIX_WORD(emit->as, reg_dest, (mp_uint_t)MP_OBJ_NEW_QSTR(qst));

size_t link_idx = emit->qstr_link_cur++;

if (emit->pass == MP_PASS_EMIT) {

emit->qstr_link[link_idx].off = loc << 2 | 2;

emit->qstr_link[link_idx].qst = 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)

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

do { \

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

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

} while (false)

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

do { \

ASM_MOV_REG_IMM_FIX_WORD((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;

#if N_PRELUDE_AS_BYTES_OBJ

emit->const_table_cur_obj = emit->do_viper_types ? 0 : 1; // reserve first obj for prelude bytes obj

#else

emit->const_table_cur_obj = 0;

#endif

emit->const_table_cur_raw_code = 0;

#if MICROPY_PERSISTENT_CODE_SAVE

emit->qstr_link_cur = 0;

#endif

emit->last_emit_was_return_value = false;

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] = VTYPE_UNBOUND;

}

// 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_t or reduced version for viper)

emit->code_state_start = 0;

if (NEED_GLOBAL_EXC_HANDLER(emit)) {

emit->code_state_start = SIZEOF_NLR_BUF;

}

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 > REG_LOCAL_NUM) {

num_locals_in_regs = REG_LOCAL_NUM;

}

// Need a spot for REG_LOCAL_3 if 4 or more args (see below)

if (scope->num_pos_args >= 4) {

--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_LOCAL_3, REG_PARENT_ARG_1, OFFSETOF_OBJ_FUN_BC_CONST_TABLE);

ASM_LOAD_REG_REG_OFFSET(emit->as, REG_FUN_TABLE, REG_LOCAL_3, 0);

// 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_3

#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_3);

#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_3, 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_3, 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_3 points to the args array so be sure not to overwrite it if it's still needed

if (i < REG_LOCAL_NUM && CAN_USE_REGS_FOR_LOCALS(emit) && (i != 2 || emit->scope->num_pos_args == 3)) {

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 3rd local from the stack back into REG_LOCAL_3 if this reg couldn't be written to above

if (emit->scope->num_pos_args >= 4 && CAN_USE_REGS_FOR_LOCALS(emit)) {

ASM_MOV_REG_LOCAL(emit->as, REG_LOCAL_3, LOCAL_IDX_LOCAL_VAR(emit, 2));

}

emit_native_global_exc_entry(emit);

} else {

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

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

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

emit->code_state_start = 0;

emit->stack_start = SIZEOF_CODE_STATE;

#if N_PRELUDE_AS_BYTES_OBJ

// Load index of prelude bytes object in const_table

mp_asm_base_data(&emit->as->base, ASM_WORD_SIZE, (uintptr_t)(emit->scope->num_pos_args + emit->scope->num_kwonly_args + 1));

#else

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

#endif

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

ASM_ENTRY(emit->as, SIZEOF_NLR_BUF);

// 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_CONST_TABLE);

ASM_LOAD_REG_REG_OFFSET(emit->as, REG_FUN_TABLE, REG_TEMP0, emit->scope->num_pos_args + emit->scope->num_kwonly_args);

} 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_LOCAL_3, REG_PARENT_ARG_1, OFFSETOF_OBJ_FUN_BC_CONST_TABLE);

ASM_LOAD_REG_REG_OFFSET(emit->as, REG_FUN_TABLE, REG_LOCAL_3, emit->scope->num_pos_args + emit->scope->num_kwonly_args);

// Set code_state.fun_bc

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

// Set code_state.ip (offset from start of this function to prelude info)

int code_state_ip_local = emit->code_state_start + OFFSETOF_CODE_STATE_IP;

#if N_PRELUDE_AS_BYTES_OBJ

// Prelude is a bytes object in const_table; store ip = prelude->data - fun_bc->bytecode

ASM_LOAD_REG_REG_OFFSET(emit->as, REG_LOCAL_3, REG_LOCAL_3, emit->scope->num_pos_args + emit->scope->num_kwonly_args + 1);

ASM_LOAD_REG_REG_OFFSET(emit->as, REG_LOCAL_3, REG_LOCAL_3, offsetof(mp_obj_str_t, data) / sizeof(uintptr_t));

ASM_LOAD_REG_REG_OFFSET(emit->as, REG_PARENT_ARG_1, REG_PARENT_ARG_1, OFFSETOF_OBJ_FUN_BC_BYTECODE);

ASM_SUB_REG_REG(emit->as, REG_LOCAL_3, REG_PARENT_ARG_1);

emit_native_mov_state_reg(emit, code_state_ip_local, REG_LOCAL_3);

#else

if (emit->pass == MP_PASS_CODE_SIZE) {

// Commit to the encoding size based on the value of prelude_offset in this pass.

// By using 32768 as the cut-off it is highly unlikely that prelude_offset will

// grow beyond 65535 by the end of thiss pass, and so require the larger encoding.

emit->prelude_offset_uses_u16_encoding = emit->prelude_offset < 32768;

}

if (emit->prelude_offset_uses_u16_encoding) {

assert(emit->prelude_offset <= 65535);

emit_native_mov_state_imm_fix_u16_via(emit, code_state_ip_local, emit->prelude_offset, REG_PARENT_ARG_1);

} else {

emit_native_mov_state_imm_fix_word_via(emit, code_state_ip_local, emit->prelude_offset, REG_PARENT_ARG_1);

}

#endif

// 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(mp_code_state_t, n_state) / sizeof(uintptr_t), 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 < REG_LOCAL_NUM && 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;

}

}

if (pass == MP_PASS_EMIT) {

// write argument names as qstr objects

// see comment in corresponding part of emitbc.c about the logic here

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

qstr qst = MP_QSTR__star_;

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

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

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

qst = id->qst;

break;

}

}

emit->const_table[i] = (mp_uint_t)MP_OBJ_NEW_QSTR(qst);

}

}

}

}

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

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

}

STATIC void 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);

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);

#if MICROPY_PERSISTENT_CODE

size_t n_info = 4;

#else

size_t n_info = 1;

#endif

MP_BC_PRELUDE_SIZE_ENCODE(n_info, emit->n_cell, emit_native_write_code_info_byte, emit);

#if MICROPY_PERSISTENT_CODE

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

mp_asm_base_data(&emit->as->base, 1, emit->scope->simple_name >> 8);

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

mp_asm_base_data(&emit->as->base, 1, emit->scope->source_file >> 8);

#else

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

#endif

// 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;

#if N_PRELUDE_AS_BYTES_OBJ

// Prelude bytes object is after qstr arg names and mp_fun_table

size_t table_off = emit->scope->num_pos_args + emit->scope->num_kwonly_args + 1;

if (emit->pass == MP_PASS_EMIT) {

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

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

emit->const_table[table_off] = (uintptr_t)mp_obj_new_bytes(buf, n);

}

#endif

}

ASM_END_PASS(emit->as);

// check stack is back to zero size

assert(emit->stack_size == 0);

assert(emit->exc_stack_size == 0);

// Deal with const table accounting

assert(emit->pass <= MP_PASS_STACK_SIZE || (emit->const_table_num_obj == emit->const_table_cur_obj));

emit->const_table_num_obj = emit->const_table_cur_obj;

if (emit->pass == MP_PASS_CODE_SIZE) {

size_t const_table_alloc = 1 + emit->const_table_num_obj + emit->const_table_cur_raw_code;

size_t nqstr = 0;

if (!emit->do_viper_types) {

// Add room for qstr names of arguments

nqstr = emit->scope->num_pos_args + emit->scope->num_kwonly_args;

const_table_alloc += nqstr;

}

emit->const_table = m_new(mp_uint_t, const_table_alloc);

#if !MICROPY_DYNAMIC_COMPILER

// Store mp_fun_table pointer just after qstrs

// (but in dynamic-compiler mode eliminate dependency on mp_fun_table)

emit->const_table[nqstr] = (mp_uint_t)(uintptr_t)&mp_fun_table;

#endif

#if MICROPY_PERSISTENT_CODE_SAVE

size_t qstr_link_alloc = emit->qstr_link_cur;

if (qstr_link_alloc > 0) {

emit->qstr_link = m_new(mp_qstr_link_entry_t, qstr_link_alloc);

}

#endif

}

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_emit_glue_assign_native(emit->scope->raw_code,

emit->do_viper_types ? MP_CODE_NATIVE_VIPER : MP_CODE_NATIVE_PY,

f, f_len, emit->const_table,

#if MICROPY_PERSISTENT_CODE_SAVE

emit->prelude_offset,

emit->const_table_cur_obj, emit->const_table_cur_raw_code,

emit->qstr_link_cur, emit->qstr_link,

#endif

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

}

}

STATIC bool emit_native_last_emit_was_return_value(emit_t *emit) {

return emit->last_emit_was_return_value;

}

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;

}

#ifdef 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) {

emit->last_emit_was_return_value = false;

}

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) {

emit->last_emit_was_return_value = false;

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) {

emit->last_emit_was_return_value = false;

adjust_stack(emit, -1);

}

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

emit->last_emit_was_return_value = false;

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;

}