[DebugInfo] Add symbol for debugger with VTable information.

One of the points mentioned by the reviewers is the
usage (pros and cons) of the global variable that
contains the vtable information:

- The consumer needs to have access to that variable
  in order to get the vtable information.

This patch eliminates that global variable and it
moves the vtable information into the static member;
in that way, a consumer always will have access to
the vtable information, just by having an object
instance or the object definition.

Author: CarlosAlbertoEnciso

clang/lib/CodeGen/CGDebugInfo.cpp

@@ -2545,25 +2545,27 @@ void CGDebugInfo::emitVTableSymbol(llvm::GlobalVariable *VTable,
   llvm::DIScope *DContext = getContextDescriptor(cast<Decl>(DC), TheCU);
   auto *Ctxt = cast<llvm::DICompositeType>(DContext);
   llvm::DIFile *Unit = getOrCreateFile(Loc);
-  llvm::DIType *VTy = getOrCreateType(VoidPtr, Unit);
+  llvm::DIType *VTableType = getOrCreateType(VoidPtr, Unit);
   llvm::DINode::DIFlags Flags = getAccessFlag(AccessSpecifier::AS_private, RD) |
                                 llvm::DINode::FlagArtificial;
   auto Tag = CGM.getCodeGenOpts().DwarfVersion >= 5
                  ? llvm::dwarf::DW_TAG_variable
                  : llvm::dwarf::DW_TAG_member;
   llvm::DIDerivedType *DT = DBuilder.createStaticMemberType(
-      Ctxt, SymbolName, Unit, /*LineNumber=*/0, VTy, Flags,
+      Ctxt, SymbolName, Unit, /*LineNumber=*/0, VTableType, Flags,
       /*Val=*/nullptr, Tag);
 
   // Use the same vtable pointer to global alignment for the symbol.
   unsigned PAlign = CGM.getGlobalVarAlignment();
 
   // The global variable is in the CU scope, and links back to the type it's
   // "within" via the declaration field.
+  // No debug information is created for it. It is just used to generate the
+  // debug information within the static data member.
   llvm::DIGlobalVariableExpression *GVE =
       DBuilder.createGlobalVariableExpression(
-          TheCU, SymbolName, VTable->getName(), Unit, /*LineNo=*/0,
-          getOrCreateType(VoidPtr, Unit), VTable->hasLocalLinkage(),
+          TheCU, SymbolName, VTable->getName(), Unit, /*LineNo=*/0, VTableType,
+          VTable->hasLocalLinkage(),
           /*isDefined=*/true, nullptr, DT, /*TemplateParameters=*/nullptr,
           PAlign);
   VTable->addDebugInfo(GVE);

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

@@ -175,6 +175,72 @@ unsigned DwarfCompileUnit::getOrCreateSourceID(const DIFile *File) {
   return LastFileID;
 }
 
+// Create the static member to hold the vtable information.
+// The debug information generated for static members is composed of 2 DIEs:
+// <DIE-1> and <DIE-2>.
+//
+// - Variable definition with a DW_AT_specification pointing to the second DIE.
+//     DIE-1: DW_TAG_variable
+//              ..
+//              DW_AT_specification <DIE-2>
+//              DW_AT_location <some-location>
+//              ..
+// - Parent for the static member.
+//     DIE-3: DW_TAG_structure_type
+//              ...
+// - Variable declaration
+//     DIE-2:   DW_TAG_variable
+//                ..
+//                DW_AT_declaration (true)
+//                ..
+//
+// As this static member is mainly intended for debuggers, there are cases
+// where there is no access to <DIE-1> making difficult to associate the
+// vtable information with its structure/class, as we can't use <DIE-2> to
+// find its parent <DIE-3>.
+// Basically, having just an instance of a structure/class, we can't access
+// its associated vtable information.
+//
+// By eliminating the <DIE-1> and moving the location information to <DIE-2>,
+// the consumers, will be able to associate the vtable information to the
+// parent <DIE-3>, using just an object or an object instance.
+//
+//     DIE-3: DW_TAG_structure_type
+//              ...
+//     DIE-2:   DW_TAG_variable
+//                ..
+//                DW_AT_location <some-location>
+void DwarfCompileUnit::createGlobalVariableVTableDIE(
+    const DIGlobalVariable *GV, ArrayRef<GlobalExpr> GlobalExprs) {
+  // Check for pre-existence.
+  if (getDIE(GV))
+    return;
+
+  assert(GV);
+  assert(GV->isDefinition());
+
+  DIDerivedType *SDMDecl = GV->getStaticDataMemberDeclaration();
+  assert(SDMDecl && "Expected static member decl");
+  assert(SDMDecl->isStaticMember() && "Expected static member decl");
+
+  // We need the declaration DIE that is in the static member's class.
+  // As some debuggers will usually ignore DIEs with the DW_AT_declaration
+  // attribute and assume that they'll be a specification DIE somewhere
+  // else that refers to it. Skip the DW_AT_declaration generation.
+  DIE *VariableSpecDIE =
+      getOrCreateStaticMemberDIE(SDMDecl, /*IsDeclaration*/false);
+
+  if (uint32_t AlignInBytes = GV->getAlignInBytes())
+    addUInt(*VariableSpecDIE, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
+            AlignInBytes);
+
+  if (MDTuple *TP = GV->getTemplateParams())
+    addTemplateParams(*VariableSpecDIE, DINodeArray(TP));
+
+  // Add location.
+  addLocationAttribute(VariableSpecDIE, GV, GlobalExprs);
+}
+
 DIE *DwarfCompileUnit::getOrCreateGlobalVariableDIE(
     const DIGlobalVariable *GV, ArrayRef<GlobalExpr> GlobalExprs) {
   // Check for pre-existence.

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.h

@@ -178,6 +178,10 @@ class DwarfCompileUnit final : public DwarfUnit {
 
   std::vector<BaseTypeRef> ExprRefedBaseTypes;
 
+  /// Create global variable DIE for VTable.
+  void createGlobalVariableVTableDIE(const DIGlobalVariable *GV,
+                                     ArrayRef<GlobalExpr> GlobalExprs);
+
   /// Get or create global variable DIE.
   DIE *
   getOrCreateGlobalVariableDIE(const DIGlobalVariable *GV,

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

@@ -1212,7 +1212,11 @@ void DwarfDebug::beginModule(Module *M) {
     for (auto *GVE : CUNode->getGlobalVariables()) {
       DIGlobalVariable *GV = GVE->getVariable();
       if (Processed.insert(GV).second)
-        CU.getOrCreateGlobalVariableDIE(GV, sortGlobalExprs(GVMap[GV]));
+        // Check if we are dealing with a variable representing a vtable.
+        if (GV->getDisplayName() == "_vtable$" && GV->isDefinition())
+          CU.createGlobalVariableVTableDIE(GV, sortGlobalExprs(GVMap[GV]));
+        else
+          CU.getOrCreateGlobalVariableDIE(GV, sortGlobalExprs(GVMap[GV]));
     }
 
     for (auto *Ty : CUNode->getEnumTypes())

llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp

@@ -1843,7 +1843,8 @@ DIE &DwarfUnit::constructMemberDIE(DIE &Buffer, const DIDerivedType *DT) {
   return MemberDie;
 }
 
-DIE *DwarfUnit::getOrCreateStaticMemberDIE(const DIDerivedType *DT) {
+DIE *DwarfUnit::getOrCreateStaticMemberDIE(const DIDerivedType *DT,
+                                           bool IsDeclaration) {
   if (!DT)
     return nullptr;
 
@@ -1864,7 +1865,8 @@ DIE *DwarfUnit::getOrCreateStaticMemberDIE(const DIDerivedType *DT) {
   addType(StaticMemberDIE, Ty);
   addSourceLine(StaticMemberDIE, DT);
   addFlag(StaticMemberDIE, dwarf::DW_AT_external);
-  addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
+  if (IsDeclaration)
+    addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
 
   // Consider the case when the static member was created by the compiler.
   if (DT->isArtificial())

llvm/lib/CodeGen/AsmPrinter/DwarfUnit.h

@@ -328,7 +328,8 @@ class DwarfUnit : public DIEUnit {
   ~DwarfUnit();
 
   /// Create new static data member DIE.
-  DIE *getOrCreateStaticMemberDIE(const DIDerivedType *DT);
+  DIE *getOrCreateStaticMemberDIE(const DIDerivedType *DT,
+                                  bool IsDeclaration = true);
 
   /// Look up the source ID for the given file. If none currently exists,
   /// create a new ID and insert it in the line table.

llvm/test/DebugInfo/X86/vtable-debug-info-inheritance-simple.ll

@@ -172,35 +172,30 @@ attributes #0 = { mustprogress noinline norecurse nounwind uwtable "frame-pointe
 
 ; CHECK:     .debug_info contents:
 ; CHECK-NEXT: 0x00000000:     Compile Unit:
-; CHECK: {{.*}}DW_TAG_variable
-; CHECK-NEXT: DW_AT_specification ([[VARDIE_1:.+]] "_vtable$")
-; CHECK-NEXT: DW_AT_alignment	(8)
-; CHECK-NEXT: DW_AT_location (DW_OP_addrx 0x0)
-; CHECK-NEXT: DW_AT_linkage_name ("_ZTVN3NSP5CBaseE")
 
 ; CHECK: {{.*}}DW_TAG_namespace
 ; CHECK-NEXT: DW_AT_name ("NSP")
 
 ; CHECK: {{.*}}DW_TAG_structure_type
 ; CHECK: DW_AT_name	("CBase")
 
-; CHECK: [[VARDIE_1]]: DW_TAG_variable
+; CHECK: DW_TAG_variable
 ; CHECK-NEXT: DW_AT_name ("_vtable$")
 ; CHECK-NEXT: DW_AT_type ({{.*}} "void *")
 ; CHECK: DW_AT_artificial	(true)
 ; CHECK-NEXT: DW_AT_accessibility	(DW_ACCESS_private)
-
-; CHECK: {{.*}}DW_TAG_variable
-; CHECK-NEXT: DW_AT_specification ([[VARDIE_2:.+]] "_vtable$")
 ; CHECK-NEXT: DW_AT_alignment	(8)
-; CHECK-NEXT: DW_AT_location (DW_OP_addrx 0x1)
-; CHECK-NEXT: DW_AT_linkage_name ("_ZTV8CDerived")
+; CHECK-NEXT: DW_AT_location (DW_OP_addrx 0x0)
+; CHECK-NEXT: DW_AT_linkage_name ("_ZTVN3NSP5CBaseE")
 
 ; CHECK: {{.*}}DW_TAG_structure_type
 ; CHECK: DW_AT_name	("CDerived")
 
-; CHECK: [[VARDIE_2]]: DW_TAG_variable
+; CHECK: DW_TAG_variable
 ; CHECK-NEXT: DW_AT_name ("_vtable$")
 ; CHECK-NEXT: DW_AT_type ({{.*}} "void *")
 ; CHECK: DW_AT_artificial	(true)
 ; CHECK-NEXT: DW_AT_accessibility	(DW_ACCESS_private)
+; CHECK-NEXT: DW_AT_alignment	(8)
+; CHECK-NEXT: DW_AT_location (DW_OP_addrx 0x1)
+; CHECK-NEXT: DW_AT_linkage_name ("_ZTV8CDerived")