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