Restructure emit so it goes through a method table.

11 files changed, 842 insertions, 450 deletions

diff --git a/py/.gitignore b/py/.gitignore
index 5761abcfdf..5408770ea1 100644
--- a/py/.gitignore
+++ b/py/.gitignore
@@ -1 +1,3 @@
 *.o
+py
+*.py
diff --git a/py/Makefile b/py/Makefile
index f360d7697f..36d2a5036c 100644
--- a/py/Makefile
+++ b/py/Makefile
@@ -1,5 +1,5 @@
 CC = gcc
-CFLAGS = -Wall -ansi -std=gnu99 -Os #-DNDEBUG
+CFLAGS = -Wall -ansi -std=gnu99 -Os -DEMIT_ENABLE_CPY -DEMIT_ENABLE_X64 #-DNDEBUG
 LDFLAGS =
 
 SRC = \
diff --git a/py/asmx64.c b/py/asmx64.c
index 59c8113bc4..ca461e0c2e 100644
--- a/py/asmx64.c
+++ b/py/asmx64.c
@@ -113,7 +113,8 @@ asm_x64_t* asm_x64_new() {
 
 void asm_x64_free(asm_x64_t* as, bool free_code) {
     if (free_code) {
-        m_free(as->code_base);
+        // need to un-mmap
+        //m_free(as->code_base);
     }
     /*
     if (as->label != NULL) {
@@ -154,6 +155,8 @@ void asm_x64_end_pass(asm_x64_t *as) {
         // calculate size of code in bytes
         as->code_size = as->code_offset;
         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);
     }
 
@@ -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) {
-    /*
     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));
-    */
     // 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_word32(as, ptr - (void*)(as->code_base + as->code_offset + 4));
+    */
 }
diff --git a/py/compile.c b/py/compile.c
index 9b778117d4..5a90bdcf77 100644
--- a/py/compile.c
+++ b/py/compile.c
@@ -15,6 +15,7 @@
 #include "emit.h"
 
 // TODO need to mangle __attr names
+// TODO add #define to enable/disable CPython compatibility
 
 typedef enum {
     PN_none = 0,
@@ -24,8 +25,8 @@ typedef enum {
     PN_maximum_number_of,
 } pn_kind_t;
 
-#define EMIT(fun, arg...) (emit_##fun(comp->emit, ##arg))
-#define EMIT_COMMON(fun, arg...) (emit_common_##fun(comp->pass, comp->scope_cur, ##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, comp->emit, comp->emit_method_table, ##arg))
 
 typedef struct _compiler_t {
     qstr qstr___class__;
@@ -53,7 +54,8 @@ typedef struct _compiler_t {
     scope_t *scope_head;
     scope_t *scope_cur;
 
-    emitter_t *emit;
+    emit_t *emit;
+    const emit_method_table_t *emit_method_table;
 } compiler_t;
 
 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) {
                 case ASSIGN_STORE:
                 case ASSIGN_AUG_STORE:
-                    EMIT_COMMON(store_id, comp->emit, arg);
+                    EMIT_COMMON(store_id, arg);
                     break;
                 case ASSIGN_AUG_LOAD:
-                    EMIT_COMMON(load_id, comp->qstr___class__, comp->emit, arg);
+                    EMIT_COMMON(load_id, comp->qstr___class__, arg);
                     break;
             }
         } else {
@@ -770,18 +772,18 @@ void compile_decorated(compiler_t *comp, py_parse_node_struct_t *pns) {
     }
 
     // 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) {
     qstr fname = compile_funcdef_helper(comp, pns);
     // 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) {
     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)) {
         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);
     qstr 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) {
@@ -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
             EMIT(import_from, id2);
             if (PY_PARSE_NODE_IS_NULL(pns3->nodes[1])) {
-                EMIT_COMMON(store_id, comp->emit, id2);
+                EMIT_COMMON(store_id, id2);
             } 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);
@@ -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) {
-    if (PY_PARSE_NODE_IS_LEAF(pns->nodes[0])) {
-        EMIT_COMMON(declare_global, PY_PARSE_NODE_LEAF_ARG(pns->nodes[0]));
-    } else {
-        pns = (py_parse_node_struct_t*)pns->nodes[0];
-        int num_nodes = PY_PARSE_NODE_STRUCT_NUM_NODES(pns);
-        for (int i = 0; i < num_nodes; i++) {
-            EMIT_COMMON(declare_global, PY_PARSE_NODE_LEAF_ARG(pns->nodes[i]));
+    if (comp->pass == PASS_1) {
+        if (PY_PARSE_NODE_IS_LEAF(pns->nodes[0])) {
+            scope_declare_global(comp->scope_cur, PY_PARSE_NODE_LEAF_ARG(pns->nodes[0]));
+        } else {
+            pns = (py_parse_node_struct_t*)pns->nodes[0];
+            int num_nodes = PY_PARSE_NODE_STRUCT_NUM_NODES(pns);
+            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) {
-    if (PY_PARSE_NODE_IS_LEAF(pns->nodes[0])) {
-        EMIT_COMMON(declare_nonlocal, PY_PARSE_NODE_LEAF_ARG(pns->nodes[0]));
-    } else {
-        pns = (py_parse_node_struct_t*)pns->nodes[0];
-        int num_nodes = PY_PARSE_NODE_STRUCT_NUM_NODES(pns);
-        for (int i = 0; i < num_nodes; i++) {
-            EMIT_COMMON(declare_nonlocal, PY_PARSE_NODE_LEAF_ARG(pns->nodes[i]));
+    if (comp->pass == PASS_1) {
+        if (PY_PARSE_NODE_IS_LEAF(pns->nodes[0])) {
+            scope_declare_nonlocal(comp->scope_cur, PY_PARSE_NODE_LEAF_ARG(pns->nodes[0]));
+        } else {
+            pns = (py_parse_node_struct_t*)pns->nodes[0];
+            int num_nodes = PY_PARSE_NODE_STRUCT_NUM_NODES(pns);
+            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) {
     int l_end = EMIT(label_new);
     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])) {
         // assertion message
         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
     //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
-        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);
         }
     //}
@@ -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
 
                 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(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
 
             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(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);
     c_if_cond(comp, pns->nodes[0], false, done_label); // condition
     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(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);
     c_assign(comp, pns->nodes[0], ASSIGN_STORE); // variable
     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(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) {
             EMIT(pop_top);
         } else {
-            EMIT_COMMON(store_id, comp->emit, qstr_exception_local);
+            EMIT_COMMON(store_id, qstr_exception_local);
         }
 
         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(label_assign, l3);
             EMIT(load_const_tok, PY_TOKEN_KW_NONE);
-            EMIT_COMMON(store_id, comp->emit, qstr_exception_local);
-            EMIT_COMMON(delete_id, comp->emit, qstr_exception_local);
+            EMIT_COMMON(store_id, qstr_exception_local);
+            EMIT_COMMON(delete_id, qstr_exception_local);
             EMIT(end_finally);
         }
         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) {
     qstr cname = compile_classdef_helper(comp, pns);
     // 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) {
@@ -2116,7 +2122,7 @@ void compile_node(compiler_t *comp, py_parse_node_t pn) {
     } else if (PY_PARSE_NODE_IS_LEAF(pn)) {
         int arg = PY_PARSE_NODE_LEAF_ARG(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_INTEGER: EMIT(load_const_int, 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) {
                 compile_node(comp, pns->nodes[0]); // a 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) {
     comp->pass = pass;
     comp->scope_cur = scope;
-    emit_start_pass(comp->emit, pass, scope);
+    EMIT(start_pass, pass, scope);
 
     if (comp->pass == PASS_1) {
         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
         // 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(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_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(for_iter, l_end);
         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
         }
 
-        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_COMMON(load_id, comp->qstr___class__, comp->emit, comp->qstr___name__);
-        EMIT_COMMON(store_id, comp->emit, comp->qstr___module__);
+        EMIT_COMMON(load_id, comp->qstr___class__, comp->qstr___name__);
+        EMIT_COMMON(store_id, comp->qstr___module__);
         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]);
         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_end_pass(comp->emit);
+    EMIT(end_pass);
 }
 
 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_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);
     scope_new_and_link(comp, SCOPE_MODULE, pn);
diff --git a/py/emit.h b/py/emit.h
index 8cad745dde..dcafbc08d7 100644
--- a/py/emit.h
+++ b/py/emit.h
@@ -1,8 +1,3 @@
-//#define EMIT_DO_CPY
-#define EMIT_DO_BC
-//#define EMIT_DO_X64
-//#define EMIT_DO_THUMB
-
 /* Notes on passes:
  * 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
@@ -19,15 +14,111 @@ typedef enum {
     PASS_3 = 3, // emit code
 } pass_kind_t;
 
-typedef struct _emitter_t emitter_t;
+typedef struct _emit_t emit_t;
+
+typedef struct _emit_method_table_t {
+    void (*set_native_types)(emit_t *emit, bool do_native_types);
+    void (*start_pass)(emit_t *emit, pass_kind_t pass, scope_t *scope);
+    void (*end_pass)(emit_t *emit);
+    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);
+
+    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_common_declare_global(pass_kind_t pass, scope_t *scope, qstr qstr);
-void emit_common_declare_nonlocal(pass_kind_t pass, scope_t *scope, qstr qstr);
-void emit_common_load_id(pass_kind_t pass, scope_t *scope, qstr qstr___class__, emitter_t *emit, qstr qstr);
-void emit_common_store_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, emitter_t *emit, 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);
 
-emitter_t *emit_new();
+/*
 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_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_yield_value(emitter_t *emit);
 void emit_yield_from(emitter_t *emit);
+*/
diff --git a/py/emitbc.c b/py/emitbc.c
index 9d159ae605..27540f18de 100644
--- a/py/emitbc.c
+++ b/py/emitbc.c
@@ -15,10 +15,8 @@
 #include "emit.h"
 #include "bc.h"
 
-#ifdef EMIT_DO_BC
-
-struct _emitter_t {
-    int pass;
+struct _emit_t {
+    pass_kind_t pass;
     int next_label;
     int stack_size;
     bool last_emit_was_return_value;
@@ -34,25 +32,18 @@ struct _emitter_t {
     byte dummy_data[8];
 };
 
-emitter_t *emit_new() {
-    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) {
+uint emit_bc_get_code_size(emit_t* emit) {
     return emit->code_size;
 }
 
-void* emit_get_code(emitter_t* emit) {
+void* emit_bc_get_code(emit_t* emit) {
     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->next_label = 1;
     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;
 }
 
-void emit_end_pass(emitter_t *emit) {
+static void emit_bc_end_pass(emit_t *emit) {
     // check stack is back to zero size
     if (emit->stack_size != 0) {
         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
-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);
     if (emit->pass < PASS_3) {
         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);
     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);
     byte* c = emit_get_cur_to_write_bytes(emit, 2);
     c[0] = b1;
     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));
     byte* c = emit_get_cur_to_write_bytes(emit, 3);
     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;
 }
 
-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
         // fit argument in single byte
         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);
 }
 
-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;
     if (emit->pass < PASS_3) {
         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);
 }
 
-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;
 }
 
-int emit_get_stack_size(emitter_t *emit) {
+int emit_bc_get_stack_size(emit_t *emit) {
     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) {
         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) {
         emit->stack_size += stack_size_delta;
         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;
 }
 
-int emit_label_new(emitter_t *emit) {
+static int emit_bc_label_new(emit_t *emit) {
     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);
     if (emit->pass > PASS_1) {
         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_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_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_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);
     switch (tok) {
         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_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_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_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_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);
     if (bytes) {
         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);
     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);
 }
 
-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);
 }
 
-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);
 }
 
-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);
 }
 
-void emit_load_const_verbatim_end(emitter_t *emit) {
+static void emit_bc_load_const_verbatim_end(emit_t *emit) {
     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);
     emit_pre(emit, 1);
     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_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_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);
     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);
     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_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_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_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);
     emit_pre(emit, -1);
     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_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_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);
     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_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_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_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);
     emit_pre(emit, 0);
     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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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);
 }
 
-void emit_pop_block(emitter_t *emit) {
+static void emit_bc_pop_block(emit_t *emit) {
     emit_pre(emit, 0);
     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_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_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_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_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);
     emit_pre(emit, 1 - 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);
     emit_pre(emit, 1 - 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);
     emit_pre(emit, -1);
     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);
     emit_pre(emit, 1);
     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_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);
     emit_pre(emit, -2);
     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);
     emit_pre(emit, 1 - 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);
     emit_pre(emit, -1);
     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);
     emit_pre(emit, 1 - 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);
     emit_pre(emit, -1 + 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);
     emit_pre(emit, -1 + n_left + n_right + 1);
     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);
     emit_pre(emit, 1);
     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);
     emit_pre(emit, -2 - n_default_params - 2 * n_dict_params);
     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;
     if (have_star_arg) {
         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
 }
 
-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;
     if (have_star_arg) {
         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
 }
 
-void emit_return_value(emitter_t *emit) {
+static void emit_bc_return_value(emit_t *emit) {
     emit_pre(emit, -1);
     emit->last_emit_was_return_value = true;
     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);
     emit_pre(emit, -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);
     if (emit->pass == PASS_2) {
         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);
 }
 
-void emit_yield_from(emitter_t *emit) {
+static void emit_bc_yield_from(emit_t *emit) {
     emit_pre(emit, -1);
     if (emit->pass == PASS_2) {
         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);
 }
 
-#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;
+}
diff --git a/py/emitcommon.c b/py/emitcommon.c
index 1fd8697c3a..95a00543ad 100644
--- a/py/emitcommon.c
+++ b/py/emitcommon.c
@@ -12,53 +12,9 @@
 #include "runtime.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) {
-    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) {
+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) {
     id_info_t *id_info = NULL;
     if (pass == PASS_1) {
         // 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;
     if (pass == PASS_1) {
         // 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;
 }
 
-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
-    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
     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
-    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
     if (id == NULL || id->kind == ID_INFO_KIND_GLOBAL_IMPLICIT) {
diff --git a/py/emitcpy.c b/py/emitcpy.c
index 637abd772a..1c600ac577 100644
--- a/py/emitcpy.c
+++ b/py/emitcpy.c
@@ -14,9 +14,9 @@
 #include "runtime.h"
 #include "emit.h"
 
-#ifdef EMIT_DO_CPY
+#ifdef EMIT_ENABLE_CPY
 
-struct _emitter_t {
+struct _emit_t {
     int pass;
     int next_label;
     int byte_code_offset;
@@ -29,14 +29,10 @@ struct _emitter_t {
     int *label_offsets;
 };
 
-emitter_t *emit_new() {
-    emitter_t *emit = m_new(emitter_t, 1);
-    emit->max_num_labels = 0;
-    emit->label_offsets = NULL;
-    return emit;
+static void emit_cpy_set_native_types(emit_t *emit, bool do_native_types) {
 }
 
-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->next_label = 1;
     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
     if (emit->stack_size != 0) {
         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;
 }
 
-int emit_get_stack_size(emitter_t *emit) {
+static int emit_cpy_get_stack_size(emit_t *emit) {
     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;
 }
 
-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;
     if (emit->pass > PASS_1 && emit->stack_size > emit->scope->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;
 }
 
-int emit_label_new(emitter_t *emit) {
+static int emit_cpy_label_new(emit_t *emit) {
     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);
     if (emit->pass > PASS_1) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         printf("LOAD_CONST ");
-        emit_load_const_verbatim_quoted_str(emit, qstr, bytes);
+        emit_cpy_load_const_verbatim_quoted_str(emit, qstr, bytes);
         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);
     if (emit->pass == PASS_3) {
         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) {
         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) {
         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) {
         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
     if (emit->pass == PASS_3) {
         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) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         printf("LOAD_ATTR %s\n", qstr_str(qstr));
     }
 }
 
-void emit_load_method(emitter_t *emit, qstr qstr) {
-    emit_load_attr(emit, qstr);
+static void emit_cpy_load_method(emit_t *emit, qstr 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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
 }
 
-void emit_pop_block(emitter_t *emit) {
+static void emit_cpy_pop_block(emit_t *emit) {
     emit_pre(emit, 0, 1);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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;
     if (have_star_arg) {
         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) {
-    emit_call_function(emit, n_positional, n_keyword, have_star_arg, 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_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->last_emit_was_return_value = true;
     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);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_3) {
         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) {
-    load_const_code_and_name(emit, scope->simple_name);
+static void emit_cpy_make_function(emit_t *emit, scope_t *scope, int n_dict_params, int n_default_params) {
+    load_cpy_const_code_and_name(emit, scope->simple_name);
     emit_pre(emit, -1 - n_default_params - 2 * n_dict_params, 3);
     if (emit->pass == PASS_3) {
         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) {
-    load_const_code_and_name(emit, scope->simple_name);
+static void emit_cpy_make_closure(emit_t *emit, scope_t *scope, int n_dict_params, int n_default_params) {
+    load_cpy_const_code_and_name(emit, scope->simple_name);
     emit_pre(emit, -2 - n_default_params - 2 * n_dict_params, 3);
     if (emit->pass == PASS_3) {
         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);
     if (emit->pass == PASS_2) {
         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);
     if (emit->pass == PASS_2) {
         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
diff --git a/py/emitx64.c b/py/emitx64.c
index da4c7e333d..38d519063e 100644
--- a/py/emitx64.c
+++ b/py/emitx64.c
@@ -27,7 +27,7 @@
 #include "emit.h"
 #include "asmx64.h"
 
-#ifdef EMIT_DO_X64
+#ifdef EMIT_ENABLE_X64
 
 #define REG_LOCAL_1 (REG_RBX)
 #define REG_LOCAL_NUM (1)
@@ -38,7 +38,7 @@ typedef enum {
     NEED_TO_PUSH_I64,
 } need_to_push_t;
 
-struct _emitter_t {
+struct _emit_t {
     int pass;
     int stack_start;
     int stack_size;
@@ -53,18 +53,11 @@ struct _emitter_t {
     bool do_native_types;
 };
 
-emitter_t *emit_new() {
-    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) {
+static void emit_x64_set_native_types(emit_t *emit, bool 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->stack_start = 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) {
         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;
 }
 
-int emit_get_stack_size(emitter_t *emit) {
+static int emit_x64_get_stack_size(emit_t *emit) {
     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;
 }
 
-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;
     assert(emit->stack_size >= 0);
     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) {
         case NEED_TO_PUSH_NOTHING:
             break;
@@ -160,17 +153,17 @@ static void stack_settle(emitter_t *emit) {
     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);
     emit->last_emit_was_return_value = false;
 }
 
-static void emit_pre(emitter_t *emit) {
+static void emit_pre(emit_t *emit) {
     stack_settle(emit);
     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) {
         case NEED_TO_PUSH_NOTHING:
             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;
 }
 
-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);
     asm_x64_mov_local_to_r64(emit->as, emit->stack_start + emit->stack_size - 1, r64b);
     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);
     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);
     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->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->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);
     emit->need_to_push = NEED_TO_PUSH_R64;
     emit->last_r64 = r64b;
     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, r64b, emit->stack_start + emit->stack_size + 1);
     asm_x64_mov_r64_to_local(emit->as, r64c, emit->stack_start + emit->stack_size + 2);
     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, r64b, emit->stack_start + emit->stack_size + 1);
     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);
 }
 
-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);
     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);
     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);
 }
 
-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_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);
 }
 
-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);
 }
 
-void emit_import_name(emitter_t *emit, qstr qstr) {
+static void emit_x64_import_name(emit_t *emit, qstr qstr) {
     assert(0);
 }
-void emit_import_from(emitter_t *emit, qstr qstr) {
+static void emit_x64_import_from(emit_t *emit, qstr qstr) {
     assert(0);
 }
-void emit_import_star(emitter_t *emit) {
+static void emit_x64_import_star(emit_t *emit) {
     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);
     py_obj_t o;
     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);
 }
 
-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);
     if (emit->do_native_types) {
         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);
 }
-void emit_load_const_dec(emitter_t *emit, qstr qstr) {
+static void emit_x64_load_const_dec(emit_t *emit, qstr qstr) {
     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);
 }
 
-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_call_with_i64_arg(emit, rt_load_const_str, qstr, REG_ARG_1);
     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);
 }
-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);
 }
-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);
 }
-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);
 }
-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);
 }
-void emit_load_const_verbatim_end(emitter_t *emit) {
+static void emit_x64_load_const_verbatim_end(emit_t *emit) {
     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) {
         emit_pre(emit);
         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_call_with_i64_arg(emit, rt_load_name, qstr, REG_ARG_1);
     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_call_with_i64_arg(emit, rt_load_global, qstr, REG_ARG_1);
     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);
 }
-void emit_load_closure(emitter_t *emit, qstr qstr) {
+static void emit_x64_load_closure(emit_t *emit, qstr qstr) {
     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_call_with_i64_arg(emit, rt_load_attr, qstr, REG_ARG_2); // arg2 = attribute name
     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_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
 }
 
-void emit_load_build_class(emitter_t *emit) {
+static void emit_x64_load_build_class(emit_t *emit) {
    assert(0);
 } // 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) {
         emit_pre_pop_r64(emit, REG_LOCAL_1);
         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_call_with_i64_arg(emit, rt_store_name, qstr, REG_ARG_1); // arg1 = name
     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);
 }
 
-void emit_store_deref(emitter_t *emit, qstr qstr) {
+static void emit_x64_store_deref(emit_t *emit, qstr qstr) {
     assert(0);
 }
-void emit_store_attr(emitter_t *emit, qstr qstr) {
+static void emit_x64_store_attr(emit_t *emit, qstr qstr) {
     assert(0);
 }
-void emit_store_locals(emitter_t *emit) {
+static void emit_x64_store_locals(emit_t *emit) {
     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_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);
 }
-void emit_delete_name(emitter_t *emit, qstr qstr) {
+static void emit_x64_delete_name(emit_t *emit, qstr qstr) {
     assert(0);
 }
-void emit_delete_global(emitter_t *emit, qstr qstr) {
+static void emit_x64_delete_global(emit_t *emit, qstr qstr) {
     assert(0);
 }
-void emit_delete_deref(emitter_t *emit, qstr qstr) {
+static void emit_x64_delete_deref(emit_t *emit, qstr qstr) {
     assert(0);
 }
-void emit_delete_attr(emitter_t *emit, qstr qstr) {
+static void emit_x64_delete_attr(emit_t *emit, qstr qstr) {
     assert(0);
 }
-void emit_delete_subscr(emitter_t *emit) {
+static void emit_x64_delete_subscr(emit_t *emit) {
     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_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_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_post(emit);
 }
 
-void emit_rot_two(emitter_t *emit) {
+static void emit_x64_rot_two(emit_t *emit) {
     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_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);
     asm_x64_jmp_label(emit->as, label);
     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) {
         emit_pre_pop_r64(emit, 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);
 }
-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);
 }
-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);
 }
 
-void emit_setup_loop(emitter_t *emit, int label) {
+static void emit_x64_setup_loop(emit_t *emit, int label) {
     emit_pre(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);
 }
-void emit_continue_loop(emitter_t *emit, int label) {
+static void emit_x64_continue_loop(emit_t *emit, int label) {
     assert(0);
 }
-void emit_setup_with(emitter_t *emit, int label) {
+static void emit_x64_setup_with(emit_t *emit, int label) {
     assert(0);
 }
-void emit_with_cleanup(emitter_t *emit) {
+static void emit_x64_with_cleanup(emit_t *emit) {
     assert(0);
 }
-void emit_setup_except(emitter_t *emit, int label) {
+static void emit_x64_setup_except(emit_t *emit, int label) {
     assert(0);
 }
-void emit_setup_finally(emitter_t *emit, int label) {
+static void emit_x64_setup_finally(emit_t *emit, int label) {
     assert(0);
 }
-void emit_end_finally(emitter_t *emit) {
+static void emit_x64_end_finally(emit_t *emit) {
     assert(0);
 }
-void emit_get_iter(emitter_t *emit) {
+static void emit_x64_get_iter(emit_t *emit) {
     assert(0);
 } // 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);
 }
-void emit_for_iter_end(emitter_t *emit) {
+static void emit_x64_for_iter_end(emit_t *emit) {
     assert(0);
 }
-void emit_pop_except(emitter_t *emit) {
+static void emit_x64_pop_except(emit_t *emit) {
     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_call_with_i64_arg(emit, rt_unary_op, op, REG_ARG_1);
     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);
 }
 
-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_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_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);
 }
 
-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_call_with_i64_arg(emit, rt_build_map, n_args, REG_ARG_1);
     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_call(emit, rt_store_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);
 }
 
-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_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_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);
 }
-void emit_build_slice(emitter_t *emit, int n_args) {
+static void emit_x64_build_slice(emit_t *emit, int n_args) {
     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);
 }
-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);
 }
 
-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);
     emit_pre(emit);
     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);
 }
 
-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);
 }
 
-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);
     if (n_positional == 0) {
         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);
 }
 
-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);
     if (n_positional == 0) {
         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);
 }
 
-void emit_pop_block(emitter_t *emit) {
+static void emit_x64_pop_block(emit_t *emit) {
     emit_pre(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) {
         assert(op == RT_BINARY_OP_ADD);
         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) {
         assert(op == RT_COMPARE_OP_LESS);
         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->last_emit_was_return_value = true;
     //asm_x64_call_ind(emit->as, 0, REG_RAX); to seg fault for debugging with gdb
     asm_x64_exit(emit->as);
 }
 
-void emit_raise_varargs(emitter_t *emit, int n_args) {
-    assert(0);
-}
-void emit_yield_value(emitter_t *emit) {
-    assert(0);
-}
-void emit_yield_from(emitter_t *emit) {
-    assert(0);
+static void emit_x64_raise_varargs(emit_t *emit, int n_args) {
+    assert(0);
+}
+static void emit_x64_yield_value(emit_t *emit) {
+    assert(0);
+}
+static void emit_x64_yield_from(emit_t *emit) {
+    assert(0);
+}
+
+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_DO_X64
+#endif // EMIT_ENABLE_X64
diff --git a/py/scope.c b/py/scope.c
index a715b2b506..5773ae0b44 100644
--- a/py/scope.c
+++ b/py/scope.c
@@ -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
 }
 
+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) {
     if (s->kind == SCOPE_MODULE) {
         printf("code <module>\n");
diff --git a/py/scope.h b/py/scope.h
index 2d620fb4fb..cb5e606c33 100644
--- a/py/scope.h
+++ b/py/scope.h
@@ -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_local_in_parent(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);