Support template template parameters

[friss]

Summary

We would fail to resolve (and thus display the value of) any
templated type which contained a template template argument even
though we don't really use template arguments.

This patch adds minimal support for template template arguments,
but I doubt we need any more than that.

[clayborg]

source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

2043

Shouldn't we be using a #define so this works on any compiler?

2093

Do we really want to kill the program here? lldbassert would be better IMHO. Templates are one of the most contentious areas of the DWARF from compiler to compiler and I would rather we not crash when we can't successfully dig out a type from DWO/DWZ/type units/-gmodules etc...

[friss]

source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

2043

You're right. I had looked in clang to see if it was used like this, but I think the many instances I saw were in the test directory.

2093

Well, the lines above are

if (!clang_type)

clang_type = m_ast.GetBasicType(eBasicTypeVoid);

I could add a test and a return false like it was before, but it seems pretty silly to expect anything when you can't even figure out the builtin void type

[friss]

Use LLVM macro for fallthrough

[friss]

Ping

[clayborg]

Sorry for the delay.

include/lldb/Symbol/ClangASTContext.h

void CreateFunctionTemplateSpecializationInfo(
       clang::FunctionDecl *func_decl, clang::FunctionTemplateDecl *Template,
       const TemplateParameterInfos &infos);
 
   clang::ClassTemplateDecl *
   CreateClassTemplateDecl(clang::DeclContext *decl_ctx,
                           lldb::AccessType access_type, const char *class_name,
                           int kind, const TemplateParameterInfos &infos);
 
+  clang::TemplateTemplateParmDecl *
+  CreateTemplateTemplateParmDecl(const char *template_name);
+
   clang::ClassTemplateSpecializationDecl *CreateClassTemplateSpecializationDecl(
       clang::DeclContext *decl_ctx,
       clang::ClassTemplateDecl *class_template_decl, int kind,
       const TemplateParameterInfos &infos);
 
   CompilerType
   CreateClassTemplateSpecializationType(clang::ClassTemplateSpecializationDecl *
                                             class_template_specialization_decl);

packages/Python/lldbsuite/test/lang/cpp/template/TestTemplateArgs.py

def test_integer_args(self):
             'got a valid expression result from expression "testneg.getArg()"')
         self.assertTrue(
             expr_result.GetValue() == "-1",
             "testneg.getArg() == -1")
         self.assertTrue(
             expr_result.GetType().GetName() == "int",
             'expr_result.GetType().GetName() == "int"')
 
+    def test_template_template_args(self):
+        frame = self.prepareProcess()
+
+        c1 = frame.FindVariable('c1')
+        self.assertTrue(
+            c1.IsValid(),
+            'make sure we find a local variabble named "c1"')
+        self.assertTrue(c1.GetType().GetName() == 'C<float, T1>')
+        f1 = c1.GetChildMemberWithName("V").GetChildAtIndex(0).GetChildMemberWithName("f")
+        self.assertTrue(f1.GetType().GetName() == 'float')
+        self.assertTrue(f1.GetValue() == '1.5')
+
+        c2 = frame.FindVariable('c2')
+        self.assertTrue(
+            c2.IsValid(),
+            'make sure we find a local variabble named "c2"')
+        self.assertTrue(c2.GetType().GetName() == 'C<double, T1, T2>')
+        f2 = c2.GetChildMemberWithName("V").GetChildAtIndex(0).GetChildMemberWithName("f")
+        self.assertTrue(f2.GetType().GetName() == 'double')
+        self.assertTrue(f2.GetValue() == '1.5')
+        f3 = c2.GetChildMemberWithName("V").GetChildAtIndex(1).GetChildMemberWithName("f")
+        self.assertTrue(f3.GetType().GetName() == 'double')
+        self.assertTrue(f3.GetValue() == '2.5')
+        f4 = c2.GetChildMemberWithName("V").GetChildAtIndex(1).GetChildMemberWithName("i")
+        self.assertTrue(f4.GetType().GetName() == 'int')
+        self.assertTrue(f4.GetValue() == '42')
+
+
     # Gcc does not generate the necessary DWARF attribute for enum template
     # parameters.
     @expectedFailureAll(bugnumber="llvm.org/pr28354", compiler="gcc")
     @expectedFailureAll(oslist=["windows"])
     def test_enum_args(self):
         frame = self.prepareProcess()
 
         # Make sure "member" can be displayed and also used in an expression

packages/Python/lldbsuite/test/lang/cpp/template/main.cpp

 //===-- main.cpp ------------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
+#include <tuple>
 
 template <int Arg>
 class TestObj
 {
 public:
   int getArg()
   {
     return Arg;
class EnumTemplate<EnumType::Subclass> :
     public EnumTemplate<EnumType::Member> 
 {
 public:
     EnumTemplate(int m) : EnumTemplate<EnumType::Member>(m)
     {
     }    
 };
 
+template <typename FLOAT> struct T1 { FLOAT f = 1.5; };
+template <typename FLOAT> struct T2 { FLOAT f = 2.5; int i = 42; };
+template <typename FLOAT, template <typename> class ...Args> class C { std::tuple<Args<FLOAT>...> V; };
+
 int main(int argc, char **argv)
 {
   TestObj<1> testpos;
   TestObj<-1> testneg;
   EnumTemplate<EnumType::Member> member(123);
   EnumTemplate<EnumType::Subclass> subclass(123*2);
+  C<float, T1> c1;
+  C<double, T1, T2> c2;
   return testpos.getArg() - testneg.getArg() + member.getMember()*2 - subclass.getMember(); // Breakpoint 1
 }

source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

 #include "lldb/Target/Language.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamString.h"
 
 #include "clang/AST/CXXInheritance.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclObjC.h"
+#include "clang/AST/DeclTemplate.h"
 
 #include <map>
 #include <vector>
 
 //#define ENABLE_DEBUG_PRINTF // COMMENT OUT THIS LINE PRIOR TO CHECKIN
 
 #ifdef ENABLE_DEBUG_PRINTF
 #include <stdio.h>
private:
   uint32_t m_property_attributes;
   std::unique_ptr<ClangASTMetadata> m_metadata_ap;
 };
 
 bool DWARFASTParserClang::ParseTemplateDIE(
     const DWARFDIE &die,
     ClangASTContext::TemplateParameterInfos &template_param_infos) {
   const dw_tag_t tag = die.Tag();
+  bool is_template_template_argument = false;
 
   switch (tag) {
   case DW_TAG_GNU_template_parameter_pack: {
     template_param_infos.packed_args.reset(
       new ClangASTContext::TemplateParameterInfos);
     for (DWARFDIE child_die = die.GetFirstChild(); child_die.IsValid();
          child_die = child_die.GetSibling()) {
       if (!ParseTemplateDIE(child_die, *template_param_infos.packed_args))
         return false;
     }
     if (const char *name = die.GetName()) {
       template_param_infos.pack_name = name;
     }
     return true;
   }
+  case DW_TAG_GNU_template_template_param:
+    is_template_template_argument = true;
+    [[clang::fallthrough]];
   case DW_TAG_template_type_parameter:
   case DW_TAG_template_value_parameter: {
     DWARFAttributes attributes;
     const size_t num_attributes = die.GetAttributes(attributes);
     const char *name = nullptr;
+    const char *template_name = nullptr;
     CompilerType clang_type;
     uint64_t uval64 = 0;
     bool uval64_valid = false;
     if (num_attributes > 0) {
       DWARFFormValue form_value;
       for (size_t i = 0; i < num_attributes; ++i) {
         const dw_attr_t attr = attributes.AttributeAtIndex(i);
 
         switch (attr) {
         case DW_AT_name:
           if (attributes.ExtractFormValueAtIndex(i, form_value))
             name = form_value.AsCString();
           break;
 
+        case DW_AT_GNU_template_name:
+          if (attributes.ExtractFormValueAtIndex(i, form_value))
+            template_name = form_value.AsCString();
+          break;
+
         case DW_AT_type:
           if (attributes.ExtractFormValueAtIndex(i, form_value)) {
             Type *lldb_type = die.ResolveTypeUID(DIERef(form_value));
             if (lldb_type)
               clang_type = lldb_type->GetForwardCompilerType();
           }
           break;
 
         case DW_AT_const_value:
           if (attributes.ExtractFormValueAtIndex(i, form_value)) {
             uval64_valid = true;
             uval64 = form_value.Unsigned();
           }
           break;
         default:
           break;
         }
       }
 
       clang::ASTContext *ast = m_ast.getASTContext();
       if (!clang_type)
         clang_type = m_ast.GetBasicType(eBasicTypeVoid);
 
-      if (clang_type) {
+      if (!is_template_template_argument) {
+        assert(clang_type && "AST context could not provide void type.");
         bool is_signed = false;
         if (name && name[0])
           template_param_infos.names.push_back(name);
         else
           template_param_infos.names.push_back(NULL);
 
         // Get the signed value for any integer or enumeration if available
         clang_type.IsIntegerOrEnumerationType(is_signed);
 
         if (tag == DW_TAG_template_value_parameter && uval64_valid) {
           llvm::APInt apint(clang_type.GetBitSize(nullptr), uval64, is_signed);
           template_param_infos.args.push_back(
               clang::TemplateArgument(*ast, llvm::APSInt(apint, !is_signed),
                                       ClangUtil::GetQualType(clang_type)));
         } else {
           template_param_infos.args.push_back(
               clang::TemplateArgument(ClangUtil::GetQualType(clang_type)));
         }
       } else {
-        return false;
+        auto *tplt_type = m_ast.CreateTemplateTemplateParmDecl(template_name);
+        template_param_infos.names.push_back(name);
+        template_param_infos.args.push_back(
+            clang::TemplateArgument(clang::TemplateName(tplt_type)));
       }
     }
   }
     return true;
 
   default:
     break;
   }
bool DWARFASTParserClang::ParseTemplateParameterInfos(
   for (DWARFDIE die = parent_die.GetFirstChild(); die.IsValid();
        die = die.GetSibling()) {
     const dw_tag_t tag = die.Tag();
 
     switch (tag) {
     case DW_TAG_template_type_parameter:
     case DW_TAG_template_value_parameter:
     case DW_TAG_GNU_template_parameter_pack:
+    case DW_TAG_GNU_template_template_param:
       ParseTemplateDIE(die, template_param_infos);
       break;
 
     default:
       break;
     }
   }
   if (template_param_infos.args.empty())

source/Symbol/ClangASTContext.cpp

 #ifdef LLDB_CONFIGURATION_DEBUG
     VerifyDecl(class_template_decl);
 #endif
   }
 
   return class_template_decl;
 }
 
+TemplateTemplateParmDecl *
+ClangASTContext::CreateTemplateTemplateParmDecl(const char *template_name) {
+  ASTContext *ast = getASTContext();
+
+  auto *decl_ctx = ast->getTranslationUnitDecl();
+
+  IdentifierInfo &identifier_info = ast->Idents.get(template_name);
+  llvm::SmallVector<NamedDecl *, 8> template_param_decls;
+
+  ClangASTContext::TemplateParameterInfos template_param_infos;
+  TemplateParameterList *template_param_list = CreateTemplateParameterList(
+      ast, template_param_infos, template_param_decls);
+
+  // LLDB needs to create those decls only to be able to display a
+  // type that includes a template template argument. Only the name
+  // matters for this purpose, so we use dummy values for the other
+  // characterisitcs of the type.
+  return TemplateTemplateParmDecl::Create(
+      *ast, decl_ctx, SourceLocation(),
+      /*Depth*/ 0, /*Position*/ 0,
+      /*IsParameterPack*/ false, &identifier_info, template_param_list);
+}
+
 ClassTemplateSpecializationDecl *
 ClangASTContext::CreateClassTemplateSpecializationDecl(
     DeclContext *decl_ctx, ClassTemplateDecl *class_template_decl, int kind,
     const TemplateParameterInfos &template_param_infos) {
   ASTContext *ast = getASTContext();
   llvm::SmallVector<clang::TemplateArgument, 2> args(
       template_param_infos.args.size() +
       (template_param_infos.packed_args ? 1 : 0));