[DebugInfo][DwarfDebug][CodeView] Allow DISubprogram to be attached to multiple Functions

Depends on:
* #152680
* #162852

In #75385 (and the following
tries), an attempt was made, to support attaching local types to
DILocalScopes, and to store function local types in DISubprogram's
`retainedNodes:` field.

That patch failed to land due to issues arising during LTO process.
If two definition DISubprograms from different compile units
represent, essentially, the same source code function, and have
common local DICompositeType, and if this DICompositeType is uniqued
(due to ODRUniquingDebugTypes feature), the subprograms end up
having wrong retainedNodes list/scoping relationship.

To tackle this issue, in
#142166, it was proposed
to force-unique all DISubporgrams even if they don't contain odr-uniqued types
(#142166 (comment)).
It should establish one-to-one-to-many relationship between
DISubprograms, abstract DIEs and function clones (from different CUs, in
case of LTO).

To implement that, AsmPrinter should support correct emission of debug info
for DISubprograms attached to multiple functions. This is the goal of
this commit.

Here, LexicalScope's function map is changed to multimap between
DISubprogram and (possible multiple) functions attached to it.
LexicalScope is modified to create an abstract scope for a DISubprogram
having multiple lllvm::Function attachments.
`DwarfCompileUnit::getOrCreateSubprogramDIE` can recognize the case of
DISubprogram attached to multiple Functions, and return abstract DIE
when needed.

CodeViewDebug is adopted as well. UDTs are ensured to be emmited properly in
the cases that are addressed here. Please let me know if more changes
to CodeView needed, as I'm not very familiar with the format.

Author: dzhidzhoev

llvm/include/llvm/CodeGen/LexicalScopes.h

@@ -199,12 +199,18 @@ class LexicalScopes {
     return I != LexicalScopeMap.end() ? &I->second : nullptr;
   }
 
+  bool currentFunctionHasInlinedScopes() {
+    return !InlinedLexicalScopeMap.empty();
+  }
+
   /// Find or create an abstract lexical scope.
   LLVM_ABI LexicalScope *getOrCreateAbstractScope(const DILocalScope *Scope);
 
-  /// Get function to which the given subprogram is attached, if exists.
-  const Function *getFunction(const DISubprogram *SP) const {
-    return FunctionMap.lookup(SP);
+  /// Get functions to which the given subprogram is attached.
+  const SmallPtrSet<const Function *, 1> *
+  getFunctions(const DISubprogram *SP) const {
+    auto I = FunctionMap.find(SP);
+    return I == FunctionMap.end() ? nullptr : &I->second;
   }
 
 private:
@@ -218,6 +224,15 @@ class LexicalScopes {
               : nullptr;
   }
 
+  /// Create abstract lexical scope for local scopes used by multiple
+  /// functions, if needed.
+  void ensureAbstractLexicalScopeIsCreated(const DILocalScope *Scope) {
+    const DISubprogram *SP = Scope->getSubprogram();
+    const auto *Fns = getFunctions(SP);
+    if (!Fns || Fns->size() != 1)
+      getOrCreateAbstractScope(Scope);
+  }
+
   /// Find or create a regular lexical scope.
   LexicalScope *getOrCreateRegularScope(const DILocalScope *Scope);
 
@@ -237,7 +252,7 @@ class LexicalScopes {
   const MachineFunction *MF = nullptr;
 
   /// Mapping between DISubprograms and IR functions.
-  DenseMap<const DISubprogram *, const Function *> FunctionMap;
+  DenseMap<const DISubprogram *, SmallPtrSet<const Function *, 1>> FunctionMap;
 
   /// Tracks the scopes in the current function.
   // Use an unordered_map to ensure value pointer validity over insertion.

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

@@ -1658,9 +1658,9 @@ void CodeViewDebug::addToUDTs(const DIType *Ty) {
       formatNestedName(ParentScopeNames, getPrettyScopeName(Ty));
 
   if (ClosestSubprogram == nullptr) {
-    GlobalUDTs.emplace_back(std::move(FullyQualifiedName), Ty);
+    GlobalUDTs[Ty] = std::move(FullyQualifiedName);
   } else if (ClosestSubprogram == CurrentSubprogram) {
-    LocalUDTs.emplace_back(std::move(FullyQualifiedName), Ty);
+    LocalUDTs[Ty] = std::move(FullyQualifiedName);
   }
 
   // TODO: What if the ClosestSubprogram is neither null or the current
@@ -2698,6 +2698,12 @@ TypeIndex CodeViewDebug::getTypeIndex(const DIType *Ty, const DIType *ClassTy) {
   if (!Ty)
     return TypeIndex::Void();
 
+  if (Ty->getTag() == dwarf::DW_TAG_typedef) {
+    // Ensure that UDT is added even if the (local) type has been translated
+    // during processing of the previous function.
+    addToUDTs(Ty);
+  }
+
   // Check if we've already translated this type. Don't try to do a
   // get-or-create style insertion that caches the hash lookup across the
   // lowerType call. It will update the TypeIndices map.
@@ -2787,6 +2793,10 @@ TypeIndex CodeViewDebug::getCompleteTypeIndex(const DIType *Ty) {
       return FwdDeclTI;
   }
 
+  // Ensure that UDT is added even if the (local) type has been translated
+  // during processing of the previous function.
+  addToUDTs(CTy);
+
   // Check if we've already translated the complete record type.
   // Insert the type with a null TypeIndex to signify that the type is currently
   // being lowered.
@@ -3217,20 +3227,19 @@ void CodeViewDebug::emitEndSymbolRecord(SymbolKind EndKind) {
   OS.emitInt16(uint16_t(EndKind)); // Record Kind
 }
 
-void CodeViewDebug::emitDebugInfoForUDTs(
-    const std::vector<std::pair<std::string, const DIType *>> &UDTs) {
+template <typename Range>
+void CodeViewDebug::emitDebugInfoForUDTs(Range &&UDTs) {
 #ifndef NDEBUG
   size_t OriginalSize = UDTs.size();
 #endif
-  for (const auto &UDT : UDTs) {
-    const DIType *T = UDT.second;
+  for (const auto &[T, Name] : UDTs) {
     assert(shouldEmitUdt(T));
     MCSymbol *UDTRecordEnd = beginSymbolRecord(SymbolKind::S_UDT);
     OS.AddComment("Type");
     OS.emitInt32(getCompleteTypeIndex(T).getIndex());
     assert(OriginalSize == UDTs.size() &&
            "getCompleteTypeIndex found new UDTs!");
-    emitNullTerminatedSymbolName(OS, UDT.first);
+    emitNullTerminatedSymbolName(OS, Name);
     endSymbolRecord(UDTRecordEnd);
   }
 }

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.h

@@ -306,8 +306,8 @@ class LLVM_LIBRARY_VISIBILITY CodeViewDebug : public DebugHandlerBase {
 
   // The UDTs we have seen while processing types; each entry is a pair of type
   // index and type name.
-  std::vector<std::pair<std::string, const DIType *>> LocalUDTs;
-  std::vector<std::pair<std::string, const DIType *>> GlobalUDTs;
+  MapVector<const DIType *, std::string> LocalUDTs;
+  MapVector<const DIType *, std::string> GlobalUDTs;
 
   using FileToFilepathMapTy = std::map<const DIFile *, std::string>;
   FileToFilepathMapTy FileToFilepathMap;
@@ -352,8 +352,7 @@ class LLVM_LIBRARY_VISIBILITY CodeViewDebug : public DebugHandlerBase {
 
   void emitDebugInfoForRetainedTypes();
 
-  void emitDebugInfoForUDTs(
-      const std::vector<std::pair<std::string, const DIType *>> &UDTs);
+  template <typename Range> void emitDebugInfoForUDTs(Range &&UDTs);
 
   void collectDebugInfoForGlobals();
   void emitDebugInfoForGlobals();

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

@@ -1839,14 +1839,16 @@ DIE *DwarfCompileUnit::getOrCreateSubprogramDIE(const DISubprogram *SP,
                                                 const Function *F,
                                                 bool Minimal) {
   if (!F && SP->isDefinition()) {
-    F = DD->getLexicalScopes().getFunction(SP);
+    const auto *Fs = DD->getLexicalScopes().getFunctions(SP);
 
-    if (!F) {
+    if (!Fs || Fs->size() != 1) {
       // SP may belong to another CU. Determine the CU similarly
       // to DwarfDebug::constructAbstractSubprogramScopeDIE.
       return &DD->getOrCreateAbstractSubprogramCU(SP, *this)
                   .getOrCreateAbstractSubprogramDIE(SP);
     }
+
+    F = *Fs->begin();
   }
 
   return DwarfUnit::getOrCreateSubprogramDIE(SP, F, Minimal);

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

@@ -2750,7 +2750,7 @@ void DwarfDebug::endFunctionImpl(const MachineFunction *MF) {
   // is still needed as we need its source location.
   if (!TheCU.getCUNode()->getDebugInfoForProfiling() &&
       TheCU.getCUNode()->getEmissionKind() == DICompileUnit::LineTablesOnly &&
-      LScopes.getAbstractScopesList().empty() && !IsDarwin) {
+      !LScopes.currentFunctionHasInlinedScopes() && !IsDarwin) {
     for (const auto &R : Asm->MBBSectionRanges)
       addArangeLabel(SymbolCU(&TheCU, R.second.BeginLabel));
 
@@ -2791,7 +2791,7 @@ void DwarfDebug::endFunctionImpl(const MachineFunction *MF) {
   DIE &ScopeDIE =
       TheCU.constructSubprogramScopeDIE(SP, F, FnScope, FunctionLineTableLabel);
   if (auto *SkelCU = TheCU.getSkeleton())
-    if (!LScopes.getAbstractScopesList().empty() &&
+    if (LScopes.currentFunctionHasInlinedScopes() &&
         TheCU.getCUNode()->getSplitDebugInlining())
       SkelCU->constructSubprogramScopeDIE(SP, F, FnScope,
                                           FunctionLineTableLabel);

llvm/lib/CodeGen/LexicalScopes.cpp

@@ -61,19 +61,28 @@ void LexicalScopes::initialize(const Module &M) {
   for (const Function &F : M) {
     DISubprogram *SP = F.getSubprogram();
     if (SP && (!SP->getUnit() || !skipUnit(SP->getUnit())))
-      FunctionMap[SP] = &F;
+      FunctionMap[SP].insert(&F);
   }
 }
 
 void LexicalScopes::scanFunction(const MachineFunction &Fn) {
   resetFunction();
   // Don't attempt any lexical scope creation for a NoDebug compile unit.
-  if (skipUnit(Fn.getFunction().getSubprogram()->getUnit()))
+  const Function &IRFunc = Fn.getFunction();
+  const DISubprogram *SP = IRFunc.getSubprogram();
+  if (skipUnit(SP->getUnit()))
     return;
+
+  // A new subprogram may be created during Codegen after module scan.
+  FunctionMap[SP].insert(&IRFunc);
+
   MF = &Fn;
   SmallVector<InsnRange, 4> MIRanges;
   DenseMap<const MachineInstr *, LexicalScope *> MI2ScopeMap;
   extractLexicalScopes(MIRanges, MI2ScopeMap);
+  // If no scopes were extracted, abstract scope is still needed
+  // for a subprogram attached to multiple functions.
+  ensureAbstractLexicalScopeIsCreated(SP);
   if (CurrentFnLexicalScope) {
     constructScopeNest(CurrentFnLexicalScope);
     assignInstructionRanges(MIRanges, MI2ScopeMap);
@@ -167,6 +176,8 @@ LexicalScope *LexicalScopes::getOrCreateLexicalScope(const DILocalScope *Scope,
     return getOrCreateInlinedScope(Scope, IA);
   }
 
+  // Parent DISubprogram may be attached by multiple functions.
+  ensureAbstractLexicalScopeIsCreated(Scope);
   return getOrCreateRegularScope(Scope);
 }
 

llvm/lib/IR/Verifier.cpp

@@ -336,9 +336,6 @@ class Verifier : public InstVisitor<Verifier>, VerifierSupport {
   /// Keep track of the metadata nodes that have been checked already.
   SmallPtrSet<const Metadata *, 32> MDNodes;
 
-  /// Keep track which DISubprogram is attached to which function.
-  DenseMap<const DISubprogram *, const Function *> DISubprogramAttachments;
-
   /// Track all DICompileUnits visited.
   SmallPtrSet<const Metadata *, 2> CUVisited;
 
@@ -485,7 +482,6 @@ class Verifier : public InstVisitor<Verifier>, VerifierSupport {
     verifyCompileUnits();
 
     verifyDeoptimizeCallingConvs();
-    DISubprogramAttachments.clear();
     return !Broken;
   }
 
@@ -3145,11 +3141,6 @@ void Verifier::visitFunction(const Function &F) {
                 "function definition may only have a distinct !dbg attachment",
                 &F);
 
-        auto *SP = cast<DISubprogram>(I.second);
-        const Function *&AttachedTo = DISubprogramAttachments[SP];
-        CheckDI(!AttachedTo || AttachedTo == &F,
-                "DISubprogram attached to more than one function", SP, &F);
-        AttachedTo = &F;
         AllowLocs = AreDebugLocsAllowed::Yes;
         break;
       }

llvm/test/DebugInfo/COFF/shared-sp.ll

@@ -0,0 +1,129 @@
+; RUN: llc -filetype=obj < %s -o - 2>&1 | llvm-readobj - --codeview | FileCheck %s
+
+; Check that when DISubprogram is attached to two functions, CodeView is
+; produced correctly.
+
+; CHECK:  Subsection [
+; CHECK:    GlobalProcIdSym {
+; CHECK:      Kind: S_GPROC32_ID (0x1147)
+; CHECK:      FunctionType: foo (0x1002)
+; CHECK:      CodeOffset: foo+0x0
+; CHECK:      Flags [ (0x80)
+; CHECK:        HasOptimizedDebugInfo (0x80)
+; CHECK:      ]
+; CHECK:      DisplayName: foo
+; CHECK:      LinkageName: foo
+; CHECK:    }
+; CHECK:    LocalSym {
+; CHECK:      Kind: S_LOCAL (0x113E)
+; CHECK:      Type: int (0x74)
+; CHECK:      Flags [ (0x0)
+; CHECK:      ]
+; CHECK:      VarName: a
+; CHECK:    }
+; CHECK:    LocalSym {
+; CHECK:      Kind: S_LOCAL (0x113E)
+; CHECK:      Type: foo::bar (0x1005)
+; CHECK:      Flags [ (0x0)
+; CHECK:      ]
+; CHECK:      VarName: c
+; CHECK:    }
+; CHECK:    UDTSym {
+; CHECK:      Kind: S_UDT (0x1108)
+; CHECK:      Type: foo::bar (0x1005)
+; CHECK:      UDTName: foo::bar
+; CHECK:    }
+; CHECK:  ]
+; CHECK:  Subsection [
+; CHECK:    GlobalProcIdSym {
+; CHECK:      Kind: S_GPROC32_ID (0x1147)
+; CHECK:      FunctionType: foo (0x1002)
+; CHECK:      CodeOffset: foo_clone+0x0
+; CHECK:      Flags [ (0x80)
+; CHECK:        HasOptimizedDebugInfo (0x80)
+; CHECK:      ]
+; CHECK:      DisplayName: foo
+; CHECK:      LinkageName: foo_clone
+; CHECK:    }
+; CHECK:    LocalSym {
+; CHECK:      Kind: S_LOCAL (0x113E)
+; CHECK:      Type: int (0x74)
+; CHECK:      Flags [ (0x0)
+; CHECK:      ]
+; CHECK:      VarName: a
+; CHECK:    }
+; CHECK:    LocalSym {
+; CHECK:      Kind: S_LOCAL (0x113E)
+; CHECK:      Type: foo::bar (0x1005)
+; CHECK:      Flags [ (0x0)
+; CHECK:      ]
+; CHECK:      VarName: c
+; CHECK:    }
+; CHECK:    UDTSym {
+; CHECK:      Kind: S_UDT (0x1108)
+; CHECK:      Type: foo::bar (0x1005)
+; CHECK:      UDTName: foo::bar
+; CHECK:    }
+; CHECK:  ]
+
+; ModuleID = 'shared-sp.ll'
+target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-pc-windows-msvc19.29.30133"
+
+!0 = distinct !DISubprogram(name: "foo", scope: !1, file: !1, line: 1, type: !2, scopeLine: 1, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !4, retainedNodes: !{})
+!1 = !DIFile(filename: "example.c", directory: "/")
+!2 = !DISubroutineType(types: !3)
+!3 = !{!5}
+!4 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, emissionKind: FullDebug)
+!5 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+
+; Local variable.
+!10 = !DILocalVariable(name: "a", scope: !0, file: !1, line: 2, type: !5)
+
+; DICompositeType local to foo.
+!11 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "bar", scope: !0, file: !1, line: 2, size: 32, elements: !12)
+!12 = !{!13}
+!13 = !DIDerivedType(tag: DW_TAG_member, name: "m", scope: !11, file: !1, line: 2, baseType: !5, size: 32)
+
+; Local variable of type struct bar, local to foo.
+!14 = !DILocalVariable(name: "c", scope: !0, file: !1, line: 2, type: !11)
+
+!101 = !DILocation(line: 2, column: 5, scope: !0)
+!102 = !DILocation(line: 3, column: 1, scope: !0)
+!103 = !DILocation(line: 2, column: 12, scope: !0)
+
+!llvm.dbg.cu = !{!4}
+!llvm.module.flags = !{!29, !30}
+
+!29 = !{i32 2, !"CodeView", i32 1}
+!30 = !{i32 2, !"Debug Info Version", i32 3}
+
+define i32 @foo() !dbg !0 {
+entry:
+  ; Local variable 'a' debug info.
+  %a.addr = alloca i32, align 4, !dbg !101
+    #dbg_declare(ptr %a.addr, !10, !DIExpression(), !101)
+  store i32 42, ptr %a.addr, align 4, !dbg !101
+
+  ; Local variable 'c' (struct bar) debug info.
+  %c.addr = alloca %struct.bar, align 4, !dbg !103
+    #dbg_declare(ptr %c.addr, !14, !DIExpression(), !103)
+
+  ret i32 42, !dbg !102
+}
+
+define i32 @foo_clone() !dbg !0 {
+entry:
+  ; Local variable 'a' debug info.
+  %a.addr = alloca i32, align 4, !dbg !101
+    #dbg_declare(ptr %a.addr, !10, !DIExpression(), !101)
+  store i32 42, ptr %a.addr, align 4, !dbg !101
+
+  ; Local variable 'c' (struct bar) debug info.
+  %c.addr = alloca %struct.bar, align 4, !dbg !103
+    #dbg_declare(ptr %c.addr, !14, !DIExpression(), !103)
+
+  ret i32 42, !dbg !102
+}
+
+%struct.bar = type { i32 }

llvm/test/DebugInfo/COFF/udts-complete.ll

@@ -33,10 +33,10 @@
 ; CHECK:   Mod 0000 | `.debug$S`:
 ; CHECK:        0 | S_GDATA32 [size = 20] `gv`
 ; CHECK:            type = 0x1002 (Foo), addr = 0000:0000
-; CHECK:        0 | S_UDT [size = 12] `Bar`
-; CHECK:            original type = 0x1002
 ; CHECK:        0 | S_UDT [size = 12] `Baz`
 ; CHECK:            original type = 0x1002
+; CHECK:        0 | S_UDT [size = 12] `Bar`
+; CHECK:            original type = 0x1002
 ; CHECK:        0 | S_UDT [size = 12] `Foo`
 ; CHECK:            original type = 0x1002
 

llvm/test/DebugInfo/COFF/udts-fixpoint.ll

@@ -16,11 +16,11 @@
 ; Check that there are only two typedefs, a and c.
 ; CHECK:        .short  4360        # Record kind: S_UDT
 ; CHECK:        .long   {{.*}}      # Type
-; CHECK:        .asciz  "a"
+; CHECK:        .asciz  "c"
 ; CHECK:        .p2align        2
 ; CHECK:        .short  4360        # Record kind: S_UDT
 ; CHECK:        .long   {{.*}}      # Type
-; CHECK:        .asciz  "c"
+; CHECK:        .asciz  "a"
 ; CHECK:        .p2align        2
 ;   No other S_UDTs.
 ; CHECK-NOT: S_UDT