[clang][DebugInfo] Simplify logic to determine DW_AT_default_value for template parameters

[Michael137]

Summary

DWARFv5 added support for labelling template parameters with
DW_AT_default_value to indicate whether the particular instantiation
defaulted parameter. The current implementation only supports a limited
set of possible cases. Namely for non-value-dependent integral template
parameters and simple type template parameters.

Useful cases that don't work are:

1. Type template parameters with defaults that are

themselves templates. E.g.,

template<typename T1, typename T2 = Foo<T1>> class C1;
template<typename T = Foo<int>> class C2;
etc.

2. Template template parameters

clang::isSubstitutedDefaultArgument already implement the required logic
to determine whether a template argument is defaulted. This patch re-uses
this logic for DWARF CodeGen.

[aprantl]

That looks nicer than the old code.

[dblaikie]

Partly feedback on D139989 too - if we could move this logic outside the switch, then it wouldn't need to be done in each different template parameter type? (& then D139989 I guess wouldn't be needed - this patch and the other would be subsumed by removing the old logic from distinct switch cases, and putting the new logic that works across different template parameter kinds outside the switch - solving things more generically)

[Michael137]

• Hoist common code out of switch

[dblaikie]

Looks good to me, thanks!

Patch description might need a tweak, this bit:

Type template parameters where the type is itself a template instantiation (e.g., template<typename T = Foo<T>>)

The quoted example is impossible (infinitely recursive) & the description might be less specific than necessary - is any template instantiation a problem (eg: template<typename T = Foo<int>) for the existing code/addressed by this patch, or only defaults that are instantiated with a prior template parameter in the same template parameter list? If it's the latter, would be good to include that nuance, if it's the former might be worth clarifying that/using some Foo<int> in the example insetad of Foo<T>

[Michael137]

In D139988#3999115, @dblaikie wrote:

Looks good to me, thanks!

Patch description might need a tweak, this bit:

Type template parameters where the type is itself a template instantiation (e.g., template<typename T = Foo<T>>)

The quoted example is impossible (infinitely recursive) & the description might be less specific than necessary - is any template instantiation a problem (eg: template<typename T = Foo<int>) for the existing code/addressed by this patch, or only defaults that are instantiated with a prior template parameter in the same template parameter list? If it's the latter, would be good to include that nuance, if it's the former might be worth clarifying that/using some Foo<int> in the example insetad of Foo<T>

Whoops good catch. What I meant to say is template<typename T1, typename T2 = Foo<T1>>. Will update the commit message

[Michael137]

• Rebase

[Michael137]

• Remove now redundant header

clang/lib/CodeGen/CGDebugInfo.cpp

CGDebugInfo::CollectTemplateParams(Optional<TemplateArgs> OArgs,
   if (!OArgs)
     return llvm::DINodeArray();
   TemplateArgs &Args = *OArgs;
   SmallVector<llvm::Metadata *, 16> TemplateParams;
   for (unsigned i = 0, e = Args.Args.size(); i != e; ++i) {
     const TemplateArgument &TA = Args.Args[i];
     StringRef Name;
     bool defaultParameter = false;
-    if (Args.TList)
+    if (Args.TList) {
       Name = Args.TList->getParam(i)->getName();
+
+      NamedDecl const *ND = Args.TList->getParam(i);
+      defaultParameter = clang::isSubstitutedDefaultArgument(
+          CGM.getContext(), TA, ND, Args.Args, Args.TList->getDepth());
+    }
+
     switch (TA.getKind()) {
     case TemplateArgument::Type: {
       llvm::DIType *TTy = getOrCreateType(TA.getAsType(), Unit);
-
-      if (Args.TList)
-        if (auto *templateType =
-                dyn_cast_or_null<TemplateTypeParmDecl>(Args.TList->getParam(i)))
-          if (templateType->hasDefaultArgument())
-            defaultParameter =
-                templateType->getDefaultArgument() == TA.getAsType();
-
       TemplateParams.push_back(DBuilder.createTemplateTypeParameter(
           TheCU, Name, TTy, defaultParameter));
 
     } break;
     case TemplateArgument::Integral: {
       llvm::DIType *TTy = getOrCreateType(TA.getIntegralType(), Unit);
-      if (Args.TList)
-        if (auto *templateType = dyn_cast_or_null<NonTypeTemplateParmDecl>(
-                Args.TList->getParam(i)))
-          if (templateType->hasDefaultArgument() &&
-              !templateType->getDefaultArgument()->isValueDependent())
-            defaultParameter = llvm::APSInt::isSameValue(
-                templateType->getDefaultArgument()->EvaluateKnownConstInt(
-                    CGM.getContext()),
-                TA.getAsIntegral());
-
       TemplateParams.push_back(DBuilder.createTemplateValueParameter(
           TheCU, Name, TTy, defaultParameter,
           llvm::ConstantInt::get(CGM.getLLVMContext(), TA.getAsIntegral())));
     } break;
     case TemplateArgument::Declaration: {
       const ValueDecl *D = TA.getAsDecl();
       QualType T = TA.getParamTypeForDecl().getDesugaredType(CGM.getContext());
       llvm::DIType *TTy = getOrCreateType(T, Unit);

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

 // Test for DebugInfo for Defaulted parameters for C++ templates
 // Supported: -O0, standalone DI
 
 // RUN: %clang_cc1 -emit-llvm %std_cxx11-14 -dwarf-version=5 -triple x86_64 %s -O0 -disable-llvm-passes -debug-info-kind=standalone -o - | FileCheck %s --check-prefixes=CHECK,PRE17
 // RUN: %clang_cc1 -emit-llvm %std_cxx17- -dwarf-version=5 -triple x86_64 %s -O0 -disable-llvm-passes -debug-info-kind=standalone -o - | FileCheck %s --check-prefixes=CHECK,CXX17
 // RUN: %clang_cc1 -emit-llvm %std_cxx17- -dwarf-version=4 -triple x86_64 %s -O0 -disable-llvm-passes -debug-info-kind=standalone -o - | FileCheck %s --check-prefixes=CHECK,CXX17
 
 // CHECK: DILocalVariable(name: "f1", {{.*}}, type: ![[TEMPLATE_TYPE:[0-9]+]]
 // CHECK: [[TEMPLATE_TYPE]] = {{.*}}!DICompositeType({{.*}}, templateParams: ![[F1_TYPE:[0-9]+]]
-// CHECK: [[F1_TYPE]] = !{![[FIRST:[0-9]+]], ![[SECOND:[0-9]+]], ![[THIRD:[0-9]+]], ![[FORTH:[0-9]+]]}
+// CHECK: [[F1_TYPE]] = !{![[FIRST:[0-9]+]], ![[SECOND:[0-9]+]], ![[THIRD:[0-9]+]], ![[FORTH:[0-9]+]], ![[FIFTH:[0-9]+]]}
 // CHECK: [[FIRST]] = !DITemplateTypeParameter(name: "T", type: !{{[0-9]*}})
 // CHECK: [[SECOND]] = !DITemplateValueParameter(name: "i", type: !{{[0-9]*}}, value: i32 6)
 // PRE17: [[THIRD]] = !DITemplateValueParameter(name: "b", type: !{{[0-9]*}}, value: i8 0)
 // CXX17: [[THIRD]] = !DITemplateValueParameter(name: "b", type: !{{[0-9]*}}, value: i1 false)
+// CHECK: [[FIFTH]] = !DITemplateTypeParameter(name: "d", type: !{{[0-9]*}})
 
 // CHECK: DILocalVariable(name: "f2", {{.*}}, type: ![[TEMPLATE_TYPE:[0-9]+]]
 // CHECK: [[TEMPLATE_TYPE]] = {{.*}}!DICompositeType({{.*}}, templateParams: ![[F2_TYPE:[0-9]+]]
-// CHECK: [[F2_TYPE]] = !{![[FIRST:[0-9]+]], ![[SECOND:[0-9]+]], ![[THIRD:[0-9]+]], ![[FORTH:[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)
 
-template <typename T = char, int i = 3, bool b = true, int x = sizeof(T)>
+template <typename T>
+class bar {
+};
+
+template <typename T = char, int i = 3, bool b = true, int x = sizeof(T),
+          typename d = bar<T>>
 class foo {
 };
 
 int main() {
-  foo<int, 6, false, 3> f1;
+  foo<int, 6, false, 3, double> f1;
   foo<> f2;
   return 0;
 }