static inline void JIT_visit(ASTNode *node, int regs[], int reg) {
switch(node->type) {
case AST_BINARY_OP: {
ASTBinaryOp *binary_op = (ASTBinaryOp*)node;
int a_reg = alloc_reg(regs);
JIT_visit(binary_op->lhs, regs, a_reg);
int b_reg = alloc_reg(regs);
JIT_visit(binary_op->rhs, regs, b_reg);
switch(binary_op->op) {
case '+': jit_addr_i(reg, a_reg, b_reg); break;
case '-': jit_subr_i(reg, a_reg, b_reg); break;
case '*': jit_mulr_i(reg, a_reg, b_reg); break;
case '/': jit_divr_i(reg, a_reg, b_reg); break;
}
free_reg(regs, a_reg);
free_reg(regs, b_reg);
break;
}
case AST_INT: {
jit_movi_i(reg, ((ASTInt*)node)->value);
break;
}
}
}
void CRegRequirementList::Free()
{
reglist::iterator it;
varlist::iterator vit;
reg_item *item;
var_item *vitem;
int i;
for(i = m_rlist.size(), it = m_rlist.begin(); i; i--, it++){
item = &(*it);
free_reg(&item->addr, item->length);
}
for(i = m_vlist.size(), vit = m_vlist.begin(); i; i--, vit++){
vitem = &(vit->second);
if(vitem->var->blk == sections){
//
// reference to a global variable
//
vitem->var->ref_count -= vitem->ref_count;
}else{
vitem->var->blk_uuid = vitem->blk_id;
delete_variable(vitem->var);
}
}
m_rlist.clear();
m_vlist.clear();
}
int main(int argc, char *argv[])
{
FILE *binfile;
int max_steps = MAX_STEP;
y86sim_t *sim;
mem_t *saver, *savem;
int step = 0;
stat_t e = STAT_AOK;
if (argc < 2 || argc > 3)
usage(argv[0]);
/* set max steps */
if (argc > 2)
max_steps = atoi(argv[2]);
/* load binary file to memory */
if (strcmp(argv[1]+(strlen(argv[1])-4), ".bin"))
usage(argv[0]); /* only support *.bin file */
binfile = fopen(argv[1], "rb");
if (!binfile) {
err_print("Can't open binary file '%s'", argv[1]);
exit(1);
}
sim = new_y86sim(MEM_SIZE);
if (load_binfile(sim->m, binfile) < 0) {
err_print("Failed to load binary file '%s'", argv[1]);
free_y86sim(sim);
exit(1);
}
fclose(binfile);
/* save initial register and memory stat */
saver = dup_reg(sim->r);
savem = dup_mem(sim->m);
/* execute binary code step-by-step */
for (step = 0; step < max_steps && e == STAT_AOK; step++)
e = nexti(sim);
/* print final stat of y86sim */
printf("Stopped in %d steps at PC = 0x%x. Status '%s', CC %s\n",
step, sim->pc, stat_name(e), cc_name(sim->cc));
printf("Changes to registers:\n");
diff_reg(saver, sim->r, stdout);
printf("\nChanges to memory:\n");
diff_mem(savem, sim->m, stdout);
free_y86sim(sim);
free_reg(saver);
free_mem(savem);
return 0;
}
int main(int argc, char *argv[])
{
FILE *code_file;
int max_steps = 10000;
// edit by leo
init_sharemem();
// edit end
state_ptr s = new_state(MEM_SIZE);
mem_t saver = copy_reg(s->r);
mem_t savem;
int step = 0;
stat_t e = STAT_AOK;
if (argc < 2 || argc > 3)
usage(argv[0]);
code_file = fopen(argv[1], "r");
if (!code_file) {
fprintf(stderr, "Can't open code file '%s'\n", argv[1]);
exit(1);
}
if (!load_mem(s->m, code_file, 1)) {
printf("Exiting\n");
return 1;
}
savem = copy_mem(s->m);
// edit by leo
// printf("error happen after here!\n");
// edit end
if (argc > 2)
max_steps = atoi(argv[2]);
for (step = 0; step < max_steps && e == STAT_AOK; step++)
e = step_state(s, stdout);
printf("Stopped in %d steps at PC = 0x%x. Status '%s', CC %s\n",
step, s->pc, stat_name(e), cc_name(s->cc));
printf("Changes to registers:\n");
diff_reg(saver, s->r, stdout);
printf("\nChanges to memory:\n");
diff_mem(savem, s->m, stdout);
free_state(s);
free_reg(saver);
free_mem(savem);
return 0;
}
void function_gen(char *name,struct ASTNode *body) {
int r1;
struct Gsymbol *g=GLookup(name);
fprintf(fp,"LL%d:\n",g->binding);
fprintf(fp,"PUSH BP\n");
fprintf(fp,"MOV BP SP\n");
struct Lsymbol *temp=LSymbolHead;
free_all_regs();
r1=get_reg();
while(temp) {
if(temp->ref==0) {
fprintf(fp,"PUSH R%d\n",r1);
}
temp=temp->next;
}
free_reg();
printf("ffefwefwef1\n");
code_gen(body);
r1=get_reg();
temp=LSymbolHead;
while(temp) {
if(temp->ref==0) {
fprintf(fp,"POP R%d\n",r1);
}
temp=temp->next;
}
free_reg();
free_all_regs();
fprintf(fp,"POP BP\n");
fprintf(fp,"RET\n");
}
int main(int argc, char *argv[])
{
FILE *code_file;
int max_steps = 10000;
state_ptr s = new_state(MEM_SIZE);
mem_t saver = copy_reg(s->r);
mem_t savem;
int step = 0;
exc_t e = EXC_NONE;
if (argc < 2 || argc > 3)
usage(argv[0]);
code_file = fopen(argv[1], "r");
if (!code_file) {
fprintf(stderr, "Can't open code file '%s'\n", argv[1]);
exit(1);
}
if (!load_mem(s->m, code_file, 1)) {
printf("Exiting\n");
return 1;
}
savem = copy_mem(s->m);
if (argc > 2)
max_steps = atoi(argv[2]);
for (step = 0; step < max_steps && e == EXC_NONE; step++)
e = step_state(s, stdout);
printf("Stopped in %d steps at PC = 0x%x. Exception '%s', CC %s\n",
step, s->pc, exc_name(e), cc_name(s->cc));
printf("Changes to registers:\n");
diff_reg(saver, s->r, stdout);
printf("\nChanges to memory:\n");
diff_mem(savem, s->m, stdout);
free_state(s);
free_reg(saver);
free_mem(savem);
return 0;
}
int main(int argc,char** argv) {
if (argc != 3) {
fprintf(stderr,"usage: RE216_CLIENT hostname port\n");
return 1;
}
// -----------------------------------------------------------------
// ------------------------ Variables ------------------------------
// Buffer
char *input = NULL; // Taille d'entrée dynamique
char output[TAILLE_MSG];// Taille de réception fixée
// Liste chaînée pour l'envoi de fichiers
struct file fichiers;
memset(&fichiers, 0, sizeof(struct file));
// Récupération de la structure sockaddr_in6 pour l'adresse du serveur
struct sockaddr_in6* server_add = get_addr_info(atoi(argv[2]), argv[1]);
// Création de la socket
int sckt = do_socket();
// Connexion de la socket à l'adresse server_add
int conn = do_connect(sckt, *server_add);
// Initialisation des tableaux pour utliser select ------------------
fd_set fd_set_read; // Ici seront stockés les descripteurs de fichier
int i, select_ret_val;
// Socket du serveur quand elle existe
int socket_fichier = -1;
// Eventuellement : timeout du select
//~ struct timeval tv;
//~ tv.tv_sec = 5;
//~ tv.tv_usec = 0;
init_reg();
// -----------------------------------------------------------------
// -----------------------------------------------------------------
start_line();
// Boucle jusqu'à recevoir le "/quit" final
do {
// ------------------------ R.A.Z ------------------------------
// clean the set before adding file descriptors
FD_ZERO(&fd_set_read);
// add the fd for server connection
FD_SET(sckt, &fd_set_read);
// add the fd for user-input
FD_SET(fileno(stdin), &fd_set_read);
// -------------------------------------------------------------
// we now wait for any file descriptor to be available for reading
select_ret_val = select(sckt + 1, &fd_set_read, NULL, NULL, NULL);//&tv);
if (select_ret_val == -1) {
error("Erreur concernant le select ");
}
//printf("Le retour de la fonction select est : %i", select_ret_val);
for (i = 0; i < (sckt+1) && select_ret_val > 0; i++) {
// Le buffer est nettoyé avec memset directement dans les fonctions
//printf("Bonjour je suis le i n°%i. Retour => %i\n", i, select_ret_val);
// Si le file descripteur i est dans le set mis en écoute, c'est qu'il y a une activité
if (FD_ISSET(i, &fd_set_read)) {
// printf("Descripteur trouvé : %i\n", i);
if (i == fileno(stdin)) // C'est une entrée utilisateur
client_write(&input, sckt, &fichiers);
else // Les données viennent du serveur
if (!client_read(sckt, output, &fichiers, &socket_fichier))
break;
// Select_ret_val est le nombre de descripteurs où il y
// a eu une activité, on diminue donc sa valeur au fur
// et à mesure.
select_ret_val--;
}
}
} while(notquit(input) && notquit(output));
//printf("Extinction.\n");
free(input);
free_file(&fichiers);
free_reg();
// Fermeture de la socket
close_socket(sckt);
printf("Fin du tchat\n");
return 0;
}
void free_y86sim(y86sim_t *sim)
{
free_reg(sim->r);
free_mem(sim->m);
free((void *) sim);
}
void free_state(state_ptr s)
{
free_reg(s->r);
free_mem(s->m);
free((void *) s);
}
/*
* run_tty_sim - Run the simulator in TTY mode
*/
static void run_tty_sim()
{
int icount = 0;
byte_t run_status = STAT_AOK;
cc_t result_cc = 0;
int byte_cnt = 0;
mem_t mem0, reg0;
state_ptr isa_state = NULL;
/* In TTY mode, the default object file comes from stdin */
if (!object_file) {
object_file = stdin;
}
if (verbosity >= 2)
sim_set_dumpfile(stdout);
sim_init();
/* Emit simulator name */
if (verbosity >= 2)
printf("%s\n", simname);
byte_cnt = load_mem(mem, object_file, 1, START_PLACE);
if (byte_cnt == 0) {
fprintf(stderr, "No lines of code found\n");
exit(1);
} else if (verbosity >= 2) {
printf("%d bytes of code read\n", byte_cnt);
}
fclose(object_file);
if (do_check) {
isa_state = new_state(0);
free_reg(isa_state->r);
free_mem(isa_state->m);
isa_state->m = copy_mem(mem);
isa_state->r = copy_reg(reg);
isa_state->cc = cc;
}
if(verbosity > 0){
mem0 = copy_mem(mem);
reg0 = copy_reg(reg);
}
icount = sim_run_pipe(instr_limit, 5*instr_limit, &run_status, &result_cc);
if (verbosity > 0) {
printf("%d instructions executed\n", icount);
printf("Status = %s\n", stat_name(run_status));
printf("Condition Codes: %s\n", cc_name(result_cc));
printf("Changed Register State:\n");
diff_reg(reg0, reg, stdout);
printf("Changed Memory State:\n");
diff_mem(mem0, mem, stdout);
}
if (do_check) {
exit(0);
byte_t e = STAT_AOK;
int step;
bool_t match = TRUE;
for (step = 0; step < instr_limit && e == STAT_AOK; step++) {
e = step_state(isa_state, stdout);
}
if (diff_reg(isa_state->r, reg, NULL)) {
match = FALSE;
if (verbosity > 0) {
printf("ISA Register != Pipeline Register File\n");
diff_reg(isa_state->r, reg, stdout);
}
}
if (diff_mem(isa_state->m, mem, NULL)) {
match = FALSE;
if (verbosity > 0) {
printf("ISA Memory != Pipeline Memory\n");
diff_mem(isa_state->m, mem, stdout);
}
}
if (isa_state->cc != result_cc) {
match = FALSE;
if (verbosity > 0) {
printf("ISA Cond. Codes (%s) != Pipeline Cond. Codes (%s)\n",
cc_name(isa_state->cc), cc_name(result_cc));
}
}
if (match) {
printf("ISA Check Succeeds\n");
} else {
printf("ISA Check Fails\n");
}
}
/* Emit CPI statistics */
{
double cpi = instructions > 0 ? (double) cycles/instructions : 1.0;
printf("%d CPI: %d cycles/%d instructions = %.2f\n", PSIM_ID,
cycles, instructions, cpi);
}
}
int code_gen (struct ASTNode * root) {
int l1,l2,r,r1,r2,r3,r4,bind;
struct Fieldlist *field;
if(!root)
return 0;
switch(root->node) {
case NODETYPE_MUL :
r1=code_gen(root->ptr1);
GetVal(root->ptr1,r1);
r2=code_gen(root->ptr2);
GetVal(root->ptr2,r2);
fprintf(fp,"MUL R%d R%d\n",r1,r2);
free_reg();
return r1;
case NODETYPE_PLUS :
r1=code_gen(root->ptr1);
GetVal(root->ptr1,r1);
r2=code_gen(root->ptr2);
GetVal(root->ptr2,r2);
fprintf(fp,"ADD R%d R%d\n",r1,r2);
free_reg();
return r1;
case NODETYPE_MINUS :
r1=code_gen(root->ptr1);
GetVal(root->ptr1,r1);
r2=code_gen(root->ptr2);
GetVal(root->ptr2,r2);
fprintf(fp,"SUB R%d R%d\n",r1,r2);
free_reg();
return r1;
case NODETYPE_MOD :
r1=code_gen(root->ptr1);
GetVal(root->ptr1,r1);
r2=code_gen(root->ptr2);
GetVal(root->ptr2,r2);
fprintf(fp,"MOD R%d R%d\n",r1,r2);
free_reg();
return r1;
case NODETYPE_DIV :
r1=code_gen(root->ptr1);
GetVal(root->ptr1,r1);
r2=code_gen(root->ptr2);
GetVal(root->ptr2,r2);
fprintf(fp,"DIV R%d R%d\n",r1,r2);
free_reg();
return r1;
case NODETYPE_FIELD_END:
r1=code_gen(root->ptr1);
field=IsField(root->ptr1->type,root->ptr2->name);
r2=get_reg();
fprintf(fp,"MOV R%d %d\n",r2,field->field_num);
fprintf(fp,"ADD R%d R%d\n",r1,r2);
free_reg();
return r1;
case NODETYPE_FIELD:
r1=code_gen(root->ptr1);
field=IsField(root->ptr1->type,root->ptr2->name);
r2=get_reg();
fprintf(fp,"MOV R%d %d\n",r2,field->field_num);
fprintf(fp,"ADD R%d R%d\n",r1,r2);
fprintf(fp,"MOV R%d [R%d]\n",r1,r1);
free_reg();
return r1;
case NODETYPE_ASGN_PAIR:
printf("frienas");
if(root->ptr2->node==NODETYPE_FUNC)
{
r1=code_gen(root->ptr2);
fprintf(fp, "// im here\n");
if(root->ptr1->Lentry)
{
r2=get_reg();
r3=get_reg();
fprintf(fp,"MOV R%d %d\n",r2,root->ptr1->Lentry->binding);
fprintf(fp,"MOV R%d BP\n",r3);
fprintf(fp,"ADD R%d R%d\n",r2,r3);
fprintf(fp,"MOV [R%d] [R%d]\n",r2,r1);
fprintf(fp,"INR R%d\n",r2);
fprintf(fp,"INR R%d\n",r1);
fprintf(fp,"MOV [R%d] [R%d]\n",r2,r1);
free_reg();
free_reg();
}
else
{ r2=get_reg();
fprintf(fp,"MOV R%d %d\n",r2,root->ptr1->Lentry->binding);
fprintf(fp,"MOV [R%d] [R%d]\n",r2,r1);
fprintf(fp,"INR R%d\n",r2);
fprintf(fp,"INR R%d\n",r1);
fprintf(fp,"MOV [R%d] [R%d]\n",r2,r1);
free_reg();
}
}
if(root->ptr1->Lentry && root->ptr2->Lentry)
{
printf("sfsf\n");
r1=get_reg();
r2=get_reg();
fprintf(fp,"MOV R%d %d\n",r1,root->ptr1->Lentry->binding);
fprintf(fp,"MOV R%d BP\n",r2);
fprintf(fp,"ADD R%d R%d\n",r1,r2);
r3=get_reg();
fprintf(fp,"MOV R%d %d\n",r2,root->ptr2->Lentry->binding);
fprintf(fp,"MOV R%d BP\n",r3);
fprintf(fp,"ADD R%d R%d\n",r2,r3);
free_reg();
fprintf(fp,"MOV [R%d] [R%d]\n",r1,r2);
fprintf(fp,"INR R%d\n",r1);
fprintf(fp,"INR R%d\n",r2);
fprintf(fp,"MOV [R%d] [R%d]\n",r1,r2);
free_reg();
free_reg();
}
else if(root->ptr1->Gentry && root->ptr2->Lentry)
{
r1=get_reg();
r2=get_reg();
fprintf(fp,"MOV R%d %d\n",r1,root->ptr1->Gentry->binding);
r3=get_reg();
fprintf(fp,"MOV R%d %d\n",r2,root->ptr2->Lentry->binding);
fprintf(fp,"MOV R%d BP\n",r3);
fprintf(fp,"ADD R%d R%d\n",r2,r3);
free_reg();
fprintf(fp,"MOV [R%d] [R%d]\n",r1,r2);
fprintf(fp,"INR R%d\n",r1);
fprintf(fp,"INR R%d\n",r2);
fprintf(fp,"MOV [R%d] [R%d]\n",r1,r2);
free_reg();
free_reg();
}
else if(root->ptr1->Lentry && root->ptr2->Gentry)
{
printf("sfsf44\n");
r1=get_reg();
r2=get_reg();
fprintf(fp,"MOV R%d %d\n",r1,root->ptr1->Lentry->binding);
fprintf(fp,"MOV R%d BP\n",r2);
fprintf(fp,"ADD R%d R%d\n",r1,r2);
fprintf(fp,"MOV R%d %d\n",r2,root->ptr2->Gentry->binding);
fprintf(fp,"MOV [R%d] [R%d]\n",r1,r2);
fprintf(fp,"INR R%d\n",r1);
fprintf(fp,"INR R%d\n",r2);
fprintf(fp,"MOV [R%d] [R%d]\n",r1,r2);
free_reg();
free_reg();
}
else if(root->ptr1->Gentry && root->ptr2->Gentry)
{
r1=get_reg();
r2=get_reg();
fprintf(fp,"MOV R%d %d\n",r1,root->ptr1->Gentry->binding);
fprintf(fp,"MOV R%d %d\n",r2,root->ptr2->Gentry->binding);
fprintf(fp,"MOV [R%d] [R%d]\n",r1,r2);
fprintf(fp,"INR R%d\n",r1);
fprintf(fp,"INR R%d\n",r2);
fprintf(fp,"MOV [R%d] [R%d]\n",r1,r2);
free_reg();
free_reg();
}
return 0;
case NODETYPE_FST:
printf("sfs\n");
if(root->ptr1->Lentry)
{
r1=get_reg();
r2=get_reg();
printf("sfs\n");
fprintf(fp,"MOV R%d %d\n",r1,root->ptr1->Lentry->binding);
fprintf(fp,"MOV R%d BP\n",r2);
fprintf(fp,"ADD R%d R%d\n",r1,r2);
free_reg();
}
else if(root->ptr1->Gentry)
{ r1=get_reg();
printf("sfs2\n");
fprintf(fp,"MOV R%d %d\n",r1,root->ptr1->Gentry->binding);
}
if(root->ptr2->Lentry)
{
printf("erewr\n");
r2=get_reg();
r3=get_reg();
fprintf(fp,"MOV R%d %d\n",r2,root->ptr2->Lentry->binding);
fprintf(fp,"MOV R%d BP\n",r3);
fprintf(fp,"ADD R%d R%d\n",r2,r3);
free_reg();
if(root->ptr2->Lentry->ref=1)
{
fprintf(fp,"MOV R%d [R%d]\n",r2,r2);
}
fprintf(fp,"MOV [R%d] [R%d]\n",r1,r2);
free_reg();
free_reg();
}
else if(root->ptr2->Gentry)
{
printf("erewr2\n");
r2=get_reg();
fprintf(fp,"MOV R%d %d\n",r2,root->ptr2->Gentry->binding);
free_reg();
fprintf(fp,"MOV [R%d] [R%d]\n",r1,r2);
free_reg();
free_reg();
}
return 0;
case NODETYPE_SND:
if(root->ptr1->Lentry)
{
r1=get_reg();
r2=get_reg();
fprintf(fp,"MOV R%d %d\n",r1,root->ptr1->Lentry->binding);
fprintf(fp,"MOV R%d BP\n",r2);
fprintf(fp,"ADD R%d R%d\n",r1,r2);
free_reg();
}
else if(root->ptr1->Gentry)
{ r1=get_reg();
fprintf(fp,"MOV R%d %d\n",r1,root->ptr1->Gentry->binding);
}
if(root->ptr2->Lentry)
{
r2=get_reg();
r3=get_reg();
fprintf(fp,"MOV R%d %d\n",r2,root->ptr2->Lentry->binding);
fprintf(fp,"MOV R%d BP\n",r3);
fprintf(fp,"ADD R%d R%d\n",r2,r3);
if(root->ptr2->Lentry->ref=1)
{
fprintf(fp,"MOV R%d [R%d]\n",r2,r2);
fprintf(fp, "DCR R%d\n",r2);
}
else
fprintf(fp, "INR R%d\n",r2);
free_reg();
fprintf(fp,"MOV [R%d] [R%d]\n",r1,r2);
free_reg();
free_reg();
}
else if(root->ptr2->Gentry)
{
r2=get_reg();
fprintf(fp,"MOV R%d %d\n",r2,root->ptr2->Gentry->binding);
fprintf(fp, "INR R%d\n",r2);
free_reg();
fprintf(fp,"MOV [R%d] [R%d]\n",r1,r2);
free_reg();
free_reg();
}
return 0;
case NODETYPE_PAIR:
r1=code_gen(root->ptr2);
r2=code_gen(root->ptr3);
r3=get_reg();
if(root->ptr1->Lentry)
{
r4=get_reg();
fprintf(fp,"MOV R%d %d\n",r3,root->ptr1->Lentry->binding);
fprintf(fp,"MOV R%d BP\n",r4);
fprintf(fp,"ADD R%d R%d\n",r3,r4);
free_reg();
fprintf(fp,"MOV [R%d] R%d\n",r3,r1);
fprintf(fp,"INR R%d\n",r3);
fprintf(fp,"MOV [R%d] R%d\n",r3,r2);
free_reg();
free_reg();
free_reg();
}
else if(root->ptr1->Gentry)
{
fprintf(fp,"MOV R%d %d\n",r3,root->ptr1->Gentry->binding);
fprintf(fp,"MOV [R%d] R%d\n",r3,r1);
fprintf(fp,"INR R%d\n",r3);
fprintf(fp,"MOV [R%d] R%d\n",r3,r2);
free_reg();
free_reg();
}
return 0;
case NODETYPE_MAIN:
printf("ffefwefwef\n");
fprintf(fp,"START\n");
fprintf(fp,"MOV SP 1750\n");
fprintf(fp,"MOV BP SP\n");
r1 = get_reg();
struct Lsymbol *Ltemp = LSymbolHead;
while(Ltemp != NULL){
if(Ltemp->ref==0){
fprintf(fp,"PUSH R%d\n",r1);
Ltemp = Ltemp->next;
}
}
fprintf(fp,"MAIN:\n");
free_reg();
code_gen(root->ptr1);
fprintf(fp,"HALT\n");
return 0;
case NODETYPE_ALLOC:
if(root->ptr1->node==NODETYPE_FIELD_END) {
r1=code_gen(root->ptr1);
fprintf(fp,"PUSH R0\n");
fprintf(fp,"PUSH R0\nPUSH R1\nPUSH R2\n");
fprintf(fp,"CALL LL2\n");
fprintf(fp,"POP R2\nPOP R1\nPOP R0\n");
r2=get_reg();
fprintf(fp,"POP R%d\n",r2);
fprintf(fp,"MOV [R%d] R%d\n",r1,r2);
free_reg();
free_reg();
}
else {
r1=get_reg();
r2=get_reg();
if(root->ptr1->Lentry) {
fprintf(fp,"MOV R%d BP\n",r1);
fprintf(fp,"MOV R%d %d\n",r2,root->ptr1->Lentry->binding);
fprintf(fp,"ADD R%d R%d\n",r1,r2);
if(root->ptr1->Lentry->ref==2)
fprintf(fp,"MOV R%d [R%d]\n",r1,r1);
}
else {
fprintf(fp,"MOV R%d %d\n",r1,root->ptr1->Gentry->binding);
if(root->ptr1->ptr1) {
r2=code_gen(root->ptr1->ptr1);
fprintf(fp,"ADD R%d R%d\n",r1,r2);}
}
fprintf(fp,"PUSH R0\n");
fprintf(fp,"PUSH R0\nPUSH R1\nPUSH R2\n");
fprintf(fp,"CALL LL2\n");
fprintf(fp,"POP R2\nPOP R1\nPOP R0\n");
fprintf(fp,"POP R%d\n",r2);
fprintf(fp,"MOV [R%d] R%d\n ",r1,r2);
free_reg();
free_reg();
}
return 0;
case NODETYPE_INITIAL:
fprintf(fp,"PUSH R0\nPUSH R1\nPUSH R2\n");
fprintf(fp,"CALL LL0\n");
fprintf(fp,"POP R2\nPOP R1\nPOP R0\n");
return 0;
case NODETYPE_FREE:
if(root->ptr1->node==NODETYPE_FIELD_END) {
r1=code_gen(root->ptr1);
fprintf(fp,"PUSH R0\n");
fprintf(fp,"PUSH R1\nPUSH R2\nPUSH R3\n");
fprintf(fp,"PUSH R%d\n",r1);
fprintf(fp,"MOV R%d [R%d]\n",r1,r1);
fprintf(fp,"PUSH R%d\n",r1);
fprintf(fp,"CALL LL1\n");
fprintf(fp,"POP R%d\n",r1);
fprintf(fp,"POP R%d\n",r1);
fprintf(fp,"POP R3\nPOP R2\nPOP R1\nPOP R0\n");
free_reg();
}
else {
r1=get_reg();
r2=get_reg();
if(root->ptr1->Lentry) {
fprintf(fp,"MOV R%d BP\n",r1);
fprintf(fp,"MOV R%d %d\n",r2,root->ptr1->Lentry->binding);
fprintf(fp,"ADD R%d R%d\n",r1,r2);
if(root->ptr1->Lentry->ref==2) {
fprintf(fp,"MOV R%d [R%d]\n",r1,r1);
}
}
else {
fprintf(fp,"MOV R%d %d\n",r1,root->ptr1->Gentry->binding);
if(root->ptr1->ptr1) {
r2=code_gen(root->ptr1->ptr1);
fprintf(fp,"ADD R%d R%d\n",r1,r2);}
}
fprintf(fp,"PUSH R0\n");
fprintf(fp,"PUSH R1\nPUSH R2\nPUSH R3\n");
fprintf(fp,"PUSH R%d\n",r1);
fprintf(fp,"MOV R%d [R%d]\n",r1,r1);
fprintf(fp,"PUSH R%d\n",r1);
fprintf(fp,"CALL LL1\n");
fprintf(fp,"POP R%d\n",r1);
fprintf(fp,"POP R%d\n",r1);
fprintf(fp,"POP R3\nPOP R2\nPOP R1\nPOP R0\n");
free_reg();
free_reg();
}
return 0;
case NODETYPE_LT :
r1=code_gen(root->ptr1);
GetVal(root->ptr1,r1);
r2=code_gen(root->ptr2);
GetVal(root->ptr2,r2);
fprintf(fp,"LT R%d R%d\n",r1,r2);
free_reg();
return r1;
case NODETYPE_FUNC:
;
fprintf(fp," // Before funtion call\n\n\n");
r=functioncall_gen(root);
return r;
case NODETYPE_LEAF:
r1=get_reg();
fprintf(fp,"MOV R%d %d\n",r1,root->val);
return r1;
case NODETYPE_LE :
r1=code_gen(root->ptr1);
GetVal(root->ptr1,r1);
r2=code_gen(root->ptr2);
GetVal(root->ptr2,r2);
fprintf(fp,"LE R%d R%d\n",r1,r2);
free_reg();
return r1;
case NODETYPE_AND:
r1 = code_gen(root->ptr1);
GetVal(root->ptr1,r1);
r2 = code_gen(root->ptr2);
GetVal(root->ptr2,r2);
fprintf(fp,"ADD R%d R%d\n",r1,r2);
fprintf(fp,"MOV R%d 2\n",r2);
fprintf(fp,"EQ R%d R%d\n",r1,r2);
free_reg();
return r1;
break;
case NODETYPE_OR:
r1 = code_gen(root->ptr1);
GetVal(root->ptr1,r1);
r2 = code_gen(root->ptr2);
GetVal(root->ptr2,r2);
fprintf(fp,"ADD R%d R%d\n",r1,r2);
fprintf(fp,"MOV R%d 0\n",r2);
fprintf(fp,"GE R%d R%d\n",r1,r2);
free_reg();
return r1;
break;
case NODETYPE_GE :
r1=code_gen(root->ptr1);
GetVal(root->ptr1,r1);
r2=code_gen(root->ptr2);
GetVal(root->ptr2,r2);
fprintf(fp,"GE R%d R%d\n",r1,r2);
free_reg();
return r1;
case NODETYPE_EQ :
r1=code_gen(root->ptr1);
GetVal(root->ptr1,r1);
r2=code_gen(root->ptr2);
GetVal(root->ptr2,r2);
fprintf(fp,"EQ R%d R%d\n",r1,r2);
free_reg();
return r1;
case NODETYPE_NE :
r1=code_gen(root->ptr1);
GetVal(root->ptr1,r1);
r2=code_gen(root->ptr2);
GetVal(root->ptr2,r2);
fprintf(fp,"NE R%d R%d\n",r1,r2);
free_reg();
return r1;
case NODETYPE_GT :
r1=code_gen(root->ptr1);
GetVal(root->ptr1,r1);
r2=code_gen(root->ptr2);
GetVal(root->ptr2,r2);
fprintf(fp,"GT R%d R%d\n",r1,r2);
free_reg();
return r1;
case NODETYPE_ID:
r1=get_reg();
if(root->ptr1==NULL) {
if(root->Lentry) {
bind=root->Lentry->binding;
r2=get_reg();
fprintf(fp,"MOV R%d BP\n",r1);
fprintf(fp,"MOV R%d %d\n",r2,bind);
fprintf(fp,"ADD R%d R%d\n",r1,r2);
fprintf(fp,"MOV R%d [R%d]\n",r1,r1);
if(root->Lentry->ref==2){
fprintf(fp,"MOV R%d [R%d]\n",r1,r1);
}
free_reg();
return r1;
}
else {
bind=root->Gentry->binding;
r2=get_reg();
fprintf(fp,"MOV R%d %d\n",r2,bind);
fprintf(fp,"MOV R%d [R%d]\n",r1,r2);
free_reg();
return r1;
}
}
else {
bind=root->Gentry->binding;
r2=code_gen(root->ptr1);
fprintf(fp,"MOV R%d %d\n",r1,bind);
fprintf(fp,"ADD R%d R%d\n",r1,r2);
free_reg();
fprintf(fp,"MOV R%d [R%d]\n",r1,r1);
return r1;
}
break;
case NODETYPE_BODY:
printf("hi1\n");
code_gen(root->ptr1);
printf("hi2\n");
code_gen(root->ptr2);
printf("hi3\n");
break;
case NODETYPE_ASGN:
r2=code_gen(root->ptr2);
if(root->ptr2->node==NODETYPE_FIELD_END) {
fprintf(fp,"MOV R%d [R%d]\n",r2,r2);
}
if(root->ptr1->node!=NODETYPE_FIELD_END) {
if(root->ptr1->ptr1) {
bind=root->ptr1->Gentry->binding;
r1=code_gen(root->ptr1->ptr1);
r3=get_reg();
fprintf(fp,"MOV R%d %d\n",r3,bind);
fprintf(fp,"ADD R%d R%d\n",r1,r3);
fprintf(fp,"MOV [R%d] R%d\n ",r1,r2);
free_reg();
free_reg();
free_reg();
}else {
if(root->ptr1->Lentry) {
bind=root->ptr1->Lentry->binding;
r1=get_reg();
r3=get_reg();
fprintf(fp,"MOV R%d BP\n",r1);
fprintf(fp,"MOV R%d %d\n",r3,bind);
fprintf(fp,"ADD R%d R%d\n",r1,r3);
if(root->ptr1->Lentry->ref==2)
fprintf(fp,"MOV R%d [R%d] \n",r1,r1);
free_reg();
fprintf(fp,"MOV [R%d] R%d\n",r1,r2);
free_reg();
free_reg();
}
else {
bind=root->ptr1->Gentry->binding;
fprintf(fp,"MOV [%d] R%d\n ",bind,r2);
free_reg();
}
}
}
else {
r1=code_gen(root->ptr1);
fprintf(fp,"MOV [R%d] R%d\n ",r1,r2);
free_reg();
free_reg();
}
return 0;
break;
case NODETYPE_READ:
if(root->ptr1->node==NODETYPE_FIELD_END) {
r1=code_gen(root->ptr1);
r2=get_reg();
fprintf(fp,"IN R%d\n",r2);
fprintf(fp,"MOV [R%d] R%d\n",r1,r2);
free_reg();
free_reg();
return 0;
}
if(root->ptr1->Lentry) {
r1=get_reg();
r2=get_reg();
fprintf(fp,"MOV R%d BP\n",r1);
bind=root->ptr1->Lentry->binding;
fprintf(fp,"MOV R%d %d\n",r2,bind);
fprintf(fp,"ADD R%d R%d\n",r1,r2);
fprintf(fp,"IN R%d\n",r2);
if(root->ptr1->Lentry->ref == 2){
fprintf(fp,"MOV R%d [R%d]\n",r1,r1);
}
fprintf(fp,"MOV [R%d] R%d\n",r1,r2);
free_reg();
free_reg();
}
else {
if(root->ptr1->ptr1) {
bind=root->ptr1->Gentry->binding;
r3=get_reg();
fprintf(fp,"MOV R%d %d\n",r3,bind);
r1=code_gen(root->ptr1->ptr1);
fprintf(fp,"ADD R%d R%d\n",r3,r1);
r2=get_reg();
fprintf(fp,"IN R%d\n",r2);
fprintf(fp,"MOV [R%d] R%d\n",r3,r2);
free_reg();
free_reg();
free_reg();
}
else {
bind=root->ptr1->Gentry->binding;
r1=get_reg();
fprintf(fp,"MOV R%d %d\n",r1,bind);
r2=get_reg();
fprintf(fp,"IN R%d\n",r2);
fprintf(fp,"MOV [R%d] R%d\n",r1,r2);
free_reg();
free_reg();
}
}
return 0;
break;
case NODETYPE_WRITE:
r1=code_gen(root->ptr1);
if(root->ptr1->node==NODETYPE_FIELD_END)
fprintf(fp,"MOV R%d [R%d]\n",r1,r1);
fprintf(fp,"OUT R%d\n",r1);
free_reg();
return 0;
case NODETYPE_RET_PAIR:
printf("//oooopp\n");
r1=get_reg();
printf("hello\n");
bind=root->ptr1->Lentry->binding;
printf(fp,"//hell00o\n");
r2=get_reg();
r3=get_reg();
fprintf(fp,"MOV R%d BP\n",r2);
fprintf(fp,"MOV R%d %d\n",r1,bind);
fprintf(fp,"ADD R%d R%d\n",r1,r2);
fprintf(fp,"MOV R%d %d\n",r3,2);
fprintf(fp,"SUB R%d R%d\n",r2,r3);
fprintf(fp,"MOV [R%d] R%d\n",r2,r1);
free_reg();
free_reg();
free_reg();
printf("hello1\n");
break;
case NODETYPE_RET:
r=code_gen(root->ptr1);
if(root->ptr1->node==NODETYPE_FIELD_END)
fprintf(fp,"MOV R%d [R%d]\n",r,r);
r1=get_reg();
fprintf(fp,"MOV R%d BP\n",r1);
r2=get_reg();
fprintf(fp,"MOV R%d 2\n",r2);
fprintf(fp,"SUB R%d R%d\n",r1,r2);
free_reg();
fprintf(fp,"MOV [R%d] R%d\n",r1,r);
free_reg();
free_reg();
break;
case NODETYPE_WHILE :
l1=get_label();
l2=get_label();
fprintf(fp,"\n//while\n");
fprintf(fp,"label%d:\n",l1);
r1=code_gen(root->ptr1);
fprintf(fp,"JZ R%d,label%d\n",r1,l2);
free_reg();
code_gen(root->ptr2);
fprintf(fp,"JMP label%d\n",l1);
fprintf(fp,"\n\n");
fprintf(fp,"label%d:\n",l2);
break;
case NODETYPE_IF :
fprintf(fp,"\n\n//if\n");
l1=get_label();
r1=code_gen(root->ptr1);
fprintf(fp,"JZ R%d label%d\n",r1,l1);
free_reg();
code_gen(root->ptr2);
fprintf(fp,"label%d:\n",l1);
break;
case NODETYPE_IFELSE :
fprintf(fp, "\n\n //ifelse\n\n");
l1=get_label();
l2=get_label();
r1=code_gen(root->ptr1);
fprintf(fp,"JZ R%d label%d\n",r1,l1);
free_reg();
code_gen(root->ptr2);
fprintf(fp,"JMP label%d\n",l2);
fprintf(fp,"label%d:\n",l1);
code_gen(root->ptr3);
fprintf(fp,"label%d:\n",l2);
break;
case NODETYPE_SLIST :
code_gen(root->ptr1);
code_gen(root->ptr2);
break;
}
}
int functioncall_gen(struct ASTNode *root) {
int r,r1,r2,r3,r4,c=0;
struct Gsymbol *g=GLookup(root->name);
struct ArgStruct *list=g->arglist;
struct ASTNode *templist=root->arglist;
//Saving the values in the registers;
while(c<=reg) {
fprintf(fp,"PUSH R%d\n",c);
c++;
}
c--;
while(templist) {
if(list->passType==1) {
r=code_gen(templist->ptr2);
if(templist->ptr2->node==NODETYPE_FIELD_END)
fprintf(fp,"MOV R%d [R%d]\n",r,r);
fprintf(fp,"PUSH R%d\n",r);
free_reg();
}
else {
if(templist->ptr2->node==NODETYPE_FIELD_END) {
r=code_gen(templist->ptr2);
fprintf(fp,"PUSH R%d\n",r);
free_reg();
}
else if(templist->ptr2->Lentry) {
if(strcmp(templist->ptr2->type->name,"pair")==0)
{
r1=get_reg();
r2=get_reg();
fprintf(fp,"MOV R%d BP\n",r1);
fprintf(fp,"MOV R%d %d\n",r2,templist->ptr2->Lentry->binding);
fprintf(fp,"ADD R%d R%d\n",r1,r2);
fprintf(fp,"PUSH R%d\n",r1);
}
else
{
r1=get_reg();
r2=get_reg();
fprintf(fp,"MOV R%d BP\n",r1);
fprintf(fp,"MOV R%d %d\n",r2,templist->ptr2->Lentry->binding);
fprintf(fp,"ADD R%d R%d\n",r1,r2);
free_reg();
if(templist->ptr2->Lentry->ref==2) {
fprintf(fp,"MOV R%d [R%d]\n",r1,r1);
}
fprintf(fp,"PUSH R%d\n",r1);
free_reg();
}
}
else {
r=get_reg();
fprintf(fp,"MOV R%d %d\n",r,templist->ptr2->Gentry->binding);
if(templist->ptr2->ptr1) {
r2=code_gen(templist->ptr2->ptr1);
fprintf(fp,"ADD R%d R%d\n",r,r2);
free_reg();
}
fprintf(fp,"PUSH R%d\n",r);
free_reg();
}
}
templist=templist->ptr1;
list=list->next;
}
r=get_reg();
fprintf(fp,"PUSH R%d\n",r);
free_reg();
fprintf(fp,"CALL LL%d\n",g->binding);
reg=c;
r=get_reg();
fprintf(fp,"POP R%d\n",r);
r1=get_reg();
list=g->arglist;
while(list) {
fprintf(fp,"POP R%d\n",r1);
list=list->next;
}
free_reg();
while(c>=0) {
fprintf(fp,"POP R%d\n",c);
c--;
}
return r;
}
