T Set_union (T set1, T set2) { T newSet; List_t p; Assert_ASSERT(set1); Assert_ASSERT(set2); newSet = Set_new (set1->equals); p = List_getFirst (set1->list); while (p){ Set_insert (newSet, p->data); p = p->next; } p = List_getFirst (set2->list); while (p){ Poly_t v = (Poly_t)p->data; if (!List_exists (set1->list, v, set1->equals)) Set_insert (newSet, v); else; p = p->next; } return newSet; }
void dumpJstring(O obj) { Assert_ASSERT(obj); Assert_ASSERT(value_offset); O c = OBJECT_DATA(obj, value_offset - 1, O); dumpChar(c); }
T HashSet_intersection (T set1, T set2) { T newSet; List_t p; Assert_ASSERT(set1); Assert_ASSERT(set2); Error_impossible (); return 0; }
T HashSet_union (T set1, T set2) { T newSet; List_t p; Assert_ASSERT(set1); Assert_ASSERT(set2); Error_impossible (); return newSet; }
void HashSet_unionVoid (T set1, T set2) { List_t p; Assert_ASSERT(set1); Assert_ASSERT(set2); gset = set1; Hash_foreach (set2->hash, localForeach); set1 = gset; gset = 0; return; }
int Jstring_equals(O s1, O s2) { Assert_ASSERT(s1 && s1->type == OBJECT_STRING); Assert_ASSERT(s2 && s2->type == OBJECT_STRING); char *c1 = Jstring2Char(s1); char *c2 = Jstring2Char(s2); if (0 == strcmp(c1, c2)) return 1; else return 0; }
void HashSet_unionVoidSet (T set1, Set_t set2) { List_t p; Assert_ASSERT(set1); Assert_ASSERT(set2); p = List_getFirst (Set_toList (set2)); while (p){ HashSet_insert (set1, p->data); p = p->next; } return; }
/** * print char[]. * @parm obj an Object_t, and type must be array. */ void dumpChar(O obj) { Assert_ASSERT(obj); Assert_ASSERT(obj->type == OBJECT_ARRAY); short *p = (short *) obj->data; int i; for (i = 0; i < obj->length; i++) { char c = (char) (*p); printf("%c", c); p++; } printf("\n"); }
void Set_foreach (T set, Poly_tyVoid f) { Assert_ASSERT(set); List_foreach (set->list, f); return; }
int HashSet_size (T set) { Assert_ASSERT(set); Error_impossible (); return 0; }
////////////////////////////////////////////////////// // functions static Ssa_Fun_t transFunEach (Ssa_Fun_t f) { Ssa_Block_t eb; // entry block List_t newBlocks; Graph_t g; Assert_ASSERT(f); // make a flow graph g = Ssa_Fun_toGraph (f); // dfs it eb = Ssa_Fun_searchLabel (f, f->entry); if (!eb) Error_impossible (); Graph_dfs (g, eb, (Poly_tyVoid)visitBlock); // now the properties should be properly set newBlocks = transBlocks (f->blocks); return Ssa_Fun_new (f->type , f->name , f->args , f->decs , newBlocks , f->retId , f->entry , f->exitt); }
int HashSet_isEmpty (T set) { Assert_ASSERT(set); Error_impossible (); return 1; }
void HashSet_foreach (T set, Poly_tyVoid f) { Assert_ASSERT(set); Error_impossible (); return; }
void X86_Operand_print (O o) { Assert_ASSERT(o); switch (o->kind){ case X86_OP_INT: print ("$"); print (Int_toString (o->u.intlit)); return; case X86_OP_GLOBAL: print ("$"); print (Id_toString (o->u.global)); return; case X86_OP_INSTACK: print (Int_toString (o->u.index)); print ("(%ebp)"); return; case X86_OP_REG: X86_Register_print (o->u.reg); return; case X86_OP_MEM: print (Int_toString (4*(o->u.mem.offset))); print ("("); X86_Register_print (o->u.mem.base); print (")"); return; default: Error_impossible(); return; } Error_impossible(); return; }
void X86_Struct_print (Stt x) { Assert_ASSERT(x); print (Id_toString (x->type)); print (" "); print (Id_toString (x->var)); print (";\n"); }
// Remove one element from a set. Poly_t HashSet_removeOne (T set) { Assert_ASSERT(set); Error_impossible (); return 0; }
void Set_delete (T set, Poly_t x) { List_t p; Assert_ASSERT(set); List_delete (set->list, x, set->equals); return; }
static void visitBlock (Ssa_Block_t b) { Assert_ASSERT(b); Property_set (visited , b , (Poly_t)1); return; }
// Remove one element from a set. Poly_t Set_removeOne (T set) { Assert_ASSERT(set); if (Set_isEmpty (set)) Error_impossible (); return List_removeHead (set->list); }
static void X86_Dec_print (Stt x) { Assert_ASSERT(x); print ("\t"); print (Id_toString (x->type)); print (" "); print (Id_toString (x->var)); print (";\n"); }
// delete all items x for pred(x) is true void Set_deleteAll (T set, Poly_tyPred pred) { List_t p; Assert_ASSERT(set); List_deleteAll (set->list, pred); return; }
void Set_unionVoid (T set1, T set2) { List_t p; Assert_ASSERT(set1); Assert_ASSERT(set2); p = List_getFirst (set2->list); while (p){ Poly_t v = (Poly_t)p->data; // this may be further enhanced if (!List_exists (set1->list, v, set1->equals)) Set_insert (set1, v); else; p = p->next; } return; }
File_t X86_Prog_print (File_t file, P p) { Assert_ASSERT(file); Assert_ASSERT(p); file_init (file); buffer_init (); printStrs (p->strings); fprintf (file, "%s", "\n"); printMask (file, p->masks); fprintf (file, "%s", "\n"); List_foldl (p->funcs , file , (Poly_tyFold)X86_Fun_print); buffer_final (); return file; }
int Set_exists (T set, Poly_t x) { List_t p; Assert_ASSERT(set); p = List_getFirst (set->list); while (p){ if (set->equals (x, p->data)) return 1; p = p->next; } return 0; }
int Set_equals (T set1, T set2) { T newSet; List_t p; Assert_ASSERT(set1); Assert_ASSERT(set1); if (List_size (set1->list) != List_size (set2->list)) return 0; p = List_getFirst (set1->list); while (p){ Poly_t v = (Poly_t)p->data; if (List_exists (set2->list, v, set1->equals)) ; else return 0; p = p->next; } return 1; }
static List_t transBlocks (List_t blocks) { List_t tmp, result = List_new (); Assert_ASSERT(blocks); tmp = List_getFirst (blocks); while (tmp){ Ssa_Block_t b = (Ssa_Block_t)tmp->data; if (Property_get (visited, b)) List_insertLast (result, b); tmp = tmp->next; } return result; }
////////////////////////////////////////////////////// // programs static Ssa_Prog_t Ssa_deadBlockTraced (Ssa_Prog_t p) { List_t newFuncs; Assert_ASSERT(p); // init the property visited = Property_new ((Poly_tyPlist)Ssa_Block_plist); newFuncs = List_map (p->funcs, (Poly_tyId)transFunEach); // clear property Property_clear (visited); return Ssa_Prog_new (p->classes, newFuncs); }
File_t X86_Mask_print (File_t file, M m) { List_t p; Assert_ASSERT(m); fprintf (file, "%s", Id_toString (m->name)); fprintf (file, ":\n\t.int "); fprintf (file, "%s", Int_toString (m->size)); if (List_isEmpty (m->index)){ fprintf (file, "\n"); return file; } fprintf (file, ", "); p = List_getFirst (m->index); while (p){ fprintf (file, "%s", Int_toString ((int)p->data)); if (p->next) fprintf (file, ", "); p = p->next; } fprintf (file, "\n"); return file; }
void X86_Fun_print (F f) { Assert_ASSERT(f); print ("\t.text\n"); print ("\t.globl _"); print (Id_toString (f->name)); print ("\n_"); print (Id_toString (f->name)); print (":\n"); print ("\tpushl %ebp\n"); print ("\tmovl %esp, %ebp\n"); { int i = List_size (f->decs); if (i){ print ("\tsubl $"); print (Int_toString (4*i)); print (", %esp\n"); } } List_foreach (f->stms, (Poly_tyVoid)X86_Stm_print); print ("\n\n"); return; }
void X86_Stm_print (S s) { Assert_ASSERT(s); switch (s->kind){ case X86_STM_MOVERR: space4 (); print ("movl "); X86_Register_print (s->u.moverr.src); print (", "); X86_Register_print (s->u.moverr.dest); break; case X86_STM_MOVERI: space4 (); print ("movl $"); print (Int_toString (s->u.moveri.src)); print (", "); X86_Register_print (s->u.moveri.dest); break; case X86_STM_LOAD: space4 (); print ("movl "); X86_Operand_print (s->u.load.src); print (", "); X86_Register_print (s->u.load.dest); break; case X86_STM_STORE: space4 (); print ("movl "); X86_Register_print (s->u.store.src); print (", "); X86_Operand_print (s->u.store.dest); break; case X86_STM_BOP: space4 (); X86_Operator_print (s->u.bop.op); X86_Register_print (s->u.bop.src); print (", "); X86_Register_print (s->u.bop.dest); break; case X86_STM_UOP: space4 (); X86_Operator_print (s->u.uop.op); X86_Register_print (s->u.uop.dest); break; case X86_STM_CALL: space4 (); print ("call "); print (Id_toString (s->u.call.name)); break; case X86_STM_CMP: space4 (); print ("cmpl "); X86_Register_print (s->u.cmp.src); print (", "); X86_Register_print (s->u.cmp.dest); break; case X86_STM_LABEL: space2(); print (Label_toString (s->u.label)); print (":"); break; case X86_STM_JE: space4 (); print ("je "); print (Label_toString (s->u.je)); break; case X86_STM_JL: space4 (); print ("jl "); print (Label_toString (s->u.je)); break; case X86_STM_JUMP: space4 (); print ("jmp "); print (Label_toString (s->u.jump)); break; case X86_STM_PUSH: space4 (); print ("pushl "); X86_Register_print (s->u.push); break; case X86_STM_NEG: space4 (); print ("negl "); X86_Register_print (s->u.neg); break; case X86_STM_SETL: space4 (); print ("setl "); X86_Register_print (s->u.setAny); break; case X86_STM_SETLE: space4 (); print ("setle "); X86_Register_print (s->u.setAny); break; case X86_STM_SETG: space4 (); print ("setg "); X86_Register_print (s->u.setAny); break; case X86_STM_SETGE: space4 (); print ("setge "); X86_Register_print (s->u.setAny); break; case X86_STM_SETE: space4 (); print ("sete "); X86_Register_print (s->u.setAny); break; case X86_STM_SETNE: space4 (); print ("setne "); X86_Register_print (s->u.setAny); break; case X86_STM_XOR: space4 (); print ("xorl "); X86_Register_print (s->u.xor.src); print (", "); X86_Register_print (s->u.xor.dest); break; case X86_STM_EXTENDAL: space4 (); print ("cbtw\n"); space4 (); print ("cwtl"); break; case X86_STM_NOT:{ space4 (); print ("notl "); X86_Register_print (s->u.not); break; } case X86_STM_RETURN: space4 (); print ("leave\n\tret"); break; case X86_STM_CLTD: space4 (); print ("cltd"); break; case X86_STM_INC: space4 (); print ("incl "); X86_Register_print (s->u.inc); break; default: Error_impossible(); break; } print ("\n"); return; }