Commit f6bb9245 authored by Sami Tolvanen's avatar Sami Tolvanen Committed by Masahiro Yamada
Browse files

gendwarfksyms: Expand structure types 



Recursively expand DWARF structure types, i.e. structs, unions, and
enums. Also include relevant DWARF attributes in type strings to
encode structure layout, for example.

Example output with --dump-dies:

  subprogram (
    formal_parameter structure_type &str {
      member pointer_type {
        base_type u8 byte_size(1) encoding(7)
      } data_ptr data_member_location(0) ,
      member base_type usize byte_size(8) encoding(7) length data_member_location(8)
    } byte_size(16) alignment(8) msg
  )
  -> base_type void

Signed-off-by: default avatarSami Tolvanen <samitolvanen@google.com>
Reviewed-by: default avatarPetr Pavlu <petr.pavlu@suse.com>
Signed-off-by: default avatarMasahiro Yamada <masahiroy@kernel.org>
parent c772f1d1

scripts/gendwarfksyms/dwarf.c

+136 −2
Original line number Diff line number Diff line
@@ -208,9 +208,14 @@ static void process_fqn(struct die *cache, Dwarf_Die *die) 
				    value);                                \

	}



DEFINE_PROCESS_UDATA_ATTRIBUTE(accessibility)

DEFINE_PROCESS_UDATA_ATTRIBUTE(alignment)

DEFINE_PROCESS_UDATA_ATTRIBUTE(bit_size)

DEFINE_PROCESS_UDATA_ATTRIBUTE(byte_size)

DEFINE_PROCESS_UDATA_ATTRIBUTE(encoding)

DEFINE_PROCESS_UDATA_ATTRIBUTE(data_bit_offset)

DEFINE_PROCESS_UDATA_ATTRIBUTE(data_member_location)

DEFINE_PROCESS_UDATA_ATTRIBUTE(discr_value)



/* Match functions -- die_match_callback_t */

#define DEFINE_MATCH(type)                                     \
@@ -219,7 +224,9 @@ DEFINE_PROCESS_UDATA_ATTRIBUTE(encoding) 
		return dwarf_tag(die) == DW_TAG_##type##_type; \

	}



DEFINE_MATCH(enumerator)

DEFINE_MATCH(formal_parameter)

DEFINE_MATCH(member)

DEFINE_MATCH(subrange)



bool match_all(Dwarf_Die *die)
@@ -298,6 +305,10 @@ static void __process_list_type(struct state *state, struct die *cache, 
		process(cache, " ");

		process(cache, name);

	}

	process_accessibility_attr(cache, die);

	process_bit_size_attr(cache, die);

	process_data_bit_offset_attr(cache, die);

	process_data_member_location_attr(cache, die);

}



#define DEFINE_PROCESS_LIST_TYPE(type)                                       \
@@ -308,6 +319,7 @@ static void __process_list_type(struct state *state, struct die *cache, 
	}



DEFINE_PROCESS_LIST_TYPE(formal_parameter)

DEFINE_PROCESS_LIST_TYPE(member)



/* Container types with DW_AT_type */

static void __process_type(struct state *state, struct die *cache,
@@ -340,6 +352,7 @@ DEFINE_PROCESS_TYPE(reference) 
DEFINE_PROCESS_TYPE(restrict)

DEFINE_PROCESS_TYPE(rvalue_reference)

DEFINE_PROCESS_TYPE(shared)

DEFINE_PROCESS_TYPE(template_type_parameter)

DEFINE_PROCESS_TYPE(volatile)

DEFINE_PROCESS_TYPE(typedef)
@@ -393,6 +406,107 @@ static void process_subroutine_type(struct state *state, struct die *cache, 
	__process_subroutine_type(state, cache, die, "subroutine_type");

}



static void process_variant_type(struct state *state, struct die *cache,

				 Dwarf_Die *die)

{

	process_list_comma(state, cache);

	process(cache, "variant {");

	process_linebreak(cache, 1);

	check(process_die_container(state, cache, die, process_type,

				    match_member_type));

	process_linebreak(cache, -1);

	process(cache, "}");

	process_discr_value_attr(cache, die);

}



static void process_variant_part_type(struct state *state, struct die *cache,

				      Dwarf_Die *die)

{

	process_list_comma(state, cache);

	process(cache, "variant_part {");

	process_linebreak(cache, 1);

	check(process_die_container(state, cache, die, process_type,

				    match_all));

	process_linebreak(cache, -1);

	process(cache, "}");

}



static int ___process_structure_type(struct state *state, struct die *cache,

				     Dwarf_Die *die)

{

	switch (dwarf_tag(die)) {

	case DW_TAG_member:

	case DW_TAG_variant_part:

		return check(process_type(state, cache, die));

	case DW_TAG_class_type:

	case DW_TAG_enumeration_type:

	case DW_TAG_structure_type:

	case DW_TAG_template_type_parameter:

	case DW_TAG_union_type:

	case DW_TAG_subprogram:

		/* Skip non-member types, including member functions */

		return 0;

	default:

		error("unexpected structure_type child: %x", dwarf_tag(die));

	}

}



static void __process_structure_type(struct state *state, struct die *cache,

				     Dwarf_Die *die, const char *type,

				     die_callback_t process_func,

				     die_match_callback_t match_func)

{

	process(cache, type);

	process_fqn(cache, die);

	process(cache, " {");

	process_linebreak(cache, 1);



	check(process_die_container(state, cache, die, process_func,

				    match_func));



	process_linebreak(cache, -1);

	process(cache, "}");



	process_byte_size_attr(cache, die);

	process_alignment_attr(cache, die);

}



#define DEFINE_PROCESS_STRUCTURE_TYPE(structure)                        \

	static void process_##structure##_type(                         \

		struct state *state, struct die *cache, Dwarf_Die *die) \

	{                                                               \

		__process_structure_type(state, cache, die,             \

					 #structure "_type",            \

					 ___process_structure_type,     \

					 match_all);                    \

	}



DEFINE_PROCESS_STRUCTURE_TYPE(class)

DEFINE_PROCESS_STRUCTURE_TYPE(structure)

DEFINE_PROCESS_STRUCTURE_TYPE(union)



static void process_enumerator_type(struct state *state, struct die *cache,

				    Dwarf_Die *die)

{

	Dwarf_Word value;



	process_list_comma(state, cache);

	process(cache, "enumerator");

	process_fqn(cache, die);



	if (get_udata_attr(die, DW_AT_const_value, &value)) {

		process(cache, " = ");

		process_fmt(cache, "%" PRIu64, value);

	}

}



static void process_enumeration_type(struct state *state, struct die *cache,

				     Dwarf_Die *die)

{

	__process_structure_type(state, cache, die, "enumeration_type",

				 process_type, match_enumerator_type);

}



static void process_base_type(struct state *state, struct die *cache,

			      Dwarf_Die *die)

{
@@ -403,6 +517,16 @@ static void process_base_type(struct state *state, struct die *cache, 
	process_alignment_attr(cache, die);

}



static void process_unspecified_type(struct state *state, struct die *cache,

				     Dwarf_Die *die)

{

	/*

	 * These can be emitted for stand-alone assembly code, which means we

	 * might run into them in vmlinux.o.

	 */

	process(cache, "unspecified_type");

}



static void process_cached(struct state *state, struct die *cache,

			   Dwarf_Die *die)

{
@@ -463,17 +587,27 @@ static int process_type(struct state *state, struct die *parent, Dwarf_Die *die) 
	PROCESS_TYPE(rvalue_reference)

	PROCESS_TYPE(shared)

	PROCESS_TYPE(volatile)

	/* Container types */

	PROCESS_TYPE(class)

	PROCESS_TYPE(structure)

	PROCESS_TYPE(union)

	PROCESS_TYPE(enumeration)

	/* Subtypes */

	PROCESS_TYPE(enumerator)

	PROCESS_TYPE(formal_parameter)

	PROCESS_TYPE(member)

	PROCESS_TYPE(subrange)

	PROCESS_TYPE(template_type_parameter)

	PROCESS_TYPE(variant)

	PROCESS_TYPE(variant_part)

	/* Other types */

	PROCESS_TYPE(array)

	PROCESS_TYPE(base)

	PROCESS_TYPE(subroutine)

	PROCESS_TYPE(typedef)

	PROCESS_TYPE(unspecified)

	default:

		debug("unimplemented type: %x", tag);

		break;

		error("unexpected type: %x", tag);

	}



	/* Update cache state and append to the parent (if any) */

scripts/gendwarfksyms/gendwarfksyms.h

+5 −0
Original line number Diff line number Diff line
@@ -60,8 +60,13 @@ extern int dump_dies; 
#define checkp(expr) __check(expr, __res < 0)



/* Consistent aliases (DW_TAG_<type>_type) for DWARF tags */

#define DW_TAG_enumerator_type DW_TAG_enumerator

#define DW_TAG_formal_parameter_type DW_TAG_formal_parameter

#define DW_TAG_member_type DW_TAG_member

#define DW_TAG_template_type_parameter_type DW_TAG_template_type_parameter

#define DW_TAG_typedef_type DW_TAG_typedef

#define DW_TAG_variant_part_type DW_TAG_variant_part

#define DW_TAG_variant_type DW_TAG_variant



/*

 * symbols.c