[binutils-gdb] gdb, dwarf: create symbols for template tags without names

[binutils-gdb] gdb, dwarf: create symbols for template tags without names

[Nils-Christian Kempke]

https://sourceware.org/git/gitweb.cgi?p=binutils-gdb.git;h=945e66a74d6dd3a94bd5f1ee5b132de42337eb4a

commit 945e66a74d6dd3a94bd5f1ee5b132de42337eb4a
Author: Nils-Christian Kempke <nils-christian.kempke@intel.com>
Date:   Mon Mar 28 17:18:53 2022 +0200

    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
    '<unnamedNUMBER>' 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<typename A, typename B, typename C>
      class Foo {};
    
      template<typename, typename B, typename>
      class Foo;
    
      int main () {
        Foo<double, int, float> 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<double, int, float>
        <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<double, int, float> [with B = int] {
          <no data fields>
      }
    
    After this patch GDB does generate symbols from the DWARF (with their
    artificial names:
    
      (gdb) ptype f
      type = class Foo<double, int, float> [with <unnamed0> = double, B = int,
      <unnamed1> = float] {
          <no data fields>
      }
    
    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:
---
 gdb/dwarf2/read.c                                  |  45 +++++-
 .../gdb.dwarf2/missing-type-name-for-templates.cc  |  58 +++++++
 .../gdb.dwarf2/missing-type-name-for-templates.exp | 170 +++++++++++++++++++++
 3 files changed, 272 insertions(+), 1 deletion(-)

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 <unnnamed0>, <unnamed1>, ... 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 = "<unnamed" + std::to_string (nth_unnamed) + ">";
+  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 <http://www.gnu.org/licenses/>.  */
+
+template<typename first, typename second>
+class template_var1
+{
+  first me;
+  second me2;
+};
+
+template<typename first, typename second>
+class template_var2
+{
+  first me;
+  second me2;
+};
+
+template<int val1, typename first, int val2, typename second>
+class template_var3
+{
+  first me;
+  second me2;
+};
+
+template<typename, typename second>
+class template_var1;
+
+template<typename, typename>
+class template_var2;
+
+template<int, typename, int, typename>
+class template_var3;
+
+int
+main (int argc, char **argv)
+{
+  asm ("main_label: .globl main_label");
+
+  template_var1<int, float> var1;
+  template_var2<int, float> 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 <http://www.gnu.org/licenses/>.
+
+# 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<int, 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_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<int, 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_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<int, float> \\\[with <unnamed0> = int, second = float\\\] {" \
+    "    <unnamed0> me;" \
+    "    second me2;" \
+    "}"]
+
+gdb_test "ptype var2" [multi_line \
+    "type = class template_var2<int, float> \\\[with <unnamed0> = int, <unnamed1> = float\\\] {" \
+    "    <unnamed0> me;" \
+    "    <unnamed1> me2;" \
+    "}"]
+
+gdb_test "ptype var3" [multi_line \
+    "type = struct template_var3<0, int, 11, float> \\\[with <unnamed1> = int, <unnamed3> = float\\\] {" \
+    "    <unnamed1> me;" \
+    "    <unnamed3> me2;" \
+    "}"]