Re: [PATCH] btf: emit linkage information in BTF_KIND_FUNC entries

[Indu Bhagat <indu.bhagat@oracle.com>]

On 7/8/22 11:30 AM, Jose E. Marchesi via Gcc-patches wrote:
> 
> 
> The kernel bpftool expects BTF_KIND_FUNC entries in BTF to include an
> annotation reflecting the linkage of functions (static, global).  For
> whatever reason they (ab)use the `vlen' field of the BTF_KIND_FUNC entry
> instead of adding a variable-part to the record like it is done with
> other entry kinds.
> 

For BTF Variables, we have the linkage information in the output section 
as "btv_linkage".  To propagate that information from DWARF to BTF, we 
have the dvd_visibility in struct ctf_dvdef (in ctfc.h). Now that the 
linkage information is needed for the BTF_KIND_FUNC entries, what do you 
think about - adding something like dtd_visibility to ctf_dtdef.

Updating the BTF format documentation will be useful 
https://www.kernel.org/doc/Documentation/bpf/btf.rst. Let's see what can 
be done for that...

Also, adding some testcases with the current patch will be great.

I have created PR debug/106263 "BTF_KIND_FUNC type does not encode 
linkage" to track this.


> This patch makes GCC to include this linkage info in BTF_KIND_FUNC
> entries.
> 
> Tested in bpf-unknown-none target.
> 
> gcc/ChangeLog:
> 
> 	* ctfc.h (struct ctf_itype): Add field ctti_linkage.
> 	* ctfc.cc (ctf_add_function): Set ctti_linkage.
> 	* dwarf2ctf.cc (gen_ctf_function_type): Pass a linkage for
> 	function types and subprograms.
> 	* btfout.cc (btf_asm_func_type): Emit linkage information for the
> 	function.
> ---
>   gcc/btfout.cc    | 3 ++-
>   gcc/ctfc.cc      | 3 ++-
>   gcc/ctfc.h       | 3 ++-
>   gcc/dwarf2ctf.cc | 4 +++-
>   4 files changed, 9 insertions(+), 4 deletions(-)
> 
> diff --git a/gcc/btfout.cc b/gcc/btfout.cc
> index 31af50521da..417d87cf519 100644
> --- a/gcc/btfout.cc
> +++ b/gcc/btfout.cc
> @@ -740,7 +740,8 @@ static void
>   btf_asm_func_type (ctf_dtdef_ref dtd)
>   {
>     dw2_asm_output_data (4, dtd->dtd_data.ctti_name, "btt_name");
> -  dw2_asm_output_data (4, BTF_TYPE_INFO (BTF_KIND_FUNC, 0, 0), "btt_info");
> +  dw2_asm_output_data (4, BTF_TYPE_INFO (BTF_KIND_FUNC, 0,
> +                                         dtd->dtd_data.ctti_linkage), "btt_info");
>     dw2_asm_output_data (4, get_btf_id (dtd->dtd_data.ctti_type), "btt_type");
>   }
>   
> diff --git a/gcc/ctfc.cc b/gcc/ctfc.cc
> index f24e7bff948..ad7f8bb8e86 100644
> --- a/gcc/ctfc.cc
> +++ b/gcc/ctfc.cc
> @@ -777,7 +777,7 @@ ctf_add_function_arg (ctf_container_ref ctfc, dw_die_ref func,
>   ctf_id_t
>   ctf_add_function (ctf_container_ref ctfc, uint32_t flag, const char * name,
>   		  const ctf_funcinfo_t * ctc, dw_die_ref die,
> -		  bool from_global_func)
> +		  bool from_global_func, int linkage)
>   {
>     ctf_dtdef_ref dtd;
>     ctf_id_t type;
> @@ -792,6 +792,7 @@ ctf_add_function (ctf_container_ref ctfc, uint32_t flag, const char * name,
>   
>     dtd->from_global_func = from_global_func;
>     dtd->dtd_data.ctti_info = CTF_TYPE_INFO (CTF_K_FUNCTION, flag, vlen);
> +  dtd->dtd_data.ctti_linkage = linkage;
>     /* Caller must make sure CTF types for ctc->ctc_return are already added.  */
>     dtd->dtd_data.ctti_type = (uint32_t) ctc->ctc_return;
>     /* Caller must make sure CTF types for function arguments are already added
> diff --git a/gcc/ctfc.h b/gcc/ctfc.h
> index 001e544ef08..273997a2302 100644
> --- a/gcc/ctfc.h
> +++ b/gcc/ctfc.h
> @@ -116,6 +116,7 @@ typedef struct GTY (()) ctf_itype
>     } _u;
>     uint32_t ctti_lsizehi;	/* High 32 bits of type size in bytes.  */
>     uint32_t ctti_lsizelo;	/* Low 32 bits of type size in bytes.  */
> +  uint32_t ctti_linkage;	/* Linkage info for function types.  */
>   } ctf_itype_t;
>   
>   #define ctti_size _u._size
> @@ -423,7 +424,7 @@ extern ctf_id_t ctf_add_forward (ctf_container_ref, uint32_t, const char *,
>   extern ctf_id_t ctf_add_typedef (ctf_container_ref, uint32_t, const char *,
>   				 ctf_id_t, dw_die_ref);
>   extern ctf_id_t ctf_add_function (ctf_container_ref, uint32_t, const char *,
> -				  const ctf_funcinfo_t *, dw_die_ref, bool);
> +				  const ctf_funcinfo_t *, dw_die_ref, bool, int);
>   extern ctf_id_t ctf_add_sou (ctf_container_ref, uint32_t, const char *,
>   			     uint32_t, size_t, dw_die_ref);
>   
> diff --git a/gcc/dwarf2ctf.cc b/gcc/dwarf2ctf.cc
> index a6329ab6ee4..397100004c2 100644
> --- a/gcc/dwarf2ctf.cc
> +++ b/gcc/dwarf2ctf.cc
> @@ -644,6 +644,7 @@ gen_ctf_function_type (ctf_container_ref ctfc, dw_die_ref function,
>   
>     ctf_funcinfo_t func_info;
>     uint32_t num_args = 0;
> +  int linkage = get_AT_flag (function, DW_AT_external);
>   
>     ctf_id_t return_type_id;
>     ctf_id_t function_type_id;
> @@ -687,7 +688,8 @@ gen_ctf_function_type (ctf_container_ref ctfc, dw_die_ref function,
>   				       function_name,
>   				       (const ctf_funcinfo_t *)&func_info,
>   				       function,
> -				       from_global_func);
> +				       from_global_func,
> +                                       linkage);
>   
>     /* Second pass on formals: generate the CTF types corresponding to
>        them and add them as CTF function args.  */
>