On 5/2/24 10:11, 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_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.
(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.
(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.
---
gcc/btfout.cc | 35 ++---
gcc/config/bpf/btfext-out.cc | 12 +-
gcc/config/bpf/core-builtins.cc | 3 +-
gcc/ctfc.cc | 137 +++++++++---------
gcc/ctfc.h | 61 ++++----
gcc/ctfout.cc | 19 +--
gcc/dwarf2ctf.cc | 244 +++++++++++++++-----------------
7 files changed, 252 insertions(+), 259 deletions(-)
diff --git a/gcc/config/bpf/btfext-out.cc b/gcc/config/bpf/btfext-out.cc
index 7ec438fd1d1..ce596e33643 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 of container. */
I find the comment "BTF type of container" associated with the member
confusing. May be we say " BTF type involved with the reloc " or
something like that ?
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,7 @@ 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 +575,9 @@ 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 : 0;
Use 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 829acea98f7..d5a7de825ad 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 : 0;
Use 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 67711606ab8..d8f1037b4e0 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. */
- 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,11 +602,11 @@ 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,
+ctf_add_enumerator (ctf_container_ref ctfc, ctf_dtdef_ref enum_dtd, const char
* name,
HOST_WIDE_INT value, dw_die_ref die)
{
ctf_dmdef_t * dmd;
@@ -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. */
-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)
{
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 e7bd93901cf..cfc805db7b5 100644
--- a/gcc/ctfc.h
+++ b/gcc/ctfc.h
@@ -48,6 +48,8 @@ along with GCC; see the file COPYING3. If not see
typedef uint64_t ctf_id_t;
+struct ctf_dtdef;
+
Should we bring the other typdefs too here and use them consistently
from here onwards ?
+ typedef struct ctf_dtdef ctf_dtdef_t;
+ typedef ctf_dtdef_t * ctf_dtdef_ref;
Earlier the only usages of the above were after struct ctf_dtdef was
defined.
/* CTF string table element (list node). */
typedef struct GTY ((chain_next ("%h.cts_next"))) ctf_string
@@ -81,23 +83,23 @@ 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. */
- unsigned int ctr_nelems; /* Number of elements. */
+ struct ctf_dtdef * ctr_contents; /* Type of array contents. */
+ struct ctf_dtdef * ctr_index; /* Type of array index. */
So this will be:
ctf_dtdef_ref ctr_contents;
ctf_dtdef_ref ctr_index;
and so on for each usage of struct ctf_dtdef * below.
+ unsigned int ctr_nelems; /* Number of elements. */
} ctf_arinfo_t;
/* Function information for CTF generation. */
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). */
+ struct ctf_dtdef * 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. */
+ struct ctf_dtdef * 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 +132,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). */
+ struct ctf_dtdef * 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 +145,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. */
+ struct ctf_dtdef * 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 +160,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. */
+ struct ctf_dtdef *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. */
@@ -188,7 +191,7 @@ 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. */
+ struct ctf_dtdef * dvd_type; /* Type of variable. */
};
typedef struct ctf_dvdef ctf_dvdef_t;
@@ -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,41 @@ 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,
+extern ctf_dtdef_ref ctf_add_reftype (ctf_container_ref, uint32_t,
ctf_dtdef_ref,
uint32_t, dw_die_ref);
-extern ctf_id_t ctf_add_enum (ctf_container_ref, uint32_t, const char *,
+extern ctf_dtdef_ref 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,
+extern ctf_dtdef_ref ctf_add_slice (ctf_container_ref, uint32_t, ctf_dtdef_ref,
uint32_t, uint32_t, dw_die_ref);
-extern ctf_id_t ctf_add_float (ctf_container_ref, uint32_t, const char *,
+extern ctf_dtdef_ref 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 *,
+extern ctf_dtdef_ref 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 *,
+extern ctf_dtdef_ref 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,
+extern ctf_dtdef_ref ctf_add_pointer (ctf_container_ref, uint32_t,
ctf_dtdef_ref,
dw_die_ref);
-extern ctf_id_t ctf_add_array (ctf_container_ref, uint32_t,
+extern ctf_dtdef_ref 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 *,
+extern ctf_dtdef_ref 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 *,
+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_id_t ctf_add_sou (ctf_container_ref, uint32_t, const char *,
+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_id_t, const char *,
+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 ee082b5fd01..dd686703ebc 100644
--- a/gcc/ctfout.cc
+++ b/gcc/ctfout.cc
@@ -380,7 +380,7 @@ 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, (uint32_t) type->dtd_u.dtu_slice.cts_type->dtd_type,
"cts_type");
What do you think about introducing an access method / macro (say
ctfc_get_type_id or such) for getting the dtd_type from given ctf_dtdef_ref.
So instead of
(uint32_t) type->dtd_u.dtu_slice.cts_type->dtd_type
we use
ctfc_get_type_id (type->dtd_u.dtu_slice.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 +390,8 @@ 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, (uint32_t) dtd->dtd_u.dtu_arr.ctr_contents->dtd_type,
"cta_contents");
+ dw2_asm_output_data (4, (uint32_t) dtd->dtd_u.dtu_arr.ctr_index->dtd_type,
"cta_index");
dw2_asm_output_data (4, dtd->dtd_u.dtu_arr.ctr_nelems, "cta_nelems");
}
@@ -403,7 +403,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, (uint32_t) var->dvd_type->dtd_type, "ctv_typeidx");
}
/* Asm'out a member of CTF struct or union, represented by ctf_lmember_t. */
@@ -414,7 +414,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, (uint32_t) dmd->dmd_type->dtd_type, "ctlm_type");
dw2_asm_output_data (4, CTF_OFFSET_TO_LMEMLO (dmd->dmd_offset),
"ctlm_offsetlo");
}
@@ -426,7 +426,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, (uint32_t) dmd->dmd_type->dtd_type, "ctm_type");
}
/* Asm'out an enumerator constant. */
@@ -443,7 +443,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
+ ? (uint32_t) farg->farg_type->dtd_type
+ : 0, "dtu_argv");
}
/* CTF writeout to asm file. */
@@ -537,7 +540,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, (uint32_t) var->dvd_type->dtd_type,
"objtinfo_var_type");
}
}
diff --git a/gcc/dwarf2ctf.cc b/gcc/dwarf2ctf.cc
index ec94982e4b1..f16b5ceee74 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. */
-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)
{
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. */
-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. */
