path: root/src/compiler.h

#ifndef BDL_COMPILER_H
#define BDL_COMPILER_H


#define PRELUDE_FILE "src/x86_64/prelude.asm"
#define POSTLUDE_FILE "src/x86_64/postlude.asm"

#define HEAP_SIZE   MB(32)

// Immediate constants.
#define NIL_VAL      47LU
#define BOOL_MASK    127LU
#define BOOL_TAG     31LU
#define BOOL_SHIFT   7LU
#define TRUE_VAL     ((1 << BOOL_SHIFT) | BOOL_TAG)
#define FALSE_VAL    ((0 << BOOL_SHIFT) | BOOL_TAG)
#define FIXNUM_MASK  3LU
#define FIXNUM_TAG   0LU
#define FIXNUM_SHIFT 2LU

// Heap allocated objects.
#define STRING_MASK  7LU
#define STRING_TAG   3LU
#define PAIR_MASK    7LU
#define PAIR_TAG     1LU

void compile_object(Object *obj);
void compile_fixnum(Object *obj);
void compile_proc_call(Object *obj);
void compile(Root *roots);

char *
generate_label(void) {
    // Generate a unique label allocated on the heap. The caller is responsible
    // for freeing the memory.
    static size_t label_counter = 0;
    char buf[32];
    sprintf(buf, ".BDLL%ld", label_counter++);
    size_t len = strlen(buf);
    char * ret = malloc(len + 1);
    memcpy(ret, buf, len);
    ret[len] = 0;
    return ret;
}

void
emit_file(char *file_name) {
    FILE *file = fopen(file_name, "r");
    if (!file) {
        fprintf(stderr, "error: couldn't open input file: %s\n", file_name);
        exit(EXIT_FAILURE);
    }
    char buf[1024];
    size_t n = 0;
    while ((n = fread(&buf, 1, 1024, file)) > 0) {
        fwrite(buf, 1, n, stdout);
    }
}

void
compile_fixnum(Object *obj) {
    printf("    ;; --> compile_fixnum\n");
    printf("    mov     rax, %ld\n", (obj->fixnum << FIXNUM_SHIFT) | FIXNUM_TAG);
    printf("    push    rax\n");
    printf("    ;; <-- compile_fixnum\n");
}

void
compile_boolean(Object *obj) {
    printf("    ;; --> compile_boolean\n");
    int is_true = obj->type == OBJ_TYPE_TRUE;
    printf("    mov     rax, %zu\n", (is_true << BOOL_SHIFT) | BOOL_TAG);
    printf("    push    rax\n");
    printf("    ;; <-- compile_boolean\n");
}

void
compile_nil(void) {
    printf("    ;; --> compile_nil\n");
    printf("    mov     rax, NIL_VAL\n");
    printf("    push    rax\n");
    printf("    ;; <-- compile_nil\n");
}

typedef enum OpType {
    // Arithmetic.
    OP_ADD,
    OP_SUB,
    OP_MUL,
    OP_DIV,
    OP_MOD,
    // Type predicates.
    OP_IS_NIL,
    OP_IS_ZERO,
    OP_IS_BOOL,
    OP_IS_FIXNUM,
    // Logic operations.
    OP_EQUAL,
    OP_GREATER,
    OP_LESS,
    OP_GREATER_EQ,
    OP_LESS_EQ,
} OpType;

void
compile_type_predicate(OpType op, Object* args) {
    printf("    ;; --> compile_type_predicate\n");
    compile_object(args->head);
    printf("    pop     rax\n");
    switch (op) {
        case OP_IS_NIL: {
            printf("    cmp     rax, NIL_VAL\n");
        } break;
        case OP_IS_ZERO: {
            printf("    cmp     rax, 0\n");
        } break;
        case OP_IS_BOOL: {
            printf("    and     rax, BOOL_MASK\n");
            printf("    cmp     rax, BOOL_TAG\n");
        } break;
        case OP_IS_FIXNUM: {
            printf("    and     rax, FIXNUM_MASK\n");
            printf("    cmp     rax, FIXNUM_TAG\n");
        } break;
        default: break;
    }
    printf("    mov     rax, 0\n");
    printf("    sete    al\n");
    printf("    shl     rax, BOOL_SHIFT\n");
    printf("    or      rax, BOOL_TAG\n");
    printf("    push    rax\n");
    printf("    ;; <-- compile_type_predicate\n");
}

void
compile_not(Object* args) {
    printf("    ;; --> compile_not\n");
    compile_object(args->head);
    printf("    pop     rax\n");
    printf("    cmp     rax, FALSE_VAL\n");
    printf("    mov     rax, 0\n");
    printf("    sete    al\n");
    printf("    shl     rax, BOOL_SHIFT\n");
    printf("    or      rax, BOOL_TAG\n");
    printf("    push    rax\n");
    printf("    ;; <-- compile_not\n");
}

void
compile_and(Object *args) {
    printf("    ;; --> compile_and\n");
    char *lab_false = generate_label();
    char *lab_exit = generate_label();
    while (args != NULL) {
        compile_object(args->head);
        args = args->tail;
        printf("    pop     rax\n");
        printf("    cmp     rax, FALSE_VAL\n");
        printf("    je      %s\n", lab_false);
    }
    printf("    mov     rax, TRUE_VAL\n");
    printf("    push    rax\n");
    printf("    jmp     %s\n", lab_exit);
    printf("%s:\n", lab_false);
    printf("    mov     rax, FALSE_VAL\n");
    printf("    push    rax\n");
    printf("%s:\n", lab_exit);
    free(lab_false);
    free(lab_exit);
    printf("    ;; <-- compile_and\n");
}

void
compile_or(Object *args) {
    printf("    ;; --> compile_or\n");
    char *lab_true = generate_label();
    char *lab_exit = generate_label();
    while (args != NULL) {
        compile_object(args->head);
        args = args->tail;
        printf("    pop     rax\n");
        printf("    cmp     rax, FALSE_VAL\n");
        printf("    jne     %s\n", lab_true);
    }
    printf("    mov     rax, FALSE_VAL\n");
    printf("    push    rax\n");
    printf("    jmp     %s\n", lab_exit);
    printf("%s:\n", lab_true);
    printf("    mov     rax, TRUE_VAL\n");
    printf("    push    rax\n");
    printf("%s:\n", lab_exit);
    free(lab_true);
    free(lab_exit);
    printf("    ;; <-- compile_or\n");
}

void
compile_cmp_list(OpType op, Object* args) {
    printf("    ;; --> compile_cmp_list\n");
    compile_object(args->head);
    char *lab_false = generate_label();
    char *lab_exit = generate_label();
    args = args->tail;
    while (args != NULL) {
        compile_object(args->head);
        args = args->tail;

        // Current value.
        printf("    pop     rcx\n");

        // Previous value.
        printf("    pop     rax\n");

        // Comparison.
        printf("    cmp     rax, rcx\n");
        switch (op) {
            case OP_EQUAL:      { printf("    jne     %s\n", lab_false); } break;
            case OP_GREATER:    { printf("    jle     %s\n", lab_false); } break;
            case OP_LESS:       { printf("    jge     %s\n", lab_false); } break;
            case OP_GREATER_EQ: { printf("    jl      %s\n", lab_false); } break;
            case OP_LESS_EQ:    { printf("    jg      %s\n", lab_false); } break;
            default: break;
        }
        printf("    push    rcx\n");
    }
    printf("    pop     rcx\n");
    printf("    mov     rax, TRUE_VAL\n");
    printf("    push    rax\n");
    printf("    jmp     %s\n", lab_exit);
    printf("%s:\n", lab_false);
    printf("    mov     rax, FALSE_VAL\n");
    printf("    push    rax\n");
    printf("%s:\n", lab_exit);
    free(lab_false);
    free(lab_exit);
    printf("    ;; <-- compile_cmp_list\n");
}

void
compile_arithmetic_list(OpType op, Object* args) {
    printf("    ;; --> compile_arithmetic\n");
    compile_object(args->head);
    args = args->tail;
    while (args != NULL) {
        compile_object(args->head);
        args = args->tail;
        printf("    pop     rcx\n");
        printf("    pop     rax\n");
        switch (op) {
            case OP_ADD: { printf("    add     rax, rcx\n"); } break;
            case OP_SUB: { printf("    sub     rax, rcx\n"); } break;
            case OP_MUL: {
                printf("    sar     rax, FIXNUM_SHIFT\n");
                printf("    sar     rcx, FIXNUM_SHIFT\n");
                printf("    mul     rcx\n");
                printf("    shl     rax, FIXNUM_SHIFT\n");
            } break;
            case OP_DIV: {
                printf("    sar     rax, FIXNUM_SHIFT\n");
                printf("    sar     rcx, FIXNUM_SHIFT\n");
                printf("    mov     rdx, 0\n");
                printf("    div     rcx\n");
                printf("    shl     rax, FIXNUM_SHIFT\n");
            } break;
            case OP_MOD: {
                printf("    sar     rax, FIXNUM_SHIFT\n");
                printf("    sar     rcx, FIXNUM_SHIFT\n");
                printf("    mov     rdx, 0\n");
                printf("    div     rcx\n");
                printf("    mov     rax, rdx\n");
                printf("    shl     rax, FIXNUM_SHIFT\n");
            } break;
            default: break;
        }
        printf("    push    rax\n");
    }
    printf("    ;; <-- compile_arithmetic\n");
}

void
compile_cons(Object *obj) {
    printf("    ;; --> compile_cons\n");
    // Store objects into the car and cdr.
    compile_object(obj->head);
    compile_object(obj->tail->head);
    printf("    pop     rdx\n");
    printf("    pop     rax\n");
    printf("    mov     [r15], rax\n");
    printf("    mov     [r15 + 8], rdx\n");

    // Push memory address of cons cell.
    printf("    mov     rax, r15\n");
    printf("    or      rax, %zu\n", PAIR_TAG);
    printf("    push    rax\n");

    // Bump allocation register.
    printf("    add     r15, 16\n");
    printf("    ;; <-- compile_cons\n");
}

void
compile_car(Object *obj) {
    printf("    ;; --> compile_car\n");
    compile_object(obj->head);
    printf("    pop     rax\n");
    printf("    and     rax, %zu\n", ~PAIR_MASK);
    printf("    mov     rdx, [rax]\n");
    printf("    push    rdx\n");
    printf("    ;; <-- compile_car\n");
}

void
compile_cdr(Object *obj) {
    printf("    ;; --> compile_cdr\n");
    compile_object(obj->head);
    printf("    pop     rax\n");
    printf("    and     rax, %zu\n", ~PAIR_MASK);
    printf("    mov     rdx, [rax + 8]\n");
    printf("    push    rdx\n");
    printf("    ;; <-- compile_cdr\n");
}

void
compile_proc_call(Object *obj) {
    // TODO: Probably we want to use a hash table for these lookups that is
    // initialized at the start of the compilation procedure.
    if (sv_equal(&obj->head->text, &STRING("+"))) {
        compile_arithmetic_list(OP_ADD, obj->tail);
    } else if (sv_equal(&obj->head->text, &STRING("-"))) {
        compile_arithmetic_list(OP_SUB, obj->tail);
    } else if (sv_equal(&obj->head->text, &STRING("*"))) {
        compile_arithmetic_list(OP_MUL, obj->tail);
    } else if (sv_equal(&obj->head->text, &STRING("/"))) {
        compile_arithmetic_list(OP_DIV, obj->tail);
    } else if (sv_equal(&obj->head->text, &STRING("%"))) {
        compile_arithmetic_list(OP_MOD, obj->tail);
    } else if (sv_equal(&obj->head->text, &STRING("nil?"))) {
        compile_type_predicate(OP_IS_NIL, obj->tail);
    } else if (sv_equal(&obj->head->text, &STRING("zero?"))) {
        compile_type_predicate(OP_IS_ZERO, obj->tail);
    } else if (sv_equal(&obj->head->text, &STRING("fixnum?"))) {
        compile_type_predicate(OP_IS_FIXNUM, obj->tail);
    } else if (sv_equal(&obj->head->text, &STRING("bool?"))) {
        compile_type_predicate(OP_IS_BOOL, obj->tail);
    } else if (sv_equal(&obj->head->text, &STRING("display"))) {
        compile_object(obj->tail->head);
        printf("    pop     rdi\n");
        printf("    call    display\n");
    } else if (sv_equal(&obj->head->text, &STRING("not"))) {
        compile_not(obj->tail);
    } else if (sv_equal(&obj->head->text, &STRING("and"))) {
        compile_and(obj->tail);
    } else if (sv_equal(&obj->head->text, &STRING("or"))) {
        compile_or(obj->tail);
    } else if (sv_equal(&obj->head->text, &STRING("="))) {
        compile_cmp_list(OP_EQUAL, obj->tail);
    } else if (sv_equal(&obj->head->text, &STRING(">"))) {
        compile_cmp_list(OP_GREATER, obj->tail);
    } else if (sv_equal(&obj->head->text, &STRING("<"))) {
        compile_cmp_list(OP_LESS, obj->tail);
    } else if (sv_equal(&obj->head->text, &STRING(">="))) {
        compile_cmp_list(OP_GREATER_EQ, obj->tail);
    } else if (sv_equal(&obj->head->text, &STRING("<="))) {
        compile_cmp_list(OP_LESS_EQ, obj->tail);
    } else if (sv_equal(&obj->head->text, &STRING("cons"))) {
        compile_cons(obj->tail);
    } else if (sv_equal(&obj->head->text, &STRING("car"))) {
        compile_car(obj->tail);
    } else if (sv_equal(&obj->head->text, &STRING("cdr"))) {
        compile_cdr(obj->tail);
    } else {
        fprintf(stderr, "error: not implemented\n");
        exit(EXIT_FAILURE);
    }
}

void
compile_if(Object *obj) {
    char *lab_false = generate_label();
    compile_object(obj->condition);
    printf("    pop     rax\n");
    printf("    cmp     rax, FALSE_VAL\n");
    printf("    je      %s\n", lab_false);
    compile_object(obj->expr_true);
    if (obj->expr_false != NULL) {
        char *lab_exit = generate_label();
        printf("    jmp     %s\n", lab_exit);
        printf("%s:\n", lab_false);
        compile_object(obj->expr_false);
        printf("%s:\n", lab_exit);
        free(lab_exit);
    } else {
        printf("%s:\n", lab_false);
    }
    free(lab_false);
}

void
compile_object(Object *obj) {
    switch (obj->type) {
        case OBJ_TYPE_NIL: { compile_nil(); } break;
        case OBJ_TYPE_TRUE:
        case OBJ_TYPE_FALSE: { compile_boolean(obj); } break;
        case OBJ_TYPE_FIXNUM: { compile_fixnum(obj); } break;
        case OBJ_TYPE_PAIR: { compile_proc_call(obj); } break;
        case OBJ_TYPE_IF: { compile_if(obj); } break;
        default: break;
    }
}

void
compile(Root *roots) {
    printf("%%define NIL_VAL      %zu\n", NIL_VAL);
    printf("%%define BOOL_MASK    %zu\n", BOOL_MASK);
    printf("%%define BOOL_TAG     %zu\n", BOOL_TAG);
    printf("%%define BOOL_SHIFT   %zu\n", BOOL_SHIFT);
    printf("%%define FIXNUM_MASK  %zu\n", FIXNUM_MASK);
    printf("%%define FIXNUM_TAG   %zu\n", FIXNUM_TAG);
    printf("%%define FIXNUM_SHIFT %zu\n", FIXNUM_SHIFT);
    printf("%%define PAIR_MASK    %zu\n", PAIR_MASK);
    printf("%%define PAIR_TAG     %zu\n", PAIR_TAG);
    printf("%%define STRING_MASK  %zu\n", STRING_MASK);
    printf("%%define STRING_TAG   %zu\n", STRING_TAG);
    printf("%%define HEAP_SIZE    %zu\n", HEAP_SIZE);
    printf("\n");
    emit_file(PRELUDE_FILE);
    for (size_t i = 0; i < array_size(roots); i++) {
        Object *root = roots[i];
        compile_object(root);
    }
    emit_file(POSTLUDE_FILE);
}

#endif // BDL_COMPILER_H