From: Nils-Christian Kempke Date: Mon, 28 Mar 2022 15:18:53 +0000 (+0200) Subject: gdb, dwarf: create symbols for template tags without names X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=945e66a74d6dd3a94bd5f1ee5b132de42337eb4a;p=binutils-gdb.git gdb, dwarf: create symbols for template tags without names The following GDB behavior was also reported as a GDB bug in https://sourceware.org/bugzilla/show_bug.cgi?id=28396 I will reiterate the problem a bit and give some more information here. This patch closes the above mentioned bug. The DWARF 5 standard 2.23 'Template Parameters' reads: A template type parameter is represented by a debugging information entry with the tag DW_TAG_template_type_parameter. A template value parameter is represented by a debugging information entry with the tag DW_TAG_template_value_parameter. The actual template parameter entries appear in the same order as the corresponding template formal parameter declarations in the source progam. A type or value parameter entry may have a DW_AT_name attribute, whose value is a null-terminated string containing the name of the corresponding formal parameter. So the DW_AT_name attribute for DW_TAG_template_type_parameter and DW_TAG_template_value_parameter is optional. Within GDB, creating a new symbol from some read DIE usually requires the presence of a DW_AT_name for the DIE (an exception here is the case of unnamed namespaces or the existence of a linkage name). This patch makes the presence of the DW_AT_name for template value/type tags optional, similar to the unnamed namespaces. For unnamed namespaces dwarf2_name simply returns the constant string CP_ANONYMOUS_NAMESPACE_STR '(anonymous namespace)'. For template tags a case was added to the switch statement calling the unnamed_template_tag_name helper. Within the scope of parent which the template parameter is a child of, the helper counts the position of the template tag within the unnamed template tags and returns '' where NUMBER is its position. This way we end up with unique names within the respective scope of the function/class/struct (these are the only currenltly supported template kinds within GDB and usually the compilers) where we discovered the template tags in. While I do not know of a way to bring GCC to emit template tags without names there is one for clang/icpx. Consider the following example template class Foo {}; template class Foo; int main () { Foo f; return 0; } The forward declaration for 'Foo' with the missing template type names 'A' and 'C' makes clang emit a bunch of template tags without names: ... <2><43>: Abbrev Number: 3 (DW_TAG_variable) <44> DW_AT_location : 2 byte block: 91 78 (DW_OP_fbreg: -8) <47> DW_AT_name : (indirect string, offset: 0x63): f <4b> DW_AT_decl_file : 1 <4c> DW_AT_decl_line : 8 <4d> DW_AT_type : <0x59> ... <1><59>: Abbrev Number: 5 (DW_TAG_class_type) <5a> DW_AT_calling_convention: 5 (pass by value) <5b> DW_AT_name : (indirect string, offset: 0x74): Foo <5f> DW_AT_byte_size : 1 <60> DW_AT_decl_file : 1 <61> DW_AT_decl_line : 2 <2><62>: Abbrev Number: 6 (DW_TAG_template_type_param) <63> DW_AT_type : <0x76> <2><67>: Abbrev Number: 7 (DW_TAG_template_type_param) <68> DW_AT_type : <0x52> <6c> DW_AT_name : (indirect string, offset: 0x6c): B <2><70>: Abbrev Number: 6 (DW_TAG_template_type_param) <71> DW_AT_type : <0x7d> ... Befor this patch, GDB would not create any symbols for the read template tag DIEs and thus lose knowledge about them. Breaking at the return statement and printing f's type would read (gdb) ptype f type = class Foo [with B = int] { } After this patch GDB does generate symbols from the DWARF (with their artificial names: (gdb) ptype f type = class Foo [with = double, B = int, = float] { } The same principle theoretically applies to template functions. Also here, GDB would not record unnamed template TAGs but I know of no visual way to trigger and test this changed behavior. Template functions do not emit a '[with...]' list and their name generation also does not suffer from template tags without names. GDB does not check whether or not a template tag has a name in 'dwarf2_compute_name' and thus, the names of the template functions are created independently of whether or not the template TAGs have a DW_TAT_name attribute. A testcase has been added in the gdb.dwarf2 for template classes and structs. Bug: https://sourceware.org/bugzilla/show_bug.cgi?id=28396 --- diff --git a/gdb/dwarf2/read.c b/gdb/dwarf2/read.c index 6c6ca96f8d9..08dd0b76b23 100644 --- a/gdb/dwarf2/read.c +++ b/gdb/dwarf2/read.c @@ -21921,6 +21921,41 @@ typename_concat (struct obstack *obs, const char *prefix, const char *suffix, } } +/* Return a generic name for a DW_TAG_template_type_param or + DW_TAG_template_value_param tag, missing a DW_AT_name attribute. We do this + per parent, so each function/class/struct template will have their own set + of template parameters named , , ... where the + enumeration starts at 0 and represents the position of the template tag in + the list of unnamed template tags for this parent, counting both, type and + value tags. */ + +static const char * +unnamed_template_tag_name (die_info *die, dwarf2_cu *cu) +{ + if (die->parent == nullptr) + return nullptr; + + /* Count the parent types unnamed template type and value children until, we + arrive at our entry. */ + size_t nth_unnamed = 0; + + die_info *child = die->parent->child; + while (child != die) + { + gdb_assert (child != nullptr); + if (child->tag == DW_TAG_template_type_param + || child->tag == DW_TAG_template_value_param) + { + if (dwarf2_attr (child, DW_AT_name, cu) == nullptr) + ++nth_unnamed; + } + child = child->sibling; + } + + const std::string name_str = ""; + return cu->per_objfile->objfile->intern (name_str.c_str ()); +} + /* Get name of a die, return NULL if not found. */ static const char * @@ -21956,7 +21991,9 @@ dwarf2_name (struct die_info *die, struct dwarf2_cu *cu) && die->tag != DW_TAG_interface_type && die->tag != DW_TAG_structure_type && die->tag != DW_TAG_namelist - && die->tag != DW_TAG_union_type) + && die->tag != DW_TAG_union_type + && die->tag != DW_TAG_template_type_param + && die->tag != DW_TAG_template_value_param) return NULL; switch (die->tag) @@ -21976,6 +22013,12 @@ dwarf2_name (struct die_info *die, struct dwarf2_cu *cu) return attr_name; return CP_ANONYMOUS_NAMESPACE_STR; + /* DWARF does not actually require template tags to have a name. */ + case DW_TAG_template_type_param: + case DW_TAG_template_value_param: + if (attr_name == nullptr) + return unnamed_template_tag_name (die, cu); + /* FALLTHROUGH. */ case DW_TAG_class_type: case DW_TAG_interface_type: case DW_TAG_structure_type: diff --git a/gdb/testsuite/gdb.dwarf2/missing-type-name-for-templates.cc b/gdb/testsuite/gdb.dwarf2/missing-type-name-for-templates.cc new file mode 100644 index 00000000000..06746b533fd --- /dev/null +++ b/gdb/testsuite/gdb.dwarf2/missing-type-name-for-templates.cc @@ -0,0 +1,58 @@ +/* Copyright (C) 2022 Free Software Foundation, Inc. + + This file is part of GDB. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . */ + +template +class template_var1 +{ + first me; + second me2; +}; + +template +class template_var2 +{ + first me; + second me2; +}; + +template +class template_var3 +{ + first me; + second me2; +}; + +template +class template_var1; + +template +class template_var2; + +template +class template_var3; + +int +main (int argc, char **argv) +{ + asm ("main_label: .globl main_label"); + + template_var1 var1; + template_var2 var2; + template_var3<0, int, 11, float> var3; + + return 0; +} diff --git a/gdb/testsuite/gdb.dwarf2/missing-type-name-for-templates.exp b/gdb/testsuite/gdb.dwarf2/missing-type-name-for-templates.exp new file mode 100644 index 00000000000..14339c86ded --- /dev/null +++ b/gdb/testsuite/gdb.dwarf2/missing-type-name-for-templates.exp @@ -0,0 +1,170 @@ +# Copyright 2022 Free Software Foundation, Inc. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +# This tests GDB's handling of DW_TAG_template_type_parameter and +# DW_TAG_template_value_parameter tags that do not have a DW_AT_name attribute. +# The attribute is optional for the tags and a bug about GDB not recording +# the respective symbols (because of the missing name) was reported in PR +# gdb/28396. + +load_lib dwarf.exp + +if {![dwarf2_support]} { + return 0 +} + +standard_testfile .cc .S + +set asm_file [standard_output_file $srcfile2] +Dwarf::assemble $asm_file { + cu {} { + DW_TAG_compile_unit { + {DW_AT_language @DW_LANG_C_plus_plus} + } { + declare_labels int float template_var1 template_var2 template_var3 + + int: DW_TAG_base_type { + {DW_AT_name "int"} + {DW_AT_byte_size 4 DW_FORM_data1} + {DW_AT_encoding @DW_ATE_signed} + } + + float: base_type { + {DW_AT_name float} + {DW_AT_byte_size 4 DW_FORM_sdata} + {DW_AT_encoding @DW_ATE_float} + } + + DW_TAG_subprogram { + {DW_AT_name "main"} + {MACRO_AT_range "main"} + {DW_AT_type :$int} + {DW_AT_external 1 DW_FORM_flag} + } { + DW_TAG_variable { + {DW_AT_name "var1"} + {DW_AT_type :$template_var1} + } + DW_TAG_variable { + {DW_AT_name "var2"} + {DW_AT_type :$template_var2} + } + DW_TAG_variable { + {DW_AT_name "var3"} + {DW_AT_type :$template_var3} + } + } + + # A variable whose type is a template instantiation with two + # template parameters, one unnamed. + template_var1: DW_TAG_structure_type { + {DW_AT_name "template_var1"} + } { + DW_TAG_member { + {DW_AT_name "me"} + {DW_AT_type :$int} + } + DW_TAG_member { + {DW_AT_name "me2"} + {DW_AT_type :$float} + } + DW_TAG_template_type_param { + {DW_AT_type :$int} + } + DW_TAG_template_type_param { + {DW_AT_name "second"} + {DW_AT_type :$float} + } + } + + # A variable whose type is a template instantiation with two + # template parameters, both unnamed. + template_var2: DW_TAG_class_type { + {DW_AT_name "template_var2"} + } { + DW_TAG_member { + {DW_AT_name "me"} + {DW_AT_type :$int} + } + DW_TAG_member { + {DW_AT_name "me2"} + {DW_AT_type :$float} + } + DW_TAG_template_type_param { + {DW_AT_type :$int} + } + DW_TAG_template_type_param { + {DW_AT_type :$float} + } + } + + # A variable whose type is a template instantiation with four + # template arguments, two types, two values, all unnamed. + template_var3: DW_TAG_structure_type { + {DW_AT_name "template_var3<0, int, 11, float>"} + } { + DW_TAG_member { + {DW_AT_name "me"} + {DW_AT_type :$int} + } + DW_TAG_member { + {DW_AT_name "me2"} + {DW_AT_type :$float} + } + DW_TAG_template_value_param { + {DW_AT_type :$int} + {DW_AT_const_value 0 DW_FORM_sdata} + } + DW_TAG_template_type_param { + {DW_AT_type :$int} + } + DW_TAG_template_value_param { + {DW_AT_type :$int} + {DW_AT_const_value 11 DW_FORM_sdata} + } + DW_TAG_template_type_param { + {DW_AT_type :$float} + } + } + } + } +} + +if { [prepare_for_testing "failed to prepare" ${testfile} \ + [list $srcfile $asm_file] {nodebug c++}] } { + return -1 +} + +if ![runto_main] { + return -1 +} + +gdb_test "ptype var1" [multi_line \ + "type = struct template_var1 \\\[with = int, second = float\\\] {" \ + " me;" \ + " second me2;" \ + "}"] + +gdb_test "ptype var2" [multi_line \ + "type = class template_var2 \\\[with = int, = float\\\] {" \ + " me;" \ + " me2;" \ + "}"] + +gdb_test "ptype var3" [multi_line \ + "type = struct template_var3<0, int, 11, float> \\\[with = int, = float\\\] {" \ + " me;" \ + " me2;" \ + "}"]