From: Indu Bhagat <indu.bhagat@oracle.com>
To: David Faust <david.faust@oracle.com>, gcc-patches@gcc.gnu.org
Cc: jose.marchesi@oracle.com, cupertino.miranda@oracle.com
Subject: Re: [PATCH v3 2/6] ctf: use pointers instead of IDs internally
Date: Wed, 5 Jun 2024 00:31:56 -0700 [thread overview]
Message-ID: <4e4f33cd-42b1-4259-857b-5e75e3c4045f@oracle.com> (raw)
In-Reply-To: <20240530213222.440435-3-david.faust@oracle.com>
On 5/30/24 14:32, David Faust wrote:
> This patch replaces all inter-type references in the ctfc internal data
> structures with pointers, rather than the references-by-ID which were
> used previously.
>
> A couple of small updates in the BPF backend are included to make it
> compatible with the change.
>
> This change is only to the in-memory representation of various CTF
> structures to make them easier to work with in various cases. It is
> outwardly transparent; there is no change in emitted CTF.
>
> gcc/
> * btfout.cc (BTF_VOID_TYPEID, BTF_INIT_TYPEID): Move defines to
> include/btf.h.
> (btf_dvd_emit_preprocess_cb, btf_emit_preprocess)
> (btf_dmd_representable_bitfield_p, btf_asm_array, btf_asm_varent)
> (btf_asm_sou_member, btf_asm_func_arg, btf_init_postprocess):
> Adapt to structural changes in ctf_* structs.
> * ctfc.h (struct ctf_dtdef): Add forward declaration.
> (ctf_dtdef_t, ctf_dtdef_ref): Move typedefs earlier.
> (struct ctf_arinfo, struct ctf_funcinfo, struct ctf_sliceinfo)
> (struct ctf_itype, struct ctf_dmdef, struct ctf_func_arg)
> (struct ctf_dvdef): Use pointers instead of type IDs for
> references to other types and use typedefs where appropriate.
> (struct ctf_dtdef): Add ref_type member.
> (ctf_type_exists): Use pointer instead of type ID.
> (ctf_add_reftype, ctf_add_enum, ctf_add_slice, ctf_add_float)
> (ctf_add_integer, ctf_add_unknown, ctf_add_pointer)
> (ctf_add_array, ctf_add_forward, ctf_add_typedef)
> (ctf_add_function, ctf_add_sou, ctf_add_enumerator)
> (ctf_add_variable): Likewise. Return pointer instead of ID.
> (ctf_lookup_tree_type): Return pointer to type instead of ID.
> * ctfc.cc: Analogous changes.
> * ctfout.cc (ctf_asm_type, ctf_asm_slice, ctf_asm_varent)
> (ctf_asm_sou_lmember, ctf_asm_sou_member, ctf_asm_func_arg)
> (output_ctf_objt_info): Adapt to changes.
> * dwarf2ctf.cc (gen_ctf_type, gen_ctf_void_type)
> (gen_ctf_unknown_type, gen_ctf_base_type, gen_ctf_pointer_type)
> (gen_ctf_subrange_type, gen_ctf_array_type, gen_ctf_typedef)
> (gen_ctf_modifier_type, gen_ctf_sou_type, gen_ctf_function_type)
> (gen_ctf_enumeration_type, gen_ctf_variable, gen_ctf_function)
> (gen_ctf_type, ctf_do_die): Likewise.
> * config/bpf/btfext-out.cc (struct btf_ext_core_reloc): Use
> pointer instead of type ID.
> (bpf_core_reloc_add, bpf_core_get_sou_member_index)
> (output_btfext_core_sections): Adapt to above changes.
> * config/bpf/core-builtins.cc (process_type): Likewise.
>
> include/
> * btf.h (BTF_VOID_TYPEID, BTF_INIT_TYPEID): Move defines here,
> from gcc/btfout.cc.
The patch looks OK overall. Few updates to code comments for function
description or in the body of the function were missed. I have pointed
them out below.
OK with those addressed.
Thanks
> ---
> gcc/btfout.cc | 40 +++---
> gcc/config/bpf/btfext-out.cc | 14 +-
> gcc/config/bpf/core-builtins.cc | 3 +-
> gcc/ctfc.cc | 139 +++++++++---------
> gcc/ctfc.h | 90 ++++++------
> gcc/ctfout.cc | 22 +--
> gcc/dwarf2ctf.cc | 244 +++++++++++++++-----------------
> include/btf.h | 5 +
> 8 files changed, 278 insertions(+), 279 deletions(-)
>
> diff --git a/gcc/btfout.cc b/gcc/btfout.cc
> index 1b6a9ed811f0..40e8d8c5c01b 100644
> --- a/gcc/btfout.cc
> +++ b/gcc/btfout.cc
> @@ -61,11 +61,6 @@ static char btf_info_section_label[MAX_BTF_LABEL_BYTES];
> #define BTF_INFO_SECTION_LABEL "Lbtf"
> #endif
>
> -/* BTF encodes void as type id 0. */
> -
> -#define BTF_VOID_TYPEID 0
> -#define BTF_INIT_TYPEID 1
> -
> #define BTF_INVALID_TYPEID 0xFFFFFFFF
>
> /* Mapping of CTF variables to the IDs they will be assigned when they are
> @@ -626,7 +621,8 @@ btf_dvd_emit_preprocess_cb (ctf_dvdef_ref *slot, ctf_container_ref arg_ctfc)
> return 1;
>
> /* Do not add variables which refer to unsupported types. */
> - if (!voids.contains (var->dvd_type) && btf_removed_type_p (var->dvd_type))
> + if (!voids.contains (var->dvd_type->dtd_type)
> + && btf_removed_type_p (var->dvd_type->dtd_type))
> return 1;
>
> arg_ctfc->ctfc_vars_list[num_vars_added] = var;
> @@ -716,7 +712,7 @@ btf_emit_preprocess (ctf_container_ref ctfc)
> static bool
> btf_dmd_representable_bitfield_p (ctf_container_ref ctfc, ctf_dmdef_t *dmd)
> {
> - ctf_dtdef_ref ref_type = ctfc->ctfc_types_list[dmd->dmd_type];
> + ctf_dtdef_ref ref_type = ctfc->ctfc_types_list[dmd->dmd_type->dtd_type];
>
> if (CTF_V2_INFO_KIND (ref_type->dtd_data.ctti_info) == CTF_K_SLICE)
> {
> @@ -913,8 +909,8 @@ btf_asm_type (ctf_container_ref ctfc, ctf_dtdef_ref dtd)
> static void
> btf_asm_array (ctf_container_ref ctfc, ctf_arinfo_t arr)
> {
> - btf_asm_type_ref ("bta_elem_type", ctfc, arr.ctr_contents);
> - btf_asm_type_ref ("bta_index_type", ctfc, arr.ctr_index);
> + btf_asm_type_ref ("bta_elem_type", ctfc, arr.ctr_contents->dtd_type);
> + btf_asm_type_ref ("bta_index_type", ctfc, arr.ctr_index->dtd_type);
> dw2_asm_output_data (4, arr.ctr_nelems, "bta_nelems");
> }
>
> @@ -927,7 +923,7 @@ btf_asm_varent (ctf_container_ref ctfc, ctf_dvdef_ref var)
> (*(btf_var_ids->get (var)) + num_types_added + 1),
> var->dvd_name);
> dw2_asm_output_data (4, BTF_TYPE_INFO (BTF_KIND_VAR, 0, 0), "btv_info");
> - btf_asm_type_ref ("btv_type", ctfc, var->dvd_type);
> + btf_asm_type_ref ("btv_type", ctfc, var->dvd_type->dtd_type);
> dw2_asm_output_data (4, var->dvd_visibility, "btv_linkage");
> }
>
> @@ -937,8 +933,8 @@ btf_asm_varent (ctf_container_ref ctfc, ctf_dvdef_ref var)
> static void
> btf_asm_sou_member (ctf_container_ref ctfc, ctf_dmdef_t * dmd, unsigned int idx)
> {
> - ctf_dtdef_ref ref_type = ctfc->ctfc_types_list[dmd->dmd_type];
> - ctf_id_t base_type = dmd->dmd_type;
> + ctf_dtdef_ref ref_type = ctfc->ctfc_types_list[dmd->dmd_type->dtd_type];
> + ctf_id_t base_type = dmd->dmd_type->dtd_type;
> uint64_t sou_offset = dmd->dmd_offset;
>
> dw2_asm_output_data (4, dmd->dmd_name_offset,
> @@ -959,7 +955,7 @@ btf_asm_sou_member (ctf_container_ref ctfc, ctf_dmdef_t * dmd, unsigned int idx)
> sou_offset |= ((bits & 0xff) << 24);
>
> /* Refer to the base type of the slice. */
> - base_type = ref_type->dtd_u.dtu_slice.cts_type;
> + base_type = ref_type->dtd_u.dtu_slice.cts_type->dtd_type;
> }
> else
> {
> @@ -1003,9 +999,11 @@ btf_asm_func_arg (ctf_container_ref ctfc, ctf_func_arg_t * farg,
> else
> dw2_asm_output_data (4, 0, "farg_name");
>
> - btf_asm_type_ref ("farg_type", ctfc, (btf_removed_type_p (farg->farg_type)
> - ? BTF_VOID_TYPEID
> - : farg->farg_type));
> + ctf_id_t ref_id = BTF_VOID_TYPEID;
> + if (farg->farg_type && !btf_removed_type_p (farg->farg_type->dtd_type))
> + ref_id = farg->farg_type->dtd_type;
> +
> + btf_asm_type_ref ("farg_type", ctfc, ref_id);
> }
>
> /* Asm'out a BTF_KIND_FUNC type. */
> @@ -1381,7 +1379,7 @@ btf_init_postprocess (void)
> to create the const modifier type (if needed) now, before making the types
> list. So we can't avoid iterating with FOR_EACH_VARIABLE here, and then
> again when creating the DATASEC entries. */
> - ctf_id_t constvoid_id = CTF_NULL_TYPEID;
> + ctf_dtdef_ref constvoid_dtd = NULL;
> varpool_node *var;
> FOR_EACH_VARIABLE (var)
> {
> @@ -1400,10 +1398,10 @@ btf_init_postprocess (void)
> continue;
>
> /* Create the 'const' modifier type for void. */
> - if (constvoid_id == CTF_NULL_TYPEID)
> - constvoid_id = ctf_add_reftype (tu_ctfc, CTF_ADD_ROOT,
> - dvd->dvd_type, CTF_K_CONST, NULL);
> - dvd->dvd_type = constvoid_id;
> + if (constvoid_dtd == NULL)
> + constvoid_dtd = ctf_add_reftype (tu_ctfc, CTF_ADD_ROOT,
> + dvd->dvd_type, CTF_K_CONST, NULL);
> + dvd->dvd_type = constvoid_dtd;
> }
> }
>
> diff --git a/gcc/config/bpf/btfext-out.cc b/gcc/config/bpf/btfext-out.cc
> index 7ec438fd1d10..b3df7b555d5f 100644
> --- a/gcc/config/bpf/btfext-out.cc
> +++ b/gcc/config/bpf/btfext-out.cc
> @@ -134,7 +134,7 @@ struct GTY ((chain_next ("%h.next"))) btf_ext_lineinfo
>
> /* Internal representation of a BPF CO-RE relocation record. */
> struct GTY ((chain_next ("%h.next"))) btf_ext_core_reloc {
> - unsigned int bpfcr_type; /* BTF type ID of container. */
> + ctf_dtdef_ref bpfcr_type; /* BTF type involved in relocation. */
> unsigned int bpfcr_astr_off; /* Offset of access string in .BTF
> string table. */
> rtx_code_label * bpfcr_insn_label; /* RTX label attached to instruction
> @@ -296,13 +296,14 @@ bpf_core_reloc_add (const tree type, const char * section_name,
> struct btf_ext_core_reloc *bpfcr = bpf_create_core_reloc (section_name, &sec);
>
> ctf_container_ref ctfc = ctf_get_tu_ctfc ();
> + ctf_dtdef_ref dtd = ctf_lookup_tree_type (ctfc, type);
>
> /* Buffer the access string in the auxiliary strtab. */
> bpfcr->bpfcr_astr_off = 0;
> gcc_assert (accessor != NULL);
> bpfcr->bpfcr_astr_off = btf_ext_add_string (accessor);
>
> - bpfcr->bpfcr_type = get_btf_id (ctf_lookup_tree_type (ctfc, type));
> + bpfcr->bpfcr_type = dtd;
> bpfcr->bpfcr_insn_label = label;
> bpfcr->bpfcr_kind = kind;
>
> @@ -341,7 +342,8 @@ bpf_core_get_sou_member_index (ctf_container_ref ctfc, const tree node)
> for (dmd = dtd->dtd_u.dtu_members;
> dmd != NULL; dmd = (ctf_dmdef_t *) ctf_dmd_list_next (dmd))
> {
> - bool field_has_btf = get_btf_id (dmd->dmd_type) <= BTF_MAX_TYPE;
> + bool field_has_btf = (dmd->dmd_type
> + && dmd->dmd_type->dtd_type <= BTF_MAX_TYPE);
>
> if (field == node)
> return field_has_btf ? i : -1;
> @@ -574,8 +576,10 @@ output_btfext_core_sections (void)
> false);
> char *str = xstrdup (pp_formatted_text (&pp));
>
> - dw2_asm_output_data (4, bpfcr->bpfcr_type, "bpfcr_type (%s)",
> - str);
> + uint32_t type_id = bpfcr->bpfcr_type
> + ? bpfcr->bpfcr_type->dtd_type
> + : BTF_VOID_TYPEID;
> + dw2_asm_output_data (4, type_id, "bpfcr_type (%s)", str);
> dw2_asm_output_data (4, bpfcr->bpfcr_astr_off + str_aux_off,
> "bpfcr_astr_off (\"%s\")",
> bpfcr->info.accessor_str);
> diff --git a/gcc/config/bpf/core-builtins.cc b/gcc/config/bpf/core-builtins.cc
> index 829acea98f79..232bebcadbd5 100644
> --- a/gcc/config/bpf/core-builtins.cc
> +++ b/gcc/config/bpf/core-builtins.cc
> @@ -1021,7 +1021,8 @@ process_type (struct cr_builtins *data)
> && data->default_value != NULL)
> {
> ctf_container_ref ctfc = ctf_get_tu_ctfc ();
> - unsigned int btf_id = get_btf_id (ctf_lookup_tree_type (ctfc, ret.type));
> + ctf_dtdef_ref dtd = ctf_lookup_tree_type (ctfc, ret.type);
> + unsigned int btf_id = dtd ? dtd->dtd_type : BTF_VOID_TYPEID;
> data->rtx_default_value = expand_normal (build_int_cst (integer_type_node,
> btf_id));
> }
> diff --git a/gcc/ctfc.cc b/gcc/ctfc.cc
> index 67711606ab85..678ca2a072cf 100644
> --- a/gcc/ctfc.cc
> +++ b/gcc/ctfc.cc
> @@ -373,9 +373,9 @@ ctf_add_cuname (ctf_container_ref ctfc, const char * filename)
> ctf_dvd_lookup, as applicable, to ascertain that the CTF type or the CTF
> variable respectively does not already exist, and then add it. */
>
> -static ctf_id_t
> +static ctf_dtdef_ref
> ctf_add_generic (ctf_container_ref ctfc, uint32_t flag, const char * name,
> - ctf_dtdef_ref * rp, dw_die_ref die)
> + dw_die_ref die)
> {
> ctf_dtdef_ref dtd;
> ctf_id_t type;
> @@ -397,18 +397,16 @@ ctf_add_generic (ctf_container_ref ctfc, uint32_t flag, const char * name,
>
> ctf_dtd_insert (ctfc, dtd);
>
> - *rp = dtd;
> - return type;
> + return dtd;
> }
>
> -static ctf_id_t
> +static ctf_dtdef_ref
> ctf_add_encoded (ctf_container_ref ctfc, uint32_t flag, const char * name,
> const ctf_encoding_t * ep, uint32_t kind, dw_die_ref die)
> {
> ctf_dtdef_ref dtd;
> - ctf_id_t type;
>
> - type = ctf_add_generic (ctfc, flag, name, &dtd, die);
> + dtd = ctf_add_generic (ctfc, flag, name, die);
>
> dtd->dtd_data.ctti_info = CTF_TYPE_INFO (kind, flag, 0);
>
> @@ -424,83 +422,81 @@ ctf_add_encoded (ctf_container_ref ctfc, uint32_t flag, const char * name,
>
> ctfc->ctfc_num_stypes++;
>
> - return type;
> + return dtd;
> }
>
> -ctf_id_t
> -ctf_add_reftype (ctf_container_ref ctfc, uint32_t flag, ctf_id_t ref,
> +ctf_dtdef_ref
> +ctf_add_reftype (ctf_container_ref ctfc, uint32_t flag, ctf_dtdef_ref ref,
> uint32_t kind, dw_die_ref die)
> {
> ctf_dtdef_ref dtd;
> - ctf_id_t type;
>
> - gcc_assert (ref <= CTF_MAX_TYPE);
> + gcc_assert (ref != NULL);
>
> - type = ctf_add_generic (ctfc, flag, NULL, &dtd, die);
> + dtd = ctf_add_generic (ctfc, flag, NULL, die);
> dtd->dtd_data.ctti_info = CTF_TYPE_INFO (kind, flag, 0);
> /* Caller of this API must guarantee that a CTF type with id = ref already
> exists. This will also be validated for us at link-time. */
> - dtd->dtd_data.ctti_type = (uint32_t) ref;
> + dtd->dtd_data.ctti_type = (uint32_t) ref->dtd_type;
> + dtd->ref_type = ref;
>
> ctfc->ctfc_num_stypes++;
>
> - return type;
> + return dtd;
> }
>
> -ctf_id_t
> +ctf_dtdef_ref
> ctf_add_forward (ctf_container_ref ctfc, uint32_t flag, const char * name,
> uint32_t kind, dw_die_ref die)
> {
> ctf_dtdef_ref dtd;
> - ctf_id_t type = 0;
>
> - type = ctf_add_generic (ctfc, flag, name, &dtd, die);
> + dtd = ctf_add_generic (ctfc, flag, name, die);
>
> dtd->dtd_data.ctti_info = CTF_TYPE_INFO (CTF_K_FORWARD, flag, 0);
> dtd->dtd_data.ctti_type = kind;
>
> ctfc->ctfc_num_stypes++;
>
> - return type;
> + return dtd;
> }
>
> -ctf_id_t
> +ctf_dtdef_ref
> ctf_add_typedef (ctf_container_ref ctfc, uint32_t flag, const char * name,
> - ctf_id_t ref, dw_die_ref die)
> + ctf_dtdef_ref ref, dw_die_ref die)
> {
> ctf_dtdef_ref dtd;
> - ctf_id_t type;
>
> - gcc_assert (ref <= CTF_MAX_TYPE);
> + gcc_assert (ref != NULL);
> /* Nameless Typedefs are not expected. */
> gcc_assert ((name != NULL) && strcmp (name, ""));
>
> - type = ctf_add_generic (ctfc, flag, name, &dtd, die);
> + dtd = ctf_add_generic (ctfc, flag, name, die);
> dtd->dtd_data.ctti_info = CTF_TYPE_INFO (CTF_K_TYPEDEF, flag, 0);
> /* Caller of this API must guarantee that a CTF type with id = ref already
> exists. This will also be validated for us at link-time. */
This comment may cause confusion now. Can you please reword or may be
remove it altogether ?
Other places where a similar function needs update: ctf_add_slice too.
Please do the same action on that comment too.
> - dtd->dtd_data.ctti_type = (uint32_t) ref;
> + dtd->dtd_data.ctti_type = (uint32_t) ref->dtd_type;
> + dtd->ref_type = ref;
>
> gcc_assert (dtd->dtd_type != dtd->dtd_data.ctti_type);
>
> ctfc->ctfc_num_stypes++;
>
> - return type;
> + return dtd;
> }
>
> -ctf_id_t
> -ctf_add_slice (ctf_container_ref ctfc, uint32_t flag, ctf_id_t ref,
> +ctf_dtdef_ref
> +ctf_add_slice (ctf_container_ref ctfc, uint32_t flag, ctf_dtdef_ref ref,
> uint32_t bit_offset, uint32_t bit_size, dw_die_ref die)
> {
> ctf_dtdef_ref dtd;
> - ctf_id_t type;
> uint32_t roundup_nbytes;
>
> gcc_assert ((bit_size <= 255) && (bit_offset <= 255));
>
> - gcc_assert (ref <= CTF_MAX_TYPE);
> + gcc_assert (ref != NULL);
>
> - type = ctf_add_generic (ctfc, flag, NULL, &dtd, die);
> + dtd = ctf_add_generic (ctfc, flag, NULL, die);
>
> dtd->dtd_data.ctti_info = CTF_TYPE_INFO (CTF_K_SLICE, flag, 0);
>
> @@ -514,49 +510,48 @@ ctf_add_slice (ctf_container_ref ctfc, uint32_t flag, ctf_id_t ref,
>
> /* Caller of this API must guarantee that a CTF type with id = ref already
> exists. This will also be validated for us at link-time. */
> - dtd->dtd_u.dtu_slice.cts_type = (uint32_t) ref;
> + dtd->dtd_u.dtu_slice.cts_type = ref;
> dtd->dtd_u.dtu_slice.cts_bits = bit_size;
> dtd->dtd_u.dtu_slice.cts_offset = bit_offset;
>
> ctfc->ctfc_num_stypes++;
>
> - return type;
> + return dtd;
> }
>
> -ctf_id_t
> +ctf_dtdef_ref
> ctf_add_float (ctf_container_ref ctfc, uint32_t flag,
> const char * name, const ctf_encoding_t * ep, dw_die_ref die)
> {
> return (ctf_add_encoded (ctfc, flag, name, ep, CTF_K_FLOAT, die));
> }
>
> -ctf_id_t
> +ctf_dtdef_ref
> ctf_add_integer (ctf_container_ref ctfc, uint32_t flag,
> const char * name, const ctf_encoding_t * ep, dw_die_ref die)
> {
> return (ctf_add_encoded (ctfc, flag, name, ep, CTF_K_INTEGER, die));
> }
>
> -ctf_id_t
> +ctf_dtdef_ref
> ctf_add_unknown (ctf_container_ref ctfc, uint32_t flag,
> const char * name, const ctf_encoding_t * ep, dw_die_ref die)
> {
> return (ctf_add_encoded (ctfc, flag, name, ep, CTF_K_UNKNOWN, die));
> }
>
> -ctf_id_t
> -ctf_add_pointer (ctf_container_ref ctfc, uint32_t flag, ctf_id_t ref,
> +ctf_dtdef_ref
> +ctf_add_pointer (ctf_container_ref ctfc, uint32_t flag, ctf_dtdef_ref ref,
> dw_die_ref die)
> {
> return (ctf_add_reftype (ctfc, flag, ref, CTF_K_POINTER, die));
> }
>
> -ctf_id_t
> +ctf_dtdef_ref
> ctf_add_array (ctf_container_ref ctfc, uint32_t flag, const ctf_arinfo_t * arp,
> dw_die_ref die)
> {
> ctf_dtdef_ref dtd;
> - ctf_id_t type;
>
> gcc_assert (arp);
>
> @@ -564,7 +559,7 @@ ctf_add_array (ctf_container_ref ctfc, uint32_t flag, const ctf_arinfo_t * arp,
> arp->ctr_index are already added. This will also be validated for us at
> link-time. */
>
> - type = ctf_add_generic (ctfc, flag, NULL, &dtd, die);
> + dtd = ctf_add_generic (ctfc, flag, NULL, die);
>
> dtd->dtd_data.ctti_info = CTF_TYPE_INFO (CTF_K_ARRAY, flag, 0);
> dtd->dtd_data.ctti_size = 0;
> @@ -572,15 +567,14 @@ ctf_add_array (ctf_container_ref ctfc, uint32_t flag, const ctf_arinfo_t * arp,
>
> ctfc->ctfc_num_stypes++;
>
> - return type;
> + return dtd;
> }
>
> -ctf_id_t
> +ctf_dtdef_ref
> ctf_add_enum (ctf_container_ref ctfc, uint32_t flag, const char * name,
> HOST_WIDE_INT size, bool eunsigned, dw_die_ref die)
> {
> ctf_dtdef_ref dtd;
> - ctf_id_t type;
>
> /* In the compiler, no need to handle the case of promoting forwards to
> enums. This comment is simply to note a divergence from libctf. */
> @@ -595,7 +589,7 @@ ctf_add_enum (ctf_container_ref ctfc, uint32_t flag, const char * name,
> = CTF_TYPE_INFO (CTF_K_FORWARD, CTF_ADD_NONROOT, 0);
> }
>
> - type = ctf_add_generic (ctfc, flag, name, &dtd, die);
> + dtd = ctf_add_generic (ctfc, flag, name, die);
>
> dtd->dtd_data.ctti_info = CTF_TYPE_INFO (CTF_K_ENUM, flag, 0);
>
> @@ -608,12 +602,12 @@ ctf_add_enum (ctf_container_ref ctfc, uint32_t flag, const char * name,
>
> ctfc->ctfc_num_stypes++;
>
> - return type;
> + return dtd;
> }
>
> int
> -ctf_add_enumerator (ctf_container_ref ctfc, ctf_id_t enid, const char * name,
> - HOST_WIDE_INT value, dw_die_ref die)
> +ctf_add_enumerator (ctf_container_ref ctfc, ctf_dtdef_ref enum_dtd,
> + const char * name, HOST_WIDE_INT value, dw_die_ref die)
This function body has a comment which mentions "enid" argument. It
needs to be updated too. How about:
"Callers of this API must make sure that CTF_K_ENUM with enid has been ..."
-->
"The associated CTF type of kind CTF_K_ENUM must already exist."
> {
> ctf_dmdef_t * dmd;
> uint32_t kind, vlen, root;
> @@ -622,7 +616,7 @@ ctf_add_enumerator (ctf_container_ref ctfc, ctf_id_t enid, const char * name,
> addded. This will also be validated for us at link-time. */
> ctf_dtdef_ref dtd = ctf_dtd_lookup (ctfc, die);
> gcc_assert (dtd);
> - gcc_assert (dtd->dtd_type == enid);
> + gcc_assert (dtd == enum_dtd);
> gcc_assert (name);
>
> kind = CTF_V2_INFO_KIND (dtd->dtd_data.ctti_info);
> @@ -646,7 +640,7 @@ ctf_add_enumerator (ctf_container_ref ctfc, ctf_id_t enid, const char * name,
>
> /* Buffer the strings in the CTF string table. */
> dmd->dmd_name = ctf_add_string (ctfc, name, &(dmd->dmd_name_offset));
> - dmd->dmd_type = CTF_NULL_TYPEID;
> + dmd->dmd_type = NULL;
> dmd->dmd_offset = 0;
>
> dmd->dmd_value = value;
> @@ -662,7 +656,7 @@ ctf_add_enumerator (ctf_container_ref ctfc, ctf_id_t enid, const char * name,
>
> int
> ctf_add_member_offset (ctf_container_ref ctfc, dw_die_ref sou,
> - const char * name, ctf_id_t type,
> + const char * name, ctf_dtdef_ref type,
> uint64_t bit_offset)
> {
> ctf_dtdef_ref dtd = ctf_dtd_lookup (ctfc, sou);
> @@ -702,7 +696,7 @@ ctf_add_member_offset (ctf_container_ref ctfc, dw_die_ref sou,
> }
>
> int
> -ctf_add_variable (ctf_container_ref ctfc, const char * name, ctf_id_t ref,
> +ctf_add_variable (ctf_container_ref ctfc, const char * name, ctf_dtdef_ref ref,
> dw_die_ref die, unsigned int external_vis,
> dw_die_ref die_var_decl)
> {
> @@ -747,16 +741,16 @@ ctf_add_variable (ctf_container_ref ctfc, const char * name, ctf_id_t ref,
>
> int
> ctf_add_function_arg (ctf_container_ref ctfc, dw_die_ref func,
> - const char * name, ctf_id_t type)
> + const char * name, ctf_dtdef_ref arg_dtd)
> {
> - ctf_dtdef_ref dtd = ctf_dtd_lookup (ctfc, func);
> + ctf_dtdef_ref func_dtd = ctf_dtd_lookup (ctfc, func);
> ctf_func_arg_t * farg;
> uint32_t vlen;
>
> /* The function to which argument is being added must already exist. */
> - gcc_assert (dtd);
> + gcc_assert (func_dtd);
> /* The number of args must have been non-zero. */
> - vlen = CTF_V2_INFO_VLEN (dtd->dtd_data.ctti_info);
> + vlen = CTF_V2_INFO_VLEN (func_dtd->dtd_data.ctti_info);
> gcc_assert (vlen);
>
> farg = ggc_cleared_alloc<ctf_func_arg_t> ();
> @@ -766,9 +760,9 @@ ctf_add_function_arg (ctf_container_ref ctfc, dw_die_ref func,
> these strings to avoid unnecessary bloat in CTF section in CTF V3. */
> farg->farg_name = ctf_add_string (ctfc, name, &(farg->farg_name_offset),
> CTF_AUX_STRTAB);
> - farg->farg_type = type;
> + farg->farg_type = arg_dtd;
>
> - ctf_farg_list_append (&dtd->dtd_u.dtu_argv, farg);
> + ctf_farg_list_append (&func_dtd->dtd_u.dtu_argv, farg);
>
> /* For aux_str, keep ctfc_aux_strlen updated for debugging. */
> if ((name != NULL) && strcmp (name, ""))
> @@ -777,13 +771,12 @@ ctf_add_function_arg (ctf_container_ref ctfc, dw_die_ref func,
> return 0;
> }
>
> -ctf_id_t
> +ctf_dtdef_ref
> 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, int linkage)
> {
> ctf_dtdef_ref dtd;
> - ctf_id_t type;
> uint32_t vlen;
>
> gcc_assert (ctc);
> @@ -791,27 +784,27 @@ ctf_add_function (ctf_container_ref ctfc, uint32_t flag, const char * name,
> vlen = ctc->ctc_argc;
> gcc_assert (vlen <= CTF_MAX_VLEN);
>
> - type = ctf_add_generic (ctfc, flag, name, &dtd, die);
> + dtd = ctf_add_generic (ctfc, flag, name, die);
>
> dtd->from_global_func = from_global_func;
> dtd->linkage = linkage;
> dtd->dtd_data.ctti_info = CTF_TYPE_INFO (CTF_K_FUNCTION, flag, vlen);
> + dtd->ref_type = ctc->ctc_return;
> /* Caller must make sure CTF types for ctc->ctc_return are already added. */
> - dtd->dtd_data.ctti_type = (uint32_t) ctc->ctc_return;
> + dtd->dtd_data.ctti_type = (uint32_t) ctc->ctc_return->dtd_type;
> /* Caller must make sure CTF types for function arguments are already added
> via ctf_add_function_arg () API. */
>
> ctfc->ctfc_num_stypes++;
>
> - return type;
> + return dtd;
> }
>
> -ctf_id_t
> +ctf_dtdef_ref
> ctf_add_sou (ctf_container_ref ctfc, uint32_t flag, const char * name,
> uint32_t kind, size_t size, dw_die_ref die)
> {
> ctf_dtdef_ref dtd;
> - ctf_id_t type = 0;
>
> gcc_assert ((kind == CTF_K_STRUCT) || (kind == CTF_K_UNION));
>
> @@ -828,7 +821,7 @@ ctf_add_sou (ctf_container_ref ctfc, uint32_t flag, const char * name,
> = CTF_TYPE_INFO (CTF_K_FORWARD, CTF_ADD_NONROOT, 0);
> }
>
> - type = ctf_add_generic (ctfc, flag, name, &dtd, die);
> + dtd = ctf_add_generic (ctfc, flag, name, die);
>
> dtd->dtd_data.ctti_info = CTF_TYPE_INFO (kind, flag, 0);
>
> @@ -845,23 +838,23 @@ ctf_add_sou (ctf_container_ref ctfc, uint32_t flag, const char * name,
> ctfc->ctfc_num_stypes++;
> }
>
> - return type;
> + return dtd;
> }
>
> /* Given a TREE_TYPE node, return the CTF type ID for that type. */
>
This comment needs an update: "return the CTF type object" ?
> -ctf_id_t
> +ctf_dtdef_ref
> ctf_lookup_tree_type (ctf_container_ref ctfc, const tree type)
> {
> dw_die_ref die = lookup_type_die (type);
> if (die == NULL)
> - return CTF_NULL_TYPEID;
> + return NULL;
>
> ctf_dtdef_ref dtd = ctf_dtd_lookup (ctfc, die);
> if (dtd == NULL)
> - return CTF_NULL_TYPEID;
> + return NULL;
>
> - return dtd->dtd_type;
> + return dtd;
> }
>
> /* Check if CTF for TYPE has already been generated. Mainstay for
> @@ -870,7 +863,7 @@ ctf_lookup_tree_type (ctf_container_ref ctfc, const tree type)
>
> bool
> ctf_type_exists (ctf_container_ref ctfc, dw_die_ref type,
> - ctf_id_t * type_id)
> + ctf_dtdef_ref * dtd)
The function-level comment for this one also needs an update.
"updates the TYPE_ID for the caller."
-->
"updates the CTF type object DTD for the caller" ?
> {
> bool exists = false;
> ctf_dtdef_ref ctf_type_seen = ctf_dtd_lookup (ctfc, type);
> @@ -879,7 +872,7 @@ ctf_type_exists (ctf_container_ref ctfc, dw_die_ref type,
> {
> exists = true;
> /* CTF type for this type exists. */
> - *type_id = ctf_type_seen->dtd_type;
> + *dtd = ctf_type_seen;
> }
>
> return exists;
> diff --git a/gcc/ctfc.h b/gcc/ctfc.h
> index e7bd93901cfa..b2060eaf7e9b 100644
> --- a/gcc/ctfc.h
> +++ b/gcc/ctfc.h
> @@ -48,6 +48,10 @@ along with GCC; see the file COPYING3. If not see
>
> typedef uint64_t ctf_id_t;
>
> +struct ctf_dtdef;
> +typedef struct ctf_dtdef ctf_dtdef_t;
> +typedef ctf_dtdef_t * ctf_dtdef_ref;
> +
> /* CTF string table element (list node). */
>
> typedef struct GTY ((chain_next ("%h.cts_next"))) ctf_string
> @@ -81,8 +85,8 @@ typedef struct GTY (()) ctf_encoding
>
> typedef struct GTY (()) ctf_arinfo
> {
> - ctf_id_t ctr_contents; /* Type of array contents. */
> - ctf_id_t ctr_index; /* Type of array index. */
> + ctf_dtdef_ref ctr_contents; /* Type of array contents. */
> + ctf_dtdef_ref ctr_index; /* Type of array index. */
> unsigned int ctr_nelems; /* Number of elements. */
> } ctf_arinfo_t;
>
> @@ -90,14 +94,14 @@ typedef struct GTY (()) ctf_arinfo
>
> typedef struct GTY (()) ctf_funcinfo
> {
> - ctf_id_t ctc_return; /* Function return type. */
> - unsigned int ctc_argc; /* Number of typed arguments to function. */
> - unsigned int ctc_flags; /* Function attributes (see below). */
> + ctf_dtdef_ref ctc_return; /* Function return type. */
> + unsigned int ctc_argc; /* Number of typed arguments to function. */
> + unsigned int ctc_flags; /* Function attributes (see below). */
> } ctf_funcinfo_t;
>
> typedef struct GTY (()) ctf_sliceinfo
> {
> - unsigned int cts_type; /* Reference CTF type. */
> + ctf_dtdef_ref cts_type; /* Reference CTF type. */
> unsigned short cts_offset; /* Offset in bits of the first bit. */
> unsigned short cts_bits; /* Size in bits. */
> } ctf_sliceinfo_t;
> @@ -130,7 +134,7 @@ typedef struct GTY (()) ctf_itype
> typedef struct GTY ((chain_next ("%h.dmd_next"))) ctf_dmdef
> {
> const char * dmd_name; /* Name of this member. */
> - ctf_id_t dmd_type; /* Type of this member (for sou). */
> + ctf_dtdef_ref dmd_type; /* Type of this member (for sou). */
> uint32_t dmd_name_offset; /* Offset of the name in str table. */
> uint64_t dmd_offset; /* Offset of this member in bits (for sou). */
> HOST_WIDE_INT dmd_value; /* Value of this member (for enum). */
> @@ -143,7 +147,7 @@ typedef struct GTY ((chain_next ("%h.dmd_next"))) ctf_dmdef
>
> typedef struct GTY (()) ctf_func_arg
> {
> - ctf_id_t farg_type; /* Type identifier of the argument. */
> + ctf_dtdef_ref farg_type; /* Type of the argument. */
> const char * farg_name; /* Name of the argument. */
> uint32_t farg_name_offset; /* Offset of the name in str table. */
> struct ctf_func_arg * farg_next;/* A list node. */
> @@ -158,6 +162,7 @@ struct GTY ((for_user)) ctf_dtdef
> dw_die_ref dtd_key; /* Type key for hashing. */
> const char * dtd_name; /* Name associated with definition (if any). */
> ctf_id_t dtd_type; /* Type identifier for this definition. */
> + ctf_dtdef_ref ref_type; /* Type referred to by this type (if any). */
> ctf_itype_t dtd_data; /* Type node. */
> bool from_global_func; /* Whether this type was added from a global
> function. */
> @@ -178,7 +183,7 @@ struct GTY ((for_user)) ctf_dtdef
> } dtd_u;
> };
>
> -typedef struct ctf_dtdef ctf_dtdef_t;
> +#define ctf_type_id(dtd) ((uint32_t) dtd->dtd_type)
>
> /* Variable definition for CTF generation. */
>
> @@ -188,13 +193,11 @@ struct GTY ((for_user)) ctf_dvdef
> const char * dvd_name; /* Name associated with variable. */
> uint32_t dvd_name_offset; /* Offset of the name in str table. */
> unsigned int dvd_visibility; /* External visibility. 0=static,1=global. */
> - ctf_id_t dvd_type; /* Type of variable. */
> + ctf_dtdef_ref dvd_type; /* Type of variable. */
> };
>
> typedef struct ctf_dvdef ctf_dvdef_t;
> -
> typedef ctf_dvdef_t * ctf_dvdef_ref;
> -typedef ctf_dtdef_t * ctf_dtdef_ref;
>
> /* Location information for CTF Types and CTF Variables. */
>
> @@ -390,7 +393,7 @@ extern void btf_finalize (void);
>
> extern ctf_container_ref ctf_get_tu_ctfc (void);
>
> -extern bool ctf_type_exists (ctf_container_ref, dw_die_ref, ctf_id_t *);
> +extern bool ctf_type_exists (ctf_container_ref, dw_die_ref, ctf_dtdef_ref *);
>
> extern void ctf_add_cuname (ctf_container_ref, const char *);
>
> @@ -404,41 +407,42 @@ extern bool ctf_dvd_ignore_lookup (const ctf_container_ref ctfc,
> extern const char * ctf_add_string (ctf_container_ref, const char *,
> uint32_t *, int);
>
> -extern ctf_id_t ctf_add_reftype (ctf_container_ref, uint32_t, ctf_id_t,
> - uint32_t, dw_die_ref);
> -extern ctf_id_t ctf_add_enum (ctf_container_ref, uint32_t, const char *,
> - HOST_WIDE_INT, bool, dw_die_ref);
> -extern ctf_id_t ctf_add_slice (ctf_container_ref, uint32_t, ctf_id_t,
> - uint32_t, uint32_t, dw_die_ref);
> -extern ctf_id_t ctf_add_float (ctf_container_ref, uint32_t, const char *,
> - const ctf_encoding_t *, dw_die_ref);
> -extern ctf_id_t ctf_add_integer (ctf_container_ref, uint32_t, const char *,
> - const ctf_encoding_t *, dw_die_ref);
> -extern ctf_id_t ctf_add_unknown (ctf_container_ref, uint32_t, const char *,
> - const ctf_encoding_t *, dw_die_ref);
> -extern ctf_id_t ctf_add_pointer (ctf_container_ref, uint32_t, ctf_id_t,
> - dw_die_ref);
> -extern ctf_id_t ctf_add_array (ctf_container_ref, uint32_t,
> - const ctf_arinfo_t *, dw_die_ref);
> -extern ctf_id_t ctf_add_forward (ctf_container_ref, uint32_t, const char *,
> - uint32_t, dw_die_ref);
> -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, int);
> -extern ctf_id_t ctf_add_sou (ctf_container_ref, uint32_t, const char *,
> - uint32_t, size_t, dw_die_ref);
> -
> -extern int ctf_add_enumerator (ctf_container_ref, ctf_id_t, const char *,
> +extern ctf_dtdef_ref ctf_add_reftype (ctf_container_ref, uint32_t,
> + ctf_dtdef_ref, uint32_t, dw_die_ref);
> +extern ctf_dtdef_ref ctf_add_enum (ctf_container_ref, uint32_t, const char *,
> + HOST_WIDE_INT, bool, dw_die_ref);
> +extern ctf_dtdef_ref ctf_add_slice (ctf_container_ref, uint32_t, ctf_dtdef_ref,
> + uint32_t, uint32_t, dw_die_ref);
> +extern ctf_dtdef_ref ctf_add_float (ctf_container_ref, uint32_t, const char *,
> + const ctf_encoding_t *, dw_die_ref);
> +extern ctf_dtdef_ref ctf_add_integer (ctf_container_ref, uint32_t, const char *,
> + const ctf_encoding_t *, dw_die_ref);
> +extern ctf_dtdef_ref ctf_add_unknown (ctf_container_ref, uint32_t, const char *,
> + const ctf_encoding_t *, dw_die_ref);
> +extern ctf_dtdef_ref ctf_add_pointer (ctf_container_ref, uint32_t,
> + ctf_dtdef_ref, dw_die_ref);
> +extern ctf_dtdef_ref ctf_add_array (ctf_container_ref, uint32_t,
> + const ctf_arinfo_t *, dw_die_ref);
> +extern ctf_dtdef_ref ctf_add_forward (ctf_container_ref, uint32_t, const char *,
> + uint32_t, dw_die_ref);
> +extern ctf_dtdef_ref ctf_add_typedef (ctf_container_ref, uint32_t, const char *,
> + ctf_dtdef_ref, dw_die_ref);
> +extern ctf_dtdef_ref ctf_add_function (ctf_container_ref, uint32_t,
> + const char *, const ctf_funcinfo_t *,
> + dw_die_ref, bool, int);
> +extern ctf_dtdef_ref ctf_add_sou (ctf_container_ref, uint32_t, const char *,
> + uint32_t, size_t, dw_die_ref);
> +
> +extern int ctf_add_enumerator (ctf_container_ref, ctf_dtdef_ref, const char *,
> HOST_WIDE_INT, dw_die_ref);
> extern int ctf_add_member_offset (ctf_container_ref, dw_die_ref, const char *,
> - ctf_id_t, uint64_t);
> + ctf_dtdef_ref, uint64_t);
> extern int ctf_add_function_arg (ctf_container_ref, dw_die_ref,
> - const char *, ctf_id_t);
> -extern int ctf_add_variable (ctf_container_ref, const char *, ctf_id_t,
> + const char *, ctf_dtdef_ref);
> +extern int ctf_add_variable (ctf_container_ref, const char *, ctf_dtdef_ref,
> dw_die_ref, unsigned int, dw_die_ref);
>
> -extern ctf_id_t ctf_lookup_tree_type (ctf_container_ref, const tree);
> +extern ctf_dtdef_ref ctf_lookup_tree_type (ctf_container_ref, const tree);
> extern ctf_id_t get_btf_id (ctf_id_t);
>
> typedef bool (*funcs_traverse_callback) (ctf_dtdef_ref, void *);
> diff --git a/gcc/ctfout.cc b/gcc/ctfout.cc
> index ee082b5fd016..157afbac4f48 100644
> --- a/gcc/ctfout.cc
> +++ b/gcc/ctfout.cc
> @@ -380,7 +380,8 @@ ctf_asm_type (ctf_dtdef_ref type)
> static void
> ctf_asm_slice (ctf_dtdef_ref type)
> {
> - dw2_asm_output_data (4, type->dtd_u.dtu_slice.cts_type, "cts_type");
> + dw2_asm_output_data (4, ctf_type_id (type->dtd_u.dtu_slice.cts_type),
> + "cts_type");
> dw2_asm_output_data (2, type->dtd_u.dtu_slice.cts_offset, "cts_offset");
> dw2_asm_output_data (2, type->dtd_u.dtu_slice.cts_bits, "cts_bits");
> }
> @@ -390,8 +391,10 @@ ctf_asm_slice (ctf_dtdef_ref type)
> static void
> ctf_asm_array (ctf_dtdef_ref dtd)
> {
> - dw2_asm_output_data (4, dtd->dtd_u.dtu_arr.ctr_contents, "cta_contents");
> - dw2_asm_output_data (4, dtd->dtd_u.dtu_arr.ctr_index, "cta_index");
> + dw2_asm_output_data (4, ctf_type_id (dtd->dtd_u.dtu_arr.ctr_contents),
> + "cta_contents");
> + dw2_asm_output_data (4, ctf_type_id (dtd->dtd_u.dtu_arr.ctr_index),
> + "cta_index");
> dw2_asm_output_data (4, dtd->dtd_u.dtu_arr.ctr_nelems, "cta_nelems");
> }
>
> @@ -403,7 +406,7 @@ ctf_asm_varent (ctf_dvdef_ref var)
> /* Output the reference to the name in the string table. */
> dw2_asm_output_data (4, var->dvd_name_offset, "ctv_name");
> /* Output the type index. */
> - dw2_asm_output_data (4, var->dvd_type, "ctv_typeidx");
> + dw2_asm_output_data (4, ctf_type_id (var->dvd_type), "ctv_typeidx");
> }
>
> /* Asm'out a member of CTF struct or union, represented by ctf_lmember_t. */
> @@ -414,7 +417,7 @@ ctf_asm_sou_lmember (ctf_dmdef_t * dmd)
> dw2_asm_output_data (4, dmd->dmd_name_offset, "ctlm_name");
> dw2_asm_output_data (4, CTF_OFFSET_TO_LMEMHI (dmd->dmd_offset),
> "ctlm_offsethi");
> - dw2_asm_output_data (4, dmd->dmd_type, "ctlm_type");
> + dw2_asm_output_data (4, ctf_type_id (dmd->dmd_type), "ctlm_type");
> dw2_asm_output_data (4, CTF_OFFSET_TO_LMEMLO (dmd->dmd_offset),
> "ctlm_offsetlo");
> }
> @@ -426,7 +429,7 @@ ctf_asm_sou_member (ctf_dmdef_t * dmd)
> {
> dw2_asm_output_data (4, dmd->dmd_name_offset, "ctm_name");
> dw2_asm_output_data (4, dmd->dmd_offset, "ctm_offset");
> - dw2_asm_output_data (4, dmd->dmd_type, "ctm_type");
> + dw2_asm_output_data (4, ctf_type_id (dmd->dmd_type), "ctm_type");
> }
>
> /* Asm'out an enumerator constant. */
> @@ -443,7 +446,10 @@ ctf_asm_enum_const (ctf_dmdef_t * dmd)
> static void
> ctf_asm_func_arg (ctf_func_arg_t * farg)
> {
> - dw2_asm_output_data (4, farg->farg_type, "dtu_argv");
> + /* farg_type may be NULL, indicating varargs. */
> + dw2_asm_output_data (4, farg->farg_type
> + ? ctf_type_id (farg->farg_type)
> + : 0, "dtu_argv");
> }
>
> /* CTF writeout to asm file. */
> @@ -537,7 +543,7 @@ output_ctf_obj_info (ctf_container_ref ctfc)
> var = ctfc->ctfc_gobjts_list[i];
>
> /* CTF type ID corresponding to the type of the variable. */
> - dw2_asm_output_data (4, var->dvd_type, "objtinfo_var_type");
> + dw2_asm_output_data (4, ctf_type_id (var->dvd_type), "objtinfo_var_type");
> }
>
> }
> diff --git a/gcc/dwarf2ctf.cc b/gcc/dwarf2ctf.cc
> index 8f9e2fada9e3..a6c8541ef2b4 100644
> --- a/gcc/dwarf2ctf.cc
> +++ b/gcc/dwarf2ctf.cc
> @@ -29,7 +29,7 @@ along with GCC; see the file COPYING3. If not see
>
> /* Forward declarations for some routines defined in this file. */
>
> -static ctf_id_t
> +static ctf_dtdef_ref
> gen_ctf_type (ctf_container_ref, dw_die_ref);
>
> /* All the DIE structures we handle come from the DWARF information
> @@ -156,7 +156,7 @@ ctf_get_die_loc_col (dw_die_ref die)
>
> /* Generate CTF for the void type. */
>
> -static ctf_id_t
> +static ctf_dtdef_ref
> gen_ctf_void_type (ctf_container_ref ctfc)
> {
> ctf_encoding_t ctf_encoding = {0, 0, 0};
> @@ -174,10 +174,10 @@ gen_ctf_void_type (ctf_container_ref ctfc)
>
> /* Generate CTF type of unknown kind. */
>
> -static ctf_id_t
> +static ctf_dtdef_ref
> gen_ctf_unknown_type (ctf_container_ref ctfc)
> {
> - ctf_id_t unknown_type_id;
> + ctf_dtdef_ref dtd;
>
> /* In CTF, the unknown type is encoded as a 0 byte sized type with kind
> CTF_K_UNKNOWN. Create an encoding object merely to reuse the underlying
> @@ -187,11 +187,11 @@ gen_ctf_unknown_type (ctf_container_ref ctfc)
>
> gcc_assert (ctf_unknown_die != NULL);
> /* Type de-duplication. */
> - if (!ctf_type_exists (ctfc, ctf_unknown_die, &unknown_type_id))
> - unknown_type_id = ctf_add_unknown (ctfc, CTF_ADD_ROOT, "unknown",
> - &ctf_encoding, ctf_unknown_die);
> + if (!ctf_type_exists (ctfc, ctf_unknown_die, &dtd))
> + dtd = ctf_add_unknown (ctfc, CTF_ADD_ROOT, "unknown",
> + &ctf_encoding, ctf_unknown_die);
>
> - return unknown_type_id;
> + return dtd;
> }
>
> /* Sizes of entities can be given in bytes or bits. This function
> @@ -217,10 +217,10 @@ ctf_die_bitsize (dw_die_ref die)
> Important: the caller of this API must make sure that duplicate types are
> not added. */
>
> -static ctf_id_t
> +static ctf_dtdef_ref
> gen_ctf_base_type (ctf_container_ref ctfc, dw_die_ref type)
> {
> - ctf_id_t type_id = CTF_NULL_TYPEID;
> + ctf_dtdef_ref dtd = NULL;
>
> ctf_encoding_t ctf_encoding = {0, 0, 0};
>
> @@ -236,8 +236,8 @@ gen_ctf_base_type (ctf_container_ref ctfc, dw_die_ref type)
> ctf_encoding.cte_bits = 0;
>
> gcc_assert (name_string);
> - type_id = ctf_add_integer (ctfc, CTF_ADD_ROOT, name_string,
> - &ctf_encoding, type);
> + dtd = ctf_add_integer (ctfc, CTF_ADD_ROOT, name_string,
> + &ctf_encoding, type);
>
> break;
> case DW_ATE_boolean:
> @@ -246,8 +246,8 @@ gen_ctf_base_type (ctf_container_ref ctfc, dw_die_ref type)
> ctf_encoding.cte_bits = bit_size;
>
> gcc_assert (name_string);
> - type_id = ctf_add_integer (ctfc, CTF_ADD_ROOT, name_string,
> - &ctf_encoding, type);
> + dtd = ctf_add_integer (ctfc, CTF_ADD_ROOT, name_string,
> + &ctf_encoding, type);
> break;
> case DW_ATE_float:
> {
> @@ -269,7 +269,7 @@ gen_ctf_base_type (ctf_container_ref ctfc, dw_die_ref type)
> break;
>
> ctf_encoding.cte_bits = bit_size;
> - type_id = ctf_add_float (ctfc, CTF_ADD_ROOT, name_string,
> + dtd = ctf_add_float (ctfc, CTF_ADD_ROOT, name_string,
> &ctf_encoding, type);
>
> break;
> @@ -291,7 +291,7 @@ gen_ctf_base_type (ctf_container_ref ctfc, dw_die_ref type)
> ctf_encoding.cte_format |= CTF_INT_SIGNED;
>
> ctf_encoding.cte_bits = bit_size;
> - type_id = ctf_add_integer (ctfc, CTF_ADD_ROOT, name_string,
> + dtd = ctf_add_integer (ctfc, CTF_ADD_ROOT, name_string,
> &ctf_encoding, type);
> break;
>
> @@ -315,7 +315,7 @@ gen_ctf_base_type (ctf_container_ref ctfc, dw_die_ref type)
> break;
>
> ctf_encoding.cte_bits = bit_size;
> - type_id = ctf_add_float (ctfc, CTF_ADD_ROOT, name_string,
> + dtd = ctf_add_float (ctfc, CTF_ADD_ROOT, name_string,
> &ctf_encoding, type);
> break;
> }
> @@ -324,41 +324,39 @@ gen_ctf_base_type (ctf_container_ref ctfc, dw_die_ref type)
> break;
> }
>
> - return type_id;
> + return dtd;
> }
>
> /* Generate CTF for a pointer type. */
>
> -static ctf_id_t
> +static ctf_dtdef_ref
> gen_ctf_pointer_type (ctf_container_ref ctfc, dw_die_ref ptr_type)
> {
> - ctf_id_t type_id = CTF_NULL_TYPEID;
> - ctf_id_t ptr_type_id = CTF_NULL_TYPEID;
> + ctf_dtdef_ref pointed_dtd, pointer_dtd;
> dw_die_ref pointed_type_die = ctf_get_AT_type (ptr_type);
>
> - type_id = gen_ctf_type (ctfc, pointed_type_die);
> + pointed_dtd = gen_ctf_type (ctfc, pointed_type_die);
>
> /* Type de-duplication.
> Consult the ctfc_types hash again before adding the CTF pointer type
> because there can be cases where a pointer type may have been added by
> the gen_ctf_type call above. */
> - if (ctf_type_exists (ctfc, ptr_type, &ptr_type_id))
> - return ptr_type_id;
> + if (!ctf_type_exists (ctfc, ptr_type, &pointer_dtd))
> + pointer_dtd = ctf_add_pointer (ctfc, CTF_ADD_ROOT, pointed_dtd, ptr_type);
>
> - ptr_type_id = ctf_add_pointer (ctfc, CTF_ADD_ROOT, type_id, ptr_type);
> - return ptr_type_id;
> + return pointer_dtd;
> }
>
> /* Recursively generate CTF for array dimensions starting at DIE C (of type
> DW_TAG_subrange_type) until DIE LAST (of type DW_TAG_subrange_type) is
> reached. ARRAY_ELEMS_TYPE_ID is base type for the array. */
>
This function-level comment needs updating. "ARRAY_ELEMS_TYPE_ID is ..."
--> say, "ARRAY_ELEMS_TYPE is the CTF type for the type of the array
elements.".
> -static ctf_id_t
> -gen_ctf_subrange_type (ctf_container_ref ctfc, ctf_id_t array_elems_type_id,
> +static ctf_dtdef_ref
> +gen_ctf_subrange_type (ctf_container_ref ctfc, ctf_dtdef_ref array_elems_type,
> dw_die_ref c, dw_die_ref last)
> {
> ctf_arinfo_t arinfo;
> - ctf_id_t array_node_type_id = CTF_NULL_TYPEID;
> + ctf_dtdef_ref array_dtd;
>
> dw_attr_node *upper_bound_at;
> dw_die_ref array_index_type;
> @@ -398,30 +396,29 @@ gen_ctf_subrange_type (ctf_container_ref ctfc, ctf_id_t array_elems_type_id,
> arinfo.ctr_index = gen_ctf_type (ctfc, array_index_type);
>
> if (c == last)
> - arinfo.ctr_contents = array_elems_type_id;
> + arinfo.ctr_contents = array_elems_type;
> else
> - arinfo.ctr_contents = gen_ctf_subrange_type (ctfc, array_elems_type_id,
> + arinfo.ctr_contents = gen_ctf_subrange_type (ctfc, array_elems_type,
> dw_get_die_sib (c), last);
>
> - if (!ctf_type_exists (ctfc, c, &array_node_type_id))
> - array_node_type_id = ctf_add_array (ctfc, CTF_ADD_ROOT, &arinfo, c);
> + if (!ctf_type_exists (ctfc, c, &array_dtd))
> + array_dtd = ctf_add_array (ctfc, CTF_ADD_ROOT, &arinfo, c);
>
> - return array_node_type_id;
> + return array_dtd;
> }
>
> /* Generate CTF for an ARRAY_TYPE. */
>
> -static ctf_id_t
> +static ctf_dtdef_ref
> gen_ctf_array_type (ctf_container_ref ctfc,
> dw_die_ref array_type)
> {
> dw_die_ref first, last, array_elems_type;
> - ctf_id_t array_elems_type_id = CTF_NULL_TYPEID;
> - ctf_id_t array_type_id = CTF_NULL_TYPEID;
> + ctf_dtdef_ref array_dtd, elem_dtd;
>
> int vector_type_p = get_AT_flag (array_type, DW_AT_GNU_vector);
> if (vector_type_p)
> - return array_elems_type_id;
> + return NULL;
>
> /* Find the first and last array dimension DIEs. */
> last = dw_get_die_child (array_type);
> @@ -429,41 +426,36 @@ gen_ctf_array_type (ctf_container_ref ctfc,
>
> /* Type de-duplication.
> Consult the ctfc_types before adding CTF type for the first dimension. */
> - if (!ctf_type_exists (ctfc, first, &array_type_id))
> + if (!ctf_type_exists (ctfc, first, &array_dtd))
> {
> array_elems_type = ctf_get_AT_type (array_type);
> /* First, register the type of the array elements if needed. */
> - array_elems_type_id = gen_ctf_type (ctfc, array_elems_type);
> + elem_dtd = gen_ctf_type (ctfc, array_elems_type);
>
> - array_type_id = gen_ctf_subrange_type (ctfc, array_elems_type_id, first,
> - last);
> + array_dtd = gen_ctf_subrange_type (ctfc, elem_dtd, first, last);
> }
>
> - return array_type_id;
> + return array_dtd;
> }
>
> /* Generate CTF for a typedef. */
>
> -static ctf_id_t
> +static ctf_dtdef_ref
> gen_ctf_typedef (ctf_container_ref ctfc, dw_die_ref tdef)
> {
> - ctf_id_t tdef_type_id, tid;
> + ctf_dtdef_ref tdef_dtd, dtd;
> const char *tdef_name = get_AT_string (tdef, DW_AT_name);
> dw_die_ref tdef_type = ctf_get_AT_type (tdef);
>
> - tid = gen_ctf_type (ctfc, tdef_type);
> + dtd = gen_ctf_type (ctfc, tdef_type);
>
> /* Type de-duplication.
> This is necessary because the ctf for the typedef may have been already
> added due to the gen_ctf_type call above. */
> - if (!ctf_type_exists (ctfc, tdef, &tdef_type_id))
> - {
> - tdef_type_id = ctf_add_typedef (ctfc, CTF_ADD_ROOT,
> - tdef_name,
> - tid,
> - tdef);
> - }
> - return tdef_type_id;
> + if (!ctf_type_exists (ctfc, tdef, &tdef_dtd))
> + tdef_dtd = ctf_add_typedef (ctfc, CTF_ADD_ROOT, tdef_name, dtd, tdef);
> +
> + return tdef_dtd;
> }
>
> /* Generate CTF for a type modifier.
> @@ -475,11 +467,11 @@ gen_ctf_typedef (ctf_container_ref ctfc, dw_die_ref tdef)
> For all other cases, this function returns a CTF_NULL_TYPEID;
> */
>
> -static ctf_id_t
> +static ctf_dtdef_ref
> gen_ctf_modifier_type (ctf_container_ref ctfc, dw_die_ref modifier)
The function-level comment of this one needs updating.
Also a stub in this function (not present in the diff below) has a
"return CTF_NULL_TYPEID;". Changing it to return NULL; is better.
> {
> uint32_t kind = CTF_K_MAX;
> - ctf_id_t modifier_type_id, qual_type_id;
> + ctf_dtdef_ref dtd, modifier_dtd;
> dw_die_ref qual_type = ctf_get_AT_type (modifier);
>
> switch (dw_get_die_tag (modifier))
> @@ -493,33 +485,31 @@ gen_ctf_modifier_type (ctf_container_ref ctfc, dw_die_ref modifier)
> }
>
> /* Register the type for which this modifier applies. */
> - qual_type_id = gen_ctf_type (ctfc, qual_type);
> + dtd = gen_ctf_type (ctfc, qual_type);
>
> /* Skip generating a CTF modifier record for _Atomic as there is no
> representation for it. */
> if (dw_get_die_tag (modifier) == DW_TAG_atomic_type)
> - return qual_type_id;
> + return dtd;
>
> gcc_assert (kind != CTF_K_MAX);
> /* Now register the modifier itself. */
> - if (!ctf_type_exists (ctfc, modifier, &modifier_type_id))
> - modifier_type_id = ctf_add_reftype (ctfc, CTF_ADD_ROOT,
> - qual_type_id, kind,
> - modifier);
> + if (!ctf_type_exists (ctfc, modifier, &modifier_dtd))
> + modifier_dtd = ctf_add_reftype (ctfc, CTF_ADD_ROOT, dtd, kind, modifier);
>
> - return modifier_type_id;
> + return modifier_dtd;
> }
>
> /* Generate CTF for a struct type. */
>
> -static ctf_id_t
> +static ctf_dtdef_ref
> gen_ctf_sou_type (ctf_container_ref ctfc, dw_die_ref sou, uint32_t kind)
> {
> uint32_t bit_size = ctf_die_bitsize (sou);
> int declaration_p = get_AT_flag (sou, DW_AT_declaration);
> const char *sou_name = get_AT_string (sou, DW_AT_name);
>
> - ctf_id_t sou_type_id;
> + ctf_dtdef_ref sou_dtd;
>
> /* An incomplete structure or union type is represented in DWARF by
> a structure or union DIE that does not have a size attribute and
> @@ -531,10 +521,10 @@ gen_ctf_sou_type (ctf_container_ref ctfc, dw_die_ref sou, uint32_t kind)
>
> /* This is a complete struct or union type. Generate a CTF type for
> it if it doesn't exist already. */
> - if (!ctf_type_exists (ctfc, sou, &sou_type_id))
> - sou_type_id = ctf_add_sou (ctfc, CTF_ADD_ROOT,
> - sou_name, kind, bit_size / 8,
> - sou);
> + if (!ctf_type_exists (ctfc, sou, &sou_dtd))
> + sou_dtd = ctf_add_sou (ctfc, CTF_ADD_ROOT,
> + sou_name, kind, bit_size / 8,
> + sou);
>
> /* Now process the struct members. */
> {
> @@ -547,7 +537,7 @@ gen_ctf_sou_type (ctf_container_ref ctfc, dw_die_ref sou, uint32_t kind)
> const char *field_name;
> dw_die_ref field_type;
> HOST_WIDE_INT field_location;
> - ctf_id_t field_type_id;
> + ctf_dtdef_ref field_dtd;
>
> c = dw_get_die_sib (c);
>
> @@ -556,7 +546,7 @@ gen_ctf_sou_type (ctf_container_ref ctfc, dw_die_ref sou, uint32_t kind)
> field_location = ctf_get_AT_data_member_location (c);
>
> /* Generate the field type. */
> - field_type_id = gen_ctf_type (ctfc, field_type);
> + field_dtd = gen_ctf_type (ctfc, field_type);
>
> /* If this is a bit-field, then wrap the field type
> generated above with a CTF slice. */
> @@ -610,29 +600,29 @@ gen_ctf_sou_type (ctf_container_ref ctfc, dw_die_ref sou, uint32_t kind)
> surely something to look at for the next format version bump
> for CTF. */
> if (bitsize <= 255 && (bitpos - field_location) <= 255)
> - field_type_id = ctf_add_slice (ctfc, CTF_ADD_NONROOT,
> - field_type_id,
> + field_dtd = ctf_add_slice (ctfc, CTF_ADD_NONROOT,
> + field_dtd,
> bitpos - field_location,
> bitsize, c);
> else
> - field_type_id = gen_ctf_unknown_type (ctfc);
> + field_dtd = gen_ctf_unknown_type (ctfc);
> }
>
> /* Add the field type to the struct or union type. */
> ctf_add_member_offset (ctfc, sou,
> field_name,
> - field_type_id,
> + field_dtd,
> field_location);
> }
> while (c != dw_get_die_child (sou));
> }
>
> - return sou_type_id;
> + return sou_dtd;
> }
>
> /* Generate CTF for a function type. */
>
> -static ctf_id_t
> +static ctf_dtdef_ref
> gen_ctf_function_type (ctf_container_ref ctfc, dw_die_ref function,
> bool from_global_func)
> {
> @@ -643,17 +633,16 @@ gen_ctf_function_type (ctf_container_ref ctfc, dw_die_ref function,
> 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;
> + ctf_dtdef_ref return_dtd, function_dtd;
>
> /* First, add the return type. */
> - return_type_id = gen_ctf_type (ctfc, return_type);
> - func_info.ctc_return = return_type_id;
> + return_dtd = gen_ctf_type (ctfc, return_type);
> + func_info.ctc_return = return_dtd;
>
> /* Type de-duplication.
> Consult the ctfc_types hash before adding the CTF function type. */
> - if (ctf_type_exists (ctfc, function, &function_type_id))
> - return function_type_id;
> + if (ctf_type_exists (ctfc, function, &function_dtd))
> + return function_dtd;
>
> /* Do a first pass on the formals to determine the number of
> arguments, and whether the function type gets a varargs. */
> @@ -681,12 +670,12 @@ gen_ctf_function_type (ctf_container_ref ctfc, dw_die_ref function,
> func_info.ctc_argc = num_args;
>
> /* Type de-duplication has already been performed by now. */
> - function_type_id = ctf_add_function (ctfc, CTF_ADD_ROOT,
> - function_name,
> - (const ctf_funcinfo_t *)&func_info,
> - function,
> - from_global_func,
> - linkage);
> + function_dtd = ctf_add_function (ctfc, CTF_ADD_ROOT,
> + function_name,
> + (const ctf_funcinfo_t *)&func_info,
> + function,
> + from_global_func,
> + linkage);
>
> /* Second pass on formals: generate the CTF types corresponding to
> them and add them as CTF function args. */
> @@ -694,7 +683,7 @@ gen_ctf_function_type (ctf_container_ref ctfc, dw_die_ref function,
> dw_die_ref c;
> unsigned int i = 0;
> const char *arg_name;
> - ctf_id_t arg_type;
> + ctf_dtdef_ref arg_type;
>
> c = dw_get_die_child (function);
> if (c)
> @@ -706,7 +695,7 @@ gen_ctf_function_type (ctf_container_ref ctfc, dw_die_ref function,
> {
> gcc_assert (i == num_args - 1);
> /* Add an argument with type 0 and no name. */
> - ctf_add_function_arg (ctfc, function, "", 0);
> + ctf_add_function_arg (ctfc, function, "", NULL);
> }
> else if (dw_get_die_tag (c) == DW_TAG_formal_parameter)
> {
> @@ -723,12 +712,12 @@ gen_ctf_function_type (ctf_container_ref ctfc, dw_die_ref function,
> while (c != dw_get_die_child (function));
> }
>
> - return function_type_id;
> + return function_dtd;
> }
>
> /* Generate CTF for an enumeration type. */
>
> -static ctf_id_t
> +static ctf_dtdef_ref
> gen_ctf_enumeration_type (ctf_container_ref ctfc, dw_die_ref enumeration)
> {
> const char *enum_name = get_AT_string (enumeration, DW_AT_name);
> @@ -736,7 +725,7 @@ gen_ctf_enumeration_type (ctf_container_ref ctfc, dw_die_ref enumeration)
> unsigned int signedness = get_AT_unsigned (enumeration, DW_AT_encoding);
> int declaration_p = get_AT_flag (enumeration, DW_AT_declaration);
>
> - ctf_id_t enumeration_type_id;
> + ctf_dtdef_ref enum_dtd;
>
> /* If this is an incomplete enum, generate a CTF forward for it and
> be done. */
> @@ -756,10 +745,10 @@ gen_ctf_enumeration_type (ctf_container_ref ctfc, dw_die_ref enumeration)
> }
>
> /* Generate a CTF type for the enumeration. */
> - enumeration_type_id = ctf_add_enum (ctfc, CTF_ADD_ROOT,
> - enum_name, bit_size / 8,
> - (signedness == DW_ATE_unsigned),
> - enumeration);
> + enum_dtd = ctf_add_enum (ctfc, CTF_ADD_ROOT,
> + enum_name, bit_size / 8,
> + (signedness == DW_ATE_unsigned),
> + enumeration);
>
> /* Process the enumerators. */
> {
> @@ -787,13 +776,13 @@ gen_ctf_enumeration_type (ctf_container_ref ctfc, dw_die_ref enumeration)
> else
> value_wide_int = AT_int (enumerator_value);
>
> - ctf_add_enumerator (ctfc, enumeration_type_id,
> + ctf_add_enumerator (ctfc, enum_dtd,
> enumerator_name, value_wide_int, enumeration);
> }
> while (c != dw_get_die_child (enumeration));
> }
>
> - return enumeration_type_id;
> + return enum_dtd;
> }
>
> /* Add a CTF variable record for the given input DWARF DIE. */
> @@ -804,7 +793,7 @@ gen_ctf_variable (ctf_container_ref ctfc, dw_die_ref die)
> const char *var_name = get_AT_string (die, DW_AT_name);
> dw_die_ref var_type = ctf_get_AT_type (die);
> unsigned int external_vis = get_AT_flag (die, DW_AT_external);
> - ctf_id_t var_type_id;
> + ctf_dtdef_ref var_dtd;
>
> /* Avoid duplicates. */
> if (ctf_dvd_lookup (ctfc, die))
> @@ -822,11 +811,10 @@ gen_ctf_variable (ctf_container_ref ctfc, dw_die_ref die)
> dw_die_ref decl = get_AT_ref (die, DW_AT_specification);
>
> /* Add the type of the variable. */
> - var_type_id = gen_ctf_type (ctfc, var_type);
> + var_dtd = gen_ctf_type (ctfc, var_type);
>
> /* Generate the new CTF variable and update global counter. */
> - (void) ctf_add_variable (ctfc, var_name, var_type_id, die, external_vis,
> - decl);
> + (void) ctf_add_variable (ctfc, var_name, var_dtd, die, external_vis, decl);
> /* Skip updating the number of global objects at this time. This is updated
> later after pre-processing as some CTF variable records although
> generated now, will not be emitted later. [PR105089]. */
> @@ -837,10 +825,10 @@ gen_ctf_variable (ctf_container_ref ctfc, dw_die_ref die)
> static void
> gen_ctf_function (ctf_container_ref ctfc, dw_die_ref die)
> {
> - ctf_id_t function_type_id;
> + ctf_dtdef_ref function_dtd;
> /* Type de-duplication.
> Consult the ctfc_types hash before adding the CTF function type. */
> - if (ctf_type_exists (ctfc, die, &function_type_id))
> + if (ctf_type_exists (ctfc, die, &function_dtd))
> return;
>
> /* Add the type of the function and update the global functions
> @@ -859,41 +847,41 @@ gen_ctf_function (ctf_container_ref ctfc, dw_die_ref die)
> If the given DIE is not recognized as a type, then this function
> returns CTF_NULL_TYPEID. */
>
Update function-level comment: returns NULL.
> -static ctf_id_t
> +static ctf_dtdef_ref
> gen_ctf_type (ctf_container_ref ctfc, dw_die_ref die)
> {
> - ctf_id_t type_id;
> + ctf_dtdef_ref dtd = NULL;
> int unrecog_die = false;
>
> - if (ctf_type_exists (ctfc, die, &type_id))
> - return type_id;
> + if (ctf_type_exists (ctfc, die, &dtd))
> + return dtd;
>
> switch (dw_get_die_tag (die))
> {
> case DW_TAG_base_type:
> - type_id = gen_ctf_base_type (ctfc, die);
> + dtd = gen_ctf_base_type (ctfc, die);
> break;
> case DW_TAG_pointer_type:
> - type_id = gen_ctf_pointer_type (ctfc, die);
> + dtd = gen_ctf_pointer_type (ctfc, die);
> break;
> case DW_TAG_typedef:
> - type_id = gen_ctf_typedef (ctfc, die);
> + dtd = gen_ctf_typedef (ctfc, die);
> break;
> case DW_TAG_array_type:
> - type_id = gen_ctf_array_type (ctfc, die);
> + dtd = gen_ctf_array_type (ctfc, die);
> break;
> case DW_TAG_structure_type:
> - type_id = gen_ctf_sou_type (ctfc, die, CTF_K_STRUCT);
> + dtd = gen_ctf_sou_type (ctfc, die, CTF_K_STRUCT);
> break;
> case DW_TAG_union_type:
> - type_id = gen_ctf_sou_type (ctfc, die, CTF_K_UNION);
> + dtd = gen_ctf_sou_type (ctfc, die, CTF_K_UNION);
> break;
> case DW_TAG_subroutine_type:
> - type_id = gen_ctf_function_type (ctfc, die,
> - false /* from_global_func */);
> + dtd = gen_ctf_function_type (ctfc, die,
> + false /* from_global_func */);
> break;
> case DW_TAG_enumeration_type:
> - type_id = gen_ctf_enumeration_type (ctfc, die);
> + dtd = gen_ctf_enumeration_type (ctfc, die);
> break;
> case DW_TAG_atomic_type:
> /* FALLTHROUGH */
> @@ -902,35 +890,35 @@ gen_ctf_type (ctf_container_ref ctfc, dw_die_ref die)
> case DW_TAG_restrict_type:
> /* FALLTHROUGH */
> case DW_TAG_volatile_type:
> - type_id = gen_ctf_modifier_type (ctfc, die);
> + dtd = gen_ctf_modifier_type (ctfc, die);
> break;
> case DW_TAG_unspecified_type:
> {
> const char *name = get_AT_string (die, DW_AT_name);
>
> if (name && strcmp (name, "void") == 0)
> - type_id = gen_ctf_void_type (ctfc);
> + dtd = gen_ctf_void_type (ctfc);
> else
> - type_id = CTF_NULL_TYPEID;
> + dtd = NULL;
>
> break;
> }
> case DW_TAG_reference_type:
> - type_id = CTF_NULL_TYPEID;
> + dtd = NULL;
> break;
> default:
> /* Unrecognized DIE. */
> unrecog_die = true;
> - type_id = CTF_NULL_TYPEID;
> + dtd = NULL;
> break;
> }
>
> /* For all types unrepresented in CTF, use an explicit CTF type of kind
> CTF_K_UNKNOWN. */
> - if ((type_id == CTF_NULL_TYPEID) && (!unrecog_die))
> - type_id = gen_ctf_unknown_type (ctfc);
> + if ((dtd == NULL) && (!unrecog_die))
> + dtd = gen_ctf_unknown_type (ctfc);
>
> - return type_id;
> + return dtd;
> }
>
> bool
> @@ -951,7 +939,7 @@ ctf_do_die (dw_die_ref die)
> return false;
> }
> else
> - return gen_ctf_type (tu_ctfc, die) == CTF_NULL_TYPEID;
> + return (gen_ctf_type (tu_ctfc, die) == NULL);
> }
>
> /* Initialize CTF subsystem for CTF debug info generation. */
> diff --git a/include/btf.h b/include/btf.h
> index 24b38bace178..3f45ffb0b6bb 100644
> --- a/include/btf.h
> +++ b/include/btf.h
> @@ -56,6 +56,11 @@ struct btf_header
> /* Maximum number of struct, union, enum members or func args. */
> #define BTF_MAX_VLEN 0xffff
>
> +/* Type ID 0 represents the void type. */
> +#define BTF_VOID_TYPEID 0
> +/* Initial type ID for regular types. */
> +#define BTF_INIT_TYPEID 1
> +
> struct btf_type
> {
> uint32_t name_off; /* Offset in string section of type name. */
next prev parent reply other threads:[~2024-06-05 7:32 UTC|newest]
Thread overview: 16+ messages / expand[flat|nested] mbox.gz Atom feed top
2024-05-30 21:32 [PATCH v3 0/6] btf: refactor and add pruning option David Faust
2024-05-30 21:32 ` [PATCH v3 1/6] ctf, btf: restructure CTF/BTF emission David Faust
2024-06-05 7:27 ` Indu Bhagat
2024-05-30 21:32 ` [PATCH v3 2/6] ctf: use pointers instead of IDs internally David Faust
2024-06-05 7:31 ` Indu Bhagat [this message]
2024-05-30 21:32 ` [PATCH v3 3/6] btf: refactor and simplify implementation David Faust
2024-06-05 7:41 ` Indu Bhagat
2024-05-30 21:32 ` [PATCH v3 4/6] btf: add -fprune-btf option David Faust
2024-05-31 7:07 ` Richard Biener
2024-05-31 15:57 ` David Faust
2024-05-31 16:24 ` Richard Biener
2024-06-05 7:56 ` Indu Bhagat
2024-05-30 21:32 ` [PATCH v3 5/6] bpf,btf: enable BTF pruning by default for BPF David Faust
2024-06-05 20:49 ` Indu Bhagat
2024-05-30 21:32 ` [PATCH v3 6/6] opts: allow any combination of DWARF, CTF, BTF David Faust
2024-06-05 22:16 ` Indu Bhagat
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=4e4f33cd-42b1-4259-857b-5e75e3c4045f@oracle.com \
--to=indu.bhagat@oracle.com \
--cc=cupertino.miranda@oracle.com \
--cc=david.faust@oracle.com \
--cc=gcc-patches@gcc.gnu.org \
--cc=jose.marchesi@oracle.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).