btf: support btf_type_tag attribute
Subsystems (2)
cover btf: support btf_type_tag attribute
btf_type_tag is a new llvm type attribute which is used similar to kernel __user/__rcu attributes. The format of btf_type_tag looks like
__attribute__((btf_type_tag("tag1")))
For the case where the attribute applied to a pointee like
#define __tag1 __attribute__((btf_type_tag("tag1"))) #define __tag2 __attribute__((btf_type_tag("tag2")))
int __tag1 * __tag1 __tag2 *g;
the information will be encoded in dwarf.
In BTF, the attribute is encoded as a new kind BTF_KIND_TYPE_TAG and latest bpf-next supports it.
The patch added support in pahole, specifically converts llvm dwarf btf_type_tag attributes to BTF types. Please see individual patches for details.
Yonghong Song (4):
libbpf: sync with latest libbpf repo
dutil: move DW_TAG_LLVM_annotation definition to dutil.h
dwarf_loader: support btf_type_tag attribute
btf_encoder: support btf_type_tag attribute
btf_encoder.c | 7 +++ dutil.h | 4 ++ dwarf_loader.c | 120 ++++++++++++++++++++++++++++++++++++++++++++++--- dwarves.h | 38 +++++++++++++++- lib/bpf | 2 +- pahole.c | 8 ++++ 6 files changed, 170 insertions(+), 9 deletions(-)
Signature · 1 line
2.30.2
PATCH 1/4 libbpf: sync with latest libbpf repo
Sync up to commit 94a49850c5ee ("Makefile: enforce gnu89 standard"). This is needed to support BTF_KIND_TYPE_TAG.
--- lib/bpf | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
lib/bpf +1 -1
@@ -1 +1 @@ -Subproject commit f05791d8cfcbbf9092b4099b9d011bb72e241ef8 +Subproject commit 94a49850c5ee61ea02dfcbabf48013391e8cecdf
Signature · 1 line
2.30.2
PATCH 2/4 dutil: move DW_TAG_LLVM_annotation definition to dutil.h
In reply to Yonghong SongMove DW_TAG_LLVM_annotation definition from dwarf_load.c to dutil.h as it will be used later for btf_encoder.c. There is no functionality change for this patch.
--- dutil.h | 4 ++++ dwarf_loader.c | 4 ---- 2 files changed, 4 insertions(+), 4 deletions(-)
dutil.h +4 -0
@@ -31,6 +31,10 @@#define roundup (x,y) ((((x) + ((y) - 1)) / (y)) * (y)) +#ifndef DW_TAG_LLVM_annotation +#define DW_TAG_LLVM_annotation 0x6000 +#endif +static inline __attribute__((const))bool is_power_of_2 (unsigned long n) {return (n !=0 && ((n & (n -1 )) ==0 ));
dwarf_loader.c +0 -4
@@ -52,10 +52,6 @@#define DW_OP_addrx 0xa1#endif -#ifndef DW_TAG_LLVM_annotation -#define DW_TAG_LLVM_annotation 0x6000 -#endif -static pthread_mutex_t libdw__lock =PTHREAD_MUTEX_INITIALIZER ;static uint32_t hashtags__bits =12 ;
Signature · 1 line
2.30.2
PATCH 3/4 dwarf_loader: support btf_type_tag attribute
In reply to Yonghong SongLLVM patches ([1] for clang, [2] and [3] for BPF backend) added support for btf_type_tag attributes. The following is
an example:
[$ ~] cat t.c
#define __tag1 __attribute__((btf_type_tag("tag1")))
#define __tag2 __attribute__((btf_type_tag("tag2")))
int __tag1 * __tag1 __tag2 *g __attribute__((section(".data..percpu"))); [$ ~] clang -O2 -g -c t.c
[$ ~] llvm-dwarfdump --debug-info t.o
t.o: file format elf64-x86-64
...
0x0000001e: DW_TAG_variable
DW_AT_name ("g")
DW_AT_type (0x00000033 "int **")
DW_AT_external (true)
DW_AT_decl_file ("/home/yhs/t.c")
DW_AT_decl_line (3)
DW_AT_location (DW_OP_addr 0x0)
0x00000033: DW_TAG_pointer_type
DW_AT_type (0x0000004b "int *")
0x00000038: DW_TAG_LLVM_annotation
DW_AT_name ("btf_type_tag")
DW_AT_const_value ("tag1")
0x00000041: DW_TAG_LLVM_annotation
DW_AT_name ("btf_type_tag")
DW_AT_const_value ("tag2")
0x0000004a: NULL
0x0000004b: DW_TAG_pointer_type
DW_AT_type (0x0000005a "int")
0x00000050: DW_TAG_LLVM_annotation
DW_AT_name ("btf_type_tag")
DW_AT_const_value ("tag1")
0x00000059: NULL
0x0000005a: DW_TAG_base_type
DW_AT_name ("int")
DW_AT_encoding (DW_ATE_signed)
DW_AT_byte_size (0x04) 0x00000061: NULL
From the above example, you can see that DW_TAG_pointer_type may contain one or more DW_TAG_LLVM_annotation btf_type_tag tags. If DW_TAG_LLVM_annotation tags are present inside DW_TAG_pointer_type, for BTF encoding, pahole will need to follow [3] to generate a type chain like
var -> ptr -> tag2 -> tag1 -> ptr -> tag1 -> int
This patch implemented dwarf_loader support. If a pointer type contains DW_TAG_LLVM_annotation tags, a new type btf_type_tag_ptr_type will be created which will store the pointer tag itself and all DW_TAG_LLVM_annotation tags. During recoding stage, the type chain will be formed properly based on the above example.
An option "--skip_encoding_btf_type_tag" is added to disable this new functionality.
[1] https://reviews.llvm.org/D111199
[2] https://reviews.llvm.org/D113222
[3] https://reviews.llvm.org/D113496
--- dwarf_loader.c | 116 +++++++++++++++++++++++++++++++++++++++++++++++-- dwarves.h | 33 +++++++++++++- pahole.c | 8 ++++ 3 files changed, 153 insertions(+), 4 deletions(-)
dwarf_loader.c +113 -3
@@ -1206,6 +1206,88 @@ static struct tag *die__create_new_tag(Dwarf_Die *die, struct cu *cu)return tag; } +static struct btf_type_tag_ptr_type *die__create_new_btf_type_tag_ptr_type (Dwarf_Die *die,struct cu *cu) +{ +struct btf_type_tag_ptr_type *tag; + + tag =tag__alloc_with_spec (cu,sizeof (struct btf_type_tag_ptr_type )); +if (tag ==NULL ) +return NULL ; + +tag__init (&tag->tag, cu, die); + tag->tag.has_btf_type_tag = true; +INIT_LIST_HEAD (&tag->tags); +return tag; +} + +static struct btf_type_tag_type *die__create_new_btf_type_tag_type (Dwarf_Die *die,struct cu *cu, +struct conf_load *conf) +{ +struct btf_type_tag_type *tag; + + tag =tag__alloc_with_spec (cu,sizeof (struct btf_type_tag_type )); +if (tag ==NULL ) +return NULL ; + +tag__init (&tag->tag, cu, die); + tag->value =attr_string (die, DW_AT_const_value, conf); +return tag; +} + +static struct tag *die__create_new_pointer_tag (Dwarf_Die *die,struct cu *cu, +struct conf_load *conf) +{ +struct btf_type_tag_ptr_type *tag =NULL ; +struct btf_type_tag_type *annot; +Dwarf_Die *cdie, child; +const char *name; +uint32_t id; + +/* If no child tags or skipping btf_type_tag encoding, just create a new tag +* and return +*/ +if (!dwarf_haschildren (die) ||dwarf_child (die, &child) !=0 || + conf->skip_encoding_btf_type_tag) +return tag__new (die, cu); + +/* Otherwise, check DW_TAG_LLVM_annotation child tags */ + cdie = &child; +do { +if (dwarf_tag (cdie) == DW_TAG_LLVM_annotation) { +/* Only check btf_type_tag annotations */ + name =attr_string (cdie, DW_AT_name, conf); +if (strcmp (name,"btf_type_tag" ) !=0 ) +continue ; + +if (tag ==NULL ) { +/* Create a btf_type_tag_ptr type. */ + tag =die__create_new_btf_type_tag_ptr_type (die, cu); +if (!tag) +return NULL ; + } + +/* Create a btf_type_tag type for this annotation. */ + annot =die__create_new_btf_type_tag_type (cdie, cu, conf); +if (annot ==NULL ) +return NULL ; + +if (cu__table_add_tag (cu, &annot->tag, &id) <0 ) +return NULL ; + +struct dwarf_tag *dtag = annot->tag.priv; + dtag->small_id = id; +cu__hash (cu, &annot->tag); + +/* For a list of DW_TAG_LLVM_annotation like tag1 -> tag2 -> tag3, +* the tag->tags contains tag3 -> tag2 -> tag1. +*/ +list_add (&annot->node, &tag->tags); + } + }while (dwarf_siblingof (cdie, cdie) ==0 ); + +return tag ? &tag->tag :tag__new (die, cu); +} +static struct tag *die__create_new_ptr_to_member_type (Dwarf_Die *die,struct cu *cu) {
@@ -1903,12 +1985,13 @@ static struct tag *__die__process_tag(Dwarf_Die *die, struct cu *cu,case DW_TAG_const_type:case DW_TAG_imported_declaration:case DW_TAG_imported_module: -case DW_TAG_pointer_type:case DW_TAG_reference_type:case DW_TAG_restrict_type:case DW_TAG_unspecified_type:case DW_TAG_volatile_type: tag =die__create_new_tag (die, cu);break ; +case DW_TAG_pointer_type: + tag =die__create_new_pointer_tag (die, cu, conf);break ;case DW_TAG_ptr_to_member_type: tag =die__create_new_ptr_to_member_type (die, cu);break ;case DW_TAG_enumeration_type:
@@ -2192,6 +2275,26 @@ static void lexblock__recode_dwarf_types(struct lexblock *tag, struct cu *cu) } } +static void dwarf_cu__recode_btf_type_tag_ptr (struct btf_type_tag_ptr_type *tag, +uint32_t pointee_type) +{ +struct btf_type_tag_type *annot; +struct dwarf_tag *annot_dtag; +struct tag *prev_tag; + +/* If tag->tags contains tag3 -> tag2 -> tag1, the final type chain +* looks like: +* pointer -> tag3 -> tag2 -> tag1 -> pointee +*/ + prev_tag = &tag->tag; +list_for_each_entry (annot, &tag->tags, node) { + annot_dtag = annot->tag.priv; + prev_tag->type = annot_dtag->small_id; + prev_tag = &annot->tag; + } + prev_tag->type = pointee_type; +} +static int tag__recode_dwarf_type (struct tag *tag,struct cu *cu) {struct dwarf_tag *dtag = tag->priv;
@@ -2301,7 +2404,10 @@ static int tag__recode_dwarf_type(struct tag *tag, struct cu *cu) }if (dtag->type.off ==0 ) { - tag->type =0 ;/* void */ +if (tag->tag != DW_TAG_pointer_type || !tag->has_btf_type_tag) + tag->type =0 ;/* void */ +else +dwarf_cu__recode_btf_type_tag_ptr (tag__btf_type_tag_ptr (tag),0 );return 0 ; }
@@ -2313,7 +2419,11 @@ check_type:return 0 ; } out: - tag->type = dtype->small_id; +if (tag->tag != DW_TAG_pointer_type || !tag->has_btf_type_tag) + tag->type = dtype->small_id; +else +dwarf_cu__recode_btf_type_tag_ptr (tag__btf_type_tag_ptr (tag), dtype->small_id); +return 0 ; }
dwarves.h +32 -1
@@ -63,6 +63,7 @@ struct conf_load {bool ptr_table_stats;bool skip_encoding_btf_decl_tag;bool skip_missing; +bool skip_encoding_btf_type_tag;uint8_t hashtable_bits;uint8_t max_hashtable_bits;uint16_t kabi_prefix_len;
@@ -413,6 +414,7 @@ struct tag {uint16_t tag;bool visited;bool top_level; +bool has_btf_type_tag;uint16_t recursivity_level;void *priv; };
@@ -533,7 +535,8 @@ static inline int tag__is_tag_type(const struct tag *tag) tag->tag == DW_TAG_restrict_type || tag->tag == DW_TAG_subroutine_type || tag->tag == DW_TAG_unspecified_type || - tag->tag == DW_TAG_volatile_type; + tag->tag == DW_TAG_volatile_type || + tag->tag == DW_TAG_LLVM_annotation; } static inline const char *tag__decl_file(const struct tag *tag,
@@ -606,6 +609,34 @@ struct llvm_annotation {struct list_head node; }; +/** struct btf_type_tag_type - representing a btf_type_tag annotation +* +* @tag - DW_TAG_LLVM_annotation tag +* @value - btf_type_tag value string +* @node - list_head node +*/ +struct btf_type_tag_type { +struct tag tag; +const char *value; +struct list_head node; +}; + +/** The struct btf_type_tag_ptr_type - type containing both pointer type and +* its btf_type_tag annotations +* +* @tag - pointer type tag +* @tags - btf_type_tag annotations for the pointer type +*/ +struct btf_type_tag_ptr_type { +struct tag tag; +struct list_head tags; +}; + +static inline struct btf_type_tag_ptr_type *tag__btf_type_tag_ptr (struct tag *tag) +{ +return (struct btf_type_tag_ptr_type *)tag; +} +/** struct namespace - base class for enums, structs, unions, typedefs, etc * * @tags - class_member, enumerators, etc
pahole.c +8 -0
@@ -1126,6 +1126,7 @@ ARGP_PROGRAM_VERSION_HOOK_DEF = dwarves_print_version;#define ARGP_devel_stats 330#define ARGP_skip_encoding_btf_decl_tag 331#define ARGP_skip_missing 332 +#define ARGP_skip_encoding_btf_type_tag 333static const struct argp_option pahole__options[] = { {
@@ -1506,6 +1507,11 @@ static const struct argp_option pahole__options[] = { .key = ARGP_skip_missing, .doc = "skip missing types passed to -C rather than stop", }, + { + .name = "skip_encoding_btf_type_tag", + .key = ARGP_skip_encoding_btf_type_tag, + .doc = "Do not encode TAGs in BTF." + }, { .name = NULL, }
@@ -1658,6 +1664,8 @@ static error_t pahole__options_parser(int key, char *arg, conf_load.skip_encoding_btf_decl_tag = true;break ;case ARGP_skip_missing: conf_load.skip_missing = true;break ; +case ARGP_skip_encoding_btf_type_tag: + conf_load.skip_encoding_btf_type_tag = true;break ;default :return ARGP_ERR_UNKNOWN ; }
Signature · 1 line
2.30.2
Re: [PATCH dwarves 3/4] dwarf_loader: support btf_type_tag attribute
Em Wed, Nov 17, 2021 at 12:22:29PM -0800, Yonghong Song escreveu:
Quoted 7 lines
This patch implemented
dwarf_loadersupport. If a pointer type containsDW_TAG_LLVM_annotationtags, a new typebtf_type_tag_ptr_typewill be created which will store the pointer tag itself and allDW_TAG_LLVM_annotationtags. During recoding stage, the type chain will be formed properly based on the above example.
Quoted 6 lines
An option "--skip_encoding_btf_type_tag" is added to disable this new functionality.
[1] https://reviews.llvm.org/D111199
[2] https://reviews.llvm.org/D113222
[3] https://reviews.llvm.org/D113496
You forgot to add your S-o-B and to add this entry to man-pages/pahole.1, I'm fixing both cases, bellow is a followup patch, I'll add one as well for the recently added --skip_encoding_btf_decl_tag.
- Arnaldo
commit 9c3101db76acf364607d90adb3052e34d81fa1bd
Author: Arnaldo Carvalho de Melo <[email protected]> Date: Thu Nov 18 09:56:35 2021 -0300
man pages: Add missing --skip_encoding_btf_type_tag entry
In the past we saw the value of being able to disable specific features due to problems in in its implementation, allowing users to use a subset of functionality, without the problematic one.
man-pages/pahole.1 +4 -0
@@ -197,6 +197,10 @@ the debugging information. .B \-\-skip_encoding_btf_vars Do not encode VARs in BTF. +.TP +.B \-\-skip_encoding_btf_type_tag +Do not encode type tags in BTF. + .TP .B \-j, \-\-jobs=N Run N jobs in parallel. Defaults to number of online processors + 10% (like
Quoted 266 lines
--- dwarf_loader.c | 116 +++++++++++++++++++++++++++++++++++++++++++++++-- dwarves.h | 33 +++++++++++++- pahole.c | 8 ++++ 3 files changed, 153 insertions(+), 4 deletions(-)dwarf_loader.c +113
-3@@ -1206,6 +1206,88 @@ static struct tag *die__create_new_tag(Dwarf_Die *die, struct cu *cu)return tag; } +static struct btf_type_tag_ptr_type *die__create_new_btf_type_tag_ptr_type (Dwarf_Die *die,struct cu *cu) +{ +struct btf_type_tag_ptr_type *tag; + + tag =tag__alloc_with_spec (cu,sizeof (struct btf_type_tag_ptr_type )); +if (tag ==NULL ) +return NULL ; + +tag__init (&tag->tag, cu, die); + tag->tag.has_btf_type_tag = true; +INIT_LIST_HEAD (&tag->tags); +return tag; +} + +static struct btf_type_tag_type *die__create_new_btf_type_tag_type (Dwarf_Die *die,struct cu *cu, +struct conf_load *conf) +{ +struct btf_type_tag_type *tag; + + tag =tag__alloc_with_spec (cu,sizeof (struct btf_type_tag_type )); +if (tag ==NULL ) +return NULL ; + +tag__init (&tag->tag, cu, die); + tag->value =attr_string (die, DW_AT_const_value, conf); +return tag; +} + +static struct tag *die__create_new_pointer_tag (Dwarf_Die *die,struct cu *cu, +struct conf_load *conf) +{ +struct btf_type_tag_ptr_type *tag =NULL ; +struct btf_type_tag_type *annot; +Dwarf_Die *cdie, child; +const char *name; +uint32_t id; + +/* If no child tags or skipping btf_type_tag encoding, just create a new tag +* and return +*/ +if (!dwarf_haschildren (die) ||dwarf_child (die, &child) !=0 || + conf->skip_encoding_btf_type_tag) +return tag__new (die, cu); + +/* Otherwise, check DW_TAG_LLVM_annotation child tags */ + cdie = &child; +do { +if (dwarf_tag (cdie) == DW_TAG_LLVM_annotation) { +/* Only check btf_type_tag annotations */ + name =attr_string (cdie, DW_AT_name, conf); +if (strcmp (name,"btf_type_tag" ) !=0 ) +continue ; + +if (tag ==NULL ) { +/* Create a btf_type_tag_ptr type. */ + tag =die__create_new_btf_type_tag_ptr_type (die, cu); +if (!tag) +return NULL ; + } + +/* Create a btf_type_tag type for this annotation. */ + annot =die__create_new_btf_type_tag_type (cdie, cu, conf); +if (annot ==NULL ) +return NULL ; + +if (cu__table_add_tag (cu, &annot->tag, &id) <0 ) +return NULL ; + +struct dwarf_tag *dtag = annot->tag.priv; + dtag->small_id = id; +cu__hash (cu, &annot->tag); + +/* For a list of DW_TAG_LLVM_annotation like tag1 -> tag2 -> tag3, +* the tag->tags contains tag3 -> tag2 -> tag1. +*/ +list_add (&annot->node, &tag->tags); + } + }while (dwarf_siblingof (cdie, cdie) ==0 ); + +return tag ? &tag->tag :tag__new (die, cu); +} +static struct tag *die__create_new_ptr_to_member_type (Dwarf_Die *die,struct cu *cu) {@@ -1903,12 +1985,13 @@ static struct tag *__die__process_tag(Dwarf_Die *die, struct cu *cu,case DW_TAG_const_type:case DW_TAG_imported_declaration:case DW_TAG_imported_module: -case DW_TAG_pointer_type:case DW_TAG_reference_type:case DW_TAG_restrict_type:case DW_TAG_unspecified_type:case DW_TAG_volatile_type: tag =die__create_new_tag (die, cu);break ; +case DW_TAG_pointer_type: + tag =die__create_new_pointer_tag (die, cu, conf);break ;case DW_TAG_ptr_to_member_type: tag =die__create_new_ptr_to_member_type (die, cu);break ;case DW_TAG_enumeration_type:@@ -2192,6 +2275,26 @@ static void lexblock__recode_dwarf_types(struct lexblock *tag, struct cu *cu) } } +static void dwarf_cu__recode_btf_type_tag_ptr (struct btf_type_tag_ptr_type *tag, +uint32_t pointee_type) +{ +struct btf_type_tag_type *annot; +struct dwarf_tag *annot_dtag; +struct tag *prev_tag; + +/* If tag->tags contains tag3 -> tag2 -> tag1, the final type chain +* looks like: +* pointer -> tag3 -> tag2 -> tag1 -> pointee +*/ + prev_tag = &tag->tag; +list_for_each_entry (annot, &tag->tags, node) { + annot_dtag = annot->tag.priv; + prev_tag->type = annot_dtag->small_id; + prev_tag = &annot->tag; + } + prev_tag->type = pointee_type; +} +static int tag__recode_dwarf_type (struct tag *tag,struct cu *cu) {struct dwarf_tag *dtag = tag->priv;@@ -2301,7 +2404,10 @@ static int tag__recode_dwarf_type(struct tag *tag, struct cu *cu) }if (dtag->type.off ==0 ) { - tag->type =0 ;/* void */ +if (tag->tag != DW_TAG_pointer_type || !tag->has_btf_type_tag) + tag->type =0 ;/* void */ +else +dwarf_cu__recode_btf_type_tag_ptr (tag__btf_type_tag_ptr (tag),0 );return 0 ; }@@ -2313,7 +2419,11 @@ check_type:return 0 ; } out: - tag->type = dtype->small_id; +if (tag->tag != DW_TAG_pointer_type || !tag->has_btf_type_tag) + tag->type = dtype->small_id; +else +dwarf_cu__recode_btf_type_tag_ptr (tag__btf_type_tag_ptr (tag), dtype->small_id); +return 0 ; }dwarves.h +32
-1@@ -63,6 +63,7 @@ struct conf_load {bool ptr_table_stats;bool skip_encoding_btf_decl_tag;bool skip_missing; +bool skip_encoding_btf_type_tag;uint8_t hashtable_bits;uint8_t max_hashtable_bits;uint16_t kabi_prefix_len;@@ -413,6 +414,7 @@ struct tag {uint16_t tag;bool visited;bool top_level; +bool has_btf_type_tag;uint16_t recursivity_level;void *priv; };@@ -533,7 +535,8 @@ static inline int tag__is_tag_type(const struct tag *tag) tag->tag == DW_TAG_restrict_type || tag->tag == DW_TAG_subroutine_type || tag->tag == DW_TAG_unspecified_type || - tag->tag == DW_TAG_volatile_type; + tag->tag == DW_TAG_volatile_type || + tag->tag == DW_TAG_LLVM_annotation; } static inline const char *tag__decl_file(const struct tag *tag,@@ -606,6 +609,34 @@ struct llvm_annotation {struct list_head node; }; +/** struct btf_type_tag_type - representing a btf_type_tag annotation +* +* @tag - DW_TAG_LLVM_annotation tag +* @value - btf_type_tag value string +* @node - list_head node +*/ +struct btf_type_tag_type { +struct tag tag; +const char *value; +struct list_head node; +}; + +/** The struct btf_type_tag_ptr_type - type containing both pointer type and +* its btf_type_tag annotations +* +* @tag - pointer type tag +* @tags - btf_type_tag annotations for the pointer type +*/ +struct btf_type_tag_ptr_type { +struct tag tag; +struct list_head tags; +}; + +static inline struct btf_type_tag_ptr_type *tag__btf_type_tag_ptr (struct tag *tag) +{ +return (struct btf_type_tag_ptr_type *)tag; +} +/** struct namespace - base class for enums, structs, unions, typedefs, etc * * @tags - class_member, enumerators, etc pahole.c +8
-0@@ -1126,6 +1126,7 @@ ARGP_PROGRAM_VERSION_HOOK_DEF = dwarves_print_version;#define ARGP_devel_stats 330#define ARGP_skip_encoding_btf_decl_tag 331#define ARGP_skip_missing 332 +#define ARGP_skip_encoding_btf_type_tag 333static const struct argp_option pahole__options[] = { {@@ -1506,6 +1507,11 @@ static const struct argp_option pahole__options[] = { .key = ARGP_skip_missing, .doc = "skip missing types passed to -C rather than stop", }, + { + .name = "skip_encoding_btf_type_tag", + .key = ARGP_skip_encoding_btf_type_tag, + .doc = "Do not encode TAGs in BTF." + }, { .name = NULL, }@@ -1658,6 +1664,8 @@ static error_t pahole__options_parser(int key, char *arg, conf_load.skip_encoding_btf_decl_tag = true;break ;case ARGP_skip_missing: conf_load.skip_missing = true;break ; +case ARGP_skip_encoding_btf_type_tag: + conf_load.skip_encoding_btf_type_tag = true;break ;default :return ARGP_ERR_UNKNOWN ; }Signature · 1 line
2.30.2
Signature · 1 line
- Arnaldo
Re: [PATCH dwarves 3/4] dwarf_loader: support btf_type_tag attribute
Quoted 11 lines · Arnaldo Carvalho de Melo
Em Wed, Nov 17, 2021 at 12:22:29PM -0800, Yonghong Song escreveu:
Quoted 10 lines
This patch implemented
dwarf_loadersupport. If a pointer type containsDW_TAG_LLVM_annotationtags, a new typebtf_type_tag_ptr_typewill be created which will store the pointer tag itself and allDW_TAG_LLVM_annotationtags. During recoding stage, the type chain will be formed properly based on the above example.An option "--skip_encoding_btf_type_tag" is added to disable this new functionality.
Quoted 8 lines
Quoted 3 lines
[1] https://reviews.llvm.org/D111199 [2] https://reviews.llvm.org/D113222 [3] https://reviews.llvm.org/D113496You forgot to add your S-o-B and to add this entry to man-pages/pahole.1, I'm fixing both cases, bellow is a followup patch, I'll add one as well for the recently added --skip_encoding_btf_decl_tag.
Thanks for the fixup! It is my fault as I never changed man page before and not aware of that.
Quoted 22 lines
- Arnaldo
commit
9c3101db76acf364607d90adb3052e34d81fa1bdAuthor: Arnaldo Carvalho de Melo <[email protected]> Date: Thu Nov 18 09:56:35 2021 -0300man pages: Add missing --skip_encoding_btf_type_tag entry
In the past we saw the value of being able to disable specific features due to problems in in its implementation, allowing users to use a subset of functionality, without the problematic one.
Signed-off-by Arnaldo Carvalho de Melo <[email protected]>man-pages/pahole.1 +0
-0
man-pages/pahole.1 the debugging information. · line 206
Quoted 10 lines
man-pages/pahole.1 +4
-0@@ -197,6 +197,10 @@ the debugging information. .B \-\-skip_encoding_btf_vars Do not encode VARs in BTF. +.TP +.B \-\-skip_encoding_btf_type_tag +Do not encode type tags in BTF. + .TP .B \-j, \-\-jobs=N Run N jobs in parallel. Defaults to number of online processors + 10% (like
LGTM.
[...]
Re: [PATCH dwarves 3/4] dwarf_loader: support btf_type_tag attribute
In reply to Yonghong SongQuoted 66 lines · Yonghong Song
LLVM patches ([1] for clang, [2] and [3] for BPF backend) added support for
btf_type_tagattributes. The following is
an example:
[$ ~] catt.c
#define__tag1__attribute__((btf_type_tag("tag1")))
#define__tag2__attribute__((btf_type_tag("tag2")))
int__tag1*__tag1__tag2*g __attribute__((section(".data..percpu"))); [$ ~] clang -O2 -g -ct.c
[$ ~] llvm-dwarfdump --debug-info t.o
t.o: file format elf64-x86-64
...
0x0000001e:DW_TAG_variableDW_AT_name ("g") DW_AT_type (0x00000033 "int **") DW_AT_external (true) DW_AT_decl_file ("/home/yhs/t.c") DW_AT_decl_line (3) DW_AT_location (DW_OP_addr 0x0) 0x00000033: DW_TAG_pointer_type DW_AT_type (0x0000004b "int *") 0x00000038: DW_TAG_LLVM_annotation DW_AT_name ("btf_type_tag") DW_AT_const_value ("tag1") 0x00000041: DW_TAG_LLVM_annotation DW_AT_name ("btf_type_tag") DW_AT_const_value ("tag2") 0x0000004a: NULL 0x0000004b: DW_TAG_pointer_type DW_AT_type (0x0000005a "int") 0x00000050: DW_TAG_LLVM_annotation DW_AT_name ("btf_type_tag") DW_AT_const_value ("tag1") 0x00000059: NULL 0x0000005a: DW_TAG_base_type DW_AT_name ("int") DW_AT_encoding (DW_ATE_signed) DW_AT_byte_size (0x04)
0x00000061: NULLFrom the above example, you can see that
DW_TAG_pointer_typemay contain one or moreDW_TAG_LLVM_annotationbtf_type_tagtags. IfDW_TAG_LLVM_annotationtags are present insideDW_TAG_pointer_type, for BTF encoding, pahole will need to follow [3] to generate a type chain like
var -> ptr -> tag2 -> tag1 -> ptr -> tag1 -> intThis patch implemented
dwarf_loadersupport. If a pointer type containsDW_TAG_LLVM_annotationtags, a new typebtf_type_tag_ptr_typewill be created which will store the pointer tag itself and allDW_TAG_LLVM_annotationtags. During recoding stage, the type chain will be formed properly based on the above example.An option "--skip_encoding_btf_type_tag" is added to disable this new functionality.
[1] https://reviews.llvm.org/D111199
[2] https://reviews.llvm.org/D113222
[3] https://reviews.llvm.org/D113496--- dwarf_loader.c | 116 +++++++++++++++++++++++++++++++++++++++++++++++-- dwarves.h | 33 +++++++++++++- pahole.c | 8 ++++ 3 files changed, 153 insertions(+), 4 deletions(-)
[...]
Quoted 11 lines
dwarf_loader.c +11
-0+ +static struct tag *die__create_new_pointer_tag (Dwarf_Die *die,struct cu *cu, +struct conf_load *conf) +{ +struct btf_type_tag_ptr_type *tag =NULL ; +struct btf_type_tag_type *annot; +Dwarf_Die *cdie, child; +const char *name; +uint32_t id; + +/* If no child tags or skipping btf_type_tag encoding, just create a new tag
dwarf_loader.c static struct tag *die__create_new_tag(Dwarf_Die *die, struct cu *cu) · line 1256
Quoted 10 lines
dwarf_loader.c +10
-0+* and return +*/ +if (!dwarf_haschildren (die) ||dwarf_child (die, &child) !=0 || + conf->skip_encoding_btf_type_tag) +return tag__new (die, cu); + +/* Otherwise, check DW_TAG_LLVM_annotation child tags */ + cdie = &child; + do { + if (dwarf_tag(cdie) == DW_TAG_LLVM_annotation) {
nit: inverting the condition and doing continue would reduce nestedness level
Quoted 57 lines
dwarf_loader.c +37
-1+/* Only check btf_type_tag annotations */ + name =attr_string (cdie, DW_AT_name, conf); +if (strcmp (name,"btf_type_tag" ) !=0 ) +continue ; + +if (tag ==NULL ) { +/* Create a btf_type_tag_ptr type. */ + tag =die__create_new_btf_type_tag_ptr_type (die, cu); +if (!tag) +return NULL ; + } + +/* Create a btf_type_tag type for this annotation. */ + annot =die__create_new_btf_type_tag_type (cdie, cu, conf); +if (annot ==NULL ) +return NULL ; + +if (cu__table_add_tag (cu, &annot->tag, &id) <0 ) +return NULL ; + +struct dwarf_tag *dtag = annot->tag.priv; + dtag->small_id = id; +cu__hash (cu, &annot->tag); + +/* For a list of DW_TAG_LLVM_annotation like tag1 -> tag2 -> tag3, +* the tag->tags contains tag3 -> tag2 -> tag1. +*/ +list_add (&annot->node, &tag->tags); + } + }while (dwarf_siblingof (cdie, cdie) ==0 ); + +return tag ? &tag->tag :tag__new (die, cu); +} +static struct tag *die__create_new_ptr_to_member_type (Dwarf_Die *die,struct cu *cu) {@@ -1903,12 +1985,13 @@ static struct tag *__die__process_tag(Dwarf_Die *die, struct cu *cu,case DW_TAG_const_type:case DW_TAG_imported_declaration:case DW_TAG_imported_module: -case DW_TAG_pointer_type:case DW_TAG_reference_type:case DW_TAG_restrict_type:case DW_TAG_unspecified_type:case DW_TAG_volatile_type: tag =die__create_new_tag (die, cu);break ; +case DW_TAG_pointer_type: + tag =die__create_new_pointer_tag (die, cu, conf);break ;case DW_TAG_ptr_to_member_type: tag =die__create_new_ptr_to_member_type (die, cu);break ;case DW_TAG_enumeration_type:@@ -2192,6 +2275,26 @@ static void lexblock__recode_dwarf_types(struct lexblock *tag, struct cu *cu) } } +static void dwarf_cu__recode_btf_type_tag_ptr(struct btf_type_tag_ptr_type *tag,
dwarf_loader.c static void lexblock__recode_dwarf_types(struct lexblock *tag, struct cu *cu) · line 2288
Quoted 10 lines
dwarf_loader.c +10
-0+ uint32_t pointee_type) +{ +struct btf_type_tag_type *annot; +struct dwarf_tag *annot_dtag; +struct tag *prev_tag; + +/* If tag->tags contains tag3 -> tag2 -> tag1, the final type chain +* looks like: +* pointer -> tag3 -> tag2 -> tag1 -> pointee +*/
is the comment accurate or the final one should have looked like pointer -> tag1 -> tag2 -> tag3 -> pointee? Basically, trying to understand if the final BTF represents the source-level order of tags or not?
Quoted 9 lines
dwarf_loader.c +9
-0+ prev_tag = &tag->tag; +list_for_each_entry (annot, &tag->tags, node) { + annot_dtag = annot->tag.priv; + prev_tag->type = annot_dtag->small_id; + prev_tag = &annot->tag; + } + prev_tag->type = pointee_type; +} +
[...]
Re: [PATCH dwarves 3/4] dwarf_loader: support btf_type_tag attribute
Quoted 85 lines · Andrii Nakryiko
Quoted 66 lines · Yonghong Song
LLVM patches ([1] for clang, [2] and [3] for BPF backend) added support for
btf_type_tagattributes. The following is an example:[$ ~] cat t.c #define __tag1 __attribute__((btf_type_tag("tag1"))) #define __tag2 __attribute__((btf_type_tag("tag2"))) int __tag1 * __tag1 __tag2 *g __attribute__((section(".data..percpu"))); [$ ~] clang -O2 -g -c t.c [$ ~] llvm-dwarfdump --debug-info t.o t.o: file format elf64-x86-64 ... 0x0000001e: DW_TAG_variable DW_AT_name ("g") DW_AT_type (0x00000033 "int **") DW_AT_external (true) DW_AT_decl_file ("/home/yhs/t.c") DW_AT_decl_line (3) DW_AT_location (DW_OP_addr 0x0) 0x00000033: DW_TAG_pointer_type DW_AT_type (0x0000004b "int *") 0x00000038: DW_TAG_LLVM_annotation DW_AT_name ("btf_type_tag") DW_AT_const_value ("tag1") 0x00000041: DW_TAG_LLVM_annotation DW_AT_name ("btf_type_tag") DW_AT_const_value ("tag2") 0x0000004a: NULL 0x0000004b: DW_TAG_pointer_type DW_AT_type (0x0000005a "int") 0x00000050: DW_TAG_LLVM_annotation DW_AT_name ("btf_type_tag") DW_AT_const_value ("tag1") 0x00000059: NULL 0x0000005a: DW_TAG_base_type DW_AT_name ("int") DW_AT_encoding (DW_ATE_signed) DW_AT_byte_size (0x04) 0x00000061: NULLFrom the above example, you can see that
DW_TAG_pointer_type
may contain one or moreDW_TAG_LLVM_annotationbtf_type_tagtags. IfDW_TAG_LLVM_annotationtags are present insideDW_TAG_pointer_type, for BTF encoding, pahole will need to follow [3] to generate a type chain like
var -> ptr -> tag2 -> tag1 -> ptr -> tag1 -> intThis patch implemented
dwarf_loadersupport. If a pointer type containsDW_TAG_LLVM_annotationtags, a new typebtf_type_tag_ptr_typewill be created which will store the pointer tag itself and allDW_TAG_LLVM_annotationtags. During recoding stage, the type chain will be formed properly based on the above example.An option "--skip_encoding_btf_type_tag" is added to disable this new functionality.
[1] https://reviews.llvm.org/D111199 [2] https://reviews.llvm.org/D113222 [3] https://reviews.llvm.org/D113496 --- dwarf_loader.c | 116 +++++++++++++++++++++++++++++++++++++++++++++++-- dwarves.h | 33 +++++++++++++- pahole.c | 8 ++++ 3 files changed, 153 insertions(+), 4 deletions(-)[...]
Quoted 15 lines
dwarf_loader.c +15
-0+ +static struct tag *die__create_new_pointer_tag (Dwarf_Die *die,struct cu *cu, +struct conf_load *conf) +{ +struct btf_type_tag_ptr_type *tag =NULL ; +struct btf_type_tag_type *annot; +Dwarf_Die *cdie, child; +const char *name; +uint32_t id; + +/* If no child tags or skipping btf_type_tag encoding, just create a new tag +* and return +*/ +if (!dwarf_haschildren (die) ||dwarf_child (die, &child) !=0 || + conf->skip_encoding_btf_type_tag)
Quoted 8 lines
dwarf_loader.c static struct tag *die__create_new_tag(Dwarf_Die *die, struct cu *cu) · line 1256
Quoted 6 lines
dwarf_loader.c +6
-0+return tag__new (die, cu); + +/* Otherwise, check DW_TAG_LLVM_annotation child tags */ + cdie = &child; + do { + if (dwarf_tag(cdie) == DW_TAG_LLVM_annotation) {nit: inverting the condition and doing continue would reduce nestedness level
good point. Will send another revision.
Quoted 57 lines
Quoted 57 lines
dwarf_loader.c +36
-1+/* Only check btf_type_tag annotations */ + name =attr_string (cdie, DW_AT_name, conf); +if (strcmp (name,"btf_type_tag" ) !=0 ) +continue ; + +if (tag ==NULL ) { +/* Create a btf_type_tag_ptr type. */ + tag =die__create_new_btf_type_tag_ptr_type (die, cu); +if (!tag) +return NULL ; + } + +/* Create a btf_type_tag type for this annotation. */ + annot =die__create_new_btf_type_tag_type (cdie, cu, conf); +if (annot ==NULL ) +return NULL ; + +if (cu__table_add_tag (cu, &annot->tag, &id) <0 ) +return NULL ; + +struct dwarf_tag *dtag = annot->tag.priv; + dtag->small_id = id; +cu__hash (cu, &annot->tag); + +/* For a list of DW_TAG_LLVM_annotation like tag1 -> tag2 -> tag3, +* the tag->tags contains tag3 -> tag2 -> tag1. +*/ +list_add (&annot->node, &tag->tags); + } + }while (dwarf_siblingof (cdie, cdie) ==0 ); + +return tag ? &tag->tag :tag__new (die, cu); +} +static struct tag *die__create_new_ptr_to_member_type (Dwarf_Die *die,struct cu *cu) {@@ -1903,12 +1985,13 @@ static struct tag *__die__process_tag(Dwarf_Die *die, struct cu *cu,case DW_TAG_const_type:case DW_TAG_imported_declaration:case DW_TAG_imported_module: -case DW_TAG_pointer_type:case DW_TAG_reference_type:case DW_TAG_restrict_type:case DW_TAG_unspecified_type:case DW_TAG_volatile_type: tag =die__create_new_tag (die, cu);break ; +case DW_TAG_pointer_type: + tag =die__create_new_pointer_tag (die, cu, conf);break ;case DW_TAG_ptr_to_member_type: tag =die__create_new_ptr_to_member_type (die, cu);break ;case DW_TAG_enumeration_type:@@ -2192,6 +2275,26 @@ static void lexblock__recode_dwarf_types(struct lexblock *tag, struct cu *cu) } }
Quoted 16 lines
dwarf_loader.c static void lexblock__recode_dwarf_types(struct lexblock *tag, struct cu *cu) · line 2288
Quoted 11 lines
dwarf_loader.c +11
-0+static void dwarf_cu__recode_btf_type_tag_ptr (struct btf_type_tag_ptr_type *tag, +uint32_t pointee_type) +{ +struct btf_type_tag_type *annot; +struct dwarf_tag *annot_dtag; +struct tag *prev_tag; + +/* If tag->tags contains tag3 -> tag2 -> tag1, the final type chain +* looks like: +* pointer -> tag3 -> tag2 -> tag1 -> pointee +*/ is the comment accurate or the final one should have looked like pointer -> tag1 -> tag2 -> tag3 -> pointee? Basically, trying to understand if the final BTF represents the source-level order of tags or not?
The comment is accurate. Given source like
int tag1 tag2 tag3 *p;
the final type chain is
p -> tag3 -> tag2 -> tag1 -> int
basically it means
- '*' applies to "int tag1 tag2 tag3"
- tag3 applies to "int tag1 tag2"
- tag2 applies to "int tag1"
- tag1 applies to "int"
This also makes final source code (format c) easier as we can do
emit for "tag3 -> tag2 -> tag1 -> int" emit '*'
For 'tag3 -> tag2 -> tag1 -> int":
emit for "tag2 -> tag1 -> int"
emit tag3
Eventually we can get the source code like
int tag1 tag2 tag3 *p
and this matches the user/kernel code.
Quoted 13 lines
Quoted 10 lines
dwarf_loader.c +9
-0+ prev_tag = &tag->tag; +list_for_each_entry (annot, &tag->tags, node) { + annot_dtag = annot->tag.priv; + prev_tag->type = annot_dtag->small_id; + prev_tag = &annot->tag; + } + prev_tag->type = pointee_type; +} +[...]
Re: [PATCH dwarves 3/4] dwarf_loader: support btf_type_tag attribute
Quoted 190 lines · Yonghong Song
Quoted 85 lines · Andrii Nakryiko
Quoted 66 lines · Yonghong Song
LLVM patches ([1] for clang, [2] and [3] for BPF backend) added support for
btf_type_tagattributes. The following is an example:[$ ~] cat t.c #define __tag1 __attribute__((btf_type_tag("tag1"))) #define __tag2 __attribute__((btf_type_tag("tag2"))) int __tag1 * __tag1 __tag2 *g __attribute__((section(".data..percpu"))); [$ ~] clang -O2 -g -c t.c [$ ~] llvm-dwarfdump --debug-info t.o t.o: file format elf64-x86-64 ... 0x0000001e: DW_TAG_variable DW_AT_name ("g") DW_AT_type (0x00000033 "int **") DW_AT_external (true) DW_AT_decl_file ("/home/yhs/t.c") DW_AT_decl_line (3) DW_AT_location (DW_OP_addr 0x0) 0x00000033: DW_TAG_pointer_type DW_AT_type (0x0000004b "int *") 0x00000038: DW_TAG_LLVM_annotation DW_AT_name ("btf_type_tag") DW_AT_const_value ("tag1") 0x00000041: DW_TAG_LLVM_annotation DW_AT_name ("btf_type_tag") DW_AT_const_value ("tag2") 0x0000004a: NULL 0x0000004b: DW_TAG_pointer_type DW_AT_type (0x0000005a "int") 0x00000050: DW_TAG_LLVM_annotation DW_AT_name ("btf_type_tag") DW_AT_const_value ("tag1") 0x00000059: NULL 0x0000005a: DW_TAG_base_type DW_AT_name ("int") DW_AT_encoding (DW_ATE_signed) DW_AT_byte_size (0x04) 0x00000061: NULLFrom the above example, you can see that
DW_TAG_pointer_type
may contain one or moreDW_TAG_LLVM_annotationbtf_type_tagtags. IfDW_TAG_LLVM_annotationtags are present insideDW_TAG_pointer_type, for BTF encoding, pahole will need to follow [3] to generate a type chain like
var -> ptr -> tag2 -> tag1 -> ptr -> tag1 -> intThis patch implemented
dwarf_loadersupport. If a pointer type containsDW_TAG_LLVM_annotationtags, a new typebtf_type_tag_ptr_typewill be created which will store the pointer tag itself and allDW_TAG_LLVM_annotationtags. During recoding stage, the type chain will be formed properly based on the above example.An option "--skip_encoding_btf_type_tag" is added to disable this new functionality.
[1] https://reviews.llvm.org/D111199 [2] https://reviews.llvm.org/D113222 [3] https://reviews.llvm.org/D113496 --- dwarf_loader.c | 116 +++++++++++++++++++++++++++++++++++++++++++++++-- dwarves.h | 33 +++++++++++++- pahole.c | 8 ++++ 3 files changed, 153 insertions(+), 4 deletions(-)[...]
Quoted 15 lines
dwarf_loader.c +15
-0+ +static struct tag *die__create_new_pointer_tag (Dwarf_Die *die,struct cu *cu, +struct conf_load *conf) +{ +struct btf_type_tag_ptr_type *tag =NULL ; +struct btf_type_tag_type *annot; +Dwarf_Die *cdie, child; +const char *name; +uint32_t id; + +/* If no child tags or skipping btf_type_tag encoding, just create a new tag +* and return +*/ +if (!dwarf_haschildren (die) ||dwarf_child (die, &child) !=0 || + conf->skip_encoding_btf_type_tag)Quoted 8 lines
dwarf_loader.c static struct tag *die__create_new_tag(Dwarf_Die *die, struct cu *cu) · line 1256
Quoted 6 lines
dwarf_loader.c +6
-0+return tag__new (die, cu); + +/* Otherwise, check DW_TAG_LLVM_annotation child tags */ + cdie = &child; + do { + if (dwarf_tag(cdie) == DW_TAG_LLVM_annotation) {nit: inverting the condition and doing continue would reduce nestedness level
good point. Will send another revision.
Quoted 57 lines
Quoted 57 lines
dwarf_loader.c +36
-1+/* Only check btf_type_tag annotations */ + name =attr_string (cdie, DW_AT_name, conf); +if (strcmp (name,"btf_type_tag" ) !=0 ) +continue ; + +if (tag ==NULL ) { +/* Create a btf_type_tag_ptr type. */ + tag =die__create_new_btf_type_tag_ptr_type (die, cu); +if (!tag) +return NULL ; + } + +/* Create a btf_type_tag type for this annotation. */ + annot =die__create_new_btf_type_tag_type (cdie, cu, conf); +if (annot ==NULL ) +return NULL ; + +if (cu__table_add_tag (cu, &annot->tag, &id) <0 ) +return NULL ; + +struct dwarf_tag *dtag = annot->tag.priv; + dtag->small_id = id; +cu__hash (cu, &annot->tag); + +/* For a list of DW_TAG_LLVM_annotation like tag1 -> tag2 -> tag3, +* the tag->tags contains tag3 -> tag2 -> tag1. +*/ +list_add (&annot->node, &tag->tags); + } + }while (dwarf_siblingof (cdie, cdie) ==0 ); + +return tag ? &tag->tag :tag__new (die, cu); +} +static struct tag *die__create_new_ptr_to_member_type (Dwarf_Die *die,struct cu *cu) {@@ -1903,12 +1985,13 @@ static struct tag *__die__process_tag(Dwarf_Die *die, struct cu *cu,case DW_TAG_const_type:case DW_TAG_imported_declaration:case DW_TAG_imported_module: -case DW_TAG_pointer_type:case DW_TAG_reference_type:case DW_TAG_restrict_type:case DW_TAG_unspecified_type:case DW_TAG_volatile_type: tag =die__create_new_tag (die, cu);break ; +case DW_TAG_pointer_type: + tag =die__create_new_pointer_tag (die, cu, conf);break ;case DW_TAG_ptr_to_member_type: tag =die__create_new_ptr_to_member_type (die, cu);break ;case DW_TAG_enumeration_type:@@ -2192,6 +2275,26 @@ static void lexblock__recode_dwarf_types(struct lexblock *tag, struct cu *cu) } }Quoted 16 lines
dwarf_loader.c static void lexblock__recode_dwarf_types(struct lexblock *tag, struct cu *cu) · line 2288
Quoted 11 lines
dwarf_loader.c +11
-0+static void dwarf_cu__recode_btf_type_tag_ptr (struct btf_type_tag_ptr_type *tag, +uint32_t pointee_type) +{ +struct btf_type_tag_type *annot; +struct dwarf_tag *annot_dtag; +struct tag *prev_tag; + +/* If tag->tags contains tag3 -> tag2 -> tag1, the final type chain +* looks like: +* pointer -> tag3 -> tag2 -> tag1 -> pointee +*/ is the comment accurate or the final one should have looked like pointer -> tag1 -> tag2 -> tag3 -> pointee? Basically, trying to understand if the final BTF represents the source-level order of tags or not?
The comment is accurate. Given source like
int tag1 tag2 tag3 *p; the final type chain is p -> tag3 -> tag2 -> tag1 -> intbasically it means
- '*' applies to "int tag1 tag2 tag3"
- tag3 applies to "int tag1 tag2"
- tag2 applies to "int tag1"
- tag1 applies to "int"This also makes final source code (format c) easier as we can do
emit for "tag3 -> tag2 -> tag1 -> int" emit '*'
Quoted 7 lines
For 'tag3 -> tag2 -> tag1 -> int":
emit for "tag2 -> tag1 -> int" emit tag3Eventually we can get the source code like
int tag1 tag2 tag3 *p
and this matches the user/kernel code.
It would be great to add that as a comment somewhere here, it's very hard to make this inference just from the code.
Quoted 14 lines
Quoted 14 lines
Quoted 11 lines
dwarf_loader.c +9
-0+ prev_tag = &tag->tag; +list_for_each_entry (annot, &tag->tags, node) { + annot_dtag = annot->tag.priv; + prev_tag->type = annot_dtag->small_id; + prev_tag = &annot->tag; + } + prev_tag->type = pointee_type; +} +[...]
Re: [PATCH dwarves 3/4] dwarf_loader: support btf_type_tag attribute
Quoted 195 lines · Andrii Nakryiko
Quoted 194 lines · Yonghong Song
Quoted 85 lines · Andrii Nakryiko
Quoted 66 lines · Yonghong Song
LLVM patches ([1] for clang, [2] and [3] for BPF backend) added support for
btf_type_tagattributes. The following is an example:[$ ~] cat t.c #define __tag1 __attribute__((btf_type_tag("tag1"))) #define __tag2 __attribute__((btf_type_tag("tag2"))) int __tag1 * __tag1 __tag2 *g __attribute__((section(".data..percpu"))); [$ ~] clang -O2 -g -c t.c [$ ~] llvm-dwarfdump --debug-info t.o t.o: file format elf64-x86-64 ... 0x0000001e: DW_TAG_variable DW_AT_name ("g") DW_AT_type (0x00000033 "int **") DW_AT_external (true) DW_AT_decl_file ("/home/yhs/t.c") DW_AT_decl_line (3) DW_AT_location (DW_OP_addr 0x0) 0x00000033: DW_TAG_pointer_type DW_AT_type (0x0000004b "int *") 0x00000038: DW_TAG_LLVM_annotation DW_AT_name ("btf_type_tag") DW_AT_const_value ("tag1") 0x00000041: DW_TAG_LLVM_annotation DW_AT_name ("btf_type_tag") DW_AT_const_value ("tag2") 0x0000004a: NULL 0x0000004b: DW_TAG_pointer_type DW_AT_type (0x0000005a "int") 0x00000050: DW_TAG_LLVM_annotation DW_AT_name ("btf_type_tag") DW_AT_const_value ("tag1") 0x00000059: NULL 0x0000005a: DW_TAG_base_type DW_AT_name ("int") DW_AT_encoding (DW_ATE_signed) DW_AT_byte_size (0x04) 0x00000061: NULLFrom the above example, you can see that
DW_TAG_pointer_type
may contain one or moreDW_TAG_LLVM_annotationbtf_type_tagtags. IfDW_TAG_LLVM_annotationtags are present insideDW_TAG_pointer_type, for BTF encoding, pahole will need to follow [3] to generate a type chain likevar -> ptr -> tag2 -> tag1 -> ptr -> tag1 -> intThis patch implemented
dwarf_loadersupport. If a pointer type containsDW_TAG_LLVM_annotationtags, a new typebtf_type_tag_ptr_typewill be created which will store the pointer tag itself and allDW_TAG_LLVM_annotationtags. During recoding stage, the type chain will be formed properly based on the above example.An option "--skip_encoding_btf_type_tag" is added to disable this new functionality.
[1] https://reviews.llvm.org/D111199 [2] https://reviews.llvm.org/D113222 [3] https://reviews.llvm.org/D113496 --- dwarf_loader.c | 116 +++++++++++++++++++++++++++++++++++++++++++++++-- dwarves.h | 33 +++++++++++++- pahole.c | 8 ++++ 3 files changed, 153 insertions(+), 4 deletions(-)[...]
Quoted 15 lines
dwarf_loader.c +15
-0+ +static struct tag *die__create_new_pointer_tag (Dwarf_Die *die,struct cu *cu, +struct conf_load *conf) +{ +struct btf_type_tag_ptr_type *tag =NULL ; +struct btf_type_tag_type *annot; +Dwarf_Die *cdie, child; +const char *name; +uint32_t id; + +/* If no child tags or skipping btf_type_tag encoding, just create a new tag +* and return +*/ +if (!dwarf_haschildren (die) ||dwarf_child (die, &child) !=0 || + conf->skip_encoding_btf_type_tag)Quoted 8 lines
dwarf_loader.c static struct tag *die__create_new_tag(Dwarf_Die *die, struct cu *cu) · line 1256
Quoted 6 lines
dwarf_loader.c +6
-0+return tag__new (die, cu); + +/* Otherwise, check DW_TAG_LLVM_annotation child tags */ + cdie = &child; + do { + if (dwarf_tag(cdie) == DW_TAG_LLVM_annotation) {nit: inverting the condition and doing continue would reduce nestedness level
good point. Will send another revision.
Quoted 57 lines
Quoted 57 lines
dwarf_loader.c +36
-1+/* Only check btf_type_tag annotations */ + name =attr_string (cdie, DW_AT_name, conf); +if (strcmp (name,"btf_type_tag" ) !=0 ) +continue ; + +if (tag ==NULL ) { +/* Create a btf_type_tag_ptr type. */ + tag =die__create_new_btf_type_tag_ptr_type (die, cu); +if (!tag) +return NULL ; + } + +/* Create a btf_type_tag type for this annotation. */ + annot =die__create_new_btf_type_tag_type (cdie, cu, conf); +if (annot ==NULL ) +return NULL ; + +if (cu__table_add_tag (cu, &annot->tag, &id) <0 ) +return NULL ; + +struct dwarf_tag *dtag = annot->tag.priv; + dtag->small_id = id; +cu__hash (cu, &annot->tag); + +/* For a list of DW_TAG_LLVM_annotation like tag1 -> tag2 -> tag3, +* the tag->tags contains tag3 -> tag2 -> tag1. +*/ +list_add (&annot->node, &tag->tags); + } + }while (dwarf_siblingof (cdie, cdie) ==0 ); + +return tag ? &tag->tag :tag__new (die, cu); +} +static struct tag *die__create_new_ptr_to_member_type (Dwarf_Die *die,struct cu *cu) {@@ -1903,12 +1985,13 @@ static struct tag *__die__process_tag(Dwarf_Die *die, struct cu *cu,case DW_TAG_const_type:case DW_TAG_imported_declaration:case DW_TAG_imported_module: -case DW_TAG_pointer_type:case DW_TAG_reference_type:case DW_TAG_restrict_type:case DW_TAG_unspecified_type:case DW_TAG_volatile_type: tag =die__create_new_tag (die, cu);break ; +case DW_TAG_pointer_type: + tag =die__create_new_pointer_tag (die, cu, conf);break ;case DW_TAG_ptr_to_member_type: tag =die__create_new_ptr_to_member_type (die, cu);break ;case DW_TAG_enumeration_type:@@ -2192,6 +2275,26 @@ static void lexblock__recode_dwarf_types(struct lexblock *tag, struct cu *cu) } }Quoted 16 lines
dwarf_loader.c static void lexblock__recode_dwarf_types(struct lexblock *tag, struct cu *cu) · line 2288
Quoted 11 lines
dwarf_loader.c +11
-0+static void dwarf_cu__recode_btf_type_tag_ptr (struct btf_type_tag_ptr_type *tag, +uint32_t pointee_type) +{ +struct btf_type_tag_type *annot; +struct dwarf_tag *annot_dtag; +struct tag *prev_tag; + +/* If tag->tags contains tag3 -> tag2 -> tag1, the final type chain +* looks like: +* pointer -> tag3 -> tag2 -> tag1 -> pointee +*/ is the comment accurate or the final one should have looked like pointer -> tag1 -> tag2 -> tag3 -> pointee? Basically, trying to understand if the final BTF represents the source-level order of tags or not?
The comment is accurate. Given source like
int tag1 tag2 tag3 *p; the final type chain is p -> tag3 -> tag2 -> tag1 -> intbasically it means
- '*' applies to "int tag1 tag2 tag3"
- tag3 applies to "int tag1 tag2"
- tag2 applies to "int tag1"
- tag1 applies to "int"This also makes final source code (format c) easier as we can do
emit for "tag3 -> tag2 -> tag1 -> int" emit '*'For 'tag3 -> tag2 -> tag1 -> int":
emit for "tag2 -> tag1 -> int" emit tag3
Quoted 6 lines
Quoted 3 lines
Eventually we can get the source code like
int tag1 tag2 tag3 *p
and this matches the user/kernel code.It would be great to add that as a comment somewhere here, it's very hard to make this inference just from the code.
Will add detailed comments in next pahole revision and will also add them in the next kernel btf_type_tag patch set.
Quoted 15 lines
Quoted 15 lines
Quoted 15 lines
Quoted 12 lines
dwarf_loader.c +9
-0+ prev_tag = &tag->tag; +list_for_each_entry (annot, &tag->tags, node) { + annot_dtag = annot->tag.priv; + prev_tag->type = annot_dtag->small_id; + prev_tag = &annot->tag; + } + prev_tag->type = pointee_type; +} +[...]
PATCH 4/4 btf_encoder: support btf_type_tag attribute
In reply to Yonghong SongThe following is an example.
[$ ~] cat t.c
#define __tag1 __attribute__((btf_type_tag("tag1")))
#define __tag2 __attribute__((btf_type_tag("tag2")))
int __tag1 * __tag1 __tag2 *g __attribute__((section(".data..percpu"))); [$ ~] clang -O2 -g -c t.c
[$ ~] pahole -JV t.o
Found per-CPU symbol 'g' at address 0x0
Found 1 per-CPU variables!
File t.o:
[1] TYPE_TAG tag1 type_id=5
[2] TYPE_TAG tag2 type_id=1
[3] PTR (anon) type_id=2
[4] TYPE_TAG tag1 type_id=6
[5] PTR (anon) type_id=4
[6] INT int size=4 nr_bits=32 encoding=SIGNED
search cu 't.c' for percpu global variables.
Variable 'g' from CU 't.c' at address 0x0 encoded
[7] VAR g type=3 linkage=1
[8] DATASEC .data..percpu size=8 vlen=1
type=7 offset=0 size=8
[$ ~]
You can see for the source
int __tag1 * __tag1 __tag2 *g __attribute__((section(".data..percpu")));
the following type chain is generated:
var -> ptr -> tag2 -> tag1 -> ptr -> tag1 -> int
The following shows pahole option "--skip_encoding_btf_type_tag" can prevent BTF_KIND_TYPE_TAG generation.
[$ ~] pahole -JV t.o --skip_encoding_btf_type_tag Found per-CPU symbol 'g' at address 0x0
Found 1 per-CPU variables!
File t.o:
[1] PTR (anon) type_id=2
[2] PTR (anon) type_id=3
[3] INT int size=4 nr_bits=32 encoding=SIGNED
search cu 't.c' for percpu global variables. Variable 'g' from CU 't.c' at address 0x0 encoded
[4] VAR g type=1 linkage=1
[5] DATASEC .data..percpu size=8 vlen=1
type=4 offset=0 size=8
[$ ~]
--- btf_encoder.c | 7 +++++++ dwarves.h | 5 +++++ 2 files changed, 12 insertions(+)
btf_encoder.c +7 -0
@@ -143,6 +143,7 @@ static const char * const btf_kind_str[NR_BTF_KINDS] = { [BTF_KIND_DATASEC] = "DATASEC", [BTF_KIND_FLOAT] = "FLOAT", [BTF_KIND_DECL_TAG] = "DECL_TAG", + [BTF_KIND_TYPE_TAG] = "TYPE_TAG", };static const char *btf__printable_name (const struct btf *btf,uint32_t offset)
@@ -393,6 +394,9 @@ static int32_t btf_encoder__add_ref_type(struct btf_encoder *encoder, uint16_t kcase BTF_KIND_TYPEDEF : id =btf__add_typedef (btf, name, type);break ; +case BTF_KIND_TYPE_TAG : + id =btf__add_type_tag (btf, name, type); +break ;case BTF_KIND_FWD : id =btf__add_fwd (btf, name, kind_flag);break ;
@@ -862,6 +866,9 @@ static int btf_encoder__encode_tag(struct btf_encoder *encoder, struct tag *tag,case DW_TAG_typedef: name =namespace__name (tag__namespace (tag));return btf_encoder__add_ref_type (encoder,BTF_KIND_TYPEDEF , ref_type_id, name, false); +case DW_TAG_LLVM_annotation: + name =tag__btf_type_tag (tag)->value; +return btf_encoder__add_ref_type (encoder,BTF_KIND_TYPE_TAG , ref_type_id, name, false);case DW_TAG_structure_type:case DW_TAG_union_type:case DW_TAG_class_type:
dwarves.h +5 -0
@@ -637,6 +637,11 @@ static inline struct btf_type_tag_ptr_type *tag__btf_type_tag_ptr(struct tag *tareturn (struct btf_type_tag_ptr_type *)tag; } +static inline struct btf_type_tag_type *tag__btf_type_tag (struct tag *tag) +{ +return (struct btf_type_tag_type *)tag; +} +/** struct namespace - base class for enums, structs, unions, typedefs, etc * * @tags - class_member, enumerators, etc
Signature · 1 line
2.30.2