ctf: translate annotation DIEs to internal ctf

Translate DW_TAG_GNU_annotation DIEs created for C attributes
btf_decl_tag and btf_type_tag into an in-memory representation in the
CTF/BTF container.  They will be output in BTF as BTF_KIND_DECL_TAG and
BTF_KIND_TYPE_TAG records.

The new CTF kinds used to represent these annotations, CTF_K_DECL_TAG
and CTF_K_TYPE_TAG, are expected to be formalized in the next version of
the CTF specification.  For now they only exist in memory as a
translation step to BTF, and are not emitted when generating CTF
information.

gcc/
	* ctfc.cc (ctf_dtu_d_union_selector): Handle CTF_K_DECL_TAG and
	CTF_K_TYPE_TAG.
	(ctf_add_type_tag, ctf_add_decl_tag): New.
	(ctf_add_variable): Return the new ctf_dvdef_ref rather than zero.
	(new_ctf_container): Initialize new members.
	(ctfc_delete_container): Deallocate new members.
	* ctfc.h (ctf_dvdef, ctf_dvdef_t, ctf_dvdef_ref): Move forward
	declarations earlier in file.
	(ctf_decl_tag_t): New typedef.
	(ctf_dtdef): Add ctf_decl_tag_t member to dtd_u union.
	(ctf_dtu_d_union_enum): Add new CTF_DTU_D_TAG enumerator.
	(ctf_container): Add ctfc_tags vector and ctfc_type_tags_map hash_map
	members.
	(ctf_add_type_tag, ctf_add_decl_tag): New function protos.
	(ctf_add_variable): Change prototype return type to ctf_dvdef_ref.
	* dwarf2ctf.cc (gen_ctf_type_tags, gen_ctf_decl_tags)
	(gen_ctf_decl_tags_for_var): New static functions.
	(gen_ctf_pointer_type): Handle type tags.
	(gen_ctf_sou_type): Handle decl tags.
	(gen_ctf_function_type): Likewise.
	(gen_ctf_variable): Likewise.
	(gen_ctf_function): Likewise.
	(gen_ctf_type): Handle TAG_GNU_annotation DIEs.

gcc/testsuite/
	* gcc.dg/debug/ctf/ctf-decl-tag-1.c: New test.
	* gcc.dg/debug/ctf/ctf-type-tag-1.c: New test.

include/
	* ctf.h (CTF_K_DECL_TAG, CTF_K_TYPE_TAG): New defines.

Author: dafaust

gcc/ctfc.cc

@@ -107,6 +107,9 @@ ctf_dtu_d_union_selector (ctf_dtdef_ref ctftype)
       return CTF_DTU_D_ARGUMENTS;
     case CTF_K_SLICE:
       return CTF_DTU_D_SLICE;
+    case CTF_K_DECL_TAG:
+    case CTF_K_TYPE_TAG:
+      return CTF_DTU_D_TAG;
     default:
       /* The largest member as default.  */
       return CTF_DTU_D_ARRAY;
@@ -445,6 +448,68 @@ ctf_add_reftype (ctf_container_ref ctfc, uint32_t flag, ctf_dtdef_ref ref,
   return dtd;
 }
 
+ctf_dtdef_ref
+ctf_add_type_tag (ctf_container_ref ctfc, uint32_t flag, const char *value,
+		  ctf_dtdef_ref ref_dtd)
+{
+  ctf_dtdef_ref dtd;
+   /* Create a DTD for the tag, but do not place it in the regular types list;
+      CTF format does not (yet) encode tags.  */
+  dtd = ggc_cleared_alloc<ctf_dtdef_t> ();
+
+  dtd->dtd_name = ctf_add_string (ctfc, value, &(dtd->dtd_data.ctti_name),
+				  CTF_AUX_STRTAB);
+  /* A single DW_TAG_GNU_annotation DIE may be referenced by multiple DIEs,
+     e.g. when multiple distinct types specify the same type tag.  We will
+     synthesize multiple CTF DTD records in that case, so we cannot tie them
+     all to the same key (the DW_TAG_GNU_annotation DIE) in ctfc_types.  */
+  dtd->dtd_key = NULL;
+  dtd->ref_type = ref_dtd;
+  dtd->dtd_data.ctti_info = CTF_TYPE_INFO (CTF_K_TYPE_TAG, flag, 0);
+  dtd->dtd_u.dtu_tag.ref_var = NULL; /* Not used for type tags.  */
+  dtd->dtd_u.dtu_tag.component_idx = 0; /* Not used for type tags.  */
+
+  /* Insert tag directly into the tag list.  Type ID will be assigned later.  */
+  vec_safe_push (ctfc->ctfc_tags, dtd);
+
+  /* Keep ctfc_aux_strlen updated.  */
+  if ((value != NULL) && strcmp (value, ""))
+    ctfc->ctfc_aux_strlen += strlen (value) + 1;
+
+  return dtd;
+}
+
+ctf_dtdef_ref
+ctf_add_decl_tag (ctf_container_ref ctfc, uint32_t flag, const char *value,
+		  ctf_dtdef_ref ref_dtd, uint32_t comp_idx)
+{
+   ctf_dtdef_ref dtd;
+   /* Create a DTD for the tag, but do not place it in the regular types list;
+      ctf format does not (yet) encode tags.  */
+  dtd = ggc_cleared_alloc<ctf_dtdef_t> ();
+
+  dtd->dtd_name = ctf_add_string (ctfc, value, &(dtd->dtd_data.ctti_name),
+				  CTF_AUX_STRTAB);
+  /* A single DW_TAG_GNU_annotation DIE may be referenced by multiple DIEs,
+     e.g. when multiple distinct declarations specify the same decl tag.
+     We will synthesize multiple CTF DTD records in that case, so we cannot tie
+     them all to the same key (the DW_TAG_GNU_annotation DIE) in ctfc_types.  */
+  dtd->dtd_key = NULL;
+  dtd->ref_type = ref_dtd;
+  dtd->dtd_data.ctti_info = CTF_TYPE_INFO (CTF_K_DECL_TAG, flag, 0);
+  dtd->dtd_u.dtu_tag.ref_var = NULL;
+  dtd->dtd_u.dtu_tag.component_idx = comp_idx;
+
+  /* Insert tag directly into the tag list.  Type ID will be assigned later.  */
+  vec_safe_push (ctfc->ctfc_tags, dtd);
+
+  /* Keep ctfc_aux_strlen updated.  */
+  if ((value != NULL) && strcmp (value, ""))
+    ctfc->ctfc_aux_strlen += strlen (value) + 1;
+
+  return dtd;
+}
+
 ctf_dtdef_ref
 ctf_add_forward (ctf_container_ref ctfc, uint32_t flag, const char * name,
 		 uint32_t kind, dw_die_ref die)
@@ -691,12 +756,12 @@ ctf_add_member_offset (ctf_container_ref ctfc, dw_die_ref sou,
   return 0;
 }
 
-int
+ctf_dvdef_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)
 {
-  ctf_dvdef_ref dvd, dvd_ignore;
+  ctf_dvdef_ref dvd = NULL, dvd_ignore;
 
   gcc_assert (name);
 
@@ -732,7 +797,7 @@ ctf_add_variable (ctf_container_ref ctfc, const char * name, ctf_dtdef_ref ref,
 	ctfc->ctfc_strlen += strlen (name) + 1;
     }
 
-  return 0;
+  return dvd;
 }
 
 int
@@ -949,6 +1014,10 @@ new_ctf_container (void)
   tu_ctfc->ctfc_ignore_vars
     = hash_table<ctfc_dvd_hasher>::create_ggc (10);
 
+  vec_alloc (tu_ctfc->ctfc_tags, 100);
+  tu_ctfc->ctfc_type_tags_map
+    = hash_map<ctf_dtdef_ref, ctf_dtdef_ref>::create_ggc (100);
+
   return tu_ctfc;
 }
 
@@ -1003,6 +1072,11 @@ ctfc_delete_container (ctf_container_ref ctfc)
       ctfc->ctfc_ignore_vars->empty ();
       ctfc->ctfc_ignore_vars = NULL;
 
+      ctfc->ctfc_tags = NULL;
+
+      ctfc->ctfc_type_tags_map->empty ();
+      ctfc->ctfc_type_tags_map = NULL;
+
       ctfc_delete_strtab (&ctfc->ctfc_strtable);
       ctfc_delete_strtab (&ctfc->ctfc_aux_strtable);
       if (ctfc->ctfc_vars_list)

gcc/ctfc.h

@@ -52,6 +52,10 @@ struct ctf_dtdef;
 typedef struct ctf_dtdef ctf_dtdef_t;
 typedef ctf_dtdef_t * ctf_dtdef_ref;
 
+struct ctf_dvdef;
+typedef struct ctf_dvdef ctf_dvdef_t;
+typedef ctf_dvdef_t * ctf_dvdef_ref;
+
 /* CTF string table element (list node).  */
 
 typedef struct GTY ((chain_next ("%h.cts_next"))) ctf_string
@@ -155,6 +159,16 @@ typedef struct GTY (()) ctf_func_arg
 
 #define ctf_farg_list_next(elem) ((ctf_func_arg_t *)((elem)->farg_next))
 
+/* Declaration Tag.
+   May be used to annotate struct/union members, variable declarations,
+   function declarations, and function arguments.  */
+
+typedef struct GTY (()) ctf_decl_tag
+{
+  uint32_t component_idx;  /* Index of component to which tag applies.  */
+  ctf_dvdef_ref ref_var;   /* Non-null iff this tag applies to a variable.  */
+} ctf_decl_tag_t;
+
 /* Type definition for CTF generation.  */
 
 struct GTY ((for_user)) ctf_dtdef
@@ -184,6 +198,8 @@ struct GTY ((for_user)) ctf_dtdef
     ctf_func_arg_t * GTY ((tag ("CTF_DTU_D_ARGUMENTS"))) dtu_argv;
     /* slice.  */
     ctf_sliceinfo_t GTY ((tag ("CTF_DTU_D_SLICE"))) dtu_slice;
+    /* decl tag.  */
+    ctf_decl_tag_t GTY ((tag ("CTF_DTU_D_TAG"))) dtu_tag;
   } dtd_u;
 };
 
@@ -201,9 +217,6 @@ struct GTY ((for_user)) ctf_dvdef
   ctf_id_t dvd_id;		/* ID of this variable.  Only used for BTF.  */
 };
 
-typedef struct ctf_dvdef ctf_dvdef_t;
-typedef ctf_dvdef_t * ctf_dvdef_ref;
-
 /* Location information for CTF Types and CTF Variables.  */
 
 typedef struct GTY (()) ctf_srcloc
@@ -222,7 +235,8 @@ enum ctf_dtu_d_union_enum {
   CTF_DTU_D_ARRAY,
   CTF_DTU_D_ENCODING,
   CTF_DTU_D_ARGUMENTS,
-  CTF_DTU_D_SLICE
+  CTF_DTU_D_SLICE,
+  CTF_DTU_D_TAG,
 };
 
 enum ctf_dtu_d_union_enum
@@ -287,6 +301,17 @@ typedef struct GTY (()) ctf_container
   /* CTF variables to be ignored.  */
   hash_table <ctfc_dvd_hasher> * GTY (()) ctfc_ignore_vars;
 
+  /* BTF type and decl tags.  Not yet represented in CTF.  These tags also
+     uniquely have a one-to-many relation with DIEs, meaning a single DIE
+     may translate to multiple CTF/BTF records.  For both of these reasons,
+     they cannot be stored in the regular types table.  */
+  vec <ctf_dtdef_ref, va_gc> * GTY (()) ctfc_tags;
+  /* Type tags logically form part of the type chain similar to cv-quals.
+     Therefore references to types need to know if the referred-to type has
+     any type tags, and if so to refer to the outermost type tag.  This map
+     maps a type to the outermost type tag created for it, if any.  */
+  hash_map <ctf_dtdef_ref, ctf_dtdef_ref> * GTY (()) ctfc_type_tags_map;
+
   /* CTF string table.  */
   ctf_strtable_t ctfc_strtable;
   /* Auxilliary string table.  At this time, used for keeping func arg names
@@ -440,15 +465,19 @@ extern ctf_dtdef_ref ctf_add_function (ctf_container_ref, uint32_t,
 				       dw_die_ref, bool, int);
 extern ctf_dtdef_ref ctf_add_sou (ctf_container_ref, uint32_t, const char *,
 				  uint32_t, unsigned HOST_WIDE_INT, dw_die_ref);
-
+extern ctf_dtdef_ref ctf_add_type_tag (ctf_container_ref, uint32_t,
+				       const char *, ctf_dtdef_ref);
+extern ctf_dtdef_ref ctf_add_decl_tag (ctf_container_ref, uint32_t,
+				       const char *, ctf_dtdef_ref, uint32_t);
 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_dtdef_ref, uint64_t);
 extern int ctf_add_function_arg (ctf_container_ref, dw_die_ref,
 				 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_dvdef_ref ctf_add_variable (ctf_container_ref, const char *,
+				       ctf_dtdef_ref, dw_die_ref, unsigned int,
+				       dw_die_ref);
 
 extern ctf_dtdef_ref ctf_lookup_tree_type (ctf_container_ref, const tree);