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