[PATCH 18/27] [noalias] Introduce PropagateAndConvertNoAlias pass

[jeroen.dobbelaere]

Summary

This is part of the series started by D68484.

This pass moves llvm.noalias intrinsics to the ptr_provenance path of
load/store instructions. At the same time, they are converted into
llvm.provenance.noalias intrinsics. For llvm.noalias intrinsics that are
returned or passed as arguments, a llvm.noalias.arg.guard is introduced,
combining the pointer path and the ptr_provenance path.

This migration allows other optimization passes to do changes on the
normal pointer path, without impacting the ptr_provenance path that
contains the restrict/noalias related information.

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

[jeroen.dobbelaere]

Rebased

[jeroen.dobbelaere]

llvm/lib/Transforms/Scalar/PropagateAndConvertNoAlias.cpp

780

A testcase from Alexey, triggers this FIXME (see http://lists.llvm.org/pipermail/llvm-dev/2020-February/139358.html)

We should do the same here as in lines 810-835, but on Operand 0.

As this is the third time we have this kind of code, it should also be refactored out.

[jeroen.dobbelaere]

This update adds 'llvm.noalias.arg.guard' to noalias pointers that are stored to memory. This ensures that the noalias relationship is not lost when the stores are optimized away later on.

Thanks to @alexey.zhikhar for reporting this problem.

[jeroen.dobbelaere]

Rebased to c06b7e2ab5167ad031745a706204abed1aefd823 (July 14, 2020)

[jeroen.dobbelaere]

Rebased to 9fb46a452d4e5666828c95610ceac8dcd9e4ce16 (September 7, 2020)

[jeroen.dobbelaere]

Fix testcase where ptr_provenance type and ptr type were different.

[jeroen.dobbelaere]

Rebased to f8dbd61074176bae92ec360a093ac7bc498c9321.

llvm/include/llvm/InitializePasses.h

 void initializePreISelIntrinsicLoweringLegacyPassPass(PassRegistry&);
 void initializePredicateInfoPrinterLegacyPassPass(PassRegistry&);
 void initializePrintBasicBlockPassPass(PassRegistry&);
 void initializePrintFunctionPassWrapperPass(PassRegistry&);
 void initializePrintModulePassWrapperPass(PassRegistry&);
 void initializeProcessImplicitDefsPass(PassRegistry&);
 void initializeProfileSummaryInfoWrapperPassPass(PassRegistry&);
 void initializePromoteLegacyPassPass(PassRegistry&);
+void initializePropagateAndConvertNoAliasLegacyPassPass(PassRegistry &);
 void initializePruneEHPass(PassRegistry&);
 void initializeRABasicPass(PassRegistry&);
 void initializeRAGreedyPass(PassRegistry&);
 void initializeReachingDefAnalysisPass(PassRegistry&);
 void initializeReassociateLegacyPassPass(PassRegistry&);
 void initializeRegAllocFastPass(PassRegistry&);
 void initializeRegBankSelectPass(PassRegistry&);
 void initializeRegToMemPass(PassRegistry&);

llvm/include/llvm/LinkAllPasses.h

 #include "llvm/Transforms/IPO/FunctionAttrs.h"
 #include "llvm/Transforms/InstCombine/InstCombine.h"
 #include "llvm/Transforms/Instrumentation.h"
 #include "llvm/Transforms/Instrumentation/BoundsChecking.h"
 #include "llvm/Transforms/ObjCARC.h"
 #include "llvm/Transforms/Scalar.h"
 #include "llvm/Transforms/Scalar/GVN.h"
 #include "llvm/Transforms/Scalar/InstSimplifyPass.h"
+#include "llvm/Transforms/Scalar/PropagateAndConvertNoAlias.h"
 #include "llvm/Transforms/Scalar/Scalarizer.h"
 #include "llvm/Transforms/Utils.h"
 #include "llvm/Transforms/Utils/SymbolRewriter.h"
 #include "llvm/Transforms/Utils/UnifyFunctionExitNodes.h"
 #include "llvm/Transforms/Vectorize.h"
 #include <cstdlib>
 
 namespace {
ForcePassLinking() {
       (void) llvm::createLoopVectorizePass();
       (void) llvm::createSLPVectorizerPass();
       (void) llvm::createLoadStoreVectorizerPass();
       (void) llvm::createPartiallyInlineLibCallsPass();
       (void) llvm::createScalarizerPass();
       (void) llvm::createSeparateConstOffsetFromGEPPass();
       (void) llvm::createSpeculativeExecutionPass();
       (void) llvm::createSpeculativeExecutionIfHasBranchDivergencePass();
+      (void) llvm::createPropagateAndConvertNoAliasPass();
       (void) llvm::createRewriteSymbolsPass();
       (void) llvm::createStraightLineStrengthReducePass();
       (void) llvm::createMemDerefPrinter();
       (void) llvm::createMustExecutePrinter();
       (void) llvm::createMustBeExecutedContextPrinter();
       (void) llvm::createFloat2IntPass();
       (void) llvm::createEliminateAvailableExternallyPass();
       (void) llvm::createScalarizeMaskedMemIntrinPass();

llvm/include/llvm/Transforms/Scalar.h

 // speculative execution on targets where branches are expensive.
 //
 FunctionPass *createSpeculativeExecutionPass();
 
 // Same as createSpeculativeExecutionPass, but does nothing unless
 // TargetTransformInfo::hasBranchDivergence() is true.
 FunctionPass *createSpeculativeExecutionIfHasBranchDivergencePass();
 
+// PropagateAndConvertNoAlias: move noalias intrinsics into a side channel of
+// load/store instructions
+FunctionPass *createPropagateAndConvertNoAliasPass();
+
 //===----------------------------------------------------------------------===//
 //
 // StraightLineStrengthReduce - This pass strength-reduces some certain
 // instruction patterns in straight-line code.
 //
 FunctionPass *createStraightLineStrengthReducePass();
 
 //===----------------------------------------------------------------------===//

llvm/include/llvm/Transforms/Scalar/PropagateAndConvertNoAlias.h

+//===- PropagateAndConvertNoAlias.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 moves dependencies on llvm.noalias onto the noalias_sidechannel.
+/// It also introduces and propagates side.noalias and noalias.arg.guard
+/// intrinsics.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_SCALAR_PROPAGATEANDCONVERTNOALIAS_H
+#define LLVM_TRANSFORMS_SCALAR_PROPAGATEANDCONVERTNOALIAS_H
+
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+class DominatorTree;
+
+class PropagateAndConvertNoAliasPass
+    : public PassInfoMixin<PropagateAndConvertNoAliasPass> {
+public:
+  PropagateAndConvertNoAliasPass();
+
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+
+  // Glue for old PM
+  bool runImpl(Function &F, llvm::DominatorTree &DT);
+
+private:
+  bool doit(Function &F, llvm::DominatorTree &DT);
+};
+} // namespace llvm
+
+#endif // LLVM_TRANSFORMS_SCALAR_PROPAGATEANDCONVERTNOALIAS_H

llvm/lib/Passes/PassBuilder.cpp

 #include "llvm/Transforms/Scalar/LowerWidenableCondition.h"
 #include "llvm/Transforms/Scalar/MakeGuardsExplicit.h"
 #include "llvm/Transforms/Scalar/MemCpyOptimizer.h"
 #include "llvm/Transforms/Scalar/MergeICmps.h"
 #include "llvm/Transforms/Scalar/MergedLoadStoreMotion.h"
 #include "llvm/Transforms/Scalar/NaryReassociate.h"
 #include "llvm/Transforms/Scalar/NewGVN.h"
 #include "llvm/Transforms/Scalar/PartiallyInlineLibCalls.h"
+#include "llvm/Transforms/Scalar/PropagateAndConvertNoAlias.h"
 #include "llvm/Transforms/Scalar/Reassociate.h"
 #include "llvm/Transforms/Scalar/RewriteStatepointsForGC.h"
 #include "llvm/Transforms/Scalar/SCCP.h"
 #include "llvm/Transforms/Scalar/SROA.h"
 #include "llvm/Transforms/Scalar/Scalarizer.h"
 #include "llvm/Transforms/Scalar/SimpleLoopUnswitch.h"
 #include "llvm/Transforms/Scalar/SimplifyCFG.h"
 #include "llvm/Transforms/Scalar/Sink.h"

llvm/lib/Passes/PassRegistry.def

 FUNCTION_PASS("add-discriminators", AddDiscriminatorsPass())
 FUNCTION_PASS("aggressive-instcombine", AggressiveInstCombinePass())
 FUNCTION_PASS("alignment-from-assumptions", AlignmentFromAssumptionsPass())
 FUNCTION_PASS("bdce", BDCEPass())
 FUNCTION_PASS("bounds-checking", BoundsCheckingPass())
 FUNCTION_PASS("break-crit-edges", BreakCriticalEdgesPass())
 FUNCTION_PASS("callsite-splitting", CallSiteSplittingPass())
 FUNCTION_PASS("consthoist", ConstantHoistingPass())
+FUNCTION_PASS("convert-noalias", PropagateAndConvertNoAliasPass())
 FUNCTION_PASS("chr", ControlHeightReductionPass())
 FUNCTION_PASS("correlated-propagation", CorrelatedValuePropagationPass())
 FUNCTION_PASS("dce", DCEPass())
 FUNCTION_PASS("div-rem-pairs", DivRemPairsPass())
 FUNCTION_PASS("dse", DSEPass())
 FUNCTION_PASS("dot-cfg", CFGPrinterPass())
 FUNCTION_PASS("dot-cfg-only", CFGOnlyPrinterPass())
 FUNCTION_PASS("early-cse", EarlyCSEPass(/*UseMemorySSA=*/false))

llvm/lib/Transforms/IPO/PassManagerBuilder.cpp

void PassManagerBuilder::populateFunctionPassManager(
 
   if (OptLevel == 0) return;
 
   addInitialAliasAnalysisPasses(FPM);
 
   FPM.add(createCFGSimplificationPass());
   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());
+
   FPM.add(createLowerExpectIntrinsicPass());
 }
 
 // Do PGO instrumentation generation or use pass as the option specified.
 void PassManagerBuilder::addPGOInstrPasses(legacy::PassManagerBase &MPM,
                                            bool IsCS = false) {
   if (IsCS) {
     if (!EnablePGOCSInstrGen && !EnablePGOCSInstrUse)
if (OptLevel > 0 && SizeLevel == 0 && !DisablePreInliner &&
     IP.DefaultThreshold = PreInlineThreshold;
     // FIXME: The hint threshold has the same value used by the regular inliner.
     // This should probably be lowered after performance testing.
     IP.HintThreshold = 325;
 
     MPM.add(createFunctionInliningPass(IP));
     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());
+
     MPM.add(createCFGSimplificationPass());    // Merge & remove BBs
     MPM.add(createInstructionCombiningPass()); // Combine silly seq's
     addExtensionsToPM(EP_Peephole, MPM);
   }
   if ((EnablePGOInstrGen && !IsCS) || (EnablePGOCSInstrGen && IsCS)) {
     MPM.add(createPGOInstrumentationGenLegacyPass(IsCS));
     // Add the profile lowering pass.
     InstrProfOptions Options;
MPM.add(
         createPGOIndirectCallPromotionLegacyPass(false, !PGOSampleUse.empty()));
 }
 void PassManagerBuilder::addFunctionSimplificationPasses(
     legacy::PassManagerBase &MPM) {
   // Start of function pass.
   // Break up aggregate allocas, using SSAUpdater.
   MPM.add(createSROAPass());
   MPM.add(createEarlyCSEPass(true /* Enable mem-ssa. */)); // 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());
+
   if (EnableGVNHoist)
     MPM.add(createGVNHoistPass());
   if (EnableGVNSink) {
     MPM.add(createGVNSinkPass());
     MPM.add(createCFGSimplificationPass());
   }
 
   // Speculative execution if the target has divergent branches; otherwise nop.
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.
   addInstructionCombiningPass(MPM);
   addExtensionsToPM(EP_Peephole, MPM);
+  // Propagate and Convert as early as possible.
+  // But do it after SROA!
+  MPM.add(createPropagateAndConvertNoAliasPass());
+  if (VerifyOutput)
+    MPM.add(createVerifierPass());
+
   MPM.add(createJumpThreadingPass());         // Thread jumps
   MPM.add(createCorrelatedValuePropagationPass());
   MPM.add(createDeadStoreEliminationPass());  // Delete dead stores
   MPM.add(createLICMPass(LicmMssaOptCap, LicmMssaNoAccForPromotionCap));
 
   addExtensionsToPM(EP_ScalarOptimizerLate, MPM);
 
   if (RerollLoops)
void PassManagerBuilder::populateModulePassManager(
 
   // Start of CallGraph SCC passes.
   MPM.add(createPruneEHPass()); // Remove dead EH info
   bool RunInliner = false;
   if (Inliner) {
     MPM.add(Inliner);
     Inliner = nullptr;
     RunInliner = true;
+
+    // Propagate and Convert as early as possible.
+    // But do it after SROA!
+    MPM.add(createPropagateAndConvertNoAliasPass());
+    if (VerifyOutput)
+      MPM.add(createVerifierPass());
   }
 
   MPM.add(createPostOrderFunctionAttrsLegacyPass());
   if (OptLevel > 2)
     MPM.add(createArgumentPromotionPass()); // Scalarize uninlined fn args
 
   addExtensionsToPM(EP_CGSCCOptimizerLate, MPM);
   addFunctionSimplificationPasses(MPM);
void PassManagerBuilder::addLTOOptimizationPasses(legacy::PassManagerBase &PM) {
   addInstructionCombiningPass(PM);
   addExtensionsToPM(EP_Peephole, PM);
 
   // Inline small functions
   bool RunInliner = Inliner;
   if (RunInliner) {
     PM.add(Inliner);
     Inliner = nullptr;
+
+    // Propagate and Convert as early as possible.
+    // But do it after SROA!
+    PM.add(createPropagateAndConvertNoAliasPass());
+    if (VerifyOutput)
+      PM.add(createVerifierPass());
   }
 
   PM.add(createPruneEHPass());   // Remove dead EH info.
 
   // CSFDO instrumentation and use pass.
   addPGOInstrPasses(PM, /* IsCS */ true);
 
   // Optimize globals again if we ran the inliner.
   if (RunInliner)
     PM.add(createGlobalOptimizerPass());
   PM.add(createGlobalDCEPass()); // Remove dead functions.
 
   // If we didn't decide to inline a function, check to see if we can
   // 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.
   addInstructionCombiningPass(PM);
   addExtensionsToPM(EP_Peephole, PM);
   PM.add(createJumpThreadingPass());
 
   // 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());
+
   // LTO provides additional opportunities for tailcall elimination due to
   // link-time inlining, and visibility of nocapture attribute.
   PM.add(createTailCallEliminationPass());
 
   // Infer attributes on declarations, call sites, arguments, etc.
   PM.add(createPostOrderFunctionAttrsLegacyPass()); // Add nocapture.
   // Run a few AA driven optimizations here and now, to cleanup the code.
   PM.add(createGlobalsAAWrapperPass()); // IP alias analysis.

llvm/lib/Transforms/Scalar/CMakeLists.txt

add_llvm_library(LLVMScalarOpts
   MakeGuardsExplicit.cpp
   MemCpyOptimizer.cpp
   MergeICmps.cpp
   MergedLoadStoreMotion.cpp
   NaryReassociate.cpp
   NewGVN.cpp
   PartiallyInlineLibCalls.cpp
   PlaceSafepoints.cpp
+  PropagateAndConvertNoAlias.cpp
   Reassociate.cpp
   Reg2Mem.cpp
   RewriteStatepointsForGC.cpp
   SCCP.cpp
   SROA.cpp
   Scalar.cpp
   Scalarizer.cpp
   SeparateConstOffsetFromGEP.cpp

llvm/lib/Transforms/Scalar/PropagateAndConvertNoAlias.cpp

+//===- PropagateAndConvertNoAlias.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
+//
+//===----------------------------------------------------------------------===//
+//
+// This pass moves dependencies on llvm.noalias onto the noalias_sidechannel.
+// It also introduces and propagates side.noalias and noalias.arg.guard
+// intrinsics.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Transforms/Scalar/PropagateAndConvertNoAlias.h"
+#include "llvm/ADT/SmallSet.h"
+#include "llvm/Analysis/GlobalsModRef.h"
+#include "llvm/Analysis/ValueTracking.h"
+#include "llvm/IR/Constants.h"
+#include "llvm/IR/Dominators.h"
+#include "llvm/IR/IRBuilder.h"
+#include "llvm/IR/Instructions.h"
+#include "llvm/IR/IntrinsicInst.h"
+#include "llvm/IR/Module.h"
+#include "llvm/IR/Operator.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/Debug.h"
+
+#include <map>
+#include <type_traits>
+
+using namespace llvm;
+
+#define DEBUG_TYPE "convert-noalias"
+
+namespace {
+
+class PropagateAndConvertNoAliasLegacyPass : public FunctionPass {
+public:
+  static char ID;
+  explicit PropagateAndConvertNoAliasLegacyPass() : FunctionPass(ID), Impl() {
+    initializePropagateAndConvertNoAliasLegacyPassPass(
+        *PassRegistry::getPassRegistry());
+  }
+
+  void getAnalysisUsage(AnalysisUsage &AU) const override;
+  bool runOnFunction(Function &F) override;
+
+  StringRef getPassName() const override {
+    return "Propagate and Convert Noalias intrinsics";
+  }
+
+private:
+  PropagateAndConvertNoAliasPass Impl;
+};
+} // namespace
+
+char PropagateAndConvertNoAliasLegacyPass::ID = 0;
+INITIALIZE_PASS_BEGIN(PropagateAndConvertNoAliasLegacyPass, "convert-noalias",
+                      "Propagate And Convert llvm.noalias intrinsics", false,
+                      false)
+INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
+INITIALIZE_PASS_END(PropagateAndConvertNoAliasLegacyPass, "convert-noalias",
+                    "Propagate And Convert llvm.noalias intrinsics", false,
+                    false)
+
+void PropagateAndConvertNoAliasLegacyPass::getAnalysisUsage(
+    AnalysisUsage &AU) const {
+  AU.addPreserved<GlobalsAAWrapperPass>();
+  // FIXME: not sure the CallGraphWrapperPass is needed. It ensures the same
+  // pass order is kept as if the PropagateAndConvertNoAlias pass was not there.
+  AU.addPreserved<CallGraphWrapperPass>();
+  AU.addPreserved<DominatorTreeWrapperPass>();
+  AU.addRequiredTransitive<DominatorTreeWrapperPass>();
+}
+
+bool PropagateAndConvertNoAliasLegacyPass::runOnFunction(Function &F) {
+  if (skipFunction(F))
+    return false;
+
+  return Impl.runImpl(F, getAnalysis<DominatorTreeWrapperPass>().getDomTree());
+}
+
+namespace llvm {
+
+bool PropagateAndConvertNoAliasPass::runImpl(Function &F, DominatorTree &DT) {
+  bool Changed = false;
+
+  // find all 'llvm.noalias', 'llvm.noalias.gep' and 'llvm.noalias.arg.guard'
+  // intrinsics
+  Changed |= doit(F, DT);
+
+  return Changed;
+}
+
+FunctionPass *createPropagateAndConvertNoAliasPass() {
+  return new PropagateAndConvertNoAliasLegacyPass();
+}
+
+PropagateAndConvertNoAliasPass::PropagateAndConvertNoAliasPass() {}
+
+PreservedAnalyses
+PropagateAndConvertNoAliasPass::run(Function &F, FunctionAnalysisManager &AM) {
+  bool Changed = runImpl(F, AM.getResult<DominatorTreeAnalysis>(F));
+
+  if (!Changed)
+    return PreservedAnalyses::all();
+  PreservedAnalyses PA;
+  PA.preserve<GlobalsAA>();
+  // FIXME: not sure this is valid:
+  //?? PA.preserve<CallGraphWrapperPass>(); // See above
+
+  return PA;
+}
+
+typedef SmallVector<Instruction *, 10> SideChannelWorklist;
+typedef SmallVector<Instruction *, 2> DepsVector;
+typedef std::map<Instruction *, DepsVector> I2Deps;
+typedef SmallSet<Instruction *, 10> InstructionSet;
+
+// Analyse and propagate the instructions that need side channels:
+// - InstructionsForSideChannel: instructions that need a side channel
+// representation
+// - at entry: (A)
+// -- llvm.noalias  -> llvm.side.noalias
+// -- llvm.noalias.arg.guard a, side_a -> side_a
+//
+// - during propagation: (B)
+// -- select a, b, c  -> select a, side_b, side_c
+// -- PHI a, b,... -> PHI side_a, side_b, ...
+//
+// - Handled: Instructions that have been investigated. The Deps side refers to
+// the side channel dependency. (C)
+// -- a nullptr indicates that the normal dependency must be used for that
+// operand
+// -- an I indictates that the side channel representation of I must be used for
+// that operand
+//
+// The algorithm:
+// - We start from the llvm.noalias and llvm.noalias.arg.guard instructions
+// - We go over their users, and check if they are special or not
+// -- special users need a side channel representation and are annotated as such
+// in 'Handled' (non-empty Dep)
+// -- normal instructions are a passthrough, and are annotated with an empty Dep
+// in 'Handled' (I->{})
+// -- some instructions stop the recursion:
+// --- ICmp
+// --- first arg of select
+// --- llvm.noalias.side.channel, llvm.noalias
+//
+// After the analysis, 'Handled' contains an overview of all instructions that
+// depend on (A)
+// - those instructions that were seen, but ignored otherwise have no
+// dependencies (I -> {} )
+// - instructions that refer to one ore more side channels have explicit
+// dependencies. (I -> { op0, op1, op2, ... })
+// -- if opX == nullptr -> not a real side_channel dependency
+// -- if opX == someI :
+// ---- if someI points to an instruction in Handled, it must be one of the
+// instructions that have a side channel representation
+// ---- otherwise, it points to a not-handle plain dependency (coming from a
+// noalias.arg.guard)
+static void propagateInstructionsForSideChannel(
+    SideChannelWorklist &InstructionsForSideChannel, I2Deps &Handled,
+    SideChannelWorklist &out_CreationList, InstructionSet &SideChannelPHIs) {
+  auto updateMatchingOperands = [](Instruction *U, Instruction *I,
+                                   DepsVector &Deps, Instruction *I4SC) {
+    assert(U->getNumOperands() == Deps.size());
+    auto it = Deps.begin();
+    for (Value *UOp : U->operands()) {
+      if (UOp == I) {
+        assert(*it == nullptr || *it == I4SC);
+        *it = I4SC;
+      }
+      ++it;
+    }
+  };
+
+  while (!InstructionsForSideChannel.empty()) {
+    Instruction *I4SC = InstructionsForSideChannel.pop_back_val();
+    LLVM_DEBUG(llvm::dbgs()
+               << "-- Propagating side channel instruction: " << *I4SC << "\n");
+    SmallVector<Instruction *, 10> WorkList = {I4SC};
+    if (auto *CB = dyn_cast<CallBase>(I4SC)) {
+      if (CB->getIntrinsicID() == Intrinsic::noalias_arg_guard) {
+        // llvm.noalias.arg.guard: delegate to side_channel (operand 1)
+        Handled.insert(I2Deps::value_type(I4SC, {}));
+        // no need to add to out_CreationList
+
+        assert(!isa<UndefValue>(I4SC->getOperand(0)) &&
+               !isa<UndefValue>(I4SC->getOperand(1)) &&
+               "Degenerated case must have been resolved already");
+        assert(I4SC->getOperand(0) != I4SC->getOperand(1) &&
+               "Degenerated case must have been resolved already");
+
+        I4SC = dyn_cast<Instruction>(I4SC->getOperand(1));
+        if (I4SC == nullptr) {
+          // Sidechannel became a constant ? Then the arg guard is not needed
+          // any more and there is nothing to propagate
+          continue;
+        }
+      }
+    }
+    while (!WorkList.empty()) {
+      Instruction *I = WorkList.pop_back_val();
+      LLVM_DEBUG(llvm::dbgs() << "-- checking:" << *I << "\n");
+      bool isPtrToInt = isa<PtrToIntInst>(I);
+      for (auto &UOp : I->uses()) {
+        auto *U_ = UOp.getUser();
+        LLVM_DEBUG(llvm::dbgs() << "--- used by:" << *U_
+                                << ", operand:" << UOp.getOperandNo() << "\n");
+        Instruction *U = dyn_cast<Instruction>(U_);
+        if (U == nullptr)
+          continue;
+
+        // Only see through a ptr2int if it used by a int2ptr
+        if (isPtrToInt && !isa<IntToPtrInst>(U))
+          continue;
+
+        if (isa<SelectInst>(U)) {
+          // ======================================== select -> { lhs, rhs }
+          bool MatchesOp1 = (U->getOperand(1) == I);
+          bool MatchesOp2 = (U->getOperand(2) == I);
+
+          if (MatchesOp1 || MatchesOp2) {
+            auto HI = Handled.insert(I2Deps::value_type(U, {nullptr, nullptr}));
+            if (HI.second)
+              out_CreationList.push_back(U);
+            if (MatchesOp1) {
+              HI.first->second[0] = I4SC;
+            }
+            if (MatchesOp2) {
+              HI.first->second[1] = I4SC;
+            }
+            if (HI.second) {
+              InstructionsForSideChannel.push_back(U);
+            }
+          }
+        } else if (isa<LoadInst>(U)) {
+          // ======================================== load -> { ptr }
+          if (UOp.getOperandNo() ==
+              LoadInst::getNoaliasSideChannelOperandIndex())
+            continue; // tracking on side channel -> ignore
+
+          auto HI = Handled.insert(I2Deps::value_type(U, {I4SC}));
+          if (HI.second)
+            out_CreationList.push_back(U);
+          assert(U->getOperand(0) == I);
+          if (HI.second) {
+            // continue
+          }
+        } else if (isa<StoreInst>(U)) {
+          // ======================================== store -> { val, ptr }
+          if (UOp.getOperandNo() ==
+              StoreInst::getNoaliasSideChannelOperandIndex())
+            continue; // tracking on side channel -> ignore
+
+          // also track if we are storing a restrict annotated pointer value...
+          // This might provide useful information about 'escaping pointers'
+          bool MatchesOp0 = (U->getOperand(0) == I);
+          bool MatchesOp1 = (U->getOperand(1) == I);
+
+          if (MatchesOp0 || MatchesOp1) {
+            auto HI = Handled.insert(I2Deps::value_type(U, {nullptr, nullptr}));
+            if (HI.second)
+              out_CreationList.push_back(U);
+            if (MatchesOp0) {
+              HI.first->second[0] = I4SC;
+            }
+            if (MatchesOp1) {
+              HI.first->second[1] = I4SC;
+            }
+          }
+        } else if (isa<InsertValueInst>(U)) {
+          // ======================================== insertvalue -> { val }
+          // track for injecting llvm.noalias.arg.guard
+          assert(U->getOperand(1) == I);
+          // need to introduce a guard
+          auto HI = Handled.insert(I2Deps::value_type(U, {I4SC}));
+          if (HI.second)
+            out_CreationList.push_back(U);
+        } else if (isa<ReturnInst>(U)) {
+          auto HI = Handled.insert(I2Deps::value_type(U, {I4SC}));
+          if (HI.second)
+            out_CreationList.push_back(U);
+        } else if (isa<PHINode>(U)) {
+          // ======================================== PHI -> { ..... }
+          PHINode *PU = cast<PHINode>(U);
+          auto HI = Handled.insert(I2Deps::value_type(U, {}));
+          if (HI.second) {
+            HI.first->second.resize(U->getNumOperands(), nullptr);
+            if (SideChannelPHIs.count(U) == 0) {
+              // This is a normal PHI, consider it for propagation
+              InstructionsForSideChannel.push_back(U);
+            }
+            if (U->getNumOperands())
+              out_CreationList.push_back(U);
+          }
+          updateMatchingOperands(PU, I, HI.first->second, I4SC);
+        } else if (auto *CS = dyn_cast<CallBase>(U)) {
+          // =============================== call/invoke/intrinsic -> { ...... }
+
+          // NOTES:
+          // - we always block at a call...
+          // - the known intrinsics should not have any extra annotations
+          switch (CS->getIntrinsicID()) {
+          case Intrinsic::side_noalias:
+          case Intrinsic::noalias: {
+            bool MatchesOp0 = (U->getOperand(0) == I);
+            bool MatchesOpP =
+                (U->getOperand(Intrinsic::NoAliasIdentifyPArg) == I);
+            static_assert(Intrinsic::NoAliasIdentifyPArg ==
+                              Intrinsic::SideNoAliasIdentifyPArg,
+                          "those must be identical");
+
+            if (MatchesOp0 || MatchesOpP) {
+              auto HI =
+                  Handled.insert(I2Deps::value_type(U, {nullptr, nullptr}));
+              if (HI.second)
+                out_CreationList.push_back(U);
+              if (MatchesOp0) {
+                HI.first->second[0] = I4SC;
+              }
+              if (MatchesOpP) {
+                HI.first->second[1] = I4SC;
+              }
+            }
+            continue;
+          }
+          case Intrinsic::noalias_arg_guard: {
+            // ignore - should be handled by the outer loop !
+            continue;
+          }
+
+          default:
+            break;
+          }
+          // if we get here, we need to inject guards for certain arguments.
+          // Track which arguments will need one.
+          auto HI = Handled.insert(I2Deps::value_type(U, {}));
+          if (HI.second) {
+            HI.first->second.resize(U->getNumOperands(), nullptr);
+            if (U->getNumOperands()) {
+              out_CreationList.push_back(U);
+            }
+          }
+          updateMatchingOperands(U, I, HI.first->second, I4SC);
+          if (I == CS->getReturnedArgOperand()) {
+            // also see through call - this does not omit the need of
+            // introducing a noalias_arg_guard
+            WorkList.push_back(U);
+          }
+        } else {
+          // ======================================== other -> {}
+          // this is the generic case... not sure if we should have a elaborate
+          // check for 'all other instructions'. just acknowledge that we saw it
+          // and propagate to any users NOTE: if we happen have already handled
+          // it, this might indicate something interesting that we should handle
+          // separately
+
+          switch (U->getOpcode()) {
+          case Instruction::ICmp:
+            // restrict pointer used in comparison - do not propagate
+            // sidechannel
+            continue;
+          default:
+            break;
+          }
+
+          auto HI = Handled.insert(I2Deps::value_type(U, {}));
+          // No need to add to out_CreationList
+          if (!HI.second) {
+            llvm::errs()
+                << "WARNING: found an instruction that was already handled:"
+                << *U << "\n";
+            assert(!HI.second &&
+                   "We should not encounter a handled instruction ??");
+          }
+
+          if (HI.second) {
+            WorkList.push_back(U);
+          }
+        }
+      }
+    }
+  }
+}
+
+typedef SmallDenseMap<std::pair<Value *, Type *>, Value *, 16>
+    ValueType2CastMap;
+static Value *createBitOrPointerOrAddrSpaceCast(Value *V, Type *T,
+                                                ValueType2CastMap &VT2C) {
+  if (V->getType() == T)
+    return V;
+
+  // Make sure we remember what casts we introduced
+  Value *&Entry = VT2C[std::make_pair(V, T)];
+  if (Entry == nullptr) {
+    Instruction *InsertionPoint = cast<Instruction>(V);
+    if (auto *PHI = dyn_cast<PHINode>(V)) {
+      InsertionPoint = PHI->getParent()->getFirstNonPHI();
+    } else {
+      InsertionPoint = InsertionPoint->getNextNode();
+    }
+
+    IRBuilder<> Builder(InsertionPoint);
+    Entry = Builder.CreateBitOrPointerCast(V, T);
+  }
+  return Entry;
+}
+
+// combine llvm.side.noalias intrinsics as much as possible
+void collapseSideNoalias(SideChannelWorklist &CollapseableSideNoaliasIntrinsics,
+                         DominatorTree &DT) {
+  if (CollapseableSideNoaliasIntrinsics.empty())
+    return;
+
+  if (!CollapseableSideNoaliasIntrinsics.empty()) {
+    // sweep from back to front, then from front to back etc... until no
+    // modifications are done
+    do {
+      LLVM_DEBUG(llvm::dbgs() << "- Trying to collapse llvm.side.noalias\n");
+      SideChannelWorklist NextList;
+      bool Changed = false;
+
+      // 1)  side_noaliasA (side_noaliasB (....), ...)  -> side_noaliasB(...)
+      while (!CollapseableSideNoaliasIntrinsics.empty()) {
+        IntrinsicInst *I =
+            cast<IntrinsicInst>(CollapseableSideNoaliasIntrinsics.back());
+        assert(I->getIntrinsicID() == Intrinsic::side_noalias);
+
+        CollapseableSideNoaliasIntrinsics.pop_back();
+
+        // side_noalias (side_noalias(....), .... )  -> side_noalias(....)
+        if (IntrinsicInst *DepI = dyn_cast<IntrinsicInst>(I->getOperand(0))) {
+          // Check if the depending intrinsic is compatible)
+          if (DepI->getIntrinsicID() == Intrinsic::side_noalias &&
+              areSideNoaliasCompatible(DepI, I)) {
+            // similar enough - look through
+            LLVM_DEBUG(llvm::dbgs() << "-- Collapsing(1):" << *I << "\n");
+            I->replaceAllUsesWith(DepI);
+            I->eraseFromParent();
+            Changed = true;
+            continue;
+          }
+        }
+        //@ FIXME: TODO:
+        // side_noalias(PHI (fum, self)) -> PHI(side_noalias(fum), phiselfref)
+        NextList.push_back(I);
+      }
+
+      // 2)  side_noaliasA (...), side_noaliasB(...)  --> side_noaliasA(...)
+      {
+        for (Instruction *I : NextList) {
+          IntrinsicInst *II = cast<IntrinsicInst>(I);
+          Instruction *DominatingUse = II;
+
+          SideChannelWorklist similarSideChannels;
+          for (User *U : II->getOperand(0)->users()) {
+            if (IntrinsicInst *UII = dyn_cast<IntrinsicInst>(U)) {
+              if (UII->getParent() && // still valid - ignore already removed
+                                      // instructions
+                  UII->getIntrinsicID() == Intrinsic::side_noalias &&
+                  areSideNoaliasCompatible(II, UII)) {
+                similarSideChannels.push_back(UII);
+                if (DT.dominates(UII, DominatingUse))
+                  DominatingUse = UII;
+              }
+            }
+          }
+
+          for (Instruction *SI : similarSideChannels) {
+            if ((SI != DominatingUse) && DT.dominates(DominatingUse, SI)) {
+              LLVM_DEBUG(llvm::dbgs() << "-- Collapsing(2):" << *SI << "\n");
+              Changed = true;
+              SI->replaceAllUsesWith(DominatingUse);
+              SI->removeFromParent(); // do not yet erase !
+            }
+          }
+        }
+
+        if (!Changed)
+          break;
+
+        // Now eliminate all removed intrinsics
+        llvm::erase_if(NextList, [](Instruction *I) {
+          if (I->getParent()) {
+            return false;
+          } else {
+            I->deleteValue();
+            return true;
+          }
+        });
+      }
+
+      CollapseableSideNoaliasIntrinsics = NextList;
+    } while (CollapseableSideNoaliasIntrinsics.size() > 1);
+  }
+}
+
+// Look at users of llvm.side.noalias to find PHI nodes that are used as a side
+// channel
+static void deduceSideChannelPHIs(SideChannelWorklist &SideNoAliasIntrinsics,
+                                  InstructionSet &out_SideChannelPHIs,
+                                  InstructionSet &out_NoAliasArgGuard) {
+  LLVM_DEBUG(llvm::dbgs() << "-- Looking up up sidechannel PHI nodes\n");
+  for (Instruction *SNI : SideNoAliasIntrinsics) {
+    SideChannelWorklist worklist = {SNI};
+    while (!worklist.empty()) {
+      Instruction *worker = worklist.pop_back_val();
+      for (auto *SNIUser_ : worker->users()) {
+        Instruction *SNIUser = dyn_cast<Instruction>(SNIUser_);
+        if (SNIUser == nullptr)
+          continue;
+
+        if (isa<PHINode>(SNIUser)) {
+          // Identify as a sidechannel PHI
+          if (out_SideChannelPHIs.insert(cast<PHINode>(SNIUser)).second) {
+            LLVM_DEBUG(llvm::dbgs() << "--- " << *SNIUser << "\n");
+            // and propagate
+            worklist.push_back(SNIUser);
+          }
+        } else if (isa<SelectInst>(SNIUser) || isa<BitCastInst>(SNIUser) ||
+                   isa<AddrSpaceCastInst>(SNIUser)) {
+          // look through select/bitcast/addressspacecast
+          worklist.push_back(SNIUser);
+        } else {
+          if (auto *CB = dyn_cast<CallBase>(SNIUser)) {
+            if (CB->getIntrinsicID() == Intrinsic::noalias_arg_guard) {
+              assert(CB->getOperand(1) == worker &&
+                     "a noalias.arg.guard side channel should be linked to "
+                     "operand 1");
+              out_NoAliasArgGuard.insert(CB);
+            }
+          }
+          // load/store/side.noalias/arg.guard -> stop looking
+        }
+      }
+    }
+  }
+}
+
+bool PropagateAndConvertNoAliasPass::doit(Function &F, DominatorTree &DT) {
+  LLVM_DEBUG(llvm::dbgs() << "PropagateAndConvertNoAliasPass:\n");
+  LLVM_DEBUG(llvm::dbgs() << "- gathering intrinsics, stores, loads:\n");
+
+  // PHASE 0: find interesting instructions
+  // - Find all:
+  // -- Propagatable noalias intrinsics
+  // -- Load instructions
+  // -- Store instructions
+  SideChannelWorklist InstructionsForSideChannel;
+  SideChannelWorklist LoadStoreIntrinsicInstructions;
+  SideChannelWorklist LookThroughIntrinsics;
+  SideChannelWorklist CollapseableSideNoaliasIntrinsics;
+  ValueType2CastMap VT2C;
+  InstructionSet SideChannelPHIs;
+  SideChannelWorklist DegeneratedNoAliasAndNoAliasArgGuards;
+  SideChannelWorklist RemainingNoAliasArgGuards;
+  InstructionSet DecentNoAliasArgGuards;
+
+  for (auto &BB : F) {
+    for (auto &I : BB) {
+      if (auto CB = dyn_cast<CallBase>(&I)) {
+        auto ID = CB->getIntrinsicID();
+        if (ID == Intrinsic::noalias) {
+          LLVM_DEBUG(llvm::dbgs() << "-- found intrinsic:" << I << "\n");
+          auto Op0 = I.getOperand(0);
+          if (isa<UndefValue>(Op0)) {
+            LLVM_DEBUG(llvm::dbgs() << "--- degenerated\n");
+            DegeneratedNoAliasAndNoAliasArgGuards.push_back(&I);
+          } else {
+            InstructionsForSideChannel.push_back(&I);
+            LoadStoreIntrinsicInstructions.push_back(&I);
+            LookThroughIntrinsics.push_back(&I);
+          }
+        } else if (ID == Intrinsic::noalias_arg_guard) {
+          LLVM_DEBUG(llvm::dbgs() << "-- found intrinsic:" << I << "\n");
+          auto Op0 = I.getOperand(0);
+          auto Op1 = I.getOperand(1);
+          if (isa<UndefValue>(Op0) || isa<UndefValue>(Op1) || (Op0 == Op1)) {
+            LLVM_DEBUG(llvm::dbgs() << "--- degenerated\n");
+            DegeneratedNoAliasAndNoAliasArgGuards.push_back(&I);
+          } else {
+            RemainingNoAliasArgGuards.push_back(&I);
+          }
+        } else if (ID == Intrinsic::side_noalias) {
+          CollapseableSideNoaliasIntrinsics.push_back(&I);
+        }
+      } else if (auto LI = dyn_cast<LoadInst>(&I)) {
+        LLVM_DEBUG(llvm::dbgs() << "-- found load:" << I << "\n");
+        LoadStoreIntrinsicInstructions.push_back(LI);
+      } else if (auto SI = dyn_cast<StoreInst>(&I)) {
+        LLVM_DEBUG(llvm::dbgs() << "-- found store:" << I << "\n");
+        LoadStoreIntrinsicInstructions.push_back(SI);
+      }
+    }
+  }
+
+  // When there are no noalias related intrinsics, don't do anything.
+  if (DegeneratedNoAliasAndNoAliasArgGuards.empty() &&
+      InstructionsForSideChannel.empty() &&
+      CollapseableSideNoaliasIntrinsics.empty() &&
+      RemainingNoAliasArgGuards.empty()) {
+    LLVM_DEBUG(llvm::dbgs() << "- Nothing to do\n");
+    return false;
+  }
+
+  LLVM_DEBUG(
+      llvm::dbgs() << "- Looking through degenerated llvm.noalias.arg.guard\n");
+  for (Instruction *I : DegeneratedNoAliasAndNoAliasArgGuards) {
+    I->replaceAllUsesWith(I->getOperand(0));
+    I->eraseFromParent();
+  }
+
+  LLVM_DEBUG(llvm::dbgs() << "- Retrieving sidechannel PHI nodes and decent "
+                             "llvm.noalias.arg.guard\n");
+  deduceSideChannelPHIs(CollapseableSideNoaliasIntrinsics, SideChannelPHIs,
+                        DecentNoAliasArgGuards);
+
+  LLVM_DEBUG(
+      llvm::dbgs() << "- looking through remaining llvm.noalias.arg.guard");
+  for (Instruction *I : RemainingNoAliasArgGuards) {
+    if (DecentNoAliasArgGuards.find(I) != DecentNoAliasArgGuards.end()) {
+      InstructionsForSideChannel.push_back(I);
+      LoadStoreIntrinsicInstructions.push_back(I);
+      LookThroughIntrinsics.push_back(I);
+    } else {
+      I->replaceAllUsesWith(I->getOperand(0));
+      I->eraseFromParent();
+    }
+  }
+
+  LLVM_DEBUG(llvm::dbgs() << "- Find out what to do:\n");
+
+  // PHASE 1: forward pass:
+  // - Start with all intrinsics
+  // -- Track all users
+  // -- Interesting users (noalias intrinsics, select, PHI, load/store)
+  // -- Do this recursively for users that we can look through
+  I2Deps Handled; // instruction -> { dependencies }
+  SideChannelWorklist
+      CreationList; // Tracks all keys in Handled, but in a reproducable way
+  propagateInstructionsForSideChannel(InstructionsForSideChannel, Handled,
+                                      CreationList, SideChannelPHIs);
+
+  // PHASE 2: add missing load/store/intrinsic instructions:
+  for (auto *I : LoadStoreIntrinsicInstructions) {
+    if (isa<LoadInst>(I)) {
+      if (Handled.insert(I2Deps::value_type(I, {nullptr})).second)
+        CreationList.push_back(I);
+    } else { // Store or llvm.no_alias
+      if (Handled.insert(I2Deps::value_type(I, {nullptr, nullptr})).second)
+        CreationList.push_back(I);
+    }
+  }
+
+#if !defined(NDEBUG)
+  auto dumpit = [](I2Deps::value_type &H) {
+    auto &out = llvm::dbgs();
+    out << *H.first << " -> {";
+    bool comma = false;
+    for (auto D : H.second) {
+      if (comma)
+        out << ",";
+      comma = true;
+      if (D == nullptr) {
+        out << "nullptr";
+      } else {
+        out << *D;
+      }
+    }
+    out << "}\n";
+  };
+#endif
+
+  // PHASE 3: reconstruct alternative tree
+  // - detected dependencies: replace them by new instructions
+  // - undetected dependencies: use the original dependency
+  // NOTE: See explanation in propagateInstructionsForSideChannel for more
+  // information !
+  LLVM_DEBUG(llvm::dbgs() << "- Reconstructing tree:\n");
+
+  SideChannelWorklist UnresolvedPHI;
+  SmallDenseMap<Instruction *, Value *, 16> I2NewV;
+  SmallDenseMap<Instruction *, Value *, 16> I2ArgGuard;
+
+  auto getNewIOrOperand = [&](Instruction *DepOp, Value *OrigOp) {
+    assert(((!DepOp) || I2NewV.count(DepOp)) && "DepOp should be known");
+    return DepOp ? static_cast<Value *>(I2NewV[DepOp]) : OrigOp;
+  };
+
+  // Helper lambda for inserting a new noalias.arg.guard
+  auto setNewNoaliasArgGuard = [&](Instruction *I, unsigned Index,
+                                   Instruction *DepOp) {
+    auto *SideOp = cast<Instruction>(I2NewV[DepOp]);
+    // if we get here, the operand has to be an 'Instruction'
+    // (otherwise, DepOp would not be set).
+    auto *OpI = cast<Instruction>(I->getOperand(Index));
+    auto &ArgGuard = I2ArgGuard[OpI];
+    if (ArgGuard == nullptr) {
+      // create the instruction close to the origin, so that we don't introduce
+      // bad dependencies
+      auto InsertionPointIt = OpI->getIterator();
+      ++InsertionPointIt;
+      if (isa<PHINode>(OpI)) {
+        auto End = OpI->getParent()->end();
+        while (InsertionPointIt != End) {
+          if (!isa<PHINode>(*InsertionPointIt))
+            break;
+          ++InsertionPointIt;
+        }
+      }
+      IRBuilder<> BuilderForArgs(OpI->getParent(), InsertionPointIt);
+      ArgGuard = BuilderForArgs.CreateNoAliasArgGuard(
+          OpI, createBitOrPointerOrAddrSpaceCast(SideOp, OpI->getType(), VT2C),
+          OpI->getName() + ".guard");
+    }
+    I->setOperand(Index, ArgGuard);
+  };
+
+  // Map known side.noalias that are not handle to themselves
+  for (auto SNI : CollapseableSideNoaliasIntrinsics)
+    if (Handled.find(SNI) == Handled.end())
+      I2NewV[SNI] = SNI;
+
+  // We are doing a number of sweeps. This should always end. Normally the
+  // amount of sweeps is low. During initial development, a number of bugs where
+  // found by putting a hard limit on the the amount.
+  unsigned Watchdog = 1000000; // Only used in assertions build
+  (void)Watchdog;
+  for (auto CloneableInst : CreationList) {
+    assert(Handled.count(CloneableInst) &&
+           "Entries in CreationList must also be in Handled");
+    assert(!Handled[CloneableInst].empty() &&
+           "Only non-empty items should be added to the CreationList");
+
+    LLVM_DEBUG(llvm::dbgs() << "- "; dumpit(*Handled.find(CloneableInst)));
+    SideChannelWorklist Worklist = {CloneableInst};
+
+    while (!Worklist.empty()) {
+      Instruction *I = Worklist.back();
+
+      if (I2NewV.count(I)) {
+        // already exists - skip
+        Worklist.pop_back();
+        continue;
+      }
+
+      LLVM_DEBUG(llvm::dbgs() << "-- Reconstructing:" << *I << "\n");
+
+      // Check if we have all the needed arguments
+      auto HandledIt = Handled.find(I);
+      if (HandledIt == Handled.end()) {
+        // This can happen after propagation of a llvm.noalias.arg.guard
+        Worklist.pop_back();
+        I2NewV[I] = I;
+        LLVM_DEBUG(llvm::dbgs() << "--- Connected to an existing path!\n");
+        continue;
+      }
+
+      // If we are a PHI node, just create it
+      if (isa<PHINode>(I)) {
+        if (SideChannelPHIs.count(cast<PHINode>(I)) == 0) {
+          // But only if it is _not_ a sidechannel PHI node
+          // ======================================== PHI -> { ..... }
+          IRBuilder<> Builder(I);
+          I2NewV[I] = Builder.CreatePHI(I->getType(), I->getNumOperands(),
+                                        Twine("side.") + I->getName());
+
+          UnresolvedPHI.push_back(I);
+        } else {
+          I2NewV[I] = I; // Map already existing SideChannel PHI to itself
+        }
+        Worklist.pop_back();
+        continue;
+      }
+
+      LLVM_DEBUG(llvm::dbgs() << "--- "; dumpit(*HandledIt));
+      auto &Deps = HandledIt->second;
+      assert((!Deps.empty()) &&
+             "Any creatable instruction must have some dependent operands");
+      bool canCreateInstruction = true;
+      for (auto *DepOp : Deps) {
+        if (DepOp != nullptr) {
+          if (I2NewV.count(DepOp) == 0) {
+            canCreateInstruction = false;
+            Worklist.push_back(DepOp);
+          }
+        }
+      }
+#if !defined(NDEBUG)
+      if (--Watchdog == 0) {
+        llvm::errs()
+            << "PropagateAndConvertNoAlias: ERROR: WATCHDOG TRIGGERED !\n";
+        assert(false && "PropagateAndConvertNoAlias: WATCHDOG TRIGGERED");
+      }
+#endif
+      if (canCreateInstruction) {
+        Worklist.pop_back();
+        IRBuilder<> Builder(I);
+
+        if (isa<SelectInst>(I)) {
+          // ======================================== select -> { lhs, rhs }
+          I2NewV[I] = Builder.CreateSelect(
+              I->getOperand(0),
+              createBitOrPointerOrAddrSpaceCast(
+                  getNewIOrOperand(Deps[0], I->getOperand(1)), I->getType(),
+                  VT2C),
+              createBitOrPointerOrAddrSpaceCast(
+                  getNewIOrOperand(Deps[1], I->getOperand(2)), I->getType(),
+                  VT2C),
+              Twine("side.") + I->getName());
+        } else if (isa<LoadInst>(I)) {
+          // ======================================== load -> { ptr }
+          LoadInst *LI = cast<LoadInst>(I);
+
+          if (Deps[0]) {
+            if (!LI->hasNoaliasSideChannelOperand() ||
+                isa<UndefValue>(LI->getNoaliasSideChannelOperand()) ||
+                (LI->getPointerOperand() ==
+                 LI->getNoaliasSideChannelOperand())) {
+              LI->setNoaliasSideChannelOperand(
+                  createBitOrPointerOrAddrSpaceCast(
+                      I2NewV[Deps[0]], LI->getPointerOperandType(), VT2C));
+            } else {
+              // nothing to do - propagation should have happend through the
+              // side channel !
+              // TODO: we might want to add an extra check that the load
+              // sidechannel was updated
+            }
+          } else {
+            if (!LI->hasNoaliasSideChannelOperand()) {
+              LI->setNoaliasSideChannelOperand(
+                  UndefValue::get(LI->getPointerOperandType()));
+            } else {
+              // has alrady a side channel - nothing to merge
+            }
+          }
+          I2NewV[I] = I;
+        } else if (isa<StoreInst>(I)) {
+          // ======================================== store -> { val, ptr }
+          StoreInst *SI = cast<StoreInst>(I);
+
+          if (Deps[0]) {
+            // We try to store a restrict pointer - restrictness
+            Instruction *DepOp = Deps[0];
+            setNewNoaliasArgGuard(I, 0, DepOp);
+          }
+          if (Deps[1]) {
+            if (!SI->hasNoaliasSideChannelOperand() ||
+                isa<UndefValue>(SI->getNoaliasSideChannelOperand()) ||
+                (SI->getPointerOperand() ==
+                 SI->getNoaliasSideChannelOperand())) {
+              SI->setNoaliasSideChannelOperand(
+                  createBitOrPointerOrAddrSpaceCast(
+                      I2NewV[Deps[1]], SI->getPointerOperandType(), VT2C));
+            } else {
+              // nothing to do - propagation should have happend through the
+              // side channel !
+              // TODO: we might want to add an extra check that the store
+              // sidechannel was updated
+            }
+          } else {
+            if (!SI->hasNoaliasSideChannelOperand()) {
+              SI->setNoaliasSideChannelOperand(
+                  UndefValue::get(SI->getPointerOperandType()));
+            } else {
+              // has already a side channel - nothing to merge
+            }
+          }
+          I2NewV[I] = I;
+        } else if (isa<InsertValueInst>(I)) {
+          // We try to insert a restrict pointer into a struct - track it.
+          // Track generated noalias_arg_guard also in I2NewI
+          assert(Deps.size() == 1 &&
+                 "InsertValue tracks exactly one dependency");
+          Instruction *DepOp = Deps[0];
+          setNewNoaliasArgGuard(I, 1, DepOp);
+        } else {
+          // =============================== ret -> { ...... }
+          // =============================== call/invoke/intrinsic -> { ...... }
+          auto CB = dyn_cast<CallBase>(I);
+          if (CB) {
+            assert(CB && "If we get here, we should have a Call");
+            switch (CB->getIntrinsicID()) {
+            case Intrinsic::noalias: {
+              // convert
+              assert(Deps.size() == 2);
+              Value *IdentifyPSideChannel;
+              if (Deps[1]) {
+                // do the same as with the noalias_sidechannel in the load
+                // instruction
+                IdentifyPSideChannel = createBitOrPointerOrAddrSpaceCast(
+                    I2NewV[Deps[1]],
+                    I->getOperand(Intrinsic::NoAliasIdentifyPArg)->getType(),
+                    VT2C);
+              } else {
+                IdentifyPSideChannel = UndefValue::get(
+                    I->getOperand(Intrinsic::NoAliasIdentifyPArg)->getType());
+              }
+              Instruction *NewI = Builder.CreateSideNoAliasPlain(
+                  getNewIOrOperand(Deps[0], I->getOperand(0)),
+                  I->getOperand(Intrinsic::NoAliasNoAliasDeclArg),
+                  I->getOperand(Intrinsic::NoAliasIdentifyPArg),
+                  IdentifyPSideChannel,
+                  I->getOperand(Intrinsic::NoAliasIdentifyPObjIdArg),
+                  I->getOperand(Intrinsic::NoAliasScopeArg));
+              I2NewV[I] = NewI;
+              CollapseableSideNoaliasIntrinsics.push_back(NewI);
+
+              // Copy over metadata that is related to the 'getOperand(1)' (aka
+              // P)
+              AAMDNodes AAMetadata;
+              I->getAAMetadata(AAMetadata);
+              NewI->setAAMetadata(AAMetadata);
+              continue;
+            }
+            case Intrinsic::noalias_arg_guard: {
+              // no update needed - depending llvm.side_noalias/gep must have
+              // been updated
+              continue;
+            }
+            case Intrinsic::side_noalias: {
+              // update
+              assert((Deps[0] || Deps[1]) &&
+                     "side_noalias update needs a depending operand");
+              if (Deps[0])
+                I->setOperand(0, createBitOrPointerOrAddrSpaceCast(
+                                     I2NewV[Deps[0]], I->getType(), VT2C));
+              if (Deps[1])
+                I->setOperand(
+                    Intrinsic::SideNoAliasIdentifyPSideChannelArg,
+                    createBitOrPointerOrAddrSpaceCast(
+                        I2NewV[Deps[1]],
+                        I->getOperand(Intrinsic::SideNoAliasIdentifyPArg)
+                            ->getType(),
+                        VT2C));
+              I2NewV[I] = I;
+              continue;
+            }
+            default:
+              break;
+            }
+          } else {
+            assert(isa<ReturnInst>(I));
+          }
+
+          // Introduce a noalias_arg_guard for every argument that is
+          // annotated
+          assert(I->getNumOperands() == Deps.size());
+          for (unsigned i = 0, ci = I->getNumOperands(); i < ci; ++i) {
+            Instruction *DepOp = Deps[i];
+            if (DepOp) {
+              setNewNoaliasArgGuard(I, i, DepOp);
+            }
+          }
+          I2NewV[I] = I;
+        }
+      }
+    }
+  }
+
+  // Phase 4: resolve the generated PHI nodes
+  LLVM_DEBUG(llvm::dbgs() << "- Resolving " << UnresolvedPHI.size()
+                          << " PHI nodes\n");
+  for (auto *PHI_ : SideChannelPHIs) {
+    PHINode *PHI = cast<PHINode>(PHI_);
+    auto it = Handled.find(PHI);
+    if (it != Handled.end()) {
+      LLVM_DEBUG(llvm::dbgs() << "-- Orig PHI:" << *PHI << "\n");
+      auto &Deps = it->second;
+      for (unsigned i = 0, ci = Deps.size(); i < ci; ++i) {
+        LLVM_DEBUG(if (Deps[i]) llvm::dbgs()
+                   << "--- UPDATING:Deps:" << *Deps[i] << "\n");
+        Value *IncomingValue = Deps[i] ? I2NewV[Deps[i]] : nullptr;
+        if (IncomingValue) {
+          if (IncomingValue->getType() != PHI->getType()) {
+            IncomingValue = createBitOrPointerOrAddrSpaceCast(
+                IncomingValue, PHI->getType(), VT2C);
+          }
+          LLVM_DEBUG(llvm::dbgs()
+                     << "--- IncomingValue:" << *IncomingValue << "\n");
+          PHI->setIncomingValue(i, IncomingValue);
+        }
+      }
+      LLVM_DEBUG(llvm::dbgs() << "-- Adapted PHI:" << *PHI << "\n");
+    }
+  }
+
+  for (auto &PHI : UnresolvedPHI) {
+    PHINode *BasePHI = cast<PHINode>(PHI);
+    PHINode *NewPHI = cast<PHINode>(I2NewV[PHI]);
+    auto &Deps = Handled[PHI];
+
+    LLVM_DEBUG(llvm::dbgs() << "-- Orig PHI:" << *BasePHI << "\n");
+    LLVM_DEBUG(llvm::dbgs() << "-- New  PHI:" << *NewPHI << "\n");
+    LLVM_DEBUG(llvm::dbgs() << "-- Deps: " << Deps.size() << "\n");
+    for (unsigned i = 0, ci = BasePHI->getNumOperands(); i < ci; ++i) {
+      auto *BB = BasePHI->getIncomingBlock(i);
+      Value *IncomingValue =
+          Deps[i] ? I2NewV[Deps[i]] : BasePHI->getIncomingValue(i);
+      if (IncomingValue == nullptr) {
+        LLVM_DEBUG(llvm::dbgs()
+                   << "--- hmm.. operand " << i << " became undef\n");
+        IncomingValue = UndefValue::get(NewPHI->getType());
+      }
+      if (IncomingValue->getType() != NewPHI->getType()) {
+        IncomingValue = createBitOrPointerOrAddrSpaceCast(
+            IncomingValue, NewPHI->getType(), VT2C);
+      }
+      NewPHI->addIncoming(IncomingValue, BB);
+    }
+  }
+
+  // Phase 5: Removing the llvm.noalias
+  LLVM_DEBUG(llvm::dbgs() << "- Looking through intrinsics:\n");
+  for (Instruction *I : LookThroughIntrinsics) {
+    auto CB = dyn_cast<CallBase>(I);
+    if (CB->getIntrinsicID() == Intrinsic::noalias ||
+        CB->getIntrinsicID() == Intrinsic::noalias_arg_guard) {
+      LLVM_DEBUG(llvm::dbgs() << "-- Eliminating: " << *I << "\n");
+      I->replaceAllUsesWith(I->getOperand(0));
+      I->eraseFromParent();
+    } else {
+      llvm_unreachable("unhandled lookthrough intrinsic");
+    }
+  }
+
+  // Phase 6: Collapse llvm.side.noalias where possible...
+  // - hmm: should we do this as a complete separate pass ??
+  collapseSideNoalias(CollapseableSideNoaliasIntrinsics, DT);
+
+  return true;
+}
+
+} // namespace llvm

llvm/lib/Transforms/Scalar/Scalar.cpp

void llvm::initializeScalarOpts(PassRegistry &Registry) {
   initializeLowerExpectIntrinsicPass(Registry);
   initializeLowerGuardIntrinsicLegacyPassPass(Registry);
   initializeLowerWidenableConditionLegacyPassPass(Registry);
   initializeMemCpyOptLegacyPassPass(Registry);
   initializeMergeICmpsLegacyPassPass(Registry);
   initializeMergedLoadStoreMotionLegacyPassPass(Registry);
   initializeNaryReassociateLegacyPassPass(Registry);
   initializePartiallyInlineLibCallsLegacyPassPass(Registry);
+  initializePropagateAndConvertNoAliasLegacyPassPass(Registry);
   initializeReassociateLegacyPassPass(Registry);
   initializeRegToMemPass(Registry);
   initializeRewriteStatepointsForGCLegacyPassPass(Registry);
   initializeSCCPLegacyPassPass(Registry);
   initializeSROALegacyPassPass(Registry);
   initializeCFGSimplifyPassPass(Registry);
   initializeStructurizeCFGPass(Registry);
   initializeSimpleLoopUnswitchLegacyPassPass(Registry);

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

 ; CHECK-NEXT: Target Library Information
 ; CHECK-NEXT:   FunctionPass Manager
 ; CHECK-NEXT:     Module Verifier
 ; CHECK-NEXT:     Instrument function entry/exit with calls to e.g. mcount() (pre inlining)
 ; CHECK-NEXT:     Simplify the CFG
 ; CHECK-NEXT:     Dominator Tree Construction
 ; CHECK-NEXT:     SROA
 ; CHECK-NEXT:     Early CSE
+; CHECK-NEXT:     Propagate and Convert Noalias intrinsics
 ; CHECK-NEXT:     Lower 'expect' 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: Scoped NoAlias Alias Analysis
 ; CHECK-NEXT: Assumption Cache Tracker

 ; CHECK-NEXT:       Optimization Remark Emitter
 ; CHECK-NEXT:       Combine redundant instructions
 ; CHECK-NEXT:       Simplify the CFG
 ; CHECK-NEXT:     CallGraph Construction
 ; CHECK-NEXT:     Globals Alias Analysis
 ; CHECK-NEXT:     Call Graph SCC Pass Manager
 ; CHECK-NEXT:       Remove unused exception handling info
 ; CHECK-NEXT:       Function Integration/Inlining
+; CHECK-NEXT:       FunctionPass Manager
+; CHECK-NEXT:         Dominator Tree Construction
+; CHECK-NEXT:         Propagate and Convert Noalias intrinsics
 ; CHECK-NEXT:       Deduce function attributes
 ; CHECK-NEXT:       FunctionPass Manager
 ; CHECK-NEXT:         Dominator Tree Construction
 ; 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:         Function Alias Analysis Results
 ; CHECK-NEXT:         Lazy Value Information Analysis
 ; CHECK-NEXT:         Jump Threading
 ; CHECK-NEXT:         Value Propagation
 ; CHECK-NEXT:         Simplify the CFG
 ; CHECK-NEXT:         Dominator Tree Construction

 ; 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:         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:         Basic Alias Analysis (stateless AA impl)
 ; CHECK-NEXT:         Function Alias Analysis Results
 ; CHECK-NEXT:         Phi Values Analysis
 ; CHECK-NEXT:         Memory Dependence Analysis
 ; CHECK-NEXT:         Dead Store Elimination

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

 ; CHECK-NEXT: Target Library Information
 ; CHECK-NEXT:   FunctionPass Manager
 ; CHECK-NEXT:     Module Verifier
 ; CHECK-NEXT:     Instrument function entry/exit with calls to e.g. mcount() (pre inlining)
 ; CHECK-NEXT:     Simplify the CFG
 ; CHECK-NEXT:     Dominator Tree Construction
 ; CHECK-NEXT:     SROA
 ; CHECK-NEXT:     Early CSE
+; CHECK-NEXT:     Propagate and Convert Noalias intrinsics
 ; CHECK-NEXT:     Lower 'expect' 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: Scoped NoAlias Alias Analysis
 ; CHECK-NEXT: Assumption Cache Tracker

 ; CHECK-NEXT:       Optimization Remark Emitter
 ; CHECK-NEXT:       Combine redundant instructions
 ; CHECK-NEXT:       Simplify the CFG
 ; CHECK-NEXT:     CallGraph Construction
 ; CHECK-NEXT:     Globals Alias Analysis
 ; CHECK-NEXT:     Call Graph SCC Pass Manager
 ; CHECK-NEXT:       Remove unused exception handling info
 ; CHECK-NEXT:       Function Integration/Inlining
+; CHECK-NEXT:       FunctionPass Manager
+; CHECK-NEXT:         Dominator Tree Construction
+; CHECK-NEXT:         Propagate and Convert Noalias intrinsics
 ; CHECK-NEXT:       Deduce function attributes
 ; CHECK-NEXT:       Promote 'by reference' arguments to scalars
 ; CHECK-NEXT:       FunctionPass Manager
 ; CHECK-NEXT:         Dominator Tree Construction
 ; 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:         Function Alias Analysis Results
 ; CHECK-NEXT:         Lazy Value Information Analysis
 ; CHECK-NEXT:         Jump Threading
 ; CHECK-NEXT:         Value Propagation
 ; CHECK-NEXT:         Simplify the CFG
 ; CHECK-NEXT:         Dominator Tree Construction

 ; 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:         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:         Basic Alias Analysis (stateless AA impl)
 ; CHECK-NEXT:         Function Alias Analysis Results
 ; CHECK-NEXT:         Phi Values Analysis
 ; CHECK-NEXT:         Memory Dependence Analysis
 ; CHECK-NEXT:         Dead Store Elimination

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

 ; CHECK-NEXT: Target Library Information
 ; CHECK-NEXT:   FunctionPass Manager
 ; CHECK-NEXT:     Module Verifier
 ; CHECK-NEXT:     Instrument function entry/exit with calls to e.g. mcount() (pre inlining)
 ; CHECK-NEXT:     Simplify the CFG
 ; CHECK-NEXT:     Dominator Tree Construction
 ; CHECK-NEXT:     SROA
 ; CHECK-NEXT:     Early CSE
+; CHECK-NEXT:     Propagate and Convert Noalias intrinsics
 ; CHECK-NEXT:     Lower 'expect' 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: Scoped NoAlias Alias Analysis
 ; CHECK-NEXT: Assumption Cache Tracker

 ; CHECK-NEXT:       Optimization Remark Emitter
 ; CHECK-NEXT:       Combine redundant instructions
 ; CHECK-NEXT:       Simplify the CFG
 ; CHECK-NEXT:     CallGraph Construction
 ; CHECK-NEXT:     Globals Alias Analysis
 ; CHECK-NEXT:     Call Graph SCC Pass Manager
 ; CHECK-NEXT:       Remove unused exception handling info
 ; CHECK-NEXT:       Function Integration/Inlining
+; CHECK-NEXT:       FunctionPass Manager
+; CHECK-NEXT:         Dominator Tree Construction
+; CHECK-NEXT:         Propagate and Convert Noalias intrinsics
 ; CHECK-NEXT:       Deduce function attributes
 ; CHECK-NEXT:       FunctionPass Manager
 ; CHECK-NEXT:         Dominator Tree Construction
 ; 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:         Function Alias Analysis Results
 ; CHECK-NEXT:         Lazy Value Information Analysis
 ; CHECK-NEXT:         Jump Threading
 ; CHECK-NEXT:         Value Propagation
 ; CHECK-NEXT:         Simplify the CFG
 ; CHECK-NEXT:         Dominator Tree Construction

 ; 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:         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:         Basic Alias Analysis (stateless AA impl)
 ; CHECK-NEXT:         Function Alias Analysis Results
 ; CHECK-NEXT:         Phi Values Analysis
 ; CHECK-NEXT:         Memory Dependence Analysis
 ; CHECK-NEXT:         Dead Store Elimination

llvm/test/Other/pass-pipelines.ll

 ; PGOUSE:      Function Integration/Inlining
 ; PGOUSE: PGOInstrumentationUsePass
 ; PGOUSE: PGOIndirectCallPromotion
 ; PGOUSE: CallGraph Construction
 ; CHECK-O2-NEXT: Globals Alias Analysis
 ; CHECK-O2-NEXT: Call Graph SCC Pass Manager
 ; CHECK-O2-NEXT: Remove unused exception handling info
 ; CHECK-O2-NEXT: Function Integration/Inlining
+; CHECK-O2-NEXT: FunctionPass Manager
+; CHECK-O2-NEXT: Dominator Tree Construction
+; CHECK-O2-NEXT: Propagate and Convert Noalias intrinsics
 ; CHECK-O2-NEXT: Deduce function attributes
 ; Next up is the main function pass pipeline. It shouldn't be split up and
 ; should contain the main loop pass pipeline as well.
 ; CHECK-O2-NEXT: FunctionPass Manager
 ; CHECK-O2-NOT: Manager
 ; CHECK-O2: Loop Pass Manager
 ; CHECK-O2-NOT: Manager
 ; FIXME: We shouldn't be pulling out to simplify-cfg and instcombine and

llvm/test/Transforms/PropagateAndConvertNoAlias/basictest.ll

+; RUN: opt < %s -convert-noalias -verify -S | FileCheck %s
+; RUN: opt < %s -passes=convert-noalias,verify -S | FileCheck %s
+
+@gpA = common dso_local global i32* null, align 4
+
+; Function Attrs: nounwind
+define dso_local void @test01(i32* %_pA) #0 {
+entry:
+  %pA.decl = call i8* @llvm.noalias.decl.p0i8.p0p0i32.i32(i32** null, i32 0, metadata !2)
+  %pA = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i32(i32* %_pA, i8* %pA.decl, i32** null, i32 0, metadata !2), !tbaa !5, !noalias !2
+  %arrayidx = getelementptr inbounds i32, i32* %pA, i32 10
+  store i32 42, i32* %arrayidx, align 4, !tbaa !9, !noalias !2
+  %pA.2 = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i32(i32* %_pA, i8* %pA.decl, i32** null, i32 0, metadata !2), !tbaa !5, !noalias !2
+  %add.ptr = getelementptr inbounds i32, i32* %pA.2, i32 1
+  %pA.3 = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i32(i32* %add.ptr, i8* %pA.decl, i32** null, i32 0, metadata !2), !tbaa !5, !noalias !2
+  %arrayidx1 = getelementptr inbounds i32, i32* %pA.3, i32 11
+  store i32 43, i32* %arrayidx1, align 4, !tbaa !9, !noalias !2
+  ret void
+}
+
+; CHECK-LABEL: @test01(
+; CHECK-NEXT: entry:
+; CHECK-NEXT:   %pA.decl = call i8* @llvm.noalias.decl.p0i8.p0p0i32.i32(i32** null, i32 0, metadata !2)
+; CHECK-NEXT:   %0 = call i32* @llvm.side.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i32(i32* %_pA, i8* %pA.decl, i32** null, i32** undef, i32 0, metadata !2), !tbaa !5, !noalias !2
+; CHECK-NEXT:   %arrayidx = getelementptr inbounds i32, i32* %_pA, i32 10
+; CHECK-NEXT:   store i32 42, i32* %arrayidx, noalias_sidechannel i32* %0, align 4, !tbaa !9, !noalias !2
+; CHECK-NEXT:   %add.ptr = getelementptr inbounds i32, i32* %_pA, i32 1
+; CHECK-NEXT:   %arrayidx1 = getelementptr inbounds i32, i32* %add.ptr, i32 11
+; CHECK-NEXT:   store i32 43, i32* %arrayidx1, noalias_sidechannel i32* %0, align 4, !tbaa !9, !noalias !2
+; CHECK-NEXT:   ret void
+; CHECK-NEXT: }
+
+; Function Attrs: nounwind
+define dso_local i32* @test02(i32* %_pA) #0 {
+entry:
+  %pA.decl = call i8* @llvm.noalias.decl.p0i8.p0p0i32.i32(i32** null, i32 0, metadata !11)
+  %pA.1 = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i32(i32* %_pA, i8* %pA.decl, i32** null, i32 0, metadata !11), !tbaa !5, !noalias !11
+  store i32* %pA.1, i32** @gpA, align 4, !tbaa !5, !noalias !11
+  %pA.2 = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i32(i32* %_pA, i8* %pA.decl, i32** null, i32 0, metadata !11), !tbaa !5, !noalias !11
+  ret i32* %pA.2
+}
+
+; CHECK-LABEL: @test02(
+; CHECK-NEXT: entry:
+; CHECK-NEXT:   %pA.decl = call i8* @llvm.noalias.decl.p0i8.p0p0i32.i32(i32** null, i32 0, metadata !11)
+; CHECK-NEXT:   %0 = call i32* @llvm.side.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i32(i32* %_pA, i8* %pA.decl, i32** null, i32** undef, i32 0, metadata !11), !tbaa !5, !noalias !11
+; CHECK-NEXT:   %pA.1.guard = call i32* @llvm.noalias.arg.guard.p0i32.p0i32(i32* %_pA, i32* %0)
+; CHECK-NEXT:   store i32* %pA.1.guard, i32** @gpA, noalias_sidechannel i32** undef, align 4, !tbaa !5, !noalias !11
+; CHECK-NEXT:   %pA.2.guard = call i32* @llvm.noalias.arg.guard.p0i32.p0i32(i32* %_pA, i32* %0)
+; CHECK-NEXT:   ret i32* %pA.2.guard
+; CHECK-NEXT: }
+
+
+; Function Attrs: argmemonly nounwind
+declare i8* @llvm.noalias.decl.p0i8.p0p0i32.i32(i32**, i32, metadata) #1
+
+; Function Attrs: argmemonly nounwind speculatable
+declare i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i32(i32*, i8*, i32**, i32, metadata) #2
+
+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 }
+
+!llvm.module.flags = !{!0}
+!llvm.ident = !{!1}
+
+!0 = !{i32 1, !"wchar_size", i32 4}
+!1 = !{!"clang"}
+!2 = !{!3}
+!3 = distinct !{!3, !4, !"test01: pA"}
+!4 = distinct !{!4, !"test01"}
+!5 = !{!6, !6, i64 0, i64 4}
+!6 = !{!7, i64 4, !"any pointer"}
+!7 = !{!8, i64 1, !"omnipotent char"}
+!8 = !{!"Simple C/C++ TBAA"}
+!9 = !{!10, !10, i64 0, i64 4}
+!10 = !{!7, i64 4, !"int"}
+!11 = !{!12}
+!12 = distinct !{!12, !13, !"test02: pA"}
+!13 = distinct !{!13, !"test02"}

llvm/test/Transforms/PropagateAndConvertNoAlias/call.ll

+; RUN: opt < %s -convert-noalias -verify -S | FileCheck %s
+; RUN: opt < %s -passes=convert-noalias,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"
+
+; Function Attrs: nounwind
+define dso_local i32* @passP(i32* %_pA) #0 {
+entry:
+  %0 = call i8* @llvm.noalias.decl.p0i8.p0p0i32.i32(i32** null, i32 0, metadata !2)
+  %1 = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i32(i32* %_pA, i8* %0, i32** null, i32 0, metadata !2), !tbaa !5, !noalias !2
+  store i32 42, i32* %1, align 4, !tbaa !9, !noalias !2
+  %2 = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i32(i32* %_pA, i8* %0, i32** null, i32 0, metadata !2), !tbaa !5, !noalias !2
+  ret i32* %2
+}
+
+; CHECK-LABEL:  @passP(
+; CHECK-NEXT: entry:
+; CHECK-NEXT:   %0 = call i8* @llvm.noalias.decl.p0i8.p0p0i32.i32(i32** null, i32 0, metadata !2)
+; CHECK-NEXT:   %1 = call i32* @llvm.side.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i32(i32* %_pA, i8* %0, i32** null, i32** undef, i32 0, metadata !2), !tbaa !5, !noalias !2
+; CHECK-NEXT:   store i32 42, i32* %_pA, noalias_sidechannel i32* %1, align 4, !tbaa !9, !noalias !2
+; CHECK-NEXT:   %.guard = call i32* @llvm.noalias.arg.guard.p0i32.p0i32(i32* %_pA, i32* %1)
+; CHECK-NEXT:   ret i32* %.guard
+; CHECK-NEXT: }
+
+; Function Attrs: nounwind
+define dso_local void @test01(i32* %_pA) #0 {
+entry:
+  %0 = call i8* @llvm.noalias.decl.p0i8.p0p0i32.i32(i32** null, i32 0, metadata !11)
+  %1 = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i32(i32* %_pA, i8* %0, i32** null, i32 0, metadata !11), !tbaa !5, !noalias !11
+  store i32 41, i32* %1, align 4, !tbaa !9, !noalias !11
+  %2 = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i32(i32* %_pA, i8* %0, i32** null, i32 0, metadata !11), !tbaa !5, !noalias !11
+  %call = call i32* @passP(i32* %2), !noalias !11
+  store i32 43, i32* %call, align 4, !tbaa !9, !noalias !11
+  ret void
+}
+
+; CHECK-LABEL: @test01(
+; CHECK-NEXT: entry:
+; CHECK-NEXT:   %0 = call i8* @llvm.noalias.decl.p0i8.p0p0i32.i32(i32** null, i32 0, metadata !11)
+; CHECK-NEXT:   %1 = call i32* @llvm.side.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i32(i32* %_pA, i8* %0, i32** null, i32** undef, i32 0, metadata !11), !tbaa !5, !noalias !11
+; CHECK-NEXT:   store i32 41, i32* %_pA, noalias_sidechannel i32* %1, align 4, !tbaa !9, !noalias !11
+; CHECK-NEXT:   %.guard = call i32* @llvm.noalias.arg.guard.p0i32.p0i32(i32* %_pA, i32* %1)
+; CHECK-NEXT:   %call = call i32* @passP(i32* %.guard), !noalias !11
+; CHECK-NEXT:   store i32 43, i32* %call, noalias_sidechannel i32* undef, align 4, !tbaa !9, !noalias !11
+; CHECK-NEXT:   ret void
+; CHECK-NEXT: }
+
+; Function Attrs: nounwind
+define dso_local void @test02(i32* %_pA) #0 {
+entry:
+  %0 = call i8* @llvm.noalias.decl.p0i8.p0p0i32.i32(i32** null, i32 0, metadata !11)
+  %1 = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i32(i32* %_pA, i8* %0, i32** null, i32 0, metadata !11), !tbaa !5, !noalias !11
+  store i32 41, i32* %1, align 4, !tbaa !9, !noalias !11
+  %2 = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i32(i32* %_pA, i8* %0, i32** null, i32 0, metadata !11), !tbaa !5, !noalias !11
+  br label %block
+
+block:
+  %tmp0 = phi i32* [ %2, %entry ]
+  %tmp1 = phi i32* [ %1, %entry ]
+  %call = call i32* @passP(i32* %tmp0), !noalias !11
+  store i32 43, i32* %call, align 4, !tbaa !9, !noalias !11
+  ret void
+}
+
+
+; CHECK-LABEL: @test02(
+; CHECK-NEXT: entry:
+; CHECK-NEXT:   %0 = call i8* @llvm.noalias.decl.p0i8.p0p0i32.i32(i32** null, i32 0, metadata !11)
+; CHECK-NEXT:   %1 = call i32* @llvm.side.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i32(i32* %_pA, i8* %0, i32** null, i32** undef, i32 0, metadata !11), !tbaa !5, !noalias !11
+; CHECK-NEXT:   store i32 41, i32* %_pA, noalias_sidechannel i32* %1, align 4, !tbaa !9, !noalias !11
+; CHECK-NEXT:   br label %block
+; CHECK: block:
+; CHECK-NEXT:   %side.tmp0 = phi i32* [ %1, %entry ]
+; CHECK-NEXT:   %tmp0 = phi i32* [ %_pA, %entry ]
+; CHECK-NEXT:   %side.tmp1 = phi i32* [ %1, %entry ]
+; CHECK-NEXT:   %tmp1 = phi i32* [ %_pA, %entry ]
+; CHECK-NEXT:   %tmp0.guard = call i32* @llvm.noalias.arg.guard.p0i32.p0i32(i32* %tmp0, i32* %side.tmp0)
+; CHECK-NEXT:   %call = call i32* @passP(i32* %tmp0.guard), !noalias !11
+; CHECK-NEXT:   store i32 43, i32* %call, noalias_sidechannel i32* undef, align 4, !tbaa !9, !noalias !11
+; CHECK-NEXT:   ret void
+; CHECK-NEXT: }
+
+; Function Attrs: argmemonly nounwind
+declare i8* @llvm.noalias.decl.p0i8.p0p0i32.i32(i32**, i32, metadata) #2
+
+; Function Attrs: argmemonly nounwind speculatable
+declare i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i32(i32*, i8*, i32**, i32, metadata) #3
+
+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 willreturn }
+attributes #2 = { argmemonly nounwind }
+attributes #3 = { argmemonly nounwind speculatable }
+attributes #4 = { nounwind readnone speculatable }
+attributes #5 = { nounwind readnone }
+
+!llvm.module.flags = !{!0}
+!llvm.ident = !{!1}
+
+!0 = !{i32 1, !"wchar_size", i32 4}
+!1 = !{!"clang"}
+!2 = !{!3}
+!3 = distinct !{!3, !4, !"passP: pA"}
+!4 = distinct !{!4, !"passP"}
+!5 = !{!6, !6, i64 0, i64 4}
+!6 = !{!7, i64 4, !"any pointer"}
+!7 = !{!8, i64 1, !"omnipotent char"}
+!8 = !{!"Simple C/C++ TBAA"}
+!9 = !{!10, !10, i64 0, i64 4}
+!10 = !{!7, i64 4, !"int"}
+!11 = !{!12}
+!12 = distinct !{!12, !13, !"test01: p1"}
+!13 = distinct !{!13, !"test01"}

llvm/test/Transforms/PropagateAndConvertNoAlias/degenerated.ll

+; RUN: opt < %s -convert-noalias -verify -S | FileCheck %s
+; RUN: opt < %s -passes=convert-noalias,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"
+
+; Function Attrs: nounwind
+define dso_local void @test01(i32* %_pA) local_unnamed_addr #0 {
+entry:
+  %0 = call i8* @llvm.noalias.decl.p0i8.p0p0i32.i32(i32** null, i32 0, metadata !2)
+  %1 = call i32* @llvm.side.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i32(i32* %_pA, i8* %0, i32** null, i32** undef, i32 0, metadata !2), !tbaa !5, !noalias !2
+  store i32 41, i32* %_pA, noalias_sidechannel i32* %1, align 4, !tbaa !9, !noalias !2
+  %.guard = call i32* @llvm.noalias.arg.guard.p0i32.p0i32(i32* %_pA, i32* %1)
+  %2 = call i8* @llvm.noalias.decl.p0i8.p0p0i32.i32(i32** null, i32 0, metadata !11) #5, !noalias !2
+  %3 = call i32* @llvm.side.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i32(i32* %.guard, i8* %2, i32** null, i32** undef, i32 0, metadata !11) #3, !tbaa !5, !noalias !14
+  store i32 42, i32* %.guard, noalias_sidechannel i32* %3, align 4, !tbaa !9, !noalias !14
+  %.guard.guard.guard.guard.i = call i32* @llvm.noalias.arg.guard.p0i32.p0i32(i32* %.guard, i32* %3) #1
+  store i32 43, i32* %.guard.guard.guard.guard.i, noalias_sidechannel i32* undef, align 4, !tbaa !9, !noalias !2
+  ret void
+}
+
+; CHECK-LABEL: @test01(
+; CHECK-NEXT: entry:
+; CHECK-NEXT:   %0 = call i8* @llvm.noalias.decl.p0i8.p0p0i32.i32(i32** null, i32 0, metadata !2)
+; CHECK-NEXT:   %1 = call i32* @llvm.side.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i32(i32* %_pA, i8* %0, i32** null, i32** undef, i32 0, metadata !2), !tbaa !5, !noalias !2
+; CHECK-NEXT:   store i32 41, i32* %_pA, noalias_sidechannel i32* %1, align 4, !tbaa !9, !noalias !2
+; CHECK-NEXT:   %2 = call i8* @llvm.noalias.decl.p0i8.p0p0i32.i32(i32** null, i32 0, metadata !11) #5, !noalias !2
+; CHECK-NEXT:   %3 = call i32* @llvm.side.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i32(i32* %1, i8* %2, i32** null, i32** undef, i32 0, metadata !11) #3, !tbaa !5, !noalias !14
+; CHECK-NEXT:   store i32 42, i32* %_pA, noalias_sidechannel i32* %3, align 4, !tbaa !9, !noalias !14
+; CHECK-NEXT:   store i32 43, i32* %_pA, noalias_sidechannel i32* %3, align 4, !tbaa !9, !noalias !2
+; CHECK-NEXT:   ret void
+; CHECK-NEXT: }
+
+; Function Attrs: nounwind
+define dso_local void @test02(i32* %_pA) local_unnamed_addr #0 {
+entry:
+  %0 = call i8* @llvm.noalias.decl.p0i8.p0p0i32.i32(i32** null, i32 0, metadata !2)
+  %1 = call i32* @llvm.side.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i32(i32* %_pA, i8* %0, i32** null, i32** undef, i32 0, metadata !2), !tbaa !5, !noalias !2
+  store i32 41, i32* %_pA, noalias_sidechannel i32* %1, align 4, !tbaa !9, !noalias !2
+  %.guard = call i32* @llvm.noalias.arg.guard.p0i32.p0i32(i32* %_pA, i32* %1)
+  %2 = call i8* @llvm.noalias.decl.p0i8.p0p0i32.i32(i32** null, i32 0, metadata !11) #5, !noalias !2
+  %3 = call i32* @llvm.side.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i32(i32* %.guard, i8* %2, i32** null, i32** undef, i32 0, metadata !11) #3, !tbaa !5, !noalias !14
+  store i32 42, i32* %.guard, noalias_sidechannel i32* %3, align 4, !tbaa !9, !noalias !14
+  %deg01 = call i32* @llvm.noalias.arg.guard.p0i32.p0i32(i32* %.guard, i32* %.guard) #1
+  %deg02 = call i32* @llvm.noalias.arg.guard.p0i32.p0i32(i32* %.guard, i32* undef) #1
+  call void @foo(i32* %deg01), !noalias !14
+  call void @foo(i32* %deg01), !noalias !14
+  ret void
+}
+
+
+; Function Attrs: argmemonly nounwind
+declare i8* @llvm.noalias.decl.p0i8.p0p0i32.i32(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: nounwind readnone speculatable
+declare i32* @llvm.side.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i32(i32*, i8*, i32**, i32**, i32, metadata) #3
+
+; Function Attrs: nounwind readnone
+declare i32* @llvm.noalias.arg.guard.p0i32.p0i32(i32*, i32*) #4
+
+declare void @foo(i32*)
+
+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 speculatable }
+attributes #4 = { nounwind readnone }
+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, !"test01: p1"}
+!4 = distinct !{!4, !"test01"}
+!5 = !{!6, !6, i64 0, i64 4}
+!6 = !{!7, i64 4, !"any pointer"}
+!7 = !{!8, i64 1, !"omnipotent char"}
+!8 = !{!"Simple C/C++ TBAA"}
+!9 = !{!10, !10, i64 0, i64 4}
+!10 = !{!7, i64 4, !"int"}
+!11 = !{!12}
+!12 = distinct !{!12, !13, !"passP: pA"}
+!13 = distinct !{!13, !"passP"}
+!14 = !{!12, !3}

llvm/test/Transforms/PropagateAndConvertNoAlias/double_noalias.ll

+; RUN: opt < %s -convert-noalias -verify -S | FileCheck %s
+; RUN: opt < %s -passes=convert-noalias,verify -S | FileCheck %s
+
+target datalayout = "e-i8:8:8-i16:16:16-i32:32:32-i64:32:32-f16:16:16-f32:32:32-f64:32:32-p:32:32:32:32:8-s0:32:32-a0:0:32-S32-n16:32-v128:32:32-P0-p0:32:32:32:32:8"
+
+; Function Attrs: nounwind
+define dso_local void @test_rr(i32** %_p) #0 !noalias !2 {
+entry:
+  %0 = call i8* @llvm.noalias.decl.p0i8.p0p0p0i32.i32(i32*** null, i32 0, metadata !5)
+  %1 = call i32** @llvm.noalias.p0p0i32.p0i8.p0p0p0i32.i32(i32** %_p, i8* %0, i32*** null, i32 0, metadata !5), !tbaa !7, !noalias !11
+  %arrayidx = getelementptr inbounds i32*, i32** %1, i32 1
+  %2 = load i32*, i32** %arrayidx, align 4, !tbaa !7, !noalias !11
+  %3 = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i32(i32* %2, i8* null, i32** %arrayidx, i32 0, metadata !2), !tbaa !7, !noalias !11
+  %arrayidx1 = getelementptr inbounds i32, i32* %3, i32 2
+  %4 = load i32, i32* %arrayidx1, align 4, !tbaa !12, !noalias !11
+  %add = add nsw i32 %4, 1
+  %5 = call i32** @llvm.noalias.p0p0i32.p0i8.p0p0p0i32.i32(i32** %_p, i8* %0, i32*** null, i32 0, metadata !5), !tbaa !7, !noalias !11
+  %6 = load i32*, i32** %5, align 4, !tbaa !7, !noalias !11
+  %7 = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i32(i32* %6, i8* null, i32** %5, i32 0, metadata !2), !tbaa !7, !noalias !11
+  store i32 %add, i32* %7, align 4, !tbaa !12, !noalias !11
+  ret void
+}
+
+; CHECK-LABEL: @test_rr(
+; CHECK-NEXT: entry:
+; CHECK-NEXT:   %0 = call i8* @llvm.noalias.decl.p0i8.p0p0p0i32.i32(i32*** null, i32 0, metadata !5)
+; CHECK-NEXT:   %1 = call i32** @llvm.side.noalias.p0p0i32.p0i8.p0p0p0i32.p0p0p0i32.i32(i32** %_p, i8* %0, i32*** null, i32*** undef, i32 0, metadata !5), !tbaa !7, !noalias !11
+; CHECK-NEXT:   %arrayidx = getelementptr inbounds i32*, i32** %_p, i32 1
+; CHECK-NEXT:   %2 = load i32*, i32** %arrayidx, noalias_sidechannel i32** %1, align 4, !tbaa !7, !noalias !11
+; CHECK-NEXT:   %3 = call i32* @llvm.side.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i32(i32* %2, i8* null, i32** %arrayidx, i32** %1, i32 0, metadata !2), !tbaa !7, !noalias !11
+; CHECK-NEXT:   %arrayidx1 = getelementptr inbounds i32, i32* %2, i32 2
+; CHECK-NEXT:   %4 = load i32, i32* %arrayidx1, noalias_sidechannel i32* %3, align 4, !tbaa !12, !noalias !11
+; CHECK-NEXT:   %add = add nsw i32 %4, 1
+; CHECK-NEXT:   %5 = load i32*, i32** %_p, noalias_sidechannel i32** %1, align 4, !tbaa !7, !noalias !11
+; CHECK-NEXT:   %6 = call i32* @llvm.side.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i32(i32* %5, i8* null, i32** %_p, i32** %1, i32 0, metadata !2), !tbaa !7, !noalias !11
+; CHECK-NEXT:   store i32 %add, i32* %5, noalias_sidechannel i32* %6, align 4, !tbaa !12, !noalias !11
+; CHECK-NEXT:   ret void
+; CHECK-NEXT: }
+
+; Function Attrs: argmemonly nounwind speculatable
+declare i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i32(i32*, i8*, i32**, i32, metadata) #1
+
+; Function Attrs: argmemonly nounwind
+declare i8* @llvm.noalias.decl.p0i8.p0p0p0i32.i32(i32***, i32, metadata) #2
+
+; Function Attrs: argmemonly nounwind speculatable
+declare i32** @llvm.noalias.p0p0i32.p0i8.p0p0p0i32.i32(i32**, i8*, i32***, i32, metadata) #1
+
+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 speculatable }
+attributes #2 = { argmemonly nounwind }
+
+!llvm.module.flags = !{!0}
+!llvm.ident = !{!1}
+
+!0 = !{i32 1, !"wchar_size", i32 4}
+!1 = !{!"clang"}
+!2 = !{!3}
+!3 = distinct !{!3, !4, !"test_rr: unknown scope"}
+!4 = distinct !{!4, !"test_rr"}
+!5 = !{!6}
+!6 = distinct !{!6, !4, !"test_rr: rprp"}
+!7 = !{!8, !8, i64 0, i64 4}
+!8 = !{!9, i64 4, !"any pointer"}
+!9 = !{!10, i64 1, !"omnipotent char"}
+!10 = !{!"Simple C/C++ TBAA"}
+!11 = !{!6, !3}
+!12 = !{!13, !13, i64 0, i64 4}
+!13 = !{!9, i64 4, !"int"}

llvm/test/Transforms/PropagateAndConvertNoAlias/inlined.ll

+; RUN: opt < %s -convert-noalias -verify -S | FileCheck %s
+; RUN: opt < %s -passes=convert-noalias,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"
+
+; Function Attrs: nounwind
+define dso_local void @test01(i32* %_pA) local_unnamed_addr #0 {
+entry:
+  %0 = call i8* @llvm.noalias.decl.p0i8.p0p0i32.i32(i32** null, i32 0, metadata !2)
+  %1 = call i32* @llvm.side.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i32(i32* %_pA, i8* %0, i32** null, i32** undef, i32 0, metadata !2), !tbaa !5, !noalias !2
+  store i32 41, i32* %_pA, noalias_sidechannel i32* %1, align 4, !tbaa !9, !noalias !2
+  %.guard = call i32* @llvm.noalias.arg.guard.p0i32.p0i32(i32* %_pA, i32* %1)
+  %2 = call i8* @llvm.noalias.decl.p0i8.p0p0i32.i32(i32** null, i32 0, metadata !11) #5, !noalias !2
+  %3 = call i32* @llvm.side.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i32(i32* %.guard, i8* %2, i32** null, i32** undef, i32 0, metadata !11) #3, !tbaa !5, !noalias !14
+  store i32 42, i32* %.guard, noalias_sidechannel i32* %3, align 4, !tbaa !9, !noalias !14
+  %.guard.guard.guard.guard.i = call i32* @llvm.noalias.arg.guard.p0i32.p0i32(i32* %.guard, i32* %3) #1
+  store i32 43, i32* %.guard.guard.guard.guard.i, noalias_sidechannel i32* undef, align 4, !tbaa !9, !noalias !2
+  ret void
+}
+
+; CHECK-LABEL: @test01(
+; CHECK-NEXT: entry:
+; CHECK-NEXT:   %0 = call i8* @llvm.noalias.decl.p0i8.p0p0i32.i32(i32** null, i32 0, metadata !2)
+; CHECK-NEXT:   %1 = call i32* @llvm.side.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i32(i32* %_pA, i8* %0, i32** null, i32** undef, i32 0, metadata !2), !tbaa !5, !noalias !2
+; CHECK-NEXT:   store i32 41, i32* %_pA, noalias_sidechannel i32* %1, align 4, !tbaa !9, !noalias !2
+; CHECK-NEXT:   %2 = call i8* @llvm.noalias.decl.p0i8.p0p0i32.i32(i32** null, i32 0, metadata !11) #5, !noalias !2
+; CHECK-NEXT:   %3 = call i32* @llvm.side.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i32(i32* %1, i8* %2, i32** null, i32** undef, i32 0, metadata !11) #3, !tbaa !5, !noalias !14
+; CHECK-NEXT:   store i32 42, i32* %_pA, noalias_sidechannel i32* %3, align 4, !tbaa !9, !noalias !14
+; CHECK-NEXT:   store i32 43, i32* %_pA, noalias_sidechannel i32* %3, align 4, !tbaa !9, !noalias !2
+; CHECK-NEXT:   ret void
+; CHECK-NEXT: }
+
+; Function Attrs: argmemonly nounwind
+declare i8* @llvm.noalias.decl.p0i8.p0p0i32.i32(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: nounwind readnone speculatable
+declare i32* @llvm.side.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i32(i32*, i8*, i32**, i32**, i32, metadata) #3
+
+; Function Attrs: nounwind readnone
+declare i32* @llvm.noalias.arg.guard.p0i32.p0i32(i32*, i32*) #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 speculatable }
+attributes #4 = { nounwind readnone }
+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, !"test01: p1"}
+!4 = distinct !{!4, !"test01"}
+!5 = !{!6, !6, i64 0, i64 4}
+!6 = !{!7, i64 4, !"any pointer"}
+!7 = !{!8, i64 1, !"omnipotent char"}
+!8 = !{!"Simple C/C++ TBAA"}
+!9 = !{!10, !10, i64 0, i64 4}
+!10 = !{!7, i64 4, !"int"}
+!11 = !{!12}
+!12 = distinct !{!12, !13, !"passP: pA"}
+!13 = distinct !{!13, !"passP"}
+!14 = !{!12, !3}

llvm/test/Transforms/PropagateAndConvertNoAlias/reduced01.ll

+; RUN: opt < %s -convert-noalias -verify -S | FileCheck %s
+; RUN: opt < %s -passes=convert-noalias,verify -S | FileCheck %s
+; RUN: opt < %s -convert-noalias -verify -convert-noalias -verify -S | FileCheck %s
+
+target datalayout = "e-i8:8:8-i16:16:16-i32:32:32-i64:32:32-f16:16:16-f32:32:32-f64:32:32-p:32:32:32:32:8-s0:32:32-a0:0:32-S32-n16:32-v128:32:32-P0-p0:32:32:32:32:8"
+
+%struct.a = type { i8 }
+
+; Function Attrs: noreturn
+define dso_local void @_Z3fooPii(i32* %_f, i32 %g) local_unnamed_addr #0 {
+entry:
+  %0 = call i8* @llvm.noalias.decl.p0i8.p0p0i32.i32(i32** null, i32 0, metadata !2)
+  %1 = call i32* @llvm.side.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i32(i32* %_f, i8* %0, i32** null, i32** undef, i32 0, metadata !2), !tbaa !5, !noalias !2
+  %2 = bitcast i32* %1 to %struct.a*
+  %3 = bitcast i32* %_f to %struct.a*
+  br label %for.cond
+
+for.cond:                                         ; preds = %for.cond, %entry
+  %side.h.0 = phi %struct.a* [ %2, %entry ], [ %h.0.guard, %for.cond ]
+  %h.0 = phi %struct.a* [ %3, %entry ], [ %h.0.guard, %for.cond ]
+  %h.0.guard = call %struct.a* @llvm.noalias.arg.guard.p0s_struct.as.p0s_struct.as(%struct.a* %h.0, %struct.a* %side.h.0)
+  %4 = getelementptr inbounds %struct.a, %struct.a* %h.0, i32 0, i32 0
+  %.unpack = load i8, i8* %4, noalias_sidechannel %struct.a* %side.h.0, align 1, !noalias !2
+  %5 = insertvalue %struct.a undef, i8 %.unpack, 0
+  %call = call i32 @_Z1b1a(%struct.a %5), !noalias !2
+  br label %for.cond
+}
+; CHECK: define dso_local void @_Z3fooPii(i32* %_f, i32 %g) local_unnamed_addr #0 {
+; CHECK-NEXT: entry:
+; CHECK-NEXT:   %0 = call i8* @llvm.noalias.decl.p0i8.p0p0i32.i32(i32** null, i32 0, metadata !2)
+; CHECK-NEXT:   %1 = call i32* @llvm.side.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i32(i32* %_f, i8* %0, i32** null, i32** undef, i32 0, metadata !2), !tbaa !5, !noalias !2
+; CHECK-NEXT:   %2 = bitcast i32* %1 to %struct.a*
+; CHECK-NEXT:   %3 = bitcast i32* %_f to %struct.a*
+; CHECK-NEXT:   br label %for.cond
+; CHECK:      for.cond:                                         ; preds = %for.cond, %entry
+; CHECK-NEXT:   %side.h.0 = phi %struct.a* [ %2, %entry ], [ %side.h.0, %for.cond ]
+; CHECK-NEXT:   %side.h.01 = phi %struct.a* [ %3, %entry ], [ %side.h.0, %for.cond ]
+; CHECK-NEXT:   %h.0 = phi %struct.a* [ %3, %entry ], [ %h.0, %for.cond ]
+; CHECK-NEXT:   %4 = getelementptr inbounds %struct.a, %struct.a* %h.0, i32 0, i32 0
+; CHECK-NEXT:   %.unpack = load i8, i8* %4, noalias_sidechannel %struct.a* %side.h.0, align 1, !noalias !2
+; CHECK-NEXT:   %5 = insertvalue %struct.a undef, i8 %.unpack, 0
+; CHECK-NEXT:   %call = call i32 @_Z1b1a(%struct.a %5), !noalias !2
+; CHECK-NEXT:   br label %for.cond
+
+
+; Function Attrs: argmemonly nounwind
+declare i8* @llvm.noalias.decl.p0i8.p0p0i32.i32(i32**, i32, metadata) #1
+
+declare dso_local i32 @_Z1b1a(%struct.a) local_unnamed_addr #2
+
+; Function Attrs: nounwind readnone
+declare %struct.a* @llvm.noalias.arg.guard.p0s_struct.as.p0s_struct.as(%struct.a*, %struct.a*) #3
+
+; Function Attrs: nounwind readnone speculatable
+declare i32* @llvm.side.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i32(i32*, i8*, i32**, i32**, i32, metadata) #4
+
+attributes #0 = { noreturn "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-frame-pointer-elim-non-leaf" "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 = { "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="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 #3 = { nounwind readnone }
+attributes #4 = { nounwind readnone speculatable }
+
+!llvm.module.flags = !{!0}
+!llvm.ident = !{!1}
+
+!0 = !{i32 1, !"wchar_size", i32 4}
+!1 = !{!"clang version 7.0.0 "}
+!2 = !{!3}
+!3 = distinct !{!3, !4, !"_Z3fooPii: f"}
+!4 = distinct !{!4, !"_Z3fooPii"}
+!5 = !{!6, !6, i64 0}
+!6 = !{!"any pointer", !7, i64 0}
+!7 = !{!"omnipotent char", !8, i64 0}
+!8 = !{!"Simple C++ TBAA"}

llvm/test/Transforms/PropagateAndConvertNoAlias/select_and_phi.ll

+; RUN: opt < %s -convert-noalias -verify -S | FileCheck %s
+; RUN: opt < %s -passes=convert-noalias,verify -S | FileCheck %s
+; RUN: opt < %s -convert-noalias -verify -convert-noalias -verify -S | FileCheck %s
+
+; Function Attrs: nounwind
+define dso_local void @test_phi01(i32* %_pA, i32** %_pB, i32 %n) #0 {
+entry:
+  %0 = call i8* @llvm.noalias.decl.p0i8.p0p0i32.i32(i32** null, i32 0, metadata !2)
+  %1 = call i8* @llvm.noalias.decl.p0i8.p0p0i32.i32(i32** null, i32 0, metadata !5)
+  %arrayidx = getelementptr inbounds i32*, i32** %_pB, i32 2
+  %2 = load i32*, i32** %arrayidx, align 4, !tbaa !7, !noalias !11
+  %3 = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i32(i32* %_pA, i8* %0, i32** null, i32 0, metadata !2), !tbaa !7, !noalias !11
+  %4 = load i32*, i32** %_pB, align 4, !tbaa !7, !noalias !11
+  %arrayidx2 = getelementptr inbounds i32*, i32** %_pB, i32 1
+  %5 = load i32*, i32** %arrayidx2, align 4, !tbaa !7, !noalias !11
+  br label %for.cond
+
+for.cond:                                         ; preds = %for.body, %entry
+  %pTmp00.0 = phi i32* [ %4, %entry ], [ %pTmp01.0, %for.body ]
+  %pTmp01.0 = phi i32* [ %5, %entry ], [ %3, %for.body ]
+  %i.0 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
+  %cmp = icmp slt i32 %i.0, %n
+  br i1 %cmp, label %for.body, label %for.cond.cleanup
+
+for.cond.cleanup:                                 ; preds = %for.cond
+  %6 = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i32(i32* %_pA, i8* %0, i32** null, i32 0, metadata !2), !tbaa !7, !noalias !11
+  store i32 99, i32* %6, align 4, !tbaa !12, !noalias !11
+  store i32 42, i32* %pTmp00.0, align 4, !tbaa !12, !noalias !11
+  %cmp5 = icmp sgt i32 %n, 5
+  %7 = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i32(i32* %2, i8* %1, i32** null, i32 0, metadata !5)
+  %cond = select i1 %cmp5, i32* %pTmp00.0, i32* %7
+  store i32 43, i32* %cond, align 4, !tbaa !12, !noalias !11
+  ret void
+
+for.body:                                         ; preds = %for.cond
+  %arrayidx3 = getelementptr inbounds i32, i32* %pTmp01.0, i32 1
+  %8 = load i32, i32* %arrayidx3, align 4, !tbaa !12, !noalias !11
+  %arrayidx4 = getelementptr inbounds i32, i32* %pTmp00.0, i32 1
+  store i32 %8, i32* %arrayidx4, align 4, !tbaa !12, !noalias !11
+  %inc = add nsw i32 %i.0, 1
+  br label %for.cond
+}
+
+; CHECK-LABEL: @test_phi01(
+; CHECK-NEXT: entry:
+; CHECK-NEXT:   %0 = call i8* @llvm.noalias.decl.p0i8.p0p0i32.i32(i32** null, i32 0, metadata !2)
+; CHECK-NEXT:   %1 = call i8* @llvm.noalias.decl.p0i8.p0p0i32.i32(i32** null, i32 0, metadata !5)
+; CHECK-NEXT:   %arrayidx = getelementptr inbounds i32*, i32** %_pB, i32 2
+; CHECK-NEXT:   %2 = load i32*, i32** %arrayidx, noalias_sidechannel i32** undef, align 4, !tbaa !7, !noalias !11
+; CHECK-NEXT:   %3 = call i32* @llvm.side.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i32(i32* %_pA, i8* %0, i32** null, i32** undef, i32 0, metadata !2), !tbaa !7, !noalias !11
+; CHECK-NEXT:   %4 = load i32*, i32** %_pB, noalias_sidechannel i32** undef, align 4, !tbaa !7, !noalias !11
+; CHECK-NEXT:   %arrayidx2 = getelementptr inbounds i32*, i32** %_pB, i32 1
+; CHECK-NEXT:   %5 = load i32*, i32** %arrayidx2, noalias_sidechannel i32** undef, align 4, !tbaa !7, !noalias !11
+; CHECK-NEXT:   br label %for.cond
+; CHECK: for.cond:
+; CHECK-NEXT:   %side.pTmp00.0 = phi i32* [ %4, %entry ], [ %side.pTmp01.0, %for.body ]
+; CHECK-NEXT:   %pTmp00.0 = phi i32* [ %4, %entry ], [ %pTmp01.0, %for.body ]
+; CHECK-NEXT:   %side.pTmp01.0 = phi i32* [ %5, %entry ], [ %3, %for.body ]
+; CHECK-NEXT:   %pTmp01.0 = phi i32* [ %5, %entry ], [ %_pA, %for.body ]
+; CHECK-NEXT:   %i.0 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
+; CHECK-NEXT:   %cmp = icmp slt i32 %i.0, %n
+; CHECK-NEXT:   br i1 %cmp, label %for.body, label %for.cond.cleanup
+; CHECK: for.cond.cleanup:
+; CHECK-NEXT:   store i32 99, i32* %_pA, noalias_sidechannel i32* %3, align 4, !tbaa !12, !noalias !11
+; CHECK-NEXT:   store i32 42, i32* %pTmp00.0, noalias_sidechannel i32* %side.pTmp00.0, align 4, !tbaa !12, !noalias !11
+; CHECK-NEXT:   %cmp5 = icmp sgt i32 %n, 5
+; CHECK-NEXT:   %6 = call i32* @llvm.side.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i32(i32* %2, i8* %1, i32** null, i32** undef, i32 0, metadata !5)
+; CHECK-NEXT:   %side.cond = select i1 %cmp5, i32* %side.pTmp00.0, i32* %6
+; CHECK-NEXT:   %cond = select i1 %cmp5, i32* %pTmp00.0, i32* %2
+; CHECK-NEXT:   store i32 43, i32* %cond, noalias_sidechannel i32* %side.cond, align 4, !tbaa !12, !noalias !11
+; CHECK-NEXT:   ret void
+; CHECK: for.body:
+; CHECK-NEXT:   %arrayidx3 = getelementptr inbounds i32, i32* %pTmp01.0, i32 1
+; CHECK-NEXT:   %7 = load i32, i32* %arrayidx3, noalias_sidechannel i32* %side.pTmp01.0, align 4, !tbaa !12, !noalias !11
+; CHECK-NEXT:   %arrayidx4 = getelementptr inbounds i32, i32* %pTmp00.0, i32 1
+; CHECK-NEXT:   store i32 %7, i32* %arrayidx4, noalias_sidechannel i32* %side.pTmp00.0, align 4, !tbaa !12, !noalias !11
+; CHECK-NEXT:   %inc = add nsw i32 %i.0, 1
+; CHECK-NEXT:   br label %for.cond
+; CHECK-NEXT: }
+
+
+; Function Attrs: nounwind
+define dso_local void @test_phi02(i32* %_pA, i32** %_pB, i32 %n) #0 {
+entry:
+  %0 = call i8* @llvm.noalias.decl.p0i8.p0p0i32.i32(i32** null, i32 0, metadata !14)
+  %1 = call i8* @llvm.noalias.decl.p0i8.p0p0i32.i32(i32** null, i32 0, metadata !17)
+  %arrayidx = getelementptr inbounds i32*, i32** %_pB, i32 2
+  %2 = load i32*, i32** %arrayidx, align 4, !tbaa !7, !noalias !19
+  %3 = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i32(i32* %_pA, i8* %0, i32** null, i32 0, metadata !14), !tbaa !7, !noalias !19
+  %4 = load i32*, i32** %_pB, align 4, !tbaa !7, !noalias !19
+  %arrayidx2 = getelementptr inbounds i32*, i32** %_pB, i32 1
+  %5 = load i32*, i32** %arrayidx2, align 4, !tbaa !7, !noalias !19
+  br label %for.cond
+
+for.cond:                                         ; preds = %for.body, %entry
+  %pTmp00.0 = phi i32* [ %4, %entry ], [ %pTmp01.0, %for.body ]
+  %pTmp01.0 = phi i32* [ %5, %entry ], [ %3, %for.body ]
+  %i.0 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
+  %cmp = icmp slt i32 %i.0, %n
+  br i1 %cmp, label %for.body, label %for.cond.cleanup
+
+for.cond.cleanup:                                 ; preds = %for.cond
+  %6 = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i32(i32* %_pA, i8* %0, i32** null, i32 0, metadata !14), !tbaa !7, !noalias !19
+  %7 = bitcast i32* %6 to i16*
+  store i16 99, i16* %7, align 2, !tbaa !20, !noalias !19
+  %8 = bitcast i32* %pTmp00.0 to i16*
+  store i16 42, i16* %8, align 2, !tbaa !20, !noalias !19
+  %cmp5 = icmp sgt i32 %n, 5
+  %9 = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i32(i32* %2, i8* %1, i32** null, i32 0, metadata !17)
+  %cond = select i1 %cmp5, i32* %pTmp00.0, i32* %9
+  %10 = bitcast i32* %cond to i16*
+  store i16 43, i16* %10, align 2, !tbaa !20, !noalias !19
+  ret void
+
+for.body:                                         ; preds = %for.cond
+  %11 = bitcast i32* %pTmp01.0 to i16*
+  %arrayidx3 = getelementptr inbounds i16, i16* %11, i32 1
+  %12 = load i16, i16* %arrayidx3, align 2, !tbaa !20, !noalias !19
+  %13 = bitcast i32* %pTmp00.0 to i16*
+  %arrayidx4 = getelementptr inbounds i16, i16* %13, i32 1
+  store i16 %12, i16* %arrayidx4, align 2, !tbaa !20, !noalias !19
+  %inc = add nsw i32 %i.0, 1
+  br label %for.cond
+}
+
+; CHECK-LABEL: @test_phi02(
+; CHECK-NEXT: entry:
+; CHECK-NEXT:   %0 = call i8* @llvm.noalias.decl.p0i8.p0p0i32.i32(i32** null, i32 0, metadata !14)
+; CHECK-NEXT:   %1 = call i8* @llvm.noalias.decl.p0i8.p0p0i32.i32(i32** null, i32 0, metadata !17)
+; CHECK-NEXT:   %arrayidx = getelementptr inbounds i32*, i32** %_pB, i32 2
+; CHECK-NEXT:   %2 = load i32*, i32** %arrayidx, noalias_sidechannel i32** undef, align 4, !tbaa !7, !noalias !19
+; CHECK-NEXT:   %3 = call i32* @llvm.side.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i32(i32* %_pA, i8* %0, i32** null, i32** undef, i32 0, metadata !14), !tbaa !7, !noalias !19
+; CHECK-NEXT:   %4 = load i32*, i32** %_pB, noalias_sidechannel i32** undef, align 4, !tbaa !7, !noalias !19
+; CHECK-NEXT:   %arrayidx2 = getelementptr inbounds i32*, i32** %_pB, i32 1
+; CHECK-NEXT:   %5 = load i32*, i32** %arrayidx2, noalias_sidechannel i32** undef, align 4, !tbaa !7, !noalias !19
+; CHECK-NEXT:   br label %for.cond
+; CHECK: for.cond:
+; CHECK-NEXT:   %side.pTmp00.0 = phi i32* [ %4, %entry ], [ %side.pTmp01.0, %for.body ]
+; CHECK-NEXT:   %pTmp00.0 = phi i32* [ %4, %entry ], [ %pTmp01.0, %for.body ]
+; CHECK-NEXT:   %side.pTmp01.0 = phi i32* [ %5, %entry ], [ %3, %for.body ]
+; CHECK-NEXT:   %pTmp01.0 = phi i32* [ %5, %entry ], [ %_pA, %for.body ]
+; CHECK-NEXT:   %i.0 = phi i32 [ 0, %entry ], [ %inc, %for.body ]
+; CHECK-NEXT:   %6 = bitcast i32* %side.pTmp00.0 to i16*
+; CHECK-NEXT:   %7 = bitcast i32* %side.pTmp01.0 to i16*
+; CHECK-NEXT:   %cmp = icmp slt i32 %i.0, %n
+; CHECK-NEXT:   br i1 %cmp, label %for.body, label %for.cond.cleanup
+; CHECK: for.cond.cleanup:
+; CHECK-NEXT:   %8 = bitcast i32* %3 to i16*
+; CHECK-NEXT:   %9 = bitcast i32* %_pA to i16*
+; CHECK-NEXT:   store i16 99, i16* %9, noalias_sidechannel i16* %8, align 2, !tbaa !20, !noalias !19
+; CHECK-NEXT:   %10 = bitcast i32* %pTmp00.0 to i16*
+; CHECK-NEXT:   store i16 42, i16* %10, noalias_sidechannel i16* %6, align 2, !tbaa !20, !noalias !19
+; CHECK-NEXT:   %cmp5 = icmp sgt i32 %n, 5
+; CHECK-NEXT:   %11 = call i32* @llvm.side.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i32(i32* %2, i8* %1, i32** null, i32** undef, i32 0, metadata !17)
+; CHECK-NEXT:   %side.cond = select i1 %cmp5, i32* %side.pTmp00.0, i32* %11
+; CHECK-NEXT:   %12 = bitcast i32* %side.cond to i16*
+; CHECK-NEXT:   %cond = select i1 %cmp5, i32* %pTmp00.0, i32* %2
+; CHECK-NEXT:   %13 = bitcast i32* %cond to i16*
+; CHECK-NEXT:   store i16 43, i16* %13, noalias_sidechannel i16* %12, align 2, !tbaa !20, !noalias !19
+; CHECK-NEXT:   ret void
+; CHECK: for.body:
+; CHECK-NEXT:   %14 = bitcast i32* %pTmp01.0 to i16*
+; CHECK-NEXT:   %arrayidx3 = getelementptr inbounds i16, i16* %14, i32 1
+; CHECK-NEXT:   %15 = load i16, i16* %arrayidx3, noalias_sidechannel i16* %7, align 2, !tbaa !20, !noalias !19
+; CHECK-NEXT:   %16 = bitcast i32* %pTmp00.0 to i16*
+; CHECK-NEXT:   %arrayidx4 = getelementptr inbounds i16, i16* %16, i32 1
+; CHECK-NEXT:   store i16 %15, i16* %arrayidx4, noalias_sidechannel i16* %6, align 2, !tbaa !20, !noalias !19
+; CHECK-NEXT:   %inc = add nsw i32 %i.0, 1
+; CHECK-NEXT:   br label %for.cond
+; CHECK-NEXT: }
+
+
+
+; Function Attrs: argmemonly nounwind
+declare i8* @llvm.noalias.decl.p0i8.p0p0i32.i32(i32**, i32, metadata) #1
+
+; Function Attrs: argmemonly nounwind speculatable
+declare i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i32(i32*, i8*, i32**, i32, metadata) #2
+
+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 }
+
+!llvm.module.flags = !{!0}
+!llvm.ident = !{!1}
+
+!0 = !{i32 1, !"wchar_size", i32 4}
+!1 = !{!"clang version 10.0.0 (sgasip@krachtcs10:/u/sgasip/ipd/repositories/llvm_ipd 6068136b7c40a5bb7a7291dd621185a209673e09)"}
+!2 = !{!3}
+!3 = distinct !{!3, !4, !"test_phi01: rpTmp"}
+!4 = distinct !{!4, !"test_phi01"}
+!5 = !{!6}
+!6 = distinct !{!6, !4, !"test_phi01: rp2"}
+!7 = !{!8, !8, i64 0, i64 4}
+!8 = !{!9, i64 4, !"any pointer"}
+!9 = !{!10, i64 1, !"omnipotent char"}
+!10 = !{!"Simple C/C++ TBAA"}
+!11 = !{!3, !6}
+!12 = !{!13, !13, i64 0, i64 4}
+!13 = !{!9, i64 4, !"int"}
+!14 = !{!15}
+!15 = distinct !{!15, !16, !"test_phi02: rpTmp"}
+!16 = distinct !{!16, !"test_phi02"}
+!17 = !{!18}
+!18 = distinct !{!18, !16, !"test_phi02: rp2"}
+!19 = !{!15, !18}
+!20 = !{!21, !21, i64 0, i64 2}
+!21 = !{!9, i64 2, !"short"}

llvm/test/Transforms/PropagateAndConvertNoAlias/struct.ll

+; RUN: opt < %s -convert-noalias -verify -S | FileCheck %s
+; RUN: opt < %s -passes=convert-noalias,verify -S | FileCheck %s
+target datalayout = "e-i8:8:8-i16:16:16-i32:32:32-i64:32:32-f16:16:16-f32:32:32-f64:32:32-p:32:32:32:32:8-s0:32:32-a0:0:32-S32-n16:32-v128:32:32-P0-p0:32:32:32:32:8"
+
+%struct.FOO = type { i32*, i32*, i32* }
+
+; Function Attrs: nounwind
+define dso_local void @test_rFOO(%struct.FOO* %_pFOO, i32* %_pA) #0 !noalias !2 {
+entry:
+  %tmp = alloca %struct.FOO, align 4
+  %0 = call i8* @llvm.noalias.decl.p0i8.p0p0s_struct.FOOs.i32(%struct.FOO** null, i32 0, metadata !5)
+  %1 = call i8* @llvm.noalias.decl.p0i8.p0p0i32.i32(i32** null, i32 0, metadata !7)
+  %2 = call i8* @llvm.noalias.decl.p0i8.p0p0i32.i32(i32** null, i32 4, metadata !7)
+  %3 = call i8* @llvm.noalias.decl.p0i8.p0p0i32.i32(i32** null, i32 8, metadata !7)
+  %4 = call %struct.FOO* @llvm.noalias.p0s_struct.FOOs.p0i8.p0p0s_struct.FOOs.i32(%struct.FOO* %_pFOO, i8* %0, %struct.FOO** null, i32 0, metadata !5), !tbaa !9, !noalias !13
+  %5 = call %struct.FOO* @llvm.noalias.copy.guard.p0s_struct.FOOs.p0i8(%struct.FOO* %4, i8* null, metadata !14, metadata !2)
+  %6 = load %struct.FOO, %struct.FOO* %5, align 4, !noalias !13
+  %.fca.0.extract = extractvalue %struct.FOO %6, 0
+  %.fca.1.extract = extractvalue %struct.FOO %6, 1
+  %.fca.2.extract = extractvalue %struct.FOO %6, 2
+  %7 = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i32(i32* %.fca.0.extract, i8* %1, i32** null, i32 0, metadata !7), !tbaa !18, !noalias !13
+  %8 = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i32(i32* %.fca.1.extract, i8* %2, i32** null, i32 4, metadata !7), !tbaa !20, !noalias !13
+  %9 = load i32, i32* %8, align 4, !tbaa !21, !noalias !13
+  store i32 %9, i32* %7, align 4, !tbaa !21, !noalias !13
+  %10 = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i32(i32* %_pA, i8* %1, i32** null, i32 0, metadata !7), !tbaa !18, !noalias !13
+  store i32 42, i32* %10, align 4, !tbaa !21, !noalias !13
+  %.fca.0.load.noalias = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i32(i32* %_pA, i8* %1, i32** null, i32 0, metadata !7)
+  %.fca.0.insert = insertvalue %struct.FOO undef, i32* %.fca.0.load.noalias, 0
+  %.fca.1.load.noalias = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i32(i32* %.fca.1.extract, i8* %2, i32** null, i32 4, metadata !7)
+  %.fca.1.insert = insertvalue %struct.FOO %.fca.0.insert, i32* %.fca.1.load.noalias, 1
+  %.fca.2.load.noalias = call i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i32(i32* %.fca.2.extract, i8* %3, i32** null, i32 8, metadata !7)
+  %.fca.2.insert = insertvalue %struct.FOO %.fca.1.insert, i32* %.fca.2.load.noalias, 2
+  call void @fum(%struct.FOO %.fca.2.insert), !noalias !13
+  ret void
+}
+
+; CHECK-LABEL: @test_rFOO(
+; CHECK-NEXT: entry:
+; CHECK-NEXT:   %tmp = alloca %struct.FOO, align 4
+; CHECK-NEXT:   %0 = call i8* @llvm.noalias.decl.p0i8.p0p0s_struct.FOOs.i32(%struct.FOO** null, i32 0, metadata !5)
+; CHECK-NEXT:   %1 = call i8* @llvm.noalias.decl.p0i8.p0p0i32.i32(i32** null, i32 0, metadata !7)
+; CHECK-NEXT:   %2 = call i8* @llvm.noalias.decl.p0i8.p0p0i32.i32(i32** null, i32 4, metadata !7)
+; CHECK-NEXT:   %3 = call i8* @llvm.noalias.decl.p0i8.p0p0i32.i32(i32** null, i32 8, metadata !7)
+; CHECK-NEXT:   %4 = call %struct.FOO* @llvm.side.noalias.p0s_struct.FOOs.p0i8.p0p0s_struct.FOOs.p0p0s_struct.FOOs.i32(%struct.FOO* %_pFOO, i8* %0, %struct.FOO** null, %struct.FOO** undef, i32 0, metadata !5), !tbaa !9, !noalias !13
+; CHECK-NEXT:   %.guard = call %struct.FOO* @llvm.noalias.arg.guard.p0s_struct.FOOs.p0s_struct.FOOs(%struct.FOO* %_pFOO, %struct.FOO* %4)
+; CHECK-NEXT:   %5 = call %struct.FOO* @llvm.noalias.copy.guard.p0s_struct.FOOs.p0i8(%struct.FOO* %.guard, i8* null, metadata !14, metadata !2)
+; CHECK-NEXT:   %6 = load %struct.FOO, %struct.FOO* %5, noalias_sidechannel %struct.FOO* undef, align 4, !noalias !13
+; CHECK-NEXT:   %.fca.0.extract = extractvalue %struct.FOO %6, 0
+; CHECK-NEXT:   %.fca.1.extract = extractvalue %struct.FOO %6, 1
+; CHECK-NEXT:   %.fca.2.extract = extractvalue %struct.FOO %6, 2
+; CHECK-NEXT:   %7 = call i32* @llvm.side.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i32(i32* %.fca.0.extract, i8* %1, i32** null, i32** undef, i32 0, metadata !7), !tbaa !18, !noalias !13
+; CHECK-NEXT:   %8 = call i32* @llvm.side.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i32(i32* %.fca.1.extract, i8* %2, i32** null, i32** undef, i32 4, metadata !7), !tbaa !20, !noalias !13
+; CHECK-NEXT:   %9 = load i32, i32* %.fca.1.extract, noalias_sidechannel i32* %8, align 4, !tbaa !21, !noalias !13
+; CHECK-NEXT:   store i32 %9, i32* %.fca.0.extract, noalias_sidechannel i32* %7, align 4, !tbaa !21, !noalias !13
+; CHECK-NEXT:   %10 = call i32* @llvm.side.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i32(i32* %_pA, i8* %1, i32** null, i32** undef, i32 0, metadata !7), !tbaa !18, !noalias !13
+; CHECK-NEXT:   store i32 42, i32* %_pA, noalias_sidechannel i32* %10, align 4, !tbaa !21, !noalias !13
+; CHECK-NEXT:   %.fca.0.load.noalias.guard = call i32* @llvm.noalias.arg.guard.p0i32.p0i32(i32* %_pA, i32* %10)
+; CHECK-NEXT:   %.fca.0.insert = insertvalue %struct.FOO undef, i32* %.fca.0.load.noalias.guard, 0
+; CHECK-NEXT:   %.fca.1.load.noalias.guard = call i32* @llvm.noalias.arg.guard.p0i32.p0i32(i32* %.fca.1.extract, i32* %8)
+; CHECK-NEXT:   %.fca.1.insert = insertvalue %struct.FOO %.fca.0.insert, i32* %.fca.1.load.noalias.guard, 1
+; CHECK-NEXT:   %11 = call i32* @llvm.side.noalias.p0i32.p0i8.p0p0i32.p0p0i32.i32(i32* %.fca.2.extract, i8* %3, i32** null, i32** undef, i32 8, metadata !7)
+; CHECK-NEXT:   %.fca.2.load.noalias.guard = call i32* @llvm.noalias.arg.guard.p0i32.p0i32(i32* %.fca.2.extract, i32* %11)
+; CHECK-NEXT:   %.fca.2.insert = insertvalue %struct.FOO %.fca.1.insert, i32* %.fca.2.load.noalias.guard, 2
+; CHECK-NEXT:   call void @fum(%struct.FOO %.fca.2.insert), !noalias !13
+; CHECK-NEXT:   ret void
+; CHECK-NEXT: }
+
+
+; Function Attrs: argmemonly nounwind speculatable
+declare %struct.FOO* @llvm.noalias.p0s_struct.FOOs.p0i8.p0p0s_struct.FOOs.i32(%struct.FOO*, i8*, %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) #2
+
+; Function Attrs: argmemonly nounwind speculatable
+declare i32* @llvm.noalias.p0i32.p0i8.p0p0i32.i32(i32*, i8*, i32**, i32, metadata) #1
+
+; Function Attrs: argmemonly nounwind
+declare i8* @llvm.noalias.decl.p0i8.p0p0i32.i32(i32**, i32, metadata) #3
+
+; Function Attrs: argmemonly nounwind
+declare i8* @llvm.noalias.decl.p0i8.p0p0s_struct.FOOs.i32(%struct.FOO**, i32, metadata) #3
+
+declare dso_local void @fum(%struct.FOO) #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 speculatable }
+attributes #2 = { nounwind readnone }
+attributes #3 = { argmemonly nounwind }
+attributes #4 = { "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "frame-pointer"="all" "less-precise-fpmad"="false" "no-infs-fp-math"="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" }
+
+!llvm.module.flags = !{!0}
+!llvm.ident = !{!1}
+
+!0 = !{i32 1, !"wchar_size", i32 4}
+!1 = !{!"clang"}
+!2 = !{!3}
+!3 = distinct !{!3, !4, !"test_rFOO: unknown scope"}
+!4 = distinct !{!4, !"test_rFOO"}
+!5 = !{!6}
+!6 = distinct !{!6, !4, !"test_rFOO: rpFOO"}
+!7 = !{!8}
+!8 = distinct !{!8, !4, !"test_rFOO: tmp"}
+!9 = !{!10, !10, i64 0, i64 4}
+!10 = !{!11, i64 4, !"any pointer"}
+!11 = !{!12, i64 1, !"omnipotent char"}
+!12 = !{!"Simple C/C++ TBAA"}
+!13 = !{!6, !8, !3}
+!14 = !{!15, !16, !17}
+!15 = !{i64 -1, i64 0}
+!16 = !{i64 -1, i64 1}
+!17 = !{i64 -1, i64 2}
+!18 = !{!19, !10, i64 0, i64 4}
+!19 = !{!11, i64 12, !"FOO", !10, i64 0, i64 4, !10, i64 4, i64 4, !10, i64 8, i64 4}
+!20 = !{!19, !10, i64 4, i64 4}
+!21 = !{!22, !22, i64 0, i64 4}
+!22 = !{!11, i64 4, !"int"}