Initial commit.

py/.gitignore

+*.o

py/Makefile

+CC = gcc
+CFLAGS = -Wall -ansi -std=gnu99 -Os #-DNDEBUG
+LDFLAGS =
+
+SRC = \
+	malloc.c \
+	misc.c \
+	qstr.c \
+	lexer.c \
+	lexerfile.c \
+	parse.c \
+	scope.c \
+	compile.c \
+	emitcommon.c \
+	emitcpy.c \
+	emitbc.c \
+	asmx64.c \
+	emitx64v2.c \
+	emitthumb.c \
+	asmthumb.c \
+	runtime.c \
+	bc.c \
+	main.c \
+
+SRC_ASM = \
+	runtime1.s \
+
+OBJ = $(SRC:.c=.o) $(SRC_ASM:.s=.o)
+LIB =
+PROG = py
+
+$(PROG): $(OBJ)
+	$(CC) -o $@ $(OBJ) $(LIB) $(LDFLAGS)
+
+runtime.o: runtime.c
+	$(CC) $(CFLAGS) -O3 -c -o $@ $<
+
+bc.o: bc.c
+	$(CC) $(CFLAGS) -O3 -c -o $@ $<
+
+parse.o: grammar.h
+compile.o: grammar.h
+emitcpy.o: emit.h
+emitbc.o: emit.h
+emitx64.o: emit.h
+emitx64v2.o: emit.h
+emitthumb.o: emit.h
+
+clean:
+	/bin/rm $(OBJ)

py/asmthumb.c

+#include <stdint.h>
+#include <stdio.h>
+#include <assert.h>
+#include <string.h>
+
+#include "misc.h"
+#include "machine.h"
+#include "asmthumb.h"
+
+#define UNSIGNED_FIT8(x) (((x) & 0xffffff00) == 0)
+#define UNSIGNED_FIT16(x) (((x) & 0xffff0000) == 0)
+#define SIGNED_FIT8(x) (((x) & 0xffffff80) == 0) || (((x) & 0xffffff80) == 0xffffff80)
+#define SIGNED_FIT9(x) (((x) & 0xffffff00) == 0) || (((x) & 0xffffff00) == 0xffffff00)
+#define SIGNED_FIT12(x) (((x) & 0xfffff800) == 0) || (((x) & 0xfffff800) == 0xfffff800)
+
+struct _asm_thumb_t {
+    int pass;
+    uint code_offset;
+    uint code_size;
+    byte *code_base;
+    byte dummy_data[8];
+
+    int next_label;
+    int max_num_labels;
+    int *label_offsets;
+    int num_locals;
+    uint push_reglist;
+    uint stack_adjust;
+};
+
+asm_thumb_t *asm_thumb_new() {
+    asm_thumb_t *as;
+
+    as = m_new(asm_thumb_t, 1);
+    as->pass = 0;
+    as->code_offset = 0;
+    as->code_size = 0;
+    as->code_base = NULL;
+    as->label_offsets = NULL;
+    as->num_locals = 0;
+
+    return as;
+}
+
+void asm_thumb_free(asm_thumb_t *as, bool free_code) {
+    if (free_code) {
+        m_free(as->code_base);
+    }
+    /*
+    if (as->label != NULL) {
+        int i;
+        for (i = 0; i < as->label->len; ++i)
+        {
+            Label *lab = &g_array_index(as->label, Label, i);
+            if (lab->unresolved != NULL)
+                g_array_free(lab->unresolved, true);
+        }
+        g_array_free(as->label, true);
+    }
+    */
+    m_free(as);
+}
+
+void asm_thumb_start_pass(asm_thumb_t *as, int pass) {
+    as->pass = pass;
+    as->code_offset = 0;
+    as->next_label = 1;
+    if (pass == ASM_THUMB_PASS_1) {
+        as->max_num_labels = 0;
+    } else {
+        if (pass == ASM_THUMB_PASS_2) {
+            memset(as->label_offsets, -1, as->max_num_labels * sizeof(int));
+        }
+    }
+}
+
+void asm_thumb_end_pass(asm_thumb_t *as) {
+    if (as->pass == ASM_THUMB_PASS_1) {
+        // calculate number of labels need
+        if (as->next_label > as->max_num_labels) {
+            as->max_num_labels = as->next_label;
+        }
+        as->label_offsets = m_new(int, as->max_num_labels);
+    } else if (as->pass == ASM_THUMB_PASS_2) {
+        // calculate size of code in bytes
+        as->code_size = as->code_offset;
+        as->code_base = m_new(byte, as->code_size);
+        printf("code_size: %u\n", as->code_size);
+    }
+
+    /*
+    // check labels are resolved
+    if (as->label != NULL)
+    {
+        int i;
+        for (i = 0; i < as->label->len; ++i)
+            if (g_array_index(as->label, Label, i).unresolved != NULL)
+                return false;
+    }
+    */
+}
+
+// all functions must go through this one to emit bytes
+static byte *asm_thumb_get_cur_to_write_bytes(asm_thumb_t *as, int num_bytes_to_write) {
+    //printf("emit %d\n", num_bytes_to_write);
+    if (as->pass < ASM_THUMB_PASS_3) {
+        as->code_offset += num_bytes_to_write;
+        return as->dummy_data;
+    } else {
+        assert(as->code_offset + num_bytes_to_write <= as->code_size);
+        byte *c = as->code_base + as->code_offset;
+        as->code_offset += num_bytes_to_write;
+        return c;
+    }
+}
+
+uint asm_thumb_get_code_size(asm_thumb_t *as) {
+    return as->code_size;
+}
+
+void *asm_thumb_get_code(asm_thumb_t *as) {
+    // need to set low bit to indicate that it's thumb code
+    return (void *)(((machine_uint_t)as->code_base) | 1);
+}
+
+/*
+static void asm_thumb_write_byte_1(asm_thumb_t *as, byte b1) {
+    byte *c = asm_thumb_get_cur_to_write_bytes(as, 1);
+    c[0] = b1;
+}
+*/
+
+static void asm_thumb_write_op16(asm_thumb_t *as, uint op) {
+    byte *c = asm_thumb_get_cur_to_write_bytes(as, 2);
+    // little endian
+    c[0] = op;
+    c[1] = op >> 8;
+}
+
+static void asm_thumb_write_op32(asm_thumb_t *as, uint op1, uint op2) {
+    byte *c = asm_thumb_get_cur_to_write_bytes(as, 4);
+    // little endian, op1 then op2
+    c[0] = op1;
+    c[1] = op1 >> 8;
+    c[2] = op2;
+    c[3] = op2 >> 8;
+}
+
+/*
+#define IMM32_L0(x) ((x) & 0xff)
+#define IMM32_L1(x) (((x) >> 8) & 0xff)
+#define IMM32_L2(x) (((x) >> 16) & 0xff)
+#define IMM32_L3(x) (((x) >> 24) & 0xff)
+
+static void asm_thumb_write_word32(asm_thumb_t *as, int w32) {
+    byte *c = asm_thumb_get_cur_to_write_bytes(as, 4);
+    c[0] = IMM32_L0(w32);
+    c[1] = IMM32_L1(w32);
+    c[2] = IMM32_L2(w32);
+    c[3] = IMM32_L3(w32);
+}
+*/
+
+// rlolist is a bit map indicating desired lo-registers
+#define OP_PUSH_RLIST(rlolist)      (0xb400 | (rlolist))
+#define OP_PUSH_RLIST_LR(rlolist)   (0xb400 | 0x0100 | (rlolist))
+#define OP_POP_RLIST(rlolist)       (0xbc00 | (rlolist))
+#define OP_POP_RLIST_PC(rlolist)    (0xbc00 | 0x0100 | (rlolist))
+
+#define OP_ADD_SP(num_words) (0xb000 | (num_words))
+#define OP_SUB_SP(num_words) (0xb080 | (num_words))
+
+void asm_thumb_entry(asm_thumb_t *as, int num_locals) {
+    // work out what to push and how many extra space to reserve on stack
+    // so that we have enough for all locals and it's aligned an 8-byte boundary
+    uint reglist;
+    uint stack_adjust;
+    if (num_locals < 0) {
+        num_locals = 0;
+    }
+    // don't ppop r0 because it's used for return value
+    switch (num_locals) {
+        case 0:
+            reglist = 0xf2;
+            stack_adjust = 0;
+            break;
+
+        case 1:
+            reglist = 0xf2;
+            stack_adjust = 0;
+            break;
+
+        case 2:
+            reglist = 0xfe;
+            stack_adjust = 0;
+            break;
+
+        case 3:
+            reglist = 0xfe;
+            stack_adjust = 0;
+            break;
+
+        default:
+            reglist = 0xfe;
+            stack_adjust = ((num_locals - 3) + 1) & (~1);
+            break;
+    }
+    asm_thumb_write_op16(as, OP_PUSH_RLIST_LR(reglist));
+    if (stack_adjust > 0) {
+        asm_thumb_write_op16(as, OP_SUB_SP(stack_adjust));
+    }
+    as->push_reglist = reglist;
+    as->stack_adjust = stack_adjust;
+    as->num_locals = num_locals;
+}
+
+void asm_thumb_exit(asm_thumb_t *as) {
+    if (as->stack_adjust > 0) {
+        asm_thumb_write_op16(as, OP_ADD_SP(as->stack_adjust));
+    }
+    asm_thumb_write_op16(as, OP_POP_RLIST_PC(as->push_reglist));
+}
+
+int asm_thumb_label_new(asm_thumb_t *as) {
+    return as->next_label++;
+}
+
+void asm_thumb_label_assign(asm_thumb_t *as, int label) {
+    if (as->pass > ASM_THUMB_PASS_1) {
+        assert(label < as->max_num_labels);
+        if (as->pass == ASM_THUMB_PASS_2) {
+            // assign label offset
+            assert(as->label_offsets[label] == -1);
+            as->label_offsets[label] = as->code_offset;
+        } else if (as->pass == ASM_THUMB_PASS_3) {
+            // ensure label offset has not changed from PASS_2 to PASS_3
+            //printf("l%d: (at %d=%ld)\n", label, as->label_offsets[label], as->code_offset);
+            assert(as->label_offsets[label] == as->code_offset);
+        }
+    }
+}
+
+// the i8 value will be zero extended into the r32 register!
+void asm_thumb_mov_reg_i8(asm_thumb_t *as, uint rlo_dest, int i8) {
+    assert(rlo_dest < REG_R8);
+    // movs rlo_dest, #i8
+    asm_thumb_write_op16(as, 0x2000 | (rlo_dest << 8) | i8);
+}
+
+// if loading lo half, the i16 value will be zero extended into the r32 register!
+void asm_thumb_mov_i16_to_reg(asm_thumb_t *as, int i16, uint reg_dest, bool load_hi_half) {
+    assert(reg_dest < REG_R15);
+    uint op;
+    if (load_hi_half) {
+        // movt reg_dest, #i16
+        op = 0xf2c0;
+    } else {
+        // movw reg_dest, #i16
+        op = 0xf240;
+    }
+    asm_thumb_write_op32(as, op | ((i16 >> 1) & 0x0400) | ((i16 >> 12) & 0xf), ((i16 << 4) & 0x7000) | (reg_dest << 8) | (i16 & 0xff));
+}
+
+void asm_thumb_mov_reg_i32(asm_thumb_t *as, uint reg_dest, machine_uint_t i32) {
+    // movw, movt does it in 8 bytes
+    // ldr [pc, #], dw does it in 6 bytes, but we might not reach to end of code for dw
+
+    asm_thumb_mov_i16_to_reg(as, i32, reg_dest, false);
+    asm_thumb_mov_i16_to_reg(as, i32 >> 16, reg_dest, true);
+}
+
+void asm_thumb_mov_reg_i32_optimised(asm_thumb_t *as, uint reg_dest, int i32) {
+    if (reg_dest < 8 && UNSIGNED_FIT8(i32)) {
+        asm_thumb_mov_reg_i8(as, reg_dest, i32);
+    } else if (UNSIGNED_FIT16(i32)) {
+        asm_thumb_mov_i16_to_reg(as, i32, reg_dest, false);
+    } else {
+        asm_thumb_mov_reg_i32(as, reg_dest, i32);
+    }
+}
+
+void asm_thumb_mov_reg_reg(asm_thumb_t *as, uint reg_dest, uint reg_src) {
+    uint op_lo;
+    if (reg_src < 8) {
+        op_lo = reg_src << 3;
+    } else {
+        op_lo = 0x40 | ((reg_src - 8) << 3);
+    }
+    if (reg_dest < 8) {
+        op_lo |= reg_dest;
+    } else {
+        op_lo |= 0x80 | (reg_dest - 8);
+    }
+    asm_thumb_write_op16(as, 0x4600 | op_lo);
+}
+
+#define OP_STR_TO_SP_OFFSET(rlo_dest, word_offset) (0x9000 | ((rlo_dest) << 8) | ((word_offset) & 0x00ff))
+#define OP_LDR_FROM_SP_OFFSET(rlo_dest, word_offset) (0x9800 | ((rlo_dest) << 8) | ((word_offset) & 0x00ff))
+
+void asm_thumb_mov_local_reg(asm_thumb_t *as, int local_num, uint rlo_src) {
+    assert(rlo_src < REG_R8);
+    int word_offset = as->num_locals - local_num - 1;
+    assert(as->pass < ASM_THUMB_PASS_3 || word_offset >= 0);
+    asm_thumb_write_op16(as, OP_STR_TO_SP_OFFSET(rlo_src, word_offset));
+}
+
+void asm_thumb_mov_reg_local(asm_thumb_t *as, uint rlo_dest, int local_num) {
+    assert(rlo_dest < REG_R8);
+    int word_offset = as->num_locals - local_num - 1;
+    assert(as->pass < ASM_THUMB_PASS_3 || word_offset >= 0);
+    asm_thumb_write_op16(as, OP_LDR_FROM_SP_OFFSET(rlo_dest, word_offset));
+}
+
+void asm_thumb_mov_reg_local_addr(asm_thumb_t *as, uint reg_dest, int local_num) {
+    assert(0);
+    // see format 12, load address
+    asm_thumb_write_op16(as, 0x0000);
+}
+
+#define OP_ADD_REG_REG_REG(rlo_dest, rlo_src_a, rlo_src_b) (0x1800 | ((rlo_src_b) << 6) | ((rlo_src_a) << 3) | (rlo_dest))
+
+void asm_thumb_add_reg_reg_reg(asm_thumb_t *as, uint rlo_dest, uint rlo_src_a, uint rlo_src_b) {
+    asm_thumb_write_op16(as, OP_ADD_REG_REG_REG(rlo_dest, rlo_src_a, rlo_src_b));
+}
+
+#define OP_CMP_REG_REG(rlo_a, rlo_b) (0x4280 | ((rlo_b) << 3) | (rlo_a))
+
+void asm_thumb_cmp_reg_reg(asm_thumb_t *as, uint rlo_a, uint rlo_b) {
+    asm_thumb_write_op16(as, OP_CMP_REG_REG(rlo_a, rlo_b));
+}
+
+void asm_thumb_ite_ge(asm_thumb_t *as) {
+    asm_thumb_write_op16(as, 0xbfac);
+}
+
+#define OP_B(byte_offset) (0xe000 | (((byte_offset) >> 1) & 0x07ff))
+// this could be wrong, because it should have a range of +/- 16MiB...
+#define OP_BW_HI(byte_offset) (0xf000 | (((byte_offset) >> 12) & 0x07ff))
+#define OP_BW_LO(byte_offset) (0xb800 | (((byte_offset) >> 1) & 0x07ff))
+
+void asm_thumb_b_label(asm_thumb_t *as, int label) {
+    if (as->pass > ASM_THUMB_PASS_1) {
+        int dest = as->label_offsets[label];
+        int rel = dest - as->code_offset;
+        rel -= 4; // account for instruction prefetch, PC is 4 bytes ahead of this instruction
+        if (dest >= 0 && rel <= -4) {
+            // is a backwards jump, so we know the size of the jump on the first pass
+            // calculate rel assuming 12 bit relative jump
+            if (SIGNED_FIT12(rel)) {
+                asm_thumb_write_op16(as, OP_B(rel));
+            } else {
+                goto large_jump;
+            }
+        } else {
+            // is a forwards jump, so need to assume it's large
+            large_jump:
+            asm_thumb_write_op32(as, OP_BW_HI(rel), OP_BW_LO(rel));
+        }
+    }
+}
+
+#define OP_CMP_REG_IMM(rlo, i8) (0x2800 | ((rlo) << 8) | (i8))
+// all these bit arithmetics need coverage testing!
+#define OP_BEQ(byte_offset) (0xd000 | (((byte_offset) >> 1) & 0x00ff))
+#define OP_BEQW_HI(byte_offset) (0xf000 | (((byte_offset) >> 10) & 0x0400) | (((byte_offset) >> 14) & 0x003f))
+#define OP_BEQW_LO(byte_offset) (0x8000 | ((byte_offset) & 0x2000) | (((byte_offset) >> 1) & 0x0fff))
+
+void asm_thumb_cmp_reg_bz_label(asm_thumb_t *as, uint rlo, int label) {
+    assert(rlo < REG_R8);
+
+    // compare reg with 0
+    asm_thumb_write_op16(as, OP_CMP_REG_IMM(rlo, 0));
+
+    // branch if equal
+    if (as->pass > ASM_THUMB_PASS_1) {
+        int dest = as->label_offsets[label];
+        int rel = dest - as->code_offset;
+        rel -= 4; // account for instruction prefetch, PC is 4 bytes ahead of this instruction
+        if (dest >= 0 && rel <= -4) {
+            // is a backwards jump, so we know the size of the jump on the first pass
+            // calculate rel assuming 12 bit relative jump
+            if (SIGNED_FIT9(rel)) {
+                asm_thumb_write_op16(as, OP_BEQ(rel));
+            } else {
+                goto large_jump;
+            }
+        } else {
+            // is a forwards jump, so need to assume it's large
+            large_jump:
+            asm_thumb_write_op32(as, OP_BEQW_HI(rel), OP_BEQW_LO(rel));
+        }
+    }
+}
+
+#define OP_BLX(reg) (0x4780 | ((reg) << 3))
+#define OP_SVC(arg) (0xdf00 | (arg))
+#define OP_LDR_FROM_BASE_OFFSET(rlo_dest, rlo_base, word_offset) (0x6800 | (((word_offset) << 6) & 0x07c0) | ((rlo_base) << 3) | (rlo_dest))
+
+void asm_thumb_bl_ind(asm_thumb_t *as, void *fun_ptr, uint fun_id, uint reg_temp) {
+    /* TODO make this use less bytes
+    uint rlo_base = REG_R3;
+    uint rlo_dest = REG_R7;
+    uint word_offset = 4;
+    asm_thumb_write_op16(as, 0x0000);
+    asm_thumb_write_op16(as, 0x6800 | (word_offset << 6) | (rlo_base << 3) | rlo_dest); // ldr rlo_dest, [rlo_base, #offset]
+    asm_thumb_write_op16(as, 0x4780 | (REG_R9 << 3)); // blx reg
+    */
+
+    if (0) {
+        // load ptr to function into register using immediate, then branch
+        // not relocatable
+        asm_thumb_mov_reg_i32(as, reg_temp, (machine_uint_t)fun_ptr);
+        asm_thumb_write_op16(as, OP_BLX(reg_temp));
+    } else if (1) {
+        asm_thumb_write_op16(as, OP_LDR_FROM_BASE_OFFSET(reg_temp, REG_R7, fun_id));
+        asm_thumb_write_op16(as, OP_BLX(reg_temp));
+    } else {
+        // use SVC
+        asm_thumb_write_op16(as, OP_SVC(fun_id));
+    }
+}

py/asmthumb.h

+#define ASM_THUMB_PASS_1 (1)
+#define ASM_THUMB_PASS_2 (2)
+#define ASM_THUMB_PASS_3 (3)
+
+#define REG_R0  (0)
+#define REG_R1  (1)
+#define REG_R2  (2)
+#define REG_R3  (3)
+#define REG_R4  (4)
+#define REG_R5  (5)
+#define REG_R6  (6)
+#define REG_R7  (7)
+#define REG_R8  (8)
+#define REG_R9  (9)
+#define REG_R10 (10)
+#define REG_R11 (11)
+#define REG_R12 (12)
+#define REG_R13 (13)
+#define REG_R14 (14)
+#define REG_R15 (15)
+#define REG_LR  (REG_R14)
+
+#define REG_RET REG_R0
+#define REG_ARG_1 REG_R0
+#define REG_ARG_2 REG_R1
+#define REG_ARG_3 REG_R2
+#define REG_ARG_4 REG_R3
+
+typedef struct _asm_thumb_t asm_thumb_t;
+
+asm_thumb_t *asm_thumb_new();
+void asm_thumb_free(asm_thumb_t *as, bool free_code);
+void asm_thumb_start_pass(asm_thumb_t *as, int pass);
+void asm_thumb_end_pass(asm_thumb_t *as);
+uint asm_thumb_get_code_size(asm_thumb_t *as);
+void *asm_thumb_get_code(asm_thumb_t *as);
+
+void asm_thumb_entry(asm_thumb_t *as, int num_locals);
+void asm_thumb_exit(asm_thumb_t *as);
+
+int asm_thumb_label_new(asm_thumb_t *as);
+void asm_thumb_label_assign(asm_thumb_t *as, int label);
+
+// argument order follows ARM, in general dest is first
+
+void asm_thumb_mov_reg_i8(asm_thumb_t *as, uint rlo_dest, int i8_src);
+void asm_thumb_mov_reg_i32(asm_thumb_t *as, uint reg_dest, machine_uint_t i32_src);
+void asm_thumb_mov_reg_i32_optimised(asm_thumb_t *as, uint reg_dest, int i32_src);
+void asm_thumb_mov_reg_reg(asm_thumb_t *as, uint reg_dest, uint reg_src);
+void asm_thumb_mov_local_reg(asm_thumb_t *as, int local_num_dest, uint rlo_src);
+void asm_thumb_mov_reg_local(asm_thumb_t *as, uint rlo_dest, int local_num);
+void asm_thumb_mov_reg_local_addr(asm_thumb_t *as, uint reg_dest, int local_num);
+
+void asm_thumb_add_reg_reg_reg(asm_thumb_t *as, uint rlo_dest, uint rlo_src_a, uint rlo_src_b);
+void asm_thumb_cmp_reg_reg(asm_thumb_t *as, uint rlo_a, uint rlo_b);
+void asm_thumb_ite_ge(asm_thumb_t *as);
+
+void asm_thumb_b_label(asm_thumb_t *as, int label);
+void asm_thumb_cmp_reg_bz_label(asm_thumb_t *as, uint rlo, int label);
+void asm_thumb_bl_ind(asm_thumb_t *as, void *fun_ptr, uint fun_id, uint reg_temp);

py/asmx64.h

+#define ASM_X64_PASS_1 (1)
+#define ASM_X64_PASS_2 (2)
+#define ASM_X64_PASS_3 (3)
+
+#define REG_RAX (0)
+#define REG_RCX (1)
+#define REG_RDX (2)
+#define REG_RBX (3)
+#define REG_RSP (4)
+#define REG_RBP (5)
+#define REG_RSI (6)
+#define REG_RDI (7)
+
+// condition codes, used for jcc and setcc (desipite their j-name!)
+#define JCC_JB  (0x2) // below, unsigned
+#define JCC_JZ  (0x4)
+#define JCC_JE  (0x4)
+#define JCC_JNZ (0x5)
+#define JCC_JNE (0x5)
+#define JCC_JL  (0xc) // less, signed
+
+#define REG_RET REG_RAX
+#define REG_ARG_1 REG_RDI
+#define REG_ARG_2 REG_RSI
+#define REG_ARG_3 REG_RDX
+
+typedef struct _asm_x64_t asm_x64_t;
+
+asm_x64_t* asm_x64_new();
+void asm_x64_free(asm_x64_t* as, bool free_code);
+void asm_x64_start_pass(asm_x64_t *as, int pass);
+void asm_x64_end_pass(asm_x64_t *as);
+uint asm_x64_get_code_size(asm_x64_t* as);
+void* asm_x64_get_code(asm_x64_t* as);
+
+void asm_x64_nop(asm_x64_t* as);
+void asm_x64_push_r64(asm_x64_t* as, int src_r64);
+void asm_x64_push_i32(asm_x64_t* as, int src_i32); // will be sign extended to 64 bits
+void asm_x64_push_disp(asm_x64_t* as, int src_r32, int src_offset);
+void asm_x64_pop_r64(asm_x64_t* as, int dest_r64);
+void asm_x64_mov_r64_to_r64(asm_x64_t* as, int src_r64, int dest_r64);
+void asm_x64_mov_r32_to_disp(asm_x64_t* as, int src_r32, int dest_r32, int dest_disp);
+void asm_x64_mov_disp_to_r32(asm_x64_t* as, int src_r32, int src_disp, int dest_r32);
+void asm_x64_mov_i32_to_r64(asm_x64_t* as, int src_i32, int dest_r64);
+void asm_x64_mov_i64_to_r64(asm_x64_t* as, int64_t src_i64, int dest_r64);
+void asm_x64_mov_i32_to_disp(asm_x64_t* as, int src_i32, int dest_r32, int dest_disp);
+void asm_x64_mov_i64_to_r64_optimised(asm_x64_t *as, int64_t src_i64, int dest_r64);
+void asm_x64_xor_r64_to_r64(asm_x64_t *as, int src_r64, int dest_r64);
+void asm_x64_add_r64_to_r64(asm_x64_t* as, int src_r64, int dest_r64);
+void asm_x64_add_i32_to_r32(asm_x64_t* as, int src_i32, int dest_r32);
+void asm_x64_sub_r32_from_r32(asm_x64_t* as, int src_r32, int dest_r32);
+void asm_x64_sub_i32_from_r32(asm_x64_t* as, int src_i32, int dest_r32);
+void asm_x64_shl_r32_by_imm(asm_x64_t* as, int r32, int imm);
+void asm_x64_shr_r32_by_imm(asm_x64_t* as, int r32, int imm);
+void asm_x64_sar_r32_by_imm(asm_x64_t* as, int r32, int imm);
+void asm_x64_cmp_r64_with_r64(asm_x64_t* as, int src_r64_a, int src_r64_b);
+void asm_x64_cmp_r32_with_disp(asm_x64_t* as, int src_r32_a, int src_r32_b, int src_disp_b);
+void asm_x64_cmp_disp_with_r32(asm_x64_t* as, int src_r32_a, int src_disp_a, int src_r32_b);
+void asm_x64_cmp_i32_with_r32(asm_x64_t* as, int src_i32, int src_r32);
+void asm_x64_test_r8_with_r8(asm_x64_t* as, int src_r64_a, int src_r64_b);
+void asm_x64_setcc_r8(asm_x64_t* as, int jcc_type, int dest_r8);
+int asm_x64_label_new(asm_x64_t* as);
+void asm_x64_label_assign(asm_x64_t* as, int label);
+void asm_x64_jmp_label(asm_x64_t* as, int label);
+void asm_x64_jcc_label(asm_x64_t* as, int jcc_type, int label);
+void asm_x64_entry(asm_x64_t* as, int num_locals);
+void asm_x64_exit(asm_x64_t* as);
+void asm_x64_push_arg(asm_x64_t* as, int src_arg_num);
+void asm_x64_mov_arg_to_r32(asm_x64_t* as, int src_arg_num, int dest_r32);
+void asm_x64_mov_r32_to_arg(asm_x64_t* as, int src_r32, int dest_arg_num);
+void asm_x64_mov_local_to_r64(asm_x64_t* as, int src_local_num, int dest_r64);
+void asm_x64_mov_r64_to_local(asm_x64_t* as, int src_r64, int dest_local_num);
+void asm_x64_mov_local_addr_to_r64(asm_x64_t* as, int local_num, int dest_r64);
+void asm_x64_push_local(asm_x64_t* as, int local_num);
+void asm_x64_push_local_addr(asm_x64_t* as, int local_num, int temp_r32);
+void asm_x64_call_ind(asm_x64_t* as, void* ptr, int temp_r32);

py/bc.c

+#include <stdint.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+
+#include "misc.h"
+#include "machine.h"
+#include "runtime.h"
+#include "bc.h"
+
+#define DECODE_UINT do { unum = *ip++; if (unum > 127) { unum = ((unum & 0x3f) << 8) | (*ip++); } } while (0)
+#define DECODE_QSTR do { qstr = *ip++; if (qstr > 127) { qstr = ((qstr & 0x3f) << 8) | (*ip++); } } while (0)
+#define PUSH(val) *--sp = (val)
+#define POP() (*sp++)
+
+py_obj_t py_execute_byte_code(byte *code, uint len, py_obj_t *args, uint n_args) {
+    byte *ip = code;
+    py_obj_t stack[10];
+    py_obj_t *sp = &stack[10]; // stack grows down, sp points to top of stack
+    machine_uint_t unum;
+    machine_int_t snum;
+    qstr qstr;
+    py_obj_t obj1, obj2;
+    py_obj_t fast0 = NULL, fast1 = NULL, fast2 = NULL, fastn[4] = {NULL, NULL, NULL, NULL};
+
+    // init args
+    for (int i = 0; i < n_args; i++) {
+        if (i == 0) {
+            fast0 = args[0];
+        } else if (i == 1) {
+            fast1 = args[1];
+        } else if (i == 2) {
+            fast2 = args[2];
+        } else {
+            assert(i - 3 < 4);
+            fastn[i - 3] = args[i];
+        }
+    }
+
+    // execute byte code
+    for (;;) {
+        int op = *ip++;
+        switch (op) {
+            case PYBC_LOAD_CONST_FALSE:
+                PUSH(py_const_false);
+                break;
+
+            case PYBC_LOAD_CONST_NONE:
+                PUSH(py_const_none);
+                break;
+
+            case PYBC_LOAD_CONST_TRUE:
+                PUSH(py_const_true);
+                break;
+
+            case PYBC_LOAD_CONST_SMALL_INT:
+                snum = ip[0] | (ip[1] << 8);
+                if (snum & 0x8000) {
+                    snum |= ~0xffff;
+                }
+                ip += 2;
+                PUSH((py_obj_t)(snum << 1 | 1));
+                break;
+
+            case PYBC_LOAD_CONST_ID:
+                DECODE_QSTR;
+                PUSH(rt_load_const_str(qstr)); // TODO
+                break;
+
+            case PYBC_LOAD_CONST_STRING:
+                DECODE_QSTR;
+                PUSH(rt_load_const_str(qstr));
+                break;
+
+            case PYBC_LOAD_FAST_0:
+                PUSH(fast0);
+                break;
+
+            case PYBC_LOAD_FAST_1:
+                PUSH(fast1);
+                break;
+
+            case PYBC_LOAD_FAST_2:
+                PUSH(fast2);
+                break;
+
+            case PYBC_LOAD_FAST_N:
+                DECODE_UINT;
+                PUSH(fastn[unum - 3]);
+                break;
+
+            case PYBC_LOAD_NAME:
+                DECODE_QSTR;
+                PUSH(rt_load_name(qstr));
+                break;
+
+            case PYBC_LOAD_GLOBAL:
+                DECODE_QSTR;
+                PUSH(rt_load_global(qstr));
+                break;
+
+            case PYBC_LOAD_ATTR:
+                DECODE_QSTR;
+                *sp = rt_load_attr(*sp, qstr);
+                break;
+
+            case PYBC_LOAD_METHOD:
+                DECODE_QSTR;
+                sp -= 1;
+                rt_load_method(sp[1], qstr, sp);
+                break;
+
+            case PYBC_LOAD_BUILD_CLASS:
+                PUSH(rt_load_build_class());
+                break;
+
+            case PYBC_STORE_FAST_0:
+                fast0 = POP();
+                break;
+
+            case PYBC_STORE_FAST_1:
+                fast1 = POP();
+                break;
+
+            case PYBC_STORE_FAST_2:
+                fast2 = POP();
+                break;
+
+            case PYBC_STORE_FAST_N:
+                DECODE_UINT;
+                fastn[unum - 3] = POP();
+                break;
+
+            case PYBC_STORE_NAME:
+                DECODE_QSTR;
+                rt_store_name(qstr, POP());
+                break;
+
+            case PYBC_STORE_SUBSCR:
+                rt_store_subscr(sp[1], sp[0], sp[2]);
+                sp += 3;
+                break;
+
+            case PYBC_DUP_TOP:
+                obj1 = *sp;
+                PUSH(obj1);
+                break;
+
+            case PYBC_DUP_TOP_TWO:
+                sp -= 2;
+                sp[0] = sp[2];
+                sp[1] = sp[3];
+                break;
+
+            case PYBC_POP_TOP:
+                ++sp;
+                break;
+
+            case PYBC_ROT_THREE:
+                obj1 = sp[0];
+                sp[0] = sp[1];
+                sp[1] = sp[2];
+                sp[2] = obj1;
+                break;
+
+            case PYBC_JUMP:
+                DECODE_UINT;
+                ip = code + unum;
+                break;
+
+            case PYBC_POP_JUMP_IF_FALSE:
+                DECODE_UINT;
+                if (!rt_is_true(POP())) {
+                    ip = code + unum;
+                }
+                break;
+
+            case PYBC_SETUP_LOOP:
+                DECODE_UINT;
+                break;
+
+            case PYBC_POP_BLOCK:
+                break;
+
+            case PYBC_BINARY_OP:
+                unum = *ip++;
+                obj2 = POP();
+                obj1 = *sp;
+                *sp = rt_binary_op(unum, obj1, obj2);
+                break;
+
+            case PYBC_COMPARE_OP:
+                unum = *ip++;
+                obj2 = POP();
+                obj1 = *sp;
+                *sp = rt_compare_op(unum, obj1, obj2);
+                break;
+
+            case PYBC_BUILD_LIST:
+                DECODE_UINT;
+                obj1 = rt_build_list(unum, sp);
+                sp += unum - 1;
+                *sp = obj1;
+                break;
+
+            case PYBC_BUILD_MAP:
+                DECODE_UINT;
+                PUSH(rt_build_map(unum));
+                break;
+
+            case PYBC_STORE_MAP:
+                sp += 2;
+                rt_store_map(sp[0], sp[-2], sp[-1]);
+                break;
+
+            case PYBC_BUILD_SET:
+                DECODE_UINT;
+                obj1 = rt_build_set(unum, sp);
+                sp += unum - 1;
+                *sp = obj1;
+                break;
+
+            case PYBC_MAKE_FUNCTION:
+                DECODE_UINT;
+                PUSH(rt_make_function_from_id(unum));
+                break;
+
+            case PYBC_CALL_FUNCTION:
+                DECODE_UINT;
+                assert((unum & 0xff00) == 0); // n_keyword
+                // switch on n_positional
+                if ((unum & 0xff) == 0) {
+                    *sp = rt_call_function_0(*sp);
+                } else if ((unum & 0xff) == 1) {
+                    obj1 = *sp++; // the single argument
+                    *sp = rt_call_function_1(*sp, obj1);
+                } else if ((unum & 0xff) == 2) {
+                    obj2 = *sp++; // the second argument
+                    obj1 = *sp++; // the first argument
+                    *sp = rt_call_function_2(*sp, obj1, obj2);
+                } else {
+                    assert(0);
+                }
+                break;
+
+            case PYBC_CALL_METHOD:
+                DECODE_UINT;
+                assert((unum & 0xff00) == 0); // n_keyword
+                // switch on n_positional
+                if ((unum & 0xff) == 0) {
+                    obj1 = *sp++; // the self object (or NULL)
+                    *sp = rt_call_method_1(*sp, obj1);
+                } else if ((unum & 0xff) == 1) {
+                    obj2 = *sp++; // the first argument
+                    obj1 = *sp++; // the self object (or NULL)
+                    *sp = rt_call_function_2(*sp, obj1, obj2);
+                } else {
+                    assert(0);
+                }
+                break;
+
+            case PYBC_RETURN_VALUE:
+                return *sp;
+
+            default:
+                printf("code %p, offset %u, byte code 0x%02x not implemented\n", code, (uint)(ip - code), op);
+                assert(0);
+                return py_const_none;
+        }
+    }
+}

py/bc.h

+#define PYBC_LOAD_CONST_FALSE   (0x10)
+#define PYBC_LOAD_CONST_NONE    (0x11)
+#define PYBC_LOAD_CONST_TRUE    (0x12)
+#define PYBC_LOAD_CONST_SMALL_INT   (0x13) // int
+#define PYBC_LOAD_CONST_INT     (0x14) // qstr
+#define PYBC_LOAD_CONST_DEC     (0x15) // qstr
+#define PYBC_LOAD_CONST_ID      (0x16) // qstr
+#define PYBC_LOAD_CONST_BYTES   (0x17) // qstr
+#define PYBC_LOAD_CONST_STRING  (0x18) // qstr
+
+#define PYBC_LOAD_FAST_0        (0x20)
+#define PYBC_LOAD_FAST_1        (0x21)
+#define PYBC_LOAD_FAST_2        (0x22)
+#define PYBC_LOAD_FAST_N        (0x23) // uint
+#define PYBC_LOAD_NAME          (0x24) // qstr
+#define PYBC_LOAD_GLOBAL        (0x25) // qstr
+#define PYBC_LOAD_ATTR          (0x26) // qstr
+#define PYBC_LOAD_METHOD        (0x27) // qstr
+#define PYBC_LOAD_BUILD_CLASS   (0x28)
+
+#define PYBC_STORE_FAST_0       (0x30)
+#define PYBC_STORE_FAST_1       (0x31)
+#define PYBC_STORE_FAST_2       (0x32)
+#define PYBC_STORE_FAST_N       (0x33) // uint
+#define PYBC_STORE_NAME         (0x34) // qstr
+#define PYBC_STORE_GLOBAL       (0x35) // qstr
+#define PYBC_STORE_ATTR         (0x36) // qstr
+#define PYBC_STORE_LOCALS       (0x37)
+#define PYBC_STORE_SUBSCR       (0x38)
+
+#define PYBC_DELETE_FAST_N      (0x39) // uint
+#define PYBC_DELETE_NAME        (0x3a) // qstr
+#define PYBC_DELETE_GLOBAL      (0x3b) // qstr
+#define PYBC_DELETE_DEREF       (0x3c) // qstr
+#define PYBC_DELETE_ATTR        (0x3d) // qstr
+#define PYBC_DELETE_SUBSCR      (0x3e)
+
+#define PYBC_DUP_TOP            (0x40)
+#define PYBC_DUP_TOP_TWO        (0x41)
+#define PYBC_POP_TOP            (0x42)
+#define PYBC_ROT_TWO            (0x43)
+#define PYBC_ROT_THREE          (0x44)
+#define PYBC_JUMP               (0x45) // pos
+#define PYBC_POP_JUMP_IF_TRUE   (0x46) // pos
+#define PYBC_POP_JUMP_IF_FALSE  (0x47) // pos
+#define PYBC_JUMP_IF_TRUE_OR_POP    (0x48) // pos
+#define PYBC_JUMP_IF_FALSE_OR_POP   (0x49) // pos
+#define PYBC_SETUP_LOOP         (0x4a) // pos
+#define PYBC_BREAK_LOOP         (0x4b) // pos
+#define PYBC_CONTINUE_LOOP      (0x4c) // pos
+#define PYBC_SETUP_WITH         (0x4d) // pos
+#define PYBC_WITH_CLEANUP       (0x4e)
+#define PYBC_SETUP_EXCEPT       (0x4f) // pos
+#define PYBC_SETUP_FINALLY      (0x50) // pos
+#define PYBC_END_FINALLY        (0x51)
+#define PYBC_GET_ITER           (0x52)
+#define PYBC_FOR_ITER           (0x53) // pos
+#define PYBC_POP_BLOCK          (0x54)
+#define PYBC_POP_EXCEPT         (0x55)
+
+#define PYBC_UNARY_OP           (0x60) // byte
+#define PYBC_BINARY_OP          (0x61) // byte
+#define PYBC_COMPARE_OP         (0x62) // byte
+
+#define PYBC_BUILD_TUPLE        (0x70) // uint
+#define PYBC_BUILD_LIST         (0x71) // uint
+#define PYBC_LIST_APPEND        (0x72) // uint
+#define PYBC_BUILD_MAP          (0x73) // uint
+#define PYBC_STORE_MAP          (0x74)
+#define PYBC_MAP_ADD            (0x75) // uint
+#define PYBC_BUILD_SET          (0x76) // uint
+#define PYBC_SET_ADD            (0x77) // uint
+#define PYBC_BUILD_SLICE        (0x78) // uint
+#define PYBC_UNPACK_SEQUENCE    (0x79) // uint
+#define PYBC_UNPACK_EX          (0x7a) // uint
+
+#define PYBC_RETURN_VALUE       (0x80)
+#define PYBC_RAISE_VARARGS      (0x81) // uint
+#define PYBC_YIELD_VALUE        (0x82)
+#define PYBC_YIELD_FROM         (0x83)
+
+#define PYBC_MAKE_FUNCTION      (0x90) // uint
+#define PYBC_MAKE_CLOSURE       (0x91) // uint?
+#define PYBC_CALL_FUNCTION      (0x92) // uint
+#define PYBC_CALL_FUNCTION_VAR  (0x93) // uint
+#define PYBC_CALL_FUNCTION_KW   (0x94) // uint
+#define PYBC_CALL_FUNCTION_VAR_KW   (0x95) // uint
+#define PYBC_CALL_METHOD        (0x96) // uint
+#define PYBC_CALL_METHOD_VAR    (0x97) // uint
+#define PYBC_CALL_METHOD_KW     (0x98) // uint
+#define PYBC_CALL_METHOD_VAR_KW (0x99) // uint
+
+#define PYBC_IMPORT_NAME (0xe0)
+#define PYBC_IMPORT_FROM (0xe1)
+#define PYBC_IMPORT_STAR (0xe2)
+
+py_obj_t py_execute_byte_code(byte *code, uint len, py_obj_t *args, uint n_args);

py/compile.h

+void py_compile(py_parse_node_t pn);

py/emit.h

+//#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
+ * depends on determining the scope of variables in each function, and this
+ * is not known until the end of pass 1.
+ * As a consequence, we don't know the maximum stack size until the end of pass 2.
+ * This is problematic for some emitters (x64) since they need to know the maximum
+ * stack size to compile the entry to the function, and this effects code size.
+ */
+
+typedef enum {
+    PASS_1 = 1, // work out id's and their kind, and number of labels
+    PASS_2 = 2, // work out stack size and code size and label offsets
+    PASS_3 = 3, // emit code
+} pass_kind_t;
+
+typedef struct _emitter_t emitter_t;
+
+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);
+
+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);
+bool emit_last_emit_was_return_value(emitter_t *emit);
+int emit_get_stack_size(emitter_t *emit);
+void emit_set_stack_size(emitter_t *emit, int size);
+
+int emit_label_new(emitter_t *emit);
+void emit_label_assign(emitter_t *emit, int l);
+void emit_import_name(emitter_t *emit, qstr qstr);
+void emit_import_from(emitter_t *emit, qstr qstr);
+void emit_import_star(emitter_t *emit);
+void emit_load_const_tok(emitter_t *emit, py_token_kind_t tok);
+void emit_load_const_small_int(emitter_t *emit, int arg);
+void emit_load_const_int(emitter_t *emit, qstr qstr);
+void emit_load_const_dec(emitter_t *emit, qstr qstr);
+void emit_load_const_id(emitter_t *emit, qstr qstr);
+void emit_load_const_str(emitter_t *emit, qstr qstr, bool bytes);
+void emit_load_const_verbatim_start(emitter_t *emit);
+void emit_load_const_verbatim_int(emitter_t *emit, int val);
+void emit_load_const_verbatim_str(emitter_t *emit, const char *str);
+void emit_load_const_verbatim_strn(emitter_t *emit, const char *str, int len);
+void emit_load_const_verbatim_quoted_str(emitter_t *emit, qstr qstr, bool bytes);
+void emit_load_const_verbatim_end(emitter_t *emit);
+void emit_load_fast(emitter_t *emit, qstr qstr, int local_num);
+void emit_load_name(emitter_t *emit, qstr qstr);
+void emit_load_global(emitter_t *emit, qstr qstr);
+void emit_load_deref(emitter_t *emit, qstr qstr);
+void emit_load_closure(emitter_t *emit, qstr qstr);
+void emit_load_attr(emitter_t *emit, qstr qstr);
+void emit_load_method(emitter_t *emit, qstr qstr);
+void emit_load_build_class(emitter_t *emit);
+void emit_store_fast(emitter_t *emit, qstr qstr, int local_num);
+void emit_store_name(emitter_t *emit, qstr qstr);
+void emit_store_global(emitter_t *emit, qstr qstr);
+void emit_store_deref(emitter_t *emit, qstr qstr);
+void emit_store_attr(emitter_t *emit, qstr qstr);
+void emit_store_locals(emitter_t *emit);
+void emit_store_subscr(emitter_t *emit);
+void emit_delete_fast(emitter_t *emit, qstr qstr, int local_num);
+void emit_delete_name(emitter_t *emit, qstr qstr);
+void emit_delete_global(emitter_t *emit, qstr qstr);
+void emit_delete_deref(emitter_t *emit, qstr qstr);
+void emit_delete_attr(emitter_t *emit, qstr qstr);
+void emit_delete_subscr(emitter_t *emit);
+void emit_dup_top(emitter_t *emit);
+void emit_dup_top_two(emitter_t *emit);
+void emit_pop_top(emitter_t *emit);
+void emit_rot_two(emitter_t *emit);
+void emit_rot_three(emitter_t *emit);
+void emit_jump(emitter_t *emit, int label);
+void emit_pop_jump_if_true(emitter_t *emit, int label);
+void emit_pop_jump_if_false(emitter_t *emit, int label);
+void emit_jump_if_true_or_pop(emitter_t *emit, int label);
+void emit_jump_if_false_or_pop(emitter_t *emit, int label);
+void emit_setup_loop(emitter_t *emit, int label);
+void emit_break_loop(emitter_t *emit, int label);
+void emit_continue_loop(emitter_t *emit, int label);
+void emit_setup_with(emitter_t *emit, int label);
+void emit_with_cleanup(emitter_t *emit);
+void emit_setup_except(emitter_t *emit, int label);
+void emit_setup_finally(emitter_t *emit, int label);
+void emit_end_finally(emitter_t *emit);
+void emit_get_iter(emitter_t *emit); // tos = getiter(tos)
+void emit_for_iter(emitter_t *emit, int label);
+void emit_for_iter_end(emitter_t *emit);
+void emit_pop_block(emitter_t *emit);
+void emit_pop_except(emitter_t *emit);
+void emit_unary_op(emitter_t *emit, rt_unary_op_t op);
+void emit_binary_op(emitter_t *emit, rt_binary_op_t op);
+void emit_compare_op(emitter_t *emit, rt_compare_op_t op);
+void emit_build_tuple(emitter_t *emit, int n_args);
+void emit_build_list(emitter_t *emit, int n_args);
+void emit_list_append(emitter_t *emit, int list_stack_index);
+void emit_build_map(emitter_t *emit, int n_args);
+void emit_store_map(emitter_t *emit);
+void emit_map_add(emitter_t *emit, int map_stack_index);
+void emit_build_set(emitter_t *emit, int n_args);
+void emit_set_add(emitter_t *emit, int set_stack_index);
+void emit_build_slice(emitter_t *emit, int n_args);
+void emit_unpack_sequence(emitter_t *emit, int n_args);
+void emit_unpack_ex(emitter_t *emit, int n_left, int n_right);
+void emit_make_function(emitter_t *emit, scope_t *scope, int n_dict_params, int n_default_params);
+void emit_make_closure(emitter_t *emit, scope_t *scope, int n_dict_params, int n_default_params);
+void emit_call_function(emitter_t *emit, int n_positional, int n_keyword, bool have_star_arg, bool have_dbl_star_arg);
+void emit_call_method(emitter_t *emit, int n_positional, int n_keyword, bool have_star_arg, bool have_dbl_star_arg);
+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);

py/emitbc.c

+#include <unistd.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+
+#include "misc.h"
+#include "lexer.h"
+#include "machine.h"
+#include "parse.h"
+#include "compile.h"
+#include "scope.h"
+#include "runtime.h"
+#include "emit.h"
+#include "bc.h"
+
+#ifdef EMIT_DO_BC
+
+struct _emitter_t {
+    int pass;
+    int next_label;
+    int stack_size;
+    bool last_emit_was_return_value;
+
+    scope_t *scope;
+
+    int max_num_labels;
+    uint *label_offsets;
+
+    uint code_offset;
+    uint code_size;
+    byte *code_base;
+    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) {
+    return emit->code_size;
+}
+
+void* emit_get_code(emitter_t* emit) {
+    return emit->code_base;
+}
+
+void emit_start_pass(emitter_t *emit, pass_kind_t pass, scope_t *scope) {
+    emit->pass = pass;
+    emit->next_label = 1;
+    emit->stack_size = 0;
+    emit->last_emit_was_return_value = false;
+    emit->scope = scope;
+    if (pass == PASS_1) {
+        scope->unique_code_id = rt_get_new_unique_code_id();
+    } else if (pass > PASS_1) {
+        if (emit->label_offsets == NULL) {
+            emit->label_offsets = m_new(uint, emit->max_num_labels);
+        }
+        if (pass == PASS_2) {
+            memset(emit->label_offsets, -1, emit->max_num_labels * sizeof(uint));
+        }
+    }
+    emit->code_offset = 0;
+}
+
+void emit_end_pass(emitter_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);
+    }
+
+    if (emit->pass == PASS_1) {
+        // calculate number of labels need
+        if (emit->next_label > emit->max_num_labels) {
+            emit->max_num_labels = emit->next_label;
+        }
+
+    } else if (emit->pass == PASS_2) {
+        // calculate size of code in bytes
+        emit->code_size = emit->code_offset;
+        emit->code_base = m_new(byte, emit->code_size);
+        printf("code_size: %u\n", emit->code_size);
+
+    } else if (emit->pass == PASS_3) {
+        rt_assign_byte_code(emit->scope->unique_code_id, emit->code_base, emit->code_size, emit->scope->num_params);
+    }
+}
+
+// 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) {
+    //printf("emit %d\n", num_bytes_to_write);
+    if (emit->pass < PASS_3) {
+        emit->code_offset += num_bytes_to_write;
+        return emit->dummy_data;
+    } else {
+        assert(emit->code_offset + num_bytes_to_write <= emit->code_size);
+        byte *c = emit->code_base + emit->code_offset;
+        emit->code_offset += num_bytes_to_write;
+        return c;
+    }
+}
+
+static void emit_write_byte_1(emitter_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) {
+    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) {
+    assert((num & (~0x7fff)) == 0 || (num & (~0x7fff)) == (~0x7fff));
+    byte* c = emit_get_cur_to_write_bytes(emit, 3);
+    c[0] = b1;
+    c[1] = num;
+    c[2] = num >> 8;
+}
+
+static void emit_write_byte_1_uint(emitter_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);
+        c[0] = b1;
+        c[1] = num;
+    } else if (num <= 16383) { // fits in 0x3fff
+        // fit argument in two bytes
+        byte* c = emit_get_cur_to_write_bytes(emit, 3);
+        c[0] = b1;
+        c[1] = (num >> 8) | 0x80;
+        c[2] = num;
+    } else {
+        // larger numbers not implemented/supported
+        assert(0);
+    }
+}
+
+static void emit_write_byte_1_qstr(emitter_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) {
+    uint code_offset;
+    if (emit->pass < PASS_3) {
+        code_offset = 0;
+    } else {
+        code_offset = emit->label_offsets[label];
+    }
+    emit_write_byte_1_uint(emit, b1, code_offset);
+}
+
+bool emit_last_emit_was_return_value(emitter_t *emit) {
+    return emit->last_emit_was_return_value;
+}
+
+int emit_get_stack_size(emitter_t *emit) {
+    return emit->stack_size;
+}
+
+void emit_set_stack_size(emitter_t *emit, int size) {
+    if (emit->pass > PASS_1) {
+        emit->stack_size = size;
+    }
+}
+
+static void emit_pre(emitter_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) {
+            emit->scope->stack_size = emit->stack_size;
+        }
+    }
+    emit->last_emit_was_return_value = false;
+}
+
+int emit_label_new(emitter_t *emit) {
+    return emit->next_label++;
+}
+
+void emit_label_assign(emitter_t *emit, int l) {
+    emit_pre(emit, 0);
+    if (emit->pass > PASS_1) {
+        assert(l < emit->max_num_labels);
+        if (emit->pass == PASS_2) {
+            // assign label offset
+            assert(emit->label_offsets[l] == -1);
+            emit->label_offsets[l] = emit->code_offset;
+        } else if (emit->pass == PASS_3) {
+            // ensure label offset has not changed from PASS_2 to PASS_3
+            assert(emit->label_offsets[l] == emit->code_offset);
+            //printf("l%d: (at %d)\n", l, emit->code_offset);
+        }
+    }
+}
+
+void emit_import_name(emitter_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) {
+    emit_pre(emit, 1);
+    emit_write_byte_1_qstr(emit, PYBC_IMPORT_FROM, qstr);
+}
+
+void emit_import_star(emitter_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) {
+    emit_pre(emit, 1);
+    switch (tok) {
+        case PY_TOKEN_KW_FALSE: emit_write_byte_1(emit, PYBC_LOAD_CONST_FALSE); break;
+        case PY_TOKEN_KW_NONE: emit_write_byte_1(emit, PYBC_LOAD_CONST_NONE); break;
+        case PY_TOKEN_KW_TRUE: emit_write_byte_1(emit, PYBC_LOAD_CONST_TRUE); break;
+        default: assert(0);
+    }
+}
+
+void emit_load_const_small_int(emitter_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) {
+    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) {
+    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) {
+    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) {
+    emit_pre(emit, 1);
+    if (bytes) {
+        emit_write_byte_1_qstr(emit, PYBC_LOAD_CONST_BYTES, qstr);
+    } else {
+        emit_write_byte_1_qstr(emit, PYBC_LOAD_CONST_STRING, qstr);
+    }
+}
+
+void emit_load_const_verbatim_start(emitter_t *emit) {
+    emit_pre(emit, 1);
+    assert(0);
+}
+
+void emit_load_const_verbatim_int(emitter_t *emit, int val) {
+    assert(0);
+}
+
+void emit_load_const_verbatim_str(emitter_t *emit, const char *str) {
+    assert(0);
+}
+
+void emit_load_const_verbatim_strn(emitter_t *emit, const char *str, int len) {
+    assert(0);
+}
+
+void emit_load_const_verbatim_quoted_str(emitter_t *emit, qstr qstr, bool bytes) {
+    assert(0);
+}
+
+void emit_load_const_verbatim_end(emitter_t *emit) {
+    assert(0);
+}
+
+void emit_load_fast(emitter_t *emit, qstr qstr, int local_num) {
+    assert(local_num >= 0);
+    emit_pre(emit, 1);
+    switch (local_num) {
+        case 0: emit_write_byte_1(emit, PYBC_LOAD_FAST_0); break;
+        case 1: emit_write_byte_1(emit, PYBC_LOAD_FAST_1); break;
+        case 2: emit_write_byte_1(emit, PYBC_LOAD_FAST_2); break;
+        default: emit_write_byte_1_uint(emit, PYBC_LOAD_FAST_N, local_num); break;
+    }
+}
+
+void emit_load_name(emitter_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) {
+    emit_pre(emit, 1);
+    emit_write_byte_1_qstr(emit, PYBC_LOAD_GLOBAL, qstr);
+}
+
+void emit_load_deref(emitter_t *emit, qstr qstr) {
+    emit_pre(emit, 1);
+    assert(0);
+}
+
+void emit_load_closure(emitter_t *emit, qstr qstr) {
+    emit_pre(emit, 1);
+    assert(0);
+}
+
+void emit_load_attr(emitter_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) {
+    emit_pre(emit, 0);
+    emit_write_byte_1_qstr(emit, PYBC_LOAD_METHOD, qstr);
+}
+
+void emit_load_build_class(emitter_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) {
+    assert(local_num >= 0);
+    emit_pre(emit, -1);
+    switch (local_num) {
+        case 0: emit_write_byte_1(emit, PYBC_STORE_FAST_0); break;
+        case 1: emit_write_byte_1(emit, PYBC_STORE_FAST_1); break;
+        case 2: emit_write_byte_1(emit, PYBC_STORE_FAST_2); break;
+        default: emit_write_byte_1_uint(emit, PYBC_STORE_FAST_N, local_num); break;
+    }
+}
+
+void emit_store_name(emitter_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) {
+    emit_pre(emit, -1);
+    emit_write_byte_1_qstr(emit, PYBC_STORE_GLOBAL, qstr);
+}
+
+void emit_store_deref(emitter_t *emit, qstr qstr) {
+    emit_pre(emit, -1);
+    assert(0);
+}
+
+void emit_store_attr(emitter_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) {
+    emit_pre(emit, -1);
+    emit_write_byte_1(emit, PYBC_STORE_LOCALS);
+}
+
+void emit_store_subscr(emitter_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) {
+    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) {
+    emit_pre(emit, 0);
+    emit_write_byte_1_qstr(emit, PYBC_DELETE_NAME, qstr);
+}
+
+void emit_delete_global(emitter_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) {
+    emit_pre(emit, 0);
+    emit_write_byte_1_qstr(emit, PYBC_DELETE_DEREF, qstr);
+}
+
+void emit_delete_attr(emitter_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) {
+    emit_pre(emit, -2);
+    emit_write_byte_1(emit, PYBC_DELETE_SUBSCR);
+}
+
+void emit_dup_top(emitter_t *emit) {
+    emit_pre(emit, 1);
+    emit_write_byte_1(emit, PYBC_DUP_TOP);
+}
+
+void emit_dup_top_two(emitter_t *emit) {
+    emit_pre(emit, 2);
+    emit_write_byte_1(emit, PYBC_DUP_TOP_TWO);
+}
+
+void emit_pop_top(emitter_t *emit) {
+    emit_pre(emit, -1);
+    emit_write_byte_1(emit, PYBC_POP_TOP);
+}
+
+void emit_rot_two(emitter_t *emit) {
+    emit_pre(emit, 0);
+    emit_write_byte_1(emit, PYBC_ROT_TWO);
+}
+
+void emit_rot_three(emitter_t *emit) {
+    emit_pre(emit, 0);
+    emit_write_byte_1(emit, PYBC_ROT_THREE);
+}
+
+void emit_jump(emitter_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) {
+    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) {
+    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) {
+    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) {
+    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) {
+    emit_pre(emit, 0);
+    emit_write_byte_1_label(emit, PYBC_SETUP_LOOP, label);
+}
+
+void emit_break_loop(emitter_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) {
+    emit_pre(emit, 0);
+    emit_write_byte_1_label(emit, PYBC_CONTINUE_LOOP, label);
+}
+
+void emit_setup_with(emitter_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) {
+    emit_pre(emit, -7);
+    emit_write_byte_1(emit, PYBC_WITH_CLEANUP);
+}
+
+void emit_setup_except(emitter_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) {
+    emit_pre(emit, 6);
+    emit_write_byte_1_label(emit, PYBC_SETUP_FINALLY, label);
+}
+
+void emit_end_finally(emitter_t *emit) {
+    emit_pre(emit, -1);
+    emit_write_byte_1(emit, PYBC_END_FINALLY);
+}
+
+void emit_get_iter(emitter_t *emit) {
+    emit_pre(emit, 0);
+    emit_write_byte_1(emit, PYBC_GET_ITER);
+}
+
+void emit_for_iter(emitter_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) {
+    emit_pre(emit, -1);
+}
+
+void emit_pop_block(emitter_t *emit) {
+    emit_pre(emit, 0);
+    emit_write_byte_1(emit, PYBC_POP_BLOCK);
+}
+
+void emit_pop_except(emitter_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) {
+    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) {
+    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) {
+    emit_pre(emit, -1);
+    emit_write_byte_1_byte(emit, PYBC_COMPARE_OP, op);
+}
+
+void emit_build_tuple(emitter_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) {
+    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) {
+    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) {
+    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) {
+    emit_pre(emit, -2);
+    emit_write_byte_1(emit, PYBC_STORE_MAP);
+}
+
+void emit_map_add(emitter_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) {
+    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) {
+    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) {
+    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) {
+    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) {
+    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) {
+    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) {
+    assert(0);
+    emit_pre(emit, -2 - n_default_params - 2 * n_dict_params);
+    if (emit->pass == PASS_3) {
+        printf("MAKE_CLOSURE %d\n", (n_dict_params << 8) | n_default_params);
+    }
+}
+
+void emit_call_function(emitter_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;
+    }
+    if (have_dbl_star_arg) {
+        s += 1;
+    }
+    emit_pre(emit, -n_positional - 2 * n_keyword - s);
+    int op;
+    if (have_star_arg) {
+        if (have_dbl_star_arg) {
+            op = PYBC_CALL_FUNCTION_VAR_KW;
+        } else {
+            op = PYBC_CALL_FUNCTION_VAR;
+        }
+    } else {
+        if (have_dbl_star_arg) {
+            op = PYBC_CALL_FUNCTION_KW;
+        } else {
+            op = PYBC_CALL_FUNCTION;
+        }
+    }
+    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) {
+    int s = 0;
+    if (have_star_arg) {
+        s += 1;
+    }
+    if (have_dbl_star_arg) {
+        s += 1;
+    }
+    emit_pre(emit, -n_positional - 2 * n_keyword - s);
+    int op;
+    if (have_star_arg) {
+        if (have_dbl_star_arg) {
+            op = PYBC_CALL_METHOD_VAR_KW;
+        } else {
+            op = PYBC_CALL_METHOD_VAR;
+        }
+    } else {
+        if (have_dbl_star_arg) {
+            op = PYBC_CALL_METHOD_KW;
+        } else {
+            op = PYBC_CALL_METHOD;
+        }
+    }
+    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) {
+    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) {
+    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) {
+    emit_pre(emit, 0);
+    if (emit->pass == PASS_2) {
+        emit->scope->flags |= SCOPE_FLAG_GENERATOR;
+    }
+    emit_write_byte_1(emit, PYBC_YIELD_VALUE);
+}
+
+void emit_yield_from(emitter_t *emit) {
+    emit_pre(emit, -1);
+    if (emit->pass == PASS_2) {
+        emit->scope->flags |= SCOPE_FLAG_GENERATOR;
+    }
+    emit_write_byte_1(emit, PYBC_YIELD_FROM);
+}
+
+#endif // EMIT_DO_BC

py/lexerfile.c

+#include <stdint.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <fcntl.h>
+
+#include "misc.h"
+#include "lexer.h"
+
+py_lexer_t *py_lexer_from_file(const char *filename) {
+    // TODO abstract away file functionality
+    int fd = open(filename, O_RDONLY);
+    if (fd < 0) {
+        printf("cannot open file %s\n", filename);
+        return NULL;
+    }
+    uint size = lseek(fd, 0, SEEK_END);
+    lseek(fd, 0, SEEK_SET);
+    char *data = m_new(char, size);
+    read(fd, data, size);
+    close(fd);
+
+    return py_lexer_from_str_len(filename, data, size, true);
+}