public inbox for gcc-patches@gcc.gnu.org
 help / color / mirror / Atom feed
* [PATCH] dwarf2out.c: Pass DWARF type modifiers around as flags argument.
@ 2014-06-18 20:56 Mark Wielaard
  2014-06-20 11:51 ` Mark Wielaard
  0 siblings, 1 reply; 30+ messages in thread
From: Mark Wielaard @ 2014-06-18 20:56 UTC (permalink / raw)
  To: gcc-patches; +Cc: Jason Merrill, Cary Coutant, Mark Wielaard

modified_type_die and add_type_attribute take two separate arguments
for whether the type should be const and/or volatile. To help add
more type modifiers pass the requested modifiers as one flag value
to these functions. And introduce helper functions dw_mod_type_flags
and dw_mod_decl_flags to easily extract the modifiers from type and
declaration trees.

DWARFv3 added restrict_type [PR debug/59051] and DWARFv5 has proposals
for atomic_type and aligned_type) pass the requested modifiers as one
flag value to these functions. Which will hopefully be easier to
implement based on this change.

gcc/ChangeLog

       * dwarf2out.h (enum dw_mod_flag): New enum.
       * dwarf2out.c (dw_mod_decl_flags): New function.
       (dw_mod_type_flags): Likewise.
       (modified_type_die): Take one modifiers flag argument instead of
       one for const and one for volatile.
       (add_type_attribute): Likewise.
       (generic_parameter_die): Call add_type_attribute with one modifier
       argument.
       (base_type_for_mode): Likewise.
       (add_bounds_info): Likewise.
       (add_subscript_info): Likewise.
       (gen_array_type_die): Likewise.
       (gen_descr_array_type_die): Likewise.
       (gen_entry_point_die): Likewise.
       (gen_enumeration_type_die): Likewise.
       (gen_formal_parameter_die): Likewise.
       (gen_subprogram_die): Likewise.
       (gen_variable_die): Likewise.
       (gen_const_die): Likewise.
       (gen_field_die): Likewise.
       (gen_pointer_type_die): Likewise.
       (gen_reference_type_die): Likewise.
       (gen_ptr_to_mbr_type_die): Likewise.
       (gen_inheritance_die): Likewise.
       (gen_subroutine_type_die): Likewise.
       (gen_typedef_die): Likewise.
       (force_type_die): Likewise.
---
 gcc/ChangeLog   |   30 ++++++++++++
 gcc/dwarf2out.c |  133 ++++++++++++++++++++++++++++++-------------------------
 gcc/dwarf2out.h |    8 +++
 3 files changed, 110 insertions(+), 61 deletions(-)

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 2d0a07c..d7ee868 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,33 @@
+2014-06-18  Mark Wielaard  <mjw@redhat.com>
+
+	* dwarf2out.h (enum dw_mod_flag): New enum.
+	* dwarf2out.c (dw_mod_decl_flags): New function.
+	(dw_mod_type_flags): Likewise.
+	(modified_type_die): Take one modifiers flag argument instead of
+	one for const and one for volatile.
+	(add_type_attribute): Likewise.
+	(generic_parameter_die): Call add_type_attribute with one modifier
+	argument.
+	(base_type_for_mode): Likewise.
+	(add_bounds_info): Likewise.
+	(add_subscript_info): Likewise.
+	(gen_array_type_die): Likewise.
+	(gen_descr_array_type_die): Likewise.
+	(gen_entry_point_die): Likewise.
+	(gen_enumeration_type_die): Likewise.
+	(gen_formal_parameter_die): Likewise.
+	(gen_subprogram_die): Likewise.
+	(gen_variable_die): Likewise.
+	(gen_const_die): Likewise.
+	(gen_field_die): Likewise.
+	(gen_pointer_type_die): Likewise.
+	(gen_reference_type_die): Likewise.
+	(gen_ptr_to_mbr_type_die): Likewise.
+	(gen_inheritance_die): Likewise.
+	(gen_subroutine_type_die): Likewise.
+	(gen_typedef_die): Likewise.
+	(force_type_die): Likewise.
+
 2014-06-18  Kyrylo Tkachov  <kyrylo.tkachov@arm.com>
 
 	* config/arm/arm_neon.h (vadd_f32): Change #ifdef to __FAST_MATH.
diff --git a/gcc/dwarf2out.c b/gcc/dwarf2out.c
index 933ec62..0216801 100644
--- a/gcc/dwarf2out.c
+++ b/gcc/dwarf2out.c
@@ -3140,7 +3140,9 @@ static void output_file_names (void);
 static dw_die_ref base_type_die (tree);
 static int is_base_type (tree);
 static dw_die_ref subrange_type_die (tree, tree, tree, dw_die_ref);
-static dw_die_ref modified_type_die (tree, int, int, dw_die_ref);
+static int dw_mod_decl_flags (const_tree);
+static int dw_mod_type_flags (const_tree);
+static dw_die_ref modified_type_die (tree, int, dw_die_ref);
 static dw_die_ref generic_parameter_die (tree, tree, bool, dw_die_ref);
 static dw_die_ref template_parameter_pack_die (tree, tree, dw_die_ref);
 static int type_is_enum (const_tree);
@@ -3198,7 +3200,7 @@ static dw_die_ref scope_die_for (tree, dw_die_ref);
 static inline int local_scope_p (dw_die_ref);
 static inline int class_scope_p (dw_die_ref);
 static inline int class_or_namespace_scope_p (dw_die_ref);
-static void add_type_attribute (dw_die_ref, tree, int, int, dw_die_ref);
+static void add_type_attribute (dw_die_ref, tree, int, dw_die_ref);
 static void add_calling_convention_attribute (dw_die_ref, tree);
 static const char *type_tag (const_tree);
 static tree member_declared_type (const_tree);
@@ -10498,12 +10500,25 @@ subrange_type_die (tree type, tree low, tree high, dw_die_ref context_die)
   return subrange_die;
 }
 
+static int
+dw_mod_decl_flags (const_tree decl)
+{
+  return ((TREE_READONLY (decl) ? dw_mod_const : dw_mod_none)
+	  | (TREE_THIS_VOLATILE (decl) ? dw_mod_volatile : dw_mod_none));
+}
+
+static int
+dw_mod_type_flags (const_tree type)
+{
+  return ((TYPE_READONLY (type) ? dw_mod_const : dw_mod_none)
+	  | (TYPE_VOLATILE (type) ? dw_mod_volatile : dw_mod_none));
+}
+
 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
    entry that chains various modifiers in front of the given type.  */
 
 static dw_die_ref
-modified_type_die (tree type, int is_const_type, int is_volatile_type,
-		   dw_die_ref context_die)
+modified_type_die (tree type, int mods, dw_die_ref context_die)
 {
   enum tree_code code = TREE_CODE (type);
   dw_die_ref mod_type_die;
@@ -10519,9 +10534,10 @@ modified_type_die (tree type, int is_const_type, int is_volatile_type,
   /* See if we already have the appropriately qualified variant of
      this type.  */
   qualified_type
-    = get_qualified_type (type,
-			  ((is_const_type ? TYPE_QUAL_CONST : 0)
-			   | (is_volatile_type ? TYPE_QUAL_VOLATILE : 0)));
+    = get_qualified_type (type, (((mods & dw_mod_const)
+				  ? TYPE_QUAL_CONST : 0)
+				 | ((mods & dw_mod_volatile)
+				    ? TYPE_QUAL_VOLATILE : 0)));
 
   if (qualified_type == sizetype
       && TYPE_NAME (qualified_type)
@@ -10559,35 +10575,34 @@ modified_type_die (tree type, int is_const_type, int is_volatile_type,
 	  gen_type_die (qualified_type, context_die);
 	  return lookup_type_die (qualified_type);
 	}
-      else if (is_const_type < TYPE_READONLY (dtype)
-	       || is_volatile_type < TYPE_VOLATILE (dtype)
-	       || (is_const_type <= TYPE_READONLY (dtype)
-		   && is_volatile_type <= TYPE_VOLATILE (dtype)
+      else if ((mods & dw_mod_const) < TYPE_READONLY (dtype)
+	       || (mods & dw_mod_volatile) < TYPE_VOLATILE (dtype)
+	       || ((mods & dw_mod_const) <= TYPE_READONLY (dtype)
+		   && (mods & dw_mod_volatile) <= TYPE_VOLATILE (dtype)
 		   && DECL_ORIGINAL_TYPE (name) != type))
 	/* cv-unqualified version of named type.  Just use the unnamed
 	   type to which it refers.  */
-	return modified_type_die (DECL_ORIGINAL_TYPE (name),
-				  is_const_type, is_volatile_type,
+	return modified_type_die (DECL_ORIGINAL_TYPE (name), mods,
 				  context_die);
       /* Else cv-qualified version of named type; fall through.  */
     }
 
   mod_scope = scope_die_for (type, context_die);
 
-  if (is_const_type
-      /* If both is_const_type and is_volatile_type, prefer the path
+  if ((mods & dw_mod_const)
+      /* If both const_type and volatile_type, prefer the path
 	 which leads to a qualified type.  */
-      && (!is_volatile_type
+      && (!(mods & dw_mod_volatile)
 	  || get_qualified_type (type, TYPE_QUAL_CONST) == NULL_TREE
 	  || get_qualified_type (type, TYPE_QUAL_VOLATILE) != NULL_TREE))
     {
       mod_type_die = new_die (DW_TAG_const_type, mod_scope, type);
-      sub_die = modified_type_die (type, 0, is_volatile_type, context_die);
+      sub_die = modified_type_die (type, mods & ~dw_mod_const, context_die);
     }
-  else if (is_volatile_type)
+  else if (mods & dw_mod_volatile)
     {
       mod_type_die = new_die (DW_TAG_volatile_type, mod_scope, type);
-      sub_die = modified_type_die (type, is_const_type, 0, context_die);
+      sub_die = modified_type_die (type, mods & ~dw_mod_volatile, context_die);
     }
   else if (code == POINTER_TYPE)
     {
@@ -10648,7 +10663,7 @@ modified_type_die (tree type, int is_const_type, int is_volatile_type,
   if (name
       && ((TREE_CODE (name) != TYPE_DECL
 	   && (qualified_type == TYPE_MAIN_VARIANT (type)
-	       || (!is_const_type && !is_volatile_type)))
+	       || (mods == dw_mod_none)))
 	  || (TREE_CODE (name) == TYPE_DECL
 	      && TREE_TYPE (name) == qualified_type
 	      && DECL_NAME (name))))
@@ -10676,9 +10691,7 @@ modified_type_die (tree type, int is_const_type, int is_volatile_type,
        this is a recursive type.  This ensures that the modified_type_die
        recursion will terminate even if the type is recursive.  Recursive
        types are possible in Ada.  */
-    sub_die = modified_type_die (item_type,
-				 TYPE_READONLY (item_type),
-				 TYPE_VOLATILE (item_type),
+    sub_die = modified_type_die (item_type, dw_mod_type_flags (type),
 				 context_die);
 
   if (sub_die != NULL)
@@ -10820,8 +10833,9 @@ generic_parameter_die (tree parm, tree arg,
 	     If PARM is a type generic parameter, TMPL_DIE should have a
 	     child DW_AT_type that is set to ARG.  */
 	  tmpl_type = TYPE_P (arg) ? arg : TREE_TYPE (arg);
-	  add_type_attribute (tmpl_die, tmpl_type, 0,
-			      TREE_THIS_VOLATILE (tmpl_type),
+	  add_type_attribute (tmpl_die, tmpl_type,
+			      (TREE_THIS_VOLATILE (tmpl_type)
+			       ? dw_mod_volatile : dw_mod_none),
 			      parent_die);
 	}
       else
@@ -11563,7 +11577,7 @@ base_type_for_mode (enum machine_mode mode, bool unsignedp)
     }
   type_die = lookup_type_die (type);
   if (!type_die)
-    type_die = modified_type_die (type, false, false, comp_unit_die ());
+    type_die = modified_type_die (type, dw_mod_none, comp_unit_die ());
   if (type_die == NULL || type_die->die_tag != DW_TAG_base_type)
     return NULL;
   return type_die;
@@ -16480,7 +16494,7 @@ add_bound_info (dw_die_ref subrange_die, enum dwarf_attribute bound_attr, tree b
 
 	decl_die = new_die (DW_TAG_variable, ctx, bound);
 	add_AT_flag (decl_die, DW_AT_artificial, 1);
-	add_type_attribute (decl_die, TREE_TYPE (bound), 1, 0, ctx);
+	add_type_attribute (decl_die, TREE_TYPE (bound), dw_mod_const, ctx);
 	add_AT_location_description (decl_die, DW_AT_location, list);
 	add_AT_die_ref (subrange_die, bound_attr, decl_die);
 	break;
@@ -16531,8 +16545,8 @@ add_subscript_info (dw_die_ref type_die, tree type, bool collapse_p)
 		  && TYPE_NAME (TREE_TYPE (domain)) == NULL_TREE)
 		;
 	      else
-		add_type_attribute (subrange_die, TREE_TYPE (domain), 0, 0,
-				    type_die);
+		add_type_attribute (subrange_die, TREE_TYPE (domain),
+				    dw_mod_none, type_die);
 	    }
 
 	  /* ??? If upper is NULL, the array has unspecified length,
@@ -17026,8 +17040,8 @@ class_or_namespace_scope_p (dw_die_ref context_die)
    by 'type', and adds a DW_AT_type attribute below the given die.  */
 
 static void
-add_type_attribute (dw_die_ref object_die, tree type, int decl_const,
-		    int decl_volatile, dw_die_ref context_die)
+add_type_attribute (dw_die_ref object_die, tree type, int mods,
+		    dw_die_ref context_die)
 {
   enum tree_code code  = TREE_CODE (type);
   dw_die_ref type_die  = NULL;
@@ -17047,9 +17061,7 @@ add_type_attribute (dw_die_ref object_die, tree type, int decl_const,
       || code == VOID_TYPE)
     return;
 
-  type_die = modified_type_die (type,
-				decl_const || TYPE_READONLY (type),
-				decl_volatile || TYPE_VOLATILE (type),
+  type_die = modified_type_die (type, mods | dw_mod_type_flags (type),
 				context_die);
 
   if (type_die != NULL)
@@ -17263,7 +17275,7 @@ gen_array_type_die (tree type, dw_die_ref context_die)
 	element_type = TREE_TYPE (element_type);
       }
 
-  add_type_attribute (array_die, element_type, 0, 0, context_die);
+  add_type_attribute (array_die, element_type, dw_mod_none, context_die);
 
   add_gnat_descriptive_type_attribute (array_die, type, context_die);
   if (TYPE_ARTIFICIAL (type))
@@ -17426,7 +17438,7 @@ gen_descr_array_type_die (tree type, struct array_descr_info *info,
     }
 
   gen_type_die (info->element_type, context_die);
-  add_type_attribute (array_die, info->element_type, 0, 0, context_die);
+  add_type_attribute (array_die, info->element_type, dw_mod_none, context_die);
 
   if (get_AT (array_die, DW_AT_name))
     add_pubtype (type, array_die);
@@ -17445,7 +17457,7 @@ gen_entry_point_die (tree decl, dw_die_ref context_die)
     {
       add_name_and_src_coords_attributes (decl_die, decl);
       add_type_attribute (decl_die, TREE_TYPE (TREE_TYPE (decl)),
-			  0, 0, context_die);
+			  dw_mod_none, context_die);
     }
 
   if (DECL_ABSTRACT (decl))
@@ -17535,7 +17547,7 @@ gen_enumeration_type_die (tree type, dw_die_ref context_die)
       if (dwarf_version >= 3 || !dwarf_strict)
 	{
 	  tree underlying = lang_hooks.types.enum_underlying_base_type (type);
-	  add_type_attribute (type_die, underlying, 0, 0, context_die);
+	  add_type_attribute (type_die, underlying, dw_mod_none, context_die);
 	}
       if (TYPE_STUB_DECL (type) != NULL_TREE)
 	{
@@ -17636,12 +17648,11 @@ gen_formal_parameter_die (tree node, tree origin, bool emit_name_p,
 	{
 	  tree type = TREE_TYPE (node_or_origin);
 	  if (decl_by_reference_p (node_or_origin))
-	    add_type_attribute (parm_die, TREE_TYPE (type), 0, 0,
+	    add_type_attribute (parm_die, TREE_TYPE (type), dw_mod_none,
 				context_die);
 	  else
 	    add_type_attribute (parm_die, type,
-				TREE_READONLY (node_or_origin),
-				TREE_THIS_VOLATILE (node_or_origin),
+				dw_mod_decl_flags (node_or_origin),
 				context_die);
 	}
       if (origin == NULL && DECL_ARTIFICIAL (node))
@@ -17657,7 +17668,7 @@ gen_formal_parameter_die (tree node, tree origin, bool emit_name_p,
 
     case tcc_type:
       /* We were called with some kind of a ..._TYPE node.  */
-      add_type_attribute (parm_die, node_or_origin, 0, 0, context_die);
+      add_type_attribute (parm_die, node_or_origin, dw_mod_none, context_die);
       break;
 
     default:
@@ -18239,7 +18250,7 @@ gen_subprogram_die (tree decl, dw_die_ref context_die)
 	      dw_die_ref die = get_AT_ref (old_die, DW_AT_type);
 	      if (die == auto_die || die == decltype_auto_die)
 		add_type_attribute (subr_die, TREE_TYPE (TREE_TYPE (decl)),
-				    0, 0, context_die);
+				    dw_mod_none, context_die);
 	    }
 	}
     }
@@ -18256,7 +18267,7 @@ gen_subprogram_die (tree decl, dw_die_ref context_die)
 	{
 	  add_prototyped_attribute (subr_die, TREE_TYPE (decl));
 	  add_type_attribute (subr_die, TREE_TYPE (TREE_TYPE (decl)),
-			      0, 0, context_die);
+			      dw_mod_none, context_die);
 	}
 
       add_pure_or_virtual_attribute (subr_die, decl);
@@ -18871,8 +18882,8 @@ gen_variable_die (tree decl, tree origin, dw_die_ref context_die)
 	}
       var_die = new_die (DW_TAG_variable, com_die, decl);
       add_name_and_src_coords_attributes (var_die, decl);
-      add_type_attribute (var_die, TREE_TYPE (decl), TREE_READONLY (decl),
-			  TREE_THIS_VOLATILE (decl), context_die);
+      add_type_attribute (var_die, TREE_TYPE (decl), dw_mod_decl_flags (decl),
+			  context_die);
       add_AT_flag (var_die, DW_AT_external, 1);
       if (loc)
 	{
@@ -18965,10 +18976,11 @@ gen_variable_die (tree decl, tree origin, dw_die_ref context_die)
       tree type = TREE_TYPE (decl_or_origin);
 
       if (decl_by_reference_p (decl_or_origin))
-	add_type_attribute (var_die, TREE_TYPE (type), 0, 0, context_die);
+	add_type_attribute (var_die, TREE_TYPE (type), dw_mod_none,
+			    context_die);
       else
-	add_type_attribute (var_die, type, TREE_READONLY (decl_or_origin),
-			    TREE_THIS_VOLATILE (decl_or_origin), context_die);
+	add_type_attribute (var_die, type, dw_mod_decl_flags (decl_or_origin),
+			    context_die);
     }
 
   if (origin == NULL && !specialization_p)
@@ -19022,7 +19034,7 @@ gen_const_die (tree decl, dw_die_ref context_die)
 
   const_die = new_die (DW_TAG_constant, context_die, decl);
   add_name_and_src_coords_attributes (const_die, decl);
-  add_type_attribute (const_die, type, 1, 0, context_die);
+  add_type_attribute (const_die, type, dw_mod_const, context_die);
   if (TREE_PUBLIC (decl))
     add_AT_flag (const_die, DW_AT_external, 1);
   if (DECL_ARTIFICIAL (decl))
@@ -19265,8 +19277,7 @@ gen_field_die (tree decl, dw_die_ref context_die)
   decl_die = new_die (DW_TAG_member, context_die, decl);
   add_name_and_src_coords_attributes (decl_die, decl);
   add_type_attribute (decl_die, member_declared_type (decl),
-		      TREE_READONLY (decl), TREE_THIS_VOLATILE (decl),
-		      context_die);
+		      dw_mod_decl_flags (decl), context_die);
 
   if (DECL_BIT_FIELD_TYPE (decl))
     {
@@ -19300,7 +19311,7 @@ gen_pointer_type_die (tree type, dw_die_ref context_die)
     = new_die (DW_TAG_pointer_type, scope_die_for (type, context_die), type);
 
   equate_type_number_to_die (type, ptr_die);
-  add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
+  add_type_attribute (ptr_die, TREE_TYPE (type), dw_mod_none, context_die);
   add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
 }
 
@@ -19320,7 +19331,7 @@ gen_reference_type_die (tree type, dw_die_ref context_die)
     ref_die = new_die (DW_TAG_reference_type, scope_die, type);
 
   equate_type_number_to_die (type, ref_die);
-  add_type_attribute (ref_die, TREE_TYPE (type), 0, 0, context_die);
+  add_type_attribute (ref_die, TREE_TYPE (type), dw_mod_none, context_die);
   add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
 }
 #endif
@@ -19337,7 +19348,7 @@ gen_ptr_to_mbr_type_die (tree type, dw_die_ref context_die)
   equate_type_number_to_die (type, ptr_die);
   add_AT_die_ref (ptr_die, DW_AT_containing_type,
 		  lookup_type_die (TYPE_OFFSET_BASETYPE (type)));
-  add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
+  add_type_attribute (ptr_die, TREE_TYPE (type), dw_mod_none, context_die);
 }
 
 typedef const char *dchar_p; /* For DEF_VEC_P.  */
@@ -19542,7 +19553,7 @@ gen_inheritance_die (tree binfo, tree access, dw_die_ref context_die)
 {
   dw_die_ref die = new_die (DW_TAG_inheritance, context_die, binfo);
 
-  add_type_attribute (die, BINFO_TYPE (binfo), 0, 0, context_die);
+  add_type_attribute (die, BINFO_TYPE (binfo), dw_mod_none, context_die);
   add_data_member_location_attribute (die, binfo);
 
   if (BINFO_VIRTUAL_P (binfo))
@@ -19739,7 +19750,7 @@ gen_subroutine_type_die (tree type, dw_die_ref context_die)
 
   equate_type_number_to_die (type, subr_die);
   add_prototyped_attribute (subr_die, type);
-  add_type_attribute (subr_die, return_type, 0, 0, context_die);
+  add_type_attribute (subr_die, return_type, dw_mod_none, context_die);
   gen_formal_types_die (type, subr_die);
 
   if (get_AT (subr_die, DW_AT_name))
@@ -19807,8 +19818,8 @@ gen_typedef_die (tree decl, dw_die_ref context_die)
 	    }
 	}
 
-      add_type_attribute (type_die, type, TREE_READONLY (decl),
-			  TREE_THIS_VOLATILE (decl), context_die);
+      add_type_attribute (type_die, type, dw_mod_decl_flags (decl),
+			  context_die);
 
       if (is_naming_typedef_decl (decl))
 	/* We want that all subsequent calls to lookup_type_die with
@@ -20383,8 +20394,8 @@ force_type_die (tree type)
     {
       dw_die_ref context_die = get_context_die (TYPE_CONTEXT (type));
 
-      type_die = modified_type_die (type, TYPE_READONLY (type),
-				    TYPE_VOLATILE (type), context_die);
+      type_die = modified_type_die (type, dw_mod_type_flags (type),
+				    context_die);
       gcc_assert (type_die);
     }
   return type_die;
diff --git a/gcc/dwarf2out.h b/gcc/dwarf2out.h
index bac5077..e7de4f8 100644
--- a/gcc/dwarf2out.h
+++ b/gcc/dwarf2out.h
@@ -46,6 +46,14 @@ enum dw_cfi_oprnd_type {
   dw_cfi_oprnd_loc
 };
 
+/* DWARF type modifier flags for base types.  Used by
+   modified_type_die () to chain a base type.  */
+enum dw_mod_flag {
+  dw_mod_none = 0,
+  dw_mod_const = 1 << 1,
+  dw_mod_volatile = 1 << 2
+};
+
 typedef union GTY(()) {
   unsigned int GTY ((tag ("dw_cfi_oprnd_reg_num"))) dw_cfi_reg_num;
   HOST_WIDE_INT GTY ((tag ("dw_cfi_oprnd_offset"))) dw_cfi_offset;
-- 
1.7.1

^ permalink raw reply	[flat|nested] 30+ messages in thread
* [PATCH 1/2] DWARFv5 Emit DW_TAG_atomic_type.
@ 2014-08-12 15:35 Mark Wielaard
  2014-08-12 15:36 ` [PATCH 2/2] DWARF5: Add DW_TAG_aligned_type support Mark Wielaard
  0 siblings, 1 reply; 30+ messages in thread
From: Mark Wielaard @ 2014-08-12 15:35 UTC (permalink / raw)
  To: gcc-patches; +Cc: Jason Merrill, Cary Coutant, Joseph S. Myers, Mark Wielaard

Ping. This patch is based on the proposed patches to support the
restrict type. But isn't meant to be integrated at this time. DWARFv5
is still only a collection of proposals and hasn't seen any draft
yet. But feedback is highly appreciated. Also if there are tips on how
(and where) to maintain an experimental patch set for a future standard
that would be welcome.

There is a corresponding patch for GDB:
https://sourceware.org/ml/gdb-patches/2014-06/msg00795.html

gcc/ChangeLog

	PR debug/60782
	* dwarf2out.c (modified_type_die): Handle TYPE_QUAL_ATOMIC.
	* opts.c (common_handle_option): Accept -gdwarf-5.

gcc/testsuite/ChangeLog

	PR debug/60782
	* gcc.dg/guality/atomic.c: New test.

include/ChangeLog

	PR debug/60782
	* dwarf2.def: Add DWARFv5 DW_TAG_atomic_type.
---
 gcc/ChangeLog                         |  6 ++++++
 gcc/dwarf2out.c                       | 22 +++++++++++++++++++---
 gcc/opts.c                            |  2 +-
 gcc/testsuite/ChangeLog               |  5 +++++
 gcc/testsuite/gcc.dg/guality/atomic.c | 13 +++++++++++++
 include/ChangeLog                     |  5 +++++
 include/dwarf2.def                    |  2 ++
 7 files changed, 51 insertions(+), 4 deletions(-)
 create mode 100644 gcc/testsuite/gcc.dg/guality/atomic.c

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 428a1e1..1adf6a6 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,9 @@
+2014-07-09  Mark Wielaard  <mjw@redhat.com>
+
+	PR debug/60782
+	* dwarf2out.c (modified_type_die): Handle TYPE_QUAL_ATOMIC.
+	* opts.c (common_handle_option): Accept -gdwarf-5.
+
 2014-07-08  Mark Wielaard  <mjw@redhat.com>
 
 	PR debug/59051
diff --git a/gcc/dwarf2out.c b/gcc/dwarf2out.c
index 51e379e..7792604 100644
--- a/gcc/dwarf2out.c
+++ b/gcc/dwarf2out.c
@@ -10478,7 +10478,8 @@ modified_type_die (tree type, int cv_quals, dw_die_ref context_die)
     return NULL;
 
   /* Only these cv-qualifiers are currently handled.  */
-  cv_quals &= (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE | TYPE_QUAL_RESTRICT);
+  cv_quals &= (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE | TYPE_QUAL_RESTRICT
+	       | TYPE_QUAL_ATOMIC);
 
   /* Don't emit DW_TAG_restrict_type for DWARFv2, since it is a type
      tag modifier (and not an attribute) old consumers won't be able
@@ -10486,6 +10487,10 @@ modified_type_die (tree type, int cv_quals, dw_die_ref context_die)
   if (dwarf_version < 3)
     cv_quals &= ~TYPE_QUAL_RESTRICT;
 
+  /* Likewise for DW_TAG_atomic_type for DWARFv5.  */
+  if (dwarf_version < 5)
+    cv_quals &= ~TYPE_QUAL_ATOMIC;
+
   /* See if we already have the appropriately qualified variant of
      this type.  */
   qualified_type = get_qualified_type (type, cv_quals);
@@ -10529,7 +10534,8 @@ modified_type_die (tree type, int cv_quals, dw_die_ref context_die)
       else
 	{
 	  int dquals = TYPE_QUALS_NO_ADDR_SPACE (dtype);
-	  dquals &= (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE | TYPE_QUAL_RESTRICT);
+	  dquals &= (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE | TYPE_QUAL_RESTRICT
+		     | TYPE_QUAL_ATOMIC);
 	  if ((dquals & ~cv_quals) != TYPE_UNQUALIFIED
 	      || (cv_quals == dquals && DECL_ORIGINAL_TYPE (name) != type))
 	    /* cv-unqualified version of named type.  Just use
@@ -10564,12 +10570,22 @@ modified_type_die (tree type, int cv_quals, dw_die_ref context_die)
       sub_die = modified_type_die (type, cv_quals & ~TYPE_QUAL_VOLATILE,
 				   context_die);
     }
-  else if (cv_quals & TYPE_QUAL_RESTRICT)
+  else if ((cv_quals & TYPE_QUAL_RESTRICT)
+	   && (((cv_quals & ~TYPE_QUAL_RESTRICT) == TYPE_UNQUALIFIED)
+	       || get_qualified_type (type, cv_quals) == NULL_TREE
+	       || (get_qualified_type (type, cv_quals & ~TYPE_QUAL_RESTRICT)
+		   != NULL_TREE)))
     {
       mod_type_die = new_die (DW_TAG_restrict_type, mod_scope, type);
       sub_die = modified_type_die (type, cv_quals & ~TYPE_QUAL_RESTRICT,
 				   context_die);
     }
+  else if (cv_quals & TYPE_QUAL_ATOMIC)
+    {
+      mod_type_die = new_die (DW_TAG_atomic_type, mod_scope, type);
+      sub_die = modified_type_die (type, cv_quals & ~TYPE_QUAL_ATOMIC,
+				   context_die);
+    }
   else if (code == POINTER_TYPE)
     {
       mod_type_die = new_die (DW_TAG_pointer_type, mod_scope, type);
diff --git a/gcc/opts.c b/gcc/opts.c
index be1867c..f3f2817 100644
--- a/gcc/opts.c
+++ b/gcc/opts.c
@@ -1884,7 +1884,7 @@ common_handle_option (struct gcc_options *opts,
       
       /* FALLTHRU */
     case OPT_gdwarf_:
-      if (value < 2 || value > 4)
+      if (value < 2 || value > 5)
 	error_at (loc, "dwarf version %d is not supported", value);
       else
 	opts->x_dwarf_version = value;
diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog
index 3f9e53f..4c8ce92 100644
--- a/gcc/testsuite/ChangeLog
+++ b/gcc/testsuite/ChangeLog
@@ -1,3 +1,8 @@
+2014-07-09  Mark Wielaard  <mjw@redhat.com>
+
+	PR debug/60782
+	* gcc.dg/guality/atomic.c: New test.
+
 2014-07-08  Mark Wielaard  <mjw@redhat.com>
 
 	PR debug/59051
diff --git a/gcc/testsuite/gcc.dg/guality/atomic.c b/gcc/testsuite/gcc.dg/guality/atomic.c
new file mode 100644
index 0000000..c76cfa4
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/guality/atomic.c
@@ -0,0 +1,13 @@
+/* debuginfo tests for the _Atomic type qualifier.  */
+/* { dg-do run } */
+/* { dg-options "-std=c11 -gdwarf-5" } */
+
+volatile _Atomic int * const _Atomic hwaddr = (void *) 0x1234;
+
+int
+main (int argc, char **argv)
+{
+  return hwaddr == (void *) argv[0];
+}
+
+/* { dg-final { gdb-test 10 "type:hwaddr" "volatile _Atomic int * const _Atomic" } } */
diff --git a/include/ChangeLog b/include/ChangeLog
index 1cda0dc..2609e70 100644
--- a/include/ChangeLog
+++ b/include/ChangeLog
@@ -1,3 +1,8 @@
+2014-07-09  Mark Wielaard  <mjw@redhat.com>
+
+	PR debug/60782
+	* dwarf2.def: Add DWARFv5 DW_TAG_atomic_type.
+
 2014-06-10  Thomas Schwinge  <thomas@codesourcery.com>
 
 	PR lto/61334
diff --git a/include/dwarf2.def b/include/dwarf2.def
index 71a37b3..6490391 100644
--- a/include/dwarf2.def
+++ b/include/dwarf2.def
@@ -133,6 +133,8 @@ DW_TAG (DW_TAG_shared_type, 0x40)
 DW_TAG (DW_TAG_type_unit, 0x41)
 DW_TAG (DW_TAG_rvalue_reference_type, 0x42)
 DW_TAG (DW_TAG_template_alias, 0x43)
+/* DWARF 5.  */
+DW_TAG (DW_TAG_atomic_type, 0x47) /* NOT AN OFFICIAL NUMBER. DWARF5 131112.1 */
 
 DW_TAG_DUP (DW_TAG_lo_user, 0x4080)
 DW_TAG_DUP (DW_TAG_hi_user, 0xffff)
-- 
1.8.3.1

^ permalink raw reply	[flat|nested] 30+ messages in thread
end of thread, other threads:[~2014-08-20 12:31 UTC | newest]

Thread overview: 30+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2014-06-18 20:56 [PATCH] dwarf2out.c: Pass DWARF type modifiers around as flags argument Mark Wielaard
2014-06-20 11:51 ` Mark Wielaard
2014-06-20 23:02   ` [PATCH] Emit DW_tag_restrict_type for restrict-qualified pointers Mark Wielaard
2014-06-22  9:39     ` [PATCH] DWARFv5 Emit DW_TAG_atomic_type Mark Wielaard
2014-06-23 16:32       ` Tom Tromey
2014-06-23 17:12         ` Mark Wielaard
2014-07-08 16:39     ` [PATCH 1/2] dwarf2out.c: Pass one cv_quals argument instead of two for const and volatile Mark Wielaard
2014-07-09 21:36       ` Some DWARFv5 proposal prototypes (atomic_type, aligned_type) Mark Wielaard
2014-07-14 20:03         ` Tom Tromey
2014-07-15 11:57           ` Mark Wielaard
2014-07-15 20:55             ` Eric Christopher
2014-07-09 21:36       ` [PATCH 1/2] DWARFv5 Emit DW_TAG_atomic_type Mark Wielaard
2014-07-09 21:37       ` [PATCH 2/2] DWARF5: Add DW_TAG_aligned_type support Mark Wielaard
2014-07-08 16:39     ` [PATCH 2/2] Emit DW_tag_restrict_type for restrict-qualified pointers Mark Wielaard
2014-07-08 18:12       ` Mark Wielaard
2014-07-03  9:53   ` [PATCH] Add guality [p]type test Mark Wielaard
2014-07-03 10:05     ` Jakub Jelinek
2014-07-03 11:15       ` Mark Wielaard
2014-07-03 19:43         ` Tom Tromey
2014-07-07  9:58     ` Richard Biener
2014-08-19 11:06       ` Mark Wielaard
2014-08-19 11:23         ` Richard Biener
2014-08-19 12:10           ` Mark Wielaard
2014-08-19 12:16             ` Richard Biener
2014-08-19 17:52               ` Mark Wielaard
2014-08-20  8:49                 ` Richard Biener
2014-08-20 12:19                   ` Mark Wielaard
2014-08-20 12:31                     ` Richard Biener
2014-08-12 15:35 [PATCH 1/2] DWARFv5 Emit DW_TAG_atomic_type Mark Wielaard
2014-08-12 15:36 ` [PATCH 2/2] DWARF5: Add DW_TAG_aligned_type support Mark Wielaard
2014-08-12 20:05   ` Jason Merrill

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).