[clang][DebugInfo] Add DW_AT_default_value support for template template parameters

[Michael137]

Summary

After this patch, in the following snippet:

template <typename T> Foo {};

template <template <typename T> class CT = Foo> Bar {};

Bar<> b;

The debug-info entry for the CT template parameter will have
a DW_AT_default_value (true) attached to it.

[dblaikie]

clang/lib/CodeGen/CGDebugInfo.cpp

2091–2093

Could we pull this snipped out and do it before the switch - so we don't have to repeat it for each different kind of template parameter type?

[Michael137]

clang/lib/CodeGen/CGDebugInfo.cpp

2091–2093

yup makes sense!

[Michael137]

• Remove now redundant isSubstitutedDefaultArgument call

[dblaikie]

Looks good to me - we'd usually split the LLVM part from the Clang part, but I don't think we have fine grained unit tests for DIBuilder (could you check - if we do, then the LLVM part should go separately, with unit test coverage, then the Clang part can go in that uses it) & /maybe/ it's worth having a default value for the IsDefault argument, so any existing callers aren't broken, but I don't feel strongly about it if it all works, the number of external callers is probably quite small/not a big deal.

(if you do split up the clang/llvm parts into separate commits, no need to send them as separate reviews - you can commit them directly)

[Michael137]

• Rebase

[Michael137]

• Split out LLVM changes into separate commit

clang/lib/CodeGen/CGDebugInfo.cpp

case TemplateArgument::NullPtr: {
           V = CGM.getCXXABI().EmitNullMemberPointer(MPT);
       if (!V)
         V = llvm::ConstantInt::get(CGM.Int8Ty, 0);
       TemplateParams.push_back(DBuilder.createTemplateValueParameter(
           TheCU, Name, TTy, defaultParameter, V));
     } break;
     case TemplateArgument::Template: {
       std::string QualName;
       llvm::raw_string_ostream OS(QualName);
       TA.getAsTemplate().getAsTemplateDecl()->printQualifiedName(
           OS, getPrintingPolicy());
       TemplateParams.push_back(DBuilder.createTemplateTemplateParameter(
-          TheCU, Name, nullptr, OS.str()));
+          TheCU, Name, nullptr, OS.str(), defaultParameter));
       break;
     }
     case TemplateArgument::Pack:
       TemplateParams.push_back(DBuilder.createTemplateParameterPack(
           TheCU, Name, nullptr,
           CollectTemplateParams({{nullptr, TA.getPackAsArray()}}, Unit)));
       break;
     case TemplateArgument::Expression: {

clang/test/CodeGenCXX/debug-info-template-parameter.cpp

 // CHECK: [[TEMPLATE_TYPE]] = {{.*}}!DICompositeType({{.*}}, templateParams: ![[F2_TYPE:[0-9]+]]
 // CHECK: [[F2_TYPE]] = !{![[FIRST:[0-9]+]], ![[SECOND:[0-9]+]], ![[THIRD:[0-9]+]], ![[FORTH:[0-9]+]], ![[FIFTH:[0-9]+]]}
 // CHECK: [[FIRST]] = !DITemplateTypeParameter(name: "T", type: !{{[0-9]*}}, defaulted: true)
 // CHECK: [[SECOND]] = !DITemplateValueParameter(name: "i", type: !{{[0-9]*}}, defaulted: true, value: i32 3)
 // PRE17: [[THIRD]] = !DITemplateValueParameter(name: "b", type: !{{[0-9]*}}, defaulted: true, value: i8 1)
 // CXX17: [[THIRD]] = !DITemplateValueParameter(name: "b", type: !{{[0-9]*}}, defaulted: true, value: i1 true)
 // CHECK: [[FIFTH]] = !DITemplateTypeParameter(name: "d", type: !{{[0-9]*}}, defaulted: true)
 
+// CHECK: DILocalVariable(name: "b1", {{.*}}, type: ![[TEMPLATE_TYPE:[0-9]+]]
+// CHECK: [[TEMPLATE_TYPE]] = {{.*}}!DICompositeType({{.*}}, templateParams: ![[B1_TYPE:[0-9]+]]
+// CHECK: [[B1_TYPE]] = !{![[FIRST:[0-9]+]]}
+// CHECK: [[FIRST]] = !DITemplateValueParameter(tag: DW_TAG_GNU_template_template_param, name: "CT", value: !"qux")
+
+// CHECK: DILocalVariable(name: "b2", {{.*}}, type: ![[TEMPLATE_TYPE:[0-9]+]]
+// CHECK: [[TEMPLATE_TYPE]] = {{.*}}!DICompositeType({{.*}}, templateParams: ![[B2_TYPE:[0-9]+]]
+// CHECK: [[B2_TYPE]] = !{![[FIRST:[0-9]+]]}
+// CHECK: [[FIRST]] = !DITemplateValueParameter(tag: DW_TAG_GNU_template_template_param, name: "CT", defaulted: true, value: !"bar")
+
 template <typename T>
 class bar {
 };
 
+template <typename T>
+class qux {
+};
+
 template <typename T = char, int i = 3, bool b = true, int x = sizeof(T),
           typename d = bar<T>>
 class foo {
 };
 
+template <template <typename T> class CT = bar>
+class baz {
+};
+
 int main() {
   foo<int, 6, false, 3, double> f1;
   foo<> f2;
+  baz<qux> b1;
+  baz<> b2;
   return 0;
 }

llvm/include/llvm/IR/DIBuilder.h

public:
     createTemplateValueParameter(DIScope *Scope, StringRef Name, DIType *Ty,
                                  bool IsDefault, Constant *Val);
 
     /// Create debugging information for a template template parameter.
     /// \param Scope        Scope in which this type is defined.
     /// \param Name         Value parameter name.
     /// \param Ty           Parameter type.
     /// \param Val          The fully qualified name of the template.
-    DITemplateValueParameter *createTemplateTemplateParameter(DIScope *Scope,
-                                                              StringRef Name,
-                                                              DIType *Ty,
-                                                              StringRef Val);
+    /// \param IsDefault    Parameter is default or not.
+    DITemplateValueParameter *
+    createTemplateTemplateParameter(DIScope *Scope, StringRef Name, DIType *Ty,
+                                    StringRef Val, bool IsDefault);
 
     /// Create debugging information for a template parameter pack.
     /// \param Scope        Scope in which this type is defined.
     /// \param Name         Value parameter name.
     /// \param Ty           Parameter type.
     /// \param Val          An array of types in the pack.
     DITemplateValueParameter *createTemplateParameterPack(DIScope *Scope,
                                                           StringRef Name,

llvm/lib/IR/DIBuilder.cpp

DIBuilder::createTemplateValueParameter(DIScope *Context, StringRef Name,
                                         Constant *Val) {
   return createTemplateValueParameterHelper(
       VMContext, dwarf::DW_TAG_template_value_parameter, Context, Name, Ty,
       isDefault, getConstantOrNull(Val));
 }
 
 DITemplateValueParameter *
 DIBuilder::createTemplateTemplateParameter(DIScope *Context, StringRef Name,
-                                           DIType *Ty, StringRef Val) {
+                                           DIType *Ty, StringRef Val,
+                                           bool IsDefault) {
   return createTemplateValueParameterHelper(
       VMContext, dwarf::DW_TAG_GNU_template_template_param, Context, Name, Ty,
-      false, MDString::get(VMContext, Val));
+      IsDefault, MDString::get(VMContext, Val));
 }
 
 DITemplateValueParameter *
 DIBuilder::createTemplateParameterPack(DIScope *Context, StringRef Name,
                                        DIType *Ty, DINodeArray Val) {
   return createTemplateValueParameterHelper(
       VMContext, dwarf::DW_TAG_GNU_template_parameter_pack, Context, Name, Ty,
       false, Val.get());