diff options
Diffstat (limited to 'py/emitbc.c')
| -rw-r--r-- | py/emitbc.c | 294 |
1 files changed, 147 insertions, 147 deletions
diff --git a/py/emitbc.c b/py/emitbc.c index 6a8861eaef..e9c3b164fa 100644 --- a/py/emitbc.c +++ b/py/emitbc.c @@ -59,8 +59,8 @@ struct _emit_t { uint code_info_offset; uint code_info_size; - uint byte_code_offset; - uint byte_code_size; + uint bytecode_offset; + uint bytecode_size; byte *code_base; // stores both byte code and code info byte dummy_data[8]; }; @@ -121,36 +121,36 @@ STATIC void emit_write_code_info_bytes_lines(emit_t* emit, uint bytes_to_skip, u #endif // all functions must go through this one to emit byte code -STATIC byte* emit_get_cur_to_write_byte_code(emit_t* emit, int num_bytes_to_write) { +STATIC byte* emit_get_cur_to_write_bytecode(emit_t* emit, int num_bytes_to_write) { //printf("emit %d\n", num_bytes_to_write); if (emit->pass < MP_PASS_EMIT) { - emit->byte_code_offset += num_bytes_to_write; + emit->bytecode_offset += num_bytes_to_write; return emit->dummy_data; } else { - assert(emit->byte_code_offset + num_bytes_to_write <= emit->byte_code_size); - byte *c = emit->code_base + emit->code_info_size + emit->byte_code_offset; - emit->byte_code_offset += num_bytes_to_write; + assert(emit->bytecode_offset + num_bytes_to_write <= emit->bytecode_size); + byte *c = emit->code_base + emit->code_info_size + emit->bytecode_offset; + emit->bytecode_offset += num_bytes_to_write; return c; } } -STATIC void emit_align_byte_code_to_machine_word(emit_t* emit) { - emit->byte_code_offset = (emit->byte_code_offset + sizeof(machine_uint_t) - 1) & (~(sizeof(machine_uint_t) - 1)); +STATIC void emit_align_bytecode_to_machine_word(emit_t* emit) { + emit->bytecode_offset = (emit->bytecode_offset + sizeof(machine_uint_t) - 1) & (~(sizeof(machine_uint_t) - 1)); } -STATIC void emit_write_byte_code_byte(emit_t* emit, byte b1) { - byte* c = emit_get_cur_to_write_byte_code(emit, 1); +STATIC void emit_write_bytecode_byte(emit_t* emit, byte b1) { + byte* c = emit_get_cur_to_write_bytecode(emit, 1); c[0] = b1; } -STATIC void emit_write_byte_code_byte_byte(emit_t* emit, byte b1, uint b2) { +STATIC void emit_write_bytecode_byte_byte(emit_t* emit, byte b1, uint b2) { assert((b2 & (~0xff)) == 0); - byte* c = emit_get_cur_to_write_byte_code(emit, 2); + byte* c = emit_get_cur_to_write_bytecode(emit, 2); c[0] = b1; c[1] = b2; } -STATIC void emit_write_byte_code_uint(emit_t* emit, uint num) { +STATIC void emit_write_bytecode_uint(emit_t* emit, uint num) { // We store each 7 bits in a separate byte, and that's how many bytes needed byte buf[(BYTES_PER_WORD * 8 + 6) / 7]; byte *p = buf + sizeof(buf); @@ -159,16 +159,16 @@ STATIC void emit_write_byte_code_uint(emit_t* emit, uint num) { *--p = num & 0x7f; num >>= 7; } while (num != 0); - byte* c = emit_get_cur_to_write_byte_code(emit, buf + sizeof(buf) - p); + byte* c = emit_get_cur_to_write_bytecode(emit, buf + sizeof(buf) - p); while (p != buf + sizeof(buf) - 1) { *c++ = *p++ | 0x80; } *c = *p; } -// Similar to emit_write_byte_code_uint(), just some extra handling to encode sign -STATIC void emit_write_byte_code_byte_int(emit_t* emit, byte b1, machine_int_t num) { - emit_write_byte_code_byte(emit, b1); +// Similar to emit_write_bytecode_uint(), just some extra handling to encode sign +STATIC void emit_write_bytecode_byte_int(emit_t* emit, byte b1, machine_int_t num) { + emit_write_bytecode_byte(emit, b1); // We store each 7 bits in a separate byte, and that's how many bytes needed byte buf[(BYTES_PER_WORD * 8 + 6) / 7]; @@ -186,64 +186,64 @@ STATIC void emit_write_byte_code_byte_int(emit_t* emit, byte b1, machine_int_t n *--p = 0; } - byte* c = emit_get_cur_to_write_byte_code(emit, buf + sizeof(buf) - p); + byte* c = emit_get_cur_to_write_bytecode(emit, buf + sizeof(buf) - p); while (p != buf + sizeof(buf) - 1) { *c++ = *p++ | 0x80; } *c = *p; } -STATIC void emit_write_byte_code_byte_uint(emit_t* emit, byte b, uint num) { - emit_write_byte_code_byte(emit, b); - emit_write_byte_code_uint(emit, num); +STATIC void emit_write_bytecode_byte_uint(emit_t* emit, byte b, uint num) { + emit_write_bytecode_byte(emit, b); + emit_write_bytecode_uint(emit, num); } // aligns the pointer so it is friendly to GC -STATIC void emit_write_byte_code_byte_ptr(emit_t* emit, byte b, void *ptr) { - emit_write_byte_code_byte(emit, b); - emit_align_byte_code_to_machine_word(emit); - machine_uint_t *c = (machine_uint_t*)emit_get_cur_to_write_byte_code(emit, sizeof(machine_uint_t)); +STATIC void emit_write_bytecode_byte_ptr(emit_t* emit, byte b, void *ptr) { + emit_write_bytecode_byte(emit, b); + emit_align_bytecode_to_machine_word(emit); + machine_uint_t *c = (machine_uint_t*)emit_get_cur_to_write_bytecode(emit, sizeof(machine_uint_t)); *c = (machine_uint_t)ptr; } /* currently unused -STATIC void emit_write_byte_code_byte_uint_uint(emit_t* emit, byte b, uint num1, uint num2) { - emit_write_byte_code_byte(emit, b); - emit_write_byte_code_byte_uint(emit, num1); - emit_write_byte_code_byte_uint(emit, num2); +STATIC void emit_write_bytecode_byte_uint_uint(emit_t* emit, byte b, uint num1, uint num2) { + emit_write_bytecode_byte(emit, b); + emit_write_bytecode_byte_uint(emit, num1); + emit_write_bytecode_byte_uint(emit, num2); } */ -STATIC void emit_write_byte_code_byte_qstr(emit_t* emit, byte b, qstr qstr) { - emit_write_byte_code_byte_uint(emit, b, qstr); +STATIC void emit_write_bytecode_byte_qstr(emit_t* emit, byte b, qstr qstr) { + emit_write_bytecode_byte_uint(emit, b, qstr); } // unsigned labels are relative to ip following this instruction, stored as 16 bits -STATIC void emit_write_byte_code_byte_unsigned_label(emit_t* emit, byte b1, uint label) { - uint byte_code_offset; +STATIC void emit_write_bytecode_byte_unsigned_label(emit_t* emit, byte b1, uint label) { + uint bytecode_offset; if (emit->pass < MP_PASS_EMIT) { - byte_code_offset = 0; + bytecode_offset = 0; } else { - byte_code_offset = emit->label_offsets[label] - emit->byte_code_offset - 3; + bytecode_offset = emit->label_offsets[label] - emit->bytecode_offset - 3; } - byte *c = emit_get_cur_to_write_byte_code(emit, 3); + byte *c = emit_get_cur_to_write_bytecode(emit, 3); c[0] = b1; - c[1] = byte_code_offset; - c[2] = byte_code_offset >> 8; + c[1] = bytecode_offset; + c[2] = bytecode_offset >> 8; } // signed labels are relative to ip following this instruction, stored as 16 bits, in excess -STATIC void emit_write_byte_code_byte_signed_label(emit_t* emit, byte b1, uint label) { - int byte_code_offset; +STATIC void emit_write_bytecode_byte_signed_label(emit_t* emit, byte b1, uint label) { + int bytecode_offset; if (emit->pass < MP_PASS_EMIT) { - byte_code_offset = 0; + bytecode_offset = 0; } else { - byte_code_offset = emit->label_offsets[label] - emit->byte_code_offset - 3 + 0x8000; + bytecode_offset = emit->label_offsets[label] - emit->bytecode_offset - 3 + 0x8000; } - byte* c = emit_get_cur_to_write_byte_code(emit, 3); + byte* c = emit_get_cur_to_write_bytecode(emit, 3); c[0] = b1; - c[1] = byte_code_offset; - c[2] = byte_code_offset >> 8; + c[1] = bytecode_offset; + c[2] = bytecode_offset >> 8; } STATIC void emit_bc_set_native_types(emit_t *emit, bool do_native_types) { @@ -259,7 +259,7 @@ STATIC void emit_bc_start_pass(emit_t *emit, pass_kind_t pass, scope_t *scope) { if (pass < MP_PASS_EMIT) { memset(emit->label_offsets, -1, emit->max_num_labels * sizeof(uint)); } - emit->byte_code_offset = 0; + emit->bytecode_offset = 0; emit->code_info_offset = 0; // write code info size; use maximum space (4 bytes) to write it; TODO possible optimise this @@ -278,7 +278,7 @@ STATIC void emit_bc_start_pass(emit_t *emit, pass_kind_t pass, scope_t *scope) { // bytecode prelude: local state size and exception stack size; 16 bit uints for now { - byte* c = emit_get_cur_to_write_byte_code(emit, 4); + byte* c = emit_get_cur_to_write_bytecode(emit, 4); uint n_state = scope->num_locals + scope->stack_size; if (n_state == 0) { // Need at least 1 entry in the state, in the case an exception is @@ -301,11 +301,11 @@ STATIC void emit_bc_start_pass(emit_t *emit, pass_kind_t pass, scope_t *scope) { } } assert(num_cell <= 255); - emit_write_byte_code_byte(emit, num_cell); // write number of locals that are cells + emit_write_bytecode_byte(emit, num_cell); // write number of locals that are cells for (int i = 0; i < scope->id_info_len; i++) { id_info_t *id = &scope->id_info[i]; if (id->kind == ID_INFO_KIND_CELL) { - emit_write_byte_code_byte(emit, id->local_num); // write the local which should be converted to a cell + emit_write_bytecode_byte(emit, id->local_num); // write the local which should be converted to a cell } } } @@ -317,21 +317,21 @@ STATIC void emit_bc_end_pass(emit_t *emit) { } *emit_get_cur_to_write_code_info(emit, 1) = 0; // end of line number info - emit_align_code_info_to_machine_word(emit); // align so that following byte_code is aligned + emit_align_code_info_to_machine_word(emit); // align so that following bytecode is aligned if (emit->pass == MP_PASS_CODE_SIZE) { // calculate size of code in bytes emit->code_info_size = emit->code_info_offset; - emit->byte_code_size = emit->byte_code_offset; - emit->code_base = m_new0(byte, emit->code_info_size + emit->byte_code_size); + emit->bytecode_size = emit->bytecode_offset; + emit->code_base = m_new0(byte, emit->code_info_size + emit->bytecode_size); } else if (emit->pass == MP_PASS_EMIT) { qstr *arg_names = m_new(qstr, emit->scope->num_pos_args + emit->scope->num_kwonly_args); for (int i = 0; i < emit->scope->num_pos_args + emit->scope->num_kwonly_args; i++) { arg_names[i] = emit->scope->id_info[i].qstr; } - mp_emit_glue_assign_byte_code(emit->scope->raw_code, emit->code_base, - emit->code_info_size + emit->byte_code_size, + mp_emit_glue_assign_bytecode(emit->scope->raw_code, emit->code_base, + emit->code_info_size + emit->bytecode_size, emit->scope->num_pos_args, emit->scope->num_kwonly_args, arg_names, emit->scope->scope_flags); } @@ -346,14 +346,14 @@ STATIC void emit_bc_adjust_stack_size(emit_t *emit, int delta) { } STATIC void emit_bc_set_source_line(emit_t *emit, int source_line) { - //printf("source: line %d -> %d offset %d -> %d\n", emit->last_source_line, source_line, emit->last_source_line_offset, emit->byte_code_offset); + //printf("source: line %d -> %d offset %d -> %d\n", emit->last_source_line, source_line, emit->last_source_line_offset, emit->bytecode_offset); #if MICROPY_ENABLE_SOURCE_LINE if (source_line > emit->last_source_line) { - uint bytes_to_skip = emit->byte_code_offset - emit->last_source_line_offset; + uint bytes_to_skip = emit->bytecode_offset - emit->last_source_line_offset; uint lines_to_skip = source_line - emit->last_source_line; emit_write_code_info_bytes_lines(emit, bytes_to_skip, lines_to_skip); //printf(" %d %d\n", bytes_to_skip, lines_to_skip); - emit->last_source_line_offset = emit->byte_code_offset; + emit->last_source_line_offset = emit->bytecode_offset; emit->last_source_line = source_line; } #endif @@ -386,167 +386,167 @@ STATIC void emit_bc_label_assign(emit_t *emit, uint l) { if (emit->pass < MP_PASS_EMIT) { // assign label offset assert(emit->label_offsets[l] == -1); - emit->label_offsets[l] = emit->byte_code_offset; + emit->label_offsets[l] = emit->bytecode_offset; } else { // ensure label offset has not changed from MP_PASS_CODE_SIZE to MP_PASS_EMIT - //printf("l%d: (at %d vs %d)\n", l, emit->byte_code_offset, emit->label_offsets[l]); - assert(emit->label_offsets[l] == emit->byte_code_offset); + //printf("l%d: (at %d vs %d)\n", l, emit->bytecode_offset, emit->label_offsets[l]); + assert(emit->label_offsets[l] == emit->bytecode_offset); } } STATIC void emit_bc_import_name(emit_t *emit, qstr qstr) { emit_bc_pre(emit, -1); - emit_write_byte_code_byte_qstr(emit, MP_BC_IMPORT_NAME, qstr); + emit_write_bytecode_byte_qstr(emit, MP_BC_IMPORT_NAME, qstr); } STATIC void emit_bc_import_from(emit_t *emit, qstr qstr) { emit_bc_pre(emit, 1); - emit_write_byte_code_byte_qstr(emit, MP_BC_IMPORT_FROM, qstr); + emit_write_bytecode_byte_qstr(emit, MP_BC_IMPORT_FROM, qstr); } STATIC void emit_bc_import_star(emit_t *emit) { emit_bc_pre(emit, -1); - emit_write_byte_code_byte(emit, MP_BC_IMPORT_STAR); + emit_write_bytecode_byte(emit, MP_BC_IMPORT_STAR); } STATIC void emit_bc_load_const_tok(emit_t *emit, mp_token_kind_t tok) { emit_bc_pre(emit, 1); switch (tok) { - case MP_TOKEN_KW_FALSE: emit_write_byte_code_byte(emit, MP_BC_LOAD_CONST_FALSE); break; - case MP_TOKEN_KW_NONE: emit_write_byte_code_byte(emit, MP_BC_LOAD_CONST_NONE); break; - case MP_TOKEN_KW_TRUE: emit_write_byte_code_byte(emit, MP_BC_LOAD_CONST_TRUE); break; - case MP_TOKEN_ELLIPSIS: emit_write_byte_code_byte(emit, MP_BC_LOAD_CONST_ELLIPSIS); break; + case MP_TOKEN_KW_FALSE: emit_write_bytecode_byte(emit, MP_BC_LOAD_CONST_FALSE); break; + case MP_TOKEN_KW_NONE: emit_write_bytecode_byte(emit, MP_BC_LOAD_CONST_NONE); break; + case MP_TOKEN_KW_TRUE: emit_write_bytecode_byte(emit, MP_BC_LOAD_CONST_TRUE); break; + case MP_TOKEN_ELLIPSIS: emit_write_bytecode_byte(emit, MP_BC_LOAD_CONST_ELLIPSIS); break; default: assert(0); } } STATIC void emit_bc_load_const_small_int(emit_t *emit, machine_int_t arg) { emit_bc_pre(emit, 1); - emit_write_byte_code_byte_int(emit, MP_BC_LOAD_CONST_SMALL_INT, arg); + emit_write_bytecode_byte_int(emit, MP_BC_LOAD_CONST_SMALL_INT, arg); } STATIC void emit_bc_load_const_int(emit_t *emit, qstr qstr) { emit_bc_pre(emit, 1); - emit_write_byte_code_byte_qstr(emit, MP_BC_LOAD_CONST_INT, qstr); + emit_write_bytecode_byte_qstr(emit, MP_BC_LOAD_CONST_INT, qstr); } STATIC void emit_bc_load_const_dec(emit_t *emit, qstr qstr) { emit_bc_pre(emit, 1); - emit_write_byte_code_byte_qstr(emit, MP_BC_LOAD_CONST_DEC, qstr); + emit_write_bytecode_byte_qstr(emit, MP_BC_LOAD_CONST_DEC, qstr); } STATIC void emit_bc_load_const_str(emit_t *emit, qstr qstr, bool bytes) { emit_bc_pre(emit, 1); if (bytes) { - emit_write_byte_code_byte_qstr(emit, MP_BC_LOAD_CONST_BYTES, qstr); + emit_write_bytecode_byte_qstr(emit, MP_BC_LOAD_CONST_BYTES, qstr); } else { - emit_write_byte_code_byte_qstr(emit, MP_BC_LOAD_CONST_STRING, qstr); + emit_write_bytecode_byte_qstr(emit, MP_BC_LOAD_CONST_STRING, qstr); } } STATIC void emit_bc_load_null(emit_t *emit) { emit_bc_pre(emit, 1); - emit_write_byte_code_byte(emit, MP_BC_LOAD_NULL); + emit_write_bytecode_byte(emit, MP_BC_LOAD_NULL); }; STATIC void emit_bc_load_fast(emit_t *emit, qstr qstr, uint id_flags, int local_num) { assert(local_num >= 0); emit_bc_pre(emit, 1); switch (local_num) { - case 0: emit_write_byte_code_byte(emit, MP_BC_LOAD_FAST_0); break; - case 1: emit_write_byte_code_byte(emit, MP_BC_LOAD_FAST_1); break; - case 2: emit_write_byte_code_byte(emit, MP_BC_LOAD_FAST_2); break; - default: emit_write_byte_code_byte_uint(emit, MP_BC_LOAD_FAST_N, local_num); break; + case 0: emit_write_bytecode_byte(emit, MP_BC_LOAD_FAST_0); break; + case 1: emit_write_bytecode_byte(emit, MP_BC_LOAD_FAST_1); break; + case 2: emit_write_bytecode_byte(emit, MP_BC_LOAD_FAST_2); break; + default: emit_write_bytecode_byte_uint(emit, MP_BC_LOAD_FAST_N, local_num); break; } } STATIC void emit_bc_load_deref(emit_t *emit, qstr qstr, int local_num) { emit_bc_pre(emit, 1); - emit_write_byte_code_byte_uint(emit, MP_BC_LOAD_DEREF, local_num); + emit_write_bytecode_byte_uint(emit, MP_BC_LOAD_DEREF, local_num); } STATIC void emit_bc_load_name(emit_t *emit, qstr qstr) { emit_bc_pre(emit, 1); - emit_write_byte_code_byte_qstr(emit, MP_BC_LOAD_NAME, qstr); + emit_write_bytecode_byte_qstr(emit, MP_BC_LOAD_NAME, qstr); } STATIC void emit_bc_load_global(emit_t *emit, qstr qstr) { emit_bc_pre(emit, 1); - emit_write_byte_code_byte_qstr(emit, MP_BC_LOAD_GLOBAL, qstr); + emit_write_bytecode_byte_qstr(emit, MP_BC_LOAD_GLOBAL, qstr); } STATIC void emit_bc_load_attr(emit_t *emit, qstr qstr) { emit_bc_pre(emit, 0); - emit_write_byte_code_byte_qstr(emit, MP_BC_LOAD_ATTR, qstr); + emit_write_bytecode_byte_qstr(emit, MP_BC_LOAD_ATTR, qstr); } STATIC void emit_bc_load_method(emit_t *emit, qstr qstr) { emit_bc_pre(emit, 1); - emit_write_byte_code_byte_qstr(emit, MP_BC_LOAD_METHOD, qstr); + emit_write_bytecode_byte_qstr(emit, MP_BC_LOAD_METHOD, qstr); } STATIC void emit_bc_load_build_class(emit_t *emit) { emit_bc_pre(emit, 1); - emit_write_byte_code_byte(emit, MP_BC_LOAD_BUILD_CLASS); + emit_write_bytecode_byte(emit, MP_BC_LOAD_BUILD_CLASS); } STATIC void emit_bc_load_subscr(emit_t *emit) { emit_bc_pre(emit, -1); - emit_write_byte_code_byte(emit, MP_BC_LOAD_SUBSCR); + emit_write_bytecode_byte(emit, MP_BC_LOAD_SUBSCR); } STATIC void emit_bc_store_fast(emit_t *emit, qstr qstr, int local_num) { assert(local_num >= 0); emit_bc_pre(emit, -1); switch (local_num) { - case 0: emit_write_byte_code_byte(emit, MP_BC_STORE_FAST_0); break; - case 1: emit_write_byte_code_byte(emit, MP_BC_STORE_FAST_1); break; - case 2: emit_write_byte_code_byte(emit, MP_BC_STORE_FAST_2); break; - default: emit_write_byte_code_byte_uint(emit, MP_BC_STORE_FAST_N, local_num); break; + case 0: emit_write_bytecode_byte(emit, MP_BC_STORE_FAST_0); break; + case 1: emit_write_bytecode_byte(emit, MP_BC_STORE_FAST_1); break; + case 2: emit_write_bytecode_byte(emit, MP_BC_STORE_FAST_2); break; + default: emit_write_bytecode_byte_uint(emit, MP_BC_STORE_FAST_N, local_num); break; } } STATIC void emit_bc_store_deref(emit_t *emit, qstr qstr, int local_num) { emit_bc_pre(emit, -1); - emit_write_byte_code_byte_uint(emit, MP_BC_STORE_DEREF, local_num); + emit_write_bytecode_byte_uint(emit, MP_BC_STORE_DEREF, local_num); } STATIC void emit_bc_store_name(emit_t *emit, qstr qstr) { emit_bc_pre(emit, -1); - emit_write_byte_code_byte_qstr(emit, MP_BC_STORE_NAME, qstr); + emit_write_bytecode_byte_qstr(emit, MP_BC_STORE_NAME, qstr); } STATIC void emit_bc_store_global(emit_t *emit, qstr qstr) { emit_bc_pre(emit, -1); - emit_write_byte_code_byte_qstr(emit, MP_BC_STORE_GLOBAL, qstr); + emit_write_bytecode_byte_qstr(emit, MP_BC_STORE_GLOBAL, qstr); } STATIC void emit_bc_store_attr(emit_t *emit, qstr qstr) { emit_bc_pre(emit, -2); - emit_write_byte_code_byte_qstr(emit, MP_BC_STORE_ATTR, qstr); + emit_write_bytecode_byte_qstr(emit, MP_BC_STORE_ATTR, qstr); } STATIC void emit_bc_store_subscr(emit_t *emit) { emit_bc_pre(emit, -3); - emit_write_byte_code_byte(emit, MP_BC_STORE_SUBSCR); + emit_write_bytecode_byte(emit, MP_BC_STORE_SUBSCR); } STATIC void emit_bc_delete_fast(emit_t *emit, qstr qstr, int local_num) { - emit_write_byte_code_byte_uint(emit, MP_BC_DELETE_FAST, local_num); + emit_write_bytecode_byte_uint(emit, MP_BC_DELETE_FAST, local_num); } STATIC void emit_bc_delete_deref(emit_t *emit, qstr qstr, int local_num) { - emit_write_byte_code_byte_uint(emit, MP_BC_DELETE_DEREF, local_num); + emit_write_bytecode_byte_uint(emit, MP_BC_DELETE_DEREF, local_num); } STATIC void emit_bc_delete_name(emit_t *emit, qstr qstr) { emit_bc_pre(emit, 0); - emit_write_byte_code_byte_qstr(emit, MP_BC_DELETE_NAME, qstr); + emit_write_bytecode_byte_qstr(emit, MP_BC_DELETE_NAME, qstr); } STATIC void emit_bc_delete_global(emit_t *emit, qstr qstr) { emit_bc_pre(emit, 0); - emit_write_byte_code_byte_qstr(emit, MP_BC_DELETE_GLOBAL, qstr); + emit_write_bytecode_byte_qstr(emit, MP_BC_DELETE_GLOBAL, qstr); } STATIC void emit_bc_delete_attr(emit_t *emit, qstr qstr) { @@ -563,52 +563,52 @@ STATIC void emit_bc_delete_subscr(emit_t *emit) { STATIC void emit_bc_dup_top(emit_t *emit) { emit_bc_pre(emit, 1); - emit_write_byte_code_byte(emit, MP_BC_DUP_TOP); + emit_write_bytecode_byte(emit, MP_BC_DUP_TOP); } STATIC void emit_bc_dup_top_two(emit_t *emit) { emit_bc_pre(emit, 2); - emit_write_byte_code_byte(emit, MP_BC_DUP_TOP_TWO); + emit_write_bytecode_byte(emit, MP_BC_DUP_TOP_TWO); } STATIC void emit_bc_pop_top(emit_t *emit) { emit_bc_pre(emit, -1); - emit_write_byte_code_byte(emit, MP_BC_POP_TOP); + emit_write_bytecode_byte(emit, MP_BC_POP_TOP); } STATIC void emit_bc_rot_two(emit_t *emit) { emit_bc_pre(emit, 0); - emit_write_byte_code_byte(emit, MP_BC_ROT_TWO); + emit_write_bytecode_byte(emit, MP_BC_ROT_TWO); } STATIC void emit_bc_rot_three(emit_t *emit) { emit_bc_pre(emit, 0); - emit_write_byte_code_byte(emit, MP_BC_ROT_THREE); + emit_write_bytecode_byte(emit, MP_BC_ROT_THREE); } STATIC void emit_bc_jump(emit_t *emit, uint label) { emit_bc_pre(emit, 0); - emit_write_byte_code_byte_signed_label(emit, MP_BC_JUMP, label); + emit_write_bytecode_byte_signed_label(emit, MP_BC_JUMP, label); } STATIC void emit_bc_pop_jump_if_true(emit_t *emit, uint label) { emit_bc_pre(emit, -1); - emit_write_byte_code_byte_signed_label(emit, MP_BC_POP_JUMP_IF_TRUE, label); + emit_write_bytecode_byte_signed_label(emit, MP_BC_POP_JUMP_IF_TRUE, label); } STATIC void emit_bc_pop_jump_if_false(emit_t *emit, uint label) { emit_bc_pre(emit, -1); - emit_write_byte_code_byte_signed_label(emit, MP_BC_POP_JUMP_IF_FALSE, label); + emit_write_bytecode_byte_signed_label(emit, MP_BC_POP_JUMP_IF_FALSE, label); } STATIC void emit_bc_jump_if_true_or_pop(emit_t *emit, uint label) { emit_bc_pre(emit, -1); - emit_write_byte_code_byte_signed_label(emit, MP_BC_JUMP_IF_TRUE_OR_POP, label); + emit_write_bytecode_byte_signed_label(emit, MP_BC_JUMP_IF_TRUE_OR_POP, label); } STATIC void emit_bc_jump_if_false_or_pop(emit_t *emit, uint label) { emit_bc_pre(emit, -1); - emit_write_byte_code_byte_signed_label(emit, MP_BC_JUMP_IF_FALSE_OR_POP, label); + emit_write_bytecode_byte_signed_label(emit, MP_BC_JUMP_IF_FALSE_OR_POP, label); } STATIC void emit_bc_unwind_jump(emit_t *emit, uint label, int except_depth) { @@ -616,44 +616,44 @@ STATIC void emit_bc_unwind_jump(emit_t *emit, uint label, int except_depth) { emit_bc_jump(emit, label); } else { emit_bc_pre(emit, 0); - emit_write_byte_code_byte_signed_label(emit, MP_BC_UNWIND_JUMP, label); - emit_write_byte_code_byte(emit, except_depth); + emit_write_bytecode_byte_signed_label(emit, MP_BC_UNWIND_JUMP, label); + emit_write_bytecode_byte(emit, except_depth); } } STATIC void emit_bc_setup_with(emit_t *emit, uint label) { emit_bc_pre(emit, 7); - emit_write_byte_code_byte_unsigned_label(emit, MP_BC_SETUP_WITH, label); + emit_write_bytecode_byte_unsigned_label(emit, MP_BC_SETUP_WITH, label); } STATIC void emit_bc_with_cleanup(emit_t *emit) { emit_bc_pre(emit, -7); - emit_write_byte_code_byte(emit, MP_BC_WITH_CLEANUP); + emit_write_bytecode_byte(emit, MP_BC_WITH_CLEANUP); } STATIC void emit_bc_setup_except(emit_t *emit, uint label) { emit_bc_pre(emit, 0); - emit_write_byte_code_byte_unsigned_label(emit, MP_BC_SETUP_EXCEPT, label); + emit_write_bytecode_byte_unsigned_label(emit, MP_BC_SETUP_EXCEPT, label); } STATIC void emit_bc_setup_finally(emit_t *emit, uint label) { emit_bc_pre(emit, 0); - emit_write_byte_code_byte_unsigned_label(emit, MP_BC_SETUP_FINALLY, label); + emit_write_bytecode_byte_unsigned_label(emit, MP_BC_SETUP_FINALLY, label); } STATIC void emit_bc_end_finally(emit_t *emit) { emit_bc_pre(emit, -1); - emit_write_byte_code_byte(emit, MP_BC_END_FINALLY); + emit_write_bytecode_byte(emit, MP_BC_END_FINALLY); } STATIC void emit_bc_get_iter(emit_t *emit) { emit_bc_pre(emit, 0); - emit_write_byte_code_byte(emit, MP_BC_GET_ITER); + emit_write_bytecode_byte(emit, MP_BC_GET_ITER); } STATIC void emit_bc_for_iter(emit_t *emit, uint label) { emit_bc_pre(emit, 1); - emit_write_byte_code_byte_unsigned_label(emit, MP_BC_FOR_ITER, label); + emit_write_bytecode_byte_unsigned_label(emit, MP_BC_FOR_ITER, label); } STATIC void emit_bc_for_iter_end(emit_t *emit) { @@ -662,23 +662,23 @@ STATIC void emit_bc_for_iter_end(emit_t *emit) { STATIC void emit_bc_pop_block(emit_t *emit) { emit_bc_pre(emit, 0); - emit_write_byte_code_byte(emit, MP_BC_POP_BLOCK); + emit_write_bytecode_byte(emit, MP_BC_POP_BLOCK); } STATIC void emit_bc_pop_except(emit_t *emit) { emit_bc_pre(emit, 0); - emit_write_byte_code_byte(emit, MP_BC_POP_EXCEPT); + emit_write_bytecode_byte(emit, MP_BC_POP_EXCEPT); } STATIC void emit_bc_unary_op(emit_t *emit, mp_unary_op_t op) { if (op == MP_UNARY_OP_NOT) { emit_bc_pre(emit, 0); - emit_write_byte_code_byte_byte(emit, MP_BC_UNARY_OP, MP_UNARY_OP_BOOL); + emit_write_bytecode_byte_byte(emit, MP_BC_UNARY_OP, MP_UNARY_OP_BOOL); emit_bc_pre(emit, 0); - emit_write_byte_code_byte(emit, MP_BC_NOT); + emit_write_bytecode_byte(emit, MP_BC_NOT); } else { emit_bc_pre(emit, 0); - emit_write_byte_code_byte_byte(emit, MP_BC_UNARY_OP, op); + emit_write_bytecode_byte_byte(emit, MP_BC_UNARY_OP, op); } } @@ -692,98 +692,98 @@ STATIC void emit_bc_binary_op(emit_t *emit, mp_binary_op_t op) { op = MP_BINARY_OP_IS; } emit_bc_pre(emit, -1); - emit_write_byte_code_byte_byte(emit, MP_BC_BINARY_OP, op); + emit_write_bytecode_byte_byte(emit, MP_BC_BINARY_OP, op); if (invert) { emit_bc_pre(emit, 0); - emit_write_byte_code_byte(emit, MP_BC_NOT); + emit_write_bytecode_byte(emit, MP_BC_NOT); } } STATIC void emit_bc_build_tuple(emit_t *emit, int n_args) { assert(n_args >= 0); emit_bc_pre(emit, 1 - n_args); - emit_write_byte_code_byte_uint(emit, MP_BC_BUILD_TUPLE, n_args); + emit_write_bytecode_byte_uint(emit, MP_BC_BUILD_TUPLE, n_args); } STATIC void emit_bc_build_list(emit_t *emit, int n_args) { assert(n_args >= 0); emit_bc_pre(emit, 1 - n_args); - emit_write_byte_code_byte_uint(emit, MP_BC_BUILD_LIST, n_args); + emit_write_bytecode_byte_uint(emit, MP_BC_BUILD_LIST, n_args); } STATIC void emit_bc_list_append(emit_t *emit, int list_stack_index) { assert(list_stack_index >= 0); emit_bc_pre(emit, -1); - emit_write_byte_code_byte_uint(emit, MP_BC_LIST_APPEND, list_stack_index); + emit_write_bytecode_byte_uint(emit, MP_BC_LIST_APPEND, list_stack_index); } STATIC void emit_bc_build_map(emit_t *emit, int n_args) { assert(n_args >= 0); emit_bc_pre(emit, 1); - emit_write_byte_code_byte_uint(emit, MP_BC_BUILD_MAP, n_args); + emit_write_bytecode_byte_uint(emit, MP_BC_BUILD_MAP, n_args); } STATIC void emit_bc_store_map(emit_t *emit) { emit_bc_pre(emit, -2); - emit_write_byte_code_byte(emit, MP_BC_STORE_MAP); + emit_write_bytecode_byte(emit, MP_BC_STORE_MAP); } STATIC void emit_bc_map_add(emit_t *emit, int map_stack_index) { assert(map_stack_index >= 0); emit_bc_pre(emit, -2); - emit_write_byte_code_byte_uint(emit, MP_BC_MAP_ADD, map_stack_index); + emit_write_bytecode_byte_uint(emit, MP_BC_MAP_ADD, map_stack_index); } STATIC void emit_bc_build_set(emit_t *emit, int n_args) { assert(n_args >= 0); emit_bc_pre(emit, 1 - n_args); - emit_write_byte_code_byte_uint(emit, MP_BC_BUILD_SET, n_args); + emit_write_bytecode_byte_uint(emit, MP_BC_BUILD_SET, n_args); } STATIC void emit_bc_set_add(emit_t *emit, int set_stack_index) { assert(set_stack_index >= 0); emit_bc_pre(emit, -1); - emit_write_byte_code_byte_uint(emit, MP_BC_SET_ADD, set_stack_index); + emit_write_bytecode_byte_uint(emit, MP_BC_SET_ADD, set_stack_index); } STATIC void emit_bc_build_slice(emit_t *emit, int n_args) { assert(n_args >= 0); emit_bc_pre(emit, 1 - n_args); - emit_write_byte_code_byte_uint(emit, MP_BC_BUILD_SLICE, n_args); + emit_write_bytecode_byte_uint(emit, MP_BC_BUILD_SLICE, n_args); } STATIC void emit_bc_unpack_sequence(emit_t *emit, int n_args) { assert(n_args >= 0); emit_bc_pre(emit, -1 + n_args); - emit_write_byte_code_byte_uint(emit, MP_BC_UNPACK_SEQUENCE, n_args); + emit_write_bytecode_byte_uint(emit, MP_BC_UNPACK_SEQUENCE, n_args); } STATIC void emit_bc_unpack_ex(emit_t *emit, int n_left, int n_right) { assert(n_left >=0 && n_right >= 0); emit_bc_pre(emit, -1 + n_left + n_right + 1); - emit_write_byte_code_byte_uint(emit, MP_BC_UNPACK_EX, n_left | (n_right << 8)); + emit_write_bytecode_byte_uint(emit, MP_BC_UNPACK_EX, n_left | (n_right << 8)); } STATIC void emit_bc_make_function(emit_t *emit, scope_t *scope, uint n_pos_defaults, uint n_kw_defaults) { if (n_pos_defaults == 0 && n_kw_defaults == 0) { emit_bc_pre(emit, 1); - emit_write_byte_code_byte_ptr(emit, MP_BC_MAKE_FUNCTION, scope->raw_code); + emit_write_bytecode_byte_ptr(emit, MP_BC_MAKE_FUNCTION, scope->raw_code); } else { emit_bc_pre(emit, -1); - emit_write_byte_code_byte_ptr(emit, MP_BC_MAKE_FUNCTION_DEFARGS, scope->raw_code); + emit_write_bytecode_byte_ptr(emit, MP_BC_MAKE_FUNCTION_DEFARGS, scope->raw_code); } } STATIC void emit_bc_make_closure(emit_t *emit, scope_t *scope, uint n_closed_over, uint n_pos_defaults, uint n_kw_defaults) { if (n_pos_defaults == 0 && n_kw_defaults == 0) { emit_bc_pre(emit, -n_closed_over + 1); - emit_write_byte_code_byte_ptr(emit, MP_BC_MAKE_CLOSURE, scope->raw_code); - emit_write_byte_code_byte(emit, n_closed_over); + emit_write_bytecode_byte_ptr(emit, MP_BC_MAKE_CLOSURE, scope->raw_code); + emit_write_bytecode_byte(emit, n_closed_over); } else { assert(n_closed_over <= 255); emit_bc_pre(emit, -2 - n_closed_over + 1); - emit_write_byte_code_byte_ptr(emit, MP_BC_MAKE_CLOSURE_DEFARGS, scope->raw_code); - emit_write_byte_code_byte(emit, n_closed_over); + emit_write_bytecode_byte_ptr(emit, MP_BC_MAKE_CLOSURE_DEFARGS, scope->raw_code); + emit_write_bytecode_byte(emit, n_closed_over); } } @@ -798,10 +798,10 @@ STATIC void emit_bc_call_function_method_helper(emit_t *emit, int stack_adj, uin emit_bc_load_null(emit); } emit_bc_pre(emit, stack_adj - n_positional - 2 * n_keyword - 2); - emit_write_byte_code_byte_uint(emit, bytecode_base + 1, (n_keyword << 8) | n_positional); // TODO make it 2 separate uints? + emit_write_bytecode_byte_uint(emit, bytecode_base + 1, (n_keyword << 8) | n_positional); // TODO make it 2 separate uints? } else { emit_bc_pre(emit, stack_adj - n_positional - 2 * n_keyword); - emit_write_byte_code_byte_uint(emit, bytecode_base, (n_keyword << 8) | n_positional); // TODO make it 2 separate uints? + emit_write_bytecode_byte_uint(emit, bytecode_base, (n_keyword << 8) | n_positional); // TODO make it 2 separate uints? } } @@ -816,25 +816,25 @@ STATIC void emit_bc_call_method(emit_t *emit, int n_positional, int n_keyword, u STATIC void emit_bc_return_value(emit_t *emit) { emit_bc_pre(emit, -1); emit->last_emit_was_return_value = true; - emit_write_byte_code_byte(emit, MP_BC_RETURN_VALUE); + emit_write_bytecode_byte(emit, MP_BC_RETURN_VALUE); } STATIC void emit_bc_raise_varargs(emit_t *emit, int n_args) { assert(0 <= n_args && n_args <= 2); emit_bc_pre(emit, -n_args); - emit_write_byte_code_byte_byte(emit, MP_BC_RAISE_VARARGS, n_args); + emit_write_bytecode_byte_byte(emit, MP_BC_RAISE_VARARGS, n_args); } STATIC void emit_bc_yield_value(emit_t *emit) { emit_bc_pre(emit, 0); emit->scope->scope_flags |= MP_SCOPE_FLAG_GENERATOR; - emit_write_byte_code_byte(emit, MP_BC_YIELD_VALUE); + emit_write_bytecode_byte(emit, MP_BC_YIELD_VALUE); } STATIC void emit_bc_yield_from(emit_t *emit) { emit_bc_pre(emit, -1); emit->scope->scope_flags |= MP_SCOPE_FLAG_GENERATOR; - emit_write_byte_code_byte(emit, MP_BC_YIELD_FROM); + emit_write_bytecode_byte(emit, MP_BC_YIELD_FROM); } const emit_method_table_t emit_bc_method_table = { |