assembly_gen.c

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>

#include "mcc/tac.h"
#include "mcc/tac_print.h"
#include "mcc/symbol_table.h"
#include "mcc/assembly_gen.h"
#include "mcc/assembly.h"

struct mcc_assembly_offset *find_var(char *temp, struct mcc_asm_gen_container *asm_container) {
    struct mcc_assembly_offset *a_offset = NULL;
    for (int i = 0; i < asm_container -> variable_offsets -> size; i++) {
       struct mcc_assembly_offset *ao = (struct mcc_assembly_offset *) asm_container -> variable_offsets -> arr[i];
        // printf("%s %s\n", temp, ao -> temporary);
        if(ao->temporary !=NULL){
            if (strcmp(ao->temporary, temp) == 0) {
                a_offset = ao;
                break;
            }
        }
        
    }

    return a_offset;
}

//TODO get vars_count of function to compute stack size
// void mcc_get_function_size(struct mcc_tac *tac, int *n_local_vars,
// 			   int *n_statements, int *return_found)
// {
// 	 for(int i = 0; i < tac->tac_entries->size; i++) {
//         struct mcc_tac_entry *entry = tac->tac_entries->arr[i];
//         do{
//             switch (entry->tac_op) {
//                 (*n_statements)++;

//                 case MCC_TAC_CALL:
//                     (*n_local_vars)++;
//                     break;

//                 /* LITERALS */
//                 case MCC_TAC_BOOL_LITERAL:
//                 case MCC_TAC_INT_LITERAL:
//                 case MCC_TAC_FLOAT_LITERAL:
//                 case MCC_TAC_STRING_LITERAL:

//                 case MCC_TAC_VARIABLE_DECLARATION:
//                     (*n_local_vars)++;
//                     break;

//                 /* ARRAYS */
//                 case MCC_TAC_ARR_DECL:
//                     (*n_local_vars) += entry->arg2;
//                     (*n_local_vars)++; // add array address
//                     break;
//                 default:
//                     break;
//                 }
              
//                 }   
//             while (entry->tac_op != MCC_TAC_FUNCTION_START);
        
//      }
// }

int mcc_compute_stack(int variable_size)
{
	int stack_size = variable_size * 4;
	if (stack_size % 16 != 0) {
		stack_size += (16 - stack_size % 16);
	}
	return stack_size;
}

void asm_gen_function_start(FILE *out, char* function_name) {
	fprintf(out, ".global	%s\n",function_name);
	fprintf(out, ".type	%s, @function\n",function_name);
    fprintf(out, "%s:\n", function_name);
    fprintf(out, "\tpushl\t(%%ebp)\n");
    fprintf(out, "\tmovl\t%%esp, %%ebp\n");
    //TODO add correct stack size 
    fprintf(out, "\tsubl\t$64, %%esp\n");
    //set current offset to 0
}

void asm_gen_function_end_no_return(FILE *out) {
    fprintf(out, "\tnop\n");
    fprintf(out, "\tpopl\t%%ebp\n");
    fprintf(out, "\tret\n");
}

void asm_gen_function_end_with_return(FILE *out, struct mcc_tac_entry *te, struct mcc_asm_gen_container *asm_container) {
    struct mcc_assembly_offset *ao = find_var(te -> result, asm_container);

    if (ao != NULL) {
        if(te->tac_op == MCC_TAC_FLOAT){
            fprintf(out, "\tflds\t%d(%%ebp)\n", ao -> offset);
        }else{
            fprintf(out, "\tmovl\t%d(%%ebp), %%eax\n", ao -> offset);
        }
        
    } else {
        fprintf(out, "\tnop\n");
    }

    fprintf(out, "\tleave\n");
    fprintf(out, "\tret\n");
}

void asm_gen_assignment_int(FILE *out, struct mcc_tac_entry *te, struct mcc_asm_gen_container *asm_container) {
    mcc_assembly_add_offset_variable(asm_container, te);

    fprintf(out, "\tmovl\t$%s, %d(%%ebp)\n", te -> arg1, mcc_assembly_get_current_offset(asm_container));
}

void asm_gen_assignment_bool(FILE *out, struct mcc_tac_entry *te, struct mcc_asm_gen_container *asm_container) {
    mcc_assembly_add_offset_variable(asm_container, te);
    if(strcmp("true",te->arg1) == 0){
        fprintf(out, "\tmovl $1,\t%d(%%ebp)\n", mcc_assembly_get_current_offset(asm_container));
    }else {
        fprintf(out, "\tmovl $0,\t%d(%%ebp)\n", mcc_assembly_get_current_offset(asm_container));
    }
   
}

void asm_gen_assignment_string(FILE *out, struct mcc_tac_entry *te, struct mcc_asm_gen_container *asm_container) {
    mcc_assembly_add_offset_variable(asm_container, te);
    te->arg1[strlen(te->arg1) - 2] = '\0';
    // fprintf(out, "\t.LC%d:\n", asm_container->labelCounter);
    // fprintf(out, "\t .string \"%s\"\n", te->arg1 + 2);
    mcc_assembly_add_constant(asm_container,MCC_ASM_CONST_STRING,te->arg1 + 2);
    fprintf(out, "\tmovl\t$.LC%d, %d(%%ebp)\n", asm_container->labelCounter++, mcc_assembly_get_current_offset(asm_container));
}

void asm_gen_assignment_float(FILE *out, struct mcc_tac_entry *te, struct mcc_asm_gen_container *asm_container) {
    mcc_assembly_add_offset_variable(asm_container, te);
    // fprintf(out, "\t.LC%d:\n", asm_container->labelCounter);
    // fprintf(out, "\t .long %s\n", te->arg1);
    fprintf(out,"\tflds .LC%d\n", asm_container->labelCounter++);
    mcc_assembly_add_constant(asm_container,MCC_ASM_CONST_FLOAT,te->arg1);
    fprintf(out, "\tfstps %d(%%ebp)\n",mcc_assembly_get_current_offset(asm_container));
}

void asm_gen_param(FILE *out, struct mcc_tac_entry *te, struct mcc_asm_gen_container *asm_container) {
    fprintf(out, "\tpushl\t%d(%%ebp)\n", mcc_assembly_get_current_offset(asm_container));
}

void asm_gen_param_array(FILE *out, struct mcc_tac_entry *te, struct mcc_asm_gen_container *asm_container) {
    fprintf(out, "\tleal\t%d(%%ebp), %%eax\n", mcc_assembly_get_current_offset(asm_container));
    fprintf(out, "\tpushl\t%%eax\n");
}

void asm_gen_binary_int_op(FILE *out, struct mcc_tac_entry *te, struct mcc_asm_gen_container *asm_container)
{
    fprintf(out, "\tmovl\t%d(%%ebp), %%eax\n", mcc_assembly_get_current_offset(asm_container));
    
    switch (te->tac_op)
    {
    case MCC_TAC_PLUS_INT:
        fprintf(out, "\taddl\t%d(%%ebp), %%eax\n", mcc_assembly_get_current_offset(asm_container));
        break;
    case MCC_TAC_MINUS_INT_BIN: 
        fprintf(out, "\tsubl\t%d(%%ebp), %%eax\n",mcc_assembly_get_current_offset(asm_container));
		break;
    case MCC_TAC_MUL_INT:
        fprintf(out, "\timull\t%d(%%ebp), %%eax\n", mcc_assembly_get_current_offset(asm_container));
        break;
    case MCC_TAC_DIV_INT:
        fprintf(out, "\tcltd\n");
		fprintf(out, "\tidivl\t%d(%%ebp)\n", mcc_assembly_get_current_offset(asm_container));
        break;
    default:
        fprintf(out,"\tnop\n");
        break;
    }
    mcc_assembly_add_offset_variable(asm_container, te);
    fprintf(out, "\tmovl\t%%eax, %d(%%ebp)\n", mcc_assembly_get_current_offset(asm_container));
}


void asm_gen_binary_float_op(FILE *out, struct mcc_tac_entry *te, struct mcc_asm_gen_container *asm_container)
{
    fprintf(out, "\tflds\t%d(%%ebp)\n", mcc_assembly_get_current_offset(asm_container));
   
    switch (te->tac_op)
    {
    case MCC_TAC_PLUS_FLOAT:
        fprintf(out, "\tfadds\t%d(%%ebp)\n", mcc_assembly_get_current_offset(asm_container));
        break;
    case MCC_TAC_MINUS_FLOAT_BIN: 
        fprintf(out, "\tfsubs\t%d(%%ebp)\n",mcc_assembly_get_current_offset(asm_container));
		break;
    case MCC_TAC_MUL_FLOAT:
        fprintf(out, "\tfmuls\t%d(%%ebp)\n", mcc_assembly_get_current_offset(asm_container));
        break;
    case MCC_TAC_DIV_FLOAT:
		fprintf(out, "\tfdivs\t%d(%%ebp)\n", mcc_assembly_get_current_offset(asm_container));
        break;