Index: llvm/include/llvm/InitializePasses.h =================================================================== --- llvm/include/llvm/InitializePasses.h +++ llvm/include/llvm/InitializePasses.h @@ -114,6 +114,7 @@ void initializeCalledValuePropagationLegacyPassPass(PassRegistry &); void initializeCheckDebugMachineModulePass(PassRegistry &); void initializeCodeGenPreparePass(PassRegistry&); +void initializeConnectNoAliasDeclLegacyPassPass(PassRegistry &); void initializeConstantHoistingLegacyPassPass(PassRegistry&); void initializeConstantMergeLegacyPassPass(PassRegistry&); void initializeConstraintEliminationPass(PassRegistry &); Index: llvm/include/llvm/Transforms/Scalar.h =================================================================== --- llvm/include/llvm/Transforms/Scalar.h +++ llvm/include/llvm/Transforms/Scalar.h @@ -24,6 +24,12 @@ class ModulePass; class Pass; +//===----------------------------------------------------------------------===// +// +// ConnectNoAliasDecl - Connects llvm.noalias.XX intrinsics to llvm.noalias.decl +// +FunctionPass *createConnectNoAliasDeclPass(); + //===----------------------------------------------------------------------===// // // AlignmentFromAssumptions - Use assume intrinsics to set load/store Index: llvm/include/llvm/Transforms/Scalar/ConnectNoAliasDecl.h =================================================================== --- /dev/null +++ llvm/include/llvm/Transforms/Scalar/ConnectNoAliasDecl.h @@ -0,0 +1,32 @@ +//===- ConnectNoAliasDecl.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 +// +//===----------------------------------------------------------------------===// +/// +/// \file +/// This pass connects provenance.noalias intrinsics to the corresponding +/// llvm.noalias.decl, based on the alloca of the pointer. +/// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_TRANSFORMS_SCALAR_CONNECTNOALIASDECL_H +#define LLVM_TRANSFORMS_SCALAR_CONNECTNOALIASDECL_H + +#include "llvm/IR/PassManager.h" + +namespace llvm { +class DominatorTree; + +class ConnectNoAliasDeclPass : public PassInfoMixin { +public: + PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM); + + // Glue for old PM + bool runImpl(Function &F); +}; +} // namespace llvm + +#endif // LLVM_TRANSFORMS_SCALAR_CONNECTNOALIASDECL_H Index: llvm/include/llvm/Transforms/Utils/Cloning.h =================================================================== --- llvm/include/llvm/Transforms/Utils/Cloning.h +++ llvm/include/llvm/Transforms/Utils/Cloning.h @@ -337,6 +337,11 @@ void cloneAndAdaptNoAliasScopes(ArrayRef NoAliasDeclScopes, Instruction *IStart, Instruction *IEnd, LLVMContext &Context, StringRef Ext); +/// Connects noalias, provenance.noalias, noalias.copy.guard intrinsics to the +/// corresponding llvm.noalias.decl, based on the alloca of the underlying +/// p.addr. +/// \returns true when the function was modified. +bool propagateAndConnectNoAliasDecl(Function *F); } // end namespace llvm #endif // LLVM_TRANSFORMS_UTILS_CLONING_H Index: llvm/lib/Passes/PassBuilder.cpp =================================================================== --- llvm/lib/Passes/PassBuilder.cpp +++ llvm/lib/Passes/PassBuilder.cpp @@ -141,6 +141,7 @@ #include "llvm/Transforms/Scalar/AnnotationRemarks.h" #include "llvm/Transforms/Scalar/BDCE.h" #include "llvm/Transforms/Scalar/CallSiteSplitting.h" +#include "llvm/Transforms/Scalar/ConnectNoAliasDecl.h" #include "llvm/Transforms/Scalar/ConstantHoisting.h" #include "llvm/Transforms/Scalar/ConstraintElimination.h" #include "llvm/Transforms/Scalar/CorrelatedValuePropagation.h" @@ -537,6 +538,8 @@ FunctionPassManager FPM; + FPM.addPass(ConnectNoAliasDeclPass()); // Do this before SROA + // Form SSA out of local memory accesses after breaking apart aggregates into // scalars. FPM.addPass(SROA()); @@ -633,6 +636,8 @@ /*UseMemorySSA=*/false, /*UseBlockFrequencyInfo=*/false)); + FPM.addPass(ConnectNoAliasDeclPass()); // Do this before SROA + // Delete small array after loop unroll. FPM.addPass(SROA()); @@ -687,6 +692,8 @@ FunctionPassManager FPM; + FPM.addPass(ConnectNoAliasDeclPass()); // Do this before SROA + // Form SSA out of local memory accesses after breaking apart aggregates into // scalars. FPM.addPass(SROA()); @@ -818,6 +825,8 @@ /*UseMemorySSA=*/false, /*UseBlockFrequencyInfo=*/false)); + FPM.addPass(ConnectNoAliasDeclPass()); // Do this before SROA + // Delete small array after loop unroll. FPM.addPass(SROA()); @@ -848,6 +857,7 @@ invokePeepholeEPCallbacks(FPM, Level); // Late noalias intrinsics cleanup + FPM.addPass(ConnectNoAliasDeclPass()); FPM.addPass(PropagateAndConvertNoAliasPass()); // Re-consider control flow based optimizations after redundancy elimination, @@ -912,6 +922,8 @@ CGSCCPassManager &CGPipeline = MIWP.getPM(); FunctionPassManager FPM; + FPM.addPass(ConnectNoAliasDeclPass()); // Do this before SROA + FPM.addPass(SROA()); FPM.addPass(EarlyCSEPass()); // Catch trivial redundancies. @@ -1109,6 +1121,8 @@ // Compare/branch metadata may alter the behavior of passes like SimplifyCFG. EarlyFPM.addPass(LowerExpectIntrinsicPass()); EarlyFPM.addPass(SimplifyCFGPass()); + EarlyFPM.addPass(ConnectNoAliasDeclPass()); // Do this before SROA + EarlyFPM.addPass(SROA()); EarlyFPM.addPass(EarlyCSEPass()); @@ -1840,6 +1854,8 @@ PGOOpt->ProfileRemappingFile); } + FPM.addPass(ConnectNoAliasDeclPass()); // Do this before SROA + // Break up allocas FPM.addPass(SROA()); Index: llvm/lib/Passes/PassRegistry.def =================================================================== --- llvm/lib/Passes/PassRegistry.def +++ llvm/lib/Passes/PassRegistry.def @@ -204,6 +204,7 @@ FUNCTION_PASS("bounds-checking", BoundsCheckingPass()) FUNCTION_PASS("break-crit-edges", BreakCriticalEdgesPass()) FUNCTION_PASS("callsite-splitting", CallSiteSplittingPass()) +FUNCTION_PASS("connect-noaliasdecl", ConnectNoAliasDeclPass()) FUNCTION_PASS("consthoist", ConstantHoistingPass()) FUNCTION_PASS("constraint-elimination", ConstraintEliminationPass()) FUNCTION_PASS("convert-noalias", PropagateAndConvertNoAliasPass()) Index: llvm/lib/Transforms/IPO/PassManagerBuilder.cpp =================================================================== --- llvm/lib/Transforms/IPO/PassManagerBuilder.cpp +++ llvm/lib/Transforms/IPO/PassManagerBuilder.cpp @@ -322,6 +322,7 @@ // Compare/branch metadata may alter the behavior of passes like SimplifyCFG. FPM.add(createLowerExpectIntrinsicPass()); FPM.add(createCFGSimplificationPass()); + FPM.add(createConnectNoAliasDeclPass()); // Do this before SROA FPM.add(createSROAPass()); FPM.add(createEarlyCSEPass()); @@ -359,6 +360,7 @@ IP.HintThreshold = SizeLevel > 0 ? PreInlineThreshold : 325; MPM.add(createFunctionInliningPass(IP)); + MPM.add(createConnectNoAliasDeclPass()); // Do this before SROA MPM.add(createSROAPass()); MPM.add(createEarlyCSEPass()); // Catch trivial redundancies @@ -395,6 +397,7 @@ void PassManagerBuilder::addFunctionSimplificationPasses( legacy::PassManagerBase &MPM) { // Start of function pass. + MPM.add(createConnectNoAliasDeclPass()); // Do this before SROA // Break up aggregate allocas, using SSAUpdater. assert(OptLevel >= 1 && "Calling function optimizer with no optimization level!"); MPM.add(createSROAPass()); @@ -490,6 +493,8 @@ addExtensionsToPM(EP_LoopOptimizerEnd, MPM); // This ends the loop pass pipelines. + MPM.add(createConnectNoAliasDeclPass()); // Do this before SROA + // Break up allocas that may now be splittable after loop unrolling. MPM.add(createSROAPass()); @@ -518,6 +523,8 @@ // opened up by them. MPM.add(createInstructionCombiningPass()); addExtensionsToPM(EP_Peephole, MPM); + + MPM.add(createConnectNoAliasDeclPass()); // late cleanup // Propagate and Convert as early as possible. // But do it after SROA! MPM.add(createPropagateAndConvertNoAliasPass()); @@ -1128,6 +1135,8 @@ addExtensionsToPM(EP_Peephole, PM); PM.add(createJumpThreadingPass(/*FreezeSelectCond*/ true)); + PM.add(createConnectNoAliasDeclPass()); // Do this before SROA + // Break up allocas PM.add(createSROAPass()); Index: llvm/lib/Transforms/Scalar/CMakeLists.txt =================================================================== --- llvm/lib/Transforms/Scalar/CMakeLists.txt +++ llvm/lib/Transforms/Scalar/CMakeLists.txt @@ -4,6 +4,7 @@ AnnotationRemarks.cpp BDCE.cpp CallSiteSplitting.cpp + ConnectNoAliasDecl.cpp ConstantHoisting.cpp ConstraintElimination.cpp CorrelatedValuePropagation.cpp Index: llvm/lib/Transforms/Scalar/ConnectNoAliasDecl.cpp =================================================================== --- /dev/null +++ llvm/lib/Transforms/Scalar/ConnectNoAliasDecl.cpp @@ -0,0 +1,114 @@ +//===- ConnectNoAliasDecl.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 +// +//===----------------------------------------------------------------------===// +/// +/// \file +/// This pass connects provenance.noalias intrinsics to the corresponding +/// llvm.noalias.decl, based on the alloca of the pointer. +/// +//===----------------------------------------------------------------------===// +// +// When the original restrict declaration is not directly available, +// llvm.noalias, llvm.provenance.noalias and llvm.noalias.copy.guard can be +// associated with an 'unknown' (out of function) noalias scope. After certain +// optimizations, like SROA, inlining, ... it is possible that a +// llvm.noalias.decl is associated to an alloca, to which a llvm.noalias, +// llvm.provenance.noalias orllvm.noalias.copy.guard intrinsics is also +// associated. When the latter intrinsics are still refering to the 'unknown' +// scope, we can now refine the information by associating the llvm.noalias.decl +// and its information to the other noalias intrinsics that are depending on the +// same alloca. +// +// This pass will connect those llvm.noalias.decl to those +// llvm.noalias,llvm.provenance.noalias and llvm.noalias.copy.guard. It will +// also propagate the embedded information. +// +// This pass is best placed before SROA or PropagateAndConvertNoAlias. +// +//===----------------------------------------------------------------------===// + +#include "llvm/Transforms/Scalar/ConnectNoAliasDecl.h" +#include "llvm/Analysis/CallGraph.h" +#include "llvm/Analysis/GlobalsModRef.h" +#include "llvm/IR/Dominators.h" +#include "llvm/InitializePasses.h" +#include "llvm/Pass.h" +#include "llvm/Transforms/Utils/Cloning.h" + +using namespace llvm; + +namespace { +class ConnectNoAliasDeclLegacyPass : public FunctionPass { +public: + static char ID; // Pass identification, replacement for typeid + ConnectNoAliasDeclLegacyPass() : FunctionPass(ID) { + initializeConnectNoAliasDeclLegacyPassPass( + *PassRegistry::getPassRegistry()); + } + + bool runOnFunction(Function &F) override; + + void getAnalysisUsage(AnalysisUsage &AU) const override { + // FIXME: is all of this valid ? + AU.addPreserved(); + AU.addPreserved(); // FIXME: not sure this is + // valid. It ensures the same pass + // order as if this pass was not + // there + AU.addPreserved(); + AU.addRequiredTransitive(); + AU.setPreservesCFG(); + } + +private: + ConnectNoAliasDeclPass Impl; +}; +} // namespace + +char ConnectNoAliasDeclLegacyPass::ID = 0; +INITIALIZE_PASS_BEGIN( + ConnectNoAliasDeclLegacyPass, "connect-noaliasdecl", + "Connect llvm.noalias.decl", false, + false) // to llvm.noalias/llvm.provenance.noalias/llvm.noalias.copy.guard + // intrinsics +INITIALIZE_PASS_END( + ConnectNoAliasDeclLegacyPass, "connect-noaliasdecl", + "Connect llvm.noalias.decl", false, + false) // to llvm.noalias/llvm.provenance.noalias/llvm.noalias.copy.guard + // intrinsics + +bool ConnectNoAliasDeclLegacyPass::runOnFunction(Function &F) { + if (skipFunction(F)) + return false; + + return Impl.runImpl(F); +} + +namespace llvm { + +bool ConnectNoAliasDeclPass::runImpl(Function &F) { + return llvm::propagateAndConnectNoAliasDecl(&F); +} + +PreservedAnalyses ConnectNoAliasDeclPass::run(Function &F, + FunctionAnalysisManager &AM) { + bool Changed = runImpl(F); + + if (!Changed) + return PreservedAnalyses::all(); + PreservedAnalyses PA; + PA.preserve(); + //?? PA.preserve(); // FIXME: not sure this is valid, + // see above + + return PA; +} + +FunctionPass *createConnectNoAliasDeclPass() { + return new ConnectNoAliasDeclLegacyPass(); +} +} // namespace llvm Index: llvm/lib/Transforms/Scalar/Scalar.cpp =================================================================== --- llvm/lib/Transforms/Scalar/Scalar.cpp +++ llvm/lib/Transforms/Scalar/Scalar.cpp @@ -38,6 +38,7 @@ initializeBDCELegacyPassPass(Registry); initializeAlignmentFromAssumptionsPass(Registry); initializeCallSiteSplittingLegacyPassPass(Registry); + initializeConnectNoAliasDeclLegacyPassPass(Registry); initializeConstantHoistingLegacyPassPass(Registry); initializeConstraintEliminationPass(Registry); initializeCorrelatedValuePropagationPass(Registry); Index: llvm/test/CodeGen/AMDGPU/opt-pipeline.ll =================================================================== --- llvm/test/CodeGen/AMDGPU/opt-pipeline.ll +++ llvm/test/CodeGen/AMDGPU/opt-pipeline.ll @@ -44,6 +44,7 @@ ; GCN-O1-NEXT: Lower 'expect' Intrinsics ; GCN-O1-NEXT: Simplify the CFG ; GCN-O1-NEXT: Dominator Tree Construction +; GCN-O1-NEXT: Connect llvm.noalias.decl ; GCN-O1-NEXT: SROA ; GCN-O1-NEXT: Early CSE ; GCN-O1-NEXT: Propagate and Convert Noalias intrinsics @@ -107,6 +108,7 @@ ; GCN-O1-NEXT: FunctionPass Manager ; GCN-O1-NEXT: AMDGPU Promote Alloca to vector ; GCN-O1-NEXT: Dominator Tree Construction +; GCN-O1-NEXT: Connect llvm.noalias.decl ; GCN-O1-NEXT: SROA ; GCN-O1-NEXT: Basic Alias Analysis (stateless AA impl) ; GCN-O1-NEXT: Function Alias Analysis Results @@ -170,6 +172,7 @@ ; GCN-O1-NEXT: Induction Variable Simplification ; GCN-O1-NEXT: Delete dead loops ; GCN-O1-NEXT: Unroll loops +; GCN-O1-NEXT: Connect llvm.noalias.decl ; GCN-O1-NEXT: SROA ; GCN-O1-NEXT: Propagate and Convert Noalias intrinsics ; GCN-O1-NEXT: Sparse Conditional Constant Propagation @@ -182,6 +185,7 @@ ; GCN-O1-NEXT: Lazy Block Frequency Analysis ; GCN-O1-NEXT: Optimization Remark Emitter ; GCN-O1-NEXT: Combine redundant instructions +; GCN-O1-NEXT: Connect llvm.noalias.decl ; GCN-O1-NEXT: Propagate and Convert Noalias intrinsics ; GCN-O1-NEXT: Post-Dominator Tree Construction ; GCN-O1-NEXT: Aggressive Dead Code Elimination @@ -362,6 +366,7 @@ ; GCN-O2-NEXT: Lower 'expect' Intrinsics ; GCN-O2-NEXT: Simplify the CFG ; GCN-O2-NEXT: Dominator Tree Construction +; GCN-O2-NEXT: Connect llvm.noalias.decl ; GCN-O2-NEXT: SROA ; GCN-O2-NEXT: Early CSE ; GCN-O2-NEXT: Propagate and Convert Noalias intrinsics @@ -426,6 +431,7 @@ ; GCN-O2-NEXT: FunctionPass Manager ; GCN-O2-NEXT: AMDGPU Promote Alloca to vector ; GCN-O2-NEXT: Dominator Tree Construction +; GCN-O2-NEXT: Connect llvm.noalias.decl ; GCN-O2-NEXT: SROA ; GCN-O2-NEXT: Basic Alias Analysis (stateless AA impl) ; GCN-O2-NEXT: Function Alias Analysis Results @@ -502,6 +508,7 @@ ; GCN-O2-NEXT: Induction Variable Simplification ; GCN-O2-NEXT: Delete dead loops ; GCN-O2-NEXT: Unroll loops +; GCN-O2-NEXT: Connect llvm.noalias.decl ; GCN-O2-NEXT: SROA ; GCN-O2-NEXT: Propagate and Convert Noalias intrinsics ; GCN-O2-NEXT: Basic Alias Analysis (stateless AA impl) @@ -524,6 +531,7 @@ ; GCN-O2-NEXT: Lazy Block Frequency Analysis ; GCN-O2-NEXT: Optimization Remark Emitter ; GCN-O2-NEXT: Combine redundant instructions +; GCN-O2-NEXT: Connect llvm.noalias.decl ; GCN-O2-NEXT: Propagate and Convert Noalias intrinsics ; GCN-O2-NEXT: Basic Alias Analysis (stateless AA impl) ; GCN-O2-NEXT: Function Alias Analysis Results @@ -728,6 +736,7 @@ ; GCN-O3-NEXT: Lower 'expect' Intrinsics ; GCN-O3-NEXT: Simplify the CFG ; GCN-O3-NEXT: Dominator Tree Construction +; GCN-O3-NEXT: Connect llvm.noalias.decl ; GCN-O3-NEXT: SROA ; GCN-O3-NEXT: Early CSE ; GCN-O3-NEXT: Propagate and Convert Noalias intrinsics @@ -796,6 +805,7 @@ ; GCN-O3-NEXT: FunctionPass Manager ; GCN-O3-NEXT: AMDGPU Promote Alloca to vector ; GCN-O3-NEXT: Dominator Tree Construction +; GCN-O3-NEXT: Connect llvm.noalias.decl ; GCN-O3-NEXT: SROA ; GCN-O3-NEXT: Basic Alias Analysis (stateless AA impl) ; GCN-O3-NEXT: Function Alias Analysis Results @@ -873,6 +883,7 @@ ; GCN-O3-NEXT: Induction Variable Simplification ; GCN-O3-NEXT: Delete dead loops ; GCN-O3-NEXT: Unroll loops +; GCN-O3-NEXT: Connect llvm.noalias.decl ; GCN-O3-NEXT: SROA ; GCN-O3-NEXT: Propagate and Convert Noalias intrinsics ; GCN-O3-NEXT: Basic Alias Analysis (stateless AA impl) @@ -895,6 +906,7 @@ ; GCN-O3-NEXT: Lazy Block Frequency Analysis ; GCN-O3-NEXT: Optimization Remark Emitter ; GCN-O3-NEXT: Combine redundant instructions +; GCN-O3-NEXT: Connect llvm.noalias.decl ; GCN-O3-NEXT: Propagate and Convert Noalias intrinsics ; GCN-O3-NEXT: Basic Alias Analysis (stateless AA impl) ; GCN-O3-NEXT: Function Alias Analysis Results Index: llvm/test/Other/new-pm-defaults.ll =================================================================== --- llvm/test/Other/new-pm-defaults.ll +++ llvm/test/Other/new-pm-defaults.ll @@ -81,6 +81,7 @@ ; CHECK-O-NEXT: Running pass: SimplifyCFGPass ; CHECK-O-NEXT: Running analysis: TargetIRAnalysis ; CHECK-O-NEXT: Running analysis: AssumptionAnalysis +; CHECK-O-NEXT: Running pass: ConnectNoAliasDeclPass ; CHECK-O-NEXT: Running pass: SROA ; CHECK-O-NEXT: Running analysis: DominatorTreeAnalysis ; CHECK-O-NEXT: Running pass: EarlyCSEPass @@ -126,6 +127,7 @@ ; CHECK-O2-NEXT: Running pass: OpenMPOptCGSCCPass on (foo) ; CHECK-O3-NEXT: Running pass: OpenMPOptCGSCCPass on (foo) ; CHECK-EP-CGSCC-LATE-NEXT: Running pass: NoOpCGSCCPass +; CHECK-O-NEXT: Running pass: ConnectNoAliasDeclPass ; CHECK-O-NEXT: Running pass: SROA ; CHECK-O-NEXT: Running pass: EarlyCSEPass ; CHECK-O-NEXT: Running analysis: MemorySSAAnalysis @@ -167,6 +169,7 @@ ; CHECK-O-NEXT: Running pass: LoopDeletionPass ; CHECK-O-NEXT: Running pass: LoopFullUnrollPass ; CHECK-EP-LOOP-END-NEXT: Running pass: NoOpLoopPass +; CHECK-O-NEXT: Running pass: ConnectNoAliasDeclPass ; CHECK-O-NEXT: Running pass: SROA on foo ; CHECK-O-NEXT: Running pass: PropagateAndConvertNoAliasPass ; CHECK-O23SZ-NEXT: Running pass: MergedLoadStoreMotionPass @@ -179,6 +182,7 @@ ; CHECK-O-NEXT: Running analysis: DemandedBitsAnalysis ; CHECK-O-NEXT: Running pass: InstCombinePass ; CHECK-EP-PEEPHOLE-NEXT: Running pass: NoOpFunctionPass +; CHECK-O23SZ-NEXT: Running pass: ConnectNoAliasDeclPass on foo ; CHECK-O23SZ-NEXT: Running pass: PropagateAndConvertNoAliasPass on foo ; CHECK-O23SZ-NEXT: Running pass: JumpThreadingPass ; CHECK-O23SZ-NEXT: Running analysis: LazyValueAnalysis Index: llvm/test/Other/new-pm-lto-defaults.ll =================================================================== --- llvm/test/Other/new-pm-lto-defaults.ll +++ llvm/test/Other/new-pm-lto-defaults.ll @@ -76,6 +76,7 @@ ; CHECK-EP-Peephole-NEXT: Running pass: NoOpFunctionPass ; CHECK-O23SZ-NEXT: Running pass: JumpThreadingPass ; CHECK-O23SZ-NEXT: Running analysis: LazyValueAnalysis +; CHECK-O23SZ-NEXT: Running pass: ConnectNoAliasDeclPass ; CHECK-O23SZ-NEXT: Running pass: SROA on foo ; CHECK-O23SZ-NEXT: Running pass: PropagateAndConvertNoAliasPass on foo ; CHECK-O23SZ-NEXT: Running pass: TailCallElimPass on foo Index: llvm/test/Other/new-pm-pgo-preinline.ll =================================================================== --- llvm/test/Other/new-pm-pgo-preinline.ll +++ llvm/test/Other/new-pm-pgo-preinline.ll @@ -9,6 +9,7 @@ ; CHECK-Osz-NEXT: Running analysis: OuterAnalysisManagerProxy ; CHECK-Osz-NEXT: Running pass: InlinerPass on (foo) ; CHECK-Osz-NEXT: Running pass: InlinerPass on (foo) +; CHECK-Osz-NEXT: Running pass: ConnectNoAliasDeclPass ; CHECK-Osz-NEXT: Running pass: SROA on foo ; CHECK-Osz-NEXT: Running pass: EarlyCSEPass on foo ; CHECK-Osz-NEXT: Running pass: PropagateAndConvertNoAliasPass on foo Index: llvm/test/Other/new-pm-thinlto-defaults.ll =================================================================== --- llvm/test/Other/new-pm-thinlto-defaults.ll +++ llvm/test/Other/new-pm-thinlto-defaults.ll @@ -66,6 +66,7 @@ ; CHECK-O-NEXT: Running pass: SimplifyCFGPass ; CHECK-O-NEXT: Running analysis: TargetIRAnalysis ; CHECK-O-NEXT: Running analysis: AssumptionAnalysis +; CHECK-O-NEXT: Running pass: ConnectNoAliasDeclPass ; CHECK-O-NEXT: Running pass: SROA ; CHECK-O-NEXT: Running analysis: DominatorTreeAnalysis ; CHECK-O-NEXT: Running pass: EarlyCSEPass @@ -109,6 +110,7 @@ ; CHECK-O3-NEXT: Running pass: ArgumentPromotionPass ; CHECK-O2-NEXT: Running pass: OpenMPOptCGSCCPass on (foo) ; CHECK-O3-NEXT: Running pass: OpenMPOptCGSCCPass on (foo) +; CHECK-O-NEXT: Running pass: ConnectNoAliasDeclPass ; CHECK-O-NEXT: Running pass: SROA ; CHECK-O-NEXT: Running pass: EarlyCSEPass ; CHECK-O-NEXT: Running analysis: MemorySSAAnalysis @@ -147,6 +149,7 @@ ; CHECK-O-NEXT: Running pass: IndVarSimplifyPass ; CHECK-O-NEXT: Running pass: LoopDeletionPass ; CHECK-O-NEXT: Running pass: LoopFullUnrollPass +; CHECK-O-NEXT: Running pass: ConnectNoAliasDeclPass ; CHECK-O-NEXT: Running pass: SROA on foo ; CHECK-O-NEXT: Running pass: PropagateAndConvertNoAliasPass ; CHECK-Os-NEXT: Running pass: MergedLoadStoreMotionPass @@ -170,6 +173,7 @@ ; CHECK-O-NEXT: Running pass: BDCEPass ; CHECK-O-NEXT: Running analysis: DemandedBitsAnalysis ; CHECK-O-NEXT: Running pass: InstCombinePass +; CHECK-O23SZ-NEXT: Running pass: ConnectNoAliasDeclPass on foo ; CHECK-O23SZ-NEXT: Running pass: PropagateAndConvertNoAliasPass on foo ; CHECK-O23SZ-NEXT: Running pass: JumpThreadingPass ; CHECK-O23SZ-NEXT: Running analysis: LazyValueAnalysis Index: llvm/test/Other/new-pm-thinlto-postlink-pgo-defaults.ll =================================================================== --- llvm/test/Other/new-pm-thinlto-postlink-pgo-defaults.ll +++ llvm/test/Other/new-pm-thinlto-postlink-pgo-defaults.ll @@ -36,6 +36,7 @@ ; CHECK-O-NEXT: Running pass: SimplifyCFGPass ; CHECK-O-NEXT: Running analysis: TargetIRAnalysis ; CHECK-O-NEXT: Running analysis: AssumptionAnalysis +; CHECK-O-NEXT: Running pass: ConnectNoAliasDeclPass ; CHECK-O-NEXT: Running pass: SROA ; CHECK-O-NEXT: Running analysis: DominatorTreeAnalysis ; CHECK-O-NEXT: Running pass: EarlyCSEPass @@ -83,6 +84,7 @@ ; CHECK-O3-NEXT: Running pass: ArgumentPromotionPass ; CHECK-O2-NEXT: Running pass: OpenMPOptCGSCCPass ; CHECK-O3-NEXT: Running pass: OpenMPOptCGSCCPass +; CHECK-O-NEXT: Running pass: ConnectNoAliasDeclPass ; CHECK-O-NEXT: Running pass: SROA ; CHECK-O-NEXT: Running pass: EarlyCSEPass ; CHECK-O-NEXT: Running analysis: MemorySSAAnalysis @@ -120,6 +122,7 @@ ; CHECK-O-NEXT: Running pass: IndVarSimplifyPass ; CHECK-O-NEXT: Running pass: LoopDeletionPass ; CHECK-O-NEXT: Running pass: LoopFullUnrollPass +; CHECK-O-NEXT: Running pass: ConnectNoAliasDeclPass ; CHECK-O-NEXT: Running pass: SROA on foo ; CHECK-O-NEXT: Running pass: PropagateAndConvertNoAliasPass ; CHECK-Os-NEXT: Running pass: MergedLoadStoreMotionPass @@ -143,6 +146,7 @@ ; CHECK-O-NEXT: Running pass: BDCEPass ; CHECK-O-NEXT: Running analysis: DemandedBitsAnalysis ; CHECK-O-NEXT: Running pass: InstCombinePass +; CHECK-O23SZ-NEXT: Running pass: ConnectNoAliasDeclPass on foo ; CHECK-O23SZ-NEXT: Running pass: PropagateAndConvertNoAliasPass on foo ; CHECK-O23SZ-NEXT: Running pass: JumpThreadingPass ; CHECK-O23SZ-NEXT: Running analysis: LazyValueAnalysis Index: llvm/test/Other/new-pm-thinlto-postlink-samplepgo-defaults.ll =================================================================== --- llvm/test/Other/new-pm-thinlto-postlink-samplepgo-defaults.ll +++ llvm/test/Other/new-pm-thinlto-postlink-samplepgo-defaults.ll @@ -38,6 +38,7 @@ ; CHECK-O-NEXT: Running pass: SimplifyCFGPass ; CHECK-O-NEXT: Running analysis: TargetIRAnalysis ; CHECK-O-NEXT: Running analysis: AssumptionAnalysis +; CHECK-O-NEXT: Running pass: ConnectNoAliasDeclPass ; CHECK-O-NEXT: Running pass: SROA ; CHECK-O-NEXT: Running analysis: DominatorTreeAnalysis ; CHECK-O-NEXT: Running pass: EarlyCSEPass @@ -92,6 +93,7 @@ ; CHECK-O3-NEXT: Running pass: ArgumentPromotionPass ; CHECK-O2-NEXT: Running pass: OpenMPOptCGSCCPass ; CHECK-O3-NEXT: Running pass: OpenMPOptCGSCCPass +; CHECK-O-NEXT: Running pass: ConnectNoAliasDeclPass ; CHECK-O-NEXT: Running pass: SROA ; CHECK-O-NEXT: Running pass: EarlyCSEPass ; CHECK-O-NEXT: Running analysis: MemorySSAAnalysis @@ -129,6 +131,7 @@ ; CHECK-O-NEXT: Running pass: IndVarSimplifyPass ; CHECK-O-NEXT: Running pass: LoopDeletionPass ; CHECK-O-NEXT: Running pass: LoopFullUnrollPass +; CHECK-O-NEXT: Running pass: ConnectNoAliasDeclPass ; CHECK-O-NEXT: Running pass: SROA on foo ; CHECK-O-NEXT: Running pass: PropagateAndConvertNoAliasPass ; CHECK-Os-NEXT: Running pass: MergedLoadStoreMotionPass @@ -152,6 +155,7 @@ ; CHECK-O-NEXT: Running pass: BDCEPass ; CHECK-O-NEXT: Running analysis: DemandedBitsAnalysis ; CHECK-O-NEXT: Running pass: InstCombinePass +; CHECK-O23SZ-NEXT: Running pass: ConnectNoAliasDeclPass on foo ; CHECK-O23SZ-NEXT: Running pass: PropagateAndConvertNoAliasPass on foo ; CHECK-O23SZ-NEXT: Running pass: JumpThreadingPass ; CHECK-O23SZ-NEXT: Running analysis: LazyValueAnalysis Index: llvm/test/Other/new-pm-thinlto-prelink-pgo-defaults.ll =================================================================== --- llvm/test/Other/new-pm-thinlto-prelink-pgo-defaults.ll +++ llvm/test/Other/new-pm-thinlto-prelink-pgo-defaults.ll @@ -37,6 +37,7 @@ ; CHECK-O-NEXT: Running pass: SimplifyCFGPass ; CHECK-O-NEXT: Running analysis: TargetIRAnalysis ; CHECK-O-NEXT: Running analysis: AssumptionAnalysis +; CHECK-O-NEXT: Running pass: ConnectNoAliasDeclPass ; CHECK-O-NEXT: Running pass: SROA ; CHECK-O-NEXT: Running analysis: DominatorTreeAnalysis ; CHECK-O-NEXT: Running pass: EarlyCSEPass @@ -66,6 +67,7 @@ ; CHECK-O123SZ-NEXT: Running analysis: OuterAnalysisManagerProxy ; CHECK-O123SZ-NEXT: Running pass: InlinerPass on (foo) ; CHECK-O123SZ-NEXT: Running pass: InlinerPass on (foo) +; CHECK-O123SZ-NEXT: Running pass: ConnectNoAliasDeclPass on foo ; CHECK-O123SZ-NEXT: Running pass: SROA on foo ; CHECK-O123SZ-NEXT: Running pass: EarlyCSEPass on foo ; CHECK-O123SZ-NEXT: Running pass: PropagateAndConvertNoAliasPass on foo @@ -112,6 +114,7 @@ ; CHECK-O3-NEXT: Running analysis: TargetIRAnalysis ; CHECK-O2-NEXT: Running pass: OpenMPOptCGSCCPass ; CHECK-O3-NEXT: Running pass: OpenMPOptCGSCCPass +; CHECK-O-NEXT: Running pass: ConnectNoAliasDeclPass ; CHECK-O-NEXT: Running pass: SROA ; CHECK-O-NEXT: Running pass: EarlyCSEPass ; CHECK-O1-NEXT: Running analysis: TargetIRAnalysis on foo @@ -161,6 +164,7 @@ ; CHECK-O-NEXT: Running pass: IndVarSimplifyPass ; CHECK-O-NEXT: Running pass: LoopDeletionPass ; CHECK-O-NEXT: Running pass: LoopFullUnrollPass +; CHECK-O-NEXT: Running pass: ConnectNoAliasDeclPass ; CHECK-O-NEXT: Running pass: SROA on foo ; CHECK-O-NEXT: Running pass: PropagateAndConvertNoAliasPass ; CHECK-Os-NEXT: Running pass: MergedLoadStoreMotionPass @@ -184,6 +188,7 @@ ; CHECK-O-NEXT: Running pass: BDCEPass ; CHECK-O-NEXT: Running analysis: DemandedBitsAnalysis ; CHECK-O-NEXT: Running pass: InstCombinePass +; CHECK-O23SZ-NEXT: Running pass: ConnectNoAliasDeclPass on foo ; CHECK-O23SZ-NEXT: Running pass: PropagateAndConvertNoAliasPass on foo ; CHECK-O23SZ-NEXT: Running pass: JumpThreadingPass ; CHECK-O23SZ-NEXT: Running analysis: LazyValueAnalysis Index: llvm/test/Other/new-pm-thinlto-prelink-samplepgo-defaults.ll =================================================================== --- llvm/test/Other/new-pm-thinlto-prelink-samplepgo-defaults.ll +++ llvm/test/Other/new-pm-thinlto-prelink-samplepgo-defaults.ll @@ -36,6 +36,7 @@ ; CHECK-O-NEXT: Running pass: SimplifyCFGPass ; CHECK-O-NEXT: Running analysis: TargetIRAnalysis ; CHECK-O-NEXT: Running analysis: AssumptionAnalysis +; CHECK-O-NEXT: Running pass: ConnectNoAliasDeclPass ; CHECK-O-NEXT: Running pass: SROA ; CHECK-O-NEXT: Running analysis: DominatorTreeAnalysis ; CHECK-O-NEXT: Running pass: EarlyCSEPass @@ -87,6 +88,7 @@ ; CHECK-O3-NEXT: Running pass: ArgumentPromotionPass ; CHECK-O2-NEXT: Running pass: OpenMPOptCGSCCPass ; CHECK-O3-NEXT: Running pass: OpenMPOptCGSCCPass +; CHECK-O-NEXT: Running pass: ConnectNoAliasDeclPass ; CHECK-O-NEXT: Running pass: SROA ; CHECK-O-NEXT: Running pass: EarlyCSEPass ; CHECK-O-NEXT: Running analysis: MemorySSAAnalysis @@ -123,6 +125,7 @@ ; CHECK-O-NEXT: Running pass: LoopIdiomRecognizePass ; CHECK-O-NEXT: Running pass: IndVarSimplifyPass ; CHECK-O-NEXT: Running pass: LoopDeletionPass +; CHECK-O-NEXT: Running pass: ConnectNoAliasDeclPass ; CHECK-O-NEXT: Running pass: SROA on foo ; CHECK-O-NEXT: Running pass: PropagateAndConvertNoAliasPass ; CHECK-Os-NEXT: Running pass: MergedLoadStoreMotionPass @@ -146,6 +149,7 @@ ; CHECK-O-NEXT: Running pass: BDCEPass ; CHECK-O-NEXT: Running analysis: DemandedBitsAnalysis ; CHECK-O-NEXT: Running pass: InstCombinePass +; CHECK-O23SZ-NEXT: Running pass: ConnectNoAliasDeclPass on foo ; CHECK-O23SZ-NEXT: Running pass: PropagateAndConvertNoAliasPass on foo ; CHECK-O23SZ-NEXT: Running pass: JumpThreadingPass ; CHECK-O23SZ-NEXT: Running analysis: LazyValueAnalysis Index: llvm/test/Other/opt-LTO-pipeline.ll =================================================================== --- llvm/test/Other/opt-LTO-pipeline.ll +++ llvm/test/Other/opt-LTO-pipeline.ll @@ -83,6 +83,7 @@ ; CHECK-NEXT: Combine redundant instructions ; CHECK-NEXT: Lazy Value Information Analysis ; CHECK-NEXT: Jump Threading +; CHECK-NEXT: Connect llvm.noalias.decl ; CHECK-NEXT: SROA ; CHECK-NEXT: Propagate and Convert Noalias intrinsics ; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) Index: llvm/test/Other/opt-O2-pipeline.ll =================================================================== --- llvm/test/Other/opt-O2-pipeline.ll +++ llvm/test/Other/opt-O2-pipeline.ll @@ -15,6 +15,7 @@ ; CHECK-NEXT: Lower 'expect' Intrinsics ; CHECK-NEXT: Simplify the CFG ; CHECK-NEXT: Dominator Tree Construction +; CHECK-NEXT: Connect llvm.noalias.decl ; CHECK-NEXT: SROA ; CHECK-NEXT: Early CSE ; CHECK-NEXT: Propagate and Convert Noalias intrinsics @@ -67,6 +68,7 @@ ; CHECK-NEXT: Deduce function attributes ; CHECK-NEXT: FunctionPass Manager ; CHECK-NEXT: Dominator Tree Construction +; CHECK-NEXT: Connect llvm.noalias.decl ; CHECK-NEXT: SROA ; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) ; CHECK-NEXT: Function Alias Analysis Results @@ -140,6 +142,7 @@ ; CHECK-NEXT: Induction Variable Simplification ; CHECK-NEXT: Delete dead loops ; CHECK-NEXT: Unroll loops +; CHECK-NEXT: Connect llvm.noalias.decl ; CHECK-NEXT: SROA ; CHECK-NEXT: Propagate and Convert Noalias intrinsics ; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) @@ -162,6 +165,7 @@ ; CHECK-NEXT: Lazy Block Frequency Analysis ; CHECK-NEXT: Optimization Remark Emitter ; CHECK-NEXT: Combine redundant instructions +; CHECK-NEXT: Connect llvm.noalias.decl ; CHECK-NEXT: Propagate and Convert Noalias intrinsics ; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) ; CHECK-NEXT: Function Alias Analysis Results Index: llvm/test/Other/opt-O3-pipeline-enable-matrix.ll =================================================================== --- llvm/test/Other/opt-O3-pipeline-enable-matrix.ll +++ llvm/test/Other/opt-O3-pipeline-enable-matrix.ll @@ -16,6 +16,7 @@ ; LEGACY-NEXT: Lower 'expect' Intrinsics ; LEGACY-NEXT: Simplify the CFG ; LEGACY-NEXT: Dominator Tree Construction +; LEGACY-NEXT: Connect llvm.noalias.decl ; LEGACY-NEXT: SROA ; LEGACY-NEXT: Early CSE ; LEGACY-NEXT: Propagate and Convert Noalias intrinsics @@ -72,6 +73,7 @@ ; LEGACY-NEXT: Promote 'by reference' arguments to scalars ; LEGACY-NEXT: FunctionPass Manager ; LEGACY-NEXT: Dominator Tree Construction +; LEGACY-NEXT: Connect llvm.noalias.decl ; LEGACY-NEXT: SROA ; LEGACY-NEXT: Basic Alias Analysis (stateless AA impl) ; LEGACY-NEXT: Function Alias Analysis Results @@ -146,6 +148,7 @@ ; LEGACY-NEXT: Induction Variable Simplification ; LEGACY-NEXT: Delete dead loops ; LEGACY-NEXT: Unroll loops +; LEGACY-NEXT: Connect llvm.noalias.decl ; LEGACY-NEXT: SROA ; LEGACY-NEXT: Propagate and Convert Noalias intrinsics ; LEGACY-NEXT: Basic Alias Analysis (stateless AA impl) @@ -168,6 +171,7 @@ ; LEGACY-NEXT: Lazy Block Frequency Analysis ; LEGACY-NEXT: Optimization Remark Emitter ; LEGACY-NEXT: Combine redundant instructions +; LEGACY-NEXT: Connect llvm.noalias.decl ; LEGACY-NEXT: Propagate and Convert Noalias intrinsics ; LEGACY-NEXT: Basic Alias Analysis (stateless AA impl) ; LEGACY-NEXT: Function Alias Analysis Results @@ -365,6 +369,7 @@ ; NEWPM-NEXT: Running pass: SimplifyCFGPass on f ; NEWPM-NEXT: Running analysis: TargetIRAnalysis on f ; NEWPM-NEXT: Running analysis: AssumptionAnalysis on f +; NEWPM-NEXT: Running pass: ConnectNoAliasDeclPass on f ; NEWPM-NEXT: Running pass: SROA on f ; NEWPM-NEXT: Running analysis: DominatorTreeAnalysis on f ; NEWPM-NEXT: Running pass: EarlyCSEPass on f @@ -413,6 +418,7 @@ ; NEWPM-NEXT: Running analysis: AAManager on f ; NEWPM-NEXT: Running pass: ArgumentPromotionPass on (f) ; NEWPM-NEXT: Running pass: OpenMPOptCGSCCPass on (f) +; NEWPM-NEXT: Running pass: ConnectNoAliasDeclPass on f ; NEWPM-NEXT: Running pass: SROA on f ; NEWPM-NEXT: Running pass: EarlyCSEPass on f ; NEWPM-NEXT: Running analysis: MemorySSAAnalysis on f @@ -437,6 +443,7 @@ ; NEWPM-NEXT: Running pass: InstCombinePass on f ; NEWPM-NEXT: Running pass: LoopSimplifyPass on f ; NEWPM-NEXT: Running pass: LCSSAPass on f +; NEWPM-NEXT: Running pass: ConnectNoAliasDeclPass on f ; NEWPM-NEXT: Running pass: SROA on f ; NEWPM-NEXT: Running pass: PropagateAndConvertNoAliasPass on f ; NEWPM-NEXT: Running pass: MergedLoadStoreMotionPass on f @@ -447,6 +454,7 @@ ; NEWPM-NEXT: Running pass: BDCEPass on f ; NEWPM-NEXT: Running analysis: DemandedBitsAnalysis on f ; NEWPM-NEXT: Running pass: InstCombinePass on f +; NEWPM-NEXT: Running pass: ConnectNoAliasDeclPass on f ; NEWPM-NEXT: Running pass: PropagateAndConvertNoAliasPass on f ; NEWPM-NEXT: Running pass: JumpThreadingPass on f ; NEWPM-NEXT: Running analysis: LazyValueAnalysis on f Index: llvm/test/Other/opt-O3-pipeline.ll =================================================================== --- llvm/test/Other/opt-O3-pipeline.ll +++ llvm/test/Other/opt-O3-pipeline.ll @@ -16,6 +16,7 @@ ; CHECK-NEXT: Lower 'expect' Intrinsics ; CHECK-NEXT: Simplify the CFG ; CHECK-NEXT: Dominator Tree Construction +; CHECK-NEXT: Connect llvm.noalias.decl ; CHECK-NEXT: SROA ; CHECK-NEXT: Early CSE ; CHECK-NEXT: Propagate and Convert Noalias intrinsics @@ -72,6 +73,7 @@ ; CHECK-NEXT: Promote 'by reference' arguments to scalars ; CHECK-NEXT: FunctionPass Manager ; CHECK-NEXT: Dominator Tree Construction +; CHECK-NEXT: Connect llvm.noalias.decl ; CHECK-NEXT: SROA ; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) ; CHECK-NEXT: Function Alias Analysis Results @@ -146,6 +148,7 @@ ; CHECK-NEXT: Induction Variable Simplification ; CHECK-NEXT: Delete dead loops ; CHECK-NEXT: Unroll loops +; CHECK-NEXT: Connect llvm.noalias.decl ; CHECK-NEXT: SROA ; CHECK-NEXT: Propagate and Convert Noalias intrinsics ; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) @@ -168,6 +171,7 @@ ; CHECK-NEXT: Lazy Block Frequency Analysis ; CHECK-NEXT: Optimization Remark Emitter ; CHECK-NEXT: Combine redundant instructions +; CHECK-NEXT: Connect llvm.noalias.decl ; CHECK-NEXT: Propagate and Convert Noalias intrinsics ; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) ; CHECK-NEXT: Function Alias Analysis Results @@ -361,6 +365,7 @@ ; NEWPM-NEXT: SimplifyCFGPass on f ; NEWPM-NEXT: TargetIRAnalysis analysis on f ; NEWPM-NEXT: AssumptionAnalysis analysis on f +; NEWPM-NEXT: ConnectNoAliasDeclPass on f ; NEWPM-NEXT: SROA on f ; NEWPM-NEXT: DominatorTreeAnalysis analysis on f ; NEWPM-NEXT: EarlyCSEPass on f @@ -412,6 +417,7 @@ ; NEWPM-NEXT: OpenMPOptCGSCCPass on (f) ; NEWPM-NEXT: CGSCCToFunctionPassAdaptor on (f) ; NEWPM-NEXT: PassManager<{{.*}}> on f +; NEWPM-NEXT: ConnectNoAliasDeclPass on f ; NEWPM-NEXT: SROA on f ; NEWPM-NEXT: EarlyCSEPass on f ; NEWPM-NEXT: MemorySSAAnalysis analysis on f @@ -439,6 +445,7 @@ ; NEWPM-NEXT: PassManager<{{.*}}> on f ; NEWPM-NEXT: LoopSimplifyPass on f ; NEWPM-NEXT: LCSSAPass on f +; NEWPM-NEXT: ConnectNoAliasDeclPass on f ; NEWPM-NEXT: SROA on f ; NEWPM-NEXT: PropagateAndConvertNoAliasPass on f ; NEWPM-NEXT: MergedLoadStoreMotionPass on f @@ -449,6 +456,7 @@ ; NEWPM-NEXT: BDCEPass on f ; NEWPM-NEXT: DemandedBitsAnalysis analysis on f ; NEWPM-NEXT: InstCombinePass on f +; NEWPM-NEXT: ConnectNoAliasDeclPass on f ; NEWPM-NEXT: PropagateAndConvertNoAliasPass on f ; NEWPM-NEXT: JumpThreadingPass on f ; NEWPM-NEXT: LazyValueAnalysis analysis on f Index: llvm/test/Other/opt-Os-pipeline.ll =================================================================== --- llvm/test/Other/opt-Os-pipeline.ll +++ llvm/test/Other/opt-Os-pipeline.ll @@ -15,6 +15,7 @@ ; CHECK-NEXT: Lower 'expect' Intrinsics ; CHECK-NEXT: Simplify the CFG ; CHECK-NEXT: Dominator Tree Construction +; CHECK-NEXT: Connect llvm.noalias.decl ; CHECK-NEXT: SROA ; CHECK-NEXT: Early CSE ; CHECK-NEXT: Propagate and Convert Noalias intrinsics @@ -67,6 +68,7 @@ ; CHECK-NEXT: Deduce function attributes ; CHECK-NEXT: FunctionPass Manager ; CHECK-NEXT: Dominator Tree Construction +; CHECK-NEXT: Connect llvm.noalias.decl ; CHECK-NEXT: SROA ; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) ; CHECK-NEXT: Function Alias Analysis Results @@ -126,6 +128,7 @@ ; CHECK-NEXT: Induction Variable Simplification ; CHECK-NEXT: Delete dead loops ; CHECK-NEXT: Unroll loops +; CHECK-NEXT: Connect llvm.noalias.decl ; CHECK-NEXT: SROA ; CHECK-NEXT: Propagate and Convert Noalias intrinsics ; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) @@ -148,6 +151,7 @@ ; CHECK-NEXT: Lazy Block Frequency Analysis ; CHECK-NEXT: Optimization Remark Emitter ; CHECK-NEXT: Combine redundant instructions +; CHECK-NEXT: Connect llvm.noalias.decl ; CHECK-NEXT: Propagate and Convert Noalias intrinsics ; CHECK-NEXT: Basic Alias Analysis (stateless AA impl) ; CHECK-NEXT: Function Alias Analysis Results Index: llvm/test/Other/pm-pgo-preinline.ll =================================================================== --- llvm/test/Other/pm-pgo-preinline.ll +++ llvm/test/Other/pm-pgo-preinline.ll @@ -7,6 +7,7 @@ ; CHECK-Osz-NEXT: Function Integration/Inlining ; CHECK-Osz-NEXT: FunctionPass Manager ; CHECK-Osz-NEXT: Dominator Tree Construction +; CHECK-Osz-NEXT: Connect llvm.noalias.decl ; CHECK-Osz-NEXT: SROA ; CHECK-Osz-NEXT: Early CSE ; CHECK-Osz-NEXT: Propagate and Convert Noalias intrinsics Index: llvm/test/Transforms/ConnectNoAliasDecl/basictest.ll =================================================================== --- /dev/null +++ llvm/test/Transforms/ConnectNoAliasDecl/basictest.ll @@ -0,0 +1,179 @@ +; RUN: opt < %s -connect-noaliasdecl -verify -S | FileCheck %s +; RUN: opt < %s -passes=connect-noaliasdecl,verify -S | FileCheck %s + +target datalayout = "e-p:64:64:64-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64" + + +%struct.FOO = type { i32*, i32*, i32* } + +; Function Attrs: nounwind +define dso_local void @test_01_before(i32** %_p, i32 %c) #0 !noalias !2 { +entry: + %rp = alloca [2 x i32*], align 4 + %other = alloca i32*, align 4 + %local_tmp = alloca i32*, align 4 + %tmp.0 = bitcast [2 x i32*]* %rp to i8* + %.fca.0.gep = getelementptr inbounds [2 x i32*], [2 x i32*]* %rp, i32 0, i32 0 + %.fca.1.gep = getelementptr inbounds [2 x i32*], [2 x i32*]* %rp, i32 0, i32 1 + call void @llvm.lifetime.start.p0i8(i64 8, i8* %tmp.0) #5, !noalias !5 + %tmp.1 = call i8* @llvm.noalias.decl.p0i8.p0a2p0i32.i32([2 x i32*]* %rp, i32 0, metadata !7) + %tmp.2 = load i32*, i32** %_p, align 4, !tbaa !8, !noalias !5 + store i32* %tmp.2, i32** %.fca.0.gep, align 4, !tbaa !8, !noalias !5 + %arrayinit.element = getelementptr inbounds i32*, i32** %.fca.0.gep, i32 1 + %arrayidx1 = getelementptr inbounds i32*, i32** %_p, i32 1 + %tmp.3 = load i32*, i32** %arrayidx1, align 4, !tbaa !8, !noalias !5 + store i32* %tmp.3, i32** %arrayinit.element, align 4, !tbaa !8, !noalias !5 + %tmp.4 = bitcast i32** %other to i8* + call void @llvm.lifetime.start.p0i8(i64 4, i8* %tmp.4) #5, !noalias !5 + %arrayidx2 = getelementptr inbounds i32*, i32** %_p, i32 2 + %tmp.5 = load i32*, i32** %arrayidx2, align 4, !tbaa !8, !noalias !5 + store i32* %tmp.5, i32** %other, align 4, !tbaa !8, !noalias !5 + %tobool = icmp ne i32 %c, 0 + %cond = select i1 %tobool, i32** %.fca.0.gep, i32** %other + %tmp.6 = load i32*, i32** %arrayinit.element, align 4, !tbaa !8, !noalias !5 + %through_local_tmp = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i32(i32* %tmp.6, i8* null, i32** %arrayinit.element, i32 0, metadata !2), !tbaa !8, !noalias !5 + %tmp.7 = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i32(i32* %through_local_tmp, i8* null, i32** %local_tmp, i32 0, metadata !2), !tbaa !8, !noalias !5 + %tmp.8 = load i32, i32* %tmp.7, align 4, !tbaa !12, !noalias !5 + %tmp.9 = load i32*, i32** %.fca.0.gep, align 4, !tbaa !8, !noalias !5 + %tmp.10 = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i32(i32* %tmp.9, i8* null, i32** %.fca.0.gep, i32 0, metadata !2), !tbaa !8, !noalias !5 + store i32 %tmp.8, i32* %tmp.10, align 4, !tbaa !12, !noalias !5 + %tmp.11 = load i32*, i32** %cond, align 4, !tbaa !8, !noalias !5 + %tmp.12 = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i32(i32* %tmp.11, i8* null, i32** %cond, i32 0, metadata !2), !tbaa !8, !noalias !5 + store i32 42, i32* %tmp.12, align 4, !tbaa !12, !noalias !5 + call void @llvm.lifetime.end.p0i8(i64 4, i8* %tmp.4) #5 + call void @llvm.lifetime.end.p0i8(i64 8, i8* %tmp.0) #5 + ret void +} + +; CHECK-LABEL: @test_01_before( +; CHECK: %tmp.1 = call i8* @llvm.noalias.decl.p0i8.p0a2p0i32.i32([2 x i32*]* %rp, i32 0, metadata !7) +; CHECK: %through_local_tmp = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i32(i32* %tmp.6, i8* %tmp.1, i32** %arrayinit.element, i32 0, metadata !7), !tbaa !8, !noalias !5 +; CHECK: %tmp.10 = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i32(i32* %tmp.9, i8* %tmp.1, i32** %.fca.0.gep, i32 0, metadata !7), !tbaa !8, !noalias !5 +; CHECK: %tmp.12 = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i32(i32* %tmp.11, i8* null, i32** %cond, i32 0, metadata !2), !tbaa !8, !noalias !5 +; CHECK-NOT: llvm.noalias + +; Function Attrs: nounwind +define dso_local void @test_02(i32** %_p, i32 %c) #0 !noalias !14 { +entry: + %foo = alloca %struct.FOO, align 4 + %tmp = alloca %struct.FOO, align 4 + %tmp.1 = call i8* @llvm.noalias.decl.p0i8.p0s_struct.FOOs.i32(%struct.FOO* %foo, i32 0, metadata !17) + %tmp.10 = call i8* @llvm.noalias.decl.p0i8.p0s_struct.FOOs.i32(%struct.FOO* %tmp, i32 0, metadata !19) + %tmp.12 = call %struct.FOO* @llvm.noalias.copy.guard.p0s_struct.FOOs.p0i8(%struct.FOO* %foo, i8* null, metadata !21, metadata !14) + %tmp.13 = load %struct.FOO, %struct.FOO* %tmp.12, align 4, !noalias !25 + store %struct.FOO %tmp.13, %struct.FOO* %tmp, !noalias !25 + ret void +} + +; CHECK-LABEL: @test_02( +; CHECK: %tmp.1 = call i8* @llvm.noalias.decl.p0i8.p0s_struct.FOOs.i32(%struct.FOO* %foo, i32 0, metadata !17) +; CHECK: %tmp.10 = call i8* @llvm.noalias.decl.p0i8.p0s_struct.FOOs.i32(%struct.FOO* %tmp, i32 0, metadata !19) +; CHECK: %tmp.12 = call %struct.FOO* @llvm.noalias.copy.guard.p0s_struct.FOOs.p0i8(%struct.FOO* %foo, i8* %tmp.1, metadata !21, metadata !17) +; CHECK-NOT: llvm.noalias + +; Function Attrs: nounwind +define dso_local void @test_01_after(i32** %_p, i32 %c) #0 !noalias !2 { +entry: + %rp = alloca [2 x i32*], align 4 + %local_tmp = alloca i32*, align 4 + %other = alloca i32*, align 4 + %.fca.0.gep = getelementptr inbounds [2 x i32*], [2 x i32*]* %rp, i32 0, i32 0 + %.fca.1.gep = getelementptr inbounds [2 x i32*], [2 x i32*]* %rp, i32 0, i32 1 + %tmp.0 = bitcast [2 x i32*]* %rp to i8* + call void @llvm.lifetime.start.p0i8(i64 8, i8* %tmp.0) #5, !noalias !5 + %tmp.1 = call i8* @llvm.noalias.decl.p0i8.p0a2p0i32.i32([2 x i32*]* %rp, i32 0, metadata !7) + %tmp.2 = load i32*, i32** %_p, ptr_provenance i32** undef, align 4, !tbaa !8, !noalias !5 + store i32* %tmp.2, i32** %.fca.0.gep, ptr_provenance i32** undef, align 4, !tbaa !8, !noalias !5 + %arrayinit.element = getelementptr inbounds i32*, i32** %.fca.0.gep, i32 1 + %arrayidx1 = getelementptr inbounds i32*, i32** %_p, i32 1 + %tmp.3 = load i32*, i32** %arrayidx1, ptr_provenance i32** undef, align 4, !tbaa !8, !noalias !5 + store i32* %tmp.3, i32** %arrayinit.element, ptr_provenance i32** undef, align 4, !tbaa !8, !noalias !5 + %tmp.4 = bitcast i32** %other to i8* + call void @llvm.lifetime.start.p0i8(i64 4, i8* %tmp.4) #5, !noalias !5 + %arrayidx2 = getelementptr inbounds i32*, i32** %_p, i32 2 + %tmp.5 = load i32*, i32** %arrayidx2, ptr_provenance i32** undef, align 4, !tbaa !8, !noalias !5 + store i32* %tmp.5, i32** %other, ptr_provenance i32** undef, align 4, !tbaa !8, !noalias !5 + %tobool = icmp ne i32 %c, 0 + %cond = select i1 %tobool, i32** %.fca.0.gep, i32** %other + %tmp.6 = load i32*, i32** %arrayinit.element, ptr_provenance i32** undef, align 4, !tbaa !8, !noalias !5 + %through_local_tmp = call i32* @llvm.provenance.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i32(i32* %tmp.6, i8* null, i32** %arrayinit.element, i32** undef, i32 0, metadata !2), !tbaa !8, !noalias !5 + %tmp.7 = call i32* @llvm.provenance.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i32(i32* %through_local_tmp, i8* null, i32** %local_tmp, i32** undef, i32 0, metadata !2), !tbaa !8, !noalias !5 + %tmp.8 = load i32, i32* %tmp.6, ptr_provenance i32* %tmp.7, align 4, !tbaa !12, !noalias !5 + %tmp.9 = load i32*, i32** %.fca.0.gep, ptr_provenance i32** undef, align 4, !tbaa !8, !noalias !5 + %tmp.10 = call i32* @llvm.provenance.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i32(i32* %tmp.9, i8* null, i32** %.fca.0.gep, i32** undef, i32 0, metadata !2), !tbaa !8, !noalias !5 + store i32 %tmp.8, i32* %tmp.9, ptr_provenance i32* %tmp.10, align 4, !tbaa !12, !noalias !5 + %tmp.11 = load i32*, i32** %cond, ptr_provenance i32** undef, align 4, !tbaa !8, !noalias !5 + %tmp.12 = call i32* @llvm.provenance.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i32(i32* %tmp.11, i8* null, i32** %cond, i32** undef, i32 0, metadata !2), !tbaa !8, !noalias !5 + store i32 42, i32* %tmp.11, ptr_provenance i32* %tmp.12, align 4, !tbaa !12, !noalias !5 + call void @llvm.lifetime.end.p0i8(i64 4, i8* %tmp.4) #5 + call void @llvm.lifetime.end.p0i8(i64 8, i8* %tmp.0) #5 + ret void +} + +; CHECK-LABEL: @test_01_after( +; CHECK: %tmp.1 = call i8* @llvm.noalias.decl.p0i8.p0a2p0i32.i32([2 x i32*]* %rp, i32 0, metadata !7) +; CHECK: %through_local_tmp = call i32* @llvm.provenance.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i32(i32* %tmp.6, i8* %tmp.1, i32** %arrayinit.element, i32** undef, i32 0, metadata !7), !tbaa !8, !noalias !5 +; CHECK: %tmp.10 = call i32* @llvm.provenance.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i32(i32* %tmp.9, i8* %tmp.1, i32** %.fca.0.gep, i32** undef, i32 0, metadata !7), !tbaa !8, !noalias !5 +; CHECK: %tmp.12 = call i32* @llvm.provenance.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i32(i32* %tmp.11, i8* null, i32** %cond, i32** undef, i32 0, metadata !2), !tbaa !8, !noalias !5 +; CHECK-NOT: llvm.noalias + +; CHECK: declare + +; Function Attrs: argmemonly nounwind +declare void @llvm.lifetime.start.p0i8(i64 immarg, i8* nocapture) #1 + +; Function Attrs: argmemonly nounwind +declare i8* @llvm.noalias.decl.p0i8.p0a2p0i32.i32([2 x i32*]*, i32, metadata) #1 + +; Function Attrs: argmemonly nounwind speculatable +declare i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i32(i32*, i8*, i32**, i32, metadata) #2 + +; Function Attrs: argmemonly nounwind +declare void @llvm.lifetime.end.p0i8(i64 immarg, i8* nocapture) #1 + +; Function Attrs: argmemonly nounwind +declare i8* @llvm.noalias.decl.p0i8.p0s_struct.FOOs.i32(%struct.FOO*, i32, metadata) #1 + +; Function Attrs: nounwind readnone +declare %struct.FOO* @llvm.noalias.copy.guard.p0s_struct.FOOs.p0i8(%struct.FOO*, i8*, metadata, metadata) #3 + +; Function Attrs: nounwind readnone speculatable +declare i32* @llvm.provenance.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i32(i32*, i8*, i32**, i32**, i32, metadata) #4 + + +attributes #0 = { nounwind "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "frame-pointer"="all" "less-precise-fpmad"="false" "min-legal-vector-width"="0" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" } +attributes #1 = { argmemonly nounwind } +attributes #2 = { argmemonly nounwind speculatable } +attributes #3 = { nounwind readnone } +attributes #4 = { nounwind readnone speculatable } +attributes #5 = { nounwind } + +!llvm.module.flags = !{!0} +!llvm.ident = !{!1} + +!0 = !{i32 1, !"wchar_size", i32 4} +!1 = !{!"clang"} +!2 = !{!3} +!3 = distinct !{!3, !4, !"test_01: unknown scope"} +!4 = distinct !{!4, !"test_01"} +!5 = !{!6, !3} +!6 = distinct !{!6, !4, !"test_01: rp"} +!7 = !{!6} +!8 = !{!9, !9, i64 0, i64 4} +!9 = !{!10, i64 4, !"any pointer"} +!10 = !{!11, i64 1, !"omnipotent char"} +!11 = !{!"Simple C/C++ TBAA"} +!12 = !{!13, !13, i64 0, i64 4} +!13 = !{!10, i64 4, !"int"} +!14 = !{!15} +!15 = distinct !{!15, !16, !"test_02: unknown scope"} +!16 = distinct !{!16, !"test_02"} +!17 = !{!18} +!18 = distinct !{!18, !16, !"test_02: foo"} +!19 = !{!20} +!20 = distinct !{!20, !16, !"test_02: tmp"} +!21 = !{!22, !23, !24} +!22 = !{i64 -1, i64 0} +!23 = !{i64 -1, i64 1} +!24 = !{i64 -1, i64 2} +!25 = !{!20, !18, !15}