Revert "[CGData][MachineOutliner] Global Outlining (#90074)"

[kyulee-com]

This reverts commit 0f52545.

[llvmbot]

@llvm/pr-subscribers-llvm-adt

@llvm/pr-subscribers-backend-aarch64

Author: Kyungwoo Lee (kyulee-com)

Changes

This reverts commit 0f52545.

---

Patch is 44.42 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/108033.diff

16 Files Affected:

• (modified) llvm/include/llvm/ADT/StableHashing.h (-6)
• (modified) llvm/include/llvm/CodeGen/MachineOutliner.h (+2-38)
• (modified) llvm/lib/CGData/CodeGenData.cpp (+1-25)
• (modified) llvm/lib/CodeGen/CMakeLists.txt (-1)
• (modified) llvm/lib/CodeGen/MachineOutliner.cpp (+1-253)
• (modified) llvm/test/CodeGen/AArch64/O3-pipeline.ll (-1)
• (removed) llvm/test/CodeGen/AArch64/cgdata-global-hash.ll (-40)
• (removed) llvm/test/CodeGen/AArch64/cgdata-outlined-name.ll (-41)
• (removed) llvm/test/CodeGen/AArch64/cgdata-read-double-outline.ll (-57)
• (removed) llvm/test/CodeGen/AArch64/cgdata-read-lto-outline.ll (-96)
• (removed) llvm/test/CodeGen/AArch64/cgdata-read-priority.ll (-68)
• (removed) llvm/test/CodeGen/AArch64/cgdata-read-single-outline-suffix.ll (-100)
• (removed) llvm/test/CodeGen/AArch64/cgdata-read-single-outline.ll (-42)
• (removed) llvm/test/CodeGen/AArch64/cgdata-write-outline.ll (-51)
• (modified) llvm/test/CodeGen/RISCV/O3-pipeline.ll (-1)
• (modified) llvm/unittests/MIR/MachineStableHashTest.cpp (-70)

diff --git a/llvm/include/llvm/ADT/StableHashing.h b/llvm/include/llvm/ADT/StableHashing.h
index b220a0ed1f9131..7852199f8b0a00 100644
--- a/llvm/include/llvm/ADT/StableHashing.h
+++ b/llvm/include/llvm/ADT/StableHashing.h
@@ -53,12 +53,6 @@ inline stable_hash stable_hash_combine(stable_hash A, stable_hash B,
 // Removes suffixes introduced by LLVM from the name to enhance stability and
 // maintain closeness to the original name across different builds.
 inline StringRef get_stable_name(StringRef Name) {
-  // Return the part after ".content." that represents contents.
-  auto [P0, S0] = Name.rsplit(".content.");
-  if (!S0.empty())
-    return S0;
-
-  // Ignore these suffixes.
   auto [P1, S1] = Name.rsplit(".llvm.");
   auto [P2, S2] = P1.rsplit(".__uniq.");
   return P2;
diff --git a/llvm/include/llvm/CodeGen/MachineOutliner.h b/llvm/include/llvm/CodeGen/MachineOutliner.h
index fbb958ccf6488e..eaba6c9b18f2bb 100644
--- a/llvm/include/llvm/CodeGen/MachineOutliner.h
+++ b/llvm/include/llvm/CodeGen/MachineOutliner.h
@@ -18,7 +18,6 @@
 #include "llvm/CodeGen/LiveRegUnits.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineRegisterInfo.h"
-#include "llvm/CodeGen/MachineStableHash.h"
 #include <initializer_list>
 
 namespace llvm {
@@ -235,11 +234,11 @@ struct OutlinedFunction {
   unsigned FrameConstructionID = 0;
 
   /// Return the number of candidates for this \p OutlinedFunction.
-  virtual unsigned getOccurrenceCount() const { return Candidates.size(); }
+  unsigned getOccurrenceCount() const { return Candidates.size(); }
 
   /// Return the number of bytes it would take to outline this
   /// function.
-  virtual unsigned getOutliningCost() const {
+  unsigned getOutliningCost() const {
     unsigned CallOverhead = 0;
     for (const Candidate &C : Candidates)
       CallOverhead += C.getCallOverhead();
@@ -273,42 +272,7 @@ struct OutlinedFunction {
   }
 
   OutlinedFunction() = delete;
-  virtual ~OutlinedFunction() = default;
 };
-
-/// The information necessary to create an outlined function that is matched
-/// globally.
-struct GlobalOutlinedFunction : public OutlinedFunction {
-  explicit GlobalOutlinedFunction(std::unique_ptr<OutlinedFunction> OF,
-                                  unsigned GlobalOccurrenceCount)
-      : OutlinedFunction(*OF), GlobalOccurrenceCount(GlobalOccurrenceCount) {}
-
-  unsigned GlobalOccurrenceCount;
-
-  /// Return the number of times that appear globally.
-  /// Global outlining candidate is uniquely created per each match, but this
-  /// might be erased out when it's overlapped with the previous outlining
-  /// instance.
-  unsigned getOccurrenceCount() const override {
-    assert(Candidates.size() <= 1);
-    return Candidates.empty() ? 0 : GlobalOccurrenceCount;
-  }
-
-  /// Return the outlining cost using the global occurrence count
-  /// with the same cost as the first (unique) candidate.
-  unsigned getOutliningCost() const override {
-    assert(Candidates.size() <= 1);
-    unsigned CallOverhead =
-        Candidates.empty()
-            ? 0
-            : Candidates[0].getCallOverhead() * getOccurrenceCount();
-    return CallOverhead + SequenceSize + FrameOverhead;
-  }
-
-  GlobalOutlinedFunction() = delete;
-  ~GlobalOutlinedFunction() = default;
-};
-
 } // namespace outliner
 } // namespace llvm
 
diff --git a/llvm/lib/CGData/CodeGenData.cpp b/llvm/lib/CGData/CodeGenData.cpp
index 55d2504231c744..9dd4b1674e094a 100644
--- a/llvm/lib/CGData/CodeGenData.cpp
+++ b/llvm/lib/CGData/CodeGenData.cpp
@@ -24,13 +24,6 @@
 using namespace llvm;
 using namespace cgdata;
 
-cl::opt<bool>
-    CodeGenDataGenerate("codegen-data-generate", cl::init(false), cl::Hidden,
-                        cl::desc("Emit CodeGen Data into custom sections"));
-cl::opt<std::string>
-    CodeGenDataUsePath("codegen-data-use-path", cl::init(""), cl::Hidden,
-                       cl::desc("File path to where .cgdata file is read"));
-
 static std::string getCGDataErrString(cgdata_error Err,
                                       const std::string &ErrMsg = "") {
   std::string Msg;
@@ -139,24 +132,7 @@ CodeGenData &CodeGenData::getInstance() {
   std::call_once(CodeGenData::OnceFlag, []() {
     Instance = std::unique_ptr<CodeGenData>(new CodeGenData());
 
-    if (CodeGenDataGenerate)
-      Instance->EmitCGData = true;
-    else if (!CodeGenDataUsePath.empty()) {
-      // Initialize the global CGData if the input file name is given.
-      // We do not error-out when failing to parse the input file.
-      // Instead, just emit an warning message and fall back as if no CGData
-      // were available.
-      auto FS = vfs::getRealFileSystem();
-      auto ReaderOrErr = CodeGenDataReader::create(CodeGenDataUsePath, *FS);
-      if (Error E = ReaderOrErr.takeError()) {
-        warn(std::move(E), CodeGenDataUsePath);
-        return;
-      }
-      // Publish each CGData based on the data type in the header.
-      auto Reader = ReaderOrErr->get();
-      if (Reader->hasOutlinedHashTree())
-        Instance->publishOutlinedHashTree(Reader->releaseOutlinedHashTree());
-    }
+    // TODO: Initialize writer or reader mode for the client optimization.
   });
   return *(Instance.get());
 }
diff --git a/llvm/lib/CodeGen/CMakeLists.txt b/llvm/lib/CodeGen/CMakeLists.txt
index 5a17944db0ae03..ae12ce1170f703 100644
--- a/llvm/lib/CodeGen/CMakeLists.txt
+++ b/llvm/lib/CodeGen/CMakeLists.txt
@@ -268,7 +268,6 @@ add_llvm_component_library(LLVMCodeGen
   Analysis
   BitReader
   BitWriter
-  CGData
   CodeGenTypes
   Core
   MC
diff --git a/llvm/lib/CodeGen/MachineOutliner.cpp b/llvm/lib/CodeGen/MachineOutliner.cpp
index c9cb8882feb4e9..97500d0abebad5 100644
--- a/llvm/lib/CodeGen/MachineOutliner.cpp
+++ b/llvm/lib/CodeGen/MachineOutliner.cpp
@@ -59,9 +59,7 @@
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/ADT/Twine.h"
-#include "llvm/Analysis/ModuleSummaryAnalysis.h"
 #include "llvm/Analysis/OptimizationRemarkEmitter.h"
-#include "llvm/CGData/CodeGenDataReader.h"
 #include "llvm/CodeGen/LivePhysRegs.h"
 #include "llvm/CodeGen/MachineModuleInfo.h"
 #include "llvm/CodeGen/MachineOptimizationRemarkEmitter.h"
@@ -77,7 +75,6 @@
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/SuffixTree.h"
 #include "llvm/Support/raw_ostream.h"
-#include "llvm/Transforms/Utils/ModuleUtils.h"
 #include <functional>
 #include <tuple>
 #include <vector>
@@ -101,10 +98,6 @@ STATISTIC(NumInvisible,
           "Invisible instructions skipped during mapping");
 STATISTIC(UnsignedVecSize,
           "Total number of instructions mapped and saved to mapping vector");
-STATISTIC(StableHashAttempts,
-          "Count of hashing attempts made for outlined functions");
-STATISTIC(StableHashDropped,
-          "Count of unsuccessful hashing attempts for outlined functions");
 
 // Set to true if the user wants the outliner to run on linkonceodr linkage
 // functions. This is false by default because the linker can dedupe linkonceodr
@@ -135,19 +128,6 @@ static cl::opt<bool> OutlinerLeafDescendants(
              "tree as candidates for outlining (if false, only leaf children "
              "are considered)"));
 
-static cl::opt<bool>
-    DisableGlobalOutlining("disable-global-outlining", cl::Hidden,
-                           cl::desc("Disable global outlining only by ignoring "
-                                    "the codegen data generation or use"),
-                           cl::init(false));
-
-static cl::opt<bool> AppendContentHashToOutlinedName(
-    "append-content-hash-outlined-name", cl::Hidden,
-    cl::desc("This appends the content hash to the globally outlined function "
-             "name. It's beneficial for enhancing the precision of the stable "
-             "hash and for ordering the outlined functions."),
-    cl::init(true));
-
 namespace {
 
 /// Maps \p MachineInstrs to unsigned integers and stores the mappings.
@@ -441,29 +421,11 @@ struct MachineOutliner : public ModulePass {
   /// Set when the pass is constructed in TargetPassConfig.
   bool RunOnAllFunctions = true;
 
-  /// This is a compact representation of hash sequences of outlined functions.
-  /// It is used when OutlinerMode = CGDataMode::Write.
-  /// The resulting hash tree will be emitted into __llvm_outlined section
-  /// which will be dead-stripped not going to the final binary.
-  /// A post-process using llvm-cgdata, lld, or ThinLTO can merge them into
-  /// a global oulined hash tree for the subsequent codegen.
-  std::unique_ptr<OutlinedHashTree> LocalHashTree;
-
-  /// The mode of the outliner.
-  /// When is's CGDataMode::None, candidates are populated with the suffix tree
-  /// within a module and outlined.
-  /// When it's CGDataMode::Write, in addition to CGDataMode::None, the hash
-  /// sequences of outlined functions are published into LocalHashTree.
-  /// When it's CGDataMode::Read, candidates are populated with the global
-  /// outlined hash tree that has been built by the previous codegen.
-  CGDataMode OutlinerMode = CGDataMode::None;
-
   StringRef getPassName() const override { return "Machine Outliner"; }
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.addRequired<MachineModuleInfoWrapperPass>();
     AU.addPreserved<MachineModuleInfoWrapperPass>();
-    AU.addRequired<ImmutableModuleSummaryIndexWrapperPass>();
     AU.setPreservesAll();
     ModulePass::getAnalysisUsage(AU);
   }
@@ -498,16 +460,6 @@ struct MachineOutliner : public ModulePass {
   findCandidates(InstructionMapper &Mapper,
                  std::vector<std::unique_ptr<OutlinedFunction>> &FunctionList);
 
-  /// Find all repeated substrings that match in the global outlined hash
-  /// tree built from the previous codegen.
-  ///
-  /// \param Mapper Contains outlining mapping information.
-  /// \param[out] FunctionList Filled with a list of \p OutlinedFunctions
-  /// each type of candidate.
-  void findGlobalCandidates(
-      InstructionMapper &Mapper,
-      std::vector<std::unique_ptr<OutlinedFunction>> &FunctionList);
-
   /// Replace the sequences of instructions represented by \p OutlinedFunctions
   /// with calls to functions.
   ///
@@ -524,17 +476,6 @@ struct MachineOutliner : public ModulePass {
                                           InstructionMapper &Mapper,
                                           unsigned Name);
 
-  /// Compute and publish the stable hash sequence of instructions in the
-  /// outlined function, \p MF. The parameter \p CandSize represents the number
-  /// of candidates that have identical instruction sequences to \p MF.
-  void computeAndPublishHashSequence(MachineFunction &MF, unsigned CandSize);
-
-  /// Initialize the outliner mode.
-  void initializeOutlinerMode(const Module &M);
-
-  /// Emit the outlined hash tree into __llvm_outline section.
-  void emitOutlinedHashTree(Module &M);
-
   /// Calls 'doOutline()' 1 + OutlinerReruns times.
   bool runOnModule(Module &M) override;
 
@@ -644,104 +585,6 @@ void MachineOutliner::emitOutlinedFunctionRemark(OutlinedFunction &OF) {
   MORE.emit(R);
 }
 
-struct MatchedEntry {
-  unsigned StartIdx;
-  unsigned EndIdx;
-  unsigned Count;
-  MatchedEntry(unsigned StartIdx, unsigned EndIdx, unsigned Count)
-      : StartIdx(StartIdx), EndIdx(EndIdx), Count(Count) {}
-  MatchedEntry() = delete;
-};
-
-// Find all matches in the global outlined hash tree.
-// It's quadratic complexity in theory, but it's nearly linear in practice
-// since the length of outlined sequences are small within a block.
-static SmallVector<MatchedEntry> getMatchedEntries(InstructionMapper &Mapper) {
-  auto &InstrList = Mapper.InstrList;
-  auto &UnsignedVec = Mapper.UnsignedVec;
-
-  SmallVector<MatchedEntry> MatchedEntries;
-  auto Size = UnsignedVec.size();
-
-  // Get the global outlined hash tree built from the previous run.
-  assert(cgdata::hasOutlinedHashTree());
-  const auto *RootNode = cgdata::getOutlinedHashTree()->getRoot();
-
-  auto getValidInstr = [&](unsigned Index) -> const MachineInstr * {
-    if (UnsignedVec[Index] >= Mapper.LegalInstrNumber)
-      return nullptr;
-    return &(*InstrList[Index]);
-  };
-
-  auto getStableHashAndFollow =
-      [](const MachineInstr &MI, const HashNode *CurrNode) -> const HashNode * {
-    stable_hash StableHash = stableHashValue(MI);
-    if (!StableHash)
-      return nullptr;
-    auto It = CurrNode->Successors.find(StableHash);
-    return (It == CurrNode->Successors.end()) ? nullptr : It->second.get();
-  };
-
-  for (unsigned I = 0; I < Size; ++I) {
-    const MachineInstr *MI = getValidInstr(I);
-    if (!MI || MI->isDebugInstr())
-      continue;
-    const HashNode *CurrNode = getStableHashAndFollow(*MI, RootNode);
-    if (!CurrNode)
-      continue;
-
-    for (unsigned J = I + 1; J < Size; ++J) {
-      const MachineInstr *MJ = getValidInstr(J);
-      if (!MJ)
-        break;
-      // Skip debug instructions as we did for the outlined function.
-      if (MJ->isDebugInstr())
-        continue;
-      CurrNode = getStableHashAndFollow(*MJ, CurrNode);
-      if (!CurrNode)
-        break;
-      // Even with a match ending with a terminal, we continue finding
-      // matches to populate all candidates.
-      if (auto Count = CurrNode->Terminals)
-        MatchedEntries.emplace_back(I, J, *Count);
-    }
-  }
-
-  return MatchedEntries;
-}
-
-void MachineOutliner::findGlobalCandidates(
-    InstructionMapper &Mapper,
-    std::vector<std::unique_ptr<OutlinedFunction>> &FunctionList) {
-  FunctionList.clear();
-  auto &InstrList = Mapper.InstrList;
-  auto &MBBFlagsMap = Mapper.MBBFlagsMap;
-
-  std::vector<Candidate> CandidatesForRepeatedSeq;
-  for (auto &ME : getMatchedEntries(Mapper)) {
-    CandidatesForRepeatedSeq.clear();
-    MachineBasicBlock::iterator StartIt = InstrList[ME.StartIdx];
-    MachineBasicBlock::iterator EndIt = InstrList[ME.EndIdx];
-    auto Length = ME.EndIdx - ME.StartIdx + 1;
-    MachineBasicBlock *MBB = StartIt->getParent();
-    CandidatesForRepeatedSeq.emplace_back(ME.StartIdx, Length, StartIt, EndIt,
-                                          MBB, FunctionList.size(),
-                                          MBBFlagsMap[MBB]);
-    const TargetInstrInfo *TII =
-        MBB->getParent()->getSubtarget().getInstrInfo();
-    unsigned MinRepeats = 1;
-    std::optional<std::unique_ptr<OutlinedFunction>> OF =
-        TII->getOutliningCandidateInfo(*MMI, CandidatesForRepeatedSeq,
-                                       MinRepeats);
-    if (!OF.has_value() || OF.value()->Candidates.empty())
-      continue;
-    // We create a global candidate for each match.
-    assert(OF.value()->Candidates.size() == MinRepeats);
-    FunctionList.emplace_back(std::make_unique<GlobalOutlinedFunction>(
-        std::move(OF.value()), ME.Count));
-  }
-}
-
 void MachineOutliner::findCandidates(
     InstructionMapper &Mapper,
     std::vector<std::unique_ptr<OutlinedFunction>> &FunctionList) {
@@ -852,39 +695,6 @@ void MachineOutliner::findCandidates(
   }
 }
 
-void MachineOutliner::computeAndPublishHashSequence(MachineFunction &MF,
-                                                    unsigned CandSize) {
-  // Compute the hash sequence for the outlined function.
-  SmallVector<stable_hash> OutlinedHashSequence;
-  for (auto &MBB : MF) {
-    for (auto &NewMI : MBB) {
-      stable_hash Hash = stableHashValue(NewMI);
-      if (!Hash) {
-        OutlinedHashSequence.clear();
-        break;
-      }
-      OutlinedHashSequence.push_back(Hash);
-    }
-  }
-
-  // Append a unique name based on the non-empty hash sequence.
-  if (AppendContentHashToOutlinedName && !OutlinedHashSequence.empty()) {
-    auto CombinedHash = stable_hash_combine(OutlinedHashSequence);
-    auto NewName =
-        MF.getName().str() + ".content." + std::to_string(CombinedHash);
-    MF.getFunction().setName(NewName);
-  }
-
-  // Publish the non-empty hash sequence to the local hash tree.
-  if (OutlinerMode == CGDataMode::Write) {
-    StableHashAttempts++;
-    if (!OutlinedHashSequence.empty())
-      LocalHashTree->insert({OutlinedHashSequence, CandSize});
-    else
-      StableHashDropped++;
-  }
-}
-
 MachineFunction *MachineOutliner::createOutlinedFunction(
     Module &M, OutlinedFunction &OF, InstructionMapper &Mapper, unsigned Name) {
 
@@ -959,9 +769,6 @@ MachineFunction *MachineOutliner::createOutlinedFunction(
     }
   }
 
-  if (OutlinerMode != CGDataMode::None)
-    computeAndPublishHashSequence(MF, OF.Candidates.size());
-
   // Set normal properties for a late MachineFunction.
   MF.getProperties().reset(MachineFunctionProperties::Property::IsSSA);
   MF.getProperties().set(MachineFunctionProperties::Property::NoPHIs);
@@ -1326,65 +1133,12 @@ void MachineOutliner::emitInstrCountChangedRemark(
   }
 }
 
-void MachineOutliner::initializeOutlinerMode(const Module &M) {
-  if (DisableGlobalOutlining)
-    return;
-
-  if (auto *IndexWrapperPass =
-          getAnalysisIfAvailable<ImmutableModuleSummaryIndexWrapperPass>()) {
-    auto *TheIndex = IndexWrapperPass->getIndex();
-    // (Full)LTO module does not have functions added to the index.
-    // In this case, we run the outliner without using codegen data as usual.
-    if (TheIndex && !TheIndex->hasExportedFunctions(M))
-      return;
-  }
-
-  // When codegen data write is enabled, we want to write the local outlined
-  // hash tree to the custom section, `__llvm_outline`.
-  // When the outlined hash tree is available from the previous codegen data,
-  // we want to read it to optimistically create global outlining candidates.
-  if (cgdata::emitCGData()) {
-    OutlinerMode = CGDataMode::Write;
-    // Create a local outlined hash tree to be published.
-    LocalHashTree = std::make_unique<OutlinedHashTree>();
-    // We don't need to read the outlined hash tree from the previous codegen
-  } else if (cgdata::hasOutlinedHashTree())
-    OutlinerMode = CGDataMode::Read;
-}
-
-void MachineOutliner::emitOutlinedHashTree(Module &M) {
-  assert(LocalHashTree);
-  if (!LocalHashTree->empty()) {
-    LLVM_DEBUG({
-      dbgs() << "Emit outlined hash tree. Size: " << LocalHashTree->size()
-             << "\n";
-    });
-    SmallVector<char> Buf;
-    raw_svector_ostream OS(Buf);
-
-    OutlinedHashTreeRecord HTR(std::move(LocalHashTree));
-    HTR.serialize(OS);
-
-    llvm::StringRef Data(Buf.data(), Buf.size());
-    std::unique_ptr<MemoryBuffer> Buffer =
-        MemoryBuffer::getMemBuffer(Data, "in-memory outlined hash tree", false);
-
-    Triple TT(M.getTargetTriple());
-    embedBufferInModule(
-        M, *Buffer.get(),
-        getCodeGenDataSectionName(CG_outline, TT.getObjectFormat()));
-  }
-}
-
 bool MachineOutliner::runOnModule(Module &M) {
   // Check if there's anything in the module. If it's empty, then there's
   // nothing to outline.
   if (M.empty())
     return false;
 
-  // Initialize the outliner mode.
-  initializeOutlinerMode(M);
-
   MMI = &getAnalysis<MachineModuleInfoWrapperPass>().getMMI();
 
   // Number to append to the current outlined function.
@@ -1406,9 +1160,6 @@ bool MachineOutliner::runOnModule(Module &M) {
     }
   }
 
-  if (OutlinerMode == CGDataMode::Write)
-    emitOutlinedHashTree(M);
-
   return true;
 }
 
@@ -1437,10 +1188,7 @@ bool MachineOutliner::doOutline(Module &M, unsigned &OutlinedFunctionNum) {
   std::vector<std::unique_ptr<OutlinedFunction>> FunctionList;
 
   // Find all of the outlining candidates.
-  if (OutlinerMode == CGDataMode::Read)
-    findGlobalCandidates(Mapper, FunctionList);
-  else
-    findCandidates(Mapper, FunctionList);
+  findCandidates(Mapper, FunctionList);
 
   // If we've requested size remarks, then collect the MI counts of every
   // function before outlining, and the MI counts after outlining.
diff --git a/llvm/test/CodeGen/AArch64/O3-pipeline.ll b/llvm/test/CodeGen/AArch64/O3-pipeline.ll
index 80e08ee713710c..fb94c040ae341a 100644
--- a/llvm/test/CodeGen/AArch64/O3-pipeline.ll
+++ b/llvm/test/CodeGen/AArch64/O3-pipeline.ll
@@ -16,7 +16,6 @@
 ; CHECK-NEXT: Machine Branch Probability Analysis
 ; CHECK-NEXT: Default Regalloc Eviction Advisor
 ; CHECK-NEXT: Default Regalloc Priority Advisor
-; CHECK-NEXT: Module summary info
 ; CHECK-NEXT:   ModulePass Manager
 ; CHECK-NEXT:     Pre-ISel Intrinsic Lowering
 ; CHECK-NEXT:     FunctionPass Manager
diff --git a/llvm/test/CodeGen/AArch64/cgdata-global-hash.ll b/llvm/test/CodeGen/AArch64/cgdata-global-hash.ll
d...
[truncated]

[kuhar]

Just a drive-by comment: It would be nice to have changes to core llvm headers like this in a separate PR, so that reverting doesn't cause everyone to rebuild a large portion of the build tree.

[kyulee-com]

Sure. I will follow this up!

[kyulee-com]

Looks like I can make a forward fix with #108037 instead of this revert.