djsundog/circuitpython
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Incorporate emit_thumb into new emit framework.

Browse Source
This commit is contained in:
Damien 2013-10-05 18:41:24 +01:00
parent 6cdd3af601
commit 5bfb759980
5 changed files with 277 additions and 171 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
py/Makefile
View File

@ -1,5 +1,5 @@
CC = gcc CC = gcc
CFLAGS = -Wall -ansi -std=gnu99 -Os -DEMIT_ENABLE_CPY -DEMIT_ENABLE_X64 #-DNDEBUG CFLAGS = -Wall -ansi -std=gnu99 -Os -DEMIT_ENABLE_CPY -DEMIT_ENABLE_X64 -DEMIT_ENABLE_THUMB #-DNDEBUG
LDFLAGS = LDFLAGS =
SRC = \ SRC = \

102
py/asmthumb.c
View File

@ -28,7 +28,7 @@ struct _asm_thumb_t {
uint stack_adjust; uint stack_adjust;
}; };
asm_thumb_t *asm_thumb_new() { asm_thumb_t *asm_thumb_new(uint max_num_labels) {
asm_thumb_t *as; asm_thumb_t *as;
as = m_new(asm_thumb_t, 1); as = m_new(asm_thumb_t, 1);
@ -36,7 +36,8 @@ asm_thumb_t *asm_thumb_new() {
as->code_offset = 0; as->code_offset = 0;
as->code_size = 0; as->code_size = 0;
as->code_base = NULL; as->code_base = NULL;
as->label_offsets = NULL; as->max_num_labels = max_num_labels;
as->label_offsets = m_new(int, max_num_labels);
as->num_locals = 0; as->num_locals = 0;
return as; return as;
@ -65,23 +66,13 @@ void asm_thumb_start_pass(asm_thumb_t *as, int pass) {
as->pass = pass; as->pass = pass;
as->code_offset = 0; as->code_offset = 0;
as->next_label = 1; as->next_label = 1;
if (pass == ASM_THUMB_PASS_1) { if (pass == ASM_THUMB_PASS_2) {
as->max_num_labels = 0; memset(as->label_offsets, -1, as->max_num_labels * sizeof(int));
} else {
if (pass == ASM_THUMB_PASS_2) {
memset(as->label_offsets, -1, as->max_num_labels * sizeof(int));
}
} }
} }
void asm_thumb_end_pass(asm_thumb_t *as) { void asm_thumb_end_pass(asm_thumb_t *as) {
if (as->pass == ASM_THUMB_PASS_1) { if (as->pass == ASM_THUMB_PASS_2) {
// calculate number of labels need
if (as->next_label > as->max_num_labels) {
as->max_num_labels = as->next_label;
}
as->label_offsets = m_new(int, as->max_num_labels);
} else if (as->pass == ASM_THUMB_PASS_2) {
// calculate size of code in bytes // calculate size of code in bytes
as->code_size = as->code_offset; as->code_size = as->code_offset;
as->code_base = m_new(byte, as->code_size); as->code_base = m_new(byte, as->code_size);
@ -226,20 +217,23 @@ int asm_thumb_label_new(asm_thumb_t *as) {
} }
void asm_thumb_label_assign(asm_thumb_t *as, int label) { void asm_thumb_label_assign(asm_thumb_t *as, int label) {
if (as->pass > ASM_THUMB_PASS_1) { assert(label < as->max_num_labels);
assert(label < as->max_num_labels); if (as->pass == ASM_THUMB_PASS_2) {
if (as->pass == ASM_THUMB_PASS_2) { // assign label offset
// assign label offset assert(as->label_offsets[label] == -1);
assert(as->label_offsets[label] == -1); as->label_offsets[label] = as->code_offset;
as->label_offsets[label] = as->code_offset; } else if (as->pass == ASM_THUMB_PASS_3) {
} else if (as->pass == ASM_THUMB_PASS_3) { // ensure label offset has not changed from PASS_2 to PASS_3
// ensure label offset has not changed from PASS_2 to PASS_3 //printf("l%d: (at %d=%ld)\n", label, as->label_offsets[label], as->code_offset);
//printf("l%d: (at %d=%ld)\n", label, as->label_offsets[label], as->code_offset); assert(as->label_offsets[label] == as->code_offset);
assert(as->label_offsets[label] == as->code_offset);
}
} }
} }
static int get_label_dest(asm_thumb_t *as, int label) {
assert(label < as->max_num_labels);
return as->label_offsets[label];
}
// the i8 value will be zero extended into the r32 register! // the i8 value will be zero extended into the r32 register!
void asm_thumb_mov_reg_i8(asm_thumb_t *as, uint rlo_dest, int i8) { void asm_thumb_mov_reg_i8(asm_thumb_t *as, uint rlo_dest, int i8) {
assert(rlo_dest < REG_R8); assert(rlo_dest < REG_R8);
@ -339,23 +333,21 @@ void asm_thumb_ite_ge(asm_thumb_t *as) {
#define OP_BW_LO(byte_offset) (0xb800 | (((byte_offset) >> 1) & 0x07ff)) #define OP_BW_LO(byte_offset) (0xb800 | (((byte_offset) >> 1) & 0x07ff))
void asm_thumb_b_label(asm_thumb_t *as, int label) { void asm_thumb_b_label(asm_thumb_t *as, int label) {
if (as->pass > ASM_THUMB_PASS_1) { int dest = get_label_dest(as, label);
int dest = as->label_offsets[label]; int rel = dest - as->code_offset;
int rel = dest - as->code_offset; rel -= 4; // account for instruction prefetch, PC is 4 bytes ahead of this instruction
rel -= 4; // account for instruction prefetch, PC is 4 bytes ahead of this instruction if (dest >= 0 && rel <= -4) {
if (dest >= 0 && rel <= -4) { // is a backwards jump, so we know the size of the jump on the first pass
// is a backwards jump, so we know the size of the jump on the first pass // calculate rel assuming 12 bit relative jump
// calculate rel assuming 12 bit relative jump if (SIGNED_FIT12(rel)) {
if (SIGNED_FIT12(rel)) { asm_thumb_write_op16(as, OP_B(rel));
asm_thumb_write_op16(as, OP_B(rel));
} else {
goto large_jump;
}
} else { } else {
// is a forwards jump, so need to assume it's large goto large_jump;
large_jump:
asm_thumb_write_op32(as, OP_BW_HI(rel), OP_BW_LO(rel));
} }
} else {
// is a forwards jump, so need to assume it's large
large_jump:
asm_thumb_write_op32(as, OP_BW_HI(rel), OP_BW_LO(rel));
} }
} }
@ -372,23 +364,21 @@ void asm_thumb_cmp_reg_bz_label(asm_thumb_t *as, uint rlo, int label) {
asm_thumb_write_op16(as, OP_CMP_REG_IMM(rlo, 0)); asm_thumb_write_op16(as, OP_CMP_REG_IMM(rlo, 0));
// branch if equal // branch if equal
if (as->pass > ASM_THUMB_PASS_1) { int dest = get_label_dest(as, label);
int dest = as->label_offsets[label]; int rel = dest - as->code_offset;
int rel = dest - as->code_offset; rel -= 4; // account for instruction prefetch, PC is 4 bytes ahead of this instruction
rel -= 4; // account for instruction prefetch, PC is 4 bytes ahead of this instruction if (dest >= 0 && rel <= -4) {
if (dest >= 0 && rel <= -4) { // is a backwards jump, so we know the size of the jump on the first pass
// is a backwards jump, so we know the size of the jump on the first pass // calculate rel assuming 12 bit relative jump
// calculate rel assuming 12 bit relative jump if (SIGNED_FIT9(rel)) {
if (SIGNED_FIT9(rel)) { asm_thumb_write_op16(as, OP_BEQ(rel));
asm_thumb_write_op16(as, OP_BEQ(rel));
} else {
goto large_jump;
}
} else { } else {
// is a forwards jump, so need to assume it's large goto large_jump;
large_jump:
asm_thumb_write_op32(as, OP_BEQW_HI(rel), OP_BEQW_LO(rel));
} }
} else {
// is a forwards jump, so need to assume it's large
large_jump:
asm_thumb_write_op32(as, OP_BEQW_HI(rel), OP_BEQW_LO(rel));
} }
} }

2
py/asmthumb.h
View File

@ -28,7 +28,7 @@
typedef struct _asm_thumb_t asm_thumb_t; typedef struct _asm_thumb_t asm_thumb_t;
asm_thumb_t *asm_thumb_new(); asm_thumb_t *asm_thumb_new(uint max_num_labels);
void asm_thumb_free(asm_thumb_t *as, bool free_code); void asm_thumb_free(asm_thumb_t *as, bool free_code);
void asm_thumb_start_pass(asm_thumb_t *as, int pass); void asm_thumb_start_pass(asm_thumb_t *as, int pass);
void asm_thumb_end_pass(asm_thumb_t *as); void asm_thumb_end_pass(asm_thumb_t *as);

8
py/compile.c
View File

@ -30,6 +30,7 @@ typedef enum {
#define EMIT_OPT_NONE (0) #define EMIT_OPT_NONE (0)
#define EMIT_OPT_BYTE_CODE (1) #define EMIT_OPT_BYTE_CODE (1)
#define EMIT_OPT_NATIVE_PYTHON (2) #define EMIT_OPT_NATIVE_PYTHON (2)
#define EMIT_OPT_ASM_THUMB (3)
typedef struct _compiler_t { typedef struct _compiler_t {
qstr qstr___class__; qstr qstr___class__;
@ -41,6 +42,7 @@ typedef struct _compiler_t {
qstr qstr_assertion_error; qstr qstr_assertion_error;
qstr qstr_micropython; qstr qstr_micropython;
qstr qstr_native; qstr qstr_native;
qstr qstr_asm_thumb;
pass_kind_t pass; pass_kind_t pass;
@ -759,6 +761,8 @@ static bool compile_built_in_decorator(compiler_t *comp, int name_len, py_parse_
qstr attr = PY_PARSE_NODE_LEAF_ARG(name_nodes[1]); qstr attr = PY_PARSE_NODE_LEAF_ARG(name_nodes[1]);
if (attr == comp->qstr_native) { if (attr == comp->qstr_native) {
*emit_options = EMIT_OPT_NATIVE_PYTHON; *emit_options = EMIT_OPT_NATIVE_PYTHON;
} else if (attr == comp->qstr_asm_thumb) {
*emit_options = EMIT_OPT_ASM_THUMB;
} else { } else {
printf("SyntaxError: invalid micropython decorator\n"); printf("SyntaxError: invalid micropython decorator\n");
} }
@ -2551,6 +2555,7 @@ void py_compile(py_parse_node_t pn) {
comp->qstr_assertion_error = qstr_from_str_static("AssertionError"); comp->qstr_assertion_error = qstr_from_str_static("AssertionError");
comp->qstr_micropython = qstr_from_str_static("micropython"); comp->qstr_micropython = qstr_from_str_static("micropython");
comp->qstr_native = qstr_from_str_static("native"); comp->qstr_native = qstr_from_str_static("native");
comp->qstr_asm_thumb = qstr_from_str_static("asm_thumb");
comp->max_num_labels = 0; comp->max_num_labels = 0;
comp->break_label = 0; comp->break_label = 0;
@ -2588,6 +2593,9 @@ void py_compile(py_parse_node_t pn) {
comp->emit_method_table = &emit_x64_method_table; comp->emit_method_table = &emit_x64_method_table;
break; break;
//case EMIT_OPT_ASM_THUMB:
//if (em
default: default:
if (emit_bc == NULL) { if (emit_bc == NULL) {
emit_bc = emit_bc_new(comp->max_num_labels); emit_bc = emit_bc_new(comp->max_num_labels);

334
py/emitthumb.c
View File

@ -14,7 +14,7 @@
#include "emit.h" #include "emit.h"
#include "asmthumb.h" #include "asmthumb.h"
#ifdef EMIT_DO_THUMB #ifdef EMIT_ENABLE_THUMB
#define REG_LOCAL_1 (REG_R4) #define REG_LOCAL_1 (REG_R4)
#define REG_LOCAL_2 (REG_R5) #define REG_LOCAL_2 (REG_R5)
@ -28,7 +28,7 @@ typedef enum {
NEED_TO_PUSH_I32, NEED_TO_PUSH_I32,
} need_to_push_t; } need_to_push_t;
struct _emitter_t { struct _emit_t {
int pass; int pass;
int stack_start; int stack_start;
int stack_size; int stack_size;
@ -43,14 +43,18 @@ struct _emitter_t {
bool do_native_types; bool do_native_types;
}; };
emitter_t *emit_new() { emit_t *emit_thumb_new(uint max_num_labels) {
emitter_t *emit = m_new(emitter_t, 1); emit_t *emit = m_new(emit_t, 1);
emit->as = asm_thumb_new(); emit->as = asm_thumb_new(max_num_labels);
emit->do_native_types = true; emit->do_native_types = false;
return emit; return emit;
} }
void emit_start_pass(emitter_t *emit, pass_kind_t pass, scope_t *scope) { static void emit_thumb_set_native_types(emit_t *emit, bool do_native_types) {
emit->do_native_types = do_native_types;
}
static void emit_thumb_start_pass(emit_t *emit, pass_kind_t pass, scope_t *scope) {
emit->pass = pass; emit->pass = pass;
emit->stack_start = 0; emit->stack_start = 0;
emit->stack_size = 0; emit->stack_size = 0;
@ -91,7 +95,7 @@ void emit_start_pass(emitter_t *emit, pass_kind_t pass, scope_t *scope) {
asm_thumb_mov_reg_i32(emit->as, REG_R7, (machine_uint_t)rt_fun_table); asm_thumb_mov_reg_i32(emit->as, REG_R7, (machine_uint_t)rt_fun_table);
} }
void emit_end_pass(emitter_t *emit) { static void emit_thumb_end_pass(emit_t *emit) {
if (!emit->last_emit_was_return_value) { if (!emit->last_emit_was_return_value) {
asm_thumb_exit(emit->as); asm_thumb_exit(emit->as);
} }
@ -108,19 +112,19 @@ void emit_end_pass(emitter_t *emit) {
} }
} }
bool emit_last_emit_was_return_value(emitter_t *emit) { static bool emit_thumb_last_emit_was_return_value(emit_t *emit) {
return emit->last_emit_was_return_value; return emit->last_emit_was_return_value;
} }
int emit_get_stack_size(emitter_t *emit) { static int emit_thumb_get_stack_size(emit_t *emit) {
return emit->stack_size; return emit->stack_size;
} }
void emit_set_stack_size(emitter_t *emit, int size) { static void emit_thumb_set_stack_size(emit_t *emit, int size) {
emit->stack_size = size; emit->stack_size = size;
} }
static void adjust_stack(emitter_t *emit, int stack_size_delta) { static void adjust_stack(emit_t *emit, int stack_size_delta) {
emit->stack_size += stack_size_delta; emit->stack_size += stack_size_delta;
assert(emit->stack_size >= 0); assert(emit->stack_size >= 0);
if (emit->pass > PASS_1 && emit->stack_size > emit->scope->stack_size) { if (emit->pass > PASS_1 && emit->stack_size > emit->scope->stack_size) {
@ -128,7 +132,7 @@ static void adjust_stack(emitter_t *emit, int stack_size_delta) {
} }
} }
static void stack_settle(emitter_t *emit) { static void stack_settle(emit_t *emit) {
switch (emit->need_to_push) { switch (emit->need_to_push) {
case NEED_TO_PUSH_NOTHING: case NEED_TO_PUSH_NOTHING:
break; break;
@ -147,17 +151,17 @@ static void stack_settle(emitter_t *emit) {
emit->need_to_push = NEED_TO_PUSH_NOTHING; emit->need_to_push = NEED_TO_PUSH_NOTHING;
} }
static void emit_pre_raw(emitter_t *emit, int stack_size_delta) { static void emit_pre_raw(emit_t *emit, int stack_size_delta) {
adjust_stack(emit, stack_size_delta); adjust_stack(emit, stack_size_delta);
emit->last_emit_was_return_value = false; emit->last_emit_was_return_value = false;
} }
static void emit_pre(emitter_t *emit) { static void emit_pre(emit_t *emit) {
stack_settle(emit); stack_settle(emit);
emit_pre_raw(emit, 0); emit_pre_raw(emit, 0);
} }
static void emit_pre_pop_reg(emitter_t *emit, int reg_dest) { static void emit_pre_pop_reg(emit_t *emit, int reg_dest) {
switch (emit->need_to_push) { switch (emit->need_to_push) {
case NEED_TO_PUSH_NOTHING: case NEED_TO_PUSH_NOTHING:
asm_thumb_mov_reg_local(emit->as, reg_dest, emit->stack_start + emit->stack_size - 1); asm_thumb_mov_reg_local(emit->as, reg_dest, emit->stack_start + emit->stack_size - 1);
@ -179,47 +183,47 @@ static void emit_pre_pop_reg(emitter_t *emit, int reg_dest) {
emit->need_to_push = NEED_TO_PUSH_NOTHING; emit->need_to_push = NEED_TO_PUSH_NOTHING;
} }
static void emit_pre_pop_reg_reg(emitter_t *emit, int rega, int regb) { static void emit_pre_pop_reg_reg(emit_t *emit, int rega, int regb) {
emit_pre_pop_reg(emit, rega); emit_pre_pop_reg(emit, rega);
asm_thumb_mov_reg_local(emit->as, regb, emit->stack_start + emit->stack_size - 1); asm_thumb_mov_reg_local(emit->as, regb, emit->stack_start + emit->stack_size - 1);
adjust_stack(emit, -1); adjust_stack(emit, -1);
} }
static void emit_pre_pop_reg_reg_reg(emitter_t *emit, int rega, int regb, int regc) { static void emit_pre_pop_reg_reg_reg(emit_t *emit, int rega, int regb, int regc) {
emit_pre_pop_reg(emit, rega); emit_pre_pop_reg(emit, rega);
asm_thumb_mov_reg_local(emit->as, regb, emit->stack_start + emit->stack_size - 1); asm_thumb_mov_reg_local(emit->as, regb, emit->stack_start + emit->stack_size - 1);
asm_thumb_mov_reg_local(emit->as, regc, emit->stack_start + emit->stack_size - 2); asm_thumb_mov_reg_local(emit->as, regc, emit->stack_start + emit->stack_size - 2);
adjust_stack(emit, -2); adjust_stack(emit, -2);
} }
static void emit_post(emitter_t *emit) { static void emit_post(emit_t *emit) {
} }
static void emit_post_push_reg(emitter_t *emit, int reg) { static void emit_post_push_reg(emit_t *emit, int reg) {
emit->need_to_push = NEED_TO_PUSH_REG; emit->need_to_push = NEED_TO_PUSH_REG;
emit->last_reg = reg; emit->last_reg = reg;
} }
static void emit_post_push_i32(emitter_t *emit, int32_t i32) { static void emit_post_push_i32(emit_t *emit, int32_t i32) {
emit->need_to_push = NEED_TO_PUSH_I32; emit->need_to_push = NEED_TO_PUSH_I32;
emit->last_i32 = i32; emit->last_i32 = i32;
} }
static void emit_post_push_reg_reg(emitter_t *emit, int rega, int regb) { static void emit_post_push_reg_reg(emit_t *emit, int rega, int regb) {
asm_thumb_mov_local_reg(emit->as, emit->stack_start + emit->stack_size, rega); asm_thumb_mov_local_reg(emit->as, emit->stack_start + emit->stack_size, rega);
emit->need_to_push = NEED_TO_PUSH_REG; emit->need_to_push = NEED_TO_PUSH_REG;
emit->last_reg = regb; emit->last_reg = regb;
adjust_stack(emit, 1); adjust_stack(emit, 1);
} }
static void emit_post_push_reg_reg_reg(emitter_t *emit, int rega, int regb, int regc) { static void emit_post_push_reg_reg_reg(emit_t *emit, int rega, int regb, int regc) {
asm_thumb_mov_local_reg(emit->as, emit->stack_start + emit->stack_size, rega); asm_thumb_mov_local_reg(emit->as, emit->stack_start + emit->stack_size, rega);
asm_thumb_mov_local_reg(emit->as, emit->stack_start + emit->stack_size + 1, regb); asm_thumb_mov_local_reg(emit->as, emit->stack_start + emit->stack_size + 1, regb);
asm_thumb_mov_local_reg(emit->as, emit->stack_start + emit->stack_size + 2, regc); asm_thumb_mov_local_reg(emit->as, emit->stack_start + emit->stack_size + 2, regc);
adjust_stack(emit, 3); adjust_stack(emit, 3);
} }
static void emit_post_push_reg_reg_reg_reg(emitter_t *emit, int rega, int regb, int regc, int regd) { static void emit_post_push_reg_reg_reg_reg(emit_t *emit, int rega, int regb, int regc, int regd) {
asm_thumb_mov_local_reg(emit->as, emit->stack_start + emit->stack_size, rega); asm_thumb_mov_local_reg(emit->as, emit->stack_start + emit->stack_size, rega);
asm_thumb_mov_local_reg(emit->as, emit->stack_start + emit->stack_size + 1, regb); asm_thumb_mov_local_reg(emit->as, emit->stack_start + emit->stack_size + 1, regb);
asm_thumb_mov_local_reg(emit->as, emit->stack_start + emit->stack_size + 2, regc); asm_thumb_mov_local_reg(emit->as, emit->stack_start + emit->stack_size + 2, regc);
@ -227,44 +231,52 @@ static void emit_post_push_reg_reg_reg_reg(emitter_t *emit, int rega, int regb,
adjust_stack(emit, 4); adjust_stack(emit, 4);
} }
static void emit_get_stack_pointer_to_reg_for_pop(emitter_t *emit, int reg_dest, int n_pop) { static void emit_get_stack_pointer_to_reg_for_pop(emit_t *emit, int reg_dest, int n_pop) {
asm_thumb_mov_reg_local_addr(emit->as, reg_dest, emit->stack_start + emit->stack_size - 1); asm_thumb_mov_reg_local_addr(emit->as, reg_dest, emit->stack_start + emit->stack_size - 1);
adjust_stack(emit, -n_pop); adjust_stack(emit, -n_pop);
} }
static void emit_get_stack_pointer_to_reg_for_push(emitter_t *emit, int reg_dest, int n_push) { static void emit_get_stack_pointer_to_reg_for_push(emit_t *emit, int reg_dest, int n_push) {
asm_thumb_mov_reg_local_addr(emit->as, reg_dest, emit->stack_start + emit->stack_size + n_push - 1); asm_thumb_mov_reg_local_addr(emit->as, reg_dest, emit->stack_start + emit->stack_size + n_push - 1);
adjust_stack(emit, n_push); adjust_stack(emit, n_push);
} }
static void emit_call(emitter_t *emit, rt_fun_kind_t fun_kind) { static void emit_call(emit_t *emit, rt_fun_kind_t fun_kind) {
asm_thumb_bl_ind(emit->as, rt_fun_table[fun_kind], fun_kind, REG_R3); asm_thumb_bl_ind(emit->as, rt_fun_table[fun_kind], fun_kind, REG_R3);
} }
static void emit_call_with_i32_arg(emitter_t *emit, rt_fun_kind_t fun_kind, int32_t arg_val, int arg_reg) { static void emit_call_with_i32_arg(emit_t *emit, rt_fun_kind_t fun_kind, int32_t arg_val, int arg_reg) {
asm_thumb_mov_reg_i32_optimised(emit->as, arg_reg, arg_val); asm_thumb_mov_reg_i32_optimised(emit->as, arg_reg, arg_val);
asm_thumb_bl_ind(emit->as, rt_fun_table[fun_kind], fun_kind, REG_R3); asm_thumb_bl_ind(emit->as, rt_fun_table[fun_kind], fun_kind, REG_R3);
} }
int emit_label_new(emitter_t *emit) { static void emit_thumb_load_id(emit_t *emit, qstr qstr) {
return asm_thumb_label_new(emit->as); emit_common_load_id(emit, &emit_thumb_method_table, emit->scope, qstr);
} }
void emit_label_assign(emitter_t *emit, int l) { static void emit_thumb_store_id(emit_t *emit, qstr qstr) {
emit_common_store_id(emit, &emit_thumb_method_table, emit->scope, qstr);
}
static void emit_thumb_delete_id(emit_t *emit, qstr qstr) {
emit_common_delete_id(emit, &emit_thumb_method_table, emit->scope, qstr);
}
static void emit_thumb_label_assign(emit_t *emit, int l) {
asm_thumb_label_assign(emit->as, l); asm_thumb_label_assign(emit->as, l);
} }
void emit_import_name(emitter_t *emit, qstr qstr) { static void emit_thumb_import_name(emit_t *emit, qstr qstr) {
assert(0); assert(0);
} }
void emit_import_from(emitter_t *emit, qstr qstr) { static void emit_thumb_import_from(emit_t *emit, qstr qstr) {
assert(0); assert(0);
} }
void emit_import_star(emitter_t *emit) { static void emit_thumb_import_star(emit_t *emit) {
assert(0); assert(0);
} }
void emit_load_const_tok(emitter_t *emit, py_token_kind_t tok) { static void emit_thumb_load_const_tok(emit_t *emit, py_token_kind_t tok) {
emit_pre(emit); emit_pre(emit);
py_obj_t o; py_obj_t o;
switch (tok) { switch (tok) {
@ -276,7 +288,7 @@ void emit_load_const_tok(emitter_t *emit, py_token_kind_t tok) {
emit_post_push_i32(emit, (machine_uint_t)o); emit_post_push_i32(emit, (machine_uint_t)o);
} }
void emit_load_const_small_int(emitter_t *emit, int arg) { static void emit_thumb_load_const_small_int(emit_t *emit, int arg) {
emit_pre(emit); emit_pre(emit);
if (emit->do_native_types) { if (emit->do_native_types) {
emit_post_push_i32(emit, arg); emit_post_push_i32(emit, arg);
@ -285,42 +297,42 @@ void emit_load_const_small_int(emitter_t *emit, int arg) {
} }
} }
void emit_load_const_int(emitter_t *emit, qstr qstr) { static void emit_thumb_load_const_int(emit_t *emit, qstr qstr) {
assert(0); assert(0);
} }
void emit_load_const_dec(emitter_t *emit, qstr qstr) { static void emit_thumb_load_const_dec(emit_t *emit, qstr qstr) {
assert(0); assert(0);
} }
void emit_load_const_id(emitter_t *emit, qstr qstr) { static void emit_thumb_load_const_id(emit_t *emit, qstr qstr) {
assert(0); assert(0);
} }
void emit_load_const_str(emitter_t *emit, qstr qstr, bool bytes) { static void emit_thumb_load_const_str(emit_t *emit, qstr qstr, bool bytes) {
emit_pre(emit); emit_pre(emit);
emit_call_with_i32_arg(emit, RT_F_LOAD_CONST_STR, qstr, REG_ARG_1); emit_call_with_i32_arg(emit, RT_F_LOAD_CONST_STR, qstr, REG_ARG_1);
emit_post_push_reg(emit, REG_RET); emit_post_push_reg(emit, REG_RET);
} }
void emit_load_const_verbatim_start(emitter_t *emit) { static void emit_thumb_load_const_verbatim_start(emit_t *emit) {
assert(0); assert(0);
} }
void emit_load_const_verbatim_int(emitter_t *emit, int val) { static void emit_thumb_load_const_verbatim_int(emit_t *emit, int val) {
assert(0); assert(0);
} }
void emit_load_const_verbatim_str(emitter_t *emit, const char *str) { static void emit_thumb_load_const_verbatim_str(emit_t *emit, const char *str) {
assert(0); assert(0);
} }
void emit_load_const_verbatim_strn(emitter_t *emit, const char *str, int len) { static void emit_thumb_load_const_verbatim_strn(emit_t *emit, const char *str, int len) {
assert(0); assert(0);
} }
void emit_load_const_verbatim_quoted_str(emitter_t *emit, qstr qstr, bool bytes) { static void emit_thumb_load_const_verbatim_quoted_str(emit_t *emit, qstr qstr, bool bytes) {
assert(0); assert(0);
} }
void emit_load_const_verbatim_end(emitter_t *emit) { static void emit_thumb_load_const_verbatim_end(emit_t *emit) {
assert(0); assert(0);
} }
void emit_load_fast(emitter_t *emit, qstr qstr, int local_num) { static void emit_thumb_load_fast(emit_t *emit, qstr qstr, int local_num) {
emit_pre(emit); emit_pre(emit);
if (local_num == 0) { if (local_num == 0) {
emit_post_push_reg(emit, REG_LOCAL_1); emit_post_push_reg(emit, REG_LOCAL_1);
@ -334,42 +346,42 @@ void emit_load_fast(emitter_t *emit, qstr qstr, int local_num) {
} }
} }
void emit_load_name(emitter_t *emit, qstr qstr) { static void emit_thumb_load_name(emit_t *emit, qstr qstr) {
emit_pre(emit); emit_pre(emit);
emit_call_with_i32_arg(emit, RT_F_LOAD_NAME, qstr, REG_ARG_1); emit_call_with_i32_arg(emit, RT_F_LOAD_NAME, qstr, REG_ARG_1);
emit_post_push_reg(emit, REG_RET); emit_post_push_reg(emit, REG_RET);
} }
void emit_load_global(emitter_t *emit, qstr qstr) { static void emit_thumb_load_global(emit_t *emit, qstr qstr) {
emit_pre(emit); emit_pre(emit);
emit_call_with_i32_arg(emit, RT_F_LOAD_GLOBAL, qstr, REG_ARG_1); emit_call_with_i32_arg(emit, RT_F_LOAD_GLOBAL, qstr, REG_ARG_1);
emit_post_push_reg(emit, REG_RET); emit_post_push_reg(emit, REG_RET);
} }
void emit_load_deref(emitter_t *emit, qstr qstr) { static void emit_thumb_load_deref(emit_t *emit, qstr qstr) {
assert(0); assert(0);
} }
void emit_load_closure(emitter_t *emit, qstr qstr) { static void emit_thumb_load_closure(emit_t *emit, qstr qstr) {
assert(0); assert(0);
} }
void emit_load_attr(emitter_t *emit, qstr qstr) { static void emit_thumb_load_attr(emit_t *emit, qstr qstr) {
emit_pre_pop_reg(emit, REG_ARG_1); // arg1 = base emit_pre_pop_reg(emit, REG_ARG_1); // arg1 = base
emit_call_with_i32_arg(emit, RT_F_LOAD_ATTR, qstr, REG_ARG_2); // arg2 = attribute name emit_call_with_i32_arg(emit, RT_F_LOAD_ATTR, qstr, REG_ARG_2); // arg2 = attribute name
emit_post_push_reg(emit, REG_RET); emit_post_push_reg(emit, REG_RET);
} }
void emit_load_method(emitter_t *emit, qstr qstr) { static void emit_thumb_load_method(emit_t *emit, qstr qstr) {
emit_pre_pop_reg(emit, REG_ARG_1); // arg1 = base emit_pre_pop_reg(emit, REG_ARG_1); // arg1 = base
emit_get_stack_pointer_to_reg_for_push(emit, REG_ARG_3, 2); // arg3 = dest ptr emit_get_stack_pointer_to_reg_for_push(emit, REG_ARG_3, 2); // arg3 = dest ptr
emit_call_with_i32_arg(emit, RT_F_LOAD_METHOD, qstr, REG_ARG_2); // arg2 = method name emit_call_with_i32_arg(emit, RT_F_LOAD_METHOD, qstr, REG_ARG_2); // arg2 = method name
} }
void emit_load_build_class(emitter_t *emit) { static void emit_thumb_load_build_class(emit_t *emit) {
assert(0); assert(0);
} // basically load __build_class__ from builtins } // basically load __build_class__ from builtins
void emit_store_fast(emitter_t *emit, qstr qstr, int local_num) { static void emit_thumb_store_fast(emit_t *emit, qstr qstr, int local_num) {
if (local_num == 0) { if (local_num == 0) {
emit_pre_pop_reg(emit, REG_LOCAL_1); emit_pre_pop_reg(emit, REG_LOCAL_1);
} else if (local_num == 1) { } else if (local_num == 1) {
@ -383,81 +395,81 @@ void emit_store_fast(emitter_t *emit, qstr qstr, int local_num) {
emit_post(emit); emit_post(emit);
} }
void emit_store_name(emitter_t *emit, qstr qstr) { static void emit_thumb_store_name(emit_t *emit, qstr qstr) {
emit_pre_pop_reg(emit, REG_ARG_2); emit_pre_pop_reg(emit, REG_ARG_2);
emit_call_with_i32_arg(emit, RT_F_STORE_NAME, qstr, REG_ARG_1); // arg1 = name emit_call_with_i32_arg(emit, RT_F_STORE_NAME, qstr, REG_ARG_1); // arg1 = name
emit_post(emit); emit_post(emit);
} }
void emit_store_global(emitter_t *emit, qstr qstr) { static void emit_thumb_store_global(emit_t *emit, qstr qstr) {
assert(0); assert(0);
} }
void emit_store_deref(emitter_t *emit, qstr qstr) { static void emit_thumb_store_deref(emit_t *emit, qstr qstr) {
assert(0); assert(0);
} }
void emit_store_attr(emitter_t *emit, qstr qstr) { static void emit_thumb_store_attr(emit_t *emit, qstr qstr) {
assert(0); assert(0);
} }
void emit_store_locals(emitter_t *emit) { static void emit_thumb_store_locals(emit_t *emit) {
assert(0); assert(0);
} }
void emit_store_subscr(emitter_t *emit) { static void emit_thumb_store_subscr(emit_t *emit) {
emit_pre_pop_reg_reg_reg(emit, REG_ARG_2, REG_ARG_1, REG_ARG_3); // index, base, value to store emit_pre_pop_reg_reg_reg(emit, REG_ARG_2, REG_ARG_1, REG_ARG_3); // index, base, value to store
emit_call(emit, RT_F_STORE_SUBSCR); emit_call(emit, RT_F_STORE_SUBSCR);
} }
void emit_delete_fast(emitter_t *emit, qstr qstr, int local_num) { static void emit_thumb_delete_fast(emit_t *emit, qstr qstr, int local_num) {
assert(0); assert(0);
} }
void emit_delete_name(emitter_t *emit, qstr qstr) { static void emit_thumb_delete_name(emit_t *emit, qstr qstr) {
assert(0); assert(0);
} }
void emit_delete_global(emitter_t *emit, qstr qstr) { static void emit_thumb_delete_global(emit_t *emit, qstr qstr) {
assert(0); assert(0);
} }
void emit_delete_deref(emitter_t *emit, qstr qstr) { static void emit_thumb_delete_deref(emit_t *emit, qstr qstr) {
assert(0); assert(0);
} }
void emit_delete_attr(emitter_t *emit, qstr qstr) { static void emit_thumb_delete_attr(emit_t *emit, qstr qstr) {
assert(0); assert(0);
} }
void emit_delete_subscr(emitter_t *emit) { static void emit_thumb_delete_subscr(emit_t *emit) {
assert(0); assert(0);
} }
void emit_dup_top(emitter_t *emit) { static void emit_thumb_dup_top(emit_t *emit) {
emit_pre_pop_reg(emit, REG_R0); emit_pre_pop_reg(emit, REG_R0);
emit_post_push_reg_reg(emit, REG_R0, REG_R0); emit_post_push_reg_reg(emit, REG_R0, REG_R0);
} }
void emit_dup_top_two(emitter_t *emit) { static void emit_thumb_dup_top_two(emit_t *emit) {
emit_pre_pop_reg_reg(emit, REG_R0, REG_R1); emit_pre_pop_reg_reg(emit, REG_R0, REG_R1);
emit_post_push_reg_reg_reg_reg(emit, REG_R1, REG_R0, REG_R1, REG_R0); emit_post_push_reg_reg_reg_reg(emit, REG_R1, REG_R0, REG_R1, REG_R0);
} }
void emit_pop_top(emitter_t *emit) { static void emit_thumb_pop_top(emit_t *emit) {
emit_pre_pop_reg(emit, REG_R0); emit_pre_pop_reg(emit, REG_R0);
emit_post(emit); emit_post(emit);
} }
void emit_rot_two(emitter_t *emit) { static void emit_thumb_rot_two(emit_t *emit) {
assert(0); assert(0);
} }
void emit_rot_three(emitter_t *emit) { static void emit_thumb_rot_three(emit_t *emit) {
emit_pre_pop_reg_reg_reg(emit, REG_R0, REG_R1, REG_R2); emit_pre_pop_reg_reg_reg(emit, REG_R0, REG_R1, REG_R2);
emit_post_push_reg_reg_reg(emit, REG_R0, REG_R2, REG_R1); emit_post_push_reg_reg_reg(emit, REG_R0, REG_R2, REG_R1);
} }
void emit_jump(emitter_t *emit, int label) { static void emit_thumb_jump(emit_t *emit, int label) {
emit_pre(emit); emit_pre(emit);
asm_thumb_b_label(emit->as, label); asm_thumb_b_label(emit->as, label);
emit_post(emit); emit_post(emit);
} }
void emit_pop_jump_if_false(emitter_t *emit, int label) { static void emit_thumb_pop_jump_if_false(emit_t *emit, int label) {
if (emit->do_native_types) { if (emit->do_native_types) {
emit_pre_pop_reg(emit, REG_RET); emit_pre_pop_reg(emit, REG_RET);
asm_thumb_cmp_reg_bz_label(emit->as, REG_RET, label); asm_thumb_cmp_reg_bz_label(emit->as, REG_RET, label);
@ -470,124 +482,124 @@ void emit_pop_jump_if_false(emitter_t *emit, int label) {
} }
} }
void emit_pop_jump_if_true(emitter_t *emit, int label) { static void emit_thumb_pop_jump_if_true(emit_t *emit, int label) {
assert(0); assert(0);
} }
void emit_jump_if_true_or_pop(emitter_t *emit, int label) { static void emit_thumb_jump_if_true_or_pop(emit_t *emit, int label) {
assert(0); assert(0);
} }
void emit_jump_if_false_or_pop(emitter_t *emit, int label) { static void emit_thumb_jump_if_false_or_pop(emit_t *emit, int label) {
assert(0); assert(0);
} }
void emit_setup_loop(emitter_t *emit, int label) { static void emit_thumb_setup_loop(emit_t *emit, int label) {
emit_pre(emit); emit_pre(emit);
emit_post(emit); emit_post(emit);
} }
void emit_break_loop(emitter_t *emit, int label) { static void emit_thumb_break_loop(emit_t *emit, int label) {
assert(0); assert(0);
} }
void emit_continue_loop(emitter_t *emit, int label) { static void emit_thumb_continue_loop(emit_t *emit, int label) {
assert(0); assert(0);
} }
void emit_setup_with(emitter_t *emit, int label) { static void emit_thumb_setup_with(emit_t *emit, int label) {
assert(0); assert(0);
} }
void emit_with_cleanup(emitter_t *emit) { static void emit_thumb_with_cleanup(emit_t *emit) {
assert(0); assert(0);
} }
void emit_setup_except(emitter_t *emit, int label) { static void emit_thumb_setup_except(emit_t *emit, int label) {
assert(0); assert(0);
} }
void emit_setup_finally(emitter_t *emit, int label) { static void emit_thumb_setup_finally(emit_t *emit, int label) {
assert(0); assert(0);
} }
void emit_end_finally(emitter_t *emit) { static void emit_thumb_end_finally(emit_t *emit) {
assert(0); assert(0);
} }
void emit_get_iter(emitter_t *emit) { static void emit_thumb_get_iter(emit_t *emit) {
assert(0); assert(0);
} // tos = getiter(tos) } // tos = getiter(tos)
void emit_for_iter(emitter_t *emit, int label) { static void emit_thumb_for_iter(emit_t *emit, int label) {
assert(0); assert(0);
} }
void emit_for_iter_end(emitter_t *emit) { static void emit_thumb_for_iter_end(emit_t *emit) {
assert(0); assert(0);
} }
void emit_pop_except(emitter_t *emit) { static void emit_thumb_pop_except(emit_t *emit) {
assert(0); assert(0);
} }
void emit_unary_op(emitter_t *emit, rt_unary_op_t op) { static void emit_thumb_unary_op(emit_t *emit, rt_unary_op_t op) {
emit_pre_pop_reg(emit, REG_ARG_2); emit_pre_pop_reg(emit, REG_ARG_2);
emit_call_with_i32_arg(emit, RT_F_UNARY_OP, op, REG_ARG_1); emit_call_with_i32_arg(emit, RT_F_UNARY_OP, op, REG_ARG_1);
emit_post_push_reg(emit, REG_RET); emit_post_push_reg(emit, REG_RET);
} }
void emit_build_tuple(emitter_t *emit, int n_args) { static void emit_thumb_build_tuple(emit_t *emit, int n_args) {
assert(0); assert(0);
} }
void emit_build_list(emitter_t *emit, int n_args) { static void emit_thumb_build_list(emit_t *emit, int n_args) {
emit_pre(emit); emit_pre(emit);
emit_get_stack_pointer_to_reg_for_pop(emit, REG_ARG_2, n_args); // pointer to items in reverse order emit_get_stack_pointer_to_reg_for_pop(emit, REG_ARG_2, n_args); // pointer to items in reverse order
emit_call_with_i32_arg(emit, RT_F_BUILD_LIST, n_args, REG_ARG_1); emit_call_with_i32_arg(emit, RT_F_BUILD_LIST, n_args, REG_ARG_1);
emit_post_push_reg(emit, REG_RET); // new list emit_post_push_reg(emit, REG_RET); // new list
} }
void emit_list_append(emitter_t *emit, int list_index) { static void emit_thumb_list_append(emit_t *emit, int list_index) {
assert(0); assert(0);
} }
void emit_build_map(emitter_t *emit, int n_args) { static void emit_thumb_build_map(emit_t *emit, int n_args) {
emit_pre(emit); emit_pre(emit);
emit_call_with_i32_arg(emit, RT_F_BUILD_MAP, n_args, REG_ARG_1); emit_call_with_i32_arg(emit, RT_F_BUILD_MAP, n_args, REG_ARG_1);
emit_post_push_reg(emit, REG_RET); // new map emit_post_push_reg(emit, REG_RET); // new map
} }
void emit_store_map(emitter_t *emit) { static void emit_thumb_store_map(emit_t *emit) {
emit_pre_pop_reg_reg_reg(emit, REG_ARG_2, REG_ARG_3, REG_ARG_1); // key, value, map emit_pre_pop_reg_reg_reg(emit, REG_ARG_2, REG_ARG_3, REG_ARG_1); // key, value, map
emit_call(emit, RT_F_STORE_MAP); emit_call(emit, RT_F_STORE_MAP);
emit_post_push_reg(emit, REG_RET); // map emit_post_push_reg(emit, REG_RET); // map
} }
void emit_map_add(emitter_t *emit, int map_index) { static void emit_thumb_map_add(emit_t *emit, int map_index) {
assert(0); assert(0);
} }
void emit_build_set(emitter_t *emit, int n_args) { static void emit_thumb_build_set(emit_t *emit, int n_args) {
emit_pre(emit); emit_pre(emit);
emit_get_stack_pointer_to_reg_for_pop(emit, REG_ARG_2, n_args); // pointer to items in reverse order emit_get_stack_pointer_to_reg_for_pop(emit, REG_ARG_2, n_args); // pointer to items in reverse order
emit_call_with_i32_arg(emit, RT_F_BUILD_SET, n_args, REG_ARG_1); emit_call_with_i32_arg(emit, RT_F_BUILD_SET, n_args, REG_ARG_1);
emit_post_push_reg(emit, REG_RET); // new set emit_post_push_reg(emit, REG_RET); // new set
} }
void emit_set_add(emitter_t *emit, int set_index) { static void emit_thumb_set_add(emit_t *emit, int set_index) {
assert(0); assert(0);
} }
void emit_build_slice(emitter_t *emit, int n_args) { static void emit_thumb_build_slice(emit_t *emit, int n_args) {
assert(0); assert(0);
} }
void emit_unpack_sequence(emitter_t *emit, int n_args) { static void emit_thumb_unpack_sequence(emit_t *emit, int n_args) {
assert(0); assert(0);
} }
void emit_unpack_ex(emitter_t *emit, int n_left, int n_right) { static void emit_thumb_unpack_ex(emit_t *emit, int n_left, int n_right) {
assert(0); assert(0);
} }
void emit_make_function(emitter_t *emit, scope_t *scope, int n_dict_params, int n_default_params) { static void emit_thumb_make_function(emit_t *emit, scope_t *scope, int n_dict_params, int n_default_params) {
assert(n_default_params == 0 && n_dict_params == 0); assert(n_default_params == 0 && n_dict_params == 0);
emit_pre(emit); emit_pre(emit);
emit_call_with_i32_arg(emit, RT_F_MAKE_FUNCTION_FROM_ID, scope->unique_code_id, REG_ARG_1); emit_call_with_i32_arg(emit, RT_F_MAKE_FUNCTION_FROM_ID, scope->unique_code_id, REG_ARG_1);
emit_post_push_reg(emit, REG_RET); emit_post_push_reg(emit, REG_RET);
} }
void emit_make_closure(emitter_t *emit, scope_t *scope, int n_dict_params, int n_default_params) { static void emit_thumb_make_closure(emit_t *emit, scope_t *scope, int n_dict_params, int n_default_params) {
assert(0); assert(0);
} }
void emit_call_function(emitter_t *emit, int n_positional, int n_keyword, bool have_star_arg, bool have_dbl_star_arg) { static void emit_thumb_call_function(emit_t *emit, int n_positional, int n_keyword, bool have_star_arg, bool have_dbl_star_arg) {
assert(n_keyword == 0 && !have_star_arg && !have_dbl_star_arg); assert(n_keyword == 0 && !have_star_arg && !have_dbl_star_arg);
if (n_positional == 0) { if (n_positional == 0) {
emit_pre_pop_reg(emit, REG_ARG_1); // the function emit_pre_pop_reg(emit, REG_ARG_1); // the function
@ -604,7 +616,7 @@ void emit_call_function(emitter_t *emit, int n_positional, int n_keyword, bool h
emit_post_push_reg(emit, REG_RET); emit_post_push_reg(emit, REG_RET);
} }
void emit_call_method(emitter_t *emit, int n_positional, int n_keyword, bool have_star_arg, bool have_dbl_star_arg) { static void emit_thumb_call_method(emit_t *emit, int n_positional, int n_keyword, bool have_star_arg, bool have_dbl_star_arg) {
assert(n_keyword == 0 && !have_star_arg && !have_dbl_star_arg); assert(n_keyword == 0 && !have_star_arg && !have_dbl_star_arg);
if (n_positional == 0) { if (n_positional == 0) {
emit_pre_pop_reg_reg(emit, REG_ARG_2, REG_ARG_1); // the self object (or NULL), the method emit_pre_pop_reg_reg(emit, REG_ARG_2, REG_ARG_1); // the self object (or NULL), the method
@ -618,12 +630,12 @@ void emit_call_method(emitter_t *emit, int n_positional, int n_keyword, bool hav
emit_post_push_reg(emit, REG_RET); emit_post_push_reg(emit, REG_RET);
} }
void emit_pop_block(emitter_t *emit) { static void emit_thumb_pop_block(emit_t *emit) {
emit_pre(emit); emit_pre(emit);
emit_post(emit); emit_post(emit);
} }
void emit_binary_op(emitter_t *emit, rt_binary_op_t op) { static void emit_thumb_binary_op(emit_t *emit, rt_binary_op_t op) {
if (emit->do_native_types) { if (emit->do_native_types) {
emit_pre_pop_reg_reg(emit, REG_ARG_2, REG_ARG_1); emit_pre_pop_reg_reg(emit, REG_ARG_2, REG_ARG_1);
asm_thumb_add_reg_reg_reg(emit->as, REG_RET, REG_ARG_1, REG_ARG_2); asm_thumb_add_reg_reg_reg(emit->as, REG_RET, REG_ARG_1, REG_ARG_2);
@ -635,7 +647,7 @@ void emit_binary_op(emitter_t *emit, rt_binary_op_t op) {
} }
} }
void emit_compare_op(emitter_t *emit, rt_compare_op_t op) { static void emit_thumb_compare_op(emit_t *emit, rt_compare_op_t op) {
if (emit->do_native_types) { if (emit->do_native_types) {
emit_pre_pop_reg_reg(emit, REG_ARG_2, REG_ARG_1); emit_pre_pop_reg_reg(emit, REG_ARG_2, REG_ARG_1);
asm_thumb_cmp_reg_reg(emit->as, REG_ARG_1, REG_ARG_2); asm_thumb_cmp_reg_reg(emit->as, REG_ARG_1, REG_ARG_2);
@ -650,21 +662,117 @@ void emit_compare_op(emitter_t *emit, rt_compare_op_t op) {
} }
} }
void emit_return_value(emitter_t *emit) { static void emit_thumb_return_value(emit_t *emit) {
emit_pre_pop_reg(emit, REG_RET); emit_pre_pop_reg(emit, REG_RET);
emit->last_emit_was_return_value = true; emit->last_emit_was_return_value = true;
//asm_thumb_call_ind(emit->as, 0, REG_R0); to seg fault for debugging with gdb //asm_thumb_call_ind(emit->as, 0, REG_R0); to seg fault for debugging with gdb
asm_thumb_exit(emit->as); asm_thumb_exit(emit->as);
} }
void emit_raise_varargs(emitter_t *emit, int n_args) { static void emit_thumb_raise_varargs(emit_t *emit, int n_args) {
assert(0); assert(0);
} }
void emit_yield_value(emitter_t *emit) { static void emit_thumb_yield_value(emit_t *emit) {
assert(0); assert(0);
} }
void emit_yield_from(emitter_t *emit) { static void emit_thumb_yield_from(emit_t *emit) {
assert(0); assert(0);
} }
#endif // EMIT_DO_THUMB const emit_method_table_t emit_thumb_method_table = {
emit_thumb_set_native_types,
emit_thumb_start_pass,
emit_thumb_end_pass,
emit_thumb_last_emit_was_return_value,
emit_thumb_get_stack_size,
emit_thumb_set_stack_size,
emit_thumb_load_id,
emit_thumb_store_id,
emit_thumb_delete_id,
emit_thumb_label_assign,
emit_thumb_import_name,
emit_thumb_import_from,
emit_thumb_import_star,
emit_thumb_load_const_tok,
emit_thumb_load_const_small_int,
emit_thumb_load_const_int,
emit_thumb_load_const_dec,
emit_thumb_load_const_id,
emit_thumb_load_const_str,
emit_thumb_load_const_verbatim_start,
emit_thumb_load_const_verbatim_int,
emit_thumb_load_const_verbatim_str,
emit_thumb_load_const_verbatim_strn,
emit_thumb_load_const_verbatim_quoted_str,
emit_thumb_load_const_verbatim_end,
emit_thumb_load_fast,
emit_thumb_load_name,
emit_thumb_load_global,
emit_thumb_load_deref,
emit_thumb_load_closure,
emit_thumb_load_attr,
emit_thumb_load_method,
emit_thumb_load_build_class,
emit_thumb_store_fast,
emit_thumb_store_name,
emit_thumb_store_global,
emit_thumb_store_deref,
emit_thumb_store_attr,
emit_thumb_store_locals,
emit_thumb_store_subscr,
emit_thumb_delete_fast,
emit_thumb_delete_name,
emit_thumb_delete_global,
emit_thumb_delete_deref,
emit_thumb_delete_attr,
emit_thumb_delete_subscr,
emit_thumb_dup_top,
emit_thumb_dup_top_two,
emit_thumb_pop_top,
emit_thumb_rot_two,
emit_thumb_rot_three,
emit_thumb_jump,
emit_thumb_pop_jump_if_true,
emit_thumb_pop_jump_if_false,
emit_thumb_jump_if_true_or_pop,
emit_thumb_jump_if_false_or_pop,
emit_thumb_setup_loop,
emit_thumb_break_loop,
emit_thumb_continue_loop,
emit_thumb_setup_with,
emit_thumb_with_cleanup,
emit_thumb_setup_except,
emit_thumb_setup_finally,
emit_thumb_end_finally,
emit_thumb_get_iter,
emit_thumb_for_iter,
emit_thumb_for_iter_end,
emit_thumb_pop_block,
emit_thumb_pop_except,
emit_thumb_unary_op,
emit_thumb_binary_op,
emit_thumb_compare_op,
emit_thumb_build_tuple,
emit_thumb_build_list,
emit_thumb_list_append,
emit_thumb_build_map,
emit_thumb_store_map,
emit_thumb_map_add,
emit_thumb_build_set,
emit_thumb_set_add,
emit_thumb_build_slice,
emit_thumb_unpack_sequence,
emit_thumb_unpack_ex,
emit_thumb_make_function,
emit_thumb_make_closure,
emit_thumb_call_function,
emit_thumb_call_method,
emit_thumb_return_value,
emit_thumb_raise_varargs,
emit_thumb_yield_value,
emit_thumb_yield_from,
};
#endif // EMIT_ENABLE_THUMB