diff --git a/gcc/btfout.cc b/gcc/btfout.cc
index 1b6a9ed811f..14a503a4f80 100644
--- a/gcc/btfout.cc
+++ b/gcc/btfout.cc
@@ -626,7 +626,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 +717,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 +914,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 +928,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 +938,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 +960,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 +1004,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 +1384,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 +1403,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 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.  */
   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;
+	      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;
     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;
+
 /* 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.  */
+  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");
   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.  */
