[nfc][DebugInfo] Move subprogram rewriting utility to header

[fdeazeve]

Summary

This utility will be useful in subsequent patches, as such we expose it
in the DebugInfoMetadata header.

Depends on D139669

[fdeazeve]

Updated stack

[fdeazeve]

Rebased

[fdeazeve]

Failures unrelated and happen even without the commit

llvm/include/llvm/IR/DebugInfoMetadata.h

 
 public:
   /// Get the subprogram for this scope.
   ///
   /// Return this if it's an \a DISubprogram; otherwise, look up the scope
   /// chain.
   DISubprogram *getSubprogram() const;
 
+  /// Traverses the scope chain rooted at RootScope until it hits a Subprogram,
+  /// recreating the chain with "NewSP" instead.
+  static DILocalScope *
+  cloneScopeForSubprogram(DILocalScope &RootScope, DISubprogram &NewSP,
+                          LLVMContext &Ctx,
+                          DenseMap<const MDNode *, MDNode *> &Cache);
+
   /// Get the first non DILexicalBlockFile scope of this scope.
   ///
   /// Return this if it's not a \a DILexicalBlockFIle; otherwise, look up the
   /// scope chain.
   DILocalScope *getNonLexicalBlockFileScope() const;
 
   static bool classof(const Metadata *MD) {
     return MD->getMetadataID() == DISubprogramKind ||

llvm/lib/IR/DebugInfoMetadata.cpp

 }
 
 DILocalScope *DILocalScope::getNonLexicalBlockFileScope() const {
   if (auto *File = dyn_cast<DILexicalBlockFile>(this))
     return File->getScope()->getNonLexicalBlockFileScope();
   return const_cast<DILocalScope *>(this);
 }
 
+DILocalScope *DILocalScope::cloneScopeForSubprogram(
+    DILocalScope &RootScope, DISubprogram &NewSP, LLVMContext &Ctx,
+    DenseMap<const MDNode *, MDNode *> &Cache) {
+  SmallVector<DIScope *> ScopeChain;
+  DIScope *CachedResult = nullptr;
+
+  for (DIScope *Scope = &RootScope; !isa<DISubprogram>(Scope);
+       Scope = Scope->getScope()) {
+    if (auto It = Cache.find(Scope); It != Cache.end()) {
+      CachedResult = cast<DIScope>(It->second);
+      break;
+    }
+    ScopeChain.push_back(Scope);
+  }
+
+  // Recreate the scope chain, bottom-up, starting at the new subprogram (or a
+  // cached result).
+  DIScope *UpdatedScope = CachedResult ? CachedResult : &NewSP;
+  for (DIScope *ScopeToUpdate : reverse(ScopeChain)) {
+    TempMDNode ClonedScope = ScopeToUpdate->clone();
+    cast<DILexicalBlockBase>(*ClonedScope).replaceScope(UpdatedScope);
+    UpdatedScope =
+        cast<DIScope>(MDNode::replaceWithUniqued(std::move(ClonedScope)));
+    Cache[ScopeToUpdate] = UpdatedScope;
+  }
+
+  return cast<DILocalScope>(UpdatedScope);
+}
+
 DISubprogram::DISPFlags DISubprogram::getFlag(StringRef Flag) {
   return StringSwitch<DISPFlags>(Flag)
 #define HANDLE_DISP_FLAG(ID, NAME) .Case("DISPFlag" #NAME, SPFlag##NAME)
 #include "llvm/IR/DebugInfoFlags.def"
       .Default(SPFlagZero);
 }
 
 StringRef DISubprogram::getFlagString(DISPFlags Flag) {

llvm/lib/IR/DebugLoc.cpp

 }
 
 void DebugLoc::setImplicitCode(bool ImplicitCode) {
   if (DILocation *Loc = get()) {
     Loc->setImplicitCode(ImplicitCode);
   }
 }
 
-/// Traverses the scope chain rooted at RootScope until it hits a Subprogram,
-/// recreating the chain with "NewSP" instead.
-static DIScope *
-cloneScopeForSubprogram(DILocalScope &RootScope, DISubprogram &NewSP,
-                        LLVMContext &Ctx,
-                        DenseMap<const MDNode *, MDNode *> &Cache) {
-  SmallVector<DIScope *> ScopeChain;
-  DIScope *CachedResult = nullptr;
-
-  for (DIScope *Scope = &RootScope; !isa<DISubprogram>(Scope);
-       Scope = Scope->getScope()) {
-    if (auto It = Cache.find(Scope); It != Cache.end()) {
-      CachedResult = cast<DIScope>(It->second);
-      break;
-    }
-    ScopeChain.push_back(Scope);
-  }
-
-  // Recreate the scope chain, bottom-up, starting at the new subprogram (or a
-  // cached result).
-  DIScope *UpdatedScope = CachedResult ? CachedResult : &NewSP;
-  for (DIScope *ScopeToUpdate : reverse(ScopeChain)) {
-    TempMDNode ClonedScope = ScopeToUpdate->clone();
-    cast<DILexicalBlockBase>(*ClonedScope).replaceScope(UpdatedScope);
-    UpdatedScope =
-        cast<DIScope>(MDNode::replaceWithUniqued(std::move(ClonedScope)));
-    Cache[ScopeToUpdate] = UpdatedScope;
-  }
-  return UpdatedScope;
-}
-
 DebugLoc DebugLoc::replaceInlinedAtSubprogram(
     const DebugLoc &RootLoc, DISubprogram &NewSP, LLVMContext &Ctx,
     DenseMap<const MDNode *, MDNode *> &Cache) {
   SmallVector<DILocation *> LocChain;
   DILocation *CachedResult = nullptr;
 
   // Collect the inline chain, stopping if we find a location that has already
   // been processed.
   for (DILocation *Loc = RootLoc; Loc; Loc = Loc->getInlinedAt()) {
     if (auto It = Cache.find(Loc); It != Cache.end()) {
       CachedResult = cast<DILocation>(It->second);
       break;
     }
     LocChain.push_back(Loc);
   }
 
   DILocation *UpdatedLoc = CachedResult;
   if (!UpdatedLoc) {
     // If no cache hits, then back() is the end of the inline chain, that is,
     // the DILocation whose scope ends in the Subprogram to be replaced.
     DILocation *LocToUpdate = LocChain.pop_back_val();
-    DIScope *NewScope =
-        cloneScopeForSubprogram(*LocToUpdate->getScope(), NewSP, Ctx, Cache);
+    DIScope *NewScope = DILocalScope::cloneScopeForSubprogram(
+        *LocToUpdate->getScope(), NewSP, Ctx, Cache);
     UpdatedLoc = DILocation::get(Ctx, LocToUpdate->getLine(),
                                  LocToUpdate->getColumn(), NewScope);
     Cache[LocToUpdate] = UpdatedLoc;
   }
 
   // Recreate the location chain, bottom-up, starting at the new scope (or a
   // cached result).
   for (const DILocation *LocToUpdate : reverse(LocChain)) {