jebbatime
/
micropython
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Restructure emit so it goes through a method table.

osx
Damien 2013-10-05 12:19:06 +01:00
parent 492d082455
commit 415eb6f850
11 changed files with 837 additions and 445 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
py/.gitignore vendored
View File

@ -1 +1,3 @@
*.o *.o
py
*.py

2
py/Makefile
View File

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

10
py/asmx64.c
View File

@ -113,7 +113,8 @@ asm_x64_t* asm_x64_new() {
void asm_x64_free(asm_x64_t* as, bool free_code) { void asm_x64_free(asm_x64_t* as, bool free_code) {
if (free_code) { if (free_code) {
m_free(as->code_base); // need to un-mmap
//m_free(as->code_base);
} }
/* /*
if (as->label != NULL) { if (as->label != NULL) {
@ -154,6 +155,8 @@ void asm_x64_end_pass(asm_x64_t *as) {
// 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);
//uint actual_alloc;
//as->code_base = alloc_mem(as->code_size, &actual_alloc, true);
printf("code_size: %u\n", as->code_size); printf("code_size: %u\n", as->code_size);
} }
@ -611,11 +614,12 @@ void asm_x64_call_i1(asm_x64_t* as, void* func, int i1)
*/ */
void asm_x64_call_ind(asm_x64_t* as, void *ptr, int temp_r64) { void asm_x64_call_ind(asm_x64_t* as, void *ptr, int temp_r64) {
/*
asm_x64_mov_i64_to_r64_optimised(as, (int64_t)ptr, temp_r64); asm_x64_mov_i64_to_r64_optimised(as, (int64_t)ptr, temp_r64);
asm_x64_write_byte_2(as, OPCODE_CALL_RM32, MODRM_R64(2) | MODRM_RM_REG | MODRM_RM_R64(temp_r64)); asm_x64_write_byte_2(as, OPCODE_CALL_RM32, MODRM_R64(2) | MODRM_RM_REG | MODRM_RM_R64(temp_r64));
*/
// this reduces code size by 2 bytes per call, but doesn't seem to speed it up at all // this reduces code size by 2 bytes per call, but doesn't seem to speed it up at all
// doesn't work anymore because calls are 64 bits away
/*
asm_x64_write_byte_1(as, OPCODE_CALL_REL32); asm_x64_write_byte_1(as, OPCODE_CALL_REL32);
asm_x64_write_word32(as, ptr - (void*)(as->code_base + as->code_offset + 4)); asm_x64_write_word32(as, ptr - (void*)(as->code_base + as->code_offset + 4));
*/
} }

100
py/compile.c
View File

@ -15,6 +15,7 @@
#include "emit.h" #include "emit.h"
// TODO need to mangle __attr names // TODO need to mangle __attr names
// TODO add #define to enable/disable CPython compatibility
typedef enum { typedef enum {
PN_none = 0, PN_none = 0,
@ -24,8 +25,8 @@ typedef enum {
PN_maximum_number_of, PN_maximum_number_of,
} pn_kind_t; } pn_kind_t;
#define EMIT(fun, arg...) (emit_##fun(comp->emit, ##arg)) #define EMIT(fun, arg...) (comp->emit_method_table->fun(comp->emit, ##arg))
#define EMIT_COMMON(fun, arg...) (emit_common_##fun(comp->pass, comp->scope_cur, ##arg)) #define EMIT_COMMON(fun, arg...) (emit_common_##fun(comp->pass, comp->scope_cur, comp->emit, comp->emit_method_table, ##arg))
typedef struct _compiler_t { typedef struct _compiler_t {
qstr qstr___class__; qstr qstr___class__;
@ -53,7 +54,8 @@ typedef struct _compiler_t {
scope_t *scope_head; scope_t *scope_head;
scope_t *scope_cur; scope_t *scope_cur;
emitter_t *emit; emit_t *emit;
const emit_method_table_t *emit_method_table;
} compiler_t; } compiler_t;
py_parse_node_t fold_constants(py_parse_node_t pn) { py_parse_node_t fold_constants(py_parse_node_t pn) {
@ -495,10 +497,10 @@ void c_assign(compiler_t *comp, py_parse_node_t pn, assign_kind_t assign_kind) {
switch (assign_kind) { switch (assign_kind) {
case ASSIGN_STORE: case ASSIGN_STORE:
case ASSIGN_AUG_STORE: case ASSIGN_AUG_STORE:
EMIT_COMMON(store_id, comp->emit, arg); EMIT_COMMON(store_id, arg);
break; break;
case ASSIGN_AUG_LOAD: case ASSIGN_AUG_LOAD:
EMIT_COMMON(load_id, comp->qstr___class__, comp->emit, arg); EMIT_COMMON(load_id, comp->qstr___class__, arg);
break; break;
} }
} else { } else {
@ -770,18 +772,18 @@ void compile_decorated(compiler_t *comp, py_parse_node_struct_t *pns) {
} }
// store func/class object into name // store func/class object into name
EMIT_COMMON(store_id, comp->emit, body_name); EMIT_COMMON(store_id, body_name);
} }
void compile_funcdef(compiler_t *comp, py_parse_node_struct_t *pns) { void compile_funcdef(compiler_t *comp, py_parse_node_struct_t *pns) {
qstr fname = compile_funcdef_helper(comp, pns); qstr fname = compile_funcdef_helper(comp, pns);
// store function object into function name // store function object into function name
EMIT_COMMON(store_id, comp->emit, fname); EMIT_COMMON(store_id, fname);
} }
void c_del_stmt(compiler_t *comp, py_parse_node_t pn) { void c_del_stmt(compiler_t *comp, py_parse_node_t pn) {
if (PY_PARSE_NODE_IS_ID(pn)) { if (PY_PARSE_NODE_IS_ID(pn)) {
EMIT_COMMON(delete_id, comp->emit, PY_PARSE_NODE_LEAF_ARG(pn)); EMIT_COMMON(delete_id, PY_PARSE_NODE_LEAF_ARG(pn));
} else if (PY_PARSE_NODE_IS_STRUCT_KIND(pn, PN_power)) { } else if (PY_PARSE_NODE_IS_STRUCT_KIND(pn, PN_power)) {
py_parse_node_struct_t *pns = (py_parse_node_struct_t*)pn; py_parse_node_struct_t *pns = (py_parse_node_struct_t*)pn;
@ -986,7 +988,7 @@ void compile_dotted_as_name(compiler_t *comp, py_parse_node_t pn) {
EMIT(load_const_tok, PY_TOKEN_KW_NONE); EMIT(load_const_tok, PY_TOKEN_KW_NONE);
qstr q1, q2; qstr q1, q2;
do_import_name(comp, pn, &q1, &q2); do_import_name(comp, pn, &q1, &q2);
EMIT_COMMON(store_id, comp->emit, q1); EMIT_COMMON(store_id, q1);
} }
void compile_import_name(compiler_t *comp, py_parse_node_struct_t *pns) { void compile_import_name(compiler_t *comp, py_parse_node_struct_t *pns) {
@ -1033,9 +1035,9 @@ void compile_import_from(compiler_t *comp, py_parse_node_struct_t *pns) {
qstr id2 = PY_PARSE_NODE_LEAF_ARG(pns3->nodes[0]); // should be id qstr id2 = PY_PARSE_NODE_LEAF_ARG(pns3->nodes[0]); // should be id
EMIT(import_from, id2); EMIT(import_from, id2);
if (PY_PARSE_NODE_IS_NULL(pns3->nodes[1])) { if (PY_PARSE_NODE_IS_NULL(pns3->nodes[1])) {
EMIT_COMMON(store_id, comp->emit, id2); EMIT_COMMON(store_id, id2);
} else { } else {
EMIT_COMMON(store_id, comp->emit, PY_PARSE_NODE_LEAF_ARG(pns3->nodes[1])); EMIT_COMMON(store_id, PY_PARSE_NODE_LEAF_ARG(pns3->nodes[1]));
} }
} }
EMIT(pop_top); EMIT(pop_top);
@ -1043,25 +1045,29 @@ void compile_import_from(compiler_t *comp, py_parse_node_struct_t *pns) {
} }
void compile_global_stmt(compiler_t *comp, py_parse_node_struct_t *pns) { void compile_global_stmt(compiler_t *comp, py_parse_node_struct_t *pns) {
if (PY_PARSE_NODE_IS_LEAF(pns->nodes[0])) { if (comp->pass == PASS_1) {
EMIT_COMMON(declare_global, PY_PARSE_NODE_LEAF_ARG(pns->nodes[0])); if (PY_PARSE_NODE_IS_LEAF(pns->nodes[0])) {
} else { scope_declare_global(comp->scope_cur, PY_PARSE_NODE_LEAF_ARG(pns->nodes[0]));
pns = (py_parse_node_struct_t*)pns->nodes[0]; } else {
int num_nodes = PY_PARSE_NODE_STRUCT_NUM_NODES(pns); pns = (py_parse_node_struct_t*)pns->nodes[0];
for (int i = 0; i < num_nodes; i++) { int num_nodes = PY_PARSE_NODE_STRUCT_NUM_NODES(pns);
EMIT_COMMON(declare_global, PY_PARSE_NODE_LEAF_ARG(pns->nodes[i])); for (int i = 0; i < num_nodes; i++) {
scope_declare_global(comp->scope_cur, PY_PARSE_NODE_LEAF_ARG(pns->nodes[i]));
}
} }
} }
} }
void compile_nonlocal_stmt(compiler_t *comp, py_parse_node_struct_t *pns) { void compile_nonlocal_stmt(compiler_t *comp, py_parse_node_struct_t *pns) {
if (PY_PARSE_NODE_IS_LEAF(pns->nodes[0])) { if (comp->pass == PASS_1) {
EMIT_COMMON(declare_nonlocal, PY_PARSE_NODE_LEAF_ARG(pns->nodes[0])); if (PY_PARSE_NODE_IS_LEAF(pns->nodes[0])) {
} else { scope_declare_nonlocal(comp->scope_cur, PY_PARSE_NODE_LEAF_ARG(pns->nodes[0]));
pns = (py_parse_node_struct_t*)pns->nodes[0]; } else {
int num_nodes = PY_PARSE_NODE_STRUCT_NUM_NODES(pns); pns = (py_parse_node_struct_t*)pns->nodes[0];
for (int i = 0; i < num_nodes; i++) { int num_nodes = PY_PARSE_NODE_STRUCT_NUM_NODES(pns);
EMIT_COMMON(declare_nonlocal, PY_PARSE_NODE_LEAF_ARG(pns->nodes[i])); for (int i = 0; i < num_nodes; i++) {
scope_declare_nonlocal(comp->scope_cur, PY_PARSE_NODE_LEAF_ARG(pns->nodes[i]));
}
} }
} }
} }
@ -1069,7 +1075,7 @@ void compile_nonlocal_stmt(compiler_t *comp, py_parse_node_struct_t *pns) {
void compile_assert_stmt(compiler_t *comp, py_parse_node_struct_t *pns) { void compile_assert_stmt(compiler_t *comp, py_parse_node_struct_t *pns) {
int l_end = EMIT(label_new); int l_end = EMIT(label_new);
c_if_cond(comp, pns->nodes[0], true, l_end); c_if_cond(comp, pns->nodes[0], true, l_end);
EMIT_COMMON(load_id, comp->qstr___class__, comp->emit, comp->qstr_assertion_error); EMIT_COMMON(load_id, comp->qstr___class__, comp->qstr_assertion_error);
if (!PY_PARSE_NODE_IS_NULL(pns->nodes[1])) { if (!PY_PARSE_NODE_IS_NULL(pns->nodes[1])) {
// assertion message // assertion message
compile_node(comp, pns->nodes[1]); compile_node(comp, pns->nodes[1]);
@ -1090,7 +1096,7 @@ void compile_if_stmt(compiler_t *comp, py_parse_node_struct_t *pns) {
compile_node(comp, pns->nodes[1]); // if block compile_node(comp, pns->nodes[1]); // if block
//if (!(PY_PARSE_NODE_IS_NULL(pns->nodes[2]) && PY_PARSE_NODE_IS_NULL(pns->nodes[3]))) { // optimisation; doesn't align with CPython //if (!(PY_PARSE_NODE_IS_NULL(pns->nodes[2]) && PY_PARSE_NODE_IS_NULL(pns->nodes[3]))) { // optimisation; doesn't align with CPython
// jump over elif/else blocks if they exist // jump over elif/else blocks if they exist
if (!emit_last_emit_was_return_value(comp->emit)) { // simple optimisation to align with CPython if (!EMIT(last_emit_was_return_value)) { // simple optimisation to align with CPython
EMIT(jump, l_end); EMIT(jump, l_end);
} }
//} //}
@ -1111,7 +1117,7 @@ void compile_if_stmt(compiler_t *comp, py_parse_node_struct_t *pns) {
c_if_cond(comp, pns_elif2->nodes[0], false, l_fail); // elif condition c_if_cond(comp, pns_elif2->nodes[0], false, l_fail); // elif condition
compile_node(comp, pns_elif2->nodes[1]); // elif block compile_node(comp, pns_elif2->nodes[1]); // elif block
if (!emit_last_emit_was_return_value(comp->emit)) { // simple optimisation to align with CPython if (!EMIT(last_emit_was_return_value)) { // simple optimisation to align with CPython
EMIT(jump, l_end); EMIT(jump, l_end);
} }
EMIT(label_assign, l_fail); EMIT(label_assign, l_fail);
@ -1124,7 +1130,7 @@ void compile_if_stmt(compiler_t *comp, py_parse_node_struct_t *pns) {
c_if_cond(comp, pns_elif->nodes[0], false, l_fail); // elif condition c_if_cond(comp, pns_elif->nodes[0], false, l_fail); // elif condition
compile_node(comp, pns_elif->nodes[1]); // elif block compile_node(comp, pns_elif->nodes[1]); // elif block
if (!emit_last_emit_was_return_value(comp->emit)) { // simple optimisation to align with CPython if (!EMIT(last_emit_was_return_value)) { // simple optimisation to align with CPython
EMIT(jump, l_end); EMIT(jump, l_end);
} }
EMIT(label_assign, l_fail); EMIT(label_assign, l_fail);
@ -1153,7 +1159,7 @@ void compile_while_stmt(compiler_t *comp, py_parse_node_struct_t *pns) {
EMIT(label_assign, continue_label); EMIT(label_assign, continue_label);
c_if_cond(comp, pns->nodes[0], false, done_label); // condition c_if_cond(comp, pns->nodes[0], false, done_label); // condition
compile_node(comp, pns->nodes[1]); // body compile_node(comp, pns->nodes[1]); // body
if (!emit_last_emit_was_return_value(comp->emit)) { if (!EMIT(last_emit_was_return_value)) {
EMIT(jump, continue_label); EMIT(jump, continue_label);
} }
EMIT(label_assign, done_label); EMIT(label_assign, done_label);
@ -1194,7 +1200,7 @@ void compile_for_stmt(compiler_t *comp, py_parse_node_struct_t *pns) {
EMIT(for_iter, pop_label); EMIT(for_iter, pop_label);
c_assign(comp, pns->nodes[0], ASSIGN_STORE); // variable c_assign(comp, pns->nodes[0], ASSIGN_STORE); // variable
compile_node(comp, pns->nodes[2]); // body compile_node(comp, pns->nodes[2]); // body
if (!emit_last_emit_was_return_value(comp->emit)) { if (!EMIT(last_emit_was_return_value)) {
EMIT(jump, for_label); EMIT(jump, for_label);
} }
EMIT(label_assign, pop_label); EMIT(label_assign, pop_label);
@ -1263,7 +1269,7 @@ void compile_try_except(compiler_t *comp, py_parse_node_t pn_body, int n_except,
if (qstr_exception_local == 0) { if (qstr_exception_local == 0) {
EMIT(pop_top); EMIT(pop_top);
} else { } else {
EMIT_COMMON(store_id, comp->emit, qstr_exception_local); EMIT_COMMON(store_id, qstr_exception_local);
} }
EMIT(pop_top); EMIT(pop_top);
@ -1282,8 +1288,8 @@ void compile_try_except(compiler_t *comp, py_parse_node_t pn_body, int n_except,
EMIT(load_const_tok, PY_TOKEN_KW_NONE); EMIT(load_const_tok, PY_TOKEN_KW_NONE);
EMIT(label_assign, l3); EMIT(label_assign, l3);
EMIT(load_const_tok, PY_TOKEN_KW_NONE); EMIT(load_const_tok, PY_TOKEN_KW_NONE);
EMIT_COMMON(store_id, comp->emit, qstr_exception_local); EMIT_COMMON(store_id, qstr_exception_local);
EMIT_COMMON(delete_id, comp->emit, qstr_exception_local); EMIT_COMMON(delete_id, qstr_exception_local);
EMIT(end_finally); EMIT(end_finally);
} }
EMIT(jump, l2); EMIT(jump, l2);
@ -2038,7 +2044,7 @@ void compile_dictorsetmaker_item(compiler_t *comp, py_parse_node_struct_t *pns)
void compile_classdef(compiler_t *comp, py_parse_node_struct_t *pns) { void compile_classdef(compiler_t *comp, py_parse_node_struct_t *pns) {
qstr cname = compile_classdef_helper(comp, pns); qstr cname = compile_classdef_helper(comp, pns);
// store class object into class name // store class object into class name
EMIT_COMMON(store_id, comp->emit, cname); EMIT_COMMON(store_id, cname);
} }
void compile_arglist_star(compiler_t *comp, py_parse_node_struct_t *pns) { void compile_arglist_star(compiler_t *comp, py_parse_node_struct_t *pns) {
@ -2116,7 +2122,7 @@ void compile_node(compiler_t *comp, py_parse_node_t pn) {
} else if (PY_PARSE_NODE_IS_LEAF(pn)) { } else if (PY_PARSE_NODE_IS_LEAF(pn)) {
int arg = PY_PARSE_NODE_LEAF_ARG(pn); int arg = PY_PARSE_NODE_LEAF_ARG(pn);
switch (PY_PARSE_NODE_LEAF_KIND(pn)) { switch (PY_PARSE_NODE_LEAF_KIND(pn)) {
case PY_PARSE_NODE_ID: EMIT_COMMON(load_id, comp->qstr___class__, comp->emit, arg); break; case PY_PARSE_NODE_ID: EMIT_COMMON(load_id, comp->qstr___class__, arg); break;
case PY_PARSE_NODE_SMALL_INT: EMIT(load_const_small_int, arg); break; case PY_PARSE_NODE_SMALL_INT: EMIT(load_const_small_int, arg); break;
case PY_PARSE_NODE_INTEGER: EMIT(load_const_int, arg); break; case PY_PARSE_NODE_INTEGER: EMIT(load_const_int, arg); break;
case PY_PARSE_NODE_DECIMAL: EMIT(load_const_dec, arg); break; case PY_PARSE_NODE_DECIMAL: EMIT(load_const_dec, arg); break;
@ -2287,7 +2293,7 @@ void check_for_doc_string(compiler_t *comp, py_parse_node_t pn) {
if (kind == PY_PARSE_NODE_STRING) { if (kind == PY_PARSE_NODE_STRING) {
compile_node(comp, pns->nodes[0]); // a doc string compile_node(comp, pns->nodes[0]); // a doc string
// store doc string // store doc string
EMIT_COMMON(store_id, comp->emit, comp->qstr___doc__); EMIT_COMMON(store_id, comp->qstr___doc__);
} }
} }
} }
@ -2296,7 +2302,7 @@ void check_for_doc_string(compiler_t *comp, py_parse_node_t pn) {
void compile_scope(compiler_t *comp, scope_t *scope, pass_kind_t pass) { void compile_scope(compiler_t *comp, scope_t *scope, pass_kind_t pass) {
comp->pass = pass; comp->pass = pass;
comp->scope_cur = scope; comp->scope_cur = scope;
emit_start_pass(comp->emit, pass, scope); EMIT(start_pass, pass, scope);
if (comp->pass == PASS_1) { if (comp->pass == PASS_1) {
scope->stack_size = 0; scope->stack_size = 0;
@ -2328,7 +2334,7 @@ void compile_scope(compiler_t *comp, scope_t *scope, pass_kind_t pass) {
compile_node(comp, pns->nodes[3]); // 3 is function body compile_node(comp, pns->nodes[3]); // 3 is function body
// emit return if it wasn't the last opcode // emit return if it wasn't the last opcode
if (!emit_last_emit_was_return_value(comp->emit)) { if (!EMIT(last_emit_was_return_value)) {
EMIT(load_const_tok, PY_TOKEN_KW_NONE); EMIT(load_const_tok, PY_TOKEN_KW_NONE);
EMIT(return_value); EMIT(return_value);
} }
@ -2373,7 +2379,7 @@ void compile_scope(compiler_t *comp, scope_t *scope, pass_kind_t pass) {
int l_end = EMIT(label_new); int l_end = EMIT(label_new);
int l_top = EMIT(label_new); int l_top = EMIT(label_new);
EMIT_COMMON(load_id, comp->qstr___class__, comp->emit, qstr_arg); EMIT_COMMON(load_id, comp->qstr___class__, qstr_arg);
EMIT(label_assign, l_top); EMIT(label_assign, l_top);
EMIT(for_iter, l_end); EMIT(for_iter, l_end);
c_assign(comp, pns_comp_for->nodes[0], ASSIGN_STORE); c_assign(comp, pns_comp_for->nodes[0], ASSIGN_STORE);
@ -2404,12 +2410,12 @@ void compile_scope(compiler_t *comp, scope_t *scope, pass_kind_t pass) {
scope->num_params = 1; // __locals__ is the parameter scope->num_params = 1; // __locals__ is the parameter
} }
EMIT_COMMON(load_id, comp->qstr___class__, comp->emit, comp->qstr___locals__); EMIT_COMMON(load_id, comp->qstr___class__, comp->qstr___locals__);
EMIT(store_locals); EMIT(store_locals);
EMIT_COMMON(load_id, comp->qstr___class__, comp->emit, comp->qstr___name__); EMIT_COMMON(load_id, comp->qstr___class__, comp->qstr___name__);
EMIT_COMMON(store_id, comp->emit, comp->qstr___module__); EMIT_COMMON(store_id, comp->qstr___module__);
EMIT(load_const_id, PY_PARSE_NODE_LEAF_ARG(pns->nodes[0])); // 0 is class name EMIT(load_const_id, PY_PARSE_NODE_LEAF_ARG(pns->nodes[0])); // 0 is class name
EMIT_COMMON(store_id, comp->emit, comp->qstr___qualname__); EMIT_COMMON(store_id, comp->qstr___qualname__);
check_for_doc_string(comp, pns->nodes[2]); check_for_doc_string(comp, pns->nodes[2]);
compile_node(comp, pns->nodes[2]); // 2 is class body compile_node(comp, pns->nodes[2]); // 2 is class body
@ -2424,7 +2430,7 @@ void compile_scope(compiler_t *comp, scope_t *scope, pass_kind_t pass) {
EMIT(return_value); EMIT(return_value);
} }
emit_end_pass(comp->emit); EMIT(end_pass);
} }
void compile_scope_compute_things(compiler_t *comp, scope_t *scope) { void compile_scope_compute_things(compiler_t *comp, scope_t *scope) {
@ -2489,7 +2495,9 @@ void py_compile(py_parse_node_t pn) {
comp->scope_head = NULL; comp->scope_head = NULL;
comp->scope_cur = NULL; comp->scope_cur = NULL;
comp->emit = emit_new(comp->qstr___class__); emit_new_cpython(&comp->emit, &comp->emit_method_table);
//emit_new_bc(&comp->emit, &comp->emit_method_table);
//emit_new_x64(&comp->emit, &comp->emit_method_table);
pn = fold_constants(pn); pn = fold_constants(pn);
scope_new_and_link(comp, SCOPE_MODULE, pn); scope_new_and_link(comp, SCOPE_MODULE, pn);

116
py/emit.h
View File

@ -1,8 +1,3 @@
//#define EMIT_DO_CPY
#define EMIT_DO_BC
//#define EMIT_DO_X64
//#define EMIT_DO_THUMB
/* Notes on passes: /* Notes on passes:
* We don't know exactly the opcodes in pass 1 because they depend on the * We don't know exactly the opcodes in pass 1 because they depend on the
* closing over of variables (LOAD_CLOSURE, BUILD_TUPLE, MAKE_CLOSURE), which * closing over of variables (LOAD_CLOSURE, BUILD_TUPLE, MAKE_CLOSURE), which
@ -19,15 +14,111 @@ typedef enum {
PASS_3 = 3, // emit code PASS_3 = 3, // emit code
} pass_kind_t; } pass_kind_t;
typedef struct _emitter_t emitter_t; typedef struct _emit_t emit_t;
void emit_common_declare_global(pass_kind_t pass, scope_t *scope, qstr qstr); typedef struct _emit_method_table_t {
void emit_common_declare_nonlocal(pass_kind_t pass, scope_t *scope, qstr qstr); void (*set_native_types)(emit_t *emit, bool do_native_types);
void emit_common_load_id(pass_kind_t pass, scope_t *scope, qstr qstr___class__, emitter_t *emit, qstr qstr); void (*start_pass)(emit_t *emit, pass_kind_t pass, scope_t *scope);
void emit_common_store_id(pass_kind_t pass, scope_t *scope, emitter_t *emit, qstr qstr); void (*end_pass)(emit_t *emit);
void emit_common_delete_id(pass_kind_t pass, scope_t *scope, emitter_t *emit, qstr qstr); bool (*last_emit_was_return_value)(emit_t *emit);
int (*get_stack_size)(emit_t *emit);
void (*set_stack_size)(emit_t *emit, int size);
emitter_t *emit_new(); int (*label_new)(emit_t *emit);
void (*label_assign)(emit_t *emit, int l);
void (*import_name)(emit_t *emit, qstr qstr);
void (*import_from)(emit_t *emit, qstr qstr);
void (*import_star)(emit_t *emit);
void (*load_const_tok)(emit_t *emit, py_token_kind_t tok);
void (*load_const_small_int)(emit_t *emit, int arg);
void (*load_const_int)(emit_t *emit, qstr qstr);
void (*load_const_dec)(emit_t *emit, qstr qstr);
void (*load_const_id)(emit_t *emit, qstr qstr);
void (*load_const_str)(emit_t *emit, qstr qstr, bool bytes);
void (*load_const_verbatim_start)(emit_t *emit);
void (*load_const_verbatim_int)(emit_t *emit, int val);
void (*load_const_verbatim_str)(emit_t *emit, const char *str);
void (*load_const_verbatim_strn)(emit_t *emit, const char *str, int len);
void (*load_const_verbatim_quoted_str)(emit_t *emit, qstr qstr, bool bytes);
void (*load_const_verbatim_end)(emit_t *emit);
void (*load_fast)(emit_t *emit, qstr qstr, int local_num);
void (*load_name)(emit_t *emit, qstr qstr);
void (*load_global)(emit_t *emit, qstr qstr);
void (*load_deref)(emit_t *emit, qstr qstr);
void (*load_closure)(emit_t *emit, qstr qstr);
void (*load_attr)(emit_t *emit, qstr qstr);
void (*load_method)(emit_t *emit, qstr qstr);
void (*load_build_class)(emit_t *emit);
void (*store_fast)(emit_t *emit, qstr qstr, int local_num);
void (*store_name)(emit_t *emit, qstr qstr);
void (*store_global)(emit_t *emit, qstr qstr);
void (*store_deref)(emit_t *emit, qstr qstr);
void (*store_attr)(emit_t *emit, qstr qstr);
void (*store_locals)(emit_t *emit);
void (*store_subscr)(emit_t *emit);
void (*delete_fast)(emit_t *emit, qstr qstr, int local_num);
void (*delete_name)(emit_t *emit, qstr qstr);
void (*delete_global)(emit_t *emit, qstr qstr);
void (*delete_deref)(emit_t *emit, qstr qstr);
void (*delete_attr)(emit_t *emit, qstr qstr);
void (*delete_subscr)(emit_t *emit);
void (*dup_top)(emit_t *emit);
void (*dup_top_two)(emit_t *emit);
void (*pop_top)(emit_t *emit);
void (*rot_two)(emit_t *emit);
void (*rot_three)(emit_t *emit);
void (*jump)(emit_t *emit, int label);
void (*pop_jump_if_true)(emit_t *emit, int label);
void (*pop_jump_if_false)(emit_t *emit, int label);
void (*jump_if_true_or_pop)(emit_t *emit, int label);
void (*jump_if_false_or_pop)(emit_t *emit, int label);
void (*setup_loop)(emit_t *emit, int label);
void (*break_loop)(emit_t *emit, int label);
void (*continue_loop)(emit_t *emit, int label);
void (*setup_with)(emit_t *emit, int label);
void (*with_cleanup)(emit_t *emit);
void (*setup_except)(emit_t *emit, int label);
void (*setup_finally)(emit_t *emit, int label);
void (*end_finally)(emit_t *emit);
void (*get_iter)(emit_t *emit); // tos = getiter(tos)
void (*for_iter)(emit_t *emit, int label);
void (*for_iter_end)(emit_t *emit);
void (*pop_block)(emit_t *emit);
void (*pop_except)(emit_t *emit);
void (*unary_op)(emit_t *emit, rt_unary_op_t op);
void (*binary_op)(emit_t *emit, rt_binary_op_t op);
void (*compare_op)(emit_t *emit, rt_compare_op_t op);
void (*build_tuple)(emit_t *emit, int n_args);
void (*build_list)(emit_t *emit, int n_args);
void (*list_append)(emit_t *emit, int list_stack_index);
void (*build_map)(emit_t *emit, int n_args);
void (*store_map)(emit_t *emit);
void (*map_add)(emit_t *emit, int map_stack_index);
void (*build_set)(emit_t *emit, int n_args);
void (*set_add)(emit_t *emit, int set_stack_index);
void (*build_slice)(emit_t *emit, int n_args);
void (*unpack_sequence)(emit_t *emit, int n_args);
void (*unpack_ex)(emit_t *emit, int n_left, int n_right);
void (*make_function)(emit_t *emit, scope_t *scope, int n_dict_params, int n_default_params);
void (*make_closure)(emit_t *emit, scope_t *scope, int n_dict_params, int n_default_params);
void (*call_function)(emit_t *emit, int n_positional, int n_keyword, bool have_star_arg, bool have_dbl_star_arg);
void (*call_method)(emit_t *emit, int n_positional, int n_keyword, bool have_star_arg, bool have_dbl_star_arg);
void (*return_value)(emit_t *emit);
void (*raise_varargs)(emit_t *emit, int n_args);
void (*yield_value)(emit_t *emit);
void (*yield_from)(emit_t *emit);
} emit_method_table_t;
void emit_common_load_id(pass_kind_t pass, scope_t *scope, emit_t *emit, const emit_method_table_t *emit_method_table, qstr qstr___class__, qstr qstr);
void emit_common_store_id(pass_kind_t pass, scope_t *scope, emit_t *emit, const emit_method_table_t *emit_method_table, qstr qstr);
void emit_common_delete_id(pass_kind_t pass, scope_t *scope, emit_t *emit, const emit_method_table_t *emit_method_table, qstr qstr);
void emit_new_cpython(emit_t **emit, const emit_method_table_t **emit_method_table);
void emit_new_bc(emit_t **emit, const emit_method_table_t **emit_method_table);
void emit_new_x64(emit_t **emit, const emit_method_table_t **emit_method_table);
void emit_new_thumb(emit_t **emit, const emit_method_table_t **emit_method_table);
/*
void emit_set_native_types(emitter_t *emit, bool do_native_types); void emit_set_native_types(emitter_t *emit, bool do_native_types);
void emit_start_pass(emitter_t *emit, pass_kind_t pass, scope_t *scope); void emit_start_pass(emitter_t *emit, pass_kind_t pass, scope_t *scope);
void emit_end_pass(emitter_t *emit); void emit_end_pass(emitter_t *emit);
@ -118,3 +209,4 @@ void emit_return_value(emitter_t *emit);
void emit_raise_varargs(emitter_t *emit, int n_args); void emit_raise_varargs(emitter_t *emit, int n_args);
void emit_yield_value(emitter_t *emit); void emit_yield_value(emitter_t *emit);
void emit_yield_from(emitter_t *emit); void emit_yield_from(emitter_t *emit);
*/

320
py/emitbc.c
View File

@ -15,10 +15,8 @@
#include "emit.h" #include "emit.h"
#include "bc.h" #include "bc.h"
#ifdef EMIT_DO_BC struct _emit_t {
pass_kind_t pass;
struct _emitter_t {
int pass;
int next_label; int next_label;
int stack_size; int stack_size;
bool last_emit_was_return_value; bool last_emit_was_return_value;
@ -34,25 +32,18 @@ struct _emitter_t {
byte dummy_data[8]; byte dummy_data[8];
}; };
emitter_t *emit_new() { uint emit_bc_get_code_size(emit_t* emit) {
emitter_t *emit = m_new(emitter_t, 1);
emit->max_num_labels = 0;
emit->label_offsets = NULL;
emit->code_offset = 0;
emit->code_size = 0;
emit->code_base = NULL;
return emit;
}
uint emit_get_code_size(emitter_t* emit) {
return emit->code_size; return emit->code_size;
} }
void* emit_get_code(emitter_t* emit) { void* emit_bc_get_code(emit_t* emit) {
return emit->code_base; return emit->code_base;
} }
void emit_start_pass(emitter_t *emit, pass_kind_t pass, scope_t *scope) { static void emit_bc_set_native_types(emit_t *emit, bool do_native_types) {
}
static void emit_bc_start_pass(emit_t *emit, pass_kind_t pass, scope_t *scope) {
emit->pass = pass; emit->pass = pass;
emit->next_label = 1; emit->next_label = 1;
emit->stack_size = 0; emit->stack_size = 0;
@ -71,7 +62,7 @@ void emit_start_pass(emitter_t *emit, pass_kind_t pass, scope_t *scope) {
emit->code_offset = 0; emit->code_offset = 0;
} }
void emit_end_pass(emitter_t *emit) { static void emit_bc_end_pass(emit_t *emit) {
// check stack is back to zero size // check stack is back to zero size
if (emit->stack_size != 0) { if (emit->stack_size != 0) {
printf("ERROR: stack size not back to zero; got %d\n", emit->stack_size); printf("ERROR: stack size not back to zero; got %d\n", emit->stack_size);
@ -95,7 +86,7 @@ void emit_end_pass(emitter_t *emit) {
} }
// all functions must go through this one to emit bytes // all functions must go through this one to emit bytes
static byte* emit_get_cur_to_write_bytes(emitter_t* emit, int num_bytes_to_write) { static byte* emit_get_cur_to_write_bytes(emit_t* emit, int num_bytes_to_write) {
//printf("emit %d\n", num_bytes_to_write); //printf("emit %d\n", num_bytes_to_write);
if (emit->pass < PASS_3) { if (emit->pass < PASS_3) {
emit->code_offset += num_bytes_to_write; emit->code_offset += num_bytes_to_write;
@ -108,19 +99,19 @@ static byte* emit_get_cur_to_write_bytes(emitter_t* emit, int num_bytes_to_write
} }
} }
static void emit_write_byte_1(emitter_t* emit, byte b1) { static void emit_write_byte_1(emit_t* emit, byte b1) {
byte* c = emit_get_cur_to_write_bytes(emit, 1); byte* c = emit_get_cur_to_write_bytes(emit, 1);
c[0] = b1; c[0] = b1;
} }
static void emit_write_byte_1_byte(emitter_t* emit, byte b1, uint b2) { static void emit_write_byte_1_byte(emit_t* emit, byte b1, uint b2) {
assert((b2 & (~0xff)) == 0); assert((b2 & (~0xff)) == 0);
byte* c = emit_get_cur_to_write_bytes(emit, 2); byte* c = emit_get_cur_to_write_bytes(emit, 2);
c[0] = b1; c[0] = b1;
c[1] = b2; c[1] = b2;
} }
static void emit_write_byte_1_int(emitter_t* emit, byte b1, int num) { static void emit_write_byte_1_int(emit_t* emit, byte b1, int num) {
assert((num & (~0x7fff)) == 0 || (num & (~0x7fff)) == (~0x7fff)); assert((num & (~0x7fff)) == 0 || (num & (~0x7fff)) == (~0x7fff));
byte* c = emit_get_cur_to_write_bytes(emit, 3); byte* c = emit_get_cur_to_write_bytes(emit, 3);
c[0] = b1; c[0] = b1;
@ -128,7 +119,7 @@ static void emit_write_byte_1_int(emitter_t* emit, byte b1, int num) {
c[2] = num >> 8; c[2] = num >> 8;
} }
static void emit_write_byte_1_uint(emitter_t* emit, byte b1, uint num) { static void emit_write_byte_1_uint(emit_t* emit, byte b1, uint num) {
if (num <= 127) { // fits in 0x7f if (num <= 127) { // fits in 0x7f
// fit argument in single byte // fit argument in single byte
byte* c = emit_get_cur_to_write_bytes(emit, 2); byte* c = emit_get_cur_to_write_bytes(emit, 2);
@ -146,11 +137,11 @@ static void emit_write_byte_1_uint(emitter_t* emit, byte b1, uint num) {
} }
} }
static void emit_write_byte_1_qstr(emitter_t* emit, byte b1, qstr qstr) { static void emit_write_byte_1_qstr(emit_t* emit, byte b1, qstr qstr) {
emit_write_byte_1_uint(emit, b1, qstr); emit_write_byte_1_uint(emit, b1, qstr);
} }
static void emit_write_byte_1_label(emitter_t* emit, byte b1, int label) { static void emit_write_byte_1_label(emit_t* emit, byte b1, int label) {
uint code_offset; uint code_offset;
if (emit->pass < PASS_3) { if (emit->pass < PASS_3) {
code_offset = 0; code_offset = 0;
@ -160,21 +151,21 @@ static void emit_write_byte_1_label(emitter_t* emit, byte b1, int label) {
emit_write_byte_1_uint(emit, b1, code_offset); emit_write_byte_1_uint(emit, b1, code_offset);
} }
bool emit_last_emit_was_return_value(emitter_t *emit) { bool emit_bc_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) { int emit_bc_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_bc_set_stack_size(emit_t *emit, int size) {
if (emit->pass > PASS_1) { if (emit->pass > PASS_1) {
emit->stack_size = size; emit->stack_size = size;
} }
} }
static void emit_pre(emitter_t *emit, int stack_size_delta) { static void emit_pre(emit_t *emit, int stack_size_delta) {
if (emit->pass > PASS_1) { if (emit->pass > PASS_1) {
emit->stack_size += stack_size_delta; emit->stack_size += stack_size_delta;
if (emit->stack_size > emit->scope->stack_size) { if (emit->stack_size > emit->scope->stack_size) {
@ -184,11 +175,11 @@ static void emit_pre(emitter_t *emit, int stack_size_delta) {
emit->last_emit_was_return_value = false; emit->last_emit_was_return_value = false;
} }
int emit_label_new(emitter_t *emit) { static int emit_bc_label_new(emit_t *emit) {
return emit->next_label++; return emit->next_label++;
} }
void emit_label_assign(emitter_t *emit, int l) { static void emit_bc_label_assign(emit_t *emit, int l) {
emit_pre(emit, 0); emit_pre(emit, 0);
if (emit->pass > PASS_1) { if (emit->pass > PASS_1) {
assert(l < emit->max_num_labels); assert(l < emit->max_num_labels);
@ -204,22 +195,22 @@ void emit_label_assign(emitter_t *emit, int l) {
} }
} }
void emit_import_name(emitter_t *emit, qstr qstr) { static void emit_bc_import_name(emit_t *emit, qstr qstr) {
emit_pre(emit, -1); emit_pre(emit, -1);
emit_write_byte_1_qstr(emit, PYBC_IMPORT_NAME, qstr); emit_write_byte_1_qstr(emit, PYBC_IMPORT_NAME, qstr);
} }
void emit_import_from(emitter_t *emit, qstr qstr) { static void emit_bc_import_from(emit_t *emit, qstr qstr) {
emit_pre(emit, 1); emit_pre(emit, 1);
emit_write_byte_1_qstr(emit, PYBC_IMPORT_FROM, qstr); emit_write_byte_1_qstr(emit, PYBC_IMPORT_FROM, qstr);
} }
void emit_import_star(emitter_t *emit) { static void emit_bc_import_star(emit_t *emit) {
emit_pre(emit, -1); emit_pre(emit, -1);
emit_write_byte_1(emit, PYBC_IMPORT_STAR); emit_write_byte_1(emit, PYBC_IMPORT_STAR);
} }
void emit_load_const_tok(emitter_t *emit, py_token_kind_t tok) { static void emit_bc_load_const_tok(emit_t *emit, py_token_kind_t tok) {
emit_pre(emit, 1); emit_pre(emit, 1);
switch (tok) { switch (tok) {
case PY_TOKEN_KW_FALSE: emit_write_byte_1(emit, PYBC_LOAD_CONST_FALSE); break; case PY_TOKEN_KW_FALSE: emit_write_byte_1(emit, PYBC_LOAD_CONST_FALSE); break;
@ -229,27 +220,27 @@ void emit_load_const_tok(emitter_t *emit, py_token_kind_t tok) {
} }
} }
void emit_load_const_small_int(emitter_t *emit, int arg) { static void emit_bc_load_const_small_int(emit_t *emit, int arg) {
emit_pre(emit, 1); emit_pre(emit, 1);
emit_write_byte_1_int(emit, PYBC_LOAD_CONST_SMALL_INT, arg); emit_write_byte_1_int(emit, PYBC_LOAD_CONST_SMALL_INT, arg);
} }
void emit_load_const_int(emitter_t *emit, qstr qstr) { static void emit_bc_load_const_int(emit_t *emit, qstr qstr) {
emit_pre(emit, 1); emit_pre(emit, 1);
emit_write_byte_1_qstr(emit, PYBC_LOAD_CONST_INT, qstr); emit_write_byte_1_qstr(emit, PYBC_LOAD_CONST_INT, qstr);
} }
void emit_load_const_dec(emitter_t *emit, qstr qstr) { static void emit_bc_load_const_dec(emit_t *emit, qstr qstr) {
emit_pre(emit, 1); emit_pre(emit, 1);
emit_write_byte_1_qstr(emit, PYBC_LOAD_CONST_DEC, qstr); emit_write_byte_1_qstr(emit, PYBC_LOAD_CONST_DEC, qstr);
} }
void emit_load_const_id(emitter_t *emit, qstr qstr) { static void emit_bc_load_const_id(emit_t *emit, qstr qstr) {
emit_pre(emit, 1); emit_pre(emit, 1);
emit_write_byte_1_qstr(emit, PYBC_LOAD_CONST_ID, qstr); emit_write_byte_1_qstr(emit, PYBC_LOAD_CONST_ID, qstr);
} }
void emit_load_const_str(emitter_t *emit, qstr qstr, bool bytes) { static void emit_bc_load_const_str(emit_t *emit, qstr qstr, bool bytes) {
emit_pre(emit, 1); emit_pre(emit, 1);
if (bytes) { if (bytes) {
emit_write_byte_1_qstr(emit, PYBC_LOAD_CONST_BYTES, qstr); emit_write_byte_1_qstr(emit, PYBC_LOAD_CONST_BYTES, qstr);
@ -258,32 +249,32 @@ void emit_load_const_str(emitter_t *emit, qstr qstr, bool bytes) {
} }
} }
void emit_load_const_verbatim_start(emitter_t *emit) { static void emit_bc_load_const_verbatim_start(emit_t *emit) {
emit_pre(emit, 1); emit_pre(emit, 1);
assert(0); assert(0);
} }
void emit_load_const_verbatim_int(emitter_t *emit, int val) { static void emit_bc_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_bc_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_bc_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_bc_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_bc_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_bc_load_fast(emit_t *emit, qstr qstr, int local_num) {
assert(local_num >= 0); assert(local_num >= 0);
emit_pre(emit, 1); emit_pre(emit, 1);
switch (local_num) { switch (local_num) {
@ -294,42 +285,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_bc_load_name(emit_t *emit, qstr qstr) {
emit_pre(emit, 1); emit_pre(emit, 1);
emit_write_byte_1_qstr(emit, PYBC_LOAD_NAME, qstr); emit_write_byte_1_qstr(emit, PYBC_LOAD_NAME, qstr);
} }
void emit_load_global(emitter_t *emit, qstr qstr) { static void emit_bc_load_global(emit_t *emit, qstr qstr) {
emit_pre(emit, 1); emit_pre(emit, 1);
emit_write_byte_1_qstr(emit, PYBC_LOAD_GLOBAL, qstr); emit_write_byte_1_qstr(emit, PYBC_LOAD_GLOBAL, qstr);
} }
void emit_load_deref(emitter_t *emit, qstr qstr) { static void emit_bc_load_deref(emit_t *emit, qstr qstr) {
emit_pre(emit, 1); emit_pre(emit, 1);
assert(0); assert(0);
} }
void emit_load_closure(emitter_t *emit, qstr qstr) { static void emit_bc_load_closure(emit_t *emit, qstr qstr) {
emit_pre(emit, 1); emit_pre(emit, 1);
assert(0); assert(0);
} }
void emit_load_attr(emitter_t *emit, qstr qstr) { static void emit_bc_load_attr(emit_t *emit, qstr qstr) {
emit_pre(emit, 0); emit_pre(emit, 0);
emit_write_byte_1_qstr(emit, PYBC_LOAD_ATTR, qstr); emit_write_byte_1_qstr(emit, PYBC_LOAD_ATTR, qstr);
} }
void emit_load_method(emitter_t *emit, qstr qstr) { static void emit_bc_load_method(emit_t *emit, qstr qstr) {
emit_pre(emit, 0); emit_pre(emit, 0);
emit_write_byte_1_qstr(emit, PYBC_LOAD_METHOD, qstr); emit_write_byte_1_qstr(emit, PYBC_LOAD_METHOD, qstr);
} }
void emit_load_build_class(emitter_t *emit) { static void emit_bc_load_build_class(emit_t *emit) {
emit_pre(emit, 1); emit_pre(emit, 1);
emit_write_byte_1(emit, PYBC_LOAD_BUILD_CLASS); emit_write_byte_1(emit, PYBC_LOAD_BUILD_CLASS);
} }
void emit_store_fast(emitter_t *emit, qstr qstr, int local_num) { static void emit_bc_store_fast(emit_t *emit, qstr qstr, int local_num) {
assert(local_num >= 0); assert(local_num >= 0);
emit_pre(emit, -1); emit_pre(emit, -1);
switch (local_num) { switch (local_num) {
@ -340,268 +331,268 @@ void emit_store_fast(emitter_t *emit, qstr qstr, int local_num) {
} }
} }
void emit_store_name(emitter_t *emit, qstr qstr) { static void emit_bc_store_name(emit_t *emit, qstr qstr) {
emit_pre(emit, -1); emit_pre(emit, -1);
emit_write_byte_1_qstr(emit, PYBC_STORE_NAME, qstr); emit_write_byte_1_qstr(emit, PYBC_STORE_NAME, qstr);
} }
void emit_store_global(emitter_t *emit, qstr qstr) { static void emit_bc_store_global(emit_t *emit, qstr qstr) {
emit_pre(emit, -1); emit_pre(emit, -1);
emit_write_byte_1_qstr(emit, PYBC_STORE_GLOBAL, qstr); emit_write_byte_1_qstr(emit, PYBC_STORE_GLOBAL, qstr);
} }
void emit_store_deref(emitter_t *emit, qstr qstr) { static void emit_bc_store_deref(emit_t *emit, qstr qstr) {
emit_pre(emit, -1); emit_pre(emit, -1);
assert(0); assert(0);
} }
void emit_store_attr(emitter_t *emit, qstr qstr) { static void emit_bc_store_attr(emit_t *emit, qstr qstr) {
emit_pre(emit, -2); emit_pre(emit, -2);
emit_write_byte_1_qstr(emit, PYBC_STORE_ATTR, qstr); emit_write_byte_1_qstr(emit, PYBC_STORE_ATTR, qstr);
} }
void emit_store_locals(emitter_t *emit) { static void emit_bc_store_locals(emit_t *emit) {
emit_pre(emit, -1); emit_pre(emit, -1);
emit_write_byte_1(emit, PYBC_STORE_LOCALS); emit_write_byte_1(emit, PYBC_STORE_LOCALS);
} }
void emit_store_subscr(emitter_t *emit) { static void emit_bc_store_subscr(emit_t *emit) {
emit_pre(emit, -3); emit_pre(emit, -3);
emit_write_byte_1(emit, PYBC_STORE_SUBSCR); emit_write_byte_1(emit, PYBC_STORE_SUBSCR);
} }
void emit_delete_fast(emitter_t *emit, qstr qstr, int local_num) { static void emit_bc_delete_fast(emit_t *emit, qstr qstr, int local_num) {
assert(local_num >= 0); assert(local_num >= 0);
emit_pre(emit, 0); emit_pre(emit, 0);
emit_write_byte_1_uint(emit, PYBC_DELETE_FAST_N, local_num); emit_write_byte_1_uint(emit, PYBC_DELETE_FAST_N, local_num);
} }
void emit_delete_name(emitter_t *emit, qstr qstr) { static void emit_bc_delete_name(emit_t *emit, qstr qstr) {
emit_pre(emit, 0); emit_pre(emit, 0);
emit_write_byte_1_qstr(emit, PYBC_DELETE_NAME, qstr); emit_write_byte_1_qstr(emit, PYBC_DELETE_NAME, qstr);
} }
void emit_delete_global(emitter_t *emit, qstr qstr) { static void emit_bc_delete_global(emit_t *emit, qstr qstr) {
emit_pre(emit, 0); emit_pre(emit, 0);
emit_write_byte_1_qstr(emit, PYBC_DELETE_GLOBAL, qstr); emit_write_byte_1_qstr(emit, PYBC_DELETE_GLOBAL, qstr);
} }
void emit_delete_deref(emitter_t *emit, qstr qstr) { static void emit_bc_delete_deref(emit_t *emit, qstr qstr) {
emit_pre(emit, 0); emit_pre(emit, 0);
emit_write_byte_1_qstr(emit, PYBC_DELETE_DEREF, qstr); emit_write_byte_1_qstr(emit, PYBC_DELETE_DEREF, qstr);
} }
void emit_delete_attr(emitter_t *emit, qstr qstr) { static void emit_bc_delete_attr(emit_t *emit, qstr qstr) {
emit_pre(emit, -1); emit_pre(emit, -1);
emit_write_byte_1_qstr(emit, PYBC_DELETE_ATTR, qstr); emit_write_byte_1_qstr(emit, PYBC_DELETE_ATTR, qstr);
} }
void emit_delete_subscr(emitter_t *emit) { static void emit_bc_delete_subscr(emit_t *emit) {
emit_pre(emit, -2); emit_pre(emit, -2);
emit_write_byte_1(emit, PYBC_DELETE_SUBSCR); emit_write_byte_1(emit, PYBC_DELETE_SUBSCR);
} }
void emit_dup_top(emitter_t *emit) { static void emit_bc_dup_top(emit_t *emit) {
emit_pre(emit, 1); emit_pre(emit, 1);
emit_write_byte_1(emit, PYBC_DUP_TOP); emit_write_byte_1(emit, PYBC_DUP_TOP);
} }
void emit_dup_top_two(emitter_t *emit) { static void emit_bc_dup_top_two(emit_t *emit) {
emit_pre(emit, 2); emit_pre(emit, 2);
emit_write_byte_1(emit, PYBC_DUP_TOP_TWO); emit_write_byte_1(emit, PYBC_DUP_TOP_TWO);
} }
void emit_pop_top(emitter_t *emit) { static void emit_bc_pop_top(emit_t *emit) {
emit_pre(emit, -1); emit_pre(emit, -1);
emit_write_byte_1(emit, PYBC_POP_TOP); emit_write_byte_1(emit, PYBC_POP_TOP);
} }
void emit_rot_two(emitter_t *emit) { static void emit_bc_rot_two(emit_t *emit) {
emit_pre(emit, 0); emit_pre(emit, 0);
emit_write_byte_1(emit, PYBC_ROT_TWO); emit_write_byte_1(emit, PYBC_ROT_TWO);
} }
void emit_rot_three(emitter_t *emit) { static void emit_bc_rot_three(emit_t *emit) {
emit_pre(emit, 0); emit_pre(emit, 0);
emit_write_byte_1(emit, PYBC_ROT_THREE); emit_write_byte_1(emit, PYBC_ROT_THREE);
} }
void emit_jump(emitter_t *emit, int label) { static void emit_bc_jump(emit_t *emit, int label) {
emit_pre(emit, 0); emit_pre(emit, 0);
emit_write_byte_1_label(emit, PYBC_JUMP, label); emit_write_byte_1_label(emit, PYBC_JUMP, label);
} }
void emit_pop_jump_if_true(emitter_t *emit, int label) { static void emit_bc_pop_jump_if_true(emit_t *emit, int label) {
emit_pre(emit, -1); emit_pre(emit, -1);
emit_write_byte_1_label(emit, PYBC_POP_JUMP_IF_TRUE, label); emit_write_byte_1_label(emit, PYBC_POP_JUMP_IF_TRUE, label);
} }
void emit_pop_jump_if_false(emitter_t *emit, int label) { static void emit_bc_pop_jump_if_false(emit_t *emit, int label) {
emit_pre(emit, -1); emit_pre(emit, -1);
emit_write_byte_1_label(emit, PYBC_POP_JUMP_IF_FALSE, label); emit_write_byte_1_label(emit, PYBC_POP_JUMP_IF_FALSE, label);
} }
void emit_jump_if_true_or_pop(emitter_t *emit, int label) { static void emit_bc_jump_if_true_or_pop(emit_t *emit, int label) {
emit_pre(emit, -1); emit_pre(emit, -1);
emit_write_byte_1_label(emit, PYBC_JUMP_IF_TRUE_OR_POP, label); emit_write_byte_1_label(emit, PYBC_JUMP_IF_TRUE_OR_POP, label);
} }
void emit_jump_if_false_or_pop(emitter_t *emit, int label) { static void emit_bc_jump_if_false_or_pop(emit_t *emit, int label) {
emit_pre(emit, -1); emit_pre(emit, -1);
emit_write_byte_1_label(emit, PYBC_JUMP_IF_FALSE_OR_POP, label); emit_write_byte_1_label(emit, PYBC_JUMP_IF_FALSE_OR_POP, label);
} }
void emit_setup_loop(emitter_t *emit, int label) { static void emit_bc_setup_loop(emit_t *emit, int label) {
emit_pre(emit, 0); emit_pre(emit, 0);
emit_write_byte_1_label(emit, PYBC_SETUP_LOOP, label); emit_write_byte_1_label(emit, PYBC_SETUP_LOOP, label);
} }
void emit_break_loop(emitter_t *emit, int label) { static void emit_bc_break_loop(emit_t *emit, int label) {
emit_pre(emit, 0); emit_pre(emit, 0);
emit_write_byte_1_label(emit, PYBC_BREAK_LOOP, label); emit_write_byte_1_label(emit, PYBC_BREAK_LOOP, label);
} }
void emit_continue_loop(emitter_t *emit, int label) { static void emit_bc_continue_loop(emit_t *emit, int label) {
emit_pre(emit, 0); emit_pre(emit, 0);
emit_write_byte_1_label(emit, PYBC_CONTINUE_LOOP, label); emit_write_byte_1_label(emit, PYBC_CONTINUE_LOOP, label);
} }
void emit_setup_with(emitter_t *emit, int label) { static void emit_bc_setup_with(emit_t *emit, int label) {
emit_pre(emit, 7); emit_pre(emit, 7);
emit_write_byte_1_label(emit, PYBC_SETUP_WITH, label); emit_write_byte_1_label(emit, PYBC_SETUP_WITH, label);
} }
void emit_with_cleanup(emitter_t *emit) { static void emit_bc_with_cleanup(emit_t *emit) {
emit_pre(emit, -7); emit_pre(emit, -7);
emit_write_byte_1(emit, PYBC_WITH_CLEANUP); emit_write_byte_1(emit, PYBC_WITH_CLEANUP);
} }
void emit_setup_except(emitter_t *emit, int label) { static void emit_bc_setup_except(emit_t *emit, int label) {
emit_pre(emit, 6); emit_pre(emit, 6);
emit_write_byte_1_label(emit, PYBC_SETUP_EXCEPT, label); emit_write_byte_1_label(emit, PYBC_SETUP_EXCEPT, label);
} }
void emit_setup_finally(emitter_t *emit, int label) { static void emit_bc_setup_finally(emit_t *emit, int label) {
emit_pre(emit, 6); emit_pre(emit, 6);
emit_write_byte_1_label(emit, PYBC_SETUP_FINALLY, label); emit_write_byte_1_label(emit, PYBC_SETUP_FINALLY, label);
} }
void emit_end_finally(emitter_t *emit) { static void emit_bc_end_finally(emit_t *emit) {
emit_pre(emit, -1); emit_pre(emit, -1);
emit_write_byte_1(emit, PYBC_END_FINALLY); emit_write_byte_1(emit, PYBC_END_FINALLY);
} }
void emit_get_iter(emitter_t *emit) { static void emit_bc_get_iter(emit_t *emit) {
emit_pre(emit, 0); emit_pre(emit, 0);
emit_write_byte_1(emit, PYBC_GET_ITER); emit_write_byte_1(emit, PYBC_GET_ITER);
} }
void emit_for_iter(emitter_t *emit, int label) { static void emit_bc_for_iter(emit_t *emit, int label) {
emit_pre(emit, 1); emit_pre(emit, 1);
emit_write_byte_1_label(emit, PYBC_FOR_ITER, label); emit_write_byte_1_label(emit, PYBC_FOR_ITER, label);
} }
void emit_for_iter_end(emitter_t *emit) { static void emit_bc_for_iter_end(emit_t *emit) {
emit_pre(emit, -1); emit_pre(emit, -1);
} }
void emit_pop_block(emitter_t *emit) { static void emit_bc_pop_block(emit_t *emit) {
emit_pre(emit, 0); emit_pre(emit, 0);
emit_write_byte_1(emit, PYBC_POP_BLOCK); emit_write_byte_1(emit, PYBC_POP_BLOCK);
} }
void emit_pop_except(emitter_t *emit) { static void emit_bc_pop_except(emit_t *emit) {
emit_pre(emit, 0); emit_pre(emit, 0);
emit_write_byte_1(emit, PYBC_POP_EXCEPT); emit_write_byte_1(emit, PYBC_POP_EXCEPT);
} }
void emit_unary_op(emitter_t *emit, rt_unary_op_t op) { static void emit_bc_unary_op(emit_t *emit, rt_unary_op_t op) {
emit_pre(emit, 0); emit_pre(emit, 0);
emit_write_byte_1_byte(emit, PYBC_UNARY_OP, op); emit_write_byte_1_byte(emit, PYBC_UNARY_OP, op);
} }
void emit_binary_op(emitter_t *emit, rt_binary_op_t op) { static void emit_bc_binary_op(emit_t *emit, rt_binary_op_t op) {
emit_pre(emit, -1); emit_pre(emit, -1);
emit_write_byte_1_byte(emit, PYBC_BINARY_OP, op); emit_write_byte_1_byte(emit, PYBC_BINARY_OP, op);
} }
void emit_compare_op(emitter_t *emit, rt_compare_op_t op) { static void emit_bc_compare_op(emit_t *emit, rt_compare_op_t op) {
emit_pre(emit, -1); emit_pre(emit, -1);
emit_write_byte_1_byte(emit, PYBC_COMPARE_OP, op); emit_write_byte_1_byte(emit, PYBC_COMPARE_OP, op);
} }
void emit_build_tuple(emitter_t *emit, int n_args) { static void emit_bc_build_tuple(emit_t *emit, int n_args) {
assert(n_args >= 0); assert(n_args >= 0);
emit_pre(emit, 1 - n_args); emit_pre(emit, 1 - n_args);
emit_write_byte_1_uint(emit, PYBC_BUILD_TUPLE, n_args); emit_write_byte_1_uint(emit, PYBC_BUILD_TUPLE, n_args);
} }
void emit_build_list(emitter_t *emit, int n_args) { static void emit_bc_build_list(emit_t *emit, int n_args) {
assert(n_args >= 0); assert(n_args >= 0);
emit_pre(emit, 1 - n_args); emit_pre(emit, 1 - n_args);
emit_write_byte_1_uint(emit, PYBC_BUILD_LIST, n_args); emit_write_byte_1_uint(emit, PYBC_BUILD_LIST, n_args);
} }
void emit_list_append(emitter_t *emit, int list_stack_index) { static void emit_bc_list_append(emit_t *emit, int list_stack_index) {
assert(list_stack_index >= 0); assert(list_stack_index >= 0);
emit_pre(emit, -1); emit_pre(emit, -1);
emit_write_byte_1_uint(emit, PYBC_LIST_APPEND, list_stack_index); emit_write_byte_1_uint(emit, PYBC_LIST_APPEND, list_stack_index);
} }
void emit_build_map(emitter_t *emit, int n_args) { static void emit_bc_build_map(emit_t *emit, int n_args) {
assert(n_args >= 0); assert(n_args >= 0);
emit_pre(emit, 1); emit_pre(emit, 1);
emit_write_byte_1_uint(emit, PYBC_BUILD_MAP, n_args); emit_write_byte_1_uint(emit, PYBC_BUILD_MAP, n_args);
} }
void emit_store_map(emitter_t *emit) { static void emit_bc_store_map(emit_t *emit) {
emit_pre(emit, -2); emit_pre(emit, -2);
emit_write_byte_1(emit, PYBC_STORE_MAP); emit_write_byte_1(emit, PYBC_STORE_MAP);
} }
void emit_map_add(emitter_t *emit, int map_stack_index) { static void emit_bc_map_add(emit_t *emit, int map_stack_index) {
assert(map_stack_index >= 0); assert(map_stack_index >= 0);
emit_pre(emit, -2); emit_pre(emit, -2);
emit_write_byte_1_uint(emit, PYBC_MAP_ADD, map_stack_index); emit_write_byte_1_uint(emit, PYBC_MAP_ADD, map_stack_index);
} }
void emit_build_set(emitter_t *emit, int n_args) { static void emit_bc_build_set(emit_t *emit, int n_args) {
assert(n_args >= 0); assert(n_args >= 0);
emit_pre(emit, 1 - n_args); emit_pre(emit, 1 - n_args);
emit_write_byte_1_uint(emit, PYBC_BUILD_SET, n_args); emit_write_byte_1_uint(emit, PYBC_BUILD_SET, n_args);
} }
void emit_set_add(emitter_t *emit, int set_stack_index) { static void emit_bc_set_add(emit_t *emit, int set_stack_index) {
assert(set_stack_index >= 0); assert(set_stack_index >= 0);
emit_pre(emit, -1); emit_pre(emit, -1);
emit_write_byte_1_uint(emit, PYBC_SET_ADD, set_stack_index); emit_write_byte_1_uint(emit, PYBC_SET_ADD, set_stack_index);
} }
void emit_build_slice(emitter_t *emit, int n_args) { static void emit_bc_build_slice(emit_t *emit, int n_args) {
assert(n_args >= 0); assert(n_args >= 0);
emit_pre(emit, 1 - n_args); emit_pre(emit, 1 - n_args);
emit_write_byte_1_uint(emit, PYBC_BUILD_SLICE, n_args); emit_write_byte_1_uint(emit, PYBC_BUILD_SLICE, n_args);
} }
void emit_unpack_sequence(emitter_t *emit, int n_args) { static void emit_bc_unpack_sequence(emit_t *emit, int n_args) {
assert(n_args >= 0); assert(n_args >= 0);
emit_pre(emit, -1 + n_args); emit_pre(emit, -1 + n_args);
emit_write_byte_1_uint(emit, PYBC_UNPACK_SEQUENCE, n_args); emit_write_byte_1_uint(emit, PYBC_UNPACK_SEQUENCE, n_args);
} }
void emit_unpack_ex(emitter_t *emit, int n_left, int n_right) { static void emit_bc_unpack_ex(emit_t *emit, int n_left, int n_right) {
assert(n_left >=0 && n_right >= 0); assert(n_left >=0 && n_right >= 0);
emit_pre(emit, -1 + n_left + n_right + 1); emit_pre(emit, -1 + n_left + n_right + 1);
emit_write_byte_1_uint(emit, PYBC_UNPACK_EX, n_left | (n_right << 8)); emit_write_byte_1_uint(emit, PYBC_UNPACK_EX, n_left | (n_right << 8));
} }
void emit_make_function(emitter_t *emit, scope_t *scope, int n_dict_params, int n_default_params) { static void emit_bc_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, 1); emit_pre(emit, 1);
emit_write_byte_1_uint(emit, PYBC_MAKE_FUNCTION, scope->unique_code_id); emit_write_byte_1_uint(emit, PYBC_MAKE_FUNCTION, scope->unique_code_id);
} }
void emit_make_closure(emitter_t *emit, scope_t *scope, int n_dict_params, int n_default_params) { static void emit_bc_make_closure(emit_t *emit, scope_t *scope, int n_dict_params, int n_default_params) {
assert(0); assert(0);
emit_pre(emit, -2 - n_default_params - 2 * n_dict_params); emit_pre(emit, -2 - n_default_params - 2 * n_dict_params);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
@ -609,7 +600,7 @@ void emit_make_closure(emitter_t *emit, scope_t *scope, int n_dict_params, int n
} }
} }
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_bc_call_function(emit_t *emit, int n_positional, int n_keyword, bool have_star_arg, bool have_dbl_star_arg) {
int s = 0; int s = 0;
if (have_star_arg) { if (have_star_arg) {
s += 1; s += 1;
@ -635,7 +626,7 @@ void emit_call_function(emitter_t *emit, int n_positional, int n_keyword, bool h
emit_write_byte_1_uint(emit, op, (n_keyword << 8) | n_positional); // TODO make it 2 separate uints emit_write_byte_1_uint(emit, op, (n_keyword << 8) | n_positional); // TODO make it 2 separate uints
} }
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_bc_call_method(emit_t *emit, int n_positional, int n_keyword, bool have_star_arg, bool have_dbl_star_arg) {
int s = 0; int s = 0;
if (have_star_arg) { if (have_star_arg) {
s += 1; s += 1;
@ -661,19 +652,19 @@ void emit_call_method(emitter_t *emit, int n_positional, int n_keyword, bool hav
emit_write_byte_1_uint(emit, op, (n_keyword << 8) | n_positional); // TODO make it 2 separate uints emit_write_byte_1_uint(emit, op, (n_keyword << 8) | n_positional); // TODO make it 2 separate uints
} }
void emit_return_value(emitter_t *emit) { static void emit_bc_return_value(emit_t *emit) {
emit_pre(emit, -1); emit_pre(emit, -1);
emit->last_emit_was_return_value = true; emit->last_emit_was_return_value = true;
emit_write_byte_1(emit, PYBC_RETURN_VALUE); emit_write_byte_1(emit, PYBC_RETURN_VALUE);
} }
void emit_raise_varargs(emitter_t *emit, int n_args) { static void emit_bc_raise_varargs(emit_t *emit, int n_args) {
assert(n_args >= 0); assert(n_args >= 0);
emit_pre(emit, -n_args); emit_pre(emit, -n_args);
emit_write_byte_1_uint(emit, PYBC_RAISE_VARARGS, n_args); emit_write_byte_1_uint(emit, PYBC_RAISE_VARARGS, n_args);
} }
void emit_yield_value(emitter_t *emit) { static void emit_bc_yield_value(emit_t *emit) {
emit_pre(emit, 0); emit_pre(emit, 0);
if (emit->pass == PASS_2) { if (emit->pass == PASS_2) {
emit->scope->flags |= SCOPE_FLAG_GENERATOR; emit->scope->flags |= SCOPE_FLAG_GENERATOR;
@ -681,7 +672,7 @@ void emit_yield_value(emitter_t *emit) {
emit_write_byte_1(emit, PYBC_YIELD_VALUE); emit_write_byte_1(emit, PYBC_YIELD_VALUE);
} }
void emit_yield_from(emitter_t *emit) { static void emit_bc_yield_from(emit_t *emit) {
emit_pre(emit, -1); emit_pre(emit, -1);
if (emit->pass == PASS_2) { if (emit->pass == PASS_2) {
emit->scope->flags |= SCOPE_FLAG_GENERATOR; emit->scope->flags |= SCOPE_FLAG_GENERATOR;
@ -689,4 +680,107 @@ void emit_yield_from(emitter_t *emit) {
emit_write_byte_1(emit, PYBC_YIELD_FROM); emit_write_byte_1(emit, PYBC_YIELD_FROM);
} }
#endif // EMIT_DO_BC static const emit_method_table_t emit_bc_method_table = {
emit_bc_set_native_types,
emit_bc_start_pass,
emit_bc_end_pass,
emit_bc_last_emit_was_return_value,
emit_bc_get_stack_size,
emit_bc_set_stack_size,
emit_bc_label_new,
emit_bc_label_assign,
emit_bc_import_name,
emit_bc_import_from,
emit_bc_import_star,
emit_bc_load_const_tok,
emit_bc_load_const_small_int,
emit_bc_load_const_int,
emit_bc_load_const_dec,
emit_bc_load_const_id,
emit_bc_load_const_str,
emit_bc_load_const_verbatim_start,
emit_bc_load_const_verbatim_int,
emit_bc_load_const_verbatim_str,
emit_bc_load_const_verbatim_strn,
emit_bc_load_const_verbatim_quoted_str,
emit_bc_load_const_verbatim_end,
emit_bc_load_fast,
emit_bc_load_name,
emit_bc_load_global,
emit_bc_load_deref,
emit_bc_load_closure,
emit_bc_load_attr,
emit_bc_load_method,
emit_bc_load_build_class,
emit_bc_store_fast,
emit_bc_store_name,
emit_bc_store_global,
emit_bc_store_deref,
emit_bc_store_attr,
emit_bc_store_locals,
emit_bc_store_subscr,
emit_bc_delete_fast,
emit_bc_delete_name,
emit_bc_delete_global,
emit_bc_delete_deref,
emit_bc_delete_attr,
emit_bc_delete_subscr,
emit_bc_dup_top,
emit_bc_dup_top_two,
emit_bc_pop_top,
emit_bc_rot_two,
emit_bc_rot_three,
emit_bc_jump,
emit_bc_pop_jump_if_true,
emit_bc_pop_jump_if_false,
emit_bc_jump_if_true_or_pop,
emit_bc_jump_if_false_or_pop,
emit_bc_setup_loop,
emit_bc_break_loop,
emit_bc_continue_loop,
emit_bc_setup_with,
emit_bc_with_cleanup,
emit_bc_setup_except,
emit_bc_setup_finally,
emit_bc_end_finally,
emit_bc_get_iter,
emit_bc_for_iter,
emit_bc_for_iter_end,
emit_bc_pop_block,
emit_bc_pop_except,
emit_bc_unary_op,
emit_bc_binary_op,
emit_bc_compare_op,
emit_bc_build_tuple,
emit_bc_build_list,
emit_bc_list_append,
emit_bc_build_map,
emit_bc_store_map,
emit_bc_map_add,
emit_bc_build_set,
emit_bc_set_add,
emit_bc_build_slice,
emit_bc_unpack_sequence,
emit_bc_unpack_ex,
emit_bc_make_function,
emit_bc_make_closure,
emit_bc_call_function,
emit_bc_call_method,
emit_bc_return_value,
emit_bc_raise_varargs,
emit_bc_yield_value,
emit_bc_yield_from,
};
void emit_new_bc(emit_t **emit_out, const emit_method_table_t **emit_method_table_out) {
emit_t *emit = m_new(emit_t, 1);
emit->max_num_labels = 0;
emit->label_offsets = NULL;
emit->code_offset = 0;
emit->code_size = 0;
emit->code_base = NULL;
*emit_out = emit;
*emit_method_table_out = &emit_bc_method_table;
}

58
py/emitcommon.c
View File

@ -12,53 +12,9 @@
#include "runtime.h" #include "runtime.h"
#include "emit.h" #include "emit.h"
#define EMIT(fun, arg...) (emit_##fun(emit, ##arg)) #define EMIT(fun, arg...) (emit_method_table->fun(emit, ##arg))
void emit_common_declare_global(pass_kind_t pass, scope_t *scope, qstr qstr) { void emit_common_load_id(pass_kind_t pass, scope_t *scope, emit_t *emit, const emit_method_table_t *emit_method_table, qstr qstr___class__, qstr qstr) {
if (pass == PASS_1) {
if (scope->kind == SCOPE_MODULE) {
printf("SyntaxError?: can't declare global in outer code\n");
return;
}
bool added;
id_info_t *id_info = scope_find_or_add_id(scope, qstr, &added);
if (!added) {
printf("SyntaxError?: identifier already declared something\n");
return;
}
id_info->kind = ID_INFO_KIND_GLOBAL_EXPLICIT;
// if the id exists in the global scope, set its kind to EXPLICIT_GLOBAL
id_info = scope_find_global(scope, qstr);
if (id_info != NULL) {
id_info->kind = ID_INFO_KIND_GLOBAL_EXPLICIT;
}
}
}
void emit_common_declare_nonlocal(pass_kind_t pass, scope_t *scope, qstr qstr) {
if (pass == PASS_1) {
if (scope->kind == SCOPE_MODULE) {
printf("SyntaxError?: can't declare nonlocal in outer code\n");
return;
}
bool added;
id_info_t *id_info = scope_find_or_add_id(scope, qstr, &added);
if (!added) {
printf("SyntaxError?: identifier already declared something\n");
return;
}
id_info_t *id_info2 = scope_find_local_in_parent(scope, qstr);
if (id_info2 == NULL || !(id_info2->kind == ID_INFO_KIND_LOCAL || id_info2->kind == ID_INFO_KIND_CELL || id_info2->kind == ID_INFO_KIND_FREE)) {
printf("SyntaxError: no binding for nonlocal '%s' found\n", qstr_str(qstr));
return;
}
id_info->kind = ID_INFO_KIND_FREE;
scope_close_over_in_parents(scope, qstr);
}
}
void emit_common_load_id(pass_kind_t pass, scope_t *scope, qstr qstr___class__, emitter_t *emit, qstr qstr) {
id_info_t *id_info = NULL; id_info_t *id_info = NULL;
if (pass == PASS_1) { if (pass == PASS_1) {
// name adding/lookup // name adding/lookup
@ -109,7 +65,7 @@ void emit_common_load_id(pass_kind_t pass, scope_t *scope, qstr qstr___class__,
} }
} }
static id_info_t *get_id_for_modification(pass_kind_t pass, scope_t *scope, emitter_t *emit, qstr qstr) { static id_info_t *get_id_for_modification(pass_kind_t pass, scope_t *scope, qstr qstr) {
id_info_t *id_info = NULL; id_info_t *id_info = NULL;
if (pass == PASS_1) { if (pass == PASS_1) {
// name adding/lookup // name adding/lookup
@ -134,9 +90,9 @@ static id_info_t *get_id_for_modification(pass_kind_t pass, scope_t *scope, emit
return id_info; return id_info;
} }
void emit_common_store_id(pass_kind_t pass, scope_t *scope, emitter_t *emit, qstr qstr) { void emit_common_store_id(pass_kind_t pass, scope_t *scope, emit_t *emit, const emit_method_table_t *emit_method_table, qstr qstr) {
// create/get the id info // create/get the id info
id_info_t *id = get_id_for_modification(pass, scope, emit, qstr); id_info_t *id = get_id_for_modification(pass, scope, qstr);
// call the emit backend with the correct code // call the emit backend with the correct code
if (id == NULL || id->kind == ID_INFO_KIND_GLOBAL_IMPLICIT) { if (id == NULL || id->kind == ID_INFO_KIND_GLOBAL_IMPLICIT) {
@ -152,9 +108,9 @@ void emit_common_store_id(pass_kind_t pass, scope_t *scope, emitter_t *emit, qst
} }
} }
void emit_common_delete_id(pass_kind_t pass, scope_t *scope, emitter_t *emit, qstr qstr) { void emit_common_delete_id(pass_kind_t pass, scope_t *scope, emit_t *emit, const emit_method_table_t *emit_method_table, qstr qstr) {
// create/get the id info // create/get the id info
id_info_t *id = get_id_for_modification(pass, scope, emit, qstr); id_info_t *id = get_id_for_modification(pass, scope, qstr);
// call the emit backend with the correct code // call the emit backend with the correct code
if (id == NULL || id->kind == ID_INFO_KIND_GLOBAL_IMPLICIT) { if (id == NULL || id->kind == ID_INFO_KIND_GLOBAL_IMPLICIT) {

305
py/emitcpy.c
View File

@ -14,9 +14,9 @@
#include "runtime.h" #include "runtime.h"
#include "emit.h" #include "emit.h"
#ifdef EMIT_DO_CPY #ifdef EMIT_ENABLE_CPY
struct _emitter_t { struct _emit_t {
int pass; int pass;
int next_label; int next_label;
int byte_code_offset; int byte_code_offset;
@ -29,14 +29,10 @@ struct _emitter_t {
int *label_offsets; int *label_offsets;
}; };
emitter_t *emit_new() { static void emit_cpy_set_native_types(emit_t *emit, bool do_native_types) {
emitter_t *emit = m_new(emitter_t, 1);
emit->max_num_labels = 0;
emit->label_offsets = NULL;
return emit;
} }
void emit_start_pass(emitter_t *emit, pass_kind_t pass, scope_t *scope) { static void emit_cpy_start_pass(emit_t *emit, pass_kind_t pass, scope_t *scope) {
emit->pass = pass; emit->pass = pass;
emit->next_label = 1; emit->next_label = 1;
emit->byte_code_offset = 0; emit->byte_code_offset = 0;
@ -53,7 +49,7 @@ void emit_start_pass(emitter_t *emit, pass_kind_t pass, scope_t *scope) {
} }
} }
void emit_end_pass(emitter_t *emit) { static void emit_cpy_end_pass(emit_t *emit) {
// check stack is back to zero size // check stack is back to zero size
if (emit->stack_size != 0) { if (emit->stack_size != 0) {
printf("ERROR: stack size not back to zero; got %d\n", emit->stack_size); printf("ERROR: stack size not back to zero; got %d\n", emit->stack_size);
@ -67,19 +63,19 @@ void emit_end_pass(emitter_t *emit) {
} }
} }
bool emit_last_emit_was_return_value(emitter_t *emit) { static bool emit_cpy_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_cpy_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_cpy_set_stack_size(emit_t *emit, int size) {
emit->stack_size = size; emit->stack_size = size;
} }
static void emit_pre(emitter_t *emit, int stack_size_delta, int byte_code_size) { static void emit_pre(emit_t *emit, int stack_size_delta, int byte_code_size) {
emit->stack_size += stack_size_delta; emit->stack_size += stack_size_delta;
if (emit->pass > PASS_1 && emit->stack_size > emit->scope->stack_size) { if (emit->pass > PASS_1 && emit->stack_size > emit->scope->stack_size) {
emit->scope->stack_size = emit->stack_size; emit->scope->stack_size = emit->stack_size;
@ -95,11 +91,11 @@ static void emit_pre(emitter_t *emit, int stack_size_delta, int byte_code_size)
emit->byte_code_offset += byte_code_size; emit->byte_code_offset += byte_code_size;
} }
int emit_label_new(emitter_t *emit) { static int emit_cpy_label_new(emit_t *emit) {
return emit->next_label++; return emit->next_label++;
} }
void emit_label_assign(emitter_t *emit, int l) { static void emit_cpy_label_assign(emit_t *emit, int l) {
emit_pre(emit, 0, 0); emit_pre(emit, 0, 0);
if (emit->pass > PASS_1) { if (emit->pass > PASS_1) {
assert(l < emit->max_num_labels); assert(l < emit->max_num_labels);
@ -115,28 +111,28 @@ void emit_label_assign(emitter_t *emit, int l) {
} }
} }
void emit_import_name(emitter_t *emit, qstr qstr) { static void emit_cpy_import_name(emit_t *emit, qstr qstr) {
emit_pre(emit, -1, 3); emit_pre(emit, -1, 3);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("IMPORT_NAME %s\n", qstr_str(qstr)); printf("IMPORT_NAME %s\n", qstr_str(qstr));
} }
} }
void emit_import_from(emitter_t *emit, qstr qstr) { static void emit_cpy_import_from(emit_t *emit, qstr qstr) {
emit_pre(emit, 1, 3); emit_pre(emit, 1, 3);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("IMPORT_FROM %s\n", qstr_str(qstr)); printf("IMPORT_FROM %s\n", qstr_str(qstr));
} }
} }
void emit_import_star(emitter_t *emit) { static void emit_cpy_import_star(emit_t *emit) {
emit_pre(emit, -1, 1); emit_pre(emit, -1, 1);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("IMPORT_STAR\n"); printf("IMPORT_STAR\n");
} }
} }
void emit_load_const_tok(emitter_t *emit, py_token_kind_t tok) { static void emit_cpy_load_const_tok(emit_t *emit, py_token_kind_t tok) {
emit_pre(emit, 1, 3); emit_pre(emit, 1, 3);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("LOAD_CONST "); printf("LOAD_CONST ");
@ -150,69 +146,70 @@ void emit_load_const_tok(emitter_t *emit, py_token_kind_t tok) {
} }
} }
void emit_load_const_small_int(emitter_t *emit, int arg) { static void emit_cpy_load_const_small_int(emit_t *emit, int arg) {
emit_pre(emit, 1, 3); emit_pre(emit, 1, 3);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("LOAD_CONST %d\n", arg); printf("LOAD_CONST %d\n", arg);
} }
} }
void emit_load_const_int(emitter_t *emit, qstr qstr) { static void emit_cpy_load_const_int(emit_t *emit, qstr qstr) {
emit_pre(emit, 1, 3); emit_pre(emit, 1, 3);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("LOAD_CONST %s\n", qstr_str(qstr)); printf("LOAD_CONST %s\n", qstr_str(qstr));
} }
} }
void emit_load_const_dec(emitter_t *emit, qstr qstr) { static void emit_cpy_load_const_dec(emit_t *emit, qstr qstr) {
emit_pre(emit, 1, 3); emit_pre(emit, 1, 3);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("LOAD_CONST %s\n", qstr_str(qstr)); printf("LOAD_CONST %s\n", qstr_str(qstr));
} }
} }
void emit_load_const_id(emitter_t *emit, qstr qstr) { static void emit_cpy_load_const_id(emit_t *emit, qstr qstr) {
emit_pre(emit, 1, 3); emit_pre(emit, 1, 3);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("LOAD_CONST '%s'\n", qstr_str(qstr)); printf("LOAD_CONST '%s'\n", qstr_str(qstr));
} }
} }
void emit_load_const_str(emitter_t *emit, qstr qstr, bool bytes) { static void emit_cpy_load_const_verbatim_quoted_str(emit_t *emit, qstr qstr, bool bytes);
static void emit_cpy_load_const_str(emit_t *emit, qstr qstr, bool bytes) {
emit_pre(emit, 1, 3); emit_pre(emit, 1, 3);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("LOAD_CONST "); printf("LOAD_CONST ");
emit_load_const_verbatim_quoted_str(emit, qstr, bytes); emit_cpy_load_const_verbatim_quoted_str(emit, qstr, bytes);
printf("\n"); printf("\n");
} }
} }
void emit_load_const_verbatim_start(emitter_t *emit) { static void emit_cpy_load_const_verbatim_start(emit_t *emit) {
emit_pre(emit, 1, 3); emit_pre(emit, 1, 3);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("LOAD_CONST "); printf("LOAD_CONST ");
} }
} }
void emit_load_const_verbatim_int(emitter_t *emit, int val) { static void emit_cpy_load_const_verbatim_int(emit_t *emit, int val) {
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("%d", val); printf("%d", val);
} }
} }
void emit_load_const_verbatim_str(emitter_t *emit, const char *str) { static void emit_cpy_load_const_verbatim_str(emit_t *emit, const char *str) {
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("%s", str); printf("%s", str);
} }
} }
void emit_load_const_verbatim_strn(emitter_t *emit, const char *str, int len) { static void emit_cpy_load_const_verbatim_strn(emit_t *emit, const char *str, int len) {
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("%.*s", len, str); printf("%.*s", len, str);
} }
} }
void emit_load_const_verbatim_quoted_str(emitter_t *emit, qstr qstr, bool bytes) { static void emit_cpy_load_const_verbatim_quoted_str(emit_t *emit, qstr qstr, bool bytes) {
// TODO strings should be escaped before we get here // TODO strings should be escaped before we get here
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
const char *str = qstr_str(qstr); const char *str = qstr_str(qstr);
@ -260,192 +257,192 @@ void emit_load_const_verbatim_quoted_str(emitter_t *emit, qstr qstr, bool bytes)
} }
} }
void emit_load_const_verbatim_end(emitter_t *emit) { static void emit_cpy_load_const_verbatim_end(emit_t *emit) {
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("\n"); printf("\n");
} }
} }
void emit_load_name(emitter_t *emit, qstr qstr) { static void emit_cpy_load_name(emit_t *emit, qstr qstr) {
emit_pre(emit, 1, 3); emit_pre(emit, 1, 3);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("LOAD_NAME %s\n", qstr_str(qstr)); printf("LOAD_NAME %s\n", qstr_str(qstr));
} }
} }
void emit_load_global(emitter_t *emit, qstr qstr) { static void emit_cpy_load_global(emit_t *emit, qstr qstr) {
emit_pre(emit, 1, 3); emit_pre(emit, 1, 3);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("LOAD_GLOBAL %s\n", qstr_str(qstr)); printf("LOAD_GLOBAL %s\n", qstr_str(qstr));
} }
} }
void emit_load_fast(emitter_t *emit, qstr qstr, int local_num) { static void emit_cpy_load_fast(emit_t *emit, qstr qstr, int local_num) {
emit_pre(emit, 1, 3); emit_pre(emit, 1, 3);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("LOAD_FAST %s\n", qstr_str(qstr)); printf("LOAD_FAST %s\n", qstr_str(qstr));
} }
} }
void emit_load_deref(emitter_t *emit, qstr qstr) { static void emit_cpy_load_deref(emit_t *emit, qstr qstr) {
emit_pre(emit, 1, 3); emit_pre(emit, 1, 3);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("LOAD_DEREF %s\n", qstr_str(qstr)); printf("LOAD_DEREF %s\n", qstr_str(qstr));
} }
} }
void emit_load_closure(emitter_t *emit, qstr qstr) { static void emit_cpy_load_closure(emit_t *emit, qstr qstr) {
emit_pre(emit, 1, 3); emit_pre(emit, 1, 3);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("LOAD_CLOSURE %s\n", qstr_str(qstr)); printf("LOAD_CLOSURE %s\n", qstr_str(qstr));
} }
} }
void emit_load_attr(emitter_t *emit, qstr qstr) { static void emit_cpy_load_attr(emit_t *emit, qstr qstr) {
emit_pre(emit, 0, 3); emit_pre(emit, 0, 3);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("LOAD_ATTR %s\n", qstr_str(qstr)); printf("LOAD_ATTR %s\n", qstr_str(qstr));
} }
} }
void emit_load_method(emitter_t *emit, qstr qstr) { static void emit_cpy_load_method(emit_t *emit, qstr qstr) {
emit_load_attr(emit, qstr); emit_cpy_load_attr(emit, qstr);
} }
void emit_load_build_class(emitter_t *emit) { static void emit_cpy_load_build_class(emit_t *emit) {
emit_pre(emit, 1, 1); emit_pre(emit, 1, 1);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("LOAD_BUILD_CLASS\n"); printf("LOAD_BUILD_CLASS\n");
} }
} }
void emit_store_name(emitter_t *emit, qstr qstr) { static void emit_cpy_store_name(emit_t *emit, qstr qstr) {
emit_pre(emit, -1, 3); emit_pre(emit, -1, 3);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("STORE_NAME %s\n", qstr_str(qstr)); printf("STORE_NAME %s\n", qstr_str(qstr));
} }
} }
void emit_store_global(emitter_t *emit, qstr qstr) { static void emit_cpy_store_global(emit_t *emit, qstr qstr) {
emit_pre(emit, -1, 3); emit_pre(emit, -1, 3);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("STORE_GLOBAL %s\n", qstr_str(qstr)); printf("STORE_GLOBAL %s\n", qstr_str(qstr));
} }
} }
void emit_store_fast(emitter_t *emit, qstr qstr, int local_num) { static void emit_cpy_store_fast(emit_t *emit, qstr qstr, int local_num) {
emit_pre(emit, -1, 3); emit_pre(emit, -1, 3);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("STORE_FAST %s\n", qstr_str(qstr)); printf("STORE_FAST %s\n", qstr_str(qstr));
} }
} }
void emit_store_deref(emitter_t *emit, qstr qstr) { static void emit_cpy_store_deref(emit_t *emit, qstr qstr) {
emit_pre(emit, -1, 3); emit_pre(emit, -1, 3);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("STORE_DEREF %s\n", qstr_str(qstr)); printf("STORE_DEREF %s\n", qstr_str(qstr));
} }
} }
void emit_store_attr(emitter_t *emit, qstr qstr) { static void emit_cpy_store_attr(emit_t *emit, qstr qstr) {
emit_pre(emit, -2, 3); emit_pre(emit, -2, 3);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("STORE_ATTR %s\n", qstr_str(qstr)); printf("STORE_ATTR %s\n", qstr_str(qstr));
} }
} }
void emit_store_locals(emitter_t *emit) { static void emit_cpy_store_locals(emit_t *emit) {
emit_pre(emit, -1, 1); emit_pre(emit, -1, 1);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("STORE_LOCALS\n"); printf("STORE_LOCALS\n");
} }
} }
void emit_store_subscr(emitter_t *emit) { static void emit_cpy_store_subscr(emit_t *emit) {
emit_pre(emit, -3, 1); emit_pre(emit, -3, 1);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("STORE_SUBSCR\n"); printf("STORE_SUBSCR\n");
} }
} }
void emit_delete_name(emitter_t *emit, qstr qstr) { static void emit_cpy_delete_name(emit_t *emit, qstr qstr) {
emit_pre(emit, 0, 3); emit_pre(emit, 0, 3);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("DELETE_NAME %s\n", qstr_str(qstr)); printf("DELETE_NAME %s\n", qstr_str(qstr));
} }
} }
void emit_delete_global(emitter_t *emit, qstr qstr) { static void emit_cpy_delete_global(emit_t *emit, qstr qstr) {
emit_pre(emit, 0, 3); emit_pre(emit, 0, 3);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("DELETE_GLOBAL %s\n", qstr_str(qstr)); printf("DELETE_GLOBAL %s\n", qstr_str(qstr));
} }
} }
void emit_delete_fast(emitter_t *emit, qstr qstr, int local_num) { static void emit_cpy_delete_fast(emit_t *emit, qstr qstr, int local_num) {
emit_pre(emit, 0, 3); emit_pre(emit, 0, 3);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("DELETE_FAST %s\n", qstr_str(qstr)); printf("DELETE_FAST %s\n", qstr_str(qstr));
} }
} }
void emit_delete_deref(emitter_t *emit, qstr qstr) { static void emit_cpy_delete_deref(emit_t *emit, qstr qstr) {
emit_pre(emit, 0, 3); emit_pre(emit, 0, 3);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("DELETE_DEREF %s\n", qstr_str(qstr)); printf("DELETE_DEREF %s\n", qstr_str(qstr));
} }
} }
void emit_delete_attr(emitter_t *emit, qstr qstr) { static void emit_cpy_delete_attr(emit_t *emit, qstr qstr) {
emit_pre(emit, -1, 3); emit_pre(emit, -1, 3);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("DELETE_ATTR %s\n", qstr_str(qstr)); printf("DELETE_ATTR %s\n", qstr_str(qstr));
} }
} }
void emit_delete_subscr(emitter_t *emit) { static void emit_cpy_delete_subscr(emit_t *emit) {
emit_pre(emit, -2, 1); emit_pre(emit, -2, 1);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("DELETE_SUBSCR\n"); printf("DELETE_SUBSCR\n");
} }
} }
void emit_dup_top(emitter_t *emit) { static void emit_cpy_dup_top(emit_t *emit) {
emit_pre(emit, 1, 1); emit_pre(emit, 1, 1);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("DUP_TOP\n"); printf("DUP_TOP\n");
} }
} }
void emit_dup_top_two(emitter_t *emit) { static void emit_cpy_dup_top_two(emit_t *emit) {
emit_pre(emit, 2, 1); emit_pre(emit, 2, 1);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("DUP_TOP_TWO\n"); printf("DUP_TOP_TWO\n");
} }
} }
void emit_pop_top(emitter_t *emit) { static void emit_cpy_pop_top(emit_t *emit) {
emit_pre(emit, -1, 1); emit_pre(emit, -1, 1);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("POP_TOP\n"); printf("POP_TOP\n");
} }
} }
void emit_rot_two(emitter_t *emit) { static void emit_cpy_rot_two(emit_t *emit) {
emit_pre(emit, 0, 1); emit_pre(emit, 0, 1);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("ROT_TWO\n"); printf("ROT_TWO\n");
} }
} }
void emit_rot_three(emitter_t *emit) { static void emit_cpy_rot_three(emit_t *emit) {
emit_pre(emit, 0, 1); emit_pre(emit, 0, 1);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("ROT_THREE\n"); printf("ROT_THREE\n");
} }
} }
void emit_jump(emitter_t *emit, int label) { static void emit_cpy_jump(emit_t *emit, int label) {
emit_pre(emit, 0, 3); emit_pre(emit, 0, 3);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
int dest = emit->label_offsets[label]; int dest = emit->label_offsets[label];
@ -457,42 +454,42 @@ void emit_jump(emitter_t *emit, int label) {
} }
} }
void emit_pop_jump_if_true(emitter_t *emit, int label) { static void emit_cpy_pop_jump_if_true(emit_t *emit, int label) {
emit_pre(emit, -1, 3); emit_pre(emit, -1, 3);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("POP_JUMP_IF_TRUE %d\n", emit->label_offsets[label]); printf("POP_JUMP_IF_TRUE %d\n", emit->label_offsets[label]);
} }
} }
void emit_pop_jump_if_false(emitter_t *emit, int label) { static void emit_cpy_pop_jump_if_false(emit_t *emit, int label) {
emit_pre(emit, -1, 3); emit_pre(emit, -1, 3);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("POP_JUMP_IF_FALSE %d\n", emit->label_offsets[label]); printf("POP_JUMP_IF_FALSE %d\n", emit->label_offsets[label]);
} }
} }
void emit_jump_if_true_or_pop(emitter_t *emit, int label) { static void emit_cpy_jump_if_true_or_pop(emit_t *emit, int label) {
emit_pre(emit, -1, 3); emit_pre(emit, -1, 3);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("JUMP_IF_TRUE_OR_POP %d\n", emit->label_offsets[label]); printf("JUMP_IF_TRUE_OR_POP %d\n", emit->label_offsets[label]);
} }
} }
void emit_jump_if_false_or_pop(emitter_t *emit, int label) { static void emit_cpy_jump_if_false_or_pop(emit_t *emit, int label) {
emit_pre(emit, -1, 3); emit_pre(emit, -1, 3);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("JUMP_IF_FALSE_OR_POP %d\n", emit->label_offsets[label]); printf("JUMP_IF_FALSE_OR_POP %d\n", emit->label_offsets[label]);
} }
} }
void emit_setup_loop(emitter_t *emit, int label) { static void emit_cpy_setup_loop(emit_t *emit, int label) {
emit_pre(emit, 0, 3); emit_pre(emit, 0, 3);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("SETUP_LOOP %d\n", emit->label_offsets[label]); printf("SETUP_LOOP %d\n", emit->label_offsets[label]);
} }
} }
void emit_break_loop(emitter_t *emit, int label) { static void emit_cpy_break_loop(emit_t *emit, int label) {
emit_pre(emit, 0, 1); emit_pre(emit, 0, 1);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("BREAK_LOOP\n"); // CPython doesn't have label printf("BREAK_LOOP\n"); // CPython doesn't have label
@ -500,81 +497,81 @@ void emit_break_loop(emitter_t *emit, int label) {
} }
} }
void emit_continue_loop(emitter_t *emit, int label) { static void emit_cpy_continue_loop(emit_t *emit, int label) {
emit_pre(emit, 0, 3); emit_pre(emit, 0, 3);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("CONTINUE_LOOP %d\n", emit->label_offsets[label]); printf("CONTINUE_LOOP %d\n", emit->label_offsets[label]);
} }
} }
void emit_setup_with(emitter_t *emit, int label) { static void emit_cpy_setup_with(emit_t *emit, int label) {
emit_pre(emit, 7, 3); emit_pre(emit, 7, 3);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("SETUP_WITH %d\n", emit->label_offsets[label]); printf("SETUP_WITH %d\n", emit->label_offsets[label]);
} }
} }
void emit_with_cleanup(emitter_t *emit) { static void emit_cpy_with_cleanup(emit_t *emit) {
emit_pre(emit, -7, 1); emit_pre(emit, -7, 1);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("WITH_CLEANUP\n"); printf("WITH_CLEANUP\n");
} }
} }
void emit_setup_except(emitter_t *emit, int label) { static void emit_cpy_setup_except(emit_t *emit, int label) {
emit_pre(emit, 6, 3); emit_pre(emit, 6, 3);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("SETUP_EXCEPT %d\n", emit->label_offsets[label]); printf("SETUP_EXCEPT %d\n", emit->label_offsets[label]);
} }
} }
void emit_setup_finally(emitter_t *emit, int label) { static void emit_cpy_setup_finally(emit_t *emit, int label) {
emit_pre(emit, 6, 3); emit_pre(emit, 6, 3);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("SETUP_FINALLY %d\n", emit->label_offsets[label]); printf("SETUP_FINALLY %d\n", emit->label_offsets[label]);
} }
} }
void emit_end_finally(emitter_t *emit) { static void emit_cpy_end_finally(emit_t *emit) {
emit_pre(emit, -1, 1); emit_pre(emit, -1, 1);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("END_FINALLY\n"); printf("END_FINALLY\n");
} }
} }
void emit_get_iter(emitter_t *emit) { static void emit_cpy_get_iter(emit_t *emit) {
emit_pre(emit, 0, 1); emit_pre(emit, 0, 1);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("GET_ITER\n"); printf("GET_ITER\n");
} }
} }
void emit_for_iter(emitter_t *emit, int label) { static void emit_cpy_for_iter(emit_t *emit, int label) {
emit_pre(emit, 1, 3); emit_pre(emit, 1, 3);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("FOR_ITER %d\n", emit->label_offsets[label]); printf("FOR_ITER %d\n", emit->label_offsets[label]);
} }
} }
void emit_for_iter_end(emitter_t *emit) { static void emit_cpy_for_iter_end(emit_t *emit) {
emit_pre(emit, -1, 0); emit_pre(emit, -1, 0);
} }
void emit_pop_block(emitter_t *emit) { static void emit_cpy_pop_block(emit_t *emit) {
emit_pre(emit, 0, 1); emit_pre(emit, 0, 1);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("POP_BLOCK\n"); printf("POP_BLOCK\n");
} }
} }
void emit_pop_except(emitter_t *emit) { static void emit_cpy_pop_except(emit_t *emit) {
emit_pre(emit, 0, 1); emit_pre(emit, 0, 1);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("POP_EXCEPT\n"); printf("POP_EXCEPT\n");
} }
} }
void emit_unary_op(emitter_t *emit, rt_unary_op_t op) { static void emit_cpy_unary_op(emit_t *emit, rt_unary_op_t op) {
emit_pre(emit, 0, 1); emit_pre(emit, 0, 1);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
switch (op) { switch (op) {
@ -587,7 +584,7 @@ void emit_unary_op(emitter_t *emit, rt_unary_op_t op) {
} }
} }
void emit_binary_op(emitter_t *emit, rt_binary_op_t op) { static void emit_cpy_binary_op(emit_t *emit, rt_binary_op_t op) {
emit_pre(emit, -1, 1); emit_pre(emit, -1, 1);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
switch (op) { switch (op) {
@ -621,7 +618,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_cpy_compare_op(emit_t *emit, rt_compare_op_t op) {
emit_pre(emit, -1, 3); emit_pre(emit, -1, 3);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
switch (op) { switch (op) {
@ -641,84 +638,84 @@ void emit_compare_op(emitter_t *emit, rt_compare_op_t op) {
} }
} }
void emit_build_tuple(emitter_t *emit, int n_args) { static void emit_cpy_build_tuple(emit_t *emit, int n_args) {
emit_pre(emit, 1 - n_args, 3); emit_pre(emit, 1 - n_args, 3);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("BUILD_TUPLE %d\n", n_args); printf("BUILD_TUPLE %d\n", n_args);
} }
} }
void emit_build_list(emitter_t *emit, int n_args) { static void emit_cpy_build_list(emit_t *emit, int n_args) {
emit_pre(emit, 1 - n_args, 3); emit_pre(emit, 1 - n_args, 3);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("BUILD_LIST %d\n", n_args); printf("BUILD_LIST %d\n", n_args);
} }
} }
void emit_list_append(emitter_t *emit, int list_index) { static void emit_cpy_list_append(emit_t *emit, int list_index) {
emit_pre(emit, -1, 3); emit_pre(emit, -1, 3);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("LIST_APPEND %d\n", list_index); printf("LIST_APPEND %d\n", list_index);
} }
} }
void emit_build_map(emitter_t *emit, int n_args) { static void emit_cpy_build_map(emit_t *emit, int n_args) {
emit_pre(emit, 1, 3); emit_pre(emit, 1, 3);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("BUILD_MAP %d\n", n_args); printf("BUILD_MAP %d\n", n_args);
} }
} }
void emit_store_map(emitter_t *emit) { static void emit_cpy_store_map(emit_t *emit) {
emit_pre(emit, -2, 1); emit_pre(emit, -2, 1);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("STORE_MAP\n"); printf("STORE_MAP\n");
} }
} }
void emit_map_add(emitter_t *emit, int map_index) { static void emit_cpy_map_add(emit_t *emit, int map_index) {
emit_pre(emit, -2, 3); emit_pre(emit, -2, 3);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("MAP_ADD %d\n", map_index); printf("MAP_ADD %d\n", map_index);
} }
} }
void emit_build_set(emitter_t *emit, int n_args) { static void emit_cpy_build_set(emit_t *emit, int n_args) {
emit_pre(emit, 1 - n_args, 3); emit_pre(emit, 1 - n_args, 3);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("BUILD_SET %d\n", n_args); printf("BUILD_SET %d\n", n_args);
} }
} }
void emit_set_add(emitter_t *emit, int set_index) { static void emit_cpy_set_add(emit_t *emit, int set_index) {
emit_pre(emit, -1, 3); emit_pre(emit, -1, 3);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("SET_ADD %d\n", set_index); printf("SET_ADD %d\n", set_index);
} }
} }
void emit_build_slice(emitter_t *emit, int n_args) { static void emit_cpy_build_slice(emit_t *emit, int n_args) {
emit_pre(emit, 1 - n_args, 3); emit_pre(emit, 1 - n_args, 3);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("BUILD_SLICE %d\n", n_args); printf("BUILD_SLICE %d\n", n_args);
} }
} }
void emit_unpack_sequence(emitter_t *emit, int n_args) { static void emit_cpy_unpack_sequence(emit_t *emit, int n_args) {
emit_pre(emit, -1 + n_args, 3); emit_pre(emit, -1 + n_args, 3);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("UNPACK_SEQUENCE %d\n", n_args); printf("UNPACK_SEQUENCE %d\n", n_args);
} }
} }
void emit_unpack_ex(emitter_t *emit, int n_left, int n_right) { static void emit_cpy_unpack_ex(emit_t *emit, int n_left, int n_right) {
emit_pre(emit, -1 + n_left + n_right + 1, 3); emit_pre(emit, -1 + n_left + n_right + 1, 3);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("UNPACK_EX %d\n", n_left | (n_right << 8)); printf("UNPACK_EX %d\n", n_left | (n_right << 8));
} }
} }
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_cpy_call_function(emit_t *emit, int n_positional, int n_keyword, bool have_star_arg, bool have_dbl_star_arg) {
int s = 0; int s = 0;
if (have_star_arg) { if (have_star_arg) {
s += 1; s += 1;
@ -745,11 +742,11 @@ void emit_call_function(emitter_t *emit, int n_positional, int n_keyword, bool h
} }
} }
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_cpy_call_method(emit_t *emit, int n_positional, int n_keyword, bool have_star_arg, bool have_dbl_star_arg) {
emit_call_function(emit, n_positional, n_keyword, have_star_arg, have_dbl_star_arg); emit_cpy_call_function(emit, n_positional, n_keyword, have_star_arg, have_dbl_star_arg);
} }
void emit_return_value(emitter_t *emit) { static void emit_cpy_return_value(emit_t *emit) {
emit_pre(emit, -1, 1); emit_pre(emit, -1, 1);
emit->last_emit_was_return_value = true; emit->last_emit_was_return_value = true;
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
@ -757,14 +754,14 @@ void emit_return_value(emitter_t *emit) {
} }
} }
void emit_raise_varargs(emitter_t *emit, int n_args) { static void emit_cpy_raise_varargs(emit_t *emit, int n_args) {
emit_pre(emit, -n_args, 3); emit_pre(emit, -n_args, 3);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("RAISE_VARARGS %d\n", n_args); printf("RAISE_VARARGS %d\n", n_args);
} }
} }
void load_const_code_and_name(emitter_t *emit, qstr qstr) { static void load_cpy_const_code_and_name(emit_t *emit, qstr qstr) {
emit_pre(emit, 1, 3); emit_pre(emit, 1, 3);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("LOAD_CONST code %s\n", qstr_str(qstr)); printf("LOAD_CONST code %s\n", qstr_str(qstr));
@ -795,23 +792,23 @@ void load_const_code_and_name(emitter_t *emit, qstr qstr) {
} }
} }
void emit_make_function(emitter_t *emit, scope_t *scope, int n_dict_params, int n_default_params) { static void emit_cpy_make_function(emit_t *emit, scope_t *scope, int n_dict_params, int n_default_params) {
load_const_code_and_name(emit, scope->simple_name); load_cpy_const_code_and_name(emit, scope->simple_name);
emit_pre(emit, -1 - n_default_params - 2 * n_dict_params, 3); emit_pre(emit, -1 - n_default_params - 2 * n_dict_params, 3);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("MAKE_FUNCTION %d\n", (n_dict_params << 8) | n_default_params); printf("MAKE_FUNCTION %d\n", (n_dict_params << 8) | n_default_params);
} }
} }
void emit_make_closure(emitter_t *emit, scope_t *scope, int n_dict_params, int n_default_params) { static void emit_cpy_make_closure(emit_t *emit, scope_t *scope, int n_dict_params, int n_default_params) {
load_const_code_and_name(emit, scope->simple_name); load_cpy_const_code_and_name(emit, scope->simple_name);
emit_pre(emit, -2 - n_default_params - 2 * n_dict_params, 3); emit_pre(emit, -2 - n_default_params - 2 * n_dict_params, 3);
if (emit->pass == PASS_3) { if (emit->pass == PASS_3) {
printf("MAKE_CLOSURE %d\n", (n_dict_params << 8) | n_default_params); printf("MAKE_CLOSURE %d\n", (n_dict_params << 8) | n_default_params);
} }
} }
void emit_yield_value(emitter_t *emit) { static void emit_cpy_yield_value(emit_t *emit) {
emit_pre(emit, 0, 1); emit_pre(emit, 0, 1);
if (emit->pass == PASS_2) { if (emit->pass == PASS_2) {
emit->scope->flags |= SCOPE_FLAG_GENERATOR; emit->scope->flags |= SCOPE_FLAG_GENERATOR;
@ -821,7 +818,7 @@ void emit_yield_value(emitter_t *emit) {
} }
} }
void emit_yield_from(emitter_t *emit) { static void emit_cpy_yield_from(emit_t *emit) {
emit_pre(emit, -1, 1); emit_pre(emit, -1, 1);
if (emit->pass == PASS_2) { if (emit->pass == PASS_2) {
emit->scope->flags |= SCOPE_FLAG_GENERATOR; emit->scope->flags |= SCOPE_FLAG_GENERATOR;
@ -831,4 +828,106 @@ void emit_yield_from(emitter_t *emit) {
} }
} }
#endif // EMIT_DO_CPY static const emit_method_table_t emit_cpy_method_table = {
emit_cpy_set_native_types,
emit_cpy_start_pass,
emit_cpy_end_pass,
emit_cpy_last_emit_was_return_value,
emit_cpy_get_stack_size,
emit_cpy_set_stack_size,
emit_cpy_label_new,
emit_cpy_label_assign,
emit_cpy_import_name,
emit_cpy_import_from,
emit_cpy_import_star,
emit_cpy_load_const_tok,
emit_cpy_load_const_small_int,
emit_cpy_load_const_int,
emit_cpy_load_const_dec,
emit_cpy_load_const_id,
emit_cpy_load_const_str,
emit_cpy_load_const_verbatim_start,
emit_cpy_load_const_verbatim_int,
emit_cpy_load_const_verbatim_str,
emit_cpy_load_const_verbatim_strn,
emit_cpy_load_const_verbatim_quoted_str,
emit_cpy_load_const_verbatim_end,
emit_cpy_load_fast,
emit_cpy_load_name,
emit_cpy_load_global,
emit_cpy_load_deref,
emit_cpy_load_closure,
emit_cpy_load_attr,
emit_cpy_load_method,
emit_cpy_load_build_class,
emit_cpy_store_fast,
emit_cpy_store_name,
emit_cpy_store_global,
emit_cpy_store_deref,
emit_cpy_store_attr,
emit_cpy_store_locals,
emit_cpy_store_subscr,
emit_cpy_delete_fast,
emit_cpy_delete_name,
emit_cpy_delete_global,
emit_cpy_delete_deref,
emit_cpy_delete_attr,
emit_cpy_delete_subscr,
emit_cpy_dup_top,
emit_cpy_dup_top_two,
emit_cpy_pop_top,
emit_cpy_rot_two,
emit_cpy_rot_three,
emit_cpy_jump,
emit_cpy_pop_jump_if_true,
emit_cpy_pop_jump_if_false,
emit_cpy_jump_if_true_or_pop,
emit_cpy_jump_if_false_or_pop,
emit_cpy_setup_loop,
emit_cpy_break_loop,
emit_cpy_continue_loop,
emit_cpy_setup_with,
emit_cpy_with_cleanup,
emit_cpy_setup_except,
emit_cpy_setup_finally,
emit_cpy_end_finally,
emit_cpy_get_iter,
emit_cpy_for_iter,
emit_cpy_for_iter_end,
emit_cpy_pop_block,
emit_cpy_pop_except,
emit_cpy_unary_op,
emit_cpy_binary_op,
emit_cpy_compare_op,
emit_cpy_build_tuple,
emit_cpy_build_list,
emit_cpy_list_append,
emit_cpy_build_map,
emit_cpy_store_map,
emit_cpy_map_add,
emit_cpy_build_set,
emit_cpy_set_add,
emit_cpy_build_slice,
emit_cpy_unpack_sequence,
emit_cpy_unpack_ex,
emit_cpy_make_function,
emit_cpy_make_closure,
emit_cpy_call_function,
emit_cpy_call_method,
emit_cpy_return_value,
emit_cpy_raise_varargs,
emit_cpy_yield_value,
emit_cpy_yield_from,
};
void emit_new_cpython(emit_t **emit_out, const emit_method_table_t **emit_method_table_out) {
emit_t *emit = m_new(emit_t, 1);
emit->max_num_labels = 0;
emit->label_offsets = NULL;
*emit_out = emit;
*emit_method_table_out = &emit_cpy_method_table;
}
#endif // EMIT_ENABLE_CPY

327
py/emitx64.c
View File

@ -27,7 +27,7 @@
#include "emit.h" #include "emit.h"
#include "asmx64.h" #include "asmx64.h"
#ifdef EMIT_DO_X64 #ifdef EMIT_ENABLE_X64
#define REG_LOCAL_1 (REG_RBX) #define REG_LOCAL_1 (REG_RBX)
#define REG_LOCAL_NUM (1) #define REG_LOCAL_NUM (1)
@ -38,7 +38,7 @@ typedef enum {
NEED_TO_PUSH_I64, NEED_TO_PUSH_I64,
} 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;
@ -53,18 +53,11 @@ struct _emitter_t {
bool do_native_types; bool do_native_types;
}; };
emitter_t *emit_new() { static void emit_x64_set_native_types(emit_t *emit, bool do_native_types) {
emitter_t *emit = m_new(emitter_t, 1);
emit->as = asm_x64_new();
emit->do_native_types = false;
return emit;
}
void emit_set_native_types(emitter_t *emit, bool do_native_types) {
emit->do_native_types = do_native_types; emit->do_native_types = do_native_types;
} }
void emit_start_pass(emitter_t *emit, pass_kind_t pass, scope_t *scope) { static void emit_x64_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;
@ -104,7 +97,7 @@ void emit_start_pass(emitter_t *emit, pass_kind_t pass, scope_t *scope) {
} }
} }
void emit_end_pass(emitter_t *emit) { static void emit_x64_end_pass(emit_t *emit) {
if (!emit->last_emit_was_return_value) { if (!emit->last_emit_was_return_value) {
asm_x64_exit(emit->as); asm_x64_exit(emit->as);
} }
@ -121,19 +114,19 @@ void emit_end_pass(emitter_t *emit) {
} }
} }
bool emit_last_emit_was_return_value(emitter_t *emit) { static bool emit_x64_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_x64_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_x64_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) {
@ -141,7 +134,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;
@ -160,17 +153,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_r64(emitter_t *emit, int r64) { static void emit_pre_pop_r64(emit_t *emit, int r64) {
switch (emit->need_to_push) { switch (emit->need_to_push) {
case NEED_TO_PUSH_NOTHING: case NEED_TO_PUSH_NOTHING:
asm_x64_mov_local_to_r64(emit->as, emit->stack_start + emit->stack_size - 1, r64); asm_x64_mov_local_to_r64(emit->as, emit->stack_start + emit->stack_size - 1, r64);
@ -192,47 +185,47 @@ static void emit_pre_pop_r64(emitter_t *emit, int r64) {
emit->need_to_push = NEED_TO_PUSH_NOTHING; emit->need_to_push = NEED_TO_PUSH_NOTHING;
} }
static void emit_pre_pop_r64_r64(emitter_t *emit, int r64a, int r64b) { static void emit_pre_pop_r64_r64(emit_t *emit, int r64a, int r64b) {
emit_pre_pop_r64(emit, r64a); emit_pre_pop_r64(emit, r64a);
asm_x64_mov_local_to_r64(emit->as, emit->stack_start + emit->stack_size - 1, r64b); asm_x64_mov_local_to_r64(emit->as, emit->stack_start + emit->stack_size - 1, r64b);
adjust_stack(emit, -1); adjust_stack(emit, -1);
} }
static void emit_pre_pop_r64_r64_r64(emitter_t *emit, int r64a, int r64b, int r64c) { static void emit_pre_pop_r64_r64_r64(emit_t *emit, int r64a, int r64b, int r64c) {
emit_pre_pop_r64(emit, r64a); emit_pre_pop_r64(emit, r64a);
asm_x64_mov_local_to_r64(emit->as, emit->stack_start + emit->stack_size - 1, r64b); asm_x64_mov_local_to_r64(emit->as, emit->stack_start + emit->stack_size - 1, r64b);
asm_x64_mov_local_to_r64(emit->as, emit->stack_start + emit->stack_size - 2, r64c); asm_x64_mov_local_to_r64(emit->as, emit->stack_start + emit->stack_size - 2, r64c);
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_r64(emitter_t *emit, int r64) { static void emit_post_push_r64(emit_t *emit, int r64) {
emit->need_to_push = NEED_TO_PUSH_R64; emit->need_to_push = NEED_TO_PUSH_R64;
emit->last_r64 = r64; emit->last_r64 = r64;
} }
static void emit_post_push_i64(emitter_t *emit, int64_t i64) { static void emit_post_push_i64(emit_t *emit, int64_t i64) {
emit->need_to_push = NEED_TO_PUSH_I64; emit->need_to_push = NEED_TO_PUSH_I64;
emit->last_i64 = i64; emit->last_i64 = i64;
} }
static void emit_post_push_r64_r64(emitter_t *emit, int r64a, int r64b) { static void emit_post_push_r64_r64(emit_t *emit, int r64a, int r64b) {
asm_x64_mov_r64_to_local(emit->as, r64a, emit->stack_start + emit->stack_size); asm_x64_mov_r64_to_local(emit->as, r64a, emit->stack_start + emit->stack_size);
emit->need_to_push = NEED_TO_PUSH_R64; emit->need_to_push = NEED_TO_PUSH_R64;
emit->last_r64 = r64b; emit->last_r64 = r64b;
adjust_stack(emit, 1); adjust_stack(emit, 1);
} }
static void emit_post_push_r64_r64_r64(emitter_t *emit, int r64a, int r64b, int r64c) { static void emit_post_push_r64_r64_r64(emit_t *emit, int r64a, int r64b, int r64c) {
asm_x64_mov_r64_to_local(emit->as, r64a, emit->stack_start + emit->stack_size); asm_x64_mov_r64_to_local(emit->as, r64a, emit->stack_start + emit->stack_size);
asm_x64_mov_r64_to_local(emit->as, r64b, emit->stack_start + emit->stack_size + 1); asm_x64_mov_r64_to_local(emit->as, r64b, emit->stack_start + emit->stack_size + 1);
asm_x64_mov_r64_to_local(emit->as, r64c, emit->stack_start + emit->stack_size + 2); asm_x64_mov_r64_to_local(emit->as, r64c, emit->stack_start + emit->stack_size + 2);
adjust_stack(emit, 3); adjust_stack(emit, 3);
} }
static void emit_post_push_r64_r64_r64_r64(emitter_t *emit, int r64a, int r64b, int r64c, int r64d) { static void emit_post_push_r64_r64_r64_r64(emit_t *emit, int r64a, int r64b, int r64c, int r64d) {
asm_x64_mov_r64_to_local(emit->as, r64a, emit->stack_start + emit->stack_size); asm_x64_mov_r64_to_local(emit->as, r64a, emit->stack_start + emit->stack_size);
asm_x64_mov_r64_to_local(emit->as, r64b, emit->stack_start + emit->stack_size + 1); asm_x64_mov_r64_to_local(emit->as, r64b, emit->stack_start + emit->stack_size + 1);
asm_x64_mov_r64_to_local(emit->as, r64c, emit->stack_start + emit->stack_size + 2); asm_x64_mov_r64_to_local(emit->as, r64c, emit->stack_start + emit->stack_size + 2);
@ -240,44 +233,44 @@ static void emit_post_push_r64_r64_r64_r64(emitter_t *emit, int r64a, int r64b,
adjust_stack(emit, 4); adjust_stack(emit, 4);
} }
static void emit_get_stack_pointer_to_r64_for_pop(emitter_t *emit, int r64, int n_pop) { static void emit_get_stack_pointer_to_r64_for_pop(emit_t *emit, int r64, int n_pop) {
asm_x64_mov_local_addr_to_r64(emit->as, emit->stack_start + emit->stack_size - 1, r64); asm_x64_mov_local_addr_to_r64(emit->as, emit->stack_start + emit->stack_size - 1, r64);
adjust_stack(emit, -n_pop); adjust_stack(emit, -n_pop);
} }
static void emit_get_stack_pointer_to_r64_for_push(emitter_t *emit, int r64, int n_push) { static void emit_get_stack_pointer_to_r64_for_push(emit_t *emit, int r64, int n_push) {
asm_x64_mov_local_addr_to_r64(emit->as, emit->stack_start + emit->stack_size + n_push - 1, r64); asm_x64_mov_local_addr_to_r64(emit->as, emit->stack_start + emit->stack_size + n_push - 1, r64);
adjust_stack(emit, n_push); adjust_stack(emit, n_push);
} }
static void emit_call(emitter_t *emit, void *fun) { static void emit_call(emit_t *emit, void *fun) {
asm_x64_call_ind(emit->as, fun, REG_RAX); asm_x64_call_ind(emit->as, fun, REG_RAX);
} }
static void emit_call_with_i64_arg(emitter_t *emit, void *fun, int64_t arg_val, int arg_r64) { static void emit_call_with_i64_arg(emit_t *emit, void *fun, int64_t arg_val, int arg_r64) {
asm_x64_mov_i64_to_r64_optimised(emit->as, arg_val, arg_r64); asm_x64_mov_i64_to_r64_optimised(emit->as, arg_val, arg_r64);
asm_x64_call_ind(emit->as, fun, REG_RAX); asm_x64_call_ind(emit->as, fun, REG_RAX);
} }
int emit_label_new(emitter_t *emit) { static int emit_x64_label_new(emit_t *emit) {
return asm_x64_label_new(emit->as); return asm_x64_label_new(emit->as);
} }
void emit_label_assign(emitter_t *emit, int l) { static void emit_x64_label_assign(emit_t *emit, int l) {
asm_x64_label_assign(emit->as, l); asm_x64_label_assign(emit->as, l);
} }
void emit_import_name(emitter_t *emit, qstr qstr) { static void emit_x64_import_name(emit_t *emit, qstr qstr) {
assert(0); assert(0);
} }
void emit_import_from(emitter_t *emit, qstr qstr) { static void emit_x64_import_from(emit_t *emit, qstr qstr) {
assert(0); assert(0);
} }
void emit_import_star(emitter_t *emit) { static void emit_x64_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_x64_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) {
@ -289,7 +282,7 @@ void emit_load_const_tok(emitter_t *emit, py_token_kind_t tok) {
emit_post_push_i64(emit, (uint64_t)o); emit_post_push_i64(emit, (uint64_t)o);
} }
void emit_load_const_small_int(emitter_t *emit, int arg) { static void emit_x64_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_i64(emit, arg); emit_post_push_i64(emit, arg);
@ -298,42 +291,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_x64_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_x64_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_x64_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_x64_load_const_str(emit_t *emit, qstr qstr, bool bytes) {
emit_pre(emit); emit_pre(emit);
emit_call_with_i64_arg(emit, rt_load_const_str, qstr, REG_ARG_1); emit_call_with_i64_arg(emit, rt_load_const_str, qstr, REG_ARG_1);
emit_post_push_r64(emit, REG_RET); emit_post_push_r64(emit, REG_RET);
} }
void emit_load_const_verbatim_start(emitter_t *emit) { static void emit_x64_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_x64_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_x64_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_x64_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_x64_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_x64_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_x64_load_fast(emit_t *emit, qstr qstr, int local_num) {
if (local_num == 0) { if (local_num == 0) {
emit_pre(emit); emit_pre(emit);
emit_post_push_r64(emit, REG_LOCAL_1); emit_post_push_r64(emit, REG_LOCAL_1);
@ -344,42 +337,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_x64_load_name(emit_t *emit, qstr qstr) {
emit_pre(emit); emit_pre(emit);
emit_call_with_i64_arg(emit, rt_load_name, qstr, REG_ARG_1); emit_call_with_i64_arg(emit, rt_load_name, qstr, REG_ARG_1);
emit_post_push_r64(emit, REG_RET); emit_post_push_r64(emit, REG_RET);
} }
void emit_load_global(emitter_t *emit, qstr qstr) { static void emit_x64_load_global(emit_t *emit, qstr qstr) {
emit_pre(emit); emit_pre(emit);
emit_call_with_i64_arg(emit, rt_load_global, qstr, REG_ARG_1); emit_call_with_i64_arg(emit, rt_load_global, qstr, REG_ARG_1);
emit_post_push_r64(emit, REG_RET); emit_post_push_r64(emit, REG_RET);
} }
void emit_load_deref(emitter_t *emit, qstr qstr) { static void emit_x64_load_deref(emit_t *emit, qstr qstr) {
assert(0); assert(0);
} }
void emit_load_closure(emitter_t *emit, qstr qstr) { static void emit_x64_load_closure(emit_t *emit, qstr qstr) {
assert(0); assert(0);
} }
void emit_load_attr(emitter_t *emit, qstr qstr) { static void emit_x64_load_attr(emit_t *emit, qstr qstr) {
emit_pre_pop_r64(emit, REG_ARG_1); // arg1 = base emit_pre_pop_r64(emit, REG_ARG_1); // arg1 = base
emit_call_with_i64_arg(emit, rt_load_attr, qstr, REG_ARG_2); // arg2 = attribute name emit_call_with_i64_arg(emit, rt_load_attr, qstr, REG_ARG_2); // arg2 = attribute name
emit_post_push_r64(emit, REG_RET); emit_post_push_r64(emit, REG_RET);
} }
void emit_load_method(emitter_t *emit, qstr qstr) { static void emit_x64_load_method(emit_t *emit, qstr qstr) {
emit_pre_pop_r64(emit, REG_ARG_1); // arg1 = base emit_pre_pop_r64(emit, REG_ARG_1); // arg1 = base
emit_get_stack_pointer_to_r64_for_push(emit, REG_ARG_3, 2); // arg3 = dest ptr emit_get_stack_pointer_to_r64_for_push(emit, REG_ARG_3, 2); // arg3 = dest ptr
emit_call_with_i64_arg(emit, rt_load_method, qstr, REG_ARG_2); // arg2 = method name emit_call_with_i64_arg(emit, rt_load_method, qstr, REG_ARG_2); // arg2 = method name
} }
void emit_load_build_class(emitter_t *emit) { static void emit_x64_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_x64_store_fast(emit_t *emit, qstr qstr, int local_num) {
if (local_num == 0) { if (local_num == 0) {
emit_pre_pop_r64(emit, REG_LOCAL_1); emit_pre_pop_r64(emit, REG_LOCAL_1);
emit_post(emit); emit_post(emit);
@ -390,81 +383,81 @@ void emit_store_fast(emitter_t *emit, qstr qstr, int local_num) {
} }
} }
void emit_store_name(emitter_t *emit, qstr qstr) { static void emit_x64_store_name(emit_t *emit, qstr qstr) {
emit_pre_pop_r64(emit, REG_ARG_2); emit_pre_pop_r64(emit, REG_ARG_2);
emit_call_with_i64_arg(emit, rt_store_name, qstr, REG_ARG_1); // arg1 = name emit_call_with_i64_arg(emit, rt_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_x64_store_global(emit_t *emit, qstr qstr) {
assert(0); assert(0);
} }
void emit_store_deref(emitter_t *emit, qstr qstr) { static void emit_x64_store_deref(emit_t *emit, qstr qstr) {
assert(0); assert(0);
} }
void emit_store_attr(emitter_t *emit, qstr qstr) { static void emit_x64_store_attr(emit_t *emit, qstr qstr) {
assert(0); assert(0);
} }
void emit_store_locals(emitter_t *emit) { static void emit_x64_store_locals(emit_t *emit) {
assert(0); assert(0);
} }
void emit_store_subscr(emitter_t *emit) { static void emit_x64_store_subscr(emit_t *emit) {
emit_pre_pop_r64_r64_r64(emit, REG_ARG_2, REG_ARG_1, REG_ARG_3); // index, base, value to store emit_pre_pop_r64_r64_r64(emit, REG_ARG_2, REG_ARG_1, REG_ARG_3); // index, base, value to store
emit_call(emit, rt_store_subscr); emit_call(emit, rt_store_subscr);
} }
void emit_delete_fast(emitter_t *emit, qstr qstr, int local_num) { static void emit_x64_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_x64_delete_name(emit_t *emit, qstr qstr) {
assert(0); assert(0);
} }
void emit_delete_global(emitter_t *emit, qstr qstr) { static void emit_x64_delete_global(emit_t *emit, qstr qstr) {
assert(0); assert(0);
} }
void emit_delete_deref(emitter_t *emit, qstr qstr) { static void emit_x64_delete_deref(emit_t *emit, qstr qstr) {
assert(0); assert(0);
} }
void emit_delete_attr(emitter_t *emit, qstr qstr) { static void emit_x64_delete_attr(emit_t *emit, qstr qstr) {
assert(0); assert(0);
} }
void emit_delete_subscr(emitter_t *emit) { static void emit_x64_delete_subscr(emit_t *emit) {
assert(0); assert(0);
} }
void emit_dup_top(emitter_t *emit) { static void emit_x64_dup_top(emit_t *emit) {
emit_pre_pop_r64(emit, REG_RAX); emit_pre_pop_r64(emit, REG_RAX);
emit_post_push_r64_r64(emit, REG_RAX, REG_RAX); emit_post_push_r64_r64(emit, REG_RAX, REG_RAX);
} }
void emit_dup_top_two(emitter_t *emit) { static void emit_x64_dup_top_two(emit_t *emit) {
emit_pre_pop_r64_r64(emit, REG_RAX, REG_RDI); emit_pre_pop_r64_r64(emit, REG_RAX, REG_RDI);
emit_post_push_r64_r64_r64_r64(emit, REG_RDI, REG_RAX, REG_RDI, REG_RAX); emit_post_push_r64_r64_r64_r64(emit, REG_RDI, REG_RAX, REG_RDI, REG_RAX);
} }
void emit_pop_top(emitter_t *emit) { static void emit_x64_pop_top(emit_t *emit) {
emit_pre_pop_r64(emit, REG_RAX); emit_pre_pop_r64(emit, REG_RAX);
emit_post(emit); emit_post(emit);
} }
void emit_rot_two(emitter_t *emit) { static void emit_x64_rot_two(emit_t *emit) {
assert(0); assert(0);
} }
void emit_rot_three(emitter_t *emit) { static void emit_x64_rot_three(emit_t *emit) {
emit_pre_pop_r64_r64_r64(emit, REG_RAX, REG_RDI, REG_RSI); emit_pre_pop_r64_r64_r64(emit, REG_RAX, REG_RDI, REG_RSI);
emit_post_push_r64_r64_r64(emit, REG_RAX, REG_RSI, REG_RDI); emit_post_push_r64_r64_r64(emit, REG_RAX, REG_RSI, REG_RDI);
} }
void emit_jump(emitter_t *emit, int label) { static void emit_x64_jump(emit_t *emit, int label) {
emit_pre(emit); emit_pre(emit);
asm_x64_jmp_label(emit->as, label); asm_x64_jmp_label(emit->as, label);
emit_post(emit); emit_post(emit);
} }
void emit_pop_jump_if_false(emitter_t *emit, int label) { static void emit_x64_pop_jump_if_false(emit_t *emit, int label) {
if (emit->do_native_types) { if (emit->do_native_types) {
emit_pre_pop_r64(emit, REG_RET); emit_pre_pop_r64(emit, REG_RET);
asm_x64_test_r8_with_r8(emit->as, REG_RET, REG_RET); asm_x64_test_r8_with_r8(emit->as, REG_RET, REG_RET);
@ -479,124 +472,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_x64_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_x64_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_x64_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_x64_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_x64_break_loop(emit_t *emit, int label) {
assert(0); assert(0);
} }
void emit_continue_loop(emitter_t *emit, int label) { static void emit_x64_continue_loop(emit_t *emit, int label) {
assert(0); assert(0);
} }
void emit_setup_with(emitter_t *emit, int label) { static void emit_x64_setup_with(emit_t *emit, int label) {
assert(0); assert(0);
} }
void emit_with_cleanup(emitter_t *emit) { static void emit_x64_with_cleanup(emit_t *emit) {
assert(0); assert(0);
} }
void emit_setup_except(emitter_t *emit, int label) { static void emit_x64_setup_except(emit_t *emit, int label) {
assert(0); assert(0);
} }
void emit_setup_finally(emitter_t *emit, int label) { static void emit_x64_setup_finally(emit_t *emit, int label) {
assert(0); assert(0);
} }
void emit_end_finally(emitter_t *emit) { static void emit_x64_end_finally(emit_t *emit) {
assert(0); assert(0);
} }
void emit_get_iter(emitter_t *emit) { static void emit_x64_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_x64_for_iter(emit_t *emit, int label) {
assert(0); assert(0);
} }
void emit_for_iter_end(emitter_t *emit) { static void emit_x64_for_iter_end(emit_t *emit) {
assert(0); assert(0);
} }
void emit_pop_except(emitter_t *emit) { static void emit_x64_pop_except(emit_t *emit) {
assert(0); assert(0);
} }
void emit_unary_op(emitter_t *emit, rt_unary_op_t op) { static void emit_x64_unary_op(emit_t *emit, rt_unary_op_t op) {
emit_pre_pop_r64(emit, REG_ARG_2); emit_pre_pop_r64(emit, REG_ARG_2);
emit_call_with_i64_arg(emit, rt_unary_op, op, REG_ARG_1); emit_call_with_i64_arg(emit, rt_unary_op, op, REG_ARG_1);
emit_post_push_r64(emit, REG_RET); emit_post_push_r64(emit, REG_RET);
} }
void emit_build_tuple(emitter_t *emit, int n_args) { static void emit_x64_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_x64_build_list(emit_t *emit, int n_args) {
emit_pre(emit); emit_pre(emit);
emit_get_stack_pointer_to_r64_for_pop(emit, REG_ARG_2, n_args); // pointer to items in reverse order emit_get_stack_pointer_to_r64_for_pop(emit, REG_ARG_2, n_args); // pointer to items in reverse order
emit_call_with_i64_arg(emit, rt_build_list, n_args, REG_ARG_1); emit_call_with_i64_arg(emit, rt_build_list, n_args, REG_ARG_1);
emit_post_push_r64(emit, REG_RET); // new list emit_post_push_r64(emit, REG_RET); // new list
} }
void emit_list_append(emitter_t *emit, int list_index) { static void emit_x64_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_x64_build_map(emit_t *emit, int n_args) {
emit_pre(emit); emit_pre(emit);
emit_call_with_i64_arg(emit, rt_build_map, n_args, REG_ARG_1); emit_call_with_i64_arg(emit, rt_build_map, n_args, REG_ARG_1);
emit_post_push_r64(emit, REG_RET); // new map emit_post_push_r64(emit, REG_RET); // new map
} }
void emit_store_map(emitter_t *emit) { static void emit_x64_store_map(emit_t *emit) {
emit_pre_pop_r64_r64_r64(emit, REG_ARG_2, REG_ARG_3, REG_ARG_1); // key, value, map emit_pre_pop_r64_r64_r64(emit, REG_ARG_2, REG_ARG_3, REG_ARG_1); // key, value, map
emit_call(emit, rt_store_map); emit_call(emit, rt_store_map);
emit_post_push_r64(emit, REG_RET); // map emit_post_push_r64(emit, REG_RET); // map
} }
void emit_map_add(emitter_t *emit, int map_index) { static void emit_x64_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_x64_build_set(emit_t *emit, int n_args) {
emit_pre(emit); emit_pre(emit);
emit_get_stack_pointer_to_r64_for_pop(emit, REG_ARG_2, n_args); // pointer to items in reverse order emit_get_stack_pointer_to_r64_for_pop(emit, REG_ARG_2, n_args); // pointer to items in reverse order
emit_call_with_i64_arg(emit, rt_build_set, n_args, REG_ARG_1); emit_call_with_i64_arg(emit, rt_build_set, n_args, REG_ARG_1);
emit_post_push_r64(emit, REG_RET); // new set emit_post_push_r64(emit, REG_RET); // new set
} }
void emit_set_add(emitter_t *emit, int set_index) { static void emit_x64_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_x64_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_x64_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_x64_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_x64_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_i64_arg(emit, rt_make_function_from_id, scope->unique_code_id, REG_ARG_1); emit_call_with_i64_arg(emit, rt_make_function_from_id, scope->unique_code_id, REG_ARG_1);
emit_post_push_r64(emit, REG_RET); emit_post_push_r64(emit, REG_RET);
} }
void emit_make_closure(emitter_t *emit, scope_t *scope, int n_dict_params, int n_default_params) { static void emit_x64_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_x64_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_r64(emit, REG_ARG_1); // the function emit_pre_pop_r64(emit, REG_ARG_1); // the function
@ -613,7 +606,7 @@ void emit_call_function(emitter_t *emit, int n_positional, int n_keyword, bool h
emit_post_push_r64(emit, REG_RET); emit_post_push_r64(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_x64_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_r64_r64(emit, REG_ARG_2, REG_ARG_1); // the self object (or NULL), the method emit_pre_pop_r64_r64(emit, REG_ARG_2, REG_ARG_1); // the self object (or NULL), the method
@ -627,12 +620,12 @@ void emit_call_method(emitter_t *emit, int n_positional, int n_keyword, bool hav
emit_post_push_r64(emit, REG_RET); emit_post_push_r64(emit, REG_RET);
} }
void emit_pop_block(emitter_t *emit) { static void emit_x64_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_x64_binary_op(emit_t *emit, rt_binary_op_t op) {
if (emit->do_native_types) { if (emit->do_native_types) {
assert(op == RT_BINARY_OP_ADD); assert(op == RT_BINARY_OP_ADD);
emit_pre_pop_r64_r64(emit, REG_ARG_2, REG_RET); emit_pre_pop_r64_r64(emit, REG_ARG_2, REG_RET);
@ -645,7 +638,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_x64_compare_op(emit_t *emit, rt_compare_op_t op) {
if (emit->do_native_types) { if (emit->do_native_types) {
assert(op == RT_COMPARE_OP_LESS); assert(op == RT_COMPARE_OP_LESS);
emit_pre_pop_r64_r64(emit, REG_ARG_3, REG_ARG_2); emit_pre_pop_r64_r64(emit, REG_ARG_3, REG_ARG_2);
@ -660,21 +653,123 @@ void emit_compare_op(emitter_t *emit, rt_compare_op_t op) {
} }
} }
void emit_return_value(emitter_t *emit) { static void emit_x64_return_value(emit_t *emit) {
emit_pre_pop_r64(emit, REG_RAX); emit_pre_pop_r64(emit, REG_RAX);
emit->last_emit_was_return_value = true; emit->last_emit_was_return_value = true;
//asm_x64_call_ind(emit->as, 0, REG_RAX); to seg fault for debugging with gdb //asm_x64_call_ind(emit->as, 0, REG_RAX); to seg fault for debugging with gdb
asm_x64_exit(emit->as); asm_x64_exit(emit->as);
} }
void emit_raise_varargs(emitter_t *emit, int n_args) { static void emit_x64_raise_varargs(emit_t *emit, int n_args) {
assert(0); assert(0);
} }
void emit_yield_value(emitter_t *emit) { static void emit_x64_yield_value(emit_t *emit) {
assert(0); assert(0);
} }
void emit_yield_from(emitter_t *emit) { static void emit_x64_yield_from(emit_t *emit) {
assert(0); assert(0);
} }
#endif // EMIT_DO_X64 static const emit_method_table_t emit_x64_method_table = {
emit_x64_set_native_types,
emit_x64_start_pass,
emit_x64_end_pass,
emit_x64_last_emit_was_return_value,
emit_x64_get_stack_size,
emit_x64_set_stack_size,
emit_x64_label_new,
emit_x64_label_assign,
emit_x64_import_name,
emit_x64_import_from,
emit_x64_import_star,
emit_x64_load_const_tok,
emit_x64_load_const_small_int,
emit_x64_load_const_int,
emit_x64_load_const_dec,
emit_x64_load_const_id,
emit_x64_load_const_str,
emit_x64_load_const_verbatim_start,
emit_x64_load_const_verbatim_int,
emit_x64_load_const_verbatim_str,
emit_x64_load_const_verbatim_strn,
emit_x64_load_const_verbatim_quoted_str,
emit_x64_load_const_verbatim_end,
emit_x64_load_fast,
emit_x64_load_name,
emit_x64_load_global,
emit_x64_load_deref,
emit_x64_load_closure,
emit_x64_load_attr,
emit_x64_load_method,
emit_x64_load_build_class,
emit_x64_store_fast,
emit_x64_store_name,
emit_x64_store_global,
emit_x64_store_deref,
emit_x64_store_attr,
emit_x64_store_locals,
emit_x64_store_subscr,
emit_x64_delete_fast,
emit_x64_delete_name,
emit_x64_delete_global,
emit_x64_delete_deref,
emit_x64_delete_attr,
emit_x64_delete_subscr,
emit_x64_dup_top,
emit_x64_dup_top_two,
emit_x64_pop_top,
emit_x64_rot_two,
emit_x64_rot_three,
emit_x64_jump,
emit_x64_pop_jump_if_true,
emit_x64_pop_jump_if_false,
emit_x64_jump_if_true_or_pop,
emit_x64_jump_if_false_or_pop,
emit_x64_setup_loop,
emit_x64_break_loop,
emit_x64_continue_loop,
emit_x64_setup_with,
emit_x64_with_cleanup,
emit_x64_setup_except,
emit_x64_setup_finally,
emit_x64_end_finally,
emit_x64_get_iter,
emit_x64_for_iter,
emit_x64_for_iter_end,
emit_x64_pop_block,
emit_x64_pop_except,
emit_x64_unary_op,
emit_x64_binary_op,
emit_x64_compare_op,
emit_x64_build_tuple,
emit_x64_build_list,
emit_x64_list_append,
emit_x64_build_map,
emit_x64_store_map,
emit_x64_map_add,
emit_x64_build_set,
emit_x64_set_add,
emit_x64_build_slice,
emit_x64_unpack_sequence,
emit_x64_unpack_ex,
emit_x64_make_function,
emit_x64_make_closure,
emit_x64_call_function,
emit_x64_call_method,
emit_x64_return_value,
emit_x64_raise_varargs,
emit_x64_yield_value,
emit_x64_yield_from,
};
void emit_new_x64(emit_t **emit_out, const emit_method_table_t **emit_method_table_out) {
emit_t *emit = m_new(emit_t, 1);
emit->as = asm_x64_new();
emit->do_native_types = false;
*emit_out = emit;
*emit_method_table_out = &emit_x64_method_table;
}
#endif // EMIT_ENABLE_X64

40
py/scope.c
View File

@ -165,6 +165,46 @@ void scope_close_over_in_parents(scope_t *scope, qstr qstr) {
assert(0); // we should have found the variable in one of the parents assert(0); // we should have found the variable in one of the parents
} }
void scope_declare_global(scope_t *scope, qstr qstr) {
if (scope->kind == SCOPE_MODULE) {
printf("SyntaxError?: can't declare global in outer code\n");
return;
}
bool added;
id_info_t *id_info = scope_find_or_add_id(scope, qstr, &added);
if (!added) {
printf("SyntaxError?: identifier already declared something\n");
return;
}
id_info->kind = ID_INFO_KIND_GLOBAL_EXPLICIT;
// if the id exists in the global scope, set its kind to EXPLICIT_GLOBAL
id_info = scope_find_global(scope, qstr);
if (id_info != NULL) {
id_info->kind = ID_INFO_KIND_GLOBAL_EXPLICIT;
}
}
void scope_declare_nonlocal(scope_t *scope, qstr qstr) {
if (scope->kind == SCOPE_MODULE) {
printf("SyntaxError?: can't declare nonlocal in outer code\n");
return;
}
bool added;
id_info_t *id_info = scope_find_or_add_id(scope, qstr, &added);
if (!added) {
printf("SyntaxError?: identifier already declared something\n");
return;
}
id_info_t *id_info2 = scope_find_local_in_parent(scope, qstr);
if (id_info2 == NULL || !(id_info2->kind == ID_INFO_KIND_LOCAL || id_info2->kind == ID_INFO_KIND_CELL || id_info2->kind == ID_INFO_KIND_FREE)) {
printf("SyntaxError: no binding for nonlocal '%s' found\n", qstr_str(qstr));
return;
}
id_info->kind = ID_INFO_KIND_FREE;
scope_close_over_in_parents(scope, qstr);
}
void scope_print_info(scope_t *s) { void scope_print_info(scope_t *s) {
if (s->kind == SCOPE_MODULE) { if (s->kind == SCOPE_MODULE) {
printf("code <module>\n"); printf("code <module>\n");

2
py/scope.h
View File

@ -55,4 +55,6 @@ id_info_t *scope_find(scope_t *scope, qstr qstr);
id_info_t *scope_find_global(scope_t *scope, qstr qstr); id_info_t *scope_find_global(scope_t *scope, qstr qstr);
id_info_t *scope_find_local_in_parent(scope_t *scope, qstr qstr); id_info_t *scope_find_local_in_parent(scope_t *scope, qstr qstr);
void scope_close_over_in_parents(scope_t *scope, qstr qstr); void scope_close_over_in_parents(scope_t *scope, qstr qstr);
void scope_declare_global(scope_t *scope, qstr qstr);
void scope_declare_nonlocal(scope_t *scope, qstr qstr);
void scope_print_info(scope_t *s); void scope_print_info(scope_t *s);