[llvm] [NewPM] Port ImplicitNullChecks to the new pass manager (PR #216965)
Bill Wendling via llvm-commits
llvm-commits at lists.llvm.org
Tue Aug 18 12:49:01 PDT 2026
https://github.com/bwendling updated https://github.com/llvm/llvm-project/pull/216965
>From aeee8b8b1b03e414be604c93859c9cd42dd5f525 Mon Sep 17 00:00:00 2001
From: Bill Wendling <morbo at google.com>
Date: Tue, 18 Aug 2026 06:59:14 +0000
Subject: [PATCH 1/3] [NewPM] Port ImplicitNullChecks to the new pass manager
Adds a newPM pass for ImplicitNullChecks.
- Refactors base logic into an ImplicitNullChecks class
- Renames old pass with the "Legacy" suffix
- Adds the new pass manager pass ImplicitNullChecksPass
- Updates MachinePassRegistry.def, PassBuilder, and CodeGenPassBuilder
- Updated existing .mir tests to also test with the New Pass Manager
TAG=agy
CONV=f54ff826-1008-4e8c-9be5-0364adbe3923
---
.../include/llvm/CodeGen/ImplicitNullChecks.h | 28 +++++++++++
llvm/include/llvm/InitializePasses.h | 2 +-
llvm/include/llvm/Passes/CodeGenPassBuilder.h | 1 +
.../llvm/Passes/MachinePassRegistry.def | 2 +-
llvm/lib/CodeGen/CodeGen.cpp | 2 +-
llvm/lib/CodeGen/ImplicitNullChecks.cpp | 49 ++++++++++++++-----
llvm/lib/Passes/PassBuilder.cpp | 1 +
.../test/CodeGen/X86/implicit-null-checks.mir | 1 +
.../X86/implicit-null-chk-reg-rewrite.mir | 1 +
9 files changed, 72 insertions(+), 15 deletions(-)
create mode 100644 llvm/include/llvm/CodeGen/ImplicitNullChecks.h
diff --git a/llvm/include/llvm/CodeGen/ImplicitNullChecks.h b/llvm/include/llvm/CodeGen/ImplicitNullChecks.h
new file mode 100644
index 0000000000000..6325e26abbf0d
--- /dev/null
+++ b/llvm/include/llvm/CodeGen/ImplicitNullChecks.h
@@ -0,0 +1,28 @@
+//===- llvm/CodeGen/ImplicitNullChecks.h ------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CODEGEN_IMPLICITNULLCHECKS_H
+#define LLVM_CODEGEN_IMPLICITNULLCHECKS_H
+
+#include "llvm/CodeGen/MachinePassManager.h"
+
+namespace llvm {
+
+class ImplicitNullChecksPass : public PassInfoMixin<ImplicitNullChecksPass> {
+public:
+ LLVM_ABI PreservedAnalyses run(MachineFunction &MF,
+ MachineFunctionAnalysisManager &MFAM);
+
+ MachineFunctionProperties getRequiredProperties() const {
+ return MachineFunctionProperties().setNoVRegs();
+ }
+};
+
+} // namespace llvm
+
+#endif // LLVM_CODEGEN_IMPLICITNULLCHECKS_H
diff --git a/llvm/include/llvm/InitializePasses.h b/llvm/include/llvm/InitializePasses.h
index 74fe01a46b5b9..c0a45c36c12da 100644
--- a/llvm/include/llvm/InitializePasses.h
+++ b/llvm/include/llvm/InitializePasses.h
@@ -139,7 +139,7 @@ LLVM_ABI void initializeIVUsersWrapperPassPass(PassRegistry &);
LLVM_ABI void initializeIfConverterPass(PassRegistry &);
LLVM_ABI void
initializeImmutableModuleSummaryIndexWrapperPassPass(PassRegistry &);
-LLVM_ABI void initializeImplicitNullChecksPass(PassRegistry &);
+LLVM_ABI void initializeImplicitNullChecksLegacyPass(PassRegistry &);
LLVM_ABI void initializeIndirectBrExpandLegacyPassPass(PassRegistry &);
LLVM_ABI void initializeInferAddressSpacesPass(PassRegistry &);
LLVM_ABI void initializeInlineAsmPreparePass(PassRegistry &);
diff --git a/llvm/include/llvm/Passes/CodeGenPassBuilder.h b/llvm/include/llvm/Passes/CodeGenPassBuilder.h
index 11e448dd7f78b..ee10aed4eec86 100644
--- a/llvm/include/llvm/Passes/CodeGenPassBuilder.h
+++ b/llvm/include/llvm/Passes/CodeGenPassBuilder.h
@@ -40,6 +40,7 @@
#include "llvm/CodeGen/GCMetadata.h"
#include "llvm/CodeGen/GlobalMerge.h"
#include "llvm/CodeGen/GlobalMergeFunctions.h"
+#include "llvm/CodeGen/ImplicitNullChecks.h"
#include "llvm/CodeGen/IndirectBrExpand.h"
#include "llvm/CodeGen/InitUndef.h"
#include "llvm/CodeGen/InlineAsmPrepare.h"
diff --git a/llvm/include/llvm/Passes/MachinePassRegistry.def b/llvm/include/llvm/Passes/MachinePassRegistry.def
index c38507bf70254..afcf6cb6894e3 100644
--- a/llvm/include/llvm/Passes/MachinePassRegistry.def
+++ b/llvm/include/llvm/Passes/MachinePassRegistry.def
@@ -80,6 +80,7 @@ MACHINE_FUNCTION_PASS("finalize-isel", FinalizeISelPass())
MACHINE_FUNCTION_PASS("finalizebundle-test", FinalizeBundleTestPass())
MACHINE_FUNCTION_PASS("fixup-statepoint-caller-saved", FixupStatepointCallerSavedPass())
MACHINE_FUNCTION_PASS("init-undef", InitUndefPass())
+MACHINE_FUNCTION_PASS("implicit-null-checks", ImplicitNullChecksPass())
MACHINE_FUNCTION_PASS("kcfi", MachineKCFIPass())
MACHINE_FUNCTION_PASS("gc-empty-basic-blocks", GCEmptyBasicBlocksPass())
MACHINE_FUNCTION_PASS("localstackalloc", LocalStackSlotAllocationPass())
@@ -240,7 +241,6 @@ DUMMY_MACHINE_FUNCTION_PASS("cfi-instr-inserter", CFIInstrInserterPass)
DUMMY_MACHINE_FUNCTION_PASS("eh-cont-guard-targets", EHContGuardTargetsPass)
DUMMY_MACHINE_FUNCTION_PASS("fs-profile-loader", MIRProfileLoaderNewPass)
DUMMY_MACHINE_FUNCTION_PASS("funclet-layout", FuncletLayoutPass)
-DUMMY_MACHINE_FUNCTION_PASS("implicit-null-checks", ImplicitNullChecksPass)
DUMMY_MACHINE_FUNCTION_PASS("instruction-select", InstructionSelectPass)
DUMMY_MACHINE_FUNCTION_PASS("irtranslator", IRTranslatorPass)
DUMMY_MACHINE_FUNCTION_PASS("legalizer", LegalizerPass)
diff --git a/llvm/lib/CodeGen/CodeGen.cpp b/llvm/lib/CodeGen/CodeGen.cpp
index e0ed5731144b3..1c2f17996ad58 100644
--- a/llvm/lib/CodeGen/CodeGen.cpp
+++ b/llvm/lib/CodeGen/CodeGen.cpp
@@ -57,7 +57,7 @@ void llvm::initializeCodeGen(PassRegistry &Registry) {
initializeGlobalMergeFuncPassWrapperPass(Registry);
initializeHardwareLoopsLegacyPass(Registry);
initializeIfConverterPass(Registry);
- initializeImplicitNullChecksPass(Registry);
+ initializeImplicitNullChecksLegacyPass(Registry);
initializeIndirectBrExpandLegacyPassPass(Registry);
initializeInsertCodePrefetchPass(Registry);
initializeInitUndefLegacyPass(Registry);
diff --git a/llvm/lib/CodeGen/ImplicitNullChecks.cpp b/llvm/lib/CodeGen/ImplicitNullChecks.cpp
index d06116a112c57..4245532dc9c05 100644
--- a/llvm/lib/CodeGen/ImplicitNullChecks.cpp
+++ b/llvm/lib/CodeGen/ImplicitNullChecks.cpp
@@ -25,6 +25,7 @@
//
//===----------------------------------------------------------------------===//
+#include "llvm/CodeGen/ImplicitNullChecks.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SmallVector.h"
@@ -76,7 +77,7 @@ STATISTIC(NumImplicitNullChecks,
namespace {
-class ImplicitNullChecks : public MachineFunctionPass {
+class ImplicitNullChecks {
/// Return true if \c computeDependence can process \p MI.
static bool canHandle(const MachineInstr *MI);
@@ -211,12 +212,27 @@ class ImplicitNullChecks : public MachineFunctionPass {
ArrayRef<MachineInstr *> InstsSeenSoFar,
MachineBasicBlock *NullSucc, MachineInstr *&Dependence);
+public:
+ ImplicitNullChecks(MachineFunction &MF, AliasAnalysis *AA)
+ : TII(MF.getSubtarget().getInstrInfo()),
+ TRI(MF.getRegInfo().getTargetRegisterInfo()), AA(AA),
+ MFI(&MF.getFrameInfo()) {}
+
+ bool run(MachineFunction &MF);
+};
+
+class ImplicitNullChecksLegacy : public MachineFunctionPass {
public:
static char ID;
- ImplicitNullChecks() : MachineFunctionPass(ID) {}
+ ImplicitNullChecksLegacy() : MachineFunctionPass(ID) {}
- bool runOnMachineFunction(MachineFunction &MF) override;
+ bool runOnMachineFunction(MachineFunction &MF) override {
+ if (skipFunction(MF.getFunction()))
+ return false;
+ auto *AA = &getAnalysis<AAResultsWrapperPass>().getAAResults();
+ return ImplicitNullChecks(MF, AA).run(MF);
+ }
void getAnalysisUsage(AnalysisUsage &AU) const override {
AU.addRequired<AAResultsWrapperPass>();
@@ -295,11 +311,7 @@ bool ImplicitNullChecks::canReorder(const MachineInstr *A,
return true;
}
-bool ImplicitNullChecks::runOnMachineFunction(MachineFunction &MF) {
- TII = MF.getSubtarget().getInstrInfo();
- TRI = MF.getRegInfo().getTargetRegisterInfo();
- MFI = &MF.getFrameInfo();
- AA = &getAnalysis<AAResultsWrapperPass>().getAAResults();
+bool ImplicitNullChecks::run(MachineFunction &MF) {
SmallVector<NullCheck, 16> NullCheckList;
@@ -801,12 +813,25 @@ void ImplicitNullChecks::rewriteNullChecks(
}
}
-char ImplicitNullChecks::ID = 0;
+char ImplicitNullChecksLegacy::ID = 0;
-char &llvm::ImplicitNullChecksID = ImplicitNullChecks::ID;
+char &llvm::ImplicitNullChecksID = ImplicitNullChecksLegacy::ID;
-INITIALIZE_PASS_BEGIN(ImplicitNullChecks, DEBUG_TYPE,
+INITIALIZE_PASS_BEGIN(ImplicitNullChecksLegacy, DEBUG_TYPE,
"Implicit null checks", false, false)
INITIALIZE_PASS_DEPENDENCY(AAResultsWrapperPass)
-INITIALIZE_PASS_END(ImplicitNullChecks, DEBUG_TYPE,
+INITIALIZE_PASS_END(ImplicitNullChecksLegacy, DEBUG_TYPE,
"Implicit null checks", false, false)
+
+PreservedAnalyses
+ImplicitNullChecksPass::run(MachineFunction &MF,
+ MachineFunctionAnalysisManager &MFAM) {
+ MFPropsModifier _(*this, MF);
+ auto &FAM = MFAM.getResult<FunctionAnalysisManagerMachineFunctionProxy>(MF)
+ .getManager();
+ auto &AA = FAM.getResult<AAManager>(MF.getFunction());
+ bool Changed = ImplicitNullChecks(MF, &AA).run(MF);
+ if (!Changed)
+ return PreservedAnalyses::all();
+ return getMachineFunctionPassPreservedAnalyses();
+}
diff --git a/llvm/lib/Passes/PassBuilder.cpp b/llvm/lib/Passes/PassBuilder.cpp
index 6abaa77f9065f..7265699c8d494 100644
--- a/llvm/lib/Passes/PassBuilder.cpp
+++ b/llvm/lib/Passes/PassBuilder.cpp
@@ -107,6 +107,7 @@
#include "llvm/CodeGen/GlobalMerge.h"
#include "llvm/CodeGen/GlobalMergeFunctions.h"
#include "llvm/CodeGen/HardwareLoops.h"
+#include "llvm/CodeGen/ImplicitNullChecks.h"
#include "llvm/CodeGen/IndirectBrExpand.h"
#include "llvm/CodeGen/InitUndef.h"
#include "llvm/CodeGen/InlineAsmPrepare.h"
diff --git a/llvm/test/CodeGen/X86/implicit-null-checks.mir b/llvm/test/CodeGen/X86/implicit-null-checks.mir
index c98019c09a1e6..894343d6d04ef 100644
--- a/llvm/test/CodeGen/X86/implicit-null-checks.mir
+++ b/llvm/test/CodeGen/X86/implicit-null-checks.mir
@@ -1,4 +1,5 @@
# RUN: llc -run-pass implicit-null-checks -mtriple=x86_64-apple-macosx -o - %s | FileCheck %s
+# RUN: llc -passes=implicit-null-checks -mtriple=x86_64-apple-macosx -o - %s | FileCheck %s
--- |
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
diff --git a/llvm/test/CodeGen/X86/implicit-null-chk-reg-rewrite.mir b/llvm/test/CodeGen/X86/implicit-null-chk-reg-rewrite.mir
index 2dac678a49845..08049b78b0fdd 100644
--- a/llvm/test/CodeGen/X86/implicit-null-chk-reg-rewrite.mir
+++ b/llvm/test/CodeGen/X86/implicit-null-chk-reg-rewrite.mir
@@ -1,4 +1,5 @@
# RUN: llc -mtriple=x86_64 -run-pass=implicit-null-checks %s -o - | FileCheck %s
+# RUN: llc -mtriple=x86_64 -passes=implicit-null-checks %s -o - | FileCheck %s
--- |
define i32 @reg-rewrite(ptr %x, i1 %arg) {
>From 81aa409fdc8ffcb0741b8195c4781bd7c8a6002f Mon Sep 17 00:00:00 2001
From: Bill Wendling <morbo at google.com>
Date: Tue, 18 Aug 2026 12:41:36 -0700
Subject: [PATCH 2/3] Update ImplicitNullChecks.h
Fix header comment.
---
llvm/include/llvm/CodeGen/ImplicitNullChecks.h | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/llvm/include/llvm/CodeGen/ImplicitNullChecks.h b/llvm/include/llvm/CodeGen/ImplicitNullChecks.h
index 6325e26abbf0d..3069c203a0d95 100644
--- a/llvm/include/llvm/CodeGen/ImplicitNullChecks.h
+++ b/llvm/include/llvm/CodeGen/ImplicitNullChecks.h
@@ -1,4 +1,4 @@
-//===- llvm/CodeGen/ImplicitNullChecks.h ------------------------*- C++ -*-===//
+//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
>From 01c479c0751dc4b4e0166e83759df6ca02bba200 Mon Sep 17 00:00:00 2001
From: Bill Wendling <morbo at google.com>
Date: Tue, 18 Aug 2026 19:47:45 +0000
Subject: [PATCH 3/3] Append 'Impl' to passname.
---
llvm/lib/CodeGen/ImplicitNullChecks.cpp | 53 ++++++++++++-------------
1 file changed, 26 insertions(+), 27 deletions(-)
diff --git a/llvm/lib/CodeGen/ImplicitNullChecks.cpp b/llvm/lib/CodeGen/ImplicitNullChecks.cpp
index 4245532dc9c05..a1e256bcd7b17 100644
--- a/llvm/lib/CodeGen/ImplicitNullChecks.cpp
+++ b/llvm/lib/CodeGen/ImplicitNullChecks.cpp
@@ -77,7 +77,7 @@ STATISTIC(NumImplicitNullChecks,
namespace {
-class ImplicitNullChecks {
+class ImplicitNullChecksImpl {
/// Return true if \c computeDependence can process \p MI.
static bool canHandle(const MachineInstr *MI);
@@ -213,7 +213,7 @@ class ImplicitNullChecks {
MachineBasicBlock *NullSucc, MachineInstr *&Dependence);
public:
- ImplicitNullChecks(MachineFunction &MF, AliasAnalysis *AA)
+ ImplicitNullChecksImpl(MachineFunction &MF, AliasAnalysis *AA)
: TII(MF.getSubtarget().getInstrInfo()),
TRI(MF.getRegInfo().getTargetRegisterInfo()), AA(AA),
MFI(&MF.getFrameInfo()) {}
@@ -231,7 +231,7 @@ class ImplicitNullChecksLegacy : public MachineFunctionPass {
if (skipFunction(MF.getFunction()))
return false;
auto *AA = &getAnalysis<AAResultsWrapperPass>().getAAResults();
- return ImplicitNullChecks(MF, AA).run(MF);
+ return ImplicitNullChecksImpl(MF, AA).run(MF);
}
void getAnalysisUsage(AnalysisUsage &AU) const override {
@@ -246,7 +246,7 @@ class ImplicitNullChecksLegacy : public MachineFunctionPass {
} // end anonymous namespace
-bool ImplicitNullChecks::canHandle(const MachineInstr *MI) {
+bool ImplicitNullChecksImpl::canHandle(const MachineInstr *MI) {
if (MI->isCall() || MI->mayRaiseFPException() ||
MI->hasUnmodeledSideEffects())
return false;
@@ -260,9 +260,9 @@ bool ImplicitNullChecks::canHandle(const MachineInstr *MI) {
return llvm::all_of(MI->memoperands(), IsUnordered);
}
-ImplicitNullChecks::DependenceResult
-ImplicitNullChecks::computeDependence(const MachineInstr *MI,
- ArrayRef<MachineInstr *> Block) {
+ImplicitNullChecksImpl::DependenceResult
+ImplicitNullChecksImpl::computeDependence(const MachineInstr *MI,
+ ArrayRef<MachineInstr *> Block) {
assert(llvm::all_of(Block, canHandle) && "Check this first!");
assert(!is_contained(Block, MI) && "Block must be exclusive of MI!");
@@ -284,8 +284,8 @@ ImplicitNullChecks::computeDependence(const MachineInstr *MI,
return {true, Dep};
}
-bool ImplicitNullChecks::canReorder(const MachineInstr *A,
- const MachineInstr *B) {
+bool ImplicitNullChecksImpl::canReorder(const MachineInstr *A,
+ const MachineInstr *B) {
assert(canHandle(A) && canHandle(B) && "Precondition!");
// canHandle makes sure that we _can_ correctly analyze the dependencies
@@ -311,7 +311,7 @@ bool ImplicitNullChecks::canReorder(const MachineInstr *A,
return true;
}
-bool ImplicitNullChecks::run(MachineFunction &MF) {
+bool ImplicitNullChecksImpl::run(MachineFunction &MF) {
SmallVector<NullCheck, 16> NullCheckList;
@@ -334,9 +334,9 @@ static bool AnyAliasLiveIn(const TargetRegisterInfo *TRI,
return false;
}
-ImplicitNullChecks::AliasResult
-ImplicitNullChecks::areMemoryOpsAliased(const MachineInstr &MI,
- const MachineInstr *PrevMI) const {
+ImplicitNullChecksImpl::AliasResult
+ImplicitNullChecksImpl::areMemoryOpsAliased(const MachineInstr &MI,
+ const MachineInstr *PrevMI) const {
// If it is not memory access, skip the check.
if (!(PrevMI->mayStore() || PrevMI->mayLoad()))
return AR_NoAlias;
@@ -369,10 +369,10 @@ ImplicitNullChecks::areMemoryOpsAliased(const MachineInstr &MI,
return AR_NoAlias;
}
-ImplicitNullChecks::SuitabilityResult
-ImplicitNullChecks::isSuitableMemoryOp(const MachineInstr &MI,
- Register PointerReg,
- ArrayRef<MachineInstr *> PrevInsts) {
+ImplicitNullChecksImpl::SuitabilityResult
+ImplicitNullChecksImpl::isSuitableMemoryOp(const MachineInstr &MI,
+ Register PointerReg,
+ ArrayRef<MachineInstr *> PrevInsts) {
// Implementation restriction for faulting_op insertion
// TODO: This could be relaxed if we find a test case which warrants it.
if (MI.getDesc().getNumDefs() > 1)
@@ -485,7 +485,7 @@ ImplicitNullChecks::isSuitableMemoryOp(const MachineInstr &MI,
return SR_Suitable;
}
-bool ImplicitNullChecks::canDependenceHoistingClobberLiveIns(
+bool ImplicitNullChecksImpl::canDependenceHoistingClobberLiveIns(
MachineInstr *DependenceMI, MachineBasicBlock *NullSucc) {
for (const auto &DependenceMO : DependenceMI->operands()) {
if (!(DependenceMO.isReg() && DependenceMO.getReg()))
@@ -517,10 +517,9 @@ bool ImplicitNullChecks::canDependenceHoistingClobberLiveIns(
return false;
}
-bool ImplicitNullChecks::canHoistInst(MachineInstr *FaultingMI,
- ArrayRef<MachineInstr *> InstsSeenSoFar,
- MachineBasicBlock *NullSucc,
- MachineInstr *&Dependence) {
+bool ImplicitNullChecksImpl::canHoistInst(
+ MachineInstr *FaultingMI, ArrayRef<MachineInstr *> InstsSeenSoFar,
+ MachineBasicBlock *NullSucc, MachineInstr *&Dependence) {
auto DepResult = computeDependence(FaultingMI, InstsSeenSoFar);
if (!DepResult.CanReorder)
return false;
@@ -558,7 +557,7 @@ bool ImplicitNullChecks::canHoistInst(MachineInstr *FaultingMI,
/// Analyze MBB to check if its terminating branch can be turned into an
/// implicit null check. If yes, append a description of the said null check to
/// NullCheckList and return true, else return false.
-bool ImplicitNullChecks::analyzeBlockForNullChecks(
+bool ImplicitNullChecksImpl::analyzeBlockForNullChecks(
MachineBasicBlock &MBB, SmallVectorImpl<NullCheck> &NullCheckList) {
using MachineBranchPredicate = TargetInstrInfo::MachineBranchPredicate;
@@ -713,7 +712,7 @@ bool ImplicitNullChecks::analyzeBlockForNullChecks(
/// The FAULTING instruction does the same load/store as MI
/// (defining the same register), and branches to HandlerMBB if the mem access
/// faults. The FAULTING instruction is inserted at the end of MBB.
-MachineInstr *ImplicitNullChecks::insertFaultingInstr(
+MachineInstr *ImplicitNullChecksImpl::insertFaultingInstr(
MachineInstr *MI, MachineBasicBlock *MBB, MachineBasicBlock *HandlerMBB) {
unsigned NumDefs = MI->getDesc().getNumDefs();
assert(NumDefs <= 1 && "other cases unhandled!");
@@ -758,8 +757,8 @@ MachineInstr *ImplicitNullChecks::insertFaultingInstr(
}
/// Rewrite the null checks in NullCheckList into implicit null checks.
-void ImplicitNullChecks::rewriteNullChecks(
- ArrayRef<ImplicitNullChecks::NullCheck> NullCheckList) {
+void ImplicitNullChecksImpl::rewriteNullChecks(
+ ArrayRef<ImplicitNullChecksImpl::NullCheck> NullCheckList) {
DebugLoc DL;
for (const auto &NC : NullCheckList) {
@@ -830,7 +829,7 @@ ImplicitNullChecksPass::run(MachineFunction &MF,
auto &FAM = MFAM.getResult<FunctionAnalysisManagerMachineFunctionProxy>(MF)
.getManager();
auto &AA = FAM.getResult<AAManager>(MF.getFunction());
- bool Changed = ImplicitNullChecks(MF, &AA).run(MF);
+ bool Changed = ImplicitNullChecksImpl(MF, &AA).run(MF);
if (!Changed)
return PreservedAnalyses::all();
return getMachineFunctionPassPreservedAnalyses();
More information about the llvm-commits
mailing list