[DebugInfo] Check for templated static data member when adding constant to record static fields

[akhuang]

Summary

Debug info for inline static data members was missing the constant value,
because the initializer for these static data members is not always emitted.

Now also try to get the initializer from the templated static data member if
the variable doesn't have an initializer.

(related to discussion on https://bugs.llvm.org/show_bug.cgi?id=47580)

[dblaikie]

clang/lib/CodeGen/CGDebugInfo.cpp

1421–1425

I'd suspect this might not be the most general solution - because it's retrieving the value from the original template static member. Two issues come to mind:

1. If the initialization is dependent or otherwise not knowable at compile-time, does this code at least not crash (I assume "evaluateValue" returns nullptr if the value can't be evaluated for whatever reason)
2. If the initialization is dependent, it might still be knowable, eg:

template<typename T>
struct static_decl_templ {
  static constexpr int static_constexpr_decl_templ_var = sizeof(T);
};

I'm guessing this patch as-is doesn't provide a value in this case, but it should be achievable, I would guess/hope/imagine - but don't really know exactly how to do that off-hand. (@zygoloid would know - but maybe a bit of looking around will find it if/before he has a chance to weigh in here)

clang/test/CodeGenCXX/debug-info-static-member.cpp

140–144

I guess the non-11 version of this variable is intended as a stub to make the test across different language levels simpler?

I think it might be better to make that more explicit - rather than having a variable with "constexpr" in the name that isn't actually constexpr. I'd say only add the variable under that macro condition - but change the test to use multiple --check-prefixes, and the check for this variable to use a CPP11 prefix or something like that.

Hmm, I'm slightly confused now that I Think about it - it looks like the macro is about testing if the version is >= 11. But the change also adds a test for C++17? Is C++17 likely to be any different than C++11 for any of this? (or C++20 for that matter) if it's not any different, I'd probably leave the 17 case out & expect the 11 case is sufficient coverage.

[saudi]

clang/lib/CodeGen/CGDebugInfo.cpp

1420

I encountered an assert inside evaluateValue() call :
assert(!Init->isValueDependent());

repro code:

template <int VAL> class A {
 static constexpr int dep = VAL;
};
A<10> a;

Note that it crashed with static constexp member but not with static const.

[saudi]

clang/lib/CodeGen/CGDebugInfo.cpp

1420

Sorry, I got the wrong line for this comment.
This was actually the case 1. from @dblaikie 's comment for the TemplateDecl evaluation.

[akhuang]

clang/lib/CodeGen/CGDebugInfo.cpp

1421–1425

@rsmith

Actually, can we just instantiate the initializer for static constexpr data members?

currently it delays creating the initializer for inline static data members; can we not do that if it's a constexpr?

clang/test/CodeGenCXX/debug-info-static-member.cpp

140–144

Yeah, it was intended as a stub, but I can remove that part.

I added c++17 because it appears that in c++17 (and for MS targets) we make constexpr data members implicitly inline, which is why the initializer is not being instantiated.

[akhuang]

update test case and add check for dependent values

clang/lib/CodeGen/CGDebugInfo.cpp

CGDebugInfo::CreateRecordStaticField(const VarDecl *Var, llvm::DIType *RecordTy,
   // constant initializers.
   Var = Var->getCanonicalDecl();
   llvm::DIFile *VUnit = getOrCreateFile(Var->getLocation());
   llvm::DIType *VTy = getOrCreateType(Var->getType(), VUnit);
 
   unsigned LineNumber = getLineNumber(Var->getLocation());
   StringRef VName = Var->getName();
   llvm::Constant *C = nullptr;
-  if (Var->getInit()) {
-    const APValue *Value = Var->evaluateValue();
-    if (Value) {
-      if (Value->isInt())
-        C = llvm::ConstantInt::get(CGM.getLLVMContext(), Value->getInt());
-      if (Value->isFloat())
-        C = llvm::ConstantFP::get(CGM.getLLVMContext(), Value->getFloat());
-    }
-  }
+  APValue *Value = nullptr;
+  if (Var->getInit())
+    Value = Var->evaluateValue();
+  else if (auto *TemplateDecl = Var->getInstantiatedFromStaticDataMember()) {
+    // Inline static data members might not have an initialization.
+    // FIXME: Still doesn't get a value if the initialization is dependent.
+    auto *TemplateInit = TemplateDecl->getInit();
+    if (TemplateInit && !TemplateInit->isValueDependent())
+      Value = TemplateDecl->evaluateValue();
+  }
+
 
   llvm::DINode::DIFlags Flags = getAccessFlag(Var->getAccess(), RD);
   auto Align = getDeclAlignIfRequired(Var, CGM.getContext());
   llvm::DIDerivedType *GV = DBuilder.createStaticMemberType(
       RecordTy, VName, VUnit, LineNumber, VTy, Flags, C, Align);
   StaticDataMemberCache[Var->getCanonicalDecl()].reset(GV);
   return GV;
 }

clang/test/CodeGenCXX/debug-info-static-member.cpp

 // RUN: %clangxx -target x86_64-unknown-unknown -g %s -emit-llvm -S -o - | FileCheck %s
 // RUN: %clangxx -target x86_64-unknown-unknown -g -std=c++98 %s -emit-llvm -S -o - | FileCheck %s
 // RUN: %clangxx -target x86_64-unknown-unknown -g -std=c++11 %s -emit-llvm -S -o - | FileCheck %s
+// RUN: %clangxx -target x86_64-unknown-unknown -g -std=c++17 %s -emit-llvm -S -o - | FileCheck %s --check-prefix=CXX17
 // RUN: %clang_cc1 -triple x86_64-windows-msvc -gcodeview -debug-info-kind=limited %s -emit-llvm -o - | FileCheck --check-prefix MSVC %s
 // PR14471
 
 // CHECK: @_ZN1C1aE = dso_local global i32 4, align 4, !dbg [[A:![0-9]+]]
 // CHECK: @_ZN1C1bE = dso_local global i32 2, align 4, !dbg [[B:![0-9]+]]
 // CHECK: @_ZN1C1cE = dso_local global i32 1, align 4, !dbg [[C:![0-9]+]]
 
 enum X {

 //
 // CHECK: !DICompositeType(tag: DW_TAG_enumeration_type, name: "X"{{.*}}, identifier: "_ZTS1X")
 // CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "anon_static_decl_struct"
 // CHECK: !DIDerivedType(tag: DW_TAG_member, name: "anon_static_decl_var"
 // CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "static_decl_templ<int>"
 // CHECK-NOT:              DIFlagFwdDecl
 // CHECK-SAME:             ){{$}}
 // CHECK: !DIDerivedType(tag: DW_TAG_member, name: "static_decl_templ_var"
+// CHECK-SAME:           extraData: i32 7
+// CXX17: !DIDerivedType(tag: DW_TAG_member, name: "static_constexpr_decl_templ_var"
+// CXX17-SAME:           extraData: i32 8
 
 int C::a = 4;
 // CHECK: [[B]] = !DIGlobalVariableExpression(var: [[BV:.*]], expr: !DIExpression())
 // CHECK: [[BV]] = distinct !DIGlobalVariable(name: "b",
 // CHECK-SAME:                                declaration: ![[DECL_B:[0-9]+]])
 // MSVC: distinct !DIGlobalVariable(name: "b"
 // CHECK: ![[DECL_B]] = !DIDerivedType(tag: DW_TAG_member, name: "b"
 // CHECK-NOT:                                 size:

 // MSVC: [[ANON_STATIC_DECL]] = distinct !DIGlobalVariable(name: "anon_static_decl_var"
 // MSVC: !DIGlobalVariableExpression(var: [[STATIC_DECL_TEMPL:![0-9]+]]
 // MSVC-SAME: !DIExpression(DW_OP_constu, 7, DW_OP_stack_value)
 // MSVC: [[STATIC_DECL_TEMPL]] = distinct !DIGlobalVariable(name: "static_decl_templ_var"
 
 template<typename T>
 struct static_decl_templ {
   static const int static_decl_templ_var = 7;
+#if __cplusplus >= 201703L
+  static constexpr int static_constexpr_decl_templ_var = 8;
+#endif
 };
 
 template<typename T>
 const int static_decl_templ<T>::static_decl_templ_var;
 
 int static_decl_templ_ref() {
   return static_decl_templ<int>::static_decl_templ_var;
 }
 
 // Verify that even when a static member declaration is created lazily when