dwarf_prototypes.c

   1 /* Most of this is Copyright Dima Kogan <dima@secretsauce.net>
   2  *
   3  * Pieces of this were taken from dwarf_prototypes.c in the dwarves project.
   4  * Those are Copyright (C) 2008 Arnaldo Carvalho de Melo <acme@redhat.com>.
   5  *
   6  * This program is free software; you can redistribute it and/or modify it under
   7  * the terms of version 2 of the GNU General Public License as published by the
   8  * Free Software Foundation.
   9  *
  10  */
  11 #include <stdio.h>
  12 #include <elfutils/libdwfl.h>
  13 #include <dwarf.h>
  14 #include <stdlib.h>
  15 #include <errno.h>
  16 #include <string.h>
  17
  18 #include "config.h"
  19 #include "prototype.h"
  20 #include "type.h"
  21 #include "param.h"
  22 #include "dict.h"
  23 #include "lens.h"
  24 #include "lens_enum.h"
  25 #include "value.h"
  26 #include "expr.h"
  27 #include "library.h"
  28 #include "options.h"
  29 #include "filter.h"
  30
  31
  32 //#define DUMP_PROTOTYPES
  33
  34 #if 1
  35 #define complain( die, format, ... )                                                    \
  36         fprintf(stderr, "%s() die '%s' @ 0x%lx: " format "\n",          \
  37                         __func__, dwarf_diename(die), dwarf_dieoffset(die),     \
  38                         ##__VA_ARGS__ )
  39 #else
  40 #define complain( die, format, ... )
  41 #endif
  42
  43 // A map from DIE addresses (Dwarf_Off) to type structures (struct
  44 // arg_type_info*). This is created and filled in at the start of each import,
  45 // and deleted when the import is complete
  46 static struct dict type_hash;
  47
  48
  49 static bool getType( struct arg_type_info** info, Dwarf_Die* type_die);
  50
  51
  52 #if 0
  53 static bool _dump_dwarf_tree(Dwarf_Die* die, int indent)
  54 {
  55     while(1)
  56     {
  57         fprintf(stderr, "%*sprocessing unit: 0x%02x/'%s'\n", indent*4, "",
  58                dwarf_tag(die), dwarf_diename(die) );
  59
  60         Dwarf_Die child;
  61         if (dwarf_child(die, &child) == 0)
  62         {
  63                         if( !_dump_dwarf_tree(&child, indent+1) )
  64                                 return false;
  65         }
  66
  67         int res = dwarf_siblingof(die, die);
  68         if( res == 0 ) continue;     // sibling exists
  69         if( res < 0 )  return false; // error
  70         break;                       // no sibling exists
  71     }
  72
  73     return true;
  74 }
  75
  76 static bool dump_dwarf_tree(Dwarf_Die* die)
  77 {
  78     return _dump_dwarf_tree( die, 0 );
  79 }
  80 #endif
  81
  82 #ifdef DUMP_PROTOTYPES
  83 static bool _dump_ltrace_tree( const struct arg_type_info* info, int indent )
  84 {
  85         if( indent > 7 )
  86         {
  87                 fprintf(stderr, "%*s%p ...\n", indent*4, "", (void*)info);
  88                 return true;
  89         }
  90
  91         if( info == NULL )
  92         {
  93                 fprintf(stderr, "%*s%p NULL\n", indent*4, "", (void*)info);
  94                 return true;
  95         }
  96
  97         switch(info->type)
  98         {
  99         case ARGTYPE_VOID:
 100                 fprintf(stderr, "%*s%p void\n", indent*4, "", (void*)info);
 101                 break;
 102
 103         case ARGTYPE_INT:
 104         case ARGTYPE_UINT:
 105         case ARGTYPE_LONG:
 106         case ARGTYPE_ULONG:
 107         case ARGTYPE_CHAR:
 108         case ARGTYPE_SHORT:
 109         case ARGTYPE_USHORT:
 110         case ARGTYPE_FLOAT:
 111         case ARGTYPE_DOUBLE:
 112                 fprintf(stderr, "%*s%p base\n", indent*4, "", (void*)info);
 113                 break;
 114
 115         case ARGTYPE_ARRAY:
 116                 fprintf(stderr, "%*s%p array. elements not printed\n", indent*4, "", (void*)info);
 117                 break;
 118
 119         case ARGTYPE_POINTER:
 120                 fprintf(stderr, "%*s%p pointer to...\n", indent*4, "", (void*)info);
 121                 _dump_ltrace_tree( info->u.ptr_info.info, indent+1 );
 122                 break;
 123
 124         case ARGTYPE_STRUCT:
 125                 fprintf(stderr, "%*s%p struct...\n", indent*4, "", (void*)info);
 126                 struct struct_field
 127                 {
 128                         struct arg_type_info *info;
 129                         int own_info;
 130                 }* elements = (struct struct_field*)info->u.entries.data;
 131                 unsigned int i;
 132                 for(i=0; i<info->u.entries.size; i++)
 133                         _dump_ltrace_tree( elements[i].info, indent+1 );
 134                 break;
 135
 136         default:
 137                 fprintf(stderr, "%*s%p unknown type\n", indent*4, "", (void*)info);
 138                 return false;;
 139         }
 140
 141         return true;
 142 }
 143
 144 static bool dump_ltrace_tree( const struct arg_type_info* info )
 145 {
 146         return _dump_ltrace_tree( info, 0 );
 147 }
 148 #endif
 149
 150
 151
 152 static uint64_t attr_numeric(Dwarf_Die *die, uint32_t name)
 153 {
 154         Dwarf_Attribute attr;
 155         uint32_t form;
 156
 157         if (dwarf_attr(die, name, &attr) == NULL)
 158                 return 0;
 159
 160         form = dwarf_whatform(&attr);
 161
 162         switch (form) {
 163         case DW_FORM_addr: {
 164                 Dwarf_Addr addr;
 165                 if (dwarf_formaddr(&attr, &addr) == 0)
 166                         return addr;
 167         }
 168                 break;
 169         case DW_FORM_data1:
 170         case DW_FORM_data2:
 171         case DW_FORM_data4:
 172         case DW_FORM_data8:
 173         case DW_FORM_sdata:
 174         case DW_FORM_udata: {
 175                 Dwarf_Word value;
 176                 if (dwarf_formudata(&attr, &value) == 0)
 177                         return value;
 178         }
 179                 break;
 180         case DW_FORM_flag:
 181         case DW_FORM_flag_present: {
 182                 bool value;
 183                 if (dwarf_formflag(&attr, &value) == 0)
 184                         return value;
 185         }
 186                 break;
 187         default:
 188                 complain(die, "DW_AT_<0x%x>=0x%x", name, form);
 189                 break;
 190         }
 191
 192         return 0;
 193 }
 194
 195 static enum arg_type getBaseType( Dwarf_Die* die )
 196 {
 197         int encoding = attr_numeric(die, DW_AT_encoding);
 198
 199         if( encoding == DW_ATE_void )
 200                 return ARGTYPE_VOID;
 201
 202         if( encoding == DW_ATE_signed_char || encoding == DW_ATE_unsigned_char )
 203                 return ARGTYPE_CHAR;
 204
 205         if( encoding == DW_ATE_signed ||
 206                 encoding == DW_ATE_unsigned )
 207         {
 208                 bool is_signed = (encoding == DW_ATE_signed);
 209                 switch( attr_numeric(die, DW_AT_byte_size) )
 210                 {
 211                 case sizeof(char):
 212                         return ARGTYPE_CHAR;
 213
 214                 case sizeof(short):
 215                         return is_signed ? ARGTYPE_SHORT : ARGTYPE_USHORT;
 216
 217                 case sizeof(int):
 218                         return is_signed ? ARGTYPE_INT : ARGTYPE_UINT;
 219
 220                 case sizeof(long):
 221                         return is_signed ? ARGTYPE_LONG : ARGTYPE_ULONG;
 222
 223                 default:
 224                         complain(die, "");
 225                         exit(1);
 226                 }
 227         }
 228
 229         if( encoding == DW_ATE_float )
 230         {
 231                 switch( attr_numeric(die, DW_AT_byte_size) )
 232                 {
 233                 case sizeof(float):
 234                         return ARGTYPE_FLOAT;
 235
 236                 case sizeof(double):
 237                         return ARGTYPE_DOUBLE;
 238
 239                 default:
 240                         complain(die, "");
 241                         exit(1);
 242                 }
 243         }
 244
 245         complain(die, "");
 246         exit(1);
 247         return ARGTYPE_VOID;
 248 }
 249
 250 static bool getTypeDie( Dwarf_Die* type_die, Dwarf_Die* die )
 251 {
 252         Dwarf_Attribute attr;
 253         return
 254                 dwarf_attr(die, DW_AT_type, &attr) != NULL &&
 255                 dwarf_formref_die(&attr, type_die) != NULL;
 256 }
 257
 258 static size_t dwarf_die_hash(const void* x)
 259 {
 260         return *(const Dwarf_Off*)x;
 261 }
 262 static int dwarf_die_eq(const void* a, const void* b)
 263 {
 264         return *(const Dwarf_Off*)a == *(const Dwarf_Off*)b;
 265 }
 266
 267 static bool getEnum(struct arg_type_info* enum_info, Dwarf_Die* parent)
 268 {
 269         enum_info->type = ARGTYPE_INT;
 270
 271         struct enum_lens *lens = calloc(1, sizeof(struct enum_lens));
 272         if (lens == NULL)
 273         {
 274                 complain(parent, "alloc error");
 275                 return false;
 276         }
 277         lens_init_enum(lens);
 278         enum_info->lens = &lens->super;
 279
 280         Dwarf_Die die;
 281         if( dwarf_child(parent, &die) != 0 )
 282         {
 283                 // empty enum. we're done
 284                 return true;
 285         }
 286
 287         while(1) {
 288                 complain(&die, "enum element: 0x%02x/'%s'", dwarf_tag(&die), dwarf_diename(&die) );
 289
 290                 if( dwarf_tag(&die) != DW_TAG_enumerator )
 291                 {
 292                         complain(&die, "Enums can have ONLY DW_TAG_enumerator elements");
 293                         return false;
 294                 }
 295
 296                 if( !dwarf_hasattr(&die, DW_AT_const_value) )
 297                 {
 298                         complain(&die, "Enums MUST have DW_AT_const_value values");
 299                         return false;
 300                 }
 301
 302                 const char* key = dwarf_diename(&die);
 303                 if( key == NULL )
 304                 {
 305                         complain(&die, "Enums must have a DW_AT_name key");
 306                         return false;
 307                 }
 308                 const char* dupkey = strdup(key);
 309                 if( dupkey == NULL )
 310                 {
 311                         complain(&die, "Couldn't duplicate enum key");
 312                         return false;
 313                 }
 314
 315                 struct value* value = calloc( 1, sizeof(struct value) );
 316                 if( value == NULL )
 317                 {
 318                         complain(&die, "Couldn't alloc enum value");
 319                         return false;
 320                 }
 321
 322                 value_init_detached(value, NULL, type_get_simple( ARGTYPE_INT ), 0);
 323                 value_set_word(value, attr_numeric(&die, DW_AT_const_value) );
 324
 325                 if( lens_enum_add( lens, dupkey, 0, value, 0 ) )
 326                 {
 327                         complain(&die, "Couldn't add enum element");
 328                         return false;
 329                 }
 330
 331                 int res = dwarf_siblingof(&die, &die);
 332                 if( res == 0 ) continue;     /* sibling exists    */
 333                 if( res < 0 )  return false; /* error             */
 334                 break;                       /* no sibling exists */
 335         }
 336
 337         return true;
 338 }
 339
 340 static bool getArray(struct arg_type_info* array_info, Dwarf_Die* parent)
 341 {
 342         Dwarf_Die type_die;
 343         if( !getTypeDie( &type_die, parent ) )
 344         {
 345                 complain( parent, "Array has unknown type" );
 346                 return false;
 347         }
 348
 349         struct arg_type_info* info;
 350         if( !getType( &info, &type_die ) )
 351         {
 352                 complain( parent, "Couldn't figure out array's type" );
 353                 return false;
 354         }
 355
 356         Dwarf_Die subrange;
 357         if( dwarf_child(parent, &subrange) != 0 )
 358         {
 359                 complain( parent, "Array must have a DW_TAG_subrange_type child, but has none" );
 360                 return false;
 361         }
 362
 363         Dwarf_Die next_subrange;
 364         if( dwarf_siblingof(&subrange, &next_subrange) <= 0 )
 365         {
 366                 complain( parent, "Array must have exactly one DW_TAG_subrange_type child" );
 367                 return false;
 368         }
 369
 370         if( !dwarf_hasattr(&subrange, DW_AT_upper_bound) )
 371         {
 372                 complain( parent, "Array subrange must have a DW_AT_upper_bound");
 373                 return false;
 374         }
 375
 376         if( dwarf_hasattr(&subrange, DW_AT_lower_bound) )
 377         {
 378                 if( attr_numeric(&subrange, DW_AT_lower_bound) != 0 )
 379                 {
 380                         complain( parent, "Array subrange has a nonzero lower bound. Don't know what to do");
 381                         return false;
 382                 }
 383         }
 384
 385         // I'm not checking the subrange type. It should be some sort of integer,
 386         // and I don't know what it would mean for it to be something else
 387
 388         struct value* value = calloc( 1, sizeof(struct value) );
 389         if( value == NULL )
 390         {
 391                 complain(&subrange, "Couldn't alloc length value");
 392                 return false;
 393         }
 394         value_init_detached(value, NULL, type_get_simple( ARGTYPE_INT ), 0);
 395         value_set_word(value, attr_numeric(&subrange, DW_AT_upper_bound)+1 );
 396
 397         struct expr_node* length = calloc( 1, sizeof(struct expr_node) );
 398         if( length == NULL )
 399         {
 400                 complain(&subrange, "Couldn't alloc length expr");
 401                 return false;
 402         }
 403         expr_init_const(length, value);
 404
 405         type_init_array(array_info, info, 0, length, 0 );
 406
 407         return true;
 408 }
 409
 410 static bool getStructure(struct arg_type_info* struct_info, Dwarf_Die* parent)
 411 {
 412         type_init_struct(struct_info);
 413
 414         Dwarf_Die die;
 415         if( dwarf_child(parent, &die) != 0 )
 416         {
 417                 // no elements; we're done
 418                 return true;
 419         }
 420
 421         while(1) {
 422                 fprintf(stderr, "member: 0x%02x/'%s'\n", dwarf_tag(&die), dwarf_diename(&die) );
 423
 424                 if( dwarf_tag(&die) != DW_TAG_member )
 425                 {
 426                         complain(&die, "Structure can have ONLY DW_TAG_member");
 427                         return false;
 428                 }
 429
 430                 Dwarf_Die type_die;
 431                 if( !getTypeDie( &type_die, &die ) )
 432                 {
 433                         complain( &die, "Couldn't get type of element");
 434                         return false;
 435                 }
 436
 437                 struct arg_type_info* member_info = NULL;
 438                 if( !getType( &member_info, &type_die ) )
 439                 {
 440                         complain(&die, "Couldn't parse type from DWARF data");
 441                         return false;
 442                 }
 443                 type_struct_add( struct_info, member_info, 0 );
 444
 445                 int res = dwarf_siblingof(&die, &die);
 446                 if( res == 0 ) continue;     /* sibling exists    */
 447                 if( res < 0 )  return false; /* error             */
 448                 break;                       /* no sibling exists */
 449         }
 450
 451         return true;
 452 }
 453
 454 // Reads the type in the die into the given structure
 455 // Returns true on sucess
 456 static bool getType( struct arg_type_info** info, Dwarf_Die* type_die)
 457 {
 458         Dwarf_Off die_offset = dwarf_dieoffset(type_die);
 459         struct arg_type_info** found_type = dict_find(&type_hash, &die_offset );
 460         if(found_type != NULL)
 461         {
 462                 *info = *found_type;
 463                 complain(type_die, "Read pre-computed type: %p", *info);
 464                 return true;
 465         }
 466
 467         Dwarf_Die next_die;
 468
 469         switch( dwarf_tag(type_die) )
 470         {
 471         case DW_TAG_base_type:
 472                 *info = type_get_simple( getBaseType( type_die ) );
 473                 complain(type_die, "Storing base type: %p", *info);
 474                 dict_insert( &type_hash, &die_offset, info );
 475                 return true;
 476
 477         case DW_TAG_subroutine_type:
 478         case DW_TAG_inlined_subroutine:
 479                 // function pointers are stored as void*. If ltrace tries to dereference
 480                 // these, it'll get a segfault
 481                 *info = type_get_simple( ARGTYPE_VOID );
 482                 complain(type_die, "Storing subroutine type: %p", *info);
 483                 dict_insert( &type_hash, &die_offset, info );
 484                 return true;
 485
 486         case DW_TAG_pointer_type:
 487
 488                 if( !getTypeDie(&next_die, type_die ) )
 489                 {
 490                         // the pointed-to type isn't defined, so I report a void*
 491                         *info = type_get_simple( ARGTYPE_VOID );
 492                         complain(type_die, "Storing void-pointer type: %p", *info);
 493                         dict_insert( &type_hash, &die_offset, info );
 494                         return true;
 495                 }
 496
 497                 *info = calloc( 1, sizeof(struct arg_type_info) );
 498                 if( *info == NULL )
 499                 {
 500                         complain(type_die, "alloc error");
 501                         return false;
 502                 }
 503                 type_init_pointer(*info, NULL, 0);
 504
 505                 complain(type_die, "Storing pointer type: %p", *info);
 506                 dict_insert( &type_hash, &die_offset, info );
 507                 return getType( &(*info)->u.ptr_info.info, &next_die );
 508
 509         case DW_TAG_structure_type:
 510                 *info = calloc( 1, sizeof(struct arg_type_info) );
 511                 if( *info == NULL )
 512                 {
 513                         complain(type_die, "alloc error");
 514                         return false;
 515                 }
 516
 517                 complain(type_die, "Storing struct type: %p", *info);
 518                 dict_insert( &type_hash, &die_offset, info );
 519                 return getStructure( *info, type_die );
 520
 521
 522         case DW_TAG_typedef: ;
 523         case DW_TAG_const_type: ;
 524         case DW_TAG_volatile_type: ;
 525                 // Various tags are simply pass-through, so I just keep going
 526                 bool res = true;
 527                 if( getTypeDie(&next_die, type_die ) )
 528                 {
 529                         complain(type_die, "Storing const/typedef type: %p", *info);
 530                         res = getType( info, &next_die );
 531                 }
 532                 else
 533                 {
 534                         // no type. Use 'void'. Normally I'd think this is bogus, but stdio
 535                         // typedefs something to void
 536                         *info = type_get_simple( ARGTYPE_VOID );
 537                         complain(type_die, "Storing void type: %p", *info);
 538                 }
 539                 if( res )
 540                         dict_insert( &type_hash, &die_offset, info );
 541                 return res;
 542
 543         case DW_TAG_enumeration_type:
 544                 // We have an enumeration. This has type "int", but has a particular
 545                 // lens to handle the enum
 546                 *info = calloc( 1, sizeof(struct arg_type_info) );
 547                 if( *info == NULL )
 548                 {
 549                         complain(type_die, "alloc error");
 550                         return false;
 551                 }
 552
 553                 complain(type_die, "Storing enum int: %p", *info);
 554                 dict_insert( &type_hash, &die_offset, info );
 555                 return getEnum( *info, type_die );
 556
 557         case DW_TAG_array_type:
 558                 *info = calloc( 1, sizeof(struct arg_type_info) );
 559                 if( *info == NULL )
 560                 {
 561                         complain(type_die, "alloc error");
 562                         return false;
 563                 }
 564
 565                 complain(type_die, "Storing array: %p", *info);
 566                 dict_insert( &type_hash, &die_offset, info );
 567                 return getArray( *info, type_die );
 568
 569         default:
 570                 complain(type_die, "Unknown type tag 0x%x", dwarf_tag(type_die));
 571                 break;
 572         }
 573
 574         return false;
 575 }
 576
 577 static bool getPrototype(struct prototype* proto, Dwarf_Die* subroutine)
 578 {
 579         // First, look at the return type. This is stored in a DW_AT_type tag in the
 580         // subroutine DIE. If there is no such tag, this function returns void
 581         Dwarf_Die return_type_die;
 582         if( !getTypeDie(&return_type_die, subroutine ) )
 583         {
 584                 proto->return_info = type_get_simple( ARGTYPE_VOID );
 585                 proto->own_return_info = 0;
 586         }
 587         else
 588         {
 589                 proto->return_info = calloc( 1, sizeof( struct arg_type_info ) );
 590                 if( proto->return_info == NULL )
 591                 {
 592                         complain(subroutine, "Couldn't alloc return type");
 593                         return false;
 594                 }
 595                 proto->own_return_info = 0;
 596
 597                 if( !getType( &proto->return_info, &return_type_die ) )
 598                 {
 599                         complain(subroutine, "Couldn't get return type");
 600                         return false;
 601                 }
 602         }
 603
 604
 605         // Now look at the arguments
 606         Dwarf_Die arg_die;
 607         if( dwarf_child(subroutine, &arg_die) != 0 )
 608         {
 609                 // no args. We're done
 610                 return true;
 611         }
 612
 613         while(1) {
 614                 if( dwarf_tag(&arg_die) != DW_TAG_formal_parameter )
 615                         goto next_prototype_argument;
 616
 617                 complain(&arg_die, "arg: 0x%02x", dwarf_tag(&arg_die));
 618
 619                 Dwarf_Die type_die;
 620                 if( !getTypeDie(&type_die, &arg_die ) )
 621                 {
 622                         complain(&arg_die, "Couldn't get the argument type die");
 623                         return false;
 624                 }
 625
 626                 struct arg_type_info* arg_type_info = NULL;
 627                 if( !getType( &arg_type_info, &type_die ) )
 628                 {
 629                         complain(&arg_die, "Couldn't parse arg type from DWARF data");
 630                         return false;
 631                 }
 632
 633                 struct param param;
 634                 param_init_type(&param, arg_type_info, 0);
 635                 if( prototype_push_param(proto, &param) <0 )
 636                 {
 637                         complain(&arg_die, "couldn't add argument to the prototype");
 638                         return false;
 639                 }
 640
 641 #ifdef DUMP_PROTOTYPES
 642                 fprintf(stderr, "Adding argument:\n");
 643                 dump_ltrace_tree(arg_type_info);
 644 #endif
 645
 646         next_prototype_argument: ;
 647                 int res = dwarf_siblingof(&arg_die, &arg_die);
 648                 if( res == 0 ) continue;     /* sibling exists    */
 649                 if( res < 0 )  return false; /* error             */
 650                 break;                       /* no sibling exists */
 651         }
 652
 653         return true;
 654 }
 655
 656 static bool process_die_compileunit(struct protolib* plib, struct library* lib, Dwarf_Die* parent)
 657 {
 658         Dwarf_Die die;
 659         if( dwarf_child(parent, &die) != 0 )
 660                 return false;
 661
 662         while(1)
 663         {
 664                 if( dwarf_tag(&die) == DW_TAG_subprogram )
 665                 {
 666                         const char* function_name = dwarf_diename(&die);
 667
 668                         complain(&die, "subroutine_type: 0x%02x; function '%s'", dwarf_tag(&die), function_name);
 669
 670                         struct prototype* proto =
 671                                 protolib_lookup_prototype(plib, function_name, true );
 672
 673                         if( proto != NULL )
 674                         {
 675                                 complain(&die, "Prototype already exists. Skipping");
 676                                 goto next_prototype;
 677                         }
 678
 679                         if( !filter_matches_symbol(options.plt_filter,    function_name, lib) &&
 680                                 !filter_matches_symbol(options.static_filter, function_name, lib) &&
 681                                 !filter_matches_symbol(options.export_filter, function_name, lib) )
 682                         {
 683                                 complain(&die, "Prototype not requested by any filter");
 684                                 goto next_prototype;
 685                         }
 686
 687                         proto = malloc(sizeof(struct prototype));
 688                         if( proto == NULL )
 689                         {
 690                                 complain(&die, "couldn't alloc prototype");
 691                                 return false;
 692                         }
 693                         prototype_init( proto );
 694
 695                         if( !getPrototype(proto, &die ) )
 696                         {
 697                                 complain(&die, "couldn't get prototype");
 698                                 return false;
 699                         }
 700
 701                         protolib_add_prototype(plib, function_name, 0, proto);
 702                 }
 703
 704                 next_prototype:;
 705                 int res = dwarf_siblingof(&die, &die);
 706                 if( res == 0 ) continue;     /* sibling exists    */
 707                 if( res < 0 )  return false; /* error             */
 708                 break;                       /* no sibling exists */
 709         }
 710
 711         return true;
 712 }
 713
 714 static bool import( struct protolib* plib, struct library* lib, Dwfl* dwfl )
 715 {
 716         dict_init(&type_hash, sizeof(Dwarf_Off), sizeof(struct arg_type_info*),
 717                           dwarf_die_hash, dwarf_die_eq, NULL );
 718
 719         Dwarf_Addr bias;
 720     Dwarf_Die* die = NULL;
 721     while( (die = dwfl_nextcu(dwfl, die, &bias)) != NULL )
 722     {
 723         if( dwarf_tag(die) == DW_TAG_compile_unit )
 724         {
 725             if( !process_die_compileunit(plib, lib, die) )
 726             {
 727                 complain(die, "Error reading compile unit");
 728                                 exit(1);
 729                                 return false;
 730             }
 731         }
 732         else
 733         {
 734             complain(die, "DW_TAG_compile_unit expected");
 735                         exit(1);
 736             return false;
 737         }
 738     }
 739
 740         dict_destroy( &type_hash, NULL, NULL, NULL );
 741         return true;
 742 }
 743
 744 bool import_DWARF_prototypes( struct protolib* plib, struct library* lib,
 745                                                           Dwfl *dwfl )
 746 {
 747         if( plib == NULL )
 748         {
 749                 plib = protolib_cache_default(&g_protocache, lib->soname, 0);
 750                 if (plib == NULL)
 751                 {
 752                         fprintf(stderr, "Error loading protolib %s: %s.\n",
 753                                         lib->soname, strerror(errno));
 754                 }
 755         }
 756
 757         return import(plib, lib, dwfl);
 758 }
 759
 760 /*
 761 - I handle static functions now. Should I? Those do not have DW_AT_external==1
 762
 763 - should process existing prototypes to make sure they match
 764
 765 - what do function pointers look like? I'm doing void*
 766
 767 - unions
 768
 769 - all my *allocs leak
 770
 771 - protolib_lookup_prototype should look for imports?
 772
 773 */