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