assembly_gen.c

#include <stdlib.h>
#include <stdio.h>
#include <string.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;
}

void    asm_gen_function_start(FILE *out, char* function_name) {
    fprintf(out, "%s:\n", function_name);
    fprintf(out, "\tpushl\t(%%ebp)\n");
    fprintf(out, "\tmovl\t%%esp, %%ebp\n");
    fprintf(out, "\tsubl\t$16, %%esp\n");
}

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);
    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++);
    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;
    default:
        fprintf(out,"\tnop\n");
        break;
    }
    mcc_assembly_add_offset_variable(asm_container, te);
    fprintf(out, "\tfstps\t%d(%%ebp)\n", mcc_assembly_get_current_offset(asm_container));
}


void asm_gen_relation_int_op(FILE *out, struct mcc_tac_entry *te, struct mcc_asm_gen_container *asm_container)
{   
    //TODO offset from te->arg1 lookup
    fprintf(out, "\tmovl\t%d(%%ebp), %%edx\n",
		mcc_assembly_get_current_offset(asm_container));

    //TODO offset from te->arg2 lookup
    fprintf(out, "\tcmpl\t%d(%%ebp), %%edx\n",
		mcc_assembly_get_current_offset(asm_container));
    
    switch (te->tac_op)
    {

    case MCC_TAC_EQ:
        fprintf(out, "\tsete\t%%al\n");
		break;
    case MCC_TAC_GT:
        fprintf(out, "\tsetg\t%%al\n");
		break;
    case MCC_TAC_GTEQ:
		fprintf(out, "\tsetge\t%%al\n");
		break;
    case MCC_TAC_LT:
        fprintf(out, "\tsetl\t%%al\n");
		break;
    case MCC_TAC_LTEQ:
        fprintf(out, "\tsetle\t%%al\n");
		break;
    case MCC_TAC_NEQ:
		fprintf(out, "\tsetne\t%%al\n");
		break;
    default:
        fprintf(out,"\tnop\n");
        break;
    }
    fprintf(out, "\tmovzbl\t%%al, %%edx\n");
    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_relation_float_op(FILE *out, struct mcc_tac_entry *te, struct mcc_asm_gen_container *asm_container)
{   
    //TODO offset from te->arg2 lookup
    fprintf(out, "\tflds\t%d(%%ebp)\n",
		mcc_assembly_get_current_offset(asm_container));

    //TODO offset from te->arg1 lookup
    fprintf(out, "\tflds\t%d(%%ebp)\n",
		mcc_assembly_get_current_offset(asm_container));

    fprintf(out, "\tfcomip\t%%st(1), %%st\n");
	fprintf(out, "\tfstp\t%%st(0)\n");
    
    switch (te->tac_op)
    {

    case MCC_TAC_EQ_FLOAT:
       	fprintf(out, "\tsete\t%%al\n");
		break;
    case MCC_TAC_GT_FLOAT:
       fprintf(out, "\tseta\t%%al\n");
		break;
    case MCC_TAC_GTEQ_FLOAT:
		fprintf(out, "\tsetae\t%%al\n");
		break;
    case MCC_TAC_LT_FLOAT:
        fprintf(out, "\tsetb\t%%al\n");
		break;
    case MCC_TAC_LTEQ_FLOAT:
        fprintf(out, "\tsetbe\t%%al\n");
		break;
    case MCC_TAC_NEQ_FLOAT:
		fprintf(out, "\tsetne\t%%al\n");
		break;
    default:
        fprintf(out,"\tnop\n");
        break;
    }
    fprintf(out, "\tmovzbl\t%%al, %%edx\n");
    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_param_pop(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));
    fprintf(out, "\tmovl\t%%eax, %d(%%ebp)\n", mcc_assembly_get_current_offset(asm_container));
    // increase parameter offset
    mcc_assembly_add_offset_variable(asm_container, te);
}

void asm_gen_param_pop_array(FILE *out, struct mcc_tac_entry *te, struct mcc_asm_gen_container *asm_container)
{   

    
    // increase parameter offset
    mcc_assembly_add_offset_variable(asm_container, te);
}

void asm_gen_load(FILE *out, struct mcc_tac_entry *te, struct mcc_asm_gen_container *asm_container)
{   
    struct mcc_assembly_offset *arg1_offset = find_var(te -> arg1, asm_container);
    struct mcc_assembly_offset *arg2_offset = find_var(te -> arg2, asm_container);

    fprintf(out, "\tmovl\t%d(%%ebp), %%edx\n", arg1_offset->offset);
    fprintf(out, "\tmovl\t%d(%%ebp), %%ecx\n", arg1_offset->offset);
    fprintf(out, "\tmovl\t0(%%ecx, %%edx, %d), %%eax\n", 4);
}

void asm_gen_load_float(FILE *out, struct mcc_tac_entry *te, struct mcc_asm_gen_container *asm_container)
{   
    struct mcc_assembly_offset *arg1_offset = find_var(te -> arg1, asm_container);
    struct mcc_assembly_offset *arg2_offset = find_var(te -> arg2, asm_container);

    fprintf(out, "\tmovl\t%d(%%ebp), %%edx\n", arg1_offset->offset);
    fprintf(out, "\tmovl\t%d(%%ebp), %%ecx\n", arg2_offset->offset);
    fprintf(out, "\tflds\t%d(%%ebp, %%edx, %d)\n", arg1_offset->offset, 8);
}

void asm_gen_store(FILE *out, struct mcc_tac_entry *te, struct mcc_asm_gen_container *asm_container)
{   
    struct mcc_assembly_offset *arg1_offset = find_var(te -> arg1, asm_container);
    struct mcc_assembly_offset *arg2_offset = find_var(te -> arg2, asm_container);

    fprintf(out, "\tmovl\t%d(%%ebp), %%eax\n", arg1_offset->offset);
    fprintf(out, "\tmovl\t%d(%%ebp), %%edx\n", arg2_offset->offset);
    fprintf(out, "\tmovl\t%d(%%ebp), %%ecx\n", mcc_assembly_get_current_offset(asm_container));
    fprintf(out, "\tmovl\t%%eax, 0(%%ecx, %%edx, %d)\n", 4);
}

void asm_gen_store_float(FILE *out, struct mcc_tac_entry *te, struct mcc_asm_gen_container *asm_container)
{   
    struct mcc_assembly_offset *arg1_offset = find_var(te -> arg1, asm_container);
    struct mcc_assembly_offset *arg2_offset = find_var(te -> arg2, asm_container);

    fprintf(out, "\tflds\t%d(%%ebp)\n", arg1_offset->offset);
    fprintf(out, "\tmovl\t%d(%%ebp), %%edx\n", arg2_offset->offset);
    fprintf(out, "\tmovl\t%d(%%ebp), %%ecx\n", mcc_assembly_get_current_offset(asm_container));
    fprintf(out, "\tfstps\t0(%%ecx, %%edx, %d)\n", 8);
}


void mcc_asm_gen(FILE *out, struct mcc_tac *tac, struct mcc_asm_gen_container *asm_container) {
    fprintf(out, ".text\n");
	fprintf(out, ".globl	main\n");
	fprintf(out, ".type	main, @function\n");
    for(int i = 0; i < tac->tac_entries->size; i++) {
        struct mcc_tac_entry *entry = tac->tac_entries->arr[i];

        switch (entry -> tac_op) {
            case MCC_TAC_FUNCTION_START:
                asm_gen_function_start(out, entry -> arg2);
                break;
            case MCC_TAC_FUNCTION_END:
                asm_gen_function_end_no_return(out);
                break;
            case MCC_TAC_CALL:

                break;
            case MCC_TAC_LABEL :
                fprintf(out, ".%s:\n",entry->result);
                break;
            case MCC_TAC_JMP :
                fprintf(out, "\tjmp\t.%s\n", entry->result);
                break;
            case MCC_TAC_JMP_FALSE :
                fprintf(out, "\tcmpl\t$0, %d(%%ebp)\n", mcc_assembly_get_current_offset(asm_container));
                fprintf(out, "\tje\t.%s\n", entry->result);
                break;
            case MCC_TAC_RETURN:
                asm_gen_function_end_with_return(out, entry, asm_container);
                break;
            case MCC_TAC_INT:
                asm_gen_assignment_int(out, entry, asm_container);
                break;
            case MCC_TAC_STRING:
                asm_gen_assignment_string(out, entry, asm_container);
                break;
            case MCC_TAC_FLOAT:
                asm_gen_assignment_float(out, entry, asm_container);
                break;
            case MCC_TAC_BOOL:
                asm_gen_assignment_bool(out, entry, asm_container);
                break;
            case MCC_TAC_PLUS_INT:
            case MCC_TAC_MINUS_INT_BIN: 
            case MCC_TAC_MUL_INT:
            case MCC_TAC_DIV_INT:
                asm_gen_binary_int_op(out, entry, asm_container);
                break;
            case MCC_TAC_PLUS_FLOAT:
            case MCC_TAC_MINUS_FLOAT_BIN: 
            case MCC_TAC_MUL_FLOAT:
            case MCC_TAC_DIV_FLOAT:
                asm_gen_binary_float_op(out, entry, asm_container);
                break;
            case MCC_TAC_EQ:
            case MCC_TAC_GT:
            case MCC_TAC_GTEQ:
            case MCC_TAC_LT:
            case MCC_TAC_LTEQ:
            case MCC_TAC_NEQ:
                asm_gen_relation_int_op(out, entry, asm_container);
                break;
            case MCC_TAC_EQ_FLOAT:
            case MCC_TAC_GT_FLOAT:
            case MCC_TAC_GTEQ_FLOAT:
            case MCC_TAC_LT_FLOAT:
            case MCC_TAC_LTEQ_FLOAT:
            case MCC_TAC_NEQ_FLOAT:
                asm_gen_relation_float_op(out, entry, asm_container);
                break;

            // push 
            case MCC_TAC_PARAM_BOOL:
            case MCC_TAC_PARAM_INT:
            case MCC_TAC_PARAM_FLOAT:
            case MCC_TAC_PARAM_STRING:
                asm_gen_param(out,entry,asm_container);
                break;
            case MCC_TAC_PARAM_BOOL_ARR:
            case MCC_TAC_PARAM_INT_ARR:
            case MCC_TAC_PARAM_FLOAT_ARR:
            case MCC_TAC_PARAM_STRING_ARR:
                asm_gen_param_array(out,entry, asm_container);
                break;
            
            //pop
            case MCC_TAC_PARAM_POP_BOOL:
            case MCC_TAC_PARAM_POP_INT:
            case MCC_TAC_PARAM_POP_FLOAT:
            case MCC_TAC_PARAM_POP_STRING:
                asm_gen_param_pop(out, entry, asm_container);
                break;
            case MCC_TAC_PARAM_POP_BOOL_ARR:
            case MCC_TAC_PARAM_POP_INT_ARR:
            case MCC_TAC_PARAM_POP_FLOAT_ARR:
            case MCC_TAC_PARAM_POP_STRING_ARR:
                asm_gen_param_pop_array(out, entry, asm_container);
                break;
            case MCC_TAC_ARR_DECL :
                // set stack offset size of pointer * elements
                break;

            //load
            case MCC_TAC_LOAD_BOOL:
            case MCC_TAC_LOAD_INT:
            case MCC_TAC_LOAD_STRING:
                asm_gen_load(out, entry, asm_container);
                break;
            case MCC_TAC_LOAD_FLOAT:
                asm_gen_load_float(out, entry, asm_container);
                break;
            
            //store
            case MCC_TAC_STORE_BOOL:
            case MCC_TAC_STORE_INT:
            case MCC_TAC_STORE_STRING:
                asm_gen_store(out, entry, asm_container);
                break;
            
            case MCC_TAC_STORE_FLOAT:
                asm_gen_store_float(out, entry, asm_container);
                break;
        }
    }
}

int mcc_asm_gen_creator(FILE *out, struct mcc_tac *tac, struct mcc_symbol_table *st) {
    struct mcc_asm_gen_container *ac = malloc(sizeof(*ac));

    ac -> variable_offsets = mcc_create_dynamic_array(20);
    ac->labelCounter = 0;

    mcc_asm_gen(out, tac, ac);


    return 0;
}

void mcc_invoke_gcc(char *file_name, char *output)
{
    //TODO add file for builtins

    char *gcc_arguments[6];
    gcc_arguments[0] = "gcc";
	gcc_arguments[1] = "-m32";
	// gcc_arguments[2] = file_name_built_in;
	gcc_arguments[2] = file_name;
	gcc_arguments[3] = "-o";
	gcc_arguments[4] = output;
	gcc_arguments[5] = NULL;

    execvp("/usr/bin/gcc", gcc_arguments);
}


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

/*
void mcc_asm_add_constant(struct mcc_asm_constant **entries,  enum mcc_asm_contant_type type, int *counter, void *value ){
    
    struct mcc_asm_constant *add_const = (struct mcc_asm_constant *)malloc(sizeof(*add_const));
    add_const->const_type = type;
    add_const->next = NULL;
    add_const->number = ++(*counter);
    if(type == MCC_ASM_CONST_STRING){
        add_const->s_value = (char *) value;
    } else if (type == MCC_ASM_CONST_FLOAT){
        add_const->f_value = *((double *)value);
    }
    if (*entries == NULL) {
		*entries = add_const;
	} else {
		struct mcc_asm_constant *constant = *entries;
		while (constant->next != NULL) {
			constant = constant->next;
		}
		constant->next = add_const;
	}
}
*/

/*void mcc_asm_print_constant(FILE *out, struct mcc_asm_constant *constant)
{
    if (constant == NULL) {
		return;
	}
	fprintf(out, "\t.section\t.rodata\n");
    if (constant == NULL) {
	struct mcc_asm_constant *current = constant;
	while (current != NULL) {
		fprintf(out, ".LC%d:\n", current->number);
		switch (current->const_type) {
		case MCC_ASM_CONST_FLOAT:
			fprintf(out, "\t.float\t%lf\n", current->f_value);
			break;

		case MCC_ASM_CONST_STRING:
			fprintf(out, "\t.string\t\"%s\"\n", current->s_value);
			break;

		default:
			break;
		}
		current = current->next;
	}
}*/

/*
void mcc_asm_gen(FILE *out, struct mcc_tac *tac) {
    int const_count = 0;

    struct mcc_asm_constant *constants = NULL;

    for(int i = 0; i < tac->tac_entries->size; i++)
    {
        struct mcc_tac_entry *entry = tac->tac_entries->arr[i];
        char *arg1 = entry->arg1;
        //TODO calculate offset and save temp offset
        
        switch (entry->tac_op)
        {
        case MCC_TAC_FUNCTION_START:
            fprintf(out, "\t.globl %s\n", arg1);
			fprintf(out, "\t.type %s, @function\n", arg1);
			fprintf(out, "%s:\n", arg1);
			fprintf(out, "\tpushl\t%%ebp\n");
			fprintf(out, "\tmovl\t%%esp, %%ebp\n");
            break;   
        case MCC_TAC_CALL:
            fprintf(out, "\tcall\t%s\n", arg1);
            break;

        // unary 
        case MCC_TAC_MINUS_INT_UN:
            fprintf(out, "\tmovl\t%d(%%ebp), %%eax\n", offset);
	        fprintf(out, "\tnegl\t%%eax\n");
            fprintf(out, "\tmovl\t%%eax, %d(%%ebp)\n", offset);
            break;
        case MCC_TAC_MINUS_FLOAT_UN:
            break;
        case MCC_TAC_NOT:
            break;

        // binary
        case MCC_TAC_PLUS_INT:
            fprintf(out, "\tmovl\t%d(%%ebp), %%eax\n", arg1->offset);
            fprintf(out, "\taddl\t%d(%%ebp), %%eax\n", arg2->offset);
            fprintf(out, "\tmovl\t%%eax, %d(%%ebp)\n", result->offset);
            break;
        case MCC_TAC_MINUS_INT_BIN:
            fprintf(out, "\tmovl\t%d(%%ebp), %%eax\n", arg1->offset);
            fprintf(out, "\tsubl\t%d(%%ebp), %%eax\n", arg2->offset);
            fprintf(out, "\tmovl\t%%eax, %d(%%ebp)\n", result->offset);
		    break;
        case MCC_TAC_MUL_INT:
            fprintf(out, "\tmovl\t%d(%%ebp), %%eax\n", arg1->offset);
            fprintf(out, "\timull\t%d(%%ebp), %%eax\n", arg2->offset);
            fprintf(out, "\tmovl\t%%eax, %d(%%ebp)\n", result->offset);
            break;
        case MCC_TAC_DIV_INT:
            fprintf(out, "\tmovl\t%d(%%ebp), %%eax\n", arg1->offset);
            fprintf(out, "\tcltd\n");
		    fprintf(out, "\tidivl\t%d(%%ebp)\n", arg2->offset);
            fprintf(out, "\tmovl\t%%eax, %d(%%ebp)\n", result->offset);
            break;
        case MCC_TAC_PLUS_FLOAT:
            fprintf(out, "\tflds\t%d(%%ebp)\n", arg1->offset);
            fprintf(out, "\tfadds\t%d(%%ebp)\n", arg2->offset);
            fprintf(out, "\tfstps\t%d(%%ebp)\n", result->offset);
            break;
        case MCC_TAC_MINUS_FLOAT_BIN:
            fprintf(out, "\tflds\t%d(%%ebp)\n", arg1->offset);
            fprintf(out, "\tfsubs\t%d(%%ebp)\n", arg2->offset);
            fprintf(out, "\tfstps\t%d(%%ebp)\n", result->offset);
            break;
        case MCC_TAC_MUL_FLOAT:
            fprintf(out, "\tflds\t%d(%%ebp)\n", arg1->offset);
            fprintf(out, "\tfmuls\t%d(%%ebp)\n", arg2->offset);
            fprintf(out, "\tfstps\t%d(%%ebp)\n", result->offset);
		    break;
        case MCC_TAC_DIV_FLOAT:
            fprintf(out, "\tflds\t%d(%%ebp)\n", arg1->offset);
            fprintf(out, "\tfdivs\t%d(%%ebp)\n", arg2->offset);
            fprintf(out, "\tfstps\t%d(%%ebp)\n", result->offset);
		    break;
        case MCC_TAC_NOT_BOOL:
            fprintf(out, "\txorl\t$1, %%edx\n");
            break;
        case MCC_TAC_AND:
            fprintf(out, "\tmovl\t%d(%%ebp), %%eax\n", arg1->offset);
            fprintf(out, "\tandl\t%d(%%ebp), %%edx\n", arg2->offset);
            fprintf(out, "\tmovl\t%%eax, %d(%%ebp)\n", result->offset);
		    break;
        case MCC_TAC_OR:
            fprintf(out, "\tmovl\t%d(%%ebp), %%eax\n", arg1->offset);
            fprintf(out, "\torl\t%d(%%ebp), %%edx\n", arg2->offset);
            fprintf(out, "\tmovl\t%%eax, %d(%%ebp)\n", result->offset);
		    break;
        case MCC_TAC_EQ:
            fprintf(out, "\tmovl\t%d(%%ebp), %%eax\n", arg1->offset);
            fprintf(out, "\tcmpl\t%d(%%ebp), %%eax\n", arg2->offset);
            fprintf(out, "\tsete\t%%al\n");
            fprintf(out, "\tmovzbl\t%%al, %%eax\n");
            fprintf(out, "\tmovl\t%%eax, %d(%%ebp)\n", result->offset);
            break;
        case MCC_TAC_NEQ:
            fprintf(out, "\tmovl\t%d(%%ebp), %%eax\n", arg1->offset);
            fprintf(out, "\tcmpl\t%d(%%ebp), %%eax\n", arg2->offset);
            fprintf(out, "\tsetne\t%%al\n");
            fprintf(out, "\tmovzbl\t%%al, %%eax\n");
            fprintf(out, "\tmovl\t%%eax, %d(%%ebp)\n", result->offset);
            break;
        case MCC_TAC_GT:
            fprintf(out, "\tmovl\t%d(%%ebp), %%eax\n", arg1->offset);
            fprintf(out, "\tcmpl\t%d(%%ebp), %%eax\n", arg2->offset);
            fprintf(out, "\tsetg\t%%al\n");
            fprintf(out, "\tmovzbl\t%%al, %%eax\n");
            fprintf(out, "\tmovl\t%%eax, %d(%%ebp)\n", result->offset);
            break;
        case MCC_TAC_LT:
            fprintf(out, "\tmovl\t%d(%%ebp), %%eax\n", arg1->offset);
            fprintf(out, "\tcmpl\t%d(%%ebp), %%eax\n", arg2->offset);
            fprintf(out, "\tsetl\t%%al\n");
            fprintf(out, "\tmovzbl\t%%al, %%eax\n");
            fprintf(out, "\tmovl\t%%eax, %d(%%ebp)\n", result->offset);
            break;
        case MCC_TAC_LTEQ:
            fprintf(out, "\tmovl\t%d(%%ebp), %%eax\n", arg1->offset);
            fprintf(out, "\tcmpl\t%d(%%ebp), %%eax\n", arg2->offset);
            fprintf(out, "\tsetle\t%%al\n");
            fprintf(out, "\tmovzbl\t%%al, %%eax\n");
            fprintf(out, "\tmovl\t%%eax, %d(%%ebp)\n", result->offset);
            break;
        case MCC_TAC_GTEQ:
            fprintf(out, "\tmovl\t%d(%%ebp), %%eax\n", arg1->offset);
            fprintf(out, "\tcmpl\t%d(%%ebp), %%eax\n", arg2->offset);
            fprintf(out, "\tsetge\t%%al\n");
            fprintf(out, "\tmovzbl\t%%al, %%eax\n");
            fprintf(out, "\tmovl\t%%eax, %d(%%ebp)\n", result->offset);
            break;
        case MCC_TAC_LT_FLOAT:
            fprintf(out, "\tflds\t%d(%%ebp)\n", arg2->offset);
            fprintf(out, "\tflds\t%d(%%ebp)\n", arg1->offset);
            fprintf(out, "\tfcomip\t%%st(1), %%st\n");
            fprintf(out, "\tfstp\t%%st(0)\n");

            fprintf(out, "\tsetb\t%%al\n");

            fprintf(out, "\tmovzbl\t%%al, %%eax\n");
            fprintf(out, "\tmovl\t%%eax, %d(%%ebp)\n", result->offset);
            break;
        case MCC_TAC_LTEQ_FLOAT:
            fprintf(out, "\tflds\t%d(%%ebp)\n", arg2->offset);
            fprintf(out, "\tflds\t%d(%%ebp)\n", arg1->offset);
            fprintf(out, "\tfcomip\t%%st(1), %%st\n");
            fprintf(out, "\tfstp\t%%st(0)\n");

            fprintf(out, "\tsetbe\t%%al\n");

            fprintf(out, "\tmovzbl\t%%al, %%eax\n");
            fprintf(out, "\tmovl\t%%eax, %d(%%ebp)\n", result->offset);
            break;
        case MCC_TAC_GT_FLOAT:
            fprintf(out, "\tflds\t%d(%%ebp)\n", arg2->offset);
            fprintf(out, "\tflds\t%d(%%ebp)\n", arg1->offset);
            fprintf(out, "\tfcomip\t%%st(1), %%st\n");
            fprintf(out, "\tfstp\t%%st(0)\n");

            fprintf(out, "\tseta\t%%al\n");

            fprintf(out, "\tmovzbl\t%%al, %%eax\n");
            fprintf(out, "\tmovl\t%%eax, %d(%%ebp)\n", result->offset);
            break;
        case MCC_TAC_GTEQ_FLOAT:
            fprintf(out, "\tflds\t%d(%%ebp)\n", arg2->offset);
            fprintf(out, "\tflds\t%d(%%ebp)\n", arg1->offset);
            fprintf(out, "\tfcomip\t%%st(1), %%st\n");
            fprintf(out, "\tfstp\t%%st(0)\n");

            fprintf(out, "\tsetae\t%%al\n");

            fprintf(out, "\tmovzbl\t%%al, %%eax\n");
            fprintf(out, "\tmovl\t%%eax, %d(%%ebp)\n", result->offset);
            break;
        case MCC_TAC_EQ_FLOAT:
            fprintf(out, "\tflds\t%d(%%ebp)\n", arg2->offset);
            fprintf(out, "\tflds\t%d(%%ebp)\n", arg1->offset);
            fprintf(out, "\tfcomip\t%%st(1), %%st\n");
            fprintf(out, "\tfstp\t%%st(0)\n");

            fprintf(out, "\tsete\t%%al\n");

            fprintf(out, "\tmovzbl\t%%al, %%eax\n");
            fprintf(out, "\tmovl\t%%eax, %d(%%ebp)\n", result->offset);
            break;
        case MCC_TAC_EQ_BOOL:
            fprintf(out, "\tmovl\t%d(%%ebp), %%eax\n", arg1->offset);
            fprintf(out, "\tcmpl\t%d(%%ebp), %%eax\n", arg2->offset);
            fprintf(out, "\tsete\t%%al\n");
            fprintf(out, "\tmovzbl\t%%al, %%eax\n");
            fprintf(out, "\tmovl\t%%eax, %d(%%ebp)\n", result->offset);
            break;
        case MCC_TAC_NEQ_FLOAT:
            fprintf(out, "\tflds\t%d(%%ebp)\n", arg2->offset);
            fprintf(out, "\tflds\t%d(%%ebp)\n", arg1->offset);
            fprintf(out, "\tfcomip\t%%st(1), %%st\n");
            fprintf(out, "\tfstp\t%%st(0)\n");

            fprintf(out, "\tsetne\t%%al\n");

            fprintf(out, "\tmovzbl\t%%al, %%eax\n");
            fprintf(out, "\tmovl\t%%eax, %d(%%ebp)\n", result->offset);
            break;
        case MCC_TAC_NEQ_BOOL:
            fprintf(out, "\tmovl\t%d(%%ebp), %%eax\n", arg1->offset);
            fprintf(out, "\tcmpl\t%d(%%ebp), %%eax\n", arg2->offset);
            fprintf(out, "\tsetne\t%%al\n");
            fprintf(out, "\tmovzbl\t%%al, %%eax\n");
            fprintf(out, "\tmovl\t%%eax, %d(%%ebp)\n", result->offset);
            break;

        // literal
        case MCC_TAC_BOOL_LITERAL:
        //TODO parse arg1 to 0 or 1??
            int bool_value = (strcmp(arg1, "true") == 0) ? 1 : 0;
            fprintf(out, "\tmovl\t$%s, %d(%%ebp)\n",arg1, result->offset);
            break;
        case MCC_TAC_INT_LITERAL:
            fprintf(out, "\tmovl\t$%s, %d(%%ebp)\n",arg1, result->offset);
            break;
        case MCC_TAC_STRING_LITERAL:
            mcc_asm_add_constant(&constants,MCC_ASM_CONST_STRING,&const_count, arg1 );
            fprintf(out, "\tmovl\t$.LCONST%d, %d(%%ebp)\n", const_count,result->offset);
            break;
        case MCC_TAC_FLOAT_LITERAL:
        //TODO create new constant
            mcc_asm_add_constant(&constants,MCC_ASM_CONST_FLOAT,&const_count, arg1 );
            fprintf(out, "\tflds\t.LCONST%d\n", const_count);
            fprintf(out, "\tfstps\t%d(%%ebp)\n", result->offset);
            break;
         
        // copy 
        case MCC_TAC_BOOL:
            break;
        case MCC_TAC_INT:
            break;
        case MCC_TAC_STRING:
            break;
        case MCC_TAC_FLOAT:
            break;

        // push 
        case MCC_TAC_PARAM_BOOL:
        case MCC_TAC_PARAM_INT:
        case MCC_TAC_PARAM_FLOAT:
        case MCC_TAC_PARAM_STRING:
            fprintf(out, "\tpushl\t%d(%%ebp)\n", arg1->offset);
            break;
        case MCC_TAC_PARAM_BOOL_ARR:
        case MCC_TAC_PARAM_INT_ARR:
        case MCC_TAC_PARAM_FLOAT_ARR:
        case MCC_TAC_PARAM_STRING_ARR:
            fprintf(out, "\tleal\t%d(%%ebp), %%eax\n", arg1->offset);
            fprintf(out, "\tpushl\t%%eax\n");
            break;

        // pop
        case MCC_TAC_PARAM_POP_BOOL:
        case MCC_TAC_PARAM_POP_INT:
        case MCC_TAC_PARAM_POP_FLOAT:
        case MCC_TAC_PARAM_POP_STRING:
            fprintf(out, "\tmovl\t%d(%%ebp), %%eax\n", param_offset);
            fprintf(out, "\tmovl\t%%eax, %d(%%ebp)\n", result->offset);
            //increase param offset
            break;
        case MCC_TAC_PARAM_POP_BOOL_ARR:
        case MCC_TAC_PARAM_POP_INT_ARR:
        case MCC_TAC_PARAM_POP_FLOAT_ARR:
        case MCC_TAC_PARAM_POP_STRING_ARR:

            //increase param offset
            break;

        // load 
        case MCC_TAC_LOAD_BOOL:
        case MCC_TAC_LOAD_INT:
        case MCC_TAC_LOAD_STRING:
            fprintf(out, "\tmovl\t%d(%%ebp), %%edx\n", arg1->offset);
            fprintf(out, "\tmovl\t%d(%%ebp), %%ecx\n", arg2->offset);
            fprintf(out, "\tmovl\t0(%%ecx, %%edx, %d), %%eax\n", 4);
            break;
        case MCC_TAC_LOAD_FLOAT:
            fprintf(out, "\tmovl\t%d(%%ebp), %%edx\n", arg1->offset);
            fprintf(out, "\tmovl\t%d(%%ebp), %%ecx\n", arg2->offset);
            fprintf(out, "\tflds\t%d(%%ebp, %%edx, %d)\n", arg1->offset, 4);
            break;

        // store
        case MCC_TAC_STORE_BOOL:
        case MCC_TAC_STORE_INT:
        case MCC_TAC_STORE_STRING:
            fprintf(out, "\tmovl\t%d(%%ebp), %%eax\n", arg1->offset);
            fprintf(out, "\tmovl\t%d(%%ebp), %%edx\n", arg2->offset);
            fprintf(out, "\tmovl\t%d(%%ebp), %%ecx\n", offset);
            fprintf(out, "\tmovl\t%%eax, 0(%%ecx, %%edx, %d)\n", 4);
            break;
        
        case MCC_TAC_STORE_FLOAT:
            fprintf(out, "\tflds\t%d(%%ebp)\n", arg1->offset);
            fprintf(out, "\tmovl\t%d(%%ebp), %%edx\n", arg2->offset);
            fprintf(out, "\tmovl\t%d(%%ebp), %%ecx\n", offset);
            fprintf(out, "\tfstps\t0(%%ecx, %%edx, %d)\n", 4);
            break;

         // IR operations
        case MCC_TAC_JMP :
            fprintf(out, "\tjmp\t.%s\n", result + sizeof(char));
            break;
        case MCC_TAC_JMP_FALSE :
            fprintf(out, "\tcmpl\t$0, %d(%%ebp)\n", arg1->offset);
            fprintf(out, "\tje\t.%s\n", result + sizeof(char));
            break;
        case MCC_TAC_RETURN :
            fprintf(out, "\tleave\n");
	        fprintf(out, "\tret\n");
            break;
        case MCC_TAC_ARR_DECL :
            // set stack offset size of pointer * elements
            break;
        case MCC_TAC_LABEL :
            fprintf(out, ".%s:\n", result + sizeof(char));
            break;
        case MCC_TAC_FUNCTION_END :
            fprintf(out, "\tleave\n");
	        fprintf(out, "\tret\n");
            break;
    
        case MCC_TAC_UNKNOWN:
            break;
        }
    }

    fprintf(out, "\n");

    //TODO add constants
    mcc_asm_print_constant(out,constants);

    //fprintf(out, ".LCONST%d:\n", i);
   
}*/