cddl/contrib/opensolaris/tools/ctf/cvt/dwarf.c

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