Exploratory patch - capture DebugInfo for constexpr variables used within lambda

[mibintc]

Summary

This is an exploratory patch, an attempt to solve bugs.llvm.org/show_bug.cgi?id=47400

That bug report shows a simple test case where the constexpr variable, declared outside the scope of the lambda but used within the lambda, is simply unknown in the DebugInfo. This is different from a gcc compilation where gdb knows the symbol, and knows that the value is "optimized out".

The problem is constexpr variables like n_steps (see example in the bug report) are not captured and so do not appear in the record type. These still appear in the AST so if we gather them it is possible to emit static data member. As a proof of concept, this is prototyped here. I didn't think about exactly which variables should be gathered but this might be a framework. This is a little hacky since the constexpr variable is not really a static member of the lambda but the use is roughly correct.

[dblaikie]

I think it'd be helpful to discuss what the DWARF does and should look like in this case (I wonder if, maybe, the better solution is in the DWARF consumer - to do name lookup out through the lambda) - could you provide some summarized llvm-dwarfdump output comparisons between Clang (with/without the patch applied) and GCC's output?

[mibintc]

In D87049#2253150, @dblaikie wrote:

I think it'd be helpful to discuss what the DWARF does and should look like in this case (I wonder if, maybe, the better solution is in the DWARF consumer - to do name lookup out through the lambda) - could you provide some summarized llvm-dwarfdump output comparisons between Clang (with/without the patch applied) and GCC's output?

I attached the 3 dwarf dumps into the bugzilla report. I'm not a dwarf expert, hope someone knowledgeable can take a look and summarize.

clang/lib/CodeGen/CGDebugInfo.cpp

 #include "ConstantEmitter.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Attr.h"
 #include "clang/AST/DeclFriend.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/RecordLayout.h"
+#include "clang/AST/StmtVisitor.h"
 #include "clang/Basic/CodeGenOptions.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/Version.h"
 #include "clang/Frontend/FrontendOptions.h"
 #include "clang/Lex/HeaderSearchOptions.h"
 #include "clang/Lex/ModuleMap.h"
 #include "clang/Lex/PreprocessorOptions.h"
if (!Align)
       Align = getTypeAlignIfRequired(type, CGM.getContext());
   }
 
   llvm::DINode::DIFlags flags = getAccessFlag(AS, RD);
   return DBuilder.createMemberType(scope, name, file, line, SizeInBits, Align,
                                    offsetInBits, flags, debugType);
 }
 
+namespace {
+/// Locate the non_odr_use constant variables in a statement.
+struct NonODRUseVarFinder final : public ConstStmtVisitor<NonODRUseVarFinder> {
+  llvm::SmallSetVector<const VarDecl *, 4> NonODRUseVars;
+
+  NonODRUseVarFinder(const Stmt *S) {
+    Visit(S);
+  }
+
+  void VisitStmt(const Stmt *S) {
+    for (const Stmt *Child : S->children())
+      if (Child)
+        Visit(Child);
+  }
+
+  void VisitDeclRefExpr(const DeclRefExpr *E) {
+    if (E->isNonOdrUse() == NOUR_Constant)
+      if (const auto *VD = dyn_cast<VarDecl>(E->getDecl()))
+        NonODRUseVars.insert(VD);
+  }
+};
+} // namespace
+
 void CGDebugInfo::CollectRecordLambdaFields(
     const CXXRecordDecl *CXXDecl, SmallVectorImpl<llvm::Metadata *> &elements,
     llvm::DIType *RecordTy) {
   // For C++11 Lambdas a Field will be the same as a Capture, but the Capture
   // has the name and the location of the variable so we should iterate over
   // both concurrently.
   const ASTRecordLayout &layout = CGM.getContext().getASTRecordLayout(CXXDecl);
   RecordDecl::field_iterator Field = CXXDecl->field_begin();
if (C.capturesVariable()) {
       QualType type = f->getType();
       llvm::DIType *fieldType = createFieldType(
           "this", type, f->getLocation(), f->getAccess(),
           layout.getFieldOffset(fieldno), VUnit, RecordTy, CXXDecl);
 
       elements.push_back(fieldType);
     }
   }
+  // constexpr variables do not need to be captured, so to view them
+  // in the debugger pretend they are const static data members.
+  CXXMethodDecl *CallOp = CXXDecl->getLambdaCallOperator();
+  assert(CallOp);
+  NonODRUseVarFinder Finder(CallOp->getBody());
+  for (const auto *VD : Finder.NonODRUseVars)
+    elements.push_back(CreateRecordStaticField(VD, RecordTy, CXXDecl));
 }
 
 llvm::DIDerivedType *
 CGDebugInfo::CreateRecordStaticField(const VarDecl *Var, llvm::DIType *RecordTy,
                                      const RecordDecl *RD) {
   // Create the descriptor for the static variable, with or without
   // constant initializers.
   Var = Var->getCanonicalDecl();