/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Transforms/Scalar/LICM.cpp

Bug Summary

File:	llvm/lib/Transforms/Scalar/LICM.cpp
Warning:	line 1262, column 41 Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name LICM.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=none -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/build-llvm/lib/Transforms/Scalar -resource-dir /usr/lib/llvm-13/lib/clang/13.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/build-llvm/lib/Transforms/Scalar -I /build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Transforms/Scalar -I /build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/build-llvm/include -I /build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../x86_64-linux-gnu/include -internal-isystem /usr/lib/llvm-13/lib/clang/13.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/build-llvm/lib/Transforms/Scalar -fdebug-prefix-map=/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4=. -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2021-04-05-202135-9119-1 -x c++ /build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Transforms/Scalar/LICM.cpp

/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Transforms/Scalar/LICM.cpp

→

1//===-- LICM.cpp - Loop Invariant Code Motion Pass ------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This pass performs loop invariant code motion, attempting to remove as much
10// code from the body of a loop as possible.  It does this by either hoisting
11// code into the preheader block, or by sinking code to the exit blocks if it is
12// safe.  This pass also promotes must-aliased memory locations in the loop to
13// live in registers, thus hoisting and sinking "invariant" loads and stores.
14//
15// Hoisting operations out of loops is a canonicalization transform.  It
16// enables and simplifies subsequent optimizations in the middle-end.
17// Rematerialization of hoisted instructions to reduce register pressure is the
18// responsibility of the back-end, which has more accurate information about
19// register pressure and also handles other optimizations than LICM that
20// increase live-ranges.
21//
22// This pass uses alias analysis for two purposes:
23//
24//  1. Moving loop invariant loads and calls out of loops.  If we can determine
25//     that a load or call inside of a loop never aliases anything stored to,
26//     we can hoist it or sink it like any other instruction.
27//  2. Scalar Promotion of Memory - If there is a store instruction inside of
28//     the loop, we try to move the store to happen AFTER the loop instead of
29//     inside of the loop.  This can only happen if a few conditions are true:
30//       A. The pointer stored through is loop invariant
31//       B. There are no stores or loads in the loop which _may_ alias the
32//          pointer.  There are no calls in the loop which mod/ref the pointer.
33//     If these conditions are true, we can promote the loads and stores in the
34//     loop of the pointer to use a temporary alloca'd variable.  We then use
35//     the SSAUpdater to construct the appropriate SSA form for the value.
36//
37//===----------------------------------------------------------------------===//

39#include "llvm/Transforms/Scalar/LICM.h"
40#include "llvm/ADT/SetOperations.h"
41#include "llvm/ADT/Statistic.h"
42#include "llvm/Analysis/AliasAnalysis.h"
43#include "llvm/Analysis/AliasSetTracker.h"
44#include "llvm/Analysis/BasicAliasAnalysis.h"
45#include "llvm/Analysis/BlockFrequencyInfo.h"
46#include "llvm/Analysis/CaptureTracking.h"
47#include "llvm/Analysis/ConstantFolding.h"
48#include "llvm/Analysis/GlobalsModRef.h"
49#include "llvm/Analysis/GuardUtils.h"
50#include "llvm/Analysis/LazyBlockFrequencyInfo.h"
51#include "llvm/Analysis/Loads.h"
52#include "llvm/Analysis/LoopInfo.h"
53#include "llvm/Analysis/LoopIterator.h"
54#include "llvm/Analysis/LoopPass.h"
55#include "llvm/Analysis/MemoryBuiltins.h"
56#include "llvm/Analysis/MemorySSA.h"
57#include "llvm/Analysis/MemorySSAUpdater.h"
58#include "llvm/Analysis/MustExecute.h"
59#include "llvm/Analysis/OptimizationRemarkEmitter.h"
60#include "llvm/Analysis/ScalarEvolution.h"
61#include "llvm/Analysis/ScalarEvolutionAliasAnalysis.h"
62#include "llvm/Analysis/TargetLibraryInfo.h"
63#include "llvm/Analysis/ValueTracking.h"
64#include "llvm/IR/CFG.h"
65#include "llvm/IR/Constants.h"
66#include "llvm/IR/DataLayout.h"
67#include "llvm/IR/DebugInfoMetadata.h"
68#include "llvm/IR/DerivedTypes.h"
69#include "llvm/IR/Dominators.h"
70#include "llvm/IR/Instructions.h"
71#include "llvm/IR/IntrinsicInst.h"
72#include "llvm/IR/LLVMContext.h"
73#include "llvm/IR/Metadata.h"
74#include "llvm/IR/PatternMatch.h"
75#include "llvm/IR/PredIteratorCache.h"
76#include "llvm/InitializePasses.h"
77#include "llvm/Support/CommandLine.h"
78#include "llvm/Support/Debug.h"
79#include "llvm/Support/raw_ostream.h"
80#include "llvm/Transforms/Scalar.h"
81#include "llvm/Transforms/Scalar/LoopPassManager.h"
82#include "llvm/Transforms/Utils/AssumeBundleBuilder.h"
83#include "llvm/Transforms/Utils/BasicBlockUtils.h"
84#include "llvm/Transforms/Utils/Local.h"
85#include "llvm/Transforms/Utils/LoopUtils.h"
86#include "llvm/Transforms/Utils/SSAUpdater.h"
87#include <algorithm>
88#include <utility>
89using namespace llvm;

91#define DEBUG_TYPE"licm" "licm"

93STATISTIC(NumCreatedBlocks, "Number of blocks created")static llvm::Statistic NumCreatedBlocks = {"licm", "NumCreatedBlocks"
, "Number of blocks created"};
94STATISTIC(NumClonedBranches, "Number of branches cloned")static llvm::Statistic NumClonedBranches = {"licm", "NumClonedBranches"
, "Number of branches cloned"};
95STATISTIC(NumSunk, "Number of instructions sunk out of loop")static llvm::Statistic NumSunk = {"licm", "NumSunk", "Number of instructions sunk out of loop"
};
96STATISTIC(NumHoisted, "Number of instructions hoisted out of loop")static llvm::Statistic NumHoisted = {"licm", "NumHoisted", "Number of instructions hoisted out of loop"
};
97STATISTIC(NumMovedLoads, "Number of load insts hoisted or sunk")static llvm::Statistic NumMovedLoads = {"licm", "NumMovedLoads"
, "Number of load insts hoisted or sunk"};
98STATISTIC(NumMovedCalls, "Number of call insts hoisted or sunk")static llvm::Statistic NumMovedCalls = {"licm", "NumMovedCalls"
, "Number of call insts hoisted or sunk"};
99STATISTIC(NumPromoted, "Number of memory locations promoted to registers")static llvm::Statistic NumPromoted = {"licm", "NumPromoted", "Number of memory locations promoted to registers"
};

101/// Memory promotion is enabled by default.
102static cl::opt<bool>
  DisablePromotion("disable-licm-promotion", cl::Hidden, cl::init(false),
                   cl::desc("Disable memory promotion in LICM pass"));

106static cl::opt<bool> ControlFlowHoisting(
  "licm-control-flow-hoisting", cl::Hidden, cl::init(false),
  cl::desc("Enable control flow (and PHI) hoisting in LICM"));

110static cl::opt<unsigned> HoistSinkColdnessThreshold(
  "licm-coldness-threshold", cl::Hidden, cl::init(4),
  cl::desc("Relative coldness Threshold of hoisting/sinking destination "
           "block for LICM to be considered beneficial"));

115static cl::opt<uint32_t> MaxNumUsesTraversed(
  "licm-max-num-uses-traversed", cl::Hidden, cl::init(8),
  cl::desc("Max num uses visited for identifying load "
           "invariance in loop using invariant start (default = 8)"));

120// Default value of zero implies we use the regular alias set tracker mechanism
121// instead of the cross product using AA to identify aliasing of the memory
122// location we are interested in.
123static cl::opt<int>
124LICMN2Theshold("licm-n2-threshold", cl::Hidden, cl::init(0),
             cl::desc("How many instruction to cross product using AA"));

127// Experimental option to allow imprecision in LICM in pathological cases, in
128// exchange for faster compile. This is to be removed if MemorySSA starts to
129// address the same issue. This flag applies only when LICM uses MemorySSA
130// instead on AliasSetTracker. LICM calls MemorySSAWalker's
131// getClobberingMemoryAccess, up to the value of the Cap, getting perfect
132// accuracy. Afterwards, LICM will call into MemorySSA's getDefiningAccess,
133// which may not be precise, since optimizeUses is capped. The result is
134// correct, but we may not get as "far up" as possible to get which access is
135// clobbering the one queried.
136cl::opt<unsigned> llvm::SetLicmMssaOptCap(
  "licm-mssa-optimization-cap", cl::init(100), cl::Hidden,
  cl::desc("Enable imprecision in LICM in pathological cases, in exchange "
           "for faster compile. Caps the MemorySSA clobbering calls."));

141// Experimentally, memory promotion carries less importance than sinking and
142// hoisting. Limit when we do promotion when using MemorySSA, in order to save
143// compile time.
144cl::opt<unsigned> llvm::SetLicmMssaNoAccForPromotionCap(
  "licm-mssa-max-acc-promotion", cl::init(250), cl::Hidden,
  cl::desc("[LICM & MemorySSA] When MSSA in LICM is disabled, this has no "
           "effect. When MSSA in LICM is enabled, then this is the maximum "
           "number of accesses allowed to be present in a loop in order to "
           "enable memory promotion."));

151static bool inSubLoop(BasicBlock *BB, Loop *CurLoop, LoopInfo *LI);
152static bool isNotUsedOrFreeInLoop(const Instruction &I, const Loop *CurLoop,
                                const LoopSafetyInfo *SafetyInfo,
                                TargetTransformInfo *TTI, bool &FreeInLoop);
155static void hoist(Instruction &I, const DominatorTree *DT, const Loop *CurLoop,
                BasicBlock *Dest, ICFLoopSafetyInfo *SafetyInfo,
                MemorySSAUpdater *MSSAU, ScalarEvolution *SE,
                OptimizationRemarkEmitter *ORE);
159static bool sink(Instruction &I, LoopInfo *LI, DominatorTree *DT,
               BlockFrequencyInfo *BFI, const Loop *CurLoop,
               ICFLoopSafetyInfo *SafetyInfo, MemorySSAUpdater *MSSAU,
               OptimizationRemarkEmitter *ORE);
163static bool isSafeToExecuteUnconditionally(Instruction &Inst,
                                         const DominatorTree *DT,
                                         const TargetLibraryInfo *TLI,
                                         const Loop *CurLoop,
                                         const LoopSafetyInfo *SafetyInfo,
                                         OptimizationRemarkEmitter *ORE,
                                         const Instruction *CtxI = nullptr);
170static bool pointerInvalidatedByLoop(MemoryLocation MemLoc,
                                   AliasSetTracker *CurAST, Loop *CurLoop,
                                   AAResults *AA);
173static bool pointerInvalidatedByLoopWithMSSA(MemorySSA *MSSA, MemoryUse *MU,
                                           Loop *CurLoop, Instruction &I,
                                           SinkAndHoistLICMFlags &Flags);
176static bool pointerInvalidatedByBlockWithMSSA(BasicBlock &BB, MemorySSA &MSSA,
                                            MemoryUse &MU);
178static Instruction *cloneInstructionInExitBlock(
  Instruction &I, BasicBlock &ExitBlock, PHINode &PN, const LoopInfo *LI,
  const LoopSafetyInfo *SafetyInfo, MemorySSAUpdater *MSSAU);

182static void eraseInstruction(Instruction &I, ICFLoopSafetyInfo &SafetyInfo,
                           AliasSetTracker *AST, MemorySSAUpdater *MSSAU);

185static void moveInstructionBefore(Instruction &I, Instruction &Dest,
                                ICFLoopSafetyInfo &SafetyInfo,
                                MemorySSAUpdater *MSSAU, ScalarEvolution *SE);

189static void foreachMemoryAccess(MemorySSA *MSSA, Loop *L,
                              function_ref<void(Instruction *)> Fn);
191static SmallVector<SmallSetVector<Value *, 8>, 0>
192collectPromotionCandidates(MemorySSA *MSSA, AliasAnalysis *AA, Loop *L,
                         SmallVectorImpl<Instruction *> &MaybePromotable);

195namespace {
196struct LoopInvariantCodeMotion {
bool runOnLoop(Loop *L, AAResults *AA, LoopInfo *LI, DominatorTree *DT,
               BlockFrequencyInfo *BFI, TargetLibraryInfo *TLI,
               TargetTransformInfo *TTI, ScalarEvolution *SE, MemorySSA *MSSA,
               OptimizationRemarkEmitter *ORE);

LoopInvariantCodeMotion(unsigned LicmMssaOptCap,
                        unsigned LicmMssaNoAccForPromotionCap)
    : LicmMssaOptCap(LicmMssaOptCap),
      LicmMssaNoAccForPromotionCap(LicmMssaNoAccForPromotionCap) {}

207private:
unsigned LicmMssaOptCap;
unsigned LicmMssaNoAccForPromotionCap;

std::unique_ptr<AliasSetTracker>
collectAliasInfoForLoop(Loop *L, LoopInfo *LI, AAResults *AA);
213};

215struct LegacyLICMPass : public LoopPass {
static char ID; // Pass identification, replacement for typeid
LegacyLICMPass(
    unsigned LicmMssaOptCap = SetLicmMssaOptCap,
    unsigned LicmMssaNoAccForPromotionCap = SetLicmMssaNoAccForPromotionCap)
    : LoopPass(ID), LICM(LicmMssaOptCap, LicmMssaNoAccForPromotionCap) {
  initializeLegacyLICMPassPass(*PassRegistry::getPassRegistry());
}

bool runOnLoop(Loop *L, LPPassManager &LPM) override {
  if (skipLoop(L))
    return false;

  LLVM_DEBUG(dbgs() << "Perform LICM on Loop with header at block "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("licm")) { dbgs() << "Perform LICM on Loop with header at block "
 << L->getHeader()->getNameOrAsOperand() <<
 "\n"; } } while (false)
                    << L->getHeader()->getNameOrAsOperand() << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("licm")) { dbgs() << "Perform LICM on Loop with header at block "
 << L->getHeader()->getNameOrAsOperand() <<
 "\n"; } } while (false);

  auto *SE = getAnalysisIfAvailable<ScalarEvolutionWrapperPass>();
  MemorySSA *MSSA = EnableMSSALoopDependency
                        ? (&getAnalysis<MemorySSAWrapperPass>().getMSSA())
                        : nullptr;
  bool hasProfileData = L->getHeader()->getParent()->hasProfileData();
  BlockFrequencyInfo *BFI =
      hasProfileData ? &getAnalysis<LazyBlockFrequencyInfoPass>().getBFI()
                     : nullptr;
  // For the old PM, we can't use OptimizationRemarkEmitter as an analysis
  // pass. Function analyses need to be preserved across loop transformations
  // but ORE cannot be preserved (see comment before the pass definition).
  OptimizationRemarkEmitter ORE(L->getHeader()->getParent());
  return LICM.runOnLoop(
      L, &getAnalysis<AAResultsWrapperPass>().getAAResults(),
      &getAnalysis<LoopInfoWrapperPass>().getLoopInfo(),
      &getAnalysis<DominatorTreeWrapperPass>().getDomTree(), BFI,
      &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(
          *L->getHeader()->getParent()),
      &getAnalysis<TargetTransformInfoWrapperPass>().getTTI(
          *L->getHeader()->getParent()),
      SE ? &SE->getSE() : nullptr, MSSA, &ORE);
}

/// This transformation requires natural loop information & requires that
/// loop preheaders be inserted into the CFG...
///
void getAnalysisUsage(AnalysisUsage &AU) const override {
  AU.addPreserved<DominatorTreeWrapperPass>();
  AU.addPreserved<LoopInfoWrapperPass>();
  AU.addRequired<TargetLibraryInfoWrapperPass>();
  if (EnableMSSALoopDependency) {
    AU.addRequired<MemorySSAWrapperPass>();
    AU.addPreserved<MemorySSAWrapperPass>();
  }
  AU.addRequired<TargetTransformInfoWrapperPass>();
  getLoopAnalysisUsage(AU);
  LazyBlockFrequencyInfoPass::getLazyBFIAnalysisUsage(AU);
  AU.addPreserved<LazyBlockFrequencyInfoPass>();
  AU.addPreserved<LazyBranchProbabilityInfoPass>();
}

272private:
LoopInvariantCodeMotion LICM;
274};
275} // namespace

277PreservedAnalyses LICMPass::run(Loop &L, LoopAnalysisManager &AM,
                              LoopStandardAnalysisResults &AR, LPMUpdater &) {
// For the new PM, we also can't use OptimizationRemarkEmitter as an analysis
// pass.  Function analyses need to be preserved across loop transformations
// but ORE cannot be preserved (see comment before the pass definition).
OptimizationRemarkEmitter ORE(L.getHeader()->getParent());

LoopInvariantCodeMotion LICM(LicmMssaOptCap, LicmMssaNoAccForPromotionCap);
if (!LICM.runOnLoop(&L, &AR.AA, &AR.LI, &AR.DT, AR.BFI, &AR.TLI, &AR.TTI,
                    &AR.SE, AR.MSSA, &ORE))
  return PreservedAnalyses::all();

auto PA = getLoopPassPreservedAnalyses();

PA.preserve<DominatorTreeAnalysis>();
PA.preserve<LoopAnalysis>();
if (AR.MSSA)
  PA.preserve<MemorySSAAnalysis>();

return PA;
297}

299char LegacyLICMPass::ID = 0;
300INITIALIZE_PASS_BEGIN(LegacyLICMPass, "licm", "Loop Invariant Code Motion",static void *initializeLegacyLICMPassPassOnce(PassRegistry &
Registry) {
                    false, false)static void *initializeLegacyLICMPassPassOnce(PassRegistry &
Registry) {
302INITIALIZE_PASS_DEPENDENCY(LoopPass)initializeLoopPassPass(Registry);
303INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass)initializeTargetLibraryInfoWrapperPassPass(Registry);
304INITIALIZE_PASS_DEPENDENCY(TargetTransformInfoWrapperPass)initializeTargetTransformInfoWrapperPassPass(Registry);
305INITIALIZE_PASS_DEPENDENCY(MemorySSAWrapperPass)initializeMemorySSAWrapperPassPass(Registry);
306INITIALIZE_PASS_DEPENDENCY(LazyBFIPass)initializeLazyBFIPassPass(Registry);
307INITIALIZE_PASS_END(LegacyLICMPass, "licm", "Loop Invariant Code Motion", false,PassInfo *PI = new PassInfo( "Loop Invariant Code Motion", "licm"
, &LegacyLICMPass::ID, PassInfo::NormalCtor_t(callDefaultCtor
<LegacyLICMPass>), false, false); Registry.registerPass
(*PI, true); return PI; } static llvm::once_flag InitializeLegacyLICMPassPassFlag
; void llvm::initializeLegacyLICMPassPass(PassRegistry &Registry
) { llvm::call_once(InitializeLegacyLICMPassPassFlag, initializeLegacyLICMPassPassOnce
, std::ref(Registry)); }
                  false)PassInfo *PI = new PassInfo( "Loop Invariant Code Motion", "licm"
, &LegacyLICMPass::ID, PassInfo::NormalCtor_t(callDefaultCtor
<LegacyLICMPass>), false, false); Registry.registerPass
(*PI, true); return PI; } static llvm::once_flag InitializeLegacyLICMPassPassFlag
; void llvm::initializeLegacyLICMPassPass(PassRegistry &Registry
) { llvm::call_once(InitializeLegacyLICMPassPassFlag, initializeLegacyLICMPassPassOnce
, std::ref(Registry)); }

310Pass *llvm::createLICMPass() { return new LegacyLICMPass(); }
311Pass *llvm::createLICMPass(unsigned LicmMssaOptCap,
                         unsigned LicmMssaNoAccForPromotionCap) {
return new LegacyLICMPass(LicmMssaOptCap, LicmMssaNoAccForPromotionCap);
314}

316llvm::SinkAndHoistLICMFlags::SinkAndHoistLICMFlags(bool IsSink, Loop *L,
                                                 MemorySSA *MSSA)
  : SinkAndHoistLICMFlags(SetLicmMssaOptCap, SetLicmMssaNoAccForPromotionCap,
                          IsSink, L, MSSA) {}

321llvm::SinkAndHoistLICMFlags::SinkAndHoistLICMFlags(
  unsigned LicmMssaOptCap, unsigned LicmMssaNoAccForPromotionCap, bool IsSink,
  Loop *L, MemorySSA *MSSA)
  : LicmMssaOptCap(LicmMssaOptCap),
    LicmMssaNoAccForPromotionCap(LicmMssaNoAccForPromotionCap),
    IsSink(IsSink) {
assert(((L != nullptr) == (MSSA != nullptr)) &&((((L != nullptr) == (MSSA != nullptr)) && "Unexpected values for SinkAndHoistLICMFlags"
) ? static_cast<void> (0) : __assert_fail ("((L != nullptr) == (MSSA != nullptr)) && \"Unexpected values for SinkAndHoistLICMFlags\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Transforms/Scalar/LICM.cpp"
, 328, __PRETTY_FUNCTION__))
       "Unexpected values for SinkAndHoistLICMFlags")((((L != nullptr) == (MSSA != nullptr)) && "Unexpected values for SinkAndHoistLICMFlags"
) ? static_cast<void> (0) : __assert_fail ("((L != nullptr) == (MSSA != nullptr)) && \"Unexpected values for SinkAndHoistLICMFlags\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Transforms/Scalar/LICM.cpp"
, 328, __PRETTY_FUNCTION__));
if (!MSSA)
  return;

unsigned AccessCapCount = 0;
for (auto *BB : L->getBlocks())
  if (const auto *Accesses = MSSA->getBlockAccesses(BB))
    for (const auto &MA : *Accesses) {
      (void)MA;
      ++AccessCapCount;
      if (AccessCapCount > LicmMssaNoAccForPromotionCap) {
        NoOfMemAccTooLarge = true;
        return;
      }
    }
343}

345/// Hoist expressions out of the specified loop. Note, alias info for inner
346/// loop is not preserved so it is not a good idea to run LICM multiple
347/// times on one loop.
348bool LoopInvariantCodeMotion::runOnLoop(
  Loop *L, AAResults *AA, LoopInfo *LI, DominatorTree *DT,
  BlockFrequencyInfo *BFI, TargetLibraryInfo *TLI, TargetTransformInfo *TTI,
  ScalarEvolution *SE, MemorySSA *MSSA, OptimizationRemarkEmitter *ORE) {
bool Changed = false;

assert(L->isLCSSAForm(*DT) && "Loop is not in LCSSA form.")((L->isLCSSAForm(*DT) && "Loop is not in LCSSA form."
) ? static_cast<void> (0) : __assert_fail ("L->isLCSSAForm(*DT) && \"Loop is not in LCSSA form.\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Transforms/Scalar/LICM.cpp"
, 354, __PRETTY_FUNCTION__));

// If this loop has metadata indicating that LICM is not to be performed then
// just exit.
if (hasDisableLICMTransformsHint(L)) {
  return false;
}

std::unique_ptr<AliasSetTracker> CurAST;
std::unique_ptr<MemorySSAUpdater> MSSAU;
std::unique_ptr<SinkAndHoistLICMFlags> Flags;

// Don't sink stores from loops with coroutine suspend instructions.
// LICM would sink instructions into the default destination of
// the coroutine switch. The default destination of the switch is to
// handle the case where the coroutine is suspended, by which point the
// coroutine frame may have been destroyed. No instruction can be sunk there.
// FIXME: This would unfortunately hurt the performance of coroutines, however
// there is currently no general solution for this. Similar issues could also
// potentially happen in other passes where instructions are being moved
// across that edge.
bool HasCoroSuspendInst = llvm::any_of(L->getBlocks(), [](BasicBlock *BB) {
  return llvm::any_of(*BB, [](Instruction &I) {
    IntrinsicInst *II = dyn_cast<IntrinsicInst>(&I);
    return II && II->getIntrinsicID() == Intrinsic::coro_suspend;
  });
});

if (!MSSA) {
  LLVM_DEBUG(dbgs() << "LICM: Using Alias Set Tracker.\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("licm")) { dbgs() << "LICM: Using Alias Set Tracker.\n"
; } } while (false);
  CurAST = collectAliasInfoForLoop(L, LI, AA);
  Flags = std::make_unique<SinkAndHoistLICMFlags>(
      LicmMssaOptCap, LicmMssaNoAccForPromotionCap, /*IsSink=*/true);
} else {
  LLVM_DEBUG(dbgs() << "LICM: Using MemorySSA.\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("licm")) { dbgs() << "LICM: Using MemorySSA.\n"; } } while
 (false);
  MSSAU = std::make_unique<MemorySSAUpdater>(MSSA);
  Flags = std::make_unique<SinkAndHoistLICMFlags>(
      LicmMssaOptCap, LicmMssaNoAccForPromotionCap, /*IsSink=*/true, L, MSSA);
}

// Get the preheader block to move instructions into...
BasicBlock *Preheader = L->getLoopPreheader();

// Compute loop safety information.
ICFLoopSafetyInfo SafetyInfo;
SafetyInfo.computeLoopSafetyInfo(L);

// We want to visit all of the instructions in this loop... that are not parts
// of our subloops (they have already had their invariants hoisted out of
// their loop, into this loop, so there is no need to process the BODIES of
// the subloops).
//
// Traverse the body of the loop in depth first order on the dominator tree so
// that we are guaranteed to see definitions before we see uses.  This allows
// us to sink instructions in one pass, without iteration.  After sinking
// instructions, we perform another pass to hoist them out of the loop.
if (L->hasDedicatedExits())
  Changed |=
      sinkRegion(DT->getNode(L->getHeader()), AA, LI, DT, BFI, TLI, TTI, L,
                 CurAST.get(), MSSAU.get(), &SafetyInfo, *Flags.get(), ORE);
Flags->setIsSink(false);
if (Preheader)
  Changed |= hoistRegion(DT->getNode(L->getHeader()), AA, LI, DT, BFI, TLI, L,
                         CurAST.get(), MSSAU.get(), SE, &SafetyInfo,
                         *Flags.get(), ORE);

// Now that all loop invariants have been removed from the loop, promote any
// memory references to scalars that we can.
// Don't sink stores from loops without dedicated block exits. Exits
// containing indirect branches are not transformed by loop simplify,
// make sure we catch that. An additional load may be generated in the
// preheader for SSA updater, so also avoid sinking when no preheader
// is available.
if (!DisablePromotion && Preheader && L->hasDedicatedExits() &&
    !Flags->tooManyMemoryAccesses() && !HasCoroSuspendInst) {
  // Figure out the loop exits and their insertion points
  SmallVector<BasicBlock *, 8> ExitBlocks;
  L->getUniqueExitBlocks(ExitBlocks);

  // We can't insert into a catchswitch.
  bool HasCatchSwitch = llvm::any_of(ExitBlocks, [](BasicBlock *Exit) {
    return isa<CatchSwitchInst>(Exit->getTerminator());
  });

  if (!HasCatchSwitch) {
    SmallVector<Instruction *, 8> InsertPts;
    SmallVector<MemoryAccess *, 8> MSSAInsertPts;
    InsertPts.reserve(ExitBlocks.size());
    if (MSSAU)
      MSSAInsertPts.reserve(ExitBlocks.size());
    for (BasicBlock *ExitBlock : ExitBlocks) {
      InsertPts.push_back(&*ExitBlock->getFirstInsertionPt());
      if (MSSAU)
        MSSAInsertPts.push_back(nullptr);
    }

    PredIteratorCache PIC;

    bool Promoted = false;
    if (CurAST.get()) {
      // Loop over all of the alias sets in the tracker object.
      for (AliasSet &AS : *CurAST) {
        // We can promote this alias set if it has a store, if it is a "Must"
        // alias set, if the pointer is loop invariant, and if we are not
        // eliminating any volatile loads or stores.
        if (AS.isForwardingAliasSet() || !AS.isMod() || !AS.isMustAlias() ||
            !L->isLoopInvariant(AS.begin()->getValue()))
          continue;

        assert(((!AS.empty() && "Must alias set should have at least one pointer element in it!"
) ? static_cast<void> (0) : __assert_fail ("!AS.empty() && \"Must alias set should have at least one pointer element in it!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Transforms/Scalar/LICM.cpp"
, 465, __PRETTY_FUNCTION__))
            !AS.empty() &&((!AS.empty() && "Must alias set should have at least one pointer element in it!"
) ? static_cast<void> (0) : __assert_fail ("!AS.empty() && \"Must alias set should have at least one pointer element in it!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Transforms/Scalar/LICM.cpp"
, 465, __PRETTY_FUNCTION__))
            "Must alias set should have at least one pointer element in it!")((!AS.empty() && "Must alias set should have at least one pointer element in it!"
) ? static_cast<void> (0) : __assert_fail ("!AS.empty() && \"Must alias set should have at least one pointer element in it!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Transforms/Scalar/LICM.cpp"
, 465, __PRETTY_FUNCTION__));

        SmallSetVector<Value *, 8> PointerMustAliases;
        for (const auto &ASI : AS)
          PointerMustAliases.insert(ASI.getValue());

        Promoted |= promoteLoopAccessesToScalars(
            PointerMustAliases, ExitBlocks, InsertPts, MSSAInsertPts, PIC, LI,
            DT, TLI, L, CurAST.get(), MSSAU.get(), &SafetyInfo, ORE);
      }
    } else {
      SmallVector<Instruction *, 16> MaybePromotable;
      foreachMemoryAccess(MSSA, L, [&](Instruction *I) {
        MaybePromotable.push_back(I);
      });

      // Promoting one set of accesses may make the pointers for another set
      // loop invariant, so run this in a loop (with the MaybePromotable set
      // decreasing in size over time).
      bool LocalPromoted;
      do {
        LocalPromoted = false;
        for (const SmallSetVector<Value *, 8> &PointerMustAliases :
             collectPromotionCandidates(MSSA, AA, L, MaybePromotable)) {
          LocalPromoted |= promoteLoopAccessesToScalars(
              PointerMustAliases, ExitBlocks, InsertPts, MSSAInsertPts, PIC,
              LI, DT, TLI, L, /*AST*/nullptr, MSSAU.get(), &SafetyInfo, ORE);
        }
        Promoted |= LocalPromoted;
      } while (LocalPromoted);
    }

    // Once we have promoted values across the loop body we have to
    // recursively reform LCSSA as any nested loop may now have values defined
    // within the loop used in the outer loop.
    // FIXME: This is really heavy handed. It would be a bit better to use an
    // SSAUpdater strategy during promotion that was LCSSA aware and reformed
    // it as it went.
    if (Promoted)
      formLCSSARecursively(*L, *DT, LI, SE);

    Changed |= Promoted;
  }
}

// Check that neither this loop nor its parent have had LCSSA broken. LICM is
// specifically moving instructions across the loop boundary and so it is
// especially in need of sanity checking here.
assert(L->isLCSSAForm(*DT) && "Loop not left in LCSSA form after LICM!")((L->isLCSSAForm(*DT) && "Loop not left in LCSSA form after LICM!"
) ? static_cast<void> (0) : __assert_fail ("L->isLCSSAForm(*DT) && \"Loop not left in LCSSA form after LICM!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Transforms/Scalar/LICM.cpp"
, 513, __PRETTY_FUNCTION__));
assert((L->isOutermost() || L->getParentLoop()->isLCSSAForm(*DT)) &&(((L->isOutermost() || L->getParentLoop()->isLCSSAForm
(*DT)) && "Parent loop not left in LCSSA form after LICM!"
) ? static_cast<void> (0) : __assert_fail ("(L->isOutermost() || L->getParentLoop()->isLCSSAForm(*DT)) && \"Parent loop not left in LCSSA form after LICM!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Transforms/Scalar/LICM.cpp"
, 515, __PRETTY_FUNCTION__))
       "Parent loop not left in LCSSA form after LICM!")(((L->isOutermost() || L->getParentLoop()->isLCSSAForm
(*DT)) && "Parent loop not left in LCSSA form after LICM!"
) ? static_cast<void> (0) : __assert_fail ("(L->isOutermost() || L->getParentLoop()->isLCSSAForm(*DT)) && \"Parent loop not left in LCSSA form after LICM!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Transforms/Scalar/LICM.cpp"
, 515, __PRETTY_FUNCTION__));

if (MSSAU.get() && VerifyMemorySSA)
  MSSAU->getMemorySSA()->verifyMemorySSA();

if (Changed && SE)
  SE->forgetLoopDispositions(L);
return Changed;
523}

525/// Walk the specified region of the CFG (defined by all blocks dominated by
526/// the specified block, and that are in the current loop) in reverse depth
527/// first order w.r.t the DominatorTree.  This allows us to visit uses before
528/// definitions, allowing us to sink a loop body in one pass without iteration.
529///
530bool llvm::sinkRegion(DomTreeNode *N, AAResults *AA, LoopInfo *LI,
                    DominatorTree *DT, BlockFrequencyInfo *BFI,
                    TargetLibraryInfo *TLI, TargetTransformInfo *TTI,
                    Loop *CurLoop, AliasSetTracker *CurAST,
                    MemorySSAUpdater *MSSAU, ICFLoopSafetyInfo *SafetyInfo,
                    SinkAndHoistLICMFlags &Flags,
                    OptimizationRemarkEmitter *ORE) {

// Verify inputs.
assert(N != nullptr && AA != nullptr && LI != nullptr && DT != nullptr &&((N != nullptr && AA != nullptr && LI != nullptr
 && DT != nullptr && CurLoop != nullptr &&
 SafetyInfo != nullptr && "Unexpected input to sinkRegion."
) ? static_cast<void> (0) : __assert_fail ("N != nullptr && AA != nullptr && LI != nullptr && DT != nullptr && CurLoop != nullptr && SafetyInfo != nullptr && \"Unexpected input to sinkRegion.\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Transforms/Scalar/LICM.cpp"
, 541, __PRETTY_FUNCTION__))
       CurLoop != nullptr && SafetyInfo != nullptr &&((N != nullptr && AA != nullptr && LI != nullptr
 && DT != nullptr && CurLoop != nullptr &&
 SafetyInfo != nullptr && "Unexpected input to sinkRegion."
) ? static_cast<void> (0) : __assert_fail ("N != nullptr && AA != nullptr && LI != nullptr && DT != nullptr && CurLoop != nullptr && SafetyInfo != nullptr && \"Unexpected input to sinkRegion.\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Transforms/Scalar/LICM.cpp"
, 541, __PRETTY_FUNCTION__))
       "Unexpected input to sinkRegion.")((N != nullptr && AA != nullptr && LI != nullptr
 && DT != nullptr && CurLoop != nullptr &&
 SafetyInfo != nullptr && "Unexpected input to sinkRegion."
) ? static_cast<void> (0) : __assert_fail ("N != nullptr && AA != nullptr && LI != nullptr && DT != nullptr && CurLoop != nullptr && SafetyInfo != nullptr && \"Unexpected input to sinkRegion.\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Transforms/Scalar/LICM.cpp"
, 541, __PRETTY_FUNCTION__));
assert(((CurAST != nullptr) ^ (MSSAU != nullptr)) &&((((CurAST != nullptr) ^ (MSSAU != nullptr)) && "Either AliasSetTracker or MemorySSA should be initialized."
) ? static_cast<void> (0) : __assert_fail ("((CurAST != nullptr) ^ (MSSAU != nullptr)) && \"Either AliasSetTracker or MemorySSA should be initialized.\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Transforms/Scalar/LICM.cpp"
, 543, __PRETTY_FUNCTION__))
       "Either AliasSetTracker or MemorySSA should be initialized.")((((CurAST != nullptr) ^ (MSSAU != nullptr)) && "Either AliasSetTracker or MemorySSA should be initialized."
) ? static_cast<void> (0) : __assert_fail ("((CurAST != nullptr) ^ (MSSAU != nullptr)) && \"Either AliasSetTracker or MemorySSA should be initialized.\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Transforms/Scalar/LICM.cpp"
, 543, __PRETTY_FUNCTION__));

// We want to visit children before parents. We will enque all the parents
// before their children in the worklist and process the worklist in reverse
// order.
SmallVector<DomTreeNode *, 16> Worklist = collectChildrenInLoop(N, CurLoop);

bool Changed = false;
for (DomTreeNode *DTN : reverse(Worklist)) {
  BasicBlock *BB = DTN->getBlock();
  // Only need to process the contents of this block if it is not part of a
  // subloop (which would already have been processed).
  if (inSubLoop(BB, CurLoop, LI))
    continue;

  for (BasicBlock::iterator II = BB->end(); II != BB->begin();) {
    Instruction &I = *--II;

    // If the instruction is dead, we would try to sink it because it isn't
    // used in the loop, instead, just delete it.
    if (isInstructionTriviallyDead(&I, TLI)) {
      LLVM_DEBUG(dbgs() << "LICM deleting dead inst: " << I << '\n')do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("licm")) { dbgs() << "LICM deleting dead inst: " <<
 I << '\n'; } } while (false);
      salvageKnowledge(&I);
      salvageDebugInfo(I);
      ++II;
      eraseInstruction(I, *SafetyInfo, CurAST, MSSAU);
      Changed = true;
      continue;
    }

    // Check to see if we can sink this instruction to the exit blocks
    // of the loop.  We can do this if the all users of the instruction are
    // outside of the loop.  In this case, it doesn't even matter if the
    // operands of the instruction are loop invariant.
    //
    bool FreeInLoop = false;
    if (!I.mayHaveSideEffects() &&
        isNotUsedOrFreeInLoop(I, CurLoop, SafetyInfo, TTI, FreeInLoop) &&
        canSinkOrHoistInst(I, AA, DT, CurLoop, CurAST, MSSAU, true, &Flags,
                           ORE)) {
      if (sink(I, LI, DT, BFI, CurLoop, SafetyInfo, MSSAU, ORE)) {
        if (!FreeInLoop) {
          ++II;
          salvageDebugInfo(I);
          eraseInstruction(I, *SafetyInfo, CurAST, MSSAU);
        }
        Changed = true;
      }
    }
  }
}
if (MSSAU && VerifyMemorySSA)
  MSSAU->getMemorySSA()->verifyMemorySSA();
return Changed;
597}

599namespace {
600// This is a helper class for hoistRegion to make it able to hoist control flow
601// in order to be able to hoist phis. The way this works is that we initially
602// start hoisting to the loop preheader, and when we see a loop invariant branch
603// we make note of this. When we then come to hoist an instruction that's
604// conditional on such a branch we duplicate the branch and the relevant control
605// flow, then hoist the instruction into the block corresponding to its original
606// block in the duplicated control flow.
607class ControlFlowHoister {
608private:
// Information about the loop we are hoisting from
LoopInfo *LI;
DominatorTree *DT;
Loop *CurLoop;
MemorySSAUpdater *MSSAU;

// A map of blocks in the loop to the block their instructions will be hoisted
// to.
DenseMap<BasicBlock *, BasicBlock *> HoistDestinationMap;

// The branches that we can hoist, mapped to the block that marks a
// convergence point of their control flow.
DenseMap<BranchInst *, BasicBlock *> HoistableBranches;

623public:
ControlFlowHoister(LoopInfo *LI, DominatorTree *DT, Loop *CurLoop,
                   MemorySSAUpdater *MSSAU)
    : LI(LI), DT(DT), CurLoop(CurLoop), MSSAU(MSSAU) {}

void registerPossiblyHoistableBranch(BranchInst *BI) {
  // We can only hoist conditional branches with loop invariant operands.
  if (!ControlFlowHoisting || !BI->isConditional() ||
      !CurLoop->hasLoopInvariantOperands(BI))
    return;

  // The branch destinations need to be in the loop, and we don't gain
  // anything by duplicating conditional branches with duplicate successors,
  // as it's essentially the same as an unconditional branch.
  BasicBlock *TrueDest = BI->getSuccessor(0);
  BasicBlock *FalseDest = BI->getSuccessor(1);
  if (!CurLoop->contains(TrueDest) || !CurLoop->contains(FalseDest) ||
      TrueDest == FalseDest)
    return;

  // We can hoist BI if one branch destination is the successor of the other,
  // or both have common successor which we check by seeing if the
  // intersection of their successors is non-empty.
  // TODO: This could be expanded to allowing branches where both ends
  // eventually converge to a single block.
  SmallPtrSet<BasicBlock *, 4> TrueDestSucc, FalseDestSucc;
  TrueDestSucc.insert(succ_begin(TrueDest), succ_end(TrueDest));
  FalseDestSucc.insert(succ_begin(FalseDest), succ_end(FalseDest));
  BasicBlock *CommonSucc = nullptr;
  if (TrueDestSucc.count(FalseDest)) {
    CommonSucc = FalseDest;
  } else if (FalseDestSucc.count(TrueDest)) {
    CommonSucc = TrueDest;
  } else {
    set_intersect(TrueDestSucc, FalseDestSucc);
    // If there's one common successor use that.
    if (TrueDestSucc.size() == 1)
      CommonSucc = *TrueDestSucc.begin();
    // If there's more than one pick whichever appears first in the block list
    // (we can't use the value returned by TrueDestSucc.begin() as it's
    // unpredicatable which element gets returned).
    else if (!TrueDestSucc.empty()) {
      Function *F = TrueDest->getParent();
      auto IsSucc = [&](BasicBlock &BB) { return TrueDestSucc.count(&BB); };
      auto It = llvm::find_if(*F, IsSucc);
      assert(It != F->end() && "Could not find successor in function")((It != F->end() && "Could not find successor in function"
) ? static_cast<void> (0) : __assert_fail ("It != F->end() && \"Could not find successor in function\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Transforms/Scalar/LICM.cpp"
, 668, __PRETTY_FUNCTION__));
      CommonSucc = &*It;
    }
  }
  // The common successor has to be dominated by the branch, as otherwise
  // there will be some other path to the successor that will not be
  // controlled by this branch so any phi we hoist would be controlled by the
  // wrong condition. This also takes care of avoiding hoisting of loop back
  // edges.
  // TODO: In some cases this could be relaxed if the successor is dominated
  // by another block that's been hoisted and we can guarantee that the
  // control flow has been replicated exactly.
  if (CommonSucc && DT->dominates(BI, CommonSucc))
    HoistableBranches[BI] = CommonSucc;
}

bool canHoistPHI(PHINode *PN) {
  // The phi must have loop invariant operands.
  if (!ControlFlowHoisting || !CurLoop->hasLoopInvariantOperands(PN))
    return false;
  // We can hoist phis if the block they are in is the target of hoistable
  // branches which cover all of the predecessors of the block.
  SmallPtrSet<BasicBlock *, 8> PredecessorBlocks;
  BasicBlock *BB = PN->getParent();
  for (BasicBlock *PredBB : predecessors(BB))
    PredecessorBlocks.insert(PredBB);
  // If we have less predecessor blocks than predecessors then the phi will
  // have more than one incoming value for the same block which we can't
  // handle.
  // TODO: This could be handled be erasing some of the duplicate incoming
  // values.
  if (PredecessorBlocks.size() != pred_size(BB))
    return false;
  for (auto &Pair : HoistableBranches) {
    if (Pair.second == BB) {
      // Which blocks are predecessors via this branch depends on if the
      // branch is triangle-like or diamond-like.
      if (Pair.first->getSuccessor(0) == BB) {
        PredecessorBlocks.erase(Pair.first->getParent());
        PredecessorBlocks.erase(Pair.first->getSuccessor(1));
      } else if (Pair.first->getSuccessor(1) == BB) {
        PredecessorBlocks.erase(Pair.first->getParent());
        PredecessorBlocks.erase(Pair.first->getSuccessor(0));
      } else {
        PredecessorBlocks.erase(Pair.first->getSuccessor(0));
        PredecessorBlocks.erase(Pair.first->getSuccessor(1));
      }
    }
  }
  // PredecessorBlocks will now be empty if for every predecessor of BB we
  // found a hoistable branch source.
  return PredecessorBlocks.empty();
}

BasicBlock *getOrCreateHoistedBlock(BasicBlock *BB) {
  if (!ControlFlowHoisting)
    return CurLoop->getLoopPreheader();
  // If BB has already been hoisted, return that
  if (HoistDestinationMap.count(BB))
    return HoistDestinationMap[BB];

  // Check if this block is conditional based on a pending branch
  auto HasBBAsSuccessor =
      [&](DenseMap<BranchInst *, BasicBlock *>::value_type &Pair) {
        return BB != Pair.second && (Pair.first->getSuccessor(0) == BB ||
                                     Pair.first->getSuccessor(1) == BB);
      };
  auto It = llvm::find_if(HoistableBranches, HasBBAsSuccessor);

  // If not involved in a pending branch, hoist to preheader
  BasicBlock *InitialPreheader = CurLoop->getLoopPreheader();
  if (It == HoistableBranches.end()) {
    LLVM_DEBUG(dbgs() << "LICM using "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("licm")) { dbgs() << "LICM using " << InitialPreheader
->getNameOrAsOperand() << " as hoist destination for "
 << BB->getNameOrAsOperand() << "\n"; } } while
 (false)
                      << InitialPreheader->getNameOrAsOperand()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("licm")) { dbgs() << "LICM using " << InitialPreheader
->getNameOrAsOperand() << " as hoist destination for "
 << BB->getNameOrAsOperand() << "\n"; } } while
 (false)
                      << " as hoist destination for "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("licm")) { dbgs() << "LICM using " << InitialPreheader
->getNameOrAsOperand() << " as hoist destination for "
 << BB->getNameOrAsOperand() << "\n"; } } while
 (false)
                      << BB->getNameOrAsOperand() << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("licm")) { dbgs() << "LICM using " << InitialPreheader
->getNameOrAsOperand() << " as hoist destination for "
 << BB->getNameOrAsOperand() << "\n"; } } while
 (false);
    HoistDestinationMap[BB] = InitialPreheader;
    return InitialPreheader;
  }
  BranchInst *BI = It->first;
  assert(std::find_if(++It, HoistableBranches.end(), HasBBAsSuccessor) ==((std::find_if(++It, HoistableBranches.end(), HasBBAsSuccessor
) == HoistableBranches.end() && "BB is expected to be the target of at most one branch"
) ? static_cast<void> (0) : __assert_fail ("std::find_if(++It, HoistableBranches.end(), HasBBAsSuccessor) == HoistableBranches.end() && \"BB is expected to be the target of at most one branch\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Transforms/Scalar/LICM.cpp"
, 750, __PRETTY_FUNCTION__))
             HoistableBranches.end() &&((std::find_if(++It, HoistableBranches.end(), HasBBAsSuccessor
) == HoistableBranches.end() && "BB is expected to be the target of at most one branch"
) ? static_cast<void> (0) : __assert_fail ("std::find_if(++It, HoistableBranches.end(), HasBBAsSuccessor) == HoistableBranches.end() && \"BB is expected to be the target of at most one branch\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Transforms/Scalar/LICM.cpp"
, 750, __PRETTY_FUNCTION__))
         "BB is expected to be the target of at most one branch")((std::find_if(++It, HoistableBranches.end(), HasBBAsSuccessor
) == HoistableBranches.end() && "BB is expected to be the target of at most one branch"
) ? static_cast<void> (0) : __assert_fail ("std::find_if(++It, HoistableBranches.end(), HasBBAsSuccessor) == HoistableBranches.end() && \"BB is expected to be the target of at most one branch\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Transforms/Scalar/LICM.cpp"
, 750, __PRETTY_FUNCTION__));

  LLVMContext &C = BB->getContext();
  BasicBlock *TrueDest = BI->getSuccessor(0);
  BasicBlock *FalseDest = BI->getSuccessor(1);
  BasicBlock *CommonSucc = HoistableBranches[BI];
  BasicBlock *HoistTarget = getOrCreateHoistedBlock(BI->getParent());

  // Create hoisted versions of blocks that currently don't have them
  auto CreateHoistedBlock = [&](BasicBlock *Orig) {
    if (HoistDestinationMap.count(Orig))
      return HoistDestinationMap[Orig];
    BasicBlock *New =
        BasicBlock::Create(C, Orig->getName() + ".licm", Orig->getParent());
    HoistDestinationMap[Orig] = New;
    DT->addNewBlock(New, HoistTarget);
    if (CurLoop->getParentLoop())
      CurLoop->getParentLoop()->addBasicBlockToLoop(New, *LI);
    ++NumCreatedBlocks;
    LLVM_DEBUG(dbgs() << "LICM created " << New->getName()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("licm")) { dbgs() << "LICM created " << New->
getName() << " as hoist destination for " << Orig
->getName() << "\n"; } } while (false)
                      << " as hoist destination for " << Orig->getName()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("licm")) { dbgs() << "LICM created " << New->
getName() << " as hoist destination for " << Orig
->getName() << "\n"; } } while (false)
                      << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("licm")) { dbgs() << "LICM created " << New->
getName() << " as hoist destination for " << Orig
->getName() << "\n"; } } while (false);
    return New;
  };
  BasicBlock *HoistTrueDest = CreateHoistedBlock(TrueDest);
  BasicBlock *HoistFalseDest = CreateHoistedBlock(FalseDest);
  BasicBlock *HoistCommonSucc = CreateHoistedBlock(CommonSucc);

  // Link up these blocks with branches.
  if (!HoistCommonSucc->getTerminator()) {
    // The new common successor we've generated will branch to whatever that
    // hoist target branched to.
    BasicBlock *TargetSucc = HoistTarget->getSingleSuccessor();
    assert(TargetSucc && "Expected hoist target to have a single successor")((TargetSucc && "Expected hoist target to have a single successor"
) ? static_cast<void> (0) : __assert_fail ("TargetSucc && \"Expected hoist target to have a single successor\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Transforms/Scalar/LICM.cpp"
, 783, __PRETTY_FUNCTION__));
    HoistCommonSucc->moveBefore(TargetSucc);
    BranchInst::Create(TargetSucc, HoistCommonSucc);
  }
  if (!HoistTrueDest->getTerminator()) {
    HoistTrueDest->moveBefore(HoistCommonSucc);
    BranchInst::Create(HoistCommonSucc, HoistTrueDest);
  }
  if (!HoistFalseDest->getTerminator()) {
    HoistFalseDest->moveBefore(HoistCommonSucc);
    BranchInst::Create(HoistCommonSucc, HoistFalseDest);
  }

  // If BI is being cloned to what was originally the preheader then
  // HoistCommonSucc will now be the new preheader.
  if (HoistTarget == InitialPreheader) {
    // Phis in the loop header now need to use the new preheader.
    InitialPreheader->replaceSuccessorsPhiUsesWith(HoistCommonSucc);
    if (MSSAU)
      MSSAU->wireOldPredecessorsToNewImmediatePredecessor(
          HoistTarget->getSingleSuccessor(), HoistCommonSucc, {HoistTarget});
    // The new preheader dominates the loop header.
    DomTreeNode *PreheaderNode = DT->getNode(HoistCommonSucc);
    DomTreeNode *HeaderNode = DT->getNode(CurLoop->getHeader());
    DT->changeImmediateDominator(HeaderNode, PreheaderNode);
    // The preheader hoist destination is now the new preheader, with the
    // exception of the hoist destination of this branch.
    for (auto &Pair : HoistDestinationMap)
      if (Pair.second == InitialPreheader && Pair.first != BI->getParent())
        Pair.second = HoistCommonSucc;
  }

  // Now finally clone BI.
  ReplaceInstWithInst(
      HoistTarget->getTerminator(),
      BranchInst::Create(HoistTrueDest, HoistFalseDest, BI->getCondition()));
  ++NumClonedBranches;

  assert(CurLoop->getLoopPreheader() &&((CurLoop->getLoopPreheader() && "Hoisting blocks should not have destroyed preheader"
) ? static_cast<void> (0) : __assert_fail ("CurLoop->getLoopPreheader() && \"Hoisting blocks should not have destroyed preheader\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Transforms/Scalar/LICM.cpp"
, 822, __PRETTY_FUNCTION__))
         "Hoisting blocks should not have destroyed preheader")((CurLoop->getLoopPreheader() && "Hoisting blocks should not have destroyed preheader"
) ? static_cast<void> (0) : __assert_fail ("CurLoop->getLoopPreheader() && \"Hoisting blocks should not have destroyed preheader\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Transforms/Scalar/LICM.cpp"
, 822, __PRETTY_FUNCTION__));
  return HoistDestinationMap[BB];
}
825};
826} // namespace

828// Hoisting/sinking instruction out of a loop isn't always beneficial. It's only
829// only worthwhile if the destination block is actually colder than current
830// block.
831static bool worthSinkOrHoistInst(Instruction &I, BasicBlock *DstBlock,
                               OptimizationRemarkEmitter *ORE,
                               BlockFrequencyInfo *BFI) {
// Check block frequency only when runtime profile is available
// to avoid pathological cases. With static profile, lean towards
// hosting because it helps canonicalize the loop for vectorizer.
if (!DstBlock->getParent()->hasProfileData())
  return true;

if (!HoistSinkColdnessThreshold || !BFI)
  return true;

BasicBlock *SrcBlock = I.getParent();
if (BFI->getBlockFreq(DstBlock).getFrequency() / HoistSinkColdnessThreshold >
    BFI->getBlockFreq(SrcBlock).getFrequency()) {
  ORE->emit([&]() {
    return OptimizationRemarkMissed(DEBUG_TYPE"licm", "SinkHoistInst", &I)
           << "failed to sink or hoist instruction because containing block "
              "has lower frequency than destination block";
  });
  return false;
}

return true;
855}

857/// Walk the specified region of the CFG (defined by all blocks dominated by
858/// the specified block, and that are in the current loop) in depth first
859/// order w.r.t the DominatorTree.  This allows us to visit definitions before
860/// uses, allowing us to hoist a loop body in one pass without iteration.
861///
862bool llvm::hoistRegion(DomTreeNode *N, AAResults *AA, LoopInfo *LI,
                     DominatorTree *DT, BlockFrequencyInfo *BFI,
                     TargetLibraryInfo *TLI, Loop *CurLoop,
                     AliasSetTracker *CurAST, MemorySSAUpdater *MSSAU,
                     ScalarEvolution *SE, ICFLoopSafetyInfo *SafetyInfo,
                     SinkAndHoistLICMFlags &Flags,
                     OptimizationRemarkEmitter *ORE) {
// Verify inputs.
assert(N != nullptr && AA != nullptr && LI != nullptr && DT != nullptr &&((N != nullptr && AA != nullptr && LI != nullptr
 && DT != nullptr && CurLoop != nullptr &&
 SafetyInfo != nullptr && "Unexpected input to hoistRegion."
) ? static_cast<void> (0) : __assert_fail ("N != nullptr && AA != nullptr && LI != nullptr && DT != nullptr && CurLoop != nullptr && SafetyInfo != nullptr && \"Unexpected input to hoistRegion.\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Transforms/Scalar/LICM.cpp"
, 872, __PRETTY_FUNCTION__))
       CurLoop != nullptr && SafetyInfo != nullptr &&((N != nullptr && AA != nullptr && LI != nullptr
 && DT != nullptr && CurLoop != nullptr &&
 SafetyInfo != nullptr && "Unexpected input to hoistRegion."
) ? static_cast<void> (0) : __assert_fail ("N != nullptr && AA != nullptr && LI != nullptr && DT != nullptr && CurLoop != nullptr && SafetyInfo != nullptr && \"Unexpected input to hoistRegion.\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Transforms/Scalar/LICM.cpp"
, 872, __PRETTY_FUNCTION__))
       "Unexpected input to hoistRegion.")((N != nullptr && AA != nullptr && LI != nullptr
 && DT != nullptr && CurLoop != nullptr &&
 SafetyInfo != nullptr && "Unexpected input to hoistRegion."
) ? static_cast<void> (0) : __assert_fail ("N != nullptr && AA != nullptr && LI != nullptr && DT != nullptr && CurLoop != nullptr && SafetyInfo != nullptr && \"Unexpected input to hoistRegion.\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Transforms/Scalar/LICM.cpp"
, 872, __PRETTY_FUNCTION__));
assert(((CurAST != nullptr) ^ (MSSAU != nullptr)) &&((((CurAST != nullptr) ^ (MSSAU != nullptr)) && "Either AliasSetTracker or MemorySSA should be initialized."
) ? static_cast<void> (0) : __assert_fail ("((CurAST != nullptr) ^ (MSSAU != nullptr)) && \"Either AliasSetTracker or MemorySSA should be initialized.\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Transforms/Scalar/LICM.cpp"
, 874, __PRETTY_FUNCTION__))
       "Either AliasSetTracker or MemorySSA should be initialized.")((((CurAST != nullptr) ^ (MSSAU != nullptr)) && "Either AliasSetTracker or MemorySSA should be initialized."
) ? static_cast<void> (0) : __assert_fail ("((CurAST != nullptr) ^ (MSSAU != nullptr)) && \"Either AliasSetTracker or MemorySSA should be initialized.\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Transforms/Scalar/LICM.cpp"
, 874, __PRETTY_FUNCTION__));

ControlFlowHoister CFH(LI, DT, CurLoop, MSSAU);

// Keep track of instructions that have been hoisted, as they may need to be
// re-hoisted if they end up not dominating all of their uses.
SmallVector<Instruction *, 16> HoistedInstructions;

// For PHI hoisting to work we need to hoist blocks before their successors.
// We can do this by iterating through the blocks in the loop in reverse
// post-order.
LoopBlocksRPO Worklist(CurLoop);
Worklist.perform(LI);
bool Changed = false;
for (BasicBlock *BB : Worklist) {
  // Only need to process the contents of this block if it is not part of a
  // subloop (which would already have been processed).
  if (inSubLoop(BB, CurLoop, LI))
    continue;

  for (BasicBlock::iterator II = BB->begin(), E = BB->end(); II != E;) {
    Instruction &I = *II++;
    // Try constant folding this instruction.  If all the operands are
    // constants, it is technically hoistable, but it would be better to
    // just fold it.
    if (Constant *C = ConstantFoldInstruction(
            &I, I.getModule()->getDataLayout(), TLI)) {
      LLVM_DEBUG(dbgs() << "LICM folding inst: " << I << "  --> " << *Cdo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("licm")) { dbgs() << "LICM folding inst: " << I <<
 "  --> " << *C << '\n'; } } while (false)
                        << '\n')do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("licm")) { dbgs() << "LICM folding inst: " << I <<
 "  --> " << *C << '\n'; } } while (false);
      if (CurAST)
        CurAST->copyValue(&I, C);
      // FIXME MSSA: Such replacements may make accesses unoptimized (D51960).
      I.replaceAllUsesWith(C);
      if (isInstructionTriviallyDead(&I, TLI))
        eraseInstruction(I, *SafetyInfo, CurAST, MSSAU);
      Changed = true;
      continue;
    }

    // Try hoisting the instruction out to the preheader.  We can only do
    // this if all of the operands of the instruction are loop invariant and
    // if it is safe to hoist the instruction. We also check block frequency
    // to make sure instruction only gets hoisted into colder blocks.
    // TODO: It may be safe to hoist if we are hoisting to a conditional block
    // and we have accurately duplicated the control flow from the loop header
    // to that block.
    if (CurLoop->hasLoopInvariantOperands(&I) &&
        canSinkOrHoistInst(I, AA, DT, CurLoop, CurAST, MSSAU, true, &Flags,
                           ORE) &&
        worthSinkOrHoistInst(I, CurLoop->getLoopPreheader(), ORE, BFI) &&
        isSafeToExecuteUnconditionally(
            I, DT, TLI, CurLoop, SafetyInfo, ORE,
            CurLoop->getLoopPreheader()->getTerminator())) {
      hoist(I, DT, CurLoop, CFH.getOrCreateHoistedBlock(BB), SafetyInfo,
            MSSAU, SE, ORE);
      HoistedInstructions.push_back(&I);
      Changed = true;
      continue;
    }

    // Attempt to remove floating point division out of the loop by
    // converting it to a reciprocal multiplication.
    if (I.getOpcode() == Instruction::FDiv && I.hasAllowReciprocal() &&
        CurLoop->isLoopInvariant(I.getOperand(1))) {
      auto Divisor = I.getOperand(1);
      auto One = llvm::ConstantFP::get(Divisor->getType(), 1.0);
      auto ReciprocalDivisor = BinaryOperator::CreateFDiv(One, Divisor);
      ReciprocalDivisor->setFastMathFlags(I.getFastMathFlags());
      SafetyInfo->insertInstructionTo(ReciprocalDivisor, I.getParent());
      ReciprocalDivisor->insertBefore(&I);

      auto Product =
          BinaryOperator::CreateFMul(I.getOperand(0), ReciprocalDivisor);
      Product->setFastMathFlags(I.getFastMathFlags());
      SafetyInfo->insertInstructionTo(Product, I.getParent());
      Product->insertAfter(&I);
      I.replaceAllUsesWith(Product);
      eraseInstruction(I, *SafetyInfo, CurAST, MSSAU);

      hoist(*ReciprocalDivisor, DT, CurLoop, CFH.getOrCreateHoistedBlock(BB),
            SafetyInfo, MSSAU, SE, ORE);
      HoistedInstructions.push_back(ReciprocalDivisor);
      Changed = true;
      continue;
    }

    auto IsInvariantStart = [&](Instruction &I) {
      using namespace PatternMatch;
      return I.use_empty() &&
             match(&I, m_Intrinsic<Intrinsic::invariant_start>());
    };
    auto MustExecuteWithoutWritesBefore = [&](Instruction &I) {
      return SafetyInfo->isGuaranteedToExecute(I, DT, CurLoop) &&
             SafetyInfo->doesNotWriteMemoryBefore(I, CurLoop);
    };
    if ((IsInvariantStart(I) || isGuard(&I)) &&
        CurLoop->hasLoopInvariantOperands(&I) &&
        MustExecuteWithoutWritesBefore(I)) {
      hoist(I, DT, CurLoop, CFH.getOrCreateHoistedBlock(BB), SafetyInfo,
            MSSAU, SE, ORE);
      HoistedInstructions.push_back(&I);
      Changed = true;
      continue;
    }

    if (PHINode *PN = dyn_cast<PHINode>(&I)) {
      if (CFH.canHoistPHI(PN)) {
        // Redirect incoming blocks first to ensure that we create hoisted
        // versions of those blocks before we hoist the phi.
        for (unsigned int i = 0; i < PN->getNumIncomingValues(); ++i)
          PN->setIncomingBlock(
              i, CFH.getOrCreateHoistedBlock(PN->getIncomingBlock(i)));
        hoist(*PN, DT, CurLoop, CFH.getOrCreateHoistedBlock(BB), SafetyInfo,
              MSSAU, SE, ORE);
        assert(DT->dominates(PN, BB) && "Conditional PHIs not expected")((DT->dominates(PN, BB) && "Conditional PHIs not expected"
) ? static_cast<void> (0) : __assert_fail ("DT->dominates(PN, BB) && \"Conditional PHIs not expected\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Transforms/Scalar/LICM.cpp"
, 988, __PRETTY_FUNCTION__));
        Changed = true;
        continue;
      }
    }

    // Remember possibly hoistable branches so we can actually hoist them
    // later if needed.
    if (BranchInst *BI = dyn_cast<BranchInst>(&I))
      CFH.registerPossiblyHoistableBranch(BI);
  }
}

// If we hoisted instructions to a conditional block they may not dominate
// their uses that weren't hoisted (such as phis where some operands are not
// loop invariant). If so make them unconditional by moving them to their
// immediate dominator. We iterate through the instructions in reverse order
// which ensures that when we rehoist an instruction we rehoist its operands,
// and also keep track of where in the block we are rehoisting to to make sure
// that we rehoist instructions before the instructions that use them.
Instruction *HoistPoint = nullptr;
if (ControlFlowHoisting) {
  for (Instruction *I : reverse(HoistedInstructions)) {
    if (!llvm::all_of(I->uses(),
                      [&](Use &U) { return DT->dominates(I, U); })) {
      BasicBlock *Dominator =
          DT->getNode(I->getParent())->getIDom()->getBlock();
      if (!HoistPoint || !DT->dominates(HoistPoint->getParent(), Dominator)) {
        if (HoistPoint)
          assert(DT->dominates(Dominator, HoistPoint->getParent()) &&((DT->dominates(Dominator, HoistPoint->getParent()) &&
 "New hoist point expected to dominate old hoist point") ? static_cast
<void> (0) : __assert_fail ("DT->dominates(Dominator, HoistPoint->getParent()) && \"New hoist point expected to dominate old hoist point\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Transforms/Scalar/LICM.cpp"
, 1018, __PRETTY_FUNCTION__))
                 "New hoist point expected to dominate old hoist point")((DT->dominates(Dominator, HoistPoint->getParent()) &&
 "New hoist point expected to dominate old hoist point") ? static_cast
<void> (0) : __assert_fail ("DT->dominates(Dominator, HoistPoint->getParent()) && \"New hoist point expected to dominate old hoist point\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Transforms/Scalar/LICM.cpp"
, 1018, __PRETTY_FUNCTION__));
        HoistPoint = Dominator->getTerminator();
      }
      LLVM_DEBUG(dbgs() << "LICM rehoisting to "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("licm")) { dbgs() << "LICM rehoisting to " << HoistPoint
->getParent()->getNameOrAsOperand() << ": " <<
 *I << "\n"; } } while (false)
                        << HoistPoint->getParent()->getNameOrAsOperand()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("licm")) { dbgs() << "LICM rehoisting to " << HoistPoint
->getParent()->getNameOrAsOperand() << ": " <<
 *I << "\n"; } } while (false)
                        << ": " << *I << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("licm")) { dbgs() << "LICM rehoisting to " << HoistPoint
->getParent()->getNameOrAsOperand() << ": " <<
 *I << "\n"; } } while (false);
      moveInstructionBefore(*I, *HoistPoint, *SafetyInfo, MSSAU, SE);
      HoistPoint = I;
      Changed = true;
    }
  }
}
if (MSSAU && VerifyMemorySSA)
  MSSAU->getMemorySSA()->verifyMemorySSA();

  // Now that we've finished hoisting make sure that LI and DT are still
  // valid.
1035#ifdef EXPENSIVE_CHECKS
if (Changed) {
  assert(DT->verify(DominatorTree::VerificationLevel::Fast) &&((DT->verify(DominatorTree::VerificationLevel::Fast) &&
 "Dominator tree verification failed") ? static_cast<void>
 (0) : __assert_fail ("DT->verify(DominatorTree::VerificationLevel::Fast) && \"Dominator tree verification failed\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Transforms/Scalar/LICM.cpp"
, 1038, __PRETTY_FUNCTION__))
         "Dominator tree verification failed")((DT->verify(DominatorTree::VerificationLevel::Fast) &&
 "Dominator tree verification failed") ? static_cast<void>
 (0) : __assert_fail ("DT->verify(DominatorTree::VerificationLevel::Fast) && \"Dominator tree verification failed\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Transforms/Scalar/LICM.cpp"
, 1038, __PRETTY_FUNCTION__));
  LI->verify(*DT);
}
1041#endif

return Changed;
1044}

1046// Return true if LI is invariant within scope of the loop. LI is invariant if
1047// CurLoop is dominated by an invariant.start representing the same memory
1048// location and size as the memory location LI loads from, and also the
1049// invariant.start has no uses.
1050static bool isLoadInvariantInLoop(LoadInst *LI, DominatorTree *DT,
                                Loop *CurLoop) {
Value *Addr = LI->getOperand(0);
const DataLayout &DL = LI->getModule()->getDataLayout();
const TypeSize LocSizeInBits = DL.getTypeSizeInBits(LI->getType());

// It is not currently possible for clang to generate an invariant.start
// intrinsic with scalable vector types because we don't support thread local
// sizeless types and we don't permit sizeless types in structs or classes.
// Furthermore, even if support is added for this in future the intrinsic
// itself is defined to have a size of -1 for variable sized objects. This
// makes it impossible to verify if the intrinsic envelops our region of
// interest. For example, both <vscale x 32 x i8> and <vscale x 16 x i8>
// types would have a -1 parameter, but the former is clearly double the size
// of the latter.
if (LocSizeInBits.isScalable())
  return false;

// if the type is i8 addrspace(x)*, we know this is the type of
// llvm.invariant.start operand
auto *PtrInt8Ty = PointerType::get(Type::getInt8Ty(LI->getContext()),
                                   LI->getPointerAddressSpace());
unsigned BitcastsVisited = 0;
// Look through bitcasts until we reach the i8* type (this is invariant.start
// operand type).
while (Addr->getType() != PtrInt8Ty) {
  auto *BC = dyn_cast<BitCastInst>(Addr);
  // Avoid traversing high number of bitcast uses.
  if (++BitcastsVisited > MaxNumUsesTraversed || !BC)
    return false;
  Addr = BC->getOperand(0);
}

unsigned UsesVisited = 0;
// Traverse all uses of the load operand value, to see if invariant.start is
// one of the uses, and whether it dominates the load instruction.
for (auto *U : Addr->users()) {
  // Avoid traversing for Load operand with high number of users.
  if (++UsesVisited > MaxNumUsesTraversed)
    return false;
  IntrinsicInst *II = dyn_cast<IntrinsicInst>(U);
  // If there are escaping uses of invariant.start instruction, the load maybe
  // non-invariant.
  if (!II || II->getIntrinsicID() != Intrinsic::invariant_start ||
      !II->use_empty())
    continue;
  ConstantInt *InvariantSize = cast<ConstantInt>(II->getArgOperand(0));
  // The intrinsic supports having a -1 argument for variable sized objects
  // so we should check for that here.
  if (InvariantSize->isNegative())
    continue;
  uint64_t InvariantSizeInBits = InvariantSize->getSExtValue() * 8;
  // Confirm the invariant.start location size contains the load operand size
  // in bits. Also, the invariant.start should dominate the load, and we
  // should not hoist the load out of a loop that contains this dominating
  // invariant.start.
  if (LocSizeInBits.getFixedSize() <= InvariantSizeInBits &&
      DT->properlyDominates(II->getParent(), CurLoop->getHeader()))
    return true;
}

return false;
1112}

1114namespace {
1115/// Return true if-and-only-if we know how to (mechanically) both hoist and
1116/// sink a given instruction out of a loop.  Does not address legality
1117/// concerns such as aliasing or speculation safety.
1118bool isHoistableAndSinkableInst(Instruction &I) {
// Only these instructions are hoistable/sinkable.
return (isa<LoadInst>(I) || isa<StoreInst>(I) || isa<CallInst>(I) ||
5
←
Assuming 'I' is a 'LoadInst'→
6
←
Returning the value 1, which participates in a condition later→
        isa<FenceInst>(I) || isa<CastInst>(I) || isa<UnaryOperator>(I) ||
        isa<BinaryOperator>(I) || isa<SelectInst>(I) ||
        isa<GetElementPtrInst>(I) || isa<CmpInst>(I) ||
        isa<InsertElementInst>(I) || isa<ExtractElementInst>(I) ||
        isa<ShuffleVectorInst>(I) || isa<ExtractValueInst>(I) ||
        isa<InsertValueInst>(I) || isa<FreezeInst>(I));
1127}
1128/// Return true if all of the alias sets within this AST are known not to
1129/// contain a Mod, or if MSSA knows thare are no MemoryDefs in the loop.
1130bool isReadOnly(AliasSetTracker *CurAST, const MemorySSAUpdater *MSSAU,
              const Loop *L) {
if (CurAST) {
  for (AliasSet &AS : *CurAST) {
    if (!AS.isForwardingAliasSet() && AS.isMod()) {
      return false;
    }
  }
  return true;
} else { /*MSSAU*/
  for (auto *BB : L->getBlocks())
    if (MSSAU->getMemorySSA()->getBlockDefs(BB))
      return false;
  return true;
}
1145}

1147/// Return true if I is the only Instruction with a MemoryAccess in L.
1148bool isOnlyMemoryAccess(const Instruction *I, const Loop *L,
                      const MemorySSAUpdater *MSSAU) {
for (auto *BB : L->getBlocks())
  if (auto *Accs = MSSAU->getMemorySSA()->getBlockAccesses(BB)) {
    int NotAPhi = 0;
    for (const auto &Acc : *Accs) {
      if (isa<MemoryPhi>(&Acc))
        continue;
      const auto *MUD = cast<MemoryUseOrDef>(&Acc);
      if (MUD->getMemoryInst() != I || NotAPhi++ == 1)
        return false;
    }
  }
return true;
1162}
1163}

1165bool llvm::canSinkOrHoistInst(Instruction &I, AAResults *AA, DominatorTree *DT,
                            Loop *CurLoop, AliasSetTracker *CurAST,
                            MemorySSAUpdater *MSSAU,
                            bool TargetExecutesOncePerLoop,
                            SinkAndHoistLICMFlags *Flags,
                            OptimizationRemarkEmitter *ORE) {
assert(((CurAST != nullptr) ^ (MSSAU != nullptr)) &&((((CurAST != nullptr) ^ (MSSAU != nullptr)) && "Either AliasSetTracker or MemorySSA should be initialized."
) ? static_cast<void> (0) : __assert_fail ("((CurAST != nullptr) ^ (MSSAU != nullptr)) && \"Either AliasSetTracker or MemorySSA should be initialized.\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Transforms/Scalar/LICM.cpp"
, 1172, __PRETTY_FUNCTION__))
1
Assuming pointer value is null→
2
←
Assuming the condition is true→
3
←
'?' condition is true→
       "Either AliasSetTracker or MemorySSA should be initialized.")((((CurAST != nullptr) ^ (MSSAU != nullptr)) && "Either AliasSetTracker or MemorySSA should be initialized."
) ? static_cast<void> (0) : __assert_fail ("((CurAST != nullptr) ^ (MSSAU != nullptr)) && \"Either AliasSetTracker or MemorySSA should be initialized.\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Transforms/Scalar/LICM.cpp"
, 1172, __PRETTY_FUNCTION__));

// If we don't understand the instruction, bail early.
if (!isHoistableAndSinkableInst(I))
4
←
Calling 'isHoistableAndSinkableInst'→
7
←
Returning from 'isHoistableAndSinkableInst'→
8
←
Taking false branch→
  return false;

MemorySSA *MSSA = MSSAU8.1
'MSSAU' is non-null
1
'MSSAU' is non-null
1
'MSSAU' is non-null
1
'MSSAU' is non-null
1
'MSSAU' is non-null
 ? MSSAU->getMemorySSA() : nullptr;
9
←
'?' condition is true→
10
←
'MSSA' initialized here→
if (MSSA)
11
←
Assuming 'MSSA' is null→
12
←
Taking false branch→
  assert(Flags != nullptr && "Flags cannot be null.")((Flags != nullptr && "Flags cannot be null.") ? static_cast
<void> (0) : __assert_fail ("Flags != nullptr && \"Flags cannot be null.\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Transforms/Scalar/LICM.cpp"
, 1180, __PRETTY_FUNCTION__));

// Loads have extra constraints we have to verify before we can hoist them.
if (LoadInst *LI13.1
'LI' is null
1
'LI' is null
1
'LI' is null
1
'LI' is null
1
'LI' is null
 = dyn_cast<LoadInst>(&I)) {
13
←
Assuming the object is not a 'LoadInst'→
14
←
Taking false branch→
  if (!LI->isUnordered())
    return false; // Don't sink/hoist volatile or ordered atomic loads!

  // Loads from constant memory are always safe to move, even if they end up
  // in the same alias set as something that ends up being modified.
  if (AA->pointsToConstantMemory(LI->getOperand(0)))
    return true;
  if (LI->hasMetadata(LLVMContext::MD_invariant_load))
    return true;

  if (LI->isAtomic() && !TargetExecutesOncePerLoop)
    return false; // Don't risk duplicating unordered loads

  // This checks for an invariant.start dominating the load.
  if (isLoadInvariantInLoop(LI, DT, CurLoop))
    return true;

  bool Invalidated;
  if (CurAST)
    Invalidated = pointerInvalidatedByLoop(MemoryLocation::get(LI), CurAST,
                                           CurLoop, AA);
  else
    Invalidated = pointerInvalidatedByLoopWithMSSA(
        MSSA, cast<MemoryUse>(MSSA->getMemoryAccess(LI)), CurLoop, I, *Flags);
  // Check loop-invariant address because this may also be a sinkable load
  // whose address is not necessarily loop-invariant.
  if (ORE && Invalidated && CurLoop->isLoopInvariant(LI->getPointerOperand()))
    ORE->emit([&]() {
      return OptimizationRemarkMissed(
                 DEBUG_TYPE"licm", "LoadWithLoopInvariantAddressInvalidated", LI)
             << "failed to move load with loop-invariant address "
                "because the loop may invalidate its value";
    });

  return !Invalidated;
} else if (CallInst *CI15.1
'CI' is non-null
1
'CI' is non-null
1
'CI' is non-null
1
'CI' is non-null
1
'CI' is non-null
 = dyn_cast<CallInst>(&I)) {
15
←
Assuming the object is a 'CallInst'→
16
←
Taking true branch→
  // Don't sink or hoist dbg info; it's legal, but not useful.
  if (isa<DbgInfoIntrinsic>(I))
17
←
Assuming 'I' is not a 'DbgInfoIntrinsic'→
18
←
Taking false branch→
    return false;

  // Don't sink calls which can throw.
  if (CI->mayThrow())
19
←
Assuming the condition is false→
20
←
Taking false branch→
    return false;

  // Convergent attribute has been used on operations that involve
  // inter-thread communication which results are implicitly affected by the
  // enclosing control flows. It is not safe to hoist or sink such operations
  // across control flow.
  if (CI->isConvergent())
21
←
Calling 'CallBase::isConvergent'→
37
←
Returning from 'CallBase::isConvergent'→
38
←
Assuming the condition is false→
39
←
Taking false branch→
    return false;

  using namespace PatternMatch;
  if (match(CI, m_Intrinsic<Intrinsic::assume>()))
40
←
Calling 'match<llvm::CallInst, llvm::PatternMatch::IntrinsicID_match>'→
47
←
Returning from 'match<llvm::CallInst, llvm::PatternMatch::IntrinsicID_match>'→
48
←
Taking false branch→
    // Assumes don't actually alias anything or throw
    return true;

  if (match(CI, m_Intrinsic<Intrinsic::experimental_widenable_condition>()))
49
←
Calling 'match<llvm::CallInst, llvm::PatternMatch::IntrinsicID_match>'→
56
←
Returning from 'match<llvm::CallInst, llvm::PatternMatch::IntrinsicID_match>'→
57
←
Taking false branch→
    // Widenable conditions don't actually alias anything or throw
    return true;

  // Handle simple cases by querying alias analysis.
  FunctionModRefBehavior Behavior = AA->getModRefBehavior(CI);
  if (Behavior == FMRB_DoesNotAccessMemory)
58
←
Assuming 'Behavior' is not equal to FMRB_DoesNotAccessMemory→
59
←
Taking false branch→
    return true;
  if (AAResults::onlyReadsMemory(Behavior)) {
60
←
Calling 'AAResults::onlyReadsMemory'→
63
←
Returning from 'AAResults::onlyReadsMemory'→
64
←
Taking true branch→
    // A readonly argmemonly function only reads from memory pointed to by
    // it's arguments with arbitrary offsets.  If we can prove there are no
    // writes to this memory in the loop, we can hoist or sink.
    if (AAResults::onlyAccessesArgPointees(Behavior)) {
65
←
Calling 'AAResults::onlyAccessesArgPointees'→
68
←
Returning from 'AAResults::onlyAccessesArgPointees'→
69
←
Taking true branch→
      // TODO: expand to writeable arguments
      for (Value *Op : CI->arg_operands())
70
←
Assuming '__begin5' is not equal to '__end5'→
        if (Op->getType()->isPointerTy()) {
71
←
Calling 'Type::isPointerTy'→
74
←
Returning from 'Type::isPointerTy'→
75
←
Taking true branch→
          bool Invalidated;
          if (CurAST75.1
'CurAST' is null
1
'CurAST' is null
1
'CurAST' is null
1
'CurAST' is null
1
'CurAST' is null
)
76
←
Taking false branch→
            Invalidated = pointerInvalidatedByLoop(
                MemoryLocation::getBeforeOrAfter(Op), CurAST, CurLoop, AA);
          else
            Invalidated = pointerInvalidatedByLoopWithMSSA(
                MSSA, cast<MemoryUse>(MSSA->getMemoryAccess(CI)), CurLoop, I,
77
←
Called C++ object pointer is null
                *Flags);
          if (Invalidated)
            return false;
        }
      return true;
    }

    // If this call only reads from memory and there are no writes to memory
    // in the loop, we can hoist or sink the call as appropriate.
    if (isReadOnly(CurAST, MSSAU, CurLoop))
      return true;
  }

  // FIXME: This should use mod/ref information to see if we can hoist or
  // sink the call.

  return false;
} else if (auto *FI = dyn_cast<FenceInst>(&I)) {
  // Fences alias (most) everything to provide ordering.  For the moment,
  // just give up if there are any other memory operations in the loop.
  if (CurAST) {
    auto Begin = CurAST->begin();
    assert(Begin != CurAST->end() && "must contain FI")((Begin != CurAST->end() && "must contain FI") ? static_cast
<void> (0) : __assert_fail ("Begin != CurAST->end() && \"must contain FI\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Transforms/Scalar/LICM.cpp"
, 1285, __PRETTY_FUNCTION__));
    if (std::next(Begin) != CurAST->end())
      // constant memory for instance, TODO: handle better
      return false;
    auto *UniqueI = Begin->getUniqueInstruction();
    if (!UniqueI)
      // other memory op, give up
      return false;
    (void)FI; // suppress unused variable warning
    assert(UniqueI == FI && "AS must contain FI")((UniqueI == FI && "AS must contain FI") ? static_cast
<void> (0) : __assert_fail ("UniqueI == FI && \"AS must contain FI\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Transforms/Scalar/LICM.cpp"
, 1294, __PRETTY_FUNCTION__));
    return true;
  } else // MSSAU
    return isOnlyMemoryAccess(FI, CurLoop, MSSAU);
} else if (auto *SI = dyn_cast<StoreInst>(&I)) {
  if (!SI->isUnordered())
    return false; // Don't sink/hoist volatile or ordered atomic store!

  // We can only hoist a store that we can prove writes a value which is not
  // read or overwritten within the loop.  For those cases, we fallback to
  // load store promotion instead.  TODO: We can extend this to cases where
  // there is exactly one write to the location and that write dominates an
  // arbitrary number of reads in the loop.
  if (CurAST) {
    auto &AS = CurAST->getAliasSetFor(MemoryLocation::get(SI));

    if (AS.isRef() || !AS.isMustAlias())
      // Quick exit test, handled by the full path below as well.
      return false;
    auto *UniqueI = AS.getUniqueInstruction();
    if (!UniqueI)
      // other memory op, give up
      return false;
    assert(UniqueI == SI && "AS must contain SI")((UniqueI == SI && "AS must contain SI") ? static_cast
<void> (0) : __assert_fail ("UniqueI == SI && \"AS must contain SI\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Transforms/Scalar/LICM.cpp"
, 1317, __PRETTY_FUNCTION__));
    return true;
  } else { // MSSAU
    if (isOnlyMemoryAccess(SI, CurLoop, MSSAU))
      return true;
    // If there are more accesses than the Promotion cap or no "quota" to
    // check clobber, then give up as we're not walking a list that long.
    if (Flags->tooManyMemoryAccesses() || Flags->tooManyClobberingCalls())
      return false;
    // If there are interfering Uses (i.e. their defining access is in the
    // loop), or ordered loads (stored as Defs!), don't move this store.
    // Could do better here, but this is conservatively correct.
    // TODO: Cache set of Uses on the first walk in runOnLoop, update when
    // moving accesses. Can also extend to dominating uses.
    auto *SIMD = MSSA->getMemoryAccess(SI);
    for (auto *BB : CurLoop->getBlocks())
      if (auto *Accesses = MSSA->getBlockAccesses(BB)) {
        for (const auto &MA : *Accesses)
          if (const auto *MU = dyn_cast<MemoryUse>(&MA)) {
            auto *MD = MU->getDefiningAccess();
            if (!MSSA->isLiveOnEntryDef(MD) &&
                CurLoop->contains(MD->getBlock()))
              return false;
            // Disable hoisting past potentially interfering loads. Optimized
            // Uses may point to an access outside the loop, as getClobbering
            // checks the previous iteration when walking the backedge.
            // FIXME: More precise: no Uses that alias SI.
            if (!Flags->getIsSink() && !MSSA->dominates(SIMD, MU))
              return false;
          } else if (const auto *MD = dyn_cast<MemoryDef>(&MA)) {
            if (auto *LI = dyn_cast<LoadInst>(MD->getMemoryInst())) {
              (void)LI; // Silence warning.
              assert(!LI->isUnordered() && "Expected unordered load")((!LI->isUnordered() && "Expected unordered load")
 ? static_cast<void> (0) : __assert_fail ("!LI->isUnordered() && \"Expected unordered load\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Transforms/Scalar/LICM.cpp"
, 1349, __PRETTY_FUNCTION__));
              return false;
            }
            // Any call, while it may not be clobbering SI, it may be a use.
            if (auto *CI = dyn_cast<CallInst>(MD->getMemoryInst())) {
              // Check if the call may read from the memory locattion written
              // to by SI. Check CI's attributes and arguments; the number of
              // such checks performed is limited above by NoOfMemAccTooLarge.
              ModRefInfo MRI = AA->getModRefInfo(CI, MemoryLocation::get(SI));
              if (isModOrRefSet(MRI))
                return false;
            }
          }
      }
    auto *Source = MSSA->getSkipSelfWalker()->getClobberingMemoryAccess(SI);
    Flags->incrementClobberingCalls();
    // If there are no clobbering Defs in the loop, store is safe to hoist.
    return MSSA->isLiveOnEntryDef(Source) ||
           !CurLoop->contains(Source->getBlock());
  }
}

assert(!I.mayReadOrWriteMemory() && "unhandled aliasing")((!I.mayReadOrWriteMemory() && "unhandled aliasing") ?
 static_cast<void> (0) : __assert_fail ("!I.mayReadOrWriteMemory() && \"unhandled aliasing\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Transforms/Scalar/LICM.cpp"
, 1371, __PRETTY_FUNCTION__));

// We've established mechanical ability and aliasing, it's up to the caller
// to check fault safety
return true;
1376}

1378/// Returns true if a PHINode is a trivially replaceable with an
1379/// Instruction.
1380/// This is true when all incoming values are that instruction.
1381/// This pattern occurs most often with LCSSA PHI nodes.
1382///
1383static bool isTriviallyReplaceablePHI(const PHINode &PN, const Instruction &I) {
for (const Value *IncValue : PN.incoming_values())
  if (IncValue != &I)
    return false;

return true;
1389}

1391/// Return true if the instruction is free in the loop.
1392static bool isFreeInLoop(const Instruction &I, const Loop *CurLoop,
                       const TargetTransformInfo *TTI) {

if (const GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(&I)) {
  if (TTI->getUserCost(GEP, TargetTransformInfo::TCK_SizeAndLatency) !=
      TargetTransformInfo::TCC_Free)
    return false;
  // For a GEP, we cannot simply use getUserCost because currently it
  // optimistically assume that a GEP will fold into addressing mode
  // regardless of its users.
  const BasicBlock *BB = GEP->getParent();
  for (const User *U : GEP->users()) {
    const Instruction *UI = cast<Instruction>(U);
    if (CurLoop->contains(UI) &&
        (BB != UI->getParent() ||
         (!isa<StoreInst>(UI) && !isa<LoadInst>(UI))))
      return false;
  }
  return true;
} else
  return TTI->getUserCost(&I, TargetTransformInfo::TCK_SizeAndLatency) ==
         TargetTransformInfo::TCC_Free;
1414}

1416/// Return true if the only users of this instruction are outside of
1417/// the loop. If this is true, we can sink the instruction to the exit
1418/// blocks of the loop.
1419///
1420/// We also return true if the instruction could be folded away in lowering.
1421/// (e.g.,  a GEP can be folded into a load as an addressing mode in the loop).
1422static bool isNotUsedOrFreeInLoop(const Instruction &I, const Loop *CurLoop,
                                const LoopSafetyInfo *SafetyInfo,
                                TargetTransformInfo *TTI, bool &FreeInLoop) {
const auto &BlockColors = SafetyInfo->getBlockColors();
bool IsFree = isFreeInLoop(I, CurLoop, TTI);
for (const User *U : I.users()) {
  const Instruction *UI = cast<Instruction>(U);
  if (const PHINode *PN = dyn_cast<PHINode>(UI)) {
    const BasicBlock *BB = PN->getParent();
    // We cannot sink uses in catchswitches.
    if (isa<CatchSwitchInst>(BB->getTerminator()))
      return false;

    // We need to sink a callsite to a unique funclet.  Avoid sinking if the
    // phi use is too muddled.
    if (isa<CallInst>(I))
      if (!BlockColors.empty() &&
          BlockColors.find(const_cast<BasicBlock *>(BB))->second.size() != 1)
        return false;
  }

  if (CurLoop->contains(UI)) {
    if (IsFree) {
      FreeInLoop = true;
      continue;
    }
    return false;
  }
}
return true;
1452}

1454static Instruction *cloneInstructionInExitBlock(
  Instruction &I, BasicBlock &ExitBlock, PHINode &PN, const LoopInfo *LI,
  const LoopSafetyInfo *SafetyInfo, MemorySSAUpdater *MSSAU) {
Instruction *New;
if (auto *CI = dyn_cast<CallInst>(&I)) {
  const auto &BlockColors = SafetyInfo->getBlockColors();

  // Sinking call-sites need to be handled differently from other
  // instructions.  The cloned call-site needs a funclet bundle operand
  // appropriate for its location in the CFG.
  SmallVector<OperandBundleDef, 1> OpBundles;
  for (unsigned BundleIdx = 0, BundleEnd = CI->getNumOperandBundles();
       BundleIdx != BundleEnd; ++BundleIdx) {
    OperandBundleUse Bundle = CI->getOperandBundleAt(BundleIdx);
    if (Bundle.getTagID() == LLVMContext::OB_funclet)
      continue;

    OpBundles.emplace_back(Bundle);
  }

  if (!BlockColors.empty()) {
    const ColorVector &CV = BlockColors.find(&ExitBlock)->second;
    assert(CV.size() == 1 && "non-unique color for exit block!")((CV.size() == 1 && "non-unique color for exit block!"
) ? static_cast<void> (0) : __assert_fail ("CV.size() == 1 && \"non-unique color for exit block!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Transforms/Scalar/LICM.cpp"
, 1476, __PRETTY_FUNCTION__));
    BasicBlock *BBColor = CV.front();
    Instruction *EHPad = BBColor->getFirstNonPHI();
    if (EHPad->isEHPad())
      OpBundles.emplace_back("funclet", EHPad);
  }

  New = CallInst::Create(CI, OpBundles);
} else {
  New = I.clone();
}

ExitBlock.getInstList().insert(ExitBlock.getFirstInsertionPt(), New);
if (!I.getName().empty())
  New->setName(I.getName() + ".le");

if (MSSAU && MSSAU->getMemorySSA()->getMemoryAccess(&I)) {
  // Create a new MemoryAccess and let MemorySSA set its defining access.
  MemoryAccess *NewMemAcc = MSSAU->createMemoryAccessInBB(
      New, nullptr, New->getParent(), MemorySSA::Beginning);
  if (NewMemAcc) {
    if (auto *MemDef = dyn_cast<MemoryDef>(NewMemAcc))
      MSSAU->insertDef(MemDef, /*RenameUses=*/true);
    else {
      auto *MemUse = cast<MemoryUse>(NewMemAcc);
      MSSAU->insertUse(MemUse, /*RenameUses=*/true);
    }
  }
}

// Build LCSSA PHI nodes for any in-loop operands (if legal).  Note that
// this is particularly cheap because we can rip off the PHI node that we're
// replacing for the number and blocks of the predecessors.
// OPT: If this shows up in a profile, we can instead finish sinking all
// invariant instructions, and then walk their operands to re-establish
// LCSSA. That will eliminate creating PHI nodes just to nuke them when
// sinking bottom-up.
for (Use &Op : New->operands())
  if (LI->wouldBeOutOfLoopUseRequiringLCSSA(Op.get(), PN.getParent())) {
    auto *OInst = cast<Instruction>(Op.get());
    PHINode *OpPN =
      PHINode::Create(OInst->getType(), PN.getNumIncomingValues(),
                      OInst->getName() + ".lcssa", &ExitBlock.front());
    for (unsigned i = 0, e = PN.getNumIncomingValues(); i != e; ++i)
      OpPN->addIncoming(OInst, PN.getIncomingBlock(i));
    Op = OpPN;
  }
return New;
1524}

1526static void eraseInstruction(Instruction &I, ICFLoopSafetyInfo &SafetyInfo,
                           AliasSetTracker *AST, MemorySSAUpdater *MSSAU) {
if (AST)
  AST->deleteValue(&I);
if (MSSAU)
  MSSAU->removeMemoryAccess(&I);
SafetyInfo.removeInstruction(&I);
I.eraseFromParent();
1534}

1536static void moveInstructionBefore(Instruction &I, Instruction &Dest,
                                ICFLoopSafetyInfo &SafetyInfo,
                                MemorySSAUpdater *MSSAU,
                                ScalarEvolution *SE) {
SafetyInfo.removeInstruction(&I);
SafetyInfo.insertInstructionTo(&I, Dest.getParent());
I.moveBefore(&Dest);
if (MSSAU)
  if (MemoryUseOrDef *OldMemAcc = cast_or_null<MemoryUseOrDef>(
          MSSAU->getMemorySSA()->getMemoryAccess(&I)))
    MSSAU->moveToPlace(OldMemAcc, Dest.getParent(),
                       MemorySSA::BeforeTerminator);
if (SE)
  SE->forgetValue(&I);
1550}

1552static Instruction *sinkThroughTriviallyReplaceablePHI(
  PHINode *TPN, Instruction *I, LoopInfo *LI,
  SmallDenseMap<BasicBlock *, Instruction *, 32> &SunkCopies,
  const LoopSafetyInfo *SafetyInfo, const Loop *CurLoop,
  MemorySSAUpdater *MSSAU) {
assert(isTriviallyReplaceablePHI(*TPN, *I) &&((isTriviallyReplaceablePHI(*TPN, *I) && "Expect only trivially replaceable PHI"
) ? static_cast<void> (0) : __assert_fail ("isTriviallyReplaceablePHI(*TPN, *I) && \"Expect only trivially replaceable PHI\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Transforms/Scalar/LICM.cpp"
, 1558, __PRETTY_FUNCTION__))
       "Expect only trivially replaceable PHI")((isTriviallyReplaceablePHI(*TPN, *I) && "Expect only trivially replaceable PHI"
) ? static_cast<void> (0) : __assert_fail ("isTriviallyReplaceablePHI(*TPN, *I) && \"Expect only trivially replaceable PHI\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Transforms/Scalar/LICM.cpp"
, 1558, __PRETTY_FUNCTION__));
BasicBlock *ExitBlock = TPN->getParent();
Instruction *New;
auto It = SunkCopies.find(ExitBlock);
if (It != SunkCopies.end())
  New = It->second;
else
  New = SunkCopies[ExitBlock] = cloneInstructionInExitBlock(
      *I, *ExitBlock, *TPN, LI, SafetyInfo, MSSAU);
return New;
1568}

1570static bool canSplitPredecessors(PHINode *PN, LoopSafetyInfo *SafetyInfo) {
BasicBlock *BB = PN->getParent();
if (!BB->canSplitPredecessors())
  return false;
// It's not impossible to split EHPad blocks, but if BlockColors already exist
// it require updating BlockColors for all offspring blocks accordingly. By
// skipping such corner case, we can make updating BlockColors after splitting
// predecessor fairly simple.
if (!SafetyInfo->getBlockColors().empty() && BB->getFirstNonPHI()->isEHPad())
  return false;
for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI) {
  BasicBlock *BBPred = *PI;
  if (isa<IndirectBrInst>(BBPred->getTerminator()) ||
      isa<CallBrInst>(BBPred->getTerminator()))
    return false;
}
return true;
1587}

1589static void splitPredecessorsOfLoopExit(PHINode *PN, DominatorTree *DT,
                                      LoopInfo *LI, const Loop *CurLoop,
                                      LoopSafetyInfo *SafetyInfo,
                                      MemorySSAUpdater *MSSAU) {
1593#ifndef NDEBUG
SmallVector<BasicBlock *, 32> ExitBlocks;
CurLoop->getUniqueExitBlocks(ExitBlocks);
SmallPtrSet<BasicBlock *, 32> ExitBlockSet(ExitBlocks.begin(),
                                           ExitBlocks.end());
1598#endif
BasicBlock *ExitBB = PN->getParent();
assert(ExitBlockSet.count(ExitBB) && "Expect the PHI is in an exit block.")((ExitBlockSet.count(ExitBB) && "Expect the PHI is in an exit block."
) ? static_cast<void> (0) : __assert_fail ("ExitBlockSet.count(ExitBB) && \"Expect the PHI is in an exit block.\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Transforms/Scalar/LICM.cpp"
, 1600, __PRETTY_FUNCTION__));

// Split predecessors of the loop exit to make instructions in the loop are
// exposed to exit blocks through trivially replaceable PHIs while keeping the
// loop in the canonical form where each predecessor of each exit block should
// be contained within the loop. For example, this will convert the loop below
// from
//
// LB1:
//   %v1 =
//   br %LE, %LB2
// LB2:
//   %v2 =
//   br %LE, %LB1
// LE:
//   %p = phi [%v1, %LB1], [%v2, %LB2] <-- non-trivially replaceable
//
// to
//
// LB1:
//   %v1 =
//   br %LE.split, %LB2
// LB2:
//   %v2 =
//   br %LE.split2, %LB1
// LE.split:
//   %p1 = phi [%v1, %LB1]  <-- trivially replaceable
//   br %LE
// LE.split2:
//   %p2 = phi [%v2, %LB2]  <-- trivially replaceable
//   br %LE
// LE:
//   %p = phi [%p1, %LE.split], [%p2, %LE.split2]
//
const auto &BlockColors = SafetyInfo->getBlockColors();
SmallSetVector<BasicBlock *, 8> PredBBs(pred_begin(ExitBB), pred_end(ExitBB));
while (!PredBBs.empty()) {
  BasicBlock *PredBB = *PredBBs.begin();
  assert(CurLoop->contains(PredBB) &&((CurLoop->contains(PredBB) && "Expect all predecessors are in the loop"
) ? static_cast<void> (0) : __assert_fail ("CurLoop->contains(PredBB) && \"Expect all predecessors are in the loop\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Transforms/Scalar/LICM.cpp"
, 1639, __PRETTY_FUNCTION__))
         "Expect all predecessors are in the loop")((CurLoop->contains(PredBB) && "Expect all predecessors are in the loop"
) ? static_cast<void> (0) : __assert_fail ("CurLoop->contains(PredBB) && \"Expect all predecessors are in the loop\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Transforms/Scalar/LICM.cpp"
, 1639, __PRETTY_FUNCTION__));
  if (PN->getBasicBlockIndex(PredBB) >= 0) {
    BasicBlock *NewPred = SplitBlockPredecessors(
        ExitBB, PredBB, ".split.loop.exit", DT, LI, MSSAU, true);
    // Since we do not allow splitting EH-block with BlockColors in
    // canSplitPredecessors(), we can simply assign predecessor's color to
    // the new block.
    if (!BlockColors.empty())
      // Grab a reference to the ColorVector to be inserted before getting the
      // reference to the vector we are copying because inserting the new
      // element in BlockColors might cause the map to be reallocated.
      SafetyInfo->copyColors(NewPred, PredBB);
  }
  PredBBs.remove(PredBB);
}
1654}

1656/// When an instruction is found to only be used outside of the loop, this
1657/// function moves it to the exit blocks and patches up SSA form as needed.
1658/// This method is guaranteed to remove the original instruction from its
1659/// position, and may either delete it or move it to outside of the loop.
1660///
1661static bool sink(Instruction &I, LoopInfo *LI, DominatorTree *DT,
               BlockFrequencyInfo *BFI, const Loop *CurLoop,
               ICFLoopSafetyInfo *SafetyInfo, MemorySSAUpdater *MSSAU,
               OptimizationRemarkEmitter *ORE) {
bool Changed = false;
LLVM_DEBUG(dbgs() << "LICM sinking instruction: " << I << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("licm")) { dbgs() << "LICM sinking instruction: " <<
 I << "\n"; } } while (false);

// Iterate over users to be ready for actual sinking. Replace users via
// unreachable blocks with undef and make all user PHIs trivially replaceable.
SmallPtrSet<Instruction *, 8> VisitedUsers;
for (Value::user_iterator UI = I.user_begin(), UE = I.user_end(); UI != UE;) {
  auto *User = cast<Instruction>(*UI);
  Use &U = UI.getUse();
  ++UI;

  if (VisitedUsers.count(User) || CurLoop->contains(User))
    continue;

  if (!DT->isReachableFromEntry(User->getParent())) {
    U = UndefValue::get(I.getType());
    Changed = true;
    continue;
  }

  // The user must be a PHI node.
  PHINode *PN = cast<PHINode>(User);

  // Surprisingly, instructions can be used outside of loops without any
  // exits.  This can only happen in PHI nodes if the incoming block is
  // unreachable.
  BasicBlock *BB = PN->getIncomingBlock(U);
  if (!DT->isReachableFromEntry(BB)) {
    U = UndefValue::get(I.getType());
    Changed = true;
    continue;
  }

  VisitedUsers.insert(PN);
  if (isTriviallyReplaceablePHI(*PN, I))
    continue;

  if (!canSplitPredecessors(PN, SafetyInfo))
    return Changed;

  // Split predecessors of the PHI so that we can make users trivially
  // replaceable.
  splitPredecessorsOfLoopExit(PN, DT, LI, CurLoop, SafetyInfo, MSSAU);

  // Should rebuild the iterators, as they may be invalidated by
  // splitPredecessorsOfLoopExit().
  UI = I.user_begin();
  UE = I.user_end();
}

if (VisitedUsers.empty())
  return Changed;

ORE->emit([&]() {
  return OptimizationRemark(DEBUG_TYPE"licm", "InstSunk", &I)
         << "sinking " << ore::NV("Inst", &I);
});
if (isa<LoadInst>(I))
  ++NumMovedLoads;
else if (isa<CallInst>(I))
  ++NumMovedCalls;
++NumSunk;

1728#ifndef NDEBUG
SmallVector<BasicBlock *, 32> ExitBlocks;
CurLoop->getUniqueExitBlocks(ExitBlocks);
SmallPtrSet<BasicBlock *, 32> ExitBlockSet(ExitBlocks.begin(),
                                           ExitBlocks.end());
1733#endif

// Clones of this instruction. Don't create more than one per exit block!
SmallDenseMap<BasicBlock *, Instruction *, 32> SunkCopies;

// If this instruction is only used outside of the loop, then all users are
// PHI nodes in exit blocks due to LCSSA form. Just RAUW them with clones of
// the instruction.
// First check if I is worth sinking for all uses. Sink only when it is worth
// across all uses.
SmallSetVector<User*, 8> Users(I.user_begin(), I.user_end());
SmallVector<PHINode *, 8> ExitPNs;
for (auto *UI : Users) {
  auto *User = cast<Instruction>(UI);

  if (CurLoop->contains(User))
    continue;

  PHINode *PN = cast<PHINode>(User);
  assert(ExitBlockSet.count(PN->getParent()) &&((ExitBlockSet.count(PN->getParent()) && "The LCSSA PHI is not in an exit block!"
) ? static_cast<void> (0) : __assert_fail ("ExitBlockSet.count(PN->getParent()) && \"The LCSSA PHI is not in an exit block!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Transforms/Scalar/LICM.cpp"
, 1753, __PRETTY_FUNCTION__))
         "The LCSSA PHI is not in an exit block!")((ExitBlockSet.count(PN->getParent()) && "The LCSSA PHI is not in an exit block!"
) ? static_cast<void> (0) : __assert_fail ("ExitBlockSet.count(PN->getParent()) && \"The LCSSA PHI is not in an exit block!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Transforms/Scalar/LICM.cpp"
, 1753, __PRETTY_FUNCTION__));
  if (!worthSinkOrHoistInst(I, PN->getParent(), ORE, BFI)) {
    return Changed;
  }

  ExitPNs.push_back(PN);
}

for (auto *PN : ExitPNs) {

  // The PHI must be trivially replaceable.
  Instruction *New = sinkThroughTriviallyReplaceablePHI(
      PN, &I, LI, SunkCopies, SafetyInfo, CurLoop, MSSAU);
  PN->replaceAllUsesWith(New);
  eraseInstruction(*PN, *SafetyInfo, nullptr, nullptr);
  Changed = true;
}
return Changed;
1771}

1773/// When an instruction is found to only use loop invariant operands that
1774/// is safe to hoist, this instruction is called to do the dirty work.
1775///
1776static void hoist(Instruction &I, const DominatorTree *DT, const Loop *CurLoop,
                BasicBlock *Dest, ICFLoopSafetyInfo *SafetyInfo,
                MemorySSAUpdater *MSSAU, ScalarEvolution *SE,
                OptimizationRemarkEmitter *ORE) {
LLVM_DEBUG(dbgs() << "LICM hoisting to " << Dest->getNameOrAsOperand() << ": "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("licm")) { dbgs() << "LICM hoisting to " << Dest
->getNameOrAsOperand() << ": " << I << "\n"
; } } while (false)
                  << I << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("licm")) { dbgs() << "LICM hoisting to " << Dest
->getNameOrAsOperand() << ": " << I << "\n"
; } } while (false);
ORE->emit([&]() {
  return OptimizationRemark(DEBUG_TYPE"licm", "Hoisted", &I) << "hoisting "
                                                       << ore::NV("Inst", &I);
});

// Metadata can be dependent on conditions we are hoisting above.
// Conservatively strip all metadata on the instruction unless we were
// guaranteed to execute I if we entered the loop, in which case the metadata
// is valid in the loop preheader.
if (I.hasMetadataOtherThanDebugLoc() &&
    // The check on hasMetadataOtherThanDebugLoc is to prevent us from burning
    // time in isGuaranteedToExecute if we don't actually have anything to
    // drop.  It is a compile time optimization, not required for correctness.
    !SafetyInfo->isGuaranteedToExecute(I, DT, CurLoop))
  I.dropUnknownNonDebugMetadata();

if (isa<PHINode>(I))
  // Move the new node to the end of the phi list in the destination block.
  moveInstructionBefore(I, *Dest->getFirstNonPHI(), *SafetyInfo, MSSAU, SE);
else
  // Move the new node to the destination block, before its terminator.
  moveInstructionBefore(I, *Dest->getTerminator(), *SafetyInfo, MSSAU, SE);

I.updateLocationAfterHoist();

if (isa<LoadInst>(I))
  ++NumMovedLoads;
else if (isa<CallInst>(I))
  ++NumMovedCalls;
++NumHoisted;
1812}

1814/// Only sink or hoist an instruction if it is not a trapping instruction,
1815/// or if the instruction is known not to trap when moved to the preheader.
1816/// or if it is a trapping instruction and is guaranteed to execute.
1817static bool isSafeToExecuteUnconditionally(Instruction &Inst,
                                         const DominatorTree *DT,
                                         const TargetLibraryInfo *TLI,
                                         const Loop *CurLoop,
                                         const LoopSafetyInfo *SafetyInfo,
                                         OptimizationRemarkEmitter *ORE,
                                         const Instruction *CtxI) {
if (isSafeToSpeculativelyExecute(&Inst, CtxI, DT, TLI))
  return true;

bool GuaranteedToExecute =
    SafetyInfo->isGuaranteedToExecute(Inst, DT, CurLoop);

if (!GuaranteedToExecute) {
  auto *LI = dyn_cast<LoadInst>(&Inst);
  if (LI && CurLoop->isLoopInvariant(LI->getPointerOperand()))
    ORE->emit([&]() {
      return OptimizationRemarkMissed(
                 DEBUG_TYPE"licm", "LoadWithLoopInvariantAddressCondExecuted", LI)
             << "failed to hoist load with loop-invariant address "
                "because load is conditionally executed";
    });
}

return GuaranteedToExecute;
1842}

1844namespace {
1845class LoopPromoter : public LoadAndStorePromoter {
Value *SomePtr; // Designated pointer to store to.
const SmallSetVector<Value *, 8> &PointerMustAliases;
SmallVectorImpl<BasicBlock *> &LoopExitBlocks;
SmallVectorImpl<Instruction *> &LoopInsertPts;
SmallVectorImpl<MemoryAccess *> &MSSAInsertPts;
PredIteratorCache &PredCache;
AliasSetTracker *AST;
MemorySSAUpdater *MSSAU;
LoopInfo &LI;
DebugLoc DL;
int Alignment;
bool UnorderedAtomic;
AAMDNodes AATags;
ICFLoopSafetyInfo &SafetyInfo;

// We're about to add a use of V in a loop exit block.  Insert an LCSSA phi
// (if legal) if doing so would add an out-of-loop use to an instruction
// defined in-loop.
Value *maybeInsertLCSSAPHI(Value *V, BasicBlock *BB) const {
  if (!LI.wouldBeOutOfLoopUseRequiringLCSSA(V, BB))
    return V;

  Instruction *I = cast<Instruction>(V);
  // We need to create an LCSSA PHI node for the incoming value and
  // store that.
  PHINode *PN = PHINode::Create(I->getType(), PredCache.size(BB),
                                I->getName() + ".lcssa", &BB->front());
  for (BasicBlock *Pred : PredCache.get(BB))
    PN->addIncoming(I, Pred);
  return PN;
}

1878public:
LoopPromoter(Value *SP, ArrayRef<const Instruction *> Insts, SSAUpdater &S,
             const SmallSetVector<Value *, 8> &PMA,
             SmallVectorImpl<BasicBlock *> &LEB,
             SmallVectorImpl<Instruction *> &LIP,
             SmallVectorImpl<MemoryAccess *> &MSSAIP, PredIteratorCache &PIC,
             AliasSetTracker *ast, MemorySSAUpdater *MSSAU, LoopInfo &li,
             DebugLoc dl, int alignment, bool UnorderedAtomic,
             const AAMDNodes &AATags, ICFLoopSafetyInfo &SafetyInfo)
    : LoadAndStorePromoter(Insts, S), SomePtr(SP), PointerMustAliases(PMA),
      LoopExitBlocks(LEB), LoopInsertPts(LIP), MSSAInsertPts(MSSAIP),
      PredCache(PIC), AST(ast), MSSAU(MSSAU), LI(li), DL(std::move(dl)),
      Alignment(alignment), UnorderedAtomic(UnorderedAtomic), AATags(AATags),
      SafetyInfo(SafetyInfo) {}

bool isInstInList(Instruction *I,
                  const SmallVectorImpl<Instruction *> &) const override {
  Value *Ptr;
  if (LoadInst *LI = dyn_cast<LoadInst>(I))
    Ptr = LI->getOperand(0);
  else
    Ptr = cast<StoreInst>(I)->getPointerOperand();
  return PointerMustAliases.count(Ptr);
}

void doExtraRewritesBeforeFinalDeletion() override {
  // Insert stores after in the loop exit blocks.  Each exit block gets a
  // store of the live-out values that feed them.  Since we've already told
  // the SSA updater about the defs in the loop and the preheader
  // definition, it is all set and we can start using it.
  for (unsigned i = 0, e = LoopExitBlocks.size(); i != e; ++i) {
    BasicBlock *ExitBlock = LoopExitBlocks[i];
    Value *LiveInValue = SSA.GetValueInMiddleOfBlock(ExitBlock);
    LiveInValue = maybeInsertLCSSAPHI(LiveInValue, ExitBlock);
    Value *Ptr = maybeInsertLCSSAPHI(SomePtr, ExitBlock);
    Instruction *InsertPos = LoopInsertPts[i];
    StoreInst *NewSI = new StoreInst(LiveInValue, Ptr, InsertPos);
    if (UnorderedAtomic)
      NewSI->setOrdering(AtomicOrdering::Unordered);
    NewSI->setAlignment(Align(Alignment));
    NewSI->setDebugLoc(DL);
    if (AATags)
      NewSI->setAAMetadata(AATags);

    if (MSSAU) {
      MemoryAccess *MSSAInsertPoint = MSSAInsertPts[i];
      MemoryAccess *NewMemAcc;
      if (!MSSAInsertPoint) {
        NewMemAcc = MSSAU->createMemoryAccessInBB(
            NewSI, nullptr, NewSI->getParent(), MemorySSA::Beginning);
      } else {
        NewMemAcc =
            MSSAU->createMemoryAccessAfter(NewSI, nullptr, MSSAInsertPoint);
      }
      MSSAInsertPts[i] = NewMemAcc;
      MSSAU->insertDef(cast<MemoryDef>(NewMemAcc), true);
      // FIXME: true for safety, false may still be correct.
    }
  }
}

void replaceLoadWithValue(LoadInst *LI, Value *V) const override {
  // Update alias analysis.
  if (AST)
    AST->copyValue(LI, V);
}
void instructionDeleted(Instruction *I) const override {
  SafetyInfo.removeInstruction(I);
  if (AST)
    AST->deleteValue(I);
  if (MSSAU)
    MSSAU->removeMemoryAccess(I);
}
1951};


1954/// Return true iff we can prove that a caller of this function can not inspect
1955/// the contents of the provided object in a well defined program.
1956bool isKnownNonEscaping(Value *Object, const TargetLibraryInfo *TLI) {
if (isa<AllocaInst>(Object))
  // Since the alloca goes out of scope, we know the caller can't retain a
  // reference to it and be well defined.  Thus, we don't need to check for
  // capture.
  return true;

// For all other objects we need to know that the caller can't possibly
// have gotten a reference to the object.  There are two components of
// that:
//   1) Object can't be escaped by this function.  This is what
//      PointerMayBeCaptured checks.
//   2) Object can't have been captured at definition site.  For this, we
//      need to know the return value is noalias.  At the moment, we use a
//      weaker condition and handle only AllocLikeFunctions (which are
//      known to be noalias).  TODO
return isAllocLikeFn(Object, TLI) &&
  !PointerMayBeCaptured(Object, true, true);
1974}

1976} // namespace

1978/// Try to promote memory values to scalars by sinking stores out of the
1979/// loop and moving loads to before the loop.  We do this by looping over
1980/// the stores in the loop, looking for stores to Must pointers which are
1981/// loop invariant.
1982///
1983bool llvm::promoteLoopAccessesToScalars(
  const SmallSetVector<Value *, 8> &PointerMustAliases,
  SmallVectorImpl<BasicBlock *> &ExitBlocks,
  SmallVectorImpl<Instruction *> &InsertPts,
  SmallVectorImpl<MemoryAccess *> &MSSAInsertPts, PredIteratorCache &PIC,
  LoopInfo *LI, DominatorTree *DT, const TargetLibraryInfo *TLI,
  Loop *CurLoop, AliasSetTracker *CurAST, MemorySSAUpdater *MSSAU,
  ICFLoopSafetyInfo *SafetyInfo, OptimizationRemarkEmitter *ORE) {
// Verify inputs.
assert(LI != nullptr && DT != nullptr && CurLoop != nullptr &&((LI != nullptr && DT != nullptr && CurLoop !=
 nullptr && SafetyInfo != nullptr && "Unexpected Input to promoteLoopAccessesToScalars"
) ? static_cast<void> (0) : __assert_fail ("LI != nullptr && DT != nullptr && CurLoop != nullptr && SafetyInfo != nullptr && \"Unexpected Input to promoteLoopAccessesToScalars\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Transforms/Scalar/LICM.cpp"
, 1994, __PRETTY_FUNCTION__))
       SafetyInfo != nullptr &&((LI != nullptr && DT != nullptr && CurLoop !=
 nullptr && SafetyInfo != nullptr && "Unexpected Input to promoteLoopAccessesToScalars"
) ? static_cast<void> (0) : __assert_fail ("LI != nullptr && DT != nullptr && CurLoop != nullptr && SafetyInfo != nullptr && \"Unexpected Input to promoteLoopAccessesToScalars\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Transforms/Scalar/LICM.cpp"
, 1994, __PRETTY_FUNCTION__))
       "Unexpected Input to promoteLoopAccessesToScalars")((LI != nullptr && DT != nullptr && CurLoop !=
 nullptr && SafetyInfo != nullptr && "Unexpected Input to promoteLoopAccessesToScalars"
) ? static_cast<void> (0) : __assert_fail ("LI != nullptr && DT != nullptr && CurLoop != nullptr && SafetyInfo != nullptr && \"Unexpected Input to promoteLoopAccessesToScalars\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Transforms/Scalar/LICM.cpp"
, 1994, __PRETTY_FUNCTION__));

Value *SomePtr = *PointerMustAliases.begin();
BasicBlock *Preheader = CurLoop->getLoopPreheader();

// It is not safe to promote a load/store from the loop if the load/store is
// conditional.  For example, turning:
//
//    for () { if (c) *P += 1; }
//
// into:
//
//    tmp = *P;  for () { if (c) tmp +=1; } *P = tmp;
//
// is not safe, because *P may only be valid to access if 'c' is true.
//
// The safety property divides into two parts:
// p1) The memory may not be dereferenceable on entry to the loop.  In this
//    case, we can't insert the required load in the preheader.
// p2) The memory model does not allow us to insert a store along any dynamic
//    path which did not originally have one.
//
// If at least one store is guaranteed to execute, both properties are
// satisfied, and promotion is legal.
//
// This, however, is not a necessary condition. Even if no store/load is
// guaranteed to execute, we can still establish these properties.
// We can establish (p1) by proving that hoisting the load into the preheader
// is safe (i.e. proving dereferenceability on all paths through the loop). We
// can use any access within the alias set to prove dereferenceability,
// since they're all must alias.
//
// There are two ways establish (p2):
// a) Prove the location is thread-local. In this case the memory model
// requirement does not apply, and stores are safe to insert.
// b) Prove a store dominates every exit block. In this case, if an exit
// blocks is reached, the original dynamic path would have taken us through
// the store, so inserting a store into the exit block is safe. Note that this
// is different from the store being guaranteed to execute. For instance,
// if an exception is thrown on the first iteration of the loop, the original
// store is never executed, but the exit blocks are not executed either.

bool DereferenceableInPH = false;
bool SafeToInsertStore = false;

SmallVector<Instruction *, 64> LoopUses;

// We start with an alignment of one and try to find instructions that allow
// us to prove better alignment.
Align Alignment;
// Keep track of which types of access we see
bool SawUnorderedAtomic = false;
bool SawNotAtomic = false;
AAMDNodes AATags;

const DataLayout &MDL = Preheader->getModule()->getDataLayout();

bool IsKnownThreadLocalObject = false;
if (SafetyInfo->anyBlockMayThrow()) {
  // If a loop can throw, we have to insert a store along each unwind edge.
  // That said, we can't actually make the unwind edge explicit. Therefore,
  // we have to prove that the store is dead along the unwind edge.  We do
  // this by proving that the caller can't have a reference to the object
  // after return and thus can't possibly load from the object.
  Value *Object = getUnderlyingObject(SomePtr);
  if (!isKnownNonEscaping(Object, TLI))
    return false;
  // Subtlety: Alloca's aren't visible to callers, but *are* potentially
  // visible to other threads if captured and used during their lifetimes.
  IsKnownThreadLocalObject = !isa<AllocaInst>(Object);
}

// Check that all of the pointers in the alias set have the same type.  We
// cannot (yet) promote a memory location that is loaded and stored in
// different sizes.  While we are at it, collect alignment and AA info.
for (Value *ASIV : PointerMustAliases) {
  // Check that all of the pointers in the alias set have the same type.  We
  // cannot (yet) promote a memory location that is loaded and stored in
  // different sizes.
  if (SomePtr->getType() != ASIV->getType())
    return false;

  for (User *U : ASIV->users()) {
    // Ignore instructions that are outside the loop.
    Instruction *UI = dyn_cast<Instruction>(U);
    if (!UI || !CurLoop->contains(UI))
      continue;

    // If there is an non-load/store instruction in the loop, we can't promote
    // it.
    if (LoadInst *Load = dyn_cast<LoadInst>(UI)) {
      if (!Load->isUnordered())
        return false;

      SawUnorderedAtomic |= Load->isAtomic();
      SawNotAtomic |= !Load->isAtomic();

      Align InstAlignment = Load->getAlign();

      // Note that proving a load safe to speculate requires proving
      // sufficient alignment at the target location.  Proving it guaranteed
      // to execute does as well.  Thus we can increase our guaranteed
      // alignment as well. 
      if (!DereferenceableInPH || (InstAlignment > Alignment))
        if (isSafeToExecuteUnconditionally(*Load, DT, TLI, CurLoop,
                                           SafetyInfo, ORE,
                                           Preheader->getTerminator())) {
          DereferenceableInPH = true;
          Alignment = std::max(Alignment, InstAlignment);
        }
    } else if (const StoreInst *Store = dyn_cast<StoreInst>(UI)) {
      // Stores *of* the pointer are not interesting, only stores *to* the
      // pointer.
      if (UI->getOperand(1) != ASIV)
        continue;
      if (!Store->isUnordered())
        return false;

      SawUnorderedAtomic |= Store->isAtomic();
      SawNotAtomic |= !Store->isAtomic();

      // If the store is guaranteed to execute, both properties are satisfied.
      // We may want to check if a store is guaranteed to execute even if we
      // already know that promotion is safe, since it may have higher
      // alignment than any other guaranteed stores, in which case we can
      // raise the alignment on the promoted store.
      Align InstAlignment = Store->getAlign();

      if (!DereferenceableInPH || !SafeToInsertStore ||
          (InstAlignment > Alignment)) {
        if (SafetyInfo->isGuaranteedToExecute(*UI, DT, CurLoop)) {
          DereferenceableInPH = true;
          SafeToInsertStore = true;
          Alignment = std::max(Alignment, InstAlignment);
        }
      }

      // If a store dominates all exit blocks, it is safe to sink.
      // As explained above, if an exit block was executed, a dominating
      // store must have been executed at least once, so we are not
      // introducing stores on paths that did not have them.
      // Note that this only looks at explicit exit blocks. If we ever
      // start sinking stores into unwind edges (see above), this will break.
      if (!SafeToInsertStore)
        SafeToInsertStore = llvm::all_of(ExitBlocks, [&](BasicBlock *Exit) {
          return DT->dominates(Store->getParent(), Exit);
        });

      // If the store is not guaranteed to execute, we may still get
      // deref info through it.
      if (!DereferenceableInPH) {
        DereferenceableInPH = isDereferenceableAndAlignedPointer(
            Store->getPointerOperand(), Store->getValueOperand()->getType(),
            Store->getAlign(), MDL, Preheader->getTerminator(), DT, TLI);
      }
    } else
      return false; // Not a load or store.

    // Merge the AA tags.
    if (LoopUses.empty()) {
      // On the first load/store, just take its AA tags.
      UI->getAAMetadata(AATags);
    } else if (AATags) {
      UI->getAAMetadata(AATags, /* Merge = */ true);
    }

    LoopUses.push_back(UI);
  }
}

// If we found both an unordered atomic instruction and a non-atomic memory
// access, bail.  We can't blindly promote non-atomic to atomic since we
// might not be able to lower the result.  We can't downgrade since that
// would violate memory model.  Also, align 0 is an error for atomics.
if (SawUnorderedAtomic && SawNotAtomic)
  return false;

// If we're inserting an atomic load in the preheader, we must be able to
// lower it.  We're only guaranteed to be able to lower naturally aligned
// atomics.
auto *SomePtrElemType = SomePtr->getType()->getPointerElementType();
if (SawUnorderedAtomic &&
    Alignment < MDL.getTypeStoreSize(SomePtrElemType))
  return false;

// If we couldn't prove we can hoist the load, bail.
if (!DereferenceableInPH)
  return false;

// We know we can hoist the load, but don't have a guaranteed store.
// Check whether the location is thread-local. If it is, then we can insert
// stores along paths which originally didn't have them without violating the
// memory model.
if (!SafeToInsertStore) {
  if (IsKnownThreadLocalObject)
    SafeToInsertStore = true;
  else {
    Value *Object = getUnderlyingObject(SomePtr);
    SafeToInsertStore =
        (isAllocLikeFn(Object, TLI) || isa<AllocaInst>(Object)) &&
        !PointerMayBeCaptured(Object, true, true);
  }
}

// If we've still failed to prove we can sink the store, give up.
if (!SafeToInsertStore)
  return false;

// Otherwise, this is safe to promote, lets do it!
LLVM_DEBUG(dbgs() << "LICM: Promoting value stored to in loop: " << *SomePtrdo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("licm")) { dbgs() << "LICM: Promoting value stored to in loop: "
 << *SomePtr << '\n'; } } while (false)
                  << '\n')do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("licm")) { dbgs() << "LICM: Promoting value stored to in loop: "
 << *SomePtr << '\n'; } } while (false);
ORE->emit([&]() {
  return OptimizationRemark(DEBUG_TYPE"licm", "PromoteLoopAccessesToScalar",
                            LoopUses[0])
         << "Moving accesses to memory location out of the loop";
});
++NumPromoted;

// Look at all the loop uses, and try to merge their locations.
std::vector<const DILocation *> LoopUsesLocs;
for (auto U : LoopUses)
  LoopUsesLocs.push_back(U->getDebugLoc().get());
auto DL = DebugLoc(DILocation::getMergedLocations(LoopUsesLocs));

// We use the SSAUpdater interface to insert phi nodes as required.
SmallVector<PHINode *, 16> NewPHIs;
SSAUpdater SSA(&NewPHIs);
LoopPromoter Promoter(SomePtr, LoopUses, SSA, PointerMustAliases, ExitBlocks,
                      InsertPts, MSSAInsertPts, PIC, CurAST, MSSAU, *LI, DL,
                      Alignment.value(), SawUnorderedAtomic, AATags,
                      *SafetyInfo);

// Set up the preheader to have a definition of the value.  It is the live-out
// value from the preheader that uses in the loop will use.
LoadInst *PreheaderLoad = new LoadInst(
    SomePtr->getType()->getPointerElementType(), SomePtr,
    SomePtr->getName() + ".promoted", Preheader->getTerminator());
if (SawUnorderedAtomic)
  PreheaderLoad->setOrdering(AtomicOrdering::Unordered);
PreheaderLoad->setAlignment(Alignment);
PreheaderLoad->setDebugLoc(DebugLoc());
if (AATags)
  PreheaderLoad->setAAMetadata(AATags);
SSA.AddAvailableValue(Preheader, PreheaderLoad);

if (MSSAU) {
  MemoryAccess *PreheaderLoadMemoryAccess = MSSAU->createMemoryAccessInBB(
      PreheaderLoad, nullptr, PreheaderLoad->getParent(), MemorySSA::End);
  MemoryUse *NewMemUse = cast<MemoryUse>(PreheaderLoadMemoryAccess);
  MSSAU->insertUse(NewMemUse, /*RenameUses=*/true);
}

if (MSSAU && VerifyMemorySSA)
  MSSAU->getMemorySSA()->verifyMemorySSA();
// Rewrite all the loads in the loop and remember all the definitions from
// stores in the loop.
Promoter.run(LoopUses);

if (MSSAU && VerifyMemorySSA)
  MSSAU->getMemorySSA()->verifyMemorySSA();
// If the SSAUpdater didn't use the load in the preheader, just zap it now.
if (PreheaderLoad->use_empty())
  eraseInstruction(*PreheaderLoad, *SafetyInfo, CurAST, MSSAU);

return true;
2259}

2261static void foreachMemoryAccess(MemorySSA *MSSA, Loop *L,
                              function_ref<void(Instruction *)> Fn) {
for (const BasicBlock *BB : L->blocks())
  if (const auto *Accesses = MSSA->getBlockAccesses(BB))
    for (const auto &Access : *Accesses)
      if (const auto *MUD = dyn_cast<MemoryUseOrDef>(&Access))
        Fn(MUD->getMemoryInst());
2268}

2270static SmallVector<SmallSetVector<Value *, 8>, 0>
2271collectPromotionCandidates(MemorySSA *MSSA, AliasAnalysis *AA, Loop *L,
                         SmallVectorImpl<Instruction *> &MaybePromotable) {
AliasSetTracker AST(*AA);

auto IsPotentiallyPromotable = [L](const Instruction *I) {
  if (const auto *SI = dyn_cast<StoreInst>(I))
    return L->isLoopInvariant(SI->getPointerOperand());
  if (const auto *LI = dyn_cast<LoadInst>(I))
    return L->isLoopInvariant(LI->getPointerOperand());
  return false;
};

// Populate AST with potentially promotable accesses and remove them from
// MaybePromotable, so they will not be checked again on the next iteration.
SmallPtrSet<Value *, 16> AttemptingPromotion;
llvm::erase_if(MaybePromotable, [&](Instruction *I) {
  if (IsPotentiallyPromotable(I)) {
    AttemptingPromotion.insert(I);
    AST.add(I);
    return true;
  }
  return false;
});

// We're only interested in must-alias sets that contain a mod.
SmallVector<const AliasSet *, 8> Sets;
for (AliasSet &AS : AST)
  if (!AS.isForwardingAliasSet() && AS.isMod() && AS.isMustAlias())
    Sets.push_back(&AS);

if (Sets.empty())
  return {}; // Nothing to promote...

// Discard any sets for which there is an aliasing non-promotable access.
foreachMemoryAccess(MSSA, L, [&](Instruction *I) {
  if (AttemptingPromotion.contains(I))
    return;

  llvm::erase_if(Sets, [&](const AliasSet *AS) {
    return AS->aliasesUnknownInst(I, *AA);
  });
});

SmallVector<SmallSetVector<Value *, 8>, 0> Result;
for (const AliasSet *Set : Sets) {
  SmallSetVector<Value *, 8> PointerMustAliases;
  for (const auto &ASI : *Set)
    PointerMustAliases.insert(ASI.getValue());
  Result.push_back(std::move(PointerMustAliases));
}

return Result;
2323}

2325/// Returns an owning pointer to an alias set which incorporates aliasing info
2326/// from L and all subloops of L.
2327std::unique_ptr<AliasSetTracker>
2328LoopInvariantCodeMotion::collectAliasInfoForLoop(Loop *L, LoopInfo *LI,
                                               AAResults *AA) {
auto CurAST = std::make_unique<AliasSetTracker>(*AA);

// Add everything from all the sub loops.
for (Loop *InnerL : L->getSubLoops())
  for (BasicBlock *BB : InnerL->blocks())
    CurAST->add(*BB);

// And merge in this loop (without anything from inner loops).
for (BasicBlock *BB : L->blocks())
  if (LI->getLoopFor(BB) == L)
    CurAST->add(*BB);

return CurAST;
2343}

2345static bool pointerInvalidatedByLoop(MemoryLocation MemLoc,
                                   AliasSetTracker *CurAST, Loop *CurLoop,
                                   AAResults *AA) {
// First check to see if any of the basic blocks in CurLoop invalidate *V.
bool isInvalidatedAccordingToAST = CurAST->getAliasSetFor(MemLoc).isMod();

if (!isInvalidatedAccordingToAST || !LICMN2Theshold)
  return isInvalidatedAccordingToAST;

// Check with a diagnostic analysis if we can refine the information above.
// This is to identify the limitations of using the AST.
// The alias set mechanism used by LICM has a major weakness in that it
// combines all things which may alias into a single set *before* asking
// modref questions. As a result, a single readonly call within a loop will
// collapse all loads and stores into a single alias set and report
// invalidation if the loop contains any store. For example, readonly calls
// with deopt states have this form and create a general alias set with all
// loads and stores.  In order to get any LICM in loops containing possible
// deopt states we need a more precise invalidation of checking the mod ref
// info of each instruction within the loop and LI. This has a complexity of
// O(N^2), so currently, it is used only as a diagnostic tool since the
// default value of LICMN2Threshold is zero.

// Don't look at nested loops.
if (CurLoop->begin() != CurLoop->end())
  return true;

int N = 0;
for (BasicBlock *BB : CurLoop->getBlocks())
  for (Instruction &I : *BB) {
    if (N >= LICMN2Theshold) {
      LLVM_DEBUG(dbgs() << "Alasing N2 threshold exhausted for "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("licm")) { dbgs() << "Alasing N2 threshold exhausted for "
 << *(MemLoc.Ptr) << "\n"; } } while (false)
                        << *(MemLoc.Ptr) << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("licm")) { dbgs() << "Alasing N2 threshold exhausted for "
 << *(MemLoc.Ptr) << "\n"; } } while (false);
      return true;
    }
    N++;
    auto Res = AA->getModRefInfo(&I, MemLoc);
    if (isModSet(Res)) {
      LLVM_DEBUG(dbgs() << "Aliasing failed on " << I << " for "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("licm")) { dbgs() << "Aliasing failed on " << I <<
 " for " << *(MemLoc.Ptr) << "\n"; } } while (false
)
                        << *(MemLoc.Ptr) << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("licm")) { dbgs() << "Aliasing failed on " << I <<
 " for " << *(MemLoc.Ptr) << "\n"; } } while (false
);
      return true;
    }
  }
LLVM_DEBUG(dbgs() << "Aliasing okay for " << *(MemLoc.Ptr) << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("licm")) { dbgs() << "Aliasing okay for " << *(MemLoc
.Ptr) << "\n"; } } while (false);
return false;
2390}

2392bool pointerInvalidatedByLoopWithMSSA(MemorySSA *MSSA, MemoryUse *MU,
                                    Loop *CurLoop, Instruction &I,
                                    SinkAndHoistLICMFlags &Flags) {
// For hoisting, use the walker to determine safety
if (!Flags.getIsSink()) {
  MemoryAccess *Source;
  // See declaration of SetLicmMssaOptCap for usage details.
  if (Flags.tooManyClobberingCalls())
    Source = MU->getDefiningAccess();
  else {
    Source = MSSA->getSkipSelfWalker()->getClobberingMemoryAccess(MU);
    Flags.incrementClobberingCalls();
  }
  return !MSSA->isLiveOnEntryDef(Source) &&
         CurLoop->contains(Source->getBlock());
}

// For sinking, we'd need to check all Defs below this use. The getClobbering
// call will look on the backedge of the loop, but will check aliasing with
// the instructions on the previous iteration.
// For example:
// for (i ... )
//   load a[i] ( Use (LoE)
//   store a[i] ( 1 = Def (2), with 2 = Phi for the loop.
//   i++;
// The load sees no clobbering inside the loop, as the backedge alias check
// does phi translation, and will check aliasing against store a[i-1].
// However sinking the load outside the loop, below the store is incorrect.

// For now, only sink if there are no Defs in the loop, and the existing ones
// precede the use and are in the same block.
// FIXME: Increase precision: Safe to sink if Use post dominates the Def;
// needs PostDominatorTreeAnalysis.
// FIXME: More precise: no Defs that alias this Use.
if (Flags.tooManyMemoryAccesses())
  return true;
for (auto *BB : CurLoop->getBlocks())
  if (pointerInvalidatedByBlockWithMSSA(*BB, *MSSA, *MU))
    return true;
// When sinking, the source block may not be part of the loop so check it.
if (!CurLoop->contains(&I))
  return pointerInvalidatedByBlockWithMSSA(*I.getParent(), *MSSA, *MU);

return false;
2436}

2438bool pointerInvalidatedByBlockWithMSSA(BasicBlock &BB, MemorySSA &MSSA,
                                     MemoryUse &MU) {
if (const auto *Accesses = MSSA.getBlockDefs(&BB))
  for (const auto &MA : *Accesses)
    if (const auto *MD = dyn_cast<MemoryDef>(&MA))
      if (MU.getBlock() != MD->getBlock() || !MSSA.locallyDominates(MD, &MU))
        return true;
return false;
2446}

2448/// Little predicate that returns true if the specified basic block is in
2449/// a subloop of the current one, not the current one itself.
2450///
2451static bool inSubLoop(BasicBlock *BB, Loop *CurLoop, LoopInfo *LI) {
assert(CurLoop->contains(BB) && "Only valid if BB is IN the loop")((CurLoop->contains(BB) && "Only valid if BB is IN the loop"
) ? static_cast<void> (0) : __assert_fail ("CurLoop->contains(BB) && \"Only valid if BB is IN the loop\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/lib/Transforms/Scalar/LICM.cpp"
, 2452, __PRETTY_FUNCTION__));
return LI->getLoopFor(BB) != CurLoop;
2454}

←

/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/InstrTypes.h

→

1//===- llvm/InstrTypes.h - Important Instruction subclasses -----*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file defines various meta classes of instructions that exist in the VM
10// representation.  Specific concrete subclasses of these may be found in the
11// i*.h files...
12//
13//===----------------------------------------------------------------------===//

15#ifndef LLVM_IR_INSTRTYPES_H
16#define LLVM_IR_INSTRTYPES_H

18#include "llvm/ADT/ArrayRef.h"
19#include "llvm/ADT/None.h"
20#include "llvm/ADT/Optional.h"
21#include "llvm/ADT/STLExtras.h"
22#include "llvm/ADT/StringMap.h"
23#include "llvm/ADT/StringRef.h"
24#include "llvm/ADT/Twine.h"
25#include "llvm/ADT/iterator_range.h"
26#include "llvm/IR/Attributes.h"
27#include "llvm/IR/CallingConv.h"
28#include "llvm/IR/Constants.h"
29#include "llvm/IR/DerivedTypes.h"
30#include "llvm/IR/Function.h"
31#include "llvm/IR/Instruction.h"
32#include "llvm/IR/LLVMContext.h"
33#include "llvm/IR/OperandTraits.h"
34#include "llvm/IR/Type.h"
35#include "llvm/IR/User.h"
36#include "llvm/IR/Value.h"
37#include "llvm/Support/Casting.h"
38#include "llvm/Support/ErrorHandling.h"
39#include <algorithm>
40#include <cassert>
41#include <cstddef>
42#include <cstdint>
43#include <iterator>
44#include <string>
45#include <vector>

47namespace llvm {

49namespace Intrinsic {
50typedef unsigned ID;
51}

53//===----------------------------------------------------------------------===//
54//                          UnaryInstruction Class
55//===----------------------------------------------------------------------===//

57class UnaryInstruction : public Instruction {
58protected:
UnaryInstruction(Type *Ty, unsigned iType, Value *V,
                 Instruction *IB = nullptr)
  : Instruction(Ty, iType, &Op<0>(), 1, IB) {
  Op<0>() = V;
}
UnaryInstruction(Type *Ty, unsigned iType, Value *V, BasicBlock *IAE)
  : Instruction(Ty, iType, &Op<0>(), 1, IAE) {
  Op<0>() = V;
}

69public:
// allocate space for exactly one operand
void *operator new(size_t s) {
  return User::operator new(s, 1);
}

/// Transparently provide more efficient getOperand methods.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)public: inline Value *getOperand(unsigned) const; inline void
 setOperand(unsigned, Value*); inline op_iterator op_begin();
 inline const_op_iterator op_begin() const; inline op_iterator
 op_end(); inline const_op_iterator op_end() const; protected
: template <int> inline Use &Op(); template <int
> inline const Use &Op() const; public: inline unsigned
 getNumOperands() const;

// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->isUnaryOp() ||
         I->getOpcode() == Instruction::Alloca ||
         I->getOpcode() == Instruction::Load ||
         I->getOpcode() == Instruction::VAArg ||
         I->getOpcode() == Instruction::ExtractValue ||
         (I->getOpcode() >= CastOpsBegin && I->getOpcode() < CastOpsEnd);
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}
90};

92template <>
93struct OperandTraits<UnaryInstruction> :
public FixedNumOperandTraits<UnaryInstruction, 1> {
95};

97DEFINE_TRANSPARENT_OPERAND_ACCESSORS(UnaryInstruction, Value)UnaryInstruction::op_iterator UnaryInstruction::op_begin() { return
 OperandTraits<UnaryInstruction>::op_begin(this); } UnaryInstruction
::const_op_iterator UnaryInstruction::op_begin() const { return
 OperandTraits<UnaryInstruction>::op_begin(const_cast<
UnaryInstruction*>(this)); } UnaryInstruction::op_iterator
 UnaryInstruction::op_end() { return OperandTraits<UnaryInstruction
>::op_end(this); } UnaryInstruction::const_op_iterator UnaryInstruction
::op_end() const { return OperandTraits<UnaryInstruction>
::op_end(const_cast<UnaryInstruction*>(this)); } Value *
UnaryInstruction::getOperand(unsigned i_nocapture) const { ((
i_nocapture < OperandTraits<UnaryInstruction>::operands
(this) && "getOperand() out of range!") ? static_cast
<void> (0) : __assert_fail ("i_nocapture < OperandTraits<UnaryInstruction>::operands(this) && \"getOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/InstrTypes.h"
, 97, __PRETTY_FUNCTION__)); return cast_or_null<Value>
( OperandTraits<UnaryInstruction>::op_begin(const_cast<
UnaryInstruction*>(this))[i_nocapture].get()); } void UnaryInstruction
::setOperand(unsigned i_nocapture, Value *Val_nocapture) { ((
i_nocapture < OperandTraits<UnaryInstruction>::operands
(this) && "setOperand() out of range!") ? static_cast
<void> (0) : __assert_fail ("i_nocapture < OperandTraits<UnaryInstruction>::operands(this) && \"setOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/InstrTypes.h"
, 97, __PRETTY_FUNCTION__)); OperandTraits<UnaryInstruction
>::op_begin(this)[i_nocapture] = Val_nocapture; } unsigned
 UnaryInstruction::getNumOperands() const { return OperandTraits
<UnaryInstruction>::operands(this); } template <int Idx_nocapture
> Use &UnaryInstruction::Op() { return this->OpFrom
<Idx_nocapture>(this); } template <int Idx_nocapture
> const Use &UnaryInstruction::Op() const { return this
->OpFrom<Idx_nocapture>(this); }

99//===----------------------------------------------------------------------===//
100//                                UnaryOperator Class
101//===----------------------------------------------------------------------===//

103class UnaryOperator : public UnaryInstruction {
void AssertOK();

106protected:
UnaryOperator(UnaryOps iType, Value *S, Type *Ty,
              const Twine &Name, Instruction *InsertBefore);
UnaryOperator(UnaryOps iType, Value *S, Type *Ty,
              const Twine &Name, BasicBlock *InsertAtEnd);

// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

UnaryOperator *cloneImpl() const;

117public:

/// Construct a unary instruction, given the opcode and an operand.
/// Optionally (if InstBefore is specified) insert the instruction
/// into a BasicBlock right before the specified instruction.  The specified
/// Instruction is allowed to be a dereferenced end iterator.
///
static UnaryOperator *Create(UnaryOps Op, Value *S,
                             const Twine &Name = Twine(),
                             Instruction *InsertBefore = nullptr);

/// Construct a unary instruction, given the opcode and an operand.
/// Also automatically insert this instruction to the end of the
/// BasicBlock specified.
///
static UnaryOperator *Create(UnaryOps Op, Value *S,
                             const Twine &Name,
                             BasicBlock *InsertAtEnd);

/// These methods just forward to Create, and are useful when you
/// statically know what type of instruction you're going to create.  These
/// helpers just save some typing.
139#define HANDLE_UNARY_INST(N, OPC, CLASS) \
static UnaryOperator *Create##OPC(Value *V, const Twine &Name = "") {\
  return Create(Instruction::OPC, V, Name);\
}
143#include "llvm/IR/Instruction.def"
144#define HANDLE_UNARY_INST(N, OPC, CLASS) \
static UnaryOperator *Create##OPC(Value *V, const Twine &Name, \
                                  BasicBlock *BB) {\
  return Create(Instruction::OPC, V, Name, BB);\
}
149#include "llvm/IR/Instruction.def"
150#define HANDLE_UNARY_INST(N, OPC, CLASS) \
static UnaryOperator *Create##OPC(Value *V, const Twine &Name, \
                                  Instruction *I) {\
  return Create(Instruction::OPC, V, Name, I);\
}
155#include "llvm/IR/Instruction.def"

static UnaryOperator *
CreateWithCopiedFlags(UnaryOps Opc, Value *V, Instruction *CopyO,
                      const Twine &Name = "",
                      Instruction *InsertBefore = nullptr) {
  UnaryOperator *UO = Create(Opc, V, Name, InsertBefore);
  UO->copyIRFlags(CopyO);
  return UO;
}

static UnaryOperator *CreateFNegFMF(Value *Op, Instruction *FMFSource,
                                    const Twine &Name = "",
                                    Instruction *InsertBefore = nullptr) {
  return CreateWithCopiedFlags(Instruction::FNeg, Op, FMFSource, Name,
                               InsertBefore);
}

UnaryOps getOpcode() const {
  return static_cast<UnaryOps>(Instruction::getOpcode());
}

// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->isUnaryOp();
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}
184};

186//===----------------------------------------------------------------------===//
187//                           BinaryOperator Class
188//===----------------------------------------------------------------------===//

190class BinaryOperator : public Instruction {
void AssertOK();

193protected:
BinaryOperator(BinaryOps iType, Value *S1, Value *S2, Type *Ty,
               const Twine &Name, Instruction *InsertBefore);
BinaryOperator(BinaryOps iType, Value *S1, Value *S2, Type *Ty,
               const Twine &Name, BasicBlock *InsertAtEnd);

// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

BinaryOperator *cloneImpl() const;

204public:
// allocate space for exactly two operands
void *operator new(size_t s) {
  return User::operator new(s, 2);
}

/// Transparently provide more efficient getOperand methods.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)public: inline Value *getOperand(unsigned) const; inline void
 setOperand(unsigned, Value*); inline op_iterator op_begin();
 inline const_op_iterator op_begin() const; inline op_iterator
 op_end(); inline const_op_iterator op_end() const; protected
: template <int> inline Use &Op(); template <int
> inline const Use &Op() const; public: inline unsigned
 getNumOperands() const;

/// Construct a binary instruction, given the opcode and the two
/// operands.  Optionally (if InstBefore is specified) insert the instruction
/// into a BasicBlock right before the specified instruction.  The specified
/// Instruction is allowed to be a dereferenced end iterator.
///
static BinaryOperator *Create(BinaryOps Op, Value *S1, Value *S2,
                              const Twine &Name = Twine(),
                              Instruction *InsertBefore = nullptr);

/// Construct a binary instruction, given the opcode and the two
/// operands.  Also automatically insert this instruction to the end of the
/// BasicBlock specified.
///
static BinaryOperator *Create(BinaryOps Op, Value *S1, Value *S2,
                              const Twine &Name, BasicBlock *InsertAtEnd);

/// These methods just forward to Create, and are useful when you
/// statically know what type of instruction you're going to create.  These
/// helpers just save some typing.
232#define HANDLE_BINARY_INST(N, OPC, CLASS) \
static BinaryOperator *Create##OPC(Value *V1, Value *V2, \
                                   const Twine &Name = "") {\
  return Create(Instruction::OPC, V1, V2, Name);\
}
237#include "llvm/IR/Instruction.def"
238#define HANDLE_BINARY_INST(N, OPC, CLASS) \
static BinaryOperator *Create##OPC(Value *V1, Value *V2, \
                                   const Twine &Name, BasicBlock *BB) {\
  return Create(Instruction::OPC, V1, V2, Name, BB);\
}
243#include "llvm/IR/Instruction.def"
244#define HANDLE_BINARY_INST(N, OPC, CLASS) \
static BinaryOperator *Create##OPC(Value *V1, Value *V2, \
                                   const Twine &Name, Instruction *I) {\
  return Create(Instruction::OPC, V1, V2, Name, I);\
}
249#include "llvm/IR/Instruction.def"

static BinaryOperator *CreateWithCopiedFlags(BinaryOps Opc,
                                             Value *V1, Value *V2,
                                             Instruction *CopyO,
                                             const Twine &Name = "") {
  BinaryOperator *BO = Create(Opc, V1, V2, Name);
  BO->copyIRFlags(CopyO);
  return BO;
}

static BinaryOperator *CreateFAddFMF(Value *V1, Value *V2,
                                     Instruction *FMFSource,
                                     const Twine &Name = "") {
  return CreateWithCopiedFlags(Instruction::FAdd, V1, V2, FMFSource, Name);
}
static BinaryOperator *CreateFSubFMF(Value *V1, Value *V2,
                                     Instruction *FMFSource,
                                     const Twine &Name = "") {
  return CreateWithCopiedFlags(Instruction::FSub, V1, V2, FMFSource, Name);
}
static BinaryOperator *CreateFMulFMF(Value *V1, Value *V2,
                                     Instruction *FMFSource,
                                     const Twine &Name = "") {
  return CreateWithCopiedFlags(Instruction::FMul, V1, V2, FMFSource, Name);
}
static BinaryOperator *CreateFDivFMF(Value *V1, Value *V2,
                                     Instruction *FMFSource,
                                     const Twine &Name = "") {
  return CreateWithCopiedFlags(Instruction::FDiv, V1, V2, FMFSource, Name);
}
static BinaryOperator *CreateFRemFMF(Value *V1, Value *V2,
                                     Instruction *FMFSource,
                                     const Twine &Name = "") {
  return CreateWithCopiedFlags(Instruction::FRem, V1, V2, FMFSource, Name);
}

static BinaryOperator *CreateNSW(BinaryOps Opc, Value *V1, Value *V2,
                                 const Twine &Name = "") {
  BinaryOperator *BO = Create(Opc, V1, V2, Name);
  BO->setHasNoSignedWrap(true);
  return BO;
}
static BinaryOperator *CreateNSW(BinaryOps Opc, Value *V1, Value *V2,
                                 const Twine &Name, BasicBlock *BB) {
  BinaryOperator *BO = Create(Opc, V1, V2, Name, BB);
  BO->setHasNoSignedWrap(true);
  return BO;
}
static BinaryOperator *CreateNSW(BinaryOps Opc, Value *V1, Value *V2,
                                 const Twine &Name, Instruction *I) {
  BinaryOperator *BO = Create(Opc, V1, V2, Name, I);
  BO->setHasNoSignedWrap(true);
  return BO;
}

static BinaryOperator *CreateNUW(BinaryOps Opc, Value *V1, Value *V2,
                                 const Twine &Name = "") {
  BinaryOperator *BO = Create(Opc, V1, V2, Name);
  BO->setHasNoUnsignedWrap(true);
  return BO;
}
static BinaryOperator *CreateNUW(BinaryOps Opc, Value *V1, Value *V2,
                                 const Twine &Name, BasicBlock *BB) {
  BinaryOperator *BO = Create(Opc, V1, V2, Name, BB);
  BO->setHasNoUnsignedWrap(true);
  return BO;
}
static BinaryOperator *CreateNUW(BinaryOps Opc, Value *V1, Value *V2,
                                 const Twine &Name, Instruction *I) {
  BinaryOperator *BO = Create(Opc, V1, V2, Name, I);
  BO->setHasNoUnsignedWrap(true);
  return BO;
}

static BinaryOperator *CreateExact(BinaryOps Opc, Value *V1, Value *V2,
                                   const Twine &Name = "") {
  BinaryOperator *BO = Create(Opc, V1, V2, Name);
  BO->setIsExact(true);
  return BO;
}
static BinaryOperator *CreateExact(BinaryOps Opc, Value *V1, Value *V2,
                                   const Twine &Name, BasicBlock *BB) {
  BinaryOperator *BO = Create(Opc, V1, V2, Name, BB);
  BO->setIsExact(true);
  return BO;
}
static BinaryOperator *CreateExact(BinaryOps Opc, Value *V1, Value *V2,
                                   const Twine &Name, Instruction *I) {
  BinaryOperator *BO = Create(Opc, V1, V2, Name, I);
  BO->setIsExact(true);
  return BO;
}

343#define DEFINE_HELPERS(OPC, NUWNSWEXACT)                                       \
static BinaryOperator *Create##NUWNSWEXACT##OPC(Value *V1, Value *V2,        \
                                                const Twine &Name = "") {    \
  return Create##NUWNSWEXACT(Instruction::OPC, V1, V2, Name);                \
}                                                                            \
static BinaryOperator *Create##NUWNSWEXACT##OPC(                             \
    Value *V1, Value *V2, const Twine &Name, BasicBlock *BB) {               \
  return Create##NUWNSWEXACT(Instruction::OPC, V1, V2, Name, BB);            \
}                                                                            \
static BinaryOperator *Create##NUWNSWEXACT##OPC(                             \
    Value *V1, Value *V2, const Twine &Name, Instruction *I) {               \
  return Create##NUWNSWEXACT(Instruction::OPC, V1, V2, Name, I);             \
}

DEFINE_HELPERS(Add, NSW) // CreateNSWAdd
DEFINE_HELPERS(Add, NUW) // CreateNUWAdd
DEFINE_HELPERS(Sub, NSW) // CreateNSWSub
DEFINE_HELPERS(Sub, NUW) // CreateNUWSub
DEFINE_HELPERS(Mul, NSW) // CreateNSWMul
DEFINE_HELPERS(Mul, NUW) // CreateNUWMul
DEFINE_HELPERS(Shl, NSW) // CreateNSWShl
DEFINE_HELPERS(Shl, NUW) // CreateNUWShl

DEFINE_HELPERS(SDiv, Exact)  // CreateExactSDiv
DEFINE_HELPERS(UDiv, Exact)  // CreateExactUDiv
DEFINE_HELPERS(AShr, Exact)  // CreateExactAShr
DEFINE_HELPERS(LShr, Exact)  // CreateExactLShr

371#undef DEFINE_HELPERS

/// Helper functions to construct and inspect unary operations (NEG and NOT)
/// via binary operators SUB and XOR:
///
/// Create the NEG and NOT instructions out of SUB and XOR instructions.
///
static BinaryOperator *CreateNeg(Value *Op, const Twine &Name = "",
                                 Instruction *InsertBefore = nullptr);
static BinaryOperator *CreateNeg(Value *Op, const Twine &Name,
                                 BasicBlock *InsertAtEnd);
static BinaryOperator *CreateNSWNeg(Value *Op, const Twine &Name = "",
                                    Instruction *InsertBefore = nullptr);
static BinaryOperator *CreateNSWNeg(Value *Op, const Twine &Name,
                                    BasicBlock *InsertAtEnd);
static BinaryOperator *CreateNUWNeg(Value *Op, const Twine &Name = "",
                                    Instruction *InsertBefore = nullptr);
static BinaryOperator *CreateNUWNeg(Value *Op, const Twine &Name,
                                    BasicBlock *InsertAtEnd);
static BinaryOperator *CreateNot(Value *Op, const Twine &Name = "",
                                 Instruction *InsertBefore = nullptr);
static BinaryOperator *CreateNot(Value *Op, const Twine &Name,
                                 BasicBlock *InsertAtEnd);

BinaryOps getOpcode() const {
  return static_cast<BinaryOps>(Instruction::getOpcode());
}

/// Exchange the two operands to this instruction.
/// This instruction is safe to use on any binary instruction and
/// does not modify the semantics of the instruction.  If the instruction
/// cannot be reversed (ie, it's a Div), then return true.
///
bool swapOperands();

// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->isBinaryOp();
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}
413};

415template <>
416struct OperandTraits<BinaryOperator> :
public FixedNumOperandTraits<BinaryOperator, 2> {
418};

420DEFINE_TRANSPARENT_OPERAND_ACCESSORS(BinaryOperator, Value)BinaryOperator::op_iterator BinaryOperator::op_begin() { return
 OperandTraits<BinaryOperator>::op_begin(this); } BinaryOperator
::const_op_iterator BinaryOperator::op_begin() const { return
 OperandTraits<BinaryOperator>::op_begin(const_cast<
BinaryOperator*>(this)); } BinaryOperator::op_iterator BinaryOperator
::op_end() { return OperandTraits<BinaryOperator>::op_end
(this); } BinaryOperator::const_op_iterator BinaryOperator::op_end
() const { return OperandTraits<BinaryOperator>::op_end
(const_cast<BinaryOperator*>(this)); } Value *BinaryOperator
::getOperand(unsigned i_nocapture) const { ((i_nocapture <
 OperandTraits<BinaryOperator>::operands(this) &&
 "getOperand() out of range!") ? static_cast<void> (0) :
 __assert_fail ("i_nocapture < OperandTraits<BinaryOperator>::operands(this) && \"getOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/InstrTypes.h"
, 420, __PRETTY_FUNCTION__)); return cast_or_null<Value>
( OperandTraits<BinaryOperator>::op_begin(const_cast<
BinaryOperator*>(this))[i_nocapture].get()); } void BinaryOperator
::setOperand(unsigned i_nocapture, Value *Val_nocapture) { ((
i_nocapture < OperandTraits<BinaryOperator>::operands
(this) && "setOperand() out of range!") ? static_cast
<void> (0) : __assert_fail ("i_nocapture < OperandTraits<BinaryOperator>::operands(this) && \"setOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/InstrTypes.h"
, 420, __PRETTY_FUNCTION__)); OperandTraits<BinaryOperator
>::op_begin(this)[i_nocapture] = Val_nocapture; } unsigned
 BinaryOperator::getNumOperands() const { return OperandTraits
<BinaryOperator>::operands(this); } template <int Idx_nocapture
> Use &BinaryOperator::Op() { return this->OpFrom<
Idx_nocapture>(this); } template <int Idx_nocapture>
 const Use &BinaryOperator::Op() const { return this->
OpFrom<Idx_nocapture>(this); }

422//===----------------------------------------------------------------------===//
423//                               CastInst Class
424//===----------------------------------------------------------------------===//

426/// This is the base class for all instructions that perform data
427/// casts. It is simply provided so that instruction category testing
428/// can be performed with code like:
429///
430/// if (isa<CastInst>(Instr)) { ... }
431/// Base class of casting instructions.
432class CastInst : public UnaryInstruction {
433protected:
/// Constructor with insert-before-instruction semantics for subclasses
CastInst(Type *Ty, unsigned iType, Value *S,
         const Twine &NameStr = "", Instruction *InsertBefore = nullptr)
  : UnaryInstruction(Ty, iType, S, InsertBefore) {
  setName(NameStr);
}
/// Constructor with insert-at-end-of-block semantics for subclasses
CastInst(Type *Ty, unsigned iType, Value *S,
         const Twine &NameStr, BasicBlock *InsertAtEnd)
  : UnaryInstruction(Ty, iType, S, InsertAtEnd) {
  setName(NameStr);
}

447public:
/// Provides a way to construct any of the CastInst subclasses using an
/// opcode instead of the subclass's constructor. The opcode must be in the
/// CastOps category (Instruction::isCast(opcode) returns true). This
/// constructor has insert-before-instruction semantics to automatically
/// insert the new CastInst before InsertBefore (if it is non-null).
/// Construct any of the CastInst subclasses
static CastInst *Create(
  Instruction::CastOps,    ///< The opcode of the cast instruction
  Value *S,                ///< The value to be casted (operand 0)
  Type *Ty,          ///< The type to which cast should be made
  const Twine &Name = "", ///< Name for the instruction
  Instruction *InsertBefore = nullptr ///< Place to insert the instruction
);
/// Provides a way to construct any of the CastInst subclasses using an
/// opcode instead of the subclass's constructor. The opcode must be in the
/// CastOps category. This constructor has insert-at-end-of-block semantics
/// to automatically insert the new CastInst at the end of InsertAtEnd (if
/// its non-null).
/// Construct any of the CastInst subclasses
static CastInst *Create(
  Instruction::CastOps,    ///< The opcode for the cast instruction
  Value *S,                ///< The value to be casted (operand 0)
  Type *Ty,          ///< The type to which operand is casted
  const Twine &Name, ///< The name for the instruction
  BasicBlock *InsertAtEnd  ///< The block to insert the instruction into
);

/// Create a ZExt or BitCast cast instruction
static CastInst *CreateZExtOrBitCast(
  Value *S,                ///< The value to be casted (operand 0)
  Type *Ty,          ///< The type to which cast should be made
  const Twine &Name = "", ///< Name for the instruction
  Instruction *InsertBefore = nullptr ///< Place to insert the instruction
);

/// Create a ZExt or BitCast cast instruction
static CastInst *CreateZExtOrBitCast(
  Value *S,                ///< The value to be casted (operand 0)
  Type *Ty,          ///< The type to which operand is casted
  const Twine &Name, ///< The name for the instruction
  BasicBlock *InsertAtEnd  ///< The block to insert the instruction into
);

/// Create a SExt or BitCast cast instruction
static CastInst *CreateSExtOrBitCast(
  Value *S,                ///< The value to be casted (operand 0)
  Type *Ty,          ///< The type to which cast should be made
  const Twine &Name = "", ///< Name for the instruction
  Instruction *InsertBefore = nullptr ///< Place to insert the instruction
);

/// Create a SExt or BitCast cast instruction
static CastInst *CreateSExtOrBitCast(
  Value *S,                ///< The value to be casted (operand 0)
  Type *Ty,          ///< The type to which operand is casted
  const Twine &Name, ///< The name for the instruction
  BasicBlock *InsertAtEnd  ///< The block to insert the instruction into
);

/// Create a BitCast AddrSpaceCast, or a PtrToInt cast instruction.
static CastInst *CreatePointerCast(
  Value *S,                ///< The pointer value to be casted (operand 0)
  Type *Ty,          ///< The type to which operand is casted
  const Twine &Name, ///< The name for the instruction
  BasicBlock *InsertAtEnd  ///< The block to insert the instruction into
);

/// Create a BitCast, AddrSpaceCast or a PtrToInt cast instruction.
static CastInst *CreatePointerCast(
  Value *S,                ///< The pointer value to be casted (operand 0)
  Type *Ty,          ///< The type to which cast should be made
  const Twine &Name = "", ///< Name for the instruction
  Instruction *InsertBefore = nullptr ///< Place to insert the instruction
);

/// Create a BitCast or an AddrSpaceCast cast instruction.
static CastInst *CreatePointerBitCastOrAddrSpaceCast(
  Value *S,                ///< The pointer value to be casted (operand 0)
  Type *Ty,          ///< The type to which operand is casted
  const Twine &Name, ///< The name for the instruction
  BasicBlock *InsertAtEnd  ///< The block to insert the instruction into
);

/// Create a BitCast or an AddrSpaceCast cast instruction.
static CastInst *CreatePointerBitCastOrAddrSpaceCast(
  Value *S,                ///< The pointer value to be casted (operand 0)
  Type *Ty,          ///< The type to which cast should be made
  const Twine &Name = "", ///< Name for the instruction
  Instruction *InsertBefore = nullptr ///< Place to insert the instruction
);

/// Create a BitCast, a PtrToInt, or an IntToPTr cast instruction.
///
/// If the value is a pointer type and the destination an integer type,
/// creates a PtrToInt cast. If the value is an integer type and the
/// destination a pointer type, creates an IntToPtr cast. Otherwise, creates
/// a bitcast.
static CastInst *CreateBitOrPointerCast(
  Value *S,                ///< The pointer value to be casted (operand 0)
  Type *Ty,          ///< The type to which cast should be made
  const Twine &Name = "", ///< Name for the instruction
  Instruction *InsertBefore = nullptr ///< Place to insert the instruction
);

/// Create a ZExt, BitCast, or Trunc for int -> int casts.
static CastInst *CreateIntegerCast(
  Value *S,                ///< The pointer value to be casted (operand 0)
  Type *Ty,          ///< The type to which cast should be made
  bool isSigned,           ///< Whether to regard S as signed or not
  const Twine &Name = "", ///< Name for the instruction
  Instruction *InsertBefore = nullptr ///< Place to insert the instruction
);

/// Create a ZExt, BitCast, or Trunc for int -> int casts.
static CastInst *CreateIntegerCast(
  Value *S,                ///< The integer value to be casted (operand 0)
  Type *Ty,          ///< The integer type to which operand is casted
  bool isSigned,           ///< Whether to regard S as signed or not
  const Twine &Name, ///< The name for the instruction
  BasicBlock *InsertAtEnd  ///< The block to insert the instruction into
);

/// Create an FPExt, BitCast, or FPTrunc for fp -> fp casts
static CastInst *CreateFPCast(
  Value *S,                ///< The floating point value to be casted
  Type *Ty,          ///< The floating point type to cast to
  const Twine &Name = "", ///< Name for the instruction
  Instruction *InsertBefore = nullptr ///< Place to insert the instruction
);

/// Create an FPExt, BitCast, or FPTrunc for fp -> fp casts
static CastInst *CreateFPCast(
  Value *S,                ///< The floating point value to be casted
  Type *Ty,          ///< The floating point type to cast to
  const Twine &Name, ///< The name for the instruction
  BasicBlock *InsertAtEnd  ///< The block to insert the instruction into
);

/// Create a Trunc or BitCast cast instruction
static CastInst *CreateTruncOrBitCast(
  Value *S,                ///< The value to be casted (operand 0)
  Type *Ty,          ///< The type to which cast should be made
  const Twine &Name = "", ///< Name for the instruction
  Instruction *InsertBefore = nullptr ///< Place to insert the instruction
);

/// Create a Trunc or BitCast cast instruction
static CastInst *CreateTruncOrBitCast(
  Value *S,                ///< The value to be casted (operand 0)
  Type *Ty,          ///< The type to which operand is casted
  const Twine &Name, ///< The name for the instruction
  BasicBlock *InsertAtEnd  ///< The block to insert the instruction into
);

/// Check whether a bitcast between these types is valid
static bool isBitCastable(
  Type *SrcTy, ///< The Type from which the value should be cast.
  Type *DestTy ///< The Type to which the value should be cast.
);

/// Check whether a bitcast, inttoptr, or ptrtoint cast between these
/// types is valid and a no-op.
///
/// This ensures that any pointer<->integer cast has enough bits in the
/// integer and any other cast is a bitcast.
static bool isBitOrNoopPointerCastable(
    Type *SrcTy,  ///< The Type from which the value should be cast.
    Type *DestTy, ///< The Type to which the value should be cast.
    const DataLayout &DL);

/// Returns the opcode necessary to cast Val into Ty using usual casting
/// rules.
/// Infer the opcode for cast operand and type
static Instruction::CastOps getCastOpcode(
  const Value *Val, ///< The value to cast
  bool SrcIsSigned, ///< Whether to treat the source as signed
  Type *Ty,   ///< The Type to which the value should be casted
  bool DstIsSigned  ///< Whether to treate the dest. as signed
);

/// There are several places where we need to know if a cast instruction
/// only deals with integer source and destination types. To simplify that
/// logic, this method is provided.
/// @returns true iff the cast has only integral typed operand and dest type.
/// Determine if this is an integer-only cast.
bool isIntegerCast() const;

/// A lossless cast is one that does not alter the basic value. It implies
/// a no-op cast but is more stringent, preventing things like int->float,
/// long->double, or int->ptr.
/// @returns true iff the cast is lossless.
/// Determine if this is a lossless cast.
bool isLosslessCast() const;

/// A no-op cast is one that can be effected without changing any bits.
/// It implies that the source and destination types are the same size. The
/// DataLayout argument is to determine the pointer size when examining casts
/// involving Integer and Pointer types. They are no-op casts if the integer
/// is the same size as the pointer. However, pointer size varies with
/// platform.  Note that a precondition of this method is that the cast is
/// legal - i.e. the instruction formed with these operands would verify.
static bool isNoopCast(
  Instruction::CastOps Opcode, ///< Opcode of cast
  Type *SrcTy,         ///< SrcTy of cast
  Type *DstTy,         ///< DstTy of cast
  const DataLayout &DL ///< DataLayout to get the Int Ptr type from.
);

/// Determine if this cast is a no-op cast.
///
/// \param DL is the DataLayout to determine pointer size.
bool isNoopCast(const DataLayout &DL) const;

/// Determine how a pair of casts can be eliminated, if they can be at all.
/// This is a helper function for both CastInst and ConstantExpr.
/// @returns 0 if the CastInst pair can't be eliminated, otherwise
/// returns Instruction::CastOps value for a cast that can replace
/// the pair, casting SrcTy to DstTy.
/// Determine if a cast pair is eliminable
static unsigned isEliminableCastPair(
  Instruction::CastOps firstOpcode,  ///< Opcode of first cast
  Instruction::CastOps secondOpcode, ///< Opcode of second cast
  Type *SrcTy, ///< SrcTy of 1st cast
  Type *MidTy, ///< DstTy of 1st cast & SrcTy of 2nd cast
  Type *DstTy, ///< DstTy of 2nd cast
  Type *SrcIntPtrTy, ///< Integer type corresponding to Ptr SrcTy, or null
  Type *MidIntPtrTy, ///< Integer type corresponding to Ptr MidTy, or null
  Type *DstIntPtrTy  ///< Integer type corresponding to Ptr DstTy, or null
);

/// Return the opcode of this CastInst
Instruction::CastOps getOpcode() const {
  return Instruction::CastOps(Instruction::getOpcode());
}

/// Return the source type, as a convenience
Type* getSrcTy() const { return getOperand(0)->getType(); }
/// Return the destination type, as a convenience
Type* getDestTy() const { return getType(); }

/// This method can be used to determine if a cast from SrcTy to DstTy using
/// Opcode op is valid or not.
/// @returns true iff the proposed cast is valid.
/// Determine if a cast is valid without creating one.
static bool castIsValid(Instruction::CastOps op, Type *SrcTy, Type *DstTy);
static bool castIsValid(Instruction::CastOps op, Value *S, Type *DstTy) {
  return castIsValid(op, S->getType(), DstTy);
}

/// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->isCast();
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}
704};

706//===----------------------------------------------------------------------===//
707//                               CmpInst Class
708//===----------------------------------------------------------------------===//

710/// This class is the base class for the comparison instructions.
711/// Abstract base class of comparison instructions.
712class CmpInst : public Instruction {
713public:
/// This enumeration lists the possible predicates for CmpInst subclasses.
/// Values in the range 0-31 are reserved for FCmpInst, while values in the
/// range 32-64 are reserved for ICmpInst. This is necessary to ensure the
/// predicate values are not overlapping between the classes.
///
/// Some passes (e.g. InstCombine) depend on the bit-wise characteristics of
/// FCMP_* values. Changing the bit patterns requires a potential change to
/// those passes.
enum Predicate : unsigned {
  // Opcode            U L G E    Intuitive operation
  FCMP_FALSE = 0, ///< 0 0 0 0    Always false (always folded)
  FCMP_OEQ = 1,   ///< 0 0 0 1    True if ordered and equal
  FCMP_OGT = 2,   ///< 0 0 1 0    True if ordered and greater than
  FCMP_OGE = 3,   ///< 0 0 1 1    True if ordered and greater than or equal
  FCMP_OLT = 4,   ///< 0 1 0 0    True if ordered and less than
  FCMP_OLE = 5,   ///< 0 1 0 1    True if ordered and less than or equal
  FCMP_ONE = 6,   ///< 0 1 1 0    True if ordered and operands are unequal
  FCMP_ORD = 7,   ///< 0 1 1 1    True if ordered (no nans)
  FCMP_UNO = 8,   ///< 1 0 0 0    True if unordered: isnan(X) | isnan(Y)
  FCMP_UEQ = 9,   ///< 1 0 0 1    True if unordered or equal
  FCMP_UGT = 10,  ///< 1 0 1 0    True if unordered or greater than
  FCMP_UGE = 11,  ///< 1 0 1 1    True if unordered, greater than, or equal
  FCMP_ULT = 12,  ///< 1 1 0 0    True if unordered or less than
  FCMP_ULE = 13,  ///< 1 1 0 1    True if unordered, less than, or equal
  FCMP_UNE = 14,  ///< 1 1 1 0    True if unordered or not equal
  FCMP_TRUE = 15, ///< 1 1 1 1    Always true (always folded)
  FIRST_FCMP_PREDICATE = FCMP_FALSE,
  LAST_FCMP_PREDICATE = FCMP_TRUE,
  BAD_FCMP_PREDICATE = FCMP_TRUE + 1,
  ICMP_EQ = 32,  ///< equal
  ICMP_NE = 33,  ///< not equal
  ICMP_UGT = 34, ///< unsigned greater than
  ICMP_UGE = 35, ///< unsigned greater or equal
  ICMP_ULT = 36, ///< unsigned less than
  ICMP_ULE = 37, ///< unsigned less or equal
  ICMP_SGT = 38, ///< signed greater than
  ICMP_SGE = 39, ///< signed greater or equal
  ICMP_SLT = 40, ///< signed less than
  ICMP_SLE = 41, ///< signed less or equal
  FIRST_ICMP_PREDICATE = ICMP_EQ,
  LAST_ICMP_PREDICATE = ICMP_SLE,
  BAD_ICMP_PREDICATE = ICMP_SLE + 1
};
using PredicateField =
    Bitfield::Element<Predicate, 0, 6, LAST_ICMP_PREDICATE>;

760protected:
CmpInst(Type *ty, Instruction::OtherOps op, Predicate pred,
        Value *LHS, Value *RHS, const Twine &Name = "",
        Instruction *InsertBefore = nullptr,
        Instruction *FlagsSource = nullptr);

CmpInst(Type *ty, Instruction::OtherOps op, Predicate pred,
        Value *LHS, Value *RHS, const Twine &Name,
        BasicBlock *InsertAtEnd);

770public:
// allocate space for exactly two operands
void *operator new(size_t s) {
  return User::operator new(s, 2);
}

/// Construct a compare instruction, given the opcode, the predicate and
/// the two operands.  Optionally (if InstBefore is specified) insert the
/// instruction into a BasicBlock right before the specified instruction.
/// The specified Instruction is allowed to be a dereferenced end iterator.
/// Create a CmpInst
static CmpInst *Create(OtherOps Op,
                       Predicate predicate, Value *S1,
                       Value *S2, const Twine &Name = "",
                       Instruction *InsertBefore = nullptr);

/// Construct a compare instruction, given the opcode, the predicate and the
/// two operands.  Also automatically insert this instruction to the end of
/// the BasicBlock specified.
/// Create a CmpInst
static CmpInst *Create(OtherOps Op, Predicate predicate, Value *S1,
                       Value *S2, const Twine &Name, BasicBlock *InsertAtEnd);

/// Get the opcode casted to the right type
OtherOps getOpcode() const {
  return static_cast<OtherOps>(Instruction::getOpcode());
}

/// Return the predicate for this instruction.
Predicate getPredicate() const { return getSubclassData<PredicateField>(); }

/// Set the predicate for this instruction to the specified value.
void setPredicate(Predicate P) { setSubclassData<PredicateField>(P); }

static bool isFPPredicate(Predicate P) {
  static_assert(FIRST_FCMP_PREDICATE == 0,
                "FIRST_FCMP_PREDICATE is required to be 0");
  return P <= LAST_FCMP_PREDICATE;
}

static bool isIntPredicate(Predicate P) {
  return P >= FIRST_ICMP_PREDICATE && P <= LAST_ICMP_PREDICATE;
}

static StringRef getPredicateName(Predicate P);

bool isFPPredicate() const { return isFPPredicate(getPredicate()); }
bool isIntPredicate() const { return isIntPredicate(getPredicate()); }

/// For example, EQ -> NE, UGT -> ULE, SLT -> SGE,
///              OEQ -> UNE, UGT -> OLE, OLT -> UGE, etc.
/// @returns the inverse predicate for the instruction's current predicate.
/// Return the inverse of the instruction's predicate.
Predicate getInversePredicate() const {
  return getInversePredicate(getPredicate());
}

/// For example, EQ -> NE, UGT -> ULE, SLT -> SGE,
///              OEQ -> UNE, UGT -> OLE, OLT -> UGE, etc.
/// @returns the inverse predicate for predicate provided in \p pred.
/// Return the inverse of a given predicate
static Predicate getInversePredicate(Predicate pred);

/// For example, EQ->EQ, SLE->SGE, ULT->UGT,
///              OEQ->OEQ, ULE->UGE, OLT->OGT, etc.
/// @returns the predicate that would be the result of exchanging the two
/// operands of the CmpInst instruction without changing the result
/// produced.
/// Return the predicate as if the operands were swapped
Predicate getSwappedPredicate() const {
  return getSwappedPredicate(getPredicate());
}

/// This is a static version that you can use without an instruction
/// available.
/// Return the predicate as if the operands were swapped.
static Predicate getSwappedPredicate(Predicate pred);

/// This is a static version that you can use without an instruction
/// available.
/// @returns true if the comparison predicate is strict, false otherwise.
static bool isStrictPredicate(Predicate predicate);

/// @returns true if the comparison predicate is strict, false otherwise.
/// Determine if this instruction is using an strict comparison predicate.
bool isStrictPredicate() const { return isStrictPredicate(getPredicate()); }

/// This is a static version that you can use without an instruction
/// available.
/// @returns true if the comparison predicate is non-strict, false otherwise.
static bool isNonStrictPredicate(Predicate predicate);

/// @returns true if the comparison predicate is non-strict, false otherwise.
/// Determine if this instruction is using an non-strict comparison predicate.
bool isNonStrictPredicate() const {
  return isNonStrictPredicate(getPredicate());
}

/// For example, SGE -> SGT, SLE -> SLT, ULE -> ULT, UGE -> UGT.
/// Returns the strict version of non-strict comparisons.
Predicate getStrictPredicate() const {
  return getStrictPredicate(getPredicate());
}

/// This is a static version that you can use without an instruction
/// available.
/// @returns the strict version of comparison provided in \p pred.
/// If \p pred is not a strict comparison predicate, returns \p pred.
/// Returns the strict version of non-strict comparisons.
static Predicate getStrictPredicate(Predicate pred);

/// For example, SGT -> SGE, SLT -> SLE, ULT -> ULE, UGT -> UGE.
/// Returns the non-strict version of strict comparisons.
Predicate getNonStrictPredicate() const {
  return getNonStrictPredicate(getPredicate());
}

/// This is a static version that you can use without an instruction
/// available.
/// @returns the non-strict version of comparison provided in \p pred.
/// If \p pred is not a strict comparison predicate, returns \p pred.
/// Returns the non-strict version of strict comparisons.
static Predicate getNonStrictPredicate(Predicate pred);

/// This is a static version that you can use without an instruction
/// available.
/// Return the flipped strictness of predicate
static Predicate getFlippedStrictnessPredicate(Predicate pred);

/// For predicate of kind "is X or equal to 0" returns the predicate "is X".
/// For predicate of kind "is X" returns the predicate "is X or equal to 0".
/// does not support other kind of predicates.
/// @returns the predicate that does not contains is equal to zero if
/// it had and vice versa.
/// Return the flipped strictness of predicate
Predicate getFlippedStrictnessPredicate() const {
  return getFlippedStrictnessPredicate(getPredicate());
}

/// Provide more efficient getOperand methods.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)public: inline Value *getOperand(unsigned) const; inline void
 setOperand(unsigned, Value*); inline op_iterator op_begin();
 inline const_op_iterator op_begin() const; inline op_iterator
 op_end(); inline const_op_iterator op_end() const; protected
: template <int> inline Use &Op(); template <int
> inline const Use &Op() const; public: inline unsigned
 getNumOperands() const;

/// This is just a convenience that dispatches to the subclasses.
/// Swap the operands and adjust predicate accordingly to retain
/// the same comparison.
void swapOperands();

/// This is just a convenience that dispatches to the subclasses.
/// Determine if this CmpInst is commutative.
bool isCommutative() const;

/// Determine if this is an equals/not equals predicate.
/// This is a static version that you can use without an instruction
/// available.
static bool isEquality(Predicate pred);

/// Determine if this is an equals/not equals predicate.
bool isEquality() const { return isEquality(getPredicate()); }

/// Return true if the predicate is relational (not EQ or NE).
static bool isRelational(Predicate P) { return !isEquality(P); }

/// Return true if the predicate is relational (not EQ or NE).
bool isRelational() const { return !isEquality(); }

/// @returns true if the comparison is signed, false otherwise.
/// Determine if this instruction is using a signed comparison.
bool isSigned() const {
  return isSigned(getPredicate());
}

/// @returns true if the comparison is unsigned, false otherwise.
/// Determine if this instruction is using an unsigned comparison.
bool isUnsigned() const {
  return isUnsigned(getPredicate());
}

/// For example, ULT->SLT, ULE->SLE, UGT->SGT, UGE->SGE, SLT->Failed assert
/// @returns the signed version of the unsigned predicate pred.
/// return the signed version of a predicate
static Predicate getSignedPredicate(Predicate pred);

/// For example, ULT->SLT, ULE->SLE, UGT->SGT, UGE->SGE, SLT->Failed assert
/// @returns the signed version of the predicate for this instruction (which
/// has to be an unsigned predicate).
/// return the signed version of a predicate
Predicate getSignedPredicate() {
  return getSignedPredicate(getPredicate());
}

/// For example, SLT->ULT, SLE->ULE, SGT->UGT, SGE->UGE, ULT->Failed assert
/// @returns the unsigned version of the signed predicate pred.
static Predicate getUnsignedPredicate(Predicate pred);

/// For example, SLT->ULT, SLE->ULE, SGT->UGT, SGE->UGE, ULT->Failed assert
/// @returns the unsigned version of the predicate for this instruction (which
/// has to be an signed predicate).
/// return the unsigned version of a predicate
Predicate getUnsignedPredicate() {
  return getUnsignedPredicate(getPredicate());
}

/// For example, SLT->ULT, ULT->SLT, SLE->ULE, ULE->SLE, EQ->Failed assert
/// @returns the unsigned version of the signed predicate pred or
///          the signed version of the signed predicate pred.
static Predicate getFlippedSignednessPredicate(Predicate pred);

/// For example, SLT->ULT, ULT->SLT, SLE->ULE, ULE->SLE, EQ->Failed assert
/// @returns the unsigned version of the signed predicate pred or
///          the signed version of the signed predicate pred.
Predicate getFlippedSignednessPredicate() {
  return getFlippedSignednessPredicate(getPredicate());
}

/// This is just a convenience.
/// Determine if this is true when both operands are the same.
bool isTrueWhenEqual() const {
  return isTrueWhenEqual(getPredicate());
}

/// This is just a convenience.
/// Determine if this is false when both operands are the same.
bool isFalseWhenEqual() const {
  return isFalseWhenEqual(getPredicate());
}

/// @returns true if the predicate is unsigned, false otherwise.
/// Determine if the predicate is an unsigned operation.
static bool isUnsigned(Predicate predicate);

/// @returns true if the predicate is signed, false otherwise.
/// Determine if the predicate is an signed operation.
static bool isSigned(Predicate predicate);

/// Determine if the predicate is an ordered operation.
static bool isOrdered(Predicate predicate);

/// Determine if the predicate is an unordered operation.
static bool isUnordered(Predicate predicate);

/// Determine if the predicate is true when comparing a value with itself.
static bool isTrueWhenEqual(Predicate predicate);

/// Determine if the predicate is false when comparing a value with itself.
static bool isFalseWhenEqual(Predicate predicate);

/// Determine if Pred1 implies Pred2 is true when two compares have matching
/// operands.
static bool isImpliedTrueByMatchingCmp(Predicate Pred1, Predicate Pred2);

/// Determine if Pred1 implies Pred2 is false when two compares have matching
/// operands.
static bool isImpliedFalseByMatchingCmp(Predicate Pred1, Predicate Pred2);

/// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {
  return I->getOpcode() == Instruction::ICmp ||
         I->getOpcode() == Instruction::FCmp;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}

/// Create a result type for fcmp/icmp
static Type* makeCmpResultType(Type* opnd_type) {
  if (VectorType* vt = dyn_cast<VectorType>(opnd_type)) {
    return VectorType::get(Type::getInt1Ty(opnd_type->getContext()),
                           vt->getElementCount());
  }
  return Type::getInt1Ty(opnd_type->getContext());
}

1042private:
// Shadow Value::setValueSubclassData with a private forwarding method so that
// subclasses cannot accidentally use it.
void setValueSubclassData(unsigned short D) {
  Value::setValueSubclassData(D);
}
1048};

1050// FIXME: these are redundant if CmpInst < BinaryOperator
1051template <>
1052struct OperandTraits<CmpInst> : public FixedNumOperandTraits<CmpInst, 2> {
1053};

1055DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CmpInst, Value)CmpInst::op_iterator CmpInst::op_begin() { return OperandTraits
<CmpInst>::op_begin(this); } CmpInst::const_op_iterator
 CmpInst::op_begin() const { return OperandTraits<CmpInst>
::op_begin(const_cast<CmpInst*>(this)); } CmpInst::op_iterator
 CmpInst::op_end() { return OperandTraits<CmpInst>::op_end
(this); } CmpInst::const_op_iterator CmpInst::op_end() const {
 return OperandTraits<CmpInst>::op_end(const_cast<CmpInst
*>(this)); } Value *CmpInst::getOperand(unsigned i_nocapture
) const { ((i_nocapture < OperandTraits<CmpInst>::operands
(this) && "getOperand() out of range!") ? static_cast
<void> (0) : __assert_fail ("i_nocapture < OperandTraits<CmpInst>::operands(this) && \"getOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/InstrTypes.h"
, 1055, __PRETTY_FUNCTION__)); return cast_or_null<Value>
( OperandTraits<CmpInst>::op_begin(const_cast<CmpInst
*>(this))[i_nocapture].get()); } void CmpInst::setOperand(
unsigned i_nocapture, Value *Val_nocapture) { ((i_nocapture <
 OperandTraits<CmpInst>::operands(this) && "setOperand() out of range!"
) ? static_cast<void> (0) : __assert_fail ("i_nocapture < OperandTraits<CmpInst>::operands(this) && \"setOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/InstrTypes.h"
, 1055, __PRETTY_FUNCTION__)); OperandTraits<CmpInst>::
op_begin(this)[i_nocapture] = Val_nocapture; } unsigned CmpInst
::getNumOperands() const { return OperandTraits<CmpInst>
::operands(this); } template <int Idx_nocapture> Use &
CmpInst::Op() { return this->OpFrom<Idx_nocapture>(this
); } template <int Idx_nocapture> const Use &CmpInst
::Op() const { return this->OpFrom<Idx_nocapture>(this
); }

1057/// A lightweight accessor for an operand bundle meant to be passed
1058/// around by value.
1059struct OperandBundleUse {
ArrayRef<Use> Inputs;

OperandBundleUse() = default;
explicit OperandBundleUse(StringMapEntry<uint32_t> *Tag, ArrayRef<Use> Inputs)
    : Inputs(Inputs), Tag(Tag) {}

/// Return true if the operand at index \p Idx in this operand bundle
/// has the attribute A.
bool operandHasAttr(unsigned Idx, Attribute::AttrKind A) const {
  if (isDeoptOperandBundle())
    if (A == Attribute::ReadOnly || A == Attribute::NoCapture)
      return Inputs[Idx]->getType()->isPointerTy();

  // Conservative answer:  no operands have any attributes.
  return false;
}

/// Return the tag of this operand bundle as a string.
StringRef getTagName() const {
  return Tag->getKey();
}

/// Return the tag of this operand bundle as an integer.
///
/// Operand bundle tags are interned by LLVMContextImpl::getOrInsertBundleTag,
/// and this function returns the unique integer getOrInsertBundleTag
/// associated the tag of this operand bundle to.
uint32_t getTagID() const {
  return Tag->getValue();
}

/// Return true if this is a "deopt" operand bundle.
bool isDeoptOperandBundle() const {
  return getTagID() == LLVMContext::OB_deopt;
}

/// Return true if this is a "funclet" operand bundle.
bool isFuncletOperandBundle() const {
  return getTagID() == LLVMContext::OB_funclet;
}

/// Return true if this is a "cfguardtarget" operand bundle.
bool isCFGuardTargetOperandBundle() const {
  return getTagID() == LLVMContext::OB_cfguardtarget;
}

1106private:
/// Pointer to an entry in LLVMContextImpl::getOrInsertBundleTag.
StringMapEntry<uint32_t> *Tag;
1109};

1111/// A container for an operand bundle being viewed as a set of values
1112/// rather than a set of uses.
1113///
1114/// Unlike OperandBundleUse, OperandBundleDefT owns the memory it carries, and
1115/// so it is possible to create and pass around "self-contained" instances of
1116/// OperandBundleDef and ConstOperandBundleDef.
1117template <typename InputTy> class OperandBundleDefT {
std::string Tag;
std::vector<InputTy> Inputs;

1121public:
explicit OperandBundleDefT(std::string Tag, std::vector<InputTy> Inputs)
    : Tag(std::move(Tag)), Inputs(std::move(Inputs)) {}
explicit OperandBundleDefT(std::string Tag, ArrayRef<InputTy> Inputs)
    : Tag(std::move(Tag)), Inputs(Inputs) {}

explicit OperandBundleDefT(const OperandBundleUse &OBU) {
  Tag = std::string(OBU.getTagName());
  llvm::append_range(Inputs, OBU.Inputs);
}

ArrayRef<InputTy> inputs() const { return Inputs; }

using input_iterator = typename std::vector<InputTy>::const_iterator;

size_t input_size() const { return Inputs.size(); }
input_iterator input_begin() const { return Inputs.begin(); }
input_iterator input_end() const { return Inputs.end(); }

StringRef getTag() const { return Tag; }
1141};

1143using OperandBundleDef = OperandBundleDefT<Value *>;
1144using ConstOperandBundleDef = OperandBundleDefT<const Value *>;

1146//===----------------------------------------------------------------------===//
1147//                               CallBase Class
1148//===----------------------------------------------------------------------===//

1150/// Base class for all callable instructions (InvokeInst and CallInst)
1151/// Holds everything related to calling a function.
1152///
1153/// All call-like instructions are required to use a common operand layout:
1154/// - Zero or more arguments to the call,
1155/// - Zero or more operand bundles with zero or more operand inputs each
1156///   bundle,
1157/// - Zero or more subclass controlled operands
1158/// - The called function.
1159///
1160/// This allows this base class to easily access the called function and the
1161/// start of the arguments without knowing how many other operands a particular
1162/// subclass requires. Note that accessing the end of the argument list isn't
1163/// as cheap as most other operations on the base class.
1164class CallBase : public Instruction {
1165protected:
// The first two bits are reserved by CallInst for fast retrieval,
using CallInstReservedField = Bitfield::Element<unsigned, 0, 2>;
using CallingConvField =
    Bitfield::Element<CallingConv::ID, CallInstReservedField::NextBit, 10,
                      CallingConv::MaxID>;
static_assert(
    Bitfield::areContiguous<CallInstReservedField, CallingConvField>(),
    "Bitfields must be contiguous");

/// The last operand is the called operand.
static constexpr int CalledOperandOpEndIdx = -1;

AttributeList Attrs; ///< parameter attributes for callable
FunctionType *FTy;

template <class... ArgsTy>
CallBase(AttributeList const &A, FunctionType *FT, ArgsTy &&... Args)
    : Instruction(std::forward<ArgsTy>(Args)...), Attrs(A), FTy(FT) {}

using Instruction::Instruction;

bool hasDescriptor() const { return Value::HasDescriptor; }

unsigned getNumSubclassExtraOperands() const {
  switch (getOpcode()) {
  case Instruction::Call:
    return 0;
  case Instruction::Invoke:
    return 2;
  case Instruction::CallBr:
    return getNumSubclassExtraOperandsDynamic();
  }
  llvm_unreachable("Invalid opcode!")::llvm::llvm_unreachable_internal("Invalid opcode!", "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/InstrTypes.h"
, 1198);
}

/// Get the number of extra operands for instructions that don't have a fixed
/// number of extra operands.
unsigned getNumSubclassExtraOperandsDynamic() const;

1205public:
using Instruction::getContext;

/// Create a clone of \p CB with a different set of operand bundles and
/// insert it before \p InsertPt.
///
/// The returned call instruction is identical \p CB in every way except that
/// the operand bundles for the new instruction are set to the operand bundles
/// in \p Bundles.
static CallBase *Create(CallBase *CB, ArrayRef<OperandBundleDef> Bundles,
                        Instruction *InsertPt = nullptr);

/// Create a clone of \p CB with the operand bundle with the tag matching
/// \p Bundle's tag replaced with Bundle, and insert it before \p InsertPt.
///
/// The returned call instruction is identical \p CI in every way except that
/// the specified operand bundle has been replaced.
static CallBase *Create(CallBase *CB,
                        OperandBundleDef Bundle,
                        Instruction *InsertPt = nullptr);

/// Create a clone of \p CB with operand bundle \p OB added.
static CallBase *addOperandBundle(CallBase *CB, uint32_t ID,
                                  OperandBundleDef OB,
                                  Instruction *InsertPt = nullptr);

/// Create a clone of \p CB with operand bundle \p ID removed.
static CallBase *removeOperandBundle(CallBase *CB, uint32_t ID,
                                     Instruction *InsertPt = nullptr);

static bool classof(const Instruction *I) {
  return I->getOpcode() == Instruction::Call ||
         I->getOpcode() == Instruction::Invoke ||
         I->getOpcode() == Instruction::CallBr;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}

FunctionType *getFunctionType() const { return FTy; }

void mutateFunctionType(FunctionType *FTy) {
  Value::mutateType(FTy->getReturnType());
  this->FTy = FTy;
}

DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)public: inline Value *getOperand(unsigned) const; inline void
 setOperand(unsigned, Value*); inline op_iterator op_begin();
 inline const_op_iterator op_begin() const; inline op_iterator
 op_end(); inline const_op_iterator op_end() const; protected
: template <int> inline Use &Op(); template <int
> inline const Use &Op() const; public: inline unsigned
 getNumOperands() const;

/// data_operands_begin/data_operands_end - Return iterators iterating over
/// the call / invoke argument list and bundle operands.  For invokes, this is
/// the set of instruction operands except the invoke target and the two
/// successor blocks; and for calls this is the set of instruction operands
/// except the call target.
User::op_iterator data_operands_begin() { return op_begin(); }
User::const_op_iterator data_operands_begin() const {
  return const_cast<CallBase *>(this)->data_operands_begin();
}
User::op_iterator data_operands_end() {
  // Walk from the end of the operands over the called operand and any
  // subclass operands.
  return op_end() - getNumSubclassExtraOperands() - 1;
}
User::const_op_iterator data_operands_end() const {
  return const_cast<CallBase *>(this)->data_operands_end();
}
iterator_range<User::op_iterator> data_ops() {
  return make_range(data_operands_begin(), data_operands_end());
}
iterator_range<User::const_op_iterator> data_ops() const {
  return make_range(data_operands_begin(), data_operands_end());
}
bool data_operands_empty() const {
  return data_operands_end() == data_operands_begin();
}
unsigned data_operands_size() const {
  return std::distance(data_operands_begin(), data_operands_end());
}

bool isDataOperand(const Use *U) const {
  assert(this == U->getUser() &&((this == U->getUser() && "Only valid to query with a use of this instruction!"
) ? static_cast<void> (0) : __assert_fail ("this == U->getUser() && \"Only valid to query with a use of this instruction!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/InstrTypes.h"
, 1285, __PRETTY_FUNCTION__))
         "Only valid to query with a use of this instruction!")((this == U->getUser() && "Only valid to query with a use of this instruction!"
) ? static_cast<void> (0) : __assert_fail ("this == U->getUser() && \"Only valid to query with a use of this instruction!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/InstrTypes.h"
, 1285, __PRETTY_FUNCTION__));
  return data_operands_begin() <= U && U < data_operands_end();
}
bool isDataOperand(Value::const_user_iterator UI) const {
  return isDataOperand(&UI.getUse());
}

/// Given a value use iterator, return the data operand corresponding to it.
/// Iterator must actually correspond to a data operand.
unsigned getDataOperandNo(Value::const_user_iterator UI) const {
  return getDataOperandNo(&UI.getUse());
}

/// Given a use for a data operand, get the data operand number that
/// corresponds to it.
unsigned getDataOperandNo(const Use *U) const {
  assert(isDataOperand(U) && "Data operand # out of range!")((isDataOperand(U) && "Data operand # out of range!")
 ? static_cast<void> (0) : __assert_fail ("isDataOperand(U) && \"Data operand # out of range!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/InstrTypes.h"
, 1301, __PRETTY_FUNCTION__));
  return U - data_operands_begin();
}

/// Return the iterator pointing to the beginning of the argument list.
User::op_iterator arg_begin() { return op_begin(); }
User::const_op_iterator arg_begin() const {
  return const_cast<CallBase *>(this)->arg_begin();
}

/// Return the iterator pointing to the end of the argument list.
User::op_iterator arg_end() {
  // From the end of the data operands, walk backwards past the bundle
  // operands.
  return data_operands_end() - getNumTotalBundleOperands();
}
User::const_op_iterator arg_end() const {
  return const_cast<CallBase *>(this)->arg_end();
}

/// Iteration adapter for range-for loops.
iterator_range<User::op_iterator> args() {
  return make_range(arg_begin(), arg_end());
}
iterator_range<User::const_op_iterator> args() const {
  return make_range(arg_begin(), arg_end());
}
bool arg_empty() const { return arg_end() == arg_begin(); }
unsigned arg_size() const { return arg_end() - arg_begin(); }

// Legacy API names that duplicate the above and will be removed once users
// are migrated.
iterator_range<User::op_iterator> arg_operands() {
  return make_range(arg_begin(), arg_end());
}
iterator_range<User::const_op_iterator> arg_operands() const {
  return make_range(arg_begin(), arg_end());
}
unsigned getNumArgOperands() const { return arg_size(); }

Value *getArgOperand(unsigned i) const {
  assert(i < getNumArgOperands() && "Out of bounds!")((i < getNumArgOperands() && "Out of bounds!") ? static_cast
<void> (0) : __assert_fail ("i < getNumArgOperands() && \"Out of bounds!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/InstrTypes.h"
, 1342, __PRETTY_FUNCTION__));
  return getOperand(i);
}

void setArgOperand(unsigned i, Value *v) {
  assert(i < getNumArgOperands() && "Out of bounds!")((i < getNumArgOperands() && "Out of bounds!") ? static_cast
<void> (0) : __assert_fail ("i < getNumArgOperands() && \"Out of bounds!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/InstrTypes.h"
, 1347, __PRETTY_FUNCTION__));
  setOperand(i, v);
}

/// Wrappers for getting the \c Use of a call argument.
const Use &getArgOperandUse(unsigned i) const {
  assert(i < getNumArgOperands() && "Out of bounds!")((i < getNumArgOperands() && "Out of bounds!") ? static_cast
<void> (0) : __assert_fail ("i < getNumArgOperands() && \"Out of bounds!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/InstrTypes.h"
, 1353, __PRETTY_FUNCTION__));
  return User::getOperandUse(i);
}
Use &getArgOperandUse(unsigned i) {
  assert(i < getNumArgOperands() && "Out of bounds!")((i < getNumArgOperands() && "Out of bounds!") ? static_cast
<void> (0) : __assert_fail ("i < getNumArgOperands() && \"Out of bounds!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/InstrTypes.h"
, 1357, __PRETTY_FUNCTION__));
  return User::getOperandUse(i);
}

bool isArgOperand(const Use *U) const {
  assert(this == U->getUser() &&((this == U->getUser() && "Only valid to query with a use of this instruction!"
) ? static_cast<void> (0) : __assert_fail ("this == U->getUser() && \"Only valid to query with a use of this instruction!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/InstrTypes.h"
, 1363, __PRETTY_FUNCTION__))
         "Only valid to query with a use of this instruction!")((this == U->getUser() && "Only valid to query with a use of this instruction!"
) ? static_cast<void> (0) : __assert_fail ("this == U->getUser() && \"Only valid to query with a use of this instruction!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/InstrTypes.h"
, 1363, __PRETTY_FUNCTION__));
  return arg_begin() <= U && U < arg_end();
}
bool isArgOperand(Value::const_user_iterator UI) const {
  return isArgOperand(&UI.getUse());
}

/// Given a use for a arg operand, get the arg operand number that
/// corresponds to it.
unsigned getArgOperandNo(const Use *U) const {
  assert(isArgOperand(U) && "Arg operand # out of range!")((isArgOperand(U) && "Arg operand # out of range!") ?
 static_cast<void> (0) : __assert_fail ("isArgOperand(U) && \"Arg operand # out of range!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/InstrTypes.h"
, 1373, __PRETTY_FUNCTION__));
  return U - arg_begin();
}

/// Given a value use iterator, return the arg operand number corresponding to
/// it. Iterator must actually correspond to a data operand.
unsigned getArgOperandNo(Value::const_user_iterator UI) const {
  return getArgOperandNo(&UI.getUse());
}

/// Returns true if this CallSite passes the given Value* as an argument to
/// the called function.
bool hasArgument(const Value *V) const {
  return llvm::is_contained(args(), V);
}

Value *getCalledOperand() const { return Op<CalledOperandOpEndIdx>(); }

const Use &getCalledOperandUse() const { return Op<CalledOperandOpEndIdx>(); }
Use &getCalledOperandUse() { return Op<CalledOperandOpEndIdx>(); }

/// Returns the function called, or null if this is an
/// indirect function invocation.
Function *getCalledFunction() const {
  return dyn_cast_or_null<Function>(getCalledOperand());
}

/// Return true if the callsite is an indirect call.
bool isIndirectCall() const;

/// Determine whether the passed iterator points to the callee operand's Use.
bool isCallee(Value::const_user_iterator UI) const {
  return isCallee(&UI.getUse());
}

/// Determine whether this Use is the callee operand's Use.
bool isCallee(const Use *U) const { return &getCalledOperandUse() == U; }

/// Helper to get the caller (the parent function).
Function *getCaller();
const Function *getCaller() const {
  return const_cast<CallBase *>(this)->getCaller();
}

/// Tests if this call site must be tail call optimized. Only a CallInst can
/// be tail call optimized.
bool isMustTailCall() const;

/// Tests if this call site is marked as a tail call.
bool isTailCall() const;

/// Returns the intrinsic ID of the intrinsic called or
/// Intrinsic::not_intrinsic if the called function is not an intrinsic, or if
/// this is an indirect call.
Intrinsic::ID getIntrinsicID() const;

void setCalledOperand(Value *V) { Op<CalledOperandOpEndIdx>() = V; }

/// Sets the function called, including updating the function type.
void setCalledFunction(Function *Fn) {
  setCalledFunction(Fn->getFunctionType(), Fn);
}

/// Sets the function called, including updating the function type.
void setCalledFunction(FunctionCallee Fn) {
  setCalledFunction(Fn.getFunctionType(), Fn.getCallee());
}

/// Sets the function called, including updating to the specified function
/// type.
void setCalledFunction(FunctionType *FTy, Value *Fn) {
  this->FTy = FTy;
  assert(FTy == cast<FunctionType>(((FTy == cast<FunctionType>( cast<PointerType>(Fn
->getType())->getElementType())) ? static_cast<void>
 (0) : __assert_fail ("FTy == cast<FunctionType>( cast<PointerType>(Fn->getType())->getElementType())"
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/InstrTypes.h"
, 1446, __PRETTY_FUNCTION__))
                    cast<PointerType>(Fn->getType())->getElementType()))((FTy == cast<FunctionType>( cast<PointerType>(Fn
->getType())->getElementType())) ? static_cast<void>
 (0) : __assert_fail ("FTy == cast<FunctionType>( cast<PointerType>(Fn->getType())->getElementType())"
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/InstrTypes.h"
, 1446, __PRETTY_FUNCTION__));
  // This function doesn't mutate the return type, only the function
  // type. Seems broken, but I'm just gonna stick an assert in for now.
  assert(getType() == FTy->getReturnType())((getType() == FTy->getReturnType()) ? static_cast<void
> (0) : __assert_fail ("getType() == FTy->getReturnType()"
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/InstrTypes.h"
, 1449, __PRETTY_FUNCTION__));
  setCalledOperand(Fn);
}

CallingConv::ID getCallingConv() const {
  return getSubclassData<CallingConvField>();
}

void setCallingConv(CallingConv::ID CC) {
  setSubclassData<CallingConvField>(CC);
}

/// Check if this call is an inline asm statement.
bool isInlineAsm() const { return isa<InlineAsm>(getCalledOperand()); }

/// \name Attribute API
///
/// These methods access and modify attributes on this call (including
/// looking through to the attributes on the called function when necessary).
///@{

/// Return the parameter attributes for this call.
///
AttributeList getAttributes() const { return Attrs; }

/// Set the parameter attributes for this call.
///
void setAttributes(AttributeList A) { Attrs = A; }

/// Determine whether this call has the given attribute. If it does not
/// then determine if the called function has the attribute, but only if
/// the attribute is allowed for the call.
bool hasFnAttr(Attribute::AttrKind Kind) const {
  assert(Kind != Attribute::NoBuiltin &&((Kind != Attribute::NoBuiltin && "Use CallBase::isNoBuiltin() to check for Attribute::NoBuiltin"
) ? static_cast<void> (0) : __assert_fail ("Kind != Attribute::NoBuiltin && \"Use CallBase::isNoBuiltin() to check for Attribute::NoBuiltin\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/InstrTypes.h"
, 1483, __PRETTY_FUNCTION__))
23
←
'?' condition is true→
         "Use CallBase::isNoBuiltin() to check for Attribute::NoBuiltin")((Kind != Attribute::NoBuiltin && "Use CallBase::isNoBuiltin() to check for Attribute::NoBuiltin"
) ? static_cast<void> (0) : __assert_fail ("Kind != Attribute::NoBuiltin && \"Use CallBase::isNoBuiltin() to check for Attribute::NoBuiltin\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/InstrTypes.h"
, 1483, __PRETTY_FUNCTION__));
  return hasFnAttrImpl(Kind);
24
←
Calling 'CallBase::hasFnAttrImpl'→
33
←
Returning from 'CallBase::hasFnAttrImpl'→
34
←
Returning value, which participates in a condition later→
}

/// Determine whether this call has the given attribute. If it does not
/// then determine if the called function has the attribute, but only if
/// the attribute is allowed for the call.
bool hasFnAttr(StringRef Kind) const { return hasFnAttrImpl(Kind); }

/// adds the attribute to the list of attributes.
void addAttribute(unsigned i, Attribute::AttrKind Kind) {
  AttributeList PAL = getAttributes();
  PAL = PAL.addAttribute(getContext(), i, Kind);
  setAttributes(PAL);
}

/// adds the attribute to the list of attributes.
void addAttribute(unsigned i, Attribute Attr) {
  AttributeList PAL = getAttributes();
  PAL = PAL.addAttribute(getContext(), i, Attr);
  setAttributes(PAL);
}

/// Adds the attribute to the indicated argument
void addParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) {
  assert(ArgNo < getNumArgOperands() && "Out of bounds")((ArgNo < getNumArgOperands() && "Out of bounds") ?
 static_cast<void> (0) : __assert_fail ("ArgNo < getNumArgOperands() && \"Out of bounds\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/InstrTypes.h"
, 1508, __PRETTY_FUNCTION__));
  AttributeList PAL = getAttributes();
  PAL = PAL.addParamAttribute(getContext(), ArgNo, Kind);
  setAttributes(PAL);
}

/// Adds the attribute to the indicated argument
void addParamAttr(unsigned ArgNo, Attribute Attr) {
  assert(ArgNo < getNumArgOperands() && "Out of bounds")((ArgNo < getNumArgOperands() && "Out of bounds") ?
 static_cast<void> (0) : __assert_fail ("ArgNo < getNumArgOperands() && \"Out of bounds\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/InstrTypes.h"
, 1516, __PRETTY_FUNCTION__));
  AttributeList PAL = getAttributes();
  PAL = PAL.addParamAttribute(getContext(), ArgNo, Attr);
  setAttributes(PAL);
}

/// removes the attribute from the list of attributes.
void removeAttribute(unsigned i, Attribute::AttrKind Kind) {
  AttributeList PAL = getAttributes();
  PAL = PAL.removeAttribute(getContext(), i, Kind);
  setAttributes(PAL);
}

/// removes the attribute from the list of attributes.
void removeAttribute(unsigned i, StringRef Kind) {
  AttributeList PAL = getAttributes();
  PAL = PAL.removeAttribute(getContext(), i, Kind);
  setAttributes(PAL);
}

void removeAttributes(unsigned i, const AttrBuilder &Attrs) {
  AttributeList PAL = getAttributes();
  PAL = PAL.removeAttributes(getContext(), i, Attrs);
  setAttributes(PAL);
}

/// Removes the attribute from the given argument
void removeParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) {
  assert(ArgNo < getNumArgOperands() && "Out of bounds")((ArgNo < getNumArgOperands() && "Out of bounds") ?
 static_cast<void> (0) : __assert_fail ("ArgNo < getNumArgOperands() && \"Out of bounds\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/InstrTypes.h"
, 1544, __PRETTY_FUNCTION__));
  AttributeList PAL = getAttributes();
  PAL = PAL.removeParamAttribute(getContext(), ArgNo, Kind);
  setAttributes(PAL);
}

/// Removes the attribute from the given argument
void removeParamAttr(unsigned ArgNo, StringRef Kind) {
  assert(ArgNo < getNumArgOperands() && "Out of bounds")((ArgNo < getNumArgOperands() && "Out of bounds") ?
 static_cast<void> (0) : __assert_fail ("ArgNo < getNumArgOperands() && \"Out of bounds\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/InstrTypes.h"
, 1552, __PRETTY_FUNCTION__));
  AttributeList PAL = getAttributes();
  PAL = PAL.removeParamAttribute(getContext(), ArgNo, Kind);
  setAttributes(PAL);
}

/// Removes noundef and other attributes that imply undefined behavior if a
/// `undef` or `poison` value is passed from the given argument.
void removeParamUndefImplyingAttrs(unsigned ArgNo) {
  assert(ArgNo < getNumArgOperands() && "Out of bounds")((ArgNo < getNumArgOperands() && "Out of bounds") ?
 static_cast<void> (0) : __assert_fail ("ArgNo < getNumArgOperands() && \"Out of bounds\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/InstrTypes.h"
, 1561, __PRETTY_FUNCTION__));
  AttributeList PAL = getAttributes();
  PAL = PAL.removeParamUndefImplyingAttributes(getContext(), ArgNo);
  setAttributes(PAL);
}

/// adds the dereferenceable attribute to the list of attributes.
void addDereferenceableAttr(unsigned i, uint64_t Bytes) {
  AttributeList PAL = getAttributes();
  PAL = PAL.addDereferenceableAttr(getContext(), i, Bytes);
  setAttributes(PAL);
}

/// adds the dereferenceable_or_null attribute to the list of
/// attributes.
void addDereferenceableOrNullAttr(unsigned i, uint64_t Bytes) {
  AttributeList PAL = getAttributes();
  PAL = PAL.addDereferenceableOrNullAttr(getContext(), i, Bytes);
  setAttributes(PAL);
}

/// Determine whether the return value has the given attribute.
bool hasRetAttr(Attribute::AttrKind Kind) const {
  return hasRetAttrImpl(Kind);
}
/// Determine whether the return value has the given attribute.
bool hasRetAttr(StringRef Kind) const { return hasRetAttrImpl(Kind); }

/// Determine whether the argument or parameter has the given attribute.
bool paramHasAttr(unsigned ArgNo, Attribute::AttrKind Kind) const;

/// Get the attribute of a given kind at a position.
Attribute getAttribute(unsigned i, Attribute::AttrKind Kind) const {
  return getAttributes().getAttribute(i, Kind);
}

/// Get the attribute of a given kind at a position.
Attribute getAttribute(unsigned i, StringRef Kind) const {
  return getAttributes().getAttribute(i, Kind);
}

/// Get the attribute of a given kind from a given arg
Attribute getParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) const {
  assert(ArgNo < getNumArgOperands() && "Out of bounds")((ArgNo < getNumArgOperands() && "Out of bounds") ?
 static_cast<void> (0) : __assert_fail ("ArgNo < getNumArgOperands() && \"Out of bounds\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/InstrTypes.h"
, 1604, __PRETTY_FUNCTION__));
  return getAttributes().getParamAttr(ArgNo, Kind);
}

/// Get the attribute of a given kind from a given arg
Attribute getParamAttr(unsigned ArgNo, StringRef Kind) const {
  assert(ArgNo < getNumArgOperands() && "Out of bounds")((ArgNo < getNumArgOperands() && "Out of bounds") ?
 static_cast<void> (0) : __assert_fail ("ArgNo < getNumArgOperands() && \"Out of bounds\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/InstrTypes.h"
, 1610, __PRETTY_FUNCTION__));
  return getAttributes().getParamAttr(ArgNo, Kind);
}

/// Return true if the data operand at index \p i has the attribute \p
/// A.
///
/// Data operands include call arguments and values used in operand bundles,
/// but does not include the callee operand.  This routine dispatches to the
/// underlying AttributeList or the OperandBundleUser as appropriate.
///
/// The index \p i is interpreted as
///
///  \p i == Attribute::ReturnIndex  -> the return value
///  \p i in [1, arg_size + 1)  -> argument number (\p i - 1)
///  \p i in [arg_size + 1, data_operand_size + 1) -> bundle operand at index
///     (\p i - 1) in the operand list.
bool dataOperandHasImpliedAttr(unsigned i, Attribute::AttrKind Kind) const {
  // Note that we have to add one because `i` isn't zero-indexed.
  assert(i < (getNumArgOperands() + getNumTotalBundleOperands() + 1) &&((i < (getNumArgOperands() + getNumTotalBundleOperands() +
 1) && "Data operand index out of bounds!") ? static_cast
<void> (0) : __assert_fail ("i < (getNumArgOperands() + getNumTotalBundleOperands() + 1) && \"Data operand index out of bounds!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/InstrTypes.h"
, 1630, __PRETTY_FUNCTION__))
         "Data operand index out of bounds!")((i < (getNumArgOperands() + getNumTotalBundleOperands() +
 1) && "Data operand index out of bounds!") ? static_cast
<void> (0) : __assert_fail ("i < (getNumArgOperands() + getNumTotalBundleOperands() + 1) && \"Data operand index out of bounds!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/InstrTypes.h"
, 1630, __PRETTY_FUNCTION__));

  // The attribute A can either be directly specified, if the operand in
  // question is a call argument; or be indirectly implied by the kind of its
  // containing operand bundle, if the operand is a bundle operand.

  if (i == AttributeList::ReturnIndex)
    return hasRetAttr(Kind);

  // FIXME: Avoid these i - 1 calculations and update the API to use
  // zero-based indices.
  if (i < (getNumArgOperands() + 1))
    return paramHasAttr(i - 1, Kind);

  assert(hasOperandBundles() && i >= (getBundleOperandsStartIndex() + 1) &&((hasOperandBundles() && i >= (getBundleOperandsStartIndex
() + 1) && "Must be either a call argument or an operand bundle!"
) ? static_cast<void> (0) : __assert_fail ("hasOperandBundles() && i >= (getBundleOperandsStartIndex() + 1) && \"Must be either a call argument or an operand bundle!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/InstrTypes.h"
, 1645, __PRETTY_FUNCTION__))
         "Must be either a call argument or an operand bundle!")((hasOperandBundles() && i >= (getBundleOperandsStartIndex
() + 1) && "Must be either a call argument or an operand bundle!"
) ? static_cast<void> (0) : __assert_fail ("hasOperandBundles() && i >= (getBundleOperandsStartIndex() + 1) && \"Must be either a call argument or an operand bundle!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/InstrTypes.h"
, 1645, __PRETTY_FUNCTION__));
  return bundleOperandHasAttr(i - 1, Kind);
}

/// Determine whether this data operand is not captured.
// FIXME: Once this API is no longer duplicated in `CallSite`, rename this to
// better indicate that this may return a conservative answer.
bool doesNotCapture(unsigned OpNo) const {
  return dataOperandHasImpliedAttr(OpNo + 1, Attribute::NoCapture);
}

/// Determine whether this argument is passed by value.
bool isByValArgument(unsigned ArgNo) const {
  return paramHasAttr(ArgNo, Attribute::ByVal);
}

/// Determine whether this argument is passed in an alloca.
bool isInAllocaArgument(unsigned ArgNo) const {
  return paramHasAttr(ArgNo, Attribute::InAlloca);
}

/// Determine whether this argument is passed by value, in an alloca, or is
/// preallocated.
bool isPassPointeeByValueArgument(unsigned ArgNo) const {
  return paramHasAttr(ArgNo, Attribute::ByVal) ||
         paramHasAttr(ArgNo, Attribute::InAlloca) ||
         paramHasAttr(ArgNo, Attribute::Preallocated);
}

/// Determine whether passing undef to this argument is undefined behavior.
/// If passing undef to this argument is UB, passing poison is UB as well
/// because poison is more undefined than undef.
bool isPassingUndefUB(unsigned ArgNo) const {
  return paramHasAttr(ArgNo, Attribute::NoUndef) ||
         // dereferenceable implies noundef.
         paramHasAttr(ArgNo, Attribute::Dereferenceable) ||
         // dereferenceable implies noundef, and null is a well-defined value.
         paramHasAttr(ArgNo, Attribute::DereferenceableOrNull);
}

/// Determine if there are is an inalloca argument. Only the last argument can
/// have the inalloca attribute.
bool hasInAllocaArgument() const {
  return !arg_empty() && paramHasAttr(arg_size() - 1, Attribute::InAlloca);
}

// FIXME: Once this API is no longer duplicated in `CallSite`, rename this to
// better indicate that this may return a conservative answer.
bool doesNotAccessMemory(unsigned OpNo) const {
  return dataOperandHasImpliedAttr(OpNo + 1, Attribute::ReadNone);
}

// FIXME: Once this API is no longer duplicated in `CallSite`, rename this to
// better indicate that this may return a conservative answer.
bool onlyReadsMemory(unsigned OpNo) const {
  return dataOperandHasImpliedAttr(OpNo + 1, Attribute::ReadOnly) ||
         dataOperandHasImpliedAttr(OpNo + 1, Attribute::ReadNone);
}

// FIXME: Once this API is no longer duplicated in `CallSite`, rename this to
// better indicate that this may return a conservative answer.
bool doesNotReadMemory(unsigned OpNo) const {
  return dataOperandHasImpliedAttr(OpNo + 1, Attribute::WriteOnly) ||
         dataOperandHasImpliedAttr(OpNo + 1, Attribute::ReadNone);
}

LLVM_ATTRIBUTE_DEPRECATED(unsigned getRetAlignment() const,[[deprecated("Use getRetAlign() instead")]] unsigned getRetAlignment
() const
                          "Use getRetAlign() instead")[[deprecated("Use getRetAlign() instead")]] unsigned getRetAlignment
() const {
  if (const auto MA = Attrs.getRetAlignment())
    return MA->value();
  return 0;
}

/// Extract the alignment of the return value.
MaybeAlign getRetAlign() const { return Attrs.getRetAlignment(); }

/// Extract the alignment for a call or parameter (0=unknown).
LLVM_ATTRIBUTE_DEPRECATED(unsigned getParamAlignment(unsigned ArgNo) const,[[deprecated("Use getParamAlign() instead")]] unsigned getParamAlignment
(unsigned ArgNo) const
                          "Use getParamAlign() instead")[[deprecated("Use getParamAlign() instead")]] unsigned getParamAlignment
(unsigned ArgNo) const {
  if (const auto MA = Attrs.getParamAlignment(ArgNo))
    return MA->value();
  return 0;
}

/// Extract the alignment for a call or parameter (0=unknown).
MaybeAlign getParamAlign(unsigned ArgNo) const {
  return Attrs.getParamAlignment(ArgNo);
}

/// Extract the byval type for a call or parameter.
Type *getParamByValType(unsigned ArgNo) const {
  Type *Ty = Attrs.getParamByValType(ArgNo);
  return Ty ? Ty : getArgOperand(ArgNo)->getType()->getPointerElementType();
}

/// Extract the preallocated type for a call or parameter.
Type *getParamPreallocatedType(unsigned ArgNo) const {
  Type *Ty = Attrs.getParamPreallocatedType(ArgNo);
  return Ty ? Ty : getArgOperand(ArgNo)->getType()->getPointerElementType();
}

/// Extract the number of dereferenceable bytes for a call or
/// parameter (0=unknown).
uint64_t getDereferenceableBytes(unsigned i) const {
  return Attrs.getDereferenceableBytes(i);
}

/// Extract the number of dereferenceable_or_null bytes for a call or
/// parameter (0=unknown).
uint64_t getDereferenceableOrNullBytes(unsigned i) const {
  return Attrs.getDereferenceableOrNullBytes(i);
}

/// Return true if the return value is known to be not null.
/// This may be because it has the nonnull attribute, or because at least
/// one byte is dereferenceable and the pointer is in addrspace(0).
bool isReturnNonNull() const;

/// Determine if the return value is marked with NoAlias attribute.
bool returnDoesNotAlias() const {
  return Attrs.hasAttribute(AttributeList::ReturnIndex, Attribute::NoAlias);
}

/// If one of the arguments has the 'returned' attribute, returns its
/// operand value. Otherwise, return nullptr.
Value *getReturnedArgOperand() const;

/// Return true if the call should not be treated as a call to a
/// builtin.
bool isNoBuiltin() const {
  return hasFnAttrImpl(Attribute::NoBuiltin) &&
         !hasFnAttrImpl(Attribute::Builtin);
}

/// Determine if the call requires strict floating point semantics.
bool isStrictFP() const { return hasFnAttr(Attribute::StrictFP); }

/// Return true if the call should not be inlined.
bool isNoInline() const { return hasFnAttr(Attribute::NoInline); }
void setIsNoInline() {
  addAttribute(AttributeList::FunctionIndex, Attribute::NoInline);
}
/// Determine if the call does not access memory.
bool doesNotAccessMemory() const { return hasFnAttr(Attribute::ReadNone); }
void setDoesNotAccessMemory() {
  addAttribute(AttributeList::FunctionIndex, Attribute::ReadNone);
}

/// Determine if the call does not access or only reads memory.
bool onlyReadsMemory() const {
  return doesNotAccessMemory() || hasFnAttr(Attribute::ReadOnly);
}

void setOnlyReadsMemory() {
  addAttribute(AttributeList::FunctionIndex, Attribute::ReadOnly);
}

/// Determine if the call does not access or only writes memory.
bool doesNotReadMemory() const {
  return doesNotAccessMemory() || hasFnAttr(Attribute::WriteOnly);
}
void setDoesNotReadMemory() {
  addAttribute(AttributeList::FunctionIndex, Attribute::WriteOnly);
}

/// Determine if the call can access memmory only using pointers based
/// on its arguments.
bool onlyAccessesArgMemory() const {
  return hasFnAttr(Attribute::ArgMemOnly);
}
void setOnlyAccessesArgMemory() {
  addAttribute(AttributeList::FunctionIndex, Attribute::ArgMemOnly);
}

/// Determine if the function may only access memory that is
/// inaccessible from the IR.
bool onlyAccessesInaccessibleMemory() const {
  return hasFnAttr(Attribute::InaccessibleMemOnly);
}
void setOnlyAccessesInaccessibleMemory() {
  addAttribute(AttributeList::FunctionIndex, Attribute::InaccessibleMemOnly);
}

/// Determine if the function may only access memory that is
/// either inaccessible from the IR or pointed to by its arguments.
bool onlyAccessesInaccessibleMemOrArgMem() const {
  return hasFnAttr(Attribute::InaccessibleMemOrArgMemOnly);
}
void setOnlyAccessesInaccessibleMemOrArgMem() {
  addAttribute(AttributeList::FunctionIndex,
               Attribute::InaccessibleMemOrArgMemOnly);
}
/// Determine if the call cannot return.
bool doesNotReturn() const { return hasFnAttr(Attribute::NoReturn); }
void setDoesNotReturn() {
  addAttribute(AttributeList::FunctionIndex, Attribute::NoReturn);
}

/// Determine if the call should not perform indirect branch tracking.
bool doesNoCfCheck() const { return hasFnAttr(Attribute::NoCfCheck); }

/// Determine if the call cannot unwind.
bool doesNotThrow() const { return hasFnAttr(Attribute::NoUnwind); }
void setDoesNotThrow() {
  addAttribute(AttributeList::FunctionIndex, Attribute::NoUnwind);
}

/// Determine if the invoke cannot be duplicated.
bool cannotDuplicate() const { return hasFnAttr(Attribute::NoDuplicate); }
void setCannotDuplicate() {
  addAttribute(AttributeList::FunctionIndex, Attribute::NoDuplicate);
}

/// Determine if the call cannot be tail merged.
bool cannotMerge() const { return hasFnAttr(Attribute::NoMerge); }
void setCannotMerge() {
  addAttribute(AttributeList::FunctionIndex, Attribute::NoMerge);
}

/// Determine if the invoke is convergent
bool isConvergent() const { return hasFnAttr(Attribute::Convergent); }
22
←
Calling 'CallBase::hasFnAttr'→
35
←
Returning from 'CallBase::hasFnAttr'→
36
←
Returning value, which participates in a condition later→
void setConvergent() {
  addAttribute(AttributeList::FunctionIndex, Attribute::Convergent);
}
void setNotConvergent() {
  removeAttribute(AttributeList::FunctionIndex, Attribute::Convergent);
}

/// Determine if the call returns a structure through first
/// pointer argument.
bool hasStructRetAttr() const {
  if (getNumArgOperands() == 0)
    return false;

  // Be friendly and also check the callee.
  return paramHasAttr(0, Attribute::StructRet);
}

/// Determine if any call argument is an aggregate passed by value.
bool hasByValArgument() const {
  return Attrs.hasAttrSomewhere(Attribute::ByVal);
}

///@{
// End of attribute API.

/// \name Operand Bundle API
///
/// This group of methods provides the API to access and manipulate operand
/// bundles on this call.
/// @{

/// Return the number of operand bundles associated with this User.
unsigned getNumOperandBundles() const {
  return std::distance(bundle_op_info_begin(), bundle_op_info_end());
}

/// Return true if this User has any operand bundles.
bool hasOperandBundles() const { return getNumOperandBundles() != 0; }

/// Return the index of the first bundle operand in the Use array.
unsigned getBundleOperandsStartIndex() const {
  assert(hasOperandBundles() && "Don't call otherwise!")((hasOperandBundles() && "Don't call otherwise!") ? static_cast
<void> (0) : __assert_fail ("hasOperandBundles() && \"Don't call otherwise!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/InstrTypes.h"
, 1907, __PRETTY_FUNCTION__));
  return bundle_op_info_begin()->Begin;
}

/// Return the index of the last bundle operand in the Use array.
unsigned getBundleOperandsEndIndex() const {
  assert(hasOperandBundles() && "Don't call otherwise!")((hasOperandBundles() && "Don't call otherwise!") ? static_cast
<void> (0) : __assert_fail ("hasOperandBundles() && \"Don't call otherwise!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/InstrTypes.h"
, 1913, __PRETTY_FUNCTION__));
  return bundle_op_info_end()[-1].End;
}

/// Return true if the operand at index \p Idx is a bundle operand.
bool isBundleOperand(unsigned Idx) const {
  return hasOperandBundles() && Idx >= getBundleOperandsStartIndex() &&
         Idx < getBundleOperandsEndIndex();
}

/// Returns true if the use is a bundle operand.
bool isBundleOperand(const Use *U) const {
  assert(this == U->getUser() &&((this == U->getUser() && "Only valid to query with a use of this instruction!"
) ? static_cast<void> (0) : __assert_fail ("this == U->getUser() && \"Only valid to query with a use of this instruction!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/InstrTypes.h"
, 1926, __PRETTY_FUNCTION__))
         "Only valid to query with a use of this instruction!")((this == U->getUser() && "Only valid to query with a use of this instruction!"
) ? static_cast<void> (0) : __assert_fail ("this == U->getUser() && \"Only valid to query with a use of this instruction!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/InstrTypes.h"
, 1926, __PRETTY_FUNCTION__));
  return hasOperandBundles() && isBundleOperand(U - op_begin());
}
bool isBundleOperand(Value::const_user_iterator UI) const {
  return isBundleOperand(&UI.getUse());
}

/// Return the total number operands (not operand bundles) used by
/// every operand bundle in this OperandBundleUser.
unsigned getNumTotalBundleOperands() const {
  if (!hasOperandBundles())
    return 0;

  unsigned Begin = getBundleOperandsStartIndex();
  unsigned End = getBundleOperandsEndIndex();

  assert(Begin <= End && "Should be!")((Begin <= End && "Should be!") ? static_cast<void
> (0) : __assert_fail ("Begin <= End && \"Should be!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/InstrTypes.h"
, 1942, __PRETTY_FUNCTION__));
  return End - Begin;
}

/// Return the operand bundle at a specific index.
OperandBundleUse getOperandBundleAt(unsigned Index) const {
  assert(Index < getNumOperandBundles() && "Index out of bounds!")((Index < getNumOperandBundles() && "Index out of bounds!"
) ? static_cast<void> (0) : __assert_fail ("Index < getNumOperandBundles() && \"Index out of bounds!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/InstrTypes.h"
, 1948, __PRETTY_FUNCTION__));
  return operandBundleFromBundleOpInfo(*(bundle_op_info_begin() + Index));
}

/// Return the number of operand bundles with the tag Name attached to
/// this instruction.
unsigned countOperandBundlesOfType(StringRef Name) const {
  unsigned Count = 0;
  for (unsigned i = 0, e = getNumOperandBundles(); i != e; ++i)
    if (getOperandBundleAt(i).getTagName() == Name)
      Count++;

  return Count;
}

/// Return the number of operand bundles with the tag ID attached to
/// this instruction.
unsigned countOperandBundlesOfType(uint32_t ID) const {
  unsigned Count = 0;
  for (unsigned i = 0, e = getNumOperandBundles(); i != e; ++i)
    if (getOperandBundleAt(i).getTagID() == ID)
      Count++;

  return Count;
}

/// Return an operand bundle by name, if present.
///
/// It is an error to call this for operand bundle types that may have
/// multiple instances of them on the same instruction.
Optional<OperandBundleUse> getOperandBundle(StringRef Name) const {
  assert(countOperandBundlesOfType(Name) < 2 && "Precondition violated!")((countOperandBundlesOfType(Name) < 2 && "Precondition violated!"
) ? static_cast<void> (0) : __assert_fail ("countOperandBundlesOfType(Name) < 2 && \"Precondition violated!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/InstrTypes.h"
, 1979, __PRETTY_FUNCTION__));

  for (unsigned i = 0, e = getNumOperandBundles(); i != e; ++i) {
    OperandBundleUse U = getOperandBundleAt(i);
    if (U.getTagName() == Name)
      return U;
  }

  return None;
}

/// Return an operand bundle by tag ID, if present.
///
/// It is an error to call this for operand bundle types that may have
/// multiple instances of them on the same instruction.
Optional<OperandBundleUse> getOperandBundle(uint32_t ID) const {
  assert(countOperandBundlesOfType(ID) < 2 && "Precondition violated!")((countOperandBundlesOfType(ID) < 2 && "Precondition violated!"
) ? static_cast<void> (0) : __assert_fail ("countOperandBundlesOfType(ID) < 2 && \"Precondition violated!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/InstrTypes.h"
, 1995, __PRETTY_FUNCTION__));

  for (unsigned i = 0, e = getNumOperandBundles(); i != e; ++i) {
    OperandBundleUse U = getOperandBundleAt(i);
    if (U.getTagID() == ID)
      return U;
  }

  return None;
}

/// Return the list of operand bundles attached to this instruction as
/// a vector of OperandBundleDefs.
///
/// This function copies the OperandBundeUse instances associated with this
/// OperandBundleUser to a vector of OperandBundleDefs.  Note:
/// OperandBundeUses and OperandBundleDefs are non-trivially *different*
/// representations of operand bundles (see documentation above).
void getOperandBundlesAsDefs(SmallVectorImpl<OperandBundleDef> &Defs) const;

/// Return the operand bundle for the operand at index OpIdx.
///
/// It is an error to call this with an OpIdx that does not correspond to an
/// bundle operand.
OperandBundleUse getOperandBundleForOperand(unsigned OpIdx) const {
  return operandBundleFromBundleOpInfo(getBundleOpInfoForOperand(OpIdx));
}

/// Return true if this operand bundle user has operand bundles that
/// may read from the heap.
bool hasReadingOperandBundles() const;

/// Return true if this operand bundle user has operand bundles that
/// may write to the heap.
bool hasClobberingOperandBundles() const {
  for (auto &BOI : bundle_op_infos()) {
    if (BOI.Tag->second == LLVMContext::OB_deopt ||
        BOI.Tag->second == LLVMContext::OB_funclet)
      continue;

    // This instruction has an operand bundle that is not known to us.
    // Assume the worst.
    return true;
  }

  return false;
}

/// Return true if the bundle operand at index \p OpIdx has the
/// attribute \p A.
bool bundleOperandHasAttr(unsigned OpIdx,  Attribute::AttrKind A) const {
  auto &BOI = getBundleOpInfoForOperand(OpIdx);
  auto OBU = operandBundleFromBundleOpInfo(BOI);
  return OBU.operandHasAttr(OpIdx - BOI.Begin, A);
}

/// Return true if \p Other has the same sequence of operand bundle
/// tags with the same number of operands on each one of them as this
/// OperandBundleUser.
bool hasIdenticalOperandBundleSchema(const CallBase &Other) const {
  if (getNumOperandBundles() != Other.getNumOperandBundles())
    return false;

  return std::equal(bundle_op_info_begin(), bundle_op_info_end(),
                    Other.bundle_op_info_begin());
}

/// Return true if this operand bundle user contains operand bundles
/// with tags other than those specified in \p IDs.
bool hasOperandBundlesOtherThan(ArrayRef<uint32_t> IDs) const {
  for (unsigned i = 0, e = getNumOperandBundles(); i != e; ++i) {
    uint32_t ID = getOperandBundleAt(i).getTagID();
    if (!is_contained(IDs, ID))
      return true;
  }
  return false;
}

/// Is the function attribute S disallowed by some operand bundle on
/// this operand bundle user?
bool isFnAttrDisallowedByOpBundle(StringRef S) const {
  // Operand bundles only possibly disallow readnone, readonly and argmemonly
  // attributes.  All String attributes are fine.
  return false;
}

/// Is the function attribute A disallowed by some operand bundle on
/// this operand bundle user?
bool isFnAttrDisallowedByOpBundle(Attribute::AttrKind A) const {
  switch (A) {
28
←
Control jumps to the 'default' case at line 2085→
  default:
    return false;
29
←
Returning zero, which participates in a condition later→

  case Attribute::InaccessibleMemOrArgMemOnly:
    return hasReadingOperandBundles();

  case Attribute::InaccessibleMemOnly:
    return hasReadingOperandBundles();

  case Attribute::ArgMemOnly:
    return hasReadingOperandBundles();

  case Attribute::ReadNone:
    return hasReadingOperandBundles();

  case Attribute::ReadOnly:
    return hasClobberingOperandBundles();
  }

  llvm_unreachable("switch has a default case!")::llvm::llvm_unreachable_internal("switch has a default case!"
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/InstrTypes.h"
, 2104);
}

/// Used to keep track of an operand bundle.  See the main comment on
/// OperandBundleUser above.
struct BundleOpInfo {
  /// The operand bundle tag, interned by
  /// LLVMContextImpl::getOrInsertBundleTag.
  StringMapEntry<uint32_t> *Tag;

  /// The index in the Use& vector where operands for this operand
  /// bundle starts.
  uint32_t Begin;

  /// The index in the Use& vector where operands for this operand
  /// bundle ends.
  uint32_t End;

  bool operator==(const BundleOpInfo &Other) const {
    return Tag == Other.Tag && Begin == Other.Begin && End == Other.End;
  }
};

/// Simple helper function to map a BundleOpInfo to an
/// OperandBundleUse.
OperandBundleUse
operandBundleFromBundleOpInfo(const BundleOpInfo &BOI) const {
  auto begin = op_begin();
  ArrayRef<Use> Inputs(begin + BOI.Begin, begin + BOI.End);
  return OperandBundleUse(BOI.Tag, Inputs);
}

using bundle_op_iterator = BundleOpInfo *;
using const_bundle_op_iterator = const BundleOpInfo *;

/// Return the start of the list of BundleOpInfo instances associated
/// with this OperandBundleUser.
///
/// OperandBundleUser uses the descriptor area co-allocated with the host User
/// to store some meta information about which operands are "normal" operands,
/// and which ones belong to some operand bundle.
///
/// The layout of an operand bundle user is
///
///          +-----------uint32_t End-------------------------------------+
///          |                                                            |
///          |  +--------uint32_t Begin--------------------+              |
///          |  |                                          |              |
///          ^  ^                                          v              v
///  |------|------|----|----|----|----|----|---------|----|---------|----|-----
///  | BOI0 | BOI1 | .. | DU | U0 | U1 | .. | BOI0_U0 | .. | BOI1_U0 | .. | Un
///  |------|------|----|----|----|----|----|---------|----|---------|----|-----
///   v  v                                  ^              ^
///   |  |                                  |              |
///   |  +--------uint32_t Begin------------+              |
///   |                                                    |
///   +-----------uint32_t End-----------------------------+
///
///
/// BOI0, BOI1 ... are descriptions of operand bundles in this User's use
/// list. These descriptions are installed and managed by this class, and
/// they're all instances of OperandBundleUser<T>::BundleOpInfo.
///
/// DU is an additional descriptor installed by User's 'operator new' to keep
/// track of the 'BOI0 ... BOIN' co-allocation.  OperandBundleUser does not
/// access or modify DU in any way, it's an implementation detail private to
/// User.
///
/// The regular Use& vector for the User starts at U0.  The operand bundle
/// uses are part of the Use& vector, just like normal uses.  In the diagram
/// above, the operand bundle uses start at BOI0_U0.  Each instance of
/// BundleOpInfo has information about a contiguous set of uses constituting
/// an operand bundle, and the total set of operand bundle uses themselves
/// form a contiguous set of uses (i.e. there are no gaps between uses
/// corresponding to individual operand bundles).
///
/// This class does not know the location of the set of operand bundle uses
/// within the use list -- that is decided by the User using this class via
/// the BeginIdx argument in populateBundleOperandInfos.
///
/// Currently operand bundle users with hung-off operands are not supported.
bundle_op_iterator bundle_op_info_begin() {
  if (!hasDescriptor())
    return nullptr;

  uint8_t *BytesBegin = getDescriptor().begin();
  return reinterpret_cast<bundle_op_iterator>(BytesBegin);
}

/// Return the start of the list of BundleOpInfo instances associated
/// with this OperandBundleUser.
const_bundle_op_iterator bundle_op_info_begin() const {
  auto *NonConstThis = const_cast<CallBase *>(this);
  return NonConstThis->bundle_op_info_begin();
}

/// Return the end of the list of BundleOpInfo instances associated
/// with this OperandBundleUser.
bundle_op_iterator bundle_op_info_end() {
  if (!hasDescriptor())
    return nullptr;

  uint8_t *BytesEnd = getDescriptor().end();
  return reinterpret_cast<bundle_op_iterator>(BytesEnd);
}

/// Return the end of the list of BundleOpInfo instances associated
/// with this OperandBundleUser.
const_bundle_op_iterator bundle_op_info_end() const {
  auto *NonConstThis = const_cast<CallBase *>(this);
  return NonConstThis->bundle_op_info_end();
}

/// Return the range [\p bundle_op_info_begin, \p bundle_op_info_end).
iterator_range<bundle_op_iterator> bundle_op_infos() {
  return make_range(bundle_op_info_begin(), bundle_op_info_end());
}

/// Return the range [\p bundle_op_info_begin, \p bundle_op_info_end).
iterator_range<const_bundle_op_iterator> bundle_op_infos() const {
  return make_range(bundle_op_info_begin(), bundle_op_info_end());
}

/// Populate the BundleOpInfo instances and the Use& vector from \p
/// Bundles.  Return the op_iterator pointing to the Use& one past the last
/// last bundle operand use.
///
/// Each \p OperandBundleDef instance is tracked by a OperandBundleInfo
/// instance allocated in this User's descriptor.
op_iterator populateBundleOperandInfos(ArrayRef<OperandBundleDef> Bundles,
                                       const unsigned BeginIndex);

2236public:
/// Return the BundleOpInfo for the operand at index OpIdx.
///
/// It is an error to call this with an OpIdx that does not correspond to an
/// bundle operand.
BundleOpInfo &getBundleOpInfoForOperand(unsigned OpIdx);
const BundleOpInfo &getBundleOpInfoForOperand(unsigned OpIdx) const {
  return const_cast<CallBase *>(this)->getBundleOpInfoForOperand(OpIdx);
}

2246protected:
/// Return the total number of values used in \p Bundles.
static unsigned CountBundleInputs(ArrayRef<OperandBundleDef> Bundles) {
  unsigned Total = 0;
  for (auto &B : Bundles)
    Total += B.input_size();
  return Total;
}

/// @}
// End of operand bundle API.

2258private:
bool hasFnAttrOnCalledFunction(Attribute::AttrKind Kind) const;
bool hasFnAttrOnCalledFunction(StringRef Kind) const;

template <typename AttrKind> bool hasFnAttrImpl(AttrKind Kind) const {
  if (Attrs.hasFnAttribute(Kind))
25
←
Assuming the condition is false→
26
←
Taking false branch→
    return true;

  // Operand bundles override attributes on the called function, but don't
  // override attributes directly present on the call instruction.
  if (isFnAttrDisallowedByOpBundle(Kind))
27
←
Calling 'CallBase::isFnAttrDisallowedByOpBundle'→
30
←
Returning from 'CallBase::isFnAttrDisallowedByOpBundle'→
31
←
Taking false branch→
    return false;

  return hasFnAttrOnCalledFunction(Kind);
32
←
Returning value, which participates in a condition later→
}

/// Determine whether the return value has the given attribute. Supports
/// Attribute::AttrKind and StringRef as \p AttrKind types.
template <typename AttrKind> bool hasRetAttrImpl(AttrKind Kind) const {
  if (Attrs.hasAttribute(AttributeList::ReturnIndex, Kind))
    return true;

  // Look at the callee, if available.
  if (const Function *F = getCalledFunction())
    return F->getAttributes().hasAttribute(AttributeList::ReturnIndex, Kind);
  return false;
}
2285};

2287template <>
2288struct OperandTraits<CallBase> : public VariadicOperandTraits<CallBase, 1> {};

2290DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CallBase, Value)CallBase::op_iterator CallBase::op_begin() { return OperandTraits
<CallBase>::op_begin(this); } CallBase::const_op_iterator
 CallBase::op_begin() const { return OperandTraits<CallBase
>::op_begin(const_cast<CallBase*>(this)); } CallBase
::op_iterator CallBase::op_end() { return OperandTraits<CallBase
>::op_end(this); } CallBase::const_op_iterator CallBase::op_end
() const { return OperandTraits<CallBase>::op_end(const_cast
<CallBase*>(this)); } Value *CallBase::getOperand(unsigned
 i_nocapture) const { ((i_nocapture < OperandTraits<CallBase
>::operands(this) && "getOperand() out of range!")
 ? static_cast<void> (0) : __assert_fail ("i_nocapture < OperandTraits<CallBase>::operands(this) && \"getOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/InstrTypes.h"
, 2290, __PRETTY_FUNCTION__)); return cast_or_null<Value>
( OperandTraits<CallBase>::op_begin(const_cast<CallBase
*>(this))[i_nocapture].get()); } void CallBase::setOperand
(unsigned i_nocapture, Value *Val_nocapture) { ((i_nocapture <
 OperandTraits<CallBase>::operands(this) && "setOperand() out of range!"
) ? static_cast<void> (0) : __assert_fail ("i_nocapture < OperandTraits<CallBase>::operands(this) && \"setOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/InstrTypes.h"
, 2290, __PRETTY_FUNCTION__)); OperandTraits<CallBase>::
op_begin(this)[i_nocapture] = Val_nocapture; } unsigned CallBase
::getNumOperands() const { return OperandTraits<CallBase>
::operands(this); } template <int Idx_nocapture> Use &
CallBase::Op() { return this->OpFrom<Idx_nocapture>(
this); } template <int Idx_nocapture> const Use &CallBase
::Op() const { return this->OpFrom<Idx_nocapture>(this
); }

2292//===----------------------------------------------------------------------===//
2293//                           FuncletPadInst Class
2294//===----------------------------------------------------------------------===//
2295class FuncletPadInst : public Instruction {
2296private:
FuncletPadInst(const FuncletPadInst &CPI);

explicit FuncletPadInst(Instruction::FuncletPadOps Op, Value *ParentPad,
                        ArrayRef<Value *> Args, unsigned Values,
                        const Twine &NameStr, Instruction *InsertBefore);
explicit FuncletPadInst(Instruction::FuncletPadOps Op, Value *ParentPad,
                        ArrayRef<Value *> Args, unsigned Values,
                        const Twine &NameStr, BasicBlock *InsertAtEnd);

void init(Value *ParentPad, ArrayRef<Value *> Args, const Twine &NameStr);

2308protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;
friend class CatchPadInst;
friend class CleanupPadInst;

FuncletPadInst *cloneImpl() const;

2316public:
/// Provide fast operand accessors
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)public: inline Value *getOperand(unsigned) const; inline void
 setOperand(unsigned, Value*); inline op_iterator op_begin();
 inline const_op_iterator op_begin() const; inline op_iterator
 op_end(); inline const_op_iterator op_end() const; protected
: template <int> inline Use &Op(); template <int
> inline const Use &Op() const; public: inline unsigned
 getNumOperands() const;

/// getNumArgOperands - Return the number of funcletpad arguments.
///
unsigned getNumArgOperands() const { return getNumOperands() - 1; }

/// Convenience accessors

/// Return the outer EH-pad this funclet is nested within.
///
/// Note: This returns the associated CatchSwitchInst if this FuncletPadInst
/// is a CatchPadInst.
Value *getParentPad() const { return Op<-1>(); }
void setParentPad(Value *ParentPad) {
  assert(ParentPad)((ParentPad) ? static_cast<void> (0) : __assert_fail ("ParentPad"
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/InstrTypes.h"
, 2332, __PRETTY_FUNCTION__));
  Op<-1>() = ParentPad;
}

/// getArgOperand/setArgOperand - Return/set the i-th funcletpad argument.
///
Value *getArgOperand(unsigned i) const { return getOperand(i); }
void setArgOperand(unsigned i, Value *v) { setOperand(i, v); }

/// arg_operands - iteration adapter for range-for loops.
op_range arg_operands() { return op_range(op_begin(), op_end() - 1); }

/// arg_operands - iteration adapter for range-for loops.
const_op_range arg_operands() const {
  return const_op_range(op_begin(), op_end() - 1);
}

// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) { return I->isFuncletPad(); }
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}
2354};

2356template <>
2357struct OperandTraits<FuncletPadInst>
  : public VariadicOperandTraits<FuncletPadInst, /*MINARITY=*/1> {};

2360DEFINE_TRANSPARENT_OPERAND_ACCESSORS(FuncletPadInst, Value)FuncletPadInst::op_iterator FuncletPadInst::op_begin() { return
 OperandTraits<FuncletPadInst>::op_begin(this); } FuncletPadInst
::const_op_iterator FuncletPadInst::op_begin() const { return
 OperandTraits<FuncletPadInst>::op_begin(const_cast<
FuncletPadInst*>(this)); } FuncletPadInst::op_iterator FuncletPadInst
::op_end() { return OperandTraits<FuncletPadInst>::op_end
(this); } FuncletPadInst::const_op_iterator FuncletPadInst::op_end
() const { return OperandTraits<FuncletPadInst>::op_end
(const_cast<FuncletPadInst*>(this)); } Value *FuncletPadInst
::getOperand(unsigned i_nocapture) const { ((i_nocapture <
 OperandTraits<FuncletPadInst>::operands(this) &&
 "getOperand() out of range!") ? static_cast<void> (0) :
 __assert_fail ("i_nocapture < OperandTraits<FuncletPadInst>::operands(this) && \"getOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/InstrTypes.h"
, 2360, __PRETTY_FUNCTION__)); return cast_or_null<Value>
( OperandTraits<FuncletPadInst>::op_begin(const_cast<
FuncletPadInst*>(this))[i_nocapture].get()); } void FuncletPadInst
::setOperand(unsigned i_nocapture, Value *Val_nocapture) { ((
i_nocapture < OperandTraits<FuncletPadInst>::operands
(this) && "setOperand() out of range!") ? static_cast
<void> (0) : __assert_fail ("i_nocapture < OperandTraits<FuncletPadInst>::operands(this) && \"setOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/InstrTypes.h"
, 2360, __PRETTY_FUNCTION__)); OperandTraits<FuncletPadInst
>::op_begin(this)[i_nocapture] = Val_nocapture; } unsigned
 FuncletPadInst::getNumOperands() const { return OperandTraits
<FuncletPadInst>::operands(this); } template <int Idx_nocapture
> Use &FuncletPadInst::Op() { return this->OpFrom<
Idx_nocapture>(this); } template <int Idx_nocapture>
 const Use &FuncletPadInst::Op() const { return this->
OpFrom<Idx_nocapture>(this); }

2362} // end namespace llvm

2364#endif // LLVM_IR_INSTRTYPES_H

←

/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/PatternMatch.h

→

1//===- PatternMatch.h - Match on the LLVM IR --------------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file provides a simple and efficient mechanism for performing general
10// tree-based pattern matches on the LLVM IR. The power of these routines is
11// that it allows you to write concise patterns that are expressive and easy to
12// understand. The other major advantage of this is that it allows you to
13// trivially capture/bind elements in the pattern to variables. For example,
14// you can do something like this:
15//
16//  Value *Exp = ...
17//  Value *X, *Y;  ConstantInt *C1, *C2;      // (X & C1) | (Y & C2)
18//  if (match(Exp, m_Or(m_And(m_Value(X), m_ConstantInt(C1)),
19//                      m_And(m_Value(Y), m_ConstantInt(C2))))) {
20//    ... Pattern is matched and variables are bound ...
21//  }
22//
23// This is primarily useful to things like the instruction combiner, but can
24// also be useful for static analysis tools or code generators.
25//
26//===----------------------------------------------------------------------===//
27 
28#ifndef LLVM_IR_PATTERNMATCH_H
29#define LLVM_IR_PATTERNMATCH_H
30 
31#include "llvm/ADT/APFloat.h"
32#include "llvm/ADT/APInt.h"
33#include "llvm/IR/Constant.h"
34#include "llvm/IR/Constants.h"
35#include "llvm/IR/DataLayout.h"
36#include "llvm/IR/InstrTypes.h"
37#include "llvm/IR/Instruction.h"
38#include "llvm/IR/Instructions.h"
39#include "llvm/IR/IntrinsicInst.h"
40#include "llvm/IR/Intrinsics.h"
41#include "llvm/IR/Operator.h"
42#include "llvm/IR/Value.h"
43#include "llvm/Support/Casting.h"
44#include <cstdint>
45 
46namespace llvm {
47namespace PatternMatch {
48 
49template <typename Val, typename Pattern> bool match(Val *V, const Pattern &P) {
50  return const_cast<Pattern &>(P).match(V);
41
←
Calling 'IntrinsicID_match::match'→
45
←
Returning from 'IntrinsicID_match::match'→
46
←
Returning zero, which participates in a condition later→
50
←
Calling 'IntrinsicID_match::match'→
54
←
Returning from 'IntrinsicID_match::match'→
55
←
Returning zero, which participates in a condition later→
51}
52 
53template <typename Pattern> bool match(ArrayRef<int> Mask, const Pattern &P) {
54  return const_cast<Pattern &>(P).match(Mask);
55}
56 
57template <typename SubPattern_t> struct OneUse_match {
58  SubPattern_t SubPattern;
59 
60  OneUse_match(const SubPattern_t &SP) : SubPattern(SP) {}
61 
62  template <typename OpTy> bool match(OpTy *V) {
63    return V->hasOneUse() && SubPattern.match(V);
64  }
65};
66 
67template <typename T> inline OneUse_match<T> m_OneUse(const T &SubPattern) {
68  return SubPattern;
69}
70 
71template <typename Class> struct class_match {
72  template <typename ITy> bool match(ITy *V) { return isa<Class>(V); }
73};
74 
75/// Match an arbitrary value and ignore it.
76inline class_match<Value> m_Value() { return class_match<Value>(); }
77 
78/// Match an arbitrary unary operation and ignore it.
79inline class_match<UnaryOperator> m_UnOp() {
80  return class_match<UnaryOperator>();
81}
82 
83/// Match an arbitrary binary operation and ignore it.
84inline class_match<BinaryOperator> m_BinOp() {
85  return class_match<BinaryOperator>();
86}
87 
88/// Matches any compare instruction and ignore it.
89inline class_match<CmpInst> m_Cmp() { return class_match<CmpInst>(); }
90 
91/// Match an arbitrary undef constant.
92inline class_match<UndefValue> m_Undef() { return class_match<UndefValue>(); }
93 
94/// Match an arbitrary poison constant.
95inline class_match<PoisonValue> m_Poison() { return class_match<PoisonValue>(); }
96 
97/// Match an arbitrary Constant and ignore it.
98inline class_match<Constant> m_Constant() { return class_match<Constant>(); }
99 
100/// Match an arbitrary ConstantInt and ignore it.
101inline class_match<ConstantInt> m_ConstantInt() {
102  return class_match<ConstantInt>();
103}
104 
105/// Match an arbitrary ConstantFP and ignore it.
106inline class_match<ConstantFP> m_ConstantFP() {
107  return class_match<ConstantFP>();
108}
109 
110/// Match an arbitrary ConstantExpr and ignore it.
111inline class_match<ConstantExpr> m_ConstantExpr() {
112  return class_match<ConstantExpr>();
113}
114 
115/// Match an arbitrary basic block value and ignore it.
116inline class_match<BasicBlock> m_BasicBlock() {
117  return class_match<BasicBlock>();
118}
119 
120/// Inverting matcher
121template <typename Ty> struct match_unless {
122  Ty M;
123 
124  match_unless(const Ty &Matcher) : M(Matcher) {}
125 
126  template <typename ITy> bool match(ITy *V) { return !M.match(V); }
127};
128 
129/// Match if the inner matcher does *NOT* match.
130template <typename Ty> inline match_unless<Ty> m_Unless(const Ty &M) {
131  return match_unless<Ty>(M);
132}
133 
134/// Matching combinators
135template <typename LTy, typename RTy> struct match_combine_or {
136  LTy L;
137  RTy R;
138 
139  match_combine_or(const LTy &Left, const RTy &Right) : L(Left), R(Right) {}
140 
141  template <typename ITy> bool match(ITy *V) {
142    if (L.match(V))
143      return true;
144    if (R.match(V))
145      return true;
146    return false;
147  }
148};
149 
150template <typename LTy, typename RTy> struct match_combine_and {
151  LTy L;
152  RTy R;
153 
154  match_combine_and(const LTy &Left, const RTy &Right) : L(Left), R(Right) {}
155 
156  template <typename ITy> bool match(ITy *V) {
157    if (L.match(V))
158      if (R.match(V))
159        return true;
160    return false;
161  }
162};
163 
164/// Combine two pattern matchers matching L || R
165template <typename LTy, typename RTy>
166inline match_combine_or<LTy, RTy> m_CombineOr(const LTy &L, const RTy &R) {
167  return match_combine_or<LTy, RTy>(L, R);
168}
169 
170/// Combine two pattern matchers matching L && R
171template <typename LTy, typename RTy>
172inline match_combine_and<LTy, RTy> m_CombineAnd(const LTy &L, const RTy &R) {
173  return match_combine_and<LTy, RTy>(L, R);
174}
175 
176struct apint_match {
177  const APInt *&Res;
178  bool AllowUndef;
179 
180  apint_match(const APInt *&Res, bool AllowUndef)
181    : Res(Res), AllowUndef(AllowUndef) {}
182 
183  template <typename ITy> bool match(ITy *V) {
184    if (auto *CI = dyn_cast<ConstantInt>(V)) {
185      Res = &CI->getValue();
186      return true;
187    }
188    if (V->getType()->isVectorTy())
189      if (const auto *C = dyn_cast<Constant>(V))
190        if (auto *CI = dyn_cast_or_null<ConstantInt>(
191                C->getSplatValue(AllowUndef))) {
192          Res = &CI->getValue();
193          return true;
194        }
195    return false;
196  }
197};
198// Either constexpr if or renaming ConstantFP::getValueAPF to
199// ConstantFP::getValue is needed to do it via single template
200// function for both apint/apfloat.
201struct apfloat_match {
202  const APFloat *&Res;
203  bool AllowUndef;
204 
205  apfloat_match(const APFloat *&Res, bool AllowUndef)
206      : Res(Res), AllowUndef(AllowUndef) {}
207 
208  template <typename ITy> bool match(ITy *V) {
209    if (auto *CI = dyn_cast<ConstantFP>(V)) {
210      Res = &CI->getValueAPF();
211      return true;
212    }
213    if (V->getType()->isVectorTy())
214      if (const auto *C = dyn_cast<Constant>(V))
215        if (auto *CI = dyn_cast_or_null<ConstantFP>(
216                C->getSplatValue(AllowUndef))) {
217          Res = &CI->getValueAPF();
218          return true;
219        }
220    return false;
221  }
222};
223 
224/// Match a ConstantInt or splatted ConstantVector, binding the
225/// specified pointer to the contained APInt.
226inline apint_match m_APInt(const APInt *&Res) {
227  // Forbid undefs by default to maintain previous behavior.
228  return apint_match(Res, /* AllowUndef */ false);
229}
230 
231/// Match APInt while allowing undefs in splat vector constants.
232inline apint_match m_APIntAllowUndef(const APInt *&Res) {
233  return apint_match(Res, /* AllowUndef */ true);
234}
235 
236/// Match APInt while forbidding undefs in splat vector constants.
237inline apint_match m_APIntForbidUndef(const APInt *&Res) {
238  return apint_match(Res, /* AllowUndef */ false);
239}
240 
241/// Match a ConstantFP or splatted ConstantVector, binding the
242/// specified pointer to the contained APFloat.
243inline apfloat_match m_APFloat(const APFloat *&Res) {
244  // Forbid undefs by default to maintain previous behavior.
245  return apfloat_match(Res, /* AllowUndef */ false);
246}
247 
248/// Match APFloat while allowing undefs in splat vector constants.
249inline apfloat_match m_APFloatAllowUndef(const APFloat *&Res) {
250  return apfloat_match(Res, /* AllowUndef */ true);
251}
252 
253/// Match APFloat while forbidding undefs in splat vector constants.
254inline apfloat_match m_APFloatForbidUndef(const APFloat *&Res) {
255  return apfloat_match(Res, /* AllowUndef */ false);
256}
257 
258template <int64_t Val> struct constantint_match {
259  template <typename ITy> bool match(ITy *V) {
260    if (const auto *CI = dyn_cast<ConstantInt>(V)) {
261      const APInt &CIV = CI->getValue();
262      if (Val >= 0)
263        return CIV == static_cast<uint64_t>(Val);
264      // If Val is negative, and CI is shorter than it, truncate to the right
265      // number of bits.  If it is larger, then we have to sign extend.  Just
266      // compare their negated values.
267      return -CIV == -Val;
268    }
269    return false;
270  }
271};
272 
273/// Match a ConstantInt with a specific value.
274template <int64_t Val> inline constantint_match<Val> m_ConstantInt() {
275  return constantint_match<Val>();
276}
277 
278/// This helper class is used to match constant scalars, vector splats,
279/// and fixed width vectors that satisfy a specified predicate.
280/// For fixed width vector constants, undefined elements are ignored.
281template <typename Predicate, typename ConstantVal>
282struct cstval_pred_ty : public Predicate {
283  template <typename ITy> bool match(ITy *V) {
284    if (const auto *CV = dyn_cast<ConstantVal>(V))
285      return this->isValue(CV->getValue());
286    if (const auto *VTy = dyn_cast<VectorType>(V->getType())) {
287      if (const auto *C = dyn_cast<Constant>(V)) {
288        if (const auto *CV = dyn_cast_or_null<ConstantVal>(C->getSplatValue()))
289          return this->isValue(CV->getValue());
290 
291        // Number of elements of a scalable vector unknown at compile time
292        auto *FVTy = dyn_cast<FixedVectorType>(VTy);
293        if (!FVTy)
294          return false;
295 
296        // Non-splat vector constant: check each element for a match.
297        unsigned NumElts = FVTy->getNumElements();
298        assert(NumElts != 0 && "Constant vector with no elements?")((NumElts != 0 && "Constant vector with no elements?"
) ? static_cast<void> (0) : __assert_fail ("NumElts != 0 && \"Constant vector with no elements?\""
, "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/PatternMatch.h"
, 298, __PRETTY_FUNCTION__));
299        bool HasNonUndefElements = false;
300        for (unsigned i = 0; i != NumElts; ++i) {
301          Constant *Elt = C->getAggregateElement(i);
302          if (!Elt)
303            return false;
304          if (isa<UndefValue>(Elt))
305            continue;
306          auto *CV = dyn_cast<ConstantVal>(Elt);
307          if (!CV || !this->isValue(CV->getValue()))
308            return false;
309          HasNonUndefElements = true;
310        }
311        return HasNonUndefElements;
312      }
313    }
314    return false;
315  }
316};
317 
318/// specialization of cstval_pred_ty for ConstantInt
319template <typename Predicate>
320using cst_pred_ty = cstval_pred_ty<Predicate, ConstantInt>;
321 
322/// specialization of cstval_pred_ty for ConstantFP
323template <typename Predicate>
324using cstfp_pred_ty = cstval_pred_ty<Predicate, ConstantFP>;
325 
326/// This helper class is used to match scalar and vector constants that
327/// satisfy a specified predicate, and bind them to an APInt.
328template <typename Predicate> struct api_pred_ty : public Predicate {
329  const APInt *&Res;
330 
331  api_pred_ty(const APInt *&R) : Res(R) {}
332 
333  template <typename ITy> bool match(ITy *V) {
334    if (const auto *CI = dyn_cast<ConstantInt>(V))
335      if (this->isValue(CI->getValue())) {
336        Res = &CI->getValue();
337        return true;
338      }
339    if (V->getType()->isVectorTy())
340      if (const auto *C = dyn_cast<Constant>(V))
341        if (auto *CI = dyn_cast_or_null<ConstantInt>(C->getSplatValue()))
342          if (this->isValue(CI->getValue())) {
343            Res = &CI->getValue();
344            return true;
345          }
346 
347    return false;
348  }
349};
350 
351/// This helper class is used to match scalar and vector constants that
352/// satisfy a specified predicate, and bind them to an APFloat.
353/// Undefs are allowed in splat vector constants.
354template <typename Predicate> struct apf_pred_ty : public Predicate {
355  const APFloat *&Res;
356 
357  apf_pred_ty(const APFloat *&R) : Res(R) {}
358 
359  template <typename ITy> bool match(ITy *V) {
360    if (const auto *CI = dyn_cast<ConstantFP>(V))
361      if (this->isValue(CI->getValue())) {
362        Res = &CI->getValue();
363        return true;
364      }
365    if (V->getType()->isVectorTy())
366      if (const auto *C = dyn_cast<Constant>(V))
367        if (auto *CI = dyn_cast_or_null<ConstantFP>(
368                C->getSplatValue(/* AllowUndef */ true)))
369          if (this->isValue(CI->getValue())) {
370            Res = &CI->getValue();
371            return true;
372          }
373 
374    return false;
375  }
376};
377 
378///////////////////////////////////////////////////////////////////////////////
379//
380// Encapsulate constant value queries for use in templated predicate matchers.
381// This allows checking if constants match using compound predicates and works
382// with vector constants, possibly with relaxed constraints. For example, ignore
383// undef values.
384//
385///////////////////////////////////////////////////////////////////////////////
386 
387struct is_any_apint {
388  bool isValue(const APInt &C) { return true; }
389};
390/// Match an integer or vector with any integral constant.
391/// For vectors, this includes constants with undefined elements.
392inline cst_pred_ty<is_any_apint> m_AnyIntegralConstant() {
393  return cst_pred_ty<is_any_apint>();
394}
395 
396struct is_all_ones {
397  bool isValue(const APInt &C) { return C.isAllOnesValue(); }
398};
399/// Match an integer or vector with all bits set.
400/// For vectors, this includes constants with undefined elements.
401inline cst_pred_ty<is_all_ones> m_AllOnes() {
402  return cst_pred_ty<is_all_ones>();
403}
404 
405struct is_maxsignedvalue {
406  bool isValue(const APInt &C) { return C.isMaxSignedValue(); }
407};
408/// Match an integer or vector with values having all bits except for the high
409/// bit set (0x7f...).
410/// For vectors, this includes constants with undefined elements.
411inline cst_pred_ty<is_maxsignedvalue> m_MaxSignedValue() {
412  return cst_pred_ty<is_maxsignedvalue>();
413}
414inline api_pred_ty<is_maxsignedvalue> m_MaxSignedValue(const APInt *&V) {
415  return V;
416}
417 
418struct is_negative {
419  bool isValue(const APInt &C) { return C.isNegative(); }
420};
421/// Match an integer or vector of negative values.
422/// For vectors, this includes constants with undefined elements.
423inline cst_pred_ty<is_negative> m_Negative() {
424  return cst_pred_ty<is_negative>();
425}
426inline api_pred_ty<is_negative> m_Negative(const APInt *&V) {
427  return V;
428}
429 
430struct is_nonnegative {
431  bool isValue(const APInt &C) { return C.isNonNegative(); }
432};
433/// Match an integer or vector of non-negative values.
434/// For vectors, this includes constants with undefined elements.
435inline cst_pred_ty<is_nonnegative> m_NonNegative() {
436  return cst_pred_ty<is_nonnegative>();
437}
438inline api_pred_ty<is_nonnegative> m_NonNegative(const APInt *&V) {
439  return V;
440}
441 
442struct is_strictlypositive {
443  bool isValue(const APInt &C) { return C.isStrictlyPositive(); }
444};
445/// Match an integer or vector of strictly positive values.
446/// For vectors, this includes constants with undefined elements.
447inline cst_pred_ty<is_strictlypositive> m_StrictlyPositive() {
448  return cst_pred_ty<is_strictlypositive>();
449}
450inline api_pred_ty<is_strictlypositive> m_StrictlyPositive(const APInt *&V) {
451  return V;
452}
453 
454struct is_nonpositive {
455  bool isValue(const APInt &C) { return C.isNonPositive(); }
456};
457/// Match an integer or vector of non-positive values.
458/// For vectors, this includes constants with undefined elements.
459inline cst_pred_ty<is_nonpositive> m_NonPositive() {
460  return cst_pred_ty<is_nonpositive>();
461}
462inline api_pred_ty<is_nonpositive> m_NonPositive(const APInt *&V) { return V; }
463 
464struct is_one {
465  bool isValue(const APInt &C) { return C.isOneValue(); }
466};
467/// Match an integer 1 or a vector with all elements equal to 1.
468/// For vectors, this includes constants with undefined elements.
469inline cst_pred_ty<is_one> m_One() {
470  return cst_pred_ty<is_one>();
471}
472 
473struct is_zero_int {
474  bool isValue(const APInt &C) { return C.isNullValue(); }
475};
476/// Match an integer 0 or a vector with all elements equal to 0.
477/// For vectors, this includes constants with undefined elements.
478inline cst_pred_ty<is_zero_int> m_ZeroInt() {
479  return cst_pred_ty<is_zero_int>();
480}
481 
482struct is_zero {
483  template <typename ITy> bool match(ITy *V) {
484    auto *C = dyn_cast<Constant>(V);
485    // FIXME: this should be able to do something for scalable vectors
486    return C && (C->isNullValue() || cst_pred_ty<is_zero_int>().match(C));
487  }
488};
489/// Match any null constant or a vector with all elements equal to 0.
490/// For vectors, this includes constants with undefined elements.
491inline is_zero m_Zero() {
492  return is_zero();
493}
494 
495struct is_power2 {
496  bool isValue(const APInt &C) { return C.isPowerOf2(); }
497};
498/// Match an integer or vector power-of-2.
499/// For vectors, this includes constants with undefined elements.
500inline cst_pred_ty<is_power2> m_Power2() {
501  return cst_pred_ty<is_power2>();
502}
503inline api_pred_ty<is_power2> m_Power2(const APInt *&V) {
504  return V;
505}
506 
507struct is_negated_power2 {
508  bool isValue(const APInt &C) { return (-C).isPowerOf2(); }
509};
510/// Match a integer or vector negated power-of-2.
511/// For vectors, this includes constants with undefined elements.
512inline cst_pred_ty<is_negated_power2> m_NegatedPower2() {
513  return cst_pred_ty<is_negated_power2>();
514}
515inline api_pred_ty<is_negated_power2> m_NegatedPower2(const APInt *&V) {
516  return V;
517}
518 
519struct is_power2_or_zero {
520  bool isValue(const APInt &C) { return !C || C.isPowerOf2(); }
521};
522/// Match an integer or vector of 0 or power-of-2 values.
523/// For vectors, this includes constants with undefined elements.
524inline cst_pred_ty<is_power2_or_zero> m_Power2OrZero() {
525  return cst_pred_ty<is_power2_or_zero>();
526}
527inline api_pred_ty<is_power2_or_zero> m_Power2OrZero(const APInt *&V) {
528  return V;
529}
530 
531struct is_sign_mask {
532  bool isValue(const APInt &C) { return C.isSignMask(); }
533};
534/// Match an integer or vector with only the sign bit(s) set.
535/// For vectors, this includes constants with undefined elements.
536inline cst_pred_ty<is_sign_mask> m_SignMask() {
537  return cst_pred_ty<is_sign_mask>();
538}
539 
540struct is_lowbit_mask {
541  bool isValue(const APInt &C) { return C.isMask(); }
542};
543/// Match an integer or vector with only the low bit(s) set.
544/// For vectors, this includes constants with undefined elements.
545inline cst_pred_ty<is_lowbit_mask> m_LowBitMask() {
546  return cst_pred_ty<is_lowbit_mask>();
547}
548 
549struct icmp_pred_with_threshold {
550  ICmpInst::Predicate Pred;
551  const APInt *Thr;
552  bool isValue(const APInt &C) {
553    switch (Pred) {
554    case ICmpInst::Predicate::ICMP_EQ:
555      return C.eq(*Thr);
556    case ICmpInst::Predicate::ICMP_NE:
557      return C.ne(*Thr);
558    case ICmpInst::Predicate::ICMP_UGT:
559      return C.ugt(*Thr);
560    case ICmpInst::Predicate::ICMP_UGE:
561      return C.uge(*Thr);
562    case ICmpInst::Predicate::ICMP_ULT:
563      return C.ult(*Thr);
564    case ICmpInst::Predicate::ICMP_ULE:
565      return C.ule(*Thr);
566    case ICmpInst::Predicate::ICMP_SGT:
567      return C.sgt(*Thr);
568    case ICmpInst::Predicate::ICMP_SGE:
569      return C.sge(*Thr);
570    case ICmpInst::Predicate::ICMP_SLT:
571      return C.slt(*Thr);
572    case ICmpInst::Predicate::ICMP_SLE:
573      return C.sle(*Thr);
574    default:
575      llvm_unreachable("Unhandled ICmp predicate")::llvm::llvm_unreachable_internal("Unhandled ICmp predicate",
 "/build/llvm-toolchain-snapshot-13~++20210405022414+5f57793c4fe4/llvm/include/llvm/IR/PatternMatch.h"
, 575);
576    }
577  }
578};
579/// Match an integer or vector with every element comparing 'pred' (eg/ne/...)
580/// to Threshold. For vectors, this includes constants with undefined elements.
581inline cst_pred_ty<icmp_pred_with_threshold>
582m_SpecificInt_ICMP(ICmpInst::Predicate Predicate, const APInt &Threshold) {
583  cst_pred_ty<icmp_pred_with_threshold> P;
584  P.Pred = Predicate;
585  P.Thr = &Threshold;
586  return P;
587}
588 
589struct is_nan {
590  bool isValue(const APFloat &C) { return C.isNaN(); }
591};
592/// Match an arbitrary NaN constant. This includes quiet and signalling nans.
593/// For vectors, this includes constants with undefined elements.
594inline cstfp_pred_ty<is_nan> m_NaN() {
595  return cstfp_pred_ty<is_nan>();
596}
597 
598struct is_nonnan {
599  bool isValue(const APFloat &C) { return !C.isNaN(); }
600};
601/// Match a non-NaN FP constant.
602/// For vectors, this includes constants with undefined elements.
603inline cstfp_pred_ty<is_nonnan> m_NonNaN() {
604  return cstfp_pred_ty<is_nonnan>();
605}
606 
607struct is_inf {
608  bool isValue(const APFloat &C) { return C.isInfinity(); }
609};
610/// Match a positive or negative infinity FP constant.
611/// For vectors, this includes constants with undefined elements.
612inline cstfp_pred_ty<is_inf> m_Inf() {
613  return cstfp_pred_ty<is_inf>();
614}
615 
616struct