[DebugMetadata][DwarfDebug][CodeView] Support function-local static variables in lexical block scopes (6/7)

[dzhidzhoev]

Summary

RFC https://discourse.llvm.org/t/rfc-dwarfdebug-fix-and-improve-handling-imported-entities-types-and-static-local-in-subprogram-and-lexical-block-scopes/68544

Similar to imported declarations and types, the patch tracks function-local
static variables (globals in terms of LLVM IR) in DISubprogram's 'retainedNodes'.
DwarfDebug is adjusted in accordance with the aforementioned metadata change and
provided a support of static locals scoped by a lexical block.
CodeViewDebug is modified to collect global variables from DISubprogram's
'retainedNodes' too.

The patch assumes that DICompileUnit's 'globals' no longer tracks static locals
and DwarfDebug would assert if any locally-scoped variables get placed there.

[ykhatav]

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1451–1455

Have you thought about adding this support to CodeView as well? I believe that a similar code could be added to CodeViewDebug::endModule() for the CodeView emission to display static locals in proper lexical blocks.

[krisb]

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1451–1455

Unfortunately, I'm not quite familiar with CodeView, but I'm going to take a look at it before committing clang's part (see https://reviews.llvm.org/D125694), since it may cause issues with other debugging formats. But if you want to go ahead I'll be happy if you could reuse this patch or any other from the patchset to improve CodeView.

[ykhatav]

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1451–1455

Okay, i'll reuse your patch and take a stab at it! Thanks!

[jmmartinez]

I've just finished reading and playing with the whole set of patches. Beside some minor nitpicks I've already posted everything else looks good to me.

I also tried compiling LLVM with the patches to see if there was any difference in size in clang's binary (w/debug info and static linking): 1454920 Kb before the patch vs 1454684 Kb after. I've got simiar results when trying with split bash.

I tested the code on some simple examples and it worked as expected.

[dblaikie]

@aprantl

Since this changes what IR goes where - are there concerns you folks have for auto-upgrade/cross compatibility?

@krisb - how's this handle cases of old IR being used in a newer compiler/linker?

[krisb]

Rebase.

[krisb]

@jmmartinez

In D144008#4184543, @jmmartinez wrote:

I've just finished reading and playing with the whole set of patches. Beside some minor nitpicks I've already posted everything else looks good to me.

I also tried compiling LLVM with the patches to see if there was any difference in size in clang's binary (w/debug info and static linking): 1454920 Kb before the patch vs 1454684 Kb after. I've got simiar results when trying with split bash.

I tested the code on some simple examples and it worked as expected.

Thank you so much for your efforts! I really appreciate your help with reviewing this patchset.

[krisb]

@dblaikie

In D144008#4185551, @dblaikie wrote:

@krisb - how's this handle cases of old IR being used in a newer compiler/linker?

There is no backward compatibility, old IR may cause DwarfDebug crash (it asserts that old IR is no longer supported) or miscompilation.
Implementing AutoUpgrade seems to be quite easy, but as far as I can see almost all the changes in debug metadata before were done w/o backward compatibility, so I haven't considered it yet.

[dblaikie]

In D144008#4188878, @krisb wrote:

@dblaikie

In D144008#4185551, @dblaikie wrote:

@krisb - how's this handle cases of old IR being used in a newer compiler/linker?

There is no backward compatibility, old IR may cause DwarfDebug crash (it asserts that old IR is no longer supported) or miscompilation.
Implementing AutoUpgrade seems to be quite easy, but as far as I can see almost all the changes in debug metadata before were done w/o backward compatibility, so I haven't considered it yet.

I don't /think/ that's the case - I know Apple used to have a pretty significant dependence on IR upgrading at least invalidating the IR metadata & dropping it (so maybe all you need to do is update the debug info IR verifier so that old IR gets deemed invalid and dropped - not necessarily upgraded).

[aprantl]

In D144008#4185551, @dblaikie wrote:

@aprantl

Since this changes what IR goes where - are there concerns you folks have for auto-upgrade/cross compatibility?

@krisb - how's this handle cases of old IR being used in a newer compiler/linker?

Can you add an auto-upgrade test to llvm/test/BitCode that tests that we can still import the old format?

[aprantl]

I don't /think/ that's the case - I know Apple used to have a pretty significant dependence on IR upgrading at least invalidating the IR metadata & dropping it (so maybe all you need to do is update the debug info IR verifier so that old IR gets deemed invalid and dropped - not necessarily upgraded).

We've supported upgrading older debug info metadata BitCode for the last couple of years. See the code in llvm/lib/Bitcode/Reader/MetadataLoader.cpp. We never supported reading older textual IR.

[dzhidzhoev]

See https://reviews.llvm.org/D143984#4341780

[dzhidzhoev]

Rebased.

[dzhidzhoev]

Addressing @aprantl comments.

Added an Auto-Updater for the commit, moving static locals from
DICompileUnit's globals to a supposedly correspoding DISubprogram, that
embraces a scope of a DIGlobalVariableExpression being reattached.

[aprantl]

llvm/test/Bitcode/upgrade-cu-static-locals.ll

19

Can you remove all attributes that aren't strictly needed? That will make the test easier to maintain.

[dzhidzhoev]

Got rid of nondetermistic order of metadata being moved in MetadataLoader.cpp.
Removed unnecessary attributes, addressing @aprantl comment.

[dzhidzhoev]

Made AutoUpdater move function-local imports/enums/globals to their DISubprograms. A code for imports/enums/globals is added incrementally in
corresponding patches to maintain backward compatibility during landing.

Made CodeViewDebug collect global variables from DISubprogram’s ‘retainedNodes’ in accordance with metadata change.

Made Verifier assert if any locally-scoped entities are found in enums/globals/imports fields of DICompileUnit.

[dzhidzhoev]

@akhuang @rnk @ykhatav could you please take a look at CodeViewReader.cpp change? Frankly, I am new to that format.

[ykhatav]

In D144008#4401633, @dzhidzhoev wrote:

@akhuang @rnk @ykhatav could you please take a look at CodeViewReader.cpp change? Frankly, I am new to that format.

Thanks for taking care of this. Could you add a CodeView-specific test to make sure that the changes work as expected?

[dzhidzhoev]

In D144008#4403052, @ykhatav wrote:

In D144008#4401633, @dzhidzhoev wrote:

@akhuang @rnk @ykhatav could you please take a look at CodeViewReader.cpp change? Frankly, I am new to that format.

Thanks for taking care of this. Could you add a CodeView-specific test to make sure that the changes work as expected?

It seems that llvm/test/DebugInfo/COFF/global_visibility.ll test ensures that local/static local/global variables are handled properly. DISubprogram's retainedNodes references a few static local variables, and we check that these variables are present within CodeView dump. Is there a corner case I probably miss?

[rnk]

I think the CodeView code changes and test updates look correct, based on my understanding of the schema change. Thanks for updating it!

[ykhatav]

In D144008#4403456, @dzhidzhoev wrote:

In D144008#4403052, @ykhatav wrote:

In D144008#4401633, @dzhidzhoev wrote:

@akhuang @rnk @ykhatav could you please take a look at CodeViewReader.cpp change? Frankly, I am new to that format.

Thanks for taking care of this. Could you add a CodeView-specific test to make sure that the changes work as expected?

It seems that llvm/test/DebugInfo/COFF/global_visibility.ll test ensures that local/static local/global variables are handled properly. DISubprogram's retainedNodes references a few static local variables, and we check that these variables are present within CodeView dump. Is there a corner case I probably miss?

Thanks for pointing that out. The CodeView changes look good to me.

llvm/include/llvm/IR/DIBuilder.h

class DIBuilder {
     Function *ValueFn;       ///< llvm.dbg.value
     Function *LabelFn;       ///< llvm.dbg.label
     Function *AssignFn;      ///< llvm.dbg.assign
 
     SmallVector<TrackingMDNodeRef, 4> EnumTypes;
     /// Track the RetainTypes, since they can be updated later on.
     SmallVector<TrackingMDNodeRef, 4> AllRetainTypes;
     SmallVector<DISubprogram *, 4> AllSubprograms;
-    SmallVector<Metadata *, 4> AllGVs;
+    SmallVector<Metadata *, 4> Globals;
     SmallVector<TrackingMDNodeRef, 4> ImportedModules;
     /// Map Macro parent (which can be DIMacroFile or nullptr) to a list of
     /// Metadata all of type DIMacroNode.
     /// DIMacroNode's with nullptr parent are DICompileUnit direct children.
     MapVector<MDNode *, SetVector<Metadata *>> AllMacrosPerParent;
 
     /// Track nodes that may be unresolved.
     SmallVector<TrackingMDNodeRef, 4> UnresolvedNodes;
     bool AllowUnresolvedNodes;
 
-    /// Each subprogram's preserved local variables, labels, imported entities,
-    /// and types.
+    /// Each subprogram's preserved local and static local variables, labels,
+    /// imported entities, and types.
     ///
     /// Do not use a std::vector.  Some versions of libc++ apparently copy
     /// instead of move on grow operations, and TrackingMDRef is expensive to
     /// copy.
     DenseMap<DISubprogram *, SmallVector<TrackingMDNodeRef, 4>>
         SubprogramTrackedNodes;
 
     SmallVectorImpl<TrackingMDNodeRef> &

llvm/include/llvm/IR/DebugInfoMetadata.h

private:
 
   static DISubprogram *
   getImpl(LLVMContext &Context, DIScope *Scope, StringRef Name,
           StringRef LinkageName, DIFile *File, unsigned Line,
           DISubroutineType *Type, unsigned ScopeLine, DIType *ContainingType,
           unsigned VirtualIndex, int ThisAdjustment, DIFlags Flags,
           DISPFlags SPFlags, DICompileUnit *Unit,
           DITemplateParameterArray TemplateParams, DISubprogram *Declaration,
-          DINodeArray RetainedNodes, DITypeArray ThrownTypes,
+          MDNodeArray RetainedNodes, DITypeArray ThrownTypes,
           DINodeArray Annotations, StringRef TargetFuncName,
           StorageType Storage, bool ShouldCreate = true) {
     return getImpl(Context, Scope, getCanonicalMDString(Context, Name),
                    getCanonicalMDString(Context, LinkageName), File, Line, Type,
                    ScopeLine, ContainingType, VirtualIndex, ThisAdjustment,
                    Flags, SPFlags, Unit, TemplateParams.get(), Declaration,
                    RetainedNodes.get(), ThrownTypes.get(), Annotations.get(),
                    getCanonicalMDString(Context, TargetFuncName),

 public:
   DEFINE_MDNODE_GET(
       DISubprogram,
       (DIScope * Scope, StringRef Name, StringRef LinkageName, DIFile *File,
        unsigned Line, DISubroutineType *Type, unsigned ScopeLine,
        DIType *ContainingType, unsigned VirtualIndex, int ThisAdjustment,
        DIFlags Flags, DISPFlags SPFlags, DICompileUnit *Unit,
        DITemplateParameterArray TemplateParams = nullptr,
-       DISubprogram *Declaration = nullptr, DINodeArray RetainedNodes = nullptr,
+       DISubprogram *Declaration = nullptr, MDNodeArray RetainedNodes = nullptr,
        DITypeArray ThrownTypes = nullptr, DINodeArray Annotations = nullptr,
        StringRef TargetFuncName = ""),
       (Scope, Name, LinkageName, File, Line, Type, ScopeLine, ContainingType,
        VirtualIndex, ThisAdjustment, Flags, SPFlags, Unit, TemplateParams,
        Declaration, RetainedNodes, ThrownTypes, Annotations, TargetFuncName))
 
   DEFINE_MDNODE_GET(
       DISubprogram,
public:
   }
   void replaceUnit(DICompileUnit *CU) { replaceOperandWith(5, CU); }
   DITemplateParameterArray getTemplateParams() const {
     return cast_or_null<MDTuple>(getRawTemplateParams());
   }
   DISubprogram *getDeclaration() const {
     return cast_or_null<DISubprogram>(getRawDeclaration());
   }
-  DINodeArray getRetainedNodes() const {
+  MDNodeArray getRetainedNodes() const {
     return cast_or_null<MDTuple>(getRawRetainedNodes());
   }
   DITypeArray getThrownTypes() const {
     return cast_or_null<MDTuple>(getRawThrownTypes());
   }
   DINodeArray getAnnotations() const {
     return cast_or_null<MDTuple>(getRawAnnotations());
   }
public:
   }
   MDString *getRawTargetFuncName() const {
     return getNumOperands() > 12 ? getOperandAs<MDString>(12) : nullptr;
   }
 
   void replaceRawLinkageName(MDString *LinkageName) {
     replaceOperandWith(3, LinkageName);
   }
-  void replaceRetainedNodes(DINodeArray N) {
-    replaceOperandWith(7, N.get());
-  }
+  void replaceRetainedNodes(MDNodeArray N) { replaceOperandWith(7, N.get()); }
 
   /// Check if this subprogram describes the given function.
   ///
   /// FIXME: Should this be looking through bitcasts?
   bool describes(const Function *F) const;
 
   static bool classof(const Metadata *MD) {
     return MD->getMetadataID() == DISubprogramKind;

llvm/lib/Bitcode/Reader/MetadataLoader.cpp

while (S && !isa<DISubprogram>(S)) {
         break;
       Visited.insert(S);
     }
     ParentSubprogram[InitialScope] = llvm::dyn_cast_or_null<DISubprogram>(S);
 
     return ParentSubprogram[InitialScope];
   }
 
-  /// Move local imports from DICompileUnit's 'imports' field to
-  /// DISubprogram's retainedNodes.
-  /// Move fucntion-local enums from DICompileUnit's enums
-  /// to DISubprogram's retainedNodes.
+  /// Move function-local entities from DICompileUnit's 'imports',
+  /// 'enums', and 'globals' fields to DISubprogram's retainedNodes.
   void upgradeCULocals() {
     if (NamedMDNode *CUNodes = TheModule.getNamedMetadata("llvm.dbg.cu")) {
       for (unsigned I = 0, E = CUNodes->getNumOperands(); I != E; ++I) {
         auto *CU = dyn_cast<DICompileUnit>(CUNodes->getOperand(I));
         if (!CU)
           continue;
 
         SmallPtrSet<Metadata *, 8> MetadataToRemove;
if (NamedMDNode *CUNodes = TheModule.getNamedMetadata("llvm.dbg.cu")) {
         if (CU->getRawEnumTypes()) {
           for (Metadata *Op : CU->getEnumTypes()->operands()) {
             auto *Enum = cast<DICompositeType>(Op);
             if (dyn_cast_or_null<DILocalScope>(Enum->getScope())) {
               MetadataToRemove.insert(Enum);
             }
           }
         }
+        // Collect globals to be moved.
+        if (CU->getRawGlobalVariables()) {
+          for (Metadata *Op : CU->getGlobalVariables()->operands()) {
+            auto *GVE = cast<DIGlobalVariableExpression>(Op);
+            if (dyn_cast_or_null<DILocalScope>(
+                    GVE->getVariable()->getScope())) {
+              MetadataToRemove.insert(GVE);
+            }
+          }
+        }
 
         if (!MetadataToRemove.empty()) {
           // Make a new list of CU's 'imports'.
           SmallVector<Metadata *> NewImports;
           if (CU->getRawImportedEntities())
             for (Metadata *Op : CU->getImportedEntities()->operands())
               if (!MetadataToRemove.contains(Op))
                 NewImports.push_back(Op);
 
           // Make a new list of CU's 'enums'.
           SmallVector<Metadata *> NewEnums;
           if (CU->getRawEnumTypes())
             for (Metadata *Op : CU->getEnumTypes()->operands())
               if (!MetadataToRemove.contains(Op))
                 NewEnums.push_back(Op);
 
+          // Make a new list of CU's 'globals'.
+          SmallVector<Metadata *> NewGVEs;
+          if (CU->getRawGlobalVariables())
+            for (Metadata *Op : CU->getGlobalVariables()->operands())
+              if (!MetadataToRemove.contains(Op))
+                NewGVEs.push_back(Op);
+
           // Find DISubprogram corresponding to each entity.
           std::map<DISubprogram *, SmallVector<Metadata *>> SPToEntities;
           for (auto *I : MetadataToRemove) {
             DILocalScope *Scope = nullptr;
             if (auto *Entity = dyn_cast<DIImportedEntity>(I))
               Scope = cast<DILocalScope>(Entity->getScope());
             else if (auto *Enum = dyn_cast<DICompositeType>(I))
               Scope = cast<DILocalScope>(Enum->getScope());
+            else if (auto *GVE = dyn_cast<DIGlobalVariableExpression>(I))
+              Scope = cast<DILocalScope>(GVE->getVariable()->getScope());
 
             if (auto *SP = findEnclosingSubprogram(Scope)) {
               SPToEntities[SP].push_back(I);
             }
           }
 
           // Update DISubprograms' retainedNodes.
           for (auto I = SPToEntities.begin(); I != SPToEntities.end(); ++I) {
             auto *SP = I->first;
             auto RetainedNodes = SP->getRetainedNodes();
             SmallVector<Metadata *> MDs(RetainedNodes.begin(),
                                         RetainedNodes.end());
             MDs.append(I->second);
             SP->replaceRetainedNodes(MDNode::get(Context, MDs));
           }
 
           // Remove entities with local scope from CU.
           if (CU->getRawImportedEntities())
             CU->replaceImportedEntities(MDTuple::get(Context, NewImports));
           // Remove enums with local scope from CU.
           if (CU->getRawEnumTypes())
             CU->replaceEnumTypes(MDTuple::get(Context, NewEnums));
+          // Remove globals with local scope from CU.
+          if (CU->getRawGlobalVariables())
+            CU->replaceGlobalVariables(MDTuple::get(Context, NewGVEs));
         }
       }
     }
 
     ParentSubprogram.clear();
   }
 
   /// Remove a leading DW_OP_deref from DIExpressions in a dbg.declare that

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.h

private:
   // collectLexicalBlocks() separates the variables between the FunctionInfo
   // and LexicalBlocks.
   DenseMap<const LexicalScope *, SmallVector<LocalVariable, 1>> ScopeVariables;
 
   // Map to separate global variables according to the lexical scope they
   // belong in. A null local scope represents the global scope.
   typedef SmallVector<CVGlobalVariable, 1> GlobalVariableList;
   DenseMap<const DIScope*, std::unique_ptr<GlobalVariableList> > ScopeGlobals;
+  DenseMap<const DIGlobalVariableExpression *, const GlobalVariable *>
+      GlobalMap;
 
   // Array of global variables which  need to be emitted into a COMDAT section.
   SmallVector<CVGlobalVariable, 1> ComdatVariables;
 
   // Array of non-COMDAT global variables.
   SmallVector<CVGlobalVariable, 1> GlobalVariables;
 
   /// List of static const data members to be emitted as S_CONSTANTs.
private:
   void emitEndSymbolRecord(codeview::SymbolKind EndKind);
 
   void emitInlinedCallSite(const FunctionInfo &FI, const DILocation *InlinedAt,
                            const InlineSite &Site);
 
   using InlinedEntity = DbgValueHistoryMap::InlinedEntity;
 
   void collectGlobalVariableInfo();
+  void
+  collectGlobalOrStaticLocalVariableInfo(const DIGlobalVariableExpression *GVE);
   void collectVariableInfo(const DISubprogram *SP);
 
   void collectVariableInfoFromMFTable(DenseSet<InlinedEntity> &Processed);
 
   // Construct the lexical block tree for a routine, pruning emptpy lexical
   // scopes, and populate it with local variables.
   void collectLexicalBlockInfo(SmallVectorImpl<LexicalScope *> &Scopes,
                                SmallVectorImpl<LexicalBlock *> &Blocks,

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

void CodeViewDebug::calculateRanges(
   }
 }
 
 void CodeViewDebug::collectVariableInfo(const DISubprogram *SP) {
   DenseSet<InlinedEntity> Processed;
   // Grab the variable info that was squirreled away in the MMI side-table.
   collectVariableInfoFromMFTable(Processed);
 
+  for (const MDNode *N : SP->getRetainedNodes()) {
+    if (const auto *GVE = dyn_cast<DIGlobalVariableExpression>(N)) {
+      collectGlobalOrStaticLocalVariableInfo(GVE);
+    }
+  }
+
   for (const auto &I : DbgValues) {
     InlinedEntity IV = I.first;
     if (Processed.count(IV))
       continue;
     const DILocalVariable *DIVar = cast<DILocalVariable>(IV.first);
     const DILocation *InlinedAt = IV.second;
 
     // Instruction ranges, specifying where IV is accessible.
for (const auto &UDT : UDTs) {
     OS.emitInt32(getCompleteTypeIndex(T).getIndex());
     assert(OriginalSize == UDTs.size() &&
            "getCompleteTypeIndex found new UDTs!");
     emitNullTerminatedSymbolName(OS, UDT.first);
     endSymbolRecord(UDTRecordEnd);
   }
 }
 
-void CodeViewDebug::collectGlobalVariableInfo() {
-  DenseMap<const DIGlobalVariableExpression *, const GlobalVariable *>
-      GlobalMap;
-  for (const GlobalVariable &GV : MMI->getModule()->globals()) {
-    SmallVector<DIGlobalVariableExpression *, 1> GVEs;
-    GV.getDebugInfo(GVEs);
-    for (const auto *GVE : GVEs)
-      GlobalMap[GVE] = &GV;
-  }
-
-  NamedMDNode *CUs = MMI->getModule()->getNamedMetadata("llvm.dbg.cu");
-  for (const MDNode *Node : CUs->operands()) {
-    const auto *CU = cast<DICompileUnit>(Node);
-    for (const auto *GVE : CU->getGlobalVariables()) {
-      const DIGlobalVariable *DIGV = GVE->getVariable();
-      const DIExpression *DIE = GVE->getExpression();
-      // Don't emit string literals in CodeView, as the only useful parts are
-      // generally the filename and line number, which isn't possible to output
-      // in CodeView. String literals should be the only unnamed GlobalVariable
-      // with debug info.
-      if (DIGV->getName().empty()) continue;
+void CodeViewDebug::collectGlobalOrStaticLocalVariableInfo(
+    const DIGlobalVariableExpression *GVE) {
+  if (DIGV->getName().empty())
+    return;
 
-      if ((DIE->getNumElements() == 2) &&
-          (DIE->getElement(0) == dwarf::DW_OP_plus_uconst))
-        // Record the constant offset for the variable.
-        //
-        // A Fortran common block uses this idiom to encode the offset
-        // of a variable from the common block's starting address.
-        CVGlobalVariableOffsets.insert(
-            std::make_pair(DIGV, DIE->getElement(1)));
+    CVGlobalVariableOffsets.insert(std::make_pair(DIGV, DIE->getElement(1)));
 
-      // Emit constant global variables in a global symbol section.
-      if (GlobalMap.count(GVE) == 0 && DIE->isConstant()) {
-        CVGlobalVariable CVGV = {DIGV, DIE};
-        GlobalVariables.emplace_back(std::move(CVGV));
-      }
 
-      const auto *GV = GlobalMap.lookup(GVE);
-      if (!GV || GV->isDeclarationForLinker())
-        continue;
+    return;
 
-      DIScope *Scope = DIGV->getScope();
-      SmallVector<CVGlobalVariable, 1> *VariableList;
-      if (Scope && isa<DILocalScope>(Scope)) {
-        // Locate a global variable list for this scope, creating one if
-        // necessary.
-        auto Insertion = ScopeGlobals.insert(
-            {Scope, std::unique_ptr<GlobalVariableList>()});
-        if (Insertion.second)
-          Insertion.first->second = std::make_unique<GlobalVariableList>();
-        VariableList = Insertion.first->second.get();
-      } else if (GV->hasComdat())
-        // Emit this global variable into a COMDAT section.
-        VariableList = &ComdatVariables;
-      else
-        // Emit this global variable in a single global symbol section.
-        VariableList = &GlobalVariables;
-      CVGlobalVariable CVGV = {DIGV, GV};
-      VariableList->emplace_back(std::move(CVGV));
-    }
+    auto Insertion =
+        ScopeGlobals.insert({Scope, std::unique_ptr<GlobalVariableList>()});
+
+void CodeViewDebug::collectGlobalVariableInfo() {
+  for (const GlobalVariable &GV : MMI->getModule()->globals()) {
+    SmallVector<DIGlobalVariableExpression *, 1> GVEs;
+    GV.getDebugInfo(GVEs);
+    for (const auto *GVE : GVEs)
+      GlobalMap[GVE] = &GV;
+  }
+
+  NamedMDNode *CUs = MMI->getModule()->getNamedMetadata("llvm.dbg.cu");
+  for (const MDNode *Node : CUs->operands()) {
+    const auto *CU = cast<DICompileUnit>(Node);
+    for (const auto *GVE : CU->getGlobalVariables()) {
+      collectGlobalOrStaticLocalVariableInfo(GVE);
+    }
   }
 }
 
 void CodeViewDebug::collectDebugInfoForGlobals() {
   for (const CVGlobalVariable &CVGV : GlobalVariables) {
     const DIGlobalVariable *DIGV = CVGV.DIGV;
     const DIScope *Scope = DIGV->getScope();
     getCompleteTypeIndex(DIGV->getType());

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

for (auto *GVE : CUNode->getGlobalVariables()) {
       auto &GVMapEntry = GVMap[GVE->getVariable()];
       auto *Expr = GVE->getExpression();
       if (!GVMapEntry.size() || (Expr && Expr->isConstant()))
         GVMapEntry.push_back({nullptr, Expr});
     }
     DenseSet<DIGlobalVariable *> Processed;
     for (auto *GVE : CUNode->getGlobalVariables()) {
       DIGlobalVariable *GV = GVE->getVariable();
+      assert(!isa_and_nonnull<DILocalScope>(GV->getScope()) &&
+             "Unexpected function-local entity in 'globals' CU field.");
       if (Processed.insert(GV).second)
         CU->getOrCreateGlobalVariableDIE(GV, sortGlobalExprs(GVMap[GV]));
     }
 
     // Emit imported entities.
     for (auto *IE : CUNode->getImportedEntities()) {
       assert(!isa_and_nonnull<DILocalScope>(IE->getScope()) &&
              "Unexpected function-local entity in 'imports' CU field.");
       CU->getOrCreateImportedEntityDIE(IE);
     }
 
     // Emit function-local entities.
     for (const auto *D : CU->getDeferredLocalDecls()) {
       if (auto *IE = dyn_cast<DIImportedEntity>(D))
         CU->getOrCreateImportedEntityDIE(IE);
       else if (auto *Ty = dyn_cast<DIType>(D))
         CU->getOrCreateTypeDIE(Ty);
-      else
+      else if (auto *GVE = dyn_cast<DIGlobalVariableExpression>(D)) {
+        DIGlobalVariable *GV = GVE->getVariable();
+        if (Processed.insert(GV).second)
+          CU->getOrCreateGlobalVariableDIE(GV, sortGlobalExprs(GVMap[GV]));
+      } else
         llvm_unreachable("Unexpected local retained node!");
     }
 
     // Emit base types.
     CU->createBaseTypeDIEs();
   }
 
   // If we aren't actually generating debug info (check beginModule -
static const DILocalScope *getRetainedNodeScope(const MDNode *N) {
   if (const auto *LV = dyn_cast<DILocalVariable>(N))
     S = LV->getScope();
   else if (const auto *L = dyn_cast<DILabel>(N))
     S = L->getScope();
   else if (const auto *IE = dyn_cast<DIImportedEntity>(N))
     S = IE->getScope();
   else if (const auto *T = dyn_cast<DIType>(N))
     S = T->getScope();
+  else if (const auto *GVE = dyn_cast<DIGlobalVariableExpression>(N))
+    S = GVE->getVariable()->getScope();
   else
     llvm_unreachable("Unexpected retained node!");
 
   // Ensure the scope is not a DILexicalBlockFile.
   return cast<DILocalScope>(S)->getNonLexicalBlockFileScope();
 }
 
 // Collect variable information from side table maintained by MF.
for (const auto &I : DbgLabels) {
     /// At this point, the temporary label is created.
     /// Save the temporary label to DbgLabel entity to get the
     /// actually address when generating Dwarf DIE.
     MCSymbol *Sym = getLabelBeforeInsn(MI);
     createConcreteEntity(TheCU, *Scope, Label, IL.second, Sym);
   }
 
   // Collect info for retained nodes.
-  for (const DINode *DN : SP->getRetainedNodes()) {
-    const auto *LS = getRetainedNodeScope(DN);
-    if (isa<DILocalVariable>(DN) || isa<DILabel>(DN)) {
+  for (const MDNode *N : SP->getRetainedNodes()) {
+    const auto *LS = getRetainedNodeScope(N);
+    if (isa<DILocalVariable>(N) || isa<DILabel>(N)) {
+      const auto *DN = cast<DINode>(N);
       if (!Processed.insert(InlinedEntity(DN, nullptr)).second)
         continue;
       LexicalScope *LexS = LScopes.findLexicalScope(LS);
       if (LexS)
         createConcreteEntity(TheCU, *LexS, DN, nullptr);
     } else {
-      LocalDeclsPerLS[LS].insert(DN);
+      LocalDeclsPerLS[LS].insert(N);
     }
   }
 }
 
 // Process beginning of an instruction.
 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
   const MachineFunction &MF = *MI->getMF();
   const auto *SP = MF.getFunction().getSubprogram();
if (!TheCU.getCUNode()->getDebugInfoForProfiling() &&
     return;
   }
 
 #ifndef NDEBUG
   size_t NumAbstractSubprograms = LScopes.getAbstractScopesList().size();
 #endif
   for (LexicalScope *AScope : LScopes.getAbstractScopesList()) {
     const auto *SP = cast<DISubprogram>(AScope->getScopeNode());
-    for (const DINode *DN : SP->getRetainedNodes()) {
-      const auto *LS = getRetainedNodeScope(DN);
+    for (const MDNode *N : SP->getRetainedNodes()) {
+      const auto *LS = getRetainedNodeScope(N);
       // Ensure LexicalScope is created for the scope of this node.
       auto *LexS = LScopes.getOrCreateAbstractScope(LS);
       assert(LexS && "Expected the LexicalScope to be created.");
-      if (isa<DILocalVariable>(DN) || isa<DILabel>(DN)) {
+      if (isa<DILocalVariable>(N) || isa<DILabel>(N)) {
+        const auto *DN = cast<DINode>(N);
         // Collect info for variables/labels that were optimized out.
         if (!Processed.insert(InlinedEntity(DN, nullptr)).second ||
             TheCU.getExistingAbstractEntity(DN))
           continue;
         TheCU.createAbstractEntity(DN, LexS);
       } else {
         // Remember the node if this is a local declarations.
-        LocalDeclsPerLS[LS].insert(DN);
+        LocalDeclsPerLS[LS].insert(N);
       }
       assert(
           LScopes.getAbstractScopesList().size() == NumAbstractSubprograms &&
           "getOrCreateAbstractScope() inserted an abstract subprogram scope");
     }
     constructAbstractSubprogramScopeDIE(TheCU, AScope);
   }
 

llvm/lib/IR/DIBuilder.cpp

: M(m), VMContext(M.getContext()), CUNode(CU), DeclareFn(nullptr),
       ValueFn(nullptr), LabelFn(nullptr), AssignFn(nullptr),
       AllowUnresolvedNodes(AllowUnresolvedNodes) {
   if (CUNode) {
     if (const auto &ETs = CUNode->getEnumTypes())
       EnumTypes.assign(ETs.begin(), ETs.end());
     if (const auto &RTs = CUNode->getRetainedTypes())
       AllRetainTypes.assign(RTs.begin(), RTs.end());
     if (const auto &GVs = CUNode->getGlobalVariables())
-      AllGVs.assign(GVs.begin(), GVs.end());
+      Globals.assign(GVs.begin(), GVs.end());
     if (const auto &IMs = CUNode->getImportedEntities())
       ImportedModules.assign(IMs.begin(), IMs.end());
     if (const auto &MNs = CUNode->getMacros())
       AllMacrosPerParent.insert({nullptr, {MNs.begin(), MNs.end()}});
   }
 }
 
 void DIBuilder::trackIfUnresolved(MDNode *N) {
if (!RetainValues.empty())
     CUNode->replaceRetainedTypes(MDTuple::get(VMContext, RetainValues));
 
   for (auto *SP : AllSubprograms)
     finalizeSubprogram(SP);
   for (auto *N : RetainValues)
     if (auto *SP = dyn_cast<DISubprogram>(N))
       finalizeSubprogram(SP);
 
-  if (!AllGVs.empty())
-    CUNode->replaceGlobalVariables(MDTuple::get(VMContext, AllGVs));
+  if (!Globals.empty())
+    CUNode->replaceGlobalVariables(MDTuple::get(VMContext, Globals));
 
   if (!ImportedModules.empty())
     CUNode->replaceImportedEntities(MDTuple::get(
         VMContext, SmallVector<Metadata *, 16>(ImportedModules.begin(),
                                                ImportedModules.end())));
 
   for (const auto &I : AllMacrosPerParent) {
     // DIMacroNode's with nullptr parent are DICompileUnit direct children.
DIGlobalVariableExpression *DIBuilder::createGlobalVariableExpression(
   auto *GV = DIGlobalVariable::getDistinct(
       VMContext, cast_or_null<DIScope>(Context), Name, LinkageName, F,
       LineNumber, Ty, IsLocalToUnit, isDefined,
       cast_or_null<DIDerivedType>(Decl), TemplateParams, AlignInBits,
       Annotations);
   if (!Expr)
     Expr = createExpression();
   auto *N = DIGlobalVariableExpression::get(VMContext, GV, Expr);
-  AllGVs.push_back(N);
+  if (isa_and_nonnull<DILocalScope>(Context))
+    getSubprogramNodesTrackingVector(Context).emplace_back(N);
+  else
+    Globals.push_back(N);
   return N;
 }
 
 DIGlobalVariable *DIBuilder::createTempGlobalVariableFwdDecl(
     DIScope *Context, StringRef Name, StringRef LinkageName, DIFile *F,
     unsigned LineNumber, DIType *Ty, bool IsLocalToUnit, MDNode *Decl,
     MDTuple *TemplateParams, uint32_t AlignInBits) {
   checkGlobalVariableScope(Context);

llvm/lib/IR/Verifier.cpp

CheckDI((N.getEmissionKind() <= DICompileUnit::LastEmissionKind),
           "invalid emission kind", &N);
 
   if (auto *Array = N.getRawEnumTypes()) {
     CheckDI(isa<MDTuple>(Array), "invalid enum list", &N, Array);
     for (Metadata *Op : N.getEnumTypes()->operands()) {
       auto *Enum = dyn_cast_or_null<DICompositeType>(Op);
       CheckDI(Enum && Enum->getTag() == dwarf::DW_TAG_enumeration_type,
               "invalid enum type", &N, N.getEnumTypes(), Op);
+      if (Enum->getScope())
+        CheckDI(!isa<DILocalScope>(Enum->getScope()),
+                "function-local enum in a DICompileUnit's enum list", &N,
+                N.getEnumTypes(), Op);
     }
   }
   if (auto *Array = N.getRawRetainedTypes()) {
     CheckDI(isa<MDTuple>(Array), "invalid retained type list", &N, Array);
     for (Metadata *Op : N.getRetainedTypes()->operands()) {
       CheckDI(
           Op && (isa<DIType>(Op) || (isa<DISubprogram>(Op) &&
                                      !cast<DISubprogram>(Op)->isDefinition())),
           "invalid retained type", &N, Op);
     }
   }
   if (auto *Array = N.getRawGlobalVariables()) {
     CheckDI(isa<MDTuple>(Array), "invalid global variable list", &N, Array);
     for (Metadata *Op : N.getGlobalVariables()->operands()) {
-      CheckDI(Op && (isa<DIGlobalVariableExpression>(Op)),
-              "invalid global variable ref", &N, Op);
+      auto *GVE = dyn_cast_or_null<DIGlobalVariableExpression>(Op);
+      CheckDI(GVE, "invalid global variable ref", &N, Op);
+      if (GVE->getVariable()->getScope())
+        CheckDI(!isa<DILocalScope>(GVE->getVariable()->getScope()),
+                "function-local variable in a DICompileUnit's global variables "
+                "list",
+                &N, Op);
     }
   }
   if (auto *Array = N.getRawImportedEntities()) {
     CheckDI(isa<MDTuple>(Array), "invalid imported entity list", &N, Array);
     for (Metadata *Op : N.getImportedEntities()->operands()) {
-      CheckDI(Op && isa<DIImportedEntity>(Op), "invalid imported entity ref",
-              &N, Op);
+      auto *IE = dyn_cast_or_null<DIImportedEntity>(Op);
+      CheckDI(IE, "invalid imported entity ref", &N, Op);
+      if (IE->getScope())
+        CheckDI(
+            !isa<DILocalScope>(IE->getScope()),
+            "function-local import in a DICompileUnit's imported entities list",
     }
   }
   if (auto *Array = N.getRawMacros()) {
     CheckDI(isa<MDTuple>(Array), "invalid macro list", &N, Array);
     for (Metadata *Op : N.getMacros()->operands()) {
       CheckDI(Op && isa<DIMacroNode>(Op), "invalid macro ref", &N, Op);
     }
   }
void Verifier::visitDISubprogram(const DISubprogram &N) {
   if (auto *S = N.getRawDeclaration())
     CheckDI(isa<DISubprogram>(S) && !cast<DISubprogram>(S)->isDefinition(),
             "invalid subprogram declaration", &N, S);
   if (auto *RawNode = N.getRawRetainedNodes()) {
     auto *Node = dyn_cast<MDTuple>(RawNode);
     CheckDI(Node, "invalid retained nodes list", &N, RawNode);
     for (Metadata *Op : Node->operands()) {
       CheckDI(Op && (isa<DILocalVariable>(Op) || isa<DILabel>(Op) ||
-                     isa<DIImportedEntity>(Op) || isa<DIType>(Op)),
+                     isa<DIImportedEntity>(Op) || isa<DIType>(Op) ||
+                     isa<DIGlobalVariableExpression>(Op)),
               "invalid retained nodes, expected DILocalVariable, DILabel, "
-              "DIImportedEntity or DIType",
+              "DIImportedEntity, DIType or DIGlobalVariableExpression",
               &N, Node, Op);
     }
   }
   CheckDI(!hasConflictingReferenceFlags(N.getFlags()),
           "invalid reference flags", &N);
 
   auto *Unit = N.getRawUnit();
   if (N.isDefinition()) {

llvm/lib/Target/BPF/BPFAbstractMemberAccess.cpp

bool BPFAbstractMemberAccess::run(Function &F) {
   // pattern like '[derived_type]* [composite_type]' to check
   // and remember (anon record -> typedef) relations where the
   // anon record is defined as
   //   typedef [const/volatile/restrict]* [anon record]
   DISubprogram *SP = F.getSubprogram();
   if (SP && SP->isDefinition()) {
     for (DIType *Ty: SP->getType()->getTypeArray())
       CheckAnonRecordType(nullptr, Ty);
-    for (const DINode *DN : SP->getRetainedNodes()) {
+    for (const MDNode *DN : SP->getRetainedNodes()) {
       if (const auto *DV = dyn_cast<DILocalVariable>(DN))
         CheckAnonRecordType(nullptr, DV->getType());
     }
   }
 
   DL = &M->getDataLayout();
   return doTransformation(F);
 }

llvm/lib/Target/BPF/BTFDebug.cpp

 
 uint32_t BTFDebug::processDISubprogram(const DISubprogram *SP,
                                        uint32_t ProtoTypeId, uint8_t Scope) {
   auto FuncTypeEntry =
       std::make_unique<BTFTypeFunc>(SP->getName(), ProtoTypeId, Scope);
   uint32_t FuncId = addType(std::move(FuncTypeEntry));
 
   // Process argument annotations.
-  for (const DINode *DN : SP->getRetainedNodes()) {
+  for (const MDNode *DN : SP->getRetainedNodes()) {
     if (const auto *DV = dyn_cast<DILocalVariable>(DN)) {
       uint32_t Arg = DV->getArg();
       if (Arg)
         processDeclAnnotations(DV->getAnnotations(), FuncId, Arg - 1);
     }
   }
   processDeclAnnotations(SP->getAnnotations(), FuncId, -1);
 
if (MapDefNotCollected) {
     processGlobals(true);
     MapDefNotCollected = false;
   }
 
   // Collect all types locally referenced in this function.
   // Use RetainedNodes so we can collect all argument names
   // even if the argument is not used.
   std::unordered_map<uint32_t, StringRef> FuncArgNames;
-  for (const DINode *DN : SP->getRetainedNodes()) {
+  for (const MDNode *DN : SP->getRetainedNodes()) {
     if (const auto *DV = dyn_cast<DILocalVariable>(DN)) {
       // Collect function arguments for subprogram func type.
       uint32_t Arg = DV->getArg();
       if (Arg) {
         visitTypeEntry(DV->getType());
         FuncArgNames[Arg] = DV->getName();
       }
     }

llvm/lib/Transforms/Instrumentation/InstrProfiling.cpp

if (auto *SP = Fn->getSubprogram()) {
       });
       auto *DICounter = DB.createGlobalVariableExpression(
           SP, CounterPtr->getName(), /*LinkageName=*/StringRef(), SP->getFile(),
           /*LineNo=*/0, DB.createUnspecifiedType("Profile Data Type"),
           CounterPtr->hasLocalLinkage(), /*IsDefined=*/true, /*Expr=*/nullptr,
           /*Decl=*/nullptr, /*TemplateParams=*/nullptr, /*AlignInBits=*/0,
           Annotations);
       CounterPtr->addDebugInfo(DICounter);
+      DB.finalizeSubprogram(SP);
       DB.finalize();
     } else {
       std::string Msg = ("Missing debug info for function " + Fn->getName() +
                          "; required for profile correlation.")
                             .str();
       Ctx.diagnose(
           DiagnosticInfoPGOProfile(M->getName().data(), Msg, DS_Warning));
     }

llvm/lib/Transforms/Utils/Debugify.cpp

for (Function &F : Functions) {
     // Stop collecting DI if the Functions number reached the limit.
     if (++FunctionsCnt >= DebugifyFunctionsLimit)
       break;
     // Collect the DISubprogram.
     auto *SP = F.getSubprogram();
     DebugInfoBeforePass.DIFunctions.insert({&F, SP});
     if (SP) {
       LLVM_DEBUG(dbgs() << "  Collecting subprogram: " << *SP << '\n');
-      for (const DINode *DN : SP->getRetainedNodes()) {
+      for (const MDNode *DN : SP->getRetainedNodes()) {
         if (const auto *DV = dyn_cast<DILocalVariable>(DN)) {
           DebugInfoBeforePass.DIVariables[DV] = 0;
         }
       }
     }
 
     for (BasicBlock &BB : F) {
       // Collect debug locations (!dbg) and debug variable intrinsics.
if (!DebugInfoBeforePass.DIFunctions.count(&F))
       continue;
     // TODO: Collect metadata other than DISubprograms.
     // Collect the DISubprogram.
     auto *SP = F.getSubprogram();
     DebugInfoAfterPass.DIFunctions.insert({&F, SP});
 
     if (SP) {
       LLVM_DEBUG(dbgs() << "  Collecting subprogram: " << *SP << '\n');
-      for (const DINode *DN : SP->getRetainedNodes()) {
+      for (const MDNode *DN : SP->getRetainedNodes()) {
         if (const auto *DV = dyn_cast<DILocalVariable>(DN)) {
           DebugInfoAfterPass.DIVariables[DV] = 0;
         }
       }
     }
 
     for (BasicBlock &BB : F) {
       // Collect debug locations (!dbg) and debug variable intrinsics.

llvm/test/Bitcode/DIModule-fortran-external-module.ll

 !omp_offload.info = !{}
 
 !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
 !1 = distinct !DIGlobalVariable(name: "dummy", linkageName: "external_module_mp_dummy_", scope: !2, file: !3, line: 1, type: !14, isLocal: false, isDefinition: true)
 !2 = distinct !DISubprogram(name: "use_external_module", linkageName: "MAIN__", scope: !3, file: !3, line: 1, type: !4, scopeLine: 1, spFlags: DISPFlagDefinition, unit: !6, retainedNodes: !12)
 !3 = !DIFile(filename: "em.f90", directory: "tests")
 !4 = !DISubroutineType(types: !5)
 !5 = !{null}
-!6 = distinct !DICompileUnit(language: DW_LANG_Fortran95, file: !3, producer: "Intel(R) Fortran 21.0-2165", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !7, globals: !8, imports: !9, splitDebugInlining: false, nameTableKind: None)
+!6 = distinct !DICompileUnit(language: DW_LANG_Fortran95, file: !3, producer: "Intel(R) Fortran 21.0-2165", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !7, globals: !7, imports: !7, splitDebugInlining: false, nameTableKind: None)
 !7 = !{}
-!8 = !{!0}
-!9 = !{!10}
 !10 = !DIImportedEntity(tag: DW_TAG_imported_module, scope: !2, entity: !11, file: !3, line: 2)
 !11 = !DIModule(scope: !2, name: "external_module", isDecl: true)
-!12 = !{!13}
+!12 = !{!0, !10, !13}
 !13 = !DILocalVariable(name: "x", scope: !2, file: !3, line: 5, type: !14)
 !14 = !DIBasicType(name: "REAL*4", size: 32, encoding: DW_ATE_float)
 !15 = !{i32 2, !"Debug Info Version", i32 3}
 !16 = !{i32 2, !"Dwarf Version", i32 4}
 !17 = !DILocation(line: 5, column: 12, scope: !2)
 !18 = !DILocation(line: 1, column: 9, scope: !2)
 !19 = !DILocation(line: 6, column: 4, scope: !2)
 !20 = !DILocation(line: 6, column: 12, scope: !2)
 !21 = !DILocation(line: 8, column: 1, scope: !2)

llvm/test/Bitcode/upgrade-cu-static-locals.ll

+; Test moving of local static variables from DICompileUnit 'globals' to DISubprogram's 'retainedNodes'
+;
+; RUN: llvm-dis -o - %s.bc | FileCheck %s
+
+; Function Attrs: norecurse nounwind
+define dso_local i32 @foo() local_unnamed_addr #0 !dbg !2 {
+  ret i32 0
+}
+
+define dso_local i32 @abc() local_unnamed_addr #0 !dbg !31 {
+  ret i32 0
+}
+
+define dso_local i32 @xyz() local_unnamed_addr #0 !dbg !32 {
+  ret i32 0
+}
+
+attributes #0 = { noinline optnone }
+
+!llvm.dbg.cu = !{!7, !30}
+!llvm.module.flags = !{!16, !17, !18}
+!llvm.ident = !{!19}
+ 
+; CHECK: ![[CU:[0-9]+]] = distinct !DICompileUnit(language: DW_LANG_C99, file: ![[F_TEST:[0-9]+]], producer: "clang version 8.0.20181009 ", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !{{.*}}, globals: ![[CU_GLOBALS:[0-9]+]]
+; CHECK: ![[CU_GLOBALS]] = !{![[AEXPR:[0-9]+]]}
+; CHECK: ![[AEXPR]] = !DIGlobalVariableExpression(var: ![[A:[0-9]+]]
+; CHECK: ![[A]] = distinct !DIGlobalVariable(name: "a", scope: ![[CU]]
+
+; CHECK: ![[CU30:[0-9]+]] = distinct !DICompileUnit(language: DW_LANG_C99, file: ![[F_TEST2:[0-9]+]], producer: "clang version 8.0.20181009 ", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !{{.*}}, globals: ![[CU30_GLOBALS:[0-9]+]]
+; CHECK: ![[CU30_GLOBALS]] = !{![[CAP_A_EXPR:[0-9]+]], ![[CAP_B_EXPR:[0-9]+]]}
+; CHECK: ![[CAP_A_EXPR]] = !DIGlobalVariableExpression(var: ![[CAP_A:[0-9]+]]
+; CHECK: ![[CAP_A]] = distinct !DIGlobalVariable(name: "A", scope: ![[CU30_GLOBALS:[0-9]+]]
+; CHECK: ![[CAP_B_EXPR]] = !DIGlobalVariableExpression(var: ![[CAP_B:[0-9]+]]
+; CHECK: ![[CAP_B]] = distinct !DIGlobalVariable(name: "B", scope: ![[CU30_GLOBALS:[0-9]+]]
+
+; CHECK: ![[FOO:[0-9]+]] = distinct !DISubprogram(name: "foo", scope: ![[F_TEST]], file: ![[F_TEST]], line: 2, type: !{{.*}}, scopeLine: 2, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: ![[CU]], retainedNodes: ![[FOO_RETAINED:[0-9]+]])
+; CHECK: ![[FOO_RETAINED]] = !{![[B_EXPR:[0-9]+]]}
+; CHECK: ![[B_EXPR]] = !DIGlobalVariableExpression(var: ![[B:[0-9]+]]
+; CHECK: ![[B]] = distinct !DIGlobalVariable(name: "b", scope: ![[FOO:[0-9]+]]
+
+; CHECK: ![[ABC:[0-9]+]] = distinct !DISubprogram(name: "abc", scope: ![[CU30]], file: ![[F_TEST2]], line: 2, type: !{{.*}}, scopeLine: 2, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: ![[CU30]], retainedNodes: ![[ABC_RETAINED:[0-9]+]])
+; CHECK: ![[ABC_RETAINED]] = !{![[ABC_A_EXPR:[0-9]+]], ![[ABC_B_EXPR:[0-9]+]]}
+; CHECK: ![[ABC_A_EXPR]] = !DIGlobalVariableExpression(var: ![[ABC_A:[0-9]+]]
+; CHECK: ![[ABC_A]] = distinct !DIGlobalVariable(name: "a", scope: ![[ABC]]
+; CHECK: ![[ABC_B_EXPR]] = !DIGlobalVariableExpression(var: ![[ABC_B:[0-9]+]]
+; CHECK: ![[ABC_B]] = distinct !DIGlobalVariable(name: "b", scope: ![[ABC]]
+
+; CHECK: ![[XYZ:[0-9]+]] = distinct !DISubprogram(name: "xyz", scope: ![[CU30]], file: ![[F_TEST2]], line: 2, type: !{{.*}}, scopeLine: 2, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: ![[CU30]], retainedNodes: ![[XYZ_RETAINED:[0-9]+]])
+; CHECK: ![[XYZ_RETAINED]] = !{![[XYZ_I:[0-9]+]], ![[XYZ_C_EXPR:[0-9]+]]}
+; CHECK: ![[XYZ_I]] = !DILocalVariable(name: "i", arg: 1, scope: ![[XYZ]], file: ![[F_TEST2]]
+; CHECK: ![[XYZ_C_EXPR]] = !DIGlobalVariableExpression(var: ![[XYZ_C:[0-9]+]]
+; CHECK: ![[XYZ_C]] = distinct !DIGlobalVariable(name: "c", scope: ![[XYZ]]
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "b", scope: !2, file: !3, line: 3, type: !14, isLocal: true, isDefinition: true)
+!2 = distinct !DISubprogram(name: "foo", scope: !3, file: !3, line: 2, type: !4, isLocal: false, isDefinition: true, scopeLine: 2, isOptimized: true, unit: !7, retainedNodes: !8)
+!3 = !DIFile(filename: "test.c", directory: "/home/yhs/work/tests/llvm/bug")
+!4 = !DISubroutineType(types: !5)
+!5 = !{!6}
+!6 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!7 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang version 8.0.20181009 ", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !8, globals: !9, nameTableKind: None)
+!8 = !{}
+!9 = !{!0, !10}
+!10 = !DIGlobalVariableExpression(var: !11, expr: !DIExpression())
+!11 = distinct !DIGlobalVariable(name: "a", scope: !7, file: !3, line: 1, type: !12, isLocal: true, isDefinition: true)
+!12 = !DIDerivedType(tag: DW_TAG_volatile_type, baseType: !13)
+!13 = !DIBasicType(name: "char", size: 8, encoding: DW_ATE_signed_char)
+!14 = !DIDerivedType(tag: DW_TAG_volatile_type, baseType: !15)
+!15 = !DIBasicType(name: "short", size: 16, encoding: DW_ATE_signed)
+!16 = !{i32 2, !"Dwarf Version", i32 4}
+!17 = !{i32 2, !"Debug Info Version", i32 3}
+!18 = !{i32 1, !"wchar_size", i32 4}
+!19 = !{!"clang version 8.0.20181009 "}
+!20 = !DILocation(line: 4, column: 10, scope: !2)
+!21 = !{!22, !22, i64 0}
+!22 = !{!"omnipotent char", !23, i64 0}
+!23 = !{!"Simple C/C++ TBAA"}
+!24 = !DILocation(line: 4, column: 14, scope: !2)
+!25 = !{!26, !26, i64 0}
+!26 = !{!"short", !22, i64 0}
+!27 = !DILocation(line: 4, column: 12, scope: !2)
+
+; Check CU with several global and several local static variables.
+!30 = distinct !DICompileUnit(language: DW_LANG_C99, file: !50, producer: "clang version 8.0.20181009 ", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !8, globals: !45, nameTableKind: None)
+
+!31 = distinct !DISubprogram(name: "abc", scope: !30, file: !50, line: 2, type: !4, isLocal: false, isDefinition: true, scopeLine: 2, isOptimized: true, unit: !30, retainedNodes: !8)
+!32 = distinct !DISubprogram(name: "xyz", scope: !30, file: !50, line: 2, type: !4, isLocal: false, isDefinition: true, scopeLine: 2, isOptimized: true, unit: !30, retainedNodes: !46)
+
+; Globals
+!33 = !DIGlobalVariableExpression(var: !34, expr: !DIExpression())
+!34 = distinct !DIGlobalVariable(name: "A", scope: !30, file: !50, line: 1, type: !12, isLocal: true, isDefinition: true)
+!35 = !DIGlobalVariableExpression(var: !36, expr: !DIExpression())
+!36 = distinct !DIGlobalVariable(name: "B", scope: !30, file: !50, line: 1, type: !12, isLocal: true, isDefinition: true)
+
+; Static locals of abc
+!37 = !DIGlobalVariableExpression(var: !38, expr: !DIExpression())
+!38 = distinct !DIGlobalVariable(name: "a", scope: !31, file: !50, line: 3, type: !14, isLocal: true, isDefinition: true)
+!39 = !DIGlobalVariableExpression(var: !40, expr: !DIExpression())
+!40 = distinct !DIGlobalVariable(name: "b", scope: !31, file: !50, line: 3, type: !14, isLocal: true, isDefinition: true)
+
+; Locals of xyz
+!41 = !DIGlobalVariableExpression(var: !42, expr: !DIExpression())
+!42 = distinct !DIGlobalVariable(name: "c", scope: !32, file: !50, line: 3, type: !14, isLocal: true, isDefinition: true)
+!43 = !DILocalVariable(name: "i", line: 2, arg: 1, scope: !32, file: !50, type: !14)
+
+!45 = !{!37, !33, !39, !35, !41}
+!46 = !{!43}
+!50 = !DIFile(filename: "test2.c", directory: "/home/yhs/work/tests/llvm/bug")

llvm/test/CodeGen/AArch64/arm64-2011-03-17-AsmPrinterCrash.ll

 declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
 
 attributes #0 = { nounwind ssp }
 attributes #1 = { nounwind readnone }
 
 !llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!9, !10}
 
-!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 3.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, globals: !2)
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 3.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug)
 !1 = !DIFile(filename: "print.i", directory: "/Volumes/Ebi/echeng/radars/r9146594")
 !2 = !{!3}
 !3 = !DIGlobalVariableExpression(var: !4, expr: !DIExpression())
 !4 = !DIGlobalVariable(name: "vsplive", scope: !5, file: !1, line: 617, type: !8, isLocal: true, isDefinition: true)
-!5 = distinct !DISubprogram(name: "drt_vsprintf", scope: !1, file: !1, line: 616, type: !6, isLocal: false, isDefinition: true, virtualIndex: 6, flags: DIFlagPrototyped, isOptimized: false, unit: !0)
+!5 = distinct !DISubprogram(name: "drt_vsprintf", scope: !1, file: !1, line: 616, type: !6, isLocal: false, isDefinition: true, virtualIndex: 6, flags: DIFlagPrototyped, isOptimized: false, unit: !0, retainedNodes: !2)
 !6 = !DISubroutineType(types: !7)
 !7 = !{!8}
 !8 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
 !9 = !{i32 2, !"Debug Info Version", i32 3}
 !10 = !{i32 2, !"Dwarf Version", i32 2}
 !11 = !DILocation(line: 653, column: 5, scope: !12)
 !12 = distinct !DILexicalBlock(scope: !13, file: !1, line: 652, column: 35)
 !13 = distinct !DILexicalBlock(scope: !5, file: !1, line: 616, column: 1)
 !14 = !DILocalVariable(name: "do_tab_convert", scope: !15, file: !1, line: 853, type: !8)
 !15 = distinct !DILexicalBlock(scope: !12, file: !1, line: 850, column: 12)
 !16 = !DIExpression()
 !17 = !DILocation(line: 853, column: 11, scope: !15)
 !18 = !DILocation(line: 853, column: 29, scope: !15)
 

llvm/test/CodeGen/BPF/BTF/static-var-inited-sec.ll

 attributes #0 = { norecurse nounwind "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "frame-pointer"="all" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
 
 !llvm.dbg.cu = !{!7}
 !llvm.module.flags = !{!16, !17, !18}
 !llvm.ident = !{!19}
 
 !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
 !1 = distinct !DIGlobalVariable(name: "b", scope: !2, file: !3, line: 3, type: !14, isLocal: true, isDefinition: true)
-!2 = distinct !DISubprogram(name: "foo", scope: !3, file: !3, line: 2, type: !4, isLocal: false, isDefinition: true, scopeLine: 2, isOptimized: true, unit: !7, retainedNodes: !8)
+!2 = distinct !DISubprogram(name: "foo", scope: !3, file: !3, line: 2, type: !4, isLocal: false, isDefinition: true, scopeLine: 2, isOptimized: true, unit: !7, retainedNodes: !29)
 !3 = !DIFile(filename: "test.c", directory: "/home/yhs/work/tests/llvm/bug")
 !4 = !DISubroutineType(types: !5)
 !5 = !{!6}
 !6 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
 !7 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang version 8.0.20181009 ", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !8, globals: !9, nameTableKind: None)
 !8 = !{}
-!9 = !{!0, !10}
+!9 = !{!10}
 !10 = !DIGlobalVariableExpression(var: !11, expr: !DIExpression())
 !11 = distinct !DIGlobalVariable(name: "a", scope: !7, file: !3, line: 1, type: !12, isLocal: true, isDefinition: true)
 !12 = !DIDerivedType(tag: DW_TAG_volatile_type, baseType: !13)
 !13 = !DIBasicType(name: "char", size: 8, encoding: DW_ATE_signed_char)
 !14 = !DIDerivedType(tag: DW_TAG_volatile_type, baseType: !15)
 !15 = !DIBasicType(name: "short", size: 16, encoding: DW_ATE_signed)
 !16 = !{i32 2, !"Dwarf Version", i32 4}
 !17 = !{i32 2, !"Debug Info Version", i32 3}
 !18 = !{i32 1, !"wchar_size", i32 4}
 !19 = !{!"clang version 8.0.20181009 "}
 !20 = !DILocation(line: 4, column: 10, scope: !2)
 !21 = !{!22, !22, i64 0}
 !22 = !{!"omnipotent char", !23, i64 0}
 !23 = !{!"Simple C/C++ TBAA"}
 !24 = !DILocation(line: 4, column: 14, scope: !2)
 !25 = !{!26, !26, i64 0}
 !26 = !{!"short", !22, i64 0}
 !27 = !DILocation(line: 4, column: 12, scope: !2)
 !28 = !DILocation(line: 4, column: 3, scope: !2)
+!29 = !{!0}

llvm/test/CodeGen/BPF/BTF/static-var-inited.ll

 attributes #0 = { norecurse nounwind "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "frame-pointer"="all" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
 
 !llvm.dbg.cu = !{!7}
 !llvm.module.flags = !{!16, !17, !18}
 !llvm.ident = !{!19}
 
 !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
 !1 = distinct !DIGlobalVariable(name: "b", scope: !2, file: !3, line: 3, type: !14, isLocal: true, isDefinition: true)
-!2 = distinct !DISubprogram(name: "foo", scope: !3, file: !3, line: 2, type: !4, isLocal: false, isDefinition: true, scopeLine: 2, isOptimized: true, unit: !7, retainedNodes: !8)
+!2 = distinct !DISubprogram(name: "foo", scope: !3, file: !3, line: 2, type: !4, isLocal: false, isDefinition: true, scopeLine: 2, isOptimized: true, unit: !7, retainedNodes: !29)
 !3 = !DIFile(filename: "test.c", directory: "/home/yhs/work/tests/llvm/bug")
 !4 = !DISubroutineType(types: !5)
 !5 = !{!6}
 !6 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
 !7 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang version 8.0.20181009 ", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !8, globals: !9, nameTableKind: None)
 !8 = !{}
-!9 = !{!0, !10}
+!9 = !{!10}
 !10 = !DIGlobalVariableExpression(var: !11, expr: !DIExpression())
 !11 = distinct !DIGlobalVariable(name: "a", scope: !7, file: !3, line: 1, type: !12, isLocal: true, isDefinition: true)
 !12 = !DIDerivedType(tag: DW_TAG_volatile_type, baseType: !13)
 !13 = !DIBasicType(name: "char", size: 8, encoding: DW_ATE_signed_char)
 !14 = !DIDerivedType(tag: DW_TAG_volatile_type, baseType: !15)
 !15 = !DIBasicType(name: "short", size: 16, encoding: DW_ATE_signed)
 !16 = !{i32 2, !"Dwarf Version", i32 4}
 !17 = !{i32 2, !"Debug Info Version", i32 3}
 !18 = !{i32 1, !"wchar_size", i32 4}
 !19 = !{!"clang version 8.0.20181009 "}
 !20 = !DILocation(line: 4, column: 10, scope: !2)
 !21 = !{!22, !22, i64 0}
 !22 = !{!"omnipotent char", !23, i64 0}
 !23 = !{!"Simple C/C++ TBAA"}
 !24 = !DILocation(line: 4, column: 14, scope: !2)
 !25 = !{!26, !26, i64 0}
 !26 = !{!"short", !22, i64 0}
 !27 = !DILocation(line: 4, column: 12, scope: !2)
 !28 = !DILocation(line: 4, column: 3, scope: !2)
+!29 = !{!0}

llvm/test/CodeGen/BPF/BTF/static-var-readonly-sec.ll

 attributes #0 = { norecurse nounwind "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "frame-pointer"="all" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
 
 !llvm.dbg.cu = !{!7}
 !llvm.module.flags = !{!18, !19, !20}
 !llvm.ident = !{!21}
 
 !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
 !1 = distinct !DIGlobalVariable(name: "b", scope: !2, file: !3, line: 3, type: !15, isLocal: true, isDefinition: true)
-!2 = distinct !DISubprogram(name: "foo", scope: !3, file: !3, line: 2, type: !4, isLocal: false, isDefinition: true, scopeLine: 2, isOptimized: true, unit: !7, retainedNodes: !8)
+!2 = distinct !DISubprogram(name: "foo", scope: !3, file: !3, line: 2, type: !4, isLocal: false, isDefinition: true, scopeLine: 2, isOptimized: true, unit: !7, retainedNodes: !31)
 !3 = !DIFile(filename: "test.c", directory: "/home/yhs/work/tests/llvm/bug")
 !4 = !DISubroutineType(types: !5)
 !5 = !{!6}
 !6 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
 !7 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang version 8.0.20181009 ", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !8, globals: !9, nameTableKind: None)
 !8 = !{}
-!9 = !{!0, !10}
+!9 = !{!10}
 !10 = !DIGlobalVariableExpression(var: !11, expr: !DIExpression())
 !11 = distinct !DIGlobalVariable(name: "a", scope: !7, file: !3, line: 1, type: !12, isLocal: true, isDefinition: true)
 !12 = !DIDerivedType(tag: DW_TAG_const_type, baseType: !13)
 !13 = !DIDerivedType(tag: DW_TAG_volatile_type, baseType: !14)
 !14 = !DIBasicType(name: "char", size: 8, encoding: DW_ATE_signed_char)
 !15 = !DIDerivedType(tag: DW_TAG_const_type, baseType: !16)
 !16 = !DIDerivedType(tag: DW_TAG_volatile_type, baseType: !17)
 !17 = !DIBasicType(name: "short", size: 16, encoding: DW_ATE_signed)
 !18 = !{i32 2, !"Dwarf Version", i32 4}
 !19 = !{i32 2, !"Debug Info Version", i32 3}
 !20 = !{i32 1, !"wchar_size", i32 4}
 !21 = !{!"clang version 8.0.20181009 "}
 !22 = !DILocation(line: 4, column: 10, scope: !2)
 !23 = !{!24, !24, i64 0}
 !24 = !{!"omnipotent char", !25, i64 0}
 !25 = !{!"Simple C/C++ TBAA"}
 !26 = !DILocation(line: 4, column: 14, scope: !2)
 !27 = !{!28, !28, i64 0}
 !28 = !{!"short", !24, i64 0}
 !29 = !DILocation(line: 4, column: 12, scope: !2)
 !30 = !DILocation(line: 4, column: 3, scope: !2)
+!31 = !{!0}

llvm/test/CodeGen/BPF/BTF/static-var-readonly.ll

 attributes #0 = { norecurse nounwind "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "frame-pointer"="all" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
 
 !llvm.dbg.cu = !{!7}
 !llvm.module.flags = !{!18, !19, !20}
 !llvm.ident = !{!21}
 
 !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
 !1 = distinct !DIGlobalVariable(name: "b", scope: !2, file: !3, line: 3, type: !15, isLocal: true, isDefinition: true)
-!2 = distinct !DISubprogram(name: "foo", scope: !3, file: !3, line: 2, type: !4, isLocal: false, isDefinition: true, scopeLine: 2, isOptimized: true, unit: !7, retainedNodes: !8)
+!2 = distinct !DISubprogram(name: "foo", scope: !3, file: !3, line: 2, type: !4, isLocal: false, isDefinition: true, scopeLine: 2, isOptimized: true, unit: !7, retainedNodes: !31)
 !3 = !DIFile(filename: "test.c", directory: "/home/yhs/work/tests/llvm/bug")
 !4 = !DISubroutineType(types: !5)
 !5 = !{!6}
 !6 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
 !7 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang version 8.0.20181009 ", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !8, globals: !9, nameTableKind: None)
 !8 = !{}
-!9 = !{!0, !10}
+!9 = !{!10}
 !10 = !DIGlobalVariableExpression(var: !11, expr: !DIExpression())
 !11 = distinct !DIGlobalVariable(name: "a", scope: !7, file: !3, line: 1, type: !12, isLocal: true, isDefinition: true)
 !12 = !DIDerivedType(tag: DW_TAG_const_type, baseType: !13)
 !13 = !DIDerivedType(tag: DW_TAG_volatile_type, baseType: !14)
 !14 = !DIBasicType(name: "char", size: 8, encoding: DW_ATE_signed_char)
 !15 = !DIDerivedType(tag: DW_TAG_const_type, baseType: !16)
 !16 = !DIDerivedType(tag: DW_TAG_volatile_type, baseType: !17)
 !17 = !DIBasicType(name: "short", size: 16, encoding: DW_ATE_signed)
 !18 = !{i32 2, !"Dwarf Version", i32 4}
 !19 = !{i32 2, !"Debug Info Version", i32 3}
 !20 = !{i32 1, !"wchar_size", i32 4}
 !21 = !{!"clang version 8.0.20181009 "}
 !22 = !DILocation(line: 4, column: 10, scope: !2)
 !23 = !{!24, !24, i64 0}
 !24 = !{!"omnipotent char", !25, i64 0}
 !25 = !{!"Simple C/C++ TBAA"}
 !26 = !DILocation(line: 4, column: 14, scope: !2)
 !27 = !{!28, !28, i64 0}
 !28 = !{!"short", !24, i64 0}
 !29 = !DILocation(line: 4, column: 12, scope: !2)
 !30 = !DILocation(line: 4, column: 3, scope: !2)
+!31 = !{!0}

llvm/test/CodeGen/BPF/BTF/static-var-sec.ll

 attributes #0 = { norecurse nounwind "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "frame-pointer"="all" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
 
 !llvm.dbg.cu = !{!7}
 !llvm.module.flags = !{!16, !17, !18}
 !llvm.ident = !{!19}
 
 !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
 !1 = distinct !DIGlobalVariable(name: "b", scope: !2, file: !3, line: 3, type: !14, isLocal: true, isDefinition: true)
-!2 = distinct !DISubprogram(name: "foo", scope: !3, file: !3, line: 2, type: !4, isLocal: false, isDefinition: true, scopeLine: 2, isOptimized: true, unit: !7, retainedNodes: !8)
+!2 = distinct !DISubprogram(name: "foo", scope: !3, file: !3, line: 2, type: !4, isLocal: false, isDefinition: true, scopeLine: 2, isOptimized: true, unit: !7, retainedNodes: !29)
 !3 = !DIFile(filename: "test.c", directory: "/home/yhs/work/tests/llvm/bug")
 !4 = !DISubroutineType(types: !5)
 !5 = !{!6}
 !6 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
 !7 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang version 8.0.20181009 ", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !8, globals: !9, nameTableKind: None)
 !8 = !{}
-!9 = !{!0, !10}
+!9 = !{!10}
 !10 = !DIGlobalVariableExpression(var: !11, expr: !DIExpression())
 !11 = distinct !DIGlobalVariable(name: "a", scope: !7, file: !3, line: 1, type: !12, isLocal: true, isDefinition: true)
 !12 = !DIDerivedType(tag: DW_TAG_volatile_type, baseType: !13)
 !13 = !DIBasicType(name: "char", size: 8, encoding: DW_ATE_signed_char)
 !14 = !DIDerivedType(tag: DW_TAG_volatile_type, baseType: !15)
 !15 = !DIBasicType(name: "short", size: 16, encoding: DW_ATE_signed)
 !16 = !{i32 2, !"Dwarf Version", i32 4}
 !17 = !{i32 2, !"Debug Info Version", i32 3}
 !18 = !{i32 1, !"wchar_size", i32 4}
 !19 = !{!"clang version 8.0.20181009 "}
 !20 = !DILocation(line: 4, column: 10, scope: !2)
 !21 = !{!22, !22, i64 0}
 !22 = !{!"omnipotent char", !23, i64 0}
 !23 = !{!"Simple C/C++ TBAA"}
 !24 = !DILocation(line: 4, column: 14, scope: !2)
 !25 = !{!26, !26, i64 0}
 !26 = !{!"short", !22, i64 0}
 !27 = !DILocation(line: 4, column: 12, scope: !2)
 !28 = !DILocation(line: 4, column: 3, scope: !2)
+!29 = !{!0}

llvm/test/CodeGen/BPF/BTF/static-var.ll

 attributes #0 = { norecurse nounwind "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "frame-pointer"="all" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
 
 !llvm.dbg.cu = !{!7}
 !llvm.module.flags = !{!16, !17, !18}
 !llvm.ident = !{!19}
 
 !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
 !1 = distinct !DIGlobalVariable(name: "b", scope: !2, file: !3, line: 3, type: !14, isLocal: true, isDefinition: true)
-!2 = distinct !DISubprogram(name: "foo", scope: !3, file: !3, line: 2, type: !4, isLocal: false, isDefinition: true, scopeLine: 2, isOptimized: true, unit: !7, retainedNodes: !8)
+!2 = distinct !DISubprogram(name: "foo", scope: !3, file: !3, line: 2, type: !4, isLocal: false, isDefinition: true, scopeLine: 2, isOptimized: true, unit: !7, retainedNodes: !29)
 !3 = !DIFile(filename: "test.c", directory: "/home/yhs/work/tests/llvm/bug")
 !4 = !DISubroutineType(types: !5)
 !5 = !{!6}
 !6 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
 !7 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang version 8.0.20181009 ", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !8, globals: !9, nameTableKind: None)
 !8 = !{}
-!9 = !{!0, !10}
+!9 = !{!10}
 !10 = !DIGlobalVariableExpression(var: !11, expr: !DIExpression())
 !11 = distinct !DIGlobalVariable(name: "a", scope: !7, file: !3, line: 1, type: !12, isLocal: true, isDefinition: true)
 !12 = !DIDerivedType(tag: DW_TAG_volatile_type, baseType: !13)
 !13 = !DIBasicType(name: "char", size: 8, encoding: DW_ATE_signed_char)
 !14 = !DIDerivedType(tag: DW_TAG_volatile_type, baseType: !15)
 !15 = !DIBasicType(name: "short", size: 16, encoding: DW_ATE_signed)
 !16 = !{i32 2, !"Dwarf Version", i32 4}
 !17 = !{i32 2, !"Debug Info Version", i32 3}
 !18 = !{i32 1, !"wchar_size", i32 4}
 !19 = !{!"clang version 8.0.20181009 "}
 !20 = !DILocation(line: 4, column: 10, scope: !2)
 !21 = !{!22, !22, i64 0}
 !22 = !{!"omnipotent char", !23, i64 0}
 !23 = !{!"Simple C/C++ TBAA"}
 !24 = !DILocation(line: 4, column: 14, scope: !2)
 !25 = !{!26, !26, i64 0}
 !26 = !{!"short", !22, i64 0}
 !27 = !DILocation(line: 4, column: 12, scope: !2)
 !28 = !DILocation(line: 4, column: 3, scope: !2)
+!29 = !{!0}

llvm/test/CodeGen/BPF/dwarfdump.ll

 
 !0 = distinct !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
 !1 = !DIGlobalVariable(name: "myvar_c", scope: !2, file: !3, line: 3, type: !6, isLocal: true, isDefinition: true)
 !2 = distinct !DISubprogram(name: "testprog", scope: !3, file: !3, line: 1, type: !4, isLocal: false, isDefinition: true, scopeLine: 2, flags: DIFlagPrototyped, isOptimized: true, unit: !7, retainedNodes: !10)
 !3 = !DIFile(filename: "testprog.c", directory: "/w/llvm/bld")
 !4 = !DISubroutineType(types: !5)
 !5 = !{!6, !6, !6}
 !6 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
-!7 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang version 4.0.0 (trunk 287518) (llvm/trunk 287520)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !8, globals: !9)
+!7 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang version 4.0.0 (trunk 287518) (llvm/trunk 287520)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !8)
 !8 = !{}
-!9 = !{!0}
-!10 = !{!11, !12}
+!10 = !{!0, !11, !12}
 !11 = !DILocalVariable(name: "myvar_a", arg: 1, scope: !2, file: !3, line: 1, type: !6)
 !12 = !DILocalVariable(name: "myvar_b", arg: 2, scope: !2, file: !3, line: 1, type: !6)
 !13 = !{i32 2, !"Dwarf Version", i32 4}
 !14 = !{i32 2, !"Debug Info Version", i32 3}
 !15 = !{!"clang version 4.0.0 (trunk 287518) (llvm/trunk 287520)"}
 !16 = !DIExpression()
 !17 = !DILocation(line: 1, column: 18, scope: !2)
 !18 = !DILocation(line: 1, column: 31, scope: !2)

llvm/test/CodeGen/PowerPC/pr24546.ll

 attributes #1 = { "disable-tail-calls"="false" "less-precise-fpmad"="false" "frame-pointer"="all" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="ppc64le" "target-features"="+altivec,+bpermd,+crypto,+direct-move,+extdiv,+power8-vector,+vsx" "unsafe-fp-math"="false" "use-soft-float"="false" }
 attributes #2 = { nounwind readnone }
 attributes #3 = { nounwind }
 
 !llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!29, !30}
 !llvm.ident = !{!31}
 
-!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 3.8.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, retainedTypes: !3, globals: !23)
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 3.8.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, retainedTypes: !3)
 !1 = !DIFile(filename: "testcase.i", directory: "/tmp/glibc.build")
 !2 = !{}
 !3 = !{!4}
 !4 = !DIBasicType(name: "double", size: 64, align: 64, encoding: DW_ATE_float)
 !6 = distinct !DISubprogram(name: "_php_math_round", scope: !1, file: !1, line: 15, type: !7, isLocal: false, isDefinition: true, scopeLine: 16, flags: DIFlagPrototyped, isOptimized: true, unit: !0, retainedNodes: !10)
 !7 = !DISubroutineType(types: !8)
 !8 = !{!4, !4, !9, !9}
 !9 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
 !10 = !{!11, !12, !13, !14, !15, !16, !17}
 !11 = !DILocalVariable(name: "value", arg: 1, scope: !6, file: !1, line: 15, type: !4)
 !12 = !DILocalVariable(name: "places", arg: 2, scope: !6, file: !1, line: 15, type: !9)
 !13 = !DILocalVariable(name: "mode", arg: 3, scope: !6, file: !1, line: 15, type: !9)
 !14 = !DILocalVariable(name: "f1", scope: !6, file: !1, line: 17, type: !4)
 !15 = !DILocalVariable(name: "f2", scope: !6, file: !1, line: 17, type: !4)
 !16 = !DILocalVariable(name: "tmp_value", scope: !6, file: !1, line: 18, type: !4)
 !17 = !DILocalVariable(name: "precision_places", scope: !6, file: !1, line: 19, type: !9)
 !18 = distinct !DISubprogram(name: "php_intpow10", scope: !1, file: !1, line: 1, type: !19, isLocal: true, isDefinition: true, scopeLine: 2, flags: DIFlagPrototyped, isOptimized: true, unit: !0, retainedNodes: !21)
 !19 = !DISubroutineType(types: !20)
 !20 = !{!4, !9}
-!21 = !{!22}
+!21 = !{!22, !24}
 !22 = !DILocalVariable(name: "power", arg: 1, scope: !18, file: !1, line: 1, type: !9)
-!23 = !{!24}
 !24 = !DIGlobalVariableExpression(var: !DIGlobalVariable(name: "powers", scope: !18, file: !1, line: 3, type: !25, isLocal: true, isDefinition: true), expr: !DIExpression())
 !25 = !DICompositeType(tag: DW_TAG_array_type, baseType: !26, size: 1472, align: 64, elements: !27)
 !26 = !DIDerivedType(tag: DW_TAG_const_type, baseType: !4)
 !27 = !{!28}
 !28 = !DISubrange(count: 23)
 !29 = !{i32 2, !"Dwarf Version", i32 4}
 !30 = !{i32 2, !"Debug Info Version", i32 3}
 !31 = !{!"clang version 3.8.0"}

llvm/test/CodeGen/X86/dbg-distringtype-uint.ll

 !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
 !1 = distinct !DIGlobalVariable(name: "elemnt", linkageName: "semiempirical_corrections_mp_esym_$ELEMNT", scope: !2, file: !3, line: 17, type: !16, isLocal: true, isDefinition: true)
 !2 = distinct !DISubprogram(name: "esym", linkageName: "semiempirical_corrections_mp_esym_", scope: !4, file: !3, line: 15, type: !5, scopeLine: 15, spFlags: DISPFlagDefinition, unit: !8, retainedNodes: !11)
 !3 = !DIFile(filename: "se6.f90", directory: "/iusers/cchen15/examples/tests/jr30349/gamess-dga-main/object")
 !4 = !DIModule(scope: null, name: "semiempirical_corrections", file: !3, line: 1)
 !5 = !DISubroutineType(types: !6)
 !6 = !{!7}
 !7 = !DIStringType(name: "CHARACTER_0", size: 64)
-!8 = distinct !DICompileUnit(language: DW_LANG_Fortran95, file: !3, producer: "Intel(R) Fortran 21.0-2745", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !9, globals: !10, splitDebugInlining: false, nameTableKind: None)
+!8 = distinct !DICompileUnit(language: DW_LANG_Fortran95, file: !3, producer: "Intel(R) Fortran 21.0-2745", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !9, splitDebugInlining: false, nameTableKind: None)
 !9 = !{}
-!10 = !{!0}
-!11 = !{!12, !14}
+!11 = !{!0, !12, !14}
 !12 = !DILocalVariable(name: "esym", arg: 1, scope: !2, file: !3, line: 15, type: !13, flags: DIFlagArtificial)
 !13 = !DIStringType(name: "CHARACTER_1", size: 64)
 !14 = !DILocalVariable(name: "i", arg: 2, scope: !2, file: !3, line: 15, type: !15)
 !15 = !DIBasicType(name: "INTEGER*4", size: 32, encoding: DW_ATE_signed)
 !16 = !DICompositeType(tag: DW_TAG_array_type, baseType: !17, elements: !18)
 !17 = !DIStringType(name: "CHARACTER_2", size: 64)
 !18 = !{!19}
 !19 = !DISubrange(count: 1, lowerBound: 1)

llvm/test/DebugInfo/COFF/enum-co.ll

 attributes #1 = { nounwind readnone speculatable }
 
 !llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!25, !26, !27, !28}
 !llvm.ident = !{!29}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 8.0.0", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, nameTableKind: None)
 !1 = !DIFile(filename: "enum-co.cpp", directory: "D:\5Cupstream\5Cllvm\5Ctest\5CDebugInfo\5CCOFF", checksumkind: CSK_MD5, checksum: "2e53b90441669acca735bad28ed3a1ab")
-!2 = !{!3, !8, !13, !18}
+!2 = !{!3, !8, !18}
 !3 = !DICompositeType(tag: DW_TAG_enumeration_type, name: "Enum", file: !1, line: 4, baseType: !4, size: 32, elements: !5, identifier: ".?AW4Enum@@")
 !4 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
 !5 = !{!6, !7}
 !6 = !DIEnumerator(name: "ON", value: 0)
 !7 = !DIEnumerator(name: "OFF", value: 1)
 !8 = !DICompositeType(tag: DW_TAG_enumeration_type, name: "EnumClass", file: !1, line: 7, baseType: !4, size: 32, flags: DIFlagEnumClass, elements: !9, identifier: ".?AW4EnumClass@@")
 !9 = !{!10, !11, !12}
 !10 = !DIEnumerator(name: "RED", value: 0)
 !11 = !DIEnumerator(name: "BLUE", value: 1)
 !12 = !DIEnumerator(name: "NOTCARE", value: 2)
 !13 = !DICompositeType(tag: DW_TAG_enumeration_type, name: "ScopedEnum", scope: !14, file: !1, line: 11, baseType: !4, size: 32, elements: !5, identifier: ".?AW4ScopedEnum@?1??Func@@YAXXZ@")
-!14 = distinct !DISubprogram(name: "Func", linkageName: "?Func@@YAXXZ", scope: !1, file: !1, line: 10, type: !15, isLocal: false, isDefinition: true, scopeLine: 10, flags: DIFlagPrototyped, isOptimized: false, unit: !0, retainedNodes: !17)
+!14 = distinct !DISubprogram(name: "Func", linkageName: "?Func@@YAXXZ", scope: !1, file: !1, line: 10, type: !15, isLocal: false, isDefinition: true, scopeLine: 10, flags: DIFlagPrototyped, isOptimized: false, unit: !0, retainedNodes: !47)
 !15 = !DISubroutineType(types: !16)
 !16 = !{null}
 !17 = !{}
 !18 = !DICompositeType(tag: DW_TAG_enumeration_type, name: "NestedEnum", scope: !19, file: !1, line: 16, baseType: !4, size: 32, elements: !24, identifier: ".?AW4NestedEnum@Union@Struct@?1??Func@@YAXXZ@")
 !19 = distinct !DICompositeType(tag: DW_TAG_union_type, name: "Union", scope: !20, file: !1, line: 15, size: 8, flags: DIFlagTypePassByValue, elements: !23, identifier: ".?ATUnion@Struct@?1??Func@@YAXXZ@")
 !20 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "Struct", scope: !14, file: !1, line: 14, size: 8, flags: DIFlagTypePassByValue, elements: !21, identifier: ".?AUStruct@?1??Func@@YAXXZ@")
 !21 = !{!19, !22}
 !22 = !DIDerivedType(tag: DW_TAG_member, name: "U", scope: !20, file: !1, line: 18, baseType: !19, size: 8)

 !39 = !DIDerivedType(tag: DW_TAG_reference_type, baseType: !8, size: 64)
 !40 = !DILocalVariable(name: "arg", arg: 1, scope: !36, file: !1, line: 8, type: !39)
 !41 = !DILocation(line: 8, scope: !36)
 !42 = !DILocalVariable(name: "SE", scope: !14, file: !1, line: 12, type: !13)
 !43 = !DILocation(line: 12, scope: !14)
 !44 = !DILocalVariable(name: "S", scope: !14, file: !1, line: 20, type: !20)
 !45 = !DILocation(line: 20, scope: !14)
 !46 = !DILocation(line: 21, scope: !14, isImplicitCode: true)
+!47 = !{!13}

llvm/test/DebugInfo/COFF/fortran-basic.ll

 !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
 !1 = distinct !DIGlobalVariable(name: "D", linkageName: "COM", scope: !2, file: !4, line: 5, type: !33, isLocal: false, isDefinition: true)
 !2 = !DICommonBlock(scope: !3, declaration: null, name: "COM", file: !4, line: 8)
 !3 = distinct !DISubprogram(name: "ARRAY", linkageName: "MAIN__", scope: !4, file: !4, line: 1, type: !5, scopeLine: 1, spFlags: DISPFlagDefinition | DISPFlagMainSubprogram, unit: !7, retainedNodes: !26)
 !4 = !DIFile(filename: "fortran-basic.f", directory: "d:\\temp")
 !5 = !DISubroutineType(types: !6)
 !6 = !{null}
 !7 = distinct !DICompileUnit(language: DW_LANG_Fortran95, file: !4, producer: "Fortran", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, globals: !8, splitDebugInlining: false, nameTableKind: None)
-!8 = !{!0, !9, !12, !15, !21}
+!8 = !{!0, !9, !12}
 !9 = !DIGlobalVariableExpression(var: !10, expr: !DIExpression(DW_OP_plus_uconst, 8))
 !10 = distinct !DIGlobalVariable(name: "L", linkageName: "COM", scope: !2, file: !4, line: 6, type: !11, isLocal: false, isDefinition: true)
 !11 = !DIBasicType(name: "LOGICAL*4", size: 32, encoding: DW_ATE_boolean)
 !12 = !DIGlobalVariableExpression(var: !13, expr: !DIExpression(DW_OP_plus_uconst, 12))
 !13 = distinct !DIGlobalVariable(name: "C", linkageName: "COM", scope: !2, file: !4, line: 7, type: !14, isLocal: false, isDefinition: true)
 !14 = !DIStringType(name: "CHARACTER_0", size: 48)
 !15 = !DIGlobalVariableExpression(var: !16, expr: !DIExpression())
 !16 = distinct !DIGlobalVariable(name: "ARRAY2", linkageName: "ARRAY$ARRAY2", scope: !3, file: !4, line: 2, type: !17, isLocal: true, isDefinition: true)
 !17 = !DICompositeType(tag: DW_TAG_array_type, baseType: !18, elements: !19)
 !18 = !DIBasicType(name: "INTEGER*4", size: 32, encoding: DW_ATE_signed)
 !19 = !{!20}
 !20 = !DISubrange(lowerBound: 3, upperBound: 10)
 !21 = !DIGlobalVariableExpression(var: !22, expr: !DIExpression())
 !22 = distinct !DIGlobalVariable(name: "ARRAY1", linkageName: "ARRAY$ARRAY1", scope: !3, file: !4, line: 2, type: !23, isLocal: true, isDefinition: true)
 !23 = !DICompositeType(tag: DW_TAG_array_type, baseType: !18, elements: !24)
 !24 = !{!25}
 !25 = !DISubrange(count: 10, lowerBound: 1)
-!26 = !{!27, !29, !31}
+!26 = !{!15, !21, !27, !29, !31}
 !27 = !DILocalVariable(name: "CMP32", scope: !3, file: !4, line: 10, type: !28)
 !28 = !DIBasicType(name: "COMPLEX*32", size: 256, encoding: DW_ATE_complex_float)
 !29 = !DILocalVariable(name: "CMP16", scope: !3, file: !4, line: 9, type: !30)
 !30 = !DIBasicType(name: "COMPLEX*16", size: 128, encoding: DW_ATE_complex_float)
 !31 = !DILocalVariable(name: "CMP8", scope: !3, file: !4, line: 8, type: !32)
 !32 = !DIBasicType(name: "COMPLEX*8", size: 64, encoding: DW_ATE_complex_float)
 !33 = !DIBasicType(name: "REAL*8", size: 64, encoding: DW_ATE_float)
 !34 = !{i32 7, !"PIC Level", i32 2}

llvm/test/DebugInfo/COFF/fortran-contained-proc.ll

 attributes #4 = { nounwind }
 
 !llvm.module.flags = !{!11, !12, !13}
 !llvm.dbg.cu = !{!6}
 !omp_offload.info = !{}
 
 !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
 !1 = distinct !DIGlobalVariable(name: "A", linkageName: "IF_TEST$A", scope: !2, file: !3, line: 11, type: !9, isLocal: true, isDefinition: true)
-!2 = distinct !DISubprogram(name: "IF_TEST", linkageName: "MAIN__", scope: !3, file: !3, line: 9, type: !4, scopeLine: 9, spFlags: DISPFlagDefinition | DISPFlagMainSubprogram, unit: !6, retainedNodes: !8)
+!2 = distinct !DISubprogram(name: "IF_TEST", linkageName: "MAIN__", scope: !3, file: !3, line: 9, type: !4, scopeLine: 9, spFlags: DISPFlagDefinition | DISPFlagMainSubprogram, unit: !6, retainedNodes: !7)
 !3 = !DIFile(filename: "tr1.f90", directory: "d:\\iusers\\cchen15\\examples\\tests\\jr14335")
 !4 = !DISubroutineType(types: !5)
 !5 = !{null}
-!6 = distinct !DICompileUnit(language: DW_LANG_Fortran95, file: !3, producer: "Intel(R) Fortran 22.0-1087", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, globals: !7, splitDebugInlining: false, nameTableKind: None)
+!6 = distinct !DICompileUnit(language: DW_LANG_Fortran95, file: !3, producer: "Intel(R) Fortran 22.0-1087", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, globals: !8, splitDebugInlining: false, nameTableKind: None)
 !7 = !{!0}
 !8 = !{}
 !9 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !10, size: 64)
 !10 = !DIBasicType(name: "INTEGER*4", size: 32, encoding: DW_ATE_signed)
 !11 = !{i32 7, !"PIC Level", i32 2}
 !12 = !{i32 2, !"Debug Info Version", i32 3}
 !13 = !{i32 2, !"CodeView", i32 1}
 !22 = !DILocation(line: 9, scope: !2)

llvm/test/DebugInfo/COFF/global_visibility.ll

 !llvm.module.flags = !{!40, !41, !42, !43}
 !llvm.ident = !{!44}
 
 !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
 !1 = distinct !DIGlobalVariable(name: "global_int", linkageName: "?global_int@@3HA", scope: !2, file: !3, line: 1, type: !11, isLocal: false, isDefinition: true)
 !2 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !3, producer: "clang version 11.0.0 (https://github.com/llvm/llvm-project.git 202f144bffd0be254a829924195e1b8ebabcbb79)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5, nameTableKind: None)
 !3 = !DIFile(filename: "a.cpp", directory: "F:\\llvm-project\\__test", checksumkind: CSK_MD5, checksum: "66a5399777dc9d37656fb00438bca542")
 !4 = !{}
-!5 = !{!0, !6, !12, !14, !17, !19, !29}
+!5 = !{!0, !19, !29}
 !6 = !DIGlobalVariableExpression(var: !7, expr: !DIExpression())
 !7 = distinct !DIGlobalVariable(name: "local_int", scope: !8, file: !3, line: 15, type: !11, isLocal: true, isDefinition: true)
-!8 = distinct !DISubprogram(name: "foo", linkageName: "?foo@@YAXXZ", scope: !3, file: !3, line: 14, type: !9, scopeLine: 14, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !2, retainedNodes: !4)
+!8 = distinct !DISubprogram(name: "foo", linkageName: "?foo@@YAXXZ", scope: !3, file: !3, line: 14, type: !9, scopeLine: 14, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !2, retainedNodes: !67)
 !9 = !DISubroutineType(types: !10)
 !10 = !{null}
 !11 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
 !12 = !DIGlobalVariableExpression(var: !13, expr: !DIExpression())
 !13 = distinct !DIGlobalVariable(name: "nested_int", scope: !8, file: !3, line: 17, type: !11, isLocal: true, isDefinition: true)
 !14 = !DIGlobalVariableExpression(var: !15, expr: !DIExpression())
 !15 = distinct !DIGlobalVariable(name: "local_int", scope: !16, file: !3, line: 24, type: !11, isLocal: true, isDefinition: true)
-!16 = distinct !DISubprogram(name: "bar", linkageName: "?bar@@YAXXZ", scope: !3, file: !3, line: 23, type: !9, scopeLine: 23, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !2, retainedNodes: !4)
+!16 = distinct !DISubprogram(name: "bar", linkageName: "?bar@@YAXXZ", scope: !3, file: !3, line: 23, type: !9, scopeLine: 23, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !2, retainedNodes: !68)
 !17 = !DIGlobalVariableExpression(var: !18, expr: !DIExpression())
 !18 = distinct !DIGlobalVariable(name: "nested_int", scope: !16, file: !3, line: 26, type: !11, isLocal: true, isDefinition: true)
 !19 = !DIGlobalVariableExpression(var: !20, expr: !DIExpression())
 !20 = distinct !DIGlobalVariable(name: "comdat_int", linkageName: "?comdat_int@?$A@H@@2HA", scope: !2, file: !3, line: 12, type: !11, isLocal: false, isDefinition: true, declaration: !21)
 !21 = !DIDerivedType(tag: DW_TAG_member, name: "comdat_int", scope: !22, file: !3, line: 4, baseType: !11, flags: DIFlagStaticMember)
 !22 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "A<int>", file: !3, line: 3, size: 8, flags: DIFlagTypePassByValue, elements: !23, templateParams: !27, identifier: ".?AU?$A@H@@")
 !23 = !{!21, !24}
 !24 = !DISubprogram(name: "set", linkageName: "?set@?$A@H@@SAHH@Z", scope: !22, file: !3, line: 5, type: !25, scopeLine: 5, flags: DIFlagPrototyped | DIFlagStaticMember, spFlags: 0)

 !59 = !DILocation(line: 30, scope: !16)
 !60 = distinct !DISubprogram(name: "set", linkageName: "?set@?$A@I@@SAII@Z", scope: !33, file: !3, line: 5, type: !36, scopeLine: 5, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !2, declaration: !35, retainedNodes: !4)
 !61 = !DILocalVariable(name: "value", arg: 1, scope: !60, file: !3, line: 5, type: !31)
 !62 = !DILocation(line: 5, scope: !60)
 !63 = !DILocalVariable(name: "r", scope: !60, file: !3, line: 6, type: !31)
 !64 = !DILocation(line: 6, scope: !60)
 !65 = !DILocation(line: 7, scope: !60)
 !66 = !DILocation(line: 8, scope: !60)
+!67 = !{!6, !12}
+!68 = !{!14, !17}

llvm/test/DebugInfo/COFF/type-quals.ll

 attributes #2 = { argmemonly nounwind }
 
 !llvm.dbg.cu = !{!9}
 !llvm.module.flags = !{!17, !18, !19, !20}
 !llvm.ident = !{!21}
 
 !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
 !1 = distinct !DIGlobalVariable(name: "str", scope: !2, file: !3, line: 18, type: !12, isLocal: true, isDefinition: true)
-!2 = distinct !DISubprogram(name: "g", linkageName: "\01?g@@YAXAEIAH@Z", scope: !3, file: !3, line: 16, type: !4, isLocal: false, isDefinition: true, scopeLine: 16, flags: DIFlagPrototyped, isOptimized: false, unit: !9, retainedNodes: !10)
+!2 = distinct !DISubprogram(name: "g", linkageName: "\01?g@@YAXAEIAH@Z", scope: !3, file: !3, line: 16, type: !4, isLocal: false, isDefinition: true, scopeLine: 16, flags: DIFlagPrototyped, isOptimized: false, unit: !9, retainedNodes: !11)
 !3 = !DIFile(filename: "m.cpp", directory: "C:\5CUsers\5CHui\5Ctmp\5Chui", checksumkind: CSK_MD5, checksum: "a8da0f4dca948db1ef1129c8728a881c")
 !4 = !DISubroutineType(types: !5)
 !5 = !{null, !6}
 !6 = !DIDerivedType(tag: DW_TAG_restrict_type, baseType: !7)
 !7 = !DIDerivedType(tag: DW_TAG_reference_type, baseType: !8, size: 64)
 !8 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
-!9 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !3, producer: "clang version 7.0.0 ", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !10, globals: !11)
+!9 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !3, producer: "clang version 7.0.0 ", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !10, globals: !10)
 !10 = !{}
 !11 = !{!0}
 !12 = !DICompositeType(tag: DW_TAG_array_type, baseType: !13, size: 32, elements: !15)
 !13 = !DIDerivedType(tag: DW_TAG_const_type, baseType: !14)
 !14 = !DIBasicType(name: "char", size: 8, encoding: DW_ATE_signed_char)
 !15 = !{!16}
 !16 = !DISubrange(count: 4)
 !17 = !{i32 2, !"CodeView", i32 1}

llvm/test/DebugInfo/Generic/2009-11-05-DeadGlobalVariable.ll

 ; RUN: llc %s -o /dev/null
 ; Here variable bar is optimized away. Do not trip over while trying to generate debug info.
 
 source_filename = "test/DebugInfo/Generic/2009-11-05-DeadGlobalVariable.ll"
 
 ; Function Attrs: nounwind readnone ssp uwtable
 define i32 @foo() #0 !dbg !6 {
 entry:
   ret i32 42, !dbg !11
 }
 
 attributes #0 = { nounwind readnone ssp uwtable }
 
 !llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!10}
 
-!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 3.0 (trunk 139632)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, retainedTypes: !2, globals: !3)
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 3.0 (trunk 139632)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, retainedTypes: !2)
 !1 = !DIFile(filename: "fb.c", directory: "/private/tmp")
 !2 = !{}
 !3 = !{!4}
 !4 = !DIGlobalVariableExpression(var: !5, expr: !DIExpression())
 !5 = !DIGlobalVariable(name: "bar", scope: !6, file: !1, line: 2, type: !9, isLocal: true, isDefinition: true)
-!6 = distinct !DISubprogram(name: "foo", scope: !1, file: !1, line: 1, type: !7, isLocal: false, isDefinition: true, virtualIndex: 6, isOptimized: true, unit: !0)
+!6 = distinct !DISubprogram(name: "foo", scope: !1, file: !1, line: 1, type: !7, isLocal: false, isDefinition: true, virtualIndex: 6, isOptimized: true, unit: !0, retainedNodes: !3)
 !7 = !DISubroutineType(types: !8)
 !8 = !{!9}
 !9 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
 !10 = !{i32 1, !"Debug Info Version", i32 3}
 !11 = !DILocation(line: 3, column: 3, scope: !12)
 !12 = distinct !DILexicalBlock(scope: !6, file: !1, line: 1, column: 11)
 

llvm/test/DebugInfo/Generic/inlined-static-var.ll

+; RUN: %llc_dwarf -O0 -filetype=obj < %s | llvm-dwarfdump -debug-info - | FileCheck --implicit-check-not "{{DW_TAG|NULL}}" %s
+; REQUIRES: object-emission
+
+; inline __attribute__((always_inline))
+; int removed() { static int A; return A++; }
+;
+; __attribute__((always_inline))
+; int not_removed() { static int B; return B++; }
+;
+; int foo() { return removed() + not_removed(); }
+
+; Ensure that global variables belong to the correct subprograms even if those
+; subprograms are inlined.
+
+; CHECK: DW_TAG_compile_unit
+; CHECK:   DW_TAG_subprogram
+; CHECK:     DW_AT_abstract_origin {{.*}} "_Z11not_removedv"
+; CHECK:   DW_TAG_subprogram
+; CHECK:     DW_AT_name       ("removed")
+; CHECK:     DW_TAG_variable
+; CHECK:       DW_AT_name     ("A")
+; CHECK:     NULL
+; CHECK:   DW_TAG_base_type
+; CHECK:   DW_TAG_subprogram
+; CHECK:     DW_AT_name       ("not_removed")
+; CHECK:     DW_TAG_variable
+; CHECK:       DW_AT_name     ("B")
+; CHECK:     NULL
+; CHECK:   DW_TAG_subprogram
+; CHECK:     DW_AT_name       ("foo")
+; CHECK:     DW_TAG_inlined_subroutine
+; CHECK:     DW_TAG_inlined_subroutine
+; CHECK:     NULL
+; CHECK:   NULL
+
+@_ZZ11not_removedvE1A = internal global i32 0, align 4, !dbg !0
+@_ZZ7removedvE1A = linkonce_odr dso_local global i32 0, align 4, !dbg !10
+
+define dso_local i32 @_Z11not_removedv() !dbg !2 {
+  %1 = load i32, i32* @_ZZ11not_removedvE1A, align 4, !dbg !24
+  %2 = add nsw i32 %1, 1, !dbg !24
+  store i32 %2, i32* @_ZZ11not_removedvE1A, align 4, !dbg !24
+  ret i32 %1, !dbg !25
+}
+
+define dso_local i32 @_Z3foov() !dbg !26 {
+  %1 = load i32, i32* @_ZZ7removedvE1A, align 4, !dbg !27
+  %2 = add nsw i32 %1, 1, !dbg !27
+  store i32 %2, i32* @_ZZ7removedvE1A, align 4, !dbg !27
+  %3 = load i32, i32* @_ZZ11not_removedvE1A, align 4, !dbg !29
+  %4 = add nsw i32 %3, 1, !dbg !29
+  store i32 %4, i32* @_ZZ11not_removedvE1A, align 4, !dbg !29
+  %5 = add nsw i32 %1, %3, !dbg !31
+  ret i32 %5, !dbg !32
+}
+
+!llvm.dbg.cu = !{!7}
+!llvm.module.flags = !{!14, !15, !16, !17, !18, !19, !20, !21, !22}
+!llvm.ident = !{!23}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "B", scope: !2, file: !3, line: 5, type: !6, isLocal: true, isDefinition: true)
+!2 = distinct !DISubprogram(name: "not_removed", linkageName: "_Z11not_removedv", scope: !3, file: !3, line: 5, type: !4, scopeLine: 5, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !7, retainedNodes: !9)
+!3 = !DIFile(filename: "example.cpp", directory: "")
+!4 = !DISubroutineType(types: !5)
+!5 = !{!6}
+!6 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!7 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !8, producer: "clang version 14.0.0", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, splitDebugInlining: false, nameTableKind: None)
+!8 = !DIFile(filename: "example.cpp", directory: "")
+!9 = !{!0}
+!10 = !DIGlobalVariableExpression(var: !11, expr: !DIExpression())
+!11 = distinct !DIGlobalVariable(name: "A", scope: !12, file: !3, line: 2, type: !6, isLocal: false, isDefinition: true)
+!12 = distinct !DISubprogram(name: "removed", linkageName: "_Z7removedv", scope: !3, file: !3, line: 2, type: !4, scopeLine: 2, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !7, retainedNodes: !33)
+!13 = !{}
+!14 = !{i32 7, !"Dwarf Version", i32 4}
+!15 = !{i32 2, !"Debug Info Version", i32 3}
+!16 = !{i32 1, !"wchar_size", i32 4}
+!17 = !{i32 1, !"branch-target-enforcement", i32 0}
+!18 = !{i32 1, !"sign-return-address", i32 0}
+!19 = !{i32 1, !"sign-return-address-all", i32 0}
+!20 = !{i32 1, !"sign-return-address-with-bkey", i32 0}
+!21 = !{i32 7, !"uwtable", i32 1}
+!22 = !{i32 7, !"frame-pointer", i32 1}
+!23 = !{!"clang version 14.0.0"}
+!24 = !DILocation(line: 5, column: 43, scope: !2)
+!25 = !DILocation(line: 5, column: 35, scope: !2)
+!26 = distinct !DISubprogram(name: "foo", linkageName: "_Z3foov", scope: !3, file: !3, line: 7, type: !4, scopeLine: 7, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !7, retainedNodes: !13)
+!27 = !DILocation(line: 2, column: 39, scope: !12, inlinedAt: !28)
+!28 = distinct !DILocation(line: 7, column: 20, scope: !26)
+!29 = !DILocation(line: 5, column: 43, scope: !2, inlinedAt: !30)
+!30 = distinct !DILocation(line: 7, column: 32, scope: !26)
+!31 = !DILocation(line: 7, column: 30, scope: !26)
+!32 = !DILocation(line: 7, column: 13, scope: !26)
+!33 = !{!10}

llvm/test/DebugInfo/Generic/lexical-block-static-var.ll

+; RUN: %llc_dwarf -O0 -filetype=obj < %s | llvm-dwarfdump -debug-info - | FileCheck --implicit-check-not "{{DW_TAG|NULL}}" %s
+; REQUIRES: object-emission
+
+; inline __attribute__((always_inline))
+; int removed() {
+;   {
+;     static int A;
+;     return A++;
+;   }
+; }
+;
+; __attribute__((always_inline))
+; int not_removed() {
+;   {
+;     static int B;
+;     return B++;
+;   }
+; }
+;
+; int foo() {
+;   {
+;     static int C;
+;     return ++C + removed() + not_removed();
+;   }
+; }
+
+; CHECK: DW_TAG_compile_unit
+
+; Out-of-line definition of `not_removed()`.
+; The empty lexical block is created to match abstract origin.
+; CHECK:   DW_TAG_subprogram
+; CHECK:     DW_AT_abstract_origin {{.*}} "_Z11not_removedv"
+; CHECK:     DW_TAG_lexical_block
+; CHECK:     NULL
+
+; Abstract definition of `removed()`
+; CHECK:   DW_TAG_subprogram
+; CHECK:     DW_AT_name ("removed")
+; CHECK:     DW_AT_inline (DW_INL_inlined)
+; CHECK:     DW_TAG_lexical_block
+; CHECK:       DW_TAG_variable
+; CHECK:         DW_AT_name ("A")
+; CHECK:         DW_AT_location (DW_OP_addr 0x0)
+; CHECK:       NULL
+; CHECK:     NULL
+; CHECK:   DW_TAG_base_type
+
+; Abstract definition of `not_removed()`
+; CHECK:   DW_TAG_subprogram
+; CHECK:     DW_AT_name ("not_removed")
+; CHECK:     DW_AT_inline (DW_INL_inlined)
+; CHECK:     DW_TAG_lexical_block
+; CHECK:       DW_TAG_variable
+; CHECK:         DW_AT_name ("B")
+; CHECK:         DW_AT_location (DW_OP_addr 0x0)
+; CHECK:       NULL
+; CHECK:     NULL
+
+; Definition of foo().
+; CHECK:   DW_TAG_subprogram
+; CHECK:     DW_AT_name ("foo")
+; CHECK:     DW_TAG_lexical_block
+; CHECK:       DW_TAG_inlined_subroutine
+; CHECK:         DW_TAG_lexical_block
+; CHECK:         NULL
+; CHECK:       DW_TAG_inlined_subroutine
+; CHECK:         DW_TAG_lexical_block
+; CHECK:         NULL
+; CHECK:       DW_TAG_variable
+; CHECK:         DW_AT_name ("C")
+; CHECK:         DW_AT_location (DW_OP_addr 0x0)
+; CHECK:       NULL
+; CHECK:     NULL
+; CHECK:   NULL
+
+target triple = "x86_64-unknown-linux-gnu"
+
+@_ZZ11not_removedvE1B = internal global i32 0, align 4, !dbg !0
+@_ZZ3foovE1C = internal global i32 0, align 4, !dbg !10
+@_ZZ7removedvE1A = linkonce_odr dso_local global i32 0, align 4, !dbg !15
+
+define dso_local i32 @_Z11not_removedv() !dbg !4 {
+entry:
+  %0 = load i32, i32* @_ZZ11not_removedvE1B, align 4, !dbg !25
+  %inc = add nsw i32 %0, 1, !dbg !25
+  store i32 %inc, i32* @_ZZ11not_removedvE1B, align 4, !dbg !25
+  ret i32 %0, !dbg !26
+}
+
+define dso_local i32 @_Z3foov() !dbg !13 {
+entry:
+  %0 = load i32, i32* @_ZZ3foovE1C, align 4, !dbg !27
+  %inc = add nsw i32 %0, 1, !dbg !27
+  store i32 %inc, i32* @_ZZ3foovE1C, align 4, !dbg !27
+  %1 = load i32, i32* @_ZZ7removedvE1A, align 4, !dbg !28
+  %inc.i3 = add nsw i32 %1, 1, !dbg !28
+  store i32 %inc.i3, i32* @_ZZ7removedvE1A, align 4, !dbg !28
+  %add = add nsw i32 %inc, %1, !dbg !30
+  %2 = load i32, i32* @_ZZ11not_removedvE1B, align 4, !dbg !31
+  %inc.i = add nsw i32 %2, 1, !dbg !31
+  store i32 %inc.i, i32* @_ZZ11not_removedvE1B, align 4, !dbg !31
+  %add2 = add nsw i32 %add, %2, !dbg !33
+  ret i32 %add2, !dbg !34
+}
+
+!llvm.dbg.cu = !{!8}
+!llvm.module.flags = !{!19, !20, !21, !22, !23}
+!llvm.ident = !{!24}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "B", scope: !2, file: !3, line: 13, type: !7, isLocal: true, isDefinition: true)
+!2 = distinct !DILexicalBlock(scope: !4, file: !3, line: 12, column: 3)
+!3 = !DIFile(filename: "test_static.cpp", directory: "/")
+!4 = distinct !DISubprogram(name: "not_removed", linkageName: "_Z11not_removedv", scope: !3, file: !3, line: 11, type: !5, scopeLine: 11, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !8, retainedNodes: !35)
+!5 = !DISubroutineType(types: !6)
+!6 = !{!7}
+!7 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!8 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !3, producer: "clang version 14.0.0", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, splitDebugInlining: false, nameTableKind: None)
+!9 = !{!15}
+!10 = !DIGlobalVariableExpression(var: !11, expr: !DIExpression())
+!11 = distinct !DIGlobalVariable(name: "C", scope: !12, file: !3, line: 20, type: !7, isLocal: true, isDefinition: true)
+!12 = distinct !DILexicalBlock(scope: !13, file: !3, line: 19, column: 3)
+!13 = distinct !DISubprogram(name: "foo", linkageName: "_Z3foov", scope: !3, file: !3, line: 18, type: !5, scopeLine: 18, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !8, retainedNodes: !36)
+!14 = !{}
+!15 = !DIGlobalVariableExpression(var: !16, expr: !DIExpression())
+!16 = distinct !DIGlobalVariable(name: "A", scope: !17, file: !3, line: 5, type: !7, isLocal: false, isDefinition: true)
+!17 = distinct !DILexicalBlock(scope: !18, file: !3, line: 4, column: 3)
+!18 = distinct !DISubprogram(name: "removed", linkageName: "_Z7removedv", scope: !3, file: !3, line: 3, type: !5, scopeLine: 3, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !8, retainedNodes: !9)
+!19 = !{i32 7, !"Dwarf Version", i32 4}
+!20 = !{i32 2, !"Debug Info Version", i32 3}
+!21 = !{i32 1, !"wchar_size", i32 4}
+!22 = !{i32 7, !"uwtable", i32 1}
+!23 = !{i32 7, !"frame-pointer", i32 2}
+!24 = !{!"clang version 14.0.0"}
+!25 = !DILocation(line: 14, column: 13, scope: !2)
+!26 = !DILocation(line: 14, column: 5, scope: !2)
+!27 = !DILocation(line: 21, column: 12, scope: !12)
+!28 = !DILocation(line: 6, column: 13, scope: !17, inlinedAt: !29)
+!29 = distinct !DILocation(line: 21, column: 18, scope: !12)
+!30 = !DILocation(line: 21, column: 16, scope: !12)
+!31 = !DILocation(line: 14, column: 13, scope: !2, inlinedAt: !32)
+!32 = distinct !DILocation(line: 21, column: 30, scope: !12)
+!33 = !DILocation(line: 21, column: 28, scope: !12)
+!34 = !DILocation(line: 21, column: 5, scope: !12)
+!35 = !{!0}
+!36 = !{!10}

llvm/test/DebugInfo/Generic/verifier-invalid-dicompileunit.ll

+; RUN: llvm-as -disable-output %s 2>&1 | FileCheck --match-full-lines %s
+
+!llvm.module.flags = !{!0}
+!llvm.dbg.cu = !{!2, !4, !5, !6, !7, !8, !9, !10, !11, !12, !13, !14, !17, !20, !22}
+
+!0 = !{i32 2, !"Debug Info Version", i32 3}
+!1 = !DIFile(filename: "-", directory: "")
+
+; CHECK: invalid file
+!2 = distinct !DICompileUnit(language: 0, file: !{})
+
+; CHECK: invalid filename
+!3 = !DIFile(filename: "", directory: "")
+!4 = distinct !DICompileUnit(language: 0, file: !3)
+
+; CHECK: invalid enum list
+!5 = distinct !DICompileUnit(language: 0, file: !1, enums: !1)
+
+; CHECK: invalid enum type
+!6 = distinct !DICompileUnit(language: 0, file: !1, enums: !{!1})
+
+; CHECK: invalid retained type list
+!7 = distinct !DICompileUnit(language: 0, file: !1, retainedTypes: !1)
+
+; CHECK: invalid retained type
+!8 = distinct !DICompileUnit(language: 0, file: !1, retainedTypes: !{!1})
+
+; CHECK: invalid global variable list
+!9 = distinct !DICompileUnit(language: 0, file: !1, globals: !1)
+
+; CHECK: invalid global variable ref
+!10 = distinct !DICompileUnit(language: 0, file: !1, globals: !{!1})
+
+; CHECK: invalid imported entity list
+!11 = distinct !DICompileUnit(language: 0, file: !1, imports: !1)
+
+; CHECK: invalid imported entity ref
+!12 = distinct !DICompileUnit(language: 0, file: !1, imports: !{!1})
+
+; CHECK: invalid macro list
+!13 = distinct !DICompileUnit(language: 0, file: !1, macros: !1)
+
+; CHECK: invalid macro ref
+!14 = distinct !DICompileUnit(language: 0, file: !1, macros: !{!1})
+
+define void @foo() !dbg !15 { ret void }
+!15 = distinct !DISubprogram(file: !1)
+
+; CHECK: function-local import in a DICompileUnit's imported entities list
+!16 = distinct !DIImportedEntity(tag: DW_TAG_imported_declaration, scope: !15, entity: !15)
+!17 = distinct !DICompileUnit(language: 0, file: !1, imports: !{!16})
+
+; CHECK: function-local variable in a DICompileUnit's global variables list
+!18 = !DIGlobalVariableExpression(var: !19, expr: !DIExpression())
+!19 = distinct !DIGlobalVariable(scope: !15)
+!20 = distinct !DICompileUnit(language: 0, file: !1, globals: !{!18})
+
+; CHECK: function-local enum in a DICompileUnit's enum list
+!21 = distinct !DICompositeType(tag: DW_TAG_enumeration_type, scope: !15)
+!22 = distinct !DICompileUnit(language: 0, file: !1, enums: !{!21})
+
+; CHECK: warning: ignoring invalid debug info{{.*}}

llvm/test/DebugInfo/Generic/verifier-invalid-disubprogram.ll

 ; CHECK: invalid subprogram declaration
 define void @invalid_subprogram_declaration() !dbg !9 { ret void }
 !9 = distinct !DISubprogram(declaration: !0)
 
 ; CHECK: invalid retained nodes list
 define void @invalid_retained_nodes_list() !dbg !10 { ret void }
 !10 = distinct !DISubprogram(retainedNodes: !0)
 
-; CHECK: invalid retained nodes, expected DILocalVariable, DILabel, DIImportedEntity or DIType
+; CHECK: invalid retained nodes, expected DILocalVariable, DILabel, DIImportedEntity, DIType or DIGlobalVariableExpression
 define void @invalid_retained_nodes_expected() !dbg !11 { ret void }
 !11 = distinct !DISubprogram(retainedNodes: !{!0})
 
 ; CHECK: invalid reference flags
 define void @invalid_reference_flags_reference() !dbg !12 { ret void }
 !12 = distinct !DISubprogram(flags: DIFlagLValueReference | DIFlagRValueReference)
 
 ; CHECK: invalid reference flags

llvm/test/DebugInfo/X86/DW_AT_specification.ll

entry:
   ret void, !dbg !17
 }
 
 !llvm.dbg.cu = !{!8}
 !llvm.module.flags = !{!16}
 
 !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
 !1 = !DIGlobalVariable(name: "x", scope: !2, file: !3, line: 5, type: !14, isLocal: true, isDefinition: true)
-!2 = distinct !DISubprogram(name: "bar", linkageName: "_ZN3foo3barEv", scope: null, file: !3, line: 4, type: !4, isLocal: false, isDefinition: true, scopeLine: 4, virtualIndex: 6, flags: DIFlagPrototyped, isOptimized: false, unit: !8, declaration: !11)
+!2 = distinct !DISubprogram(name: "bar", linkageName: "_ZN3foo3barEv", scope: null, file: !3, line: 4, type: !4, isLocal: false, isDefinition: true, scopeLine: 4, virtualIndex: 6, flags: DIFlagPrototyped, isOptimized: false, unit: !8, declaration: !11, retainedNodes: !10)
 !3 = !DIFile(filename: "nsNativeAppSupportBase.ii", directory: "/Users/espindola/mozilla-central/obj-x86_64-apple-darwin11.2.0/toolkit/library")
 !4 = !DISubroutineType(types: !5)
 !5 = !{null, !6}
 !6 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !7, size: 64, align: 64, flags: DIFlagArtificial)
 !7 = !DICompositeType(tag: DW_TAG_structure_type, name: "foo", file: !3, line: 1, flags: DIFlagFwdDecl)
-!8 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !3, producer: "clang version 3.0 ()", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !9, retainedTypes: !9, globals: !10, imports: !9)
+!8 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !3, producer: "clang version 3.0 ()", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !9, retainedTypes: !9, imports: !9)
 !9 = !{}
 !10 = !{!0}
 !11 = !DISubprogram(name: "bar", linkageName: "_ZN3foo3barEv", scope: !12, file: !3, line: 2, type: !4, isLocal: false, isDefinition: false, scopeLine: 2, virtualIndex: 6, flags: DIFlagPrototyped, isOptimized: false)
 !12 = !DICompositeType(tag: DW_TAG_class_type, name: "foo", file: !3, line: 1, size: 8, align: 8, elements: !13)
 !13 = !{!11}
 !14 = !DIDerivedType(tag: DW_TAG_const_type, baseType: !15)
 !15 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
 !16 = !{i32 1, !"Debug Info Version", i32 3}
 !17 = !DILocation(line: 6, column: 1, scope: !18)
 !18 = distinct !DILexicalBlock(scope: !2, file: !3, line: 4, column: 17)
 

llvm/test/DebugInfo/X86/dbg-value-transfer-order.ll

 
 attributes #0 = { noinline nounwind readonly uwtable }
 attributes #1 = { nounwind readnone speculatable }
 
 !llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!14, !15, !16, !17}
 !llvm.ident = !{!18}
 
-!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 6.0.0 ", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, globals: !3)
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 6.0.0 ", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, globals: !2)
 !1 = !DIFile(filename: "t.c", directory: "C:\5Csrc\5Cllvm-project\5Cbuild", checksumkind: CSK_MD5, checksum: "f80d0003faf76554dfdec6c95da285cc")
 !2 = !{}
 !3 = !{!4}
 !4 = !DIGlobalVariableExpression(var: !5, expr: !DIExpression())
 !5 = distinct !DIGlobalVariable(name: "pages", scope: !6, file: !1, line: 18, type: !10, isLocal: true, isDefinition: true)
-!6 = distinct !DISubprogram(name: "main", scope: !1, file: !1, line: 17, type: !7, isLocal: false, isDefinition: true, scopeLine: 17, isOptimized: true, unit: !0, retainedNodes: !2)
+!6 = distinct !DISubprogram(name: "main", scope: !1, file: !1, line: 17, type: !7, isLocal: false, isDefinition: true, scopeLine: 17, isOptimized: true, unit: !0, retainedNodes: !3)
 !7 = !DISubroutineType(types: !8)
 !8 = !{!9}
 !9 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
 !10 = !DICompositeType(tag: DW_TAG_array_type, baseType: !11, size: 1024, elements: !12)
 !11 = !DIBasicType(name: "unsigned int", size: 32, encoding: DW_ATE_unsigned)
 !12 = !{!13}
 !13 = !DISubrange(count: 32)
 !14 = !{i32 2, !"CodeView", i32 1}

llvm/test/DebugInfo/X86/dimodule-external-fortran.ll

 !omp_offload.info = !{}
 
 !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
 !1 = distinct !DIGlobalVariable(name: "dummy", linkageName: "external_module_mp_dummy_", scope: !2, file: !3, line: 1, type: !14, isLocal: false, isDefinition: true)
 !2 = distinct !DISubprogram(name: "use_external_module", linkageName: "MAIN__", scope: !3, file: !3, line: 1, type: !4, scopeLine: 1, spFlags: DISPFlagDefinition, unit: !6, retainedNodes: !12)
 !3 = !DIFile(filename: "em.f90", directory: "tests")
 !4 = !DISubroutineType(types: !5)
 !5 = !{null}
-!6 = distinct !DICompileUnit(language: DW_LANG_Fortran95, file: !3, producer: "Intel(R) Fortran 21.0-2165", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !7, globals: !8, splitDebugInlining: false, nameTableKind: None)
+!6 = distinct !DICompileUnit(language: DW_LANG_Fortran95, file: !3, producer: "Intel(R) Fortran 21.0-2165", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !7, splitDebugInlining: false, nameTableKind: None)
 !7 = !{}
-!8 = !{!0}
 !9 = !{}
 !10 = !DIImportedEntity(tag: DW_TAG_imported_module, scope: !2, entity: !11, file: !3, line: 2)
 !11 = !DIModule(scope: !2, name: "external_module", isDecl: true)
-!12 = !{!10, !13}
+!12 = !{!0, !10, !13}
 !13 = !DILocalVariable(name: "x", scope: !2, file: !3, line: 5, type: !14)
 !14 = !DIBasicType(name: "REAL*4", size: 32, encoding: DW_ATE_float)
 !15 = !{i32 2, !"Debug Info Version", i32 3}
 !16 = !{i32 2, !"Dwarf Version", i32 4}
 !17 = !DILocation(line: 5, column: 12, scope: !2)
 !18 = !DILocation(line: 1, column: 9, scope: !2)
 !19 = !DILocation(line: 6, column: 4, scope: !2)
 !20 = !DILocation(line: 6, column: 12, scope: !2)
 !21 = !DILocation(line: 8, column: 1, scope: !2)

llvm/test/DebugInfo/X86/distringtype.ll

 attributes #1 = { nofree nosync nounwind readnone speculatable willreturn }
 
 !llvm.module.flags = !{!10, !11}
 !llvm.dbg.cu = !{!6}
 !omp_offload.info = !{}
 
 !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
 !1 = distinct !DIGlobalVariable(name: "deferred", linkageName: "assumedlength_$DEFERRED", scope: !2, file: !3, line: 2, type: !9, isLocal: true, isDefinition: true)
-!2 = distinct !DISubprogram(name: "assumedlength", linkageName: "MAIN__", scope: !3, file: !3, line: 1, type: !4, scopeLine: 1, spFlags: DISPFlagDefinition, unit: !6, retainedNodes: !7)
+!2 = distinct !DISubprogram(name: "assumedlength", linkageName: "MAIN__", scope: !3, file: !3, line: 1, type: !4, scopeLine: 1, spFlags: DISPFlagDefinition, unit: !6, retainedNodes: !8)
 !3 = !DIFile(filename: "distring.f90", directory: "/iusers/cchen15/examples/tests")
 !4 = !DISubroutineType(types: !5)
 !5 = !{null}
-!6 = distinct !DICompileUnit(language: DW_LANG_Fortran95, file: !3, producer: "Intel(R) Fortran 21.0-2142", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !7, globals: !8, splitDebugInlining: false, nameTableKind: None)
+!6 = distinct !DICompileUnit(language: DW_LANG_Fortran95, file: !3, producer: "Intel(R) Fortran 21.0-2142", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !7, splitDebugInlining: false, nameTableKind: None)
 !7 = !{}
 !8 = !{!0}
 !9 = !DIStringType(name: ".str.DEFERRED", stringLengthExpression: !DIExpression(DW_OP_push_object_address, DW_OP_plus_uconst, 8), stringLocationExpression: !DIExpression(DW_OP_push_object_address, DW_OP_deref))
 !10 = !{i32 2, !"Debug Info Version", i32 3}
 !11 = !{i32 2, !"Dwarf Version", i32 4}
 !12 = !DILocation(line: 1, column: 9, scope: !2)
 !13 = !DILocation(line: 3, column: 3, scope: !2)
 !14 = !DILocation(line: 4, column: 8, scope: !2)

llvm/test/DebugInfo/X86/global-sra-struct-fit-segment.ll

 ; CHECK-DAG: ![[GVE4]] = !DIGlobalVariableExpression(var: ![[GV4:.*]], expr: !DIExpression(DW_OP_plus_uconst, 2))
 ; CHECK-DAG: ![[GV4]] = distinct !DIGlobalVariable(name: "ivar2"
 
 ;; This does not make sense should be removed.
 ; CHECK-NOT: !DIGlobalVariable(name: "doesnotexist"
 
 !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
 !1 = distinct !DIGlobalVariable(name: "nodea", scope: !2, file: !3, line: 3, type: !9, isLocal: true, isDefinition: true)
-!2 = distinct !DISubprogram(name: "sub", scope: !4, file: !3, line: 1, type: !12, scopeLine: 1, flags: DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition, unit: !4)
+!2 = distinct !DISubprogram(name: "sub", scope: !4, file: !3, line: 1, type: !12, scopeLine: 1, flags: DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition, unit: !4, retainedNodes: !6)
 !3 = !DIFile(filename: "global-sra-struct-fit-segment.f90", directory: "/tmp")
-!4 = distinct !DICompileUnit(language: DW_LANG_Fortran90, file: !3, producer: " F90 Flang - 1.5 2017-05-01", isOptimized: false, flags: "'+flang -g -O0 -S -emit-llvm'", runtimeVersion: 0, emissionKind: FullDebug, enums: !5, retainedTypes: !5, globals: !6, imports: !5, nameTableKind: None)
+!4 = distinct !DICompileUnit(language: DW_LANG_Fortran90, file: !3, producer: " F90 Flang - 1.5 2017-05-01", isOptimized: false, flags: "'+flang -g -O0 -S -emit-llvm'", runtimeVersion: 0, emissionKind: FullDebug, enums: !5, retainedTypes: !5, globals: !5, imports: !5, nameTableKind: None)
 !5 = !{}
 !6 = !{!0, !7, !10, !29}
 !7 = !DIGlobalVariableExpression(var: !8, expr: !DIExpression(DW_OP_plus_uconst, 4))
 !8 = distinct !DIGlobalVariable(name: "nodeb", scope: !2, file: !3, line: 3, type: !9, isLocal: true, isDefinition: true)
 !9 = !DIBasicType(name: "integer", size: 32, align: 32, encoding: DW_ATE_signed)
 !10 = !DIGlobalVariableExpression(var: !11, expr: !DIExpression(DW_OP_plus_uconst, 8))
 !11 = distinct !DIGlobalVariable(name: "jmax", scope: !2, file: !3, line: 3, type: !9, isLocal: true, isDefinition: true)
 !12 = !DISubroutineType(types: !13)

llvm/test/DebugInfo/X86/global-sra-struct-part-overlap-segment.ll

 ; CHECK-DAG: ![[GV3]] = distinct !DIGlobalVariable(name: "ivar"
 
 !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
 !1 = distinct !DIGlobalVariable(name: "bar1", scope: !2, file: !4, type: !12, isLocal: true, isDefinition: true)
 !2 = !DIModule(scope: !3, name: "mymod", isDecl: true)
 !3 = distinct !DICompileUnit(language: DW_LANG_Fortran90, file: !4, producer: " F90 Flang - 1.5 2017-05-01", isOptimized: true, flags: "'+flang -g -O3 -S -emit-llvm -o -O1'", runtimeVersion: 0, emissionKind: FullDebug, enums: !5, retainedTypes: !5, globals: !6, imports: !5, nameTableKind: None)
 !4 = !DIFile(filename: "global-sra-struct-part-overlap-segment_0.f90", directory: "/tmp")
 !5 = !{}
-!6 = !{!0, !7, !29}
+!6 = !{!0}
 !7 = !DIGlobalVariableExpression(var: !8, expr: !DIExpression())
 !8 = distinct !DIGlobalVariable(name: "rvar", scope: !9, file: !4, line: 13, type: !19, isLocal: true, isDefinition: true)
-!9 = distinct !DISubprogram(name: "bar", scope: !2, file: !4, line: 10, type: !10, scopeLine: 10, flags: DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !3)
+!9 = distinct !DISubprogram(name: "bar", scope: !2, file: !4, line: 10, type: !10, scopeLine: 10, retainedNodes: !32, flags: DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !3)
 !10 = !DISubroutineType(types: !11)
 !11 = !{null, !12, !16}
 !12 = !DICompositeType(tag: DW_TAG_array_type, baseType: !13, size: 96, align: 32, elements: !14)
 !13 = !DIBasicType(name: "integer", size: 32, align: 32, encoding: DW_ATE_signed)
 !14 = !{!15}
 !15 = !DISubrange(lowerBound: 1, upperBound: 3)
 !16 = !DICompositeType(tag: DW_TAG_array_type, baseType: !17, size: 576, align: 64, elements: !18)
 !17 = !DIBasicType(name: "double precision", size: 64, align: 64, encoding: DW_ATE_float)
 !18 = !{!15, !15}
 !19 = !DICompositeType(tag: DW_TAG_array_type, baseType: !17, size: 192, align: 64, elements: !14)
 !20 = !{i32 2, !"Dwarf Version", i32 4}
 !21 = !{i32 2, !"Debug Info Version", i32 3}
 !22 = distinct !DISubprogram(name: "foo", scope: !2, file: !4, line: 5, type: !10, scopeLine: 5, flags: DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !3)
 !23 = !{!24}
 !24 = distinct !{!24, !25, !"mymod_bar_: %bar"}
 !25 = distinct !{!25, !"mymod_bar_"}
 !26 = !{!27}
 !27 = distinct !{!27, !25, !"mymod_bar_: %arg"}
 !28 = !{!24, !27}
 !29 = !DIGlobalVariableExpression(var: !30, expr: !DIExpression(DW_OP_plus_uconst, 4))
 !30 = distinct !DIGlobalVariable(name: "ivar", scope: !9, file: !4, line: 13, type: !31, isLocal: true, isDefinition: true)
 !31 = !DIBasicType(name: "integer*8", size: 64, align: 32, encoding: DW_ATE_signed)
+!32 = !{!7, !29}

llvm/test/DebugInfo/X86/gnu-public-names.ll

 !9 = !DICompositeType(tag: DW_TAG_enumeration_type, name: "named_enum", file: !3, line: 52, baseType: !6, size: 32, elements: !10, identifier: "_ZTS10named_enum")
 !10 = !{!11}
 !11 = !DIEnumerator(name: "named_enum_enumerator", value: 0, isUnsigned: true)
 !12 = !DICompositeType(tag: DW_TAG_enumeration_type, name: "named_enum_class", file: !3, line: 55, baseType: !13, size: 32, flags: DIFlagEnumClass, elements: !14, identifier: "_ZTS16named_enum_class")
 !13 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
 !14 = !{!15}
 !15 = !DIEnumerator(name: "named_enum_class_enumerator", value: 0)
 !16 = !{!13}
-!17 = !{!0, !18, !29, !32, !37, !44, !47, !50}
+!17 = !{!0, !18, !29, !32, !44, !47, !50}
 !18 = !DIGlobalVariableExpression(var: !19, expr: !DIExpression())
 !19 = distinct !DIGlobalVariable(name: "global_variable", scope: !2, file: !3, line: 13, type: !20, isLocal: false, isDefinition: true)
 !20 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "C", file: !3, line: 1, size: 8, flags: DIFlagTypePassByValue, elements: !21, identifier: "_ZTS1C")
 !21 = !{!22, !23, !27}
 !22 = !DIDerivedType(tag: DW_TAG_member, name: "static_member_variable", scope: !20, file: !3, line: 4, baseType: !13, flags: DIFlagStaticMember)
 !23 = !DISubprogram(name: "member_function", linkageName: "_ZN1C15member_functionEv", scope: !20, file: !3, line: 2, type: !24, scopeLine: 2, flags: DIFlagPrototyped, spFlags: 0)
 !24 = !DISubroutineType(types: !25)
 !25 = !{null, !26}
 !26 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !20, size: 64, flags: DIFlagArtificial | DIFlagObjectPointer)
 !27 = !DISubprogram(name: "static_member_function", linkageName: "_ZN1C22static_member_functionEv", scope: !20, file: !3, line: 3, type: !28, scopeLine: 3, flags: DIFlagPrototyped | DIFlagStaticMember, spFlags: 0)
 !28 = !DISubroutineType(types: !16)
 !29 = !DIGlobalVariableExpression(var: !30, expr: !DIExpression())
 !30 = distinct !DIGlobalVariable(name: "global_namespace_variable", linkageName: "_ZN2ns25global_namespace_variableE", scope: !31, file: !3, line: 19, type: !13, isLocal: false, isDefinition: true)
 !31 = !DINamespace(name: "ns", scope: null)
 !32 = !DIGlobalVariableExpression(var: !33, expr: !DIExpression())
 !33 = distinct !DIGlobalVariable(name: "d", linkageName: "_ZN2ns1dE", scope: !31, file: !3, line: 23, type: !34, isLocal: false, isDefinition: true)
 !34 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "D", scope: !31, file: !3, line: 21, size: 32, flags: DIFlagTypePassByValue, elements: !35, identifier: "_ZTSN2ns1DE")
 !35 = !{!36}
 !36 = !DIDerivedType(tag: DW_TAG_member, name: "A", scope: !34, file: !3, line: 22, baseType: !13, size: 32)
 !37 = !DIGlobalVariableExpression(var: !38, expr: !DIExpression())
 !38 = distinct !DIGlobalVariable(name: "z", scope: !39, file: !3, line: 33, type: !13, isLocal: true, isDefinition: true)
-!39 = distinct !DISubprogram(name: "f3", linkageName: "_Z2f3v", scope: !3, file: !3, line: 32, type: !40, scopeLine: 32, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !2, retainedNodes: !43)
+!39 = distinct !DISubprogram(name: "f3", linkageName: "_Z2f3v", scope: !3, file: !3, line: 32, type: !40, scopeLine: 32, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !2, retainedNodes: !91)
 !40 = !DISubroutineType(types: !41)
 !41 = !{!42}
 !42 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !13, size: 64)
 !43 = !{}
 !44 = !DIGlobalVariableExpression(var: !45, expr: !DIExpression())
 !45 = distinct !DIGlobalVariable(name: "i", linkageName: "_ZN12_GLOBAL__N_11iE", scope: !46, file: !3, line: 29, type: !13, isLocal: true, isDefinition: true)
 !46 = !DINamespace(scope: null)
 !47 = !DIGlobalVariableExpression(var: !48, expr: !DIExpression())

 !83 = !DILocation(line: 59, column: 22, scope: !78)
 !84 = !DILocation(line: 59, column: 20, scope: !78)
 !85 = !DILocation(line: 59, column: 33, scope: !78)
 !86 = !DILocation(line: 59, column: 31, scope: !78)
 !87 = !DILocation(line: 59, column: 42, scope: !78)
 !88 = !DILocation(line: 59, column: 68, scope: !78)
 !89 = !DILocation(line: 60, column: 32, scope: !78)
 !90 = !DILocation(line: 59, column: 3, scope: !78)
+!91 = !{!37}

llvm/test/DebugInfo/X86/namelist1.ll

 declare void @llvm.dbg.declare(metadata, metadata, metadata)
 declare void @llvm.dbg.value(metadata, metadata, metadata)
 
 !llvm.module.flags = !{!10, !11}
 !llvm.dbg.cu = !{!4}
 
 !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression(DW_OP_plus_uconst, 120))
 !1 = distinct !DIGlobalVariable(name: "a", scope: !2, file: !3, line: 3, type: !9, isLocal: true, isDefinition: true)
-!2 = distinct !DISubprogram(name: "main", scope: !4, file: !3, line: 1, type: !7, scopeLine: 1, flags: DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagMainSubprogram, unit: !4)
+!2 = distinct !DISubprogram(name: "main", scope: !4, file: !3, line: 1, type: !7, scopeLine: 1, flags: DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagMainSubprogram, unit: !4, retainedNodes: !6)
 !3 = !DIFile(filename: "namelist.f90", directory: "/dir")
-!4 = distinct !DICompileUnit(language: DW_LANG_Fortran90, file: !3, producer: " F90 Flang - 1.5 2017-05-01", isOptimized: false, flags: "'+flang -g namelist.f90 -S -emit-llvm'", runtimeVersion: 0, emissionKind: FullDebug, enums: !5, retainedTypes: !5, globals: !6, imports: !5, nameTableKind: None)
+!4 = distinct !DICompileUnit(language: DW_LANG_Fortran90, file: !3, producer: " F90 Flang - 1.5 2017-05-01", isOptimized: false, flags: "'+flang -g namelist.f90 -S -emit-llvm'", runtimeVersion: 0, emissionKind: FullDebug, enums: !5, retainedTypes: !5, imports: !5, nameTableKind: None)
 !5 = !{}
 !6 = !{!0}
 !7 = !DISubroutineType(cc: DW_CC_program, types: !8)
 !8 = !{null}
 !9 = !DIBasicType(name: "integer", size: 32, align: 32, encoding: DW_ATE_signed)
 !10 = !{i32 2, !"Dwarf Version", i32 4}
 !11 = !{i32 2, !"Debug Info Version", i32 3}
 !12 = !DILocalVariable(name: "b", scope: !2, file: !3, line: 3, type: !9)
 !13 = !DILocation(line: 0, scope: !2)
 !14 = distinct !DILocalVariable(scope: !2, file: !3, line: 2, type: !15, flags: DIFlagArtificial)
 !15 = !DICompositeType(tag: DW_TAG_namelist, name: "nml", scope: !2, file: !3, elements: !16)
 !16 = !{!1, !12}
 !17 = !DILocation(line: 10, column: 1, scope: !2)

llvm/test/DebugInfo/X86/sdag-dbgvalue-phi-use-4.ll

 
 ; CHECK-LABEL: bb.{{.*}}.if.end36:
 ; CHECK:         [[REG1:%[0-9]+]]:gr32 = PHI
 ; INSTRREF-SAME:    debug-instr-number 1
 ; CHECK-NEXT:    [[REG2:%[0-9]+]]:gr32 = PHI
 ; INSTRREF-SAME:    debug-instr-number 2
 ; CHECK-NEXT:    [[REG3:%[0-9]+]]:gr32 = PHI
 ; INSTRREF-SAME:    debug-instr-number 3
-; INSTRREF-NEXT: DBG_INSTR_REF !13, !DIExpression(DW_OP_LLVM_arg, 0, DW_OP_LLVM_fragment, 0, 32), dbg-instr-ref(1, 0)
-; INSTRREF-NEXT: DBG_INSTR_REF !13, !DIExpression(DW_OP_LLVM_arg, 0, DW_OP_LLVM_fragment, 32, 32), dbg-instr-ref(2, 0)
-; INSTRREF-NEXT: DBG_INSTR_REF !13, !DIExpression(DW_OP_LLVM_arg, 0, DW_OP_LLVM_fragment, 64, 16), dbg-instr-ref(3, 0)
-; INSTRREF-NEXT: DBG_INSTR_REF !12, !DIExpression(DW_OP_LLVM_arg, 0, DW_OP_LLVM_fragment, 10, 32), dbg-instr-ref(1, 0)
-; INSTRREF-NEXT: DBG_INSTR_REF !12, !DIExpression(DW_OP_LLVM_arg, 0, DW_OP_LLVM_fragment, 42, 13), dbg-instr-ref(2, 0)
-; DBGVALUE-NEXT: DBG_VALUE [[REG1]], $noreg,  !13, !DIExpression(DW_OP_LLVM_fragment, 0, 32)
-; DBGVALUE-NEXT: DBG_VALUE [[REG2]], $noreg,  !13, !DIExpression(DW_OP_LLVM_fragment, 32, 32)
-; DBGVALUE-NEXT: DBG_VALUE [[REG3]], $noreg,  !13, !DIExpression(DW_OP_LLVM_fragment, 64, 16)
-; DBGVALUE-NEXT: DBG_VALUE [[REG1]], $noreg,  !12, !DIExpression(DW_OP_LLVM_fragment, 10, 32)
-; DBGVALUE-NEXT: DBG_VALUE [[REG2]], $noreg,  !12, !DIExpression(DW_OP_LLVM_fragment, 42, 13)
+; INSTRREF-NEXT: DBG_INSTR_REF !16, !DIExpression(DW_OP_LLVM_arg, 0, DW_OP_LLVM_fragment, 0, 32), dbg-instr-ref(1, 0)
+; INSTRREF-NEXT: DBG_INSTR_REF !16, !DIExpression(DW_OP_LLVM_arg, 0, DW_OP_LLVM_fragment, 32, 32), dbg-instr-ref(2, 0)
+; INSTRREF-NEXT: DBG_INSTR_REF !16, !DIExpression(DW_OP_LLVM_arg, 0, DW_OP_LLVM_fragment, 64, 16), dbg-instr-ref(3, 0)
+; INSTRREF-NEXT: DBG_INSTR_REF !15, !DIExpression(DW_OP_LLVM_arg, 0, DW_OP_LLVM_fragment, 10, 32), dbg-instr-ref(1, 0)
+; INSTRREF-NEXT: DBG_INSTR_REF !15, !DIExpression(DW_OP_LLVM_arg, 0, DW_OP_LLVM_fragment, 42, 13), dbg-instr-ref(2, 0)
+; DBGVALUE-NEXT: DBG_VALUE [[REG1]], $noreg,  !16, !DIExpression(DW_OP_LLVM_fragment, 0, 32)
+; DBGVALUE-NEXT: DBG_VALUE [[REG2]], $noreg,  !16, !DIExpression(DW_OP_LLVM_fragment, 32, 32)
+; DBGVALUE-NEXT: DBG_VALUE [[REG3]], $noreg,  !16, !DIExpression(DW_OP_LLVM_fragment, 64, 16)
+; DBGVALUE-NEXT: DBG_VALUE [[REG1]], $noreg,  !15, !DIExpression(DW_OP_LLVM_fragment, 10, 32)
+; DBGVALUE-NEXT: DBG_VALUE [[REG2]], $noreg,  !15, !DIExpression(DW_OP_LLVM_fragment, 42, 13)
 ; CHECK-NOT:  DBG_
 
 target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32"
 target triple = "i686-w64-windows-gnu"
 
 ; Function Attrs: nounwind readnone
-define dso_local i64 @nextafterl(i80 %a) local_unnamed_addr #0 !dbg !6 {
+define dso_local i64 @nextafterl(i80 %a) local_unnamed_addr #0 !dbg !5 {
 entry:
-  br i1 undef, label %if.else, label %if.then13, !dbg !28
+  br i1 undef, label %if.else, label %if.then13, !dbg !27
 
 if.then13:                                        ; preds = %entry
-  %u.sroa.0.8.insert.insert = or i80 %a, 2222, !dbg !29
-  br label %if.end36, !dbg !33
+  %u.sroa.0.8.insert.insert = or i80 %a, 2222, !dbg !28
+  br label %if.end36, !dbg !32
 
 if.else:                                          ; preds = %entry
   br label %if.end36
 
 if.end36:                                         ; preds = %if.else, %if.then13
   %u.sroa.0.1.in = phi i80 [ %u.sroa.0.8.insert.insert, %if.then13 ], [ 1234567, %if.else ]
-  call void @llvm.dbg.value(metadata i80 %u.sroa.0.1.in, metadata !13, metadata !DIExpression(DW_OP_LLVM_fragment, 0, 80)), !dbg !34
-  call void @llvm.dbg.value(metadata i80 %u.sroa.0.1.in, metadata !12, metadata !DIExpression(DW_OP_LLVM_fragment, 10, 45)), !dbg !34
-  %u.sroa.0.0.extract.ashr = ashr i80 %u.sroa.0.1.in, 8, !dbg !35
-  %u.sroa.0.0.extract.trunc = trunc i80 %u.sroa.0.0.extract.ashr to i64, !dbg !35
+  call void @llvm.dbg.value(metadata i80 %u.sroa.0.1.in, metadata !16, metadata !DIExpression(DW_OP_LLVM_fragment, 0, 80)), !dbg !33
+  call void @llvm.dbg.value(metadata i80 %u.sroa.0.1.in, metadata !15, metadata !DIExpression(DW_OP_LLVM_fragment, 10, 45)), !dbg !33
+  %u.sroa.0.0.extract.ashr = ashr i80 %u.sroa.0.1.in, 8, !dbg !34
+  %u.sroa.0.0.extract.trunc = trunc i80 %u.sroa.0.0.extract.ashr to i64, !dbg !34
   ret i64 %u.sroa.0.0.extract.trunc
 }
 
 ; Function Attrs: nounwind readnone speculatable
 declare void @llvm.dbg.value(metadata, metadata, metadata) #1
 
 attributes #0 = { nounwind readnone }
 attributes #1 = { nounwind readnone speculatable }
 
 !llvm.dbg.cu = !{!0}
-!llvm.module.flags = !{!26, !27}
+!llvm.module.flags = !{!4, !3}
 
-!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 7.0.0 (trunk 330808) (llvm/trunk 330813)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, globals: !3)
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 7.0.0 (trunk 330808) (llvm/trunk 330813)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, globals: !2)
 !1 = !DIFile(filename: "pr37321.c", directory: "")
 !2 = !{}
-!3 = !{!4}
-!4 = !DIGlobalVariableExpression(var: !5, expr: !DIExpression())
-!5 = distinct !DIGlobalVariable(name: "normal_bit", scope: !6, file: !1, line: 31, type: !25, isLocal: true, isDefinition: true)
-!6 = distinct !DISubprogram(name: "nextafterl", scope: !1, file: !1, line: 17, type: !7, isLocal: false, isDefinition: true, scopeLine: 18, flags: DIFlagPrototyped, isOptimized: true, unit: !0, retainedNodes: !10)
-!7 = !DISubroutineType(types: !8)
-!8 = !{!9, !9, !9}
-!9 = !DIBasicType(name: "long double", size: 96, encoding: DW_ATE_float)
-!10 = !{!11, !12, !13}
-!11 = !DILocalVariable(name: "x", arg: 1, scope: !6, file: !1, line: 17, type: !9)
-!12 = !DILocalVariable(name: "y", arg: 2, scope: !6, file: !1, line: 17, type: !9)
-!13 = !DILocalVariable(name: "u", scope: !6, file: !1, line: 27, type: !14)
-!14 = distinct !DICompositeType(tag: DW_TAG_union_type, scope: !6, file: !1, line: 19, size: 128, elements: !15)
-!15 = !{!16, !17}
-!16 = !DIDerivedType(tag: DW_TAG_member, name: "ld", scope: !14, file: !1, line: 20, baseType: !9, size: 96)
-!17 = !DIDerivedType(tag: DW_TAG_member, name: "parts", scope: !14, file: !1, line: 26, baseType: !18, size: 128)
-!18 = distinct !DICompositeType(tag: DW_TAG_structure_type, scope: !14, file: !1, line: 21, size: 128, elements: !19)
-!19 = !{!20, !22, !24}
-!20 = !DIDerivedType(tag: DW_TAG_member, name: "mantissa", scope: !18, file: !1, line: 23, baseType: !21, size: 64)
-!21 = !DIBasicType(name: "long long unsigned int", size: 64, encoding: DW_ATE_unsigned)
-!22 = !DIDerivedType(tag: DW_TAG_member, name: "expn", scope: !18, file: !1, line: 24, baseType: !23, size: 16, offset: 64)
-!23 = !DIBasicType(name: "unsigned short", size: 16, encoding: DW_ATE_unsigned)
-!24 = !DIDerivedType(tag: DW_TAG_member, name: "pad", scope: !18, file: !1, line: 25, baseType: !23, size: 16, offset: 80)
-!25 = !DIDerivedType(tag: DW_TAG_const_type, baseType: !21)
-!26 = !{i32 2, !"Debug Info Version", i32 3}
-!27 = !{i32 1, !"wchar_size", i32 2}
-!28 = !DILocation(line: 47, column: 7, scope: !6)
-!29 = !DILocation(line: 51, column: 14, scope: !30)
-!30 = distinct !DILexicalBlock(scope: !31, file: !1, line: 50, column: 11)
-!31 = distinct !DILexicalBlock(scope: !32, file: !1, line: 48, column: 5)
-!32 = distinct !DILexicalBlock(scope: !6, file: !1, line: 47, column: 7)
-!33 = !DILocation(line: 51, column: 2, scope: !30)
-!34 = !DILocation(line: 27, column: 5, scope: !6)
-!35 = !DILocation(line: 63, column: 22, scope: !36)
-!36 = distinct !DILexicalBlock(scope: !6, file: !1, line: 62, column: 7)
+!3 = !{i32 1, !"wchar_size", i32 2}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = distinct !DISubprogram(name: "nextafterl", scope: !1, file: !1, line: 17, type: !6, isLocal: false, isDefinition: true, scopeLine: 18, flags: DIFlagPrototyped, isOptimized: true, unit: !0, retainedNodes: !9)
+!6 = !DISubroutineType(types: !7)
+!7 = !{!8, !8, !8}
+!8 = !DIBasicType(name: "long double", size: 96, encoding: DW_ATE_float)
+!9 = !{!10, !14, !15, !16}
+!10 = !DIGlobalVariableExpression(var: !11, expr: !DIExpression())
+!11 = distinct !DIGlobalVariable(name: "normal_bit", scope: !5, file: !1, line: 31, type: !12, isLocal: true, isDefinition: true)
+!12 = !DIDerivedType(tag: DW_TAG_const_type, baseType: !13)
+!13 = !DIBasicType(name: "long long unsigned int", size: 64, encoding: DW_ATE_unsigned)
+!14 = !DILocalVariable(name: "x", arg: 1, scope: !5, file: !1, line: 17, type: !8)
+!15 = !DILocalVariable(name: "y", arg: 2, scope: !5, file: !1, line: 17, type: !8)
+!16 = !DILocalVariable(name: "u", scope: !5, file: !1, line: 27, type: !24)
+!17 = !DIDerivedType(tag: DW_TAG_member, name: "parts", scope: !24, file: !1, line: 26, baseType: !18, size: 128)
+!18 = distinct !DICompositeType(tag: DW_TAG_structure_type, scope: !24, file: !1, line: 21, size: 128, elements: !19)
+!19 = !{!20, !21, !23}
+!20 = !DIDerivedType(tag: DW_TAG_member, name: "mantissa", scope: !18, file: !1, line: 23, baseType: !13, size: 64)
+!21 = !DIDerivedType(tag: DW_TAG_member, name: "expn", scope: !18, file: !1, line: 24, baseType: !22, size: 16, offset: 64)
+!22 = !DIBasicType(name: "unsigned short", size: 16, encoding: DW_ATE_unsigned)
+!23 = !DIDerivedType(tag: DW_TAG_member, name: "pad", scope: !18, file: !1, line: 25, baseType: !22, size: 16, offset: 80)
+!24 = distinct !DICompositeType(tag: DW_TAG_union_type, scope: !5, file: !1, line: 19, size: 128, elements: !25)
+!25 = !{!26, !17}
+!26 = !DIDerivedType(tag: DW_TAG_member, name: "ld", scope: !24, file: !1, line: 20, baseType: !8, size: 96)
+!27 = !DILocation(line: 47, column: 7, scope: !5)
+!28 = !DILocation(line: 51, column: 14, scope: !29)
+!29 = distinct !DILexicalBlock(scope: !30, file: !1, line: 50, column: 11)
+!30 = distinct !DILexicalBlock(scope: !31, file: !1, line: 48, column: 5)
+!31 = distinct !DILexicalBlock(scope: !5, file: !1, line: 47, column: 7)
+!32 = !DILocation(line: 51, column: 2, scope: !29)
+!33 = !DILocation(line: 27, column: 5, scope: !5)
+!34 = !DILocation(line: 63, column: 22, scope: !35)
+!35 = distinct !DILexicalBlock(scope: !5, file: !1, line: 62, column: 7)

llvm/test/DebugInfo/duplicate_dbgvalue.ll

 ; Function Attrs: nounwind readnone speculatable willreturn
 declare void @llvm.dbg.value(metadata, metadata, metadata)
 
 !llvm.module.flags = !{!14, !15}
 !llvm.dbg.cu = !{!4}
 
 !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
 !1 = distinct !DIGlobalVariable(name: "res", scope: !2, file: !3, type: !9, isLocal: true, isDefinition: true)
-!2 = distinct !DISubprogram(name: "main", scope: !4, file: !3, line: 1, type: !12, scopeLine: 1, spFlags: DISPFlagDefinition | DISPFlagMainSubprogram, unit: !4)
+!2 = distinct !DISubprogram(name: "main", scope: !4, file: !3, line: 1, type: !12, scopeLine: 1, spFlags: DISPFlagDefinition | DISPFlagMainSubprogram, unit: !4, retainedNodes: !60)
 !3 = !DIFile(filename: "duplicate-dbgvalue.f90", directory: "/dir")
 !4 = distinct !DICompileUnit(language: DW_LANG_Fortran90, file: !3, producer: " F90 Flang - 1.5", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !5, retainedTypes: !5, globals: !6, imports: !5)
 !5 = !{}
-!6 = !{!0, !7, !10}
+!6 = !{!7, !10}
 !7 = !DIGlobalVariableExpression(var: !8, expr: !DIExpression())
 !8 = distinct !DIGlobalVariable(name: "res", scope: !4, file: !3, type: !9, isLocal: true, isDefinition: true)
 !9 = !DIBasicType(name: "integer", size: 32, align: 32, encoding: DW_ATE_signed)
 !10 = !DIGlobalVariableExpression(var: !11, expr: !DIExpression())
 !11 = distinct !DIGlobalVariable(name: "res", scope: !4, file: !3, type: !9, isLocal: true, isDefinition: true)
 !12 = !DISubroutineType(cc: DW_CC_program, types: !13)
 !13 = !{null}
 !14 = !{i32 2, !"Dwarf Version", i32 4}

 !52 = !DILexicalBlock(scope: !45, file: !3, line: 12, column: 1)
 !53 = !DILocalVariable(arg: 2, scope: !45, file: !3, type: !32, flags: DIFlagArtificial)
 !54 = !DILocation(line: 14, column: 1, scope: !52)
 !55 = !{!56, !56, i64 0}
 !56 = !{!"t3.2", !57, i64 0}
 !57 = !{!"unlimited ptr", !58, i64 0}
 !58 = !{!"Flang FAA 3"}
 !59 = !DILocation(line: 15, column: 1, scope: !52)
+!60 = !{!0}

llvm/test/Instrumentation/InstrProfiling/debug-info-correlate.ll

 ; CHECK:      ![[SCOPE]] = {{.*}} !DISubprogram(name: "foo"
 ; CHECK:      ![[ANNOTATIONS]] = !{![[NAME:[0-9]+]], ![[HASH:[0-9]+]], ![[COUNTERS:[0-9]+]]}
 ; CHECK:      ![[NAME]] = !{!"Function Name", !"foo"}
 ; CHECK:      ![[HASH]] = !{!"CFG Hash", i64 12345678}
 ; CHECK:      ![[COUNTERS]] = !{!"Num Counters", i32 2}
 
 define void @_Z3foov() !dbg !12 {
   call void @llvm.instrprof.increment(ptr @__profn_foo, i64 12345678, i32 2, i32 0)
-  ret void
+  ret void, !dbg !17
 }
 
 declare void @llvm.instrprof.increment(ptr, i64, i32, i32)
 
 !llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!2, !3, !4, !5, !6, !7, !8, !9, !10}
 !llvm.ident = !{!11}
 

 !9 = !{i32 7, !"uwtable", i32 1}
 !10 = !{i32 7, !"frame-pointer", i32 1}
 !11 = !{!"clang version 14.0.0"}
 !12 = distinct !DISubprogram(name: "foo", linkageName: "_Z3foov", scope: !13, file: !13, line: 1, type: !14, scopeLine: 1, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !16)
 !13 = !DIFile(filename: "debug-info-correlate.cpp", directory: "")
 !14 = !DISubroutineType(types: !15)
 !15 = !{null}
 !16 = !{}
+!17 = !DILocation(line: 1, scope: !12)
 
 ; CHECK-DWARF: DW_TAG_compile_unit
 ; CHECK-DWARF:   DW_TAG_subprogram
 ; CHECK-DWARF:     DW_AT_name ("foo")
 ; CHECK-DWARF:     DW_TAG_variable
 ; CHECK-DWARF:       DW_AT_name ("__profc_foo")
 ; CHECK-DWARF:       DW_AT_type ({{.*}} "Profile Data Type")
 ; CHECK-DWARF:       DW_TAG_LLVM_annotation

llvm/test/Transforms/Util/clone-dicompileunit.ll

 
 ; Test that when the module is cloned it does not contain a reference to
 ; the original DICompileUnit as a result of a collision between the cloned
 ; DISubprogram for m_fn2<B> (which refers to the non-ODR entity B via
 ; template parameters) and the original DISubprogram.
 
 ; CHECK: DICompileUnit
 ; CHECK-NOT: DICompileUnit
+; CHECK: DISubprogram
+; CHECK-NOT: DICompileUnit
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux"
 
+define void @foo() !dbg !6 {
+  ret void
+}
+
 !llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!28, !29}
 !llvm.ident = !{!30}
 
-!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 5.0.0 ", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, globals: !3)
+!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 5.0.0 ", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, globals: !2)
 !1 = !DIFile(filename: "p.cpp", directory: "/usr/local/google/home/pcc/b682773-2-repro/small2")
 !2 = !{}
-!3 = !{!4}
 !4 = !DIGlobalVariableExpression(var: !5, expr: !DIExpression())
 !5 = distinct !DIGlobalVariable(name: "a", scope: !6, file: !1, line: 5, type: !27, isLocal: true, isDefinition: true)
 !6 = distinct !DISubprogram(name: "m_fn2<B>", linkageName: "_ZN1A5m_fn2IZ3foovE1BEEvv", scope: !7, file: !1, line: 5, type: !8, isLocal: true, isDefinition: true, scopeLine: 5, flags: DIFlagPrototyped, isOptimized: true, unit: !0, templateParams: !11, declaration: !23, retainedNodes: !24)
 !7 = !DICompositeType(tag: DW_TAG_class_type, name: "A", file: !1, line: 3, flags: DIFlagFwdDecl, identifier: "_ZTS1A")
 !8 = !DISubroutineType(types: !9)
 !9 = !{null, !10}
 !10 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !7, size: 64, flags: DIFlagArtificial | DIFlagObjectPointer)
 !11 = !{!12}
 !12 = !DITemplateTypeParameter(type: !13)
 !13 = distinct !DICompositeType(tag: DW_TAG_class_type, name: "B", scope: !14, file: !1, line: 10, size: 64, elements: !17, vtableHolder: !7)
 !14 = distinct !DISubprogram(name: "foo", linkageName: "_Z3foov", scope: !1, file: !1, line: 9, type: !15, isLocal: false, isDefinition: true, scopeLine: 9, flags: DIFlagPrototyped, isOptimized: true, unit: !0, retainedNodes: !2)
 !15 = !DISubroutineType(types: !16)
 !16 = !{null}
 !17 = !{!18, !19}
 !18 = !DIDerivedType(tag: DW_TAG_inheritance, scope: !13, baseType: !7, flags: DIFlagPublic)
 !19 = !DISubprogram(name: "B", scope: !13, file: !1, line: 12, type: !20, isLocal: false, isDefinition: false, scopeLine: 12, flags: DIFlagPublic | DIFlagPrototyped, isOptimized: true)
 !20 = !DISubroutineType(types: !21)
 !21 = !{null, !22}
 !22 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !13, size: 64, flags: DIFlagArtificial | DIFlagObjectPointer)
 !23 = !DISubprogram(name: "m_fn2<B>", linkageName: "_ZN1A5m_fn2IZ3foovE1BEEvv", scope: !7, file: !1, line: 5, type: !8, isLocal: false, isDefinition: false, scopeLine: 5, flags: DIFlagPublic | DIFlagPrototyped, isOptimized: true, templateParams: !11)
-!24 = !{!25}
+!24 = !{!25, !4}
 !25 = !DILocalVariable(name: "this", arg: 1, scope: !6, type: !26, flags: DIFlagArtificial | DIFlagObjectPointer)
 !26 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !7, size: 64)
 !27 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
 !28 = !{i32 2, !"Dwarf Version", i32 4}
 !29 = !{i32 2, !"Debug Info Version", i32 3}
 !30 = !{!"clang version 5.0.0 "}

llvm/unittests/Transforms/Utils/CloningTest.cpp

 
 TEST_F(CloneModule, Subprogram) {
   Function *NewF = NewM->getFunction("f");
   DISubprogram *SP = NewF->getSubprogram();
   EXPECT_TRUE(SP != nullptr);
   EXPECT_EQ(SP->getName(), "f");
   EXPECT_EQ(SP->getFile()->getFilename(), "filename.c");
   EXPECT_EQ(SP->getLine(), (unsigned)4);
+
+  // Check static locals.
+  MDNodeArray LocalDeclsArray = SP->getRetainedNodes();
+  EXPECT_EQ(LocalDeclsArray.size(), 2U);
+  for (auto *Node : LocalDeclsArray) {
+    auto *GVExpr = cast<DIGlobalVariableExpression>(Node);
+    DIGlobalVariable *GV = GVExpr->getVariable();
+    EXPECT_EQ(GV->getScope(), SP);
+  }
 }
 
 TEST_F(CloneModule, FunctionDeclarationMetadata) {
   Function *NewF = NewM->getFunction("g");
   EXPECT_NE(nullptr, NewF->getMetadata(LLVMContext::MD_type));
 }
 
 TEST_F(CloneModule, GlobalMetadata) {
TEST_F(CloneModule, CompileUnit) {
   DICompileUnit *CU = dyn_cast<llvm::DICompileUnit>(NMD->getOperand(1));
   EXPECT_TRUE(CU != nullptr);
   EXPECT_EQ("CloneModule", CU->getProducer());
 
   // Assert this CU is consistent with the cloned function debug info
   DISubprogram *SP = NewM->getFunction("f")->getSubprogram();
   EXPECT_TRUE(SP != nullptr);
   EXPECT_EQ(SP->getUnit(), CU);
-
-  // Check globals listed in CU have the correct scope
-  DIGlobalVariableExpressionArray GlobalArray = CU->getGlobalVariables();
-  EXPECT_EQ(GlobalArray.size(), 2U);
-  for (DIGlobalVariableExpression *GVExpr : GlobalArray) {
-    DIGlobalVariable *GV = GVExpr->getVariable();
-    EXPECT_EQ(GV->getScope(), SP);
-  }
 }
 
 TEST_F(CloneModule, Comdat) {
   GlobalVariable *NewGV = NewM->getGlobalVariable("gv");
   auto *CD = NewGV->getComdat();
   ASSERT_NE(nullptr, CD);
   EXPECT_EQ("comdat", CD->getName());
   EXPECT_EQ(Comdat::ExactMatch, CD->getSelectionKind());