void expr_codegen(struct expr *e, FILE *file) {
int string_count = 0, found = 0, count = 1;
struct string_node *sn;
char* string_label = (char*)malloc(9);
char* label_name = (char*)malloc(9);
struct expr *temp_ptr;
if(!e) return;
switch(e->kind) {
case EXPR_LIST:
break;
case EXPR_ASSIGNMENT:
expr_codegen(e->right, file);
fprintf(file, "\tMOV %s, %s\t\t# Assignment\n", register_name(e->right->reg), symbol_code(e->left->symbol));
e->reg = e->right->reg;
register_free(e->left->reg);
break;
case EXPR_OR:
expr_codegen(e->left, file);
expr_codegen(e->right, file);
fprintf(file, "\tOR %s, %s\n", register_name(e->left->reg), register_name(e->right->reg));
e->reg = e->right->reg;
register_free(e->left->reg);
break;
case EXPR_AND:
expr_codegen(e->left, file);
expr_codegen(e->right, file);
fprintf(file, "\tAND %s, %s\n", register_name(e->left->reg), register_name(e->right->reg));
e->reg = e->right->reg;
register_free(e->left->reg);
break;
case EXPR_LT:
expr_codegen(e->left, file);
expr_codegen(e->right, file);
fprintf(file, "\tCMP %s, %s\t\t\n", register_name(e->left->reg), register_name(e->right->reg));
fprintf(file, "\tMOV $1, %s\n", register_name(e->right->reg));
sprintf(label_name, "done_%d", labelNum);
fprintf(file, "\tJG %s\n", label_name);
fprintf(file, "\tMOV $0, %s\n", register_name(e->right->reg));
fprintf(file, "%s:\n", label_name);
e->reg = e->right->reg;
register_free(e->left->reg);
labelNum++;
break;
case EXPR_GT:
expr_codegen(e->left, file);
expr_codegen(e->right, file);
fprintf(file, "\tCMP %s, %s\t\t\n", register_name(e->left->reg), register_name(e->right->reg));
fprintf(file, "\tMOV $1, %s\n", register_name(e->right->reg));
fprintf(file, "\tMOV $1, %s\n", register_name(e->right->reg));
sprintf(label_name, "done_%d", labelNum);
fprintf(file, "\tJL %s\n", label_name);
fprintf(file, "\tMOV $0, %s\n", register_name(e->right->reg));
fprintf(file, "%s:\n", label_name);
e->reg = e->right->reg;
register_free(e->left->reg);
labelNum++;
break;
case EXPR_LE:
expr_codegen(e->left, file);
expr_codegen(e->right, file);
fprintf(file, "\tCMP %s, %s\t\t\n", register_name(e->left->reg), register_name(e->right->reg));
fprintf(file, "\tMOV $1, %s\n", register_name(e->right->reg));
fprintf(file, "\tMOV $1, %s\n", register_name(e->right->reg));
sprintf(label_name, "done_%d", labelNum);
fprintf(file, "\tJGE %s\n", label_name);
fprintf(file, "\tMOV $0, %s\n", register_name(e->right->reg));
fprintf(file, "%s:\n", label_name);
e->reg = e->right->reg;
register_free(e->left->reg);
labelNum++;
break;
case EXPR_GE:
expr_codegen(e->left, file);
expr_codegen(e->right, file);
fprintf(file, "\tCMP %s, %s\t\t\n", register_name(e->left->reg), register_name(e->right->reg));
fprintf(file, "\tMOV $1, %s\n", register_name(e->right->reg));
fprintf(file, "\tMOV $1, %s\n", register_name(e->right->reg));
sprintf(label_name, "done_%d", labelNum);
fprintf(file, "\tJLE %s\n", label_name);
fprintf(file, "\tMOV $0, %s\n", register_name(e->right->reg));
fprintf(file, "%s:\n", label_name);
e->reg = e->right->reg;
register_free(e->left->reg);
labelNum++;
break;
case EXPR_NOT_EQUALS:
expr_codegen(e->left, file);
expr_codegen(e->right, file);
fprintf(file, "\tCMP %s, %s\t\t\n", register_name(e->left->reg), register_name(e->right->reg));
fprintf(file, "\tMOV $1, %s\n", register_name(e->right->reg));
fprintf(file, "\tMOV $1, %s\n", register_name(e->right->reg));
sprintf(label_name, "done_%d", labelNum);
fprintf(file, "\tJNE %s\n", label_name);
fprintf(file, "\tMOV $0, %s\n", register_name(e->right->reg));
fprintf(file, "%s:\n", label_name);
e->reg = e->right->reg;
register_free(e->left->reg);
labelNum++;
break;
case EXPR_EQUALS:
expr_codegen(e->left, file);
expr_codegen(e->right, file);
fprintf(file, "\tCMP %s, %s\t\t\n", register_name(e->left->reg), register_name(e->right->reg));
fprintf(file, "\tMOV $1, %s\n", register_name(e->right->reg));
fprintf(file, "\tMOV $1, %s\n", register_name(e->right->reg));
sprintf(label_name, "done_%d", labelNum);
fprintf(file, "\tJE %s\n", label_name);
fprintf(file, "\tMOV $0, %s\n", register_name(e->right->reg));
fprintf(file, "%s:\n", label_name);
e->reg = e->right->reg;
register_free(e->left->reg);
labelNum++;
break;
case EXPR_ADD:
expr_codegen(e->left, file);
expr_codegen(e->right, file);
fprintf(file, "\tADD %s, %s\n", register_name(e->left->reg), register_name(e->right->reg));
e->reg = e->right->reg;
register_free(e->left->reg);
break;
case EXPR_MINUS:
expr_codegen(e->left, file);
expr_codegen(e->right, file);
fprintf(file, "\tSUB %s, %s\n", register_name(e->right->reg), register_name(e->left->reg));
e->reg = e->left->reg;
register_free(e->right->reg);
break;
case EXPR_TIMES:
expr_codegen(e->left, file);
expr_codegen(e->right, file);
fprintf(file, "\tMOV %s, %rax\t\t#Move left value into rax to prepare for multiplying\n", register_name(e->left->reg));
fprintf(file, "\tIMUL %s\t\t# Multiply %rax by the value in %s\n", register_name(e->right->reg), register_name(e->right->reg));
fprintf(file, "\tMOV %rax, %s\t\t# Move multiplied result back to non-scratch register\n", register_name(e->right->reg));
e->reg = e->right->reg;
register_free(e->left->reg);
break;
case EXPR_DIVIDES:
expr_codegen(e->left, file);
expr_codegen(e->right, file);
fprintf(file, "\tMOVQ %s, %rax\t\t#Move left value into rax to prepare for dividing\n", register_name(e->left->reg));
fprintf(file, "\tCQTO\n");
fprintf(file, "\tIDIVQ %s\t\t\t# Divide %rax by the value in %s\n", register_name(e->right->reg), register_name(e->right->reg));
fprintf(file, "\tMOVQ %rax, %s\t\t# Move divided result back to non-scratch register\n", register_name(e->right->reg));
e->reg = e->right->reg;
register_free(e->left->reg);
break;
case EXPR_MOD:
expr_codegen(e->left, file);
expr_codegen(e->right, file);
fprintf(file, "\tMOVQ %s, %rax\t\t#Move left value into rax to prepare for dividing\n", register_name(e->left->reg));
fprintf(file, "\tCQTO\n");
fprintf(file, "\tIDIVQ %s\t\t\t# Divide %rax by the value in %s\n", register_name(e->right->reg), register_name(e->right->reg));
fprintf(file, "\tMOVQ %rdx, %s\t\t# Move remainder back to non-scratch register\n", register_name(e->right->reg));
e->reg = e->right->reg;
register_free(e->left->reg);
break;
case EXPR_POWER:
expr_codegen(e->left, file);
expr_codegen(e->right, file);
fprintf(file, "\tMOV %s, %rdi\t\t# Move first argument for base of power\n", register_name(e->left->reg));
fprintf(file, "\tMOV %s, %rsi\t\t# Move second argument for exponent\n", register_name(e->right->reg));
fprintf(file, "\n\tPUSHQ %r10\n");
fprintf(file, "\tPUSHQ %r11\n");
fprintf(file, "\n\tCALL integer_power\n\n");
fprintf(file, "\tPOPQ %r11\n");
fprintf(file, "\tPOPQ %r10\n");
fprintf(file, "\tMOV %rax, %s\t\t# Move result of integer_power into register\n", register_name(e->right->reg));
e->reg = e->right->reg;
register_free(e->left->reg);
break;
case EXPR_NEGATIVE:
expr_codegen(e->right, file);
fprintf(file, "\tNEG %s\t\t# Negate the value\n", register_name(e->right->reg));
e->reg = e->right->reg;
break;
case EXPR_NOT:
expr_codegen(e->right, file);
fprintf(file, "\tSUB $1, %s\t\t# Negate the boolean\n", register_name(e->right->reg));
e->reg = e->right->reg;
break;
case EXPR_PRE_INCREMENT:
expr_codegen(e->right, file);
fprintf(file, "\tINC %s\n", register_name(e->right->reg));
fprintf(file, "\tMOV %s, %s\n", register_name(e->right->reg), symbol_code(e->right->symbol));
e->reg = e->right->reg;
break;
case EXPR_PRE_DECREMENT:
expr_codegen(e->right, file);
fprintf(file, "\tDEC %s\n", register_name(e->right->reg));
fprintf(file, "\tMOV %s, %s\n", register_name(e->right->reg), symbol_code(e->right->symbol));
e->reg = e->right->reg;
break;
case EXPR_POST_INCREMENT:
// TODO: Delay incrementing
expr_codegen(e->left, file);
fprintf(file, "\tINC %s\n", register_name(e->left->reg));
fprintf(file, "\tMOV %s, %s\n", register_name(e->left->reg), symbol_code(e->left->symbol));
e->reg = e->left->reg;
break;
case EXPR_POST_DECREMENT:
expr_codegen(e->left, file);
fprintf(file, "\tDEC %s\n", register_name(e->left->reg));
fprintf(file, "\tMOV %s, %s\n", register_name(e->left->reg), symbol_code(e->left->symbol));
e->reg = e->left->reg;
break;
case EXPR_FUNCTION:
// setup function args
fprintf(file, "\tMOV $0, %rax\n");
temp_ptr = e->right;
while(temp_ptr) {
if(count > 6) {
printf("You may only supple 6 arguments to a function\n");
exit(1);
}
expr_codegen(temp_ptr->left, file);
fprintf(file, "\tMOV %s, %s\n", register_name(temp_ptr->left->reg), num_to_arg(count++));
temp_ptr = temp_ptr->right;
}
// call function
fprintf(file, "\n\tPUSH %r10\n");
fprintf(file, "\tPUSH %r11\n");
fprintf(file, "\n\tCALL %s\n\n", e->left->name);
fprintf(file, "\tPOP %r11\n");
fprintf(file, "\tPOP %r10\n");
e->reg = register_alloc();
fprintf(file, "\tMOV %rax, %s\n", register_name(e->reg));
break;
case EXPR_BOOLEAN:
e->reg = register_alloc();
fprintf(file, "\tMOV $%d, %s\n", e->literal_value, register_name(e->reg));
break;
case EXPR_INT:
e->reg = register_alloc();
fprintf(file, "\tMOV $%d, %s\n", e->literal_value, register_name(e->reg));
break;
case EXPR_CHAR:
e->reg = register_alloc();
fprintf(file, "\tMOV $%d, %s\n", e->literal_value, register_name(e->reg));
break;
case EXPR_STRING:
e->reg = register_alloc();
// find the string
sn = string_head;
while(sn) {
if(!strcmp(sn->text, e->string_literal)) {
// string found
found = 1;
sprintf(string_label, "LC%d", string_count);
e->reg = register_alloc();
fprintf(file, "\tMOV $%s, %s\t\t# Move string into register\n", string_label, register_name(e->reg));
break;
}
string_count++;
sn = sn->next;
}
if(!found) {
printf("Could not find string %s in data\n", e->string_literal);
exit(1);
}
break;
case EXPR_NAME:
e->reg = register_alloc();
fprintf(file, "\tMOV %s, %s\n", symbol_code(e->symbol), register_name(e->reg));
break;
case EXPR_ARRAY:
break;
case EXPR_ARRAY_LITERAL:
break;
}
}
void decl_codegen(struct decl *d, FILE * file){
if(!d)return;
if(d->symbol->kind == SYMBOL_GLOBAL){
if(!d->code && !d->value && d->type->kind != TYPE_FUNCTION){
if(d->type->kind != TYPE_STRING)fprintf(file,".data\n%s: .quad 0\n",d->name);
else{
//printf("teste");
fprintf(file,".data\n.global %s\n%s:\n .string \"\" \n",d->name,d->name);
}
}
else{
if(d->value && d->type->kind != TYPE_FUNCTION){
if(d->type->kind == TYPE_STRING && d->type->kind != TYPE_FUNCTION){
fprintf(file,".data\n.global %s\n%s:\n .string ""%s""\n",d->name,d->name,d->value->string_literal);//nao esquecer de tratar quebras de linha
}
else if(d->type->kind != TYPE_FUNCTION) fprintf(file,".data\n.global %s\n%s:\n .quad %d\n",d->name,d->name,d->value->literal_value);//pode ter expressoes do tipo 10+1 na declaracao?
}else{
if(d->code){
fprintf(file,".text\n.global %s\n%s:\n",d->name,d->name);
struct param_list *p = d->type->params;
fprintf(file," pushq %%rbp\n movq %%rsp, %%rbp\n");
int parameters_cont = 0;
while(p){
p = p->next;
parameters_cont++;
}
if(parameters_cont >= 1){
fprintf(file," pushq %%rdi\n");
}
if(parameters_cont >= 2){
fprintf(file," pushq %%rsi\n");
}
if(parameters_cont >= 3){
fprintf(file," pushq %%rdx\n");
}
if(parameters_cont >= 4){
fprintf(file," pushq %%rcx\n");
}
if(parameters_cont >= 5){
fprintf(file," pushq %%r8\n");
}
if(parameters_cont == 6){
fprintf(file," pushq %%r9\n");
}
if(d->symbol->total_locals > 0){
fprintf(file," subq $%d,%%rsp\n",d->symbol->total_locals*8);
}
fprintf(file," pushq %%rbx\n");
fprintf(file," pushq %%r12\n");
fprintf(file," pushq %%r13\n");
fprintf(file," pushq %%r14\n");
fprintf(file," pushq %%r15\n\n");
stmt_codegen(d->code,file);
fprintf(file,"FUNCAO%d:\n",funcoes);
fprintf(file,"\n");
fprintf(file," popq %%r15\n");
fprintf(file," popq %%r14\n");
fprintf(file," popq %%r13\n");
fprintf(file," popq %%r12\n");
fprintf(file," popq %%rbx\n");
fprintf(file," movq %%rbp,%%rsp\n");
fprintf(file," popq %%rbp\n");
fprintf(file," ret\n");
funcoes++;
//postamble como tratar
}
}
}
}
else if(d->symbol->kind == SYMBOL_LOCAL){
if(d->value){
expr_codegen(d->value,file);
fprintf(file," movq %s,-%d(%%rbp)\n",register_name(d->value->reg),d->symbol->param_local_variables*8);//arrumar isso, voce usou valor aleatorio,
register_free(d->value->reg);
//dont forget to free registers
//voltar no video do dia 20, minuto 35 para tratar o caso das strings
}
}
decl_codegen(d->next,file);
}
void stmt_codegen(struct stmt *s, FILE *f) {
if(!s) return;
switch(s -> kind) {
case STMT_DECL:
decl_codegen(s -> decl, f, SYMBOL_LOCAL);
break;
case STMT_EXPR:
expr_codegen(s -> expr, f);
register_free(s -> expr -> reg);
break;
case STMT_IF_ELSE: {
int done = assembly_jump_label++;
expr_codegen(s -> expr, f);
fprintf(f, "\tCMP $0, %s\n", register_name(s -> expr -> reg));
register_free(s -> expr -> reg);
if(s -> else_body) {
int el = assembly_jump_label++;
// jump to else
fprintf(f, "\tJE L%d\n", el);
stmt_codegen(s -> body, f);
assembly_comment(f, "\t# jump to done label (don't evaluate else label)\n");
fprintf(f, "JMP L%d\n", done);
assembly_comment(f, "\t# else label\n");
fprintf(f, "L%d:\n", el);
stmt_codegen(s -> else_body, f);
assembly_comment(f, "\t# done label\n");
fprintf(f, "L%d:\n", done);
}
else {
// jump to done
fprintf(f, "\tJE L%d\n", done);
stmt_codegen(s -> body, f);
assembly_comment(f, "\t# done label\n");
fprintf(f, "L%d:\n", done);
}
break;
}
case STMT_FOR: {
// check for nulls since all exprs optional
int loop = assembly_jump_label++;
int done = assembly_jump_label++;
if(s -> init_expr) {
expr_codegen(s -> init_expr, f);
register_free(s -> init_expr -> reg);
}
// loop label
assembly_comment(f, "\t# loop label\n");
fprintf(f, "L%d:\n", loop);
if(s -> expr) {
expr_codegen(s -> expr, f);
// don't need the return value
fprintf(f, "\tCMP $0, %s\n", register_name(s -> expr -> reg));
register_free(s -> expr -> reg);
assembly_comment(f, "\t# jump to done label (break condition)\n");
fprintf(f, "\tJE L%d\n", done);
}
stmt_codegen(s -> body, f);
if(s -> next_expr) {
expr_codegen(s -> next_expr, f);
register_free(s -> next_expr -> reg);
}
assembly_comment(f, "\t# unconditional jump to next loop\n");
fprintf(f, "JMP L%d\n", loop);
assembly_comment(f, "\t# done label\n");
fprintf(f, "L%d:\n", done);
break;
}
case STMT_WHILE:
fprintf(stderr, "CODEGEN_ERROR: cminor does not support while loops\n");
exit(1);
break;
case STMT_PRINT: {
struct expr *curr = s -> expr;
while(curr) {
expr_codegen(curr, f);
int count = 0;
if(ASSEMBLY_COMMENT_FLAG) {
fprintf(f, "\t# move arg %d (in %s) into %s\n", count, register_name(curr -> reg), register_arg_names[count]);
}
fprintf(f, "\tMOVQ %s, %s\n", register_name(curr -> reg), register_arg_names[count++]);
register_free(curr -> reg);
// calls func_codegen which save ret val in reg
// so need to free reg beforehand
stmt_call_print(curr, f);
curr = curr -> next;
}
break;
}
case STMT_RET:
expr_codegen(s -> expr, f);
if(ASSEMBLY_COMMENT_FLAG) {
fprintf(f, "\n\t# return statement (return ");
expr_fprint(f, s -> expr);
fprintf(f, ")\n");
}
if(s -> expr) {
fprintf(f, "\tMOVQ %s, %%rax\n", register_name(s -> expr -> reg));
register_free(s -> expr -> reg);
}
// postamble
assembly_comment(f, "\t### function postamble\n");
assembly_comment(f, "\t# restore callee-saved registers\n");
fprintf(f, "\tPOPQ %%r15\n");
fprintf(f, "\tPOPQ %%r14\n");
fprintf(f, "\tPOPQ %%r13\n");
fprintf(f, "\tPOPQ %%r12\n");
fprintf(f, "\tPOPQ %%rbx\n");
assembly_comment(f, "\t# reset stack to base pointer\n");
fprintf(f, "\tMOVQ %%rbp, %%rsp\n");
assembly_comment(f, "\t# restore the old base pointer\n");
fprintf(f, "\tPOPQ %%rbp\n");
fprintf(f, "\tRET\n");
break;
case STMT_BLOCK:
stmt_codegen(s -> body, f);
break;
}
stmt_codegen(s -> next, f);
}
void compare(struct expr *e, FILE *file) {
expr_codegen(e->left, file);
expr_codegen(e->right, file);
e->reg = register_alloc();
if(expr_typecheck(e->left)->kind==TYPE_STRING && expr_typecheck(e->right)->kind==TYPE_STRING){
fprintf(file, "\n\t#String comparison\n");
const char *left;
const char *right;
//get the correct string for left
if(e->left->kind==EXPR_STRING_LITERAL) left = e->left->string_literal;
else if(e->left->kind==EXPR_IDENT) left = e->left->symbol->string_literal;
//get the correct string for right
if(e->right->kind==EXPR_STRING_LITERAL) right = e->right->string_literal;
else if(e->right->kind==EXPR_IDENT) right = e->right->symbol->string_literal;
//compare the strings
int result = strcmp(left, right);
if(e->kind == EXPR_EQ){
if(result){
fprintf(file, "\tMOV $0, %s\n", register_name(e->reg));
} else {
fprintf(file, "\tMOV $1, %s\n", register_name(e->reg));
}
} else if(e->kind == EXPR_NE){
if(result){
fprintf(file, "\tMOV $1, %s\n", register_name(e->reg));
} else {
fprintf(file, "\tMOV $0, %s\n", register_name(e->reg));
}
}
} else {
fprintf(file, "\n\t#Comparison\n");
fprintf(file, "\tCMP %s, %s\n", register_name(e->right->reg), register_name(e->left->reg));
register_free(e->left->reg);
register_free(e->right->reg);
char *jump = malloc(4);
switch(e->kind){
case EXPR_GE:
strcpy(jump, "JGE");
break;
case EXPR_LE:
strcpy(jump, "JLE");
break;
case EXPR_GT:
strcpy(jump, "JG");
break;
case EXPR_LT:
strcpy(jump, "JL");
break;
case EXPR_EQ:
strcpy(jump, "JE");
break;
case EXPR_NE:
strcpy(jump, "JNE");
break;
}
int label_true = label_count++;
int label_false = label_count++;
fprintf(file, "\t%s L%d\n", jump, label_true);
fprintf(file, "\tMOV $0, %s\n", register_name(e->reg));
fprintf(file, "\tJMP L%d\n", label_false);
fprintf(file, "L%d:\n", label_true);
fprintf(file, "\tMOV $1, %s\n", register_name(e->reg));
fprintf(file, "L%d:\n", label_false);
free(jump);
}
}
//Generates code and writes it to a file
void expr_codegen(struct expr *e, FILE *file) {
if(!e) return;
struct expr *e2;
switch(e->kind) {
case EXPR_ASSIGNMENT:
fprintf(file, "\n\t#Assignment of %s %d right value\n", e->left->symbol->name, e->left->symbol->which);
expr_codegen(e->right, file);
fprintf(file, "\n\t#Assignment assign to %s %d\n", e->left->symbol->name, e->left->symbol->which);
fprintf(file, "\tMOV %s, %s\n", register_name(e->right->reg), symbol_code(e->left->symbol));
e->reg = e->right->reg;
register_free(e->left->reg);
break;
case EXPR_GE: //all of these go to the compare function
case EXPR_LE:
case EXPR_GT:
case EXPR_LT:
case EXPR_EQ:
case EXPR_NE:
compare(e, file);
break;
case EXPR_ADD:
expr_codegen(e->left, file);
expr_codegen(e->right, file);
fprintf(file, "\n\t#Addition\n");
fprintf(file, "\tADD %s, %s\n", register_name(e->left->reg), register_name(e->right->reg));
e->reg = e->right->reg;
register_free(e->left->reg);
break;
case EXPR_SUB:
expr_codegen(e->left, file);
expr_codegen(e->right, file);
fprintf(file, "\n\t#Subtraction\n");
fprintf(file, "\tSUB %s, %s\n", register_name(e->right->reg), register_name(e->left->reg));
e->reg = e->left->reg;
register_free(e->right->reg);
break;
case EXPR_MUL:
expr_codegen(e->left, file);
expr_codegen(e->right, file);
fprintf(file, "\n\t#Multiplication\n");
fprintf(file, "\tMOV %s, %%rax\n", register_name(e->left->reg));
fprintf(file, "\tIMUL %s\n", register_name(e->right->reg));
fprintf(file, "\tMOV %%rax, %s\n", register_name(e->right->reg));
register_free(e->left->reg);
e->reg = e->right->reg;
break;
case EXPR_DIV:
expr_codegen(e->left, file);
expr_codegen(e->right, file);
fprintf(file, "\n\t#Division\n");
fprintf(file, "\tMOV %s, %%rax\n", register_name(e->left->reg));
fprintf(file, "\tCQO\n");
fprintf(file, "\tIDIV %s\n", register_name(e->right->reg));
fprintf(file, "\tMOV %%rax, %s\n", register_name(e->right->reg));
register_free(e->left->reg);
e->reg = e->right->reg;
break;
case EXPR_MOD:
expr_codegen(e->left, file);
expr_codegen(e->right, file);
fprintf(file, "\n\t#Modulus\n");
fprintf(file, "\tMOV %s, %%rax\n", register_name(e->left->reg));
fprintf(file, "\tCQO\n");
fprintf(file, "\tIDIV %s\n", register_name(e->right->reg));
fprintf(file, "\tMOV %%rdx, %s\n", register_name(e->right->reg));
register_free(e->left->reg);
e->reg = e->right->reg;
break;
case EXPR_POW:
expr_codegen(e->left, file);
expr_codegen(e->right, file);
int label_start = label_count++;
int label_end = label_count++;
fprintf(file, "\n\t#Exponent function\n");
fprintf(file, "\tMOV $1, %%rax\n");
fprintf(file, "L%d:\n", label_start);
fprintf(file, "\tCMP $0, %s\n", register_name(e->right->reg));
fprintf(file, "\tJE L%d\n", label_end);
fprintf(file, "\tSUB $1, %s\n", register_name(e->right->reg));
fprintf(file, "\tMUL %s\n", register_name(e->left->reg));
fprintf(file, "\tJMP L%d\n", label_start);
fprintf(file, "L%d:\n", label_end);
register_free(e->left->reg);
register_free(e->right->reg);
e->reg = register_alloc();
fprintf(file, "\tMOV %%rax, %s\n", register_name(e->reg));
break;
case EXPR_LOGICAL_NOT:
expr_codegen(e->right, file);
fprintf(file, "\n\t#Logical Not\n");
e->reg = e->right->reg;
fprintf(file, "\tCMPQ $0, %s\n", register_name(e->reg));
fprintf(file, "\tJNE L%d\n", label_count);
fprintf(file, "\tMOV $1, %s\n", register_name(e->reg));
fprintf(file, "\tJMP L%d\n", label_count+1);
fprintf(file, "L%d:\n", label_count++);
fprintf(file, "\tMOV $0, %s\n", register_name(e->reg));
fprintf(file, "L%d:\n", label_count++);
break;
case EXPR_LOGICAL_AND:
expr_codegen(e->left, file);
expr_codegen(e->right, file);
fprintf(file, "\n\t#Logical And\n");
fprintf(file, "\tAND %s, %s\n", register_name(e->left->reg), register_name(e->right->reg));
e->reg = e->right->reg;
register_free(e->left->reg);
break;
case EXPR_LOGICAL_OR:
expr_codegen(e->left, file);
expr_codegen(e->right, file);
fprintf(file, "\n\t#Logical Or\n");
fprintf(file, "\tOR %s, %s\n", register_name(e->left->reg), register_name(e->right->reg));
e->reg = e->right->reg;
register_free(e->left->reg);
break;
case EXPR_POSTFIX_PLUS:
expr_codegen(e->left, file);
fprintf(file, "\n\t#Increment\n");
e->reg = register_alloc();
fprintf(file, "\tMOV %s, %s\n", register_name(e->left->reg), register_name(e->reg));
fprintf(file, "\tADD $1, %s\n", register_name(e->left->reg));
fprintf(file, "\tMOV %s, %s\n", register_name(e->left->reg), symbol_code(e->left->symbol));
register_free(e->left->reg);
break;
case EXPR_POSTFIX_MINUS:
expr_codegen(e->left, file);
fprintf(file, "\n\t#Increment\n");
e->reg = register_alloc();
fprintf(file, "\tMOV %s, %s\n", register_name(e->left->reg), register_name(e->reg));
fprintf(file, "\tSUB $1, %s\n", register_name(e->left->reg));
fprintf(file, "\tMOV %s, %s\n", register_name(e->left->reg), symbol_code(e->left->symbol));
register_free(e->left->reg);
break;
case EXPR_IDENT:
fprintf(file, "\n\t#Identifier %d %s\n", e->symbol->which, e->symbol->name);
e->reg = register_alloc();
if(e->symbol->type->kind == TYPE_STRING && e->symbol->kind == SCOPE_GLOBAL){
fprintf(file, "\tLEA %s, %s\n", symbol_code(e->symbol), register_name(e->reg));
} else {
fprintf(file, "\tMOV %s, %s\n", symbol_code(e->symbol), register_name(e->reg));
}
break;
case EXPR_INTEGER_LITERAL:
//comment label
fprintf(file, "\n\t#Integer literal %d\n", e->literal_value);
e->reg = register_alloc();
fprintf(file, "\tMOV $%d, %s\n", e->literal_value, register_name(e->reg));
break;
case EXPR_STRING_LITERAL:
//comment label
fprintf(file, "\n\t#String literal %s\n", e->string_literal);
e->reg = register_alloc();
fprintf(file, ".data\nSTR%d: \n.string \"%s\"\n.text\n", string_number, e->string_literal);
fprintf(file, "\tLEA STR%d, %s\n", string_number++, register_name(e->reg));
break;
case EXPR_CHAR_LITERAL:
fprintf(file, "\n\t#Char literal %c\n", e->literal_value);
e->reg = register_alloc();
fprintf(file, "\tMOV $%d, %s\n", e->literal_value, register_name(e->reg));
break;
case EXPR_TRUE:
fprintf(file, "\n\t#True\n");
e->reg = register_alloc();
fprintf(file, "\tMOV $%d, %s\n", e->literal_value, register_name(e->reg));
break;
case EXPR_FALSE:
fprintf(file, "\n\t#False\n");
e->reg = register_alloc();
fprintf(file, "\tMOV $%d, %s\n", e->literal_value, register_name(e->reg));
register_free(e->reg);
break;
case EXPR_FCALL:
if(function_params(e) >= 6) fcall_error();
e->reg = register_alloc();
fprintf(file, "\n\t#Calling function %s\n", e->left->name);
if(!e->right){
/* do nothing for no params */
} else if(e->right->kind != EXPR_COMMA){ //this means single argument
expr_codegen(e->right, file);
fprintf(file, "\n\t#Move Only Argument\n");
fprintf(file, "\tMOV %s, %%rdi\n", register_name(e->right->reg));
register_free(e->right->reg);
} else { //multiple parameters
struct expr *param = e->right;
int param_number = 0;
while(param->kind == EXPR_COMMA){
expr_codegen(param->left, file);
fprintf(file, "\n\t#Move Argument %d\n", param_number);
fprintf(file, "\tMOV %s, ", register_name(param->left->reg));
register_free(param->left->reg);
switch(param_number++){
case 0: fprintf(file, "%%rdi"); break;
case 1: fprintf(file, "%%rsi"); break;
case 2: fprintf(file, "%%rdx"); break;
case 3: fprintf(file, "%%rcx"); break;
case 4: fprintf(file, "%%r8"); break;
case 5: fprintf(file, "%%r9"); break;
}
fprintf(file, "\n");
param = param->right;
}
expr_codegen(param, file);
fprintf(file, "\n\t#Move Argument %d\n", param_number);
fprintf(file, "\tMOV %s, ", register_name(param->reg));
switch(param_number++){
case 0: fprintf(file, "%%rdi"); break;
case 1: fprintf(file, "%%rsi"); break;
case 2: fprintf(file, "%%rdx"); break;
case 3: fprintf(file, "%%rcx"); break;
case 4: fprintf(file, "%%r8"); break;
case 5: fprintf(file, "%%r9"); break;
}
fprintf(file, "\n");
register_free(param->reg);
}
fprintf(file, "\tPUSH %%r10\n");
fprintf(file, "\tPUSH %%r11\n");
fprintf(file, "\n\tCALL %s\n\n", e->left->name);
fprintf(file, "\tPOP %%r11\n");
fprintf(file, "\tPOP %%r10\n");
fprintf(file, "\tMOV %%rax, %s\n", register_name(e->reg));
break;
case EXPR_PARENS:
expr_codegen(e->right, file);
e->reg = e->right->reg;
break;
case EXPR_ARRCALL: //These 4 have to do with arrays
case EXPR_ARRINDEX: //We are not implementing arrays for codegen
case EXPR_BLOCK:
case EXPR_BLOCK_COMMA:
array_error();
break;
}
}
void stmt_codegen(struct stmt *s, FILE * output) {
struct expr * e_cursor;
int label_save;
if (!s) return;
switch (s->kind) {
case STMT_DECL:
decl_codegen(s->decl, output);
break;
case STMT_EXPR:
expr_codegen(s->expr, output);
register_free(s->expr->reg);
break;
case STMT_IF_ELSE:
fprintf(output, "\n\t## if statement ##\n");
label_save = label_count;
label_count+=2;
expr_codegen(s->expr, output);
fprintf(output, "\tCMP $0, %s\n", register_name(s->expr->reg));
register_free(s->expr->reg);
fprintf(output, "\tJE .L%d\n", label_save);
stmt_codegen(s->body, output);
fprintf(output, "\tJMP .L%d\n", label_save+1);
fprintf(output, "\t.L%d:\n", label_save);
stmt_codegen(s->else_body, output);
fprintf(output, "\t.L%d:\n", label_save+1);
fprintf(output, "\n\t## end of if statement ##\n");
break;
case STMT_FOR:
label_save = label_count;
label_count+=2;
fprintf(output, "\n\t## for loop ##\n");
expr_codegen(s->init_expr, output);
if(s->init_expr) { // for infinite for loops
register_free(s->init_expr->reg);
}
fprintf(output, "\t.L%d:\n", label_save);
expr_codegen(s->expr, output);
if (s->expr) { // for infinite for loops
register_free(s->expr->reg);
fprintf(output, "\tCMP $0, %s\n", register_name(s->expr->reg));
fprintf(output, "\tJE .L%d\n", label_save+1);
}
stmt_codegen(s->body, output);
expr_codegen(s->next_expr, output);
if (s->next_expr) {
register_free(s->next_expr->reg);
}
fprintf(output, "\tJMP .L%d\n", label_save);
fprintf(output, "\t.L%d:\n", label_save+1);
fprintf(output, "\t## end of for loop ##\n");
break;
case STMT_PRINT:
if(s->expr) {
if(s->expr->kind == EXPR_LIST) { // multiple things to print
e_cursor = s->expr; // traverse the expr_list
while(e_cursor) {
expr_print_codegen(e_cursor->left, output);
e_cursor = e_cursor->right;
}
}
else { // single thing to print
expr_print_codegen(s->expr, output);
}
}
break;
case STMT_RETURN:
fprintf(output, "\n\t## return statement ##\n");
if (s->expr) {
expr_codegen(s->expr, output);
fprintf(output, "\tMOV %s, %%rax\n", register_name(s->expr->reg));
register_free(s->expr->reg);
fprintf(output, "\tJMP .ret%d\n", ret_count); // return to caller
}
else {
fprintf(output, "\tJMP .ret%d\n", ret_count);
}
fprintf(output, "\t## end return statement ##\n\n");
break;
case STMT_BLOCK:
stmt_codegen(s->body, output);
break;
case STMT_EMPTY:
break;
}
stmt_codegen(s->next, output);
}
