projects/linux·blob master · refs

1185 lines · 29.5 KiB

1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright (C) 2024 Google LLC
4 */
5
6#define _GNU_SOURCE
7#include <assert.h>
8#include <inttypes.h>
9#include <stdarg.h>
10#include "gendwarfksyms.h"
11
12/* See get_union_kabi_status */
13#define KABI_PREFIX "__kabi_"
14#define KABI_PREFIX_LEN (sizeof(KABI_PREFIX) - 1)
15#define KABI_RESERVED_PREFIX "reserved"
16#define KABI_RESERVED_PREFIX_LEN (sizeof(KABI_RESERVED_PREFIX) - 1)
17#define KABI_RENAMED_PREFIX "renamed"
18#define KABI_RENAMED_PREFIX_LEN (sizeof(KABI_RENAMED_PREFIX) - 1)
19#define KABI_IGNORED_PREFIX "ignored"
20#define KABI_IGNORED_PREFIX_LEN (sizeof(KABI_IGNORED_PREFIX) - 1)
21
22static inline bool is_kabi_prefix(const char *name)
23{
24 return name && !strncmp(name, KABI_PREFIX, KABI_PREFIX_LEN);
25}
26
27enum kabi_status {
28 /* >0 to stop DIE processing */
29 KABI_NORMAL = 1,
30 KABI_RESERVED,
31 KABI_IGNORED,
32};
33
34static bool do_linebreak;
35static int indentation_level;
36
37/* Line breaks and indentation for pretty-printing */
38static void process_linebreak(struct die *cache, int n)
39{
40 indentation_level += n;
41 do_linebreak = true;
42 die_map_add_linebreak(cache, n);
43}
44
45#define DEFINE_GET_ATTR(attr, type) \
46 static bool get_##attr##_attr(Dwarf_Die *die, unsigned int id, \
47 type *value) \
48 { \
49 Dwarf_Attribute da; \
50 return dwarf_attr(die, id, &da) && \
51 !dwarf_form##attr(&da, value); \
52 }
53
54DEFINE_GET_ATTR(flag, bool)
55DEFINE_GET_ATTR(udata, Dwarf_Word)
56
57static bool get_ref_die_attr(Dwarf_Die *die, unsigned int id, Dwarf_Die *value)
58{
59 Dwarf_Attribute da;
60
61 /* dwarf_formref_die returns a pointer instead of an error value. */
62 return dwarf_attr(die, id, &da) && dwarf_formref_die(&da, value);
63}
64
65#define DEFINE_GET_STRING_ATTR(attr) \
66 static const char *get_##attr##_attr(Dwarf_Die *die) \
67 { \
68 Dwarf_Attribute da; \
69 if (dwarf_attr(die, DW_AT_##attr, &da)) \
70 return dwarf_formstring(&da); \
71 return NULL; \
72 }
73
74DEFINE_GET_STRING_ATTR(name)
75DEFINE_GET_STRING_ATTR(linkage_name)
76
77static const char *get_symbol_name(Dwarf_Die *die)
78{
79 const char *name;
80
81 /* rustc uses DW_AT_linkage_name for exported symbols */
82 name = get_linkage_name_attr(die);
83 if (!name)
84 name = get_name_attr(die);
85
86 return name;
87}
88
89static bool match_export_symbol(struct state *state, Dwarf_Die *die)
90{
91 Dwarf_Die *source = die;
92 Dwarf_Die origin;
93
94 /* If the DIE has an abstract origin, use it for type information. */
95 if (get_ref_die_attr(die, DW_AT_abstract_origin, &origin))
96 source = &origin;
97
98 state->sym = symbol_get(get_symbol_name(die));
99
100 /* Look up using the origin name if there are no matches. */
101 if (!state->sym && source != die)
102 state->sym = symbol_get(get_symbol_name(source));
103
104 state->die = *source;
105 return !!state->sym;
106}
107
108/* DW_AT_decl_file -> struct srcfile */
109static struct cache srcfile_cache;
110
111static bool is_definition_private(Dwarf_Die *die)
112{
113 Dwarf_Word filenum;
114 Dwarf_Files *files;
115 Dwarf_Die cudie;
116 const char *s;
117 int res;
118
119 /*
120 * Definitions in .c files cannot change the public ABI,
121 * so consider them private.
122 */
123 if (!get_udata_attr(die, DW_AT_decl_file, &filenum))
124 return false;
125
126 res = cache_get(&srcfile_cache, filenum);
127 if (res >= 0)
128 return !!res;
129
130 if (!dwarf_cu_die(die->cu, &cudie, NULL, NULL, NULL, NULL, NULL, NULL))
131 error("dwarf_cu_die failed: '%s'", dwarf_errmsg(-1));
132
133 if (dwarf_getsrcfiles(&cudie, &files, NULL))
134 error("dwarf_getsrcfiles failed: '%s'", dwarf_errmsg(-1));
135
136 s = dwarf_filesrc(files, filenum, NULL, NULL);
137 if (!s)
138 error("dwarf_filesrc failed: '%s'", dwarf_errmsg(-1));
139
140 s = strrchr(s, '.');
141 res = s && !strcmp(s, ".c");
142 cache_set(&srcfile_cache, filenum, res);
143
144 return !!res;
145}
146
147static bool is_kabi_definition(struct die *cache, Dwarf_Die *die)
148{
149 bool value;
150
151 if (get_flag_attr(die, DW_AT_declaration, &value) && value)
152 return false;
153
154 if (kabi_is_declonly(cache->fqn))
155 return false;
156
157 return !is_definition_private(die);
158}
159
160/*
161 * Type string processing
162 */
163static void process(struct die *cache, const char *s)
164{
165 s = s ?: "<null>";
166
167 if (dump_dies && do_linebreak) {
168 fputs("\n", stderr);
169 for (int i = 0; i < indentation_level; i++)
170 fputs(" ", stderr);
171 do_linebreak = false;
172 }
173 if (dump_dies)
174 fputs(s, stderr);
175
176 if (cache)
177 die_debug_r("cache %p string '%s'", cache, s);
178 die_map_add_string(cache, s);
179}
180
181#define MAX_FMT_BUFFER_SIZE 128
182
183static void process_fmt(struct die *cache, const char *fmt, ...)
184{
185 char buf[MAX_FMT_BUFFER_SIZE];
186 va_list args;
187
188 va_start(args, fmt);
189
190 if (checkp(vsnprintf(buf, sizeof(buf), fmt, args)) >= sizeof(buf))
191 error("vsnprintf overflow: increase MAX_FMT_BUFFER_SIZE");
192
193 process(cache, buf);
194 va_end(args);
195}
196
197static void update_fqn(struct die *cache, Dwarf_Die *die)
198{
199 struct die *fqn;
200
201 if (!cache->fqn) {
202 if (!__die_map_get((uintptr_t)die->addr, DIE_FQN, &fqn) &&
203 *fqn->fqn)
204 cache->fqn = xstrdup(fqn->fqn);
205 else
206 cache->fqn = "";
207 }
208}
209
210static void process_fqn(struct die *cache, Dwarf_Die *die)
211{
212 update_fqn(cache, die);
213 if (*cache->fqn)
214 process(cache, " ");
215 process(cache, cache->fqn);
216}
217
218#define DEFINE_PROCESS_UDATA_ATTRIBUTE(attribute) \
219 static void process_##attribute##_attr(struct die *cache, \
220 Dwarf_Die *die) \
221 { \
222 Dwarf_Word value; \
223 if (get_udata_attr(die, DW_AT_##attribute, &value)) \
224 process_fmt(cache, " " #attribute "(%" PRIu64 ")", \
225 value); \
226 }
227
228DEFINE_PROCESS_UDATA_ATTRIBUTE(accessibility)
229DEFINE_PROCESS_UDATA_ATTRIBUTE(alignment)
230DEFINE_PROCESS_UDATA_ATTRIBUTE(bit_size)
231DEFINE_PROCESS_UDATA_ATTRIBUTE(encoding)
232DEFINE_PROCESS_UDATA_ATTRIBUTE(data_bit_offset)
233DEFINE_PROCESS_UDATA_ATTRIBUTE(data_member_location)
234DEFINE_PROCESS_UDATA_ATTRIBUTE(discr_value)
235
236static void process_byte_size_attr(struct die *cache, Dwarf_Die *die)
237{
238 Dwarf_Word value;
239 unsigned long override;
240
241 if (get_udata_attr(die, DW_AT_byte_size, &value)) {
242 if (stable && kabi_get_byte_size(cache->fqn, &override))
243 value = override;
244
245 process_fmt(cache, " byte_size(%" PRIu64 ")", value);
246 }
247}
248
249/* Match functions -- die_match_callback_t */
250#define DEFINE_MATCH(type) \
251 static bool match_##type##_type(Dwarf_Die *die) \
252 { \
253 return dwarf_tag(die) == DW_TAG_##type##_type; \
254 }
255
256DEFINE_MATCH(enumerator)
257DEFINE_MATCH(formal_parameter)
258DEFINE_MATCH(member)
259DEFINE_MATCH(subrange)
260
261bool match_all(Dwarf_Die *die)
262{
263 return true;
264}
265
266int process_die_container(struct state *state, struct die *cache,
267 Dwarf_Die *die, die_callback_t func,
268 die_match_callback_t match)
269{
270 Dwarf_Die current;
271 int res;
272
273 /* Track the first item in lists. */
274 if (state)
275 state->first_list_item = true;
276
277 res = checkp(dwarf_child(die, &current));
278 while (!res) {
279 if (match(&current)) {
280 /* <0 = error, 0 = continue, >0 = stop */
281 res = checkp(func(state, cache, &current));
282 if (res)
283 goto out;
284 }
285
286 res = checkp(dwarf_siblingof(&current, &current));
287 }
288
289 res = 0;
290out:
291 if (state)
292 state->first_list_item = false;
293
294 return res;
295}
296
297static int process_type(struct state *state, struct die *parent,
298 Dwarf_Die *die);
299
300static void process_type_attr(struct state *state, struct die *cache,
301 Dwarf_Die *die)
302{
303 Dwarf_Die type;
304
305 if (get_ref_die_attr(die, DW_AT_type, &type)) {
306 check(process_type(state, cache, &type));
307 return;
308 }
309
310 /* Compilers can omit DW_AT_type -- print out 'void' to clarify */
311 process(cache, "base_type void");
312}
313
314static void process_list_comma(struct state *state, struct die *cache)
315{
316 if (state->first_list_item) {
317 state->first_list_item = false;
318 } else {
319 process(cache, " ,");
320 process_linebreak(cache, 0);
321 }
322}
323
324/* Comma-separated with DW_AT_type */
325static void __process_list_type(struct state *state, struct die *cache,
326 Dwarf_Die *die, const char *type)
327{
328 const char *name = get_name_attr(die);
329
330 if (stable) {
331 if (is_kabi_prefix(name))
332 name = NULL;
333 state->kabi.orig_name = NULL;
334 }
335
336 process_list_comma(state, cache);
337 process(cache, type);
338 process_type_attr(state, cache, die);
339
340 if (stable && state->kabi.orig_name)
341 name = state->kabi.orig_name;
342 if (name) {
343 process(cache, " ");
344 process(cache, name);
345 }
346
347 process_accessibility_attr(cache, die);
348 process_bit_size_attr(cache, die);
349 process_data_bit_offset_attr(cache, die);
350 process_data_member_location_attr(cache, die);
351}
352
353#define DEFINE_PROCESS_LIST_TYPE(type) \
354 static void process_##type##_type(struct state *state, \
355 struct die *cache, Dwarf_Die *die) \
356 { \
357 __process_list_type(state, cache, die, #type " "); \
358 }
359
360DEFINE_PROCESS_LIST_TYPE(formal_parameter)
361DEFINE_PROCESS_LIST_TYPE(member)
362
363/* Container types with DW_AT_type */
364static void __process_type(struct state *state, struct die *cache,
365 Dwarf_Die *die, const char *type)
366{
367 process(cache, type);
368 process_fqn(cache, die);
369 process(cache, " {");
370 process_linebreak(cache, 1);
371 process_type_attr(state, cache, die);
372 process_linebreak(cache, -1);
373 process(cache, "}");
374 process_byte_size_attr(cache, die);
375 process_alignment_attr(cache, die);
376}
377
378#define DEFINE_PROCESS_TYPE(type) \
379 static void process_##type##_type(struct state *state, \
380 struct die *cache, Dwarf_Die *die) \
381 { \
382 __process_type(state, cache, die, #type "_type"); \
383 }
384
385DEFINE_PROCESS_TYPE(atomic)
386DEFINE_PROCESS_TYPE(const)
387DEFINE_PROCESS_TYPE(immutable)
388DEFINE_PROCESS_TYPE(packed)
389DEFINE_PROCESS_TYPE(pointer)
390DEFINE_PROCESS_TYPE(reference)
391DEFINE_PROCESS_TYPE(restrict)
392DEFINE_PROCESS_TYPE(rvalue_reference)
393DEFINE_PROCESS_TYPE(shared)
394DEFINE_PROCESS_TYPE(template_type_parameter)
395DEFINE_PROCESS_TYPE(volatile)
396DEFINE_PROCESS_TYPE(typedef)
397
398static void process_subrange_type(struct state *state, struct die *cache,
399 Dwarf_Die *die)
400{
401 Dwarf_Word count = 0;
402
403 if (get_udata_attr(die, DW_AT_count, &count))
404 process_fmt(cache, "[%" PRIu64 "]", count);
405 else if (get_udata_attr(die, DW_AT_upper_bound, &count))
406 process_fmt(cache, "[%" PRIu64 "]", count + 1);
407 else
408 process(cache, "[]");
409}
410
411static void process_array_type(struct state *state, struct die *cache,
412 Dwarf_Die *die)
413{
414 process(cache, "array_type");
415 /* Array size */
416 check(process_die_container(state, cache, die, process_type,
417 match_subrange_type));
418 process(cache, " {");
419 process_linebreak(cache, 1);
420 process_type_attr(state, cache, die);
421 process_linebreak(cache, -1);
422 process(cache, "}");
423}
424
425static void __process_subroutine_type(struct state *state, struct die *cache,
426 Dwarf_Die *die, const char *type)
427{
428 process(cache, type);
429 process(cache, " (");
430 process_linebreak(cache, 1);
431 /* Parameters */
432 check(process_die_container(state, cache, die, process_type,
433 match_formal_parameter_type));
434 process_linebreak(cache, -1);
435 process(cache, ")");
436 process_linebreak(cache, 0);
437 /* Return type */
438 process(cache, "-> ");
439 process_type_attr(state, cache, die);
440}
441
442static void process_subroutine_type(struct state *state, struct die *cache,
443 Dwarf_Die *die)
444{
445 __process_subroutine_type(state, cache, die, "subroutine_type");
446}
447
448static void process_variant_type(struct state *state, struct die *cache,
449 Dwarf_Die *die)
450{
451 process_list_comma(state, cache);
452 process(cache, "variant {");
453 process_linebreak(cache, 1);
454 check(process_die_container(state, cache, die, process_type,
455 match_member_type));
456 process_linebreak(cache, -1);
457 process(cache, "}");
458 process_discr_value_attr(cache, die);
459}
460
461static void process_variant_part_type(struct state *state, struct die *cache,
462 Dwarf_Die *die)
463{
464 process_list_comma(state, cache);
465 process(cache, "variant_part {");
466 process_linebreak(cache, 1);
467 check(process_die_container(state, cache, die, process_type,
468 match_all));
469 process_linebreak(cache, -1);
470 process(cache, "}");
471}
472
473static int get_kabi_status(Dwarf_Die *die, const char **suffix)
474{
475 const char *name = get_name_attr(die);
476
477 if (suffix)
478 *suffix = NULL;
479
480 if (is_kabi_prefix(name)) {
481 name += KABI_PREFIX_LEN;
482
483 if (!strncmp(name, KABI_RESERVED_PREFIX,
484 KABI_RESERVED_PREFIX_LEN))
485 return KABI_RESERVED;
486 if (!strncmp(name, KABI_IGNORED_PREFIX,
487 KABI_IGNORED_PREFIX_LEN))
488 return KABI_IGNORED;
489
490 if (!strncmp(name, KABI_RENAMED_PREFIX,
491 KABI_RENAMED_PREFIX_LEN)) {
492 if (suffix) {
493 name += KABI_RENAMED_PREFIX_LEN;
494 *suffix = name;
495 }
496 return KABI_RESERVED;
497 }
498 }
499
500 return KABI_NORMAL;
501}
502
503static int check_struct_member_kabi_status(struct state *state,
504 struct die *__unused, Dwarf_Die *die)
505{
506 int res;
507
508 assert(dwarf_tag(die) == DW_TAG_member_type);
509
510 /*
511 * If the union member is a struct, expect the __kabi field to
512 * be the first member of the structure, i.e..:
513 *
514 * union {
515 * type new_member;
516 * struct {
517 * type __kabi_field;
518 * }
519 * };
520 */
521 res = get_kabi_status(die, &state->kabi.orig_name);
522
523 if (res == KABI_RESERVED &&
524 !get_ref_die_attr(die, DW_AT_type, &state->kabi.placeholder))
525 error("structure member missing a type?");
526
527 return res;
528}
529
530static int check_union_member_kabi_status(struct state *state,
531 struct die *__unused, Dwarf_Die *die)
532{
533 Dwarf_Die type;
534 int res;
535
536 assert(dwarf_tag(die) == DW_TAG_member_type);
537
538 if (!get_ref_die_attr(die, DW_AT_type, &type))
539 error("union member missing a type?");
540
541 /*
542 * We expect a union with two members. Check if either of them
543 * has a __kabi name prefix, i.e.:
544 *
545 * union {
546 * ...
547 * type memberN; // <- type, N = {0,1}
548 * ...
549 * };
550 *
551 * The member can also be a structure type, in which case we'll
552 * check the first structure member.
553 *
554 * In any case, stop processing after we've seen two members.
555 */
556 res = get_kabi_status(die, &state->kabi.orig_name);
557
558 if (res == KABI_RESERVED)
559 state->kabi.placeholder = type;
560 if (res != KABI_NORMAL)
561 return res;
562
563 if (dwarf_tag(&type) == DW_TAG_structure_type)
564 res = checkp(process_die_container(
565 state, NULL, &type, check_struct_member_kabi_status,
566 match_member_type));
567
568 if (res <= KABI_NORMAL && ++state->kabi.members < 2)
569 return 0; /* Continue */
570
571 return res;
572}
573
574static int get_union_kabi_status(Dwarf_Die *die, Dwarf_Die *placeholder,
575 const char **orig_name)
576{
577 struct state state;
578 int res;
579
580 if (!stable)
581 return KABI_NORMAL;
582
583 /*
584 * To maintain a stable kABI, distributions may choose to reserve
585 * space in structs for later use by adding placeholder members,
586 * for example:
587 *
588 * struct s {
589 * u32 a;
590 * // an 8-byte placeholder for future use
591 * u64 __kabi_reserved_0;
592 * };
593 *
594 * When the reserved member is taken into use, the type change
595 * would normally cause the symbol version to change as well, but
596 * if the replacement uses the following convention, gendwarfksyms
597 * continues to use the placeholder type for versioning instead,
598 * thus maintaining the same symbol version:
599 *
600 * struct s {
601 * u32 a;
602 * union {
603 * // placeholder replaced with a new member `b`
604 * struct t b;
605 * struct {
606 * // the placeholder type that is still
607 * // used for versioning
608 * u64 __kabi_reserved_0;
609 * };
610 * };
611 * };
612 *
613 * I.e., as long as the replaced member is in a union, and the
614 * placeholder has a __kabi_reserved name prefix, we'll continue
615 * to use the placeholder type (here u64) for version calculation
616 * instead of the union type.
617 *
618 * It's also possible to ignore new members from versioning if
619 * they've been added to alignment holes, for example, by
620 * including them in a union with another member that uses the
621 * __kabi_ignored name prefix:
622 *
623 * struct s {
624 * u32 a;
625 * // an alignment hole is used to add `n`
626 * union {
627 * u32 n;
628 * // hide the entire union member from versioning
629 * u8 __kabi_ignored_0;
630 * };
631 * u64 b;
632 * };
633 *
634 * Note that the user of this feature is responsible for ensuring
635 * that the structure actually remains ABI compatible.
636 */
637 memset(&state.kabi, 0, sizeof(state.kabi));
638
639 res = checkp(process_die_container(&state, NULL, die,
640 check_union_member_kabi_status,
641 match_member_type));
642
643 if (res == KABI_RESERVED) {
644 if (placeholder)
645 *placeholder = state.kabi.placeholder;
646 if (orig_name)
647 *orig_name = state.kabi.orig_name;
648 }
649
650 return res;
651}
652
653static bool is_kabi_ignored(Dwarf_Die *die)
654{
655 Dwarf_Die type;
656
657 if (!stable)
658 return false;
659
660 if (!get_ref_die_attr(die, DW_AT_type, &type))
661 error("member missing a type?");
662
663 return dwarf_tag(&type) == DW_TAG_union_type &&
664 checkp(get_union_kabi_status(&type, NULL, NULL)) == KABI_IGNORED;
665}
666
667static int ___process_structure_type(struct state *state, struct die *cache,
668 Dwarf_Die *die)
669{
670 switch (dwarf_tag(die)) {
671 case DW_TAG_member:
672 if (is_kabi_ignored(die))
673 return 0;
674 return check(process_type(state, cache, die));
675 case DW_TAG_variant_part:
676 return check(process_type(state, cache, die));
677 case DW_TAG_class_type:
678 case DW_TAG_enumeration_type:
679 case DW_TAG_structure_type:
680 case DW_TAG_template_type_parameter:
681 case DW_TAG_union_type:
682 case DW_TAG_subprogram:
683 /* Skip non-member types, including member functions */
684 return 0;
685 default:
686 error("unexpected structure_type child: %x", dwarf_tag(die));
687 }
688}
689
690static void __process_structure_type(struct state *state, struct die *cache,
691 Dwarf_Die *die, const char *type,
692 die_callback_t process_func,
693 die_match_callback_t match_func)
694{
695 bool expand;
696
697 process(cache, type);
698 process_fqn(cache, die);
699 process(cache, " {");
700 process_linebreak(cache, 1);
701
702 expand = state->expand.expand && is_kabi_definition(cache, die);
703
704 if (expand) {
705 state->expand.current_fqn = cache->fqn;
706 check(process_die_container(state, cache, die, process_func,
707 match_func));
708 }
709
710 process_linebreak(cache, -1);
711 process(cache, "}");
712
713 if (expand) {
714 process_byte_size_attr(cache, die);
715 process_alignment_attr(cache, die);
716 }
717}
718
719#define DEFINE_PROCESS_STRUCTURE_TYPE(structure) \
720 static void process_##structure##_type( \
721 struct state *state, struct die *cache, Dwarf_Die *die) \
722 { \
723 __process_structure_type(state, cache, die, \
724 #structure "_type", \
725 ___process_structure_type, \
726 match_all); \
727 }
728
729DEFINE_PROCESS_STRUCTURE_TYPE(class)
730DEFINE_PROCESS_STRUCTURE_TYPE(structure)
731
732static void process_union_type(struct state *state, struct die *cache,
733 Dwarf_Die *die)
734{
735 Dwarf_Die placeholder;
736
737 int res = checkp(get_union_kabi_status(die, &placeholder,
738 &state->kabi.orig_name));
739
740 if (res == KABI_RESERVED)
741 check(process_type(state, cache, &placeholder));
742 if (res > KABI_NORMAL)
743 return;
744
745 __process_structure_type(state, cache, die, "union_type",
746 ___process_structure_type, match_all);
747}
748
749static void process_enumerator_type(struct state *state, struct die *cache,
750 Dwarf_Die *die)
751{
752 bool overridden = false;
753 unsigned long override;
754 Dwarf_Word value;
755
756 if (stable) {
757 /* Get the fqn before we process anything */
758 update_fqn(cache, die);
759
760 if (kabi_is_enumerator_ignored(state->expand.current_fqn,
761 cache->fqn))
762 return;
763
764 overridden = kabi_get_enumerator_value(
765 state->expand.current_fqn, cache->fqn, &override);
766 value = override;
767 }
768
769 process_list_comma(state, cache);
770 process(cache, "enumerator");
771 process_fqn(cache, die);
772
773 if (overridden || get_udata_attr(die, DW_AT_const_value, &value)) {
774 process(cache, " = ");
775 process_fmt(cache, "%" PRIu64, value);
776 }
777}
778
779static void process_enumeration_type(struct state *state, struct die *cache,
780 Dwarf_Die *die)
781{
782 __process_structure_type(state, cache, die, "enumeration_type",
783 process_type, match_enumerator_type);
784}
785
786static void process_base_type(struct state *state, struct die *cache,
787 Dwarf_Die *die)
788{
789 process(cache, "base_type");
790 process_fqn(cache, die);
791 process_byte_size_attr(cache, die);
792 process_encoding_attr(cache, die);
793 process_alignment_attr(cache, die);
794}
795
796static void process_unspecified_type(struct state *state, struct die *cache,
797 Dwarf_Die *die)
798{
799 /*
800 * These can be emitted for stand-alone assembly code, which means we
801 * might run into them in vmlinux.o.
802 */
803 process(cache, "unspecified_type");
804}
805
806static void process_cached(struct state *state, struct die *cache,
807 Dwarf_Die *die)
808{
809 struct die_fragment *df;
810 Dwarf_Die child;
811
812 list_for_each_entry(df, &cache->fragments, list) {
813 switch (df->type) {
814 case FRAGMENT_STRING:
815 die_debug_b("cache %p STRING '%s'", cache,
816 df->data.str);
817 process(NULL, df->data.str);
818 break;
819 case FRAGMENT_LINEBREAK:
820 process_linebreak(NULL, df->data.linebreak);
821 break;
822 case FRAGMENT_DIE:
823 if (!dwarf_die_addr_die(dwarf_cu_getdwarf(die->cu),
824 (void *)df->data.addr, &child))
825 error("dwarf_die_addr_die failed");
826 die_debug_b("cache %p DIE addr %" PRIxPTR " tag %x",
827 cache, df->data.addr, dwarf_tag(&child));
828 check(process_type(state, NULL, &child));
829 break;
830 default:
831 error("empty die_fragment");
832 }
833 }
834}
835
836static void state_init(struct state *state)
837{
838 state->expand.expand = true;
839 state->expand.current_fqn = NULL;
840 cache_init(&state->expansion_cache);
841}
842
843static void expansion_state_restore(struct expansion_state *state,
844 struct expansion_state *saved)
845{
846 state->expand = saved->expand;
847 state->current_fqn = saved->current_fqn;
848}
849
850static void expansion_state_save(struct expansion_state *state,
851 struct expansion_state *saved)
852{
853 expansion_state_restore(saved, state);
854}
855
856static bool is_expanded_type(int tag)
857{
858 return tag == DW_TAG_class_type || tag == DW_TAG_structure_type ||
859 tag == DW_TAG_union_type || tag == DW_TAG_enumeration_type;
860}
861
862#define PROCESS_TYPE(type) \
863 case DW_TAG_##type##_type: \
864 process_##type##_type(state, cache, die); \
865 break;
866
867static int process_type(struct state *state, struct die *parent, Dwarf_Die *die)
868{
869 enum die_state want_state = DIE_COMPLETE;
870 struct die *cache;
871 struct expansion_state saved;
872 int tag = dwarf_tag(die);
873
874 expansion_state_save(&state->expand, &saved);
875
876 /*
877 * Structures and enumeration types are expanded only once per
878 * exported symbol. This is sufficient for detecting ABI changes
879 * within the structure.
880 */
881 if (is_expanded_type(tag)) {
882 if (cache_was_expanded(&state->expansion_cache, die->addr))
883 state->expand.expand = false;
884
885 if (state->expand.expand)
886 cache_mark_expanded(&state->expansion_cache, die->addr);
887 else
888 want_state = DIE_UNEXPANDED;
889 }
890
891 /*
892 * If we have want_state already cached, use it instead of walking
893 * through DWARF.
894 */
895 cache = die_map_get(die, want_state);
896
897 if (cache->state == want_state) {
898 die_debug_g("cached addr %p tag %x -- %s", die->addr, tag,
899 die_state_name(cache->state));
900
901 process_cached(state, cache, die);
902 die_map_add_die(parent, cache);
903
904 expansion_state_restore(&state->expand, &saved);
905 return 0;
906 }
907
908 die_debug_g("addr %p tag %x -- %s -> %s", die->addr, tag,
909 die_state_name(cache->state), die_state_name(want_state));
910
911 switch (tag) {
912 /* Type modifiers */
913 PROCESS_TYPE(atomic)
914 PROCESS_TYPE(const)
915 PROCESS_TYPE(immutable)
916 PROCESS_TYPE(packed)
917 PROCESS_TYPE(pointer)
918 PROCESS_TYPE(reference)
919 PROCESS_TYPE(restrict)
920 PROCESS_TYPE(rvalue_reference)
921 PROCESS_TYPE(shared)
922 PROCESS_TYPE(volatile)
923 /* Container types */
924 PROCESS_TYPE(class)
925 PROCESS_TYPE(structure)
926 PROCESS_TYPE(union)
927 PROCESS_TYPE(enumeration)
928 /* Subtypes */
929 PROCESS_TYPE(enumerator)
930 PROCESS_TYPE(formal_parameter)
931 PROCESS_TYPE(member)
932 PROCESS_TYPE(subrange)
933 PROCESS_TYPE(template_type_parameter)
934 PROCESS_TYPE(variant)
935 PROCESS_TYPE(variant_part)
936 /* Other types */
937 PROCESS_TYPE(array)
938 PROCESS_TYPE(base)
939 PROCESS_TYPE(subroutine)
940 PROCESS_TYPE(typedef)
941 PROCESS_TYPE(unspecified)
942 default:
943 error("unexpected type: %x", tag);
944 }
945
946 die_debug_r("parent %p cache %p die addr %p tag %x", parent, cache,
947 die->addr, tag);
948
949 /* Update cache state and append to the parent (if any) */
950 cache->tag = tag;
951 cache->state = want_state;
952 die_map_add_die(parent, cache);
953
954 expansion_state_restore(&state->expand, &saved);
955 return 0;
956}
957
958/*
959 * Exported symbol processing
960 */
961static struct die *get_symbol_cache(struct state *state, Dwarf_Die *die)
962{
963 struct die *cache;
964
965 cache = die_map_get(die, DIE_SYMBOL);
966
967 if (cache->state != DIE_INCOMPLETE)
968 return NULL; /* We already processed a symbol for this DIE */
969
970 cache->tag = dwarf_tag(die);
971 return cache;
972}
973
974static void process_symbol(struct state *state, Dwarf_Die *die,
975 die_callback_t process_func)
976{
977 struct die *cache;
978
979 symbol_set_die(state->sym, die);
980
981 cache = get_symbol_cache(state, die);
982 if (!cache)
983 return;
984
985 debug("%s", state->sym->name);
986 check(process_func(state, cache, die));
987 cache->state = DIE_SYMBOL;
988 if (dump_dies)
989 fputs("\n", stderr);
990}
991
992static int __process_subprogram(struct state *state, struct die *cache,
993 Dwarf_Die *die)
994{
995 __process_subroutine_type(state, cache, die, "subprogram");
996 return 0;
997}
998
999static void process_subprogram(struct state *state, Dwarf_Die *die)
1000{
1001 process_symbol(state, die, __process_subprogram);
1002}
1003
1004static int __process_variable(struct state *state, struct die *cache,
1005 Dwarf_Die *die)
1006{
1007 process(cache, "variable ");
1008 process_type_attr(state, cache, die);
1009 return 0;
1010}
1011
1012static void process_variable(struct state *state, Dwarf_Die *die)
1013{
1014 process_symbol(state, die, __process_variable);
1015}
1016
1017static void save_symbol_ptr(struct state *state)
1018{
1019 Dwarf_Die ptr_type;
1020 Dwarf_Die type;
1021
1022 if (!get_ref_die_attr(&state->die, DW_AT_type, &ptr_type) ||
1023 dwarf_tag(&ptr_type) != DW_TAG_pointer_type)
1024 error("%s must be a pointer type!",
1025 get_symbol_name(&state->die));
1026
1027 if (!get_ref_die_attr(&ptr_type, DW_AT_type, &type))
1028 error("%s pointer missing a type attribute?",
1029 get_symbol_name(&state->die));
1030
1031 /*
1032 * Save the symbol pointer DIE in case the actual symbol is
1033 * missing from the DWARF. Clang, for example, intentionally
1034 * omits external symbols from the debugging information.
1035 */
1036 if (dwarf_tag(&type) == DW_TAG_subroutine_type)
1037 symbol_set_ptr(state->sym, &type);
1038 else
1039 symbol_set_ptr(state->sym, &ptr_type);
1040}
1041
1042static int process_exported_symbols(struct state *unused, struct die *cache,
1043 Dwarf_Die *die)
1044{
1045 int tag = dwarf_tag(die);
1046
1047 switch (tag) {
1048 /* Possible containers of exported symbols */
1049 case DW_TAG_namespace:
1050 case DW_TAG_class_type:
1051 case DW_TAG_structure_type:
1052 return check(process_die_container(
1053 NULL, cache, die, process_exported_symbols, match_all));
1054
1055 /* Possible exported symbols */
1056 case DW_TAG_subprogram:
1057 case DW_TAG_variable: {
1058 struct state state;
1059
1060 if (!match_export_symbol(&state, die))
1061 return 0;
1062
1063 state_init(&state);
1064
1065 if (is_symbol_ptr(get_symbol_name(&state.die)))
1066 save_symbol_ptr(&state);
1067 else if (tag == DW_TAG_subprogram)
1068 process_subprogram(&state, &state.die);
1069 else
1070 process_variable(&state, &state.die);
1071
1072 cache_free(&state.expansion_cache);
1073 return 0;
1074 }
1075 default:
1076 return 0;
1077 }
1078}
1079
1080static void process_symbol_ptr(struct symbol *sym, void *arg)
1081{
1082 struct state state;
1083 Dwarf *dwarf = arg;
1084
1085 if (sym->state != SYMBOL_UNPROCESSED || !sym->ptr_die_addr)
1086 return;
1087
1088 debug("%s", sym->name);
1089 state_init(&state);
1090 state.sym = sym;
1091
1092 if (!dwarf_die_addr_die(dwarf, (void *)sym->ptr_die_addr, &state.die))
1093 error("dwarf_die_addr_die failed for symbol ptr: '%s'",
1094 sym->name);
1095
1096 if (dwarf_tag(&state.die) == DW_TAG_subroutine_type)
1097 process_subprogram(&state, &state.die);
1098 else
1099 process_variable(&state, &state.die);
1100
1101 cache_free(&state.expansion_cache);
1102}
1103
1104static int resolve_fqns(struct state *parent, struct die *unused,
1105 Dwarf_Die *die)
1106{
1107 struct state state;
1108 struct die *cache;
1109 const char *name;
1110 bool use_prefix;
1111 char *prefix = NULL;
1112 char *fqn = "";
1113 int tag;
1114
1115 if (!__die_map_get((uintptr_t)die->addr, DIE_FQN, &cache))
1116 return 0;
1117
1118 tag = dwarf_tag(die);
1119
1120 /*
1121 * Only namespaces and structures need to pass a prefix to the next
1122 * scope.
1123 */
1124 use_prefix = tag == DW_TAG_namespace || tag == DW_TAG_class_type ||
1125 tag == DW_TAG_structure_type;
1126
1127 state.expand.current_fqn = NULL;
1128 name = get_name_attr(die);
1129
1130 if (parent && parent->expand.current_fqn && (use_prefix || name)) {
1131 /*
1132 * The fqn for the current DIE, and if needed, a prefix for the
1133 * next scope.
1134 */
1135 if (asprintf(&prefix, "%s::%s", parent->expand.current_fqn,
1136 name ? name : "<anonymous>") < 0)
1137 error("asprintf failed");
1138
1139 if (use_prefix)
1140 state.expand.current_fqn = prefix;
1141
1142 /*
1143 * Use fqn only if the DIE has a name. Otherwise fqn will
1144 * remain empty.
1145 */
1146 if (name) {
1147 fqn = prefix;
1148 /* prefix will be freed by die_map. */
1149 prefix = NULL;
1150 }
1151 } else if (name) {
1152 /* No prefix from the previous scope. Use only the name. */
1153 fqn = xstrdup(name);
1154
1155 if (use_prefix)
1156 state.expand.current_fqn = fqn;
1157 }
1158
1159 /* If the DIE has a non-empty name, cache it. */
1160 if (*fqn) {
1161 cache = die_map_get(die, DIE_FQN);
1162 /* Move ownership of fqn to die_map. */
1163 cache->fqn = fqn;
1164 cache->state = DIE_FQN;
1165 }
1166
1167 check(process_die_container(&state, NULL, die, resolve_fqns,
1168 match_all));
1169
1170 free(prefix);
1171 return 0;
1172}
1173
1174void process_cu(Dwarf_Die *cudie)
1175{
1176 check(process_die_container(NULL, NULL, cudie, resolve_fqns,
1177 match_all));
1178
1179 check(process_die_container(NULL, NULL, cudie, process_exported_symbols,
1180 match_all));
1181
1182 symbol_for_each(process_symbol_ptr, dwarf_cu_getdwarf(cudie->cu));
1183
1184 cache_free(&srcfile_cache);
1185}