From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 10025 invoked by alias); 8 Jul 2014 16:39:36 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Received: (qmail 9850 invoked by uid 89); 8 Jul 2014 16:39:33 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-1.9 required=5.0 tests=BAYES_00,SPF_PASS autolearn=ham version=3.3.2 X-HELO: gnu.wildebeest.org Received: from wildebeest.demon.nl (HELO gnu.wildebeest.org) (212.238.236.112) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with (AES256-SHA encrypted) ESMTPS; Tue, 08 Jul 2014 16:39:25 +0000 From: Mark Wielaard To: gcc-patches@gcc.gnu.org Cc: Jason Merrill , Cary Coutant , "Joseph S. Myers" , Mark Wielaard Subject: [PATCH 1/2] dwarf2out.c: Pass one cv_quals argument instead of two for const and volatile. Date: Tue, 08 Jul 2014 16:39:00 -0000 Message-Id: <1404837544-32127-1-git-send-email-mjw@redhat.com> In-Reply-To: <1403305305-29532-1-git-send-email-mjw@redhat.com> References: <1403305305-29532-1-git-send-email-mjw@redhat.com> X-Spam-Score: -2.9 (--) X-SW-Source: 2014-07/txt/msg00569.txt.bz2 Hi, In my original patch I introduced a new enum to keep track of the qualifiers that we might want to output. But that seems silly in retrospect. We already have the tree cv_qualifier enum to encode all possible cv-qualifier combinations, so this variant of the patch just reuses those and uses TYPE_QUALS_NO_ADDR_SPACE to extract the qualifiers from the tree types. I kept this patch separate from the actual patch that introduces the DW_TAG_restrict_type because I thought that would be easier to review. But I can merge the two patches together if people feel that is more appropriate. 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 cv_quals argument to these functions. And introduce helper function decl_quals to extract additional cv_quals from declaration trees. DWARFv3 added restrict_type [PR debug/59051] and DWARFv5 has proposals for atomic_type and aligned_type. Which will be easier to implement based on this change. gcc/ChangeLog * dwarf2out.c (decl_quals): New function. (modified_type_die): Take one cv_quals argument instead of two, 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 | 28 ++++++++++ gcc/dwarf2out.c | 154 +++++++++++++++++++++++++++++++------------------------ 2 files changed, 115 insertions(+), 67 deletions(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index cf55712..3f63f1b 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,31 @@ +2014-07-07 Mark Wielaard + + * dwarf2out.c (decl_quals): New function. + (modified_type_die): Take one cv_quals argument instead of two, + 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-07-01 Jan Hubicka * ipa-utils.h (method_class_type, vtable_pointer_value_to_binfo, diff --git a/gcc/dwarf2out.c b/gcc/dwarf2out.c index b65b37e..068bbc3 100644 --- a/gcc/dwarf2out.c +++ b/gcc/dwarf2out.c @@ -3140,7 +3140,8 @@ 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 decl_quals (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 +3199,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); @@ -10490,12 +10491,24 @@ subrange_type_die (tree type, tree low, tree high, dw_die_ref context_die) return subrange_die; } +/* Returns the (const and/or volatile) cv_qualifiers associated with + the decl node. This will normally be augmented with the + cv_qualifiers of the underlying type in add_type_attribute. */ + +static int +decl_quals (const_tree decl) +{ + return ((TREE_READONLY (decl) + ? TYPE_QUAL_CONST : TYPE_UNQUALIFIED) + | (TREE_THIS_VOLATILE (decl) + ? TYPE_QUAL_VOLATILE : TYPE_UNQUALIFIED)); +} + /* 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 cv_quals, dw_die_ref context_die) { enum tree_code code = TREE_CODE (type); dw_die_ref mod_type_die; @@ -10508,12 +10521,12 @@ modified_type_die (tree type, int is_const_type, int is_volatile_type, if (code == ERROR_MARK) return NULL; + /* Only these cv-qualifiers are currently handled. */ + cv_quals &= (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE); + /* 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))); + qualified_type = get_qualified_type (type, cv_quals); if (qualified_type == sizetype && TYPE_NAME (qualified_type) @@ -10551,35 +10564,38 @@ 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) - && 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, - context_die); - /* Else cv-qualified version of named type; fall through. */ + else + { + int dquals = TYPE_QUALS_NO_ADDR_SPACE (dtype); + dquals &= (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE); + if ((dquals & ~cv_quals) != TYPE_UNQUALIFIED + || (cv_quals == dquals && 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), + cv_quals, 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 ((cv_quals & TYPE_QUAL_CONST) + /* If both const_type and volatile_type, prefer the path which leads to a qualified type. */ - && (!is_volatile_type + && (!(cv_quals & TYPE_QUAL_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, cv_quals & ~TYPE_QUAL_CONST, + context_die); } - else if (is_volatile_type) + else if (cv_quals & TYPE_QUAL_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, cv_quals & ~TYPE_QUAL_VOLATILE, + context_die); } else if (code == POINTER_TYPE) { @@ -10640,7 +10656,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))) + || (cv_quals == TYPE_UNQUALIFIED))) || (TREE_CODE (name) == TYPE_DECL && TREE_TYPE (name) == qualified_type && DECL_NAME (name)))) @@ -10669,8 +10685,7 @@ modified_type_die (tree type, int is_const_type, int is_volatile_type, 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), + TYPE_QUALS_NO_ADDR_SPACE (item_type), context_die); if (sub_die != NULL) @@ -10812,8 +10827,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) + ? TYPE_QUAL_VOLATILE : TYPE_UNQUALIFIED), parent_die); } else @@ -11555,7 +11571,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, TYPE_UNQUALIFIED, comp_unit_die ()); if (type_die == NULL || type_die->die_tag != DW_TAG_base_type) return NULL; return type_die; @@ -16472,7 +16488,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), TYPE_QUAL_CONST, ctx); add_AT_location_description (decl_die, DW_AT_location, list); add_AT_die_ref (subrange_die, bound_attr, decl_die); break; @@ -16523,8 +16539,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), + TYPE_UNQUALIFIED, type_die); } /* ??? If upper is NULL, the array has unspecified length, @@ -17015,11 +17031,12 @@ class_or_namespace_scope_p (dw_die_ref context_die) /* Many forms of DIEs require a "type description" attribute. This routine locates the proper "type descriptor" die for the type given - by 'type', and adds a DW_AT_type attribute below the given die. */ + by 'type' plus any additional qualifiers given by 'cv_quals', 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 cv_quals, + dw_die_ref context_die) { enum tree_code code = TREE_CODE (type); dw_die_ref type_die = NULL; @@ -17040,8 +17057,7 @@ add_type_attribute (dw_die_ref object_die, tree type, int decl_const, return; type_die = modified_type_die (type, - decl_const || TYPE_READONLY (type), - decl_volatile || TYPE_VOLATILE (type), + cv_quals | TYPE_QUALS_NO_ADDR_SPACE (type), context_die); if (type_die != NULL) @@ -17255,7 +17271,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, TYPE_UNQUALIFIED, context_die); add_gnat_descriptive_type_attribute (array_die, type, context_die); if (TYPE_ARTIFICIAL (type)) @@ -17418,7 +17434,8 @@ 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, TYPE_UNQUALIFIED, + context_die); if (get_AT (array_die, DW_AT_name)) add_pubtype (type, array_die); @@ -17437,7 +17454,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); + TYPE_UNQUALIFIED, context_die); } if (DECL_ABSTRACT (decl)) @@ -17527,7 +17544,8 @@ 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, TYPE_UNQUALIFIED, + context_die); } if (TYPE_STUB_DECL (type) != NULL_TREE) { @@ -17628,12 +17646,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, - context_die); + add_type_attribute (parm_die, TREE_TYPE (type), + TYPE_UNQUALIFIED, context_die); else add_type_attribute (parm_die, type, - TREE_READONLY (node_or_origin), - TREE_THIS_VOLATILE (node_or_origin), + decl_quals (node_or_origin), context_die); } if (origin == NULL && DECL_ARTIFICIAL (node)) @@ -17649,7 +17666,8 @@ 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, TYPE_UNQUALIFIED, + context_die); break; default: @@ -18231,7 +18249,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); + TYPE_UNQUALIFIED, context_die); } } } @@ -18248,7 +18266,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); + TYPE_UNQUALIFIED, context_die); } add_pure_or_virtual_attribute (subr_die, decl); @@ -18863,8 +18881,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), decl_quals (decl), + context_die); add_AT_flag (var_die, DW_AT_external, 1); if (loc) { @@ -18957,10 +18975,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), TYPE_UNQUALIFIED, + 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, decl_quals (decl_or_origin), + context_die); } if (origin == NULL && !specialization_p) @@ -19014,7 +19033,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, TYPE_QUAL_CONST, context_die); if (TREE_PUBLIC (decl)) add_AT_flag (const_die, DW_AT_external, 1); if (DECL_ARTIFICIAL (decl)) @@ -19257,8 +19276,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); + decl_quals (decl), context_die); if (DECL_BIT_FIELD_TYPE (decl)) { @@ -19292,7 +19310,8 @@ 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), TYPE_UNQUALIFIED, + context_die); add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE); } @@ -19312,7 +19331,8 @@ 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), TYPE_UNQUALIFIED, + context_die); add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE); } #endif @@ -19329,7 +19349,8 @@ 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), TYPE_UNQUALIFIED, + context_die); } typedef const char *dchar_p; /* For DEF_VEC_P. */ @@ -19534,7 +19555,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), TYPE_UNQUALIFIED, context_die); add_data_member_location_attribute (die, binfo); if (BINFO_VIRTUAL_P (binfo)) @@ -19731,7 +19752,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, TYPE_UNQUALIFIED, context_die); gen_formal_types_die (type, subr_die); if (get_AT (subr_die, DW_AT_name)) @@ -19799,8 +19820,7 @@ 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, decl_quals (decl), context_die); if (is_naming_typedef_decl (decl)) /* We want that all subsequent calls to lookup_type_die with @@ -20375,8 +20395,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, TYPE_QUALS_NO_ADDR_SPACE (type), + context_die); gcc_assert (type_die); } return type_die; -- 1.7.1