struct genhashtable * builddominatormappings(struct heap_state *heap, int includecurrent) {
struct genhashtable * mindominator=genallocatehashtable(NULL,NULL);
struct method *m=heap->methodlist;
if ((includecurrent==0)&&(m!=NULL)) {
struct localvars *lv=m->lv;
while(lv!=NULL) {
int * i=(int *)malloc(sizeof(int));
*i=0;
genputtable(mindominator, lv, i);
lv=lv->next;
}
m=m->caller;
}
while(m!=NULL) {
struct localvars *lv=m->lv;
while(lv!=NULL) {
genputtable(mindominator, lv,minimaldominatorset(lv,NULL, heap, includecurrent));
lv=lv->next;
}
m=m->caller;
}
{
struct globallist *globals=heap->gl;
while(globals!=NULL) {
genputtable(mindominator, globals,minimaldominatorset(NULL,globals,heap,includecurrent));
globals=globals->next;
}
}
return mindominator;
}
int printtype(collection_type *collection_ptr,struct genhashtable *ght)
{
int j=0;
int offset=0;
int value=0;
struct valuepair *vp=NULL;
if (gencontains(ght,collection_ptr->name))
vp=(struct valuepair *)gengettable(ght,collection_ptr->name);
if (vp!=NULL)
collection_ptr=(collection_type*) dwarf_entry_array[vp->index].entry_ptr;
for(j=0;j<collection_ptr->num_members;j++) {
dwarf_entry *entry=collection_ptr->members[j];
if (entry->tag_name==DW_TAG_inheritance) {
inherit * inherit_ptr=(inherit *)entry->entry_ptr;
if (inherit_ptr->data_member_location>offset) {
printf(" reserved byte[%ld];\n",inherit_ptr->data_member_location-offset);
offset=inherit_ptr->data_member_location;
}
{
dwarf_entry *type=inherit_ptr->target_ptr;
collection_type *c_ptr=(collection_type*)type->entry_ptr;
offset+=printtype(c_ptr,ght);
}
} else {
member * member_ptr=(member *)entry->entry_ptr;
char *name=member_ptr->name;
char *newname=NULL;
dwarf_entry *type=member_ptr->type_ptr;
char *typestr=printname(type,GETTYPE);
char *poststr=printname(type,POSTNAME);
if (member_ptr->data_member_location>offset) {
printf(" reserved byte[%ld];\n",member_ptr->data_member_location-offset);
offset=member_ptr->data_member_location;
}
offset+=getsize(type);
newname=escapestr(name);
{
char buf[512];
char *dtype;
sprintf(buf, "%s.%s\0", collection_ptr->name,newname);
if (arrayt!=NULL&&gencontains(arrayt, &buf)) {
genputtable(arraytype, buf, typestr);
dtype=deref(typestr);
printf(" %s_array * %s%s;\n",dtype,newname,poststr);
free(dtype);
} else
printf(" %s %s%s;\n",typestr,newname,poststr);
}
free(newname);
}
}
return offset;
}
struct rolemethod * methodaddtable(struct heap_state * heap , struct rolemethod *method) {
if (gencontains(heap->methodtable, method)) {
struct rolemethod * retval=gengettable(heap->methodtable, method);
methodfree(method);
return retval;
} else {
genputtable(heap->methodtable, method,method);
return method;
}
}
// If the first basic block of a function ends before entryPC, use
// the last instruction of that basic block as our entrypoint. Otherwise
// use entryPC
static void find_entry_pt(IRSB* bb_orig, FunctionEntry *f) {
int i;
Addr entry_pt = 0;
if(gencontains(funcs_handled, f))
return;
if (dyncomp_delayed_trace) {
dyncomp_print_trace_info = True;
dyncomp_delayed_trace = False;
}
if (dyncomp_delayed_print_IR) {
fjalar_print_IR = True;
dyncomp_delayed_print_IR = False;
}
FJALAR_DPRINTF("[find_entry_pt] Searching %s for entry address %x\n", f->fjalar_name, (UInt)f->entryPC);
for(i=0 ; i < bb_orig->stmts_used; i++) {
IRStmt *st = bb_orig->stmts[i];
if(st->tag == Ist_IMark) {
FJALAR_DPRINTF("\tEncountered IMark for address %x\n", (UInt)st->Ist.IMark.addr);
if(st->Ist.IMark.addr <= f->entryPC) {
entry_pt = st->Ist.IMark.addr;
}
}
}
tl_assert( entry_pt );
FJALAR_DPRINTF("\t%x chosen for entry\n", (UInt)entry_pt);
genputtable(funcs_handled, (void *)f, (void *)1);
genputtable(FunctionTable_by_endOfBb,
(void *)entry_pt,
(void *)f);
}
void mergerolechanges(struct heap_state *heap) {
struct geniterator *it=gengetiterator(heap->methodlist->rolechangetable);
while(1) {
struct rolechange *rc=(struct rolechange *)gennext(it);
struct method *method=heap->methodlist;
int inner=2;
if (rc==NULL)
break;
while(method!=NULL) {
struct rolemethod *rm=method->rm;
struct genhashtable * rolechanges=rm->rolechanges;
struct rolechangesum *rcs=(struct rolechangesum *)calloc(1,sizeof(struct rolechangesum));
struct rolechangeheader *rch;
struct effectregexpr *ere=NULL;
struct rolechangepath *rcp;
if (!(heap->options&OPTION_NORCEXPR))
ere=buildregexpr(method->pathtable, rc->uid);
rcs->origrole=copystr(rc->origrole);
rcs->newrole=copystr(rc->newrole);
if (!gencontains(rolechanges, rcs)) {
rch=(struct rolechangeheader *)calloc(1,sizeof(struct rolechangeheader));
if (inner)
rch->inner=1;
genputtable(rolechanges,rcs,rch);
} else {
rch=(struct rolechangeheader *) gengettable(rolechanges,rcs);
if (inner)
rch->inner=1;
free(rcs->origrole);
free(rcs->newrole);
free(rcs);
}
/* rch points to appropriate rolechangeheader */
/* ere points to our regular expression */
rcp=rch->rcp;
if (!(heap->options&OPTION_NORCEXPR)) {
while(rcp!=NULL) {
struct effectregexpr *ere2=rcp->expr;
struct effectregexpr *erem=mergeeffectregexpr(ere,ere2);
if (erem!=NULL) {
rcp->expr=erem;
if ((rcp->inner||inner)&&((inner==0)||(rcp->inner==0))) {
rcp->inner=1;
}
/*Update count */
if ((rcp->exact+1)==rm->numberofcalls)
rcp->exact=rm->numberofcalls;
if (rcp->exact<rm->numberofcalls)
rcp->exact=0;
freeeffectregexpr(ere2);
freeeffectregexpr(ere);
break;
}
rcp=rcp->next;
}
if(rcp==NULL) {
/* Couldn't merge in */
struct rolechangepath *rcp2=(struct rolechangepath *)calloc(1, sizeof(struct rolechangepath));
rcp2->expr=ere;
if(rm->numberofcalls==1)
rcp2->exact=1;
rcp2->next=rch->rcp;
rcp2->inner=inner;
rch->rcp=rcp2;
}
}
method=method->caller;
inner=0;
}
free(rc->origrole);
free(rc->newrole);
free(rc);
}
genfreeiterator(it);
genfreehashtable(heap->methodlist->rolechangetable);
heap->methodlist->rolechangetable=NULL;
}
void initializeTypeArray()
{
int i;
dwarf_entry * cur_entry;
struct genhashtable * ght=genallocatehashtable((unsigned int (*)(void *)) & hashstring,(int (*)(void *,void *)) &equivalentstrings);
struct genhashtable * sht=NULL;
if (rootfile!=NULL) {
char buf[512];
char a;
int fd=open(rootfile,O_RDONLY);
int offset=0;
sht=genallocatehashtable((unsigned int (*)(void *)) & hashstring,(int (*)(void *,void *)) &equivalentstrings);
while(1) {
if (read(fd,&a,1)>0) {
if (a!=13&&a!=10)
buf[offset++]=a;
} else
break;
if (offset>0&&(a==13||a==10)) {
buf[offset++]=0;
{
char *str=copystr(buf);
genputtable(sht,str,str);
}
offset=0;
}
}
}
if (arrayfile!=NULL) {
char buf[512];
char sizebuf[512];
char a;
int fd=open(arrayfile,O_RDONLY);
int offset=0;
int readmore=1;
int state=0;
arrayt=genallocatehashtable((unsigned int (*)(void *)) & hashstring,(int (*)(void *,void *)) &equivalentstrings);
arraytype=genallocatehashtable((unsigned int (*)(void *)) & hashstring,(int (*)(void *,void *)) &equivalentstrings);
while(readmore) {
if (read(fd,&a,1)<=0)
readmore=0;
if (readmore) {
if (a==' ') {
state=1;
buf[offset]=0;
offset=0;
} else if (a!=13&&a!=10) {
if (state==0)
buf[offset++]=a;
else
sizebuf[offset++]=a;
}
}
if ((state==1)&&offset>0&&(a==13||a==10||!readmore)) {
state=0;
sizebuf[offset]=0;
{
char *str=copystr(buf);
char *sizestr=copystr(sizebuf);
genputtable(arrayt,str,sizestr);
}
offset=0;
}
}
}
/* Assign names */
for (i = 0; i < dwarf_entry_array_size; i++)
{
cur_entry = &dwarf_entry_array[i];
if (entry_is_type(cur_entry))
{
collection_type* collection_ptr = (collection_type*)(cur_entry->entry_ptr);
int j=0;
int offset=0;
int value=0;
for(j=0;j<collection_ptr->num_members;j++) {
dwarf_entry *entry=collection_ptr->members[j];
if (entry->tag_name==DW_TAG_inheritance) {
value++;
} else {
member * member_ptr=(member *)entry->entry_ptr;
char *name=member_ptr->name;
dwarf_entry *type=member_ptr->type_ptr;
char *typestr=printname(type,GETTYPE);
char *poststr=printname(type,POSTNAME);
if (typestr!=NULL)
value++;
}
}
}
}
for (i = 0; i < dwarf_entry_array_size; i++)
{
cur_entry = &dwarf_entry_array[i];
if (entry_is_type(cur_entry))
{
collection_type* collection_ptr = (collection_type*)(cur_entry->entry_ptr);
int j=0;
int offset=0;
int value=0;
for(j=0;j<collection_ptr->num_members;j++) {
dwarf_entry *entry=collection_ptr->members[j];
if (entry->tag_name==DW_TAG_inheritance) {
value++;
} else {
member * member_ptr=(member *)entry->entry_ptr;
char *name=member_ptr->name;
dwarf_entry *type=member_ptr->type_ptr;
char *typestr=printname(type,GETTYPE);
char *poststr=printname(type,POSTNAME);
if (typestr!=NULL)
value++;
}
}
if (collection_ptr->name!=NULL) {
struct valuepair *vp=NULL;
if (gencontains(ght,collection_ptr->name))
vp=(struct valuepair *)gengettable(ght,collection_ptr->name);
if (vp==NULL||vp->value<value) {
if (vp==NULL) {
vp=(struct valuepair*)calloc(1,sizeof(struct valuepair));
genputtable(ght,collection_ptr->name,vp);
}
vp->value=value;
vp->index=i;
}
}
}
}
assigntype=1;
if (sht!=NULL) {
int repeat=1;
while(repeat) {
repeat=0;
for (i = 0; i < dwarf_entry_array_size; i++) {
cur_entry = &dwarf_entry_array[i];
if (entry_is_type(cur_entry)) {
collection_type* collection_ptr = (collection_type*)(cur_entry->entry_ptr);
int j=0;
int offset=0;
int value=0;
if (!gencontains(sht,collection_ptr->name))
continue;
if (gencontains(ght,collection_ptr->name)) {
struct valuepair *vp=(struct valuepair*)gengettable(ght,collection_ptr->name);
if (vp->index!=i)
continue;
}
for(j=0;j<collection_ptr->num_members;j++) {
dwarf_entry *entry=collection_ptr->members[j];
if (entry->tag_name==DW_TAG_inheritance) {
inherit *in_ptr=(inherit*)collection_ptr->members[j]->entry_ptr;
dwarf_entry *typeptr=in_ptr->target_ptr;
collection_type* sub_ptr = (collection_type*)(typeptr->entry_ptr);
if (!gencontains(sht,sub_ptr->name)) {
repeat=1;
genputtable(sht,sub_ptr->name,sub_ptr->name);
}
} else {
member * member_ptr=(member *)entry->entry_ptr;
char *name=member_ptr->name;
dwarf_entry *type=member_ptr->type_ptr;
char *typestr=printname(type,GETJUSTTYPE);
if (typestr!=NULL&&!gencontains(sht,typestr)) {
repeat=1;
genputtable(sht,typestr,typestr);
}
}
}
}
}
}
}
for (i = 0; i < dwarf_entry_array_size; i++)
{
cur_entry = &dwarf_entry_array[i];
if (entry_is_type(cur_entry))
{
collection_type* collection_ptr = (collection_type*)(cur_entry->entry_ptr);
int j=0;
int offset=0;
if (collection_ptr->name==NULL)
continue;
if (sht!=NULL&&!gencontains(sht,collection_ptr->name))
continue;
if (gencontains(ght,collection_ptr->name)) {
struct valuepair *vp=(struct valuepair*)gengettable(ght,collection_ptr->name);
if (vp->index!=i)
continue;
}
j=0;
printf("structure %s ",collection_ptr->name);
while(j<collection_ptr->num_members&&
collection_ptr->members[j]->tag_name==DW_TAG_inheritance) {
inherit *in_ptr=(inherit*)collection_ptr->members[j]->entry_ptr;
dwarf_entry *typeptr=in_ptr->target_ptr;
collection_type* sub_ptr = (collection_type*)(typeptr->entry_ptr);
if (j==0)
printf("subclass of ");
else
printf(", ");
printf("%s ",sub_ptr->name);
j++;
}
printf("{ \n");
for(j=0;j<collection_ptr->num_members;j++) {
dwarf_entry *entry=collection_ptr->members[j];
if (entry->tag_name==DW_TAG_inheritance) {
inherit * inherit_ptr=(inherit *)entry->entry_ptr;
if (inherit_ptr->data_member_location>offset) {
printf(" reserved byte[%ld];\n",inherit_ptr->data_member_location-offset);
offset=inherit_ptr->data_member_location;
}
{
dwarf_entry *type=inherit_ptr->target_ptr;
collection_type *c_ptr=(collection_type*)type->entry_ptr;
offset+=printtype(c_ptr,ght);
}
} else {
member * member_ptr=(member *)entry->entry_ptr;
char *name=member_ptr->name;
dwarf_entry *type=member_ptr->type_ptr;
char *typestr=printname(type,GETTYPE);
char *poststr=printname(type,POSTNAME);
char *newname=NULL;
if (member_ptr->data_member_location>offset) {
printf(" reserved byte[%ld];\n",member_ptr->data_member_location-offset);
offset=member_ptr->data_member_location;
}
offset+=getsize(type);
newname=escapestr(name);
{
char buf[512];
char *dtype;
sprintf(buf, "%s.%s\0", collection_ptr->name,newname);
if (arrayt!=NULL&&gencontains(arrayt, &buf)) {
genputtable(arraytype, copystr(buf), typestr);
dtype=deref(typestr);
printf(" %s_array * %s%s;\n",dtype,newname,poststr);
free(dtype);
} else
printf(" %s %s%s;\n",typestr,newname,poststr);
}
free(newname);
}
}
if (offset<collection_ptr->byte_size)
printf(" reserved byte[%ld];\n",collection_ptr->byte_size-offset);
printf("}\n\n");
}
}
if (arrayt!=NULL) {
struct geniterator * gi=gengetiterator(arrayt);
while(1) {
char * str=(char *)gennext(gi);
char *size=NULL;
char *typestr=NULL;
if (str==NULL)
break;
size=(char *)gengettable(arrayt,str);
typestr=deref((char *)gengettable(arraytype,str));
printf("structure %s_array {\n",typestr);
printf(" %s elem[%s];\n",typestr,size);
printf("}\n");
free(typestr);
}
genfreeiterator(gi);
}
}
void fastscan() {
struct methodchain *methodstack=NULL;
struct namer *namer=allocatenamer();
struct genhashtable *calltable=genallocatehashtable((int (*)(void *)) &hashmethod, (int (*)(void *,void *)) &comparemethod);
struct genhashtable *statictable=genallocatehashtable((int (*)(void *)) &hashmethod, (int (*)(void *,void *)) &comparemethod);
while(1) {
char *line=getline();
#ifdef DEBUG
printf("------------------------------------------------------\n");
#endif
if (line==0) {
outputinfo(namer, calltable,statictable);
return;
}
#ifdef DEBUG
printf("[%s]\n",line);
#endif
switch(line[0]) {
case 'C':
break;
case 'O':
break;
case 'N':
{
/* Natively created object...may not have pointer to it*/
char buf[1000];
sscanf(line,"NI: %s",buf);
getclass(namer,buf);
}
break;
case 'U':
{
/* New object*/
char buf[1000];
sscanf(line,"UI: %s",buf);
getclass(namer,buf);
}
break;
case 'K':
break;
case 'L':
/* Do Load */
{
struct localvars * lv=(struct localvars *) calloc(1, sizeof(struct localvars));
long long uid, objuid;
char fieldname[600], classname[600], fielddesc[600];
sscanf(line,"LF: %s %ld %s %lld %s %s %s %lld",lv->name,&lv->linenumber, lv->sourcename, &objuid, classname, fieldname, fielddesc, &uid);
getfield(namer,classname, fieldname,fielddesc);
}
break;
case 'G':
/* Do Array Load */
break;
case 'M':
/* Mark Local*/
break;
case 'I':
/* Enter Method*/
{
struct methodchain* methodchain=(struct methodchain *) calloc(1,sizeof(struct methodchain));
char classname[600], methodname[600],signature[600];
int isStatic;
sscanf(line,"IM: %s %s %s %d", classname, methodname, signature, &isStatic);
methodchain->method=getmethod(namer, classname, methodname, signature);
methodchain->caller=methodstack;
if (!gencontains(statictable, methodchain->method)) {
int * staticflag=(int *)malloc(sizeof (int));
*staticflag=isStatic;
genputtable(statictable, methodchain->method, staticflag);
}
if (methodstack!=NULL) {
if (!gencontains(calltable, methodchain->method)) {
struct methodchain *mc=(struct methodchain *) calloc(1,sizeof(struct methodchain));
mc->method=methodstack->method;
genputtable(calltable, methodchain->method, mc);
} else {
struct methodchain *tosearch=(struct methodchain *)gengettable(calltable, methodchain->method);
while(tosearch->method!=methodstack->method) {
if (tosearch->caller==NULL) {
struct methodchain *mc=(struct methodchain *) calloc(1,sizeof(struct methodchain));
mc->method=methodstack->method;
tosearch->caller=mc;
break;
}
tosearch=tosearch->caller;
}
}
}
methodstack=methodchain;
}
break;
case 'R':
/* Return from method */
{
struct methodchain* caller=methodstack->caller;
free(methodstack);
methodstack=caller;
}
break;
case 'F':
/* Field Assignment */
{
long long suid;
long long duid;
char classname[1000];
char fieldname[1000];
char descname[1000];
sscanf(line,"FA: %lld %s %s %s %lld", &suid, classname, fieldname, descname, &duid);
getfield(namer, classname, fieldname, descname);
}
break;
case 'A':
/* Array Assignment */
{
long long suid;
long long duid;
long index;
sscanf(line,"AA: %lld %ld %lld", &suid, &index, &duid);
}
break;
}
free(line);
}
}
