gen_x86.c

#include "9cc.h"

char *regs[] = {"r10", "r11", "rbx", "r12", "r13", "r14", "r15"};
char *regs8[] = {"r10b", "r11b", "bl", "r12b", "r13b", "r14b", "r15b"};
char *regs32[] = {"r10d", "r11d", "ebx", "r12d", "r13d", "r14d", "r15d"};

int num_regs = sizeof(regs) / sizeof(*regs);

static char *argregs[] = {"rdi", "rsi", "rdx", "rcx", "r8", "r9"};
static char *argregs8[] = {"dil", "sil", "dl", "cl", "r8b", "r9b"};
static char *argregs32[] = {"edi", "esi", "edx", "ecx", "r8d", "r9d"};

__attribute__((format(printf, 1, 2))) static void p(char *fmt, ...);
__attribute__((format(printf, 1, 2))) static void emit(char *fmt, ...);

static void p(char *fmt, ...) {
    va_list ap;
    va_start(ap, fmt);
    vprintf(fmt, ap);
    printf("\n");
}

static void emit(char *fmt, ...) {
    va_list ap;
    va_start(ap, fmt);
    printf("\t");
    vprintf(fmt, ap);
    printf("\n");
}

static void emit_cmp(char *insn, IR *ir) {
    int r0 = ir->r0->rn;
    int r1 = ir->r1->rn;
    int r2 = ir->r2->rn;

    emit("cmp %s, %s", regs[r1], regs[r2]);
    emit("%s %s", insn, regs8[r0]);
    emit("movzb %s, %s", regs[r0], regs8[r0]);
}

static char *reg(int r, int size) {
    if (size == 1) {
        return regs8[r];
    }
    if (size == 4) {
        return regs32[r];
    }
    assert(size == 8);
    return regs[r];
}

static char *argreg(int r, int size) {
    if (size == 1) {
        return argregs8[r];
    }
    if (size == 4) {
        return argregs32[r];
    }
    assert(size == 8);
    return argregs[r];
}

static void emit_ir(IR *ir, char *ret) {
    int r0 = ir->r0 ? ir->r0->rn : 0;
    int r1 = ir->r1 ? ir->r1->rn : 0;
    int r2 = ir->r2 ? ir->r2->rn : 0;

    switch (ir->op) {
        case IR_IMM:
            emit("mov %s, %d", regs[r0], ir->imm);
            break;
        case IR_BPREL:
            emit("lea %s, [rbp%d]", regs[r0], ir->var->offset);
            break;
        case IR_MOV:
            emit("mov %s, %s", regs[r0], regs[r2]);
            break;
        case IR_RETURN:
            emit("mov rax, %s", regs[r2]);
            emit("jmp %s", ret);
            break;
        case IR_CALL:
            for (int i = 0; i < ir->nargs; i++) {
                emit("mov %s, %s", argregs[i], regs[ir->args[i]->rn]);
            }
            emit("push r10");
            emit("push r11");
            emit("mov rax, 0");
            emit("call %s", ir->name);
            emit("pop r11");
            emit("pop r10");
            emit("mov %s, rax", regs[r0]);
            break;
        case IR_LABEL_ADDR:
            emit("lea %s, %s", regs[r0], ir->name);
            break;
        case IR_EQ:
            emit_cmp("sete", ir);
            break;
        case IR_NE:
            emit_cmp("setne", ir);
            break;
        case IR_LT:
            emit_cmp("setl", ir);
            break;
        case IR_LE:
            emit_cmp("setle", ir);
            break;
        case IR_AND:
            emit("and %s, %s", regs[r0], regs[r2]);
            break;
        case IR_OR:
            emit("or %s, %s", regs[r0], regs[r2]);
            break;
        case IR_XOR:
            emit("xor %s, %s", regs[r0], regs[r2]);
            break;
        case IR_SHL:
            emit("mov cl, %s", regs8[r2]);
            emit("shl %s, cl", regs[r0]);
            break;
        case IR_SHR:
            emit("mov cl, %s", regs8[r2]);
            emit("shr %s, cl", regs[r0]);
            break;
        case IR_JMP:
            if (ir->bbarg) {
                emit("mov %s, %s", regs[ir->bb1->param->rn], regs[ir->bbarg->rn]);
            }
            emit("jmp .L%d", ir->bb1->label);
            break;
        case IR_BR:
            emit("cmp %s, 0", regs[r2]);
            emit("jne .L%d", ir->bb1->label);
            emit("jmp .L%d", ir->bb2->label);
            break;
        case IR_LOAD:
            emit("mov %s, [%s]", reg(r0, ir->size), regs[r2]);
            if (ir->size == 1)
                emit("movzb %s, %s", regs[r0], regs8[r0]);
            break;
        case IR_LOAD_SPILL:
            emit("mov %s, [rbp%d]", regs[r0], ir->var->offset);
            break;
        case IR_STORE:
            emit("mov [%s], %s", regs[r1], reg(r2, ir->size));
            break;
        case IR_STORE_ARG:
            emit("mov [rbp%d], %s", ir->var->offset, argreg(ir->imm, ir->size));
            break;
        case IR_STORE_SPILL:
            emit("mov [rbp%d], %s", ir->var->offset, regs[r1]);
            break;
        case IR_ADD:
            emit("add %s, %s", regs[r0], regs[r2]);
            break;
        case IR_SUB:
            emit("sub %s, %s", regs[r0], regs[r2]);
            break;
        case IR_MUL:
            emit("mov rax, %s", regs[r2]);
            emit("imul %s", regs[r0]);
            emit("mov %s, rax", regs[r0]);
            break;
        case IR_DIV:
            emit("mov rax, %s", regs[r0]);
            emit("cqo");
            emit("idiv %s", regs[r2]);
            emit("mov %s, rax", regs[r0]);
            break;
        case IR_MOD:
            emit("mov rax, %s", regs[r0]);
            emit("cqo");
            emit("idiv %s", regs[r2]);
            emit("mov %s, rdx", regs[r0]);
            break;
        case IR_NOP:
            break;
        default:
            assert(0 && "unknown operator");
    }
}

void emit_code(Function *fn) {
    int off = 0;
    for (int i = 0; i < fn->lvars->len; i++) {
        Var *var = fn->lvars->data[i];
        off += var->ty->size;
        off = roundup(off, var->ty->align);
        var->offset = -off;
    }

    char *ret = format(".Lend%d", nlabel++);

    p(".text");
    p(".global %s", fn->name);
    p("%s:", fn->name);
    emit("push rbp");
    emit("mov rbp, rsp");
    emit("sub rsp, %d", roundup(off, 16));
    emit("push r12");
    emit("push r13");
    emit("push r14");
    emit("push r15");

    for (int i = 0; i < fn->bbs->len; i++) {
        BB *bb = fn->bbs->data[i];
        p(".L%d:", bb->label);
        for (int i = 0; i < bb->ir->len; i++) {
            IR *ir = bb->ir->data[i];
            emit_ir(ir, ret);
        }
    }

    p("%s:", ret);
    emit("pop r15");
    emit("pop r14");
    emit("pop r13");
    emit("pop r12");
    emit("mov rsp, rbp");
    emit("pop rbp");
    emit("ret");
}

static char *backslash_escape(char *s, int len) {
    static char escaped[256] = {
            ['\b'] = 'b', ['\f'] = 'f',  ['\n'] = 'n',  ['\r'] = 'r',
            ['\t'] = 't', ['\\'] = '\\', ['\''] = '\'', ['"'] = '"',
    };

    StringBuilder *sb = new_sb();
    for (int i = 0; i < len; i++) {
        uint8_t c = s[i];
        char esc = escaped[c];
        if (esc) {
            sb_add(sb, '\\');
            sb_add(sb, esc);
        } else if (isgraph(c) || c == ' ') {
            sb_add(sb, c);
        } else {
            sb_append(sb, format("\\%03o", c));
        }
    }
    return sb_get(sb);
}


static void emit_data(Var *var) {
    if (var->data) {
        p(".data");
        p("%s:", var->name);
        emit(".ascii \"%s\"", backslash_escape(var->data, var->ty->size));
        return;
    }
    p(".bss");
    p("%s:", var->name);
    emit(".zero %d", var->ty->size);
}

void gen_x86(Program *prog) {
    p(".intel_syntax noprefix");

    for (int i = 0; i < prog->gvars->len; i++) {
        emit_data(prog->gvars->data[i]);
    }

    for (int i = 0; i < prog->funcs->len; i++) {
        emit_code(prog->funcs->data[i]);
    }
}