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;
}
