[PATCH 19/27] [noalias] Introduce ConnectNoAliasDecl pass

[jeroen.dobbelaere]

Summary

This is part of the series started by D68484.

This pass connects llvm.noalias.decl to llvm.noalias, llvm.provenance.noalias
and llvm.noalias.copy.guard intrinsics when those are associated with the
unknown function scope and depend on the same alloca object. The connection
allows a refinement of the noalias information for those intrinsics, resulting
in better code.

Note: this is a stable point and tests should run fine with the patches applied up to this point.

[jeroen.dobbelaere]

Rebased

[jeroen.dobbelaere]

Rebased to c06b7e2ab5167ad031745a706204abed1aefd823 (July 14, 2020)

[jeroen.dobbelaere]

Rebased to 9fb46a452d4e5666828c95610ceac8dcd9e4ce16 (September 7, 2020)

[jeroen.dobbelaere]

Rebased to f8dbd61074176bae92ec360a093ac7bc498c9321.

llvm/include/llvm/InitializePasses.h

 void initializeCallGraphDOTPrinterPass(PassRegistry&);
 void initializeCallGraphPrinterLegacyPassPass(PassRegistry&);
 void initializeCallGraphViewerPass(PassRegistry&);
 void initializeCallGraphWrapperPassPass(PassRegistry&);
 void initializeCallSiteSplittingLegacyPassPass(PassRegistry&);
 void initializeCalledValuePropagationLegacyPassPass(PassRegistry &);
 void initializeCheckDebugMachineModulePass(PassRegistry &);
 void initializeCodeGenPreparePass(PassRegistry&);
+void initializeConnectNoAliasDeclLegacyPassPass(PassRegistry &);
 void initializeConstantHoistingLegacyPassPass(PassRegistry&);
 void initializeConstantMergeLegacyPassPass(PassRegistry&);
 void initializeConstraintEliminationPass(PassRegistry &);
 void initializeControlHeightReductionLegacyPassPass(PassRegistry&);
 void initializeCorrelatedValuePropagationPass(PassRegistry&);
 void initializeCostModelAnalysisPass(PassRegistry&);
 void initializeCrossDSOCFIPass(PassRegistry&);
 void initializeDAEPass(PassRegistry&);

llvm/include/llvm/Transforms/Scalar.h

 
 class Function;
 class FunctionPass;
 class ModulePass;
 class Pass;
 
 //===----------------------------------------------------------------------===//
 //
+// ConnectNoAliasDecl - Connects llvm.noalias.XX intrinsics to llvm.noalias.decl
+//
+FunctionPass *createConnectNoAliasDeclPass();
+
+//===----------------------------------------------------------------------===//
+//
 // AlignmentFromAssumptions - Use assume intrinsics to set load/store
 // alignments.
 //
 FunctionPass *createAlignmentFromAssumptionsPass();
 
 //===----------------------------------------------------------------------===//
 //
 // AnnotationRemarks - Emit remarks for !annotation metadata.

llvm/include/llvm/Transforms/Scalar/ConnectNoAliasDecl.h

+//===- 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<ConnectNoAliasDeclPass> {
+public:
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+
+  // Glue for old PM
+  bool runImpl(Function &F);
+};
+} // namespace llvm
+
+#endif // LLVM_TRANSFORMS_SCALAR_CONNECTNOALIASDECL_H

llvm/include/llvm/Transforms/Utils/Cloning.h

void cloneAndAdaptNoAliasScopes(ArrayRef<MDNode *> NoAliasDeclScopes,
                                 LLVMContext &Context, StringRef Ext);
 
 /// Clone the specified noalias decl scopes. Then adapt all instructions in the
 /// [IStart, IEnd] (IEnd included !) range to the cloned versions. 'Ext' will be
 /// added to the duplicate scope names.
 void cloneAndAdaptNoAliasScopes(ArrayRef<MDNode *> 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

llvm/lib/Passes/PassBuilder.cpp

 #include "llvm/Transforms/Instrumentation/SanitizerCoverage.h"
 #include "llvm/Transforms/Instrumentation/ThreadSanitizer.h"
 #include "llvm/Transforms/ObjCARC.h"
 #include "llvm/Transforms/Scalar/ADCE.h"
 #include "llvm/Transforms/Scalar/AlignmentFromAssumptions.h"
 #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"
 #include "llvm/Transforms/Scalar/DCE.h"
 #include "llvm/Transforms/Scalar/DeadStoreElimination.h"
 #include "llvm/Transforms/Scalar/DivRemPairs.h"
 #include "llvm/Transforms/Scalar/EarlyCSE.h"
 #include "llvm/Transforms/Scalar/Float2Int.h"

 
 // TODO: Investigate the cost/benefit of tail call elimination on debugging.
 FunctionPassManager
 PassBuilder::buildO1FunctionSimplificationPipeline(OptimizationLevel Level,
                                                    ThinOrFullLTOPhase Phase) {
 
   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());
 
   // Catch trivial redundancies
   FPM.addPass(EarlyCSEPass(true /* Enable mem-ssa. */));
 
   // Propagate and Convert noalias intrinsics as early as possible.
PassBuilder::buildO1FunctionSimplificationPipeline(OptimizationLevel Level,
   if (EnableLoopFlatten)
     FPM.addPass(LoopFlattenPass());
   // The loop passes in LPM2 (LoopFullUnrollPass) do not preserve MemorySSA.
   // *All* loop passes must preserve it, in order to be able to use it.
   FPM.addPass(createFunctionToLoopPassAdaptor(std::move(LPM2),
                                               /*UseMemorySSA=*/false,
                                               /*UseBlockFrequencyInfo=*/false));
 
+  FPM.addPass(ConnectNoAliasDeclPass()); // Do this before SROA
+
   // Delete small array after loop unroll.
   FPM.addPass(SROA());
 
   // Propagate and Convert noalias intrinsics as early as possible.
   // But do it after SROA and EarlyCSE !
   FPM.addPass(PropagateAndConvertNoAliasPass());
 
   // Specially optimize memory movement as it doesn't look like dataflow in SSA.
PassBuilder::buildFunctionSimplificationPipeline(OptimizationLevel Level,
 
   // The O1 pipeline has a separate pipeline creation function to simplify
   // construction readability.
   if (Level.getSpeedupLevel() == 1)
     return buildO1FunctionSimplificationPipeline(Level, Phase);
 
   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());
 
   // Catch trivial redundancies
   FPM.addPass(EarlyCSEPass(true /* Enable mem-ssa. */));
 
   // Propagate and Convert noalias intrinsics as early as possible.
if (EnableLoopFlatten)
     FPM.addPass(LoopFlattenPass());
   // The loop passes in LPM2 (LoopIdiomRecognizePass, IndVarSimplifyPass,
   // LoopDeletionPass and LoopFullUnrollPass) do not preserve MemorySSA.
   // *All* loop passes must preserve it, in order to be able to use it.
   FPM.addPass(createFunctionToLoopPassAdaptor(std::move(LPM2),
                                               /*UseMemorySSA=*/false,
                                               /*UseBlockFrequencyInfo=*/false));
 
+  FPM.addPass(ConnectNoAliasDeclPass()); // Do this before SROA
+
   // Delete small array after loop unroll.
   FPM.addPass(SROA());
 
   // Propagate and Convert noalias intrinsics as early as possible.
   // But do it after SROA and EarlyCSE !
   FPM.addPass(PropagateAndConvertNoAliasPass());
 
   // Eliminate redundancies.
PassBuilder::buildFunctionSimplificationPipeline(OptimizationLevel Level,
   FPM.addPass(BDCEPass());
 
   // Run instcombine after redundancy and dead bit elimination to exploit
   // opportunities opened up by them.
   FPM.addPass(InstCombinePass());
   invokePeepholeEPCallbacks(FPM, Level);
 
   // Late noalias intrinsics cleanup
+  FPM.addPass(ConnectNoAliasDeclPass());
   FPM.addPass(PropagateAndConvertNoAliasPass());
 
   // Re-consider control flow based optimizations after redundancy elimination,
   // redo DCE, etc.
   FPM.addPass(JumpThreadingPass());
   FPM.addPass(CorrelatedValuePropagationPass());
 
   // Finally, do an expensive DCE pass to catch all the dead code exposed by
if (!IsCS && !DisablePreInliner) {
     // when not optimzing for size. This should probably be lowered after
     // performance testing.
     // FIXME: this comment is cargo culted from the old pass manager, revisit).
     IP.HintThreshold = Level.isOptimizingForSize() ? PreInlineThreshold : 325;
     ModuleInlinerWrapperPass MIWP(IP);
     CGSCCPassManager &CGPipeline = MIWP.getPM();
 
     FunctionPassManager FPM;
+    FPM.addPass(ConnectNoAliasDeclPass()); // Do this before SROA
+
     FPM.addPass(SROA());
     FPM.addPass(EarlyCSEPass());    // Catch trivial redundancies.
 
     // Propagate and Convert as early as possible.
     // But do it after SROA and EarlyCSE !
     FPM.addPass(PropagateAndConvertNoAliasPass());
 
     FPM.addPass(SimplifyCFGPass()); // Merge & remove basic blocks.
PassBuilder::buildModuleSimplificationPipeline(OptimizationLevel Level,
 
   // Create an early function pass manager to cleanup the output of the
   // frontend.
   FunctionPassManager EarlyFPM;
   // Lower llvm.expect to metadata before attempting transforms.
   // 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());
 
   // Propagate and Convert as early as possible.
   // But do it after SROA and EarlyCSE !
   EarlyFPM.addPass(PropagateAndConvertNoAliasPass());
 
   if (PTO.Coroutines)
if (PGOOpt->CSAction == PGOOptions::CSIRInstr)
                         /* IsCS */ true, PGOOpt->CSProfileGenFile,
                         PGOOpt->ProfileRemappingFile);
     else if (PGOOpt->CSAction == PGOOptions::CSIRUse)
       addPGOInstrPasses(MPM, Level, /* RunProfileGen */ false,
                         /* IsCS */ true, PGOOpt->ProfileFile,
                         PGOOpt->ProfileRemappingFile);
   }
 
+  FPM.addPass(ConnectNoAliasDeclPass()); // Do this before SROA
+
   // Break up allocas
   FPM.addPass(SROA());
 
   // Propagate and Convert as early as possible.
   // But do it after SROA and EarlyCSE !
   FPM.addPass(PropagateAndConvertNoAliasPass());
 
   // LTO provides additional opportunities for tailcall elimination due to

llvm/lib/Passes/PassRegistry.def

 FUNCTION_PASS("assume-builder", AssumeBuilderPass())
 FUNCTION_PASS("assume-simplify", AssumeSimplifyPass())
 FUNCTION_PASS("alignment-from-assumptions", AlignmentFromAssumptionsPass())
 FUNCTION_PASS("annotation-remarks", AnnotationRemarksPass())
 FUNCTION_PASS("bdce", BDCEPass())
 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())
 FUNCTION_PASS("chr", ControlHeightReductionPass())
 FUNCTION_PASS("coro-early", CoroEarlyPass())
 FUNCTION_PASS("coro-elide", CoroElidePass())
 FUNCTION_PASS("coro-cleanup", CoroCleanupPass())
 FUNCTION_PASS("correlated-propagation", CorrelatedValuePropagationPass())

llvm/lib/Transforms/IPO/PassManagerBuilder.cpp

void PassManagerBuilder::populateFunctionPassManager(
   if (OptLevel == 0) return;
 
   addInitialAliasAnalysisPasses(FPM);
 
   // Lower llvm.expect to metadata before attempting transforms.
   // 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());
 
   // Propagate and Convert as early as possible.
   // But do it after SROA!
   FPM.add(createPropagateAndConvertNoAliasPass());
   if (VerifyOutput)
     FPM.add(createVerifierPass());
if (OptLevel > 0 && !DisablePreInliner && PGOSampleUse.empty() && !IsCS) {
     // when not optimzing for size. This should probably be lowered after
     // performance testing.
     // Use PreInlineThreshold for both -Os and -Oz. Not running preinliner makes
     // the instrumented binary unusably large. Even if PreInlineThreshold is not
     // correct thresold for -Oz, it is better than not running preinliner.
     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
 
     // Propagate and Convert as early as possible.
     // But do it after SROA and EarlyCSE !
     MPM.add(createPropagateAndConvertNoAliasPass());
     if (VerifyOutput)
       MPM.add(createVerifierPass());
void PassManagerBuilder::addPGOInstrPasses(legacy::PassManagerBase &MPM,
   // for imported functions. We don't run this at -O0.
   if (OptLevel > 0 && !IsCS)
     MPM.add(
         createPGOIndirectCallPromotionLegacyPass(false, !PGOSampleUse.empty()));
 }
 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());
   MPM.add(createEarlyCSEPass(true /* Enable mem-ssa. */)); // Catch trivial redundancies
   if (EnableKnowledgeRetention)
     MPM.add(createAssumeSimplifyPass());
 
   // Propagate and Convert as early as possible.
if (EnableLoopInterchange)
     MPM.add(createLoopInterchangePass()); // Interchange loops
 
   // Unroll small loops and perform peeling.
   MPM.add(createSimpleLoopUnrollPass(OptLevel, DisableUnrollLoops,
                                      ForgetAllSCEVInLoopUnroll));
   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());
 
   // Propagate and Convert as early as possible.
   // But do it after SROA!
   MPM.add(createPropagateAndConvertNoAliasPass());
   if (VerifyOutput)
     MPM.add(createVerifierPass());
void PassManagerBuilder::addFunctionSimplificationPasses(
   // computations, and then ADCE will run later to exploit any new DCE
   // opportunities that creates).
   MPM.add(createBitTrackingDCEPass());        // Delete dead bit computations
 
   // Run instcombine after redundancy elimination to exploit opportunities
   // 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());
   if (VerifyOutput)
     MPM.add(createVerifierPass());
 
   if (OptLevel > 1) {
     MPM.add(createJumpThreadingPass());         // Thread jumps
void PassManagerBuilder::addLTOOptimizationPasses(legacy::PassManagerBase &PM) {
   // transform it to pass arguments by value instead of by reference.
   PM.add(createArgumentPromotionPass());
 
   // The IPO passes may leave cruft around.  Clean up after them.
   PM.add(createInstructionCombiningPass());
   addExtensionsToPM(EP_Peephole, PM);
   PM.add(createJumpThreadingPass(/*FreezeSelectCond*/ true));
 
+  PM.add(createConnectNoAliasDeclPass()); // Do this before SROA
+
   // Break up allocas
   PM.add(createSROAPass());
 
   // Propagate and Convert as early as possible.
   // But do it after SROA!
   PM.add(createPropagateAndConvertNoAliasPass());
   if (VerifyOutput)
     PM.add(createVerifierPass());

llvm/lib/Transforms/Scalar/CMakeLists.txt

 add_llvm_component_library(LLVMScalarOpts
   ADCE.cpp
   AlignmentFromAssumptions.cpp
   AnnotationRemarks.cpp
   BDCE.cpp
   CallSiteSplitting.cpp
+  ConnectNoAliasDecl.cpp
   ConstantHoisting.cpp
   ConstraintElimination.cpp
   CorrelatedValuePropagation.cpp
   DCE.cpp
   DeadStoreElimination.cpp
   DivRemPairs.cpp
   EarlyCSE.cpp
   FlattenCFGPass.cpp

llvm/lib/Transforms/Scalar/ConnectNoAliasDecl.cpp

+//===- 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<GlobalsAAWrapperPass>();
+    AU.addPreserved<CallGraphWrapperPass>(); // FIXME: not sure this is
+                                             // valid. It ensures the same pass
+                                             // order as if this pass was not
+                                             // there
+    AU.addPreserved<DominatorTreeWrapperPass>();
+    AU.addRequiredTransitive<DominatorTreeWrapperPass>();
+    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<GlobalsAA>();
+  //?? PA.preserve<CallGraphWrapperPass>(); // FIXME: not sure this is valid,
+  // see above
+
+  return PA;
+}
+
+FunctionPass *createConnectNoAliasDeclPass() {
+  return new ConnectNoAliasDeclLegacyPass();
+}
+} // namespace llvm

llvm/lib/Transforms/Scalar/Scalar.cpp

 /// initializeScalarOptsPasses - Initialize all passes linked into the
 /// ScalarOpts library.
 void llvm::initializeScalarOpts(PassRegistry &Registry) {
   initializeADCELegacyPassPass(Registry);
   initializeAnnotationRemarksLegacyPass(Registry);
   initializeBDCELegacyPassPass(Registry);
   initializeAlignmentFromAssumptionsPass(Registry);
   initializeCallSiteSplittingLegacyPassPass(Registry);
+  initializeConnectNoAliasDeclLegacyPassPass(Registry);
   initializeConstantHoistingLegacyPassPass(Registry);
   initializeConstraintEliminationPass(Registry);
   initializeCorrelatedValuePropagationPass(Registry);
   initializeDCELegacyPassPass(Registry);
   initializeDivRemPairsLegacyPassPass(Registry);
   initializeScalarizerLegacyPassPass(Registry);
   initializeDSELegacyPassPass(Registry);
   initializeGuardWideningLegacyPassPass(Registry);

llvm/test/CodeGen/AMDGPU/opt-pipeline.ll

 ; GCN-O1-NEXT:     Replace builtin math calls with that native versions.
 ; GCN-O1-NEXT:     Dominator Tree Construction
 ; GCN-O1-NEXT:     Basic Alias Analysis (stateless AA impl)
 ; GCN-O1-NEXT:     Function Alias Analysis Results
 ; GCN-O1-NEXT:     Simplify well-known AMD library calls
 ; 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
 
 ; GCN-O1-NEXT: Pass Arguments:
 ; GCN-O1-NEXT: Target Library Information
 ; GCN-O1-NEXT: Target Transform Information
 ; GCN-O1-NEXT: Target Pass Configuration

 ; GCN-O1-NEXT:         Propagate and Convert Noalias intrinsics
 ; GCN-O1-NEXT:       Deduce function attributes
 ; GCN-O1-NEXT:       FunctionPass Manager
 ; GCN-O1-NEXT:         Infer address spaces
 ; GCN-O1-NEXT:     AMDGPU Kernel Attributes
 ; 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
 ; GCN-O1-NEXT:       Memory SSA
 ; GCN-O1-NEXT:       Early CSE w/ MemorySSA
 ; GCN-O1-NEXT:       Propagate and Convert Noalias intrinsics
 ; GCN-O1-NEXT:       Simplify the CFG
 ; GCN-O1-NEXT:       Dominator Tree Construction

 ; GCN-O1-NEXT:       LCSSA Verifier
 ; GCN-O1-NEXT:       Loop-Closed SSA Form Pass
 ; GCN-O1-NEXT:       Scalar Evolution Analysis
 ; GCN-O1-NEXT:       Loop Pass Manager
 ; GCN-O1-NEXT:         Recognize loop idioms
 ; 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
 ; GCN-O1-NEXT:       Demanded bits analysis
 ; GCN-O1-NEXT:       Bit-Tracking Dead Code Elimination
 ; GCN-O1-NEXT:       Basic Alias Analysis (stateless AA impl)
 ; GCN-O1-NEXT:       Function Alias Analysis Results
 ; GCN-O1-NEXT:       Natural Loop Information
 ; GCN-O1-NEXT:       Lazy Branch Probability Analysis
 ; 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
 ; GCN-O1-NEXT:       Basic Alias Analysis (stateless AA impl)
 ; GCN-O1-NEXT:       Function Alias Analysis Results
 ; GCN-O1-NEXT:       Memory SSA
 ; GCN-O1-NEXT:       MemCpy Optimization
 ; GCN-O1-NEXT:       Simplify the CFG

 ; GCN-O2-NEXT:     Replace builtin math calls with that native versions.
 ; GCN-O2-NEXT:     Dominator Tree Construction
 ; GCN-O2-NEXT:     Basic Alias Analysis (stateless AA impl)
 ; GCN-O2-NEXT:     Function Alias Analysis Results
 ; GCN-O2-NEXT:     Simplify well-known AMD library calls
 ; 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
 
 ; GCN-O2-NEXT: Pass Arguments:
 ; GCN-O2-NEXT: Target Library Information
 ; GCN-O2-NEXT: Target Transform Information
 ; GCN-O2-NEXT: Target Pass Configuration

 ; GCN-O2-NEXT:       OpenMP specific optimizations
 ; GCN-O2-NEXT:       Deduce function attributes
 ; GCN-O2-NEXT:       FunctionPass Manager
 ; GCN-O2-NEXT:         Infer address spaces
 ; GCN-O2-NEXT:     AMDGPU Kernel Attributes
 ; 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
 ; GCN-O2-NEXT:       Memory SSA
 ; GCN-O2-NEXT:       Early CSE w/ MemorySSA
 ; GCN-O2-NEXT:       Propagate and Convert Noalias intrinsics
 ; GCN-O2-NEXT:       Speculatively execute instructions if target has divergent branches
 ; GCN-O2-NEXT:       Basic Alias Analysis (stateless AA impl)

 ; GCN-O2-NEXT:       LCSSA Verifier
 ; GCN-O2-NEXT:       Loop-Closed SSA Form Pass
 ; GCN-O2-NEXT:       Scalar Evolution Analysis
 ; GCN-O2-NEXT:       Loop Pass Manager
 ; GCN-O2-NEXT:         Recognize loop idioms
 ; 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)
 ; GCN-O2-NEXT:       Function Alias Analysis Results
 ; GCN-O2-NEXT:       MergedLoadStoreMotion
 ; GCN-O2-NEXT:       Natural Loop Information
 ; GCN-O2-NEXT:       Phi Values Analysis
 ; GCN-O2-NEXT:       Function Alias Analysis Results
 ; GCN-O2-NEXT:       Memory Dependence Analysis
 ; GCN-O2-NEXT:       Lazy Branch Probability Analysis
 ; GCN-O2-NEXT:       Lazy Block Frequency Analysis
 ; GCN-O2-NEXT:       Optimization Remark Emitter
 ; GCN-O2-NEXT:       Global Value Numbering
 ; GCN-O2-NEXT:       Sparse Conditional Constant Propagation
 ; GCN-O2-NEXT:       Demanded bits analysis
 ; GCN-O2-NEXT:       Bit-Tracking Dead Code Elimination
 ; GCN-O2-NEXT:       Basic Alias Analysis (stateless AA impl)
 ; GCN-O2-NEXT:       Function Alias Analysis Results
 ; GCN-O2-NEXT:       Lazy Branch Probability Analysis
 ; 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
 ; GCN-O2-NEXT:       Lazy Value Information Analysis
 ; GCN-O2-NEXT:       Jump Threading
 ; GCN-O2-NEXT:       Value Propagation
 ; GCN-O2-NEXT:       Post-Dominator Tree Construction
 ; GCN-O2-NEXT:       Aggressive Dead Code Elimination

 ; GCN-O3-NEXT:     Replace builtin math calls with that native versions.
 ; GCN-O3-NEXT:     Dominator Tree Construction
 ; GCN-O3-NEXT:     Basic Alias Analysis (stateless AA impl)
 ; GCN-O3-NEXT:     Function Alias Analysis Results
 ; GCN-O3-NEXT:     Simplify well-known AMD library calls
 ; 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
 
 ; GCN-O3-NEXT: Pass Arguments:
 ; GCN-O3-NEXT: Target Library Information
 ; GCN-O3-NEXT: Target Transform Information
 ; GCN-O3-NEXT: Target Pass Configuration

 ; GCN-O3-NEXT:       Deduce function attributes
 ; GCN-O3-NEXT:       Promote 'by reference' arguments to scalars
 ; GCN-O3-NEXT:       FunctionPass Manager
 ; GCN-O3-NEXT:         Infer address spaces
 ; GCN-O3-NEXT:     AMDGPU Kernel Attributes
 ; 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
 ; GCN-O3-NEXT:       Memory SSA
 ; GCN-O3-NEXT:       Early CSE w/ MemorySSA
 ; GCN-O3-NEXT:       Propagate and Convert Noalias intrinsics
 ; GCN-O3-NEXT:       Speculatively execute instructions if target has divergent branches
 ; GCN-O3-NEXT:       Basic Alias Analysis (stateless AA impl)

 ; GCN-O3-NEXT:       LCSSA Verifier
 ; GCN-O3-NEXT:       Loop-Closed SSA Form Pass
 ; GCN-O3-NEXT:       Scalar Evolution Analysis
 ; GCN-O3-NEXT:       Loop Pass Manager
 ; GCN-O3-NEXT:         Recognize loop idioms
 ; 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)
 ; GCN-O3-NEXT:       Function Alias Analysis Results
 ; GCN-O3-NEXT:       MergedLoadStoreMotion
 ; GCN-O3-NEXT:       Natural Loop Information
 ; GCN-O3-NEXT:       Phi Values Analysis
 ; GCN-O3-NEXT:       Function Alias Analysis Results
 ; GCN-O3-NEXT:       Memory Dependence Analysis
 ; GCN-O3-NEXT:       Lazy Branch Probability Analysis
 ; GCN-O3-NEXT:       Lazy Block Frequency Analysis
 ; GCN-O3-NEXT:       Optimization Remark Emitter
 ; GCN-O3-NEXT:       Global Value Numbering
 ; GCN-O3-NEXT:       Sparse Conditional Constant Propagation
 ; GCN-O3-NEXT:       Demanded bits analysis
 ; GCN-O3-NEXT:       Bit-Tracking Dead Code Elimination
 ; GCN-O3-NEXT:       Basic Alias Analysis (stateless AA impl)
 ; GCN-O3-NEXT:       Function Alias Analysis Results
 ; GCN-O3-NEXT:       Lazy Branch Probability Analysis
 ; 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
 ; GCN-O3-NEXT:       Lazy Value Information Analysis
 ; GCN-O3-NEXT:       Jump Threading
 ; GCN-O3-NEXT:       Value Propagation
 ; GCN-O3-NEXT:       Post-Dominator Tree Construction
 ; GCN-O3-NEXT:       Aggressive Dead Code Elimination

llvm/test/Other/new-pm-defaults.ll

 ; CHECK-O-NEXT: Running pass: InferFunctionAttrsPass
 ; CHECK-O-NEXT: Running analysis: InnerAnalysisManagerProxy
 ; CHECK-O-NEXT: Running analysis: TargetLibraryAnalysis
 ; CHECK-O-NEXT: Running analysis: PreservedCFGCheckerAnalysis on foo
 ; CHECK-O-NEXT: Running pass: LowerExpectIntrinsicPass
 ; 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
 ; CHECK-O-NEXT: Running analysis: TargetLibraryAnalysis
 ; CHECK-O-NEXT: Running pass: PropagateAndConvertNoAliasPass
 ; CHECK-O3-NEXT: Running pass: CallSiteSplittingPass
 ; CHECK-O2-NEXT: Running pass: OpenMPOptPass
 ; CHECK-O3-NEXT: Running pass: OpenMPOptPass

 ; CHECK-O-NEXT: Running pass: InlinerPass
 ; CHECK-O-NEXT: Running pass: InlinerPass
 ; CHECK-O-NEXT: Running pass: PostOrderFunctionAttrsPass
 ; CHECK-O-NEXT: Running analysis: AAManager
 ; CHECK-O3-NEXT: Running pass: ArgumentPromotionPass
 ; 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
 ; CHECK-O-NEXT: Running pass: PropagateAndConvertNoAliasPass
 ; CHECK-O23SZ-NEXT: Running pass: SpeculativeExecutionPass
 ; CHECK-O23SZ-NEXT: Running pass: JumpThreadingPass
 ; CHECK-O23SZ-NEXT: Running analysis: LazyValueAnalysis
 ; CHECK-O23SZ-NEXT: Running pass: CorrelatedValuePropagationPass

 ; CHECK-O-NEXT: Running pass: LoopSimplifyPass
 ; CHECK-O-NEXT: Running pass: LCSSAPass
 ; CHECK-O-NEXT: Running pass: LoopIdiomRecognizePass
 ; CHECK-O-NEXT: Running pass: IndVarSimplifyPass
 ; CHECK-EP-LOOP-LATE-NEXT: Running pass: NoOpLoopPass
 ; 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
 ; CHECK-O23SZ-NEXT: Running pass: GVN
 ; CHECK-O23SZ-NEXT: Running analysis: MemoryDependenceAnalysis
 ; CHECK-O23SZ-NEXT: Running analysis: PhiValuesAnalysis
 ; CHECK-O1-NEXT: Running pass: MemCpyOptPass
 ; CHECK-O-NEXT: Running pass: SCCPPass
 ; CHECK-O-NEXT: Running pass: BDCEPass
 ; 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
 ; CHECK-O23SZ-NEXT: Running pass: CorrelatedValuePropagationPass
 ; CHECK-O23SZ-NEXT: Invalidating analysis: LazyValueAnalysis
 ; CHECK-O-NEXT: Running pass: ADCEPass
 ; CHECK-O-NEXT: Running analysis: PostDominatorTreeAnalysis
 ; CHECK-O23SZ-NEXT: Running pass: MemCpyOptPass

llvm/test/Other/new-pm-lto-defaults.ll

 ; CHECK-O23SZ-NEXT: Running pass: InlinerPass
 ; CHECK-O23SZ-NEXT: Running pass: InlinerPass
 ; CHECK-O23SZ-NEXT: Running pass: GlobalOptPass
 ; CHECK-O23SZ-NEXT: Running pass: GlobalDCEPass
 ; CHECK-O23SZ-NEXT: Running pass: InstCombinePass
 ; 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
 ; CHECK-O23SZ-NEXT: Running pass: PostOrderFunctionAttrsPass on (foo)
 ; CHECK-O23SZ-NEXT: Running pass: RequireAnalysisPass<{{.*}}GlobalsAA
 ; CHECK-O23SZ-NEXT: Running analysis: GlobalsAA on [module]
 ; CHECK-O23SZ-NEXT: Running pass: InvalidateAnalysisPass<{{.*}}AAManager
 ; CHECK-O23SZ-NEXT: Invalidating analysis: AAManager on foo

llvm/test/Other/new-pm-pgo-preinline.ll

 ; RUN: opt -disable-verify -debug-pass-manager -pgo-kind=pgo-instr-gen-pipeline -passes='default<Os>' -S %s 2>&1 | FileCheck %s --check-prefixes=CHECK-Osz
 ; RUN: opt -disable-verify -debug-pass-manager -pgo-kind=pgo-instr-gen-pipeline -passes='default<Oz>' -S %s 2>&1 | FileCheck %s --check-prefixes=CHECK-Osz
 
 ; CHECK-Osz: Running pass: ModuleInlinerWrapperPass
 ; CHECK-Osz-NEXT: Running analysis: InlineAdvisorAnalysis
 ; CHECK-Osz-NEXT: Running analysis: InnerAnalysisManagerProxy
 ; CHECK-Osz-NEXT: Running analysis: LazyCallGraphAnalysis
 ; CHECK-Osz-NEXT: Running analysis: FunctionAnalysisManagerCGSCCProxy on (foo)
 ; 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
 ; CHECK-Osz-NEXT: Running pass: SimplifyCFGPass on foo
 ; CHECK-Osz-NEXT: Running pass: InstCombinePass on foo
 ; CHECK-Osz-NEXT: Running pass: GlobalDCEPass
 ; CHECK-Osz-NEXT: Running pass: PGOInstrumentationGen
 
 define void @foo() {
   ret void
 }

llvm/test/Other/new-pm-thinlto-defaults.ll

 ; CHECK-POSTLINK-O-NEXT: Running analysis: OptimizationRemarkEmitterAnalysis
 ; CHECK-O-NEXT: Running pass: InferFunctionAttrsPass
 ; CHECK-PRELINK-O-NODIS-NEXT: Running analysis: InnerAnalysisManagerProxy
 ; CHECK-O-NEXT: Running analysis: TargetLibraryAnalysis
 ; CHECK-O-NEXT: Running pass: LowerExpectIntrinsicPass
 ; 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
 ; CHECK-O-NEXT: Running analysis: TargetLibraryAnalysis
 ; CHECK-O-NEXT: Running pass: PropagateAndConvertNoAliasPass
 ; CHECK-O3-NEXT: Running pass: CallSiteSplittingPass
 ; CHECK-O2-NEXT: Running pass: OpenMPOptPass
 ; CHECK-O3-NEXT: Running pass: OpenMPOptPass

 ; CHECK-O-NEXT: Running pass: DevirtSCCRepeatedPass
 ; CHECK-O-NEXT: Running pass: InlinerPass
 ; CHECK-O-NEXT: Running pass: InlinerPass
 ; CHECK-O-NEXT: Running pass: PostOrderFunctionAttrsPass
 ; CHECK-O-NEXT: Running analysis: AAManager
 ; 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
 ; CHECK-O-NEXT: Running pass: PropagateAndConvertNoAliasPass
 ; CHECK-O23SZ-NEXT: Running pass: SpeculativeExecutionPass
 ; CHECK-O23SZ-NEXT: Running pass: JumpThreadingPass
 ; CHECK-O23SZ-NEXT: Running analysis: LazyValueAnalysis
 ; CHECK-O23SZ-NEXT: Running pass: CorrelatedValuePropagationPass

 ; CHECK-O-NEXT: Running pass: SimplifyCFGPass
 ; CHECK-O-NEXT: Running pass: InstCombinePass
 ; CHECK-O-NEXT: Running pass: LoopSimplifyPass
 ; CHECK-O-NEXT: Running pass: LCSSAPass
 ; CHECK-O-NEXT: Running pass: LoopIdiomRecognizePass
 ; 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
 ; CHECK-Os-NEXT: Running pass: GVN
 ; CHECK-Os-NEXT: Running analysis: MemoryDependenceAnalysis
 ; CHECK-Os-NEXT: Running analysis: PhiValuesAnalysis
 ; CHECK-Oz-NEXT: Running pass: MergedLoadStoreMotionPass
 ; CHECK-Oz-NEXT: Running pass: GVN
 ; CHECK-Oz-NEXT: Running analysis: MemoryDependenceAnalysis
 ; CHECK-Oz-NEXT: Running analysis: PhiValuesAnalysis
 ; CHECK-O2-NEXT: Running pass: MergedLoadStoreMotionPass
 ; CHECK-O2-NEXT: Running pass: GVN
 ; CHECK-O2-NEXT: Running analysis: MemoryDependenceAnalysis
 ; CHECK-O2-NEXT: Running analysis: PhiValuesAnalysis
 ; CHECK-O3-NEXT: Running pass: MergedLoadStoreMotionPass
 ; CHECK-O3-NEXT: Running pass: GVN
 ; CHECK-O3-NEXT: Running analysis: MemoryDependenceAnalysis
 ; CHECK-O3-NEXT: Running analysis: PhiValuesAnalysis
 ; CHECK-O1-NEXT: Running pass: MemCpyOptPass
 ; CHECK-O-NEXT: Running pass: SCCPPass
 ; 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
 ; CHECK-O23SZ-NEXT: Running pass: CorrelatedValuePropagationPass
 ; CHECK-O23SZ-NEXT: Invalidating analysis: LazyValueAnalysis
 ; CHECK-O-NEXT: Running pass: ADCEPass
 ; CHECK-O-NEXT: Running analysis: PostDominatorTreeAnalysis
 ; CHECK-O23SZ-NEXT: Running pass: MemCpyOptPass

llvm/test/Other/new-pm-thinlto-postlink-pgo-defaults.ll

 ; CHECK-O-NEXT: Running analysis: InnerAnalysisManagerProxy
 ; CHECK-O-NEXT: Running analysis: OptimizationRemarkEmitterAnalysis
 ; CHECK-O-NEXT: Running pass: InferFunctionAttrsPass
 ; CHECK-O-NEXT: Running analysis: TargetLibraryAnalysis
 ; CHECK-O-NEXT: Running pass: LowerExpectIntrinsicPass
 ; 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
 ; CHECK-O-NEXT: Running analysis: TargetLibraryAnalysis
 ; CHECK-O-NEXT: Running pass: PropagateAndConvertNoAliasPass
 ; CHECK-O3-NEXT: Running pass: CallSiteSplittingPass
 ; CHECK-O2-NEXT: Running pass: OpenMPOptPass
 ; CHECK-O3-NEXT: Running pass: OpenMPOptPass

 ; CHECK-O-NEXT: Running pass: DevirtSCCRepeatedPass
 ; CHECK-O-NEXT: Running pass: InlinerPass
 ; CHECK-O-NEXT: Running pass: InlinerPass
 ; CHECK-O-NEXT: Running pass: PostOrderFunctionAttrsPass
 ; CHECK-O-NEXT: Running analysis: AAManager
 ; 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
 ; CHECK-O-NEXT: Running pass: PropagateAndConvertNoAliasPass
 ; CHECK-O23SZ-NEXT: Running pass: SpeculativeExecutionPass
 ; CHECK-O23SZ-NEXT: Running pass: JumpThreadingPass
 ; CHECK-O23SZ-NEXT: Running analysis: LazyValueAnalysis
 ; CHECK-O23SZ-NEXT: Running pass: CorrelatedValuePropagationPass

 ; CHECK-O-NEXT: Running pass: SimplifyCFGPass
 ; CHECK-O-NEXT: Running pass: InstCombinePass
 ; CHECK-O-NEXT: Running pass: LoopSimplifyPass
 ; CHECK-O-NEXT: Running pass: LCSSAPass
 ; CHECK-O-NEXT: Running pass: LoopIdiomRecognizePass
 ; 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
 ; CHECK-Os-NEXT: Running pass: GVN
 ; CHECK-Os-NEXT: Running analysis: MemoryDependenceAnalysis
 ; CHECK-Os-NEXT: Running analysis: PhiValuesAnalysis
 ; CHECK-Oz-NEXT: Running pass: MergedLoadStoreMotionPass
 ; CHECK-Oz-NEXT: Running pass: GVN
 ; CHECK-Oz-NEXT: Running analysis: MemoryDependenceAnalysis
 ; CHECK-Oz-NEXT: Running analysis: PhiValuesAnalysis
 ; CHECK-O2-NEXT: Running pass: MergedLoadStoreMotionPass
 ; CHECK-O2-NEXT: Running pass: GVN
 ; CHECK-O2-NEXT: Running analysis: MemoryDependenceAnalysis
 ; CHECK-O2-NEXT: Running analysis: PhiValuesAnalysis
 ; CHECK-O3-NEXT: Running pass: MergedLoadStoreMotionPass
 ; CHECK-O3-NEXT: Running pass: GVN
 ; CHECK-O3-NEXT: Running analysis: MemoryDependenceAnalysis
 ; CHECK-O3-NEXT: Running analysis: PhiValuesAnalysis
 ; CHECK-O1-NEXT: Running pass: MemCpyOptPass
 ; CHECK-O-NEXT: Running pass: SCCPPass
 ; 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
 ; CHECK-O23SZ-NEXT: Running pass: CorrelatedValuePropagationPass
 ; CHECK-O23SZ-NEXT: Invalidating analysis: LazyValueAnalysis
 ; CHECK-O-NEXT: Running pass: ADCEPass
 ; CHECK-O23SZ-NEXT: Running pass: MemCpyOptPass
 ; CHECK-O23SZ-NEXT: Running pass: DSEPass

llvm/test/Other/new-pm-thinlto-postlink-samplepgo-defaults.ll

 ; CHECK-EP-PIPELINE-START-NEXT: Running pass: NoOpModulePass
 ; CHECK-O-NEXT: Running pass: InferFunctionAttrsPass
 ; CHECK-O-NEXT: Running analysis: InnerAnalysisManagerProxy
 ; CHECK-O-NEXT: Running analysis: TargetLibraryAnalysis
 ; CHECK-O-NEXT: Running pass: LowerExpectIntrinsicPass
 ; 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
 ; CHECK-O-NEXT: Running analysis: TargetLibraryAnalysis
 ; CHECK-O-NEXT: Running pass: PropagateAndConvertNoAliasPass
 ; CHECK-O3-NEXT: Running pass: CallSiteSplittingPass
 ; CHECK-O-NEXT: Running pass: InstCombinePass on foo
 ; CHECK-O-NEXT: Running analysis: OptimizationRemarkEmitterAnalysis on foo

 ; CHECK-O-NEXT: Running pass: DevirtSCCRepeatedPass
 ; CHECK-O-NEXT: Running pass: InlinerPass
 ; CHECK-O-NEXT: Running pass: InlinerPass
 ; CHECK-O-NEXT: Running pass: PostOrderFunctionAttrsPass
 ; CHECK-O-NEXT: Running analysis: AAManager
 ; 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
 ; CHECK-O-NEXT: Running pass: PropagateAndConvertNoAliasPass
 ; CHECK-O23SZ-NEXT: Running pass: SpeculativeExecutionPass
 ; CHECK-O23SZ-NEXT: Running pass: JumpThreadingPass
 ; CHECK-O23SZ-NEXT: Running analysis: LazyValueAnalysis
 ; CHECK-O23SZ-NEXT: Running pass: CorrelatedValuePropagationPass

 ; CHECK-O-NEXT: Running pass: SimplifyCFGPass
 ; CHECK-O-NEXT: Running pass: InstCombinePass
 ; CHECK-O-NEXT: Running pass: LoopSimplifyPass
 ; CHECK-O-NEXT: Running pass: LCSSAPass
 ; CHECK-O-NEXT: Running pass: LoopIdiomRecognizePass
 ; 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
 ; CHECK-Os-NEXT: Running pass: GVN
 ; CHECK-Os-NEXT: Running analysis: MemoryDependenceAnalysis
 ; CHECK-Os-NEXT: Running analysis: PhiValuesAnalysis
 ; CHECK-Oz-NEXT: Running pass: MergedLoadStoreMotionPass
 ; CHECK-Oz-NEXT: Running pass: GVN
 ; CHECK-Oz-NEXT: Running analysis: MemoryDependenceAnalysis
 ; CHECK-Oz-NEXT: Running analysis: PhiValuesAnalysis
 ; CHECK-O2-NEXT: Running pass: MergedLoadStoreMotionPass
 ; CHECK-O2-NEXT: Running pass: GVN
 ; CHECK-O2-NEXT: Running analysis: MemoryDependenceAnalysis
 ; CHECK-O2-NEXT: Running analysis: PhiValuesAnalysis
 ; CHECK-O3-NEXT: Running pass: MergedLoadStoreMotionPass
 ; CHECK-O3-NEXT: Running pass: GVN
 ; CHECK-O3-NEXT: Running analysis: MemoryDependenceAnalysis
 ; CHECK-O3-NEXT: Running analysis: PhiValuesAnalysis
 ; CHECK-O1-NEXT: Running pass: MemCpyOptPass
 ; CHECK-O-NEXT: Running pass: SCCPPass
 ; 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
 ; CHECK-O23SZ-NEXT: Running pass: CorrelatedValuePropagationPass
 ; CHECK-O23SZ-NEXT: Invalidating analysis: LazyValueAnalysis
 ; CHECK-O-NEXT: Running pass: ADCEPass
 ; CHECK-O23SZ-NEXT: Running pass: MemCpyOptPass
 ; CHECK-O23SZ-NEXT: Running pass: DSEPass

llvm/test/Other/new-pm-thinlto-prelink-pgo-defaults.ll

 ; CHECK-EP-PIPELINE-START-NEXT: Running pass: NoOpModulePass
 ; CHECK-O-NEXT: Running pass: InferFunctionAttrsPass
 ; CHECK-O-NEXT: Running analysis: InnerAnalysisManagerProxy
 ; CHECK-O-NEXT: Running analysis: TargetLibraryAnalysis
 ; CHECK-O-NEXT: Running pass: LowerExpectIntrinsicPass
 ; 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
 ; CHECK-O-NEXT: Running analysis: TargetLibraryAnalysis
 ; CHECK-O-NEXT: Running pass: PropagateAndConvertNoAliasPass
 ; CHECK-O3-NEXT: Running pass: CallSiteSplittingPass
 ; CHECK-O2-NEXT: Running pass: OpenMPOptPass
 ; CHECK-O3-NEXT: Running pass: OpenMPOptPass

 ; CHECK-O123SZ-NEXT: Running pass: ModuleInlinerWrapperPass
 ; CHECK-O123SZ-NEXT: Running analysis: InlineAdvisorAnalysis
 ; CHECK-O123SZ-NEXT: Running analysis: InnerAnalysisManagerProxy
 ; CHECK-O123SZ-NEXT: Running analysis: LazyCallGraphAnalysis
 ; CHECK-O123SZ-NEXT: Running analysis: FunctionAnalysisManagerCGSCCProxy on (foo)
 ; 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
 ; CHECK-O123SZ-NEXT: Running pass: SimplifyCFGPass on foo
 ; CHECK-O123SZ-NEXT: Running pass: InstCombinePass on foo
 ; CHECK-O123SZ-NEXT: Running pass: GlobalDCEPass
 ; CHECK-O-NEXT: Running pass: PGOInstrumentationUse
 ; These next two can appear in any order since they are accessed as parameters

 ; CHECK-O-NEXT: Running analysis: DominatorTreeAnalysis
 ; CHECK-O-NEXT: Running analysis: ScopedNoAliasAA
 ; CHECK-O-NEXT: Running analysis: TypeBasedAA
 ; CHECK-O-NEXT: Running analysis: OuterAnalysisManagerProxy
 ; CHECK-O3-NEXT: Running pass: ArgumentPromotionPass
 ; 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
 ; CHECK-O2-NEXT: Running analysis: TargetIRAnalysis on foo
 ; CHECK-Os-NEXT: Running analysis: TargetIRAnalysis on foo
 ; CHECK-Oz-NEXT: Running analysis: TargetIRAnalysis on foo
 ; CHECK-O-NEXT: Running analysis: MemorySSAAnalysis
 ; CHECK-O-NEXT: Running pass: PropagateAndConvertNoAliasPass

 ; CHECK-O-NEXT: Running pass: SimplifyCFGPass
 ; CHECK-O-NEXT: Running pass: InstCombinePass
 ; CHECK-O-NEXT: Running pass: LoopSimplifyPass
 ; CHECK-O-NEXT: Running pass: LCSSAPass
 ; CHECK-O-NEXT: Running pass: LoopIdiomRecognizePass
 ; 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
 ; CHECK-Os-NEXT: Running pass: GVN
 ; CHECK-Os-NEXT: Running analysis: MemoryDependenceAnalysis
 ; CHECK-Os-NEXT: Running analysis: PhiValuesAnalysis
 ; CHECK-Oz-NEXT: Running pass: MergedLoadStoreMotionPass
 ; CHECK-Oz-NEXT: Running pass: GVN
 ; CHECK-Oz-NEXT: Running analysis: MemoryDependenceAnalysis
 ; CHECK-Oz-NEXT: Running analysis: PhiValuesAnalysis
 ; CHECK-O2-NEXT: Running pass: MergedLoadStoreMotionPass
 ; CHECK-O2-NEXT: Running pass: GVN
 ; CHECK-O2-NEXT: Running analysis: MemoryDependenceAnalysis
 ; CHECK-O2-NEXT: Running analysis: PhiValuesAnalysis
 ; CHECK-O3-NEXT: Running pass: MergedLoadStoreMotionPass
 ; CHECK-O3-NEXT: Running pass: GVN
 ; CHECK-O3-NEXT: Running analysis: MemoryDependenceAnalysis
 ; CHECK-O3-NEXT: Running analysis: PhiValuesAnalysis
 ; CHECK-O1-NEXT: Running pass: MemCpyOptPass
 ; CHECK-O-NEXT: Running pass: SCCPPass
 ; 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
 ; CHECK-O23SZ-NEXT: Running pass: CorrelatedValuePropagationPass
 ; CHECK-O23SZ-NEXT: Invalidating analysis: LazyValueAnalysis
 ; CHECK-O-NEXT: Running pass: ADCEPass
 ; CHECK-O23SZ-NEXT: Running pass: MemCpyOptPass
 ; CHECK-O23SZ-NEXT: Running pass: DSEPass

llvm/test/Other/new-pm-thinlto-prelink-samplepgo-defaults.ll

 ; CHECK-O-NEXT: Running pass: AddDiscriminatorsPass
 ; CHECK-EP-PIPELINE-START-NEXT: Running pass: NoOpModulePass
 ; CHECK-O-NEXT: Running pass: InferFunctionAttrsPass
 ; CHECK-O-NEXT: Running analysis: TargetLibraryAnalysis
 ; CHECK-O-NEXT: Running pass: LowerExpectIntrinsicPass
 ; 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
 ; CHECK-O-NEXT: Running analysis: TargetLibraryAnalysis
 ; CHECK-O-NEXT: Running pass: PropagateAndConvertNoAliasPass
 ; CHECK-O3-NEXT: Running pass: CallSiteSplittingPass
 ; CHECK-O-NEXT: Running pass: InstCombinePass on foo
 ; CHECK-O-NEXT: Running analysis: OptimizationRemarkEmitterAnalysis on foo

 ; CHECK-O-NEXT: Running pass: DevirtSCCRepeatedPass
 ; CHECK-O-NEXT: Running pass: InlinerPass
 ; CHECK-O-NEXT: Running pass: InlinerPass
 ; CHECK-O-NEXT: Running pass: PostOrderFunctionAttrsPass
 ; CHECK-O-NEXT: Running analysis: AAManager
 ; 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
 ; CHECK-O-NEXT: Running pass: PropagateAndConvertNoAliasPass
 ; CHECK-O23SZ-NEXT: Running pass: SpeculativeExecutionPass
 ; CHECK-O23SZ-NEXT: Running pass: JumpThreadingPass
 ; CHECK-O23SZ-NEXT: Running analysis: LazyValueAnalysis
 ; CHECK-O23SZ-NEXT: Running pass: CorrelatedValuePropagationPass

 ; CHECK-O-NEXT: Running pass: SimpleLoopUnswitchPass
 ; CHECK-O-NEXT: Running pass: SimplifyCFGPass
 ; CHECK-O-NEXT: Running pass: InstCombinePass
 ; CHECK-O-NEXT: Running pass: LoopSimplifyPass
 ; CHECK-O-NEXT: Running pass: LCSSAPass
 ; 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
 ; CHECK-Os-NEXT: Running pass: GVN
 ; CHECK-Os-NEXT: Running analysis: MemoryDependenceAnalysis
 ; CHECK-Os-NEXT: Running analysis: PhiValuesAnalysis
 ; CHECK-Oz-NEXT: Running pass: MergedLoadStoreMotionPass
 ; CHECK-Oz-NEXT: Running pass: GVN
 ; CHECK-Oz-NEXT: Running analysis: MemoryDependenceAnalysis
 ; CHECK-Oz-NEXT: Running analysis: PhiValuesAnalysis
 ; CHECK-O2-NEXT: Running pass: MergedLoadStoreMotionPass
 ; CHECK-O2-NEXT: Running pass: GVN
 ; CHECK-O2-NEXT: Running analysis: MemoryDependenceAnalysis
 ; CHECK-O2-NEXT: Running analysis: PhiValuesAnalysis
 ; CHECK-O3-NEXT: Running pass: MergedLoadStoreMotionPass
 ; CHECK-O3-NEXT: Running pass: GVN
 ; CHECK-O3-NEXT: Running analysis: MemoryDependenceAnalysis
 ; CHECK-O3-NEXT: Running analysis: PhiValuesAnalysis
 ; CHECK-O1-NEXT: Running pass: MemCpyOptPass
 ; CHECK-O-NEXT: Running pass: SCCPPass
 ; 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
 ; CHECK-O23SZ-NEXT: Running pass: CorrelatedValuePropagationPass
 ; CHECK-O23SZ-NEXT: Invalidating analysis: LazyValueAnalysis
 ; CHECK-O-NEXT: Running pass: ADCEPass
 ; CHECK-O23SZ-NEXT: Running pass: MemCpyOptPass
 ; CHECK-O23SZ-NEXT: Running pass: DSEPass

llvm/test/Other/opt-LTO-pipeline.ll

 ; CHECK-NEXT:         Function Alias Analysis Results
 ; CHECK-NEXT:         Natural Loop Information
 ; CHECK-NEXT:         Lazy Branch Probability Analysis
 ; CHECK-NEXT:         Lazy Block Frequency Analysis
 ; CHECK-NEXT:         Optimization Remark Emitter
 ; 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)
 ; CHECK-NEXT:         Function Alias Analysis Results
 ; CHECK-NEXT:         Natural Loop Information
 ; CHECK-NEXT:         Lazy Branch Probability Analysis
 ; CHECK-NEXT:         Lazy Block Frequency Analysis
 ; CHECK-NEXT:         Optimization Remark Emitter

llvm/test/Other/opt-O2-pipeline.ll

 ; CHECK-NEXT: Target Library Information
 ; CHECK-NEXT:   FunctionPass Manager
 ; CHECK-NEXT:     Module Verifier
 ; CHECK-EXT:      Good Bye World Pass
 ; CHECK-NOEXT-NOT:      Good Bye World Pass
 ; 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
 ; CHECK-NEXT: Pass Arguments:
 ; CHECK-NEXT: Target Library Information
 ; CHECK-NEXT: Target Transform Information
 ;             Target Pass Configuration
 ; CHECK:      Type-Based Alias Analysis

 ; CHECK-NEXT:       Function Integration/Inlining
 ; CHECK-NEXT:       FunctionPass Manager
 ; CHECK-NEXT:         Dominator Tree Construction
 ; CHECK-NEXT:         Propagate and Convert Noalias intrinsics
 ; CHECK-NEXT:       OpenMP specific optimizations
 ; 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
 ; CHECK-NEXT:         Memory SSA
 ; CHECK-NEXT:         Early CSE w/ MemorySSA
 ; CHECK-NEXT:         Propagate and Convert Noalias intrinsics
 ; CHECK-NEXT:         Speculatively execute instructions if target has divergent branches
 ; CHECK-NEXT:         Basic Alias Analysis (stateless AA impl)

 ; CHECK-NEXT:         LCSSA Verifier
 ; CHECK-NEXT:         Loop-Closed SSA Form Pass
 ; CHECK-NEXT:         Scalar Evolution Analysis
 ; CHECK-NEXT:         Loop Pass Manager
 ; CHECK-NEXT:           Recognize loop idioms
 ; 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)
 ; CHECK-NEXT:         Function Alias Analysis Results
 ; CHECK-NEXT:         MergedLoadStoreMotion
 ; CHECK-NEXT:         Natural Loop Information
 ; CHECK-NEXT:         Phi Values Analysis
 ; CHECK-NEXT:         Function Alias Analysis Results
 ; CHECK-NEXT:         Memory Dependence Analysis
 ; CHECK-NEXT:         Lazy Branch Probability Analysis
 ; CHECK-NEXT:         Lazy Block Frequency Analysis
 ; CHECK-NEXT:         Optimization Remark Emitter
 ; CHECK-NEXT:         Global Value Numbering
 ; CHECK-NEXT:         Sparse Conditional Constant Propagation
 ; CHECK-NEXT:         Demanded bits analysis
 ; CHECK-NEXT:         Bit-Tracking Dead Code Elimination
 ; CHECK-NEXT:         Basic Alias Analysis (stateless AA impl)
 ; CHECK-NEXT:         Function Alias Analysis Results
 ; CHECK-NEXT:         Lazy Branch Probability Analysis
 ; 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
 ; CHECK-NEXT:         Lazy Value Information Analysis
 ; CHECK-NEXT:         Jump Threading
 ; CHECK-NEXT:         Value Propagation
 ; CHECK-NEXT:         Post-Dominator Tree Construction
 ; CHECK-NEXT:         Aggressive Dead Code Elimination

llvm/test/Other/opt-O3-pipeline-enable-matrix.ll

 ; LEGACY-NEXT: Target Library Information
 ; LEGACY-NEXT:   FunctionPass Manager
 ; LEGACY-NEXT:     Module Verifier
 ; LEGACY-EXT:      Good Bye World Pass
 ; LEGACY-NOEXT-NOT:      Good Bye World Pass
 ; 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
 ; LEGACY-NEXT: Pass Arguments:
 ; LEGACY-NEXT: Target Library Information
 ; LEGACY-NEXT: Target Transform Information
 ;             Target Pass Configuration
 ; LEGACY:      Type-Based Alias Analysis

 ; LEGACY-NEXT:       FunctionPass Manager
 ; LEGACY-NEXT:       Dominator Tree Construction
 ; LEGACY-NEXT:       Propagate and Convert Noalias intrinsics
 ; LEGACY-NEXT:       OpenMP specific optimizations
 ; LEGACY-NEXT:       Deduce function attributes
 ; 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
 ; LEGACY-NEXT:         Memory SSA
 ; LEGACY-NEXT:         Early CSE w/ MemorySSA
 ; LEGACY-NEXT:         Propagate and Convert Noalias intrinsics
 ; LEGACY-NEXT:         Speculatively execute instructions if target has divergent branches
 ; LEGACY-NEXT:         Basic Alias Analysis (stateless AA impl)

 ; LEGACY-NEXT:         LCSSA Verifier
 ; LEGACY-NEXT:         Loop-Closed SSA Form Pass
 ; LEGACY-NEXT:         Scalar Evolution Analysis
 ; LEGACY-NEXT:         Loop Pass Manager
 ; LEGACY-NEXT:           Recognize loop idioms
 ; 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)
 ; LEGACY-NEXT:         Function Alias Analysis Results
 ; LEGACY-NEXT:         MergedLoadStoreMotion
 ; LEGACY-NEXT:         Natural Loop Information
 ; LEGACY-NEXT:         Phi Values Analysis
 ; LEGACY-NEXT:         Function Alias Analysis Results
 ; LEGACY-NEXT:         Memory Dependence Analysis
 ; LEGACY-NEXT:         Lazy Branch Probability Analysis
 ; LEGACY-NEXT:         Lazy Block Frequency Analysis
 ; LEGACY-NEXT:         Optimization Remark Emitter
 ; LEGACY-NEXT:         Global Value Numbering
 ; LEGACY-NEXT:         Sparse Conditional Constant Propagation
 ; LEGACY-NEXT:         Demanded bits analysis
 ; LEGACY-NEXT:         Bit-Tracking Dead Code Elimination
 ; LEGACY-NEXT:         Basic Alias Analysis (stateless AA impl)
 ; LEGACY-NEXT:         Function Alias Analysis Results
 ; LEGACY-NEXT:         Lazy Branch Probability Analysis
 ; 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
 ; LEGACY-NEXT:         Lazy Value Information Analysis
 ; LEGACY-NEXT:         Jump Threading
 ; LEGACY-NEXT:         Value Propagation
 ; LEGACY-NEXT:         Post-Dominator Tree Construction
 ; LEGACY-NEXT:         Aggressive Dead Code Elimination

 ; NEWPM-NEXT:Running pass: ForceFunctionAttrsPass on
 ; NEWPM-NEXT:Running pass: InferFunctionAttrsPass on
 ; NEWPM-NEXT:Running analysis: InnerAnalysisManagerProxy<
 ; NEWPM-NEXT:Running analysis: PreservedCFGCheckerAnalysis on f
 ; NEWPM-NEXT:Running pass: LowerExpectIntrinsicPass on f
 ; 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
 ; NEWPM-NEXT: Running analysis: TargetLibraryAnalysis on f
 ; NEWPM-NEXT: Running pass: PropagateAndConvertNoAliasPass on f
 ; NEWPM-NEXT: Running pass: CallSiteSplittingPass on f
 ; NEWPM-NEXT: Running pass: OpenMPOptPass on
 ; NEWPM-NEXT: Running pass: IPSCCPPass on

 ; NEWPM-NEXT: Running analysis: OuterAnalysisManagerProxy<
 ; NEWPM-NEXT: Running pass: DevirtSCCRepeatedPass on (f)
 ; NEWPM-NEXT: Running pass: InlinerPass on (f)
 ; NEWPM-NEXT: Running pass: InlinerPass on (f)
 ; NEWPM-NEXT: Running pass: PostOrderFunctionAttrsPass on (f)
 ; 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
 ; NEWPM-NEXT: Running pass: PropagateAndConvertNoAliasPass on f
 ; NEWPM-NEXT: Running pass: SpeculativeExecutionPass on f
 ; NEWPM-NEXT: Running pass: JumpThreadingPass on f
 ; NEWPM-NEXT: Running analysis: LazyValueAnalysis on f
 ; NEWPM-NEXT: Running pass: CorrelatedValuePropagationPass on f
 ; NEWPM-NEXT: Invalidating analysis: LazyValueAnalysis on f
 ; NEWPM-NEXT: Running pass: SimplifyCFGPass on f
 ; NEWPM-NEXT: Running pass: AggressiveInstCombinePass on f
 ; NEWPM-NEXT: Running pass: InstCombinePass on f
 ; NEWPM-NEXT: Running pass: LibCallsShrinkWrapPass on f
 ; NEWPM-NEXT: Running pass: TailCallElimPass on f
 ; NEWPM-NEXT: Running pass: SimplifyCFGPass on f
 ; NEWPM-NEXT: Running pass: ReassociatePass on f
 ; NEWPM-NEXT: Running pass: RequireAnalysisPass<{{.*}}OptimizationRemarkEmitterAnalysis
 ; NEWPM-NEXT: Running pass: LoopSimplifyPass on f
 ; NEWPM-NEXT: Running analysis: LoopAnalysis on f
 ; NEWPM-NEXT: Running pass: LCSSAPass on f
 ; NEWPM-NEXT: Running pass: SimplifyCFGPass on f
 ; 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
 ; NEWPM-NEXT: Running pass: GVN on f
 ; NEWPM-NEXT: Running analysis: MemoryDependenceAnalysis on f
 ; NEWPM-NEXT: Running analysis: PhiValuesAnalysis on f
 ; NEWPM-NEXT: Running pass: SCCPPass on f
 ; 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
 ; NEWPM-NEXT: Running pass: CorrelatedValuePropagationPass on f
 ; NEWPM-NEXT: Invalidating analysis: LazyValueAnalysis on f
 ; NEWPM-NEXT: Running pass: ADCEPass on f
 ; NEWPM-NEXT: Running analysis: PostDominatorTreeAnalysis on f
 ; NEWPM-NEXT: Running pass: MemCpyOptPass on f

llvm/test/Other/opt-O3-pipeline.ll

 ; CHECK-NEXT: Target Library Information
 ; CHECK-NEXT:   FunctionPass Manager
 ; CHECK-NEXT:     Module Verifier
 ; CHECK-EXT:      Good Bye World Pass
 ; CHECK-NOEXT-NOT:      Good Bye World Pass
 ; 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
 ; CHECK-NEXT: Pass Arguments:
 ; CHECK-NEXT: Target Library Information
 ; CHECK-NEXT: Target Transform Information
 ;             Target Pass Configuration
 ; CHECK:      Type-Based Alias Analysis

 ; CHECK-NEXT:       FunctionPass Manager
 ; CHECK-NEXT:         Dominator Tree Construction
 ; CHECK-NEXT:         Propagate and Convert Noalias intrinsics
 ; CHECK-NEXT:       OpenMP specific optimizations
 ; CHECK-NEXT:       Deduce function attributes
 ; 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
 ; CHECK-NEXT:         Memory SSA
 ; CHECK-NEXT:         Early CSE w/ MemorySSA
 ; CHECK-NEXT:         Propagate and Convert Noalias intrinsics
 ; CHECK-NEXT:         Speculatively execute instructions if target has divergent branches
 ; CHECK-NEXT:         Basic Alias Analysis (stateless AA impl)

 ; CHECK-NEXT:         LCSSA Verifier
 ; CHECK-NEXT:         Loop-Closed SSA Form Pass
 ; CHECK-NEXT:         Scalar Evolution Analysis
 ; CHECK-NEXT:         Loop Pass Manager
 ; CHECK-NEXT:           Recognize loop idioms
 ; 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)
 ; CHECK-NEXT:         Function Alias Analysis Results
 ; CHECK-NEXT:         MergedLoadStoreMotion
 ; CHECK-NEXT:         Natural Loop Information
 ; CHECK-NEXT:         Phi Values Analysis
 ; CHECK-NEXT:         Function Alias Analysis Results
 ; CHECK-NEXT:         Memory Dependence Analysis
 ; CHECK-NEXT:         Lazy Branch Probability Analysis
 ; CHECK-NEXT:         Lazy Block Frequency Analysis
 ; CHECK-NEXT:         Optimization Remark Emitter
 ; CHECK-NEXT:         Global Value Numbering
 ; CHECK-NEXT:         Sparse Conditional Constant Propagation
 ; CHECK-NEXT:         Demanded bits analysis
 ; CHECK-NEXT:         Bit-Tracking Dead Code Elimination
 ; CHECK-NEXT:         Basic Alias Analysis (stateless AA impl)
 ; CHECK-NEXT:         Function Alias Analysis Results
 ; CHECK-NEXT:         Lazy Branch Probability Analysis
 ; 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
 ; CHECK-NEXT:         Lazy Value Information Analysis
 ; CHECK-NEXT:         Jump Threading
 ; CHECK-NEXT:         Value Propagation
 ; CHECK-NEXT:         Post-Dominator Tree Construction
 ; CHECK-NEXT:         Aggressive Dead Code Elimination

 ; NEWPM-NEXT:   InnerAnalysisManagerProxy<{{.*}}> analysis on [module]
 ; NEWPM-NEXT: ModuleToFunctionPassAdaptor on [module]
 ; NEWPM-NEXT:   PassManager<{{.*}}> on f
 ; NEWPM-NEXT:     PreservedCFGCheckerAnalysis analysis on f
 ; NEWPM-NEXT:     LowerExpectIntrinsicPass on f
 ; 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
 ; NEWPM-NEXT:       TargetLibraryAnalysis analysis on f
 ; NEWPM-NEXT:     PropagateAndConvertNoAliasPass on f
 ; NEWPM-NEXT:     CallSiteSplittingPass on f
 ; NEWPM-NEXT: OpenMPOptPass on [module]
 ; NEWPM-NEXT: IPSCCPPass on [module]

 ; NEWPM-NEXT:         InlinerPass on (f)
 ; NEWPM-NEXT:         InlinerPass on (f)
 ; NEWPM-NEXT:         PostOrderFunctionAttrsPass on (f)
 ; NEWPM-NEXT:           AAManager analysis on f
 ; NEWPM-NEXT:         ArgumentPromotionPass on (f)
 ; 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
 ; NEWPM-NEXT:             PropagateAndConvertNoAliasPass on f
 ; NEWPM-NEXT:             SpeculativeExecutionPass on f
 ; NEWPM-NEXT:             JumpThreadingPass on f
 ; NEWPM-NEXT:               LazyValueAnalysis analysis on f
 ; NEWPM-NEXT:             CorrelatedValuePropagationPass on f

 ; NEWPM-NEXT:                   LoopAnalysis analysis on f
 ; NEWPM-NEXT:                 LCSSAPass on f
 ; NEWPM-NEXT:             SimplifyCFGPass on f
 ; NEWPM-NEXT:             InstCombinePass on f
 ; NEWPM-NEXT:             FunctionToLoopPassAdaptor on f
 ; 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
 ; NEWPM-NEXT:             GVN on f
 ; NEWPM-NEXT:               MemoryDependenceAnalysis analysis on f
 ; NEWPM-NEXT:                 PhiValuesAnalysis analysis on f
 ; NEWPM-NEXT:             SCCPPass on f
 ; 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
 ; NEWPM-NEXT:             CorrelatedValuePropagationPass on f
 ; NEWPM-NEXT:             ADCEPass on f
 ; NEWPM-NEXT:               PostDominatorTreeAnalysis analysis on f
 ; NEWPM-NEXT:             MemCpyOptPass on f
 ; NEWPM-NEXT:             DSEPass on f

llvm/test/Other/opt-Os-pipeline.ll

 ; CHECK-NEXT: Target Library Information
 ; CHECK-NEXT:   FunctionPass Manager
 ; CHECK-NEXT:     Module Verifier
 ; CHECK-EXT:      Good Bye World Pass
 ; CHECK-NOEXT-NOT:      Good Bye World Pass
 ; 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
 ; CHECK-NEXT: Pass Arguments:
 ; CHECK-NEXT: Target Library Information
 ; CHECK-NEXT: Target Transform Information
 ;             Target Pass Configuration
 ; CHECK:      Type-Based Alias Analysis

 ; CHECK-NEXT:       Function Integration/Inlining
 ; CHECK-NEXT:       FunctionPass Manager
 ; CHECK-NEXT:         Dominator Tree Construction
 ; CHECK-NEXT:         Propagate and Convert Noalias intrinsics
 ; CHECK-NEXT:       OpenMP specific optimizations
 ; 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
 ; CHECK-NEXT:         Memory SSA
 ; CHECK-NEXT:         Early CSE w/ MemorySSA
 ; CHECK-NEXT:         Propagate and Convert Noalias intrinsics
 ; CHECK-NEXT:         Speculatively execute instructions if target has divergent branches
 ; CHECK-NEXT:         Basic Alias Analysis (stateless AA impl)

 ; CHECK-NEXT:         LCSSA Verifier
 ; CHECK-NEXT:         Loop-Closed SSA Form Pass
 ; CHECK-NEXT:         Scalar Evolution Analysis
 ; CHECK-NEXT:         Loop Pass Manager
 ; CHECK-NEXT:           Recognize loop idioms
 ; 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)
 ; CHECK-NEXT:         Function Alias Analysis Results
 ; CHECK-NEXT:         MergedLoadStoreMotion
 ; CHECK-NEXT:         Natural Loop Information
 ; CHECK-NEXT:         Phi Values Analysis
 ; CHECK-NEXT:         Function Alias Analysis Results
 ; CHECK-NEXT:         Memory Dependence Analysis
 ; CHECK-NEXT:         Lazy Branch Probability Analysis
 ; CHECK-NEXT:         Lazy Block Frequency Analysis
 ; CHECK-NEXT:         Optimization Remark Emitter
 ; CHECK-NEXT:         Global Value Numbering
 ; CHECK-NEXT:         Sparse Conditional Constant Propagation
 ; CHECK-NEXT:         Demanded bits analysis
 ; CHECK-NEXT:         Bit-Tracking Dead Code Elimination
 ; CHECK-NEXT:         Basic Alias Analysis (stateless AA impl)
 ; CHECK-NEXT:         Function Alias Analysis Results
 ; CHECK-NEXT:         Lazy Branch Probability Analysis
 ; 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
 ; CHECK-NEXT:         Lazy Value Information Analysis
 ; CHECK-NEXT:         Jump Threading
 ; CHECK-NEXT:         Value Propagation
 ; CHECK-NEXT:         Post-Dominator Tree Construction
 ; CHECK-NEXT:         Aggressive Dead Code Elimination

llvm/test/Other/pm-pgo-preinline.ll

 ; RUN: opt -disable-verify -enable-new-pm=0 -pgo-kind=pgo-instr-gen-pipeline -mtriple=x86_64-- -Os -debug-pass=Structure < %s -o /dev/null 2>&1 | FileCheck %s --check-prefix=CHECK-Osz
 ; RUN: opt -disable-verify -enable-new-pm=0 -pgo-kind=pgo-instr-gen-pipeline -mtriple=x86_64-- -Oz -debug-pass=Structure < %s -o /dev/null 2>&1 | FileCheck %s --check-prefix=CHECK-Osz
 
 
 ; CHECK-Osz: CallGraph Construction
 ; CHECK-Osz-NEXT: Call Graph SCC Pass Manager
 ; 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
 ; CHECK-Osz-NEXT: Simplify the CFG
 ; CHECK-Osz-NEXT: Dominator Tree Construction
 ; CHECK-Osz-NEXT: Basic Alias Analysis (stateless AA impl)
 ; CHECK-Osz-NEXT: Function Alias Analysis Results
 ; CHECK-Osz-NEXT: Natural Loop Information
 ; CHECK-Osz-NEXT: Lazy Branch Probability Analysis
 ; CHECK-Osz-NEXT: Lazy Block Frequency Analysis
 ; CHECK-Osz-NEXT: Optimization Remark Emitter
 ; CHECK-Osz-NEXT: Combine redundant instructions
 
 define void @foo() {
   ret void
 }

llvm/test/Transforms/ConnectNoAliasDecl/basictest.ll

+; 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}