[llvm-branch-commits] [CodeGen] Port ExecutionDomainFix to NewPM (PR #238546)

via llvm-branch-commits llvm-branch-commits at lists.llvm.org
Tue Nov 3 14:00:30 PST 2026


llvmorg-github-actions[bot] wrote:


<!--LLVM PR SUMMARY COMMENT-->

@llvm/pr-subscribers-backend-arm

Author: Aiden Grossman (boomanaiden154)

<details>
<summary>Changes</summary>

Standard NewPM pass porting.


---

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


10 Files Affected:

- (modified) llvm/include/llvm/CodeGen/ExecutionDomainFix.h (+13-83) 
- (modified) llvm/include/llvm/CodeGen/Passes.h (+1-1) 
- (modified) llvm/include/llvm/InitializePasses.h (+1-1) 
- (modified) llvm/include/llvm/Passes/MachinePassRegistry.def (+1) 
- (modified) llvm/lib/CodeGen/ExecutionDomainFix.cpp (+144-27) 
- (modified) llvm/lib/Passes/PassBuilder.cpp (+1) 
- (modified) llvm/lib/Target/ARM/ARMTargetMachine.cpp (+1-1) 
- (modified) llvm/lib/Target/X86/X86CodeGenPassBuilder.cpp (+2-2) 
- (modified) llvm/lib/Target/X86/X86TargetMachine.cpp (+1-1) 
- (modified) llvm/test/CodeGen/X86/llc-pipeline-npm.ll (+2) 


``````````diff
diff --git a/llvm/include/llvm/CodeGen/ExecutionDomainFix.h b/llvm/include/llvm/CodeGen/ExecutionDomainFix.h
index b3aaa30da69d7c..632aae311a2ca0 100644
--- a/llvm/include/llvm/CodeGen/ExecutionDomainFix.h
+++ b/llvm/include/llvm/CodeGen/ExecutionDomainFix.h
@@ -24,9 +24,12 @@
 
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/CodeGen/LoopTraversal.h"
+#include "llvm/CodeGen/MachineFunctionAnalysisManager.h"
 #include "llvm/CodeGen/MachineFunctionPass.h"
 #include "llvm/CodeGen/ReachingDefAnalysis.h"
 #include "llvm/CodeGen/TargetRegisterInfo.h"
+#include "llvm/IR/Analysis.h"
+#include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
@@ -113,31 +116,11 @@ struct DomainValue {
   }
 };
 
-class LLVM_ABI ExecutionDomainFix : public MachineFunctionPass {
-  SpecificBumpPtrAllocator<DomainValue> Allocator;
-  SmallVector<DomainValue *, 16> Avail;
-
-  const TargetRegisterClass *RC;
-  MachineFunction *MF = nullptr;
-  const TargetInstrInfo *TII = nullptr;
-  const TargetRegisterInfo *TRI = nullptr;
-  std::vector<SmallVector<int, 1>> AliasMap;
-  /// Value currently in each register, or NULL when no value is being tracked.
-  /// This counts as a DomainValue reference.
-  using LiveRegsDVInfo = std::vector<DomainValue *>;
-  LiveRegsDVInfo LiveRegs;
-  /// Keeps domain information for all registers. Note that this
-  /// is different from the usual definition notion of liveness. The CPU
-  /// doesn't care whether or not we consider a register killed.
-  using OutRegsInfoMap = SmallVector<LiveRegsDVInfo, 4>;
-  OutRegsInfoMap MBBOutRegsInfos;
-
-  ReachingDefInfo *RDI = nullptr;
-
+class LLVM_ABI ExecutionDomainFixLegacy : public MachineFunctionPass {
 public:
   static char ID; // Pass identification, replacement for typeid
 
-  ExecutionDomainFix() : MachineFunctionPass(ID) {}
+  ExecutionDomainFixLegacy() : MachineFunctionPass(ID) {}
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.setPreservesAll();
@@ -152,69 +135,16 @@ class LLVM_ABI ExecutionDomainFix : public MachineFunctionPass {
   }
 
   StringRef getPassName() const override { return "Execution Domain Fix"; }
+};
 
-private:
-  /// Translate TRI register number to a list of indices into our smaller tables
-  /// of interesting registers.
-  iterator_range<SmallVectorImpl<int>::const_iterator>
-  regIndices(MCRegister Reg) const;
-
-  /// DomainValue allocation.
-  DomainValue *alloc(int domain = -1);
-
-  /// Add reference to DV.
-  DomainValue *retain(DomainValue *DV) {
-    if (DV)
-      ++DV->Refs;
-    return DV;
+class ExecutionDomainFixPass
+    : public OptionalPassInfoMixin<ExecutionDomainFixPass> {
+public:
+  PreservedAnalyses run(MachineFunction &MF,
+                        MachineFunctionAnalysisManager &MFAM);
+  MachineFunctionProperties getRequiredProperties() const {
+    return MachineFunctionProperties().setNoVRegs();
   }
-
-  /// Release a reference to DV.  When the last reference is released,
-  /// collapse if needed.
-  void release(DomainValue *);
-
-  /// Follow the chain of dead DomainValues until a live DomainValue is reached.
-  /// Update the referenced pointer when necessary.
-  DomainValue *resolve(DomainValue *&);
-
-  /// Set LiveRegs[rx] = dv, updating reference counts.
-  void setLiveReg(int rx, DomainValue *DV);
-
-  /// Kill register rx, recycle or collapse any DomainValue.
-  void kill(int rx);
-
-  /// Force register rx into domain.
-  void force(int rx, unsigned domain);
-
-  /// Collapse open DomainValue into given domain. If there are multiple
-  /// registers using dv, they each get a unique collapsed DomainValue.
-  void collapse(DomainValue *dv, unsigned domain);
-
-  /// All instructions and registers in B are moved to A, and B is released.
-  bool merge(DomainValue *A, DomainValue *B);
-
-  /// Set up LiveRegs by merging predecessor live-out values.
-  void enterBasicBlock(const LoopTraversal::TraversedMBBInfo &TraversedMBB);
-
-  /// Update live-out values.
-  void leaveBasicBlock(const LoopTraversal::TraversedMBBInfo &TraversedMBB);
-
-  /// Process he given basic block.
-  void processBasicBlock(const LoopTraversal::TraversedMBBInfo &TraversedMBB);
-
-  /// Visit given insturcion.
-  bool visitInstr(MachineInstr *);
-
-  /// Update def-ages for registers defined by MI.
-  /// If Kill is set, also kill off DomainValues clobbered by the defs.
-  void processDefs(MachineInstr *, bool Kill);
-
-  /// A soft instruction can be changed to work in other domains given by mask.
-  void visitSoftInstr(MachineInstr *, unsigned mask);
-
-  /// A hard instruction only works in one domain. All input registers will be
-  /// forced into that domain.
-  void visitHardInstr(MachineInstr *, unsigned domain);
 };
 
 } // namespace llvm
diff --git a/llvm/include/llvm/CodeGen/Passes.h b/llvm/include/llvm/CodeGen/Passes.h
index 552a06fe9195fb..2da0a0f51f1202 100644
--- a/llvm/include/llvm/CodeGen/Passes.h
+++ b/llvm/include/llvm/CodeGen/Passes.h
@@ -545,7 +545,7 @@ LLVM_ABI FunctionPass *createExpandIRInstsPass(CodeGenOptLevel);
 LLVM_ABI FunctionPass *createBreakFalseDepsLegacyPass();
 
 /// Minimizes execution domain crossings for specific register classes.
-LLVM_ABI FunctionPass *createExecutionDomainFixPass();
+LLVM_ABI FunctionPass *createExecutionDomainFixLegacyPass();
 
 // This pass expands indirectbr instructions.
 LLVM_ABI FunctionPass *createIndirectBrExpandPass(CodeGenOptLevel OptLevel);
diff --git a/llvm/include/llvm/InitializePasses.h b/llvm/include/llvm/InitializePasses.h
index c3da6341c3f2de..6d17d6a0d6ccc3 100644
--- a/llvm/include/llvm/InitializePasses.h
+++ b/llvm/include/llvm/InitializePasses.h
@@ -110,7 +110,7 @@ LLVM_ABI void initializeEarlyMachineLICMPass(PassRegistry &);
 LLVM_ABI void initializeEarlyTailDuplicateLegacyPass(PassRegistry &);
 LLVM_ABI void initializeEdgeBundlesWrapperLegacyPass(PassRegistry &);
 LLVM_ABI void initializeEHContGuardTargetsLegacyPass(PassRegistry &);
-LLVM_ABI void initializeExecutionDomainFixPass(PassRegistry &);
+LLVM_ABI void initializeExecutionDomainFixLegacyPass(PassRegistry &);
 LLVM_ABI void initializeExpandIRInstsLegacyPassPass(PassRegistry &);
 LLVM_ABI void initializeExpandPostRALegacyPass(PassRegistry &);
 LLVM_ABI void initializeExpandReductionsPass(PassRegistry &);
diff --git a/llvm/include/llvm/Passes/MachinePassRegistry.def b/llvm/include/llvm/Passes/MachinePassRegistry.def
index fe88aebb85d604..7a31b3a6e45f37 100644
--- a/llvm/include/llvm/Passes/MachinePassRegistry.def
+++ b/llvm/include/llvm/Passes/MachinePassRegistry.def
@@ -72,6 +72,7 @@ MACHINE_FUNCTION_PASS("early-ifcvt", EarlyIfConverterPass())
 MACHINE_FUNCTION_PASS("early-machinelicm", EarlyMachineLICMPass())
 MACHINE_FUNCTION_PASS("early-tailduplication", EarlyTailDuplicatePass())
 MACHINE_FUNCTION_PASS("eh-cont-guard-targets", EHContGuardTargetsPass())
+MACHINE_FUNCTION_PASS("execution-domain-fix", ExecutionDomainFixPass())
 MACHINE_FUNCTION_PASS("fentry-insert", FEntryInserterPass())
 MACHINE_FUNCTION_PASS("finalize-isel", FinalizeISelPass())
 MACHINE_FUNCTION_PASS("finalizebundle-test", FinalizeBundleTestPass())
diff --git a/llvm/lib/CodeGen/ExecutionDomainFix.cpp b/llvm/lib/CodeGen/ExecutionDomainFix.cpp
index 62e3ac1b199f33..836dcccc41ca48 100644
--- a/llvm/lib/CodeGen/ExecutionDomainFix.cpp
+++ b/llvm/lib/CodeGen/ExecutionDomainFix.cpp
@@ -7,23 +7,120 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/CodeGen/ExecutionDomainFix.h"
+#include "llvm/CodeGen/MachineFunctionAnalysisManager.h"
+#include "llvm/CodeGen/MachinePassManager.h"
 #include "llvm/CodeGen/MachineRegisterInfo.h"
 #include "llvm/CodeGen/Passes.h"
+#include "llvm/CodeGen/ReachingDefAnalysis.h"
 #include "llvm/CodeGen/TargetInstrInfo.h"
+#include "llvm/IR/Analysis.h"
 #include "llvm/Support/Debug.h"
 
 using namespace llvm;
 
 #define DEBUG_TYPE "execution-deps-fix"
 
+namespace {
+
+class ExecutionDomainFixImpl {
+  SpecificBumpPtrAllocator<DomainValue> Allocator;
+  SmallVector<DomainValue *, 16> Avail;
+
+  const TargetRegisterClass *RC;
+  MachineFunction *MF = nullptr;
+  const TargetInstrInfo *TII = nullptr;
+  const TargetRegisterInfo *TRI = nullptr;
+  std::vector<SmallVector<int, 1>> AliasMap;
+  /// Value currently in each register, or NULL when no value is being tracked.
+  /// This counts as a DomainValue reference.
+  using LiveRegsDVInfo = std::vector<DomainValue *>;
+  LiveRegsDVInfo LiveRegs;
+  /// Keeps domain information for all registers. Note that this
+  /// is different from the usual definition notion of liveness. The CPU
+  /// doesn't care whether or not we consider a register killed.
+  using OutRegsInfoMap = SmallVector<LiveRegsDVInfo, 4>;
+  OutRegsInfoMap MBBOutRegsInfos;
+
+  ReachingDefInfo *RDI = nullptr;
+
+public:
+  bool runOnMachineFunction(MachineFunction &MF,
+                            function_ref<ReachingDefInfo *()> GetRDI);
+
+private:
+  /// Translate TRI register number to a list of indices into our smaller tables
+  /// of interesting registers.
+  iterator_range<SmallVectorImpl<int>::const_iterator>
+  regIndices(MCRegister Reg) const;
+
+  /// DomainValue allocation.
+  DomainValue *alloc(int domain = -1);
+
+  /// Add reference to DV.
+  DomainValue *retain(DomainValue *DV) {
+    if (DV)
+      ++DV->Refs;
+    return DV;
+  }
+
+  /// Release a reference to DV.  When the last reference is released,
+  /// collapse if needed.
+  void release(DomainValue *);
+
+  /// Follow the chain of dead DomainValues until a live DomainValue is reached.
+  /// Update the referenced pointer when necessary.
+  DomainValue *resolve(DomainValue *&);
+
+  /// Set LiveRegs[rx] = dv, updating reference counts.
+  void setLiveReg(int rx, DomainValue *DV);
+
+  /// Kill register rx, recycle or collapse any DomainValue.
+  void kill(int rx);
+
+  /// Force register rx into domain.
+  void force(int rx, unsigned domain);
+
+  /// Collapse open DomainValue into given domain. If there are multiple
+  /// registers using dv, they each get a unique collapsed DomainValue.
+  void collapse(DomainValue *dv, unsigned domain);
+
+  /// All instructions and registers in B are moved to A, and B is released.
+  bool merge(DomainValue *A, DomainValue *B);
+
+  /// Set up LiveRegs by merging predecessor live-out values.
+  void enterBasicBlock(const LoopTraversal::TraversedMBBInfo &TraversedMBB);
+
+  /// Update live-out values.
+  void leaveBasicBlock(const LoopTraversal::TraversedMBBInfo &TraversedMBB);
+
+  /// Process he given basic block.
+  void processBasicBlock(const LoopTraversal::TraversedMBBInfo &TraversedMBB);
+
+  /// Visit given insturcion.
+  bool visitInstr(MachineInstr *);
+
+  /// Update def-ages for registers defined by MI.
+  /// If Kill is set, also kill off DomainValues clobbered by the defs.
+  void processDefs(MachineInstr *, bool Kill);
+
+  /// A soft instruction can be changed to work in other domains given by mask.
+  void visitSoftInstr(MachineInstr *, unsigned mask);
+
+  /// A hard instruction only works in one domain. All input registers will be
+  /// forced into that domain.
+  void visitHardInstr(MachineInstr *, unsigned domain);
+};
+
+} // namespace
+
 iterator_range<SmallVectorImpl<int>::const_iterator>
-ExecutionDomainFix::regIndices(MCRegister Reg) const {
+ExecutionDomainFixImpl::regIndices(MCRegister Reg) const {
   assert(Reg < AliasMap.size() && "Invalid register");
   const auto &Entry = AliasMap[Reg.id()];
   return make_range(Entry.begin(), Entry.end());
 }
 
-DomainValue *ExecutionDomainFix::alloc(int domain) {
+DomainValue *ExecutionDomainFixImpl::alloc(int domain) {
   DomainValue *dv = Avail.empty() ? new (Allocator.Allocate()) DomainValue
                                   : Avail.pop_back_val();
   if (domain >= 0)
@@ -33,7 +130,7 @@ DomainValue *ExecutionDomainFix::alloc(int domain) {
   return dv;
 }
 
-void ExecutionDomainFix::release(DomainValue *DV) {
+void ExecutionDomainFixImpl::release(DomainValue *DV) {
   while (DV) {
     assert(DV->Refs && "Bad DomainValue");
     if (--DV->Refs)
@@ -51,7 +148,7 @@ void ExecutionDomainFix::release(DomainValue *DV) {
   }
 }
 
-DomainValue *ExecutionDomainFix::resolve(DomainValue *&DVRef) {
+DomainValue *ExecutionDomainFixImpl::resolve(DomainValue *&DVRef) {
   DomainValue *DV = DVRef;
   if (!DV || !DV->Next)
     return DV;
@@ -68,7 +165,7 @@ DomainValue *ExecutionDomainFix::resolve(DomainValue *&DVRef) {
   return DV;
 }
 
-void ExecutionDomainFix::setLiveReg(int rx, DomainValue *dv) {
+void ExecutionDomainFixImpl::setLiveReg(int rx, DomainValue *dv) {
   assert(unsigned(rx) < RC->getNumRegs() && "Invalid index");
   assert(!LiveRegs.empty() && "Must enter basic block first.");
 
@@ -79,7 +176,7 @@ void ExecutionDomainFix::setLiveReg(int rx, DomainValue *dv) {
   LiveRegs[rx] = retain(dv);
 }
 
-void ExecutionDomainFix::kill(int rx) {
+void ExecutionDomainFixImpl::kill(int rx) {
   assert(unsigned(rx) < RC->getNumRegs() && "Invalid index");
   assert(!LiveRegs.empty() && "Must enter basic block first.");
   if (!LiveRegs[rx])
@@ -89,7 +186,7 @@ void ExecutionDomainFix::kill(int rx) {
   LiveRegs[rx] = nullptr;
 }
 
-void ExecutionDomainFix::force(int rx, unsigned domain) {
+void ExecutionDomainFixImpl::force(int rx, unsigned domain) {
   assert(unsigned(rx) < RC->getNumRegs() && "Invalid index");
   assert(!LiveRegs.empty() && "Must enter basic block first.");
   if (DomainValue *dv = LiveRegs[rx]) {
@@ -110,7 +207,7 @@ void ExecutionDomainFix::force(int rx, unsigned domain) {
   }
 }
 
-void ExecutionDomainFix::collapse(DomainValue *dv, unsigned domain) {
+void ExecutionDomainFixImpl::collapse(DomainValue *dv, unsigned domain) {
   assert(dv->hasDomain(domain) && "Cannot collapse");
 
   // Collapse all the instructions.
@@ -125,7 +222,7 @@ void ExecutionDomainFix::collapse(DomainValue *dv, unsigned domain) {
         setLiveReg(rx, alloc(domain));
 }
 
-bool ExecutionDomainFix::merge(DomainValue *A, DomainValue *B) {
+bool ExecutionDomainFixImpl::merge(DomainValue *A, DomainValue *B) {
   assert(!A->isCollapsed() && "Cannot merge into collapsed");
   assert(!B->isCollapsed() && "Cannot merge from collapsed");
   if (A == B)
@@ -150,7 +247,7 @@ bool ExecutionDomainFix::merge(DomainValue *A, DomainValue *B) {
   return true;
 }
 
-void ExecutionDomainFix::enterBasicBlock(
+void ExecutionDomainFixImpl::enterBasicBlock(
     const LoopTraversal::TraversedMBBInfo &TraversedMBB) {
 
   MachineBasicBlock *MBB = TraversedMBB.MBB;
@@ -206,7 +303,7 @@ void ExecutionDomainFix::enterBasicBlock(
                                              : ": all preds known\n"));
 }
 
-void ExecutionDomainFix::leaveBasicBlock(
+void ExecutionDomainFixImpl::leaveBasicBlock(
     const LoopTraversal::TraversedMBBInfo &TraversedMBB) {
   assert(!LiveRegs.empty() && "Must enter basic block first.");
   unsigned MBBNumber = TraversedMBB.MBB->getNumber();
@@ -220,7 +317,7 @@ void ExecutionDomainFix::leaveBasicBlock(
   LiveRegs.clear();
 }
 
-bool ExecutionDomainFix::visitInstr(MachineInstr *MI) {
+bool ExecutionDomainFixImpl::visitInstr(MachineInstr *MI) {
   // Update instructions with explicit execution domains.
   std::pair<uint16_t, uint16_t> DomP = TII->getExecutionDomain(*MI);
   if (DomP.first) {
@@ -233,7 +330,7 @@ bool ExecutionDomainFix::visitInstr(MachineInstr *MI) {
   return !DomP.first;
 }
 
-void ExecutionDomainFix::processDefs(MachineInstr *MI, bool Kill) {
+void ExecutionDomainFixImpl::processDefs(MachineInstr *MI, bool Kill) {
   assert(!MI->isDebugInstr() && "Won't process debug values");
   const MCInstrDesc &MCID = MI->getDesc();
   for (unsigned i = 0,
@@ -255,7 +352,7 @@ void ExecutionDomainFix::processDefs(MachineInstr *MI, bool Kill) {
   }
 }
 
-void ExecutionDomainFix::visitHardInstr(MachineInstr *mi, unsigned domain) {
+void ExecutionDomainFixImpl::visitHardInstr(MachineInstr *mi, unsigned domain) {
   // Collapse all uses.
   for (unsigned i = mi->getDesc().getNumDefs(),
                 e = mi->getDesc().getNumOperands();
@@ -280,7 +377,7 @@ void ExecutionDomainFix::visitHardInstr(MachineInstr *mi, unsigned domain) {
   }
 }
 
-void ExecutionDomainFix::visitSoftInstr(MachineInstr *mi, unsigned mask) {
+void ExecutionDomainFixImpl::visitSoftInstr(MachineInstr *mi, unsigned mask) {
   // Bitmask of available domains for this instruction after taking collapsed
   // operands into account.
   unsigned available = mask;
@@ -393,7 +490,7 @@ void ExecutionDomainFix::visitSoftInstr(MachineInstr *mi, unsigned mask) {
   }
 }
 
-void ExecutionDomainFix::processBasicBlock(
+void ExecutionDomainFixImpl::processBasicBlock(
     const LoopTraversal::TraversedMBBInfo &TraversedMBB) {
   enterBasicBlock(TraversedMBB);
   // If this block is not done, it makes little sense to make any decisions
@@ -411,9 +508,8 @@ void ExecutionDomainFix::processBasicBlock(
   leaveBasicBlock(TraversedMBB);
 }
 
-bool ExecutionDomainFix::runOnMachineFunction(MachineFunction &mf) {
-  if (skipFunction(mf.getFunction()))
-    return false;
+bool ExecutionDomainFixImpl::runOnMachineFunction(
+    MachineFunction &mf, function_ref<ReachingDefInfo *()> GetRDI) {
   MF = &mf;
   TII = MF->getSubtarget().getInstrInfo();
   TRI = MF->getSubtarget().getRegisterInfo();
@@ -439,7 +535,7 @@ bool ExecutionDomainFix::runOnMachineFunction(MachineFunction &mf) {
   if (!anyregs)
     return false;
 
-  RDI = &getAnalysis<ReachingDefInfoWrapperPass>().getRDI();
+  RDI = GetRDI();
 
   // Initialize the AliasMap on the first use.
   if (AliasMap.empty()) {
@@ -473,13 +569,34 @@ bool ExecutionDomainFix::runOnMachineFunction(MachineFunction &mf) {
   return false;
 }
 
-char ExecutionDomainFix::ID = 0;
-INITIALIZE_PASS_BEGIN(ExecutionDomainFix, DEBUG_TYPE, "execution-domain-fix",
-                      false, false)
+char ExecutionDomainFixLegacy::ID = 0;
+INITIALIZE_PASS_BEGIN(ExecutionDomainFixLegacy, DEBUG_TYPE,
+                      "execution-domain-fix", false, false)
 INITIALIZE_PASS_DEPENDENCY(ReachingDefInfoWrapperPass)
-INITIALIZE_PASS_END(ExecutionDomainFix, DEBUG_TYPE, "execution-domain-fix",
-                    false, false)
+INITIALIZE_PASS_END(ExecutionDomainFixLegacy, DEBUG_TYPE,
+                    "execution-domain-fix", false, false)
+
+FunctionPass *llvm::createExecutionDomainFixLegacyPass() {
+  return new ExecutionDomainFixLegacy();
+}
+
+bool ExecutionDomainFixLegacy::runOnMachineFunction(MachineFunction &MF) {
+  if (skipFunction(MF.getFunction()))
+    return false;
+  ExecutionDomainFixImpl Impl;
+  return Impl.runOnMachineFunction(MF, [&]() {
+    return &getAnalysis<ReachingDefInfoWrapperPass>().getRDI();
+  });
+}
 
-FunctionPass *llvm::createExecutionDomainFixPass() {
-  return new ExecutionDomainFix();
+PreservedAnalyses
+ExecutionDomainFixPass::run(MachineFunction &MF,
+                            MachineFunctionAnalysisManager &MFAM) {
+  MFPropsModifier _(*this, MF);
+  ExecutionDomainFixImpl Impl;
+  bool Changed = Impl.runOnMachineFunction(
+      MF, [&]() { return &MFAM.getResult<ReachingDefAnalysis>(MF); });
+  if (!Changed)
+    return PreservedAnalyses::all();
+  return getMachineFunctionPassPreservedAnalyses().preserveSet<CFGAnalyses>();
 }
diff --git a/llvm/lib/Passes/PassBuilder.cpp b/llvm/lib/Passes/PassBuilder.cpp
index 8db9e561c825e4..7daabf9b38cd28 100644
--- a/llvm/lib/Passes/PassBuilder.cpp
+++ b/llvm/lib/Passes/PassBuilder.cpp
@@ -99,6 +99,7 @@
 #include "llvm/CodeGen/EHContGuardTargets.h"
 #include "llvm/CodeGen/EarlyIfConversion.h"
 #include "llvm/CodeGen/EdgeBundles.h"
+#include "llvm/CodeGen/ExecutionDomainFix.h"
 #include "llvm/CodeGen/ExpandIRInsts.h"
 #include "llvm/CodeGen/ExpandPostRAPseudos.h"
 #include "llvm/CodeGen/ExpandReductions.h"
diff --git a/llvm/lib/Target/ARM/ARMTargetMachine.cpp b/llvm/lib/Target/ARM/ARMTargetMachine.cpp
index 7c71a616ffc14d..ba46077f01e37e 100644
--- a/llvm/lib/Target/ARM/ARMTargetMachine.cpp
+++ b/llvm/lib/Target/ARM/ARMTargetMachine.cpp
@@ -492,7 +492,7 @@ void ARMPassConfig::addPreSched2() {
     if (EnableARMLoadStoreOpt)
       addPass(createARMLoadStoreOptLegacyPass());
 
-    addPass(createExecutionDomainFixPass());
+    addPass(createExecutionDomainFixLegacyPass());
     addPass(createBreakFalseDepsLegacyPass());
   }
 
diff --git a/llvm/lib/Target/X86/X86CodeGenPassBuilder.cpp b/llvm/lib/Target/X86/X86CodeGenPassBuilder.cpp
index f4c97fa50fe71c..a87f85e45acb78 100644
--- a/llvm/lib/Target/X86/X86CodeGenPassBuilder.cpp
+++ b/llvm/lib/Target/X86/X86CodeGenPassBuilder.c...
[truncated]

``````````

</details>


https://github.com/llvm/llvm-project/pull/238546


More information about the llvm-branch-commits mailing list