/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/LICM.cpp

Bug Summary

File:	llvm/lib/Transforms/Scalar/LICM.cpp
Warning:	line 1142, column 33 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 -mframe-pointer=none -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -fno-split-dwarf-inlining -debugger-tuning=gdb -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-12/lib/clang/12.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/build-llvm/lib/Transforms/Scalar -I /build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar -I /build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/build-llvm/include -I /build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/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/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/llvm-12/lib/clang/12.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-12.0.0~++20201102111116+1ed2ca68191/build-llvm/lib/Transforms/Scalar -fdebug-prefix-map=/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191=. -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 -o /tmp/scan-build-2020-11-21-121427-42170-1 -x c++ /build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/LICM.cpp

/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/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// This pass uses alias analysis for two purposes:
16//
17//  1. Moving loop invariant loads and calls out of loops.  If we can determine
18//     that a load or call inside of a loop never aliases anything stored to,
19//     we can hoist it or sink it like any other instruction.
20//  2. Scalar Promotion of Memory - If there is a store instruction inside of
21//     the loop, we try to move the store to happen AFTER the loop instead of
22//     inside of the loop.  This can only happen if a few conditions are true:
23//       A. The pointer stored through is loop invariant
24//       B. There are no stores or loads in the loop which _may_ alias the
25//          pointer.  There are no calls in the loop which mod/ref the pointer.
26//     If these conditions are true, we can promote the loads and stores in the
27//     loop of the pointer to use a temporary alloca'd variable.  We then use
28//     the SSAUpdater to construct the appropriate SSA form for the value.
29//
30//===----------------------------------------------------------------------===//

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

84#define DEBUG_TYPE"licm" "licm"

86STATISTIC(NumCreatedBlocks, "Number of blocks created")static llvm::Statistic NumCreatedBlocks = {"licm", "NumCreatedBlocks"
, "Number of blocks created"};
87STATISTIC(NumClonedBranches, "Number of branches cloned")static llvm::Statistic NumClonedBranches = {"licm", "NumClonedBranches"
, "Number of branches cloned"};
88STATISTIC(NumSunk, "Number of instructions sunk out of loop")static llvm::Statistic NumSunk = {"licm", "NumSunk", "Number of instructions sunk out of loop"
};
89STATISTIC(NumHoisted, "Number of instructions hoisted out of loop")static llvm::Statistic NumHoisted = {"licm", "NumHoisted", "Number of instructions hoisted out of loop"
};
90STATISTIC(NumMovedLoads, "Number of load insts hoisted or sunk")static llvm::Statistic NumMovedLoads = {"licm", "NumMovedLoads"
, "Number of load insts hoisted or sunk"};
91STATISTIC(NumMovedCalls, "Number of call insts hoisted or sunk")static llvm::Statistic NumMovedCalls = {"licm", "NumMovedCalls"
, "Number of call insts hoisted or sunk"};
92STATISTIC(NumPromoted, "Number of memory locations promoted to registers")static llvm::Statistic NumPromoted = {"licm", "NumPromoted", "Number of memory locations promoted to registers"
};

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

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

103static 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"));

108static 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)"));

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

120// Experimental option to allow imprecision in LICM in pathological cases, in
121// exchange for faster compile. This is to be removed if MemorySSA starts to
122// address the same issue. This flag applies only when LICM uses MemorySSA
123// instead on AliasSetTracker. LICM calls MemorySSAWalker's
124// getClobberingMemoryAccess, up to the value of the Cap, getting perfect
125// accuracy. Afterwards, LICM will call into MemorySSA's getDefiningAccess,
126// which may not be precise, since optimizeUses is capped. The result is
127// correct, but we may not get as "far up" as possible to get which access is
128// clobbering the one queried.
129cl::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."));

134// Experimentally, memory promotion carries less importance than sinking and
135// hoisting. Limit when we do promotion when using MemorySSA, in order to save
136// compile time.
137cl::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."));

144static bool inSubLoop(BasicBlock *BB, Loop *CurLoop, LoopInfo *LI);
145static bool isNotUsedOrFreeInLoop(const Instruction &I, const Loop *CurLoop,
                                const LoopSafetyInfo *SafetyInfo,
                                TargetTransformInfo *TTI, bool &FreeInLoop);
148static void hoist(Instruction &I, const DominatorTree *DT, const Loop *CurLoop,
                BasicBlock *Dest, ICFLoopSafetyInfo *SafetyInfo,
                MemorySSAUpdater *MSSAU, ScalarEvolution *SE,
                OptimizationRemarkEmitter *ORE);
152static bool sink(Instruction &I, LoopInfo *LI, DominatorTree *DT,
               BlockFrequencyInfo *BFI, const Loop *CurLoop,
               ICFLoopSafetyInfo *SafetyInfo, MemorySSAUpdater *MSSAU,
               OptimizationRemarkEmitter *ORE);
156static bool isSafeToExecuteUnconditionally(Instruction &Inst,
                                         const DominatorTree *DT,
                                         const Loop *CurLoop,
                                         const LoopSafetyInfo *SafetyInfo,
                                         OptimizationRemarkEmitter *ORE,
                                         const Instruction *CtxI = nullptr);
162static bool pointerInvalidatedByLoop(MemoryLocation MemLoc,
                                   AliasSetTracker *CurAST, Loop *CurLoop,
                                   AAResults *AA);
165static bool pointerInvalidatedByLoopWithMSSA(MemorySSA *MSSA, MemoryUse *MU,
                                           Loop *CurLoop,
                                           SinkAndHoistLICMFlags &Flags);
168static Instruction *cloneInstructionInExitBlock(
  Instruction &I, BasicBlock &ExitBlock, PHINode &PN, const LoopInfo *LI,
  const LoopSafetyInfo *SafetyInfo, MemorySSAUpdater *MSSAU);

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

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

179namespace {
180struct 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) {}

191private:
unsigned LicmMssaOptCap;
unsigned LicmMssaNoAccForPromotionCap;

std::unique_ptr<AliasSetTracker>
collectAliasInfoForLoop(Loop *L, LoopInfo *LI, AAResults *AA);
std::unique_ptr<AliasSetTracker>
collectAliasInfoForLoopWithMSSA(Loop *L, AAResults *AA,
                                MemorySSAUpdater *MSSAU);
200};

202struct 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;

  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>();
}

256private:
LoopInvariantCodeMotion LICM;
258};
259} // namespace

261PreservedAnalyses 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;
281}

283char LegacyLICMPass::ID = 0;
284INITIALIZE_PASS_BEGIN(LegacyLICMPass, "licm", "Loop Invariant Code Motion",static void *initializeLegacyLICMPassPassOnce(PassRegistry &
Registry) {
                    false, false)static void *initializeLegacyLICMPassPassOnce(PassRegistry &
Registry) {
286INITIALIZE_PASS_DEPENDENCY(LoopPass)initializeLoopPassPass(Registry);
287INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass)initializeTargetLibraryInfoWrapperPassPass(Registry);
288INITIALIZE_PASS_DEPENDENCY(TargetTransformInfoWrapperPass)initializeTargetTransformInfoWrapperPassPass(Registry);
289INITIALIZE_PASS_DEPENDENCY(MemorySSAWrapperPass)initializeMemorySSAWrapperPassPass(Registry);
290INITIALIZE_PASS_DEPENDENCY(LazyBFIPass)initializeLazyBFIPassPass(Registry);
291INITIALIZE_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)); }

294Pass *llvm::createLICMPass() { return new LegacyLICMPass(); }
295Pass *llvm::createLICMPass(unsigned LicmMssaOptCap,
                         unsigned LicmMssaNoAccForPromotionCap) {
return new LegacyLICMPass(LicmMssaOptCap, LicmMssaNoAccForPromotionCap);
298}

300/// Hoist expressions out of the specified loop. Note, alias info for inner
301/// loop is not preserved so it is not a good idea to run LICM multiple
302/// times on one loop.
303bool 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-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/LICM.cpp"
, 309, __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;
bool NoOfMemAccTooLarge = false;
unsigned LicmMssaOptCounter = 0;

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

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

// 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.
SinkAndHoistLICMFlags Flags = {NoOfMemAccTooLarge, LicmMssaOptCounter,
                               LicmMssaOptCap, LicmMssaNoAccForPromotionCap,
                               /*IsSink=*/true};
if (L->hasDedicatedExits())
  Changed |=
      sinkRegion(DT->getNode(L->getHeader()), AA, LI, DT, BFI, TLI, TTI, L,
                 CurAST.get(), MSSAU.get(), &SafetyInfo, Flags, ORE);
Flags.IsSink = false;
if (Preheader)
  Changed |=
      hoistRegion(DT->getNode(L->getHeader()), AA, LI, DT, BFI, TLI, L,
                  CurAST.get(), MSSAU.get(), SE, &SafetyInfo, Flags, 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() &&
    !NoOfMemAccTooLarge) {
  // 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;

    // Build an AST using MSSA.
    if (!CurAST.get())
      CurAST = collectAliasInfoForLoopWithMSSA(L, AA, MSSAU.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-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/LICM.cpp"
, 424, __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-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/LICM.cpp"
, 424, __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-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/LICM.cpp"
, 424, __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);
    }

    // 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-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/LICM.cpp"
, 451, __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-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/LICM.cpp"
, 453, __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-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/LICM.cpp"
, 453, __PRETTY_FUNCTION__));

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

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

463/// Walk the specified region of the CFG (defined by all blocks dominated by
464/// the specified block, and that are in the current loop) in reverse depth
465/// first order w.r.t the DominatorTree.  This allows us to visit uses before
466/// definitions, allowing us to sink a loop body in one pass without iteration.
467///
468bool 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-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/LICM.cpp"
, 479, __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-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/LICM.cpp"
, 479, __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-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/LICM.cpp"
, 479, __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-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/LICM.cpp"
, 481, __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-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/LICM.cpp"
, 481, __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;
535}

537namespace {
538// This is a helper class for hoistRegion to make it able to hoist control flow
539// in order to be able to hoist phis. The way this works is that we initially
540// start hoisting to the loop preheader, and when we see a loop invariant branch
541// we make note of this. When we then come to hoist an instruction that's
542// conditional on such a branch we duplicate the branch and the relevant control
543// flow, then hoist the instruction into the block corresponding to its original
544// block in the duplicated control flow.
545class ControlFlowHoister {
546private:
// 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;

561public:
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 = std::find_if(F->begin(), F->end(), 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-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/LICM.cpp"
, 606, __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 = std::find_if(HoistableBranches.begin(), HoistableBranches.end(),
                         HasBBAsSuccessor);

  // If not involved in a pending branch, hoist to preheader
  BasicBlock *InitialPreheader = CurLoop->getLoopPreheader();
  if (It == HoistableBranches.end()) {
    LLVM_DEBUG(dbgs() << "LICM using " << InitialPreheader->getName()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("licm")) { dbgs() << "LICM using " << InitialPreheader
->getName() << " as hoist destination for " <<
 BB->getName() << "\n"; } } while (false)
                      << " as hoist destination for " << BB->getName()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("licm")) { dbgs() << "LICM using " << InitialPreheader
->getName() << " as hoist destination for " <<
 BB->getName() << "\n"; } } while (false)
                      << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("licm")) { dbgs() << "LICM using " << InitialPreheader
->getName() << " as hoist destination for " <<
 BB->getName() << "\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-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/LICM.cpp"
, 688, __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-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/LICM.cpp"
, 688, __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-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/LICM.cpp"
, 688, __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-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/LICM.cpp"
, 721, __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-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/LICM.cpp"
, 760, __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-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/LICM.cpp"
, 760, __PRETTY_FUNCTION__));
  return HoistDestinationMap[BB];
}
763};
764} // namespace

766// Hoisting/sinking instruction out of a loop isn't always beneficial. It's only
767// only worthwhile if the destination block is actually colder than current
768// block.
769static 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;
793}

795/// Walk the specified region of the CFG (defined by all blocks dominated by
796/// the specified block, and that are in the current loop) in depth first
797/// order w.r.t the DominatorTree.  This allows us to visit definitions before
798/// uses, allowing us to hoist a loop body in one pass without iteration.
799///
800bool 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-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/LICM.cpp"
, 810, __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-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/LICM.cpp"
, 810, __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-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/LICM.cpp"
, 810, __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-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/LICM.cpp"
, 812, __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-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/LICM.cpp"
, 812, __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, 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-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/LICM.cpp"
, 926, __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-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/LICM.cpp"
, 956, __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-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/LICM.cpp"
, 956, __PRETTY_FUNCTION__));
        HoistPoint = Dominator->getTerminator();
      }
      LLVM_DEBUG(dbgs() << "LICM rehoisting to "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("licm")) { dbgs() << "LICM rehoisting to " << HoistPoint
->getParent()->getName() << ": " << *I <<
 "\n"; } } while (false)
                        << HoistPoint->getParent()->getName()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("licm")) { dbgs() << "LICM rehoisting to " << HoistPoint
->getParent()->getName() << ": " << *I <<
 "\n"; } } while (false)
                        << ": " << *I << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("licm")) { dbgs() << "LICM rehoisting to " << HoistPoint
->getParent()->getName() << ": " << *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.
973#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-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/LICM.cpp"
, 976, __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-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/LICM.cpp"
, 976, __PRETTY_FUNCTION__));
  LI->verify(*DT);
}
979#endif

return Changed;
982}

984// Return true if LI is invariant within scope of the loop. LI is invariant if
985// CurLoop is dominated by an invariant.start representing the same memory
986// location and size as the memory location LI loads from, and also the
987// invariant.start has no uses.
988static 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())
27
←
Assuming the condition is true→
28
←
Taking true branch→
  return false;
29
←
Returning zero, which participates in a condition later→

// 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;
1050}

1052namespace {
1053/// Return true if-and-only-if we know how to (mechanically) both hoist and
1054/// sink a given instruction out of a loop.  Does not address legality
1055/// concerns such as aliasing or speculation safety.
1056bool isHoistableAndSinkableInst(Instruction &I) {
// Only these instructions are hoistable/sinkable.
return (isa<LoadInst>(I) || isa<StoreInst>(I) || isa<CallInst>(I) ||
2
←
Assuming 'I' is a 'LoadInst'→
3
←
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));
1065}
1066/// Return true if all of the alias sets within this AST are known not to
1067/// contain a Mod, or if MSSA knows thare are no MemoryDefs in the loop.
1068bool 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;
}
1083}

1085/// Return true if I is the only Instruction with a MemoryAccess in L.
1086bool 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;
1100}
1101}

1103bool llvm::canSinkOrHoistInst(Instruction &I, AAResults *AA, DominatorTree *DT,
                            Loop *CurLoop, AliasSetTracker *CurAST,
                            MemorySSAUpdater *MSSAU,
                            bool TargetExecutesOncePerLoop,
                            SinkAndHoistLICMFlags *Flags,
                            OptimizationRemarkEmitter *ORE) {
// If we don't understand the instruction, bail early.
if (!isHoistableAndSinkableInst(I))
1
Calling 'isHoistableAndSinkableInst'→
4
←
Returning from 'isHoistableAndSinkableInst'→
5
←
Taking false branch→
  return false;

MemorySSA *MSSA = MSSAU ? MSSAU->getMemorySSA() : nullptr;
6
←
Assuming 'MSSAU' is null→
7
←
'?' condition is false→
8
←
'MSSA' initialized to a null pointer value→
if (MSSA8.1
'MSSA' is null
1
'MSSA' is null
1
'MSSA' is null
)
9
←
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-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/LICM.cpp"
, 1115, __PRETTY_FUNCTION__));

// Loads have extra constraints we have to verify before we can hoist them.
if (LoadInst *LI10.1
'LI' is non-null
1
'LI' is non-null
1
'LI' is non-null
 = dyn_cast<LoadInst>(&I)) {
10
←
Assuming the object is a 'LoadInst'→
11
←
Taking true branch→
  if (!LI->isUnordered())
12
←
Calling 'LoadInst::isUnordered'→
17
←
Returning from 'LoadInst::isUnordered'→
18
←
Taking false branch→
    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)))
19
←
Assuming the condition is false→
20
←
Taking false branch→
    return true;
  if (LI->hasMetadata(LLVMContext::MD_invariant_load))
21
←
Calling 'Instruction::hasMetadata'→
23
←
Returning from 'Instruction::hasMetadata'→
24
←
Taking false branch→
    return true;

  if (LI->isAtomic() && !TargetExecutesOncePerLoop)
25
←
Assuming the condition is false→
    return false; // Don't risk duplicating unordered loads

  // This checks for an invariant.start dominating the load.
  if (isLoadInvariantInLoop(LI, DT, CurLoop))
26
←
Calling 'isLoadInvariantInLoop'→
30
←
Returning from 'isLoadInvariantInLoop'→
31
←
Taking false branch→
    return true;

  bool Invalidated;
  if (CurAST)
32
←
Assuming 'CurAST' is null→
33
←
Taking false branch→
    Invalidated = pointerInvalidatedByLoop(MemoryLocation::get(LI), CurAST,
                                           CurLoop, AA);
  else
    Invalidated = pointerInvalidatedByLoopWithMSSA(
        MSSA, cast<MemoryUse>(MSSA->getMemoryAccess(LI)), CurLoop, *Flags);
34
←
Called C++ object pointer is null
  // 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 *CI = dyn_cast<CallInst>(&I)) {
  // Don't sink or hoist dbg info; it's legal, but not useful.
  if (isa<DbgInfoIntrinsic>(I))
    return false;

  // Don't sink calls which can throw.
  if (CI->mayThrow())
    return false;

  using namespace PatternMatch;
  if (match(CI, m_Intrinsic<Intrinsic::assume>()))
    // Assumes don't actually alias anything or throw
    return true;

  if (match(CI, m_Intrinsic<Intrinsic::experimental_widenable_condition>()))
    // 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)
    return true;
  if (AAResults::onlyReadsMemory(Behavior)) {
    // 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)) {
      // TODO: expand to writeable arguments
      for (Value *Op : CI->arg_operands())
        if (Op->getType()->isPointerTy()) {
          bool Invalidated;
          if (CurAST)
            Invalidated = pointerInvalidatedByLoop(
                MemoryLocation(Op, LocationSize::unknown(), AAMDNodes()),
                CurAST, CurLoop, AA);
          else
            Invalidated = pointerInvalidatedByLoopWithMSSA(
                MSSA, cast<MemoryUse>(MSSA->getMemoryAccess(CI)), CurLoop,
                *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-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/LICM.cpp"
, 1214, __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-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/LICM.cpp"
, 1223, __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-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/LICM.cpp"
, 1246, __PRETTY_FUNCTION__));
    return true;
  } else { // MSSAU
    if (isOnlyMemoryAccess(SI, CurLoop, MSSAU))
      return true;
    // If there are more accesses than the Promotion cap, give up, we're not
    // walking a list that long.
    if (Flags->NoOfMemAccTooLarge)
      return false;
    // Check store only if there's still "quota" to check clobber.
    if (Flags->LicmMssaOptCounter >= Flags->LicmMssaOptCap)
      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->IsSink && !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-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/LICM.cpp"
, 1281, __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->LicmMssaOptCounter++;
    // 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-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/LICM.cpp"
, 1304, __PRETTY_FUNCTION__));

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

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

return true;
1322}

1324/// Return true if the instruction is free in the loop.
1325static 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;
1347}

1349/// Return true if the only users of this instruction are outside of
1350/// the loop. If this is true, we can sink the instruction to the exit
1351/// blocks of the loop.
1352///
1353/// We also return true if the instruction could be folded away in lowering.
1354/// (e.g.,  a GEP can be folded into a load as an addressing mode in the loop).
1355static 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;
1385}

1387static 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-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/LICM.cpp"
, 1409, __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. 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 (User::op_iterator OI = New->op_begin(), OE = New->op_end(); OI != OE;
     ++OI)
  if (Instruction *OInst = dyn_cast<Instruction>(*OI))
    if (Loop *OLoop = LI->getLoopFor(OInst->getParent()))
      if (!OLoop->contains(&PN)) {
        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));
        *OI = OpPN;
      }
return New;
1459}

1461static 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();
1469}

1471static 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);
1485}

1487static 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-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/LICM.cpp"
, 1493, __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-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/LICM.cpp"
, 1493, __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;
1503}

1505static 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;
1522}

1524static void splitPredecessorsOfLoopExit(PHINode *PN, DominatorTree *DT,
                                      LoopInfo *LI, const Loop *CurLoop,
                                      LoopSafetyInfo *SafetyInfo,
                                      MemorySSAUpdater *MSSAU) {
1528#ifndef NDEBUG
SmallVector<BasicBlock *, 32> ExitBlocks;
CurLoop->getUniqueExitBlocks(ExitBlocks);
SmallPtrSet<BasicBlock *, 32> ExitBlockSet(ExitBlocks.begin(),
                                           ExitBlocks.end());
1533#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-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/LICM.cpp"
, 1535, __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-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/LICM.cpp"
, 1574, __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-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/LICM.cpp"
, 1574, __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);
}
1589}

1591/// When an instruction is found to only be used outside of the loop, this
1592/// function moves it to the exit blocks and patches up SSA form as needed.
1593/// This method is guaranteed to remove the original instruction from its
1594/// position, and may either delete it or move it to outside of the loop.
1595///
1596static bool sink(Instruction &I, LoopInfo *LI, DominatorTree *DT,
               BlockFrequencyInfo *BFI, const Loop *CurLoop,
               ICFLoopSafetyInfo *SafetyInfo, MemorySSAUpdater *MSSAU,
               OptimizationRemarkEmitter *ORE) {
LLVM_DEBUG(dbgs() << "LICM sinking instruction: " << I << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("licm")) { dbgs() << "LICM sinking instruction: " <<
 I << "\n"; } } while (false);
ORE->emit([&]() {
  return OptimizationRemark(DEBUG_TYPE"licm", "InstSunk", &I)
         << "sinking " << ore::NV("Inst", &I);
});
bool Changed = false;
if (isa<LoadInst>(I))
  ++NumMovedLoads;
else if (isa<CallInst>(I))
  ++NumMovedCalls;
++NumSunk;

// 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;

1662#ifndef NDEBUG
SmallVector<BasicBlock *, 32> ExitBlocks;
CurLoop->getUniqueExitBlocks(ExitBlocks);
SmallPtrSet<BasicBlock *, 32> ExitBlockSet(ExitBlocks.begin(),
                                           ExitBlocks.end());
1667#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-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/LICM.cpp"
, 1687, __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-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/LICM.cpp"
, 1687, __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;
1705}

1707/// When an instruction is found to only use loop invariant operands that
1708/// is safe to hoist, this instruction is called to do the dirty work.
1709///
1710static 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->getName() << ": " << Ido { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("licm")) { dbgs() << "LICM hoisting to " << Dest
->getName() << ": " << I << "\n"; } } while
 (false)
                  << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("licm")) { dbgs() << "LICM hoisting to " << Dest
->getName() << ": " << 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;
1746}

1748/// Only sink or hoist an instruction if it is not a trapping instruction,
1749/// or if the instruction is known not to trap when moved to the preheader.
1750/// or if it is a trapping instruction and is guaranteed to execute.
1751static bool isSafeToExecuteUnconditionally(Instruction &Inst,
                                         const DominatorTree *DT,
                                         const Loop *CurLoop,
                                         const LoopSafetyInfo *SafetyInfo,
                                         OptimizationRemarkEmitter *ORE,
                                         const Instruction *CtxI) {
if (isSafeToSpeculativelyExecute(&Inst, CtxI, DT))
  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;
1775}

1777namespace {
1778class 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;

Value *maybeInsertLCSSAPHI(Value *V, BasicBlock *BB) const {
  if (Instruction *I = dyn_cast<Instruction>(V))
    if (Loop *L = LI.getLoopFor(I->getParent()))
      if (!L->contains(BB)) {
        // 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;
      }
  return V;
}

1809public:
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);
}
1882};


1885/// Return true iff we can prove that a caller of this function can not inspect
1886/// the contents of the provided object in a well defined program.
1887bool 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);
1905}

1907} // namespace

1909/// Try to promote memory values to scalars by sinking stores out of the
1910/// loop and moving loads to before the loop.  We do this by looping over
1911/// the stores in the loop, looking for stores to Must pointers which are
1912/// loop invariant.
1913///
1914bool 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-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/LICM.cpp"
, 1925, __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-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/LICM.cpp"
, 1925, __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-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/LICM.cpp"
, 1925, __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, 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);
      }
    } 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;
2189}

2191/// Returns an owning pointer to an alias set which incorporates aliasing info
2192/// from L and all subloops of L.
2193std::unique_ptr<AliasSetTracker>
2194LoopInvariantCodeMotion::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;
2209}

2211std::unique_ptr<AliasSetTracker>
2212LoopInvariantCodeMotion::collectAliasInfoForLoopWithMSSA(
  Loop *L, AAResults *AA, MemorySSAUpdater *MSSAU) {
auto *MSSA = MSSAU->getMemorySSA();
auto CurAST = std::make_unique<AliasSetTracker>(*AA, MSSA, L);
CurAST->addAllInstructionsInLoopUsingMSSA();
return CurAST;
2218}

2220static 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;
2265}

2267static bool pointerInvalidatedByLoopWithMSSA(MemorySSA *MSSA, MemoryUse *MU,
                                           Loop *CurLoop,
                                           SinkAndHoistLICMFlags &Flags) {
// For hoisting, use the walker to determine safety
if (!Flags.IsSink) {
  MemoryAccess *Source;
  // See declaration of SetLicmMssaOptCap for usage details.
  if (Flags.LicmMssaOptCounter >= Flags.LicmMssaOptCap)
    Source = MU->getDefiningAccess();
  else {
    Source = MSSA->getSkipSelfWalker()->getClobberingMemoryAccess(MU);
    Flags.LicmMssaOptCounter++;
  }
  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.NoOfMemAccTooLarge)
  return true;
for (auto *BB : CurLoop->getBlocks())
  if (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;
2311}

2313/// Little predicate that returns true if the specified basic block is in
2314/// a subloop of the current one, not the current one itself.
2315///
2316static 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-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/LICM.cpp"
, 2317, __PRETTY_FUNCTION__));
return LI->getLoopFor(BB) != CurLoop;
2319}

←

/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h

→

1//===- llvm/Instructions.h - Instruction subclass definitions ---*- 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 exposes the class definitions of all of the subclasses of the
10// Instruction class.  This is meant to be an easy way to get access to all
11// instruction subclasses.
12//
13//===----------------------------------------------------------------------===//

15#ifndef LLVM_IR_INSTRUCTIONS_H
16#define LLVM_IR_INSTRUCTIONS_H

18#include "llvm/ADT/ArrayRef.h"
19#include "llvm/ADT/Bitfields.h"
20#include "llvm/ADT/None.h"
21#include "llvm/ADT/STLExtras.h"
22#include "llvm/ADT/SmallVector.h"
23#include "llvm/ADT/StringRef.h"
24#include "llvm/ADT/Twine.h"
25#include "llvm/ADT/iterator.h"
26#include "llvm/ADT/iterator_range.h"
27#include "llvm/IR/Attributes.h"
28#include "llvm/IR/BasicBlock.h"
29#include "llvm/IR/CallingConv.h"
30#include "llvm/IR/CFG.h"
31#include "llvm/IR/Constant.h"
32#include "llvm/IR/DerivedTypes.h"
33#include "llvm/IR/Function.h"
34#include "llvm/IR/InstrTypes.h"
35#include "llvm/IR/Instruction.h"
36#include "llvm/IR/OperandTraits.h"
37#include "llvm/IR/Type.h"
38#include "llvm/IR/Use.h"
39#include "llvm/IR/User.h"
40#include "llvm/IR/Value.h"
41#include "llvm/Support/AtomicOrdering.h"
42#include "llvm/Support/Casting.h"
43#include "llvm/Support/ErrorHandling.h"
44#include <cassert>
45#include <cstddef>
46#include <cstdint>
47#include <iterator>

49namespace llvm {

51class APInt;
52class ConstantInt;
53class DataLayout;
54class LLVMContext;

56//===----------------------------------------------------------------------===//
57//                                AllocaInst Class
58//===----------------------------------------------------------------------===//

60/// an instruction to allocate memory on the stack
61class AllocaInst : public UnaryInstruction {
Type *AllocatedType;

using AlignmentField = AlignmentBitfieldElementT<0>;
using UsedWithInAllocaField = BoolBitfieldElementT<AlignmentField::NextBit>;
using SwiftErrorField = BoolBitfieldElementT<UsedWithInAllocaField::NextBit>;
static_assert(Bitfield::areContiguous<AlignmentField, UsedWithInAllocaField,
                                      SwiftErrorField>(),
              "Bitfields must be contiguous");

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

AllocaInst *cloneImpl() const;

77public:
explicit AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize,
                    const Twine &Name, Instruction *InsertBefore);
AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize,
           const Twine &Name, BasicBlock *InsertAtEnd);

AllocaInst(Type *Ty, unsigned AddrSpace, const Twine &Name,
           Instruction *InsertBefore);
AllocaInst(Type *Ty, unsigned AddrSpace,
           const Twine &Name, BasicBlock *InsertAtEnd);

AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize, Align Align,
           const Twine &Name = "", Instruction *InsertBefore = nullptr);
AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize, Align Align,
           const Twine &Name, BasicBlock *InsertAtEnd);

/// Return true if there is an allocation size parameter to the allocation
/// instruction that is not 1.
bool isArrayAllocation() const;

/// Get the number of elements allocated. For a simple allocation of a single
/// element, this will return a constant 1 value.
const Value *getArraySize() const { return getOperand(0); }
Value *getArraySize() { return getOperand(0); }

/// Overload to return most specific pointer type.
PointerType *getType() const {
  return cast<PointerType>(Instruction::getType());
}

/// Get allocation size in bits. Returns None if size can't be determined,
/// e.g. in case of a VLA.
Optional<uint64_t> getAllocationSizeInBits(const DataLayout &DL) const;

/// Return the type that is being allocated by the instruction.
Type *getAllocatedType() const { return AllocatedType; }
/// for use only in special circumstances that need to generically
/// transform a whole instruction (eg: IR linking and vectorization).
void setAllocatedType(Type *Ty) { AllocatedType = Ty; }

/// Return the alignment of the memory that is being allocated by the
/// instruction.
Align getAlign() const {
  return Align(1ULL << getSubclassData<AlignmentField>());
}

void setAlignment(Align Align) {
  setSubclassData<AlignmentField>(Log2(Align));
}

// FIXME: Remove this one transition to Align is over.
unsigned getAlignment() const { return getAlign().value(); }

/// Return true if this alloca is in the entry block of the function and is a
/// constant size. If so, the code generator will fold it into the
/// prolog/epilog code, so it is basically free.
bool isStaticAlloca() const;

/// Return true if this alloca is used as an inalloca argument to a call. Such
/// allocas are never considered static even if they are in the entry block.
bool isUsedWithInAlloca() const {
  return getSubclassData<UsedWithInAllocaField>();
}

/// Specify whether this alloca is used to represent the arguments to a call.
void setUsedWithInAlloca(bool V) {
  setSubclassData<UsedWithInAllocaField>(V);
}

/// Return true if this alloca is used as a swifterror argument to a call.
bool isSwiftError() const { return getSubclassData<SwiftErrorField>(); }
/// Specify whether this alloca is used to represent a swifterror.
void setSwiftError(bool V) { setSubclassData<SwiftErrorField>(V); }

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

159private:
// Shadow Instruction::setInstructionSubclassData with a private forwarding
// method so that subclasses cannot accidentally use it.
template <typename Bitfield>
void setSubclassData(typename Bitfield::Type Value) {
  Instruction::setSubclassData<Bitfield>(Value);
}
166};

168//===----------------------------------------------------------------------===//
169//                                LoadInst Class
170//===----------------------------------------------------------------------===//

172/// An instruction for reading from memory. This uses the SubclassData field in
173/// Value to store whether or not the load is volatile.
174class LoadInst : public UnaryInstruction {
using VolatileField = BoolBitfieldElementT<0>;
using AlignmentField = AlignmentBitfieldElementT<VolatileField::NextBit>;
using OrderingField = AtomicOrderingBitfieldElementT<AlignmentField::NextBit>;
static_assert(
    Bitfield::areContiguous<VolatileField, AlignmentField, OrderingField>(),
    "Bitfields must be contiguous");

void AssertOK();

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

LoadInst *cloneImpl() const;

190public:
LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr,
         Instruction *InsertBefore);
LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, BasicBlock *InsertAtEnd);
LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
         Instruction *InsertBefore);
LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
         BasicBlock *InsertAtEnd);
LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
         Align Align, Instruction *InsertBefore = nullptr);
LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
         Align Align, BasicBlock *InsertAtEnd);
LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
         Align Align, AtomicOrdering Order,
         SyncScope::ID SSID = SyncScope::System,
         Instruction *InsertBefore = nullptr);
LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
         Align Align, AtomicOrdering Order, SyncScope::ID SSID,
         BasicBlock *InsertAtEnd);

/// Return true if this is a load from a volatile memory location.
bool isVolatile() const { return getSubclassData<VolatileField>(); }

/// Specify whether this is a volatile load or not.
void setVolatile(bool V) { setSubclassData<VolatileField>(V); }

/// Return the alignment of the access that is being performed.
/// FIXME: Remove this function once transition to Align is over.
/// Use getAlign() instead.
unsigned getAlignment() const { return getAlign().value(); }

/// Return the alignment of the access that is being performed.
Align getAlign() const {
  return Align(1ULL << (getSubclassData<AlignmentField>()));
}

void setAlignment(Align Align) {
  setSubclassData<AlignmentField>(Log2(Align));
}

/// Returns the ordering constraint of this load instruction.
AtomicOrdering getOrdering() const {
  return getSubclassData<OrderingField>();
}
/// Sets the ordering constraint of this load instruction.  May not be Release
/// or AcquireRelease.
void setOrdering(AtomicOrdering Ordering) {
  setSubclassData<OrderingField>(Ordering);
}

/// Returns the synchronization scope ID of this load instruction.
SyncScope::ID getSyncScopeID() const {
  return SSID;
}

/// Sets the synchronization scope ID of this load instruction.
void setSyncScopeID(SyncScope::ID SSID) {
  this->SSID = SSID;
}

/// Sets the ordering constraint and the synchronization scope ID of this load
/// instruction.
void setAtomic(AtomicOrdering Ordering,
               SyncScope::ID SSID = SyncScope::System) {
  setOrdering(Ordering);
  setSyncScopeID(SSID);
}

bool isSimple() const { return !isAtomic() && !isVolatile(); }

bool isUnordered() const {
  return (getOrdering() == AtomicOrdering::NotAtomic ||
13
←
Assuming the condition is false→
16
←
Returning the value 1, which participates in a condition later→
          getOrdering() == AtomicOrdering::Unordered) &&
14
←
Assuming the condition is true→
         !isVolatile();
15
←
Assuming the condition is true→
}

Value *getPointerOperand() { return getOperand(0); }
const Value *getPointerOperand() const { return getOperand(0); }
static unsigned getPointerOperandIndex() { return 0U; }
Type *getPointerOperandType() const { return getPointerOperand()->getType(); }

/// Returns the address space of the pointer operand.
unsigned getPointerAddressSpace() const {
  return getPointerOperandType()->getPointerAddressSpace();
}

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

284private:
// Shadow Instruction::setInstructionSubclassData with a private forwarding
// method so that subclasses cannot accidentally use it.
template <typename Bitfield>
void setSubclassData(typename Bitfield::Type Value) {
  Instruction::setSubclassData<Bitfield>(Value);
}

/// The synchronization scope ID of this load instruction.  Not quite enough
/// room in SubClassData for everything, so synchronization scope ID gets its
/// own field.
SyncScope::ID SSID;
296};

298//===----------------------------------------------------------------------===//
299//                                StoreInst Class
300//===----------------------------------------------------------------------===//

302/// An instruction for storing to memory.
303class StoreInst : public Instruction {
using VolatileField = BoolBitfieldElementT<0>;
using AlignmentField = AlignmentBitfieldElementT<VolatileField::NextBit>;
using OrderingField = AtomicOrderingBitfieldElementT<AlignmentField::NextBit>;
static_assert(
    Bitfield::areContiguous<VolatileField, AlignmentField, OrderingField>(),
    "Bitfields must be contiguous");

void AssertOK();

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

StoreInst *cloneImpl() const;

319public:
StoreInst(Value *Val, Value *Ptr, Instruction *InsertBefore);
StoreInst(Value *Val, Value *Ptr, BasicBlock *InsertAtEnd);
StoreInst(Value *Val, Value *Ptr, bool isVolatile, Instruction *InsertBefore);
StoreInst(Value *Val, Value *Ptr, bool isVolatile, BasicBlock *InsertAtEnd);
StoreInst(Value *Val, Value *Ptr, bool isVolatile, Align Align,
          Instruction *InsertBefore = nullptr);
StoreInst(Value *Val, Value *Ptr, bool isVolatile, Align Align,
          BasicBlock *InsertAtEnd);
StoreInst(Value *Val, Value *Ptr, bool isVolatile, Align Align,
          AtomicOrdering Order, SyncScope::ID SSID = SyncScope::System,
          Instruction *InsertBefore = nullptr);
StoreInst(Value *Val, Value *Ptr, bool isVolatile, Align Align,
          AtomicOrdering Order, SyncScope::ID SSID, BasicBlock *InsertAtEnd);

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

/// Return true if this is a store to a volatile memory location.
bool isVolatile() const { return getSubclassData<VolatileField>(); }

/// Specify whether this is a volatile store or not.
void setVolatile(bool V) { setSubclassData<VolatileField>(V); }

/// 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;

/// Return the alignment of the access that is being performed
/// FIXME: Remove this function once transition to Align is over.
/// Use getAlign() instead.
unsigned getAlignment() const { return getAlign().value(); }

Align getAlign() const {
  return Align(1ULL << (getSubclassData<AlignmentField>()));
}

void setAlignment(Align Align) {
  setSubclassData<AlignmentField>(Log2(Align));
}

/// Returns the ordering constraint of this store instruction.
AtomicOrdering getOrdering() const {
  return getSubclassData<OrderingField>();
}

/// Sets the ordering constraint of this store instruction.  May not be
/// Acquire or AcquireRelease.
void setOrdering(AtomicOrdering Ordering) {
  setSubclassData<OrderingField>(Ordering);
}

/// Returns the synchronization scope ID of this store instruction.
SyncScope::ID getSyncScopeID() const {
  return SSID;
}

/// Sets the synchronization scope ID of this store instruction.
void setSyncScopeID(SyncScope::ID SSID) {
  this->SSID = SSID;
}

/// Sets the ordering constraint and the synchronization scope ID of this
/// store instruction.
void setAtomic(AtomicOrdering Ordering,
               SyncScope::ID SSID = SyncScope::System) {
  setOrdering(Ordering);
  setSyncScopeID(SSID);
}

bool isSimple() const { return !isAtomic() && !isVolatile(); }

bool isUnordered() const {
  return (getOrdering() == AtomicOrdering::NotAtomic ||
          getOrdering() == AtomicOrdering::Unordered) &&
         !isVolatile();
}

Value *getValueOperand() { return getOperand(0); }
const Value *getValueOperand() const { return getOperand(0); }

Value *getPointerOperand() { return getOperand(1); }
const Value *getPointerOperand() const { return getOperand(1); }
static unsigned getPointerOperandIndex() { return 1U; }
Type *getPointerOperandType() const { return getPointerOperand()->getType(); }

/// Returns the address space of the pointer operand.
unsigned getPointerAddressSpace() const {
  return getPointerOperandType()->getPointerAddressSpace();
}

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

419private:
// Shadow Instruction::setInstructionSubclassData with a private forwarding
// method so that subclasses cannot accidentally use it.
template <typename Bitfield>
void setSubclassData(typename Bitfield::Type Value) {
  Instruction::setSubclassData<Bitfield>(Value);
}

/// The synchronization scope ID of this store instruction.  Not quite enough
/// room in SubClassData for everything, so synchronization scope ID gets its
/// own field.
SyncScope::ID SSID;
431};

433template <>
434struct OperandTraits<StoreInst> : public FixedNumOperandTraits<StoreInst, 2> {
435};

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

439//===----------------------------------------------------------------------===//
440//                                FenceInst Class
441//===----------------------------------------------------------------------===//

443/// An instruction for ordering other memory operations.
444class FenceInst : public Instruction {
using OrderingField = AtomicOrderingBitfieldElementT<0>;

void Init(AtomicOrdering Ordering, SyncScope::ID SSID);

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

FenceInst *cloneImpl() const;

455public:
// Ordering may only be Acquire, Release, AcquireRelease, or
// SequentiallyConsistent.
FenceInst(LLVMContext &C, AtomicOrdering Ordering,
          SyncScope::ID SSID = SyncScope::System,
          Instruction *InsertBefore = nullptr);
FenceInst(LLVMContext &C, AtomicOrdering Ordering, SyncScope::ID SSID,
          BasicBlock *InsertAtEnd);

// allocate space for exactly zero operands
void *operator new(size_t s) {
  return User::operator new(s, 0);
}

/// Returns the ordering constraint of this fence instruction.
AtomicOrdering getOrdering() const {
  return getSubclassData<OrderingField>();
}

/// Sets the ordering constraint of this fence instruction.  May only be
/// Acquire, Release, AcquireRelease, or SequentiallyConsistent.
void setOrdering(AtomicOrdering Ordering) {
  setSubclassData<OrderingField>(Ordering);
}

/// Returns the synchronization scope ID of this fence instruction.
SyncScope::ID getSyncScopeID() const {
  return SSID;
}

/// Sets the synchronization scope ID of this fence instruction.
void setSyncScopeID(SyncScope::ID SSID) {
  this->SSID = SSID;
}

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

498private:
// Shadow Instruction::setInstructionSubclassData with a private forwarding
// method so that subclasses cannot accidentally use it.
template <typename Bitfield>
void setSubclassData(typename Bitfield::Type Value) {
  Instruction::setSubclassData<Bitfield>(Value);
}

/// The synchronization scope ID of this fence instruction.  Not quite enough
/// room in SubClassData for everything, so synchronization scope ID gets its
/// own field.
SyncScope::ID SSID;
510};

512//===----------------------------------------------------------------------===//
513//                                AtomicCmpXchgInst Class
514//===----------------------------------------------------------------------===//

516/// An instruction that atomically checks whether a
517/// specified value is in a memory location, and, if it is, stores a new value
518/// there. The value returned by this instruction is a pair containing the
519/// original value as first element, and an i1 indicating success (true) or
520/// failure (false) as second element.
521///
522class AtomicCmpXchgInst : public Instruction {
void Init(Value *Ptr, Value *Cmp, Value *NewVal, Align Align,
          AtomicOrdering SuccessOrdering, AtomicOrdering FailureOrdering,
          SyncScope::ID SSID);

template <unsigned Offset>
using AtomicOrderingBitfieldElement =
    typename Bitfield::Element<AtomicOrdering, Offset, 3,
                               AtomicOrdering::LAST>;

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

AtomicCmpXchgInst *cloneImpl() const;

538public:
AtomicCmpXchgInst(Value *Ptr, Value *Cmp, Value *NewVal, Align Alignment,
                  AtomicOrdering SuccessOrdering,
                  AtomicOrdering FailureOrdering, SyncScope::ID SSID,
                  Instruction *InsertBefore = nullptr);
AtomicCmpXchgInst(Value *Ptr, Value *Cmp, Value *NewVal, Align Alignment,
                  AtomicOrdering SuccessOrdering,
                  AtomicOrdering FailureOrdering, SyncScope::ID SSID,
                  BasicBlock *InsertAtEnd);

// allocate space for exactly three operands
void *operator new(size_t s) {
  return User::operator new(s, 3);
}

using VolatileField = BoolBitfieldElementT<0>;
using WeakField = BoolBitfieldElementT<VolatileField::NextBit>;
using SuccessOrderingField =
    AtomicOrderingBitfieldElementT<WeakField::NextBit>;
using FailureOrderingField =
    AtomicOrderingBitfieldElementT<SuccessOrderingField::NextBit>;
using AlignmentField =
    AlignmentBitfieldElementT<FailureOrderingField::NextBit>;
static_assert(
    Bitfield::areContiguous<VolatileField, WeakField, SuccessOrderingField,
                            FailureOrderingField, AlignmentField>(),
    "Bitfields must be contiguous");

/// Return the alignment of the memory that is being allocated by the
/// instruction.
Align getAlign() const {
  return Align(1ULL << getSubclassData<AlignmentField>());
}

void setAlignment(Align Align) {
  setSubclassData<AlignmentField>(Log2(Align));
}

/// Return true if this is a cmpxchg from a volatile memory
/// location.
///
bool isVolatile() const { return getSubclassData<VolatileField>(); }

/// Specify whether this is a volatile cmpxchg.
///
void setVolatile(bool V) { setSubclassData<VolatileField>(V); }

/// Return true if this cmpxchg may spuriously fail.
bool isWeak() const { return getSubclassData<WeakField>(); }

void setWeak(bool IsWeak) { setSubclassData<WeakField>(IsWeak); }

/// 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;

/// Returns the success ordering constraint of this cmpxchg instruction.
AtomicOrdering getSuccessOrdering() const {
  return getSubclassData<SuccessOrderingField>();
}

/// Sets the success ordering constraint of this cmpxchg instruction.
void setSuccessOrdering(AtomicOrdering Ordering) {
  assert(Ordering != AtomicOrdering::NotAtomic &&((Ordering != AtomicOrdering::NotAtomic && "CmpXchg instructions can only be atomic."
) ? static_cast<void> (0) : __assert_fail ("Ordering != AtomicOrdering::NotAtomic && \"CmpXchg instructions can only be atomic.\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 601, __PRETTY_FUNCTION__))
         "CmpXchg instructions can only be atomic.")((Ordering != AtomicOrdering::NotAtomic && "CmpXchg instructions can only be atomic."
) ? static_cast<void> (0) : __assert_fail ("Ordering != AtomicOrdering::NotAtomic && \"CmpXchg instructions can only be atomic.\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 601, __PRETTY_FUNCTION__));
  setSubclassData<SuccessOrderingField>(Ordering);
}

/// Returns the failure ordering constraint of this cmpxchg instruction.
AtomicOrdering getFailureOrdering() const {
  return getSubclassData<FailureOrderingField>();
}

/// Sets the failure ordering constraint of this cmpxchg instruction.
void setFailureOrdering(AtomicOrdering Ordering) {
  assert(Ordering != AtomicOrdering::NotAtomic &&((Ordering != AtomicOrdering::NotAtomic && "CmpXchg instructions can only be atomic."
) ? static_cast<void> (0) : __assert_fail ("Ordering != AtomicOrdering::NotAtomic && \"CmpXchg instructions can only be atomic.\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 613, __PRETTY_FUNCTION__))
         "CmpXchg instructions can only be atomic.")((Ordering != AtomicOrdering::NotAtomic && "CmpXchg instructions can only be atomic."
) ? static_cast<void> (0) : __assert_fail ("Ordering != AtomicOrdering::NotAtomic && \"CmpXchg instructions can only be atomic.\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 613, __PRETTY_FUNCTION__));
  setSubclassData<FailureOrderingField>(Ordering);
}

/// Returns the synchronization scope ID of this cmpxchg instruction.
SyncScope::ID getSyncScopeID() const {
  return SSID;
}

/// Sets the synchronization scope ID of this cmpxchg instruction.
void setSyncScopeID(SyncScope::ID SSID) {
  this->SSID = SSID;
}

Value *getPointerOperand() { return getOperand(0); }
const Value *getPointerOperand() const { return getOperand(0); }
static unsigned getPointerOperandIndex() { return 0U; }

Value *getCompareOperand() { return getOperand(1); }
const Value *getCompareOperand() const { return getOperand(1); }

Value *getNewValOperand() { return getOperand(2); }
const Value *getNewValOperand() const { return getOperand(2); }

/// Returns the address space of the pointer operand.
unsigned getPointerAddressSpace() const {
  return getPointerOperand()->getType()->getPointerAddressSpace();
}

/// Returns the strongest permitted ordering on failure, given the
/// desired ordering on success.
///
/// If the comparison in a cmpxchg operation fails, there is no atomic store
/// so release semantics cannot be provided. So this function drops explicit
/// Release requests from the AtomicOrdering. A SequentiallyConsistent
/// operation would remain SequentiallyConsistent.
static AtomicOrdering
getStrongestFailureOrdering(AtomicOrdering SuccessOrdering) {
  switch (SuccessOrdering) {
  default:
    llvm_unreachable("invalid cmpxchg success ordering")::llvm::llvm_unreachable_internal("invalid cmpxchg success ordering"
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 653);
  case AtomicOrdering::Release:
  case AtomicOrdering::Monotonic:
    return AtomicOrdering::Monotonic;
  case AtomicOrdering::AcquireRelease:
  case AtomicOrdering::Acquire:
    return AtomicOrdering::Acquire;
  case AtomicOrdering::SequentiallyConsistent:
    return AtomicOrdering::SequentiallyConsistent;
  }
}

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

673private:
// Shadow Instruction::setInstructionSubclassData with a private forwarding
// method so that subclasses cannot accidentally use it.
template <typename Bitfield>
void setSubclassData(typename Bitfield::Type Value) {
  Instruction::setSubclassData<Bitfield>(Value);
}

/// The synchronization scope ID of this cmpxchg instruction.  Not quite
/// enough room in SubClassData for everything, so synchronization scope ID
/// gets its own field.
SyncScope::ID SSID;
685};

687template <>
688struct OperandTraits<AtomicCmpXchgInst> :
  public FixedNumOperandTraits<AtomicCmpXchgInst, 3> {
690};

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

694//===----------------------------------------------------------------------===//
695//                                AtomicRMWInst Class
696//===----------------------------------------------------------------------===//

698/// an instruction that atomically reads a memory location,
699/// combines it with another value, and then stores the result back.  Returns
700/// the old value.
701///
702class AtomicRMWInst : public Instruction {
703protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

AtomicRMWInst *cloneImpl() const;

709public:
/// This enumeration lists the possible modifications atomicrmw can make.  In
/// the descriptions, 'p' is the pointer to the instruction's memory location,
/// 'old' is the initial value of *p, and 'v' is the other value passed to the
/// instruction.  These instructions always return 'old'.
enum BinOp : unsigned {
  /// *p = v
  Xchg,
  /// *p = old + v
  Add,
  /// *p = old - v
  Sub,
  /// *p = old & v
  And,
  /// *p = ~(old & v)
  Nand,
  /// *p = old | v
  Or,
  /// *p = old ^ v
  Xor,
  /// *p = old >signed v ? old : v
  Max,
  /// *p = old <signed v ? old : v
  Min,
  /// *p = old >unsigned v ? old : v
  UMax,
  /// *p = old <unsigned v ? old : v
  UMin,

  /// *p = old + v
  FAdd,

  /// *p = old - v
  FSub,

  FIRST_BINOP = Xchg,
  LAST_BINOP = FSub,
  BAD_BINOP
};

749private:
template <unsigned Offset>
using AtomicOrderingBitfieldElement =
    typename Bitfield::Element<AtomicOrdering, Offset, 3,
                               AtomicOrdering::LAST>;

template <unsigned Offset>
using BinOpBitfieldElement =
    typename Bitfield::Element<BinOp, Offset, 4, BinOp::LAST_BINOP>;

759public:
AtomicRMWInst(BinOp Operation, Value *Ptr, Value *Val, Align Alignment,
              AtomicOrdering Ordering, SyncScope::ID SSID,
              Instruction *InsertBefore = nullptr);
AtomicRMWInst(BinOp Operation, Value *Ptr, Value *Val, Align Alignment,
              AtomicOrdering Ordering, SyncScope::ID SSID,
              BasicBlock *InsertAtEnd);

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

using VolatileField = BoolBitfieldElementT<0>;
using AtomicOrderingField =
    AtomicOrderingBitfieldElementT<VolatileField::NextBit>;
using OperationField = BinOpBitfieldElement<AtomicOrderingField::NextBit>;
using AlignmentField = AlignmentBitfieldElementT<OperationField::NextBit>;
static_assert(Bitfield::areContiguous<VolatileField, AtomicOrderingField,
                                      OperationField, AlignmentField>(),
              "Bitfields must be contiguous");

BinOp getOperation() const { return getSubclassData<OperationField>(); }

static StringRef getOperationName(BinOp Op);

static bool isFPOperation(BinOp Op) {
  switch (Op) {
  case AtomicRMWInst::FAdd:
  case AtomicRMWInst::FSub:
    return true;
  default:
    return false;
  }
}

void setOperation(BinOp Operation) {
  setSubclassData<OperationField>(Operation);
}

/// Return the alignment of the memory that is being allocated by the
/// instruction.
Align getAlign() const {
  return Align(1ULL << getSubclassData<AlignmentField>());
}

void setAlignment(Align Align) {
  setSubclassData<AlignmentField>(Log2(Align));
}

/// Return true if this is a RMW on a volatile memory location.
///
bool isVolatile() const { return getSubclassData<VolatileField>(); }

/// Specify whether this is a volatile RMW or not.
///
void setVolatile(bool V) { setSubclassData<VolatileField>(V); }

/// 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;

/// Returns the ordering constraint of this rmw instruction.
AtomicOrdering getOrdering() const {
  return getSubclassData<AtomicOrderingField>();
}

/// Sets the ordering constraint of this rmw instruction.
void setOrdering(AtomicOrdering Ordering) {
  assert(Ordering != AtomicOrdering::NotAtomic &&((Ordering != AtomicOrdering::NotAtomic && "atomicrmw instructions can only be atomic."
) ? static_cast<void> (0) : __assert_fail ("Ordering != AtomicOrdering::NotAtomic && \"atomicrmw instructions can only be atomic.\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 828, __PRETTY_FUNCTION__))
         "atomicrmw instructions can only be atomic.")((Ordering != AtomicOrdering::NotAtomic && "atomicrmw instructions can only be atomic."
) ? static_cast<void> (0) : __assert_fail ("Ordering != AtomicOrdering::NotAtomic && \"atomicrmw instructions can only be atomic.\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 828, __PRETTY_FUNCTION__));
  setSubclassData<AtomicOrderingField>(Ordering);
}

/// Returns the synchronization scope ID of this rmw instruction.
SyncScope::ID getSyncScopeID() const {
  return SSID;
}

/// Sets the synchronization scope ID of this rmw instruction.
void setSyncScopeID(SyncScope::ID SSID) {
  this->SSID = SSID;
}

Value *getPointerOperand() { return getOperand(0); }
const Value *getPointerOperand() const { return getOperand(0); }
static unsigned getPointerOperandIndex() { return 0U; }

Value *getValOperand() { return getOperand(1); }
const Value *getValOperand() const { return getOperand(1); }

/// Returns the address space of the pointer operand.
unsigned getPointerAddressSpace() const {
  return getPointerOperand()->getType()->getPointerAddressSpace();
}

bool isFloatingPointOperation() const {
  return isFPOperation(getOperation());
}

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

866private:
void Init(BinOp Operation, Value *Ptr, Value *Val, Align Align,
          AtomicOrdering Ordering, SyncScope::ID SSID);

// Shadow Instruction::setInstructionSubclassData with a private forwarding
// method so that subclasses cannot accidentally use it.
template <typename Bitfield>
void setSubclassData(typename Bitfield::Type Value) {
  Instruction::setSubclassData<Bitfield>(Value);
}

/// The synchronization scope ID of this rmw instruction.  Not quite enough
/// room in SubClassData for everything, so synchronization scope ID gets its
/// own field.
SyncScope::ID SSID;
881};

883template <>
884struct OperandTraits<AtomicRMWInst>
  : public FixedNumOperandTraits<AtomicRMWInst,2> {
886};

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

890//===----------------------------------------------------------------------===//
891//                             GetElementPtrInst Class
892//===----------------------------------------------------------------------===//

894// checkGEPType - Simple wrapper function to give a better assertion failure
895// message on bad indexes for a gep instruction.
896//
897inline Type *checkGEPType(Type *Ty) {
assert(Ty && "Invalid GetElementPtrInst indices for type!")((Ty && "Invalid GetElementPtrInst indices for type!"
) ? static_cast<void> (0) : __assert_fail ("Ty && \"Invalid GetElementPtrInst indices for type!\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 898, __PRETTY_FUNCTION__));
return Ty;
900}

902/// an instruction for type-safe pointer arithmetic to
903/// access elements of arrays and structs
904///
905class GetElementPtrInst : public Instruction {
Type *SourceElementType;
Type *ResultElementType;

GetElementPtrInst(const GetElementPtrInst &GEPI);

/// Constructors - Create a getelementptr instruction with a base pointer an
/// list of indices. The first ctor can optionally insert before an existing
/// instruction, the second appends the new instruction to the specified
/// BasicBlock.
inline GetElementPtrInst(Type *PointeeType, Value *Ptr,
                         ArrayRef<Value *> IdxList, unsigned Values,
                         const Twine &NameStr, Instruction *InsertBefore);
inline GetElementPtrInst(Type *PointeeType, Value *Ptr,
                         ArrayRef<Value *> IdxList, unsigned Values,
                         const Twine &NameStr, BasicBlock *InsertAtEnd);

void init(Value *Ptr, ArrayRef<Value *> IdxList, const Twine &NameStr);

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

GetElementPtrInst *cloneImpl() const;

930public:
static GetElementPtrInst *Create(Type *PointeeType, Value *Ptr,
                                 ArrayRef<Value *> IdxList,
                                 const Twine &NameStr = "",
                                 Instruction *InsertBefore = nullptr) {
  unsigned Values = 1 + unsigned(IdxList.size());
  if (!PointeeType)
    PointeeType =
        cast<PointerType>(Ptr->getType()->getScalarType())->getElementType();
  else
    assert(((PointeeType == cast<PointerType>(Ptr->getType()->
getScalarType())->getElementType()) ? static_cast<void>
 (0) : __assert_fail ("PointeeType == cast<PointerType>(Ptr->getType()->getScalarType())->getElementType()"
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 942, __PRETTY_FUNCTION__))
        PointeeType ==((PointeeType == cast<PointerType>(Ptr->getType()->
getScalarType())->getElementType()) ? static_cast<void>
 (0) : __assert_fail ("PointeeType == cast<PointerType>(Ptr->getType()->getScalarType())->getElementType()"
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 942, __PRETTY_FUNCTION__))
        cast<PointerType>(Ptr->getType()->getScalarType())->getElementType())((PointeeType == cast<PointerType>(Ptr->getType()->
getScalarType())->getElementType()) ? static_cast<void>
 (0) : __assert_fail ("PointeeType == cast<PointerType>(Ptr->getType()->getScalarType())->getElementType()"
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 942, __PRETTY_FUNCTION__));
  return new (Values) GetElementPtrInst(PointeeType, Ptr, IdxList, Values,
                                        NameStr, InsertBefore);
}

static GetElementPtrInst *Create(Type *PointeeType, Value *Ptr,
                                 ArrayRef<Value *> IdxList,
                                 const Twine &NameStr,
                                 BasicBlock *InsertAtEnd) {
  unsigned Values = 1 + unsigned(IdxList.size());
  if (!PointeeType)
    PointeeType =
        cast<PointerType>(Ptr->getType()->getScalarType())->getElementType();
  else
    assert(((PointeeType == cast<PointerType>(Ptr->getType()->
getScalarType())->getElementType()) ? static_cast<void>
 (0) : __assert_fail ("PointeeType == cast<PointerType>(Ptr->getType()->getScalarType())->getElementType()"
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 958, __PRETTY_FUNCTION__))
        PointeeType ==((PointeeType == cast<PointerType>(Ptr->getType()->
getScalarType())->getElementType()) ? static_cast<void>
 (0) : __assert_fail ("PointeeType == cast<PointerType>(Ptr->getType()->getScalarType())->getElementType()"
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 958, __PRETTY_FUNCTION__))
        cast<PointerType>(Ptr->getType()->getScalarType())->getElementType())((PointeeType == cast<PointerType>(Ptr->getType()->
getScalarType())->getElementType()) ? static_cast<void>
 (0) : __assert_fail ("PointeeType == cast<PointerType>(Ptr->getType()->getScalarType())->getElementType()"
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 958, __PRETTY_FUNCTION__));
  return new (Values) GetElementPtrInst(PointeeType, Ptr, IdxList, Values,
                                        NameStr, InsertAtEnd);
}

/// Create an "inbounds" getelementptr. See the documentation for the
/// "inbounds" flag in LangRef.html for details.
static GetElementPtrInst *CreateInBounds(Value *Ptr,
                                         ArrayRef<Value *> IdxList,
                                         const Twine &NameStr = "",
                                         Instruction *InsertBefore = nullptr){
  return CreateInBounds(nullptr, Ptr, IdxList, NameStr, InsertBefore);
}

static GetElementPtrInst *
CreateInBounds(Type *PointeeType, Value *Ptr, ArrayRef<Value *> IdxList,
               const Twine &NameStr = "",
               Instruction *InsertBefore = nullptr) {
  GetElementPtrInst *GEP =
      Create(PointeeType, Ptr, IdxList, NameStr, InsertBefore);
  GEP->setIsInBounds(true);
  return GEP;
}

static GetElementPtrInst *CreateInBounds(Value *Ptr,
                                         ArrayRef<Value *> IdxList,
                                         const Twine &NameStr,
                                         BasicBlock *InsertAtEnd) {
  return CreateInBounds(nullptr, Ptr, IdxList, NameStr, InsertAtEnd);
}

static GetElementPtrInst *CreateInBounds(Type *PointeeType, Value *Ptr,
                                         ArrayRef<Value *> IdxList,
                                         const Twine &NameStr,
                                         BasicBlock *InsertAtEnd) {
  GetElementPtrInst *GEP =
      Create(PointeeType, Ptr, IdxList, NameStr, InsertAtEnd);
  GEP->setIsInBounds(true);
  return GEP;
}

/// 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;

Type *getSourceElementType() const { return SourceElementType; }

void setSourceElementType(Type *Ty) { SourceElementType = Ty; }
void setResultElementType(Type *Ty) { ResultElementType = Ty; }

Type *getResultElementType() const {
  assert(ResultElementType ==((ResultElementType == cast<PointerType>(getType()->
getScalarType())->getElementType()) ? static_cast<void>
 (0) : __assert_fail ("ResultElementType == cast<PointerType>(getType()->getScalarType())->getElementType()"
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 1009, __PRETTY_FUNCTION__))
         cast<PointerType>(getType()->getScalarType())->getElementType())((ResultElementType == cast<PointerType>(getType()->
getScalarType())->getElementType()) ? static_cast<void>
 (0) : __assert_fail ("ResultElementType == cast<PointerType>(getType()->getScalarType())->getElementType()"
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 1009, __PRETTY_FUNCTION__));
  return ResultElementType;
}

/// Returns the address space of this instruction's pointer type.
unsigned getAddressSpace() const {
  // Note that this is always the same as the pointer operand's address space
  // and that is cheaper to compute, so cheat here.
  return getPointerAddressSpace();
}

/// Returns the result type of a getelementptr with the given source
/// element type and indexes.
///
/// Null is returned if the indices are invalid for the specified
/// source element type.
static Type *getIndexedType(Type *Ty, ArrayRef<Value *> IdxList);
static Type *getIndexedType(Type *Ty, ArrayRef<Constant *> IdxList);
static Type *getIndexedType(Type *Ty, ArrayRef<uint64_t> IdxList);

/// Return the type of the element at the given index of an indexable
/// type.  This is equivalent to "getIndexedType(Agg, {Zero, Idx})".
///
/// Returns null if the type can't be indexed, or the given index is not
/// legal for the given type.
static Type *getTypeAtIndex(Type *Ty, Value *Idx);
static Type *getTypeAtIndex(Type *Ty, uint64_t Idx);

inline op_iterator       idx_begin()       { return op_begin()+1; }
inline const_op_iterator idx_begin() const { return op_begin()+1; }
inline op_iterator       idx_end()         { return op_end(); }
inline const_op_iterator idx_end()   const { return op_end(); }

inline iterator_range<op_iterator> indices() {
  return make_range(idx_begin(), idx_end());
}

inline iterator_range<const_op_iterator> indices() const {
  return make_range(idx_begin(), idx_end());
}

Value *getPointerOperand() {
  return getOperand(0);
}
const Value *getPointerOperand() const {
  return getOperand(0);
}
static unsigned getPointerOperandIndex() {
  return 0U;    // get index for modifying correct operand.
}

/// Method to return the pointer operand as a
/// PointerType.
Type *getPointerOperandType() const {
  return getPointerOperand()->getType();
}

/// Returns the address space of the pointer operand.
unsigned getPointerAddressSpace() const {
  return getPointerOperandType()->getPointerAddressSpace();
}

/// Returns the pointer type returned by the GEP
/// instruction, which may be a vector of pointers.
static Type *getGEPReturnType(Type *ElTy, Value *Ptr,
                              ArrayRef<Value *> IdxList) {
  Type *PtrTy = PointerType::get(checkGEPType(getIndexedType(ElTy, IdxList)),
                                 Ptr->getType()->getPointerAddressSpace());
  // Vector GEP
  if (auto *PtrVTy = dyn_cast<VectorType>(Ptr->getType())) {
    ElementCount EltCount = PtrVTy->getElementCount();
    return VectorType::get(PtrTy, EltCount);
  }
  for (Value *Index : IdxList)
    if (auto *IndexVTy = dyn_cast<VectorType>(Index->getType())) {
      ElementCount EltCount = IndexVTy->getElementCount();
      return VectorType::get(PtrTy, EltCount);
    }
  // Scalar GEP
  return PtrTy;
}

unsigned getNumIndices() const {  // Note: always non-negative
  return getNumOperands() - 1;
}

bool hasIndices() const {
  return getNumOperands() > 1;
}

/// Return true if all of the indices of this GEP are
/// zeros.  If so, the result pointer and the first operand have the same
/// value, just potentially different types.
bool hasAllZeroIndices() const;

/// Return true if all of the indices of this GEP are
/// constant integers.  If so, the result pointer and the first operand have
/// a constant offset between them.
bool hasAllConstantIndices() const;

/// Set or clear the inbounds flag on this GEP instruction.
/// See LangRef.html for the meaning of inbounds on a getelementptr.
void setIsInBounds(bool b = true);

/// Determine whether the GEP has the inbounds flag.
bool isInBounds() const;

/// Accumulate the constant address offset of this GEP if possible.
///
/// This routine accepts an APInt into which it will accumulate the constant
/// offset of this GEP if the GEP is in fact constant. If the GEP is not
/// all-constant, it returns false and the value of the offset APInt is
/// undefined (it is *not* preserved!). The APInt passed into this routine
/// must be at least as wide as the IntPtr type for the address space of
/// the base GEP pointer.
bool accumulateConstantOffset(const DataLayout &DL, APInt &Offset) const;

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

1135template <>
1136struct OperandTraits<GetElementPtrInst> :
public VariadicOperandTraits<GetElementPtrInst, 1> {
1138};

1140GetElementPtrInst::GetElementPtrInst(Type *PointeeType, Value *Ptr,
                                   ArrayRef<Value *> IdxList, unsigned Values,
                                   const Twine &NameStr,
                                   Instruction *InsertBefore)
  : Instruction(getGEPReturnType(PointeeType, Ptr, IdxList), GetElementPtr,
                OperandTraits<GetElementPtrInst>::op_end(this) - Values,
                Values, InsertBefore),
    SourceElementType(PointeeType),
    ResultElementType(getIndexedType(PointeeType, IdxList)) {
assert(ResultElementType ==((ResultElementType == cast<PointerType>(getType()->
getScalarType())->getElementType()) ? static_cast<void>
 (0) : __assert_fail ("ResultElementType == cast<PointerType>(getType()->getScalarType())->getElementType()"
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 1150, __PRETTY_FUNCTION__))
       cast<PointerType>(getType()->getScalarType())->getElementType())((ResultElementType == cast<PointerType>(getType()->
getScalarType())->getElementType()) ? static_cast<void>
 (0) : __assert_fail ("ResultElementType == cast<PointerType>(getType()->getScalarType())->getElementType()"
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 1150, __PRETTY_FUNCTION__));
init(Ptr, IdxList, NameStr);
1152}

1154GetElementPtrInst::GetElementPtrInst(Type *PointeeType, Value *Ptr,
                                   ArrayRef<Value *> IdxList, unsigned Values,
                                   const Twine &NameStr,
                                   BasicBlock *InsertAtEnd)
  : Instruction(getGEPReturnType(PointeeType, Ptr, IdxList), GetElementPtr,
                OperandTraits<GetElementPtrInst>::op_end(this) - Values,
                Values, InsertAtEnd),
    SourceElementType(PointeeType),
    ResultElementType(getIndexedType(PointeeType, IdxList)) {
assert(ResultElementType ==((ResultElementType == cast<PointerType>(getType()->
getScalarType())->getElementType()) ? static_cast<void>
 (0) : __assert_fail ("ResultElementType == cast<PointerType>(getType()->getScalarType())->getElementType()"
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 1164, __PRETTY_FUNCTION__))
       cast<PointerType>(getType()->getScalarType())->getElementType())((ResultElementType == cast<PointerType>(getType()->
getScalarType())->getElementType()) ? static_cast<void>
 (0) : __assert_fail ("ResultElementType == cast<PointerType>(getType()->getScalarType())->getElementType()"
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 1164, __PRETTY_FUNCTION__));
init(Ptr, IdxList, NameStr);
1166}

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

1170//===----------------------------------------------------------------------===//
1171//                               ICmpInst Class
1172//===----------------------------------------------------------------------===//

1174/// This instruction compares its operands according to the predicate given
1175/// to the constructor. It only operates on integers or pointers. The operands
1176/// must be identical types.
1177/// Represent an integer comparison operator.
1178class ICmpInst: public CmpInst {
void AssertOK() {
  assert(isIntPredicate() &&((isIntPredicate() && "Invalid ICmp predicate value")
 ? static_cast<void> (0) : __assert_fail ("isIntPredicate() && \"Invalid ICmp predicate value\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 1181, __PRETTY_FUNCTION__))
         "Invalid ICmp predicate value")((isIntPredicate() && "Invalid ICmp predicate value")
 ? static_cast<void> (0) : __assert_fail ("isIntPredicate() && \"Invalid ICmp predicate value\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 1181, __PRETTY_FUNCTION__));
  assert(getOperand(0)->getType() == getOperand(1)->getType() &&((getOperand(0)->getType() == getOperand(1)->getType() &&
 "Both operands to ICmp instruction are not of the same type!"
) ? static_cast<void> (0) : __assert_fail ("getOperand(0)->getType() == getOperand(1)->getType() && \"Both operands to ICmp instruction are not of the same type!\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 1183, __PRETTY_FUNCTION__))
        "Both operands to ICmp instruction are not of the same type!")((getOperand(0)->getType() == getOperand(1)->getType() &&
 "Both operands to ICmp instruction are not of the same type!"
) ? static_cast<void> (0) : __assert_fail ("getOperand(0)->getType() == getOperand(1)->getType() && \"Both operands to ICmp instruction are not of the same type!\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 1183, __PRETTY_FUNCTION__));
  // Check that the operands are the right type
  assert((getOperand(0)->getType()->isIntOrIntVectorTy() ||(((getOperand(0)->getType()->isIntOrIntVectorTy() || getOperand
(0)->getType()->isPtrOrPtrVectorTy()) && "Invalid operand types for ICmp instruction"
) ? static_cast<void> (0) : __assert_fail ("(getOperand(0)->getType()->isIntOrIntVectorTy() || getOperand(0)->getType()->isPtrOrPtrVectorTy()) && \"Invalid operand types for ICmp instruction\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 1187, __PRETTY_FUNCTION__))
          getOperand(0)->getType()->isPtrOrPtrVectorTy()) &&(((getOperand(0)->getType()->isIntOrIntVectorTy() || getOperand
(0)->getType()->isPtrOrPtrVectorTy()) && "Invalid operand types for ICmp instruction"
) ? static_cast<void> (0) : __assert_fail ("(getOperand(0)->getType()->isIntOrIntVectorTy() || getOperand(0)->getType()->isPtrOrPtrVectorTy()) && \"Invalid operand types for ICmp instruction\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 1187, __PRETTY_FUNCTION__))
         "Invalid operand types for ICmp instruction")(((getOperand(0)->getType()->isIntOrIntVectorTy() || getOperand
(0)->getType()->isPtrOrPtrVectorTy()) && "Invalid operand types for ICmp instruction"
) ? static_cast<void> (0) : __assert_fail ("(getOperand(0)->getType()->isIntOrIntVectorTy() || getOperand(0)->getType()->isPtrOrPtrVectorTy()) && \"Invalid operand types for ICmp instruction\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 1187, __PRETTY_FUNCTION__));
}

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

/// Clone an identical ICmpInst
ICmpInst *cloneImpl() const;

1197public:
/// Constructor with insert-before-instruction semantics.
ICmpInst(
  Instruction *InsertBefore,  ///< Where to insert
  Predicate pred,  ///< The predicate to use for the comparison
  Value *LHS,      ///< The left-hand-side of the expression
  Value *RHS,      ///< The right-hand-side of the expression
  const Twine &NameStr = ""  ///< Name of the instruction
) : CmpInst(makeCmpResultType(LHS->getType()),
            Instruction::ICmp, pred, LHS, RHS, NameStr,
            InsertBefore) {
1208#ifndef NDEBUG
AssertOK();
1210#endif
}

/// Constructor with insert-at-end semantics.
ICmpInst(
  BasicBlock &InsertAtEnd, ///< Block to insert into.
  Predicate pred,  ///< The predicate to use for the comparison
  Value *LHS,      ///< The left-hand-side of the expression
  Value *RHS,      ///< The right-hand-side of the expression
  const Twine &NameStr = ""  ///< Name of the instruction
) : CmpInst(makeCmpResultType(LHS->getType()),
            Instruction::ICmp, pred, LHS, RHS, NameStr,
            &InsertAtEnd) {
1223#ifndef NDEBUG
AssertOK();
1225#endif
}

/// Constructor with no-insertion semantics
ICmpInst(
  Predicate pred, ///< The predicate to use for the comparison
  Value *LHS,     ///< The left-hand-side of the expression
  Value *RHS,     ///< The right-hand-side of the expression
  const Twine &NameStr = "" ///< Name of the instruction
) : CmpInst(makeCmpResultType(LHS->getType()),
            Instruction::ICmp, pred, LHS, RHS, NameStr) {
1236#ifndef NDEBUG
AssertOK();
1238#endif
}

/// For example, EQ->EQ, SLE->SLE, UGT->SGT, etc.
/// @returns the predicate that would be the result if the operand were
/// regarded as signed.
/// Return the signed version of the predicate
Predicate getSignedPredicate() const {
  return getSignedPredicate(getPredicate());
}

/// This is a static version that you can use without an instruction.
/// Return the signed version of the predicate.
static Predicate getSignedPredicate(Predicate pred);

/// For example, EQ->EQ, SLE->ULE, UGT->UGT, etc.
/// @returns the predicate that would be the result if the operand were
/// regarded as unsigned.
/// Return the unsigned version of the predicate
Predicate getUnsignedPredicate() const {
  return getUnsignedPredicate(getPredicate());
}

/// This is a static version that you can use without an instruction.
/// Return the unsigned version of the predicate.
static Predicate getUnsignedPredicate(Predicate pred);

/// Return true if this predicate is either EQ or NE.  This also
/// tests for commutativity.
static bool isEquality(Predicate P) {
  return P == ICMP_EQ || P == ICMP_NE;
}

/// Return true if this predicate is either EQ or NE.  This also
/// tests for commutativity.
bool isEquality() const {
  return isEquality(getPredicate());
}

/// @returns true if the predicate of this ICmpInst is commutative
/// Determine if this relation is commutative.
bool isCommutative() const { return isEquality(); }

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

/// 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 SGT or UGT.
///
static bool isGT(Predicate P) {
  return P == ICMP_SGT || P == ICMP_UGT;
}

/// Return true if the predicate is SLT or ULT.
///
static bool isLT(Predicate P) {
  return P == ICMP_SLT || P == ICMP_ULT;
}

/// Return true if the predicate is SGE or UGE.
///
static bool isGE(Predicate P) {
  return P == ICMP_SGE || P == ICMP_UGE;
}

/// Return true if the predicate is SLE or ULE.
///
static bool isLE(Predicate P) {
  return P == ICMP_SLE || P == ICMP_ULE;
}

/// Exchange the two operands to this instruction in such a way that it does
/// not modify the semantics of the instruction. The predicate value may be
/// changed to retain the same result if the predicate is order dependent
/// (e.g. ult).
/// Swap operands and adjust predicate.
void swapOperands() {
  setPredicate(getSwappedPredicate());
  Op<0>().swap(Op<1>());
}

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

1336//===----------------------------------------------------------------------===//
1337//                               FCmpInst Class
1338//===----------------------------------------------------------------------===//

1340/// This instruction compares its operands according to the predicate given
1341/// to the constructor. It only operates on floating point values or packed
1342/// vectors of floating point values. The operands must be identical types.
1343/// Represents a floating point comparison operator.
1344class FCmpInst: public CmpInst {
void AssertOK() {
  assert(isFPPredicate() && "Invalid FCmp predicate value")((isFPPredicate() && "Invalid FCmp predicate value") ?
 static_cast<void> (0) : __assert_fail ("isFPPredicate() && \"Invalid FCmp predicate value\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 1346, __PRETTY_FUNCTION__));
  assert(getOperand(0)->getType() == getOperand(1)->getType() &&((getOperand(0)->getType() == getOperand(1)->getType() &&
 "Both operands to FCmp instruction are not of the same type!"
) ? static_cast<void> (0) : __assert_fail ("getOperand(0)->getType() == getOperand(1)->getType() && \"Both operands to FCmp instruction are not of the same type!\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 1348, __PRETTY_FUNCTION__))
         "Both operands to FCmp instruction are not of the same type!")((getOperand(0)->getType() == getOperand(1)->getType() &&
 "Both operands to FCmp instruction are not of the same type!"
) ? static_cast<void> (0) : __assert_fail ("getOperand(0)->getType() == getOperand(1)->getType() && \"Both operands to FCmp instruction are not of the same type!\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 1348, __PRETTY_FUNCTION__));
  // Check that the operands are the right type
  assert(getOperand(0)->getType()->isFPOrFPVectorTy() &&((getOperand(0)->getType()->isFPOrFPVectorTy() &&
 "Invalid operand types for FCmp instruction") ? static_cast<
void> (0) : __assert_fail ("getOperand(0)->getType()->isFPOrFPVectorTy() && \"Invalid operand types for FCmp instruction\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 1351, __PRETTY_FUNCTION__))
         "Invalid operand types for FCmp instruction")((getOperand(0)->getType()->isFPOrFPVectorTy() &&
 "Invalid operand types for FCmp instruction") ? static_cast<
void> (0) : __assert_fail ("getOperand(0)->getType()->isFPOrFPVectorTy() && \"Invalid operand types for FCmp instruction\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 1351, __PRETTY_FUNCTION__));
}

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

/// Clone an identical FCmpInst
FCmpInst *cloneImpl() const;

1361public:
/// Constructor with insert-before-instruction semantics.
FCmpInst(
  Instruction *InsertBefore, ///< Where to insert
  Predicate pred,  ///< The predicate to use for the comparison
  Value *LHS,      ///< The left-hand-side of the expression
  Value *RHS,      ///< The right-hand-side of the expression
  const Twine &NameStr = ""  ///< Name of the instruction
) : CmpInst(makeCmpResultType(LHS->getType()),
            Instruction::FCmp, pred, LHS, RHS, NameStr,
            InsertBefore) {
  AssertOK();
}

/// Constructor with insert-at-end semantics.
FCmpInst(
  BasicBlock &InsertAtEnd, ///< Block to insert into.
  Predicate pred,  ///< The predicate to use for the comparison
  Value *LHS,      ///< The left-hand-side of the expression
  Value *RHS,      ///< The right-hand-side of the expression
  const Twine &NameStr = ""  ///< Name of the instruction
) : CmpInst(makeCmpResultType(LHS->getType()),
            Instruction::FCmp, pred, LHS, RHS, NameStr,
            &InsertAtEnd) {
  AssertOK();
}

/// Constructor with no-insertion semantics
FCmpInst(
  Predicate Pred, ///< The predicate to use for the comparison
  Value *LHS,     ///< The left-hand-side of the expression
  Value *RHS,     ///< The right-hand-side of the expression
  const Twine &NameStr = "", ///< Name of the instruction
  Instruction *FlagsSource = nullptr
) : CmpInst(makeCmpResultType(LHS->getType()), Instruction::FCmp, Pred, LHS,
            RHS, NameStr, nullptr, FlagsSource) {
  AssertOK();
}

/// @returns true if the predicate of this instruction is EQ or NE.
/// Determine if this is an equality predicate.
static bool isEquality(Predicate Pred) {
  return Pred == FCMP_OEQ || Pred == FCMP_ONE || Pred == FCMP_UEQ ||
         Pred == FCMP_UNE;
}

/// @returns true if the predicate of this instruction is EQ or NE.
/// Determine if this is an equality predicate.
bool isEquality() const { return isEquality(getPredicate()); }

/// @returns true if the predicate of this instruction is commutative.
/// Determine if this is a commutative predicate.
bool isCommutative() const {
  return isEquality() ||
         getPredicate() == FCMP_FALSE ||
         getPredicate() == FCMP_TRUE ||
         getPredicate() == FCMP_ORD ||
         getPredicate() == FCMP_UNO;
}

/// @returns true if the predicate is relational (not EQ or NE).
/// Determine if this a relational predicate.
bool isRelational() const { return !isEquality(); }

/// Exchange the two operands to this instruction in such a way that it does
/// not modify the semantics of the instruction. The predicate value may be
/// changed to retain the same result if the predicate is order dependent
/// (e.g. ult).
/// Swap operands and adjust predicate.
void swapOperands() {
  setPredicate(getSwappedPredicate());
  Op<0>().swap(Op<1>());
}

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

1444//===----------------------------------------------------------------------===//
1445/// This class represents a function call, abstracting a target
1446/// machine's calling convention.  This class uses low bit of the SubClassData
1447/// field to indicate whether or not this is a tail call.  The rest of the bits
1448/// hold the calling convention of the call.
1449///
1450class CallInst : public CallBase {
CallInst(const CallInst &CI);

/// Construct a CallInst given a range of arguments.
/// Construct a CallInst from a range of arguments
inline CallInst(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
                ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr,
                Instruction *InsertBefore);

inline CallInst(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
                const Twine &NameStr, Instruction *InsertBefore)
    : CallInst(Ty, Func, Args, None, NameStr, InsertBefore) {}

/// Construct a CallInst given a range of arguments.
/// Construct a CallInst from a range of arguments
inline CallInst(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
                ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr,
                BasicBlock *InsertAtEnd);

explicit CallInst(FunctionType *Ty, Value *F, const Twine &NameStr,
                  Instruction *InsertBefore);

CallInst(FunctionType *ty, Value *F, const Twine &NameStr,
         BasicBlock *InsertAtEnd);

void init(FunctionType *FTy, Value *Func, ArrayRef<Value *> Args,
          ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr);
void init(FunctionType *FTy, Value *Func, const Twine &NameStr);

/// Compute the number of operands to allocate.
static int ComputeNumOperands(int NumArgs, int NumBundleInputs = 0) {
  // We need one operand for the called function, plus the input operand
  // counts provided.
  return 1 + NumArgs + NumBundleInputs;
}

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

CallInst *cloneImpl() const;

1492public:
static CallInst *Create(FunctionType *Ty, Value *F, const Twine &NameStr = "",
                        Instruction *InsertBefore = nullptr) {
  return new (ComputeNumOperands(0)) CallInst(Ty, F, NameStr, InsertBefore);
}

static CallInst *Create(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
                        const Twine &NameStr,
                        Instruction *InsertBefore = nullptr) {
  return new (ComputeNumOperands(Args.size()))
      CallInst(Ty, Func, Args, None, NameStr, InsertBefore);
}

static CallInst *Create(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
                        ArrayRef<OperandBundleDef> Bundles = None,
                        const Twine &NameStr = "",
                        Instruction *InsertBefore = nullptr) {
  const int NumOperands =
      ComputeNumOperands(Args.size(), CountBundleInputs(Bundles));
  const unsigned DescriptorBytes = Bundles.size() * sizeof(BundleOpInfo);

  return new (NumOperands, DescriptorBytes)
      CallInst(Ty, Func, Args, Bundles, NameStr, InsertBefore);
}

static CallInst *Create(FunctionType *Ty, Value *F, const Twine &NameStr,
                        BasicBlock *InsertAtEnd) {
  return new (ComputeNumOperands(0)) CallInst(Ty, F, NameStr, InsertAtEnd);
}

static CallInst *Create(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
                        const Twine &NameStr, BasicBlock *InsertAtEnd) {
  return new (ComputeNumOperands(Args.size()))
      CallInst(Ty, Func, Args, None, NameStr, InsertAtEnd);
}

static CallInst *Create(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
                        ArrayRef<OperandBundleDef> Bundles,
                        const Twine &NameStr, BasicBlock *InsertAtEnd) {
  const int NumOperands =
      ComputeNumOperands(Args.size(), CountBundleInputs(Bundles));
  const unsigned DescriptorBytes = Bundles.size() * sizeof(BundleOpInfo);

  return new (NumOperands, DescriptorBytes)
      CallInst(Ty, Func, Args, Bundles, NameStr, InsertAtEnd);
}

static CallInst *Create(FunctionCallee Func, const Twine &NameStr = "",
                        Instruction *InsertBefore = nullptr) {
  return Create(Func.getFunctionType(), Func.getCallee(), NameStr,
                InsertBefore);
}

static CallInst *Create(FunctionCallee Func, ArrayRef<Value *> Args,
                        ArrayRef<OperandBundleDef> Bundles = None,
                        const Twine &NameStr = "",
                        Instruction *InsertBefore = nullptr) {
  return Create(Func.getFunctionType(), Func.getCallee(), Args, Bundles,
                NameStr, InsertBefore);
}

static CallInst *Create(FunctionCallee Func, ArrayRef<Value *> Args,
                        const Twine &NameStr,
                        Instruction *InsertBefore = nullptr) {
  return Create(Func.getFunctionType(), Func.getCallee(), Args, NameStr,
                InsertBefore);
}

static CallInst *Create(FunctionCallee Func, const Twine &NameStr,
                        BasicBlock *InsertAtEnd) {
  return Create(Func.getFunctionType(), Func.getCallee(), NameStr,
                InsertAtEnd);
}

static CallInst *Create(FunctionCallee Func, ArrayRef<Value *> Args,
                        const Twine &NameStr, BasicBlock *InsertAtEnd) {
  return Create(Func.getFunctionType(), Func.getCallee(), Args, NameStr,
                InsertAtEnd);
}

static CallInst *Create(FunctionCallee Func, ArrayRef<Value *> Args,
                        ArrayRef<OperandBundleDef> Bundles,
                        const Twine &NameStr, BasicBlock *InsertAtEnd) {
  return Create(Func.getFunctionType(), Func.getCallee(), Args, Bundles,
                NameStr, InsertAtEnd);
}

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

/// Create a clone of \p CI with a different set of operand bundles and
/// insert it before \p InsertPt.
///
/// The returned call instruction is identical \p CI in every way except that
/// the operand bundle for the new instruction is set to the operand bundle
/// in \p Bundle.
static CallInst *CreateWithReplacedBundle(CallInst *CI,
                                          OperandBundleDef Bundle,
                                          Instruction *InsertPt = nullptr);

/// Generate the IR for a call to malloc:
/// 1. Compute the malloc call's argument as the specified type's size,
///    possibly multiplied by the array size if the array size is not
///    constant 1.
/// 2. Call malloc with that argument.
/// 3. Bitcast the result of the malloc call to the specified type.
static Instruction *CreateMalloc(Instruction *InsertBefore, Type *IntPtrTy,
                                 Type *AllocTy, Value *AllocSize,
                                 Value *ArraySize = nullptr,
                                 Function *MallocF = nullptr,
                                 const Twine &Name = "");
static Instruction *CreateMalloc(BasicBlock *InsertAtEnd, Type *IntPtrTy,
                                 Type *AllocTy, Value *AllocSize,
                                 Value *ArraySize = nullptr,
                                 Function *MallocF = nullptr,
                                 const Twine &Name = "");
static Instruction *CreateMalloc(Instruction *InsertBefore, Type *IntPtrTy,
                                 Type *AllocTy, Value *AllocSize,
                                 Value *ArraySize = nullptr,
                                 ArrayRef<OperandBundleDef> Bundles = None,
                                 Function *MallocF = nullptr,
                                 const Twine &Name = "");
static Instruction *CreateMalloc(BasicBlock *InsertAtEnd, Type *IntPtrTy,
                                 Type *AllocTy, Value *AllocSize,
                                 Value *ArraySize = nullptr,
                                 ArrayRef<OperandBundleDef> Bundles = None,
                                 Function *MallocF = nullptr,
                                 const Twine &Name = "");
/// Generate the IR for a call to the builtin free function.
static Instruction *CreateFree(Value *Source, Instruction *InsertBefore);
static Instruction *CreateFree(Value *Source, BasicBlock *InsertAtEnd);
static Instruction *CreateFree(Value *Source,
                               ArrayRef<OperandBundleDef> Bundles,
                               Instruction *InsertBefore);
static Instruction *CreateFree(Value *Source,
                               ArrayRef<OperandBundleDef> Bundles,
                               BasicBlock *InsertAtEnd);

// Note that 'musttail' implies 'tail'.
enum TailCallKind : unsigned {
  TCK_None = 0,
  TCK_Tail = 1,
  TCK_MustTail = 2,
  TCK_NoTail = 3,
  TCK_LAST = TCK_NoTail
};

using TailCallKindField = Bitfield::Element<TailCallKind, 0, 2, TCK_LAST>;
static_assert(
    Bitfield::areContiguous<TailCallKindField, CallBase::CallingConvField>(),
    "Bitfields must be contiguous");

TailCallKind getTailCallKind() const {
  return getSubclassData<TailCallKindField>();
}

bool isTailCall() const {
  TailCallKind Kind = getTailCallKind();
  return Kind == TCK_Tail || Kind == TCK_MustTail;
}

bool isMustTailCall() const { return getTailCallKind() == TCK_MustTail; }

bool isNoTailCall() const { return getTailCallKind() == TCK_NoTail; }

void setTailCallKind(TailCallKind TCK) {
  setSubclassData<TailCallKindField>(TCK);
}

void setTailCall(bool IsTc = true) {
  setTailCallKind(IsTc ? TCK_Tail : TCK_None);
}

/// Return true if the call can return twice
bool canReturnTwice() const { return hasFnAttr(Attribute::ReturnsTwice); }
void setCanReturnTwice() {
  addAttribute(AttributeList::FunctionIndex, Attribute::ReturnsTwice);
}

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

/// Updates profile metadata by scaling it by \p S / \p T.
void updateProfWeight(uint64_t S, uint64_t T);

1688private:
// Shadow Instruction::setInstructionSubclassData with a private forwarding
// method so that subclasses cannot accidentally use it.
template <typename Bitfield>
void setSubclassData(typename Bitfield::Type Value) {
  Instruction::setSubclassData<Bitfield>(Value);
}
1695};

1697CallInst::CallInst(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
                 ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr,
                 BasicBlock *InsertAtEnd)
  : CallBase(Ty->getReturnType(), Instruction::Call,
             OperandTraits<CallBase>::op_end(this) -
                 (Args.size() + CountBundleInputs(Bundles) + 1),
             unsigned(Args.size() + CountBundleInputs(Bundles) + 1),
             InsertAtEnd) {
init(Ty, Func, Args, Bundles, NameStr);
1706}

1708CallInst::CallInst(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
                 ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr,
                 Instruction *InsertBefore)
  : CallBase(Ty->getReturnType(), Instruction::Call,
             OperandTraits<CallBase>::op_end(this) -
                 (Args.size() + CountBundleInputs(Bundles) + 1),
             unsigned(Args.size() + CountBundleInputs(Bundles) + 1),
             InsertBefore) {
init(Ty, Func, Args, Bundles, NameStr);
1717}

1719//===----------------------------------------------------------------------===//
1720//                               SelectInst Class
1721//===----------------------------------------------------------------------===//

1723/// This class represents the LLVM 'select' instruction.
1724///
1725class SelectInst : public Instruction {
SelectInst(Value *C, Value *S1, Value *S2, const Twine &NameStr,
           Instruction *InsertBefore)
  : Instruction(S1->getType(), Instruction::Select,
                &Op<0>(), 3, InsertBefore) {
  init(C, S1, S2);
  setName(NameStr);
}

SelectInst(Value *C, Value *S1, Value *S2, const Twine &NameStr,
           BasicBlock *InsertAtEnd)
  : Instruction(S1->getType(), Instruction::Select,
                &Op<0>(), 3, InsertAtEnd) {
  init(C, S1, S2);
  setName(NameStr);
}

void init(Value *C, Value *S1, Value *S2) {
  assert(!areInvalidOperands(C, S1, S2) && "Invalid operands for select")((!areInvalidOperands(C, S1, S2) && "Invalid operands for select"
) ? static_cast<void> (0) : __assert_fail ("!areInvalidOperands(C, S1, S2) && \"Invalid operands for select\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 1743, __PRETTY_FUNCTION__));
  Op<0>() = C;
  Op<1>() = S1;
  Op<2>() = S2;
}

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

SelectInst *cloneImpl() const;

1755public:
static SelectInst *Create(Value *C, Value *S1, Value *S2,
                          const Twine &NameStr = "",
                          Instruction *InsertBefore = nullptr,
                          Instruction *MDFrom = nullptr) {
  SelectInst *Sel = new(3) SelectInst(C, S1, S2, NameStr, InsertBefore);
  if (MDFrom)
    Sel->copyMetadata(*MDFrom);
  return Sel;
}

static SelectInst *Create(Value *C, Value *S1, Value *S2,
                          const Twine &NameStr,
                          BasicBlock *InsertAtEnd) {
  return new(3) SelectInst(C, S1, S2, NameStr, InsertAtEnd);
}

const Value *getCondition() const { return Op<0>(); }
const Value *getTrueValue() const { return Op<1>(); }
const Value *getFalseValue() const { return Op<2>(); }
Value *getCondition() { return Op<0>(); }
Value *getTrueValue() { return Op<1>(); }
Value *getFalseValue() { return Op<2>(); }

void setCondition(Value *V) { Op<0>() = V; }
void setTrueValue(Value *V) { Op<1>() = V; }
void setFalseValue(Value *V) { Op<2>() = V; }

/// Swap the true and false values of the select instruction.
/// This doesn't swap prof metadata.
void swapValues() { Op<1>().swap(Op<2>()); }

/// Return a string if the specified operands are invalid
/// for a select operation, otherwise return null.
static const char *areInvalidOperands(Value *Cond, Value *True, Value *False);

/// 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;

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

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

1807template <>
1808struct OperandTraits<SelectInst> : public FixedNumOperandTraits<SelectInst, 3> {
1809};

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

1813//===----------------------------------------------------------------------===//
1814//                                VAArgInst Class
1815//===----------------------------------------------------------------------===//

1817/// This class represents the va_arg llvm instruction, which returns
1818/// an argument of the specified type given a va_list and increments that list
1819///
1820class VAArgInst : public UnaryInstruction {
1821protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

VAArgInst *cloneImpl() const;

1827public:
VAArgInst(Value *List, Type *Ty, const Twine &NameStr = "",
           Instruction *InsertBefore = nullptr)
  : UnaryInstruction(Ty, VAArg, List, InsertBefore) {
  setName(NameStr);
}

VAArgInst(Value *List, Type *Ty, const Twine &NameStr,
          BasicBlock *InsertAtEnd)
  : UnaryInstruction(Ty, VAArg, List, InsertAtEnd) {
  setName(NameStr);
}

Value *getPointerOperand() { return getOperand(0); }
const Value *getPointerOperand() const { return getOperand(0); }
static unsigned getPointerOperandIndex() { return 0U; }

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

1853//===----------------------------------------------------------------------===//
1854//                                ExtractElementInst Class
1855//===----------------------------------------------------------------------===//

1857/// This instruction extracts a single (scalar)
1858/// element from a VectorType value
1859///
1860class ExtractElementInst : public Instruction {
ExtractElementInst(Value *Vec, Value *Idx, const Twine &NameStr = "",
                   Instruction *InsertBefore = nullptr);
ExtractElementInst(Value *Vec, Value *Idx, const Twine &NameStr,
                   BasicBlock *InsertAtEnd);

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

ExtractElementInst *cloneImpl() const;

1872public:
static ExtractElementInst *Create(Value *Vec, Value *Idx,
                                 const Twine &NameStr = "",
                                 Instruction *InsertBefore = nullptr) {
  return new(2) ExtractElementInst(Vec, Idx, NameStr, InsertBefore);
}

static ExtractElementInst *Create(Value *Vec, Value *Idx,
                                 const Twine &NameStr,
                                 BasicBlock *InsertAtEnd) {
  return new(2) ExtractElementInst(Vec, Idx, NameStr, InsertAtEnd);
}

/// Return true if an extractelement instruction can be
/// formed with the specified operands.
static bool isValidOperands(const Value *Vec, const Value *Idx);

Value *getVectorOperand() { return Op<0>(); }
Value *getIndexOperand() { return Op<1>(); }
const Value *getVectorOperand() const { return Op<0>(); }
const Value *getIndexOperand() const { return Op<1>(); }

VectorType *getVectorOperandType() const {
  return cast<VectorType>(getVectorOperand()->getType());
}

/// 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->getOpcode() == Instruction::ExtractElement;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}
1908};

1910template <>
1911struct OperandTraits<ExtractElementInst> :
public FixedNumOperandTraits<ExtractElementInst, 2> {
1913};

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

1917//===----------------------------------------------------------------------===//
1918//                                InsertElementInst Class
1919//===----------------------------------------------------------------------===//

1921/// This instruction inserts a single (scalar)
1922/// element into a VectorType value
1923///
1924class InsertElementInst : public Instruction {
InsertElementInst(Value *Vec, Value *NewElt, Value *Idx,
                  const Twine &NameStr = "",
                  Instruction *InsertBefore = nullptr);
InsertElementInst(Value *Vec, Value *NewElt, Value *Idx, const Twine &NameStr,
                  BasicBlock *InsertAtEnd);

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

InsertElementInst *cloneImpl() const;

1937public:
static InsertElementInst *Create(Value *Vec, Value *NewElt, Value *Idx,
                                 const Twine &NameStr = "",
                                 Instruction *InsertBefore = nullptr) {
  return new(3) InsertElementInst(Vec, NewElt, Idx, NameStr, InsertBefore);
}

static InsertElementInst *Create(Value *Vec, Value *NewElt, Value *Idx,
                                 const Twine &NameStr,
                                 BasicBlock *InsertAtEnd) {
  return new(3) InsertElementInst(Vec, NewElt, Idx, NameStr, InsertAtEnd);
}

/// Return true if an insertelement instruction can be
/// formed with the specified operands.
static bool isValidOperands(const Value *Vec, const Value *NewElt,
                            const Value *Idx);

/// Overload to return most specific vector type.
///
VectorType *getType() const {
  return cast<VectorType>(Instruction::getType());
}

/// 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->getOpcode() == Instruction::InsertElement;
}
static bool classof(const Value *V) {
  return isa<Instruction>(V) && classof(cast<Instruction>(V));
}
1971};

1973template <>
1974struct OperandTraits<InsertElementInst> :
public FixedNumOperandTraits<InsertElementInst, 3> {
1976};

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

1980//===----------------------------------------------------------------------===//
1981//                           ShuffleVectorInst Class
1982//===----------------------------------------------------------------------===//

1984constexpr int UndefMaskElem = -1;

1986/// This instruction constructs a fixed permutation of two
1987/// input vectors.
1988///
1989/// For each element of the result vector, the shuffle mask selects an element
1990/// from one of the input vectors to copy to the result. Non-negative elements
1991/// in the mask represent an index into the concatenated pair of input vectors.
1992/// UndefMaskElem (-1) specifies that the result element is undefined.
1993///
1994/// For scalable vectors, all the elements of the mask must be 0 or -1. This
1995/// requirement may be relaxed in the future.
1996class ShuffleVectorInst : public Instruction {
SmallVector<int, 4> ShuffleMask;
Constant *ShuffleMaskForBitcode;

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

ShuffleVectorInst *cloneImpl() const;

2006public:
ShuffleVectorInst(Value *V1, Value *V2, Value *Mask,
                  const Twine &NameStr = "",
                  Instruction *InsertBefor = nullptr);
ShuffleVectorInst(Value *V1, Value *V2, Value *Mask,
                  const Twine &NameStr, BasicBlock *InsertAtEnd);
ShuffleVectorInst(Value *V1, Value *V2, ArrayRef<int> Mask,
                  const Twine &NameStr = "",
                  Instruction *InsertBefor = nullptr);
ShuffleVectorInst(Value *V1, Value *V2, ArrayRef<int> Mask,
                  const Twine &NameStr, BasicBlock *InsertAtEnd);

void *operator new(size_t s) { return User::operator new(s, 2); }

/// Swap the operands and adjust the mask to preserve the semantics
/// of the instruction.
void commute();

/// Return true if a shufflevector instruction can be
/// formed with the specified operands.
static bool isValidOperands(const Value *V1, const Value *V2,
                            const Value *Mask);
static bool isValidOperands(const Value *V1, const Value *V2,
                            ArrayRef<int> Mask);

/// Overload to return most specific vector type.
///
VectorType *getType() const {
  return cast<VectorType>(Instruction::getType());
}

/// 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;

/// Return the shuffle mask value of this instruction for the given element
/// index. Return UndefMaskElem if the element is undef.
int getMaskValue(unsigned Elt) const { return ShuffleMask[Elt]; }

/// Convert the input shuffle mask operand to a vector of integers. Undefined
/// elements of the mask are returned as UndefMaskElem.
static void getShuffleMask(const Constant *Mask,
                           SmallVectorImpl<int> &Result);

/// Return the mask for this instruction as a vector of integers. Undefined
/// elements of the mask are returned as UndefMaskElem.
void getShuffleMask(SmallVectorImpl<int> &Result) const {
  Result.assign(ShuffleMask.begin(), ShuffleMask.end());
}

/// Return the mask for this instruction, for use in bitcode.
///
/// TODO: This is temporary until we decide a new bitcode encoding for
/// shufflevector.
Constant *getShuffleMaskForBitcode() const { return ShuffleMaskForBitcode; }

static Constant *convertShuffleMaskForBitcode(ArrayRef<int> Mask,
                                              Type *ResultTy);

void setShuffleMask(ArrayRef<int> Mask);

ArrayRef<int> getShuffleMask() const { return ShuffleMask; }

/// Return true if this shuffle returns a vector with a different number of
/// elements than its source vectors.
/// Examples: shufflevector <4 x n> A, <4 x n> B, <1,2,3>
///           shufflevector <4 x n> A, <4 x n> B, <1,2,3,4,5>
bool changesLength() const {
  unsigned NumSourceElts = cast<VectorType>(Op<0>()->getType())
                               ->getElementCount()
                               .getKnownMinValue();
  unsigned NumMaskElts = ShuffleMask.size();
  return NumSourceElts != NumMaskElts;
}

/// Return true if this shuffle returns a vector with a greater number of
/// elements than its source vectors.
/// Example: shufflevector <2 x n> A, <2 x n> B, <1,2,3>
bool increasesLength() const {
  unsigned NumSourceElts =
      cast<FixedVectorType>(Op<0>()->getType())->getNumElements();
  unsigned NumMaskElts = ShuffleMask.size();
  return NumSourceElts < NumMaskElts;
}

/// Return true if this shuffle mask chooses elements from exactly one source
/// vector.
/// Example: <7,5,undef,7>
/// This assumes that vector operands are the same length as the mask.
static bool isSingleSourceMask(ArrayRef<int> Mask);
static bool isSingleSourceMask(const Constant *Mask) {
  assert(Mask->getType()->isVectorTy() && "Shuffle needs vector constant.")((Mask->getType()->isVectorTy() && "Shuffle needs vector constant."
) ? static_cast<void> (0) : __assert_fail ("Mask->getType()->isVectorTy() && \"Shuffle needs vector constant.\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 2096, __PRETTY_FUNCTION__));
  SmallVector<int, 16> MaskAsInts;
  getShuffleMask(Mask, MaskAsInts);
  return isSingleSourceMask(MaskAsInts);
}

/// Return true if this shuffle chooses elements from exactly one source
/// vector without changing the length of that vector.
/// Example: shufflevector <4 x n> A, <4 x n> B, <3,0,undef,3>
/// TODO: Optionally allow length-changing shuffles.
bool isSingleSource() const {
  return !changesLength() && isSingleSourceMask(ShuffleMask);
}

/// Return true if this shuffle mask chooses elements from exactly one source
/// vector without lane crossings. A shuffle using this mask is not
/// necessarily a no-op because it may change the number of elements from its
/// input vectors or it may provide demanded bits knowledge via undef lanes.
/// Example: <undef,undef,2,3>
static bool isIdentityMask(ArrayRef<int> Mask);
static bool isIdentityMask(const Constant *Mask) {
  assert(Mask->getType()->isVectorTy() && "Shuffle needs vector constant.")((Mask->getType()->isVectorTy() && "Shuffle needs vector constant."
) ? static_cast<void> (0) : __assert_fail ("Mask->getType()->isVectorTy() && \"Shuffle needs vector constant.\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 2117, __PRETTY_FUNCTION__));
  SmallVector<int, 16> MaskAsInts;
  getShuffleMask(Mask, MaskAsInts);
  return isIdentityMask(MaskAsInts);
}

/// Return true if this shuffle chooses elements from exactly one source
/// vector without lane crossings and does not change the number of elements
/// from its input vectors.
/// Example: shufflevector <4 x n> A, <4 x n> B, <4,undef,6,undef>
bool isIdentity() const {
  return !changesLength() && isIdentityMask(ShuffleMask);
}

/// Return true if this shuffle lengthens exactly one source vector with
/// undefs in the high elements.
bool isIdentityWithPadding() const;

/// Return true if this shuffle extracts the first N elements of exactly one
/// source vector.
bool isIdentityWithExtract() const;

/// Return true if this shuffle concatenates its 2 source vectors. This
/// returns false if either input is undefined. In that case, the shuffle is
/// is better classified as an identity with padding operation.
bool isConcat() const;

/// Return true if this shuffle mask chooses elements from its source vectors
/// without lane crossings. A shuffle using this mask would be
/// equivalent to a vector select with a constant condition operand.
/// Example: <4,1,6,undef>
/// This returns false if the mask does not choose from both input vectors.
/// In that case, the shuffle is better classified as an identity shuffle.
/// This assumes that vector operands are the same length as the mask
/// (a length-changing shuffle can never be equivalent to a vector select).
static bool isSelectMask(ArrayRef<int> Mask);
static bool isSelectMask(const Constant *Mask) {
  assert(Mask->getType()->isVectorTy() && "Shuffle needs vector constant.")((Mask->getType()->isVectorTy() && "Shuffle needs vector constant."
) ? static_cast<void> (0) : __assert_fail ("Mask->getType()->isVectorTy() && \"Shuffle needs vector constant.\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 2154, __PRETTY_FUNCTION__));
  SmallVector<int, 16> MaskAsInts;
  getShuffleMask(Mask, MaskAsInts);
  return isSelectMask(MaskAsInts);
}

/// Return true if this shuffle chooses elements from its source vectors
/// without lane crossings and all operands have the same number of elements.
/// In other words, this shuffle is equivalent to a vector select with a
/// constant condition operand.
/// Example: shufflevector <4 x n> A, <4 x n> B, <undef,1,6,3>
/// This returns false if the mask does not choose from both input vectors.
/// In that case, the shuffle is better classified as an identity shuffle.
/// TODO: Optionally allow length-changing shuffles.
bool isSelect() const {
  return !changesLength() && isSelectMask(ShuffleMask);
}

/// Return true if this shuffle mask swaps the order of elements from exactly
/// one source vector.
/// Example: <7,6,undef,4>
/// This assumes that vector operands are the same length as the mask.
static bool isReverseMask(ArrayRef<int> Mask);
static bool isReverseMask(const Constant *Mask) {
  assert(Mask->getType()->isVectorTy() && "Shuffle needs vector constant.")((Mask->getType()->isVectorTy() && "Shuffle needs vector constant."
) ? static_cast<void> (0) : __assert_fail ("Mask->getType()->isVectorTy() && \"Shuffle needs vector constant.\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 2178, __PRETTY_FUNCTION__));
  SmallVector<int, 16> MaskAsInts;
  getShuffleMask(Mask, MaskAsInts);
  return isReverseMask(MaskAsInts);
}

/// Return true if this shuffle swaps the order of elements from exactly
/// one source vector.
/// Example: shufflevector <4 x n> A, <4 x n> B, <3,undef,1,undef>
/// TODO: Optionally allow length-changing shuffles.
bool isReverse() const {
  return !changesLength() && isReverseMask(ShuffleMask);
}

/// Return true if this shuffle mask chooses all elements with the same value
/// as the first element of exactly one source vector.
/// Example: <4,undef,undef,4>
/// This assumes that vector operands are the same length as the mask.
static bool isZeroEltSplatMask(ArrayRef<int> Mask);
static bool isZeroEltSplatMask(const Constant *Mask) {
  assert(Mask->getType()->isVectorTy() && "Shuffle needs vector constant.")((Mask->getType()->isVectorTy() && "Shuffle needs vector constant."
) ? static_cast<void> (0) : __assert_fail ("Mask->getType()->isVectorTy() && \"Shuffle needs vector constant.\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 2198, __PRETTY_FUNCTION__));
  SmallVector<int, 16> MaskAsInts;
  getShuffleMask(Mask, MaskAsInts);
  return isZeroEltSplatMask(MaskAsInts);
}

/// Return true if all elements of this shuffle are the same value as the
/// first element of exactly one source vector without changing the length
/// of that vector.
/// Example: shufflevector <4 x n> A, <4 x n> B, <undef,0,undef,0>
/// TODO: Optionally allow length-changing shuffles.
/// TODO: Optionally allow splats from other elements.
bool isZeroEltSplat() const {
  return !changesLength() && isZeroEltSplatMask(ShuffleMask);
}

/// Return true if this shuffle mask is a transpose mask.
/// Transpose vector masks transpose a 2xn matrix. They read corresponding
/// even- or odd-numbered vector elements from two n-dimensional source
/// vectors and write each result into consecutive elements of an
/// n-dimensional destination vector. Two shuffles are necessary to complete
/// the transpose, one for the even elements and another for the odd elements.
/// This description closely follows how the TRN1 and TRN2 AArch64
/// instructions operate.
///
/// For example, a simple 2x2 matrix can be transposed with:
///
///   ; Original matrix
///   m0 = < a, b >
///   m1 = < c, d >
///
///   ; Transposed matrix
///   t0 = < a, c > = shufflevector m0, m1, < 0, 2 >
///   t1 = < b, d > = shufflevector m0, m1, < 1, 3 >
///
/// For matrices having greater than n columns, the resulting nx2 transposed
/// matrix is stored in two result vectors such that one vector contains
/// interleaved elements from all the even-numbered rows and the other vector
/// contains interleaved elements from all the odd-numbered rows. For example,
/// a 2x4 matrix can be transposed with:
///
///   ; Original matrix
///   m0 = < a, b, c, d >
///   m1 = < e, f, g, h >
///
///   ; Transposed matrix
///   t0 = < a, e, c, g > = shufflevector m0, m1 < 0, 4, 2, 6 >
///   t1 = < b, f, d, h > = shufflevector m0, m1 < 1, 5, 3, 7 >
static bool isTransposeMask(ArrayRef<int> Mask);
static bool isTransposeMask(const Constant *Mask) {
  assert(Mask->getType()->isVectorTy() && "Shuffle needs vector constant.")((Mask->getType()->isVectorTy() && "Shuffle needs vector constant."
) ? static_cast<void> (0) : __assert_fail ("Mask->getType()->isVectorTy() && \"Shuffle needs vector constant.\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 2248, __PRETTY_FUNCTION__));
  SmallVector<int, 16> MaskAsInts;
  getShuffleMask(Mask, MaskAsInts);
  return isTransposeMask(MaskAsInts);
}

/// Return true if this shuffle transposes the elements of its inputs without
/// changing the length of the vectors. This operation may also be known as a
/// merge or interleave. See the description for isTransposeMask() for the
/// exact specification.
/// Example: shufflevector <4 x n> A, <4 x n> B, <0,4,2,6>
bool isTranspose() const {
  return !changesLength() && isTransposeMask(ShuffleMask);
}

/// Return true if this shuffle mask is an extract subvector mask.
/// A valid extract subvector mask returns a smaller vector from a single
/// source operand. The base extraction index is returned as well.
static bool isExtractSubvectorMask(ArrayRef<int> Mask, int NumSrcElts,
                                   int &Index);
static bool isExtractSubvectorMask(const Constant *Mask, int NumSrcElts,
                                   int &Index) {
  assert(Mask->getType()->isVectorTy() && "Shuffle needs vector constant.")((Mask->getType()->isVectorTy() && "Shuffle needs vector constant."
) ? static_cast<void> (0) : __assert_fail ("Mask->getType()->isVectorTy() && \"Shuffle needs vector constant.\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 2270, __PRETTY_FUNCTION__));
  SmallVector<int, 16> MaskAsInts;
  getShuffleMask(Mask, MaskAsInts);
  return isExtractSubvectorMask(MaskAsInts, NumSrcElts, Index);
}

/// Return true if this shuffle mask is an extract subvector mask.
bool isExtractSubvectorMask(int &Index) const {
  int NumSrcElts =
      cast<FixedVectorType>(Op<0>()->getType())->getNumElements();
  return isExtractSubvectorMask(ShuffleMask, NumSrcElts, Index);
}

/// Change values in a shuffle permute mask assuming the two vector operands
/// of length InVecNumElts have swapped position.
static void commuteShuffleMask(MutableArrayRef<int> Mask,
                               unsigned InVecNumElts) {
  for (int &Idx : Mask) {
    if (Idx == -1)
      continue;
    Idx = Idx < (int)InVecNumElts ? Idx + InVecNumElts : Idx - InVecNumElts;
    assert(Idx >= 0 && Idx < (int)InVecNumElts * 2 &&((Idx >= 0 && Idx < (int)InVecNumElts * 2 &&
 "shufflevector mask index out of range") ? static_cast<void
> (0) : __assert_fail ("Idx >= 0 && Idx < (int)InVecNumElts * 2 && \"shufflevector mask index out of range\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 2292, __PRETTY_FUNCTION__))
           "shufflevector mask index out of range")((Idx >= 0 && Idx < (int)InVecNumElts * 2 &&
 "shufflevector mask index out of range") ? static_cast<void
> (0) : __assert_fail ("Idx >= 0 && Idx < (int)InVecNumElts * 2 && \"shufflevector mask index out of range\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 2292, __PRETTY_FUNCTION__));
  }
}

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

2305template <>
2306struct OperandTraits<ShuffleVectorInst>
  : public FixedNumOperandTraits<ShuffleVectorInst, 2> {};

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

2311//===----------------------------------------------------------------------===//
2312//                                ExtractValueInst Class
2313//===----------------------------------------------------------------------===//

2315/// This instruction extracts a struct member or array
2316/// element value from an aggregate value.
2317///
2318class ExtractValueInst : public UnaryInstruction {
SmallVector<unsigned, 4> Indices;

ExtractValueInst(const ExtractValueInst &EVI);

/// Constructors - Create a extractvalue instruction with a base aggregate
/// value and a list of indices.  The first ctor can optionally insert before
/// an existing instruction, the second appends the new instruction to the
/// specified BasicBlock.
inline ExtractValueInst(Value *Agg,
                        ArrayRef<unsigned> Idxs,
                        const Twine &NameStr,
                        Instruction *InsertBefore);
inline ExtractValueInst(Value *Agg,
                        ArrayRef<unsigned> Idxs,
                        const Twine &NameStr, BasicBlock *InsertAtEnd);

void init(ArrayRef<unsigned> Idxs, const Twine &NameStr);

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

ExtractValueInst *cloneImpl() const;

2343public:
static ExtractValueInst *Create(Value *Agg,
                                ArrayRef<unsigned> Idxs,
                                const Twine &NameStr = "",
                                Instruction *InsertBefore = nullptr) {
  return new
    ExtractValueInst(Agg, Idxs, NameStr, InsertBefore);
}

static ExtractValueInst *Create(Value *Agg,
                                ArrayRef<unsigned> Idxs,
                                const Twine &NameStr,
                                BasicBlock *InsertAtEnd) {
  return new ExtractValueInst(Agg, Idxs, NameStr, InsertAtEnd);
}

/// Returns the type of the element that would be extracted
/// with an extractvalue instruction with the specified parameters.
///
/// Null is returned if the indices are invalid for the specified type.
static Type *getIndexedType(Type *Agg, ArrayRef<unsigned> Idxs);

using idx_iterator = const unsigned*;

inline idx_iterator idx_begin() const { return Indices.begin(); }
inline idx_iterator idx_end()   const { return Indices.end(); }
inline iterator_range<idx_iterator> indices() const {
  return make_range(idx_begin(), idx_end());
}

Value *getAggregateOperand() {
  return getOperand(0);
}
const Value *getAggregateOperand() const {
  return getOperand(0);
}
static unsigned getAggregateOperandIndex() {
  return 0U;                      // get index for modifying correct operand
}

ArrayRef<unsigned> getIndices() const {
  return Indices;
}

unsigned getNumIndices() const {
  return (unsigned)Indices.size();
}

bool hasIndices() const {
  return true;
}

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

2404ExtractValueInst::ExtractValueInst(Value *Agg,
                                 ArrayRef<unsigned> Idxs,
                                 const Twine &NameStr,
                                 Instruction *InsertBefore)
: UnaryInstruction(checkGEPType(getIndexedType(Agg->getType(), Idxs)),
                   ExtractValue, Agg, InsertBefore) {
init(Idxs, NameStr);
2411}

2413ExtractValueInst::ExtractValueInst(Value *Agg,
                                 ArrayRef<unsigned> Idxs,
                                 const Twine &NameStr,
                                 BasicBlock *InsertAtEnd)
: UnaryInstruction(checkGEPType(getIndexedType(Agg->getType(), Idxs)),
                   ExtractValue, Agg, InsertAtEnd) {
init(Idxs, NameStr);
2420}

2422//===----------------------------------------------------------------------===//
2423//                                InsertValueInst Class
2424//===----------------------------------------------------------------------===//

2426/// This instruction inserts a struct field of array element
2427/// value into an aggregate value.
2428///
2429class InsertValueInst : public Instruction {
SmallVector<unsigned, 4> Indices;

InsertValueInst(const InsertValueInst &IVI);

/// Constructors - Create a insertvalue instruction with a base aggregate
/// value, a value to insert, and a list of indices.  The first ctor can
/// optionally insert before an existing instruction, the second appends
/// the new instruction to the specified BasicBlock.
inline InsertValueInst(Value *Agg, Value *Val,
                       ArrayRef<unsigned> Idxs,
                       const Twine &NameStr,
                       Instruction *InsertBefore);
inline InsertValueInst(Value *Agg, Value *Val,
                       ArrayRef<unsigned> Idxs,
                       const Twine &NameStr, BasicBlock *InsertAtEnd);

/// Constructors - These two constructors are convenience methods because one
/// and two index insertvalue instructions are so common.
InsertValueInst(Value *Agg, Value *Val, unsigned Idx,
                const Twine &NameStr = "",
                Instruction *InsertBefore = nullptr);
InsertValueInst(Value *Agg, Value *Val, unsigned Idx, const Twine &NameStr,
                BasicBlock *InsertAtEnd);

void init(Value *Agg, Value *Val, ArrayRef<unsigned> Idxs,
          const Twine &NameStr);

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

InsertValueInst *cloneImpl() const;

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

static InsertValueInst *Create(Value *Agg, Value *Val,
                               ArrayRef<unsigned> Idxs,
                               const Twine &NameStr = "",
                               Instruction *InsertBefore = nullptr) {
  return new InsertValueInst(Agg, Val, Idxs, NameStr, InsertBefore);
}

static InsertValueInst *Create(Value *Agg, Value *Val,
                               ArrayRef<unsigned> Idxs,
                               const Twine &NameStr,
                               BasicBlock *InsertAtEnd) {
  return new InsertValueInst(Agg, Val, Idxs, NameStr, InsertAtEnd);
}

/// 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;

using idx_iterator = const unsigned*;

inline idx_iterator idx_begin() const { return Indices.begin(); }
inline idx_iterator idx_end()   const { return Indices.end(); }
inline iterator_range<idx_iterator> indices() const {
  return make_range(idx_begin(), idx_end());
}

Value *getAggregateOperand() {
  return getOperand(0);
}
const Value *getAggregateOperand() const {
  return getOperand(0);
}
static unsigned getAggregateOperandIndex() {
  return 0U;                      // get index for modifying correct operand
}

Value *getInsertedValueOperand() {
  return getOperand(1);
}
const Value *getInsertedValueOperand() const {
  return getOperand(1);
}
static unsigned getInsertedValueOperandIndex() {
  return 1U;                      // get index for modifying correct operand
}

ArrayRef<unsigned> getIndices() const {
  return Indices;
}

unsigned getNumIndices() const {
  return (unsigned)Indices.size();
}

bool hasIndices() const {
  return true;
}

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

2535template <>
2536struct OperandTraits<InsertValueInst> :
public FixedNumOperandTraits<InsertValueInst, 2> {
2538};

2540InsertValueInst::InsertValueInst(Value *Agg,
                               Value *Val,
                               ArrayRef<unsigned> Idxs,
                               const Twine &NameStr,
                               Instruction *InsertBefore)
: Instruction(Agg->getType(), InsertValue,
              OperandTraits<InsertValueInst>::op_begin(this),
              2, InsertBefore) {
init(Agg, Val, Idxs, NameStr);
2549}

2551InsertValueInst::InsertValueInst(Value *Agg,
                               Value *Val,
                               ArrayRef<unsigned> Idxs,
                               const Twine &NameStr,
                               BasicBlock *InsertAtEnd)
: Instruction(Agg->getType(), InsertValue,
              OperandTraits<InsertValueInst>::op_begin(this),
              2, InsertAtEnd) {
init(Agg, Val, Idxs, NameStr);
2560}

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

2564//===----------------------------------------------------------------------===//
2565//                               PHINode Class
2566//===----------------------------------------------------------------------===//

2568// PHINode - The PHINode class is used to represent the magical mystical PHI
2569// node, that can not exist in nature, but can be synthesized in a computer
2570// scientist's overactive imagination.
2571//
2572class PHINode : public Instruction {
/// The number of operands actually allocated.  NumOperands is
/// the number actually in use.
unsigned ReservedSpace;

PHINode(const PHINode &PN);

explicit PHINode(Type *Ty, unsigned NumReservedValues,
                 const Twine &NameStr = "",
                 Instruction *InsertBefore = nullptr)
  : Instruction(Ty, Instruction::PHI, nullptr, 0, InsertBefore),
    ReservedSpace(NumReservedValues) {
  setName(NameStr);
  allocHungoffUses(ReservedSpace);
}

PHINode(Type *Ty, unsigned NumReservedValues, const Twine &NameStr,
        BasicBlock *InsertAtEnd)
  : Instruction(Ty, Instruction::PHI, nullptr, 0, InsertAtEnd),
    ReservedSpace(NumReservedValues) {
  setName(NameStr);
  allocHungoffUses(ReservedSpace);
}

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

PHINode *cloneImpl() const;

// allocHungoffUses - this is more complicated than the generic
// User::allocHungoffUses, because we have to allocate Uses for the incoming
// values and pointers to the incoming blocks, all in one allocation.
void allocHungoffUses(unsigned N) {
  User::allocHungoffUses(N, /* IsPhi */ true);
}

2609public:
/// Constructors - NumReservedValues is a hint for the number of incoming
/// edges that this phi node will have (use 0 if you really have no idea).
static PHINode *Create(Type *Ty, unsigned NumReservedValues,
                       const Twine &NameStr = "",
                       Instruction *InsertBefore = nullptr) {
  return new PHINode(Ty, NumReservedValues, NameStr, InsertBefore);
}

static PHINode *Create(Type *Ty, unsigned NumReservedValues,
                       const Twine &NameStr, BasicBlock *InsertAtEnd) {
  return new PHINode(Ty, NumReservedValues, NameStr, InsertAtEnd);
}

/// 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;

// Block iterator interface. This provides access to the list of incoming
// basic blocks, which parallels the list of incoming values.

using block_iterator = BasicBlock **;
using const_block_iterator = BasicBlock * const *;

block_iterator block_begin() {
  return reinterpret_cast<block_iterator>(op_begin() + ReservedSpace);
}

const_block_iterator block_begin() const {
  return reinterpret_cast<const_block_iterator>(op_begin() + ReservedSpace);
}

block_iterator block_end() {
  return block_begin() + getNumOperands();
}

const_block_iterator block_end() const {
  return block_begin() + getNumOperands();
}

iterator_range<block_iterator> blocks() {
  return make_range(block_begin(), block_end());
}

iterator_range<const_block_iterator> blocks() const {
  return make_range(block_begin(), block_end());
}

op_range incoming_values() { return operands(); }

const_op_range incoming_values() const { return operands(); }

/// Return the number of incoming edges
///
unsigned getNumIncomingValues() const { return getNumOperands(); }

/// Return incoming value number x
///
Value *getIncomingValue(unsigned i) const {
  return getOperand(i);
}
void setIncomingValue(unsigned i, Value *V) {
  assert(V && "PHI node got a null value!")((V && "PHI node got a null value!") ? static_cast<
void> (0) : __assert_fail ("V && \"PHI node got a null value!\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 2670, __PRETTY_FUNCTION__));
  assert(getType() == V->getType() &&((getType() == V->getType() && "All operands to PHI node must be the same type as the PHI node!"
) ? static_cast<void> (0) : __assert_fail ("getType() == V->getType() && \"All operands to PHI node must be the same type as the PHI node!\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 2672, __PRETTY_FUNCTION__))
         "All operands to PHI node must be the same type as the PHI node!")((getType() == V->getType() && "All operands to PHI node must be the same type as the PHI node!"
) ? static_cast<void> (0) : __assert_fail ("getType() == V->getType() && \"All operands to PHI node must be the same type as the PHI node!\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 2672, __PRETTY_FUNCTION__));
  setOperand(i, V);
}

static unsigned getOperandNumForIncomingValue(unsigned i) {
  return i;
}

static unsigned getIncomingValueNumForOperand(unsigned i) {
  return i;
}

/// Return incoming basic block number @p i.
///
BasicBlock *getIncomingBlock(unsigned i) const {
  return block_begin()[i];
}

/// Return incoming basic block corresponding
/// to an operand of the PHI.
///
BasicBlock *getIncomingBlock(const Use &U) const {
  assert(this == U.getUser() && "Iterator doesn't point to PHI's Uses?")((this == U.getUser() && "Iterator doesn't point to PHI's Uses?"
) ? static_cast<void> (0) : __assert_fail ("this == U.getUser() && \"Iterator doesn't point to PHI's Uses?\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 2694, __PRETTY_FUNCTION__));
  return getIncomingBlock(unsigned(&U - op_begin()));
}

/// Return incoming basic block corresponding
/// to value use iterator.
///
BasicBlock *getIncomingBlock(Value::const_user_iterator I) const {
  return getIncomingBlock(I.getUse());
}

void setIncomingBlock(unsigned i, BasicBlock *BB) {
  assert(BB && "PHI node got a null basic block!")((BB && "PHI node got a null basic block!") ? static_cast
<void> (0) : __assert_fail ("BB && \"PHI node got a null basic block!\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 2706, __PRETTY_FUNCTION__));
  block_begin()[i] = BB;
}

/// Replace every incoming basic block \p Old to basic block \p New.
void replaceIncomingBlockWith(const BasicBlock *Old, BasicBlock *New) {
  assert(New && Old && "PHI node got a null basic block!")((New && Old && "PHI node got a null basic block!"
) ? static_cast<void> (0) : __assert_fail ("New && Old && \"PHI node got a null basic block!\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 2712, __PRETTY_FUNCTION__));
  for (unsigned Op = 0, NumOps = getNumOperands(); Op != NumOps; ++Op)
    if (getIncomingBlock(Op) == Old)
      setIncomingBlock(Op, New);
}

/// Add an incoming value to the end of the PHI list
///
void addIncoming(Value *V, BasicBlock *BB) {
  if (getNumOperands() == ReservedSpace)
    growOperands();  // Get more space!
  // Initialize some new operands.
  setNumHungOffUseOperands(getNumOperands() + 1);
  setIncomingValue(getNumOperands() - 1, V);
  setIncomingBlock(getNumOperands() - 1, BB);
}

/// Remove an incoming value.  This is useful if a
/// predecessor basic block is deleted.  The value removed is returned.
///
/// If the last incoming value for a PHI node is removed (and DeletePHIIfEmpty
/// is true), the PHI node is destroyed and any uses of it are replaced with
/// dummy values.  The only time there should be zero incoming values to a PHI
/// node is when the block is dead, so this strategy is sound.
///
Value *removeIncomingValue(unsigned Idx, bool DeletePHIIfEmpty = true);

Value *removeIncomingValue(const BasicBlock *BB, bool DeletePHIIfEmpty=true) {
  int Idx = getBasicBlockIndex(BB);
  assert(Idx >= 0 && "Invalid basic block argument to remove!")((Idx >= 0 && "Invalid basic block argument to remove!"
) ? static_cast<void> (0) : __assert_fail ("Idx >= 0 && \"Invalid basic block argument to remove!\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 2741, __PRETTY_FUNCTION__));
  return removeIncomingValue(Idx, DeletePHIIfEmpty);
}

/// Return the first index of the specified basic
/// block in the value list for this PHI.  Returns -1 if no instance.
///
int getBasicBlockIndex(const BasicBlock *BB) const {
  for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
    if (block_begin()[i] == BB)
      return i;
  return -1;
}

Value *getIncomingValueForBlock(const BasicBlock *BB) const {
  int Idx = getBasicBlockIndex(BB);
  assert(Idx >= 0 && "Invalid basic block argument!")((Idx >= 0 && "Invalid basic block argument!") ? static_cast
<void> (0) : __assert_fail ("Idx >= 0 && \"Invalid basic block argument!\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 2757, __PRETTY_FUNCTION__));
  return getIncomingValue(Idx);
}

/// Set every incoming value(s) for block \p BB to \p V.
void setIncomingValueForBlock(const BasicBlock *BB, Value *V) {
  assert(BB && "PHI node got a null basic block!")((BB && "PHI node got a null basic block!") ? static_cast
<void> (0) : __assert_fail ("BB && \"PHI node got a null basic block!\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 2763, __PRETTY_FUNCTION__));
  bool Found = false;
  for (unsigned Op = 0, NumOps = getNumOperands(); Op != NumOps; ++Op)
    if (getIncomingBlock(Op) == BB) {
      Found = true;
      setIncomingValue(Op, V);
    }
  (void)Found;
  assert(Found && "Invalid basic block argument to set!")((Found && "Invalid basic block argument to set!") ? static_cast
<void> (0) : __assert_fail ("Found && \"Invalid basic block argument to set!\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 2771, __PRETTY_FUNCTION__));
}

/// If the specified PHI node always merges together the
/// same value, return the value, otherwise return null.
Value *hasConstantValue() const;

/// Whether the specified PHI node always merges
/// together the same value, assuming undefs are equal to a unique
/// non-undef value.
bool hasConstantOrUndefValue() const;

/// If the PHI node is complete which means all of its parent's predecessors
/// have incoming value in this PHI, return true, otherwise return false.
bool isComplete() const {
  return llvm::all_of(predecessors(getParent()),
                      [this](const BasicBlock *Pred) {
                        return getBasicBlockIndex(Pred) >= 0;
                      });
}

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

2800private:
void growOperands();
2802};

2804template <>
2805struct OperandTraits<PHINode> : public HungoffOperandTraits<2> {
2806};

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

2810//===----------------------------------------------------------------------===//
2811//                           LandingPadInst Class
2812//===----------------------------------------------------------------------===//

2814//===---------------------------------------------------------------------------
2815/// The landingpad instruction holds all of the information
2816/// necessary to generate correct exception handling. The landingpad instruction
2817/// cannot be moved from the top of a landing pad block, which itself is
2818/// accessible only from the 'unwind' edge of an invoke. This uses the
2819/// SubclassData field in Value to store whether or not the landingpad is a
2820/// cleanup.
2821///
2822class LandingPadInst : public Instruction {
using CleanupField = BoolBitfieldElementT<0>;

/// The number of operands actually allocated.  NumOperands is
/// the number actually in use.
unsigned ReservedSpace;

LandingPadInst(const LandingPadInst &LP);

2831public:
enum ClauseType { Catch, Filter };

2834private:
explicit LandingPadInst(Type *RetTy, unsigned NumReservedValues,
                        const Twine &NameStr, Instruction *InsertBefore);
explicit LandingPadInst(Type *RetTy, unsigned NumReservedValues,
                        const Twine &NameStr, BasicBlock *InsertAtEnd);

// Allocate space for exactly zero operands.
void *operator new(size_t s) {
  return User::operator new(s);
}

void growOperands(unsigned Size);
void init(unsigned NumReservedValues, const Twine &NameStr);

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

LandingPadInst *cloneImpl() const;

2854public:
/// Constructors - NumReservedClauses is a hint for the number of incoming
/// clauses that this landingpad will have (use 0 if you really have no idea).
static LandingPadInst *Create(Type *RetTy, unsigned NumReservedClauses,
                              const Twine &NameStr = "",
                              Instruction *InsertBefore = nullptr);
static LandingPadInst *Create(Type *RetTy, unsigned NumReservedClauses,
                              const Twine &NameStr, BasicBlock *InsertAtEnd);

/// 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;

/// Return 'true' if this landingpad instruction is a
/// cleanup. I.e., it should be run when unwinding even if its landing pad
/// doesn't catch the exception.
bool isCleanup() const { return getSubclassData<CleanupField>(); }

/// Indicate that this landingpad instruction is a cleanup.
void setCleanup(bool V) { setSubclassData<CleanupField>(V); }

/// Add a catch or filter clause to the landing pad.
void addClause(Constant *ClauseVal);

/// Get the value of the clause at index Idx. Use isCatch/isFilter to
/// determine what type of clause this is.
Constant *getClause(unsigned Idx) const {
  return cast<Constant>(getOperandList()[Idx]);
}

/// Return 'true' if the clause and index Idx is a catch clause.
bool isCatch(unsigned Idx) const {
  return !isa<ArrayType>(getOperandList()[Idx]->getType());
}

/// Return 'true' if the clause and index Idx is a filter clause.
bool isFilter(unsigned Idx) const {
  return isa<ArrayType>(getOperandList()[Idx]->getType());
}

/// Get the number of clauses for this landing pad.
unsigned getNumClauses() const { return getNumOperands(); }

/// Grow the size of the operand list to accommodate the new
/// number of clauses.
void reserveClauses(unsigned Size) { growOperands(Size); }

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

2909template <>
2910struct OperandTraits<LandingPadInst> : public HungoffOperandTraits<1> {
2911};

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

2915//===----------------------------------------------------------------------===//
2916//                               ReturnInst Class
2917//===----------------------------------------------------------------------===//

2919//===---------------------------------------------------------------------------
2920/// Return a value (possibly void), from a function.  Execution
2921/// does not continue in this function any longer.
2922///
2923class ReturnInst : public Instruction {
ReturnInst(const ReturnInst &RI);

2926private:
// ReturnInst constructors:
// ReturnInst()                  - 'ret void' instruction
// ReturnInst(    null)          - 'ret void' instruction
// ReturnInst(Value* X)          - 'ret X'    instruction
// ReturnInst(    null, Inst *I) - 'ret void' instruction, insert before I
// ReturnInst(Value* X, Inst *I) - 'ret X'    instruction, insert before I
// ReturnInst(    null, BB *B)   - 'ret void' instruction, insert @ end of B
// ReturnInst(Value* X, BB *B)   - 'ret X'    instruction, insert @ end of B
//
// NOTE: If the Value* passed is of type void then the constructor behaves as
// if it was passed NULL.
explicit ReturnInst(LLVMContext &C, Value *retVal = nullptr,
                    Instruction *InsertBefore = nullptr);
ReturnInst(LLVMContext &C, Value *retVal, BasicBlock *InsertAtEnd);
explicit ReturnInst(LLVMContext &C, BasicBlock *InsertAtEnd);

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

ReturnInst *cloneImpl() const;

2949public:
static ReturnInst* Create(LLVMContext &C, Value *retVal = nullptr,
                          Instruction *InsertBefore = nullptr) {
  return new(!!retVal) ReturnInst(C, retVal, InsertBefore);
}

static ReturnInst* Create(LLVMContext &C, Value *retVal,
                          BasicBlock *InsertAtEnd) {
  return new(!!retVal) ReturnInst(C, retVal, InsertAtEnd);
}

static ReturnInst* Create(LLVMContext &C, BasicBlock *InsertAtEnd) {
  return new(0) ReturnInst(C, InsertAtEnd);
}

/// 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;

/// Convenience accessor. Returns null if there is no return value.
Value *getReturnValue() const {
  return getNumOperands() != 0 ? getOperand(0) : nullptr;
}

unsigned getNumSuccessors() const { return 0; }

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

2982private:
BasicBlock *getSuccessor(unsigned idx) const {
  llvm_unreachable("ReturnInst has no successors!")::llvm::llvm_unreachable_internal("ReturnInst has no successors!"
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 2984);
}

void setSuccessor(unsigned idx, BasicBlock *B) {
  llvm_unreachable("ReturnInst has no successors!")::llvm::llvm_unreachable_internal("ReturnInst has no successors!"
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 2988);
}
2990};

2992template <>
2993struct OperandTraits<ReturnInst> : public VariadicOperandTraits<ReturnInst> {
2994};

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

2998//===----------------------------------------------------------------------===//
2999//                               BranchInst Class
3000//===----------------------------------------------------------------------===//

3002//===---------------------------------------------------------------------------
3003/// Conditional or Unconditional Branch instruction.
3004///
3005class BranchInst : public Instruction {
/// Ops list - Branches are strange.  The operands are ordered:
///  [Cond, FalseDest,] TrueDest.  This makes some accessors faster because
/// they don't have to check for cond/uncond branchness. These are mostly
/// accessed relative from op_end().
BranchInst(const BranchInst &BI);
// BranchInst constructors (where {B, T, F} are blocks, and C is a condition):
// BranchInst(BB *B)                           - 'br B'
// BranchInst(BB* T, BB *F, Value *C)          - 'br C, T, F'
// BranchInst(BB* B, Inst *I)                  - 'br B'        insert before I
// BranchInst(BB* T, BB *F, Value *C, Inst *I) - 'br C, T, F', insert before I
// BranchInst(BB* B, BB *I)                    - 'br B'        insert at end
// BranchInst(BB* T, BB *F, Value *C, BB *I)   - 'br C, T, F', insert at end
explicit BranchInst(BasicBlock *IfTrue, Instruction *InsertBefore = nullptr);
BranchInst(BasicBlock *IfTrue, BasicBlock *IfFalse, Value *Cond,
           Instruction *InsertBefore = nullptr);
BranchInst(BasicBlock *IfTrue, BasicBlock *InsertAtEnd);
BranchInst(BasicBlock *IfTrue, BasicBlock *IfFalse, Value *Cond,
           BasicBlock *InsertAtEnd);

void AssertOK();

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

BranchInst *cloneImpl() const;

3033public:
/// Iterator type that casts an operand to a basic block.
///
/// This only makes sense because the successors are stored as adjacent
/// operands for branch instructions.
struct succ_op_iterator
    : iterator_adaptor_base<succ_op_iterator, value_op_iterator,
                            std::random_access_iterator_tag, BasicBlock *,
                            ptrdiff_t, BasicBlock *, BasicBlock *> {
  explicit succ_op_iterator(value_op_iterator I) : iterator_adaptor_base(I) {}

  BasicBlock *operator*() const { return cast<BasicBlock>(*I); }
  BasicBlock *operator->() const { return operator*(); }
};

/// The const version of `succ_op_iterator`.
struct const_succ_op_iterator
    : iterator_adaptor_base<const_succ_op_iterator, const_value_op_iterator,
                            std::random_access_iterator_tag,
                            const BasicBlock *, ptrdiff_t, const BasicBlock *,
                            const BasicBlock *> {
  explicit const_succ_op_iterator(const_value_op_iterator I)
      : iterator_adaptor_base(I) {}

  const BasicBlock *operator*() const { return cast<BasicBlock>(*I); }
  const BasicBlock *operator->() const { return operator*(); }
};

static BranchInst *Create(BasicBlock *IfTrue,
                          Instruction *InsertBefore = nullptr) {
  return new(1) BranchInst(IfTrue, InsertBefore);
}

static BranchInst *Create(BasicBlock *IfTrue, BasicBlock *IfFalse,
                          Value *Cond, Instruction *InsertBefore = nullptr) {
  return new(3) BranchInst(IfTrue, IfFalse, Cond, InsertBefore);
}

static BranchInst *Create(BasicBlock *IfTrue, BasicBlock *InsertAtEnd) {
  return new(1) BranchInst(IfTrue, InsertAtEnd);
}

static BranchInst *Create(BasicBlock *IfTrue, BasicBlock *IfFalse,
                          Value *Cond, BasicBlock *InsertAtEnd) {
  return new(3) BranchInst(IfTrue, IfFalse, Cond, InsertAtEnd);
}

/// 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;

bool isUnconditional() const { return getNumOperands() == 1; }
bool isConditional()   const { return getNumOperands() == 3; }

Value *getCondition() const {
  assert(isConditional() && "Cannot get condition of an uncond branch!")((isConditional() && "Cannot get condition of an uncond branch!"
) ? static_cast<void> (0) : __assert_fail ("isConditional() && \"Cannot get condition of an uncond branch!\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 3087, __PRETTY_FUNCTION__));
  return Op<-3>();
}

void setCondition(Value *V) {
  assert(isConditional() && "Cannot set condition of unconditional branch!")((isConditional() && "Cannot set condition of unconditional branch!"
) ? static_cast<void> (0) : __assert_fail ("isConditional() && \"Cannot set condition of unconditional branch!\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 3092, __PRETTY_FUNCTION__));
  Op<-3>() = V;
}

unsigned getNumSuccessors() const { return 1+isConditional(); }

BasicBlock *getSuccessor(unsigned i) const {
  assert(i < getNumSuccessors() && "Successor # out of range for Branch!")((i < getNumSuccessors() && "Successor # out of range for Branch!"
) ? static_cast<void> (0) : __assert_fail ("i < getNumSuccessors() && \"Successor # out of range for Branch!\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 3099, __PRETTY_FUNCTION__));
  return cast_or_null<BasicBlock>((&Op<-1>() - i)->get());
}

void setSuccessor(unsigned idx, BasicBlock *NewSucc) {
  assert(idx < getNumSuccessors() && "Successor # out of range for Branch!")((idx < getNumSuccessors() && "Successor # out of range for Branch!"
) ? static_cast<void> (0) : __assert_fail ("idx < getNumSuccessors() && \"Successor # out of range for Branch!\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 3104, __PRETTY_FUNCTION__));
  *(&Op<-1>() - idx) = NewSucc;
}

/// Swap the successors of this branch instruction.
///
/// Swaps the successors of the branch instruction. This also swaps any
/// branch weight metadata associated with the instruction so that it
/// continues to map correctly to each operand.
void swapSuccessors();

iterator_range<succ_op_iterator> successors() {
  return make_range(
      succ_op_iterator(std::next(value_op_begin(), isConditional() ? 1 : 0)),
      succ_op_iterator(value_op_end()));
}

iterator_range<const_succ_op_iterator> successors() const {
  return make_range(const_succ_op_iterator(
                        std::next(value_op_begin(), isConditional() ? 1 : 0)),
                    const_succ_op_iterator(value_op_end()));
}

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

3136template <>
3137struct OperandTraits<BranchInst> : public VariadicOperandTraits<BranchInst, 1> {
3138};

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

3142//===----------------------------------------------------------------------===//
3143//                               SwitchInst Class
3144//===----------------------------------------------------------------------===//

3146//===---------------------------------------------------------------------------
3147/// Multiway switch
3148///
3149class SwitchInst : public Instruction {
unsigned ReservedSpace;

// Operand[0]    = Value to switch on
// Operand[1]    = Default basic block destination
// Operand[2n  ] = Value to match
// Operand[2n+1] = BasicBlock to go to on match
SwitchInst(const SwitchInst &SI);

/// Create a new switch instruction, specifying a value to switch on and a
/// default destination. The number of additional cases can be specified here
/// to make memory allocation more efficient. This constructor can also
/// auto-insert before another instruction.
SwitchInst(Value *Value, BasicBlock *Default, unsigned NumCases,
           Instruction *InsertBefore);

/// Create a new switch instruction, specifying a value to switch on and a
/// default destination. The number of additional cases can be specified here
/// to make memory allocation more efficient. This constructor also
/// auto-inserts at the end of the specified BasicBlock.
SwitchInst(Value *Value, BasicBlock *Default, unsigned NumCases,
           BasicBlock *InsertAtEnd);

// allocate space for exactly zero operands
void *operator new(size_t s) {
  return User::operator new(s);
}

void init(Value *Value, BasicBlock *Default, unsigned NumReserved);
void growOperands();

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

SwitchInst *cloneImpl() const;

3186public:
// -2
static const unsigned DefaultPseudoIndex = static_cast<unsigned>(~0L-1);

template <typename CaseHandleT> class CaseIteratorImpl;

/// A handle to a particular switch case. It exposes a convenient interface
/// to both the case value and the successor block.
///
/// We define this as a template and instantiate it to form both a const and
/// non-const handle.
template <typename SwitchInstT, typename ConstantIntT, typename BasicBlockT>
class CaseHandleImpl {
  // Directly befriend both const and non-const iterators.
  friend class SwitchInst::CaseIteratorImpl<
      CaseHandleImpl<SwitchInstT, ConstantIntT, BasicBlockT>>;

protected:
  // Expose the switch type we're parameterized with to the iterator.
  using SwitchInstType = SwitchInstT;

  SwitchInstT *SI;
  ptrdiff_t Index;

  CaseHandleImpl() = default;
  CaseHandleImpl(SwitchInstT *SI, ptrdiff_t Index) : SI(SI), Index(Index) {}

public:
  /// Resolves case value for current case.
  ConstantIntT *getCaseValue() const {
    assert((unsigned)Index < SI->getNumCases() &&(((unsigned)Index < SI->getNumCases() && "Index out the number of cases."
) ? static_cast<void> (0) : __assert_fail ("(unsigned)Index < SI->getNumCases() && \"Index out the number of cases.\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 3217, __PRETTY_FUNCTION__))
           "Index out the number of cases.")(((unsigned)Index < SI->getNumCases() && "Index out the number of cases."
) ? static_cast<void> (0) : __assert_fail ("(unsigned)Index < SI->getNumCases() && \"Index out the number of cases.\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 3217, __PRETTY_FUNCTION__));
    return reinterpret_cast<ConstantIntT *>(SI->getOperand(2 + Index * 2));
  }

  /// Resolves successor for current case.
  BasicBlockT *getCaseSuccessor() const {
    assert(((unsigned)Index < SI->getNumCases() ||((((unsigned)Index < SI->getNumCases() || (unsigned)Index
 == DefaultPseudoIndex) && "Index out the number of cases."
) ? static_cast<void> (0) : __assert_fail ("((unsigned)Index < SI->getNumCases() || (unsigned)Index == DefaultPseudoIndex) && \"Index out the number of cases.\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 3225, __PRETTY_FUNCTION__))
            (unsigned)Index == DefaultPseudoIndex) &&((((unsigned)Index < SI->getNumCases() || (unsigned)Index
 == DefaultPseudoIndex) && "Index out the number of cases."
) ? static_cast<void> (0) : __assert_fail ("((unsigned)Index < SI->getNumCases() || (unsigned)Index == DefaultPseudoIndex) && \"Index out the number of cases.\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 3225, __PRETTY_FUNCTION__))
           "Index out the number of cases.")((((unsigned)Index < SI->getNumCases() || (unsigned)Index
 == DefaultPseudoIndex) && "Index out the number of cases."
) ? static_cast<void> (0) : __assert_fail ("((unsigned)Index < SI->getNumCases() || (unsigned)Index == DefaultPseudoIndex) && \"Index out the number of cases.\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 3225, __PRETTY_FUNCTION__));
    return SI->getSuccessor(getSuccessorIndex());
  }

  /// Returns number of current case.
  unsigned getCaseIndex() const { return Index; }

  /// Returns successor index for current case successor.
  unsigned getSuccessorIndex() const {
    assert(((unsigned)Index == DefaultPseudoIndex ||((((unsigned)Index == DefaultPseudoIndex || (unsigned)Index <
 SI->getNumCases()) && "Index out the number of cases."
) ? static_cast<void> (0) : __assert_fail ("((unsigned)Index == DefaultPseudoIndex || (unsigned)Index < SI->getNumCases()) && \"Index out the number of cases.\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 3236, __PRETTY_FUNCTION__))
            (unsigned)Index < SI->getNumCases()) &&((((unsigned)Index == DefaultPseudoIndex || (unsigned)Index <
 SI->getNumCases()) && "Index out the number of cases."
) ? static_cast<void> (0) : __assert_fail ("((unsigned)Index == DefaultPseudoIndex || (unsigned)Index < SI->getNumCases()) && \"Index out the number of cases.\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 3236, __PRETTY_FUNCTION__))
           "Index out the number of cases.")((((unsigned)Index == DefaultPseudoIndex || (unsigned)Index <
 SI->getNumCases()) && "Index out the number of cases."
) ? static_cast<void> (0) : __assert_fail ("((unsigned)Index == DefaultPseudoIndex || (unsigned)Index < SI->getNumCases()) && \"Index out the number of cases.\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 3236, __PRETTY_FUNCTION__));
    return (unsigned)Index != DefaultPseudoIndex ? Index + 1 : 0;
  }

  bool operator==(const CaseHandleImpl &RHS) const {
    assert(SI == RHS.SI && "Incompatible operators.")((SI == RHS.SI && "Incompatible operators.") ? static_cast
<void> (0) : __assert_fail ("SI == RHS.SI && \"Incompatible operators.\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 3241, __PRETTY_FUNCTION__));
    return Index == RHS.Index;
  }
};

using ConstCaseHandle =
    CaseHandleImpl<const SwitchInst, const ConstantInt, const BasicBlock>;

class CaseHandle
    : public CaseHandleImpl<SwitchInst, ConstantInt, BasicBlock> {
  friend class SwitchInst::CaseIteratorImpl<CaseHandle>;

public:
  CaseHandle(SwitchInst *SI, ptrdiff_t Index) : CaseHandleImpl(SI, Index) {}

  /// Sets the new value for current case.
  void setValue(ConstantInt *V) {
    assert((unsigned)Index < SI->getNumCases() &&(((unsigned)Index < SI->getNumCases() && "Index out the number of cases."
) ? static_cast<void> (0) : __assert_fail ("(unsigned)Index < SI->getNumCases() && \"Index out the number of cases.\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 3259, __PRETTY_FUNCTION__))
           "Index out the number of cases.")(((unsigned)Index < SI->getNumCases() && "Index out the number of cases."
) ? static_cast<void> (0) : __assert_fail ("(unsigned)Index < SI->getNumCases() && \"Index out the number of cases.\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 3259, __PRETTY_FUNCTION__));
    SI->setOperand(2 + Index*2, reinterpret_cast<Value*>(V));
  }

  /// Sets the new successor for current case.
  void setSuccessor(BasicBlock *S) {
    SI->setSuccessor(getSuccessorIndex(), S);
  }
};

template <typename CaseHandleT>
class CaseIteratorImpl
    : public iterator_facade_base<CaseIteratorImpl<CaseHandleT>,
                                  std::random_access_iterator_tag,
                                  CaseHandleT> {
  using SwitchInstT = typename CaseHandleT::SwitchInstType;

  CaseHandleT Case;

public:
  /// Default constructed iterator is in an invalid state until assigned to
  /// a case for a particular switch.
  CaseIteratorImpl() = default;

  /// Initializes case iterator for given SwitchInst and for given
  /// case number.
  CaseIteratorImpl(SwitchInstT *SI, unsigned CaseNum) : Case(SI, CaseNum) {}

  /// Initializes case iterator for given SwitchInst and for given
  /// successor index.
  static CaseIteratorImpl fromSuccessorIndex(SwitchInstT *SI,
                                             unsigned SuccessorIndex) {
    assert(SuccessorIndex < SI->getNumSuccessors() &&((SuccessorIndex < SI->getNumSuccessors() && "Successor index # out of range!"
) ? static_cast<void> (0) : __assert_fail ("SuccessorIndex < SI->getNumSuccessors() && \"Successor index # out of range!\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 3292, __PRETTY_FUNCTION__))
           "Successor index # out of range!")((SuccessorIndex < SI->getNumSuccessors() && "Successor index # out of range!"
) ? static_cast<void> (0) : __assert_fail ("SuccessorIndex < SI->getNumSuccessors() && \"Successor index # out of range!\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 3292, __PRETTY_FUNCTION__));
    return SuccessorIndex != 0 ? CaseIteratorImpl(SI, SuccessorIndex - 1)
                               : CaseIteratorImpl(SI, DefaultPseudoIndex);
  }

  /// Support converting to the const variant. This will be a no-op for const
  /// variant.
  operator CaseIteratorImpl<ConstCaseHandle>() const {
    return CaseIteratorImpl<ConstCaseHandle>(Case.SI, Case.Index);
  }

  CaseIteratorImpl &operator+=(ptrdiff_t N) {
    // Check index correctness after addition.
    // Note: Index == getNumCases() means end().
    assert(Case.Index + N >= 0 &&((Case.Index + N >= 0 && (unsigned)(Case.Index + N
) <= Case.SI->getNumCases() && "Case.Index out the number of cases."
) ? static_cast<void> (0) : __assert_fail ("Case.Index + N >= 0 && (unsigned)(Case.Index + N) <= Case.SI->getNumCases() && \"Case.Index out the number of cases.\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 3308, __PRETTY_FUNCTION__))
           (unsigned)(Case.Index + N) <= Case.SI->getNumCases() &&((Case.Index + N >= 0 && (unsigned)(Case.Index + N
) <= Case.SI->getNumCases() && "Case.Index out the number of cases."
) ? static_cast<void> (0) : __assert_fail ("Case.Index + N >= 0 && (unsigned)(Case.Index + N) <= Case.SI->getNumCases() && \"Case.Index out the number of cases.\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 3308, __PRETTY_FUNCTION__))
           "Case.Index out the number of cases.")((Case.Index + N >= 0 && (unsigned)(Case.Index + N
) <= Case.SI->getNumCases() && "Case.Index out the number of cases."
) ? static_cast<void> (0) : __assert_fail ("Case.Index + N >= 0 && (unsigned)(Case.Index + N) <= Case.SI->getNumCases() && \"Case.Index out the number of cases.\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 3308, __PRETTY_FUNCTION__));
    Case.Index += N;
    return *this;
  }
  CaseIteratorImpl &operator-=(ptrdiff_t N) {
    // Check index correctness after subtraction.
    // Note: Case.Index == getNumCases() means end().
    assert(Case.Index - N >= 0 &&((Case.Index - N >= 0 && (unsigned)(Case.Index - N
) <= Case.SI->getNumCases() && "Case.Index out the number of cases."
) ? static_cast<void> (0) : __assert_fail ("Case.Index - N >= 0 && (unsigned)(Case.Index - N) <= Case.SI->getNumCases() && \"Case.Index out the number of cases.\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 3317, __PRETTY_FUNCTION__))
           (unsigned)(Case.Index - N) <= Case.SI->getNumCases() &&((Case.Index - N >= 0 && (unsigned)(Case.Index - N
) <= Case.SI->getNumCases() && "Case.Index out the number of cases."
) ? static_cast<void> (0) : __assert_fail ("Case.Index - N >= 0 && (unsigned)(Case.Index - N) <= Case.SI->getNumCases() && \"Case.Index out the number of cases.\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 3317, __PRETTY_FUNCTION__))
           "Case.Index out the number of cases.")((Case.Index - N >= 0 && (unsigned)(Case.Index - N
) <= Case.SI->getNumCases() && "Case.Index out the number of cases."
) ? static_cast<void> (0) : __assert_fail ("Case.Index - N >= 0 && (unsigned)(Case.Index - N) <= Case.SI->getNumCases() && \"Case.Index out the number of cases.\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 3317, __PRETTY_FUNCTION__));
    Case.Index -= N;
    return *this;
  }
  ptrdiff_t operator-(const CaseIteratorImpl &RHS) const {
    assert(Case.SI == RHS.Case.SI && "Incompatible operators.")((Case.SI == RHS.Case.SI && "Incompatible operators."
) ? static_cast<void> (0) : __assert_fail ("Case.SI == RHS.Case.SI && \"Incompatible operators.\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 3322, __PRETTY_FUNCTION__));
    return Case.Index - RHS.Case.Index;
  }
  bool operator==(const CaseIteratorImpl &RHS) const {
    return Case == RHS.Case;
  }
  bool operator<(const CaseIteratorImpl &RHS) const {
    assert(Case.SI == RHS.Case.SI && "Incompatible operators.")((Case.SI == RHS.Case.SI && "Incompatible operators."
) ? static_cast<void> (0) : __assert_fail ("Case.SI == RHS.Case.SI && \"Incompatible operators.\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 3329, __PRETTY_FUNCTION__));
    return Case.Index < RHS.Case.Index;
  }
  CaseHandleT &operator*() { return Case; }
  const CaseHandleT &operator*() const { return Case; }
};

using CaseIt = CaseIteratorImpl<CaseHandle>;
using ConstCaseIt = CaseIteratorImpl<ConstCaseHandle>;

static SwitchInst *Create(Value *Value, BasicBlock *Default,
                          unsigned NumCases,
                          Instruction *InsertBefore = nullptr) {
  return new SwitchInst(Value, Default, NumCases, InsertBefore);
}

static SwitchInst *Create(Value *Value, BasicBlock *Default,
                          unsigned NumCases, BasicBlock *InsertAtEnd) {
  return new SwitchInst(Value, Default, NumCases, InsertAtEnd);
}

/// 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;

// Accessor Methods for Switch stmt
Value *getCondition() const { return getOperand(0); }
void setCondition(Value *V) { setOperand(0, V); }

BasicBlock *getDefaultDest() const {
  return cast<BasicBlock>(getOperand(1));
}

void setDefaultDest(BasicBlock *DefaultCase) {
  setOperand(1, reinterpret_cast<Value*>(DefaultCase));
}

/// Return the number of 'cases' in this switch instruction, excluding the
/// default case.
unsigned getNumCases() const {
  return getNumOperands()/2 - 1;
}

/// Returns a read/write iterator that points to the first case in the
/// SwitchInst.
CaseIt case_begin() {
  return CaseIt(this, 0);
}

/// Returns a read-only iterator that points to the first case in the
/// SwitchInst.
ConstCaseIt case_begin() const {
  return ConstCaseIt(this, 0);
}

/// Returns a read/write iterator that points one past the last in the
/// SwitchInst.
CaseIt case_end() {
  return CaseIt(this, getNumCases());
}

/// Returns a read-only iterator that points one past the last in the
/// SwitchInst.
ConstCaseIt case_end() const {
  return ConstCaseIt(this, getNumCases());
}

/// Iteration adapter for range-for loops.
iterator_range<CaseIt> cases() {
  return make_range(case_begin(), case_end());
}

/// Constant iteration adapter for range-for loops.
iterator_range<ConstCaseIt> cases() const {
  return make_range(case_begin(), case_end());
}

/// Returns an iterator that points to the default case.
/// Note: this iterator allows to resolve successor only. Attempt
/// to resolve case value causes an assertion.
/// Also note, that increment and decrement also causes an assertion and
/// makes iterator invalid.
CaseIt case_default() {
  return CaseIt(this, DefaultPseudoIndex);
}
ConstCaseIt case_default() const {
  return ConstCaseIt(this, DefaultPseudoIndex);
}

/// Search all of the case values for the specified constant. If it is
/// explicitly handled, return the case iterator of it, otherwise return
/// default case iterator to indicate that it is handled by the default
/// handler.
CaseIt findCaseValue(const ConstantInt *C) {
  CaseIt I = llvm::find_if(
      cases(), [C](CaseHandle &Case) { return Case.getCaseValue() == C; });
  if (I != case_end())
    return I;

  return case_default();
}
ConstCaseIt findCaseValue(const ConstantInt *C) const {
  ConstCaseIt I = llvm::find_if(cases(), [C](ConstCaseHandle &Case) {
    return Case.getCaseValue() == C;
  });
  if (I != case_end())
    return I;

  return case_default();
}

/// Finds the unique case value for a given successor. Returns null if the
/// successor is not found, not unique, or is the default case.
ConstantInt *findCaseDest(BasicBlock *BB) {
  if (BB == getDefaultDest())
    return nullptr;

  ConstantInt *CI = nullptr;
  for (auto Case : cases()) {
    if (Case.getCaseSuccessor() != BB)
      continue;

    if (CI)
      return nullptr; // Multiple cases lead to BB.

    CI = Case.getCaseValue();
  }

  return CI;
}

/// Add an entry to the switch instruction.
/// Note:
/// This action invalidates case_end(). Old case_end() iterator will
/// point to the added case.
void addCase(ConstantInt *OnVal, BasicBlock *Dest);

/// This method removes the specified case and its successor from the switch
/// instruction. Note that this operation may reorder the remaining cases at
/// index idx and above.
/// Note:
/// This action invalidates iterators for all cases following the one removed,
/// including the case_end() iterator. It returns an iterator for the next
/// case.
CaseIt removeCase(CaseIt I);

unsigned getNumSuccessors() const { return getNumOperands()/2; }
BasicBlock *getSuccessor(unsigned idx) const {
  assert(idx < getNumSuccessors() &&"Successor idx out of range for switch!")((idx < getNumSuccessors() &&"Successor idx out of range for switch!"
) ? static_cast<void> (0) : __assert_fail ("idx < getNumSuccessors() &&\"Successor idx out of range for switch!\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 3476, __PRETTY_FUNCTION__));
  return cast<BasicBlock>(getOperand(idx*2+1));
}
void setSuccessor(unsigned idx, BasicBlock *NewSucc) {
  assert(idx < getNumSuccessors() && "Successor # out of range for switch!")((idx < getNumSuccessors() && "Successor # out of range for switch!"
) ? static_cast<void> (0) : __assert_fail ("idx < getNumSuccessors() && \"Successor # out of range for switch!\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 3480, __PRETTY_FUNCTION__));
  setOperand(idx * 2 + 1, NewSucc);
}

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

3493/// A wrapper class to simplify modification of SwitchInst cases along with
3494/// their prof branch_weights metadata.
3495class SwitchInstProfUpdateWrapper {
SwitchInst &SI;
Optional<SmallVector<uint32_t, 8> > Weights = None;
bool Changed = false;

3500protected:
static MDNode *getProfBranchWeightsMD(const SwitchInst &SI);

MDNode *buildProfBranchWeightsMD();

void init();

3507public:
using CaseWeightOpt = Optional<uint32_t>;
SwitchInst *operator->() { return &SI; }
SwitchInst &operator*() { return SI; }
operator SwitchInst *() { return &SI; }

SwitchInstProfUpdateWrapper(SwitchInst &SI) : SI(SI) { init(); }

~SwitchInstProfUpdateWrapper() {
  if (Changed)
    SI.setMetadata(LLVMContext::MD_prof, buildProfBranchWeightsMD());
}

/// Delegate the call to the underlying SwitchInst::removeCase() and remove
/// correspondent branch weight.
SwitchInst::CaseIt removeCase(SwitchInst::CaseIt I);

/// Delegate the call to the underlying SwitchInst::addCase() and set the
/// specified branch weight for the added case.
void addCase(ConstantInt *OnVal, BasicBlock *Dest, CaseWeightOpt W);

/// Delegate the call to the underlying SwitchInst::eraseFromParent() and mark
/// this object to not touch the underlying SwitchInst in destructor.
SymbolTableList<Instruction>::iterator eraseFromParent();

void setSuccessorWeight(unsigned idx, CaseWeightOpt W);
CaseWeightOpt getSuccessorWeight(unsigned idx);

static CaseWeightOpt getSuccessorWeight(const SwitchInst &SI, unsigned idx);
3536};

3538template <>
3539struct OperandTraits<SwitchInst> : public HungoffOperandTraits<2> {
3540};

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

3544//===----------------------------------------------------------------------===//
3545//                             IndirectBrInst Class
3546//===----------------------------------------------------------------------===//

3548//===---------------------------------------------------------------------------
3549/// Indirect Branch Instruction.
3550///
3551class IndirectBrInst : public Instruction {
unsigned ReservedSpace;

// Operand[0]   = Address to jump to
// Operand[n+1] = n-th destination
IndirectBrInst(const IndirectBrInst &IBI);

/// Create a new indirectbr instruction, specifying an
/// Address to jump to.  The number of expected destinations can be specified
/// here to make memory allocation more efficient.  This constructor can also
/// autoinsert before another instruction.
IndirectBrInst(Value *Address, unsigned NumDests, Instruction *InsertBefore);

/// Create a new indirectbr instruction, specifying an
/// Address to jump to.  The number of expected destinations can be specified
/// here to make memory allocation more efficient.  This constructor also
/// autoinserts at the end of the specified BasicBlock.
IndirectBrInst(Value *Address, unsigned NumDests, BasicBlock *InsertAtEnd);

// allocate space for exactly zero operands
void *operator new(size_t s) {
  return User::operator new(s);
}

void init(Value *Address, unsigned NumDests);
void growOperands();

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

IndirectBrInst *cloneImpl() const;

3584public:
/// Iterator type that casts an operand to a basic block.
///
/// This only makes sense because the successors are stored as adjacent
/// operands for indirectbr instructions.
struct succ_op_iterator
    : iterator_adaptor_base<succ_op_iterator, value_op_iterator,
                            std::random_access_iterator_tag, BasicBlock *,
                            ptrdiff_t, BasicBlock *, BasicBlock *> {
  explicit succ_op_iterator(value_op_iterator I) : iterator_adaptor_base(I) {}

  BasicBlock *operator*() const { return cast<BasicBlock>(*I); }
  BasicBlock *operator->() const { return operator*(); }
};

/// The const version of `succ_op_iterator`.
struct const_succ_op_iterator
    : iterator_adaptor_base<const_succ_op_iterator, const_value_op_iterator,
                            std::random_access_iterator_tag,
                            const BasicBlock *, ptrdiff_t, const BasicBlock *,
                            const BasicBlock *> {
  explicit const_succ_op_iterator(const_value_op_iterator I)
      : iterator_adaptor_base(I) {}

  const BasicBlock *operator*() const { return cast<BasicBlock>(*I); }
  const BasicBlock *operator->() const { return operator*(); }
};

static IndirectBrInst *Create(Value *Address, unsigned NumDests,
                              Instruction *InsertBefore = nullptr) {
  return new IndirectBrInst(Address, NumDests, InsertBefore);
}

static IndirectBrInst *Create(Value *Address, unsigned NumDests,
                              BasicBlock *InsertAtEnd) {
  return new IndirectBrInst(Address, NumDests, InsertAtEnd);
}

/// 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;

// Accessor Methods for IndirectBrInst instruction.
Value *getAddress() { return getOperand(0); }
const Value *getAddress() const { return getOperand(0); }
void setAddress(Value *V) { setOperand(0, V); }

/// return the number of possible destinations in this
/// indirectbr instruction.
unsigned getNumDestinations() const { return getNumOperands()-1; }

/// Return the specified destination.
BasicBlock *getDestination(unsigned i) { return getSuccessor(i); }
const BasicBlock *getDestination(unsigned i) const { return getSuccessor(i); }

/// Add a destination.
///
void addDestination(BasicBlock *Dest);

/// This method removes the specified successor from the
/// indirectbr instruction.
void removeDestination(unsigned i);

unsigned getNumSuccessors() const { return getNumOperands()-1; }
BasicBlock *getSuccessor(unsigned i) const {
  return cast<BasicBlock>(getOperand(i+1));
}
void setSuccessor(unsigned i, BasicBlock *NewSucc) {
  setOperand(i + 1, NewSucc);
}

iterator_range<succ_op_iterator> successors() {
  return make_range(succ_op_iterator(std::next(value_op_begin())),
                    succ_op_iterator(value_op_end()));
}

iterator_range<const_succ_op_iterator> successors() const {
  return make_range(const_succ_op_iterator(std::next(value_op_begin())),
                    const_succ_op_iterator(value_op_end()));
}

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

3673template <>
3674struct OperandTraits<IndirectBrInst> : public HungoffOperandTraits<1> {
3675};

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

3679//===----------------------------------------------------------------------===//
3680//                               InvokeInst Class
3681//===----------------------------------------------------------------------===//

3683/// Invoke instruction.  The SubclassData field is used to hold the
3684/// calling convention of the call.
3685///
3686class InvokeInst : public CallBase {
/// The number of operands for this call beyond the called function,
/// arguments, and operand bundles.
static constexpr int NumExtraOperands = 2;

/// The index from the end of the operand array to the normal destination.
static constexpr int NormalDestOpEndIdx = -3;

/// The index from the end of the operand array to the unwind destination.
static constexpr int UnwindDestOpEndIdx = -2;

InvokeInst(const InvokeInst &BI);

/// Construct an InvokeInst given a range of arguments.
///
/// Construct an InvokeInst from a range of arguments
inline InvokeInst(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
                  BasicBlock *IfException, ArrayRef<Value *> Args,
                  ArrayRef<OperandBundleDef> Bundles, int NumOperands,
                  const Twine &NameStr, Instruction *InsertBefore);

inline InvokeInst(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
                  BasicBlock *IfException, ArrayRef<Value *> Args,
                  ArrayRef<OperandBundleDef> Bundles, int NumOperands,
                  const Twine &NameStr, BasicBlock *InsertAtEnd);

void init(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
          BasicBlock *IfException, ArrayRef<Value *> Args,
          ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr);

/// Compute the number of operands to allocate.
static int ComputeNumOperands(int NumArgs, int NumBundleInputs = 0) {
  // We need one operand for the called function, plus our extra operands and
  // the input operand counts provided.
  return 1 + NumExtraOperands + NumArgs + NumBundleInputs;
}

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

InvokeInst *cloneImpl() const;

3729public:
static InvokeInst *Create(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
                          BasicBlock *IfException, ArrayRef<Value *> Args,
                          const Twine &NameStr,
                          Instruction *InsertBefore = nullptr) {
  int NumOperands = ComputeNumOperands(Args.size());
  return new (NumOperands)
      InvokeInst(Ty, Func, IfNormal, IfException, Args, None, NumOperands,
                 NameStr, InsertBefore);
}

static InvokeInst *Create(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
                          BasicBlock *IfException, ArrayRef<Value *> Args,
                          ArrayRef<OperandBundleDef> Bundles = None,
                          const Twine &NameStr = "",
                          Instruction *InsertBefore = nullptr) {
  int NumOperands =
      ComputeNumOperands(Args.size(), CountBundleInputs(Bundles));
  unsigned DescriptorBytes = Bundles.size() * sizeof(BundleOpInfo);

  return new (NumOperands, DescriptorBytes)
      InvokeInst(Ty, Func, IfNormal, IfException, Args, Bundles, NumOperands,
                 NameStr, InsertBefore);
}

static InvokeInst *Create(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
                          BasicBlock *IfException, ArrayRef<Value *> Args,
                          const Twine &NameStr, BasicBlock *InsertAtEnd) {
  int NumOperands = ComputeNumOperands(Args.size());
  return new (NumOperands)
      InvokeInst(Ty, Func, IfNormal, IfException, Args, None, NumOperands,
                 NameStr, InsertAtEnd);
}

static InvokeInst *Create(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
                          BasicBlock *IfException, ArrayRef<Value *> Args,
                          ArrayRef<OperandBundleDef> Bundles,
                          const Twine &NameStr, BasicBlock *InsertAtEnd) {
  int NumOperands =
      ComputeNumOperands(Args.size(), CountBundleInputs(Bundles));
  unsigned DescriptorBytes = Bundles.size() * sizeof(BundleOpInfo);

  return new (NumOperands, DescriptorBytes)
      InvokeInst(Ty, Func, IfNormal, IfException, Args, Bundles, NumOperands,
                 NameStr, InsertAtEnd);
}

static InvokeInst *Create(FunctionCallee Func, BasicBlock *IfNormal,
                          BasicBlock *IfException, ArrayRef<Value *> Args,
                          const Twine &NameStr,
                          Instruction *InsertBefore = nullptr) {
  return Create(Func.getFunctionType(), Func.getCallee(), IfNormal,
                IfException, Args, None, NameStr, InsertBefore);
}

static InvokeInst *Create(FunctionCallee Func, BasicBlock *IfNormal,
                          BasicBlock *IfException, ArrayRef<Value *> Args,
                          ArrayRef<OperandBundleDef> Bundles = None,
                          const Twine &NameStr = "",
                          Instruction *InsertBefore = nullptr) {
  return Create(Func.getFunctionType(), Func.getCallee(), IfNormal,
                IfException, Args, Bundles, NameStr, InsertBefore);
}

static InvokeInst *Create(FunctionCallee Func, BasicBlock *IfNormal,
                          BasicBlock *IfException, ArrayRef<Value *> Args,
                          const Twine &NameStr, BasicBlock *InsertAtEnd) {
  return Create(Func.getFunctionType(), Func.getCallee(), IfNormal,
                IfException, Args, NameStr, InsertAtEnd);
}

static InvokeInst *Create(FunctionCallee Func, BasicBlock *IfNormal,
                          BasicBlock *IfException, ArrayRef<Value *> Args,
                          ArrayRef<OperandBundleDef> Bundles,
                          const Twine &NameStr, BasicBlock *InsertAtEnd) {
  return Create(Func.getFunctionType(), Func.getCallee(), IfNormal,
                IfException, Args, Bundles, NameStr, InsertAtEnd);
}

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

/// Create a clone of \p II with a different set of operand bundles and
/// insert it before \p InsertPt.
///
/// The returned invoke instruction is identical to \p II in every way except
/// that the operand bundle for the new instruction is set to the operand
/// bundle in \p Bundle.
static InvokeInst *CreateWithReplacedBundle(InvokeInst *II,
                                            OperandBundleDef Bundles,
                                            Instruction *InsertPt = nullptr);

// get*Dest - Return the destination basic blocks...
BasicBlock *getNormalDest() const {
  return cast<BasicBlock>(Op<NormalDestOpEndIdx>());
}
BasicBlock *getUnwindDest() const {
  return cast<BasicBlock>(Op<UnwindDestOpEndIdx>());
}
void setNormalDest(BasicBlock *B) {
  Op<NormalDestOpEndIdx>() = reinterpret_cast<Value *>(B);
}
void setUnwindDest(BasicBlock *B) {
  Op<UnwindDestOpEndIdx>() = reinterpret_cast<Value *>(B);
}

/// Get the landingpad instruction from the landing pad
/// block (the unwind destination).
LandingPadInst *getLandingPadInst() const;

BasicBlock *getSuccessor(unsigned i) const {
  assert(i < 2 && "Successor # out of range for invoke!")((i < 2 && "Successor # out of range for invoke!")
 ? static_cast<void> (0) : __assert_fail ("i < 2 && \"Successor # out of range for invoke!\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 3846, __PRETTY_FUNCTION__));
  return i == 0 ? getNormalDest() : getUnwindDest();
}

void setSuccessor(unsigned i, BasicBlock *NewSucc) {
  assert(i < 2 && "Successor # out of range for invoke!")((i < 2 && "Successor # out of range for invoke!")
 ? static_cast<void> (0) : __assert_fail ("i < 2 && \"Successor # out of range for invoke!\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 3851, __PRETTY_FUNCTION__));
  if (i == 0)
    setNormalDest(NewSucc);
  else
    setUnwindDest(NewSucc);
}

unsigned getNumSuccessors() const { return 2; }

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

3868private:
// Shadow Instruction::setInstructionSubclassData with a private forwarding
// method so that subclasses cannot accidentally use it.
template <typename Bitfield>
void setSubclassData(typename Bitfield::Type Value) {
  Instruction::setSubclassData<Bitfield>(Value);
}
3875};

3877InvokeInst::InvokeInst(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
                     BasicBlock *IfException, ArrayRef<Value *> Args,
                     ArrayRef<OperandBundleDef> Bundles, int NumOperands,
                     const Twine &NameStr, Instruction *InsertBefore)
  : CallBase(Ty->getReturnType(), Instruction::Invoke,
             OperandTraits<CallBase>::op_end(this) - NumOperands, NumOperands,
             InsertBefore) {
init(Ty, Func, IfNormal, IfException, Args, Bundles, NameStr);
3885}

3887InvokeInst::InvokeInst(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
                     BasicBlock *IfException, ArrayRef<Value *> Args,
                     ArrayRef<OperandBundleDef> Bundles, int NumOperands,
                     const Twine &NameStr, BasicBlock *InsertAtEnd)
  : CallBase(Ty->getReturnType(), Instruction::Invoke,
             OperandTraits<CallBase>::op_end(this) - NumOperands, NumOperands,
             InsertAtEnd) {
init(Ty, Func, IfNormal, IfException, Args, Bundles, NameStr);
3895}

3897//===----------------------------------------------------------------------===//
3898//                              CallBrInst Class
3899//===----------------------------------------------------------------------===//

3901/// CallBr instruction, tracking function calls that may not return control but
3902/// instead transfer it to a third location. The SubclassData field is used to
3903/// hold the calling convention of the call.
3904///
3905class CallBrInst : public CallBase {

unsigned NumIndirectDests;

CallBrInst(const CallBrInst &BI);

/// Construct a CallBrInst given a range of arguments.
///
/// Construct a CallBrInst from a range of arguments
inline CallBrInst(FunctionType *Ty, Value *Func, BasicBlock *DefaultDest,
                  ArrayRef<BasicBlock *> IndirectDests,
                  ArrayRef<Value *> Args,
                  ArrayRef<OperandBundleDef> Bundles, int NumOperands,
                  const Twine &NameStr, Instruction *InsertBefore);

inline CallBrInst(FunctionType *Ty, Value *Func, BasicBlock *DefaultDest,
                  ArrayRef<BasicBlock *> IndirectDests,
                  ArrayRef<Value *> Args,
                  ArrayRef<OperandBundleDef> Bundles, int NumOperands,
                  const Twine &NameStr, BasicBlock *InsertAtEnd);

void init(FunctionType *FTy, Value *Func, BasicBlock *DefaultDest,
          ArrayRef<BasicBlock *> IndirectDests, ArrayRef<Value *> Args,
          ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr);

/// Should the Indirect Destinations change, scan + update the Arg list.
void updateArgBlockAddresses(unsigned i, BasicBlock *B);

/// Compute the number of operands to allocate.
static int ComputeNumOperands(int NumArgs, int NumIndirectDests,
                              int NumBundleInputs = 0) {
  // We need one operand for the called function, plus our extra operands and
  // the input operand counts provided.
  return 2 + NumIndirectDests + NumArgs + NumBundleInputs;
}

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

CallBrInst *cloneImpl() const;

3947public:
static CallBrInst *Create(FunctionType *Ty, Value *Func,
                          BasicBlock *DefaultDest,
                          ArrayRef<BasicBlock *> IndirectDests,
                          ArrayRef<Value *> Args, const Twine &NameStr,
                          Instruction *InsertBefore = nullptr) {
  int NumOperands = ComputeNumOperands(Args.size(), IndirectDests.size());
  return new (NumOperands)
      CallBrInst(Ty, Func, DefaultDest, IndirectDests, Args, None,
                 NumOperands, NameStr, InsertBefore);
}

static CallBrInst *Create(FunctionType *Ty, Value *Func,
                          BasicBlock *DefaultDest,
                          ArrayRef<BasicBlock *> IndirectDests,
                          ArrayRef<Value *> Args,
                          ArrayRef<OperandBundleDef> Bundles = None,
                          const Twine &NameStr = "",
                          Instruction *InsertBefore = nullptr) {
  int NumOperands = ComputeNumOperands(Args.size(), IndirectDests.size(),
                                       CountBundleInputs(Bundles));
  unsigned DescriptorBytes = Bundles.size() * sizeof(BundleOpInfo);

  return new (NumOperands, DescriptorBytes)
      CallBrInst(Ty, Func, DefaultDest, IndirectDests, Args, Bundles,
                 NumOperands, NameStr, InsertBefore);
}

static CallBrInst *Create(FunctionType *Ty, Value *Func,
                          BasicBlock *DefaultDest,
                          ArrayRef<BasicBlock *> IndirectDests,
                          ArrayRef<Value *> Args, const Twine &NameStr,
                          BasicBlock *InsertAtEnd) {
  int NumOperands = ComputeNumOperands(Args.size(), IndirectDests.size());
  return new (NumOperands)
      CallBrInst(Ty, Func, DefaultDest, IndirectDests, Args, None,
                 NumOperands, NameStr, InsertAtEnd);
}

static CallBrInst *Create(FunctionType *Ty, Value *Func,
                          BasicBlock *DefaultDest,
                          ArrayRef<BasicBlock *> IndirectDests,
                          ArrayRef<Value *> Args,
                          ArrayRef<OperandBundleDef> Bundles,
                          const Twine &NameStr, BasicBlock *InsertAtEnd) {
  int NumOperands = ComputeNumOperands(Args.size(), IndirectDests.size(),
                                       CountBundleInputs(Bundles));
  unsigned DescriptorBytes = Bundles.size() * sizeof(BundleOpInfo);

  return new (NumOperands, DescriptorBytes)
      CallBrInst(Ty, Func, DefaultDest, IndirectDests, Args, Bundles,
                 NumOperands, NameStr, InsertAtEnd);
}

static CallBrInst *Create(FunctionCallee Func, BasicBlock *DefaultDest,
                          ArrayRef<BasicBlock *> IndirectDests,
                          ArrayRef<Value *> Args, const Twine &NameStr,
                          Instruction *InsertBefore = nullptr) {
  return Create(Func.getFunctionType(), Func.getCallee(), DefaultDest,
                IndirectDests, Args, NameStr, InsertBefore);
}

static CallBrInst *Create(FunctionCallee Func, BasicBlock *DefaultDest,
                          ArrayRef<BasicBlock *> IndirectDests,
                          ArrayRef<Value *> Args,
                          ArrayRef<OperandBundleDef> Bundles = None,
                          const Twine &NameStr = "",
                          Instruction *InsertBefore = nullptr) {
  return Create(Func.getFunctionType(), Func.getCallee(), DefaultDest,
                IndirectDests, Args, Bundles, NameStr, InsertBefore);
}

static CallBrInst *Create(FunctionCallee Func, BasicBlock *DefaultDest,
                          ArrayRef<BasicBlock *> IndirectDests,
                          ArrayRef<Value *> Args, const Twine &NameStr,
                          BasicBlock *InsertAtEnd) {
  return Create(Func.getFunctionType(), Func.getCallee(), DefaultDest,
                IndirectDests, Args, NameStr, InsertAtEnd);
}

static CallBrInst *Create(FunctionCallee Func,
                          BasicBlock *DefaultDest,
                          ArrayRef<BasicBlock *> IndirectDests,
                          ArrayRef<Value *> Args,
                          ArrayRef<OperandBundleDef> Bundles,
                          const Twine &NameStr, BasicBlock *InsertAtEnd) {
  return Create(Func.getFunctionType(), Func.getCallee(), DefaultDest,
                IndirectDests, Args, Bundles, NameStr, InsertAtEnd);
}

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

/// Return the number of callbr indirect dest labels.
///
unsigned getNumIndirectDests() const { return NumIndirectDests; }

/// getIndirectDestLabel - Return the i-th indirect dest label.
///
Value *getIndirectDestLabel(unsigned i) const {
  assert(i < getNumIndirectDests() && "Out of bounds!")((i < getNumIndirectDests() && "Out of bounds!") ?
 static_cast<void> (0) : __assert_fail ("i < getNumIndirectDests() && \"Out of bounds!\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 4054, __PRETTY_FUNCTION__));
  return getOperand(i + getNumArgOperands() + getNumTotalBundleOperands() +
                    1);
}

Value *getIndirectDestLabelUse(unsigned i) const {
  assert(i < getNumIndirectDests() && "Out of bounds!")((i < getNumIndirectDests() && "Out of bounds!") ?
 static_cast<void> (0) : __assert_fail ("i < getNumIndirectDests() && \"Out of bounds!\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 4060, __PRETTY_FUNCTION__));
  return getOperandUse(i + getNumArgOperands() + getNumTotalBundleOperands() +
                       1);
}

// Return the destination basic blocks...
BasicBlock *getDefaultDest() const {
  return cast<BasicBlock>(*(&Op<-1>() - getNumIndirectDests() - 1));
}
BasicBlock *getIndirectDest(unsigned i) const {
  return cast_or_null<BasicBlock>(*(&Op<-1>() - getNumIndirectDests() + i));
}
SmallVector<BasicBlock *, 16> getIndirectDests() const {
  SmallVector<BasicBlock *, 16> IndirectDests;
  for (unsigned i = 0, e = getNumIndirectDests(); i < e; ++i)
    IndirectDests.push_back(getIndirectDest(i));
  return IndirectDests;
}
void setDefaultDest(BasicBlock *B) {
  *(&Op<-1>() - getNumIndirectDests() - 1) = reinterpret_cast<Value *>(B);
}
void setIndirectDest(unsigned i, BasicBlock *B) {
  updateArgBlockAddresses(i, B);
  *(&Op<-1>() - getNumIndirectDests() + i) = reinterpret_cast<Value *>(B);
}

BasicBlock *getSuccessor(unsigned i) const {
  assert(i < getNumSuccessors() + 1 &&((i < getNumSuccessors() + 1 && "Successor # out of range for callbr!"
) ? static_cast<void> (0) : __assert_fail ("i < getNumSuccessors() + 1 && \"Successor # out of range for callbr!\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 4088, __PRETTY_FUNCTION__))
         "Successor # out of range for callbr!")((i < getNumSuccessors() + 1 && "Successor # out of range for callbr!"
) ? static_cast<void> (0) : __assert_fail ("i < getNumSuccessors() + 1 && \"Successor # out of range for callbr!\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 4088, __PRETTY_FUNCTION__));
  return i == 0 ? getDefaultDest() : getIndirectDest(i - 1);
}

void setSuccessor(unsigned i, BasicBlock *NewSucc) {
  assert(i < getNumIndirectDests() + 1 &&((i < getNumIndirectDests() + 1 && "Successor # out of range for callbr!"
) ? static_cast<void> (0) : __assert_fail ("i < getNumIndirectDests() + 1 && \"Successor # out of range for callbr!\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 4094, __PRETTY_FUNCTION__))
         "Successor # out of range for callbr!")((i < getNumIndirectDests() + 1 && "Successor # out of range for callbr!"
) ? static_cast<void> (0) : __assert_fail ("i < getNumIndirectDests() + 1 && \"Successor # out of range for callbr!\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 4094, __PRETTY_FUNCTION__));
  return i == 0 ? setDefaultDest(NewSucc) : setIndirectDest(i - 1, NewSucc);
}

unsigned getNumSuccessors() const { return getNumIndirectDests() + 1; }

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

4108private:
// Shadow Instruction::setInstructionSubclassData with a private forwarding
// method so that subclasses cannot accidentally use it.
template <typename Bitfield>
void setSubclassData(typename Bitfield::Type Value) {
  Instruction::setSubclassData<Bitfield>(Value);
}
4115};

4117CallBrInst::CallBrInst(FunctionType *Ty, Value *Func, BasicBlock *DefaultDest,
                     ArrayRef<BasicBlock *> IndirectDests,
                     ArrayRef<Value *> Args,
                     ArrayRef<OperandBundleDef> Bundles, int NumOperands,
                     const Twine &NameStr, Instruction *InsertBefore)
  : CallBase(Ty->getReturnType(), Instruction::CallBr,
             OperandTraits<CallBase>::op_end(this) - NumOperands, NumOperands,
             InsertBefore) {
init(Ty, Func, DefaultDest, IndirectDests, Args, Bundles, NameStr);
4126}

4128CallBrInst::CallBrInst(FunctionType *Ty, Value *Func, BasicBlock *DefaultDest,
                     ArrayRef<BasicBlock *> IndirectDests,
                     ArrayRef<Value *> Args,
                     ArrayRef<OperandBundleDef> Bundles, int NumOperands,
                     const Twine &NameStr, BasicBlock *InsertAtEnd)
  : CallBase(Ty->getReturnType(), Instruction::CallBr,
             OperandTraits<CallBase>::op_end(this) - NumOperands, NumOperands,
             InsertAtEnd) {
init(Ty, Func, DefaultDest, IndirectDests, Args, Bundles, NameStr);
4137}

4139//===----------------------------------------------------------------------===//
4140//                              ResumeInst Class
4141//===----------------------------------------------------------------------===//

4143//===---------------------------------------------------------------------------
4144/// Resume the propagation of an exception.
4145///
4146class ResumeInst : public Instruction {
ResumeInst(const ResumeInst &RI);

explicit ResumeInst(Value *Exn, Instruction *InsertBefore=nullptr);
ResumeInst(Value *Exn, BasicBlock *InsertAtEnd);

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

ResumeInst *cloneImpl() const;

4158public:
static ResumeInst *Create(Value *Exn, Instruction *InsertBefore = nullptr) {
  return new(1) ResumeInst(Exn, InsertBefore);
}

static ResumeInst *Create(Value *Exn, BasicBlock *InsertAtEnd) {
  return new(1) ResumeInst(Exn, InsertAtEnd);
}

/// 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;

/// Convenience accessor.
Value *getValue() const { return Op<0>(); }

unsigned getNumSuccessors() const { return 0; }

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

4183private:
BasicBlock *getSuccessor(unsigned idx) const {
  llvm_unreachable("ResumeInst has no successors!")::llvm::llvm_unreachable_internal("ResumeInst has no successors!"
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 4185);
}

void setSuccessor(unsigned idx, BasicBlock *NewSucc) {
  llvm_unreachable("ResumeInst has no successors!")::llvm::llvm_unreachable_internal("ResumeInst has no successors!"
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 4189);
}
4191};

4193template <>
4194struct OperandTraits<ResumeInst> :
  public FixedNumOperandTraits<ResumeInst, 1> {
4196};

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

4200//===----------------------------------------------------------------------===//
4201//                         CatchSwitchInst Class
4202//===----------------------------------------------------------------------===//
4203class CatchSwitchInst : public Instruction {
using UnwindDestField = BoolBitfieldElementT<0>;

/// The number of operands actually allocated.  NumOperands is
/// the number actually in use.
unsigned ReservedSpace;

// Operand[0] = Outer scope
// Operand[1] = Unwind block destination
// Operand[n] = BasicBlock to go to on match
CatchSwitchInst(const CatchSwitchInst &CSI);

/// Create a new switch instruction, specifying a
/// default destination.  The number of additional handlers can be specified
/// here to make memory allocation more efficient.
/// This constructor can also autoinsert before another instruction.
CatchSwitchInst(Value *ParentPad, BasicBlock *UnwindDest,
                unsigned NumHandlers, const Twine &NameStr,
                Instruction *InsertBefore);

/// Create a new switch instruction, specifying a
/// default destination.  The number of additional handlers can be specified
/// here to make memory allocation more efficient.
/// This constructor also autoinserts at the end of the specified BasicBlock.
CatchSwitchInst(Value *ParentPad, BasicBlock *UnwindDest,
                unsigned NumHandlers, const Twine &NameStr,
                BasicBlock *InsertAtEnd);

// allocate space for exactly zero operands
void *operator new(size_t s) { return User::operator new(s); }

void init(Value *ParentPad, BasicBlock *UnwindDest, unsigned NumReserved);
void growOperands(unsigned Size);

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

CatchSwitchInst *cloneImpl() const;

4243public:
static CatchSwitchInst *Create(Value *ParentPad, BasicBlock *UnwindDest,
                               unsigned NumHandlers,
                               const Twine &NameStr = "",
                               Instruction *InsertBefore = nullptr) {
  return new CatchSwitchInst(ParentPad, UnwindDest, NumHandlers, NameStr,
                             InsertBefore);
}

static CatchSwitchInst *Create(Value *ParentPad, BasicBlock *UnwindDest,
                               unsigned NumHandlers, const Twine &NameStr,
                               BasicBlock *InsertAtEnd) {
  return new CatchSwitchInst(ParentPad, UnwindDest, NumHandlers, NameStr,
                             InsertAtEnd);
}

/// 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;

// Accessor Methods for CatchSwitch stmt
Value *getParentPad() const { return getOperand(0); }
void setParentPad(Value *ParentPad) { setOperand(0, ParentPad); }

// Accessor Methods for CatchSwitch stmt
bool hasUnwindDest() const { return getSubclassData<UnwindDestField>(); }
bool unwindsToCaller() const { return !hasUnwindDest(); }
BasicBlock *getUnwindDest() const {
  if (hasUnwindDest())
    return cast<BasicBlock>(getOperand(1));
  return nullptr;
}
void setUnwindDest(BasicBlock *UnwindDest) {
  assert(UnwindDest)((UnwindDest) ? static_cast<void> (0) : __assert_fail (
"UnwindDest", "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 4275, __PRETTY_FUNCTION__));
  assert(hasUnwindDest())((hasUnwindDest()) ? static_cast<void> (0) : __assert_fail
 ("hasUnwindDest()", "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 4276, __PRETTY_FUNCTION__));
  setOperand(1, UnwindDest);
}

/// return the number of 'handlers' in this catchswitch
/// instruction, except the default handler
unsigned getNumHandlers() const {
  if (hasUnwindDest())
    return getNumOperands() - 2;
  return getNumOperands() - 1;
}

4288private:
static BasicBlock *handler_helper(Value *V) { return cast<BasicBlock>(V); }
static const BasicBlock *handler_helper(const Value *V) {
  return cast<BasicBlock>(V);
}

4294public:
using DerefFnTy = BasicBlock *(*)(Value *);
using handler_iterator = mapped_iterator<op_iterator, DerefFnTy>;
using handler_range = iterator_range<handler_iterator>;
using ConstDerefFnTy = const BasicBlock *(*)(const Value *);
using const_handler_iterator =
    mapped_iterator<const_op_iterator, ConstDerefFnTy>;
using const_handler_range = iterator_range<const_handler_iterator>;

/// Returns an iterator that points to the first handler in CatchSwitchInst.
handler_iterator handler_begin() {
  op_iterator It = op_begin() + 1;
  if (hasUnwindDest())
    ++It;
  return handler_iterator(It, DerefFnTy(handler_helper));
}

/// Returns an iterator that points to the first handler in the
/// CatchSwitchInst.
const_handler_iterator handler_begin() const {
  const_op_iterator It = op_begin() + 1;
  if (hasUnwindDest())
    ++It;
  return const_handler_iterator(It, ConstDerefFnTy(handler_helper));
}

/// Returns a read-only iterator that points one past the last
/// handler in the CatchSwitchInst.
handler_iterator handler_end() {
  return handler_iterator(op_end(), DerefFnTy(handler_helper));
}

/// Returns an iterator that points one past the last handler in the
/// CatchSwitchInst.
const_handler_iterator handler_end() const {
  return const_handler_iterator(op_end(), ConstDerefFnTy(handler_helper));
}

/// iteration adapter for range-for loops.
handler_range handlers() {
  return make_range(handler_begin(), handler_end());
}

/// iteration adapter for range-for loops.
const_handler_range handlers() const {
  return make_range(handler_begin(), handler_end());
}

/// Add an entry to the switch instruction...
/// Note:
/// This action invalidates handler_end(). Old handler_end() iterator will
/// point to the added handler.
void addHandler(BasicBlock *Dest);

void removeHandler(handler_iterator HI);

unsigned getNumSuccessors() const { return getNumOperands() - 1; }
BasicBlock *getSuccessor(unsigned Idx) const {
  assert(Idx < getNumSuccessors() &&((Idx < getNumSuccessors() && "Successor # out of range for catchswitch!"
) ? static_cast<void> (0) : __assert_fail ("Idx < getNumSuccessors() && \"Successor # out of range for catchswitch!\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 4353, __PRETTY_FUNCTION__))
         "Successor # out of range for catchswitch!")((Idx < getNumSuccessors() && "Successor # out of range for catchswitch!"
) ? static_cast<void> (0) : __assert_fail ("Idx < getNumSuccessors() && \"Successor # out of range for catchswitch!\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 4353, __PRETTY_FUNCTION__));
  return cast<BasicBlock>(getOperand(Idx + 1));
}
void setSuccessor(unsigned Idx, BasicBlock *NewSucc) {
  assert(Idx < getNumSuccessors() &&((Idx < getNumSuccessors() && "Successor # out of range for catchswitch!"
) ? static_cast<void> (0) : __assert_fail ("Idx < getNumSuccessors() && \"Successor # out of range for catchswitch!\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 4358, __PRETTY_FUNCTION__))
         "Successor # out of range for catchswitch!")((Idx < getNumSuccessors() && "Successor # out of range for catchswitch!"
) ? static_cast<void> (0) : __assert_fail ("Idx < getNumSuccessors() && \"Successor # out of range for catchswitch!\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 4358, __PRETTY_FUNCTION__));
  setOperand(Idx + 1, NewSucc);
}

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

4371template <>
4372struct OperandTraits<CatchSwitchInst> : public HungoffOperandTraits<2> {};

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

4376//===----------------------------------------------------------------------===//
4377//                               CleanupPadInst Class
4378//===----------------------------------------------------------------------===//
4379class CleanupPadInst : public FuncletPadInst {
4380private:
explicit CleanupPadInst(Value *ParentPad, ArrayRef<Value *> Args,
                        unsigned Values, const Twine &NameStr,
                        Instruction *InsertBefore)
    : FuncletPadInst(Instruction::CleanupPad, ParentPad, Args, Values,
                     NameStr, InsertBefore) {}
explicit CleanupPadInst(Value *ParentPad, ArrayRef<Value *> Args,
                        unsigned Values, const Twine &NameStr,
                        BasicBlock *InsertAtEnd)
    : FuncletPadInst(Instruction::CleanupPad, ParentPad, Args, Values,
                     NameStr, InsertAtEnd) {}

4392public:
static CleanupPadInst *Create(Value *ParentPad, ArrayRef<Value *> Args = None,
                              const Twine &NameStr = "",
                              Instruction *InsertBefore = nullptr) {
  unsigned Values = 1 + Args.size();
  return new (Values)
      CleanupPadInst(ParentPad, Args, Values, NameStr, InsertBefore);
}

static CleanupPadInst *Create(Value *ParentPad, ArrayRef<Value *> Args,
                              const Twine &NameStr, BasicBlock *InsertAtEnd) {
  unsigned Values = 1 + Args.size();
  return new (Values)
      CleanupPadInst(ParentPad, Args, Values, NameStr, InsertAtEnd);
}

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

4417//===----------------------------------------------------------------------===//
4418//                               CatchPadInst Class
4419//===----------------------------------------------------------------------===//
4420class CatchPadInst : public FuncletPadInst {
4421private:
explicit CatchPadInst(Value *CatchSwitch, ArrayRef<Value *> Args,
                      unsigned Values, const Twine &NameStr,
                      Instruction *InsertBefore)
    : FuncletPadInst(Instruction::CatchPad, CatchSwitch, Args, Values,
                     NameStr, InsertBefore) {}
explicit CatchPadInst(Value *CatchSwitch, ArrayRef<Value *> Args,
                      unsigned Values, const Twine &NameStr,
                      BasicBlock *InsertAtEnd)
    : FuncletPadInst(Instruction::CatchPad, CatchSwitch, Args, Values,
                     NameStr, InsertAtEnd) {}

4433public:
static CatchPadInst *Create(Value *CatchSwitch, ArrayRef<Value *> Args,
                            const Twine &NameStr = "",
                            Instruction *InsertBefore = nullptr) {
  unsigned Values = 1 + Args.size();
  return new (Values)
      CatchPadInst(CatchSwitch, Args, Values, NameStr, InsertBefore);
}

static CatchPadInst *Create(Value *CatchSwitch, ArrayRef<Value *> Args,
                            const Twine &NameStr, BasicBlock *InsertAtEnd) {
  unsigned Values = 1 + Args.size();
  return new (Values)
      CatchPadInst(CatchSwitch, Args, Values, NameStr, InsertAtEnd);
}

/// Convenience accessors
CatchSwitchInst *getCatchSwitch() const {
  return cast<CatchSwitchInst>(Op<-1>());
}
void setCatchSwitch(Value *CatchSwitch) {
  assert(CatchSwitch)((CatchSwitch) ? static_cast<void> (0) : __assert_fail (
"CatchSwitch", "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 4454, __PRETTY_FUNCTION__));
  Op<-1>() = CatchSwitch;
}

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

4467//===----------------------------------------------------------------------===//
4468//                               CatchReturnInst Class
4469//===----------------------------------------------------------------------===//

4471class CatchReturnInst : public Instruction {
CatchReturnInst(const CatchReturnInst &RI);
CatchReturnInst(Value *CatchPad, BasicBlock *BB, Instruction *InsertBefore);
CatchReturnInst(Value *CatchPad, BasicBlock *BB, BasicBlock *InsertAtEnd);

void init(Value *CatchPad, BasicBlock *BB);

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

CatchReturnInst *cloneImpl() const;

4484public:
static CatchReturnInst *Create(Value *CatchPad, BasicBlock *BB,
                               Instruction *InsertBefore = nullptr) {
  assert(CatchPad)((CatchPad) ? static_cast<void> (0) : __assert_fail ("CatchPad"
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 4487, __PRETTY_FUNCTION__));
  assert(BB)((BB) ? static_cast<void> (0) : __assert_fail ("BB", "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 4488, __PRETTY_FUNCTION__));
  return new (2) CatchReturnInst(CatchPad, BB, InsertBefore);
}

static CatchReturnInst *Create(Value *CatchPad, BasicBlock *BB,
                               BasicBlock *InsertAtEnd) {
  assert(CatchPad)((CatchPad) ? static_cast<void> (0) : __assert_fail ("CatchPad"
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 4494, __PRETTY_FUNCTION__));
  assert(BB)((BB) ? static_cast<void> (0) : __assert_fail ("BB", "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 4495, __PRETTY_FUNCTION__));
  return new (2) CatchReturnInst(CatchPad, BB, InsertAtEnd);
}

/// 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;

/// Convenience accessors.
CatchPadInst *getCatchPad() const { return cast<CatchPadInst>(Op<0>()); }
void setCatchPad(CatchPadInst *CatchPad) {
  assert(CatchPad)((CatchPad) ? static_cast<void> (0) : __assert_fail ("CatchPad"
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 4505, __PRETTY_FUNCTION__));
  Op<0>() = CatchPad;
}

BasicBlock *getSuccessor() const { return cast<BasicBlock>(Op<1>()); }
void setSuccessor(BasicBlock *NewSucc) {
  assert(NewSucc)((NewSucc) ? static_cast<void> (0) : __assert_fail ("NewSucc"
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 4511, __PRETTY_FUNCTION__));
  Op<1>() = NewSucc;
}
unsigned getNumSuccessors() const { return 1; }

/// Get the parentPad of this catchret's catchpad's catchswitch.
/// The successor block is implicitly a member of this funclet.
Value *getCatchSwitchParentPad() const {
  return getCatchPad()->getCatchSwitch()->getParentPad();
}

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

4530private:
BasicBlock *getSuccessor(unsigned Idx) const {
  assert(Idx < getNumSuccessors() && "Successor # out of range for catchret!")((Idx < getNumSuccessors() && "Successor # out of range for catchret!"
) ? static_cast<void> (0) : __assert_fail ("Idx < getNumSuccessors() && \"Successor # out of range for catchret!\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 4532, __PRETTY_FUNCTION__));
  return getSuccessor();
}

void setSuccessor(unsigned Idx, BasicBlock *B) {
  assert(Idx < getNumSuccessors() && "Successor # out of range for catchret!")((Idx < getNumSuccessors() && "Successor # out of range for catchret!"
) ? static_cast<void> (0) : __assert_fail ("Idx < getNumSuccessors() && \"Successor # out of range for catchret!\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 4537, __PRETTY_FUNCTION__));
  setSuccessor(B);
}
4540};

4542template <>
4543struct OperandTraits<CatchReturnInst>
  : public FixedNumOperandTraits<CatchReturnInst, 2> {};

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

4548//===----------------------------------------------------------------------===//
4549//                               CleanupReturnInst Class
4550//===----------------------------------------------------------------------===//

4552class CleanupReturnInst : public Instruction {
using UnwindDestField = BoolBitfieldElementT<0>;

4555private:
CleanupReturnInst(const CleanupReturnInst &RI);
CleanupReturnInst(Value *CleanupPad, BasicBlock *UnwindBB, unsigned Values,
                  Instruction *InsertBefore = nullptr);
CleanupReturnInst(Value *CleanupPad, BasicBlock *UnwindBB, unsigned Values,
                  BasicBlock *InsertAtEnd);

void init(Value *CleanupPad, BasicBlock *UnwindBB);

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

CleanupReturnInst *cloneImpl() const;

4570public:
static CleanupReturnInst *Create(Value *CleanupPad,
                                 BasicBlock *UnwindBB = nullptr,
                                 Instruction *InsertBefore = nullptr) {
  assert(CleanupPad)((CleanupPad) ? static_cast<void> (0) : __assert_fail (
"CleanupPad", "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 4574, __PRETTY_FUNCTION__));
  unsigned Values = 1;
  if (UnwindBB)
    ++Values;
  return new (Values)
      CleanupReturnInst(CleanupPad, UnwindBB, Values, InsertBefore);
}

static CleanupReturnInst *Create(Value *CleanupPad, BasicBlock *UnwindBB,
                                 BasicBlock *InsertAtEnd) {
  assert(CleanupPad)((CleanupPad) ? static_cast<void> (0) : __assert_fail (
"CleanupPad", "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 4584, __PRETTY_FUNCTION__));
  unsigned Values = 1;
  if (UnwindBB)
    ++Values;
  return new (Values)
      CleanupReturnInst(CleanupPad, UnwindBB, Values, InsertAtEnd);
}

/// 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;

bool hasUnwindDest() const { return getSubclassData<UnwindDestField>(); }
bool unwindsToCaller() const { return !hasUnwindDest(); }

/// Convenience accessor.
CleanupPadInst *getCleanupPad() const {
  return cast<CleanupPadInst>(Op<0>());
}
void setCleanupPad(CleanupPadInst *CleanupPad) {
  assert(CleanupPad)((CleanupPad) ? static_cast<void> (0) : __assert_fail (
"CleanupPad", "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 4603, __PRETTY_FUNCTION__));
  Op<0>() = CleanupPad;
}

unsigned getNumSuccessors() const { return hasUnwindDest() ? 1 : 0; }

BasicBlock *getUnwindDest() const {
  return hasUnwindDest() ? cast<BasicBlock>(Op<1>()) : nullptr;
}
void setUnwindDest(BasicBlock *NewDest) {
  assert(NewDest)((NewDest) ? static_cast<void> (0) : __assert_fail ("NewDest"
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 4613, __PRETTY_FUNCTION__));
  assert(hasUnwindDest())((hasUnwindDest()) ? static_cast<void> (0) : __assert_fail
 ("hasUnwindDest()", "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 4614, __PRETTY_FUNCTION__));
  Op<1>() = NewDest;
}

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

4626private:
BasicBlock *getSuccessor(unsigned Idx) const {
  assert(Idx == 0)((Idx == 0) ? static_cast<void> (0) : __assert_fail ("Idx == 0"
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 4628, __PRETTY_FUNCTION__));
  return getUnwindDest();
}

void setSuccessor(unsigned Idx, BasicBlock *B) {
  assert(Idx == 0)((Idx == 0) ? static_cast<void> (0) : __assert_fail ("Idx == 0"
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 4633, __PRETTY_FUNCTION__));
  setUnwindDest(B);
}

// Shadow Instruction::setInstructionSubclassData with a private forwarding
// method so that subclasses cannot accidentally use it.
template <typename Bitfield>
void setSubclassData(typename Bitfield::Type Value) {
  Instruction::setSubclassData<Bitfield>(Value);
}
4643};

4645template <>
4646struct OperandTraits<CleanupReturnInst>
  : public VariadicOperandTraits<CleanupReturnInst, /*MINARITY=*/1> {};

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

4651//===----------------------------------------------------------------------===//
4652//                           UnreachableInst Class
4653//===----------------------------------------------------------------------===//

4655//===---------------------------------------------------------------------------
4656/// This function has undefined behavior.  In particular, the
4657/// presence of this instruction indicates some higher level knowledge that the
4658/// end of the block cannot be reached.
4659///
4660class UnreachableInst : public Instruction {
4661protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

UnreachableInst *cloneImpl() const;

4667public:
explicit UnreachableInst(LLVMContext &C, Instruction *InsertBefore = nullptr);
explicit UnreachableInst(LLVMContext &C, BasicBlock *InsertAtEnd);

// allocate space for exactly zero operands
void *operator new(size_t s) {
  return User::operator new(s, 0);
}

unsigned getNumSuccessors() const { return 0; }

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

4686private:
BasicBlock *getSuccessor(unsigned idx) const {
  llvm_unreachable("UnreachableInst has no successors!")::llvm::llvm_unreachable_internal("UnreachableInst has no successors!"
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 4688);
}

void setSuccessor(unsigned idx, BasicBlock *B) {
  llvm_unreachable("UnreachableInst has no successors!")::llvm::llvm_unreachable_internal("UnreachableInst has no successors!"
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 4692);
}
4694};

4696//===----------------------------------------------------------------------===//
4697//                                 TruncInst Class
4698//===----------------------------------------------------------------------===//

4700/// This class represents a truncation of integer types.
4701class TruncInst : public CastInst {
4702protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

/// Clone an identical TruncInst
TruncInst *cloneImpl() const;

4709public:
/// Constructor with insert-before-instruction semantics
TruncInst(
  Value *S,                           ///< The value to be truncated
  Type *Ty,                           ///< The (smaller) type to truncate to
  const Twine &NameStr = "",          ///< A name for the new instruction
  Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
);

/// Constructor with insert-at-end-of-block semantics
TruncInst(
  Value *S,                     ///< The value to be truncated
  Type *Ty,                     ///< The (smaller) type to truncate to
  const Twine &NameStr,         ///< A name for the new instruction
  BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
);

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

4735//===----------------------------------------------------------------------===//
4736//                                 ZExtInst Class
4737//===----------------------------------------------------------------------===//

4739/// This class represents zero extension of integer types.
4740class ZExtInst : public CastInst {
4741protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

/// Clone an identical ZExtInst
ZExtInst *cloneImpl() const;

4748public:
/// Constructor with insert-before-instruction semantics
ZExtInst(
  Value *S,                           ///< The value to be zero extended
  Type *Ty,                           ///< The type to zero extend to
  const Twine &NameStr = "",          ///< A name for the new instruction
  Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
);

/// Constructor with insert-at-end semantics.
ZExtInst(
  Value *S,                     ///< The value to be zero extended
  Type *Ty,                     ///< The type to zero extend to
  const Twine &NameStr,         ///< A name for the new instruction
  BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
);

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

4774//===----------------------------------------------------------------------===//
4775//                                 SExtInst Class
4776//===----------------------------------------------------------------------===//

4778/// This class represents a sign extension of integer types.
4779class SExtInst : public CastInst {
4780protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

/// Clone an identical SExtInst
SExtInst *cloneImpl() const;

4787public:
/// Constructor with insert-before-instruction semantics
SExtInst(
  Value *S,                           ///< The value to be sign extended
  Type *Ty,                           ///< The type to sign extend to
  const Twine &NameStr = "",          ///< A name for the new instruction
  Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
);

/// Constructor with insert-at-end-of-block semantics
SExtInst(
  Value *S,                     ///< The value to be sign extended
  Type *Ty,                     ///< The type to sign extend to
  const Twine &NameStr,         ///< A name for the new instruction
  BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
);

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

4813//===----------------------------------------------------------------------===//
4814//                                 FPTruncInst Class
4815//===----------------------------------------------------------------------===//

4817/// This class represents a truncation of floating point types.
4818class FPTruncInst : public CastInst {
4819protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

/// Clone an identical FPTruncInst
FPTruncInst *cloneImpl() const;

4826public:
/// Constructor with insert-before-instruction semantics
FPTruncInst(
  Value *S,                           ///< The value to be truncated
  Type *Ty,                           ///< The type to truncate to
  const Twine &NameStr = "",          ///< A name for the new instruction
  Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
);

/// Constructor with insert-before-instruction semantics
FPTruncInst(
  Value *S,                     ///< The value to be truncated
  Type *Ty,                     ///< The type to truncate to
  const Twine &NameStr,         ///< A name for the new instruction
  BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
);

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

4852//===----------------------------------------------------------------------===//
4853//                                 FPExtInst Class
4854//===----------------------------------------------------------------------===//

4856/// This class represents an extension of floating point types.
4857class FPExtInst : public CastInst {
4858protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

/// Clone an identical FPExtInst
FPExtInst *cloneImpl() const;

4865public:
/// Constructor with insert-before-instruction semantics
FPExtInst(
  Value *S,                           ///< The value to be extended
  Type *Ty,                           ///< The type to extend to
  const Twine &NameStr = "",          ///< A name for the new instruction
  Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
);

/// Constructor with insert-at-end-of-block semantics
FPExtInst(
  Value *S,                     ///< The value to be extended
  Type *Ty,                     ///< The type to extend to
  const Twine &NameStr,         ///< A name for the new instruction
  BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
);

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

4891//===----------------------------------------------------------------------===//
4892//                                 UIToFPInst Class
4893//===----------------------------------------------------------------------===//

4895/// This class represents a cast unsigned integer to floating point.
4896class UIToFPInst : public CastInst {
4897protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

/// Clone an identical UIToFPInst
UIToFPInst *cloneImpl() const;

4904public:
/// Constructor with insert-before-instruction semantics
UIToFPInst(
  Value *S,                           ///< The value to be converted
  Type *Ty,                           ///< The type to convert to
  const Twine &NameStr = "",          ///< A name for the new instruction
  Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
);

/// Constructor with insert-at-end-of-block semantics
UIToFPInst(
  Value *S,                     ///< The value to be converted
  Type *Ty,                     ///< The type to convert to
  const Twine &NameStr,         ///< A name for the new instruction
  BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
);

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

4930//===----------------------------------------------------------------------===//
4931//                                 SIToFPInst Class
4932//===----------------------------------------------------------------------===//

4934/// This class represents a cast from signed integer to floating point.
4935class SIToFPInst : public CastInst {
4936protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

/// Clone an identical SIToFPInst
SIToFPInst *cloneImpl() const;

4943public:
/// Constructor with insert-before-instruction semantics
SIToFPInst(
  Value *S,                           ///< The value to be converted
  Type *Ty,                           ///< The type to convert to
  const Twine &NameStr = "",          ///< A name for the new instruction
  Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
);

/// Constructor with insert-at-end-of-block semantics
SIToFPInst(
  Value *S,                     ///< The value to be converted
  Type *Ty,                     ///< The type to convert to
  const Twine &NameStr,         ///< A name for the new instruction
  BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
);

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

4969//===----------------------------------------------------------------------===//
4970//                                 FPToUIInst Class
4971//===----------------------------------------------------------------------===//

4973/// This class represents a cast from floating point to unsigned integer
4974class FPToUIInst  : public CastInst {
4975protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

/// Clone an identical FPToUIInst
FPToUIInst *cloneImpl() const;

4982public:
/// Constructor with insert-before-instruction semantics
FPToUIInst(
  Value *S,                           ///< The value to be converted
  Type *Ty,                           ///< The type to convert to
  const Twine &NameStr = "",          ///< A name for the new instruction
  Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
);

/// Constructor with insert-at-end-of-block semantics
FPToUIInst(
  Value *S,                     ///< The value to be converted
  Type *Ty,                     ///< The type to convert to
  const Twine &NameStr,         ///< A name for the new instruction
  BasicBlock *InsertAtEnd       ///< Where to insert the new instruction
);

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

5008//===----------------------------------------------------------------------===//
5009//                                 FPToSIInst Class
5010//===----------------------------------------------------------------------===//

5012/// This class represents a cast from floating point to signed integer.
5013class FPToSIInst  : public CastInst {
5014protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

/// Clone an identical FPToSIInst
FPToSIInst *cloneImpl() const;

5021public:
/// Constructor with insert-before-instruction semantics
FPToSIInst(
  Value *S,                           ///< The value to be converted
  Type *Ty,                           ///< The type to convert to
  const Twine &NameStr = "",          ///< A name for the new instruction
  Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
);

/// Constructor with insert-at-end-of-block semantics
FPToSIInst(
  Value *S,                     ///< The value to be converted
  Type *Ty,                     ///< The type to convert to
  const Twine &NameStr,         ///< A name for the new instruction
  BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
);

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

5047//===----------------------------------------------------------------------===//
5048//                                 IntToPtrInst Class
5049//===----------------------------------------------------------------------===//

5051/// This class represents a cast from an integer to a pointer.
5052class IntToPtrInst : public CastInst {
5053public:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

/// Constructor with insert-before-instruction semantics
IntToPtrInst(
  Value *S,                           ///< The value to be converted
  Type *Ty,                           ///< The type to convert to
  const Twine &NameStr = "",          ///< A name for the new instruction
  Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
);

/// Constructor with insert-at-end-of-block semantics
IntToPtrInst(
  Value *S,                     ///< The value to be converted
  Type *Ty,                     ///< The type to convert to
  const Twine &NameStr,         ///< A name for the new instruction
  BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
);

/// Clone an identical IntToPtrInst.
IntToPtrInst *cloneImpl() const;

/// Returns the address space of this instruction's pointer type.
unsigned getAddressSpace() const {
  return getType()->getPointerAddressSpace();
}

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

5090//===----------------------------------------------------------------------===//
5091//                                 PtrToIntInst Class
5092//===----------------------------------------------------------------------===//

5094/// This class represents a cast from a pointer to an integer.
5095class PtrToIntInst : public CastInst {
5096protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

/// Clone an identical PtrToIntInst.
PtrToIntInst *cloneImpl() const;

5103public:
/// Constructor with insert-before-instruction semantics
PtrToIntInst(
  Value *S,                           ///< The value to be converted
  Type *Ty,                           ///< The type to convert to
  const Twine &NameStr = "",          ///< A name for the new instruction
  Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
);

/// Constructor with insert-at-end-of-block semantics
PtrToIntInst(
  Value *S,                     ///< The value to be converted
  Type *Ty,                     ///< The type to convert to
  const Twine &NameStr,         ///< A name for the new instruction
  BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
);

/// Gets the pointer operand.
Value *getPointerOperand() { return getOperand(0); }
/// Gets the pointer operand.
const Value *getPointerOperand() const { return getOperand(0); }
/// Gets the operand index of the pointer operand.
static unsigned getPointerOperandIndex() { return 0U; }

/// Returns the address space of the pointer operand.
unsigned getPointerAddressSpace() const {
  return getPointerOperand()->getType()->getPointerAddressSpace();
}

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

5141//===----------------------------------------------------------------------===//
5142//                             BitCastInst Class
5143//===----------------------------------------------------------------------===//

5145/// This class represents a no-op cast from one type to another.
5146class BitCastInst : public CastInst {
5147protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

/// Clone an identical BitCastInst.
BitCastInst *cloneImpl() const;

5154public:
/// Constructor with insert-before-instruction semantics
BitCastInst(
  Value *S,                           ///< The value to be casted
  Type *Ty,                           ///< The type to casted to
  const Twine &NameStr = "",          ///< A name for the new instruction
  Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
);

/// Constructor with insert-at-end-of-block semantics
BitCastInst(
  Value *S,                     ///< The value to be casted
  Type *Ty,                     ///< The type to casted to
  const Twine &NameStr,         ///< A name for the new instruction
  BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
);

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

5180//===----------------------------------------------------------------------===//
5181//                          AddrSpaceCastInst Class
5182//===----------------------------------------------------------------------===//

5184/// This class represents a conversion between pointers from one address space
5185/// to another.
5186class AddrSpaceCastInst : public CastInst {
5187protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

/// Clone an identical AddrSpaceCastInst.
AddrSpaceCastInst *cloneImpl() const;

5194public:
/// Constructor with insert-before-instruction semantics
AddrSpaceCastInst(
  Value *S,                           ///< The value to be casted
  Type *Ty,                           ///< The type to casted to
  const Twine &NameStr = "",          ///< A name for the new instruction
  Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
);

/// Constructor with insert-at-end-of-block semantics
AddrSpaceCastInst(
  Value *S,                     ///< The value to be casted
  Type *Ty,                     ///< The type to casted to
  const Twine &NameStr,         ///< A name for the new instruction
  BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
);

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

/// Gets the pointer operand.
Value *getPointerOperand() {
  return getOperand(0);
}

/// Gets the pointer operand.
const Value *getPointerOperand() const {
  return getOperand(0);
}

/// Gets the operand index of the pointer operand.
static unsigned getPointerOperandIndex() {
  return 0U;
}

/// Returns the address space of the pointer operand.
unsigned getSrcAddressSpace() const {
  return getPointerOperand()->getType()->getPointerAddressSpace();
}

/// Returns the address space of the result.
unsigned getDestAddressSpace() const {
  return getType()->getPointerAddressSpace();
}
5243};

5245/// A helper function that returns the pointer operand of a load or store
5246/// instruction. Returns nullptr if not load or store.
5247inline const Value *getLoadStorePointerOperand(const Value *V) {
if (auto *Load = dyn_cast<LoadInst>(V))
  return Load->getPointerOperand();
if (auto *Store = dyn_cast<StoreInst>(V))
  return Store->getPointerOperand();
return nullptr;
5253}
5254inline Value *getLoadStorePointerOperand(Value *V) {
return const_cast<Value *>(
    getLoadStorePointerOperand(static_cast<const Value *>(V)));
5257}

5259/// A helper function that returns the pointer operand of a load, store
5260/// or GEP instruction. Returns nullptr if not load, store, or GEP.
5261inline const Value *getPointerOperand(const Value *V) {
if (auto *Ptr = getLoadStorePointerOperand(V))
  return Ptr;
if (auto *Gep = dyn_cast<GetElementPtrInst>(V))
  return Gep->getPointerOperand();
return nullptr;
5267}
5268inline Value *getPointerOperand(Value *V) {
return const_cast<Value *>(getPointerOperand(static_cast<const Value *>(V)));
5270}

5272/// A helper function that returns the alignment of load or store instruction.
5273inline Align getLoadStoreAlignment(Value *I) {
assert((isa<LoadInst>(I) || isa<StoreInst>(I)) &&(((isa<LoadInst>(I) || isa<StoreInst>(I)) &&
 "Expected Load or Store instruction") ? static_cast<void>
 (0) : __assert_fail ("(isa<LoadInst>(I) || isa<StoreInst>(I)) && \"Expected Load or Store instruction\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 5275, __PRETTY_FUNCTION__))
       "Expected Load or Store instruction")(((isa<LoadInst>(I) || isa<StoreInst>(I)) &&
 "Expected Load or Store instruction") ? static_cast<void>
 (0) : __assert_fail ("(isa<LoadInst>(I) || isa<StoreInst>(I)) && \"Expected Load or Store instruction\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 5275, __PRETTY_FUNCTION__));
if (auto *LI = dyn_cast<LoadInst>(I))
  return LI->getAlign();
return cast<StoreInst>(I)->getAlign();
5279}

5281/// A helper function that returns the address space of the pointer operand of
5282/// load or store instruction.
5283inline unsigned getLoadStoreAddressSpace(Value *I) {
assert((isa<LoadInst>(I) || isa<StoreInst>(I)) &&(((isa<LoadInst>(I) || isa<StoreInst>(I)) &&
 "Expected Load or Store instruction") ? static_cast<void>
 (0) : __assert_fail ("(isa<LoadInst>(I) || isa<StoreInst>(I)) && \"Expected Load or Store instruction\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 5285, __PRETTY_FUNCTION__))
       "Expected Load or Store instruction")(((isa<LoadInst>(I) || isa<StoreInst>(I)) &&
 "Expected Load or Store instruction") ? static_cast<void>
 (0) : __assert_fail ("(isa<LoadInst>(I) || isa<StoreInst>(I)) && \"Expected Load or Store instruction\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instructions.h"
, 5285, __PRETTY_FUNCTION__));
if (auto *LI = dyn_cast<LoadInst>(I))
  return LI->getPointerAddressSpace();
return cast<StoreInst>(I)->getPointerAddressSpace();
5289}

5291//===----------------------------------------------------------------------===//
5292//                              FreezeInst Class
5293//===----------------------------------------------------------------------===//

5295/// This class represents a freeze function that returns random concrete
5296/// value if an operand is either a poison value or an undef value
5297class FreezeInst : public UnaryInstruction {
5298protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

/// Clone an identical FreezeInst
FreezeInst *cloneImpl() const;

5305public:
explicit FreezeInst(Value *S,
                    const Twine &NameStr = "",
                    Instruction *InsertBefore = nullptr);
FreezeInst(Value *S, const Twine &NameStr, BasicBlock *InsertAtEnd);

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

5320} // end namespace llvm

5322#endif // LLVM_IR_INSTRUCTIONS_H

←

/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/IR/Instruction.h

1//===-- llvm/Instruction.h - Instruction class definition -------*- 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 contains the declaration of the Instruction class, which is the
10// base class for all of the LLVM instructions.
11//
12//===----------------------------------------------------------------------===//

14#ifndef LLVM_IR_INSTRUCTION_H
15#define LLVM_IR_INSTRUCTION_H

17#include "llvm/ADT/ArrayRef.h"
18#include "llvm/ADT/Bitfields.h"
19#include "llvm/ADT/None.h"
20#include "llvm/ADT/StringRef.h"
21#include "llvm/ADT/ilist_node.h"
22#include "llvm/IR/DebugLoc.h"
23#include "llvm/IR/SymbolTableListTraits.h"
24#include "llvm/IR/User.h"
25#include "llvm/IR/Value.h"
26#include "llvm/Support/AtomicOrdering.h"
27#include "llvm/Support/Casting.h"
28#include <algorithm>
29#include <cassert>
30#include <cstdint>
31#include <utility>

33namespace llvm {

35class BasicBlock;
36class FastMathFlags;
37class MDNode;
38class Module;
39struct AAMDNodes;

41template <> struct ilist_alloc_traits<Instruction> {
static inline void deleteNode(Instruction *V);
43};

45class Instruction : public User,
                  public ilist_node_with_parent<Instruction, BasicBlock> {
BasicBlock *Parent;
DebugLoc DbgLoc;                         // 'dbg' Metadata cache.

/// Relative order of this instruction in its parent basic block. Used for
/// O(1) local dominance checks between instructions.
mutable unsigned Order = 0;

54protected:
// The 15 first bits of `Value::SubclassData` are available for subclasses of
// `Instruction` to use.
using OpaqueField = Bitfield::Element<uint16_t, 0, 15>;

// Template alias so that all Instruction storing alignment use the same
// definiton.
// Valid alignments are powers of two from 2^0 to 2^MaxAlignmentExponent =
// 2^29. We store them as Log2(Alignment), so we need 5 bits to encode the 30
// possible values.
template <unsigned Offset>
using AlignmentBitfieldElementT =
    typename Bitfield::Element<unsigned, Offset, 5,
                               Value::MaxAlignmentExponent>;

template <unsigned Offset>
using BoolBitfieldElementT = typename Bitfield::Element<bool, Offset, 1>;

template <unsigned Offset>
using AtomicOrderingBitfieldElementT =
    typename Bitfield::Element<AtomicOrdering, Offset, 3,
                               AtomicOrdering::LAST>;

77private:
// The last bit is used to store whether the instruction has metadata attached
// or not.
using HasMetadataField = Bitfield::Element<bool, 15, 1>;

82protected:
~Instruction(); // Use deleteValue() to delete a generic Instruction.

85public:
Instruction(const Instruction &) = delete;
Instruction &operator=(const Instruction &) = delete;

/// Specialize the methods defined in Value, as we know that an instruction
/// can only be used by other instructions.
Instruction       *user_back()       { return cast<Instruction>(*user_begin());}
const Instruction *user_back() const { return cast<Instruction>(*user_begin());}

inline const BasicBlock *getParent() const { return Parent; }
inline       BasicBlock *getParent()       { return Parent; }

/// Return the module owning the function this instruction belongs to
/// or nullptr it the function does not have a module.
///
/// Note: this is undefined behavior if the instruction does not have a
/// parent, or the parent basic block does not have a parent function.
const Module *getModule() const;
Module *getModule() {
  return const_cast<Module *>(
                         static_cast<const Instruction *>(this)->getModule());
}

/// Return the function this instruction belongs to.
///
/// Note: it is undefined behavior to call this on an instruction not
/// currently inserted into a function.
const Function *getFunction() const;
Function *getFunction() {
  return const_cast<Function *>(
                       static_cast<const Instruction *>(this)->getFunction());
}

/// This method unlinks 'this' from the containing basic block, but does not
/// delete it.
void removeFromParent();

/// This method unlinks 'this' from the containing basic block and deletes it.
///
/// \returns an iterator pointing to the element after the erased one
SymbolTableList<Instruction>::iterator eraseFromParent();

/// Insert an unlinked instruction into a basic block immediately before
/// the specified instruction.
void insertBefore(Instruction *InsertPos);

/// Insert an unlinked instruction into a basic block immediately after the
/// specified instruction.
void insertAfter(Instruction *InsertPos);

/// Unlink this instruction from its current basic block and insert it into
/// the basic block that MovePos lives in, right before MovePos.
void moveBefore(Instruction *MovePos);

/// Unlink this instruction and insert into BB before I.
///
/// \pre I is a valid iterator into BB.
void moveBefore(BasicBlock &BB, SymbolTableList<Instruction>::iterator I);

/// Unlink this instruction from its current basic block and insert it into
/// the basic block that MovePos lives in, right after MovePos.
void moveAfter(Instruction *MovePos);

/// Given an instruction Other in the same basic block as this instruction,
/// return true if this instruction comes before Other. In this worst case,
/// this takes linear time in the number of instructions in the block. The
/// results are cached, so in common cases when the block remains unmodified,
/// it takes constant time.
bool comesBefore(const Instruction *Other) const;

//===--------------------------------------------------------------------===//
// Subclass classification.
//===--------------------------------------------------------------------===//

/// Returns a member of one of the enums like Instruction::Add.
unsigned getOpcode() const { return getValueID() - InstructionVal; }

const char *getOpcodeName() const { return getOpcodeName(getOpcode()); }
bool isTerminator() const { return isTerminator(getOpcode()); }
bool isUnaryOp() const { return isUnaryOp(getOpcode()); }
bool isBinaryOp() const { return isBinaryOp(getOpcode()); }
bool isIntDivRem() const { return isIntDivRem(getOpcode()); }
bool isShift() const { return isShift(getOpcode()); }
bool isCast() const { return isCast(getOpcode()); }
bool isFuncletPad() const { return isFuncletPad(getOpcode()); }
bool isExceptionalTerminator() const {
  return isExceptionalTerminator(getOpcode());
}
bool isIndirectTerminator() const {
  return isIndirectTerminator(getOpcode());
}

static const char* getOpcodeName(unsigned OpCode);

static inline bool isTerminator(unsigned OpCode) {
  return OpCode >= TermOpsBegin && OpCode < TermOpsEnd;
}

static inline bool isUnaryOp(unsigned Opcode) {
  return Opcode >= UnaryOpsBegin && Opcode < UnaryOpsEnd;
}
static inline bool isBinaryOp(unsigned Opcode) {
  return Opcode >= BinaryOpsBegin && Opcode < BinaryOpsEnd;
}

static inline bool isIntDivRem(unsigned Opcode) {
  return Opcode == UDiv || Opcode == SDiv || Opcode == URem || Opcode == SRem;
}

/// Determine if the Opcode is one of the shift instructions.
static inline bool isShift(unsigned Opcode) {
  return Opcode >= Shl && Opcode <= AShr;
}

/// Return true if this is a logical shift left or a logical shift right.
inline bool isLogicalShift() const {
  return getOpcode() == Shl || getOpcode() == LShr;
}

/// Return true if this is an arithmetic shift right.
inline bool isArithmeticShift() const {
  return getOpcode() == AShr;
}

/// Determine if the Opcode is and/or/xor.
static inline bool isBitwiseLogicOp(unsigned Opcode) {
  return Opcode == And || Opcode == Or || Opcode == Xor;
}

/// Return true if this is and/or/xor.
inline bool isBitwiseLogicOp() const {
  return isBitwiseLogicOp(getOpcode());
}

/// Determine if the OpCode is one of the CastInst instructions.
static inline bool isCast(unsigned OpCode) {
  return OpCode >= CastOpsBegin && OpCode < CastOpsEnd;
}

/// Determine if the OpCode is one of the FuncletPadInst instructions.
static inline bool isFuncletPad(unsigned OpCode) {
  return OpCode >= FuncletPadOpsBegin && OpCode < FuncletPadOpsEnd;
}

/// Returns true if the OpCode is a terminator related to exception handling.
static inline bool isExceptionalTerminator(unsigned OpCode) {
  switch (OpCode) {
  case Instruction::CatchSwitch:
  case Instruction::CatchRet:
  case Instruction::CleanupRet:
  case Instruction::Invoke:
  case Instruction::Resume:
    return true;
  default:
    return false;
  }
}

/// Returns true if the OpCode is a terminator with indirect targets.
static inline bool isIndirectTerminator(unsigned OpCode) {
  switch (OpCode) {
  case Instruction::IndirectBr:
  case Instruction::CallBr:
    return true;
  default:
    return false;
  }
}

//===--------------------------------------------------------------------===//
// Metadata manipulation.
//===--------------------------------------------------------------------===//

/// Return true if this instruction has any metadata attached to it.
bool hasMetadata() const { return DbgLoc || Value::hasMetadata(); }

/// Return true if this instruction has metadata attached to it other than a
/// debug location.
bool hasMetadataOtherThanDebugLoc() const { return Value::hasMetadata(); }

/// Return true if this instruction has the given type of metadata attached.
bool hasMetadata(unsigned KindID) const {
  return getMetadata(KindID) != nullptr;
22
←
Returning zero, which participates in a condition later→
}

/// Return true if this instruction has the given type of metadata attached.
bool hasMetadata(StringRef Kind) const {
  return getMetadata(Kind) != nullptr;
}

/// Get the metadata of given kind attached to this Instruction.
/// If the metadata is not found then return null.
MDNode *getMetadata(unsigned KindID) const {
  if (!hasMetadata()) return nullptr;
  return getMetadataImpl(KindID);
}

/// Get the metadata of given kind attached to this Instruction.
/// If the metadata is not found then return null.
MDNode *getMetadata(StringRef Kind) const {
  if (!hasMetadata()) return nullptr;
  return getMetadataImpl(Kind);
}

/// Get all metadata attached to this Instruction. The first element of each
/// pair returned is the KindID, the second element is the metadata value.
/// This list is returned sorted by the KindID.
void
getAllMetadata(SmallVectorImpl<std::pair<unsigned, MDNode *>> &MDs) const {
  if (hasMetadata())
    getAllMetadataImpl(MDs);
}

/// This does the same thing as getAllMetadata, except that it filters out the
/// debug location.
void getAllMetadataOtherThanDebugLoc(
    SmallVectorImpl<std::pair<unsigned, MDNode *>> &MDs) const {
  Value::getAllMetadata(MDs);
}

/// Fills the AAMDNodes structure with AA metadata from this instruction.
/// When Merge is true, the existing AA metadata is merged with that from this
/// instruction providing the most-general result.
void getAAMetadata(AAMDNodes &N, bool Merge = false) const;

/// Set the metadata of the specified kind to the specified node. This updates
/// or replaces metadata if already present, or removes it if Node is null.
void setMetadata(unsigned KindID, MDNode *Node);
void setMetadata(StringRef Kind, MDNode *Node);

/// Copy metadata from \p SrcInst to this instruction. \p WL, if not empty,
/// specifies the list of meta data that needs to be copied. If \p WL is
/// empty, all meta data will be copied.
void copyMetadata(const Instruction &SrcInst,
                  ArrayRef<unsigned> WL = ArrayRef<unsigned>());

/// If the instruction has "branch_weights" MD_prof metadata and the MDNode
/// has three operands (including name string), swap the order of the
/// metadata.
void swapProfMetadata();

/// Drop all unknown metadata except for debug locations.
/// @{
/// Passes are required to drop metadata they don't understand. This is a
/// convenience method for passes to do so.
void dropUnknownNonDebugMetadata(ArrayRef<unsigned> KnownIDs);
void dropUnknownNonDebugMetadata() {
  return dropUnknownNonDebugMetadata(None);
}
void dropUnknownNonDebugMetadata(unsigned ID1) {
  return dropUnknownNonDebugMetadata(makeArrayRef(ID1));
}
void dropUnknownNonDebugMetadata(unsigned ID1, unsigned ID2) {
  unsigned IDs[] = {ID1, ID2};
  return dropUnknownNonDebugMetadata(IDs);
}
/// @}

/// Sets the metadata on this instruction from the AAMDNodes structure.
void setAAMetadata(const AAMDNodes &N);

/// Retrieve the raw weight values of a conditional branch or select.
/// Returns true on success with profile weights filled in.
/// Returns false if no metadata or invalid metadata was found.
bool extractProfMetadata(uint64_t &TrueVal, uint64_t &FalseVal) const;

/// Retrieve total raw weight values of a branch.
/// Returns true on success with profile total weights filled in.
/// Returns false if no metadata was found.
bool extractProfTotalWeight(uint64_t &TotalVal) const;

/// Set the debug location information for this instruction.
void setDebugLoc(DebugLoc Loc) { DbgLoc = std::move(Loc); }

/// Return the debug location for this node as a DebugLoc.
const DebugLoc &getDebugLoc() const { return DbgLoc; }

/// Set or clear the nuw flag on this instruction, which must be an operator
/// which supports this flag. See LangRef.html for the meaning of this flag.
void setHasNoUnsignedWrap(bool b = true);

/// Set or clear the nsw flag on this instruction, which must be an operator
/// which supports this flag. See LangRef.html for the meaning of this flag.
void setHasNoSignedWrap(bool b = true);

/// Set or clear the exact flag on this instruction, which must be an operator
/// which supports this flag. See LangRef.html for the meaning of this flag.
void setIsExact(bool b = true);

/// Determine whether the no unsigned wrap flag is set.
bool hasNoUnsignedWrap() const;

/// Determine whether the no signed wrap flag is set.
bool hasNoSignedWrap() const;

/// Drops flags that may cause this instruction to evaluate to poison despite
/// having non-poison inputs.
void dropPoisonGeneratingFlags();

/// Determine whether the exact flag is set.
bool isExact() const;

/// Set or clear all fast-math-flags on this instruction, which must be an
/// operator which supports this flag. See LangRef.html for the meaning of
/// this flag.
void setFast(bool B);

/// Set or clear the reassociation flag on this instruction, which must be
/// an operator which supports this flag. See LangRef.html for the meaning of
/// this flag.
void setHasAllowReassoc(bool B);

/// Set or clear the no-nans flag on this instruction, which must be an
/// operator which supports this flag. See LangRef.html for the meaning of
/// this flag.
void setHasNoNaNs(bool B);

/// Set or clear the no-infs flag on this instruction, which must be an
/// operator which supports this flag. See LangRef.html for the meaning of
/// this flag.
void setHasNoInfs(bool B);

/// Set or clear the no-signed-zeros flag on this instruction, which must be
/// an operator which supports this flag. See LangRef.html for the meaning of
/// this flag.
void setHasNoSignedZeros(bool B);

/// Set or clear the allow-reciprocal flag on this instruction, which must be
/// an operator which supports this flag. See LangRef.html for the meaning of
/// this flag.
void setHasAllowReciprocal(bool B);

/// Set or clear the allow-contract flag on this instruction, which must be
/// an operator which supports this flag. See LangRef.html for the meaning of
/// this flag.
void setHasAllowContract(bool B);

/// Set or clear the approximate-math-functions flag on this instruction,
/// which must be an operator which supports this flag. See LangRef.html for
/// the meaning of this flag.
void setHasApproxFunc(bool B);

/// Convenience function for setting multiple fast-math flags on this
/// instruction, which must be an operator which supports these flags. See
/// LangRef.html for the meaning of these flags.
void setFastMathFlags(FastMathFlags FMF);

/// Convenience function for transferring all fast-math flag values to this
/// instruction, which must be an operator which supports these flags. See
/// LangRef.html for the meaning of these flags.
void copyFastMathFlags(FastMathFlags FMF);

/// Determine whether all fast-math-flags are set.
bool isFast() const;

/// Determine whether the allow-reassociation flag is set.
bool hasAllowReassoc() const;

/// Determine whether the no-NaNs flag is set.
bool hasNoNaNs() const;

/// Determine whether the no-infs flag is set.
bool hasNoInfs() const;

/// Determine whether the no-signed-zeros flag is set.
bool hasNoSignedZeros() const;

/// Determine whether the allow-reciprocal flag is set.
bool hasAllowReciprocal() const;

/// Determine whether the allow-contract flag is set.
bool hasAllowContract() const;

/// Determine whether the approximate-math-functions flag is set.
bool hasApproxFunc() const;

/// Convenience function for getting all the fast-math flags, which must be an
/// operator which supports these flags. See LangRef.html for the meaning of
/// these flags.
FastMathFlags getFastMathFlags() const;

/// Copy I's fast-math flags
void copyFastMathFlags(const Instruction *I);

/// Convenience method to copy supported exact, fast-math, and (optionally)
/// wrapping flags from V to this instruction.
void copyIRFlags(const Value *V, bool IncludeWrapFlags = true);

/// Logical 'and' of any supported wrapping, exact, and fast-math flags of
/// V and this instruction.
void andIRFlags(const Value *V);

/// Merge 2 debug locations and apply it to the Instruction. If the
/// instruction is a CallIns, we need to traverse the inline chain to find
/// the common scope. This is not efficient for N-way merging as each time
/// you merge 2 iterations, you need to rebuild the hashmap to find the
/// common scope. However, we still choose this API because:
///  1) Simplicity: it takes 2 locations instead of a list of locations.
///  2) In worst case, it increases the complexity from O(N*I) to
///     O(2*N*I), where N is # of Instructions to merge, and I is the
///     maximum level of inline stack. So it is still linear.
///  3) Merging of call instructions should be extremely rare in real
///     applications, thus the N-way merging should be in code path.
/// The DebugLoc attached to this instruction will be overwritten by the
/// merged DebugLoc.
void applyMergedLocation(const DILocation *LocA, const DILocation *LocB);

/// Updates the debug location given that the instruction has been hoisted
/// from a block to a predecessor of that block.
/// Note: it is undefined behavior to call this on an instruction not
/// currently inserted into a function.
void updateLocationAfterHoist();

/// Drop the instruction's debug location. This does not guarantee removal
/// of the !dbg source location attachment, as it must set a line 0 location
/// with scope information attached on call instructions. To guarantee
/// removal of the !dbg attachment, use the \ref setDebugLoc() API.
/// Note: it is undefined behavior to call this on an instruction not
/// currently inserted into a function.
void dropLocation();

506private:
// These are all implemented in Metadata.cpp.
MDNode *getMetadataImpl(unsigned KindID) const;
MDNode *getMetadataImpl(StringRef Kind) const;
void
getAllMetadataImpl(SmallVectorImpl<std::pair<unsigned, MDNode *>> &) const;

513public:
//===--------------------------------------------------------------------===//
// Predicates and helper methods.
//===--------------------------------------------------------------------===//

/// Return true if the instruction is associative:
///
///   Associative operators satisfy:  x op (y op z) === (x op y) op z
///
/// In LLVM, the Add, Mul, And, Or, and Xor operators are associative.
///
bool isAssociative() const LLVM_READONLY__attribute__((__pure__));
static bool isAssociative(unsigned Opcode) {
  return Opcode == And || Opcode == Or || Opcode == Xor ||
         Opcode == Add || Opcode == Mul;
}

/// Return true if the instruction is commutative:
///
///   Commutative operators satisfy: (x op y) === (y op x)
///
/// In LLVM, these are the commutative operators, plus SetEQ and SetNE, when
/// applied to any type.
///
bool isCommutative() const LLVM_READONLY__attribute__((__pure__));
static bool isCommutative(unsigned Opcode) {
  switch (Opcode) {
  case Add: case FAdd:
  case Mul: case FMul:
  case And: case Or: case Xor:
    return true;
  default:
    return false;
}
}

/// Return true if the instruction is idempotent:
///
///   Idempotent operators satisfy:  x op x === x
///
/// In LLVM, the And and Or operators are idempotent.
///
bool isIdempotent() const { return isIdempotent(getOpcode()); }
static bool isIdempotent(unsigned Opcode) {
  return Opcode == And || Opcode == Or;
}

/// Return true if the instruction is nilpotent:
///
///   Nilpotent operators satisfy:  x op x === Id,
///
///   where Id is the identity for the operator, i.e. a constant such that
///     x op Id === x and Id op x === x for all x.
///
/// In LLVM, the Xor operator is nilpotent.
///
bool isNilpotent() const { return isNilpotent(getOpcode()); }
static bool isNilpotent(unsigned Opcode) {
  return Opcode == Xor;
}

/// Return true if this instruction may modify memory.
bool mayWriteToMemory() const;

/// Return true if this instruction may read memory.
bool mayReadFromMemory() const;

/// Return true if this instruction may read or write memory.
bool mayReadOrWriteMemory() const {
  return mayReadFromMemory() || mayWriteToMemory();
}

/// Return true if this instruction has an AtomicOrdering of unordered or
/// higher.
bool isAtomic() const;

/// Return true if this atomic instruction loads from memory.
bool hasAtomicLoad() const;

/// Return true if this atomic instruction stores to memory.
bool hasAtomicStore() const;

/// Return true if this instruction may throw an exception.
bool mayThrow() const;

/// Return true if this instruction behaves like a memory fence: it can load
/// or store to memory location without being given a memory location.
bool isFenceLike() const {
  switch (getOpcode()) {
  default:
    return false;
  // This list should be kept in sync with the list in mayWriteToMemory for
  // all opcodes which don't have a memory location.
  case Instruction::Fence:
  case Instruction::CatchPad:
  case Instruction::CatchRet:
  case Instruction::Call:
  case Instruction::Invoke:
    return true;
  }
}

/// Return true if the instruction may have side effects.
///
/// Note that this does not consider malloc and alloca to have side
/// effects because the newly allocated memory is completely invisible to
/// instructions which don't use the returned value.  For cases where this
/// matters, isSafeToSpeculativelyExecute may be more appropriate.
bool mayHaveSideEffects() const { return mayWriteToMemory() || mayThrow(); }

/// Return true if the instruction can be removed if the result is unused.
///
/// When constant folding some instructions cannot be removed even if their
/// results are unused. Specifically terminator instructions and calls that
/// may have side effects cannot be removed without semantically changing the
/// generated program.
bool isSafeToRemove() const;

/// Return true if the instruction is a variety of EH-block.
bool isEHPad() const {
  switch (getOpcode()) {
  case Instruction::CatchSwitch:
  case Instruction::CatchPad:
  case Instruction::CleanupPad:
  case Instruction::LandingPad:
    return true;
  default:
    return false;
  }
}

/// Return true if the instruction is a llvm.lifetime.start or
/// llvm.lifetime.end marker.
bool isLifetimeStartOrEnd() const;

/// Return a pointer to the next non-debug instruction in the same basic
/// block as 'this', or nullptr if no such instruction exists.
const Instruction *getNextNonDebugInstruction() const;
Instruction *getNextNonDebugInstruction() {
  return const_cast<Instruction *>(
      static_cast<const Instruction *>(this)->getNextNonDebugInstruction());
}

/// Return a pointer to the previous non-debug instruction in the same basic
/// block as 'this', or nullptr if no such instruction exists.
const Instruction *getPrevNonDebugInstruction() const;
Instruction *getPrevNonDebugInstruction() {
  return const_cast<Instruction *>(
      static_cast<const Instruction *>(this)->getPrevNonDebugInstruction());
}

/// Create a copy of 'this' instruction that is identical in all ways except
/// the following:
///   * The instruction has no parent
///   * The instruction has no name
///
Instruction *clone() const;

/// Return true if the specified instruction is exactly identical to the
/// current one. This means that all operands match and any extra information
/// (e.g. load is volatile) agree.
bool isIdenticalTo(const Instruction *I) const;

/// This is like isIdenticalTo, except that it ignores the
/// SubclassOptionalData flags, which may specify conditions under which the
/// instruction's result is undefined.
bool isIdenticalToWhenDefined(const Instruction *I) const;

/// When checking for operation equivalence (using isSameOperationAs) it is
/// sometimes useful to ignore certain attributes.
enum OperationEquivalenceFlags {
  /// Check for equivalence ignoring load/store alignment.
  CompareIgnoringAlignment = 1<<0,
  /// Check for equivalence treating a type and a vector of that type
  /// as equivalent.
  CompareUsingScalarTypes = 1<<1
};

/// This function determines if the specified instruction executes the same
/// operation as the current one. This means that the opcodes, type, operand
/// types and any other factors affecting the operation must be the same. This
/// is similar to isIdenticalTo except the operands themselves don't have to
/// be identical.
/// @returns true if the specified instruction is the same operation as
/// the current one.
/// Determine if one instruction is the same operation as another.
bool isSameOperationAs(const Instruction *I, unsigned flags = 0) const;

/// Return true if there are any uses of this instruction in blocks other than
/// the specified block. Note that PHI nodes are considered to evaluate their
/// operands in the corresponding predecessor block.
bool isUsedOutsideOfBlock(const BasicBlock *BB) const;

/// Return the number of successors that this instruction has. The instruction
/// must be a terminator.
unsigned getNumSuccessors() const;

/// Return the specified successor. This instruction must be a terminator.
BasicBlock *getSuccessor(unsigned Idx) const;

/// Update the specified successor to point at the provided block. This
/// instruction must be a terminator.
void setSuccessor(unsigned Idx, BasicBlock *BB);

/// Replace specified successor OldBB to point at the provided block.
/// This instruction must be a terminator.
void replaceSuccessorWith(BasicBlock *OldBB, BasicBlock *NewBB);

/// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Value *V) {
  return V->getValueID() >= Value::InstructionVal;
}

//----------------------------------------------------------------------
// Exported enumerations.
//
enum TermOps {       // These terminate basic blocks
730#define  FIRST_TERM_INST(N)             TermOpsBegin = N,
731#define HANDLE_TERM_INST(N, OPC, CLASS) OPC = N,
732#define   LAST_TERM_INST(N)             TermOpsEnd = N+1
733#include "llvm/IR/Instruction.def"
};

enum UnaryOps {
737#define  FIRST_UNARY_INST(N)             UnaryOpsBegin = N,
738#define HANDLE_UNARY_INST(N, OPC, CLASS) OPC = N,
739#define   LAST_UNARY_INST(N)             UnaryOpsEnd = N+1
740#include "llvm/IR/Instruction.def"
};

enum BinaryOps {
744#define  FIRST_BINARY_INST(N)             BinaryOpsBegin = N,
745#define HANDLE_BINARY_INST(N, OPC, CLASS) OPC = N,
746#define   LAST_BINARY_INST(N)             BinaryOpsEnd = N+1
747#include "llvm/IR/Instruction.def"
};

enum MemoryOps {
751#define  FIRST_MEMORY_INST(N)             MemoryOpsBegin = N,
752#define HANDLE_MEMORY_INST(N, OPC, CLASS) OPC = N,
753#define   LAST_MEMORY_INST(N)             MemoryOpsEnd = N+1
754#include "llvm/IR/Instruction.def"
};

enum CastOps {
758#define  FIRST_CAST_INST(N)             CastOpsBegin = N,
759#define HANDLE_CAST_INST(N, OPC, CLASS) OPC = N,
760#define   LAST_CAST_INST(N)             CastOpsEnd = N+1
761#include "llvm/IR/Instruction.def"
};

enum FuncletPadOps {
765#define  FIRST_FUNCLETPAD_INST(N)             FuncletPadOpsBegin = N,
766#define HANDLE_FUNCLETPAD_INST(N, OPC, CLASS) OPC = N,
767#define   LAST_FUNCLETPAD_INST(N)             FuncletPadOpsEnd = N+1
768#include "llvm/IR/Instruction.def"
};

enum OtherOps {
772#define  FIRST_OTHER_INST(N)             OtherOpsBegin = N,
773#define HANDLE_OTHER_INST(N, OPC, CLASS) OPC = N,
774#define   LAST_OTHER_INST(N)             OtherOpsEnd = N+1
775#include "llvm/IR/Instruction.def"
};

778private:
friend class SymbolTableListTraits<Instruction>;
friend class BasicBlock; // For renumbering.

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

unsigned short getSubclassDataFromValue() const {
  return Value::getSubclassDataFromValue();
}

void setParent(BasicBlock *P);

794protected:
// Instruction subclasses can stick up to 15 bits of stuff into the
// SubclassData field of instruction with these members.

template <typename BitfieldElement>
typename BitfieldElement::Type getSubclassData() const {
  static_assert(
      std::is_same<BitfieldElement, HasMetadataField>::value ||
          !Bitfield::isOverlapping<BitfieldElement, HasMetadataField>(),
      "Must not overlap with the metadata bit");
  return Bitfield::get<BitfieldElement>(getSubclassDataFromValue());
}

template <typename BitfieldElement>
void setSubclassData(typename BitfieldElement::Type Value) {
  static_assert(
      std::is_same<BitfieldElement, HasMetadataField>::value ||
          !Bitfield::isOverlapping<BitfieldElement, HasMetadataField>(),
      "Must not overlap with the metadata bit");
  auto Storage = getSubclassDataFromValue();
  Bitfield::set<BitfieldElement>(Storage, Value);
  setValueSubclassData(Storage);
}

Instruction(Type *Ty, unsigned iType, Use *Ops, unsigned NumOps,
            Instruction *InsertBefore = nullptr);
Instruction(Type *Ty, unsigned iType, Use *Ops, unsigned NumOps,
            BasicBlock *InsertAtEnd);

823private:
/// Create a copy of this instruction.
Instruction *cloneImpl() const;
826};

828inline void ilist_alloc_traits<Instruction>::deleteNode(Instruction *V) {
V->deleteValue();
830}

832} // end namespace llvm

834#endif // LLVM_IR_INSTRUCTION_H