[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