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 124 typedef 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 140 static void die_create_one(dwarf_t *, Dwarf_Die); 141 static void die_create(dwarf_t *, Dwarf_Die); 142 143 static tid_t 144 mfgtid_next(dwarf_t *dw) 145 { 146 return (++dw->dw_mfgtid_last); 147 } 148 149 static void 150 tdesc_add(dwarf_t *dw, tdesc_t *tdp) 151 { 152 hash_add(dw->dw_tidhash, tdp); 153 } 154 155 static tdesc_t * 156 tdesc_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 */ 173 static size_t 174 tdesc_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 207 static size_t 208 tdesc_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 243 static tdesc_t * 244 tdesc_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 262 static Dwarf_Off 263 die_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 276 static Dwarf_Die 277 die_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 294 static Dwarf_Die 295 die_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 311 static Dwarf_Half 312 die_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 325 static Dwarf_Attribute 326 die_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 348 static int 349 die_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 363 static int 364 die_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 378 static int 379 die_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 393 static int 394 die_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 412 static Dwarf_Off 413 die_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 425 static char * 426 die_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 437 static int 438 die_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 445 static int 446 die_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 461 static tdesc_t * 462 die_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 473 static tdesc_t * 474 die_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 485 static int 486 die_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 562 static tdesc_t * 563 tdesc_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 */ 595 static tdesc_t * 596 tdesc_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 604 static tdesc_t * 605 tdesc_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 */ 620 static tdesc_t * 621 tdesc_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 645 static void 646 tdesc_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 687 ar->ad_nelems = 0; 688 689 /* 690 * Different compilers use different index types. Force the type to be 691 * a common, known value (long). 692 */ 693 ar->ad_idxtype = tdesc_intr_long(dw); 694 ar->ad_contents = ctdp; 695 696 if (ar->ad_contents->t_size != 0) { 697 dimtdp->t_size = ar->ad_contents->t_size * ar->ad_nelems; 698 dimtdp->t_flags |= TDESC_F_RESOLVED; 699 } 700 } 701 702 /* 703 * Create a tdesc from an array node. Some arrays will come with byte size 704 * attributes, and thus can be resolved immediately. Others don't, and will 705 * need to wait until the second pass for resolution. 706 */ 707 static void 708 die_array_create(dwarf_t *dw, Dwarf_Die arr, Dwarf_Off off, tdesc_t *tdp) 709 { 710 tdesc_t *arrtdp = die_lookup_pass1(dw, arr, DW_AT_type); 711 Dwarf_Unsigned uval; 712 Dwarf_Die dim; 713 714 debug(3, "die %llu <%llx>: creating array\n", off, off); 715 716 if ((dim = die_child(dw, arr)) == NULL || 717 die_tag(dw, dim) != DW_TAG_subrange_type) 718 terminate("die %llu: failed to retrieve array bounds\n", off); 719 720 tdesc_array_create(dw, dim, arrtdp, tdp); 721 722 if (die_unsigned(dw, arr, DW_AT_byte_size, &uval, 0)) { 723 tdesc_t *dimtdp; 724 int flags; 725 726 /* Check for bogus gcc DW_AT_byte_size attribute */ 727 if (uval == (unsigned)-1) { 728 printf("dwarf.c:%s() working around bogus -1 DW_AT_byte_size\n", 729 __func__); 730 uval = 0; 731 } 732 733 tdp->t_size = uval; 734 735 /* 736 * Ensure that sub-dimensions have sizes too before marking 737 * as resolved. 738 */ 739 flags = TDESC_F_RESOLVED; 740 for (dimtdp = tdp->t_ardef->ad_contents; 741 dimtdp->t_type == ARRAY; 742 dimtdp = dimtdp->t_ardef->ad_contents) { 743 if (!(dimtdp->t_flags & TDESC_F_RESOLVED)) { 744 flags = 0; 745 break; 746 } 747 } 748 749 tdp->t_flags |= flags; 750 } 751 752 debug(3, "die %llu <%llx>: array nelems %u size %u\n", off, off, 753 tdp->t_ardef->ad_nelems, tdp->t_size); 754 } 755 756 /*ARGSUSED1*/ 757 static int 758 die_array_resolve(tdesc_t *tdp, tdesc_t **tdpp __unused, void *private) 759 { 760 dwarf_t *dw = private; 761 size_t sz; 762 763 if (tdp->t_flags & TDESC_F_RESOLVED) 764 return (1); 765 766 debug(3, "trying to resolve array %d (cont %d)\n", tdp->t_id, 767 tdp->t_ardef->ad_contents->t_id); 768 769 if ((sz = tdesc_size(tdp->t_ardef->ad_contents)) == 0) { 770 debug(3, "unable to resolve array %s (%d) contents %d\n", 771 tdesc_name(tdp), tdp->t_id, 772 tdp->t_ardef->ad_contents->t_id); 773 774 dw->dw_nunres++; 775 return (1); 776 } 777 778 tdp->t_size = sz * tdp->t_ardef->ad_nelems; 779 tdp->t_flags |= TDESC_F_RESOLVED; 780 781 debug(3, "resolved array %d: %u bytes\n", tdp->t_id, tdp->t_size); 782 783 return (1); 784 } 785 786 /*ARGSUSED1*/ 787 static int 788 die_array_failed(tdesc_t *tdp, tdesc_t **tdpp __unused, void *private __unused) 789 { 790 tdesc_t *cont = tdp->t_ardef->ad_contents; 791 792 if (tdp->t_flags & TDESC_F_RESOLVED) 793 return (1); 794 795 fprintf(stderr, "Array %d: failed to size contents type %s (%d)\n", 796 tdp->t_id, tdesc_name(cont), cont->t_id); 797 798 return (1); 799 } 800 801 /* 802 * Most enums (those with members) will be resolved during this first pass. 803 * Others - those without members (see the file comment) - won't be, and will 804 * need to wait until the second pass when they can be matched with their full 805 * definitions. 806 */ 807 static void 808 die_enum_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp) 809 { 810 Dwarf_Die mem; 811 Dwarf_Unsigned uval; 812 Dwarf_Signed sval; 813 814 debug(3, "die %llu: creating enum\n", off); 815 816 tdp->t_type = ENUM; 817 818 (void) die_unsigned(dw, die, DW_AT_byte_size, &uval, DW_ATTR_REQ); 819 /* Check for bogus gcc DW_AT_byte_size attribute */ 820 if (uval == (unsigned)-1) { 821 printf("dwarf.c:%s() working around bogus -1 DW_AT_byte_size\n", 822 __func__); 823 uval = 0; 824 } 825 tdp->t_size = uval; 826 827 if ((mem = die_child(dw, die)) != NULL) { 828 elist_t **elastp = &tdp->t_emem; 829 830 do { 831 elist_t *el; 832 833 if (die_tag(dw, mem) != DW_TAG_enumerator) { 834 /* Nested type declaration */ 835 die_create_one(dw, mem); 836 continue; 837 } 838 839 el = xcalloc(sizeof (elist_t)); 840 el->el_name = die_name(dw, mem); 841 842 if (die_signed(dw, mem, DW_AT_const_value, &sval, 0)) { 843 el->el_number = sval; 844 } else if (die_unsigned(dw, mem, DW_AT_const_value, 845 &uval, 0)) { 846 el->el_number = uval; 847 } else { 848 terminate("die %llu: enum %llu: member without " 849 "value\n", off, die_off(dw, mem)); 850 } 851 852 debug(3, "die %llu: enum %llu: created %s = %d\n", off, 853 die_off(dw, mem), el->el_name, el->el_number); 854 855 *elastp = el; 856 elastp = &el->el_next; 857 858 } while ((mem = die_sibling(dw, mem)) != NULL); 859 860 hash_add(dw->dw_enumhash, tdp); 861 862 tdp->t_flags |= TDESC_F_RESOLVED; 863 864 if (tdp->t_name != NULL) { 865 iidesc_t *ii = xcalloc(sizeof (iidesc_t)); 866 ii->ii_type = II_SOU; 867 ii->ii_name = xstrdup(tdp->t_name); 868 ii->ii_dtype = tdp; 869 870 iidesc_add(dw->dw_td->td_iihash, ii); 871 } 872 } 873 } 874 875 static int 876 die_enum_match(void *arg1, void *arg2) 877 { 878 tdesc_t *tdp = arg1, **fullp = arg2; 879 880 if (tdp->t_emem != NULL) { 881 *fullp = tdp; 882 return (-1); /* stop the iteration */ 883 } 884 885 return (0); 886 } 887 888 /*ARGSUSED1*/ 889 static int 890 die_enum_resolve(tdesc_t *tdp, tdesc_t **tdpp __unused, void *private) 891 { 892 dwarf_t *dw = private; 893 tdesc_t *full = NULL; 894 895 if (tdp->t_flags & TDESC_F_RESOLVED) 896 return (1); 897 898 (void) hash_find_iter(dw->dw_enumhash, tdp, die_enum_match, &full); 899 900 /* 901 * The answer to this one won't change from iteration to iteration, 902 * so don't even try. 903 */ 904 if (full == NULL) { 905 terminate("tdp %u: enum %s has no members\n", tdp->t_id, 906 tdesc_name(tdp)); 907 } 908 909 debug(3, "tdp %u: enum %s redirected to %u\n", tdp->t_id, 910 tdesc_name(tdp), full->t_id); 911 912 tdp->t_flags |= TDESC_F_RESOLVED; 913 914 return (1); 915 } 916 917 static int 918 die_fwd_map(void *arg1, void *arg2) 919 { 920 tdesc_t *fwd = arg1, *sou = arg2; 921 922 debug(3, "tdp %u: mapped forward %s to sou %u\n", fwd->t_id, 923 tdesc_name(fwd), sou->t_id); 924 fwd->t_tdesc = sou; 925 926 return (0); 927 } 928 929 /* 930 * Structures and unions will never be resolved during the first pass, as we 931 * won't be able to fully determine the member sizes. The second pass, which 932 * have access to sizing information, will be able to complete the resolution. 933 */ 934 static void 935 die_sou_create(dwarf_t *dw, Dwarf_Die str, Dwarf_Off off, tdesc_t *tdp, 936 int type, const char *typename) 937 { 938 Dwarf_Unsigned sz, bitsz, bitoff, maxsz=0; 939 #if BYTE_ORDER == _LITTLE_ENDIAN 940 Dwarf_Unsigned bysz; 941 #endif 942 Dwarf_Die mem; 943 mlist_t *ml, **mlastp; 944 iidesc_t *ii; 945 946 tdp->t_type = (die_isdecl(dw, str) ? FORWARD : type); 947 948 debug(3, "die %llu: creating %s %s\n", off, 949 (tdp->t_type == FORWARD ? "forward decl" : typename), 950 tdesc_name(tdp)); 951 952 if (tdp->t_type == FORWARD) { 953 hash_add(dw->dw_fwdhash, tdp); 954 return; 955 } 956 957 (void) hash_find_iter(dw->dw_fwdhash, tdp, die_fwd_map, tdp); 958 959 (void) die_unsigned(dw, str, DW_AT_byte_size, &sz, DW_ATTR_REQ); 960 tdp->t_size = sz; 961 962 /* 963 * GCC allows empty SOUs as an extension. 964 */ 965 if ((mem = die_child(dw, str)) == NULL) { 966 goto out; 967 } 968 969 mlastp = &tdp->t_members; 970 971 do { 972 Dwarf_Off memoff = die_off(dw, mem); 973 Dwarf_Half tag = die_tag(dw, mem); 974 Dwarf_Unsigned mloff; 975 976 if (tag != DW_TAG_member) { 977 /* Nested type declaration */ 978 die_create_one(dw, mem); 979 continue; 980 } 981 982 debug(3, "die %llu: mem %llu: creating member\n", off, memoff); 983 984 ml = xcalloc(sizeof (mlist_t)); 985 986 /* 987 * This could be a GCC anon struct/union member, so we'll allow 988 * an empty name, even though nothing can really handle them 989 * properly. Note that some versions of GCC miss out debug 990 * info for anon structs, though recent versions are fixed (gcc 991 * bug 11816). 992 */ 993 if ((ml->ml_name = die_name(dw, mem)) == NULL) 994 ml->ml_name = NULL; 995 996 ml->ml_type = die_lookup_pass1(dw, mem, DW_AT_type); 997 debug(3, "die_sou_create(): ml_type = %p t_id = %d\n", 998 ml->ml_type, ml->ml_type->t_id); 999 1000 if (die_mem_offset(dw, mem, DW_AT_data_member_location, 1001 &mloff, 0)) { 1002 debug(3, "die %llu: got mloff %llx\n", off, 1003 (u_longlong_t)mloff); 1004 ml->ml_offset = mloff * 8; 1005 } 1006 1007 if (die_unsigned(dw, mem, DW_AT_bit_size, &bitsz, 0)) 1008 ml->ml_size = bitsz; 1009 else 1010 ml->ml_size = tdesc_bitsize(ml->ml_type); 1011 1012 if (die_unsigned(dw, mem, DW_AT_bit_offset, &bitoff, 0)) { 1013 #if BYTE_ORDER == _BIG_ENDIAN 1014 ml->ml_offset += bitoff; 1015 #else 1016 /* 1017 * Note that Clang 3.4 will sometimes generate 1018 * member DIE before generating the DIE for the 1019 * member's type. The code can not handle this 1020 * properly so that tdesc_bitsize(ml->ml_type) will 1021 * return 0 because ml->ml_type is unknown. As a 1022 * result, a wrong member offset will be calculated. 1023 * To workaround this, we can instead try to 1024 * retrieve the value of DW_AT_byte_size attribute 1025 * which stores the byte size of the space occupied 1026 * by the type. If this attribute exists, its value 1027 * should equal to tdesc_bitsize(ml->ml_type)/NBBY. 1028 */ 1029 if (die_unsigned(dw, mem, DW_AT_byte_size, &bysz, 0) && 1030 bysz > 0) 1031 ml->ml_offset += bysz * NBBY - bitoff - 1032 ml->ml_size; 1033 else 1034 ml->ml_offset += tdesc_bitsize(ml->ml_type) - 1035 bitoff - ml->ml_size; 1036 #endif 1037 } 1038 1039 debug(3, "die %llu: mem %llu: created \"%s\" (off %u sz %u)\n", 1040 off, memoff, ml->ml_name, ml->ml_offset, ml->ml_size); 1041 1042 *mlastp = ml; 1043 mlastp = &ml->ml_next; 1044 1045 /* Find the size of the largest member to work around a gcc 1046 * bug. See GCC Bugzilla 35998. 1047 */ 1048 if (maxsz < ml->ml_size) 1049 maxsz = ml->ml_size; 1050 1051 } while ((mem = die_sibling(dw, mem)) != NULL); 1052 1053 /* See if we got a bogus DW_AT_byte_size. GCC will sometimes 1054 * emit this. 1055 */ 1056 if (sz == (unsigned)-1) { 1057 printf("dwarf.c:%s() working around bogus -1 DW_AT_byte_size\n", 1058 __func__); 1059 tdp->t_size = maxsz / 8; /* maxsz is in bits, t_size is bytes */ 1060 } 1061 1062 /* 1063 * GCC will attempt to eliminate unused types, thus decreasing the 1064 * size of the emitted dwarf. That is, if you declare a foo_t in your 1065 * header, include said header in your source file, and neglect to 1066 * actually use (directly or indirectly) the foo_t in the source file, 1067 * the foo_t won't make it into the emitted DWARF. So, at least, goes 1068 * the theory. 1069 * 1070 * Occasionally, it'll emit the DW_TAG_structure_type for the foo_t, 1071 * and then neglect to emit the members. Strangely, the loner struct 1072 * tag will always be followed by a proper nested declaration of 1073 * something else. This is clearly a bug, but we're not going to have 1074 * time to get it fixed before this goo goes back, so we'll have to work 1075 * around it. If we see a no-membered struct with a nested declaration 1076 * (i.e. die_child of the struct tag won't be null), we'll ignore it. 1077 * Being paranoid, we won't simply remove it from the hash. Instead, 1078 * we'll decline to create an iidesc for it, thus ensuring that this 1079 * type won't make it into the output file. To be safe, we'll also 1080 * change the name. 1081 */ 1082 if (tdp->t_members == NULL) { 1083 const char *old = tdesc_name(tdp); 1084 size_t newsz = 7 + strlen(old) + 1; 1085 char *new = xmalloc(newsz); 1086 (void) snprintf(new, newsz, "orphan %s", old); 1087 1088 debug(3, "die %llu: worked around %s %s\n", off, typename, old); 1089 1090 if (tdp->t_name != NULL) 1091 free(tdp->t_name); 1092 tdp->t_name = new; 1093 return; 1094 } 1095 1096 out: 1097 if (tdp->t_name != NULL) { 1098 ii = xcalloc(sizeof (iidesc_t)); 1099 ii->ii_type = II_SOU; 1100 ii->ii_name = xstrdup(tdp->t_name); 1101 ii->ii_dtype = tdp; 1102 1103 iidesc_add(dw->dw_td->td_iihash, ii); 1104 } 1105 } 1106 1107 static void 1108 die_struct_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp) 1109 { 1110 die_sou_create(dw, die, off, tdp, STRUCT, "struct"); 1111 } 1112 1113 static void 1114 die_union_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp) 1115 { 1116 die_sou_create(dw, die, off, tdp, UNION, "union"); 1117 } 1118 1119 /*ARGSUSED1*/ 1120 static int 1121 die_sou_resolve(tdesc_t *tdp, tdesc_t **tdpp __unused, void *private) 1122 { 1123 dwarf_t *dw = private; 1124 mlist_t *ml; 1125 tdesc_t *mt; 1126 1127 if (tdp->t_flags & TDESC_F_RESOLVED) 1128 return (1); 1129 1130 debug(3, "resolving sou %s\n", tdesc_name(tdp)); 1131 1132 for (ml = tdp->t_members; ml != NULL; ml = ml->ml_next) { 1133 if (ml->ml_size == 0) { 1134 mt = tdesc_basetype(ml->ml_type); 1135 1136 if ((ml->ml_size = tdesc_bitsize(mt)) != 0) 1137 continue; 1138 1139 /* 1140 * For empty members, or GCC/C99 flexible array 1141 * members, a size of 0 is correct. 1142 */ 1143 if (mt->t_members == NULL) 1144 continue; 1145 if (mt->t_type == ARRAY && mt->t_ardef->ad_nelems == 0) 1146 continue; 1147 1148 dw->dw_nunres++; 1149 return (1); 1150 } 1151 1152 if ((mt = tdesc_basetype(ml->ml_type)) == NULL) { 1153 dw->dw_nunres++; 1154 return (1); 1155 } 1156 1157 if (ml->ml_size != 0 && mt->t_type == INTRINSIC && 1158 mt->t_intr->intr_nbits != (int)ml->ml_size) { 1159 /* 1160 * This member is a bitfield, and needs to reference 1161 * an intrinsic type with the same width. If the 1162 * currently-referenced type isn't of the same width, 1163 * we'll copy it, adjusting the width of the copy to 1164 * the size we'd like. 1165 */ 1166 debug(3, "tdp %u: creating bitfield for %d bits\n", 1167 tdp->t_id, ml->ml_size); 1168 1169 ml->ml_type = tdesc_intr_clone(dw, mt, ml->ml_size); 1170 } 1171 } 1172 1173 tdp->t_flags |= TDESC_F_RESOLVED; 1174 1175 return (1); 1176 } 1177 1178 /*ARGSUSED1*/ 1179 static int 1180 die_sou_failed(tdesc_t *tdp, tdesc_t **tdpp __unused, void *private __unused) 1181 { 1182 const char *typename = (tdp->t_type == STRUCT ? "struct" : "union"); 1183 mlist_t *ml; 1184 1185 if (tdp->t_flags & TDESC_F_RESOLVED) 1186 return (1); 1187 1188 for (ml = tdp->t_members; ml != NULL; ml = ml->ml_next) { 1189 if (ml->ml_size == 0) { 1190 fprintf(stderr, "%s %d <%x>: failed to size member \"%s\" " 1191 "of type %s (%d <%x>)\n", typename, tdp->t_id, 1192 tdp->t_id, 1193 ml->ml_name, tdesc_name(ml->ml_type), 1194 ml->ml_type->t_id, ml->ml_type->t_id); 1195 } 1196 } 1197 1198 return (1); 1199 } 1200 1201 static void 1202 die_funcptr_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp) 1203 { 1204 Dwarf_Attribute attr; 1205 Dwarf_Half tag; 1206 Dwarf_Die arg; 1207 fndef_t *fn; 1208 int i; 1209 1210 debug(3, "die %llu <%llx>: creating function pointer\n", off, off); 1211 1212 /* 1213 * We'll begin by processing any type definition nodes that may be 1214 * lurking underneath this one. 1215 */ 1216 for (arg = die_child(dw, die); arg != NULL; 1217 arg = die_sibling(dw, arg)) { 1218 if ((tag = die_tag(dw, arg)) != DW_TAG_formal_parameter && 1219 tag != DW_TAG_unspecified_parameters) { 1220 /* Nested type declaration */ 1221 die_create_one(dw, arg); 1222 } 1223 } 1224 1225 if (die_isdecl(dw, die)) { 1226 /* 1227 * This is a prototype. We don't add prototypes to the 1228 * tree, so we're going to drop the tdesc. Unfortunately, 1229 * it has already been added to the tree. Nobody will reference 1230 * it, though, and it will be leaked. 1231 */ 1232 return; 1233 } 1234 1235 fn = xcalloc(sizeof (fndef_t)); 1236 1237 tdp->t_type = FUNCTION; 1238 1239 if ((attr = die_attr(dw, die, DW_AT_type, 0)) != NULL) { 1240 fn->fn_ret = die_lookup_pass1(dw, die, DW_AT_type); 1241 } else { 1242 fn->fn_ret = tdesc_intr_void(dw); 1243 } 1244 1245 /* 1246 * Count the arguments to the function, then read them in. 1247 */ 1248 for (fn->fn_nargs = 0, arg = die_child(dw, die); arg != NULL; 1249 arg = die_sibling(dw, arg)) { 1250 if ((tag = die_tag(dw, arg)) == DW_TAG_formal_parameter) 1251 fn->fn_nargs++; 1252 else if (tag == DW_TAG_unspecified_parameters && 1253 fn->fn_nargs > 0) 1254 fn->fn_vargs = 1; 1255 } 1256 1257 if (fn->fn_nargs != 0) { 1258 debug(3, "die %llu: adding %d argument%s\n", off, fn->fn_nargs, 1259 (fn->fn_nargs > 1 ? "s" : "")); 1260 1261 fn->fn_args = xcalloc(sizeof (tdesc_t *) * fn->fn_nargs); 1262 for (i = 0, arg = die_child(dw, die); 1263 arg != NULL && i < (int) fn->fn_nargs; 1264 arg = die_sibling(dw, arg)) { 1265 if (die_tag(dw, arg) != DW_TAG_formal_parameter) 1266 continue; 1267 1268 fn->fn_args[i++] = die_lookup_pass1(dw, arg, 1269 DW_AT_type); 1270 } 1271 } 1272 1273 tdp->t_fndef = fn; 1274 tdp->t_flags |= TDESC_F_RESOLVED; 1275 } 1276 1277 /* 1278 * GCC and DevPro use different names for the base types. While the terms are 1279 * the same, they are arranged in a different order. Some terms, such as int, 1280 * are implied in one, and explicitly named in the other. Given a base type 1281 * as input, this routine will return a common name, along with an intr_t 1282 * that reflects said name. 1283 */ 1284 static intr_t * 1285 die_base_name_parse(const char *name, char **newp) 1286 { 1287 char buf[100]; 1288 char const *base; 1289 char *c; 1290 int nlong = 0, nshort = 0, nchar = 0, nint = 0; 1291 int sign = 1; 1292 char fmt = '\0'; 1293 intr_t *intr; 1294 1295 if (strlen(name) > sizeof (buf) - 1) 1296 terminate("base type name \"%s\" is too long\n", name); 1297 1298 strncpy(buf, name, sizeof (buf)); 1299 1300 for (c = strtok(buf, " "); c != NULL; c = strtok(NULL, " ")) { 1301 if (strcmp(c, "signed") == 0) 1302 sign = 1; 1303 else if (strcmp(c, "unsigned") == 0) 1304 sign = 0; 1305 else if (strcmp(c, "long") == 0) 1306 nlong++; 1307 else if (strcmp(c, "char") == 0) { 1308 nchar++; 1309 fmt = 'c'; 1310 } else if (strcmp(c, "short") == 0) 1311 nshort++; 1312 else if (strcmp(c, "int") == 0) 1313 nint++; 1314 else { 1315 /* 1316 * If we don't recognize any of the tokens, we'll tell 1317 * the caller to fall back to the dwarf-provided 1318 * encoding information. 1319 */ 1320 return (NULL); 1321 } 1322 } 1323 1324 if (nchar > 1 || nshort > 1 || nint > 1 || nlong > 2) 1325 return (NULL); 1326 1327 if (nchar > 0) { 1328 if (nlong > 0 || nshort > 0 || nint > 0) 1329 return (NULL); 1330 1331 base = "char"; 1332 1333 } else if (nshort > 0) { 1334 if (nlong > 0) 1335 return (NULL); 1336 1337 base = "short"; 1338 1339 } else if (nlong > 0) { 1340 base = "long"; 1341 1342 } else { 1343 base = "int"; 1344 } 1345 1346 intr = xcalloc(sizeof (intr_t)); 1347 intr->intr_type = INTR_INT; 1348 intr->intr_signed = sign; 1349 intr->intr_iformat = fmt; 1350 1351 snprintf(buf, sizeof (buf), "%s%s%s", 1352 (sign ? "" : "unsigned "), 1353 (nlong > 1 ? "long " : ""), 1354 base); 1355 1356 *newp = xstrdup(buf); 1357 return (intr); 1358 } 1359 1360 typedef struct fp_size_map { 1361 size_t fsm_typesz[2]; /* size of {32,64} type */ 1362 uint_t fsm_enc[3]; /* CTF_FP_* for {bare,cplx,imagry} type */ 1363 } fp_size_map_t; 1364 1365 static const fp_size_map_t fp_encodings[] = { 1366 { { 4, 4 }, { CTF_FP_SINGLE, CTF_FP_CPLX, CTF_FP_IMAGRY } }, 1367 { { 8, 8 }, { CTF_FP_DOUBLE, CTF_FP_DCPLX, CTF_FP_DIMAGRY } }, 1368 #ifdef __sparc 1369 { { 16, 16 }, { CTF_FP_LDOUBLE, CTF_FP_LDCPLX, CTF_FP_LDIMAGRY } }, 1370 #else 1371 { { 12, 16 }, { CTF_FP_LDOUBLE, CTF_FP_LDCPLX, CTF_FP_LDIMAGRY } }, 1372 #endif 1373 { { 0, 0 }, { 0, 0, 0 } } 1374 }; 1375 1376 static uint_t 1377 die_base_type2enc(dwarf_t *dw, Dwarf_Off off, Dwarf_Signed enc, size_t sz) 1378 { 1379 const fp_size_map_t *map = fp_encodings; 1380 uint_t szidx = dw->dw_ptrsz == sizeof (uint64_t); 1381 uint_t mult = 1, col = 0; 1382 1383 if (enc == DW_ATE_complex_float) { 1384 mult = 2; 1385 col = 1; 1386 } else if (enc == DW_ATE_imaginary_float 1387 #if defined(sun) 1388 || enc == DW_ATE_SUN_imaginary_float 1389 #endif 1390 ) 1391 col = 2; 1392 1393 while (map->fsm_typesz[szidx] != 0) { 1394 if (map->fsm_typesz[szidx] * mult == sz) 1395 return (map->fsm_enc[col]); 1396 map++; 1397 } 1398 1399 terminate("die %llu: unrecognized real type size %u\n", off, sz); 1400 /*NOTREACHED*/ 1401 return (0); 1402 } 1403 1404 static intr_t * 1405 die_base_from_dwarf(dwarf_t *dw, Dwarf_Die base, Dwarf_Off off, size_t sz) 1406 { 1407 intr_t *intr = xcalloc(sizeof (intr_t)); 1408 Dwarf_Signed enc; 1409 1410 (void) die_signed(dw, base, DW_AT_encoding, &enc, DW_ATTR_REQ); 1411 1412 switch (enc) { 1413 case DW_ATE_unsigned: 1414 case DW_ATE_address: 1415 intr->intr_type = INTR_INT; 1416 break; 1417 case DW_ATE_unsigned_char: 1418 intr->intr_type = INTR_INT; 1419 intr->intr_iformat = 'c'; 1420 break; 1421 case DW_ATE_signed: 1422 intr->intr_type = INTR_INT; 1423 intr->intr_signed = 1; 1424 break; 1425 case DW_ATE_signed_char: 1426 intr->intr_type = INTR_INT; 1427 intr->intr_signed = 1; 1428 intr->intr_iformat = 'c'; 1429 break; 1430 case DW_ATE_boolean: 1431 intr->intr_type = INTR_INT; 1432 intr->intr_signed = 1; 1433 intr->intr_iformat = 'b'; 1434 break; 1435 case DW_ATE_float: 1436 case DW_ATE_complex_float: 1437 case DW_ATE_imaginary_float: 1438 #if defined(sun) 1439 case DW_ATE_SUN_imaginary_float: 1440 case DW_ATE_SUN_interval_float: 1441 #endif 1442 intr->intr_type = INTR_REAL; 1443 intr->intr_signed = 1; 1444 intr->intr_fformat = die_base_type2enc(dw, off, enc, sz); 1445 break; 1446 default: 1447 terminate("die %llu: unknown base type encoding 0x%llx\n", 1448 off, enc); 1449 } 1450 1451 return (intr); 1452 } 1453 1454 static void 1455 die_base_create(dwarf_t *dw, Dwarf_Die base, Dwarf_Off off, tdesc_t *tdp) 1456 { 1457 Dwarf_Unsigned sz; 1458 intr_t *intr; 1459 char *new; 1460 1461 debug(3, "die %llu: creating base type\n", off); 1462 1463 /* 1464 * The compilers have their own clever (internally inconsistent) ideas 1465 * as to what base types should look like. Some times gcc will, for 1466 * example, use DW_ATE_signed_char for char. Other times, however, it 1467 * will use DW_ATE_signed. Needless to say, this causes some problems 1468 * down the road, particularly with merging. We do, however, use the 1469 * DWARF idea of type sizes, as this allows us to avoid caring about 1470 * the data model. 1471 */ 1472 (void) die_unsigned(dw, base, DW_AT_byte_size, &sz, DW_ATTR_REQ); 1473 1474 /* Check for bogus gcc DW_AT_byte_size attribute */ 1475 if (sz == (unsigned)-1) { 1476 printf("dwarf.c:%s() working around bogus -1 DW_AT_byte_size\n", 1477 __func__); 1478 sz = 0; 1479 } 1480 1481 if (tdp->t_name == NULL) 1482 terminate("die %llu: base type without name\n", off); 1483 1484 /* XXX make a name parser for float too */ 1485 if ((intr = die_base_name_parse(tdp->t_name, &new)) != NULL) { 1486 /* Found it. We'll use the parsed version */ 1487 debug(3, "die %llu: name \"%s\" remapped to \"%s\"\n", off, 1488 tdesc_name(tdp), new); 1489 1490 free(tdp->t_name); 1491 tdp->t_name = new; 1492 } else { 1493 /* 1494 * We didn't recognize the type, so we'll create an intr_t 1495 * based on the DWARF data. 1496 */ 1497 debug(3, "die %llu: using dwarf data for base \"%s\"\n", off, 1498 tdesc_name(tdp)); 1499 1500 intr = die_base_from_dwarf(dw, base, off, sz); 1501 } 1502 1503 intr->intr_nbits = sz * 8; 1504 1505 tdp->t_type = INTRINSIC; 1506 tdp->t_intr = intr; 1507 tdp->t_size = sz; 1508 1509 tdp->t_flags |= TDESC_F_RESOLVED; 1510 } 1511 1512 static void 1513 die_through_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp, 1514 int type, const char *typename) 1515 { 1516 Dwarf_Attribute attr; 1517 1518 debug(3, "die %llu <%llx>: creating %s type %d\n", off, off, typename, type); 1519 1520 tdp->t_type = type; 1521 1522 if ((attr = die_attr(dw, die, DW_AT_type, 0)) != NULL) { 1523 tdp->t_tdesc = die_lookup_pass1(dw, die, DW_AT_type); 1524 } else { 1525 tdp->t_tdesc = tdesc_intr_void(dw); 1526 } 1527 1528 if (type == POINTER) 1529 tdp->t_size = dw->dw_ptrsz; 1530 1531 tdp->t_flags |= TDESC_F_RESOLVED; 1532 1533 if (type == TYPEDEF) { 1534 iidesc_t *ii = xcalloc(sizeof (iidesc_t)); 1535 ii->ii_type = II_TYPE; 1536 ii->ii_name = xstrdup(tdp->t_name); 1537 ii->ii_dtype = tdp; 1538 1539 iidesc_add(dw->dw_td->td_iihash, ii); 1540 } 1541 } 1542 1543 static void 1544 die_typedef_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp) 1545 { 1546 die_through_create(dw, die, off, tdp, TYPEDEF, "typedef"); 1547 } 1548 1549 static void 1550 die_const_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp) 1551 { 1552 die_through_create(dw, die, off, tdp, CONST, "const"); 1553 } 1554 1555 static void 1556 die_pointer_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp) 1557 { 1558 die_through_create(dw, die, off, tdp, POINTER, "pointer"); 1559 } 1560 1561 static void 1562 die_restrict_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp) 1563 { 1564 die_through_create(dw, die, off, tdp, RESTRICT, "restrict"); 1565 } 1566 1567 static void 1568 die_volatile_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp) 1569 { 1570 die_through_create(dw, die, off, tdp, VOLATILE, "volatile"); 1571 } 1572 1573 /*ARGSUSED3*/ 1574 static void 1575 die_function_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp __unused) 1576 { 1577 Dwarf_Die arg; 1578 Dwarf_Half tag; 1579 iidesc_t *ii; 1580 char *name; 1581 1582 debug(3, "die %llu <%llx>: creating function definition\n", off, off); 1583 1584 /* 1585 * We'll begin by processing any type definition nodes that may be 1586 * lurking underneath this one. 1587 */ 1588 for (arg = die_child(dw, die); arg != NULL; 1589 arg = die_sibling(dw, arg)) { 1590 if ((tag = die_tag(dw, arg)) != DW_TAG_formal_parameter && 1591 tag != DW_TAG_variable) { 1592 /* Nested type declaration */ 1593 die_create_one(dw, arg); 1594 } 1595 } 1596 1597 if (die_isdecl(dw, die) || (name = die_name(dw, die)) == NULL) { 1598 /* 1599 * We process neither prototypes nor subprograms without 1600 * names. 1601 */ 1602 return; 1603 } 1604 1605 ii = xcalloc(sizeof (iidesc_t)); 1606 ii->ii_type = die_isglobal(dw, die) ? II_GFUN : II_SFUN; 1607 ii->ii_name = name; 1608 if (ii->ii_type == II_SFUN) 1609 ii->ii_owner = xstrdup(dw->dw_cuname); 1610 1611 debug(3, "die %llu: function %s is %s\n", off, ii->ii_name, 1612 (ii->ii_type == II_GFUN ? "global" : "static")); 1613 1614 if (die_attr(dw, die, DW_AT_type, 0) != NULL) 1615 ii->ii_dtype = die_lookup_pass1(dw, die, DW_AT_type); 1616 else 1617 ii->ii_dtype = tdesc_intr_void(dw); 1618 1619 for (arg = die_child(dw, die); arg != NULL; 1620 arg = die_sibling(dw, arg)) { 1621 char *name1; 1622 1623 debug(3, "die %llu: looking at sub member at %llu\n", 1624 off, die_off(dw, die)); 1625 1626 if (die_tag(dw, arg) != DW_TAG_formal_parameter) 1627 continue; 1628 1629 if ((name1 = die_name(dw, arg)) == NULL) { 1630 terminate("die %llu: func arg %d has no name\n", 1631 off, ii->ii_nargs + 1); 1632 } 1633 1634 if (strcmp(name1, "...") == 0) { 1635 free(name1); 1636 ii->ii_vargs = 1; 1637 continue; 1638 } 1639 1640 ii->ii_nargs++; 1641 } 1642 1643 if (ii->ii_nargs > 0) { 1644 int i; 1645 1646 debug(3, "die %llu: function has %d argument%s\n", off, 1647 ii->ii_nargs, (ii->ii_nargs == 1 ? "" : "s")); 1648 1649 ii->ii_args = xcalloc(sizeof (tdesc_t) * ii->ii_nargs); 1650 1651 for (arg = die_child(dw, die), i = 0; 1652 arg != NULL && i < ii->ii_nargs; 1653 arg = die_sibling(dw, arg)) { 1654 if (die_tag(dw, arg) != DW_TAG_formal_parameter) 1655 continue; 1656 1657 ii->ii_args[i++] = die_lookup_pass1(dw, arg, 1658 DW_AT_type); 1659 } 1660 } 1661 1662 iidesc_add(dw->dw_td->td_iihash, ii); 1663 } 1664 1665 /*ARGSUSED3*/ 1666 static void 1667 die_variable_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp __unused) 1668 { 1669 iidesc_t *ii; 1670 char *name; 1671 1672 debug(3, "die %llu: creating object definition\n", off); 1673 1674 if (die_isdecl(dw, die) || (name = die_name(dw, die)) == NULL) 1675 return; /* skip prototypes and nameless objects */ 1676 1677 ii = xcalloc(sizeof (iidesc_t)); 1678 ii->ii_type = die_isglobal(dw, die) ? II_GVAR : II_SVAR; 1679 ii->ii_name = name; 1680 ii->ii_dtype = die_lookup_pass1(dw, die, DW_AT_type); 1681 if (ii->ii_type == II_SVAR) 1682 ii->ii_owner = xstrdup(dw->dw_cuname); 1683 1684 iidesc_add(dw->dw_td->td_iihash, ii); 1685 } 1686 1687 /*ARGSUSED2*/ 1688 static int 1689 die_fwd_resolve(tdesc_t *fwd, tdesc_t **fwdp, void *private __unused) 1690 { 1691 if (fwd->t_flags & TDESC_F_RESOLVED) 1692 return (1); 1693 1694 if (fwd->t_tdesc != NULL) { 1695 debug(3, "tdp %u: unforwarded %s\n", fwd->t_id, 1696 tdesc_name(fwd)); 1697 *fwdp = fwd->t_tdesc; 1698 } 1699 1700 fwd->t_flags |= TDESC_F_RESOLVED; 1701 1702 return (1); 1703 } 1704 1705 /*ARGSUSED*/ 1706 static void 1707 die_lexblk_descend(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off __unused, tdesc_t *tdp __unused) 1708 { 1709 Dwarf_Die child = die_child(dw, die); 1710 1711 if (child != NULL) 1712 die_create(dw, child); 1713 } 1714 1715 /* 1716 * Used to map the die to a routine which can parse it, using the tag to do the 1717 * mapping. While the processing of most tags entails the creation of a tdesc, 1718 * there are a few which don't - primarily those which result in the creation of 1719 * iidescs which refer to existing tdescs. 1720 */ 1721 1722 #define DW_F_NOTDP 0x1 /* Don't create a tdesc for the creator */ 1723 1724 typedef struct die_creator { 1725 Dwarf_Half dc_tag; 1726 uint16_t dc_flags; 1727 void (*dc_create)(dwarf_t *, Dwarf_Die, Dwarf_Off, tdesc_t *); 1728 } die_creator_t; 1729 1730 static const die_creator_t die_creators[] = { 1731 { DW_TAG_array_type, 0, die_array_create }, 1732 { DW_TAG_enumeration_type, 0, die_enum_create }, 1733 { DW_TAG_lexical_block, DW_F_NOTDP, die_lexblk_descend }, 1734 { DW_TAG_pointer_type, 0, die_pointer_create }, 1735 { DW_TAG_structure_type, 0, die_struct_create }, 1736 { DW_TAG_subroutine_type, 0, die_funcptr_create }, 1737 { DW_TAG_typedef, 0, die_typedef_create }, 1738 { DW_TAG_union_type, 0, die_union_create }, 1739 { DW_TAG_base_type, 0, die_base_create }, 1740 { DW_TAG_const_type, 0, die_const_create }, 1741 { DW_TAG_subprogram, DW_F_NOTDP, die_function_create }, 1742 { DW_TAG_variable, DW_F_NOTDP, die_variable_create }, 1743 { DW_TAG_volatile_type, 0, die_volatile_create }, 1744 { DW_TAG_restrict_type, 0, die_restrict_create }, 1745 { 0, 0, NULL } 1746 }; 1747 1748 static const die_creator_t * 1749 die_tag2ctor(Dwarf_Half tag) 1750 { 1751 const die_creator_t *dc; 1752 1753 for (dc = die_creators; dc->dc_create != NULL; dc++) { 1754 if (dc->dc_tag == tag) 1755 return (dc); 1756 } 1757 1758 return (NULL); 1759 } 1760 1761 static void 1762 die_create_one(dwarf_t *dw, Dwarf_Die die) 1763 { 1764 Dwarf_Off off = die_off(dw, die); 1765 const die_creator_t *dc; 1766 Dwarf_Half tag; 1767 tdesc_t *tdp; 1768 1769 debug(3, "die %llu <%llx>: create_one\n", off, off); 1770 1771 if (off > dw->dw_maxoff) { 1772 terminate("illegal die offset %llu (max %llu)\n", off, 1773 dw->dw_maxoff); 1774 } 1775 1776 tag = die_tag(dw, die); 1777 1778 if ((dc = die_tag2ctor(tag)) == NULL) { 1779 debug(2, "die %llu: ignoring tag type %x\n", off, tag); 1780 return; 1781 } 1782 1783 if ((tdp = tdesc_lookup(dw, off)) == NULL && 1784 !(dc->dc_flags & DW_F_NOTDP)) { 1785 tdp = xcalloc(sizeof (tdesc_t)); 1786 tdp->t_id = off; 1787 tdesc_add(dw, tdp); 1788 } 1789 1790 if (tdp != NULL) 1791 tdp->t_name = die_name(dw, die); 1792 1793 dc->dc_create(dw, die, off, tdp); 1794 } 1795 1796 static void 1797 die_create(dwarf_t *dw, Dwarf_Die die) 1798 { 1799 do { 1800 die_create_one(dw, die); 1801 } while ((die = die_sibling(dw, die)) != NULL); 1802 } 1803 1804 static tdtrav_cb_f die_resolvers[] = { 1805 NULL, 1806 NULL, /* intrinsic */ 1807 NULL, /* pointer */ 1808 die_array_resolve, /* array */ 1809 NULL, /* function */ 1810 die_sou_resolve, /* struct */ 1811 die_sou_resolve, /* union */ 1812 die_enum_resolve, /* enum */ 1813 die_fwd_resolve, /* forward */ 1814 NULL, /* typedef */ 1815 NULL, /* typedef unres */ 1816 NULL, /* volatile */ 1817 NULL, /* const */ 1818 NULL, /* restrict */ 1819 }; 1820 1821 static tdtrav_cb_f die_fail_reporters[] = { 1822 NULL, 1823 NULL, /* intrinsic */ 1824 NULL, /* pointer */ 1825 die_array_failed, /* array */ 1826 NULL, /* function */ 1827 die_sou_failed, /* struct */ 1828 die_sou_failed, /* union */ 1829 NULL, /* enum */ 1830 NULL, /* forward */ 1831 NULL, /* typedef */ 1832 NULL, /* typedef unres */ 1833 NULL, /* volatile */ 1834 NULL, /* const */ 1835 NULL, /* restrict */ 1836 }; 1837 1838 static void 1839 die_resolve(dwarf_t *dw) 1840 { 1841 int last = -1; 1842 int pass = 0; 1843 1844 do { 1845 pass++; 1846 dw->dw_nunres = 0; 1847 1848 (void) iitraverse_hash(dw->dw_td->td_iihash, 1849 &dw->dw_td->td_curvgen, NULL, NULL, die_resolvers, dw); 1850 1851 debug(3, "resolve: pass %d, %u left\n", pass, dw->dw_nunres); 1852 1853 if ((int) dw->dw_nunres == last) { 1854 fprintf(stderr, "%s: failed to resolve the following " 1855 "types:\n", progname); 1856 1857 (void) iitraverse_hash(dw->dw_td->td_iihash, 1858 &dw->dw_td->td_curvgen, NULL, NULL, 1859 die_fail_reporters, dw); 1860 1861 terminate("failed to resolve types\n"); 1862 } 1863 1864 last = dw->dw_nunres; 1865 1866 } while (dw->dw_nunres != 0); 1867 } 1868 1869 /* 1870 * Any object containing a function or object symbol at any scope should also 1871 * contain DWARF data. 1872 */ 1873 static boolean_t 1874 should_have_dwarf(Elf *elf) 1875 { 1876 Elf_Scn *scn = NULL; 1877 Elf_Data *data = NULL; 1878 GElf_Shdr shdr; 1879 GElf_Sym sym; 1880 uint32_t symdx = 0; 1881 size_t nsyms = 0; 1882 boolean_t found = B_FALSE; 1883 1884 while ((scn = elf_nextscn(elf, scn)) != NULL) { 1885 gelf_getshdr(scn, &shdr); 1886 1887 if (shdr.sh_type == SHT_SYMTAB) { 1888 found = B_TRUE; 1889 break; 1890 } 1891 } 1892 1893 if (!found) 1894 terminate("cannot convert stripped objects\n"); 1895 1896 data = elf_getdata(scn, NULL); 1897 nsyms = shdr.sh_size / shdr.sh_entsize; 1898 1899 for (symdx = 0; symdx < nsyms; symdx++) { 1900 gelf_getsym(data, symdx, &sym); 1901 1902 if ((GELF_ST_TYPE(sym.st_info) == STT_FUNC) || 1903 (GELF_ST_TYPE(sym.st_info) == STT_TLS) || 1904 (GELF_ST_TYPE(sym.st_info) == STT_OBJECT)) { 1905 char *name; 1906 1907 name = elf_strptr(elf, shdr.sh_link, sym.st_name); 1908 1909 /* Studio emits these local symbols regardless */ 1910 if ((strcmp(name, "Bbss.bss") != 0) && 1911 (strcmp(name, "Ttbss.bss") != 0) && 1912 (strcmp(name, "Ddata.data") != 0) && 1913 (strcmp(name, "Ttdata.data") != 0) && 1914 (strcmp(name, "Drodata.rodata") != 0)) 1915 return (B_TRUE); 1916 } 1917 } 1918 1919 return (B_FALSE); 1920 } 1921 1922 /*ARGSUSED*/ 1923 int 1924 dw_read(tdata_t *td, Elf *elf, char *filename __unused) 1925 { 1926 Dwarf_Unsigned abboff, hdrlen, nxthdr; 1927 Dwarf_Half vers, addrsz, offsz; 1928 Dwarf_Die cu = 0; 1929 Dwarf_Die child = 0; 1930 dwarf_t dw; 1931 char *prod = NULL; 1932 int rc; 1933 1934 bzero(&dw, sizeof (dwarf_t)); 1935 dw.dw_td = td; 1936 dw.dw_ptrsz = elf_ptrsz(elf); 1937 dw.dw_mfgtid_last = TID_MFGTID_BASE; 1938 dw.dw_tidhash = hash_new(TDESC_HASH_BUCKETS, tdesc_idhash, tdesc_idcmp); 1939 dw.dw_fwdhash = hash_new(TDESC_HASH_BUCKETS, tdesc_namehash, 1940 tdesc_namecmp); 1941 dw.dw_enumhash = hash_new(TDESC_HASH_BUCKETS, tdesc_namehash, 1942 tdesc_namecmp); 1943 1944 if ((rc = dwarf_elf_init(elf, DW_DLC_READ, NULL, NULL, &dw.dw_dw, 1945 &dw.dw_err)) == DW_DLV_NO_ENTRY) { 1946 if (should_have_dwarf(elf)) { 1947 errno = ENOENT; 1948 return (-1); 1949 } else { 1950 return (0); 1951 } 1952 } else if (rc != DW_DLV_OK) { 1953 if (dwarf_errno(dw.dw_err) == DW_DLE_DEBUG_INFO_NULL) { 1954 /* 1955 * There's no type data in the DWARF section, but 1956 * libdwarf is too clever to handle that properly. 1957 */ 1958 return (0); 1959 } 1960 1961 terminate("failed to initialize DWARF: %s\n", 1962 dwarf_errmsg(dw.dw_err)); 1963 } 1964 1965 if ((rc = dwarf_next_cu_header_b(dw.dw_dw, &hdrlen, &vers, &abboff, 1966 &addrsz, &offsz, NULL, &nxthdr, &dw.dw_err)) != DW_DLV_OK) 1967 terminate("rc = %d %s\n", rc, dwarf_errmsg(dw.dw_err)); 1968 1969 if ((cu = die_sibling(&dw, NULL)) == NULL || 1970 (((child = die_child(&dw, cu)) == NULL) && 1971 should_have_dwarf(elf))) { 1972 terminate("file does not contain dwarf type data " 1973 "(try compiling with -g)\n"); 1974 } else if (child == NULL) { 1975 return (0); 1976 } 1977 1978 dw.dw_maxoff = nxthdr - 1; 1979 1980 if (dw.dw_maxoff > TID_FILEMAX) 1981 terminate("file contains too many types\n"); 1982 1983 debug(1, "DWARF version: %d\n", vers); 1984 if (vers < 2 || vers > 4) { 1985 terminate("file contains incompatible version %d DWARF code " 1986 "(version 2, 3 or 4 required)\n", vers); 1987 } 1988 1989 if (die_string(&dw, cu, DW_AT_producer, &prod, 0)) { 1990 debug(1, "DWARF emitter: %s\n", prod); 1991 free(prod); 1992 } 1993 1994 if ((dw.dw_cuname = die_name(&dw, cu)) != NULL) { 1995 char *base = xstrdup(basename(dw.dw_cuname)); 1996 free(dw.dw_cuname); 1997 dw.dw_cuname = base; 1998 1999 debug(1, "CU name: %s\n", dw.dw_cuname); 2000 } 2001 2002 if ((child = die_child(&dw, cu)) != NULL) 2003 die_create(&dw, child); 2004 2005 if ((rc = dwarf_next_cu_header_b(dw.dw_dw, &hdrlen, &vers, &abboff, 2006 &addrsz, &offsz, NULL, &nxthdr, &dw.dw_err)) != DW_DLV_NO_ENTRY) 2007 terminate("multiple compilation units not supported\n"); 2008 2009 (void) dwarf_finish(dw.dw_dw, &dw.dw_err); 2010 2011 die_resolve(&dw); 2012 2013 cvt_fixups(td, dw.dw_ptrsz); 2014 2015 /* leak the dwarf_t */ 2016 2017 return (0); 2018 } 2019