2 This file is part of Kvasir, a Valgrind skin that implements the
3 C language front-end for the Daikon Invariant Detection System
5 Copyright (C) 2004 Philip Guo, MIT CSAIL Program Analysis Group
7 This program is free software; you can redistribute it and/or
8 modify it under the terms of the GNU General Public License as
9 published by the Free Software Foundation; either version 2 of the
10 License, or (at your option) any later version.
18 #include "dumpstructures.h"
20 #include "elf/dwarf2.h"
26 int process_elf_binary_data(char* filename);
28 int main(int argc, char **argv) {
31 process_elf_binary_data(argv[1]);
32 daikon_preprocess_entry_array();
35 // Pre-processes global dwarf_entry_array in order to place
36 // the data in a form that can easily be turned into .decls
38 void daikon_preprocess_entry_array()
40 initializeTypeArray();
45 int entry_is_type(dwarf_entry *entry) {
46 if (entry->tag_name==DW_TAG_structure_type||
47 entry->tag_name==DW_TAG_union_type) {
48 collection_type* collection_ptr = (collection_type*)(entry->entry_ptr);
49 /* if (collection_ptr->name==0&&assigntype) {
50 collection_ptr->name=(char*)malloc(100);
51 sprintf(collection_ptr->name,"TYPE%ld",typecount++);
58 int entry_is_valid_function(dwarf_entry *entry) {
59 if (tag_is_function(entry->tag_name)) {
60 function* funcPtr = (function*)(entry->entry_ptr);
61 if (funcPtr->start_pc != 0 && funcPtr->name != 0) {
65 printf("Skipping invalid-looking function %s\n", funcPtr->name);
77 void initializeTypeArray()
80 dwarf_entry * cur_entry;
81 struct genhashtable * ght=genallocatehashtable((unsigned int (*)(void *)) & hashstring,(int (*)(void *,void *)) &equivalentstrings);
83 for (i = 0; i < dwarf_entry_array_size; i++)
85 cur_entry = &dwarf_entry_array[i];
86 if (entry_is_type(cur_entry))
88 collection_type* collection_ptr = (collection_type*)(cur_entry->entry_ptr);
92 for(j=0;j<collection_ptr->num_members;j++) {
93 dwarf_entry *entry=collection_ptr->members[j];
94 if (entry->tag_name==DW_TAG_inheritance) {
99 member * member_ptr=(member *)entry->entry_ptr;
100 char *name=member_ptr->name;
101 dwarf_entry *type=member_ptr->type_ptr;
102 char *typestr=printname(type,GETTYPE);
103 char *poststr=printname(type,POSTNAME);
109 if (collection_ptr->name!=NULL) {
110 struct valuepair *vp=NULL;
111 if (gencontains(ght,collection_ptr->name))
112 vp=(struct valuepair *)gengettable(ght,collection_ptr->name);
113 if (vp==NULL||vp->value<value) {
115 vp=(struct valuepair*)calloc(1,sizeof(struct valuepair));
116 genputtable(ght,collection_ptr->name,vp);
126 for (i = 0; i < dwarf_entry_array_size; i++)
128 cur_entry = &dwarf_entry_array[i];
129 if (entry_is_type(cur_entry))
131 collection_type* collection_ptr = (collection_type*)(cur_entry->entry_ptr);
134 if (collection_ptr->name==NULL)
136 if (gencontains(ght,collection_ptr->name)) {
137 struct valuepair *vp=(struct valuepair*)gengettable(ght,collection_ptr->name);
142 printf("structure %s ",collection_ptr->name);
144 while(j<collection_ptr->num_members&&
145 collection_ptr->members[j]->tag_name==DW_TAG_inheritance) {
146 inherit *in_ptr=(inherit*)collection_ptr->members[j]->entry_ptr;
147 dwarf_entry *typeptr=in_ptr->target_ptr;
148 collection_type* sub_ptr = (collection_type*)(typeptr->entry_ptr);
150 printf("subclasses ");
153 printf("%s ",sub_ptr->name);
158 for(j=0;j<collection_ptr->num_members;j++) {
159 dwarf_entry *entry=collection_ptr->members[j];
160 if (entry->tag_name==DW_TAG_inheritance) {
161 inherit * inherit_ptr=(inherit *)entry->entry_ptr;
162 if (inherit_ptr->data_member_location>offset) {
163 printf(" reserved byte[%ld];\n",inherit_ptr->data_member_location-offset);
164 offset=inherit_ptr->data_member_location;
167 dwarf_entry *type=inherit_ptr->target_ptr;
168 collection_type *c_ptr=(collection_type*)type->entry_ptr;
169 offset+=printtype(c_ptr,ght);
172 member * member_ptr=(member *)entry->entry_ptr;
173 char *name=member_ptr->name;
174 dwarf_entry *type=member_ptr->type_ptr;
175 char *typestr=printname(type,GETTYPE);
176 char *poststr=printname(type,POSTNAME);
177 if (member_ptr->data_member_location>offset) {
178 printf(" reserved byte[%ld];\n",member_ptr->data_member_location-offset);
179 offset=member_ptr->data_member_location;
181 offset+=getsize(type);
183 printf(" %s %s%s;\n",typestr,name,poststr);
191 int printtype(collection_type *collection_ptr,struct genhashtable *ght)
197 struct valuepair *vp=NULL;
198 if (gencontains(ght,collection_ptr->name))
199 vp=(struct valuepair *)gengettable(ght,collection_ptr->name);
201 collection_ptr=(collection_type*) dwarf_entry_array[vp->index].entry_ptr;
203 for(j=0;j<collection_ptr->num_members;j++) {
204 dwarf_entry *entry=collection_ptr->members[j];
205 if (entry->tag_name==DW_TAG_inheritance) {
206 inherit * inherit_ptr=(inherit *)entry->entry_ptr;
207 if (inherit_ptr->data_member_location>offset) {
208 printf(" reserved byte[%ld];\n",inherit_ptr->data_member_location-offset);
209 offset=inherit_ptr->data_member_location;
213 dwarf_entry *type=inherit_ptr->target_ptr;
214 collection_type *c_ptr=(collection_type*)type->entry_ptr;
215 offset+=printtype(c_ptr,ght);
218 member * member_ptr=(member *)entry->entry_ptr;
219 char *name=member_ptr->name;
220 dwarf_entry *type=member_ptr->type_ptr;
221 char *typestr=printname(type,GETTYPE);
222 char *poststr=printname(type,POSTNAME);
223 if (member_ptr->data_member_location>offset) {
224 printf(" reserved byte[%ld];\n",member_ptr->data_member_location-offset);
225 offset=member_ptr->data_member_location;
227 offset+=getsize(type);
229 printf(" %s %s%s;\n",typestr,name,poststr);
237 int getsize(dwarf_entry *type) {
240 switch(type->tag_name) {
241 case DW_TAG_enumeration_type:
243 case DW_TAG_array_type: {
244 modifier_type * modifier_ptr=(modifier_type*)type->entry_ptr;
247 for(i=0;i<modifier_ptr->num_array;i++) {
248 size*=((array_bound*)modifier_ptr->array_ptr[i]->entry_ptr)->upperbound+1;
250 return size*getsize(modifier_ptr->target_ptr);
252 case DW_TAG_base_type: {
253 base_type *base=(base_type*)type->entry_ptr;
254 return base->byte_size;
256 case DW_TAG_pointer_type: {
259 case DW_TAG_structure_type: {
260 collection_type *ctype=(collection_type*)type->entry_ptr;
261 return ctype->byte_size;
268 char * printname(dwarf_entry * type,int op) {
274 switch(type->tag_name) {
275 case DW_TAG_enumeration_type:
279 case DW_TAG_array_type: {
280 modifier_type * modifier_ptr=(modifier_type*)type->entry_ptr;
282 char *typename=printname(modifier_ptr->target_ptr,op);
284 } else if (op==POSTNAME) {
287 char *typename=printname(modifier_ptr->target_ptr,op);
288 char *newptr=(char *)malloc(200);
289 for(i=0;i<modifier_ptr->num_array;i++) {
290 size*=((array_bound*)modifier_ptr->array_ptr[i]->entry_ptr)->upperbound+1;
292 sprintf(newptr,"%s[%ld]",typename,size);
297 case DW_TAG_const_type:
299 consttype * ctype_ptr=(consttype*)type->entry_ptr;
301 char *typename=printname(ctype_ptr->target_ptr,op);
306 case DW_TAG_subroutine_type: {
311 tdef * tdef_ptr=(tdef*)type->entry_ptr;
313 char *typename=printname(tdef_ptr->target_ptr,op);
318 case DW_TAG_base_type: {
319 base_type *base=(base_type*)type->entry_ptr;
321 switch(base->byte_size) {
329 char *m=(char*)malloc(100);
330 sprintf(m,"error%ld",base->byte_size);
336 case DW_TAG_pointer_type: {
337 modifier_type * modifier_ptr=(modifier_type*)type->entry_ptr;
339 if (modifier_ptr->target_ptr==NULL)
340 return "void *"; /* seems like a good guess */
342 char *typename=printname(modifier_ptr->target_ptr,op);
344 char *newptr=(char *)malloc(200);
345 sprintf(newptr,"%s *",typename);
351 case DW_TAG_union_type:
352 case DW_TAG_structure_type: {
353 collection_type *ctype=(collection_type*)type->entry_ptr;
354 if (op==GETTYPE&&ctype->name==NULL&&assigntype) {
355 ctype->name=(char*)malloc(100);
356 sprintf(ctype->name,"TYPE%ld",typecount++);
367 char * p=(char *)malloc(100);
368 sprintf(p,"0x%x",type->tag_name);