path: root/src/compiler.c

#ifndef COMPILER_C
#define COMPILER_C

#include "badlib.h"

#include "parser.c"

typedef struct Variable {
    Str name;
    Str type;
    sz size;
    sz offset;
    sz idx;
} Variable;

MAPDEF(StrVarMap, varmap, Str, Variable, str_hash, str_eq)

typedef struct Instruction {
    u8 dst;
    u8 a;
    u8 b;
    u8 op;
} Instruction;

typedef union Constant {
    s64 i;
    u64 u;
    double f;
    ptrsize ptr;
} Constant;

typedef struct Chunk {
    sz id;
    Instruction *code;

    // Constant values that fit in 64 bits.
    Constant *constants;
    IntIntMap *intmap;
    sz const_idx;

    // Constant strings.
    Str *strings;
    StrIntMap *strmap;
    sz str_idx;

    // Global/Local variables.
    Variable *vars;
    StrVarMap *varmap;
    sz var_off;

    // Number of registers currently used in this chunk.
    sz reg_idx;

    // Debugging.
    Str file_name;
    Arena *storage;
    // TODO: line/col info for debugging.
} Chunk;

typedef enum OpCode {
    //            OP    DST   A   B
    // ---------------------------------------------------------------
    // VM/high level instructions.
    OP_HALT,    // halt
    OP_STVARI,  // stvari vx, ca
    OP_STVAR,   // stvar  vx, ra
    OP_LDVAR,   // ldvar  rx, vx
    // Load/Store instructions.
    OP_LD8K,   // ld8k   rx, ca      -> u8  rx = ca
    OP_LD16K,  // ld16k  rx, ca      -> u16 rx = ca
    OP_LD32K,  // ld32k  rx, ca      -> u32 rx = ca
    OP_LD64K,  // ld64k  rx, ca      -> u64 rx = ca
    OP_LD8I,   // ld8i   rx, ra, cb  -> u8  *p; rx = p[ra + cb]
    OP_LD16I,  // ld16i  rx, ra, cb  -> u16 *p; rx = p[ra + cb]
    OP_LD32I,  // ld32i  rx, ra, cb  -> u32 *p; rx = p[ra + cb]
    OP_LD64I,  // ld64i  rx, ra, cb  -> u64 *p; rx = p[ra + cb]
    OP_LD8,    // ld8    rx, ra, rb  -> u8  *p; rx = p[ra + rb]
    OP_LD16,   // ld16   rx, ra, rb  -> u16 *p; rx = p[ra + rb]
    OP_LD32,   // ld32   rx, ra, rb  -> u32 *p; rx = p[ra + rb]
    OP_LD64,   // ld64   rx, ra, rb  -> u64 *p; rx = p[ra + rb]
    OP_ST8I,   // st8i   rx, ra, cb  -> u8  *p; p[ra + cb] = rx
    OP_ST16I,  // st16i  rx, ra, cb  -> u16 *p; p[ra + cb] = rx
    OP_ST32I,  // st32i  rx, ra, cb  -> u32 *p; p[ra + cb] = rx
    OP_ST64I,  // st64i  rx, ra, cb  -> u64 *p; p[ra + cb] = rx
    OP_ST8,    // st8    rx, ra, rb  -> u8  *p; p[ra + rb] = rx
    OP_ST16,   // st16   rx, ra, rb  -> u16 *p; p[ra + rb] = rx
    OP_ST32,   // st32   rx, ra, rb  -> u32 *p; p[ra + rb] = rx
    OP_ST64,   // st64   rx, ra, rb  -> u64 *p; p[ra + rb] = rx
    // Integer arithmetic (only int/s64 for now).
    OP_ADDI,  // addk   rx, ra, cb
    OP_SUBI,  // subk   rx, ra, cb
    OP_MULI,  // mulk   rx, ra, cb
    OP_DIVI,  // divk   rx, ra, cb
    OP_MODI,  // modk   rx, ra, cb
    OP_ADD,   // add    rx, ra, rb
    OP_SUB,   // sub    rx, ra, rb
    OP_MUL,   // mul    rx, ra, rb
    OP_DIV,   // div    rx, ra, rb
    OP_MOD,   // mod    rx, ra, rb
    // Floating point arithmetic (only f64 for now).
    OP_ADDFI,  // addfk  rx, ra, cb
    OP_SUBFI,  // subfk  rx, ra, cb
    OP_MULFI,  // mulfk  rx, ra, cb
    OP_DIVFI,  // divfk  rx, ra, cb
    OP_MODFI,  // modfk  rx, ra, cb
    OP_ADDF,   // addf   rx, ra, rb
    OP_SUBF,   // subf   rx, ra, rb
    OP_MULF,   // mulf   rx, ra, rb
    OP_DIVF,   // divf   rx, ra, rb
    OP_MODF,   // modf   rx, ra, rb
    // Register-to-register copy.
    OP_MOV8,   // mov8   rx, ra  -> rx = ra & 0xFF
    OP_MOV16,  // mov16  rx, ra  -> rx = ra & 0xFFFF
    OP_MOV32,  // mov32  rx, ra  -> rx = ra & 0xFFFFFFFF
    OP_MOV64,  // mov64  rx, ra  -> rx = ra & 0xFFFFFFFFFFFFFFFF
    // Logic operations (only 64 bits for now).
    OP_EQI,   // eqk   rx, ra, cb
    OP_NEQI,  // neqk   rx, ra, cb
    OP_LTI,   // ltk   rx, ra, cb
    OP_GTI,   // gtk   rx, ra, cb
    OP_LEI,   // lek   rx, ra, cb
    OP_GEI,   // gek   rx, ra, cb
    OP_ANDI,  // andk   rx, ra, cb
    OP_ORI,   // ork    rx, ra, cb
    OP_NOTI,  // noti  rx, ra
    OP_EQ,    // eq    rx, ra, rb
    OP_NEQ,   // neq    rx, ra, rb
    OP_LT,    // lt    rx, ra, rb
    OP_GT,    // gt    rx, ra, rb
    OP_LE,    // le    rx, ra, rb
    OP_GE,    // ge    rx, ra, rb
    OP_AND,   // and   rx, ra, rb
    OP_OR,    // or    rx, ra, rb
    OP_NOT,   // not   rx, ra
    // Bitwise operations.
    OP_BITLSHIFTI,  // shli   rx, ra, cb
    OP_BITRSHIFTI,  // shri   rx, ra, cb
    OP_BITANDI,     // bandi  rx, ra, cb
    OP_BITORI,      // bori   rx, ra, cb
    OP_BITNOTI,     // bnoti  rx, ca
    OP_BITLSHIFT,   // shl    rx, ra, rb
    OP_BITRSHIFT,   // shr    rx, ra, rb
    OP_BITAND,      // band   rx, ra, rb
    OP_BITOR,       // bor    rx, ra, rb
    OP_BITNOT,      // bnot   rx, ra
} OpCode;

Str op_str[] = {
    [OP_HALT] = cstr("HALT    "),
    [OP_STVAR] = cstr("STVAR   "),
    [OP_STVARI] = cstr("STVARI  "),
    [OP_LDVAR] = cstr("LDVAR   "),
    // Load ops.
    [OP_LD8K] = cstr("LD8K    "),
    [OP_LD16K] = cstr("LD16K   "),
    [OP_LD32K] = cstr("LD32K   "),
    [OP_LD64K] = cstr("LD64K   "),
    [OP_LD8I] = cstr("LD8I    "),
    [OP_LD16I] = cstr("LD16I   "),
    [OP_LD32I] = cstr("LD32I   "),
    [OP_LD64I] = cstr("LD64I   "),
    [OP_LD8] = cstr("LD8     "),
    [OP_LD16] = cstr("LD16    "),
    [OP_LD32] = cstr("LD32    "),
    [OP_LD64] = cstr("LD64    "),
    // Store ops.
    [OP_ST8I] = cstr("ST8I    "),
    [OP_ST16I] = cstr("ST16I   "),
    [OP_ST32I] = cstr("ST32I   "),
    [OP_ST64I] = cstr("ST64I   "),
    [OP_ST8] = cstr("ST8     "),
    [OP_ST16] = cstr("ST16    "),
    [OP_ST32] = cstr("ST32    "),
    [OP_ST64] = cstr("ST64    "),
    // Arithmetic.
    [OP_ADDI] = cstr("ADDI    "),
    [OP_SUBI] = cstr("SUBI    "),
    [OP_MULI] = cstr("MULI    "),
    [OP_DIVI] = cstr("DIVI    "),
    [OP_MODI] = cstr("MODI    "),
    [OP_ADD] = cstr("ADD     "),
    [OP_SUB] = cstr("SUB     "),
    [OP_MUL] = cstr("MUL     "),
    [OP_DIV] = cstr("DIV     "),
    [OP_MOD] = cstr("MOD     "),
    [OP_ADDFI] = cstr("ADDFI   "),
    [OP_SUBFI] = cstr("SUBFI   "),
    [OP_MULFI] = cstr("MULFI   "),
    [OP_DIVFI] = cstr("DIVFI   "),
    [OP_MODFI] = cstr("MODFI   "),
    [OP_ADDF] = cstr("ADDF    "),
    [OP_SUBF] = cstr("SUBF    "),
    [OP_MULF] = cstr("MULF    "),
    [OP_DIVF] = cstr("DIVF    "),
    // Reg copy/move.
    [OP_MODF] = cstr("MODF    "),
    [OP_MOV8] = cstr("MOV8    "),
    [OP_MOV16] = cstr("MOV16   "),
    [OP_MOV32] = cstr("MOV32   "),
    [OP_MOV64] = cstr("MOV64   "),
    // Logic operations.
    [OP_EQI] = cstr("EQI     "),
    [OP_NEQI] = cstr("NEQI    "),
    [OP_LTI] = cstr("LTI     "),
    [OP_GTI] = cstr("GTI     "),
    [OP_LEI] = cstr("LEI     "),
    [OP_GEI] = cstr("GEI     "),
    [OP_ANDI] = cstr("ANDI    "),
    [OP_ORI] = cstr("ORI     "),
    [OP_NOTI] = cstr("NOTI    "),
    [OP_EQ] = cstr("EQ      "),
    [OP_NEQ] = cstr("NEQ     "),
    [OP_LT] = cstr("LT      "),
    [OP_GT] = cstr("GT      "),
    [OP_LE] = cstr("LE      "),
    [OP_GE] = cstr("GE      "),
    [OP_AND] = cstr("AND     "),
    [OP_OR] = cstr("OR      "),
    [OP_NOT] = cstr("NOT     "),
    // Bitwise operations.
    [OP_BITLSHIFTI] = cstr("LSHI    "),
    [OP_BITRSHIFTI] = cstr("RSHI    "),
    [OP_BITANDI] = cstr("BANDI   "),
    [OP_BITORI] = cstr("BORI    "),
    [OP_BITNOTI] = cstr("BNOTI   "),
    [OP_BITLSHIFT] = cstr("LSH     "),
    [OP_BITRSHIFT] = cstr("RSH     "),
    [OP_BITAND] = cstr("BAND    "),
    [OP_BITOR] = cstr("BOR     "),
    [OP_BITNOT] = cstr("BNOT    "),
};

typedef enum {
    COMP_NIL,
    COMP_CONST,
    COMP_STRING,
    COMP_REG,
    COMP_ERR,
} CompResultType;

typedef struct CompResult {
    sz idx;
    CompResultType type;
} CompResult;

CompResult compile_expr(Chunk *chunk, Node *node);

#define EMIT_OP(OP, DST, A, B, NODE, CHUNK)                \
    do {                                                   \
        Instruction inst = (Instruction){                  \
            .op = (OP),                                    \
            .dst = (DST),                                  \
            .a = (A),                                      \
            .b = (B),                                      \
        };                                                 \
        array_push((CHUNK)->code, inst, (CHUNK)->storage); \
    } while (0)

CompResult
compile_binary(Chunk *chunk, Node *node) {
    OpCode op = OP_HALT;
    OpCode opi = OP_HALT;
    OpCode ldop = OP_LD64K;
    switch (node->kind) {
        // Arithmetic.
        case NODE_ADD: {
            if (str_eq(node->type, cstr("int"))) {
                op = OP_ADD;
                opi = OP_ADDI;
            } else if (str_eq(node->type, cstr("f64"))) {
                op = OP_ADDF;
                opi = OP_ADDFI;
            }
        } break;
        case NODE_SUB: {
            if (str_eq(node->type, cstr("int"))) {
                op = OP_SUB;
                opi = OP_SUBI;
            } else if (str_eq(node->type, cstr("f64"))) {
                op = OP_SUBF;
                opi = OP_SUBFI;
            }
        } break;
        case NODE_MUL: {
            if (str_eq(node->type, cstr("int"))) {
                op = OP_MUL;
                opi = OP_MULI;
            } else if (str_eq(node->type, cstr("f64"))) {
                op = OP_MULF;
                opi = OP_MULFI;
            }
        } break;
        case NODE_DIV: {
            if (str_eq(node->type, cstr("int"))) {
                op = OP_DIV;
                opi = OP_DIVI;
            } else if (str_eq(node->type, cstr("f64"))) {
                op = OP_DIVF;
                opi = OP_DIVFI;
            }
        } break;
        case NODE_MOD: {
            if (str_eq(node->type, cstr("int"))) {
                op = OP_MOD;
                opi = OP_MODI;
            } else if (str_eq(node->type, cstr("f64"))) {
                op = OP_MODF;
                opi = OP_MODFI;
            }
        } break;
        // Logic.
        case NODE_EQ: {
            op = OP_EQ;
            opi = OP_EQI;
        } break;
        case NODE_NEQ: {
            op = OP_NEQ;
            opi = OP_NEQI;
        } break;
        case NODE_LT: {
            op = OP_LT;
            opi = OP_LTI;
        } break;
        case NODE_GT: {
            op = OP_GT;
            opi = OP_GTI;
        } break;
        case NODE_LE: {
            op = OP_LE;
            opi = OP_LEI;
        } break;
        case NODE_GE: {
            op = OP_GE;
            opi = OP_GEI;
        } break;
        case NODE_AND: {
            op = OP_AND;
            opi = OP_ANDI;
        } break;
        case NODE_OR: {
            op = OP_OR;
            opi = OP_ORI;
        } break;
        // Bitwise.
        case NODE_BITOR: {
            op = OP_BITOR;
            opi = OP_BITORI;
        } break;
        case NODE_BITAND: {
            op = OP_BITAND;
            opi = OP_BITANDI;
        } break;
        case NODE_BITLSHIFT: {
            op = OP_BITLSHIFT;
            opi = OP_BITLSHIFTI;
        } break;
        case NODE_BITRSHIFT: {
            op = OP_BITRSHIFT;
            opi = OP_BITRSHIFTI;
        } break;
        default: break;
    }
    CompResult comp_a = compile_expr(chunk, node->left);
    CompResult comp_b = compile_expr(chunk, node->right);
    sz reg_a;
    sz reg_b;
    switch (comp_a.type) {
        case COMP_CONST: {
            reg_a = chunk->reg_idx++;
            EMIT_OP(ldop, reg_a, comp_a.idx, 0, node, chunk);
        } break;
        case COMP_REG: {
            reg_a = comp_a.idx;
        } break;
        default: {
            return (CompResult){.type = COMP_ERR};
        } break;
    }
    switch (comp_b.type) {
        case COMP_CONST: {
            reg_b = comp_b.idx;
            op = opi;
        } break;
        case COMP_REG: {
            reg_b = comp_b.idx;
        } break;
        default: {
            return (CompResult){.type = COMP_ERR};
        } break;
    }
    sz reg_dst = chunk->reg_idx++;  // Better for optimization
    EMIT_OP(op, reg_dst, reg_a, reg_b, node, chunk);
    return (CompResult){.type = COMP_REG, .idx = reg_dst};
}

CompResult
compile_unary(Chunk *chunk, Node *node) {
    OpCode op = OP_HALT;
    OpCode opi = OP_HALT;
    switch (node->kind) {
        case NODE_NOT: {
            op = OP_NOT;
            opi = OP_NOTI;
        } break;
        case NODE_BITNOT: {
            op = OP_BITNOT;
            opi = OP_BITNOTI;
        } break;
        default: break;
    }
    CompResult comp_a = compile_expr(chunk, node->left);
    sz reg_a;
    switch (comp_a.type) {
        case COMP_CONST: {
            reg_a = comp_a.idx;
            op = opi;
        } break;
        case COMP_REG: {
            reg_a = comp_a.idx;
        } break;
        default: {
            return (CompResult){.type = COMP_ERR};
        } break;
    }
    sz reg_dst = chunk->reg_idx++;
    EMIT_OP(op, reg_dst, reg_a, 0, node, chunk);
    return (CompResult){.type = COMP_REG, .idx = reg_dst};
}

CompResult
compile_expr(Chunk *chunk, Node *node) {
    switch (node->kind) {
        // Logic.
        // case NODE_XOR:
        case NODE_BITNOT:
        case NODE_NOT: return compile_unary(chunk, node); break;
        case NODE_AND:
        case NODE_OR:
        case NODE_EQ:
        case NODE_NEQ:
        case NODE_LT:
        case NODE_GT:
        case NODE_LE:
        // Bitwise ops.
        case NODE_BITAND:
        case NODE_BITOR:
        case NODE_BITLSHIFT:
        case NODE_BITRSHIFT:
        // Arithmetic.
        case NODE_GE:
        case NODE_ADD:
        case NODE_SUB:
        case NODE_MUL:
        case NODE_DIV:
        case NODE_MOD: return compile_binary(chunk, node); break;
        case NODE_TRUE:
        case NODE_FALSE:
        case NODE_NUM_FLOAT:
        case NODE_NUM_UINT:
        case NODE_NUM_INT: {
            sz value = node->value.i;
            // Make sure we don't have duplicated constants.
            IntIntMap *map = intintmap_lookup(&chunk->intmap, value);
            if (!map) {
                map = intintmap_insert(&chunk->intmap, value,
                                       chunk->const_idx++, chunk->storage);
                Constant c = (Constant){.i = node->value.i};
                array_push(chunk->constants, c, chunk->storage);
            }
            return (CompResult){
                .type = COMP_CONST,
                .idx = map->val,
            };
        } break;
        case NODE_STRING: {
            Str string = node->value.str;
            // Make sure we don't have duplicated strings.
            StrIntMap *map = strintmap_lookup(&chunk->strmap, string);
            if (!map) {
                map = strintmap_insert(&chunk->strmap, string, chunk->str_idx++,
                                       chunk->storage);
                array_push(chunk->strings, string, chunk->storage);
            }
            return (CompResult){
                .type = COMP_STRING,
                .idx = map->val,
            };
        } break;
        case NODE_LET: {
            sz idx = array_size(chunk->vars);
            Str name = node->unique_name;
            Str type = node->var_name->type;
            sz size = 8;
            // TODO: get type storage from a table to consider all the basic
            // types as well as user defined ones.
            if (str_eq(type, cstr("str"))) {
                size = 16;
            }
            Variable var = (Variable){
                .name = name,
                .type = type,
                .size = size,
                .offset = chunk->var_off,
                .idx = idx,
            };
            varmap_insert(&chunk->varmap, name, var, chunk->storage);
            array_push(chunk->vars, var, chunk->storage);
            chunk->var_off += size;

            // Value.
            if (node->var_val) {
                CompResult res = compile_expr(chunk, node->var_val);
                switch (res.type) {
                    case COMP_CONST: {
                        EMIT_OP(OP_STVARI, idx, res.idx, 0, node->var_val,
                                chunk);
                    } break;
                    case COMP_REG: {
                        EMIT_OP(OP_STVAR, idx, res.idx, 0, node->var_val,
                                chunk);
                    } break;
                    default: {
                        return (CompResult){.type = COMP_ERR};
                    } break;
                }
            }

            return (CompResult){.type = COMP_NIL};
        } break;
        case NODE_SYMBOL: {
            Str name = node->unique_name;
            StrVarMap *map = varmap_lookup(&chunk->varmap, name);
            if (!map) {
                println("error: unreachable... name: %s", name);
                exit(EXIT_FAILURE);
            }
            Variable var = map->val;
            u8 reg_dst = chunk->reg_idx++;
            EMIT_OP(OP_LDVAR, reg_dst, var.idx, 0, node->var_val, chunk);
            return (CompResult){.type = COMP_REG, .idx = reg_dst};
        } break;
        case NODE_BLOCK: {
            CompResult res;
            for (sz i = 0; i < array_size(node->elements); i++) {
                Node *root = node->elements[i];
                res = compile_expr(chunk, root);
            }
            return res;
        } break;
        default: {
            eprintln("error: compilation not implemented for node %s",
                     node_str[node->kind]);
            exit(EXIT_FAILURE);
        } break;
    }
    return (CompResult){.type = COMP_ERR};
}

void
disassemble_instruction(Instruction instruction) {
    switch (instruction.op) {
        case OP_MOV8:
        case OP_MOV16:
        case OP_MOV32:
        case OP_MOV64:
            println("%s r%d, r%d", op_str[instruction.op], instruction.dst,
                    instruction.a, instruction.b);
            break;
        case OP_LD8K:
        case OP_LD16K:
        case OP_LD32K:
        case OP_LD64K:
            println("%s r%d, c%d", op_str[instruction.op], instruction.dst,
                    instruction.a, instruction.b);
            break;
        case OP_LD8I:
        case OP_LD16I:
        case OP_LD32I:
        case OP_LD64I:
        case OP_ST8I:
        case OP_ST16I:
        case OP_ST32I:
        case OP_ST64I:
        case OP_ADDI:
        case OP_SUBI:
        case OP_MULI:
        case OP_DIVI:
        case OP_MODI:
        case OP_ADDFI:
        case OP_SUBFI:
        case OP_MULFI:
        case OP_DIVFI:
        case OP_MODFI:
        case OP_EQI:
        case OP_NEQI:
        case OP_LTI:
        case OP_GTI:
        case OP_LEI:
        case OP_GEI:
        case OP_ANDI:
        case OP_ORI:
        case OP_BITLSHIFTI:
        case OP_BITRSHIFTI:
        case OP_BITANDI:
        case OP_BITORI:
            println("%s r%d, r%d, c%d", op_str[instruction.op], instruction.dst,
                    instruction.a, instruction.b);
            break;
        case OP_LD8:
        case OP_LD16:
        case OP_LD32:
        case OP_LD64:
        case OP_ST8:
        case OP_ST16:
        case OP_ST32:
        case OP_ST64:
        case OP_ADD:
        case OP_SUB:
        case OP_MUL:
        case OP_DIV:
        case OP_MOD:
        case OP_ADDF:
        case OP_SUBF:
        case OP_MULF:
        case OP_DIVF:
        case OP_MODF:
        case OP_EQ:
        case OP_NEQ:
        case OP_LT:
        case OP_GT:
        case OP_LE:
        case OP_GE:
        case OP_AND:
        case OP_OR:
        case OP_BITLSHIFT:
        case OP_BITRSHIFT:
        case OP_BITAND:
        case OP_BITOR:
            println("%s r%d, r%d, r%d", op_str[instruction.op], instruction.dst,
                    instruction.a, instruction.b);
            break;
        case OP_LDVAR:
            println("%s r%d, v%d", op_str[instruction.op], instruction.dst,
                    instruction.a, instruction.b);
            break;
        case OP_STVAR:
            println("%s v%d, r%d", op_str[instruction.op], instruction.dst,
                    instruction.a, instruction.b);
            break;
        case OP_STVARI:
            println("%s v%d, c%d", op_str[instruction.op], instruction.dst,
                    instruction.a, instruction.b);
            break;
        case OP_BITNOTI:
        case OP_NOTI:
            println("%s r%d, c%d", op_str[instruction.op], instruction.dst,
                    instruction.a, instruction.b);
            break;
        case OP_BITNOT:
        case OP_NOT:
            println("%s r%d, r%d", op_str[instruction.op], instruction.dst,
                    instruction.a, instruction.b);
            break;
        case OP_HALT: println("%s", op_str[instruction.op]); break;
        default: println("Unknown opcode %d", instruction.op); break;
    }
}

void
disassemble_chunk(Chunk chunk) {
    println("%s: =========== code ===========", chunk.file_name);
    for (sz i = 0; i < array_size(chunk.code); i++) {
        print("%s: %x{4}:  ", chunk.file_name, i);
        disassemble_instruction(chunk.code[i]);
    }
    if (array_size(chunk.constants) > 0) {
        println("%s: ========= constants ========", chunk.file_name);
        for (sz i = 0; i < array_size(chunk.constants); i++) {
            println("%s: %x{2}:  %x{8}", chunk.file_name, i,
                    chunk.constants[i]);
        }
    }
    if (array_size(chunk.strings) > 0) {
        println("%s: ========== strings =========", chunk.file_name);
        for (sz i = 0; i < array_size(chunk.strings); i++) {
            println("%s: %x{2}:  %s", chunk.file_name, i, chunk.strings[i]);
        }
    }
    if (array_size(chunk.vars) > 0) {
        println("%s: ========= variables ========", chunk.file_name);
        for (sz i = 0; i < array_size(chunk.vars); i++) {
            println("%s: %x{2}: [%x{4}:%x{4}] %s: %s", chunk.file_name, i,
                    chunk.vars[i].offset,
                    chunk.vars[i].offset + chunk.vars[i].size,
                    chunk.vars[i].name, chunk.vars[i].type);
        }
    }
    println("n_regs: %d, n_vars: %d, n_strings: %d, n_consts: %d",
            chunk.reg_idx, array_size(chunk.vars), chunk.str_idx,
            chunk.const_idx);
}

#endif  // COMPILER_C