1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25 /*
  26  * Copyright 2012 Jason King.  All rights reserved.
  27  * Use is subject to license terms.
  28  */
  29 
  30 /*
  31  * DWARF to tdata conversion
  32  *
  33  * For the most part, conversion is straightforward, proceeding in two passes.
  34  * On the first pass, we iterate through every die, creating new type nodes as
  35  * necessary.  Referenced tdesc_t's are created in an uninitialized state, thus
  36  * allowing type reference pointers to be filled in.  If the tdesc_t
  37  * corresponding to a given die can be completely filled out (sizes and offsets
  38  * calculated, and so forth) without using any referenced types, the tdesc_t is
  39  * marked as resolved.  Consider an array type.  If the type corresponding to
  40  * the array contents has not yet been processed, we will create a blank tdesc
  41  * for the contents type (only the type ID will be filled in, relying upon the
  42  * later portion of the first pass to encounter and complete the referenced
  43  * type).  We will then attempt to determine the size of the array.  If the
  44  * array has a byte size attribute, we will have completely characterized the
  45  * array type, and will be able to mark it as resolved.  The lack of a byte
  46  * size attribute, on the other hand, will prevent us from fully resolving the
  47  * type, as the size will only be calculable with reference to the contents
  48  * type, which has not, as yet, been encountered.  The array type will thus be
  49  * left without the resolved flag, and the first pass will continue.
  50  *
  51  * When we begin the second pass, we will have created tdesc_t nodes for every
  52  * type in the section.  We will traverse the tree, from the iidescs down,
  53  * processing each unresolved node.  As the referenced nodes will have been
  54  * populated, the array type used in our example above will be able to use the
  55  * size of the referenced types (if available) to determine its own type.  The
  56  * traversal will be repeated until all types have been resolved or we have
  57  * failed to make progress.  When all tdescs have been resolved, the conversion
  58  * is complete.
  59  *
  60  * There are, as always, a few special cases that are handled during the first
  61  * and second passes:
  62  *
  63  *  1. Empty enums - GCC will occasionally emit an enum without any members.
  64  *     Later on in the file, it will emit the same enum type, though this time
  65  *     with the full complement of members.  All references to the memberless
  66  *     enum need to be redirected to the full definition.  During the first
  67  *     pass, each enum is entered in dm_enumhash, along with a pointer to its
  68  *     corresponding tdesc_t.  If, during the second pass, we encounter a
  69  *     memberless enum, we use the hash to locate the full definition.  All
  70  *     tdescs referencing the empty enum are then redirected.
  71  *
  72  *  2. Forward declarations - If the compiler sees a forward declaration for
  73  *     a structure, followed by the definition of that structure, it will emit
  74  *     DWARF data for both the forward declaration and the definition.  We need
  75  *     to resolve the forward declarations when possible, by redirecting
  76  *     forward-referencing tdescs to the actual struct/union definitions.  This
  77  *     redirection is done completely within the first pass.  We begin by
  78  *     recording all forward declarations in dw_fwdhash.  When we define a
  79  *     structure, we check to see if there have been any corresponding forward
  80  *     declarations.  If so, we redirect the tdescs which referenced the forward
  81  *     declarations to the structure or union definition.
  82  *
  83  * XXX see if a post traverser will allow the elimination of repeated pass 2
  84  * traversals.
  85  */
  86 
  87 #include <stdio.h>
  88 #include <stdlib.h>
  89 #include <strings.h>
  90 #include <errno.h>
  91 #include <libelf.h>
  92 #include <libdwarf.h>
  93 #include <libgen.h>
  94 #include <dwarf.h>
  95 
  96 #include "ctf_headers.h"
  97 #include "ctftools.h"
  98 #include "memory.h"
  99 #include "list.h"
 100 #include "traverse.h"
 101 
 102 /* The version of DWARF which we support. */
 103 #define DWARF_VERSION   2
 104 
 105 /*
 106  * We need to define a couple of our own intrinsics, to smooth out some of the
 107  * differences between the GCC and DevPro DWARF emitters.  See the referenced
 108  * routines and the special cases in the file comment for more details.
 109  *
 110  * Type IDs are 32 bits wide.  We're going to use the top of that field to
 111  * indicate types that we've created ourselves.
 112  */
 113 #define TID_FILEMAX             0x3fffffff      /* highest tid from file */
 114 #define TID_VOID                0x40000001      /* see die_void() */
 115 #define TID_LONG                0x40000002      /* see die_array() */
 116 
 117 #define TID_MFGTID_BASE         0x40000003      /* first mfg'd tid */
 118 
 119 /*
 120  * To reduce the staggering amount of error-handling code that would otherwise
 121  * be required, the attribute-retrieval routines handle most of their own
 122  * errors.  If the following flag is supplied as the value of the `req'
 123  * argument, they will also handle the absence of a requested attribute by
 124  * terminating the program.
 125  */
 126 #define DW_ATTR_REQ     1
 127 
 128 #define TDESC_HASH_BUCKETS      511
 129 
 130 typedef struct dwarf {
 131         Dwarf_Debug dw_dw;              /* for libdwarf */
 132         Dwarf_Error dw_err;             /* for libdwarf */
 133         Dwarf_Unsigned dw_maxoff;       /* highest legal offset in this cu */
 134         tdata_t *dw_td;                 /* root of the tdesc/iidesc tree */
 135         hash_t *dw_tidhash;             /* hash of tdescs by t_id */
 136         hash_t *dw_fwdhash;             /* hash of fwd decls by name */
 137         hash_t *dw_enumhash;            /* hash of memberless enums by name */
 138         tdesc_t *dw_void;               /* manufactured void type */
 139         tdesc_t *dw_long;               /* manufactured long type for arrays */
 140         size_t dw_ptrsz;                /* size of a pointer in this file */
 141         tid_t dw_mfgtid_last;           /* last mfg'd type ID used */
 142         uint_t dw_nunres;               /* count of unresolved types */
 143         char *dw_cuname;                /* name of compilation unit */
 144 } dwarf_t;
 145 
 146 static void die_create_one(dwarf_t *, Dwarf_Die);
 147 static void die_create(dwarf_t *, Dwarf_Die);
 148 
 149 static tid_t
 150 mfgtid_next(dwarf_t *dw)
 151 {
 152         return (++dw->dw_mfgtid_last);
 153 }
 154 
 155 static void
 156 tdesc_add(dwarf_t *dw, tdesc_t *tdp)
 157 {
 158         hash_add(dw->dw_tidhash, tdp);
 159 }
 160 
 161 static tdesc_t *
 162 tdesc_lookup(dwarf_t *dw, int tid)
 163 {
 164         tdesc_t tmpl, *tdp;
 165 
 166         tmpl.t_id = tid;
 167 
 168         if (hash_find(dw->dw_tidhash, &tmpl, (void **)&tdp))
 169                 return (tdp);
 170         else
 171                 return (NULL);
 172 }
 173 
 174 /*
 175  * Resolve a tdesc down to a node which should have a size.  Returns the size,
 176  * zero if the size hasn't yet been determined.
 177  */
 178 static size_t
 179 tdesc_size(tdesc_t *tdp)
 180 {
 181         for (;;) {
 182                 switch (tdp->t_type) {
 183                 case INTRINSIC:
 184                 case POINTER:
 185                 case ARRAY:
 186                 case FUNCTION:
 187                 case STRUCT:
 188                 case UNION:
 189                 case ENUM:
 190                         return (tdp->t_size);
 191 
 192                 case FORWARD:
 193                         return (0);
 194 
 195                 case TYPEDEF:
 196                 case VOLATILE:
 197                 case CONST:
 198                 case RESTRICT:
 199                         tdp = tdp->t_tdesc;
 200                         continue;
 201 
 202                 case 0: /* not yet defined */
 203                         return (0);
 204 
 205                 default:
 206                         terminate("tdp %u: tdesc_size on unknown type %d\n",
 207                             tdp->t_id, tdp->t_type);
 208                 }
 209         }
 210 }
 211 
 212 static size_t
 213 tdesc_bitsize(tdesc_t *tdp)
 214 {
 215         for (;;) {
 216                 switch (tdp->t_type) {
 217                 case INTRINSIC:
 218                         return (tdp->t_intr->intr_nbits);
 219 
 220                 case ARRAY:
 221                 case FUNCTION:
 222                 case STRUCT:
 223                 case UNION:
 224                 case ENUM:
 225                 case POINTER:
 226                         return (tdp->t_size * NBBY);
 227 
 228                 case FORWARD:
 229                         return (0);
 230 
 231                 case TYPEDEF:
 232                 case VOLATILE:
 233                 case RESTRICT:
 234                 case CONST:
 235                         tdp = tdp->t_tdesc;
 236                         continue;
 237 
 238                 case 0: /* not yet defined */
 239                         return (0);
 240 
 241                 default:
 242                         terminate("tdp %u: tdesc_bitsize on unknown type %d\n",
 243                             tdp->t_id, tdp->t_type);
 244                 }
 245         }
 246 }
 247 
 248 static tdesc_t *
 249 tdesc_basetype(tdesc_t *tdp)
 250 {
 251         for (;;) {
 252                 switch (tdp->t_type) {
 253                 case TYPEDEF:
 254                 case VOLATILE:
 255                 case RESTRICT:
 256                 case CONST:
 257                         tdp = tdp->t_tdesc;
 258                         break;
 259                 case 0: /* not yet defined */
 260                         return (NULL);
 261                 default:
 262                         return (tdp);
 263                 }
 264         }
 265 }
 266 
 267 static Dwarf_Off
 268 die_off(dwarf_t *dw, Dwarf_Die die)
 269 {
 270         Dwarf_Off off;
 271 
 272         if (dwarf_dieoffset(die, &off, &dw->dw_err) == DW_DLV_OK)
 273                 return (off);
 274 
 275         terminate("failed to get offset for die: %s\n",
 276             dwarf_errmsg(dw->dw_err));
 277         /*NOTREACHED*/
 278         return (0);
 279 }
 280 
 281 static Dwarf_Die
 282 die_sibling(dwarf_t *dw, Dwarf_Die die)
 283 {
 284         Dwarf_Die sib;
 285         int rc;
 286 
 287         if ((rc = dwarf_siblingof(dw->dw_dw, die, &sib, &dw->dw_err)) ==
 288             DW_DLV_OK)
 289                 return (sib);
 290         else if (rc == DW_DLV_NO_ENTRY)
 291                 return (NULL);
 292 
 293         terminate("die %llu: failed to find type sibling: %s\n",
 294             die_off(dw, die), dwarf_errmsg(dw->dw_err));
 295         /*NOTREACHED*/
 296         return (NULL);
 297 }
 298 
 299 static Dwarf_Die
 300 die_child(dwarf_t *dw, Dwarf_Die die)
 301 {
 302         Dwarf_Die child;
 303         int rc;
 304 
 305         if ((rc = dwarf_child(die, &child, &dw->dw_err)) == DW_DLV_OK)
 306                 return (child);
 307         else if (rc == DW_DLV_NO_ENTRY)
 308                 return (NULL);
 309 
 310         terminate("die %llu: failed to find type child: %s\n",
 311             die_off(dw, die), dwarf_errmsg(dw->dw_err));
 312         /*NOTREACHED*/
 313         return (NULL);
 314 }
 315 
 316 static Dwarf_Half
 317 die_tag(dwarf_t *dw, Dwarf_Die die)
 318 {
 319         Dwarf_Half tag;
 320 
 321         if (dwarf_tag(die, &tag, &dw->dw_err) == DW_DLV_OK)
 322                 return (tag);
 323 
 324         terminate("die %llu: failed to get tag for type: %s\n",
 325             die_off(dw, die), dwarf_errmsg(dw->dw_err));
 326         /*NOTREACHED*/
 327         return (0);
 328 }
 329 
 330 static Dwarf_Attribute
 331 die_attr(dwarf_t *dw, Dwarf_Die die, Dwarf_Half name, int req)
 332 {
 333         Dwarf_Attribute attr;
 334         int rc;
 335 
 336         if ((rc = dwarf_attr(die, name, &attr, &dw->dw_err)) == DW_DLV_OK) {
 337                 return (attr);
 338         } else if (rc == DW_DLV_NO_ENTRY) {
 339                 if (req) {
 340                         terminate("die %llu: no attr 0x%x\n", die_off(dw, die),
 341                             name);
 342                 } else {
 343                         return (NULL);
 344                 }
 345         }
 346 
 347         terminate("die %llu: failed to get attribute for type: %s\n",
 348             die_off(dw, die), dwarf_errmsg(dw->dw_err));
 349         /*NOTREACHED*/
 350         return (NULL);
 351 }
 352 
 353 static Dwarf_Half
 354 die_attr_form(dwarf_t *dw, Dwarf_Attribute attr)
 355 {
 356         Dwarf_Half form;
 357 
 358         if (dwarf_whatform(attr, &form, &dw->dw_err) == DW_DLV_OK)
 359                 return (form);
 360 
 361         terminate("failed to get attribute form for type: %s\n",
 362             dwarf_errmsg(dw->dw_err));
 363         /*NOTREACHED*/
 364         return (0);
 365 }
 366 
 367 /*
 368  * the following functions lookup the value of an attribute in a DIE:
 369  *
 370  * die_signed
 371  * die_unsigned
 372  * die_bool
 373  * die_string
 374  *
 375  * They all take the same parameters (with the exception of valp which is
 376  * a pointer to the type of the attribute we are looking up):
 377  *
 378  * dw - the dwarf object to look in
 379  * die - the DIE we're interested in
 380  * name - the name of the attribute to lookup
 381  * valp - pointer to where the value of the attribute is placed
 382  * req - if the value is required (0 / non-zero)
 383  *
 384  * If the attribute is not found, one of the following happens:
 385  * - program terminates (req is non-zero)
 386  * - function returns 0
 387  *
 388  * If the value is found, and in a form (class) we can handle, the function
 389  * returns 1.
 390  *
 391  * Currently, we can only handle attribute values that are stored as
 392  * constants (immediate value).  If an attribute has a form we cannot
 393  * handle (for example VLAs may store the dimensions of the array
 394  * as a DWARF expression that can compute it at runtime by reading
 395  * values off the stack or other locations in memory), it is treated
 396  * the same as if the attribute does not exist.
 397  */
 398 static int
 399 die_signed(dwarf_t *dw, Dwarf_Die die, Dwarf_Half name, Dwarf_Signed *valp,
 400     int req)
 401 {
 402         Dwarf_Attribute attr;
 403         Dwarf_Signed val;
 404 
 405         if ((attr = die_attr(dw, die, name, req)) == NULL)
 406                 return (0); /* die_attr will terminate for us if necessary */
 407 
 408         if (dwarf_formsdata(attr, &val, &dw->dw_err) != DW_DLV_OK) {
 409                 if (req == 0)
 410                         return (0);
 411 
 412                 terminate("die %llu: failed to get signed (form 0x%x)\n",
 413                     die_off(dw, die), die_attr_form(dw, attr));
 414         }
 415 
 416         dwarf_dealloc(dw->dw_dw, attr, DW_DLA_ATTR);
 417 
 418         *valp = val;
 419         return (1);
 420 }
 421 
 422 static int
 423 die_unsigned(dwarf_t *dw, Dwarf_Die die, Dwarf_Half name, Dwarf_Unsigned *valp,
 424     int req)
 425 {
 426         Dwarf_Attribute attr;
 427         Dwarf_Unsigned val;
 428 
 429         if ((attr = die_attr(dw, die, name, req)) == NULL)
 430                 return (0); /* die_attr will terminate for us if necessary */
 431 
 432         if (dwarf_formudata(attr, &val, &dw->dw_err) != DW_DLV_OK) {
 433                 if (req == 0)
 434                         return (0);
 435 
 436                 terminate("die %llu: failed to get unsigned (form 0x%x)\n",
 437                     die_off(dw, die), die_attr_form(dw, attr));
 438         }
 439 
 440         dwarf_dealloc(dw->dw_dw, attr, DW_DLA_ATTR);
 441 
 442         *valp = val;
 443         return (1);
 444 }
 445 
 446 static int
 447 die_bool(dwarf_t *dw, Dwarf_Die die, Dwarf_Half name, Dwarf_Bool *valp, int req)
 448 {
 449         Dwarf_Attribute attr;
 450         Dwarf_Bool val;
 451 
 452         if ((attr = die_attr(dw, die, name, req)) == NULL)
 453                 return (0); /* die_attr will terminate for us if necessary */
 454 
 455         if (dwarf_formflag(attr, &val, &dw->dw_err) != DW_DLV_OK) {
 456                 if (req == 0)
 457                         return (0);
 458 
 459                 terminate("die %llu: failed to get bool (form 0x%x)\n",
 460                     die_off(dw, die), die_attr_form(dw, attr));
 461         }
 462 
 463         dwarf_dealloc(dw->dw_dw, attr, DW_DLA_ATTR);
 464 
 465         *valp = val;
 466         return (1);
 467 }
 468 
 469 static int
 470 die_string(dwarf_t *dw, Dwarf_Die die, Dwarf_Half name, char **strp, int req)
 471 {
 472         Dwarf_Attribute attr;
 473         char *str;
 474 
 475         if ((attr = die_attr(dw, die, name, req)) == NULL)
 476                 return (0); /* die_attr will terminate for us if necessary */
 477 
 478         if (dwarf_formstring(attr, &str, &dw->dw_err) != DW_DLV_OK) {
 479                 if (req == 0)
 480                         return (0);
 481 
 482                 terminate("die %llu: failed to get string (form 0x%x)\n",
 483                     die_off(dw, die), die_attr_form(dw, attr));
 484         }
 485 
 486         *strp = xstrdup(str);
 487         dwarf_dealloc(dw->dw_dw, str, DW_DLA_STRING);
 488 
 489         return (1);
 490 }
 491 
 492 static Dwarf_Off
 493 die_attr_ref(dwarf_t *dw, Dwarf_Die die, Dwarf_Half name)
 494 {
 495         Dwarf_Attribute attr;
 496         Dwarf_Off off;
 497 
 498         attr = die_attr(dw, die, name, DW_ATTR_REQ);
 499 
 500         if (dwarf_formref(attr, &off, &dw->dw_err) != DW_DLV_OK) {
 501                 terminate("die %llu: failed to get ref (form 0x%x)\n",
 502                     die_off(dw, die), die_attr_form(dw, attr));
 503         }
 504 
 505         dwarf_dealloc(dw->dw_dw, attr, DW_DLA_ATTR);
 506 
 507         return (off);
 508 }
 509 
 510 static char *
 511 die_name(dwarf_t *dw, Dwarf_Die die)
 512 {
 513         char *str = NULL;
 514 
 515         (void) die_string(dw, die, DW_AT_name, &str, 0);
 516 
 517         return (str);
 518 }
 519 
 520 static int
 521 die_isdecl(dwarf_t *dw, Dwarf_Die die)
 522 {
 523         Dwarf_Bool val;
 524 
 525         return (die_bool(dw, die, DW_AT_declaration, &val, 0) && val);
 526 }
 527 
 528 static int
 529 die_isglobal(dwarf_t *dw, Dwarf_Die die)
 530 {
 531         Dwarf_Signed vis;
 532         Dwarf_Bool ext;
 533 
 534         /*
 535          * Some compilers (gcc) use DW_AT_external to indicate function
 536          * visibility.  Others (Sun) use DW_AT_visibility.
 537          */
 538         if (die_signed(dw, die, DW_AT_visibility, &vis, 0))
 539                 return (vis == DW_VIS_exported);
 540         else
 541                 return (die_bool(dw, die, DW_AT_external, &ext, 0) && ext);
 542 }
 543 
 544 static tdesc_t *
 545 die_add(dwarf_t *dw, Dwarf_Off off)
 546 {
 547         tdesc_t *tdp = xcalloc(sizeof (tdesc_t));
 548 
 549         tdp->t_id = off;
 550 
 551         tdesc_add(dw, tdp);
 552 
 553         return (tdp);
 554 }
 555 
 556 static tdesc_t *
 557 die_lookup_pass1(dwarf_t *dw, Dwarf_Die die, Dwarf_Half name)
 558 {
 559         Dwarf_Off ref = die_attr_ref(dw, die, name);
 560         tdesc_t *tdp;
 561 
 562         if ((tdp = tdesc_lookup(dw, ref)) != NULL)
 563                 return (tdp);
 564 
 565         return (die_add(dw, ref));
 566 }
 567 
 568 static int
 569 die_mem_offset(dwarf_t *dw, Dwarf_Die die, Dwarf_Half name,
 570     Dwarf_Unsigned *valp, int req)
 571 {
 572         Dwarf_Attribute attr;
 573         Dwarf_Locdesc *loc;
 574         Dwarf_Signed locnum;
 575 
 576         if ((attr = die_attr(dw, die, name, req)) == NULL)
 577                 return (0); /* die_attr will terminate for us if necessary */
 578 
 579         if (dwarf_loclist(attr, &loc, &locnum, &dw->dw_err) != DW_DLV_OK) {
 580                 terminate("die %llu: failed to get mem offset location list\n",
 581                     die_off(dw, die));
 582         }
 583 
 584         dwarf_dealloc(dw->dw_dw, attr, DW_DLA_ATTR);
 585 
 586         if (locnum != 1 || loc->ld_s->lr_atom != DW_OP_plus_uconst) {
 587                 terminate("die %llu: cannot parse member offset\n",
 588                     die_off(dw, die));
 589         }
 590 
 591         *valp = loc->ld_s->lr_number;
 592 
 593         dwarf_dealloc(dw->dw_dw, loc->ld_s, DW_DLA_LOC_BLOCK);
 594         dwarf_dealloc(dw->dw_dw, loc, DW_DLA_LOCDESC);
 595 
 596         return (1);
 597 }
 598 
 599 static tdesc_t *
 600 tdesc_intr_common(dwarf_t *dw, int tid, const char *name, size_t sz)
 601 {
 602         tdesc_t *tdp;
 603         intr_t *intr;
 604 
 605         intr = xcalloc(sizeof (intr_t));
 606         intr->intr_type = INTR_INT;
 607         intr->intr_signed = 1;
 608         intr->intr_nbits = sz * NBBY;
 609 
 610         tdp = xcalloc(sizeof (tdesc_t));
 611         tdp->t_name = xstrdup(name);
 612         tdp->t_size = sz;
 613         tdp->t_id = tid;
 614         tdp->t_type = INTRINSIC;
 615         tdp->t_intr = intr;
 616         tdp->t_flags = TDESC_F_RESOLVED;
 617 
 618         tdesc_add(dw, tdp);
 619 
 620         return (tdp);
 621 }
 622 
 623 /*
 624  * Manufacture a void type.  Used for gcc-emitted stabs, where the lack of a
 625  * type reference implies a reference to a void type.  A void *, for example
 626  * will be represented by a pointer die without a DW_AT_type.  CTF requires
 627  * that pointer nodes point to something, so we'll create a void for use as
 628  * the target.  Note that the DWARF data may already create a void type.  Ours
 629  * would then be a duplicate, but it'll be removed in the self-uniquification
 630  * merge performed at the completion of DWARF->tdesc conversion.
 631  */
 632 static tdesc_t *
 633 tdesc_intr_void(dwarf_t *dw)
 634 {
 635         if (dw->dw_void == NULL)
 636                 dw->dw_void = tdesc_intr_common(dw, TID_VOID, "void", 0);
 637 
 638         return (dw->dw_void);
 639 }
 640 
 641 static tdesc_t *
 642 tdesc_intr_long(dwarf_t *dw)
 643 {
 644         if (dw->dw_long == NULL) {
 645                 dw->dw_long = tdesc_intr_common(dw, TID_LONG, "long",
 646                     dw->dw_ptrsz);
 647         }
 648 
 649         return (dw->dw_long);
 650 }
 651 
 652 /*
 653  * Used for creating bitfield types.  We create a copy of an existing intrinsic,
 654  * adjusting the size of the copy to match what the caller requested.  The
 655  * caller can then use the copy as the type for a bitfield structure member.
 656  */
 657 static tdesc_t *
 658 tdesc_intr_clone(dwarf_t *dw, tdesc_t *old, size_t bitsz)
 659 {
 660         tdesc_t *new = xcalloc(sizeof (tdesc_t));
 661 
 662         if (!(old->t_flags & TDESC_F_RESOLVED)) {
 663                 terminate("tdp %u: attempt to make a bit field from an "
 664                     "unresolved type\n", old->t_id);
 665         }
 666 
 667         new->t_name = xstrdup(old->t_name);
 668         new->t_size = old->t_size;
 669         new->t_id = mfgtid_next(dw);
 670         new->t_type = INTRINSIC;
 671         new->t_flags = TDESC_F_RESOLVED;
 672 
 673         new->t_intr = xcalloc(sizeof (intr_t));
 674         bcopy(old->t_intr, new->t_intr, sizeof (intr_t));
 675         new->t_intr->intr_nbits = bitsz;
 676 
 677         tdesc_add(dw, new);
 678 
 679         return (new);
 680 }
 681 
 682 static void
 683 tdesc_array_create(dwarf_t *dw, Dwarf_Die dim, tdesc_t *arrtdp,
 684     tdesc_t *dimtdp)
 685 {
 686         Dwarf_Unsigned uval;
 687         Dwarf_Signed sval;
 688         tdesc_t *ctdp;
 689         Dwarf_Die dim2;
 690         ardef_t *ar;
 691 
 692         if ((dim2 = die_sibling(dw, dim)) == NULL) {
 693                 ctdp = arrtdp;
 694         } else if (die_tag(dw, dim2) == DW_TAG_subrange_type) {
 695                 ctdp = xcalloc(sizeof (tdesc_t));
 696                 ctdp->t_id = mfgtid_next(dw);
 697                 debug(3, "die %llu: creating new type %u for sub-dimension\n",
 698                     die_off(dw, dim2), ctdp->t_id);
 699                 tdesc_array_create(dw, dim2, arrtdp, ctdp);
 700         } else {
 701                 terminate("die %llu: unexpected non-subrange node in array\n",
 702                     die_off(dw, dim2));
 703         }
 704 
 705         dimtdp->t_type = ARRAY;
 706         dimtdp->t_ardef = ar = xcalloc(sizeof (ardef_t));
 707 
 708         /*
 709          * Array bounds can be signed or unsigned, but there are several kinds
 710          * of signless forms (data1, data2, etc) that take their sign from the
 711          * routine that is trying to interpret them.  That is, data1 can be
 712          * either signed or unsigned, depending on whether you use the signed or
 713          * unsigned accessor function.  GCC will use the signless forms to store
 714          * unsigned values which have their high bit set, so we need to try to
 715          * read them first as unsigned to get positive values.  We could also
 716          * try signed first, falling back to unsigned if we got a negative
 717          * value.
 718          */
 719         if (die_unsigned(dw, dim, DW_AT_upper_bound, &uval, 0))
 720                 ar->ad_nelems = uval + 1;
 721         else if (die_signed(dw, dim, DW_AT_upper_bound, &sval, 0))
 722                 ar->ad_nelems = sval + 1;
 723         else
 724                 ar->ad_nelems = 0;
 725 
 726         /*
 727          * Different compilers use different index types.  Force the type to be
 728          * a common, known value (long).
 729          */
 730         ar->ad_idxtype = tdesc_intr_long(dw);
 731         ar->ad_contents = ctdp;
 732 
 733         if (ar->ad_contents->t_size != 0) {
 734                 dimtdp->t_size = ar->ad_contents->t_size * ar->ad_nelems;
 735                 dimtdp->t_flags |= TDESC_F_RESOLVED;
 736         }
 737 }
 738 
 739 /*
 740  * Create a tdesc from an array node.  Some arrays will come with byte size
 741  * attributes, and thus can be resolved immediately.  Others don't, and will
 742  * need to wait until the second pass for resolution.
 743  */
 744 static void
 745 die_array_create(dwarf_t *dw, Dwarf_Die arr, Dwarf_Off off, tdesc_t *tdp)
 746 {
 747         tdesc_t *arrtdp = die_lookup_pass1(dw, arr, DW_AT_type);
 748         Dwarf_Unsigned uval;
 749         Dwarf_Die dim;
 750 
 751         debug(3, "die %llu: creating array\n", off);
 752 
 753         if ((dim = die_child(dw, arr)) == NULL ||
 754             die_tag(dw, dim) != DW_TAG_subrange_type)
 755                 terminate("die %llu: failed to retrieve array bounds\n", off);
 756 
 757         tdesc_array_create(dw, dim, arrtdp, tdp);
 758 
 759         if (die_unsigned(dw, arr, DW_AT_byte_size, &uval, 0)) {
 760                 tdesc_t *dimtdp;
 761                 int flags;
 762 
 763                 tdp->t_size = uval;
 764 
 765                 /*
 766                  * Ensure that sub-dimensions have sizes too before marking
 767                  * as resolved.
 768                  */
 769                 flags = TDESC_F_RESOLVED;
 770                 for (dimtdp = tdp->t_ardef->ad_contents;
 771                     dimtdp->t_type == ARRAY;
 772                     dimtdp = dimtdp->t_ardef->ad_contents) {
 773                         if (!(dimtdp->t_flags & TDESC_F_RESOLVED)) {
 774                                 flags = 0;
 775                                 break;
 776                         }
 777                 }
 778 
 779                 tdp->t_flags |= flags;
 780         }
 781 
 782         debug(3, "die %llu: array nelems %u size %u\n", off,
 783             tdp->t_ardef->ad_nelems, tdp->t_size);
 784 }
 785 
 786 /*ARGSUSED1*/
 787 static int
 788 die_array_resolve(tdesc_t *tdp, tdesc_t **tdpp, void *private)
 789 {
 790         dwarf_t *dw = private;
 791         size_t sz;
 792 
 793         if (tdp->t_flags & TDESC_F_RESOLVED)
 794                 return (1);
 795 
 796         debug(3, "trying to resolve array %d (cont %d)\n", tdp->t_id,
 797             tdp->t_ardef->ad_contents->t_id);
 798 
 799         if ((sz = tdesc_size(tdp->t_ardef->ad_contents)) == 0) {
 800                 debug(3, "unable to resolve array %s (%d) contents %d\n",
 801                     tdesc_name(tdp), tdp->t_id,
 802                     tdp->t_ardef->ad_contents->t_id);
 803 
 804                 dw->dw_nunres++;
 805                 return (1);
 806         }
 807 
 808         tdp->t_size = sz * tdp->t_ardef->ad_nelems;
 809         tdp->t_flags |= TDESC_F_RESOLVED;
 810 
 811         debug(3, "resolved array %d: %u bytes\n", tdp->t_id, tdp->t_size);
 812 
 813         return (1);
 814 }
 815 
 816 /*ARGSUSED1*/
 817 static int
 818 die_array_failed(tdesc_t *tdp, tdesc_t **tdpp, void *private)
 819 {
 820         tdesc_t *cont = tdp->t_ardef->ad_contents;
 821 
 822         if (tdp->t_flags & TDESC_F_RESOLVED)
 823                 return (1);
 824 
 825         fprintf(stderr, "Array %d: failed to size contents type %s (%d)\n",
 826             tdp->t_id, tdesc_name(cont), cont->t_id);
 827 
 828         return (1);
 829 }
 830 
 831 /*
 832  * Most enums (those with members) will be resolved during this first pass.
 833  * Others - those without members (see the file comment) - won't be, and will
 834  * need to wait until the second pass when they can be matched with their full
 835  * definitions.
 836  */
 837 static void
 838 die_enum_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp)
 839 {
 840         Dwarf_Die mem;
 841         Dwarf_Unsigned uval;
 842         Dwarf_Signed sval;
 843 
 844         debug(3, "die %llu: creating enum\n", off);
 845 
 846         tdp->t_type = ENUM;
 847 
 848         (void) die_unsigned(dw, die, DW_AT_byte_size, &uval, DW_ATTR_REQ);
 849         tdp->t_size = uval;
 850 
 851         if ((mem = die_child(dw, die)) != NULL) {
 852                 elist_t **elastp = &tdp->t_emem;
 853 
 854                 do {
 855                         elist_t *el;
 856 
 857                         if (die_tag(dw, mem) != DW_TAG_enumerator) {
 858                                 /* Nested type declaration */
 859                                 die_create_one(dw, mem);
 860                                 continue;
 861                         }
 862 
 863                         el = xcalloc(sizeof (elist_t));
 864                         el->el_name = die_name(dw, mem);
 865 
 866                         if (die_signed(dw, mem, DW_AT_const_value, &sval, 0)) {
 867                                 el->el_number = sval;
 868                         } else if (die_unsigned(dw, mem, DW_AT_const_value,
 869                             &uval, 0)) {
 870                                 el->el_number = uval;
 871                         } else {
 872                                 terminate("die %llu: enum %llu: member without "
 873                                     "value\n", off, die_off(dw, mem));
 874                         }
 875 
 876                         debug(3, "die %llu: enum %llu: created %s = %d\n", off,
 877                             die_off(dw, mem), el->el_name, el->el_number);
 878 
 879                         *elastp = el;
 880                         elastp = &el->el_next;
 881 
 882                 } while ((mem = die_sibling(dw, mem)) != NULL);
 883 
 884                 hash_add(dw->dw_enumhash, tdp);
 885 
 886                 tdp->t_flags |= TDESC_F_RESOLVED;
 887 
 888                 if (tdp->t_name != NULL) {
 889                         iidesc_t *ii = xcalloc(sizeof (iidesc_t));
 890                         ii->ii_type = II_SOU;
 891                         ii->ii_name = xstrdup(tdp->t_name);
 892                         ii->ii_dtype = tdp;
 893 
 894                         iidesc_add(dw->dw_td->td_iihash, ii);
 895                 }
 896         }
 897 }
 898 
 899 static int
 900 die_enum_match(void *arg1, void *arg2)
 901 {
 902         tdesc_t *tdp = arg1, **fullp = arg2;
 903 
 904         if (tdp->t_emem != NULL) {
 905                 *fullp = tdp;
 906                 return (-1); /* stop the iteration */
 907         }
 908 
 909         return (0);
 910 }
 911 
 912 /*ARGSUSED1*/
 913 static int
 914 die_enum_resolve(tdesc_t *tdp, tdesc_t **tdpp, void *private)
 915 {
 916         dwarf_t *dw = private;
 917         tdesc_t *full = NULL;
 918 
 919         if (tdp->t_flags & TDESC_F_RESOLVED)
 920                 return (1);
 921 
 922         (void) hash_find_iter(dw->dw_enumhash, tdp, die_enum_match, &full);
 923 
 924         /*
 925          * The answer to this one won't change from iteration to iteration,
 926          * so don't even try.
 927          */
 928         if (full == NULL) {
 929                 terminate("tdp %u: enum %s has no members\n", tdp->t_id,
 930                     tdesc_name(tdp));
 931         }
 932 
 933         debug(3, "tdp %u: enum %s redirected to %u\n", tdp->t_id,
 934             tdesc_name(tdp), full->t_id);
 935 
 936         tdp->t_flags |= TDESC_F_RESOLVED;
 937 
 938         return (1);
 939 }
 940 
 941 static int
 942 die_fwd_map(void *arg1, void *arg2)
 943 {
 944         tdesc_t *fwd = arg1, *sou = arg2;
 945 
 946         debug(3, "tdp %u: mapped forward %s to sou %u\n", fwd->t_id,
 947             tdesc_name(fwd), sou->t_id);
 948         fwd->t_tdesc = sou;
 949 
 950         return (0);
 951 }
 952 
 953 /*
 954  * Structures and unions will never be resolved during the first pass, as we
 955  * won't be able to fully determine the member sizes.  The second pass, which
 956  * have access to sizing information, will be able to complete the resolution.
 957  */
 958 static void
 959 die_sou_create(dwarf_t *dw, Dwarf_Die str, Dwarf_Off off, tdesc_t *tdp,
 960     int type, const char *typename)
 961 {
 962         Dwarf_Unsigned sz, bitsz, bitoff;
 963         Dwarf_Die mem;
 964         mlist_t *ml, **mlastp;
 965         iidesc_t *ii;
 966 
 967         tdp->t_type = (die_isdecl(dw, str) ? FORWARD : type);
 968 
 969         debug(3, "die %llu: creating %s %s\n", off,
 970             (tdp->t_type == FORWARD ? "forward decl" : typename),
 971             tdesc_name(tdp));
 972 
 973         if (tdp->t_type == FORWARD) {
 974                 hash_add(dw->dw_fwdhash, tdp);
 975                 return;
 976         }
 977 
 978         (void) hash_find_iter(dw->dw_fwdhash, tdp, die_fwd_map, tdp);
 979 
 980         (void) die_unsigned(dw, str, DW_AT_byte_size, &sz, DW_ATTR_REQ);
 981         tdp->t_size = sz;
 982 
 983         /*
 984          * GCC allows empty SOUs as an extension.
 985          */
 986         if ((mem = die_child(dw, str)) == NULL)
 987                 goto out;
 988 
 989         mlastp = &tdp->t_members;
 990 
 991         do {
 992                 Dwarf_Off memoff = die_off(dw, mem);
 993                 Dwarf_Half tag = die_tag(dw, mem);
 994                 Dwarf_Unsigned mloff;
 995 
 996                 if (tag != DW_TAG_member) {
 997                         /* Nested type declaration */
 998                         die_create_one(dw, mem);
 999                         continue;
1000                 }
1001 
1002                 debug(3, "die %llu: mem %llu: creating member\n", off, memoff);
1003 
1004                 ml = xcalloc(sizeof (mlist_t));
1005 
1006                 /*
1007                  * This could be a GCC anon struct/union member, so we'll allow
1008                  * an empty name, even though nothing can really handle them
1009                  * properly.  Note that some versions of GCC miss out debug
1010                  * info for anon structs, though recent versions are fixed (gcc
1011                  * bug 11816).
1012                  */
1013                 if ((ml->ml_name = die_name(dw, mem)) == NULL)
1014                         ml->ml_name = "";
1015 
1016                 ml->ml_type = die_lookup_pass1(dw, mem, DW_AT_type);
1017 
1018                 if (die_mem_offset(dw, mem, DW_AT_data_member_location,
1019                     &mloff, 0)) {
1020                         debug(3, "die %llu: got mloff %llx\n", off,
1021                             (u_longlong_t)mloff);
1022                         ml->ml_offset = mloff * 8;
1023                 }
1024 
1025                 if (die_unsigned(dw, mem, DW_AT_bit_size, &bitsz, 0))
1026                         ml->ml_size = bitsz;
1027                 else
1028                         ml->ml_size = tdesc_bitsize(ml->ml_type);
1029 
1030                 if (die_unsigned(dw, mem, DW_AT_bit_offset, &bitoff, 0)) {
1031 #ifdef  _BIG_ENDIAN
1032                         ml->ml_offset += bitoff;
1033 #else
1034                         ml->ml_offset += tdesc_bitsize(ml->ml_type) - bitoff -
1035                             ml->ml_size;
1036 #endif
1037                 }
1038 
1039                 debug(3, "die %llu: mem %llu: created \"%s\" (off %u sz %u)\n",
1040                     off, memoff, ml->ml_name, ml->ml_offset, ml->ml_size);
1041 
1042                 *mlastp = ml;
1043                 mlastp = &ml->ml_next;
1044         } while ((mem = die_sibling(dw, mem)) != NULL);
1045 
1046         /*
1047          * GCC will attempt to eliminate unused types, thus decreasing the
1048          * size of the emitted dwarf.  That is, if you declare a foo_t in your
1049          * header, include said header in your source file, and neglect to
1050          * actually use (directly or indirectly) the foo_t in the source file,
1051          * the foo_t won't make it into the emitted DWARF.  So, at least, goes
1052          * the theory.
1053          *
1054          * Occasionally, it'll emit the DW_TAG_structure_type for the foo_t,
1055          * and then neglect to emit the members.  Strangely, the loner struct
1056          * tag will always be followed by a proper nested declaration of
1057          * something else.  This is clearly a bug, but we're not going to have
1058          * time to get it fixed before this goo goes back, so we'll have to work
1059          * around it.  If we see a no-membered struct with a nested declaration
1060          * (i.e. die_child of the struct tag won't be null), we'll ignore it.
1061          * Being paranoid, we won't simply remove it from the hash.  Instead,
1062          * we'll decline to create an iidesc for it, thus ensuring that this
1063          * type won't make it into the output file.  To be safe, we'll also
1064          * change the name.
1065          */
1066         if (tdp->t_members == NULL) {
1067                 const char *old = tdesc_name(tdp);
1068                 size_t newsz = 7 + strlen(old) + 1;
1069                 char *new = xmalloc(newsz);
1070                 (void) snprintf(new, newsz, "orphan %s", old);
1071 
1072                 debug(3, "die %llu: worked around %s %s\n", off, typename, old);
1073 
1074                 if (tdp->t_name != NULL)
1075                         free(tdp->t_name);
1076                 tdp->t_name = new;
1077                 return;
1078         }
1079 
1080 out:
1081         if (tdp->t_name != NULL) {
1082                 ii = xcalloc(sizeof (iidesc_t));
1083                 ii->ii_type = II_SOU;
1084                 ii->ii_name = xstrdup(tdp->t_name);
1085                 ii->ii_dtype = tdp;
1086 
1087                 iidesc_add(dw->dw_td->td_iihash, ii);
1088         }
1089 }
1090 
1091 static void
1092 die_struct_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp)
1093 {
1094         die_sou_create(dw, die, off, tdp, STRUCT, "struct");
1095 }
1096 
1097 static void
1098 die_union_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp)
1099 {
1100         die_sou_create(dw, die, off, tdp, UNION, "union");
1101 }
1102 
1103 /*ARGSUSED1*/
1104 static int
1105 die_sou_resolve(tdesc_t *tdp, tdesc_t **tdpp, void *private)
1106 {
1107         dwarf_t *dw = private;
1108         mlist_t *ml;
1109         tdesc_t *mt;
1110 
1111         if (tdp->t_flags & TDESC_F_RESOLVED)
1112                 return (1);
1113 
1114         debug(3, "resolving sou %s\n", tdesc_name(tdp));
1115 
1116         for (ml = tdp->t_members; ml != NULL; ml = ml->ml_next) {
1117                 if (ml->ml_size == 0) {
1118                         mt = tdesc_basetype(ml->ml_type);
1119 
1120                         if ((ml->ml_size = tdesc_bitsize(mt)) != 0)
1121                                 continue;
1122 
1123                         /*
1124                          * For empty members, or GCC/C99 flexible array
1125                          * members, a size of 0 is correct.
1126                          */
1127                         if (mt->t_members == NULL)
1128                                 continue;
1129                         if (mt->t_type == ARRAY && mt->t_ardef->ad_nelems == 0)
1130                                 continue;
1131 
1132                         dw->dw_nunres++;
1133                         return (1);
1134                 }
1135 
1136                 if ((mt = tdesc_basetype(ml->ml_type)) == NULL) {
1137                         dw->dw_nunres++;
1138                         return (1);
1139                 }
1140 
1141                 if (ml->ml_size != 0 && mt->t_type == INTRINSIC &&
1142                     mt->t_intr->intr_nbits != ml->ml_size) {
1143                         /*
1144                          * This member is a bitfield, and needs to reference
1145                          * an intrinsic type with the same width.  If the
1146                          * currently-referenced type isn't of the same width,
1147                          * we'll copy it, adjusting the width of the copy to
1148                          * the size we'd like.
1149                          */
1150                         debug(3, "tdp %u: creating bitfield for %d bits\n",
1151                             tdp->t_id, ml->ml_size);
1152 
1153                         ml->ml_type = tdesc_intr_clone(dw, mt, ml->ml_size);
1154                 }
1155         }
1156 
1157         tdp->t_flags |= TDESC_F_RESOLVED;
1158 
1159         return (1);
1160 }
1161 
1162 /*ARGSUSED1*/
1163 static int
1164 die_sou_failed(tdesc_t *tdp, tdesc_t **tdpp, void *private)
1165 {
1166         const char *typename = (tdp->t_type == STRUCT ? "struct" : "union");
1167         mlist_t *ml;
1168 
1169         if (tdp->t_flags & TDESC_F_RESOLVED)
1170                 return (1);
1171 
1172         for (ml = tdp->t_members; ml != NULL; ml = ml->ml_next) {
1173                 if (ml->ml_size == 0) {
1174                         fprintf(stderr, "%s %d: failed to size member \"%s\" "
1175                             "of type %s (%d)\n", typename, tdp->t_id,
1176                             ml->ml_name, tdesc_name(ml->ml_type),
1177                             ml->ml_type->t_id);
1178                 }
1179         }
1180 
1181         return (1);
1182 }
1183 
1184 static void
1185 die_funcptr_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp)
1186 {
1187         Dwarf_Attribute attr;
1188         Dwarf_Half tag;
1189         Dwarf_Die arg;
1190         fndef_t *fn;
1191         int i;
1192 
1193         debug(3, "die %llu: creating function pointer\n", off);
1194 
1195         /*
1196          * We'll begin by processing any type definition nodes that may be
1197          * lurking underneath this one.
1198          */
1199         for (arg = die_child(dw, die); arg != NULL;
1200             arg = die_sibling(dw, arg)) {
1201                 if ((tag = die_tag(dw, arg)) != DW_TAG_formal_parameter &&
1202                     tag != DW_TAG_unspecified_parameters) {
1203                         /* Nested type declaration */
1204                         die_create_one(dw, arg);
1205                 }
1206         }
1207 
1208         if (die_isdecl(dw, die)) {
1209                 /*
1210                  * This is a prototype.  We don't add prototypes to the
1211                  * tree, so we're going to drop the tdesc.  Unfortunately,
1212                  * it has already been added to the tree.  Nobody will reference
1213                  * it, though, and it will be leaked.
1214                  */
1215                 return;
1216         }
1217 
1218         fn = xcalloc(sizeof (fndef_t));
1219 
1220         tdp->t_type = FUNCTION;
1221 
1222         if ((attr = die_attr(dw, die, DW_AT_type, 0)) != NULL) {
1223                 dwarf_dealloc(dw->dw_dw, attr, DW_DLA_ATTR);
1224                 fn->fn_ret = die_lookup_pass1(dw, die, DW_AT_type);
1225         } else {
1226                 fn->fn_ret = tdesc_intr_void(dw);
1227         }
1228 
1229         /*
1230          * Count the arguments to the function, then read them in.
1231          */
1232         for (fn->fn_nargs = 0, arg = die_child(dw, die); arg != NULL;
1233             arg = die_sibling(dw, arg)) {
1234                 if ((tag = die_tag(dw, arg)) == DW_TAG_formal_parameter)
1235                         fn->fn_nargs++;
1236                 else if (tag == DW_TAG_unspecified_parameters &&
1237                     fn->fn_nargs > 0)
1238                         fn->fn_vargs = 1;
1239         }
1240 
1241         if (fn->fn_nargs != 0) {
1242                 debug(3, "die %llu: adding %d argument%s\n", off, fn->fn_nargs,
1243                     (fn->fn_nargs > 1 ? "s" : ""));
1244 
1245                 fn->fn_args = xcalloc(sizeof (tdesc_t *) * fn->fn_nargs);
1246                 for (i = 0, arg = die_child(dw, die);
1247                     arg != NULL && i < fn->fn_nargs;
1248                     arg = die_sibling(dw, arg)) {
1249                         if (die_tag(dw, arg) != DW_TAG_formal_parameter)
1250                                 continue;
1251 
1252                         fn->fn_args[i++] = die_lookup_pass1(dw, arg,
1253                             DW_AT_type);
1254                 }
1255         }
1256 
1257         tdp->t_fndef = fn;
1258         tdp->t_flags |= TDESC_F_RESOLVED;
1259 }
1260 
1261 /*
1262  * GCC and DevPro use different names for the base types.  While the terms are
1263  * the same, they are arranged in a different order.  Some terms, such as int,
1264  * are implied in one, and explicitly named in the other.  Given a base type
1265  * as input, this routine will return a common name, along with an intr_t
1266  * that reflects said name.
1267  */
1268 static intr_t *
1269 die_base_name_parse(const char *name, char **newp)
1270 {
1271         char buf[100];
1272         char *base, *c;
1273         int nlong = 0, nshort = 0, nchar = 0, nint = 0;
1274         int sign = 1;
1275         char fmt = '\0';
1276         intr_t *intr;
1277 
1278         if (strlen(name) > sizeof (buf) - 1)
1279                 terminate("base type name \"%s\" is too long\n", name);
1280 
1281         strncpy(buf, name, sizeof (buf));
1282 
1283         for (c = strtok(buf, " "); c != NULL; c = strtok(NULL, " ")) {
1284                 if (strcmp(c, "signed") == 0)
1285                         sign = 1;
1286                 else if (strcmp(c, "unsigned") == 0)
1287                         sign = 0;
1288                 else if (strcmp(c, "long") == 0)
1289                         nlong++;
1290                 else if (strcmp(c, "char") == 0) {
1291                         nchar++;
1292                         fmt = 'c';
1293                 } else if (strcmp(c, "short") == 0)
1294                         nshort++;
1295                 else if (strcmp(c, "int") == 0)
1296                         nint++;
1297                 else {
1298                         /*
1299                          * If we don't recognize any of the tokens, we'll tell
1300                          * the caller to fall back to the dwarf-provided
1301                          * encoding information.
1302                          */
1303                         return (NULL);
1304                 }
1305         }
1306 
1307         if (nchar > 1 || nshort > 1 || nint > 1 || nlong > 2)
1308                 return (NULL);
1309 
1310         if (nchar > 0) {
1311                 if (nlong > 0 || nshort > 0 || nint > 0)
1312                         return (NULL);
1313 
1314                 base = "char";
1315 
1316         } else if (nshort > 0) {
1317                 if (nlong > 0)
1318                         return (NULL);
1319 
1320                 base = "short";
1321 
1322         } else if (nlong > 0) {
1323                 base = "long";
1324 
1325         } else {
1326                 base = "int";
1327         }
1328 
1329         intr = xcalloc(sizeof (intr_t));
1330         intr->intr_type = INTR_INT;
1331         intr->intr_signed = sign;
1332         intr->intr_iformat = fmt;
1333 
1334         snprintf(buf, sizeof (buf), "%s%s%s",
1335             (sign ? "" : "unsigned "),
1336             (nlong > 1 ? "long " : ""),
1337             base);
1338 
1339         *newp = xstrdup(buf);
1340         return (intr);
1341 }
1342 
1343 typedef struct fp_size_map {
1344         size_t fsm_typesz[2];   /* size of {32,64} type */
1345         uint_t fsm_enc[3];      /* CTF_FP_* for {bare,cplx,imagry} type */
1346 } fp_size_map_t;
1347 
1348 static const fp_size_map_t fp_encodings[] = {
1349         { { 4, 4 }, { CTF_FP_SINGLE, CTF_FP_CPLX, CTF_FP_IMAGRY } },
1350         { { 8, 8 }, { CTF_FP_DOUBLE, CTF_FP_DCPLX, CTF_FP_DIMAGRY } },
1351 #ifdef __sparc
1352         { { 16, 16 }, { CTF_FP_LDOUBLE, CTF_FP_LDCPLX, CTF_FP_LDIMAGRY } },
1353 #else
1354         { { 12, 16 }, { CTF_FP_LDOUBLE, CTF_FP_LDCPLX, CTF_FP_LDIMAGRY } },
1355 #endif
1356         { { 0, 0 } }
1357 };
1358 
1359 static uint_t
1360 die_base_type2enc(dwarf_t *dw, Dwarf_Off off, Dwarf_Signed enc, size_t sz)
1361 {
1362         const fp_size_map_t *map = fp_encodings;
1363         uint_t szidx = dw->dw_ptrsz == sizeof (uint64_t);
1364         uint_t mult = 1, col = 0;
1365 
1366         if (enc == DW_ATE_complex_float) {
1367                 mult = 2;
1368                 col = 1;
1369         } else if (enc == DW_ATE_imaginary_float ||
1370             enc == DW_ATE_SUN_imaginary_float)
1371                 col = 2;
1372 
1373         while (map->fsm_typesz[szidx] != 0) {
1374                 if (map->fsm_typesz[szidx] * mult == sz)
1375                         return (map->fsm_enc[col]);
1376                 map++;
1377         }
1378 
1379         terminate("die %llu: unrecognized real type size %u\n", off, sz);
1380         /*NOTREACHED*/
1381         return (0);
1382 }
1383 
1384 static intr_t *
1385 die_base_from_dwarf(dwarf_t *dw, Dwarf_Die base, Dwarf_Off off, size_t sz)
1386 {
1387         intr_t *intr = xcalloc(sizeof (intr_t));
1388         Dwarf_Signed enc;
1389 
1390         (void) die_signed(dw, base, DW_AT_encoding, &enc, DW_ATTR_REQ);
1391 
1392         switch (enc) {
1393         case DW_ATE_unsigned:
1394         case DW_ATE_address:
1395                 intr->intr_type = INTR_INT;
1396                 break;
1397         case DW_ATE_unsigned_char:
1398                 intr->intr_type = INTR_INT;
1399                 intr->intr_iformat = 'c';
1400                 break;
1401         case DW_ATE_signed:
1402                 intr->intr_type = INTR_INT;
1403                 intr->intr_signed = 1;
1404                 break;
1405         case DW_ATE_signed_char:
1406                 intr->intr_type = INTR_INT;
1407                 intr->intr_signed = 1;
1408                 intr->intr_iformat = 'c';
1409                 break;
1410         case DW_ATE_boolean:
1411                 intr->intr_type = INTR_INT;
1412                 intr->intr_signed = 1;
1413                 intr->intr_iformat = 'b';
1414                 break;
1415         case DW_ATE_float:
1416         case DW_ATE_complex_float:
1417         case DW_ATE_imaginary_float:
1418         case DW_ATE_SUN_imaginary_float:
1419         case DW_ATE_SUN_interval_float:
1420                 intr->intr_type = INTR_REAL;
1421                 intr->intr_signed = 1;
1422                 intr->intr_fformat = die_base_type2enc(dw, off, enc, sz);
1423                 break;
1424         default:
1425                 terminate("die %llu: unknown base type encoding 0x%llx\n",
1426                     off, enc);
1427         }
1428 
1429         return (intr);
1430 }
1431 
1432 static void
1433 die_base_create(dwarf_t *dw, Dwarf_Die base, Dwarf_Off off, tdesc_t *tdp)
1434 {
1435         Dwarf_Unsigned sz;
1436         intr_t *intr;
1437         char *new;
1438 
1439         debug(3, "die %llu: creating base type\n", off);
1440 
1441         /*
1442          * The compilers have their own clever (internally inconsistent) ideas
1443          * as to what base types should look like.  Some times gcc will, for
1444          * example, use DW_ATE_signed_char for char.  Other times, however, it
1445          * will use DW_ATE_signed.  Needless to say, this causes some problems
1446          * down the road, particularly with merging.  We do, however, use the
1447          * DWARF idea of type sizes, as this allows us to avoid caring about
1448          * the data model.
1449          */
1450         (void) die_unsigned(dw, base, DW_AT_byte_size, &sz, DW_ATTR_REQ);
1451 
1452         if (tdp->t_name == NULL)
1453                 terminate("die %llu: base type without name\n", off);
1454 
1455         /* XXX make a name parser for float too */
1456         if ((intr = die_base_name_parse(tdp->t_name, &new)) != NULL) {
1457                 /* Found it.  We'll use the parsed version */
1458                 debug(3, "die %llu: name \"%s\" remapped to \"%s\"\n", off,
1459                     tdesc_name(tdp), new);
1460 
1461                 free(tdp->t_name);
1462                 tdp->t_name = new;
1463         } else {
1464                 /*
1465                  * We didn't recognize the type, so we'll create an intr_t
1466                  * based on the DWARF data.
1467                  */
1468                 debug(3, "die %llu: using dwarf data for base \"%s\"\n", off,
1469                     tdesc_name(tdp));
1470 
1471                 intr = die_base_from_dwarf(dw, base, off, sz);
1472         }
1473 
1474         intr->intr_nbits = sz * 8;
1475 
1476         tdp->t_type = INTRINSIC;
1477         tdp->t_intr = intr;
1478         tdp->t_size = sz;
1479 
1480         tdp->t_flags |= TDESC_F_RESOLVED;
1481 }
1482 
1483 static void
1484 die_through_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp,
1485     int type, const char *typename)
1486 {
1487         Dwarf_Attribute attr;
1488 
1489         debug(3, "die %llu: creating %s\n", off, typename);
1490 
1491         tdp->t_type = type;
1492 
1493         if ((attr = die_attr(dw, die, DW_AT_type, 0)) != NULL) {
1494                 dwarf_dealloc(dw->dw_dw, attr, DW_DLA_ATTR);
1495                 tdp->t_tdesc = die_lookup_pass1(dw, die, DW_AT_type);
1496         } else {
1497                 tdp->t_tdesc = tdesc_intr_void(dw);
1498         }
1499 
1500         if (type == POINTER)
1501                 tdp->t_size = dw->dw_ptrsz;
1502 
1503         tdp->t_flags |= TDESC_F_RESOLVED;
1504 
1505         if (type == TYPEDEF) {
1506                 iidesc_t *ii = xcalloc(sizeof (iidesc_t));
1507                 ii->ii_type = II_TYPE;
1508                 ii->ii_name = xstrdup(tdp->t_name);
1509                 ii->ii_dtype = tdp;
1510 
1511                 iidesc_add(dw->dw_td->td_iihash, ii);
1512         }
1513 }
1514 
1515 static void
1516 die_typedef_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp)
1517 {
1518         die_through_create(dw, die, off, tdp, TYPEDEF, "typedef");
1519 }
1520 
1521 static void
1522 die_const_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp)
1523 {
1524         die_through_create(dw, die, off, tdp, CONST, "const");
1525 }
1526 
1527 static void
1528 die_pointer_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp)
1529 {
1530         die_through_create(dw, die, off, tdp, POINTER, "pointer");
1531 }
1532 
1533 static void
1534 die_restrict_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp)
1535 {
1536         die_through_create(dw, die, off, tdp, RESTRICT, "restrict");
1537 }
1538 
1539 static void
1540 die_volatile_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp)
1541 {
1542         die_through_create(dw, die, off, tdp, VOLATILE, "volatile");
1543 }
1544 
1545 /*ARGSUSED3*/
1546 static void
1547 die_function_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp)
1548 {
1549         Dwarf_Die arg;
1550         Dwarf_Half tag;
1551         iidesc_t *ii;
1552         char *name;
1553 
1554         debug(3, "die %llu: creating function definition\n", off);
1555 
1556         /*
1557          * We'll begin by processing any type definition nodes that may be
1558          * lurking underneath this one.
1559          */
1560         for (arg = die_child(dw, die); arg != NULL;
1561             arg = die_sibling(dw, arg)) {
1562                 if ((tag = die_tag(dw, arg)) != DW_TAG_formal_parameter &&
1563                     tag != DW_TAG_variable) {
1564                         /* Nested type declaration */
1565                         die_create_one(dw, arg);
1566                 }
1567         }
1568 
1569         if (die_isdecl(dw, die) || (name = die_name(dw, die)) == NULL) {
1570                 /*
1571                  * We process neither prototypes nor subprograms without
1572                  * names.
1573                  */
1574                 return;
1575         }
1576 
1577         ii = xcalloc(sizeof (iidesc_t));
1578         ii->ii_type = die_isglobal(dw, die) ? II_GFUN : II_SFUN;
1579         ii->ii_name = name;
1580         if (ii->ii_type == II_SFUN)
1581                 ii->ii_owner = xstrdup(dw->dw_cuname);
1582 
1583         debug(3, "die %llu: function %s is %s\n", off, ii->ii_name,
1584             (ii->ii_type == II_GFUN ? "global" : "static"));
1585 
1586         if (die_attr(dw, die, DW_AT_type, 0) != NULL)
1587                 ii->ii_dtype = die_lookup_pass1(dw, die, DW_AT_type);
1588         else
1589                 ii->ii_dtype = tdesc_intr_void(dw);
1590 
1591         for (arg = die_child(dw, die); arg != NULL;
1592             arg = die_sibling(dw, arg)) {
1593                 char *name;
1594 
1595                 debug(3, "die %llu: looking at sub member at %llu\n",
1596                     off, die_off(dw, die));
1597 
1598                 if (die_tag(dw, arg) != DW_TAG_formal_parameter)
1599                         continue;
1600 
1601                 if ((name = die_name(dw, arg)) == NULL) {
1602                         terminate("die %llu: func arg %d has no name\n",
1603                             off, ii->ii_nargs + 1);
1604                 }
1605 
1606                 if (strcmp(name, "...") == 0) {
1607                         free(name);
1608                         ii->ii_vargs = 1;
1609                         continue;
1610                 }
1611 
1612                 ii->ii_nargs++;
1613         }
1614 
1615         if (ii->ii_nargs > 0) {
1616                 int i;
1617 
1618                 debug(3, "die %llu: function has %d argument%s\n", off,
1619                     ii->ii_nargs, (ii->ii_nargs == 1 ? "" : "s"));
1620 
1621                 ii->ii_args = xcalloc(sizeof (tdesc_t) * ii->ii_nargs);
1622 
1623                 for (arg = die_child(dw, die), i = 0;
1624                     arg != NULL && i < ii->ii_nargs;
1625                     arg = die_sibling(dw, arg)) {
1626                         if (die_tag(dw, arg) != DW_TAG_formal_parameter)
1627                                 continue;
1628 
1629                         ii->ii_args[i++] = die_lookup_pass1(dw, arg,
1630                             DW_AT_type);
1631                 }
1632         }
1633 
1634         iidesc_add(dw->dw_td->td_iihash, ii);
1635 }
1636 
1637 /*ARGSUSED3*/
1638 static void
1639 die_variable_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp)
1640 {
1641         iidesc_t *ii;
1642         char *name;
1643 
1644         debug(3, "die %llu: creating object definition\n", off);
1645 
1646         if (die_isdecl(dw, die) || (name = die_name(dw, die)) == NULL)
1647                 return; /* skip prototypes and nameless objects */
1648 
1649         ii = xcalloc(sizeof (iidesc_t));
1650         ii->ii_type = die_isglobal(dw, die) ? II_GVAR : II_SVAR;
1651         ii->ii_name = name;
1652         ii->ii_dtype = die_lookup_pass1(dw, die, DW_AT_type);
1653         if (ii->ii_type == II_SVAR)
1654                 ii->ii_owner = xstrdup(dw->dw_cuname);
1655 
1656         iidesc_add(dw->dw_td->td_iihash, ii);
1657 }
1658 
1659 /*ARGSUSED2*/
1660 static int
1661 die_fwd_resolve(tdesc_t *fwd, tdesc_t **fwdp, void *private)
1662 {
1663         if (fwd->t_flags & TDESC_F_RESOLVED)
1664                 return (1);
1665 
1666         if (fwd->t_tdesc != NULL) {
1667                 debug(3, "tdp %u: unforwarded %s\n", fwd->t_id,
1668                     tdesc_name(fwd));
1669                 *fwdp = fwd->t_tdesc;
1670         }
1671 
1672         fwd->t_flags |= TDESC_F_RESOLVED;
1673 
1674         return (1);
1675 }
1676 
1677 /*ARGSUSED*/
1678 static void
1679 die_lexblk_descend(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp)
1680 {
1681         Dwarf_Die child = die_child(dw, die);
1682 
1683         if (child != NULL)
1684                 die_create(dw, child);
1685 }
1686 
1687 /*
1688  * Used to map the die to a routine which can parse it, using the tag to do the
1689  * mapping.  While the processing of most tags entails the creation of a tdesc,
1690  * there are a few which don't - primarily those which result in the creation of
1691  * iidescs which refer to existing tdescs.
1692  */
1693 
1694 #define DW_F_NOTDP      0x1     /* Don't create a tdesc for the creator */
1695 
1696 typedef struct die_creator {
1697         Dwarf_Half dc_tag;
1698         uint16_t dc_flags;
1699         void (*dc_create)(dwarf_t *, Dwarf_Die, Dwarf_Off, tdesc_t *);
1700 } die_creator_t;
1701 
1702 static const die_creator_t die_creators[] = {
1703         { DW_TAG_array_type,            0,              die_array_create },
1704         { DW_TAG_enumeration_type,      0,              die_enum_create },
1705         { DW_TAG_lexical_block,         DW_F_NOTDP,     die_lexblk_descend },
1706         { DW_TAG_pointer_type,          0,              die_pointer_create },
1707         { DW_TAG_structure_type,        0,              die_struct_create },
1708         { DW_TAG_subroutine_type,       0,              die_funcptr_create },
1709         { DW_TAG_typedef,               0,              die_typedef_create },
1710         { DW_TAG_union_type,            0,              die_union_create },
1711         { DW_TAG_base_type,             0,              die_base_create },
1712         { DW_TAG_const_type,            0,              die_const_create },
1713         { DW_TAG_subprogram,            DW_F_NOTDP,     die_function_create },
1714         { DW_TAG_variable,              DW_F_NOTDP,     die_variable_create },
1715         { DW_TAG_volatile_type,         0,              die_volatile_create },
1716         { DW_TAG_restrict_type,         0,              die_restrict_create },
1717         { 0, 0, NULL }
1718 };
1719 
1720 static const die_creator_t *
1721 die_tag2ctor(Dwarf_Half tag)
1722 {
1723         const die_creator_t *dc;
1724 
1725         for (dc = die_creators; dc->dc_create != NULL; dc++) {
1726                 if (dc->dc_tag == tag)
1727                         return (dc);
1728         }
1729 
1730         return (NULL);
1731 }
1732 
1733 static void
1734 die_create_one(dwarf_t *dw, Dwarf_Die die)
1735 {
1736         Dwarf_Off off = die_off(dw, die);
1737         const die_creator_t *dc;
1738         Dwarf_Half tag;
1739         tdesc_t *tdp;
1740 
1741         debug(3, "die %llu: create_one\n", off);
1742 
1743         if (off > dw->dw_maxoff) {
1744                 terminate("illegal die offset %llu (max %llu)\n", off,
1745                     dw->dw_maxoff);
1746         }
1747 
1748         tag = die_tag(dw, die);
1749 
1750         if ((dc = die_tag2ctor(tag)) == NULL) {
1751                 debug(2, "die %llu: ignoring tag type %x\n", off, tag);
1752                 return;
1753         }
1754 
1755         if ((tdp = tdesc_lookup(dw, off)) == NULL &&
1756             !(dc->dc_flags & DW_F_NOTDP)) {
1757                 tdp = xcalloc(sizeof (tdesc_t));
1758                 tdp->t_id = off;
1759                 tdesc_add(dw, tdp);
1760         }
1761 
1762         if (tdp != NULL)
1763                 tdp->t_name = die_name(dw, die);
1764 
1765         dc->dc_create(dw, die, off, tdp);
1766 }
1767 
1768 static void
1769 die_create(dwarf_t *dw, Dwarf_Die die)
1770 {
1771         do {
1772                 die_create_one(dw, die);
1773         } while ((die = die_sibling(dw, die)) != NULL);
1774 }
1775 
1776 static tdtrav_cb_f die_resolvers[] = {
1777         NULL,
1778         NULL,                   /* intrinsic */
1779         NULL,                   /* pointer */
1780         die_array_resolve,      /* array */
1781         NULL,                   /* function */
1782         die_sou_resolve,        /* struct */
1783         die_sou_resolve,        /* union */
1784         die_enum_resolve,       /* enum */
1785         die_fwd_resolve,        /* forward */
1786         NULL,                   /* typedef */
1787         NULL,                   /* typedef unres */
1788         NULL,                   /* volatile */
1789         NULL,                   /* const */
1790         NULL,                   /* restrict */
1791 };
1792 
1793 static tdtrav_cb_f die_fail_reporters[] = {
1794         NULL,
1795         NULL,                   /* intrinsic */
1796         NULL,                   /* pointer */
1797         die_array_failed,       /* array */
1798         NULL,                   /* function */
1799         die_sou_failed,         /* struct */
1800         die_sou_failed,         /* union */
1801         NULL,                   /* enum */
1802         NULL,                   /* forward */
1803         NULL,                   /* typedef */
1804         NULL,                   /* typedef unres */
1805         NULL,                   /* volatile */
1806         NULL,                   /* const */
1807         NULL,                   /* restrict */
1808 };
1809 
1810 static void
1811 die_resolve(dwarf_t *dw)
1812 {
1813         int last = -1;
1814         int pass = 0;
1815 
1816         do {
1817                 pass++;
1818                 dw->dw_nunres = 0;
1819 
1820                 (void) iitraverse_hash(dw->dw_td->td_iihash,
1821                     &dw->dw_td->td_curvgen, NULL, NULL, die_resolvers, dw);
1822 
1823                 debug(3, "resolve: pass %d, %u left\n", pass, dw->dw_nunres);
1824 
1825                 if (dw->dw_nunres == last) {
1826                         fprintf(stderr, "%s: failed to resolve the following "
1827                             "types:\n", progname);
1828 
1829                         (void) iitraverse_hash(dw->dw_td->td_iihash,
1830                             &dw->dw_td->td_curvgen, NULL, NULL,
1831                             die_fail_reporters, dw);
1832 
1833                         terminate("failed to resolve types\n");
1834                 }
1835 
1836                 last = dw->dw_nunres;
1837 
1838         } while (dw->dw_nunres != 0);
1839 }
1840 
1841 /*
1842  * Any object containing a function or object symbol at any scope should also
1843  * contain DWARF data.
1844  */
1845 static boolean_t
1846 should_have_dwarf(Elf *elf)
1847 {
1848         Elf_Scn *scn = NULL;
1849         Elf_Data *data = NULL;
1850         GElf_Shdr shdr;
1851         GElf_Sym sym;
1852         uint32_t symdx = 0;
1853         size_t nsyms = 0;
1854         boolean_t found = B_FALSE;
1855 
1856         while ((scn = elf_nextscn(elf, scn)) != NULL) {
1857                 gelf_getshdr(scn, &shdr);
1858 
1859                 if (shdr.sh_type == SHT_SYMTAB) {
1860                         found = B_TRUE;
1861                         break;
1862                 }
1863         }
1864 
1865         if (!found)
1866                 terminate("cannot convert stripped objects\n");
1867 
1868         data = elf_getdata(scn, NULL);
1869         nsyms = shdr.sh_size / shdr.sh_entsize;
1870 
1871         for (symdx = 0; symdx < nsyms; symdx++) {
1872                 gelf_getsym(data, symdx, &sym);
1873 
1874                 if ((GELF_ST_TYPE(sym.st_info) == STT_FUNC) ||
1875                     (GELF_ST_TYPE(sym.st_info) == STT_TLS) ||
1876                     (GELF_ST_TYPE(sym.st_info) == STT_OBJECT)) {
1877                         char *name;
1878 
1879                         name = elf_strptr(elf, shdr.sh_link, sym.st_name);
1880 
1881                         /* Studio emits these local symbols regardless */
1882                         if ((strcmp(name, "Bbss.bss") != 0) &&
1883                             (strcmp(name, "Ttbss.bss") != 0) &&
1884                             (strcmp(name, "Ddata.data") != 0) &&
1885                             (strcmp(name, "Ttdata.data") != 0) &&
1886                             (strcmp(name, "Drodata.rodata") != 0))
1887                                 return (B_TRUE);
1888                 }
1889         }
1890 
1891         return (B_FALSE);
1892 }
1893 
1894 /*ARGSUSED*/
1895 int
1896 dw_read(tdata_t *td, Elf *elf, const char *filename)
1897 {
1898         Dwarf_Unsigned abboff, hdrlen, nxthdr;
1899         Dwarf_Half vers, addrsz;
1900         Dwarf_Die cu, child;
1901         dwarf_t dw;
1902         char *prod = NULL;
1903         int rc;
1904 
1905         bzero(&dw, sizeof (dwarf_t));
1906         dw.dw_td = td;
1907         dw.dw_ptrsz = elf_ptrsz(elf);
1908         dw.dw_mfgtid_last = TID_MFGTID_BASE;
1909         dw.dw_tidhash = hash_new(TDESC_HASH_BUCKETS, tdesc_idhash, tdesc_idcmp);
1910         dw.dw_fwdhash = hash_new(TDESC_HASH_BUCKETS, tdesc_namehash,
1911             tdesc_namecmp);
1912         dw.dw_enumhash = hash_new(TDESC_HASH_BUCKETS, tdesc_namehash,
1913             tdesc_namecmp);
1914 
1915         if ((rc = dwarf_elf_init(elf, DW_DLC_READ, NULL, NULL, &dw.dw_dw,
1916             &dw.dw_err)) == DW_DLV_NO_ENTRY) {
1917                 if (should_have_dwarf(elf)) {
1918                         errno = ENOENT;
1919                         return (-1);
1920                 } else {
1921                         return (0);
1922                 }
1923         } else if (rc != DW_DLV_OK) {
1924                 if (dwarf_errno(dw.dw_err) == DW_DLE_DEBUG_INFO_NULL) {
1925                         /*
1926                          * There's no type data in the DWARF section, but
1927                          * libdwarf is too clever to handle that properly.
1928                          */
1929                         return (0);
1930                 }
1931 
1932                 terminate("failed to initialize DWARF: %s\n",
1933                     dwarf_errmsg(dw.dw_err));
1934         }
1935 
1936         if ((rc = dwarf_next_cu_header(dw.dw_dw, &hdrlen, &vers, &abboff,
1937             &addrsz, &nxthdr, &dw.dw_err)) != DW_DLV_OK)
1938                 terminate("file does not contain valid DWARF data: %s\n",
1939                     dwarf_errmsg(dw.dw_err));
1940 
1941         /*
1942          * Some compilers emit no DWARF for empty files, others emit an empty
1943          * compilation unit.
1944          */
1945         if ((cu = die_sibling(&dw, NULL)) == NULL ||
1946             ((child = die_child(&dw, cu)) == NULL) &&
1947             should_have_dwarf(elf)) {
1948                 terminate("file does not contain dwarf type data "
1949                     "(try compiling with -g)\n");
1950         } else if (child == NULL) {
1951                 return (0);
1952         }
1953 
1954         dw.dw_maxoff = nxthdr - 1;
1955 
1956         if (dw.dw_maxoff > TID_FILEMAX)
1957                 terminate("file contains too many types\n");
1958 
1959         debug(1, "DWARF version: %d\n", vers);
1960         if (vers != DWARF_VERSION) {
1961                 terminate("file contains incompatible version %d DWARF code "
1962                     "(version 2 required)\n", vers);
1963         }
1964 
1965         if (die_string(&dw, cu, DW_AT_producer, &prod, 0)) {
1966                 debug(1, "DWARF emitter: %s\n", prod);
1967                 free(prod);
1968         }
1969 
1970         if ((dw.dw_cuname = die_name(&dw, cu)) != NULL) {
1971                 char *base = xstrdup(basename(dw.dw_cuname));
1972                 free(dw.dw_cuname);
1973                 dw.dw_cuname = base;
1974 
1975                 debug(1, "CU name: %s\n", dw.dw_cuname);
1976         }
1977 
1978         die_create(&dw, child);
1979 
1980         if ((rc = dwarf_next_cu_header(dw.dw_dw, &hdrlen, &vers, &abboff,
1981             &addrsz, &nxthdr, &dw.dw_err)) != DW_DLV_NO_ENTRY)
1982                 terminate("multiple compilation units not supported\n");
1983 
1984         (void) dwarf_finish(dw.dw_dw, &dw.dw_err);
1985 
1986         die_resolve(&dw);
1987 
1988         cvt_fixups(td, dw.dw_ptrsz);
1989 
1990         /* leak the dwarf_t */
1991 
1992         return (0);
1993 }