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