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

Bug Summary

File:	llvm/lib/Transforms/Scalar/JumpThreading.cpp
Warning:	line 1424, column 7 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 JumpThreading.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/JumpThreading.cpp

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

→

1//===- JumpThreading.cpp - Thread control through conditional blocks ------===//
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 implements the Jump Threading pass.
10//
11//===----------------------------------------------------------------------===//

13#include "llvm/Transforms/Scalar/JumpThreading.h"
14#include "llvm/ADT/DenseMap.h"
15#include "llvm/ADT/DenseSet.h"
16#include "llvm/ADT/MapVector.h"
17#include "llvm/ADT/Optional.h"
18#include "llvm/ADT/STLExtras.h"
19#include "llvm/ADT/SmallPtrSet.h"
20#include "llvm/ADT/SmallVector.h"
21#include "llvm/ADT/Statistic.h"
22#include "llvm/Analysis/AliasAnalysis.h"
23#include "llvm/Analysis/BlockFrequencyInfo.h"
24#include "llvm/Analysis/BranchProbabilityInfo.h"
25#include "llvm/Analysis/CFG.h"
26#include "llvm/Analysis/ConstantFolding.h"
27#include "llvm/Analysis/DomTreeUpdater.h"
28#include "llvm/Analysis/GlobalsModRef.h"
29#include "llvm/Analysis/GuardUtils.h"
30#include "llvm/Analysis/InstructionSimplify.h"
31#include "llvm/Analysis/LazyValueInfo.h"
32#include "llvm/Analysis/Loads.h"
33#include "llvm/Analysis/LoopInfo.h"
34#include "llvm/Analysis/TargetLibraryInfo.h"
35#include "llvm/Analysis/ValueTracking.h"
36#include "llvm/IR/BasicBlock.h"
37#include "llvm/IR/CFG.h"
38#include "llvm/IR/Constant.h"
39#include "llvm/IR/ConstantRange.h"
40#include "llvm/IR/Constants.h"
41#include "llvm/IR/DataLayout.h"
42#include "llvm/IR/Dominators.h"
43#include "llvm/IR/Function.h"
44#include "llvm/IR/InstrTypes.h"
45#include "llvm/IR/Instruction.h"
46#include "llvm/IR/Instructions.h"
47#include "llvm/IR/IntrinsicInst.h"
48#include "llvm/IR/Intrinsics.h"
49#include "llvm/IR/LLVMContext.h"
50#include "llvm/IR/MDBuilder.h"
51#include "llvm/IR/Metadata.h"
52#include "llvm/IR/Module.h"
53#include "llvm/IR/PassManager.h"
54#include "llvm/IR/PatternMatch.h"
55#include "llvm/IR/Type.h"
56#include "llvm/IR/Use.h"
57#include "llvm/IR/User.h"
58#include "llvm/IR/Value.h"
59#include "llvm/InitializePasses.h"
60#include "llvm/Pass.h"
61#include "llvm/Support/BlockFrequency.h"
62#include "llvm/Support/BranchProbability.h"
63#include "llvm/Support/Casting.h"
64#include "llvm/Support/CommandLine.h"
65#include "llvm/Support/Debug.h"
66#include "llvm/Support/raw_ostream.h"
67#include "llvm/Transforms/Scalar.h"
68#include "llvm/Transforms/Utils/BasicBlockUtils.h"
69#include "llvm/Transforms/Utils/Cloning.h"
70#include "llvm/Transforms/Utils/Local.h"
71#include "llvm/Transforms/Utils/SSAUpdater.h"
72#include "llvm/Transforms/Utils/ValueMapper.h"
73#include <algorithm>
74#include <cassert>
75#include <cstddef>
76#include <cstdint>
77#include <iterator>
78#include <memory>
79#include <utility>

81using namespace llvm;
82using namespace jumpthreading;

84#define DEBUG_TYPE"jump-threading" "jump-threading"

86STATISTIC(NumThreads, "Number of jumps threaded")static llvm::Statistic NumThreads = {"jump-threading", "NumThreads"
, "Number of jumps threaded"};
87STATISTIC(NumFolds,   "Number of terminators folded")static llvm::Statistic NumFolds = {"jump-threading", "NumFolds"
, "Number of terminators folded"};
88STATISTIC(NumDupes,   "Number of branch blocks duplicated to eliminate phi")static llvm::Statistic NumDupes = {"jump-threading", "NumDupes"
, "Number of branch blocks duplicated to eliminate phi"};

90static cl::opt<unsigned>
91BBDuplicateThreshold("jump-threading-threshold",
        cl::desc("Max block size to duplicate for jump threading"),
        cl::init(6), cl::Hidden);

95static cl::opt<unsigned>
96ImplicationSearchThreshold(
"jump-threading-implication-search-threshold",
cl::desc("The number of predecessors to search for a stronger "
         "condition to use to thread over a weaker condition"),
cl::init(3), cl::Hidden);

102static cl::opt<bool> PrintLVIAfterJumpThreading(
  "print-lvi-after-jump-threading",
  cl::desc("Print the LazyValueInfo cache after JumpThreading"), cl::init(false),
  cl::Hidden);

107static cl::opt<bool> JumpThreadingFreezeSelectCond(
  "jump-threading-freeze-select-cond",
  cl::desc("Freeze the condition when unfolding select"), cl::init(false),
  cl::Hidden);

112static cl::opt<bool> ThreadAcrossLoopHeaders(
  "jump-threading-across-loop-headers",
  cl::desc("Allow JumpThreading to thread across loop headers, for testing"),
  cl::init(false), cl::Hidden);


118namespace {

/// This pass performs 'jump threading', which looks at blocks that have
/// multiple predecessors and multiple successors.  If one or more of the
/// predecessors of the block can be proven to always jump to one of the
/// successors, we forward the edge from the predecessor to the successor by
/// duplicating the contents of this block.
///
/// An example of when this can occur is code like this:
///
///   if () { ...
///     X = 4;
///   }
///   if (X < 3) {
///
/// In this case, the unconditional branch at the end of the first if can be
/// revectored to the false side of the second if.
class JumpThreading : public FunctionPass {
  JumpThreadingPass Impl;

public:
  static char ID; // Pass identification

  JumpThreading(bool InsertFreezeWhenUnfoldingSelect = false, int T = -1)
      : FunctionPass(ID), Impl(InsertFreezeWhenUnfoldingSelect, T) {
    initializeJumpThreadingPass(*PassRegistry::getPassRegistry());
  }

  bool runOnFunction(Function &F) override;

  void getAnalysisUsage(AnalysisUsage &AU) const override {
    AU.addRequired<DominatorTreeWrapperPass>();
    AU.addPreserved<DominatorTreeWrapperPass>();
    AU.addRequired<AAResultsWrapperPass>();
    AU.addRequired<LazyValueInfoWrapperPass>();
    AU.addPreserved<LazyValueInfoWrapperPass>();
    AU.addPreserved<GlobalsAAWrapperPass>();
    AU.addRequired<TargetLibraryInfoWrapperPass>();
  }

  void releaseMemory() override { Impl.releaseMemory(); }
};

161} // end anonymous namespace

163char JumpThreading::ID = 0;

165INITIALIZE_PASS_BEGIN(JumpThreading, "jump-threading",static void *initializeJumpThreadingPassOnce(PassRegistry &
Registry) {
              "Jump Threading", false, false)static void *initializeJumpThreadingPassOnce(PassRegistry &
Registry) {
167INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)initializeDominatorTreeWrapperPassPass(Registry);
168INITIALIZE_PASS_DEPENDENCY(LazyValueInfoWrapperPass)initializeLazyValueInfoWrapperPassPass(Registry);
169INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass)initializeTargetLibraryInfoWrapperPassPass(Registry);
170INITIALIZE_PASS_DEPENDENCY(AAResultsWrapperPass)initializeAAResultsWrapperPassPass(Registry);
171INITIALIZE_PASS_END(JumpThreading, "jump-threading",PassInfo *PI = new PassInfo( "Jump Threading", "jump-threading"
, &JumpThreading::ID, PassInfo::NormalCtor_t(callDefaultCtor
<JumpThreading>), false, false); Registry.registerPass(
*PI, true); return PI; } static llvm::once_flag InitializeJumpThreadingPassFlag
; void llvm::initializeJumpThreadingPass(PassRegistry &Registry
) { llvm::call_once(InitializeJumpThreadingPassFlag, initializeJumpThreadingPassOnce
, std::ref(Registry)); }
              "Jump Threading", false, false)PassInfo *PI = new PassInfo( "Jump Threading", "jump-threading"
, &JumpThreading::ID, PassInfo::NormalCtor_t(callDefaultCtor
<JumpThreading>), false, false); Registry.registerPass(
*PI, true); return PI; } static llvm::once_flag InitializeJumpThreadingPassFlag
; void llvm::initializeJumpThreadingPass(PassRegistry &Registry
) { llvm::call_once(InitializeJumpThreadingPassFlag, initializeJumpThreadingPassOnce
, std::ref(Registry)); }

174// Public interface to the Jump Threading pass
175FunctionPass *llvm::createJumpThreadingPass(bool InsertFr, int Threshold) {
return new JumpThreading(InsertFr, Threshold);
177}

179JumpThreadingPass::JumpThreadingPass(bool InsertFr, int T) {
InsertFreezeWhenUnfoldingSelect = JumpThreadingFreezeSelectCond | InsertFr;
DefaultBBDupThreshold = (T == -1) ? BBDuplicateThreshold : unsigned(T);
182}

184// Update branch probability information according to conditional
185// branch probability. This is usually made possible for cloned branches
186// in inline instances by the context specific profile in the caller.
187// For instance,
188//
189//  [Block PredBB]
190//  [Branch PredBr]
191//  if (t) {
192//     Block A;
193//  } else {
194//     Block B;
195//  }
196//
197//  [Block BB]
198//  cond = PN([true, %A], [..., %B]); // PHI node
199//  [Branch CondBr]
200//  if (cond) {
201//    ...  // P(cond == true) = 1%
202//  }
203//
204//  Here we know that when block A is taken, cond must be true, which means
205//      P(cond == true | A) = 1
206//
207//  Given that P(cond == true) = P(cond == true | A) * P(A) +
208//                               P(cond == true | B) * P(B)
209//  we get:
210//     P(cond == true ) = P(A) + P(cond == true | B) * P(B)
211//
212//  which gives us:
213//     P(A) is less than P(cond == true), i.e.
214//     P(t == true) <= P(cond == true)
215//
216//  In other words, if we know P(cond == true) is unlikely, we know
217//  that P(t == true) is also unlikely.
218//
219static void updatePredecessorProfileMetadata(PHINode *PN, BasicBlock *BB) {
BranchInst *CondBr = dyn_cast<BranchInst>(BB->getTerminator());
if (!CondBr)
  return;

uint64_t TrueWeight, FalseWeight;
if (!CondBr->extractProfMetadata(TrueWeight, FalseWeight))
  return;

if (TrueWeight + FalseWeight == 0)
  // Zero branch_weights do not give a hint for getting branch probabilities.
  // Technically it would result in division by zero denominator, which is
  // TrueWeight + FalseWeight.
  return;

// Returns the outgoing edge of the dominating predecessor block
// that leads to the PhiNode's incoming block:
auto GetPredOutEdge =
    [](BasicBlock *IncomingBB,
       BasicBlock *PhiBB) -> std::pair<BasicBlock *, BasicBlock *> {
  auto *PredBB = IncomingBB;
  auto *SuccBB = PhiBB;
  SmallPtrSet<BasicBlock *, 16> Visited;
  while (true) {
    BranchInst *PredBr = dyn_cast<BranchInst>(PredBB->getTerminator());
    if (PredBr && PredBr->isConditional())
      return {PredBB, SuccBB};
    Visited.insert(PredBB);
    auto *SinglePredBB = PredBB->getSinglePredecessor();
    if (!SinglePredBB)
      return {nullptr, nullptr};

    // Stop searching when SinglePredBB has been visited. It means we see
    // an unreachable loop.
    if (Visited.count(SinglePredBB))
      return {nullptr, nullptr};

    SuccBB = PredBB;
    PredBB = SinglePredBB;
  }
};

for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) {
  Value *PhiOpnd = PN->getIncomingValue(i);
  ConstantInt *CI = dyn_cast<ConstantInt>(PhiOpnd);

  if (!CI || !CI->getType()->isIntegerTy(1))
    continue;

  BranchProbability BP =
      (CI->isOne() ? BranchProbability::getBranchProbability(
                         TrueWeight, TrueWeight + FalseWeight)
                   : BranchProbability::getBranchProbability(
                         FalseWeight, TrueWeight + FalseWeight));

  auto PredOutEdge = GetPredOutEdge(PN->getIncomingBlock(i), BB);
  if (!PredOutEdge.first)
    return;

  BasicBlock *PredBB = PredOutEdge.first;
  BranchInst *PredBr = dyn_cast<BranchInst>(PredBB->getTerminator());
  if (!PredBr)
    return;

  uint64_t PredTrueWeight, PredFalseWeight;
  // FIXME: We currently only set the profile data when it is missing.
  // With PGO, this can be used to refine even existing profile data with
  // context information. This needs to be done after more performance
  // testing.
  if (PredBr->extractProfMetadata(PredTrueWeight, PredFalseWeight))
    continue;

  // We can not infer anything useful when BP >= 50%, because BP is the
  // upper bound probability value.
  if (BP >= BranchProbability(50, 100))
    continue;

  SmallVector<uint32_t, 2> Weights;
  if (PredBr->getSuccessor(0) == PredOutEdge.second) {
    Weights.push_back(BP.getNumerator());
    Weights.push_back(BP.getCompl().getNumerator());
  } else {
    Weights.push_back(BP.getCompl().getNumerator());
    Weights.push_back(BP.getNumerator());
  }
  PredBr->setMetadata(LLVMContext::MD_prof,
                      MDBuilder(PredBr->getParent()->getContext())
                          .createBranchWeights(Weights));
}
308}

310/// runOnFunction - Toplevel algorithm.
311bool JumpThreading::runOnFunction(Function &F) {
if (skipFunction(F))
  return false;
auto TLI = &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(F);
auto DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
auto LVI = &getAnalysis<LazyValueInfoWrapperPass>().getLVI();
auto AA = &getAnalysis<AAResultsWrapperPass>().getAAResults();
DomTreeUpdater DTU(*DT, DomTreeUpdater::UpdateStrategy::Lazy);
std::unique_ptr<BlockFrequencyInfo> BFI;
std::unique_ptr<BranchProbabilityInfo> BPI;
if (F.hasProfileData()) {
  LoopInfo LI{DominatorTree(F)};
  BPI.reset(new BranchProbabilityInfo(F, LI, TLI));
  BFI.reset(new BlockFrequencyInfo(F, *BPI, LI));
}

bool Changed = Impl.runImpl(F, TLI, LVI, AA, &DTU, F.hasProfileData(),
                            std::move(BFI), std::move(BPI));
if (PrintLVIAfterJumpThreading) {
  dbgs() << "LVI for function '" << F.getName() << "':\n";
  LVI->printLVI(F, DTU.getDomTree(), dbgs());
}
return Changed;
334}

336PreservedAnalyses JumpThreadingPass::run(Function &F,
                                       FunctionAnalysisManager &AM) {
auto &TLI = AM.getResult<TargetLibraryAnalysis>(F);
auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
auto &LVI = AM.getResult<LazyValueAnalysis>(F);
auto &AA = AM.getResult<AAManager>(F);
DomTreeUpdater DTU(DT, DomTreeUpdater::UpdateStrategy::Lazy);

std::unique_ptr<BlockFrequencyInfo> BFI;
std::unique_ptr<BranchProbabilityInfo> BPI;
if (F.hasProfileData()) {
  LoopInfo LI{DominatorTree(F)};
  BPI.reset(new BranchProbabilityInfo(F, LI, &TLI));
  BFI.reset(new BlockFrequencyInfo(F, *BPI, LI));
}

bool Changed = runImpl(F, &TLI, &LVI, &AA, &DTU, F.hasProfileData(),
                       std::move(BFI), std::move(BPI));

if (!Changed)
  return PreservedAnalyses::all();
PreservedAnalyses PA;
PA.preserve<GlobalsAA>();
PA.preserve<DominatorTreeAnalysis>();
PA.preserve<LazyValueAnalysis>();
return PA;
362}

364bool JumpThreadingPass::runImpl(Function &F, TargetLibraryInfo *TLI_,
                              LazyValueInfo *LVI_, AliasAnalysis *AA_,
                              DomTreeUpdater *DTU_, bool HasProfileData_,
                              std::unique_ptr<BlockFrequencyInfo> BFI_,
                              std::unique_ptr<BranchProbabilityInfo> BPI_) {
LLVM_DEBUG(dbgs() << "Jump threading on function '" << F.getName() << "'\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { dbgs() << "Jump threading on function '"
 << F.getName() << "'\n"; } } while (false);
TLI = TLI_;
LVI = LVI_;
AA = AA_;
DTU = DTU_;
BFI.reset();
BPI.reset();
// When profile data is available, we need to update edge weights after
// successful jump threading, which requires both BPI and BFI being available.
HasProfileData = HasProfileData_;
auto *GuardDecl = F.getParent()->getFunction(
    Intrinsic::getName(Intrinsic::experimental_guard));
HasGuards = GuardDecl && !GuardDecl->use_empty();
if (HasProfileData) {
  BPI = std::move(BPI_);
  BFI = std::move(BFI_);
}

// Reduce the number of instructions duplicated when optimizing strictly for
// size.
if (BBDuplicateThreshold.getNumOccurrences())
  BBDupThreshold = BBDuplicateThreshold;
else if (F.hasFnAttribute(Attribute::MinSize))
  BBDupThreshold = 3;
else
  BBDupThreshold = DefaultBBDupThreshold;

// JumpThreading must not processes blocks unreachable from entry. It's a
// waste of compute time and can potentially lead to hangs.
SmallPtrSet<BasicBlock *, 16> Unreachable;
assert(DTU && "DTU isn't passed into JumpThreading before using it.")((DTU && "DTU isn't passed into JumpThreading before using it."
) ? static_cast<void> (0) : __assert_fail ("DTU && \"DTU isn't passed into JumpThreading before using it.\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/JumpThreading.cpp"
, 399, __PRETTY_FUNCTION__));
assert(DTU->hasDomTree() && "JumpThreading relies on DomTree to proceed.")((DTU->hasDomTree() && "JumpThreading relies on DomTree to proceed."
) ? static_cast<void> (0) : __assert_fail ("DTU->hasDomTree() && \"JumpThreading relies on DomTree to proceed.\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/JumpThreading.cpp"
, 400, __PRETTY_FUNCTION__));
DominatorTree &DT = DTU->getDomTree();
for (auto &BB : F)
  if (!DT.isReachableFromEntry(&BB))
    Unreachable.insert(&BB);

if (!ThreadAcrossLoopHeaders)
  FindLoopHeaders(F);

bool EverChanged = false;
bool Changed;
do {
  Changed = false;
  for (auto &BB : F) {
    if (Unreachable.count(&BB))
      continue;
    while (ProcessBlock(&BB)) // Thread all of the branches we can over BB.
      Changed = true;

    // Jump threading may have introduced redundant debug values into BB
    // which should be removed.
    if (Changed)
      RemoveRedundantDbgInstrs(&BB);

    // Stop processing BB if it's the entry or is now deleted. The following
    // routines attempt to eliminate BB and locating a suitable replacement
    // for the entry is non-trivial.
    if (&BB == &F.getEntryBlock() || DTU->isBBPendingDeletion(&BB))
      continue;

    if (pred_empty(&BB)) {
      // When ProcessBlock makes BB unreachable it doesn't bother to fix up
      // the instructions in it. We must remove BB to prevent invalid IR.
      LLVM_DEBUG(dbgs() << "  JT: Deleting dead block '" << BB.getName()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { dbgs() << "  JT: Deleting dead block '"
 << BB.getName() << "' with terminator: " <<
 *BB.getTerminator() << '\n'; } } while (false)
                        << "' with terminator: " << *BB.getTerminator()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { dbgs() << "  JT: Deleting dead block '"
 << BB.getName() << "' with terminator: " <<
 *BB.getTerminator() << '\n'; } } while (false)
                        << '\n')do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { dbgs() << "  JT: Deleting dead block '"
 << BB.getName() << "' with terminator: " <<
 *BB.getTerminator() << '\n'; } } while (false);
      LoopHeaders.erase(&BB);
      LVI->eraseBlock(&BB);
      DeleteDeadBlock(&BB, DTU);
      Changed = true;
      continue;
    }

    // ProcessBlock doesn't thread BBs with unconditional TIs. However, if BB
    // is "almost empty", we attempt to merge BB with its sole successor.
    auto *BI = dyn_cast<BranchInst>(BB.getTerminator());
    if (BI && BI->isUnconditional()) {
      BasicBlock *Succ = BI->getSuccessor(0);
      if (
          // The terminator must be the only non-phi instruction in BB.
          BB.getFirstNonPHIOrDbg()->isTerminator() &&
          // Don't alter Loop headers and latches to ensure another pass can
          // detect and transform nested loops later.
          !LoopHeaders.count(&BB) && !LoopHeaders.count(Succ) &&
          TryToSimplifyUncondBranchFromEmptyBlock(&BB, DTU)) {
        RemoveRedundantDbgInstrs(Succ);
        // BB is valid for cleanup here because we passed in DTU. F remains
        // BB's parent until a DTU->getDomTree() event.
        LVI->eraseBlock(&BB);
        Changed = true;
      }
    }
  }
  EverChanged |= Changed;
} while (Changed);

LoopHeaders.clear();
return EverChanged;
468}

470// Replace uses of Cond with ToVal when safe to do so. If all uses are
471// replaced, we can remove Cond. We cannot blindly replace all uses of Cond
472// because we may incorrectly replace uses when guards/assumes are uses of
473// of `Cond` and we used the guards/assume to reason about the `Cond` value
474// at the end of block. RAUW unconditionally replaces all uses
475// including the guards/assumes themselves and the uses before the
476// guard/assume.
477static void ReplaceFoldableUses(Instruction *Cond, Value *ToVal) {
assert(Cond->getType() == ToVal->getType())((Cond->getType() == ToVal->getType()) ? static_cast<
void> (0) : __assert_fail ("Cond->getType() == ToVal->getType()"
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/JumpThreading.cpp"
, 478, __PRETTY_FUNCTION__));
auto *BB = Cond->getParent();
// We can unconditionally replace all uses in non-local blocks (i.e. uses
// strictly dominated by BB), since LVI information is true from the
// terminator of BB.
replaceNonLocalUsesWith(Cond, ToVal);
for (Instruction &I : reverse(*BB)) {
  // Reached the Cond whose uses we are trying to replace, so there are no
  // more uses.
  if (&I == Cond)
    break;
  // We only replace uses in instructions that are guaranteed to reach the end
  // of BB, where we know Cond is ToVal.
  if (!isGuaranteedToTransferExecutionToSuccessor(&I))
    break;
  I.replaceUsesOfWith(Cond, ToVal);
}
if (Cond->use_empty() && !Cond->mayHaveSideEffects())
  Cond->eraseFromParent();
497}

499/// Return the cost of duplicating a piece of this block from first non-phi
500/// and before StopAt instruction to thread across it. Stop scanning the block
501/// when exceeding the threshold. If duplication is impossible, returns ~0U.
502static unsigned getJumpThreadDuplicationCost(BasicBlock *BB,
                                           Instruction *StopAt,
                                           unsigned Threshold) {
assert(StopAt->getParent() == BB && "Not an instruction from proper BB?")((StopAt->getParent() == BB && "Not an instruction from proper BB?"
) ? static_cast<void> (0) : __assert_fail ("StopAt->getParent() == BB && \"Not an instruction from proper BB?\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/JumpThreading.cpp"
, 505, __PRETTY_FUNCTION__));
/// Ignore PHI nodes, these will be flattened when duplication happens.
BasicBlock::const_iterator I(BB->getFirstNonPHI());

// FIXME: THREADING will delete values that are just used to compute the
// branch, so they shouldn't count against the duplication cost.

unsigned Bonus = 0;
if (BB->getTerminator() == StopAt) {
  // Threading through a switch statement is particularly profitable.  If this
  // block ends in a switch, decrease its cost to make it more likely to
  // happen.
  if (isa<SwitchInst>(StopAt))
    Bonus = 6;

  // The same holds for indirect branches, but slightly more so.
  if (isa<IndirectBrInst>(StopAt))
    Bonus = 8;
}

// Bump the threshold up so the early exit from the loop doesn't skip the
// terminator-based Size adjustment at the end.
Threshold += Bonus;

// Sum up the cost of each instruction until we get to the terminator.  Don't
// include the terminator because the copy won't include it.
unsigned Size = 0;
for (; &*I != StopAt; ++I) {

  // Stop scanning the block if we've reached the threshold.
  if (Size > Threshold)
    return Size;

  // Debugger intrinsics don't incur code size.
  if (isa<DbgInfoIntrinsic>(I)) continue;

  // If this is a pointer->pointer bitcast, it is free.
  if (isa<BitCastInst>(I) && I->getType()->isPointerTy())
    continue;

  // Freeze instruction is free, too.
  if (isa<FreezeInst>(I))
    continue;

  // Bail out if this instruction gives back a token type, it is not possible
  // to duplicate it if it is used outside this BB.
  if (I->getType()->isTokenTy() && I->isUsedOutsideOfBlock(BB))
    return ~0U;

  // All other instructions count for at least one unit.
  ++Size;

  // Calls are more expensive.  If they are non-intrinsic calls, we model them
  // as having cost of 4.  If they are a non-vector intrinsic, we model them
  // as having cost of 2 total, and if they are a vector intrinsic, we model
  // them as having cost 1.
  if (const CallInst *CI = dyn_cast<CallInst>(I)) {
    if (CI->cannotDuplicate() || CI->isConvergent())
      // Blocks with NoDuplicate are modelled as having infinite cost, so they
      // are never duplicated.
      return ~0U;
    else if (!isa<IntrinsicInst>(CI))
      Size += 3;
    else if (!CI->getType()->isVectorTy())
      Size += 1;
  }
}

return Size > Bonus ? Size - Bonus : 0;
574}

576/// FindLoopHeaders - We do not want jump threading to turn proper loop
577/// structures into irreducible loops.  Doing this breaks up the loop nesting
578/// hierarchy and pessimizes later transformations.  To prevent this from
579/// happening, we first have to find the loop headers.  Here we approximate this
580/// by finding targets of backedges in the CFG.
581///
582/// Note that there definitely are cases when we want to allow threading of
583/// edges across a loop header.  For example, threading a jump from outside the
584/// loop (the preheader) to an exit block of the loop is definitely profitable.
585/// It is also almost always profitable to thread backedges from within the loop
586/// to exit blocks, and is often profitable to thread backedges to other blocks
587/// within the loop (forming a nested loop).  This simple analysis is not rich
588/// enough to track all of these properties and keep it up-to-date as the CFG
589/// mutates, so we don't allow any of these transformations.
590void JumpThreadingPass::FindLoopHeaders(Function &F) {
SmallVector<std::pair<const BasicBlock*,const BasicBlock*>, 32> Edges;
FindFunctionBackedges(F, Edges);

for (const auto &Edge : Edges)
  LoopHeaders.insert(Edge.second);
596}

598/// getKnownConstant - Helper method to determine if we can thread over a
599/// terminator with the given value as its condition, and if so what value to
600/// use for that. What kind of value this is depends on whether we want an
601/// integer or a block address, but an undef is always accepted.
602/// Returns null if Val is null or not an appropriate constant.
603static Constant *getKnownConstant(Value *Val, ConstantPreference Preference) {
if (!Val)
  return nullptr;

// Undef is "known" enough.
if (UndefValue *U = dyn_cast<UndefValue>(Val))
  return U;

if (Preference == WantBlockAddress)
  return dyn_cast<BlockAddress>(Val->stripPointerCasts());

return dyn_cast<ConstantInt>(Val);
615}

617/// ComputeValueKnownInPredecessors - Given a basic block BB and a value V, see
618/// if we can infer that the value is a known ConstantInt/BlockAddress or undef
619/// in any of our predecessors.  If so, return the known list of value and pred
620/// BB in the result vector.
621///
622/// This returns true if there were any known values.
623bool JumpThreadingPass::ComputeValueKnownInPredecessorsImpl(
  Value *V, BasicBlock *BB, PredValueInfo &Result,
  ConstantPreference Preference, DenseSet<Value *> &RecursionSet,
  Instruction *CxtI) {
// This method walks up use-def chains recursively.  Because of this, we could
// get into an infinite loop going around loops in the use-def chain.  To
// prevent this, keep track of what (value, block) pairs we've already visited
// and terminate the search if we loop back to them
if (!RecursionSet.insert(V).second)
  return false;

// If V is a constant, then it is known in all predecessors.
if (Constant *KC = getKnownConstant(V, Preference)) {
  for (BasicBlock *Pred : predecessors(BB))
    Result.emplace_back(KC, Pred);

  return !Result.empty();
}

// If V is a non-instruction value, or an instruction in a different block,
// then it can't be derived from a PHI.
Instruction *I = dyn_cast<Instruction>(V);
if (!I || I->getParent() != BB) {

  // Okay, if this is a live-in value, see if it has a known value at the end
  // of any of our predecessors.
  //
  // FIXME: This should be an edge property, not a block end property.
  /// TODO: Per PR2563, we could infer value range information about a
  /// predecessor based on its terminator.
  //
  // FIXME: change this to use the more-rich 'getPredicateOnEdge' method if
  // "I" is a non-local compare-with-a-constant instruction.  This would be
  // able to handle value inequalities better, for example if the compare is
  // "X < 4" and "X < 3" is known true but "X < 4" itself is not available.
  // Perhaps getConstantOnEdge should be smart enough to do this?
  for (BasicBlock *P : predecessors(BB)) {
    // If the value is known by LazyValueInfo to be a constant in a
    // predecessor, use that information to try to thread this block.
    Constant *PredCst = LVI->getConstantOnEdge(V, P, BB, CxtI);
    if (Constant *KC = getKnownConstant(PredCst, Preference))
      Result.emplace_back(KC, P);
  }

  return !Result.empty();
}

/// If I is a PHI node, then we know the incoming values for any constants.
if (PHINode *PN = dyn_cast<PHINode>(I)) {
  for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) {
    Value *InVal = PN->getIncomingValue(i);
    if (Constant *KC = getKnownConstant(InVal, Preference)) {
      Result.emplace_back(KC, PN->getIncomingBlock(i));
    } else {
      Constant *CI = LVI->getConstantOnEdge(InVal,
                                            PN->getIncomingBlock(i),
                                            BB, CxtI);
      if (Constant *KC = getKnownConstant(CI, Preference))
        Result.emplace_back(KC, PN->getIncomingBlock(i));
    }
  }

  return !Result.empty();
}

// Handle Cast instructions.
if (CastInst *CI = dyn_cast<CastInst>(I)) {
  Value *Source = CI->getOperand(0);
  ComputeValueKnownInPredecessorsImpl(Source, BB, Result, Preference,
                                      RecursionSet, CxtI);
  if (Result.empty())
    return false;

  // Convert the known values.
  for (auto &R : Result)
    R.first = ConstantExpr::getCast(CI->getOpcode(), R.first, CI->getType());

  return true;
}

if (FreezeInst *FI = dyn_cast<FreezeInst>(I)) {
  Value *Source = FI->getOperand(0);
  ComputeValueKnownInPredecessorsImpl(Source, BB, Result, Preference,
                                      RecursionSet, CxtI);

  erase_if(Result, [](auto &Pair) {
    return !isGuaranteedNotToBeUndefOrPoison(Pair.first);
  });

  return !Result.empty();
}

// Handle some boolean conditions.
if (I->getType()->getPrimitiveSizeInBits() == 1) {
  assert(Preference == WantInteger && "One-bit non-integer type?")((Preference == WantInteger && "One-bit non-integer type?"
) ? static_cast<void> (0) : __assert_fail ("Preference == WantInteger && \"One-bit non-integer type?\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/JumpThreading.cpp"
, 717, __PRETTY_FUNCTION__));
  // X | true -> true
  // X & false -> false
  if (I->getOpcode() == Instruction::Or ||
      I->getOpcode() == Instruction::And) {
    PredValueInfoTy LHSVals, RHSVals;

    ComputeValueKnownInPredecessorsImpl(I->getOperand(0), BB, LHSVals,
                                    WantInteger, RecursionSet, CxtI);
    ComputeValueKnownInPredecessorsImpl(I->getOperand(1), BB, RHSVals,
                                        WantInteger, RecursionSet, CxtI);

    if (LHSVals.empty() && RHSVals.empty())
      return false;

    ConstantInt *InterestingVal;
    if (I->getOpcode() == Instruction::Or)
      InterestingVal = ConstantInt::getTrue(I->getContext());
    else
      InterestingVal = ConstantInt::getFalse(I->getContext());

    SmallPtrSet<BasicBlock*, 4> LHSKnownBBs;

    // Scan for the sentinel.  If we find an undef, force it to the
    // interesting value: x|undef -> true and x&undef -> false.
    for (const auto &LHSVal : LHSVals)
      if (LHSVal.first == InterestingVal || isa<UndefValue>(LHSVal.first)) {
        Result.emplace_back(InterestingVal, LHSVal.second);
        LHSKnownBBs.insert(LHSVal.second);
      }
    for (const auto &RHSVal : RHSVals)
      if (RHSVal.first == InterestingVal || isa<UndefValue>(RHSVal.first)) {
        // If we already inferred a value for this block on the LHS, don't
        // re-add it.
        if (!LHSKnownBBs.count(RHSVal.second))
          Result.emplace_back(InterestingVal, RHSVal.second);
      }

    return !Result.empty();
  }

  // Handle the NOT form of XOR.
  if (I->getOpcode() == Instruction::Xor &&
      isa<ConstantInt>(I->getOperand(1)) &&
      cast<ConstantInt>(I->getOperand(1))->isOne()) {
    ComputeValueKnownInPredecessorsImpl(I->getOperand(0), BB, Result,
                                        WantInteger, RecursionSet, CxtI);
    if (Result.empty())
      return false;

    // Invert the known values.
    for (auto &R : Result)
      R.first = ConstantExpr::getNot(R.first);

    return true;
  }

// Try to simplify some other binary operator values.
} else if (BinaryOperator *BO = dyn_cast<BinaryOperator>(I)) {
  assert(Preference != WantBlockAddress((Preference != WantBlockAddress && "A binary operator creating a block address?"
) ? static_cast<void> (0) : __assert_fail ("Preference != WantBlockAddress && \"A binary operator creating a block address?\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/JumpThreading.cpp"
, 777, __PRETTY_FUNCTION__))
          && "A binary operator creating a block address?")((Preference != WantBlockAddress && "A binary operator creating a block address?"
) ? static_cast<void> (0) : __assert_fail ("Preference != WantBlockAddress && \"A binary operator creating a block address?\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/JumpThreading.cpp"
, 777, __PRETTY_FUNCTION__));
  if (ConstantInt *CI = dyn_cast<ConstantInt>(BO->getOperand(1))) {
    PredValueInfoTy LHSVals;
    ComputeValueKnownInPredecessorsImpl(BO->getOperand(0), BB, LHSVals,
                                        WantInteger, RecursionSet, CxtI);

    // Try to use constant folding to simplify the binary operator.
    for (const auto &LHSVal : LHSVals) {
      Constant *V = LHSVal.first;
      Constant *Folded = ConstantExpr::get(BO->getOpcode(), V, CI);

      if (Constant *KC = getKnownConstant(Folded, WantInteger))
        Result.emplace_back(KC, LHSVal.second);
    }
  }

  return !Result.empty();
}

// Handle compare with phi operand, where the PHI is defined in this block.
if (CmpInst *Cmp = dyn_cast<CmpInst>(I)) {
  assert(Preference == WantInteger && "Compares only produce integers")((Preference == WantInteger && "Compares only produce integers"
) ? static_cast<void> (0) : __assert_fail ("Preference == WantInteger && \"Compares only produce integers\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/JumpThreading.cpp"
, 798, __PRETTY_FUNCTION__));
  Type *CmpType = Cmp->getType();
  Value *CmpLHS = Cmp->getOperand(0);
  Value *CmpRHS = Cmp->getOperand(1);
  CmpInst::Predicate Pred = Cmp->getPredicate();

  PHINode *PN = dyn_cast<PHINode>(CmpLHS);
  if (!PN)
    PN = dyn_cast<PHINode>(CmpRHS);
  if (PN && PN->getParent() == BB) {
    const DataLayout &DL = PN->getModule()->getDataLayout();
    // We can do this simplification if any comparisons fold to true or false.
    // See if any do.
    for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) {
      BasicBlock *PredBB = PN->getIncomingBlock(i);
      Value *LHS, *RHS;
      if (PN == CmpLHS) {
        LHS = PN->getIncomingValue(i);
        RHS = CmpRHS->DoPHITranslation(BB, PredBB);
      } else {
        LHS = CmpLHS->DoPHITranslation(BB, PredBB);
        RHS = PN->getIncomingValue(i);
      }
      Value *Res = SimplifyCmpInst(Pred, LHS, RHS, {DL});
      if (!Res) {
        if (!isa<Constant>(RHS))
          continue;

        // getPredicateOnEdge call will make no sense if LHS is defined in BB.
        auto LHSInst = dyn_cast<Instruction>(LHS);
        if (LHSInst && LHSInst->getParent() == BB)
          continue;

        LazyValueInfo::Tristate
          ResT = LVI->getPredicateOnEdge(Pred, LHS,
                                         cast<Constant>(RHS), PredBB, BB,
                                         CxtI ? CxtI : Cmp);
        if (ResT == LazyValueInfo::Unknown)
          continue;
        Res = ConstantInt::get(Type::getInt1Ty(LHS->getContext()), ResT);
      }

      if (Constant *KC = getKnownConstant(Res, WantInteger))
        Result.emplace_back(KC, PredBB);
    }

    return !Result.empty();
  }

  // If comparing a live-in value against a constant, see if we know the
  // live-in value on any predecessors.
  if (isa<Constant>(CmpRHS) && !CmpType->isVectorTy()) {
    Constant *CmpConst = cast<Constant>(CmpRHS);

    if (!isa<Instruction>(CmpLHS) ||
        cast<Instruction>(CmpLHS)->getParent() != BB) {
      for (BasicBlock *P : predecessors(BB)) {
        // If the value is known by LazyValueInfo to be a constant in a
        // predecessor, use that information to try to thread this block.
        LazyValueInfo::Tristate Res =
          LVI->getPredicateOnEdge(Pred, CmpLHS,
                                  CmpConst, P, BB, CxtI ? CxtI : Cmp);
        if (Res == LazyValueInfo::Unknown)
          continue;

        Constant *ResC = ConstantInt::get(CmpType, Res);
        Result.emplace_back(ResC, P);
      }

      return !Result.empty();
    }

    // InstCombine can fold some forms of constant range checks into
    // (icmp (add (x, C1)), C2). See if we have we have such a thing with
    // x as a live-in.
    {
      using namespace PatternMatch;

      Value *AddLHS;
      ConstantInt *AddConst;
      if (isa<ConstantInt>(CmpConst) &&
          match(CmpLHS, m_Add(m_Value(AddLHS), m_ConstantInt(AddConst)))) {
        if (!isa<Instruction>(AddLHS) ||
            cast<Instruction>(AddLHS)->getParent() != BB) {
          for (BasicBlock *P : predecessors(BB)) {
            // If the value is known by LazyValueInfo to be a ConstantRange in
            // a predecessor, use that information to try to thread this
            // block.
            ConstantRange CR = LVI->getConstantRangeOnEdge(
                AddLHS, P, BB, CxtI ? CxtI : cast<Instruction>(CmpLHS));
            // Propagate the range through the addition.
            CR = CR.add(AddConst->getValue());

            // Get the range where the compare returns true.
            ConstantRange CmpRange = ConstantRange::makeExactICmpRegion(
                Pred, cast<ConstantInt>(CmpConst)->getValue());

            Constant *ResC;
            if (CmpRange.contains(CR))
              ResC = ConstantInt::getTrue(CmpType);
            else if (CmpRange.inverse().contains(CR))
              ResC = ConstantInt::getFalse(CmpType);
            else
              continue;

            Result.emplace_back(ResC, P);
          }

          return !Result.empty();
        }
      }
    }

    // Try to find a constant value for the LHS of a comparison,
    // and evaluate it statically if we can.
    PredValueInfoTy LHSVals;
    ComputeValueKnownInPredecessorsImpl(I->getOperand(0), BB, LHSVals,
                                        WantInteger, RecursionSet, CxtI);

    for (const auto &LHSVal : LHSVals) {
      Constant *V = LHSVal.first;
      Constant *Folded = ConstantExpr::getCompare(Pred, V, CmpConst);
      if (Constant *KC = getKnownConstant(Folded, WantInteger))
        Result.emplace_back(KC, LHSVal.second);
    }

    return !Result.empty();
  }
}

if (SelectInst *SI = dyn_cast<SelectInst>(I)) {
  // Handle select instructions where at least one operand is a known constant
  // and we can figure out the condition value for any predecessor block.
  Constant *TrueVal = getKnownConstant(SI->getTrueValue(), Preference);
  Constant *FalseVal = getKnownConstant(SI->getFalseValue(), Preference);
  PredValueInfoTy Conds;
  if ((TrueVal || FalseVal) &&
      ComputeValueKnownInPredecessorsImpl(SI->getCondition(), BB, Conds,
                                          WantInteger, RecursionSet, CxtI)) {
    for (auto &C : Conds) {
      Constant *Cond = C.first;

      // Figure out what value to use for the condition.
      bool KnownCond;
      if (ConstantInt *CI = dyn_cast<ConstantInt>(Cond)) {
        // A known boolean.
        KnownCond = CI->isOne();
      } else {
        assert(isa<UndefValue>(Cond) && "Unexpected condition value")((isa<UndefValue>(Cond) && "Unexpected condition value"
) ? static_cast<void> (0) : __assert_fail ("isa<UndefValue>(Cond) && \"Unexpected condition value\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/JumpThreading.cpp"
, 946, __PRETTY_FUNCTION__));
        // Either operand will do, so be sure to pick the one that's a known
        // constant.
        // FIXME: Do this more cleverly if both values are known constants?
        KnownCond = (TrueVal != nullptr);
      }

      // See if the select has a known constant value for this predecessor.
      if (Constant *Val = KnownCond ? TrueVal : FalseVal)
        Result.emplace_back(Val, C.second);
    }

    return !Result.empty();
  }
}

// If all else fails, see if LVI can figure out a constant value for us.
assert(CxtI->getParent() == BB && "CxtI should be in BB")((CxtI->getParent() == BB && "CxtI should be in BB"
) ? static_cast<void> (0) : __assert_fail ("CxtI->getParent() == BB && \"CxtI should be in BB\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/JumpThreading.cpp"
, 963, __PRETTY_FUNCTION__));
Constant *CI = LVI->getConstant(V, CxtI);
if (Constant *KC = getKnownConstant(CI, Preference)) {
  for (BasicBlock *Pred : predecessors(BB))
    Result.emplace_back(KC, Pred);
}

return !Result.empty();
971}

973/// GetBestDestForBranchOnUndef - If we determine that the specified block ends
974/// in an undefined jump, decide which block is best to revector to.
975///
976/// Since we can pick an arbitrary destination, we pick the successor with the
977/// fewest predecessors.  This should reduce the in-degree of the others.
978static unsigned GetBestDestForJumpOnUndef(BasicBlock *BB) {
Instruction *BBTerm = BB->getTerminator();
unsigned MinSucc = 0;
BasicBlock *TestBB = BBTerm->getSuccessor(MinSucc);
// Compute the successor with the minimum number of predecessors.
unsigned MinNumPreds = pred_size(TestBB);
for (unsigned i = 1, e = BBTerm->getNumSuccessors(); i != e; ++i) {
  TestBB = BBTerm->getSuccessor(i);
  unsigned NumPreds = pred_size(TestBB);
  if (NumPreds < MinNumPreds) {
    MinSucc = i;
    MinNumPreds = NumPreds;
  }
}

return MinSucc;
994}

996static bool hasAddressTakenAndUsed(BasicBlock *BB) {
if (!BB->hasAddressTaken()) return false;

// If the block has its address taken, it may be a tree of dead constants
// hanging off of it.  These shouldn't keep the block alive.
BlockAddress *BA = BlockAddress::get(BB);
BA->removeDeadConstantUsers();
return !BA->use_empty();
1004}

1006/// ProcessBlock - If there are any predecessors whose control can be threaded
1007/// through to a successor, transform them now.
1008bool JumpThreadingPass::ProcessBlock(BasicBlock *BB) {
// If the block is trivially dead, just return and let the caller nuke it.
// This simplifies other transformations.
if (DTU->isBBPendingDeletion(BB) ||
    (pred_empty(BB) && BB != &BB->getParent()->getEntryBlock()))
  return false;

// If this block has a single predecessor, and if that pred has a single
// successor, merge the blocks.  This encourages recursive jump threading
// because now the condition in this block can be threaded through
// predecessors of our predecessor block.
if (MaybeMergeBasicBlockIntoOnlyPred(BB))
  return true;

if (TryToUnfoldSelectInCurrBB(BB))
  return true;

// Look if we can propagate guards to predecessors.
if (HasGuards && ProcessGuards(BB))
  return true;

// What kind of constant we're looking for.
ConstantPreference Preference = WantInteger;

// Look to see if the terminator is a conditional branch, switch or indirect
// branch, if not we can't thread it.
Value *Condition;
Instruction *Terminator = BB->getTerminator();
if (BranchInst *BI = dyn_cast<BranchInst>(Terminator)) {
  // Can't thread an unconditional jump.
  if (BI->isUnconditional()) return false;
  Condition = BI->getCondition();
} else if (SwitchInst *SI = dyn_cast<SwitchInst>(Terminator)) {
  Condition = SI->getCondition();
} else if (IndirectBrInst *IB = dyn_cast<IndirectBrInst>(Terminator)) {
  // Can't thread indirect branch with no successors.
  if (IB->getNumSuccessors() == 0) return false;
  Condition = IB->getAddress()->stripPointerCasts();
  Preference = WantBlockAddress;
} else {
  return false; // Must be an invoke or callbr.
}

// Keep track if we constant folded the condition in this invocation.
bool ConstantFolded = false;

// Run constant folding to see if we can reduce the condition to a simple
// constant.
if (Instruction *I = dyn_cast<Instruction>(Condition)) {
  Value *SimpleVal =
      ConstantFoldInstruction(I, BB->getModule()->getDataLayout(), TLI);
  if (SimpleVal) {
    I->replaceAllUsesWith(SimpleVal);
    if (isInstructionTriviallyDead(I, TLI))
      I->eraseFromParent();
    Condition = SimpleVal;
    ConstantFolded = true;
  }
}

// If the terminator is branching on an undef or freeze undef, we can pick any
// of the successors to branch to.  Let GetBestDestForJumpOnUndef decide.
auto *FI = dyn_cast<FreezeInst>(Condition);
if (isa<UndefValue>(Condition) ||
    (FI && isa<UndefValue>(FI->getOperand(0)) && FI->hasOneUse())) {
  unsigned BestSucc = GetBestDestForJumpOnUndef(BB);
  std::vector<DominatorTree::UpdateType> Updates;

  // Fold the branch/switch.
  Instruction *BBTerm = BB->getTerminator();
  Updates.reserve(BBTerm->getNumSuccessors());
  for (unsigned i = 0, e = BBTerm->getNumSuccessors(); i != e; ++i) {
    if (i == BestSucc) continue;
    BasicBlock *Succ = BBTerm->getSuccessor(i);
    Succ->removePredecessor(BB, true);
    Updates.push_back({DominatorTree::Delete, BB, Succ});
  }

  LLVM_DEBUG(dbgs() << "  In block '" << BB->getName()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { dbgs() << "  In block '" <<
 BB->getName() << "' folding undef terminator: " <<
 *BBTerm << '\n'; } } while (false)
                    << "' folding undef terminator: " << *BBTerm << '\n')do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { dbgs() << "  In block '" <<
 BB->getName() << "' folding undef terminator: " <<
 *BBTerm << '\n'; } } while (false);
  BranchInst::Create(BBTerm->getSuccessor(BestSucc), BBTerm);
  BBTerm->eraseFromParent();
  DTU->applyUpdatesPermissive(Updates);
  if (FI)
    FI->eraseFromParent();
  return true;
}

// If the terminator of this block is branching on a constant, simplify the
// terminator to an unconditional branch.  This can occur due to threading in
// other blocks.
if (getKnownConstant(Condition, Preference)) {
  LLVM_DEBUG(dbgs() << "  In block '" << BB->getName()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { dbgs() << "  In block '" <<
 BB->getName() << "' folding terminator: " << *
BB->getTerminator() << '\n'; } } while (false)
                    << "' folding terminator: " << *BB->getTerminator()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { dbgs() << "  In block '" <<
 BB->getName() << "' folding terminator: " << *
BB->getTerminator() << '\n'; } } while (false)
                    << '\n')do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { dbgs() << "  In block '" <<
 BB->getName() << "' folding terminator: " << *
BB->getTerminator() << '\n'; } } while (false);
  ++NumFolds;
  ConstantFoldTerminator(BB, true, nullptr, DTU);
  return true;
}

Instruction *CondInst = dyn_cast<Instruction>(Condition);

// All the rest of our checks depend on the condition being an instruction.
if (!CondInst) {
  // FIXME: Unify this with code below.
  if (ProcessThreadableEdges(Condition, BB, Preference, Terminator))
    return true;
  return ConstantFolded;
}

if (CmpInst *CondCmp = dyn_cast<CmpInst>(CondInst)) {
  // If we're branching on a conditional, LVI might be able to determine
  // it's value at the branch instruction.  We only handle comparisons
  // against a constant at this time.
  // TODO: This should be extended to handle switches as well.
  BranchInst *CondBr = dyn_cast<BranchInst>(BB->getTerminator());
  Constant *CondConst = dyn_cast<Constant>(CondCmp->getOperand(1));
  if (CondBr && CondConst) {
    // We should have returned as soon as we turn a conditional branch to
    // unconditional. Because its no longer interesting as far as jump
    // threading is concerned.
    assert(CondBr->isConditional() && "Threading on unconditional terminator")((CondBr->isConditional() && "Threading on unconditional terminator"
) ? static_cast<void> (0) : __assert_fail ("CondBr->isConditional() && \"Threading on unconditional terminator\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/JumpThreading.cpp"
, 1129, __PRETTY_FUNCTION__));

    LazyValueInfo::Tristate Ret =
      LVI->getPredicateAt(CondCmp->getPredicate(), CondCmp->getOperand(0),
                          CondConst, CondBr);
    if (Ret != LazyValueInfo::Unknown) {
      unsigned ToRemove = Ret == LazyValueInfo::True ? 1 : 0;
      unsigned ToKeep = Ret == LazyValueInfo::True ? 0 : 1;
      BasicBlock *ToRemoveSucc = CondBr->getSuccessor(ToRemove);
      ToRemoveSucc->removePredecessor(BB, true);
      BranchInst *UncondBr =
        BranchInst::Create(CondBr->getSuccessor(ToKeep), CondBr);
      UncondBr->setDebugLoc(CondBr->getDebugLoc());
      CondBr->eraseFromParent();
      if (CondCmp->use_empty())
        CondCmp->eraseFromParent();
      // We can safely replace *some* uses of the CondInst if it has
      // exactly one value as returned by LVI. RAUW is incorrect in the
      // presence of guards and assumes, that have the `Cond` as the use. This
      // is because we use the guards/assume to reason about the `Cond` value
      // at the end of block, but RAUW unconditionally replaces all uses
      // including the guards/assumes themselves and the uses before the
      // guard/assume.
      else if (CondCmp->getParent() == BB) {
        auto *CI = Ret == LazyValueInfo::True ?
          ConstantInt::getTrue(CondCmp->getType()) :
          ConstantInt::getFalse(CondCmp->getType());
        ReplaceFoldableUses(CondCmp, CI);
      }
      DTU->applyUpdatesPermissive(
          {{DominatorTree::Delete, BB, ToRemoveSucc}});
      return true;
    }

    // We did not manage to simplify this branch, try to see whether
    // CondCmp depends on a known phi-select pattern.
    if (TryToUnfoldSelect(CondCmp, BB))
      return true;
  }
}

if (SwitchInst *SI = dyn_cast<SwitchInst>(BB->getTerminator()))
  if (TryToUnfoldSelect(SI, BB))
    return true;

// Check for some cases that are worth simplifying.  Right now we want to look
// for loads that are used by a switch or by the condition for the branch.  If
// we see one, check to see if it's partially redundant.  If so, insert a PHI
// which can then be used to thread the values.
Value *SimplifyValue = CondInst;

if (auto *FI = dyn_cast<FreezeInst>(SimplifyValue))
  // Look into freeze's operand
  SimplifyValue = FI->getOperand(0);

if (CmpInst *CondCmp = dyn_cast<CmpInst>(SimplifyValue))
  if (isa<Constant>(CondCmp->getOperand(1)))
    SimplifyValue = CondCmp->getOperand(0);

// TODO: There are other places where load PRE would be profitable, such as
// more complex comparisons.
if (LoadInst *LoadI = dyn_cast<LoadInst>(SimplifyValue))
  if (SimplifyPartiallyRedundantLoad(LoadI))
    return true;

// Before threading, try to propagate profile data backwards:
if (PHINode *PN = dyn_cast<PHINode>(CondInst))
  if (PN->getParent() == BB && isa<BranchInst>(BB->getTerminator()))
    updatePredecessorProfileMetadata(PN, BB);

// Handle a variety of cases where we are branching on something derived from
// a PHI node in the current block.  If we can prove that any predecessors
// compute a predictable value based on a PHI node, thread those predecessors.
if (ProcessThreadableEdges(CondInst, BB, Preference, Terminator))
  return true;

// If this is an otherwise-unfoldable branch on a phi node or freeze(phi) in
// the current block, see if we can simplify.
PHINode *PN = dyn_cast<PHINode>(
    isa<FreezeInst>(CondInst) ? cast<FreezeInst>(CondInst)->getOperand(0)
                              : CondInst);

if (PN && PN->getParent() == BB && isa<BranchInst>(BB->getTerminator()))
  return ProcessBranchOnPHI(PN);

// If this is an otherwise-unfoldable branch on a XOR, see if we can simplify.
if (CondInst->getOpcode() == Instruction::Xor &&
    CondInst->getParent() == BB && isa<BranchInst>(BB->getTerminator()))
  return ProcessBranchOnXOR(cast<BinaryOperator>(CondInst));

// Search for a stronger dominating condition that can be used to simplify a
// conditional branch leaving BB.
if (ProcessImpliedCondition(BB))
  return true;

return false;
1225}

1227bool JumpThreadingPass::ProcessImpliedCondition(BasicBlock *BB) {
auto *BI = dyn_cast<BranchInst>(BB->getTerminator());
if (!BI || !BI->isConditional())
  return false;

Value *Cond = BI->getCondition();
BasicBlock *CurrentBB = BB;
BasicBlock *CurrentPred = BB->getSinglePredecessor();
unsigned Iter = 0;

auto &DL = BB->getModule()->getDataLayout();

while (CurrentPred && Iter++ < ImplicationSearchThreshold) {
  auto *PBI = dyn_cast<BranchInst>(CurrentPred->getTerminator());
  if (!PBI || !PBI->isConditional())
    return false;
  if (PBI->getSuccessor(0) != CurrentBB && PBI->getSuccessor(1) != CurrentBB)
    return false;

  bool CondIsTrue = PBI->getSuccessor(0) == CurrentBB;
  Optional<bool> Implication =
      isImpliedCondition(PBI->getCondition(), Cond, DL, CondIsTrue);
  if (Implication) {
    BasicBlock *KeepSucc = BI->getSuccessor(*Implication ? 0 : 1);
    BasicBlock *RemoveSucc = BI->getSuccessor(*Implication ? 1 : 0);
    RemoveSucc->removePredecessor(BB);
    BranchInst *UncondBI = BranchInst::Create(KeepSucc, BI);
    UncondBI->setDebugLoc(BI->getDebugLoc());
    BI->eraseFromParent();
    DTU->applyUpdatesPermissive({{DominatorTree::Delete, BB, RemoveSucc}});
    return true;
  }
  CurrentBB = CurrentPred;
  CurrentPred = CurrentBB->getSinglePredecessor();
}

return false;
1264}

1266/// Return true if Op is an instruction defined in the given block.
1267static bool isOpDefinedInBlock(Value *Op, BasicBlock *BB) {
if (Instruction *OpInst = dyn_cast<Instruction>(Op))
12
←
Assuming 'OpInst' is null→
13
←
Taking false branch→
  if (OpInst->getParent() == BB)
    return true;
return false;
14
←
Returning zero, which participates in a condition later→
1272}

1274/// SimplifyPartiallyRedundantLoad - If LoadI is an obviously partially
1275/// redundant load instruction, eliminate it by replacing it with a PHI node.
1276/// This is an important optimization that encourages jump threading, and needs
1277/// to be run interlaced with other jump threading tasks.
1278bool JumpThreadingPass::SimplifyPartiallyRedundantLoad(LoadInst *LoadI) {
// Don't hack volatile and ordered loads.
if (!LoadI->isUnordered()) return false;
1
Calling 'LoadInst::isUnordered'→
5
←
Returning from 'LoadInst::isUnordered'→
6
←
Taking false branch→

// If the load is defined in a block with exactly one predecessor, it can't be
// partially redundant.
BasicBlock *LoadBB = LoadI->getParent();
if (LoadBB->getSinglePredecessor())
7
←
Assuming the condition is false→
8
←
Taking false branch→
  return false;

// If the load is defined in an EH pad, it can't be partially redundant,
// because the edges between the invoke and the EH pad cannot have other
// instructions between them.
if (LoadBB->isEHPad())
9
←
Assuming the condition is false→
10
←
Taking false branch→
  return false;

Value *LoadedPtr = LoadI->getOperand(0);

// If the loaded operand is defined in the LoadBB and its not a phi,
// it can't be available in predecessors.
if (isOpDefinedInBlock(LoadedPtr, LoadBB) && !isa<PHINode>(LoadedPtr))
11
←
Calling 'isOpDefinedInBlock'→
15
←
Returning from 'isOpDefinedInBlock'→
  return false;

// Scan a few instructions up from the load, to see if it is obviously live at
// the entry to its block.
BasicBlock::iterator BBIt(LoadI);
bool IsLoadCSE;
if (Value *AvailableVal = FindAvailableLoadedValue(
16
←
Assuming 'AvailableVal' is null→
17
←
Taking false branch→
        LoadI, LoadBB, BBIt, DefMaxInstsToScan, AA, &IsLoadCSE)) {
  // If the value of the load is locally available within the block, just use
  // it.  This frequently occurs for reg2mem'd allocas.

  if (IsLoadCSE) {
    LoadInst *NLoadI = cast<LoadInst>(AvailableVal);
    combineMetadataForCSE(NLoadI, LoadI, false);
  };

  // If the returned value is the load itself, replace with an undef. This can
  // only happen in dead loops.
  if (AvailableVal == LoadI)
    AvailableVal = UndefValue::get(LoadI->getType());
  if (AvailableVal->getType() != LoadI->getType())
    AvailableVal = CastInst::CreateBitOrPointerCast(
        AvailableVal, LoadI->getType(), "", LoadI);
  LoadI->replaceAllUsesWith(AvailableVal);
  LoadI->eraseFromParent();
  return true;
}

// Otherwise, if we scanned the whole block and got to the top of the block,
// we know the block is locally transparent to the load.  If not, something
// might clobber its value.
if (BBIt != LoadBB->begin())
18
←
Calling 'operator!='→
21
←
Returning from 'operator!='→
22
←
Taking false branch→
  return false;

// If all of the loads and stores that feed the value have the same AA tags,
// then we can propagate them onto any newly inserted loads.
AAMDNodes AATags;
LoadI->getAAMetadata(AATags);

SmallPtrSet<BasicBlock*, 8> PredsScanned;

using AvailablePredsTy = SmallVector<std::pair<BasicBlock *, Value *>, 8>;

AvailablePredsTy AvailablePreds;
BasicBlock *OneUnavailablePred = nullptr;
23
←
'OneUnavailablePred' initialized to a null pointer value→
SmallVector<LoadInst*, 8> CSELoads;

// If we got here, the loaded value is transparent through to the start of the
// block.  Check to see if it is available in any of the predecessor blocks.
for (BasicBlock *PredBB : predecessors(LoadBB)) {
  // If we already scanned this predecessor, skip it.
  if (!PredsScanned.insert(PredBB).second)
    continue;

  BBIt = PredBB->end();
  unsigned NumScanedInst = 0;
  Value *PredAvailable = nullptr;
  // NOTE: We don't CSE load that is volatile or anything stronger than
  // unordered, that should have been checked when we entered the function.
  assert(LoadI->isUnordered() &&((LoadI->isUnordered() && "Attempting to CSE volatile or atomic loads"
) ? static_cast<void> (0) : __assert_fail ("LoadI->isUnordered() && \"Attempting to CSE volatile or atomic loads\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/JumpThreading.cpp"
, 1359, __PRETTY_FUNCTION__))
         "Attempting to CSE volatile or atomic loads")((LoadI->isUnordered() && "Attempting to CSE volatile or atomic loads"
) ? static_cast<void> (0) : __assert_fail ("LoadI->isUnordered() && \"Attempting to CSE volatile or atomic loads\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/JumpThreading.cpp"
, 1359, __PRETTY_FUNCTION__));
  // If this is a load on a phi pointer, phi-translate it and search
  // for available load/store to the pointer in predecessors.
  Value *Ptr = LoadedPtr->DoPHITranslation(LoadBB, PredBB);
  PredAvailable = FindAvailablePtrLoadStore(
      Ptr, LoadI->getType(), LoadI->isAtomic(), PredBB, BBIt,
      DefMaxInstsToScan, AA, &IsLoadCSE, &NumScanedInst);

  // If PredBB has a single predecessor, continue scanning through the
  // single predecessor.
  BasicBlock *SinglePredBB = PredBB;
  while (!PredAvailable && SinglePredBB && BBIt == SinglePredBB->begin() &&
         NumScanedInst < DefMaxInstsToScan) {
    SinglePredBB = SinglePredBB->getSinglePredecessor();
    if (SinglePredBB) {
      BBIt = SinglePredBB->end();
      PredAvailable = FindAvailablePtrLoadStore(
          Ptr, LoadI->getType(), LoadI->isAtomic(), SinglePredBB, BBIt,
          (DefMaxInstsToScan - NumScanedInst), AA, &IsLoadCSE,
          &NumScanedInst);
    }
  }

  if (!PredAvailable) {
    OneUnavailablePred = PredBB;
    continue;
  }

  if (IsLoadCSE)
    CSELoads.push_back(cast<LoadInst>(PredAvailable));

  // If so, this load is partially redundant.  Remember this info so that we
  // can create a PHI node.
  AvailablePreds.emplace_back(PredBB, PredAvailable);
}

// If the loaded value isn't available in any predecessor, it isn't partially
// redundant.
if (AvailablePreds.empty()) return false;
24
←
Calling 'SmallVectorBase::empty'→
27
←
Returning from 'SmallVectorBase::empty'→
28
←
Taking false branch→

// Okay, the loaded value is available in at least one (and maybe all!)
// predecessors.  If the value is unavailable in more than one unique
// predecessor, we want to insert a merge block for those common predecessors.
// This ensures that we only have to insert one reload, thus not increasing
// code size.
BasicBlock *UnavailablePred = nullptr;

// If the value is unavailable in one of predecessors, we will end up
// inserting a new instruction into them. It is only valid if all the
// instructions before LoadI are guaranteed to pass execution to its
// successor, or if LoadI is safe to speculate.
// TODO: If this logic becomes more complex, and we will perform PRE insertion
// farther than to a predecessor, we need to reuse the code from GVN's PRE.
// It requires domination tree analysis, so for this simple case it is an
// overkill.
if (PredsScanned.size() != AvailablePreds.size() &&
29
←
Assuming the condition is false→
    !isSafeToSpeculativelyExecute(LoadI))
  for (auto I = LoadBB->begin(); &*I != LoadI; ++I)
    if (!isGuaranteedToTransferExecutionToSuccessor(&*I))
      return false;

// If there is exactly one predecessor where the value is unavailable, the
// already computed 'OneUnavailablePred' block is it.  If it ends in an
// unconditional branch, we know that it isn't a critical edge.
if (PredsScanned.size() == AvailablePreds.size()+1 &&
30
←
Assuming the condition is true→
    OneUnavailablePred->getTerminator()->getNumSuccessors() == 1) {
31
←
Called C++ object pointer is null
  UnavailablePred = OneUnavailablePred;
} else if (PredsScanned.size() != AvailablePreds.size()) {
  // Otherwise, we had multiple unavailable predecessors or we had a critical
  // edge from the one.
  SmallVector<BasicBlock*, 8> PredsToSplit;
  SmallPtrSet<BasicBlock*, 8> AvailablePredSet;

  for (const auto &AvailablePred : AvailablePreds)
    AvailablePredSet.insert(AvailablePred.first);

  // Add all the unavailable predecessors to the PredsToSplit list.
  for (BasicBlock *P : predecessors(LoadBB)) {
    // If the predecessor is an indirect goto, we can't split the edge.
    // Same for CallBr.
    if (isa<IndirectBrInst>(P->getTerminator()) ||
        isa<CallBrInst>(P->getTerminator()))
      return false;

    if (!AvailablePredSet.count(P))
      PredsToSplit.push_back(P);
  }

  // Split them out to their own block.
  UnavailablePred = SplitBlockPreds(LoadBB, PredsToSplit, "thread-pre-split");
}

// If the value isn't available in all predecessors, then there will be
// exactly one where it isn't available.  Insert a load on that edge and add
// it to the AvailablePreds list.
if (UnavailablePred) {
  assert(UnavailablePred->getTerminator()->getNumSuccessors() == 1 &&((UnavailablePred->getTerminator()->getNumSuccessors() ==
&& "Can't handle critical edge here!") ? static_cast
<void> (0) : __assert_fail ("UnavailablePred->getTerminator()->getNumSuccessors() == 1 && \"Can't handle critical edge here!\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/JumpThreading.cpp"
, 1456, __PRETTY_FUNCTION__))
         "Can't handle critical edge here!")((UnavailablePred->getTerminator()->getNumSuccessors() ==
&& "Can't handle critical edge here!") ? static_cast
<void> (0) : __assert_fail ("UnavailablePred->getTerminator()->getNumSuccessors() == 1 && \"Can't handle critical edge here!\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/JumpThreading.cpp"
, 1456, __PRETTY_FUNCTION__));
  LoadInst *NewVal = new LoadInst(
      LoadI->getType(), LoadedPtr->DoPHITranslation(LoadBB, UnavailablePred),
      LoadI->getName() + ".pr", false, LoadI->getAlign(),
      LoadI->getOrdering(), LoadI->getSyncScopeID(),
      UnavailablePred->getTerminator());
  NewVal->setDebugLoc(LoadI->getDebugLoc());
  if (AATags)
    NewVal->setAAMetadata(AATags);

  AvailablePreds.emplace_back(UnavailablePred, NewVal);
}

// Now we know that each predecessor of this block has a value in
// AvailablePreds, sort them for efficient access as we're walking the preds.
array_pod_sort(AvailablePreds.begin(), AvailablePreds.end());

// Create a PHI node at the start of the block for the PRE'd load value.
pred_iterator PB = pred_begin(LoadBB), PE = pred_end(LoadBB);
PHINode *PN = PHINode::Create(LoadI->getType(), std::distance(PB, PE), "",
                              &LoadBB->front());
PN->takeName(LoadI);
PN->setDebugLoc(LoadI->getDebugLoc());

// Insert new entries into the PHI for each predecessor.  A single block may
// have multiple entries here.
for (pred_iterator PI = PB; PI != PE; ++PI) {
  BasicBlock *P = *PI;
  AvailablePredsTy::iterator I =
      llvm::lower_bound(AvailablePreds, std::make_pair(P, (Value *)nullptr));

  assert(I != AvailablePreds.end() && I->first == P &&((I != AvailablePreds.end() && I->first == P &&
 "Didn't find entry for predecessor!") ? static_cast<void>
 (0) : __assert_fail ("I != AvailablePreds.end() && I->first == P && \"Didn't find entry for predecessor!\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/JumpThreading.cpp"
, 1488, __PRETTY_FUNCTION__))
         "Didn't find entry for predecessor!")((I != AvailablePreds.end() && I->first == P &&
 "Didn't find entry for predecessor!") ? static_cast<void>
 (0) : __assert_fail ("I != AvailablePreds.end() && I->first == P && \"Didn't find entry for predecessor!\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/JumpThreading.cpp"
, 1488, __PRETTY_FUNCTION__));

  // If we have an available predecessor but it requires casting, insert the
  // cast in the predecessor and use the cast. Note that we have to update the
  // AvailablePreds vector as we go so that all of the PHI entries for this
  // predecessor use the same bitcast.
  Value *&PredV = I->second;
  if (PredV->getType() != LoadI->getType())
    PredV = CastInst::CreateBitOrPointerCast(PredV, LoadI->getType(), "",
                                             P->getTerminator());

  PN->addIncoming(PredV, I->first);
}

for (LoadInst *PredLoadI : CSELoads) {
  combineMetadataForCSE(PredLoadI, LoadI, true);
}

LoadI->replaceAllUsesWith(PN);
LoadI->eraseFromParent();

return true;
1510}

1512/// FindMostPopularDest - The specified list contains multiple possible
1513/// threadable destinations.  Pick the one that occurs the most frequently in
1514/// the list.
1515static BasicBlock *
1516FindMostPopularDest(BasicBlock *BB,
                  const SmallVectorImpl<std::pair<BasicBlock *,
                                        BasicBlock *>> &PredToDestList) {
assert(!PredToDestList.empty())((!PredToDestList.empty()) ? static_cast<void> (0) : __assert_fail
 ("!PredToDestList.empty()", "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/JumpThreading.cpp"
, 1519, __PRETTY_FUNCTION__));

// Determine popularity.  If there are multiple possible destinations, we
// explicitly choose to ignore 'undef' destinations.  We prefer to thread
// blocks with known and real destinations to threading undef.  We'll handle
// them later if interesting.
MapVector<BasicBlock *, unsigned> DestPopularity;

// Populate DestPopularity with the successors in the order they appear in the
// successor list.  This way, we ensure determinism by iterating it in the
// same order in std::max_element below.  We map nullptr to 0 so that we can
// return nullptr when PredToDestList contains nullptr only.
DestPopularity[nullptr] = 0;
for (auto *SuccBB : successors(BB))
  DestPopularity[SuccBB] = 0;

for (const auto &PredToDest : PredToDestList)
  if (PredToDest.second)
    DestPopularity[PredToDest.second]++;

// Find the most popular dest.
using VT = decltype(DestPopularity)::value_type;
auto MostPopular = std::max_element(
    DestPopularity.begin(), DestPopularity.end(),
    [](const VT &L, const VT &R) { return L.second < R.second; });

// Okay, we have finally picked the most popular destination.
return MostPopular->first;
1547}

1549// Try to evaluate the value of V when the control flows from PredPredBB to
1550// BB->getSinglePredecessor() and then on to BB.
1551Constant *JumpThreadingPass::EvaluateOnPredecessorEdge(BasicBlock *BB,
                                                     BasicBlock *PredPredBB,
                                                     Value *V) {
BasicBlock *PredBB = BB->getSinglePredecessor();
assert(PredBB && "Expected a single predecessor")((PredBB && "Expected a single predecessor") ? static_cast
<void> (0) : __assert_fail ("PredBB && \"Expected a single predecessor\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/JumpThreading.cpp"
, 1555, __PRETTY_FUNCTION__));

if (Constant *Cst = dyn_cast<Constant>(V)) {
  return Cst;
}

// Consult LVI if V is not an instruction in BB or PredBB.
Instruction *I = dyn_cast<Instruction>(V);
if (!I || (I->getParent() != BB && I->getParent() != PredBB)) {
  return LVI->getConstantOnEdge(V, PredPredBB, PredBB, nullptr);
}

// Look into a PHI argument.
if (PHINode *PHI = dyn_cast<PHINode>(V)) {
  if (PHI->getParent() == PredBB)
    return dyn_cast<Constant>(PHI->getIncomingValueForBlock(PredPredBB));
  return nullptr;
}

// If we have a CmpInst, try to fold it for each incoming edge into PredBB.
if (CmpInst *CondCmp = dyn_cast<CmpInst>(V)) {
  if (CondCmp->getParent() == BB) {
    Constant *Op0 =
        EvaluateOnPredecessorEdge(BB, PredPredBB, CondCmp->getOperand(0));
    Constant *Op1 =
        EvaluateOnPredecessorEdge(BB, PredPredBB, CondCmp->getOperand(1));
    if (Op0 && Op1) {
      return ConstantExpr::getCompare(CondCmp->getPredicate(), Op0, Op1);
    }
  }
  return nullptr;
}

return nullptr;
1589}

1591bool JumpThreadingPass::ProcessThreadableEdges(Value *Cond, BasicBlock *BB,
                                             ConstantPreference Preference,
                                             Instruction *CxtI) {
// If threading this would thread across a loop header, don't even try to
// thread the edge.
if (LoopHeaders.count(BB))
  return false;

PredValueInfoTy PredValues;
if (!ComputeValueKnownInPredecessors(Cond, BB, PredValues, Preference,
                                     CxtI)) {
  // We don't have known values in predecessors.  See if we can thread through
  // BB and its sole predecessor.
  return MaybeThreadThroughTwoBasicBlocks(BB, Cond);
}

assert(!PredValues.empty() &&((!PredValues.empty() && "ComputeValueKnownInPredecessors returned true with no values"
) ? static_cast<void> (0) : __assert_fail ("!PredValues.empty() && \"ComputeValueKnownInPredecessors returned true with no values\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/JumpThreading.cpp"
, 1608, __PRETTY_FUNCTION__))
       "ComputeValueKnownInPredecessors returned true with no values")((!PredValues.empty() && "ComputeValueKnownInPredecessors returned true with no values"
) ? static_cast<void> (0) : __assert_fail ("!PredValues.empty() && \"ComputeValueKnownInPredecessors returned true with no values\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/JumpThreading.cpp"
, 1608, __PRETTY_FUNCTION__));

LLVM_DEBUG(dbgs() << "IN BB: " << *BB;do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { dbgs() << "IN BB: " << *BB;
 for (const auto &PredValue : PredValues) { dbgs() <<
 "  BB '" << BB->getName() << "': FOUND condition = "
 << *PredValue.first << " for pred '" << PredValue
.second->getName() << "'.\n"; }; } } while (false)
           for (const auto &PredValue : PredValues) {do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { dbgs() << "IN BB: " << *BB;
 for (const auto &PredValue : PredValues) { dbgs() <<
 "  BB '" << BB->getName() << "': FOUND condition = "
 << *PredValue.first << " for pred '" << PredValue
.second->getName() << "'.\n"; }; } } while (false)
             dbgs() << "  BB '" << BB->getName()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { dbgs() << "IN BB: " << *BB;
 for (const auto &PredValue : PredValues) { dbgs() <<
 "  BB '" << BB->getName() << "': FOUND condition = "
 << *PredValue.first << " for pred '" << PredValue
.second->getName() << "'.\n"; }; } } while (false)
                    << "': FOUND condition = " << *PredValue.firstdo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { dbgs() << "IN BB: " << *BB;
 for (const auto &PredValue : PredValues) { dbgs() <<
 "  BB '" << BB->getName() << "': FOUND condition = "
 << *PredValue.first << " for pred '" << PredValue
.second->getName() << "'.\n"; }; } } while (false)
                    << " for pred '" << PredValue.second->getName() << "'.\n";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { dbgs() << "IN BB: " << *BB;
 for (const auto &PredValue : PredValues) { dbgs() <<
 "  BB '" << BB->getName() << "': FOUND condition = "
 << *PredValue.first << " for pred '" << PredValue
.second->getName() << "'.\n"; }; } } while (false)
})do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { dbgs() << "IN BB: " << *BB;
 for (const auto &PredValue : PredValues) { dbgs() <<
 "  BB '" << BB->getName() << "': FOUND condition = "
 << *PredValue.first << " for pred '" << PredValue
.second->getName() << "'.\n"; }; } } while (false);

// Decide what we want to thread through.  Convert our list of known values to
// a list of known destinations for each pred.  This also discards duplicate
// predecessors and keeps track of the undefined inputs (which are represented
// as a null dest in the PredToDestList).
SmallPtrSet<BasicBlock*, 16> SeenPreds;
SmallVector<std::pair<BasicBlock*, BasicBlock*>, 16> PredToDestList;

BasicBlock *OnlyDest = nullptr;
BasicBlock *MultipleDestSentinel = (BasicBlock*)(intptr_t)~0ULL;
Constant *OnlyVal = nullptr;
Constant *MultipleVal = (Constant *)(intptr_t)~0ULL;

for (const auto &PredValue : PredValues) {
  BasicBlock *Pred = PredValue.second;
  if (!SeenPreds.insert(Pred).second)
    continue;  // Duplicate predecessor entry.

  Constant *Val = PredValue.first;

  BasicBlock *DestBB;
  if (isa<UndefValue>(Val))
    DestBB = nullptr;
  else if (BranchInst *BI = dyn_cast<BranchInst>(BB->getTerminator())) {
    assert(isa<ConstantInt>(Val) && "Expecting a constant integer")((isa<ConstantInt>(Val) && "Expecting a constant integer"
) ? static_cast<void> (0) : __assert_fail ("isa<ConstantInt>(Val) && \"Expecting a constant integer\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/JumpThreading.cpp"
, 1640, __PRETTY_FUNCTION__));
    DestBB = BI->getSuccessor(cast<ConstantInt>(Val)->isZero());
  } else if (SwitchInst *SI = dyn_cast<SwitchInst>(BB->getTerminator())) {
    assert(isa<ConstantInt>(Val) && "Expecting a constant integer")((isa<ConstantInt>(Val) && "Expecting a constant integer"
) ? static_cast<void> (0) : __assert_fail ("isa<ConstantInt>(Val) && \"Expecting a constant integer\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/JumpThreading.cpp"
, 1643, __PRETTY_FUNCTION__));
    DestBB = SI->findCaseValue(cast<ConstantInt>(Val))->getCaseSuccessor();
  } else {
    assert(isa<IndirectBrInst>(BB->getTerminator())((isa<IndirectBrInst>(BB->getTerminator()) &&
 "Unexpected terminator") ? static_cast<void> (0) : __assert_fail
 ("isa<IndirectBrInst>(BB->getTerminator()) && \"Unexpected terminator\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/JumpThreading.cpp"
, 1647, __PRETTY_FUNCTION__))
            && "Unexpected terminator")((isa<IndirectBrInst>(BB->getTerminator()) &&
 "Unexpected terminator") ? static_cast<void> (0) : __assert_fail
 ("isa<IndirectBrInst>(BB->getTerminator()) && \"Unexpected terminator\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/JumpThreading.cpp"
, 1647, __PRETTY_FUNCTION__));
    assert(isa<BlockAddress>(Val) && "Expecting a constant blockaddress")((isa<BlockAddress>(Val) && "Expecting a constant blockaddress"
) ? static_cast<void> (0) : __assert_fail ("isa<BlockAddress>(Val) && \"Expecting a constant blockaddress\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/JumpThreading.cpp"
, 1648, __PRETTY_FUNCTION__));
    DestBB = cast<BlockAddress>(Val)->getBasicBlock();
  }

  // If we have exactly one destination, remember it for efficiency below.
  if (PredToDestList.empty()) {
    OnlyDest = DestBB;
    OnlyVal = Val;
  } else {
    if (OnlyDest != DestBB)
      OnlyDest = MultipleDestSentinel;
    // It possible we have same destination, but different value, e.g. default
    // case in switchinst.
    if (Val != OnlyVal)
      OnlyVal = MultipleVal;
  }

  // If the predecessor ends with an indirect goto, we can't change its
  // destination. Same for CallBr.
  if (isa<IndirectBrInst>(Pred->getTerminator()) ||
      isa<CallBrInst>(Pred->getTerminator()))
    continue;

  PredToDestList.emplace_back(Pred, DestBB);
}

// If all edges were unthreadable, we fail.
if (PredToDestList.empty())
  return false;

// If all the predecessors go to a single known successor, we want to fold,
// not thread. By doing so, we do not need to duplicate the current block and
// also miss potential opportunities in case we dont/cant duplicate.
if (OnlyDest && OnlyDest != MultipleDestSentinel) {
  if (BB->hasNPredecessors(PredToDestList.size())) {
    bool SeenFirstBranchToOnlyDest = false;
    std::vector <DominatorTree::UpdateType> Updates;
    Updates.reserve(BB->getTerminator()->getNumSuccessors() - 1);
    for (BasicBlock *SuccBB : successors(BB)) {
      if (SuccBB == OnlyDest && !SeenFirstBranchToOnlyDest) {
        SeenFirstBranchToOnlyDest = true; // Don't modify the first branch.
      } else {
        SuccBB->removePredecessor(BB, true); // This is unreachable successor.
        Updates.push_back({DominatorTree::Delete, BB, SuccBB});
      }
    }

    // Finally update the terminator.
    Instruction *Term = BB->getTerminator();
    BranchInst::Create(OnlyDest, Term);
    Term->eraseFromParent();
    DTU->applyUpdatesPermissive(Updates);

    // If the condition is now dead due to the removal of the old terminator,
    // erase it.
    if (auto *CondInst = dyn_cast<Instruction>(Cond)) {
      if (CondInst->use_empty() && !CondInst->mayHaveSideEffects())
        CondInst->eraseFromParent();
      // We can safely replace *some* uses of the CondInst if it has
      // exactly one value as returned by LVI. RAUW is incorrect in the
      // presence of guards and assumes, that have the `Cond` as the use. This
      // is because we use the guards/assume to reason about the `Cond` value
      // at the end of block, but RAUW unconditionally replaces all uses
      // including the guards/assumes themselves and the uses before the
      // guard/assume.
      else if (OnlyVal && OnlyVal != MultipleVal &&
               CondInst->getParent() == BB)
        ReplaceFoldableUses(CondInst, OnlyVal);
    }
    return true;
  }
}

// Determine which is the most common successor.  If we have many inputs and
// this block is a switch, we want to start by threading the batch that goes
// to the most popular destination first.  If we only know about one
// threadable destination (the common case) we can avoid this.
BasicBlock *MostPopularDest = OnlyDest;

if (MostPopularDest == MultipleDestSentinel) {
  // Remove any loop headers from the Dest list, ThreadEdge conservatively
  // won't process them, but we might have other destination that are eligible
  // and we still want to process.
  erase_if(PredToDestList,
           [&](const std::pair<BasicBlock *, BasicBlock *> &PredToDest) {
             return LoopHeaders.count(PredToDest.second) != 0;
           });

  if (PredToDestList.empty())
    return false;

  MostPopularDest = FindMostPopularDest(BB, PredToDestList);
}

// Now that we know what the most popular destination is, factor all
// predecessors that will jump to it into a single predecessor.
SmallVector<BasicBlock*, 16> PredsToFactor;
for (const auto &PredToDest : PredToDestList)
  if (PredToDest.second == MostPopularDest) {
    BasicBlock *Pred = PredToDest.first;

    // This predecessor may be a switch or something else that has multiple
    // edges to the block.  Factor each of these edges by listing them
    // according to # occurrences in PredsToFactor.
    for (BasicBlock *Succ : successors(Pred))
      if (Succ == BB)
        PredsToFactor.push_back(Pred);
  }

// If the threadable edges are branching on an undefined value, we get to pick
// the destination that these predecessors should get to.
if (!MostPopularDest)
  MostPopularDest = BB->getTerminator()->
                          getSuccessor(GetBestDestForJumpOnUndef(BB));

// Ok, try to thread it!
return TryThreadEdge(BB, PredsToFactor, MostPopularDest);
1765}

1767/// ProcessBranchOnPHI - We have an otherwise unthreadable conditional branch on
1768/// a PHI node (or freeze PHI) in the current block.  See if there are any
1769/// simplifications we can do based on inputs to the phi node.
1770bool JumpThreadingPass::ProcessBranchOnPHI(PHINode *PN) {
BasicBlock *BB = PN->getParent();

// TODO: We could make use of this to do it once for blocks with common PHI
// values.
SmallVector<BasicBlock*, 1> PredBBs;
PredBBs.resize(1);

// If any of the predecessor blocks end in an unconditional branch, we can
// *duplicate* the conditional branch into that block in order to further
// encourage jump threading and to eliminate cases where we have branch on a
// phi of an icmp (branch on icmp is much better).
// This is still beneficial when a frozen phi is used as the branch condition
// because it allows CodeGenPrepare to further canonicalize br(freeze(icmp))
// to br(icmp(freeze ...)).
for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) {
  BasicBlock *PredBB = PN->getIncomingBlock(i);
  if (BranchInst *PredBr = dyn_cast<BranchInst>(PredBB->getTerminator()))
    if (PredBr->isUnconditional()) {
      PredBBs[0] = PredBB;
      // Try to duplicate BB into PredBB.
      if (DuplicateCondBranchOnPHIIntoPred(BB, PredBBs))
        return true;
    }
}

return false;
1797}

1799/// ProcessBranchOnXOR - We have an otherwise unthreadable conditional branch on
1800/// a xor instruction in the current block.  See if there are any
1801/// simplifications we can do based on inputs to the xor.
1802bool JumpThreadingPass::ProcessBranchOnXOR(BinaryOperator *BO) {
BasicBlock *BB = BO->getParent();

// If either the LHS or RHS of the xor is a constant, don't do this
// optimization.
if (isa<ConstantInt>(BO->getOperand(0)) ||
    isa<ConstantInt>(BO->getOperand(1)))
  return false;

// If the first instruction in BB isn't a phi, we won't be able to infer
// anything special about any particular predecessor.
if (!isa<PHINode>(BB->front()))
  return false;

// If this BB is a landing pad, we won't be able to split the edge into it.
if (BB->isEHPad())
  return false;

// If we have a xor as the branch input to this block, and we know that the
// LHS or RHS of the xor in any predecessor is true/false, then we can clone
// the condition into the predecessor and fix that value to true, saving some
// logical ops on that path and encouraging other paths to simplify.
//
// This copies something like this:
//
//  BB:
//    %X = phi i1 [1],  [%X']
//    %Y = icmp eq i32 %A, %B
//    %Z = xor i1 %X, %Y
//    br i1 %Z, ...
//
// Into:
//  BB':
//    %Y = icmp ne i32 %A, %B
//    br i1 %Y, ...

PredValueInfoTy XorOpValues;
bool isLHS = true;
if (!ComputeValueKnownInPredecessors(BO->getOperand(0), BB, XorOpValues,
                                     WantInteger, BO)) {
  assert(XorOpValues.empty())((XorOpValues.empty()) ? static_cast<void> (0) : __assert_fail
 ("XorOpValues.empty()", "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/JumpThreading.cpp"
, 1842, __PRETTY_FUNCTION__));
  if (!ComputeValueKnownInPredecessors(BO->getOperand(1), BB, XorOpValues,
                                       WantInteger, BO))
    return false;
  isLHS = false;
}

assert(!XorOpValues.empty() &&((!XorOpValues.empty() && "ComputeValueKnownInPredecessors returned true with no values"
) ? static_cast<void> (0) : __assert_fail ("!XorOpValues.empty() && \"ComputeValueKnownInPredecessors returned true with no values\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/JumpThreading.cpp"
, 1850, __PRETTY_FUNCTION__))
       "ComputeValueKnownInPredecessors returned true with no values")((!XorOpValues.empty() && "ComputeValueKnownInPredecessors returned true with no values"
) ? static_cast<void> (0) : __assert_fail ("!XorOpValues.empty() && \"ComputeValueKnownInPredecessors returned true with no values\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/JumpThreading.cpp"
, 1850, __PRETTY_FUNCTION__));

// Scan the information to see which is most popular: true or false.  The
// predecessors can be of the set true, false, or undef.
unsigned NumTrue = 0, NumFalse = 0;
for (const auto &XorOpValue : XorOpValues) {
  if (isa<UndefValue>(XorOpValue.first))
    // Ignore undefs for the count.
    continue;
  if (cast<ConstantInt>(XorOpValue.first)->isZero())
    ++NumFalse;
  else
    ++NumTrue;
}

// Determine which value to split on, true, false, or undef if neither.
ConstantInt *SplitVal = nullptr;
if (NumTrue > NumFalse)
  SplitVal = ConstantInt::getTrue(BB->getContext());
else if (NumTrue != 0 || NumFalse != 0)
  SplitVal = ConstantInt::getFalse(BB->getContext());

// Collect all of the blocks that this can be folded into so that we can
// factor this once and clone it once.
SmallVector<BasicBlock*, 8> BlocksToFoldInto;
for (const auto &XorOpValue : XorOpValues) {
  if (XorOpValue.first != SplitVal && !isa<UndefValue>(XorOpValue.first))
    continue;

  BlocksToFoldInto.push_back(XorOpValue.second);
}

// If we inferred a value for all of the predecessors, then duplication won't
// help us.  However, we can just replace the LHS or RHS with the constant.
if (BlocksToFoldInto.size() ==
    cast<PHINode>(BB->front()).getNumIncomingValues()) {
  if (!SplitVal) {
    // If all preds provide undef, just nuke the xor, because it is undef too.
    BO->replaceAllUsesWith(UndefValue::get(BO->getType()));
    BO->eraseFromParent();
  } else if (SplitVal->isZero()) {
    // If all preds provide 0, replace the xor with the other input.
    BO->replaceAllUsesWith(BO->getOperand(isLHS));
    BO->eraseFromParent();
  } else {
    // If all preds provide 1, set the computed value to 1.
    BO->setOperand(!isLHS, SplitVal);
  }

  return true;
}

// If any of predecessors end with an indirect goto, we can't change its
// destination. Same for CallBr.
if (any_of(BlocksToFoldInto, [](BasicBlock *Pred) {
      return isa<IndirectBrInst>(Pred->getTerminator()) ||
             isa<CallBrInst>(Pred->getTerminator());
    }))
  return false;

// Try to duplicate BB into PredBB.
return DuplicateCondBranchOnPHIIntoPred(BB, BlocksToFoldInto);
1912}

1914/// AddPHINodeEntriesForMappedBlock - We're adding 'NewPred' as a new
1915/// predecessor to the PHIBB block.  If it has PHI nodes, add entries for
1916/// NewPred using the entries from OldPred (suitably mapped).
1917static void AddPHINodeEntriesForMappedBlock(BasicBlock *PHIBB,
                                          BasicBlock *OldPred,
                                          BasicBlock *NewPred,
                                   DenseMap<Instruction*, Value*> &ValueMap) {
for (PHINode &PN : PHIBB->phis()) {
  // Ok, we have a PHI node.  Figure out what the incoming value was for the
  // DestBlock.
  Value *IV = PN.getIncomingValueForBlock(OldPred);

  // Remap the value if necessary.
  if (Instruction *Inst = dyn_cast<Instruction>(IV)) {
    DenseMap<Instruction*, Value*>::iterator I = ValueMap.find(Inst);
    if (I != ValueMap.end())
      IV = I->second;
  }

  PN.addIncoming(IV, NewPred);
}
1935}

1937/// Merge basic block BB into its sole predecessor if possible.
1938bool JumpThreadingPass::MaybeMergeBasicBlockIntoOnlyPred(BasicBlock *BB) {
BasicBlock *SinglePred = BB->getSinglePredecessor();
if (!SinglePred)
  return false;

const Instruction *TI = SinglePred->getTerminator();
if (TI->isExceptionalTerminator() || TI->getNumSuccessors() != 1 ||
    SinglePred == BB || hasAddressTakenAndUsed(BB))
  return false;

// If SinglePred was a loop header, BB becomes one.
if (LoopHeaders.erase(SinglePred))
  LoopHeaders.insert(BB);

LVI->eraseBlock(SinglePred);
MergeBasicBlockIntoOnlyPred(BB, DTU);

// Now that BB is merged into SinglePred (i.e. SinglePred code followed by
// BB code within one basic block `BB`), we need to invalidate the LVI
// information associated with BB, because the LVI information need not be
// true for all of BB after the merge. For example,
// Before the merge, LVI info and code is as follows:
// SinglePred: <LVI info1 for %p val>
// %y = use of %p
// call @exit() // need not transfer execution to successor.
// assume(%p) // from this point on %p is true
// br label %BB
// BB: <LVI info2 for %p val, i.e. %p is true>
// %x = use of %p
// br label exit
//
// Note that this LVI info for blocks BB and SinglPred is correct for %p
// (info2 and info1 respectively). After the merge and the deletion of the
// LVI info1 for SinglePred. We have the following code:
// BB: <LVI info2 for %p val>
// %y = use of %p
// call @exit()
// assume(%p)
// %x = use of %p <-- LVI info2 is correct from here onwards.
// br label exit
// LVI info2 for BB is incorrect at the beginning of BB.

// Invalidate LVI information for BB if the LVI is not provably true for
// all of BB.
if (!isGuaranteedToTransferExecutionToSuccessor(BB))
  LVI->eraseBlock(BB);
return true;
1985}

1987/// Update the SSA form.  NewBB contains instructions that are copied from BB.
1988/// ValueMapping maps old values in BB to new ones in NewBB.
1989void JumpThreadingPass::UpdateSSA(
  BasicBlock *BB, BasicBlock *NewBB,
  DenseMap<Instruction *, Value *> &ValueMapping) {
// If there were values defined in BB that are used outside the block, then we
// now have to update all uses of the value to use either the original value,
// the cloned value, or some PHI derived value.  This can require arbitrary
// PHI insertion, of which we are prepared to do, clean these up now.
SSAUpdater SSAUpdate;
SmallVector<Use *, 16> UsesToRename;

for (Instruction &I : *BB) {
  // Scan all uses of this instruction to see if it is used outside of its
  // block, and if so, record them in UsesToRename.
  for (Use &U : I.uses()) {
    Instruction *User = cast<Instruction>(U.getUser());
    if (PHINode *UserPN = dyn_cast<PHINode>(User)) {
      if (UserPN->getIncomingBlock(U) == BB)
        continue;
    } else if (User->getParent() == BB)
      continue;

    UsesToRename.push_back(&U);
  }

  // If there are no uses outside the block, we're done with this instruction.
  if (UsesToRename.empty())
    continue;
  LLVM_DEBUG(dbgs() << "JT: Renaming non-local uses of: " << I << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { dbgs() << "JT: Renaming non-local uses of: "
 << I << "\n"; } } while (false);

  // We found a use of I outside of BB.  Rename all uses of I that are outside
  // its block to be uses of the appropriate PHI node etc.  See ValuesInBlocks
  // with the two values we know.
  SSAUpdate.Initialize(I.getType(), I.getName());
  SSAUpdate.AddAvailableValue(BB, &I);
  SSAUpdate.AddAvailableValue(NewBB, ValueMapping[&I]);

  while (!UsesToRename.empty())
    SSAUpdate.RewriteUse(*UsesToRename.pop_back_val());
  LLVM_DEBUG(dbgs() << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { dbgs() << "\n"; } } while (false);
}
2029}

2031/// Clone instructions in range [BI, BE) to NewBB.  For PHI nodes, we only clone
2032/// arguments that come from PredBB.  Return the map from the variables in the
2033/// source basic block to the variables in the newly created basic block.
2034DenseMap<Instruction *, Value *>
2035JumpThreadingPass::CloneInstructions(BasicBlock::iterator BI,
                                   BasicBlock::iterator BE, BasicBlock *NewBB,
                                   BasicBlock *PredBB) {
// We are going to have to map operands from the source basic block to the new
// copy of the block 'NewBB'.  If there are PHI nodes in the source basic
// block, evaluate them to account for entry from PredBB.
DenseMap<Instruction *, Value *> ValueMapping;

// Clone the phi nodes of the source basic block into NewBB.  The resulting
// phi nodes are trivial since NewBB only has one predecessor, but SSAUpdater
// might need to rewrite the operand of the cloned phi.
for (; PHINode *PN = dyn_cast<PHINode>(BI); ++BI) {
  PHINode *NewPN = PHINode::Create(PN->getType(), 1, PN->getName(), NewBB);
  NewPN->addIncoming(PN->getIncomingValueForBlock(PredBB), PredBB);
  ValueMapping[PN] = NewPN;
}

// Clone the non-phi instructions of the source basic block into NewBB,
// keeping track of the mapping and using it to remap operands in the cloned
// instructions.
for (; BI != BE; ++BI) {
  Instruction *New = BI->clone();
  New->setName(BI->getName());
  NewBB->getInstList().push_back(New);
  ValueMapping[&*BI] = New;

  // Remap operands to patch up intra-block references.
  for (unsigned i = 0, e = New->getNumOperands(); i != e; ++i)
    if (Instruction *Inst = dyn_cast<Instruction>(New->getOperand(i))) {
      DenseMap<Instruction *, Value *>::iterator I = ValueMapping.find(Inst);
      if (I != ValueMapping.end())
        New->setOperand(i, I->second);
    }
}

return ValueMapping;
2071}

2073/// Attempt to thread through two successive basic blocks.
2074bool JumpThreadingPass::MaybeThreadThroughTwoBasicBlocks(BasicBlock *BB,
                                                       Value *Cond) {
// Consider:
//
// PredBB:
//   %var = phi i32* [ null, %bb1 ], [ @a, %bb2 ]
//   %tobool = icmp eq i32 %cond, 0
//   br i1 %tobool, label %BB, label ...
//
// BB:
//   %cmp = icmp eq i32* %var, null
//   br i1 %cmp, label ..., label ...
//
// We don't know the value of %var at BB even if we know which incoming edge
// we take to BB.  However, once we duplicate PredBB for each of its incoming
// edges (say, PredBB1 and PredBB2), we know the value of %var in each copy of
// PredBB.  Then we can thread edges PredBB1->BB and PredBB2->BB through BB.

// Require that BB end with a Branch for simplicity.
BranchInst *CondBr = dyn_cast<BranchInst>(BB->getTerminator());
if (!CondBr)
  return false;

// BB must have exactly one predecessor.
BasicBlock *PredBB = BB->getSinglePredecessor();
if (!PredBB)
  return false;

// Require that PredBB end with a conditional Branch. If PredBB ends with an
// unconditional branch, we should be merging PredBB and BB instead. For
// simplicity, we don't deal with a switch.
BranchInst *PredBBBranch = dyn_cast<BranchInst>(PredBB->getTerminator());
if (!PredBBBranch || PredBBBranch->isUnconditional())
  return false;

// If PredBB has exactly one incoming edge, we don't gain anything by copying
// PredBB.
if (PredBB->getSinglePredecessor())
  return false;

// Don't thread through PredBB if it contains a successor edge to itself, in
// which case we would infinite loop.  Suppose we are threading an edge from
// PredPredBB through PredBB and BB to SuccBB with PredBB containing a
// successor edge to itself.  If we allowed jump threading in this case, we
// could duplicate PredBB and BB as, say, PredBB.thread and BB.thread.  Since
// PredBB.thread has a successor edge to PredBB, we would immediately come up
// with another jump threading opportunity from PredBB.thread through PredBB
// and BB to SuccBB.  This jump threading would repeatedly occur.  That is, we
// would keep peeling one iteration from PredBB.
if (llvm::is_contained(successors(PredBB), PredBB))
  return false;

// Don't thread across a loop header.
if (LoopHeaders.count(PredBB))
  return false;

// Avoid complication with duplicating EH pads.
if (PredBB->isEHPad())
  return false;

// Find a predecessor that we can thread.  For simplicity, we only consider a
// successor edge out of BB to which we thread exactly one incoming edge into
// PredBB.
unsigned ZeroCount = 0;
unsigned OneCount = 0;
BasicBlock *ZeroPred = nullptr;
BasicBlock *OnePred = nullptr;
for (BasicBlock *P : predecessors(PredBB)) {
  if (ConstantInt *CI = dyn_cast_or_null<ConstantInt>(
          EvaluateOnPredecessorEdge(BB, P, Cond))) {
    if (CI->isZero()) {
      ZeroCount++;
      ZeroPred = P;
    } else if (CI->isOne()) {
      OneCount++;
      OnePred = P;
    }
  }
}

// Disregard complicated cases where we have to thread multiple edges.
BasicBlock *PredPredBB;
if (ZeroCount == 1) {
  PredPredBB = ZeroPred;
} else if (OneCount == 1) {
  PredPredBB = OnePred;
} else {
  return false;
}

BasicBlock *SuccBB = CondBr->getSuccessor(PredPredBB == ZeroPred);

// If threading to the same block as we come from, we would infinite loop.
if (SuccBB == BB) {
  LLVM_DEBUG(dbgs() << "  Not threading across BB '" << BB->getName()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { dbgs() << "  Not threading across BB '"
 << BB->getName() << "' - would thread to self!\n"
; } } while (false)
                    << "' - would thread to self!\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { dbgs() << "  Not threading across BB '"
 << BB->getName() << "' - would thread to self!\n"
; } } while (false);
  return false;
}

// If threading this would thread across a loop header, don't thread the edge.
// See the comments above FindLoopHeaders for justifications and caveats.
if (LoopHeaders.count(BB) || LoopHeaders.count(SuccBB)) {
  LLVM_DEBUG({do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { { bool BBIsHeader = LoopHeaders.count(BB
); bool SuccIsHeader = LoopHeaders.count(SuccBB); dbgs() <<
 "  Not threading across " << (BBIsHeader ? "loop header BB '"
 : "block BB '") << BB->getName() << "' to dest "
 << (SuccIsHeader ? "loop header BB '" : "block BB '") <<
 SuccBB->getName() << "' - it might create an irreducible loop!\n"
; }; } } while (false)
    bool BBIsHeader = LoopHeaders.count(BB);do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { { bool BBIsHeader = LoopHeaders.count(BB
); bool SuccIsHeader = LoopHeaders.count(SuccBB); dbgs() <<
 "  Not threading across " << (BBIsHeader ? "loop header BB '"
 : "block BB '") << BB->getName() << "' to dest "
 << (SuccIsHeader ? "loop header BB '" : "block BB '") <<
 SuccBB->getName() << "' - it might create an irreducible loop!\n"
; }; } } while (false)
    bool SuccIsHeader = LoopHeaders.count(SuccBB);do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { { bool BBIsHeader = LoopHeaders.count(BB
); bool SuccIsHeader = LoopHeaders.count(SuccBB); dbgs() <<
 "  Not threading across " << (BBIsHeader ? "loop header BB '"
 : "block BB '") << BB->getName() << "' to dest "
 << (SuccIsHeader ? "loop header BB '" : "block BB '") <<
 SuccBB->getName() << "' - it might create an irreducible loop!\n"
; }; } } while (false)
    dbgs() << "  Not threading across "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { { bool BBIsHeader = LoopHeaders.count(BB
); bool SuccIsHeader = LoopHeaders.count(SuccBB); dbgs() <<
 "  Not threading across " << (BBIsHeader ? "loop header BB '"
 : "block BB '") << BB->getName() << "' to dest "
 << (SuccIsHeader ? "loop header BB '" : "block BB '") <<
 SuccBB->getName() << "' - it might create an irreducible loop!\n"
; }; } } while (false)
           << (BBIsHeader ? "loop header BB '" : "block BB '")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { { bool BBIsHeader = LoopHeaders.count(BB
); bool SuccIsHeader = LoopHeaders.count(SuccBB); dbgs() <<
 "  Not threading across " << (BBIsHeader ? "loop header BB '"
 : "block BB '") << BB->getName() << "' to dest "
 << (SuccIsHeader ? "loop header BB '" : "block BB '") <<
 SuccBB->getName() << "' - it might create an irreducible loop!\n"
; }; } } while (false)
           << BB->getName() << "' to dest "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { { bool BBIsHeader = LoopHeaders.count(BB
); bool SuccIsHeader = LoopHeaders.count(SuccBB); dbgs() <<
 "  Not threading across " << (BBIsHeader ? "loop header BB '"
 : "block BB '") << BB->getName() << "' to dest "
 << (SuccIsHeader ? "loop header BB '" : "block BB '") <<
 SuccBB->getName() << "' - it might create an irreducible loop!\n"
; }; } } while (false)
           << (SuccIsHeader ? "loop header BB '" : "block BB '")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { { bool BBIsHeader = LoopHeaders.count(BB
); bool SuccIsHeader = LoopHeaders.count(SuccBB); dbgs() <<
 "  Not threading across " << (BBIsHeader ? "loop header BB '"
 : "block BB '") << BB->getName() << "' to dest "
 << (SuccIsHeader ? "loop header BB '" : "block BB '") <<
 SuccBB->getName() << "' - it might create an irreducible loop!\n"
; }; } } while (false)
           << SuccBB->getName()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { { bool BBIsHeader = LoopHeaders.count(BB
); bool SuccIsHeader = LoopHeaders.count(SuccBB); dbgs() <<
 "  Not threading across " << (BBIsHeader ? "loop header BB '"
 : "block BB '") << BB->getName() << "' to dest "
 << (SuccIsHeader ? "loop header BB '" : "block BB '") <<
 SuccBB->getName() << "' - it might create an irreducible loop!\n"
; }; } } while (false)
           << "' - it might create an irreducible loop!\n";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { { bool BBIsHeader = LoopHeaders.count(BB
); bool SuccIsHeader = LoopHeaders.count(SuccBB); dbgs() <<
 "  Not threading across " << (BBIsHeader ? "loop header BB '"
 : "block BB '") << BB->getName() << "' to dest "
 << (SuccIsHeader ? "loop header BB '" : "block BB '") <<
 SuccBB->getName() << "' - it might create an irreducible loop!\n"
; }; } } while (false)
  })do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { { bool BBIsHeader = LoopHeaders.count(BB
); bool SuccIsHeader = LoopHeaders.count(SuccBB); dbgs() <<
 "  Not threading across " << (BBIsHeader ? "loop header BB '"
 : "block BB '") << BB->getName() << "' to dest "
 << (SuccIsHeader ? "loop header BB '" : "block BB '") <<
 SuccBB->getName() << "' - it might create an irreducible loop!\n"
; }; } } while (false);
  return false;
}

// Compute the cost of duplicating BB and PredBB.
unsigned BBCost =
    getJumpThreadDuplicationCost(BB, BB->getTerminator(), BBDupThreshold);
unsigned PredBBCost = getJumpThreadDuplicationCost(
    PredBB, PredBB->getTerminator(), BBDupThreshold);

// Give up if costs are too high.  We need to check BBCost and PredBBCost
// individually before checking their sum because getJumpThreadDuplicationCost
// return (unsigned)~0 for those basic blocks that cannot be duplicated.
if (BBCost > BBDupThreshold || PredBBCost > BBDupThreshold ||
    BBCost + PredBBCost > BBDupThreshold) {
  LLVM_DEBUG(dbgs() << "  Not threading BB '" << BB->getName()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { dbgs() << "  Not threading BB '" <<
 BB->getName() << "' - Cost is too high: " << PredBBCost
 << " for PredBB, " << BBCost << "for BB\n"
; } } while (false)
                    << "' - Cost is too high: " << PredBBCostdo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { dbgs() << "  Not threading BB '" <<
 BB->getName() << "' - Cost is too high: " << PredBBCost
 << " for PredBB, " << BBCost << "for BB\n"
; } } while (false)
                    << " for PredBB, " << BBCost << "for BB\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { dbgs() << "  Not threading BB '" <<
 BB->getName() << "' - Cost is too high: " << PredBBCost
 << " for PredBB, " << BBCost << "for BB\n"
; } } while (false);
  return false;
}

// Now we are ready to duplicate PredBB.
ThreadThroughTwoBasicBlocks(PredPredBB, PredBB, BB, SuccBB);
return true;
2209}

2211void JumpThreadingPass::ThreadThroughTwoBasicBlocks(BasicBlock *PredPredBB,
                                                  BasicBlock *PredBB,
                                                  BasicBlock *BB,
                                                  BasicBlock *SuccBB) {
LLVM_DEBUG(dbgs() << "  Threading through '" << PredBB->getName() << "' and '"do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { dbgs() << "  Threading through '"
 << PredBB->getName() << "' and '" << BB
->getName() << "'\n"; } } while (false)
                  << BB->getName() << "'\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { dbgs() << "  Threading through '"
 << PredBB->getName() << "' and '" << BB
->getName() << "'\n"; } } while (false);

BranchInst *CondBr = cast<BranchInst>(BB->getTerminator());
BranchInst *PredBBBranch = cast<BranchInst>(PredBB->getTerminator());

BasicBlock *NewBB =
    BasicBlock::Create(PredBB->getContext(), PredBB->getName() + ".thread",
                       PredBB->getParent(), PredBB);
NewBB->moveAfter(PredBB);

// Set the block frequency of NewBB.
if (HasProfileData) {
  auto NewBBFreq = BFI->getBlockFreq(PredPredBB) *
                   BPI->getEdgeProbability(PredPredBB, PredBB);
  BFI->setBlockFreq(NewBB, NewBBFreq.getFrequency());
}

// We are going to have to map operands from the original BB block to the new
// copy of the block 'NewBB'.  If there are PHI nodes in PredBB, evaluate them
// to account for entry from PredPredBB.
DenseMap<Instruction *, Value *> ValueMapping =
    CloneInstructions(PredBB->begin(), PredBB->end(), NewBB, PredPredBB);

// Copy the edge probabilities from PredBB to NewBB.
if (HasProfileData) {
  SmallVector<BranchProbability, 4> Probs;
  for (BasicBlock *Succ : successors(PredBB))
    Probs.push_back(BPI->getEdgeProbability(PredBB, Succ));
  BPI->setEdgeProbability(NewBB, Probs);
}

// Update the terminator of PredPredBB to jump to NewBB instead of PredBB.
// This eliminates predecessors from PredPredBB, which requires us to simplify
// any PHI nodes in PredBB.
Instruction *PredPredTerm = PredPredBB->getTerminator();
for (unsigned i = 0, e = PredPredTerm->getNumSuccessors(); i != e; ++i)
  if (PredPredTerm->getSuccessor(i) == PredBB) {
    PredBB->removePredecessor(PredPredBB, true);
    PredPredTerm->setSuccessor(i, NewBB);
  }

AddPHINodeEntriesForMappedBlock(PredBBBranch->getSuccessor(0), PredBB, NewBB,
                                ValueMapping);
AddPHINodeEntriesForMappedBlock(PredBBBranch->getSuccessor(1), PredBB, NewBB,
                                ValueMapping);

DTU->applyUpdatesPermissive(
    {{DominatorTree::Insert, NewBB, CondBr->getSuccessor(0)},
     {DominatorTree::Insert, NewBB, CondBr->getSuccessor(1)},
     {DominatorTree::Insert, PredPredBB, NewBB},
     {DominatorTree::Delete, PredPredBB, PredBB}});

UpdateSSA(PredBB, NewBB, ValueMapping);

// Clean up things like PHI nodes with single operands, dead instructions,
// etc.
SimplifyInstructionsInBlock(NewBB, TLI);
SimplifyInstructionsInBlock(PredBB, TLI);

SmallVector<BasicBlock *, 1> PredsToFactor;
PredsToFactor.push_back(NewBB);
ThreadEdge(BB, PredsToFactor, SuccBB);
2278}

2280/// TryThreadEdge - Thread an edge if it's safe and profitable to do so.
2281bool JumpThreadingPass::TryThreadEdge(
  BasicBlock *BB, const SmallVectorImpl<BasicBlock *> &PredBBs,
  BasicBlock *SuccBB) {
// If threading to the same block as we come from, we would infinite loop.
if (SuccBB == BB) {
  LLVM_DEBUG(dbgs() << "  Not threading across BB '" << BB->getName()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { dbgs() << "  Not threading across BB '"
 << BB->getName() << "' - would thread to self!\n"
; } } while (false)
                    << "' - would thread to self!\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { dbgs() << "  Not threading across BB '"
 << BB->getName() << "' - would thread to self!\n"
; } } while (false);
  return false;
}

// If threading this would thread across a loop header, don't thread the edge.
// See the comments above FindLoopHeaders for justifications and caveats.
if (LoopHeaders.count(BB) || LoopHeaders.count(SuccBB)) {
  LLVM_DEBUG({do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { { bool BBIsHeader = LoopHeaders.count(BB
); bool SuccIsHeader = LoopHeaders.count(SuccBB); dbgs() <<
 "  Not threading across " << (BBIsHeader ? "loop header BB '"
 : "block BB '") << BB->getName() << "' to dest "
 << (SuccIsHeader ? "loop header BB '" : "block BB '") <<
 SuccBB->getName() << "' - it might create an irreducible loop!\n"
; }; } } while (false)
    bool BBIsHeader = LoopHeaders.count(BB);do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { { bool BBIsHeader = LoopHeaders.count(BB
); bool SuccIsHeader = LoopHeaders.count(SuccBB); dbgs() <<
 "  Not threading across " << (BBIsHeader ? "loop header BB '"
 : "block BB '") << BB->getName() << "' to dest "
 << (SuccIsHeader ? "loop header BB '" : "block BB '") <<
 SuccBB->getName() << "' - it might create an irreducible loop!\n"
; }; } } while (false)
    bool SuccIsHeader = LoopHeaders.count(SuccBB);do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { { bool BBIsHeader = LoopHeaders.count(BB
); bool SuccIsHeader = LoopHeaders.count(SuccBB); dbgs() <<
 "  Not threading across " << (BBIsHeader ? "loop header BB '"
 : "block BB '") << BB->getName() << "' to dest "
 << (SuccIsHeader ? "loop header BB '" : "block BB '") <<
 SuccBB->getName() << "' - it might create an irreducible loop!\n"
; }; } } while (false)
    dbgs() << "  Not threading across "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { { bool BBIsHeader = LoopHeaders.count(BB
); bool SuccIsHeader = LoopHeaders.count(SuccBB); dbgs() <<
 "  Not threading across " << (BBIsHeader ? "loop header BB '"
 : "block BB '") << BB->getName() << "' to dest "
 << (SuccIsHeader ? "loop header BB '" : "block BB '") <<
 SuccBB->getName() << "' - it might create an irreducible loop!\n"
; }; } } while (false)
        << (BBIsHeader ? "loop header BB '" : "block BB '") << BB->getName()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { { bool BBIsHeader = LoopHeaders.count(BB
); bool SuccIsHeader = LoopHeaders.count(SuccBB); dbgs() <<
 "  Not threading across " << (BBIsHeader ? "loop header BB '"
 : "block BB '") << BB->getName() << "' to dest "
 << (SuccIsHeader ? "loop header BB '" : "block BB '") <<
 SuccBB->getName() << "' - it might create an irreducible loop!\n"
; }; } } while (false)
        << "' to dest " << (SuccIsHeader ? "loop header BB '" : "block BB '")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { { bool BBIsHeader = LoopHeaders.count(BB
); bool SuccIsHeader = LoopHeaders.count(SuccBB); dbgs() <<
 "  Not threading across " << (BBIsHeader ? "loop header BB '"
 : "block BB '") << BB->getName() << "' to dest "
 << (SuccIsHeader ? "loop header BB '" : "block BB '") <<
 SuccBB->getName() << "' - it might create an irreducible loop!\n"
; }; } } while (false)
        << SuccBB->getName() << "' - it might create an irreducible loop!\n";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { { bool BBIsHeader = LoopHeaders.count(BB
); bool SuccIsHeader = LoopHeaders.count(SuccBB); dbgs() <<
 "  Not threading across " << (BBIsHeader ? "loop header BB '"
 : "block BB '") << BB->getName() << "' to dest "
 << (SuccIsHeader ? "loop header BB '" : "block BB '") <<
 SuccBB->getName() << "' - it might create an irreducible loop!\n"
; }; } } while (false)
  })do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { { bool BBIsHeader = LoopHeaders.count(BB
); bool SuccIsHeader = LoopHeaders.count(SuccBB); dbgs() <<
 "  Not threading across " << (BBIsHeader ? "loop header BB '"
 : "block BB '") << BB->getName() << "' to dest "
 << (SuccIsHeader ? "loop header BB '" : "block BB '") <<
 SuccBB->getName() << "' - it might create an irreducible loop!\n"
; }; } } while (false);
  return false;
}

unsigned JumpThreadCost =
    getJumpThreadDuplicationCost(BB, BB->getTerminator(), BBDupThreshold);
if (JumpThreadCost > BBDupThreshold) {
  LLVM_DEBUG(dbgs() << "  Not threading BB '" << BB->getName()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { dbgs() << "  Not threading BB '" <<
 BB->getName() << "' - Cost is too high: " << JumpThreadCost
 << "\n"; } } while (false)
                    << "' - Cost is too high: " << JumpThreadCost << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { dbgs() << "  Not threading BB '" <<
 BB->getName() << "' - Cost is too high: " << JumpThreadCost
 << "\n"; } } while (false);
  return false;
}

ThreadEdge(BB, PredBBs, SuccBB);
return true;
2315}

2317/// ThreadEdge - We have decided that it is safe and profitable to factor the
2318/// blocks in PredBBs to one predecessor, then thread an edge from it to SuccBB
2319/// across BB.  Transform the IR to reflect this change.
2320void JumpThreadingPass::ThreadEdge(BasicBlock *BB,
                                 const SmallVectorImpl<BasicBlock *> &PredBBs,
                                 BasicBlock *SuccBB) {
assert(SuccBB != BB && "Don't create an infinite loop")((SuccBB != BB && "Don't create an infinite loop") ? static_cast
<void> (0) : __assert_fail ("SuccBB != BB && \"Don't create an infinite loop\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/JumpThreading.cpp"
, 2323, __PRETTY_FUNCTION__));

assert(!LoopHeaders.count(BB) && !LoopHeaders.count(SuccBB) &&((!LoopHeaders.count(BB) && !LoopHeaders.count(SuccBB
) && "Don't thread across loop headers") ? static_cast
<void> (0) : __assert_fail ("!LoopHeaders.count(BB) && !LoopHeaders.count(SuccBB) && \"Don't thread across loop headers\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/JumpThreading.cpp"
, 2326, __PRETTY_FUNCTION__))
       "Don't thread across loop headers")((!LoopHeaders.count(BB) && !LoopHeaders.count(SuccBB
) && "Don't thread across loop headers") ? static_cast
<void> (0) : __assert_fail ("!LoopHeaders.count(BB) && !LoopHeaders.count(SuccBB) && \"Don't thread across loop headers\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/JumpThreading.cpp"
, 2326, __PRETTY_FUNCTION__));

// And finally, do it!  Start by factoring the predecessors if needed.
BasicBlock *PredBB;
if (PredBBs.size() == 1)
  PredBB = PredBBs[0];
else {
  LLVM_DEBUG(dbgs() << "  Factoring out " << PredBBs.size()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { dbgs() << "  Factoring out " <<
 PredBBs.size() << " common predecessors.\n"; } } while
 (false)
                    << " common predecessors.\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { dbgs() << "  Factoring out " <<
 PredBBs.size() << " common predecessors.\n"; } } while
 (false);
  PredBB = SplitBlockPreds(BB, PredBBs, ".thr_comm");
}

// And finally, do it!
LLVM_DEBUG(dbgs() << "  Threading edge from '" << PredBB->getName()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { dbgs() << "  Threading edge from '"
 << PredBB->getName() << "' to '" << SuccBB
->getName() << ", across block:\n    " << *BB <<
 "\n"; } } while (false)
                  << "' to '" << SuccBB->getName()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { dbgs() << "  Threading edge from '"
 << PredBB->getName() << "' to '" << SuccBB
->getName() << ", across block:\n    " << *BB <<
 "\n"; } } while (false)
                  << ", across block:\n    " << *BB << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { dbgs() << "  Threading edge from '"
 << PredBB->getName() << "' to '" << SuccBB
->getName() << ", across block:\n    " << *BB <<
 "\n"; } } while (false);

LVI->threadEdge(PredBB, BB, SuccBB);

BasicBlock *NewBB = BasicBlock::Create(BB->getContext(),
                                       BB->getName()+".thread",
                                       BB->getParent(), BB);
NewBB->moveAfter(PredBB);

// Set the block frequency of NewBB.
if (HasProfileData) {
  auto NewBBFreq =
      BFI->getBlockFreq(PredBB) * BPI->getEdgeProbability(PredBB, BB);
  BFI->setBlockFreq(NewBB, NewBBFreq.getFrequency());
}

// Copy all the instructions from BB to NewBB except the terminator.
DenseMap<Instruction *, Value *> ValueMapping =
    CloneInstructions(BB->begin(), std::prev(BB->end()), NewBB, PredBB);

// We didn't copy the terminator from BB over to NewBB, because there is now
// an unconditional jump to SuccBB.  Insert the unconditional jump.
BranchInst *NewBI = BranchInst::Create(SuccBB, NewBB);
NewBI->setDebugLoc(BB->getTerminator()->getDebugLoc());

// Check to see if SuccBB has PHI nodes. If so, we need to add entries to the
// PHI nodes for NewBB now.
AddPHINodeEntriesForMappedBlock(SuccBB, BB, NewBB, ValueMapping);

// Update the terminator of PredBB to jump to NewBB instead of BB.  This
// eliminates predecessors from BB, which requires us to simplify any PHI
// nodes in BB.
Instruction *PredTerm = PredBB->getTerminator();
for (unsigned i = 0, e = PredTerm->getNumSuccessors(); i != e; ++i)
  if (PredTerm->getSuccessor(i) == BB) {
    BB->removePredecessor(PredBB, true);
    PredTerm->setSuccessor(i, NewBB);
  }

// Enqueue required DT updates.
DTU->applyUpdatesPermissive({{DominatorTree::Insert, NewBB, SuccBB},
                             {DominatorTree::Insert, PredBB, NewBB},
                             {DominatorTree::Delete, PredBB, BB}});

UpdateSSA(BB, NewBB, ValueMapping);

// At this point, the IR is fully up to date and consistent.  Do a quick scan
// over the new instructions and zap any that are constants or dead.  This
// frequently happens because of phi translation.
SimplifyInstructionsInBlock(NewBB, TLI);

// Update the edge weight from BB to SuccBB, which should be less than before.
UpdateBlockFreqAndEdgeWeight(PredBB, BB, NewBB, SuccBB);

// Threaded an edge!
++NumThreads;
2397}

2399/// Create a new basic block that will be the predecessor of BB and successor of
2400/// all blocks in Preds. When profile data is available, update the frequency of
2401/// this new block.
2402BasicBlock *JumpThreadingPass::SplitBlockPreds(BasicBlock *BB,
                                             ArrayRef<BasicBlock *> Preds,
                                             const char *Suffix) {
SmallVector<BasicBlock *, 2> NewBBs;

// Collect the frequencies of all predecessors of BB, which will be used to
// update the edge weight of the result of splitting predecessors.
DenseMap<BasicBlock *, BlockFrequency> FreqMap;
if (HasProfileData)
  for (auto Pred : Preds)
    FreqMap.insert(std::make_pair(
        Pred, BFI->getBlockFreq(Pred) * BPI->getEdgeProbability(Pred, BB)));

// In the case when BB is a LandingPad block we create 2 new predecessors
// instead of just one.
if (BB->isLandingPad()) {
  std::string NewName = std::string(Suffix) + ".split-lp";
  SplitLandingPadPredecessors(BB, Preds, Suffix, NewName.c_str(), NewBBs);
} else {
  NewBBs.push_back(SplitBlockPredecessors(BB, Preds, Suffix));
}

std::vector<DominatorTree::UpdateType> Updates;
Updates.reserve((2 * Preds.size()) + NewBBs.size());
for (auto NewBB : NewBBs) {
  BlockFrequency NewBBFreq(0);
  Updates.push_back({DominatorTree::Insert, NewBB, BB});
  for (auto Pred : predecessors(NewBB)) {
    Updates.push_back({DominatorTree::Delete, Pred, BB});
    Updates.push_back({DominatorTree::Insert, Pred, NewBB});
    if (HasProfileData) // Update frequencies between Pred -> NewBB.
      NewBBFreq += FreqMap.lookup(Pred);
  }
  if (HasProfileData) // Apply the summed frequency to NewBB.
    BFI->setBlockFreq(NewBB, NewBBFreq.getFrequency());
}

DTU->applyUpdatesPermissive(Updates);
return NewBBs[0];
2441}

2443bool JumpThreadingPass::doesBlockHaveProfileData(BasicBlock *BB) {
const Instruction *TI = BB->getTerminator();
assert(TI->getNumSuccessors() > 1 && "not a split")((TI->getNumSuccessors() > 1 && "not a split") ?
 static_cast<void> (0) : __assert_fail ("TI->getNumSuccessors() > 1 && \"not a split\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/JumpThreading.cpp"
, 2445, __PRETTY_FUNCTION__));

MDNode *WeightsNode = TI->getMetadata(LLVMContext::MD_prof);
if (!WeightsNode)
  return false;

MDString *MDName = cast<MDString>(WeightsNode->getOperand(0));
if (MDName->getString() != "branch_weights")
  return false;

// Ensure there are weights for all of the successors. Note that the first
// operand to the metadata node is a name, not a weight.
return WeightsNode->getNumOperands() == TI->getNumSuccessors() + 1;
2458}

2460/// Update the block frequency of BB and branch weight and the metadata on the
2461/// edge BB->SuccBB. This is done by scaling the weight of BB->SuccBB by 1 -
2462/// Freq(PredBB->BB) / Freq(BB->SuccBB).
2463void JumpThreadingPass::UpdateBlockFreqAndEdgeWeight(BasicBlock *PredBB,
                                                   BasicBlock *BB,
                                                   BasicBlock *NewBB,
                                                   BasicBlock *SuccBB) {
if (!HasProfileData)
  return;

assert(BFI && BPI && "BFI & BPI should have been created here")((BFI && BPI && "BFI & BPI should have been created here"
) ? static_cast<void> (0) : __assert_fail ("BFI && BPI && \"BFI & BPI should have been created here\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/JumpThreading.cpp"
, 2470, __PRETTY_FUNCTION__));

// As the edge from PredBB to BB is deleted, we have to update the block
// frequency of BB.
auto BBOrigFreq = BFI->getBlockFreq(BB);
auto NewBBFreq = BFI->getBlockFreq(NewBB);
auto BB2SuccBBFreq = BBOrigFreq * BPI->getEdgeProbability(BB, SuccBB);
auto BBNewFreq = BBOrigFreq - NewBBFreq;
BFI->setBlockFreq(BB, BBNewFreq.getFrequency());

// Collect updated outgoing edges' frequencies from BB and use them to update
// edge probabilities.
SmallVector<uint64_t, 4> BBSuccFreq;
for (BasicBlock *Succ : successors(BB)) {
  auto SuccFreq = (Succ == SuccBB)
                      ? BB2SuccBBFreq - NewBBFreq
                      : BBOrigFreq * BPI->getEdgeProbability(BB, Succ);
  BBSuccFreq.push_back(SuccFreq.getFrequency());
}

uint64_t MaxBBSuccFreq =
    *std::max_element(BBSuccFreq.begin(), BBSuccFreq.end());

SmallVector<BranchProbability, 4> BBSuccProbs;
if (MaxBBSuccFreq == 0)
  BBSuccProbs.assign(BBSuccFreq.size(),
                     {1, static_cast<unsigned>(BBSuccFreq.size())});
else {
  for (uint64_t Freq : BBSuccFreq)
    BBSuccProbs.push_back(
        BranchProbability::getBranchProbability(Freq, MaxBBSuccFreq));
  // Normalize edge probabilities so that they sum up to one.
  BranchProbability::normalizeProbabilities(BBSuccProbs.begin(),
                                            BBSuccProbs.end());
}

// Update edge probabilities in BPI.
BPI->setEdgeProbability(BB, BBSuccProbs);

// Update the profile metadata as well.
//
// Don't do this if the profile of the transformed blocks was statically
// estimated.  (This could occur despite the function having an entry
// frequency in completely cold parts of the CFG.)
//
// In this case we don't want to suggest to subsequent passes that the
// calculated weights are fully consistent.  Consider this graph:
//
//                 check_1
//             50% /  |
//             eq_1   | 50%
//                 \  |
//                 check_2
//             50% /  |
//             eq_2   | 50%
//                 \  |
//                 check_3
//             50% /  |
//             eq_3   | 50%
//                 \  |
//
// Assuming the blocks check_* all compare the same value against 1, 2 and 3,
// the overall probabilities are inconsistent; the total probability that the
// value is either 1, 2 or 3 is 150%.
//
// As a consequence if we thread eq_1 -> check_2 to check_3, check_2->check_3
// becomes 0%.  This is even worse if the edge whose probability becomes 0% is
// the loop exit edge.  Then based solely on static estimation we would assume
// the loop was extremely hot.
//
// FIXME this locally as well so that BPI and BFI are consistent as well.  We
// shouldn't make edges extremely likely or unlikely based solely on static
// estimation.
if (BBSuccProbs.size() >= 2 && doesBlockHaveProfileData(BB)) {
  SmallVector<uint32_t, 4> Weights;
  for (auto Prob : BBSuccProbs)
    Weights.push_back(Prob.getNumerator());

  auto TI = BB->getTerminator();
  TI->setMetadata(
      LLVMContext::MD_prof,
      MDBuilder(TI->getParent()->getContext()).createBranchWeights(Weights));
}
2553}

2555/// DuplicateCondBranchOnPHIIntoPred - PredBB contains an unconditional branch
2556/// to BB which contains an i1 PHI node and a conditional branch on that PHI.
2557/// If we can duplicate the contents of BB up into PredBB do so now, this
2558/// improves the odds that the branch will be on an analyzable instruction like
2559/// a compare.
2560bool JumpThreadingPass::DuplicateCondBranchOnPHIIntoPred(
  BasicBlock *BB, const SmallVectorImpl<BasicBlock *> &PredBBs) {
assert(!PredBBs.empty() && "Can't handle an empty set")((!PredBBs.empty() && "Can't handle an empty set") ? static_cast
<void> (0) : __assert_fail ("!PredBBs.empty() && \"Can't handle an empty set\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/JumpThreading.cpp"
, 2562, __PRETTY_FUNCTION__));

// If BB is a loop header, then duplicating this block outside the loop would
// cause us to transform this into an irreducible loop, don't do this.
// See the comments above FindLoopHeaders for justifications and caveats.
if (LoopHeaders.count(BB)) {
  LLVM_DEBUG(dbgs() << "  Not duplicating loop header '" << BB->getName()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { dbgs() << "  Not duplicating loop header '"
 << BB->getName() << "' into predecessor block '"
 << PredBBs[0]->getName() << "' - it might create an irreducible loop!\n"
; } } while (false)
                    << "' into predecessor block '" << PredBBs[0]->getName()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { dbgs() << "  Not duplicating loop header '"
 << BB->getName() << "' into predecessor block '"
 << PredBBs[0]->getName() << "' - it might create an irreducible loop!\n"
; } } while (false)
                    << "' - it might create an irreducible loop!\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { dbgs() << "  Not duplicating loop header '"
 << BB->getName() << "' into predecessor block '"
 << PredBBs[0]->getName() << "' - it might create an irreducible loop!\n"
; } } while (false);
  return false;
}

unsigned DuplicationCost =
    getJumpThreadDuplicationCost(BB, BB->getTerminator(), BBDupThreshold);
if (DuplicationCost > BBDupThreshold) {
  LLVM_DEBUG(dbgs() << "  Not duplicating BB '" << BB->getName()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { dbgs() << "  Not duplicating BB '"
 << BB->getName() << "' - Cost is too high: " <<
 DuplicationCost << "\n"; } } while (false)
                    << "' - Cost is too high: " << DuplicationCost << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { dbgs() << "  Not duplicating BB '"
 << BB->getName() << "' - Cost is too high: " <<
 DuplicationCost << "\n"; } } while (false);
  return false;
}

// And finally, do it!  Start by factoring the predecessors if needed.
std::vector<DominatorTree::UpdateType> Updates;
BasicBlock *PredBB;
if (PredBBs.size() == 1)
  PredBB = PredBBs[0];
else {
  LLVM_DEBUG(dbgs() << "  Factoring out " << PredBBs.size()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { dbgs() << "  Factoring out " <<
 PredBBs.size() << " common predecessors.\n"; } } while
 (false)
                    << " common predecessors.\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { dbgs() << "  Factoring out " <<
 PredBBs.size() << " common predecessors.\n"; } } while
 (false);
  PredBB = SplitBlockPreds(BB, PredBBs, ".thr_comm");
}
Updates.push_back({DominatorTree::Delete, PredBB, BB});

// Okay, we decided to do this!  Clone all the instructions in BB onto the end
// of PredBB.
LLVM_DEBUG(dbgs() << "  Duplicating block '" << BB->getName()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { dbgs() << "  Duplicating block '"
 << BB->getName() << "' into end of '" <<
 PredBB->getName() << "' to eliminate branch on phi.  Cost: "
 << DuplicationCost << " block is:" << *BB <<
 "\n"; } } while (false)
                  << "' into end of '" << PredBB->getName()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { dbgs() << "  Duplicating block '"
 << BB->getName() << "' into end of '" <<
 PredBB->getName() << "' to eliminate branch on phi.  Cost: "
 << DuplicationCost << " block is:" << *BB <<
 "\n"; } } while (false)
                  << "' to eliminate branch on phi.  Cost: "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { dbgs() << "  Duplicating block '"
 << BB->getName() << "' into end of '" <<
 PredBB->getName() << "' to eliminate branch on phi.  Cost: "
 << DuplicationCost << " block is:" << *BB <<
 "\n"; } } while (false)
                  << DuplicationCost << " block is:" << *BB << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { dbgs() << "  Duplicating block '"
 << BB->getName() << "' into end of '" <<
 PredBB->getName() << "' to eliminate branch on phi.  Cost: "
 << DuplicationCost << " block is:" << *BB <<
 "\n"; } } while (false);

// Unless PredBB ends with an unconditional branch, split the edge so that we
// can just clone the bits from BB into the end of the new PredBB.
BranchInst *OldPredBranch = dyn_cast<BranchInst>(PredBB->getTerminator());

if (!OldPredBranch || !OldPredBranch->isUnconditional()) {
  BasicBlock *OldPredBB = PredBB;
  PredBB = SplitEdge(OldPredBB, BB);
  Updates.push_back({DominatorTree::Insert, OldPredBB, PredBB});
  Updates.push_back({DominatorTree::Insert, PredBB, BB});
  Updates.push_back({DominatorTree::Delete, OldPredBB, BB});
  OldPredBranch = cast<BranchInst>(PredBB->getTerminator());
}

// We are going to have to map operands from the original BB block into the
// PredBB block.  Evaluate PHI nodes in BB.
DenseMap<Instruction*, Value*> ValueMapping;

BasicBlock::iterator BI = BB->begin();
for (; PHINode *PN = dyn_cast<PHINode>(BI); ++BI)
  ValueMapping[PN] = PN->getIncomingValueForBlock(PredBB);
// Clone the non-phi instructions of BB into PredBB, keeping track of the
// mapping and using it to remap operands in the cloned instructions.
for (; BI != BB->end(); ++BI) {
  Instruction *New = BI->clone();

  // Remap operands to patch up intra-block references.
  for (unsigned i = 0, e = New->getNumOperands(); i != e; ++i)
    if (Instruction *Inst = dyn_cast<Instruction>(New->getOperand(i))) {
      DenseMap<Instruction*, Value*>::iterator I = ValueMapping.find(Inst);
      if (I != ValueMapping.end())
        New->setOperand(i, I->second);
    }

  // If this instruction can be simplified after the operands are updated,
  // just use the simplified value instead.  This frequently happens due to
  // phi translation.
  if (Value *IV = SimplifyInstruction(
          New,
          {BB->getModule()->getDataLayout(), TLI, nullptr, nullptr, New})) {
    ValueMapping[&*BI] = IV;
    if (!New->mayHaveSideEffects()) {
      New->deleteValue();
      New = nullptr;
    }
  } else {
    ValueMapping[&*BI] = New;
  }
  if (New) {
    // Otherwise, insert the new instruction into the block.
    New->setName(BI->getName());
    PredBB->getInstList().insert(OldPredBranch->getIterator(), New);
    // Update Dominance from simplified New instruction operands.
    for (unsigned i = 0, e = New->getNumOperands(); i != e; ++i)
      if (BasicBlock *SuccBB = dyn_cast<BasicBlock>(New->getOperand(i)))
        Updates.push_back({DominatorTree::Insert, PredBB, SuccBB});
  }
}

// Check to see if the targets of the branch had PHI nodes. If so, we need to
// add entries to the PHI nodes for branch from PredBB now.
BranchInst *BBBranch = cast<BranchInst>(BB->getTerminator());
AddPHINodeEntriesForMappedBlock(BBBranch->getSuccessor(0), BB, PredBB,
                                ValueMapping);
AddPHINodeEntriesForMappedBlock(BBBranch->getSuccessor(1), BB, PredBB,
                                ValueMapping);

UpdateSSA(BB, PredBB, ValueMapping);

// PredBB no longer jumps to BB, remove entries in the PHI node for the edge
// that we nuked.
BB->removePredecessor(PredBB, true);

// Remove the unconditional branch at the end of the PredBB block.
OldPredBranch->eraseFromParent();
DTU->applyUpdatesPermissive(Updates);

++NumDupes;
return true;
2679}

2681// Pred is a predecessor of BB with an unconditional branch to BB. SI is
2682// a Select instruction in Pred. BB has other predecessors and SI is used in
2683// a PHI node in BB. SI has no other use.
2684// A new basic block, NewBB, is created and SI is converted to compare and 
2685// conditional branch. SI is erased from parent.
2686void JumpThreadingPass::UnfoldSelectInstr(BasicBlock *Pred, BasicBlock *BB,
                                        SelectInst *SI, PHINode *SIUse,
                                        unsigned Idx) {
// Expand the select.
//
// Pred --
//  |    v
//  |  NewBB
//  |    |
//  |-----
//  v
// BB
BranchInst *PredTerm = cast<BranchInst>(Pred->getTerminator());
BasicBlock *NewBB = BasicBlock::Create(BB->getContext(), "select.unfold",
                                       BB->getParent(), BB);
// Move the unconditional branch to NewBB.
PredTerm->removeFromParent();
NewBB->getInstList().insert(NewBB->end(), PredTerm);
// Create a conditional branch and update PHI nodes.
BranchInst::Create(NewBB, BB, SI->getCondition(), Pred);
SIUse->setIncomingValue(Idx, SI->getFalseValue());
SIUse->addIncoming(SI->getTrueValue(), NewBB);

// The select is now dead.
SI->eraseFromParent();
DTU->applyUpdatesPermissive({{DominatorTree::Insert, NewBB, BB},
                             {DominatorTree::Insert, Pred, NewBB}});

// Update any other PHI nodes in BB.
for (BasicBlock::iterator BI = BB->begin();
     PHINode *Phi = dyn_cast<PHINode>(BI); ++BI)
  if (Phi != SIUse)
    Phi->addIncoming(Phi->getIncomingValueForBlock(Pred), NewBB);
2719}

2721bool JumpThreadingPass::TryToUnfoldSelect(SwitchInst *SI, BasicBlock *BB) {
PHINode *CondPHI = dyn_cast<PHINode>(SI->getCondition());

if (!CondPHI || CondPHI->getParent() != BB)
  return false;

for (unsigned I = 0, E = CondPHI->getNumIncomingValues(); I != E; ++I) {
  BasicBlock *Pred = CondPHI->getIncomingBlock(I);
  SelectInst *PredSI = dyn_cast<SelectInst>(CondPHI->getIncomingValue(I));

  // The second and third condition can be potentially relaxed. Currently
  // the conditions help to simplify the code and allow us to reuse existing
  // code, developed for TryToUnfoldSelect(CmpInst *, BasicBlock *)
  if (!PredSI || PredSI->getParent() != Pred || !PredSI->hasOneUse())
    continue;

  BranchInst *PredTerm = dyn_cast<BranchInst>(Pred->getTerminator());
  if (!PredTerm || !PredTerm->isUnconditional())
    continue;

  UnfoldSelectInstr(Pred, BB, PredSI, CondPHI, I);
  return true;
}
return false;
2745}

2747/// TryToUnfoldSelect - Look for blocks of the form
2748/// bb1:
2749///   %a = select
2750///   br bb2
2751///
2752/// bb2:
2753///   %p = phi [%a, %bb1] ...
2754///   %c = icmp %p
2755///   br i1 %c
2756///
2757/// And expand the select into a branch structure if one of its arms allows %c
2758/// to be folded. This later enables threading from bb1 over bb2.
2759bool JumpThreadingPass::TryToUnfoldSelect(CmpInst *CondCmp, BasicBlock *BB) {
BranchInst *CondBr = dyn_cast<BranchInst>(BB->getTerminator());
PHINode *CondLHS = dyn_cast<PHINode>(CondCmp->getOperand(0));
Constant *CondRHS = cast<Constant>(CondCmp->getOperand(1));

if (!CondBr || !CondBr->isConditional() || !CondLHS ||
    CondLHS->getParent() != BB)
  return false;

for (unsigned I = 0, E = CondLHS->getNumIncomingValues(); I != E; ++I) {
  BasicBlock *Pred = CondLHS->getIncomingBlock(I);
  SelectInst *SI = dyn_cast<SelectInst>(CondLHS->getIncomingValue(I));

  // Look if one of the incoming values is a select in the corresponding
  // predecessor.
  if (!SI || SI->getParent() != Pred || !SI->hasOneUse())
    continue;

  BranchInst *PredTerm = dyn_cast<BranchInst>(Pred->getTerminator());
  if (!PredTerm || !PredTerm->isUnconditional())
    continue;

  // Now check if one of the select values would allow us to constant fold the
  // terminator in BB. We don't do the transform if both sides fold, those
  // cases will be threaded in any case.
  LazyValueInfo::Tristate LHSFolds =
      LVI->getPredicateOnEdge(CondCmp->getPredicate(), SI->getOperand(1),
                              CondRHS, Pred, BB, CondCmp);
  LazyValueInfo::Tristate RHSFolds =
      LVI->getPredicateOnEdge(CondCmp->getPredicate(), SI->getOperand(2),
                              CondRHS, Pred, BB, CondCmp);
  if ((LHSFolds != LazyValueInfo::Unknown ||
       RHSFolds != LazyValueInfo::Unknown) &&
      LHSFolds != RHSFolds) {
    UnfoldSelectInstr(Pred, BB, SI, CondLHS, I);
    return true;
  }
}
return false;
2798}

2800/// TryToUnfoldSelectInCurrBB - Look for PHI/Select or PHI/CMP/Select in the
2801/// same BB in the form
2802/// bb:
2803///   %p = phi [false, %bb1], [true, %bb2], [false, %bb3], [true, %bb4], ...
2804///   %s = select %p, trueval, falseval
2805///
2806/// or
2807///
2808/// bb:
2809///   %p = phi [0, %bb1], [1, %bb2], [0, %bb3], [1, %bb4], ...
2810///   %c = cmp %p, 0
2811///   %s = select %c, trueval, falseval
2812///
2813/// And expand the select into a branch structure. This later enables
2814/// jump-threading over bb in this pass.
2815///
2816/// Using the similar approach of SimplifyCFG::FoldCondBranchOnPHI(), unfold
2817/// select if the associated PHI has at least one constant.  If the unfolded
2818/// select is not jump-threaded, it will be folded again in the later
2819/// optimizations.
2820bool JumpThreadingPass::TryToUnfoldSelectInCurrBB(BasicBlock *BB) {
// This transform would reduce the quality of msan diagnostics.
// Disable this transform under MemorySanitizer.
if (BB->getParent()->hasFnAttribute(Attribute::SanitizeMemory))
  return false;

// If threading this would thread across a loop header, don't thread the edge.
// See the comments above FindLoopHeaders for justifications and caveats.
if (LoopHeaders.count(BB))
  return false;

for (BasicBlock::iterator BI = BB->begin();
     PHINode *PN = dyn_cast<PHINode>(BI); ++BI) {
  // Look for a Phi having at least one constant incoming value.
  if (llvm::all_of(PN->incoming_values(),
                   [](Value *V) { return !isa<ConstantInt>(V); }))
    continue;

  auto isUnfoldCandidate = [BB](SelectInst *SI, Value *V) {
    // Check if SI is in BB and use V as condition.
    if (SI->getParent() != BB)
      return false;
    Value *Cond = SI->getCondition();
    return (Cond && Cond == V && Cond->getType()->isIntegerTy(1));
  };

  SelectInst *SI = nullptr;
  for (Use &U : PN->uses()) {
    if (ICmpInst *Cmp = dyn_cast<ICmpInst>(U.getUser())) {
      // Look for a ICmp in BB that compares PN with a constant and is the
      // condition of a Select.
      if (Cmp->getParent() == BB && Cmp->hasOneUse() &&
          isa<ConstantInt>(Cmp->getOperand(1 - U.getOperandNo())))
        if (SelectInst *SelectI = dyn_cast<SelectInst>(Cmp->user_back()))
          if (isUnfoldCandidate(SelectI, Cmp->use_begin()->get())) {
            SI = SelectI;
            break;
          }
    } else if (SelectInst *SelectI = dyn_cast<SelectInst>(U.getUser())) {
      // Look for a Select in BB that uses PN as condition.
      if (isUnfoldCandidate(SelectI, U.get())) {
        SI = SelectI;
        break;
      }
    }
  }

  if (!SI)
    continue;
  // Expand the select.
  Value *Cond = SI->getCondition();
  if (InsertFreezeWhenUnfoldingSelect &&
      !isGuaranteedNotToBeUndefOrPoison(Cond, nullptr, SI,
                                        &DTU->getDomTree()))
    Cond = new FreezeInst(Cond, "cond.fr", SI);
  Instruction *Term = SplitBlockAndInsertIfThen(Cond, SI, false);
  BasicBlock *SplitBB = SI->getParent();
  BasicBlock *NewBB = Term->getParent();
  PHINode *NewPN = PHINode::Create(SI->getType(), 2, "", SI);
  NewPN->addIncoming(SI->getTrueValue(), Term->getParent());
  NewPN->addIncoming(SI->getFalseValue(), BB);
  SI->replaceAllUsesWith(NewPN);
  SI->eraseFromParent();
  // NewBB and SplitBB are newly created blocks which require insertion.
  std::vector<DominatorTree::UpdateType> Updates;
  Updates.reserve((2 * SplitBB->getTerminator()->getNumSuccessors()) + 3);
  Updates.push_back({DominatorTree::Insert, BB, SplitBB});
  Updates.push_back({DominatorTree::Insert, BB, NewBB});
  Updates.push_back({DominatorTree::Insert, NewBB, SplitBB});
  // BB's successors were moved to SplitBB, update DTU accordingly.
  for (auto *Succ : successors(SplitBB)) {
    Updates.push_back({DominatorTree::Delete, BB, Succ});
    Updates.push_back({DominatorTree::Insert, SplitBB, Succ});
  }
  DTU->applyUpdatesPermissive(Updates);
  return true;
}
return false;
2898}

2900/// Try to propagate a guard from the current BB into one of its predecessors
2901/// in case if another branch of execution implies that the condition of this
2902/// guard is always true. Currently we only process the simplest case that
2903/// looks like:
2904///
2905/// Start:
2906///   %cond = ...
2907///   br i1 %cond, label %T1, label %F1
2908/// T1:
2909///   br label %Merge
2910/// F1:
2911///   br label %Merge
2912/// Merge:
2913///   %condGuard = ...
2914///   call void(i1, ...) @llvm.experimental.guard( i1 %condGuard )[ "deopt"() ]
2915///
2916/// And cond either implies condGuard or !condGuard. In this case all the
2917/// instructions before the guard can be duplicated in both branches, and the
2918/// guard is then threaded to one of them.
2919bool JumpThreadingPass::ProcessGuards(BasicBlock *BB) {
using namespace PatternMatch;

// We only want to deal with two predecessors.
BasicBlock *Pred1, *Pred2;
auto PI = pred_begin(BB), PE = pred_end(BB);
if (PI == PE)
  return false;
Pred1 = *PI++;
if (PI == PE)
  return false;
Pred2 = *PI++;
if (PI != PE)
  return false;
if (Pred1 == Pred2)
  return false;

// Try to thread one of the guards of the block.
// TODO: Look up deeper than to immediate predecessor?
auto *Parent = Pred1->getSinglePredecessor();
if (!Parent || Parent != Pred2->getSinglePredecessor())
  return false;

if (auto *BI = dyn_cast<BranchInst>(Parent->getTerminator()))
  for (auto &I : *BB)
    if (isGuard(&I) && ThreadGuard(BB, cast<IntrinsicInst>(&I), BI))
      return true;

return false;
2948}

2950/// Try to propagate the guard from BB which is the lower block of a diamond
2951/// to one of its branches, in case if diamond's condition implies guard's
2952/// condition.
2953bool JumpThreadingPass::ThreadGuard(BasicBlock *BB, IntrinsicInst *Guard,
                                  BranchInst *BI) {
assert(BI->getNumSuccessors() == 2 && "Wrong number of successors?")((BI->getNumSuccessors() == 2 && "Wrong number of successors?"
) ? static_cast<void> (0) : __assert_fail ("BI->getNumSuccessors() == 2 && \"Wrong number of successors?\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/JumpThreading.cpp"
, 2955, __PRETTY_FUNCTION__));
assert(BI->isConditional() && "Unconditional branch has 2 successors?")((BI->isConditional() && "Unconditional branch has 2 successors?"
) ? static_cast<void> (0) : __assert_fail ("BI->isConditional() && \"Unconditional branch has 2 successors?\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/JumpThreading.cpp"
, 2956, __PRETTY_FUNCTION__));
Value *GuardCond = Guard->getArgOperand(0);
Value *BranchCond = BI->getCondition();
BasicBlock *TrueDest = BI->getSuccessor(0);
BasicBlock *FalseDest = BI->getSuccessor(1);

auto &DL = BB->getModule()->getDataLayout();
bool TrueDestIsSafe = false;
bool FalseDestIsSafe = false;

// True dest is safe if BranchCond => GuardCond.
auto Impl = isImpliedCondition(BranchCond, GuardCond, DL);
if (Impl && *Impl)
  TrueDestIsSafe = true;
else {
  // False dest is safe if !BranchCond => GuardCond.
  Impl = isImpliedCondition(BranchCond, GuardCond, DL, /* LHSIsTrue */ false);
  if (Impl && *Impl)
    FalseDestIsSafe = true;
}

if (!TrueDestIsSafe && !FalseDestIsSafe)
  return false;

BasicBlock *PredUnguardedBlock = TrueDestIsSafe ? TrueDest : FalseDest;
BasicBlock *PredGuardedBlock = FalseDestIsSafe ? TrueDest : FalseDest;

ValueToValueMapTy UnguardedMapping, GuardedMapping;
Instruction *AfterGuard = Guard->getNextNode();
unsigned Cost = getJumpThreadDuplicationCost(BB, AfterGuard, BBDupThreshold);
if (Cost > BBDupThreshold)
  return false;
// Duplicate all instructions before the guard and the guard itself to the
// branch where implication is not proved.
BasicBlock *GuardedBlock = DuplicateInstructionsInSplitBetween(
    BB, PredGuardedBlock, AfterGuard, GuardedMapping, *DTU);
assert(GuardedBlock && "Could not create the guarded block?")((GuardedBlock && "Could not create the guarded block?"
) ? static_cast<void> (0) : __assert_fail ("GuardedBlock && \"Could not create the guarded block?\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/JumpThreading.cpp"
, 2992, __PRETTY_FUNCTION__));
// Duplicate all instructions before the guard in the unguarded branch.
// Since we have successfully duplicated the guarded block and this block
// has fewer instructions, we expect it to succeed.
BasicBlock *UnguardedBlock = DuplicateInstructionsInSplitBetween(
    BB, PredUnguardedBlock, Guard, UnguardedMapping, *DTU);
assert(UnguardedBlock && "Could not create the unguarded block?")((UnguardedBlock && "Could not create the unguarded block?"
) ? static_cast<void> (0) : __assert_fail ("UnguardedBlock && \"Could not create the unguarded block?\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/JumpThreading.cpp"
, 2998, __PRETTY_FUNCTION__));
LLVM_DEBUG(dbgs() << "Moved guard " << *Guard << " to block "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { dbgs() << "Moved guard " <<
 *Guard << " to block " << GuardedBlock->getName
() << "\n"; } } while (false)
                  << GuardedBlock->getName() << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("jump-threading")) { dbgs() << "Moved guard " <<
 *Guard << " to block " << GuardedBlock->getName
() << "\n"; } } while (false);
// Some instructions before the guard may still have uses. For them, we need
// to create Phi nodes merging their copies in both guarded and unguarded
// branches. Those instructions that have no uses can be just removed.
SmallVector<Instruction *, 4> ToRemove;
for (auto BI = BB->begin(); &*BI != AfterGuard; ++BI)
  if (!isa<PHINode>(&*BI))
    ToRemove.push_back(&*BI);

Instruction *InsertionPoint = &*BB->getFirstInsertionPt();
assert(InsertionPoint && "Empty block?")((InsertionPoint && "Empty block?") ? static_cast<
void> (0) : __assert_fail ("InsertionPoint && \"Empty block?\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/lib/Transforms/Scalar/JumpThreading.cpp"
, 3010, __PRETTY_FUNCTION__));
// Substitute with Phis & remove.
for (auto *Inst : reverse(ToRemove)) {
  if (!Inst->use_empty()) {
    PHINode *NewPN = PHINode::Create(Inst->getType(), 2);
    NewPN->addIncoming(UnguardedMapping[Inst], UnguardedBlock);
    NewPN->addIncoming(GuardedMapping[Inst], GuardedBlock);
    NewPN->insertBefore(InsertionPoint);
    Inst->replaceAllUsesWith(NewPN);
  }
  Inst->eraseFromParent();
}
return true;
3023}

←

/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 ||
2
←
Assuming the condition is true→
4
←
Returning the value 1, which participates in a condition later→
          getOrdering() == AtomicOrdering::Unordered) &&
         !isVolatile();
3
←
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/ADT/ilist_iterator.h

→

1//===- llvm/ADT/ilist_iterator.h - Intrusive List Iterator ------*- 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//===----------------------------------------------------------------------===//

9#ifndef LLVM_ADT_ILIST_ITERATOR_H
10#define LLVM_ADT_ILIST_ITERATOR_H

12#include "llvm/ADT/ilist_node.h"
13#include <cassert>
14#include <cstddef>
15#include <iterator>
16#include <type_traits>

18namespace llvm {

20namespace ilist_detail {

22/// Find const-correct node types.
23template <class OptionsT, bool IsConst> struct IteratorTraits;
24template <class OptionsT> struct IteratorTraits<OptionsT, false> {
using value_type = typename OptionsT::value_type;
using pointer = typename OptionsT::pointer;
using reference = typename OptionsT::reference;
using node_pointer = ilist_node_impl<OptionsT> *;
using node_reference = ilist_node_impl<OptionsT> &;
30};
31template <class OptionsT> struct IteratorTraits<OptionsT, true> {
using value_type = const typename OptionsT::value_type;
using pointer = typename OptionsT::const_pointer;
using reference = typename OptionsT::const_reference;
using node_pointer = const ilist_node_impl<OptionsT> *;
using node_reference = const ilist_node_impl<OptionsT> &;
37};

39template <bool IsReverse> struct IteratorHelper;
40template <> struct IteratorHelper<false> : ilist_detail::NodeAccess {
using Access = ilist_detail::NodeAccess;

template <class T> static void increment(T *&I) { I = Access::getNext(*I); }
template <class T> static void decrement(T *&I) { I = Access::getPrev(*I); }
45};
46template <> struct IteratorHelper<true> : ilist_detail::NodeAccess {
using Access = ilist_detail::NodeAccess;

template <class T> static void increment(T *&I) { I = Access::getPrev(*I); }
template <class T> static void decrement(T *&I) { I = Access::getNext(*I); }
51};

53} // end namespace ilist_detail

55/// Iterator for intrusive lists  based on ilist_node.
56template <class OptionsT, bool IsReverse, bool IsConst>
57class ilist_iterator : ilist_detail::SpecificNodeAccess<OptionsT> {
friend ilist_iterator<OptionsT, IsReverse, !IsConst>;
friend ilist_iterator<OptionsT, !IsReverse, IsConst>;
friend ilist_iterator<OptionsT, !IsReverse, !IsConst>;

using Traits = ilist_detail::IteratorTraits<OptionsT, IsConst>;
using Access = ilist_detail::SpecificNodeAccess<OptionsT>;

65public:
using value_type = typename Traits::value_type;
using pointer = typename Traits::pointer;
using reference = typename Traits::reference;
using difference_type = ptrdiff_t;
using iterator_category = std::bidirectional_iterator_tag;
using const_pointer = typename OptionsT::const_pointer;
using const_reference = typename OptionsT::const_reference;

74private:
using node_pointer = typename Traits::node_pointer;
using node_reference = typename Traits::node_reference;

node_pointer NodePtr = nullptr;

80public:
/// Create from an ilist_node.
explicit ilist_iterator(node_reference N) : NodePtr(&N) {}

explicit ilist_iterator(pointer NP) : NodePtr(Access::getNodePtr(NP)) {}
explicit ilist_iterator(reference NR) : NodePtr(Access::getNodePtr(&NR)) {}
ilist_iterator() = default;

// This is templated so that we can allow constructing a const iterator from
// a nonconst iterator...
template <bool RHSIsConst>
ilist_iterator(const ilist_iterator<OptionsT, IsReverse, RHSIsConst> &RHS,
               std::enable_if_t<IsConst || !RHSIsConst, void *> = nullptr)
    : NodePtr(RHS.NodePtr) {}

// This is templated so that we can allow assigning to a const iterator from
// a nonconst iterator...
template <bool RHSIsConst>
std::enable_if_t<IsConst || !RHSIsConst, ilist_iterator &>
operator=(const ilist_iterator<OptionsT, IsReverse, RHSIsConst> &RHS) {
  NodePtr = RHS.NodePtr;
  return *this;
}

/// Explicit conversion between forward/reverse iterators.
///
/// Translate between forward and reverse iterators without changing range
/// boundaries.  The resulting iterator will dereference (and have a handle)
/// to the previous node, which is somewhat unexpected; but converting the
/// two endpoints in a range will give the same range in reverse.
///
/// This matches std::reverse_iterator conversions.
explicit ilist_iterator(
    const ilist_iterator<OptionsT, !IsReverse, IsConst> &RHS)
    : ilist_iterator(++RHS.getReverse()) {}

/// Get a reverse iterator to the same node.
///
/// Gives a reverse iterator that will dereference (and have a handle) to the
/// same node.  Converting the endpoint iterators in a range will give a
/// different range; for range operations, use the explicit conversions.
ilist_iterator<OptionsT, !IsReverse, IsConst> getReverse() const {
  if (NodePtr)
    return ilist_iterator<OptionsT, !IsReverse, IsConst>(*NodePtr);
  return ilist_iterator<OptionsT, !IsReverse, IsConst>();
}

/// Const-cast.
ilist_iterator<OptionsT, IsReverse, false> getNonConst() const {
  if (NodePtr)
    return ilist_iterator<OptionsT, IsReverse, false>(
        const_cast<typename ilist_iterator<OptionsT, IsReverse,
                                           false>::node_reference>(*NodePtr));
  return ilist_iterator<OptionsT, IsReverse, false>();
}

// Accessors...
reference operator*() const {
  assert(!NodePtr->isKnownSentinel())((!NodePtr->isKnownSentinel()) ? static_cast<void> (
0) : __assert_fail ("!NodePtr->isKnownSentinel()", "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/ADT/ilist_iterator.h"
, 138, __PRETTY_FUNCTION__));
  return *Access::getValuePtr(NodePtr);
}
pointer operator->() const { return &operator*(); }

// Comparison operators
friend bool operator==(const ilist_iterator &LHS, const ilist_iterator &RHS) {
  return LHS.NodePtr == RHS.NodePtr;
}
friend bool operator!=(const ilist_iterator &LHS, const ilist_iterator &RHS) {
  return LHS.NodePtr != RHS.NodePtr;
19
←
Assuming 'LHS.NodePtr' is equal to 'RHS.NodePtr'→
20
←
Returning zero, which participates in a condition later→
}

// Increment and decrement operators...
ilist_iterator &operator--() {
  NodePtr = IsReverse ? NodePtr->getNext() : NodePtr->getPrev();
  return *this;
}
ilist_iterator &operator++() {
  NodePtr = IsReverse ? NodePtr->getPrev() : NodePtr->getNext();
  return *this;
}
ilist_iterator operator--(int) {
  ilist_iterator tmp = *this;
  --*this;
  return tmp;
}
ilist_iterator operator++(int) {
  ilist_iterator tmp = *this;
  ++*this;
  return tmp;
}

/// Get the underlying ilist_node.
node_pointer getNodePtr() const { return static_cast<node_pointer>(NodePtr); }

/// Check for end.  Only valid if ilist_sentinel_tracking<true>.
bool isEnd() const { return NodePtr ? NodePtr->isSentinel() : false; }
176};

178template <typename From> struct simplify_type;

180/// Allow ilist_iterators to convert into pointers to a node automatically when
181/// used by the dyn_cast, cast, isa mechanisms...
182///
183/// FIXME: remove this, since there is no implicit conversion to NodeTy.
184template <class OptionsT, bool IsConst>
185struct simplify_type<ilist_iterator<OptionsT, false, IsConst>> {
using iterator = ilist_iterator<OptionsT, false, IsConst>;
using SimpleType = typename iterator::pointer;

static SimpleType getSimplifiedValue(const iterator &Node) { return &*Node; }
190};
191template <class OptionsT, bool IsConst>
192struct simplify_type<const ilist_iterator<OptionsT, false, IsConst>>
  : simplify_type<ilist_iterator<OptionsT, false, IsConst>> {};

195} // end namespace llvm

197#endif // LLVM_ADT_ILIST_ITERATOR_H

←

/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/ADT/SmallVector.h

1//===- llvm/ADT/SmallVector.h - 'Normally small' vectors --------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file defines the SmallVector class.
10//
11//===----------------------------------------------------------------------===//

13#ifndef LLVM_ADT_SMALLVECTOR_H
14#define LLVM_ADT_SMALLVECTOR_H

16#include "llvm/ADT/iterator_range.h"
17#include "llvm/Support/Compiler.h"
18#include "llvm/Support/ErrorHandling.h"
19#include "llvm/Support/MathExtras.h"
20#include "llvm/Support/MemAlloc.h"
21#include "llvm/Support/type_traits.h"
22#include <algorithm>
23#include <cassert>
24#include <cstddef>
25#include <cstdlib>
26#include <cstring>
27#include <initializer_list>
28#include <iterator>
29#include <limits>
30#include <memory>
31#include <new>
32#include <type_traits>
33#include <utility>

35namespace llvm {

37/// This is all the stuff common to all SmallVectors.
38///
39/// The template parameter specifies the type which should be used to hold the
40/// Size and Capacity of the SmallVector, so it can be adjusted.
41/// Using 32 bit size is desirable to shrink the size of the SmallVector.
42/// Using 64 bit size is desirable for cases like SmallVector<char>, where a
43/// 32 bit size would limit the vector to ~4GB. SmallVectors are used for
44/// buffering bitcode output - which can exceed 4GB.
45template <class Size_T> class SmallVectorBase {
46protected:
void *BeginX;
Size_T Size = 0, Capacity;

/// The maximum value of the Size_T used.
static constexpr size_t SizeTypeMax() {
  return std::numeric_limits<Size_T>::max();
}

SmallVectorBase() = delete;
SmallVectorBase(void *FirstEl, size_t TotalCapacity)
    : BeginX(FirstEl), Capacity(TotalCapacity) {}

/// This is an implementation of the grow() method which only works
/// on POD-like data types and is out of line to reduce code duplication.
/// This function will report a fatal error if it cannot increase capacity.
void grow_pod(void *FirstEl, size_t MinSize, size_t TSize);

/// Report that MinSize doesn't fit into this vector's size type. Throws
/// std::length_error or calls report_fatal_error.
LLVM_ATTRIBUTE_NORETURN__attribute__((noreturn)) static void report_size_overflow(size_t MinSize);
/// Report that this vector is already at maximum capacity. Throws
/// std::length_error or calls report_fatal_error.
LLVM_ATTRIBUTE_NORETURN__attribute__((noreturn)) static void report_at_maximum_capacity();

71public:
size_t size() const { return Size; }
size_t capacity() const { return Capacity; }

LLVM_NODISCARD[[clang::warn_unused_result]] bool empty() const { return !Size; }
25
←
Assuming field 'Size' is not equal to 0, which participates in a condition later→
26
←
Returning zero, which participates in a condition later→

/// Set the array size to \p N, which the current array must have enough
/// capacity for.
///
/// This does not construct or destroy any elements in the vector.
///
/// Clients can use this in conjunction with capacity() to write past the end
/// of the buffer when they know that more elements are available, and only
/// update the size later. This avoids the cost of value initializing elements
/// which will only be overwritten.
void set_size(size_t N) {
  assert(N <= capacity())((N <= capacity()) ? static_cast<void> (0) : __assert_fail
 ("N <= capacity()", "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/ADT/SmallVector.h"
, 87, __PRETTY_FUNCTION__));
  Size = N;
}
90};

92template <class T>
93using SmallVectorSizeType =
  typename std::conditional<sizeof(T) < 4 && sizeof(void *) >= 8, uint64_t,
                            uint32_t>::type;

97/// Figure out the offset of the first element.
98template <class T, typename = void> struct SmallVectorAlignmentAndSize {
alignas(SmallVectorBase<SmallVectorSizeType<T>>) char Base[sizeof(
    SmallVectorBase<SmallVectorSizeType<T>>)];
alignas(T) char FirstEl[sizeof(T)];
102};

104/// This is the part of SmallVectorTemplateBase which does not depend on whether
105/// the type T is a POD. The extra dummy template argument is used by ArrayRef
106/// to avoid unnecessarily requiring T to be complete.
107template <typename T, typename = void>
108class SmallVectorTemplateCommon
  : public SmallVectorBase<SmallVectorSizeType<T>> {
using Base = SmallVectorBase<SmallVectorSizeType<T>>;

/// Find the address of the first element.  For this pointer math to be valid
/// with small-size of 0 for T with lots of alignment, it's important that
/// SmallVectorStorage is properly-aligned even for small-size of 0.
void *getFirstEl() const {
  return const_cast<void *>(reinterpret_cast<const void *>(
      reinterpret_cast<const char *>(this) +
      offsetof(SmallVectorAlignmentAndSize<T>, FirstEl)__builtin_offsetof(SmallVectorAlignmentAndSize<T>, FirstEl
)));
}
// Space after 'FirstEl' is clobbered, do not add any instance vars after it.

122protected:
SmallVectorTemplateCommon(size_t Size) : Base(getFirstEl(), Size) {}

void grow_pod(size_t MinSize, size_t TSize) {
  Base::grow_pod(getFirstEl(), MinSize, TSize);
}

/// Return true if this is a smallvector which has not had dynamic
/// memory allocated for it.
bool isSmall() const { return this->BeginX == getFirstEl(); }

/// Put this vector in a state of being small.
void resetToSmall() {
  this->BeginX = getFirstEl();
  this->Size = this->Capacity = 0; // FIXME: Setting Capacity to 0 is suspect.
}

139public:
using size_type = size_t;
using difference_type = ptrdiff_t;
using value_type = T;
using iterator = T *;
using const_iterator = const T *;

using const_reverse_iterator = std::reverse_iterator<const_iterator>;
using reverse_iterator = std::reverse_iterator<iterator>;

using reference = T &;
using const_reference = const T &;
using pointer = T *;
using const_pointer = const T *;

using Base::capacity;
using Base::empty;
using Base::size;

// forward iterator creation methods.
iterator begin() { return (iterator)this->BeginX; }
const_iterator begin() const { return (const_iterator)this->BeginX; }
iterator end() { return begin() + size(); }
const_iterator end() const { return begin() + size(); }

// reverse iterator creation methods.
reverse_iterator rbegin()            { return reverse_iterator(end()); }
const_reverse_iterator rbegin() const{ return const_reverse_iterator(end()); }
reverse_iterator rend()              { return reverse_iterator(begin()); }
const_reverse_iterator rend() const { return const_reverse_iterator(begin());}

size_type size_in_bytes() const { return size() * sizeof(T); }
size_type max_size() const {
  return std::min(this->SizeTypeMax(), size_type(-1) / sizeof(T));
}

size_t capacity_in_bytes() const { return capacity() * sizeof(T); }

/// Return a pointer to the vector's buffer, even if empty().
pointer data() { return pointer(begin()); }
/// Return a pointer to the vector's buffer, even if empty().
const_pointer data() const { return const_pointer(begin()); }

reference operator[](size_type idx) {
  assert(idx < size())((idx < size()) ? static_cast<void> (0) : __assert_fail
 ("idx < size()", "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/ADT/SmallVector.h"
, 183, __PRETTY_FUNCTION__));
  return begin()[idx];
}
const_reference operator[](size_type idx) const {
  assert(idx < size())((idx < size()) ? static_cast<void> (0) : __assert_fail
 ("idx < size()", "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/ADT/SmallVector.h"
, 187, __PRETTY_FUNCTION__));
  return begin()[idx];
}

reference front() {
  assert(!empty())((!empty()) ? static_cast<void> (0) : __assert_fail ("!empty()"
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/ADT/SmallVector.h"
, 192, __PRETTY_FUNCTION__));
  return begin()[0];
}
const_reference front() const {
  assert(!empty())((!empty()) ? static_cast<void> (0) : __assert_fail ("!empty()"
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/ADT/SmallVector.h"
, 196, __PRETTY_FUNCTION__));
  return begin()[0];
}

reference back() {
  assert(!empty())((!empty()) ? static_cast<void> (0) : __assert_fail ("!empty()"
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/ADT/SmallVector.h"
, 201, __PRETTY_FUNCTION__));
  return end()[-1];
}
const_reference back() const {
  assert(!empty())((!empty()) ? static_cast<void> (0) : __assert_fail ("!empty()"
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/ADT/SmallVector.h"
, 205, __PRETTY_FUNCTION__));
  return end()[-1];
}
208};

210/// SmallVectorTemplateBase<TriviallyCopyable = false> - This is where we put
211/// method implementations that are designed to work with non-trivial T's.
212///
213/// We approximate is_trivially_copyable with trivial move/copy construction and
214/// trivial destruction. While the standard doesn't specify that you're allowed
215/// copy these types with memcpy, there is no way for the type to observe this.
216/// This catches the important case of std::pair<POD, POD>, which is not
217/// trivially assignable.
218template <typename T, bool = (is_trivially_copy_constructible<T>::value) &&
                           (is_trivially_move_constructible<T>::value) &&
                           std::is_trivially_destructible<T>::value>
221class SmallVectorTemplateBase : public SmallVectorTemplateCommon<T> {
222protected:
SmallVectorTemplateBase(size_t Size) : SmallVectorTemplateCommon<T>(Size) {}

static void destroy_range(T *S, T *E) {
  while (S != E) {
    --E;
    E->~T();
  }
}

/// Move the range [I, E) into the uninitialized memory starting with "Dest",
/// constructing elements as needed.
template<typename It1, typename It2>
static void uninitialized_move(It1 I, It1 E, It2 Dest) {
  std::uninitialized_copy(std::make_move_iterator(I),
                          std::make_move_iterator(E), Dest);
}

/// Copy the range [I, E) onto the uninitialized memory starting with "Dest",
/// constructing elements as needed.
template<typename It1, typename It2>
static void uninitialized_copy(It1 I, It1 E, It2 Dest) {
  std::uninitialized_copy(I, E, Dest);
}

/// Grow the allocated memory (without initializing new elements), doubling
/// the size of the allocated memory. Guarantees space for at least one more
/// element, or MinSize more elements if specified.
void grow(size_t MinSize = 0);

252public:
void push_back(const T &Elt) {
  if (LLVM_UNLIKELY(this->size() >= this->capacity())__builtin_expect((bool)(this->size() >= this->capacity
()), false))
    this->grow();
  ::new ((void*) this->end()) T(Elt);
  this->set_size(this->size() + 1);
}

void push_back(T &&Elt) {
  if (LLVM_UNLIKELY(this->size() >= this->capacity())__builtin_expect((bool)(this->size() >= this->capacity
()), false))
    this->grow();
  ::new ((void*) this->end()) T(::std::move(Elt));
  this->set_size(this->size() + 1);
}

void pop_back() {
  this->set_size(this->size() - 1);
  this->end()->~T();
}
271};

273// Define this out-of-line to dissuade the C++ compiler from inlining it.
274template <typename T, bool TriviallyCopyable>
275void SmallVectorTemplateBase<T, TriviallyCopyable>::grow(size_t MinSize) {
// Ensure we can fit the new capacity.
// This is only going to be applicable when the capacity is 32 bit.
if (MinSize > this->SizeTypeMax())
  this->report_size_overflow(MinSize);

// Ensure we can meet the guarantee of space for at least one more element.
// The above check alone will not catch the case where grow is called with a
// default MinSize of 0, but the current capacity cannot be increased.
// This is only going to be applicable when the capacity is 32 bit.
if (this->capacity() == this->SizeTypeMax())
  this->report_at_maximum_capacity();

// Always grow, even from zero.
size_t NewCapacity = size_t(NextPowerOf2(this->capacity() + 2));
NewCapacity = std::min(std::max(NewCapacity, MinSize), this->SizeTypeMax());
T *NewElts = static_cast<T*>(llvm::safe_malloc(NewCapacity*sizeof(T)));

// Move the elements over.
this->uninitialized_move(this->begin(), this->end(), NewElts);

// Destroy the original elements.
destroy_range(this->begin(), this->end());

// If this wasn't grown from the inline copy, deallocate the old space.
if (!this->isSmall())
  free(this->begin());

this->BeginX = NewElts;
this->Capacity = NewCapacity;
305}

307/// SmallVectorTemplateBase<TriviallyCopyable = true> - This is where we put
308/// method implementations that are designed to work with trivially copyable
309/// T's. This allows using memcpy in place of copy/move construction and
310/// skipping destruction.
311template <typename T>
312class SmallVectorTemplateBase<T, true> : public SmallVectorTemplateCommon<T> {
313protected:
SmallVectorTemplateBase(size_t Size) : SmallVectorTemplateCommon<T>(Size) {}

// No need to do a destroy loop for POD's.
static void destroy_range(T *, T *) {}

/// Move the range [I, E) onto the uninitialized memory
/// starting with "Dest", constructing elements into it as needed.
template<typename It1, typename It2>
static void uninitialized_move(It1 I, It1 E, It2 Dest) {
  // Just do a copy.
  uninitialized_copy(I, E, Dest);
}

/// Copy the range [I, E) onto the uninitialized memory
/// starting with "Dest", constructing elements into it as needed.
template<typename It1, typename It2>
static void uninitialized_copy(It1 I, It1 E, It2 Dest) {
  // Arbitrary iterator types; just use the basic implementation.
  std::uninitialized_copy(I, E, Dest);
}

/// Copy the range [I, E) onto the uninitialized memory
/// starting with "Dest", constructing elements into it as needed.
template <typename T1, typename T2>
static void uninitialized_copy(
    T1 *I, T1 *E, T2 *Dest,
    std::enable_if_t<std::is_same<typename std::remove_const<T1>::type,
                                  T2>::value> * = nullptr) {
  // Use memcpy for PODs iterated by pointers (which includes SmallVector
  // iterators): std::uninitialized_copy optimizes to memmove, but we can
  // use memcpy here. Note that I and E are iterators and thus might be
  // invalid for memcpy if they are equal.
  if (I != E)
    memcpy(reinterpret_cast<void *>(Dest), I, (E - I) * sizeof(T));
}

/// Double the size of the allocated memory, guaranteeing space for at
/// least one more element or MinSize if specified.
void grow(size_t MinSize = 0) { this->grow_pod(MinSize, sizeof(T)); }

354public:
void push_back(const T &Elt) {
  if (LLVM_UNLIKELY(this->size() >= this->capacity())__builtin_expect((bool)(this->size() >= this->capacity
()), false))
    this->grow();
  memcpy(reinterpret_cast<void *>(this->end()), &Elt, sizeof(T));
  this->set_size(this->size() + 1);
}

void pop_back() { this->set_size(this->size() - 1); }
363};

365/// This class consists of common code factored out of the SmallVector class to
366/// reduce code duplication based on the SmallVector 'N' template parameter.
367template <typename T>
368class SmallVectorImpl : public SmallVectorTemplateBase<T> {
using SuperClass = SmallVectorTemplateBase<T>;

371public:
using iterator = typename SuperClass::iterator;
using const_iterator = typename SuperClass::const_iterator;
using reference = typename SuperClass::reference;
using size_type = typename SuperClass::size_type;

377protected:
// Default ctor - Initialize to empty.
explicit SmallVectorImpl(unsigned N)
    : SmallVectorTemplateBase<T>(N) {}

382public:
SmallVectorImpl(const SmallVectorImpl &) = delete;

~SmallVectorImpl() {
  // Subclass has already destructed this vector's elements.
  // If this wasn't grown from the inline copy, deallocate the old space.
  if (!this->isSmall())
    free(this->begin());
}

void clear() {
  this->destroy_range(this->begin(), this->end());
  this->Size = 0;
}

void resize(size_type N) {
  if (N < this->size()) {
    this->destroy_range(this->begin()+N, this->end());
    this->set_size(N);
  } else if (N > this->size()) {
    if (this->capacity() < N)
      this->grow(N);
    for (auto I = this->end(), E = this->begin() + N; I != E; ++I)
      new (&*I) T();
    this->set_size(N);
  }
}

void resize(size_type N, const T &NV) {
  if (N < this->size()) {
    this->destroy_range(this->begin()+N, this->end());
    this->set_size(N);
  } else if (N > this->size()) {
    if (this->capacity() < N)
      this->grow(N);
    std::uninitialized_fill(this->end(), this->begin()+N, NV);
    this->set_size(N);
  }
}

void reserve(size_type N) {
  if (this->capacity() < N)
    this->grow(N);
}

LLVM_NODISCARD[[clang::warn_unused_result]] T pop_back_val() {
  T Result = ::std::move(this->back());
  this->pop_back();
  return Result;
}

void swap(SmallVectorImpl &RHS);

/// Add the specified range to the end of the SmallVector.
template <typename in_iter,
          typename = std::enable_if_t<std::is_convertible<
              typename std::iterator_traits<in_iter>::iterator_category,
              std::input_iterator_tag>::value>>
void append(in_iter in_start, in_iter in_end) {
  size_type NumInputs = std::distance(in_start, in_end);
  if (NumInputs > this->capacity() - this->size())
    this->grow(this->size()+NumInputs);

  this->uninitialized_copy(in_start, in_end, this->end());
  this->set_size(this->size() + NumInputs);
}

/// Append \p NumInputs copies of \p Elt to the end.
void append(size_type NumInputs, const T &Elt) {
  if (NumInputs > this->capacity() - this->size())
    this->grow(this->size()+NumInputs);

  std::uninitialized_fill_n(this->end(), NumInputs, Elt);
  this->set_size(this->size() + NumInputs);
}

void append(std::initializer_list<T> IL) {
  append(IL.begin(), IL.end());
}

// FIXME: Consider assigning over existing elements, rather than clearing &
// re-initializing them - for all assign(...) variants.

void assign(size_type NumElts, const T &Elt) {
  clear();
  if (this->capacity() < NumElts)
    this->grow(NumElts);
  this->set_size(NumElts);
  std::uninitialized_fill(this->begin(), this->end(), Elt);
}

template <typename in_iter,
          typename = std::enable_if_t<std::is_convertible<
              typename std::iterator_traits<in_iter>::iterator_category,
              std::input_iterator_tag>::value>>
void assign(in_iter in_start, in_iter in_end) {
  clear();
  append(in_start, in_end);
}

void assign(std::initializer_list<T> IL) {
  clear();
  append(IL);
}

iterator erase(const_iterator CI) {
  // Just cast away constness because this is a non-const member function.
  iterator I = const_cast<iterator>(CI);

  assert(I >= this->begin() && "Iterator to erase is out of bounds.")((I >= this->begin() && "Iterator to erase is out of bounds."
) ? static_cast<void> (0) : __assert_fail ("I >= this->begin() && \"Iterator to erase is out of bounds.\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/ADT/SmallVector.h"
, 491, __PRETTY_FUNCTION__));
  assert(I < this->end() && "Erasing at past-the-end iterator.")((I < this->end() && "Erasing at past-the-end iterator."
) ? static_cast<void> (0) : __assert_fail ("I < this->end() && \"Erasing at past-the-end iterator.\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/ADT/SmallVector.h"
, 492, __PRETTY_FUNCTION__));

  iterator N = I;
  // Shift all elts down one.
  std::move(I+1, this->end(), I);
  // Drop the last elt.
  this->pop_back();
  return(N);
}

iterator erase(const_iterator CS, const_iterator CE) {
  // Just cast away constness because this is a non-const member function.
  iterator S = const_cast<iterator>(CS);
  iterator E = const_cast<iterator>(CE);

  assert(S >= this->begin() && "Range to erase is out of bounds.")((S >= this->begin() && "Range to erase is out of bounds."
) ? static_cast<void> (0) : __assert_fail ("S >= this->begin() && \"Range to erase is out of bounds.\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/ADT/SmallVector.h"
, 507, __PRETTY_FUNCTION__));
  assert(S <= E && "Trying to erase invalid range.")((S <= E && "Trying to erase invalid range.") ? static_cast
<void> (0) : __assert_fail ("S <= E && \"Trying to erase invalid range.\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/ADT/SmallVector.h"
, 508, __PRETTY_FUNCTION__));
  assert(E <= this->end() && "Trying to erase past the end.")((E <= this->end() && "Trying to erase past the end."
) ? static_cast<void> (0) : __assert_fail ("E <= this->end() && \"Trying to erase past the end.\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/ADT/SmallVector.h"
, 509, __PRETTY_FUNCTION__));

  iterator N = S;
  // Shift all elts down.
  iterator I = std::move(E, this->end(), S);
  // Drop the last elts.
  this->destroy_range(I, this->end());
  this->set_size(I - this->begin());
  return(N);
}

iterator insert(iterator I, T &&Elt) {
  if (I == this->end()) {  // Important special case for empty vector.
    this->push_back(::std::move(Elt));
    return this->end()-1;
  }

  assert(I >= this->begin() && "Insertion iterator is out of bounds.")((I >= this->begin() && "Insertion iterator is out of bounds."
) ? static_cast<void> (0) : __assert_fail ("I >= this->begin() && \"Insertion iterator is out of bounds.\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/ADT/SmallVector.h"
, 526, __PRETTY_FUNCTION__));
  assert(I <= this->end() && "Inserting past the end of the vector.")((I <= this->end() && "Inserting past the end of the vector."
) ? static_cast<void> (0) : __assert_fail ("I <= this->end() && \"Inserting past the end of the vector.\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/ADT/SmallVector.h"
, 527, __PRETTY_FUNCTION__));

  if (this->size() >= this->capacity()) {
    size_t EltNo = I-this->begin();
    this->grow();
    I = this->begin()+EltNo;
  }

  ::new ((void*) this->end()) T(::std::move(this->back()));
  // Push everything else over.
  std::move_backward(I, this->end()-1, this->end());
  this->set_size(this->size() + 1);

  // If we just moved the element we're inserting, be sure to update
  // the reference.
  T *EltPtr = &Elt;
  if (I <= EltPtr && EltPtr < this->end())
    ++EltPtr;

  *I = ::std::move(*EltPtr);
  return I;
}

iterator insert(iterator I, const T &Elt) {
  if (I == this->end()) {  // Important special case for empty vector.
    this->push_back(Elt);
    return this->end()-1;
  }

  assert(I >= this->begin() && "Insertion iterator is out of bounds.")((I >= this->begin() && "Insertion iterator is out of bounds."
) ? static_cast<void> (0) : __assert_fail ("I >= this->begin() && \"Insertion iterator is out of bounds.\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/ADT/SmallVector.h"
, 556, __PRETTY_FUNCTION__));
  assert(I <= this->end() && "Inserting past the end of the vector.")((I <= this->end() && "Inserting past the end of the vector."
) ? static_cast<void> (0) : __assert_fail ("I <= this->end() && \"Inserting past the end of the vector.\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/ADT/SmallVector.h"
, 557, __PRETTY_FUNCTION__));

  if (this->size() >= this->capacity()) {
    size_t EltNo = I-this->begin();
    this->grow();
    I = this->begin()+EltNo;
  }
  ::new ((void*) this->end()) T(std::move(this->back()));
  // Push everything else over.
  std::move_backward(I, this->end()-1, this->end());
  this->set_size(this->size() + 1);

  // If we just moved the element we're inserting, be sure to update
  // the reference.
  const T *EltPtr = &Elt;
  if (I <= EltPtr && EltPtr < this->end())
    ++EltPtr;

  *I = *EltPtr;
  return I;
}

iterator insert(iterator I, size_type NumToInsert, const T &Elt) {
  // Convert iterator to elt# to avoid invalidating iterator when we reserve()
  size_t InsertElt = I - this->begin();

  if (I == this->end()) {  // Important special case for empty vector.
    append(NumToInsert, Elt);
    return this->begin()+InsertElt;
  }

  assert(I >= this->begin() && "Insertion iterator is out of bounds.")((I >= this->begin() && "Insertion iterator is out of bounds."
) ? static_cast<void> (0) : __assert_fail ("I >= this->begin() && \"Insertion iterator is out of bounds.\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/ADT/SmallVector.h"
, 588, __PRETTY_FUNCTION__));
  assert(I <= this->end() && "Inserting past the end of the vector.")((I <= this->end() && "Inserting past the end of the vector."
) ? static_cast<void> (0) : __assert_fail ("I <= this->end() && \"Inserting past the end of the vector.\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/ADT/SmallVector.h"
, 589, __PRETTY_FUNCTION__));

  // Ensure there is enough space.
  reserve(this->size() + NumToInsert);

  // Uninvalidate the iterator.
  I = this->begin()+InsertElt;

  // If there are more elements between the insertion point and the end of the
  // range than there are being inserted, we can use a simple approach to
  // insertion.  Since we already reserved space, we know that this won't
  // reallocate the vector.
  if (size_t(this->end()-I) >= NumToInsert) {
    T *OldEnd = this->end();
    append(std::move_iterator<iterator>(this->end() - NumToInsert),
           std::move_iterator<iterator>(this->end()));

    // Copy the existing elements that get replaced.
    std::move_backward(I, OldEnd-NumToInsert, OldEnd);

    std::fill_n(I, NumToInsert, Elt);
    return I;
  }

  // Otherwise, we're inserting more elements than exist already, and we're
  // not inserting at the end.

  // Move over the elements that we're about to overwrite.
  T *OldEnd = this->end();
  this->set_size(this->size() + NumToInsert);
  size_t NumOverwritten = OldEnd-I;
  this->uninitialized_move(I, OldEnd, this->end()-NumOverwritten);

  // Replace the overwritten part.
  std::fill_n(I, NumOverwritten, Elt);

  // Insert the non-overwritten middle part.
  std::uninitialized_fill_n(OldEnd, NumToInsert-NumOverwritten, Elt);
  return I;
}

template <typename ItTy,
          typename = std::enable_if_t<std::is_convertible<
              typename std::iterator_traits<ItTy>::iterator_category,
              std::input_iterator_tag>::value>>
iterator insert(iterator I, ItTy From, ItTy To) {
  // Convert iterator to elt# to avoid invalidating iterator when we reserve()
  size_t InsertElt = I - this->begin();

  if (I == this->end()) {  // Important special case for empty vector.
    append(From, To);
    return this->begin()+InsertElt;
  }

  assert(I >= this->begin() && "Insertion iterator is out of bounds.")((I >= this->begin() && "Insertion iterator is out of bounds."
) ? static_cast<void> (0) : __assert_fail ("I >= this->begin() && \"Insertion iterator is out of bounds.\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/ADT/SmallVector.h"
, 643, __PRETTY_FUNCTION__));
  assert(I <= this->end() && "Inserting past the end of the vector.")((I <= this->end() && "Inserting past the end of the vector."
) ? static_cast<void> (0) : __assert_fail ("I <= this->end() && \"Inserting past the end of the vector.\""
, "/build/llvm-toolchain-snapshot-12.0.0~++20201102111116+1ed2ca68191/llvm/include/llvm/ADT/SmallVector.h"
, 644, __PRETTY_FUNCTION__));

  size_t NumToInsert = std::distance(From, To);

  // Ensure there is enough space.
  reserve(this->size() + NumToInsert);

  // Uninvalidate the iterator.
  I = this->begin()+InsertElt;

  // If there are more elements between the insertion point and the end of the
  // range than there are being inserted, we can use a simple approach to
  // insertion.  Since we already reserved space, we know that this won't
  // reallocate the vector.
  if (size_t(this->end()-I) >= NumToInsert) {
    T *OldEnd = this->end();
    append(std::move_iterator<iterator>(this->end() - NumToInsert),
           std::move_iterator<iterator>(this->end()));

    // Copy the existing elements that get replaced.
    std::move_backward(I, OldEnd-NumToInsert, OldEnd);

    std::copy(From, To, I);
    return I;
  }

  // Otherwise, we're inserting more elements than exist already, and we're
  // not inserting at the end.

  // Move over the elements that we're about to overwrite.
  T *OldEnd = this->end();
  this->set_size(this->size() + NumToInsert);
  size_t NumOverwritten = OldEnd-I;
  this->uninitialized_move(I, OldEnd, this->end()-NumOverwritten);

  // Replace the overwritten part.
  for (T *J = I; NumOverwritten > 0; --NumOverwritten) {
    *J = *From;
    ++J; ++From;
  }

  // Insert the non-overwritten middle part.
  this->uninitialized_copy(From, To, OldEnd);
  return I;
}

void insert(iterator I, std::initializer_list<T> IL) {
  insert(I, IL.begin(), IL.end());
}

template <typename... ArgTypes> reference emplace_back(ArgTypes &&... Args) {
  if (LLVM_UNLIKELY(this->size() >= this->capacity())__builtin_expect((bool)(this->size() >= this->capacity
()), false))
    this->grow();
  ::new ((void *)this->end()) T(std::forward<ArgTypes>(Args)...);
  this->set_size(this->size() + 1);
  return this->back();
}

SmallVectorImpl &operator=(const SmallVectorImpl &RHS);

SmallVectorImpl &operator=(SmallVectorImpl &&RHS);

bool operator==(const SmallVectorImpl &RHS) const {
  if (this->size() != RHS.size()) return false;
  return std::equal(this->begin(), this->end(), RHS.begin());
}
bool operator!=(const SmallVectorImpl &RHS) const {
  return !(*this == RHS);
}

bool operator<(const SmallVectorImpl &RHS) const {
  return std::lexicographical_compare(this->begin(), this->end(),
                                      RHS.begin(), RHS.end());
}
718};

720template <typename T>
721void SmallVectorImpl<T>::swap(SmallVectorImpl<T> &RHS) {
if (this == &RHS) return;

// We can only avoid copying elements if neither vector is small.
if (!this->isSmall() && !RHS.isSmall()) {
  std::swap(this->BeginX, RHS.BeginX);
  std::swap(this->Size, RHS.Size);
  std::swap(this->Capacity, RHS.Capacity);
  return;
}
if (RHS.size() > this->capacity())
  this->grow(RHS.size());
if (this->size() > RHS.capacity())
  RHS.grow(this->size());

// Swap the shared elements.
size_t NumShared = this->size();
if (NumShared > RHS.size()) NumShared = RHS.size();
for (size_type i = 0; i != NumShared; ++i)
  std::swap((*this)[i], RHS[i]);

// Copy over the extra elts.
if (this->size() > RHS.size()) {
  size_t EltDiff = this->size() - RHS.size();
  this->uninitialized_copy(this->begin()+NumShared, this->end(), RHS.end());
  RHS.set_size(RHS.size() + EltDiff);
  this->destroy_range(this->begin()+NumShared, this->end());
  this->set_size(NumShared);
} else if (RHS.size() > this->size()) {
  size_t EltDiff = RHS.size() - this->size();
  this->uninitialized_copy(RHS.begin()+NumShared, RHS.end(), this->end());
  this->set_size(this->size() + EltDiff);
  this->destroy_range(RHS.begin()+NumShared, RHS.end());
  RHS.set_size(NumShared);
}
756}

758template <typename T>
759SmallVectorImpl<T> &SmallVectorImpl<T>::
operator=(const SmallVectorImpl<T> &RHS) {
// Avoid self-assignment.
if (this == &RHS) return *this;

// If we already have sufficient space, assign the common elements, then
// destroy any excess.
size_t RHSSize = RHS.size();
size_t CurSize = this->size();
if (CurSize >= RHSSize) {
  // Assign common elements.
  iterator NewEnd;
  if (RHSSize)
    NewEnd = std::copy(RHS.begin(), RHS.begin()+RHSSize, this->begin());
  else
    NewEnd = this->begin();

  // Destroy excess elements.
  this->destroy_range(NewEnd, this->end());

  // Trim.
  this->set_size(RHSSize);
  return *this;
}

// If we have to grow to have enough elements, destroy the current elements.
// This allows us to avoid copying them during the grow.
// FIXME: don't do this if they're efficiently moveable.
if (this->capacity() < RHSSize) {
  // Destroy current elements.
  this->destroy_range(this->begin(), this->end());
  this->set_size(0);
  CurSize = 0;
  this->grow(RHSSize);
} else if (CurSize) {
  // Otherwise, use assignment for the already-constructed elements.
  std::copy(RHS.begin(), RHS.begin()+CurSize, this->begin());
}

// Copy construct the new elements in place.
this->uninitialized_copy(RHS.begin()+CurSize, RHS.end(),
                         this->begin()+CurSize);

// Set end.
this->set_size(RHSSize);
return *this;
805}

807template <typename T>
808SmallVectorImpl<T> &SmallVectorImpl<T>::operator=(SmallVectorImpl<T> &&RHS) {
// Avoid self-assignment.
if (this == &RHS) return *this;

// If the RHS isn't small, clear this vector and then steal its buffer.
if (!RHS.isSmall()) {
  this->destroy_range(this->begin(), this->end());
  if (!this->isSmall()) free(this->begin());
  this->BeginX = RHS.BeginX;
  this->Size = RHS.Size;
  this->Capacity = RHS.Capacity;
  RHS.resetToSmall();
  return *this;
}

// If we already have sufficient space, assign the common elements, then
// destroy any excess.
size_t RHSSize = RHS.size();
size_t CurSize = this->size();
if (CurSize >= RHSSize) {
  // Assign common elements.
  iterator NewEnd = this->begin();
  if (RHSSize)
    NewEnd = std::move(RHS.begin(), RHS.end(), NewEnd);

  // Destroy excess elements and trim the bounds.
  this->destroy_range(NewEnd, this->end());
  this->set_size(RHSSize);

  // Clear the RHS.
  RHS.clear();

  return *this;
}

// If we have to grow to have enough elements, destroy the current elements.
// This allows us to avoid copying them during the grow.
// FIXME: this may not actually make any sense if we can efficiently move
// elements.
if (this->capacity() < RHSSize) {
  // Destroy current elements.
  this->destroy_range(this->begin(), this->end());
  this->set_size(0);
  CurSize = 0;
  this->grow(RHSSize);
} else if (CurSize) {
  // Otherwise, use assignment for the already-constructed elements.
  std::move(RHS.begin(), RHS.begin()+CurSize, this->begin());
}

// Move-construct the new elements in place.
this->uninitialized_move(RHS.begin()+CurSize, RHS.end(),
                         this->begin()+CurSize);

// Set end.
this->set_size(RHSSize);

RHS.clear();
return *this;
867}

869/// Storage for the SmallVector elements.  This is specialized for the N=0 case
870/// to avoid allocating unnecessary storage.
871template <typename T, unsigned N>
872struct SmallVectorStorage {
alignas(T) char InlineElts[N * sizeof(T)];
874};

876/// We need the storage to be properly aligned even for small-size of 0 so that
877/// the pointer math in \a SmallVectorTemplateCommon::getFirstEl() is
878/// well-defined.
879template <typename T> struct alignas(T) SmallVectorStorage<T, 0> {};

881/// This is a 'vector' (really, a variable-sized array), optimized
882/// for the case when the array is small.  It contains some number of elements
883/// in-place, which allows it to avoid heap allocation when the actual number of
884/// elements is below that threshold.  This allows normal "small" cases to be
885/// fast without losing generality for large inputs.
886///
887/// Note that this does not attempt to be exception safe.
888///
889template <typename T, unsigned N>
890class LLVM_GSL_OWNER[[gsl::Owner]] SmallVector : public SmallVectorImpl<T>,
                                 SmallVectorStorage<T, N> {
892public:
SmallVector() : SmallVectorImpl<T>(N) {}

~SmallVector() {
  // Destroy the constructed elements in the vector.
  this->destroy_range(this->begin(), this->end());
}

explicit SmallVector(size_t Size, const T &Value = T())
  : SmallVectorImpl<T>(N) {
  this->assign(Size, Value);
}

template <typename ItTy,
          typename = std::enable_if_t<std::is_convertible<
              typename std::iterator_traits<ItTy>::iterator_category,
              std::input_iterator_tag>::value>>
SmallVector(ItTy S, ItTy E) : SmallVectorImpl<T>(N) {
  this->append(S, E);
}

template <typename RangeTy>
explicit SmallVector(const iterator_range<RangeTy> &R)
    : SmallVectorImpl<T>(N) {
  this->append(R.begin(), R.end());
}

SmallVector(std::initializer_list<T> IL) : SmallVectorImpl<T>(N) {
  this->assign(IL);
}

SmallVector(const SmallVector &RHS) : SmallVectorImpl<T>(N) {
  if (!RHS.empty())
    SmallVectorImpl<T>::operator=(RHS);
}

SmallVector &operator=(const SmallVector &RHS) {
  SmallVectorImpl<T>::operator=(RHS);
  return *this;
}

SmallVector(SmallVector &&RHS) : SmallVectorImpl<T>(N) {
  if (!RHS.empty())
    SmallVectorImpl<T>::operator=(::std::move(RHS));
}

SmallVector(SmallVectorImpl<T> &&RHS) : SmallVectorImpl<T>(N) {
  if (!RHS.empty())
    SmallVectorImpl<T>::operator=(::std::move(RHS));
}

SmallVector &operator=(SmallVector &&RHS) {
  SmallVectorImpl<T>::operator=(::std::move(RHS));
  return *this;
}

SmallVector &operator=(SmallVectorImpl<T> &&RHS) {
  SmallVectorImpl<T>::operator=(::std::move(RHS));
  return *this;
}

SmallVector &operator=(std::initializer_list<T> IL) {
  this->assign(IL);
  return *this;
}
957};

959template <typename T, unsigned N>
960inline size_t capacity_in_bytes(const SmallVector<T, N> &X) {
return X.capacity_in_bytes();
962}

964/// Given a range of type R, iterate the entire range and return a
965/// SmallVector with elements of the vector.  This is useful, for example,
966/// when you want to iterate a range and then sort the results.
967template <unsigned Size, typename R>
968SmallVector<typename std::remove_const<typename std::remove_reference<
              decltype(*std::begin(std::declval<R &>()))>::type>::type,
          Size>
971to_vector(R &&Range) {
return {std::begin(Range), std::end(Range)};
973}

975} // end namespace llvm

977namespace std {

/// Implement std::swap in terms of SmallVector swap.
template<typename T>
inline void
swap(llvm::SmallVectorImpl<T> &LHS, llvm::SmallVectorImpl<T> &RHS) {
  LHS.swap(RHS);
}

/// Implement std::swap in terms of SmallVector swap.
template<typename T, unsigned N>
inline void
swap(llvm::SmallVector<T, N> &LHS, llvm::SmallVector<T, N> &RHS) {
  LHS.swap(RHS);
}

993} // end namespace std

995#endif // LLVM_ADT_SMALLVECTOR_H