/build/llvm-toolchain-snapshot-7~svn329677/lib/Transforms/Scalar/LoopIdiomRecognize.cpp

Bug Summary

File:	lib/Transforms/Scalar/LoopIdiomRecognize.cpp
Warning:	line 1424, column 46 Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name LoopIdiomRecognize.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-eagerly-assume -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 -mrelocation-model pic -pic-level 2 -mthread-model posix -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-7/lib/clang/7.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-7~svn329677/build-llvm/lib/Transforms/Scalar -I /build/llvm-toolchain-snapshot-7~svn329677/lib/Transforms/Scalar -I /build/llvm-toolchain-snapshot-7~svn329677/build-llvm/include -I /build/llvm-toolchain-snapshot-7~svn329677/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0/backward -internal-isystem /usr/include/clang/7.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-7/lib/clang/7.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++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-7~svn329677/build-llvm/lib/Transforms/Scalar -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-checker optin.performance.Padding -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-04-11-031539-24776-1 -x c++ /build/llvm-toolchain-snapshot-7~svn329677/lib/Transforms/Scalar/LoopIdiomRecognize.cpp

/build/llvm-toolchain-snapshot-7~svn329677/lib/Transforms/Scalar/LoopIdiomRecognize.cpp

→

1//===- LoopIdiomRecognize.cpp - Loop idiom recognition --------------------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This pass implements an idiom recognizer that transforms simple loops into a
11// non-loop form.  In cases that this kicks in, it can be a significant
12// performance win.
13//
14// If compiling for code size we avoid idiom recognition if the resulting
15// code could be larger than the code for the original loop. One way this could
16// happen is if the loop is not removable after idiom recognition due to the
17// presence of non-idiom instructions. The initial implementation of the
18// heuristics applies to idioms in multi-block loops.
19//
20//===----------------------------------------------------------------------===//
21//
22// TODO List:
23//
24// Future loop memory idioms to recognize:
25//   memcmp, memmove, strlen, etc.
26// Future floating point idioms to recognize in -ffast-math mode:
27//   fpowi
28// Future integer operation idioms to recognize:
29//   ctpop, ctlz, cttz
30//
31// Beware that isel's default lowering for ctpop is highly inefficient for
32// i64 and larger types when i64 is legal and the value has few bits set.  It
33// would be good to enhance isel to emit a loop for ctpop in this case.
34//
35// This could recognize common matrix multiplies and dot product idioms and
36// replace them with calls to BLAS (if linked in??).
37//
38//===----------------------------------------------------------------------===//

40#include "llvm/ADT/APInt.h"
41#include "llvm/ADT/ArrayRef.h"
42#include "llvm/ADT/DenseMap.h"
43#include "llvm/ADT/MapVector.h"
44#include "llvm/ADT/SetVector.h"
45#include "llvm/ADT/SmallPtrSet.h"
46#include "llvm/ADT/SmallVector.h"
47#include "llvm/ADT/Statistic.h"
48#include "llvm/ADT/StringRef.h"
49#include "llvm/Analysis/AliasAnalysis.h"
50#include "llvm/Analysis/LoopAccessAnalysis.h"
51#include "llvm/Analysis/LoopInfo.h"
52#include "llvm/Analysis/LoopPass.h"
53#include "llvm/Analysis/MemoryLocation.h"
54#include "llvm/Analysis/ScalarEvolution.h"
55#include "llvm/Analysis/ScalarEvolutionExpander.h"
56#include "llvm/Analysis/ScalarEvolutionExpressions.h"
57#include "llvm/Analysis/TargetLibraryInfo.h"
58#include "llvm/Analysis/TargetTransformInfo.h"
59#include "llvm/Analysis/Utils/Local.h"
60#include "llvm/Analysis/ValueTracking.h"
61#include "llvm/IR/Attributes.h"
62#include "llvm/IR/BasicBlock.h"
63#include "llvm/IR/Constant.h"
64#include "llvm/IR/Constants.h"
65#include "llvm/IR/DataLayout.h"
66#include "llvm/IR/DebugLoc.h"
67#include "llvm/IR/DerivedTypes.h"
68#include "llvm/IR/Dominators.h"
69#include "llvm/IR/GlobalValue.h"
70#include "llvm/IR/GlobalVariable.h"
71#include "llvm/IR/IRBuilder.h"
72#include "llvm/IR/InstrTypes.h"
73#include "llvm/IR/Instruction.h"
74#include "llvm/IR/Instructions.h"
75#include "llvm/IR/IntrinsicInst.h"
76#include "llvm/IR/Intrinsics.h"
77#include "llvm/IR/LLVMContext.h"
78#include "llvm/IR/Module.h"
79#include "llvm/IR/PassManager.h"
80#include "llvm/IR/Type.h"
81#include "llvm/IR/User.h"
82#include "llvm/IR/Value.h"
83#include "llvm/IR/ValueHandle.h"
84#include "llvm/Pass.h"
85#include "llvm/Support/Casting.h"
86#include "llvm/Support/CommandLine.h"
87#include "llvm/Support/Debug.h"
88#include "llvm/Support/raw_ostream.h"
89#include "llvm/Transforms/Scalar.h"
90#include "llvm/Transforms/Scalar/LoopIdiomRecognize.h"
91#include "llvm/Transforms/Utils/BuildLibCalls.h"
92#include "llvm/Transforms/Utils/LoopUtils.h"
93#include <algorithm>
94#include <cassert>
95#include <cstdint>
96#include <utility>
97#include <vector>

99using namespace llvm;

101#define DEBUG_TYPE"loop-idiom" "loop-idiom"

103STATISTIC(NumMemSet, "Number of memset's formed from loop stores")static llvm::Statistic NumMemSet = {"loop-idiom", "NumMemSet"
, "Number of memset's formed from loop stores", {0}, {false}};
104STATISTIC(NumMemCpy, "Number of memcpy's formed from loop load+stores")static llvm::Statistic NumMemCpy = {"loop-idiom", "NumMemCpy"
, "Number of memcpy's formed from loop load+stores", {0}, {false
}};

106static cl::opt<bool> UseLIRCodeSizeHeurs(
  "use-lir-code-size-heurs",
  cl::desc("Use loop idiom recognition code size heuristics when compiling"
           "with -Os/-Oz"),
  cl::init(true), cl::Hidden);

112namespace {

114class LoopIdiomRecognize {
Loop *CurLoop = nullptr;
AliasAnalysis *AA;
DominatorTree *DT;
LoopInfo *LI;
ScalarEvolution *SE;
TargetLibraryInfo *TLI;
const TargetTransformInfo *TTI;
const DataLayout *DL;
bool ApplyCodeSizeHeuristics;

125public:
explicit LoopIdiomRecognize(AliasAnalysis *AA, DominatorTree *DT,
                            LoopInfo *LI, ScalarEvolution *SE,
                            TargetLibraryInfo *TLI,
                            const TargetTransformInfo *TTI,
                            const DataLayout *DL)
    : AA(AA), DT(DT), LI(LI), SE(SE), TLI(TLI), TTI(TTI), DL(DL) {}

bool runOnLoop(Loop *L);

135private:
using StoreList = SmallVector<StoreInst *, 8>;
using StoreListMap = MapVector<Value *, StoreList>;

StoreListMap StoreRefsForMemset;
StoreListMap StoreRefsForMemsetPattern;
StoreList StoreRefsForMemcpy;
bool HasMemset;
bool HasMemsetPattern;
bool HasMemcpy;

/// Return code for isLegalStore()
enum LegalStoreKind {
  None = 0,
  Memset,
  MemsetPattern,
  Memcpy,
  UnorderedAtomicMemcpy,
  DontUse // Dummy retval never to be used. Allows catching errors in retval
          // handling.
};

/// \name Countable Loop Idiom Handling
/// @{

bool runOnCountableLoop();
bool runOnLoopBlock(BasicBlock *BB, const SCEV *BECount,
                    SmallVectorImpl<BasicBlock *> &ExitBlocks);

void collectStores(BasicBlock *BB);
LegalStoreKind isLegalStore(StoreInst *SI);
bool processLoopStores(SmallVectorImpl<StoreInst *> &SL, const SCEV *BECount,
                       bool ForMemset);
bool processLoopMemSet(MemSetInst *MSI, const SCEV *BECount);

bool processLoopStridedStore(Value *DestPtr, unsigned StoreSize,
                             unsigned StoreAlignment, Value *StoredVal,
                             Instruction *TheStore,
                             SmallPtrSetImpl<Instruction *> &Stores,
                             const SCEVAddRecExpr *Ev, const SCEV *BECount,
                             bool NegStride, bool IsLoopMemset = false);
bool processLoopStoreOfLoopLoad(StoreInst *SI, const SCEV *BECount);
bool avoidLIRForMultiBlockLoop(bool IsMemset = false,
                               bool IsLoopMemset = false);

/// @}
/// \name Noncountable Loop Idiom Handling
/// @{

bool runOnNoncountableLoop();

bool recognizePopcount();
void transformLoopToPopcount(BasicBlock *PreCondBB, Instruction *CntInst,
                             PHINode *CntPhi, Value *Var);
bool recognizeAndInsertCTLZ();
void transformLoopToCountable(BasicBlock *PreCondBB, Instruction *CntInst,
                              PHINode *CntPhi, Value *Var, const DebugLoc DL,
                              bool ZeroCheck, bool IsCntPhiUsedOutsideLoop);

/// @}
195};

197class LoopIdiomRecognizeLegacyPass : public LoopPass {
198public:
static char ID;

explicit LoopIdiomRecognizeLegacyPass() : LoopPass(ID) {
  initializeLoopIdiomRecognizeLegacyPassPass(
      *PassRegistry::getPassRegistry());
}

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

  AliasAnalysis *AA = &getAnalysis<AAResultsWrapperPass>().getAAResults();
  DominatorTree *DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
  LoopInfo *LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
  ScalarEvolution *SE = &getAnalysis<ScalarEvolutionWrapperPass>().getSE();
  TargetLibraryInfo *TLI =
      &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI();
  const TargetTransformInfo *TTI =
      &getAnalysis<TargetTransformInfoWrapperPass>().getTTI(
          *L->getHeader()->getParent());
  const DataLayout *DL = &L->getHeader()->getModule()->getDataLayout();

  LoopIdiomRecognize LIR(AA, DT, LI, SE, TLI, TTI, DL);
  return LIR.runOnLoop(L);
}

/// This transformation requires natural loop information & requires that
/// loop preheaders be inserted into the CFG.
void getAnalysisUsage(AnalysisUsage &AU) const override {
  AU.addRequired<TargetLibraryInfoWrapperPass>();
  AU.addRequired<TargetTransformInfoWrapperPass>();
  getLoopAnalysisUsage(AU);
}
232};

234} // end anonymous namespace

236char LoopIdiomRecognizeLegacyPass::ID = 0;

238PreservedAnalyses LoopIdiomRecognizePass::run(Loop &L, LoopAnalysisManager &AM,
                                            LoopStandardAnalysisResults &AR,
                                            LPMUpdater &) {
const auto *DL = &L.getHeader()->getModule()->getDataLayout();

LoopIdiomRecognize LIR(&AR.AA, &AR.DT, &AR.LI, &AR.SE, &AR.TLI, &AR.TTI, DL);
if (!LIR.runOnLoop(&L))
1
Calling 'LoopIdiomRecognize::runOnLoop'→
  return PreservedAnalyses::all();

return getLoopPassPreservedAnalyses();
248}

250INITIALIZE_PASS_BEGIN(LoopIdiomRecognizeLegacyPass, "loop-idiom",static void *initializeLoopIdiomRecognizeLegacyPassPassOnce(PassRegistry
 &Registry) {
                    "Recognize loop idioms", false, false)static void *initializeLoopIdiomRecognizeLegacyPassPassOnce(PassRegistry
 &Registry) {
252INITIALIZE_PASS_DEPENDENCY(LoopPass)initializeLoopPassPass(Registry);
253INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass)initializeTargetLibraryInfoWrapperPassPass(Registry);
254INITIALIZE_PASS_DEPENDENCY(TargetTransformInfoWrapperPass)initializeTargetTransformInfoWrapperPassPass(Registry);
255INITIALIZE_PASS_END(LoopIdiomRecognizeLegacyPass, "loop-idiom",PassInfo *PI = new PassInfo( "Recognize loop idioms", "loop-idiom"
, &LoopIdiomRecognizeLegacyPass::ID, PassInfo::NormalCtor_t
(callDefaultCtor<LoopIdiomRecognizeLegacyPass>), false,
 false); Registry.registerPass(*PI, true); return PI; } static
 llvm::once_flag InitializeLoopIdiomRecognizeLegacyPassPassFlag
; void llvm::initializeLoopIdiomRecognizeLegacyPassPass(PassRegistry
 &Registry) { llvm::call_once(InitializeLoopIdiomRecognizeLegacyPassPassFlag
, initializeLoopIdiomRecognizeLegacyPassPassOnce, std::ref(Registry
)); }
                  "Recognize loop idioms", false, false)PassInfo *PI = new PassInfo( "Recognize loop idioms", "loop-idiom"
, &LoopIdiomRecognizeLegacyPass::ID, PassInfo::NormalCtor_t
(callDefaultCtor<LoopIdiomRecognizeLegacyPass>), false,
 false); Registry.registerPass(*PI, true); return PI; } static
 llvm::once_flag InitializeLoopIdiomRecognizeLegacyPassPassFlag
; void llvm::initializeLoopIdiomRecognizeLegacyPassPass(PassRegistry
 &Registry) { llvm::call_once(InitializeLoopIdiomRecognizeLegacyPassPassFlag
, initializeLoopIdiomRecognizeLegacyPassPassOnce, std::ref(Registry
)); }

258Pass *llvm::createLoopIdiomPass() { return new LoopIdiomRecognizeLegacyPass(); }

260static void deleteDeadInstruction(Instruction *I) {
I->replaceAllUsesWith(UndefValue::get(I->getType()));
I->eraseFromParent();
263}

265//===----------------------------------------------------------------------===//
266//
267//          Implementation of LoopIdiomRecognize
268//
269//===----------------------------------------------------------------------===//

271bool LoopIdiomRecognize::runOnLoop(Loop *L) {
CurLoop = L;
// If the loop could not be converted to canonical form, it must have an
// indirectbr in it, just give up.
if (!L->getLoopPreheader())
2
←
Assuming the condition is false→
3
←
Taking false branch→
  return false;

// Disable loop idiom recognition if the function's name is a common idiom.
StringRef Name = L->getHeader()->getParent()->getName();
if (Name == "memset" || Name == "memcpy")
4
←
Assuming the condition is false→
5
←
Assuming the condition is false→
6
←
Taking false branch→
  return false;

// Determine if code size heuristics need to be applied.
ApplyCodeSizeHeuristics =
    L->getHeader()->getParent()->optForSize() && UseLIRCodeSizeHeurs;
7
←
Assuming the condition is false→

HasMemset = TLI->has(LibFunc_memset);
HasMemsetPattern = TLI->has(LibFunc_memset_pattern16);
HasMemcpy = TLI->has(LibFunc_memcpy);

if (HasMemset || HasMemsetPattern || HasMemcpy)
8
←
Taking false branch→
  if (SE->hasLoopInvariantBackedgeTakenCount(L))
    return runOnCountableLoop();

return runOnNoncountableLoop();
9
←
Calling 'LoopIdiomRecognize::runOnNoncountableLoop'→
296}

298bool LoopIdiomRecognize::runOnCountableLoop() {
const SCEV *BECount = SE->getBackedgeTakenCount(CurLoop);
assert(!isa<SCEVCouldNotCompute>(BECount) &&(static_cast <bool> (!isa<SCEVCouldNotCompute>(BECount
) && "runOnCountableLoop() called on a loop without a predictable"
 "backedge-taken count") ? void (0) : __assert_fail ("!isa<SCEVCouldNotCompute>(BECount) && \"runOnCountableLoop() called on a loop without a predictable\" \"backedge-taken count\""
, "/build/llvm-toolchain-snapshot-7~svn329677/lib/Transforms/Scalar/LoopIdiomRecognize.cpp"
, 302, __extension__ __PRETTY_FUNCTION__))
       "runOnCountableLoop() called on a loop without a predictable"(static_cast <bool> (!isa<SCEVCouldNotCompute>(BECount
) && "runOnCountableLoop() called on a loop without a predictable"
 "backedge-taken count") ? void (0) : __assert_fail ("!isa<SCEVCouldNotCompute>(BECount) && \"runOnCountableLoop() called on a loop without a predictable\" \"backedge-taken count\""
, "/build/llvm-toolchain-snapshot-7~svn329677/lib/Transforms/Scalar/LoopIdiomRecognize.cpp"
, 302, __extension__ __PRETTY_FUNCTION__))
       "backedge-taken count")(static_cast <bool> (!isa<SCEVCouldNotCompute>(BECount
) && "runOnCountableLoop() called on a loop without a predictable"
 "backedge-taken count") ? void (0) : __assert_fail ("!isa<SCEVCouldNotCompute>(BECount) && \"runOnCountableLoop() called on a loop without a predictable\" \"backedge-taken count\""
, "/build/llvm-toolchain-snapshot-7~svn329677/lib/Transforms/Scalar/LoopIdiomRecognize.cpp"
, 302, __extension__ __PRETTY_FUNCTION__));

// If this loop executes exactly one time, then it should be peeled, not
// optimized by this pass.
if (const SCEVConstant *BECst = dyn_cast<SCEVConstant>(BECount))
  if (BECst->getAPInt() == 0)
    return false;

SmallVector<BasicBlock *, 8> ExitBlocks;
CurLoop->getUniqueExitBlocks(ExitBlocks);

DEBUG(dbgs() << "loop-idiom Scanning: F["do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-idiom")) { dbgs() << "loop-idiom Scanning: F[" <<
 CurLoop->getHeader()->getParent()->getName() <<
 "] Loop %" << CurLoop->getHeader()->getName() <<
 "\n"; } } while (false)
             << CurLoop->getHeader()->getParent()->getName() << "] Loop %"do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-idiom")) { dbgs() << "loop-idiom Scanning: F[" <<
 CurLoop->getHeader()->getParent()->getName() <<
 "] Loop %" << CurLoop->getHeader()->getName() <<
 "\n"; } } while (false)
             << CurLoop->getHeader()->getName() << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-idiom")) { dbgs() << "loop-idiom Scanning: F[" <<
 CurLoop->getHeader()->getParent()->getName() <<
 "] Loop %" << CurLoop->getHeader()->getName() <<
 "\n"; } } while (false);

bool MadeChange = false;

// The following transforms hoist stores/memsets into the loop pre-header.
// Give up if the loop has instructions may throw.
LoopSafetyInfo SafetyInfo;
computeLoopSafetyInfo(&SafetyInfo, CurLoop);
if (SafetyInfo.MayThrow)
  return MadeChange;

// Scan all the blocks in the loop that are not in subloops.
for (auto *BB : CurLoop->getBlocks()) {
  // Ignore blocks in subloops.
  if (LI->getLoopFor(BB) != CurLoop)
    continue;

  MadeChange |= runOnLoopBlock(BB, BECount, ExitBlocks);
}
return MadeChange;
335}

337static APInt getStoreStride(const SCEVAddRecExpr *StoreEv) {
const SCEVConstant *ConstStride = cast<SCEVConstant>(StoreEv->getOperand(1));
return ConstStride->getAPInt();
340}

342/// getMemSetPatternValue - If a strided store of the specified value is safe to
343/// turn into a memset_pattern16, return a ConstantArray of 16 bytes that should
344/// be passed in.  Otherwise, return null.
345///
346/// Note that we don't ever attempt to use memset_pattern8 or 4, because these
347/// just replicate their input array and then pass on to memset_pattern16.
348static Constant *getMemSetPatternValue(Value *V, const DataLayout *DL) {
// If the value isn't a constant, we can't promote it to being in a constant
// array.  We could theoretically do a store to an alloca or something, but
// that doesn't seem worthwhile.
Constant *C = dyn_cast<Constant>(V);
if (!C)
  return nullptr;

// Only handle simple values that are a power of two bytes in size.
uint64_t Size = DL->getTypeSizeInBits(V->getType());
if (Size == 0 || (Size & 7) || (Size & (Size - 1)))
  return nullptr;

// Don't care enough about darwin/ppc to implement this.
if (DL->isBigEndian())
  return nullptr;

// Convert to size in bytes.
Size /= 8;

// TODO: If CI is larger than 16-bytes, we can try slicing it in half to see
// if the top and bottom are the same (e.g. for vectors and large integers).
if (Size > 16)
  return nullptr;

// If the constant is exactly 16 bytes, just use it.
if (Size == 16)
  return C;

// Otherwise, we'll use an array of the constants.
unsigned ArraySize = 16 / Size;
ArrayType *AT = ArrayType::get(V->getType(), ArraySize);
return ConstantArray::get(AT, std::vector<Constant *>(ArraySize, C));
381}

383LoopIdiomRecognize::LegalStoreKind
384LoopIdiomRecognize::isLegalStore(StoreInst *SI) {
// Don't touch volatile stores.
if (SI->isVolatile())
  return LegalStoreKind::None;
// We only want simple or unordered-atomic stores.
if (!SI->isUnordered())
  return LegalStoreKind::None;

// Don't convert stores of non-integral pointer types to memsets (which stores
// integers).
if (DL->isNonIntegralPointerType(SI->getValueOperand()->getType()))
  return LegalStoreKind::None;

// Avoid merging nontemporal stores.
if (SI->getMetadata(LLVMContext::MD_nontemporal))
  return LegalStoreKind::None;

Value *StoredVal = SI->getValueOperand();
Value *StorePtr = SI->getPointerOperand();

// Reject stores that are so large that they overflow an unsigned.
uint64_t SizeInBits = DL->getTypeSizeInBits(StoredVal->getType());
if ((SizeInBits & 7) || (SizeInBits >> 32) != 0)
  return LegalStoreKind::None;

// See if the pointer expression is an AddRec like {base,+,1} on the current
// loop, which indicates a strided store.  If we have something else, it's a
// random store we can't handle.
const SCEVAddRecExpr *StoreEv =
    dyn_cast<SCEVAddRecExpr>(SE->getSCEV(StorePtr));
if (!StoreEv || StoreEv->getLoop() != CurLoop || !StoreEv->isAffine())
  return LegalStoreKind::None;

// Check to see if we have a constant stride.
if (!isa<SCEVConstant>(StoreEv->getOperand(1)))
  return LegalStoreKind::None;

// See if the store can be turned into a memset.

// If the stored value is a byte-wise value (like i32 -1), then it may be
// turned into a memset of i8 -1, assuming that all the consecutive bytes
// are stored.  A store of i32 0x01020304 can never be turned into a memset,
// but it can be turned into memset_pattern if the target supports it.
Value *SplatValue = isBytewiseValue(StoredVal);
Constant *PatternValue = nullptr;

// Note: memset and memset_pattern on unordered-atomic is yet not supported
bool UnorderedAtomic = SI->isUnordered() && !SI->isSimple();

// If we're allowed to form a memset, and the stored value would be
// acceptable for memset, use it.
if (!UnorderedAtomic && HasMemset && SplatValue &&
    // Verify that the stored value is loop invariant.  If not, we can't
    // promote the memset.
    CurLoop->isLoopInvariant(SplatValue)) {
  // It looks like we can use SplatValue.
  return LegalStoreKind::Memset;
} else if (!UnorderedAtomic && HasMemsetPattern &&
           // Don't create memset_pattern16s with address spaces.
           StorePtr->getType()->getPointerAddressSpace() == 0 &&
           (PatternValue = getMemSetPatternValue(StoredVal, DL))) {
  // It looks like we can use PatternValue!
  return LegalStoreKind::MemsetPattern;
}

// Otherwise, see if the store can be turned into a memcpy.
if (HasMemcpy) {
  // Check to see if the stride matches the size of the store.  If so, then we
  // know that every byte is touched in the loop.
  APInt Stride = getStoreStride(StoreEv);
  unsigned StoreSize = DL->getTypeStoreSize(SI->getValueOperand()->getType());
  if (StoreSize != Stride && StoreSize != -Stride)
    return LegalStoreKind::None;

  // The store must be feeding a non-volatile load.
  LoadInst *LI = dyn_cast<LoadInst>(SI->getValueOperand());

  // Only allow non-volatile loads
  if (!LI || LI->isVolatile())
    return LegalStoreKind::None;
  // Only allow simple or unordered-atomic loads
  if (!LI->isUnordered())
    return LegalStoreKind::None;

  // See if the pointer expression is an AddRec like {base,+,1} on the current
  // loop, which indicates a strided load.  If we have something else, it's a
  // random load we can't handle.
  const SCEVAddRecExpr *LoadEv =
      dyn_cast<SCEVAddRecExpr>(SE->getSCEV(LI->getPointerOperand()));
  if (!LoadEv || LoadEv->getLoop() != CurLoop || !LoadEv->isAffine())
    return LegalStoreKind::None;

  // The store and load must share the same stride.
  if (StoreEv->getOperand(1) != LoadEv->getOperand(1))
    return LegalStoreKind::None;

  // Success.  This store can be converted into a memcpy.
  UnorderedAtomic = UnorderedAtomic || LI->isAtomic();
  return UnorderedAtomic ? LegalStoreKind::UnorderedAtomicMemcpy
                         : LegalStoreKind::Memcpy;
}
// This store can't be transformed into a memset/memcpy.
return LegalStoreKind::None;
487}

489void LoopIdiomRecognize::collectStores(BasicBlock *BB) {
StoreRefsForMemset.clear();
StoreRefsForMemsetPattern.clear();
StoreRefsForMemcpy.clear();
for (Instruction &I : *BB) {
  StoreInst *SI = dyn_cast<StoreInst>(&I);
  if (!SI)
    continue;

  // Make sure this is a strided store with a constant stride.
  switch (isLegalStore(SI)) {
  case LegalStoreKind::None:
    // Nothing to do
    break;
  case LegalStoreKind::Memset: {
    // Find the base pointer.
    Value *Ptr = GetUnderlyingObject(SI->getPointerOperand(), *DL);
    StoreRefsForMemset[Ptr].push_back(SI);
  } break;
  case LegalStoreKind::MemsetPattern: {
    // Find the base pointer.
    Value *Ptr = GetUnderlyingObject(SI->getPointerOperand(), *DL);
    StoreRefsForMemsetPattern[Ptr].push_back(SI);
  } break;
  case LegalStoreKind::Memcpy:
  case LegalStoreKind::UnorderedAtomicMemcpy:
    StoreRefsForMemcpy.push_back(SI);
    break;
  default:
    assert(false && "unhandled return value")(static_cast <bool> (false && "unhandled return value"
) ? void (0) : __assert_fail ("false && \"unhandled return value\""
, "/build/llvm-toolchain-snapshot-7~svn329677/lib/Transforms/Scalar/LoopIdiomRecognize.cpp"
, 518, __extension__ __PRETTY_FUNCTION__));
    break;
  }
}
522}

524/// runOnLoopBlock - Process the specified block, which lives in a counted loop
525/// with the specified backedge count.  This block is known to be in the current
526/// loop and not in any subloops.
527bool LoopIdiomRecognize::runOnLoopBlock(
  BasicBlock *BB, const SCEV *BECount,
  SmallVectorImpl<BasicBlock *> &ExitBlocks) {
// We can only promote stores in this block if they are unconditionally
// executed in the loop.  For a block to be unconditionally executed, it has
// to dominate all the exit blocks of the loop.  Verify this now.
for (unsigned i = 0, e = ExitBlocks.size(); i != e; ++i)
  if (!DT->dominates(BB, ExitBlocks[i]))
    return false;

bool MadeChange = false;
// Look for store instructions, which may be optimized to memset/memcpy.
collectStores(BB);

// Look for a single store or sets of stores with a common base, which can be
// optimized into a memset (memset_pattern).  The latter most commonly happens
// with structs and handunrolled loops.
for (auto &SL : StoreRefsForMemset)
  MadeChange |= processLoopStores(SL.second, BECount, true);

for (auto &SL : StoreRefsForMemsetPattern)
  MadeChange |= processLoopStores(SL.second, BECount, false);

// Optimize the store into a memcpy, if it feeds an similarly strided load.
for (auto &SI : StoreRefsForMemcpy)
  MadeChange |= processLoopStoreOfLoopLoad(SI, BECount);

for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E;) {
  Instruction *Inst = &*I++;
  // Look for memset instructions, which may be optimized to a larger memset.
  if (MemSetInst *MSI = dyn_cast<MemSetInst>(Inst)) {
    WeakTrackingVH InstPtr(&*I);
    if (!processLoopMemSet(MSI, BECount))
      continue;
    MadeChange = true;

    // If processing the memset invalidated our iterator, start over from the
    // top of the block.
    if (!InstPtr)
      I = BB->begin();
    continue;
  }
}

return MadeChange;
572}

574/// processLoopStores - See if this store(s) can be promoted to a memset.
575bool LoopIdiomRecognize::processLoopStores(SmallVectorImpl<StoreInst *> &SL,
                                         const SCEV *BECount,
                                         bool ForMemset) {
// Try to find consecutive stores that can be transformed into memsets.
SetVector<StoreInst *> Heads, Tails;
SmallDenseMap<StoreInst *, StoreInst *> ConsecutiveChain;

// Do a quadratic search on all of the given stores and find
// all of the pairs of stores that follow each other.
SmallVector<unsigned, 16> IndexQueue;
for (unsigned i = 0, e = SL.size(); i < e; ++i) {
  assert(SL[i]->isSimple() && "Expected only non-volatile stores.")(static_cast <bool> (SL[i]->isSimple() && "Expected only non-volatile stores."
) ? void (0) : __assert_fail ("SL[i]->isSimple() && \"Expected only non-volatile stores.\""
, "/build/llvm-toolchain-snapshot-7~svn329677/lib/Transforms/Scalar/LoopIdiomRecognize.cpp"
, 586, __extension__ __PRETTY_FUNCTION__));

  Value *FirstStoredVal = SL[i]->getValueOperand();
  Value *FirstStorePtr = SL[i]->getPointerOperand();
  const SCEVAddRecExpr *FirstStoreEv =
      cast<SCEVAddRecExpr>(SE->getSCEV(FirstStorePtr));
  APInt FirstStride = getStoreStride(FirstStoreEv);
  unsigned FirstStoreSize = DL->getTypeStoreSize(SL[i]->getValueOperand()->getType());

  // See if we can optimize just this store in isolation.
  if (FirstStride == FirstStoreSize || -FirstStride == FirstStoreSize) {
    Heads.insert(SL[i]);
    continue;
  }

  Value *FirstSplatValue = nullptr;
  Constant *FirstPatternValue = nullptr;

  if (ForMemset)
    FirstSplatValue = isBytewiseValue(FirstStoredVal);
  else
    FirstPatternValue = getMemSetPatternValue(FirstStoredVal, DL);

  assert((FirstSplatValue || FirstPatternValue) &&(static_cast <bool> ((FirstSplatValue || FirstPatternValue
) && "Expected either splat value or pattern value.")
 ? void (0) : __assert_fail ("(FirstSplatValue || FirstPatternValue) && \"Expected either splat value or pattern value.\""
, "/build/llvm-toolchain-snapshot-7~svn329677/lib/Transforms/Scalar/LoopIdiomRecognize.cpp"
, 610, __extension__ __PRETTY_FUNCTION__))
         "Expected either splat value or pattern value.")(static_cast <bool> ((FirstSplatValue || FirstPatternValue
) && "Expected either splat value or pattern value.")
 ? void (0) : __assert_fail ("(FirstSplatValue || FirstPatternValue) && \"Expected either splat value or pattern value.\""
, "/build/llvm-toolchain-snapshot-7~svn329677/lib/Transforms/Scalar/LoopIdiomRecognize.cpp"
, 610, __extension__ __PRETTY_FUNCTION__));

  IndexQueue.clear();
  // If a store has multiple consecutive store candidates, search Stores
  // array according to the sequence: from i+1 to e, then from i-1 to 0.
  // This is because usually pairing with immediate succeeding or preceding
  // candidate create the best chance to find memset opportunity.
  unsigned j = 0;
  for (j = i + 1; j < e; ++j)
    IndexQueue.push_back(j);
  for (j = i; j > 0; --j)
    IndexQueue.push_back(j - 1);

  for (auto &k : IndexQueue) {
    assert(SL[k]->isSimple() && "Expected only non-volatile stores.")(static_cast <bool> (SL[k]->isSimple() && "Expected only non-volatile stores."
) ? void (0) : __assert_fail ("SL[k]->isSimple() && \"Expected only non-volatile stores.\""
, "/build/llvm-toolchain-snapshot-7~svn329677/lib/Transforms/Scalar/LoopIdiomRecognize.cpp"
, 624, __extension__ __PRETTY_FUNCTION__));
    Value *SecondStorePtr = SL[k]->getPointerOperand();
    const SCEVAddRecExpr *SecondStoreEv =
        cast<SCEVAddRecExpr>(SE->getSCEV(SecondStorePtr));
    APInt SecondStride = getStoreStride(SecondStoreEv);

    if (FirstStride != SecondStride)
      continue;

    Value *SecondStoredVal = SL[k]->getValueOperand();
    Value *SecondSplatValue = nullptr;
    Constant *SecondPatternValue = nullptr;

    if (ForMemset)
      SecondSplatValue = isBytewiseValue(SecondStoredVal);
    else
      SecondPatternValue = getMemSetPatternValue(SecondStoredVal, DL);

    assert((SecondSplatValue || SecondPatternValue) &&(static_cast <bool> ((SecondSplatValue || SecondPatternValue
) && "Expected either splat value or pattern value.")
 ? void (0) : __assert_fail ("(SecondSplatValue || SecondPatternValue) && \"Expected either splat value or pattern value.\""
, "/build/llvm-toolchain-snapshot-7~svn329677/lib/Transforms/Scalar/LoopIdiomRecognize.cpp"
, 643, __extension__ __PRETTY_FUNCTION__))
           "Expected either splat value or pattern value.")(static_cast <bool> ((SecondSplatValue || SecondPatternValue
) && "Expected either splat value or pattern value.")
 ? void (0) : __assert_fail ("(SecondSplatValue || SecondPatternValue) && \"Expected either splat value or pattern value.\""
, "/build/llvm-toolchain-snapshot-7~svn329677/lib/Transforms/Scalar/LoopIdiomRecognize.cpp"
, 643, __extension__ __PRETTY_FUNCTION__));

    if (isConsecutiveAccess(SL[i], SL[k], *DL, *SE, false)) {
      if (ForMemset) {
        if (FirstSplatValue != SecondSplatValue)
          continue;
      } else {
        if (FirstPatternValue != SecondPatternValue)
          continue;
      }
      Tails.insert(SL[k]);
      Heads.insert(SL[i]);
      ConsecutiveChain[SL[i]] = SL[k];
      break;
    }
  }
}

// We may run into multiple chains that merge into a single chain. We mark the
// stores that we transformed so that we don't visit the same store twice.
SmallPtrSet<Value *, 16> TransformedStores;
bool Changed = false;

// For stores that start but don't end a link in the chain:
for (SetVector<StoreInst *>::iterator it = Heads.begin(), e = Heads.end();
     it != e; ++it) {
  if (Tails.count(*it))
    continue;

  // We found a store instr that starts a chain. Now follow the chain and try
  // to transform it.
  SmallPtrSet<Instruction *, 8> AdjacentStores;
  StoreInst *I = *it;

  StoreInst *HeadStore = I;
  unsigned StoreSize = 0;

  // Collect the chain into a list.
  while (Tails.count(I) || Heads.count(I)) {
    if (TransformedStores.count(I))
      break;
    AdjacentStores.insert(I);

    StoreSize += DL->getTypeStoreSize(I->getValueOperand()->getType());
    // Move to the next value in the chain.
    I = ConsecutiveChain[I];
  }

  Value *StoredVal = HeadStore->getValueOperand();
  Value *StorePtr = HeadStore->getPointerOperand();
  const SCEVAddRecExpr *StoreEv = cast<SCEVAddRecExpr>(SE->getSCEV(StorePtr));
  APInt Stride = getStoreStride(StoreEv);

  // Check to see if the stride matches the size of the stores.  If so, then
  // we know that every byte is touched in the loop.
  if (StoreSize != Stride && StoreSize != -Stride)
    continue;

  bool NegStride = StoreSize == -Stride;

  if (processLoopStridedStore(StorePtr, StoreSize, HeadStore->getAlignment(),
                              StoredVal, HeadStore, AdjacentStores, StoreEv,
                              BECount, NegStride)) {
    TransformedStores.insert(AdjacentStores.begin(), AdjacentStores.end());
    Changed = true;
  }
}

return Changed;
712}

714/// processLoopMemSet - See if this memset can be promoted to a large memset.
715bool LoopIdiomRecognize::processLoopMemSet(MemSetInst *MSI,
                                         const SCEV *BECount) {
// We can only handle non-volatile memsets with a constant size.
if (MSI->isVolatile() || !isa<ConstantInt>(MSI->getLength()))
  return false;

// If we're not allowed to hack on memset, we fail.
if (!HasMemset)
  return false;

Value *Pointer = MSI->getDest();

// See if the pointer expression is an AddRec like {base,+,1} on the current
// loop, which indicates a strided store.  If we have something else, it's a
// random store we can't handle.
const SCEVAddRecExpr *Ev = dyn_cast<SCEVAddRecExpr>(SE->getSCEV(Pointer));
if (!Ev || Ev->getLoop() != CurLoop || !Ev->isAffine())
  return false;

// Reject memsets that are so large that they overflow an unsigned.
uint64_t SizeInBytes = cast<ConstantInt>(MSI->getLength())->getZExtValue();
if ((SizeInBytes >> 32) != 0)
  return false;

// Check to see if the stride matches the size of the memset.  If so, then we
// know that every byte is touched in the loop.
const SCEVConstant *ConstStride = dyn_cast<SCEVConstant>(Ev->getOperand(1));
if (!ConstStride)
  return false;

APInt Stride = ConstStride->getAPInt();
if (SizeInBytes != Stride && SizeInBytes != -Stride)
  return false;

// Verify that the memset value is loop invariant.  If not, we can't promote
// the memset.
Value *SplatValue = MSI->getValue();
if (!SplatValue || !CurLoop->isLoopInvariant(SplatValue))
  return false;

SmallPtrSet<Instruction *, 1> MSIs;
MSIs.insert(MSI);
bool NegStride = SizeInBytes == -Stride;
return processLoopStridedStore(Pointer, (unsigned)SizeInBytes,
                               MSI->getDestAlignment(), SplatValue, MSI, MSIs,
                               Ev, BECount, NegStride, /*IsLoopMemset=*/true);
761}

763/// mayLoopAccessLocation - Return true if the specified loop might access the
764/// specified pointer location, which is a loop-strided access.  The 'Access'
765/// argument specifies what the verboten forms of access are (read or write).
766static bool
767mayLoopAccessLocation(Value *Ptr, ModRefInfo Access, Loop *L,
                    const SCEV *BECount, unsigned StoreSize,
                    AliasAnalysis &AA,
                    SmallPtrSetImpl<Instruction *> &IgnoredStores) {
// Get the location that may be stored across the loop.  Since the access is
// strided positively through memory, we say that the modified location starts
// at the pointer and has infinite size.
uint64_t AccessSize = MemoryLocation::UnknownSize;

// If the loop iterates a fixed number of times, we can refine the access size
// to be exactly the size of the memset, which is (BECount+1)*StoreSize
if (const SCEVConstant *BECst = dyn_cast<SCEVConstant>(BECount))
  AccessSize = (BECst->getValue()->getZExtValue() + 1) * StoreSize;

// TODO: For this to be really effective, we have to dive into the pointer
// operand in the store.  Store to &A[i] of 100 will always return may alias
// with store of &A[100], we need to StoreLoc to be "A" with size of 100,
// which will then no-alias a store to &A[100].
MemoryLocation StoreLoc(Ptr, AccessSize);

for (Loop::block_iterator BI = L->block_begin(), E = L->block_end(); BI != E;
     ++BI)
  for (Instruction &I : **BI)
    if (IgnoredStores.count(&I) == 0 &&
        isModOrRefSet(
            intersectModRef(AA.getModRefInfo(&I, StoreLoc), Access)))
      return true;

return false;
796}

798// If we have a negative stride, Start refers to the end of the memory location
799// we're trying to memset.  Therefore, we need to recompute the base pointer,
800// which is just Start - BECount*Size.
801static const SCEV *getStartForNegStride(const SCEV *Start, const SCEV *BECount,
                                      Type *IntPtr, unsigned StoreSize,
                                      ScalarEvolution *SE) {
const SCEV *Index = SE->getTruncateOrZeroExtend(BECount, IntPtr);
if (StoreSize != 1)
  Index = SE->getMulExpr(Index, SE->getConstant(IntPtr, StoreSize),
                         SCEV::FlagNUW);
return SE->getMinusSCEV(Start, Index);
809}

811/// Compute the number of bytes as a SCEV from the backedge taken count.
812///
813/// This also maps the SCEV into the provided type and tries to handle the
814/// computation in a way that will fold cleanly.
815static const SCEV *getNumBytes(const SCEV *BECount, Type *IntPtr,
                             unsigned StoreSize, Loop *CurLoop,
                             const DataLayout *DL, ScalarEvolution *SE) {
const SCEV *NumBytesS;
// The # stored bytes is (BECount+1)*Size.  Expand the trip count out to
// pointer size if it isn't already.
//
// If we're going to need to zero extend the BE count, check if we can add
// one to it prior to zero extending without overflow. Provided this is safe,
// it allows better simplification of the +1.
if (DL->getTypeSizeInBits(BECount->getType()) <
        DL->getTypeSizeInBits(IntPtr) &&
    SE->isLoopEntryGuardedByCond(
        CurLoop, ICmpInst::ICMP_NE, BECount,
        SE->getNegativeSCEV(SE->getOne(BECount->getType())))) {
  NumBytesS = SE->getZeroExtendExpr(
      SE->getAddExpr(BECount, SE->getOne(BECount->getType()), SCEV::FlagNUW),
      IntPtr);
} else {
  NumBytesS = SE->getAddExpr(SE->getTruncateOrZeroExtend(BECount, IntPtr),
                             SE->getOne(IntPtr), SCEV::FlagNUW);
}

// And scale it based on the store size.
if (StoreSize != 1) {
  NumBytesS = SE->getMulExpr(NumBytesS, SE->getConstant(IntPtr, StoreSize),
                             SCEV::FlagNUW);
}
return NumBytesS;
844}

846/// processLoopStridedStore - We see a strided store of some value.  If we can
847/// transform this into a memset or memset_pattern in the loop preheader, do so.
848bool LoopIdiomRecognize::processLoopStridedStore(
  Value *DestPtr, unsigned StoreSize, unsigned StoreAlignment,
  Value *StoredVal, Instruction *TheStore,
  SmallPtrSetImpl<Instruction *> &Stores, const SCEVAddRecExpr *Ev,
  const SCEV *BECount, bool NegStride, bool IsLoopMemset) {
Value *SplatValue = isBytewiseValue(StoredVal);
Constant *PatternValue = nullptr;

if (!SplatValue)
  PatternValue = getMemSetPatternValue(StoredVal, DL);

assert((SplatValue || PatternValue) &&(static_cast <bool> ((SplatValue || PatternValue) &&
 "Expected either splat value or pattern value.") ? void (0) :
 __assert_fail ("(SplatValue || PatternValue) && \"Expected either splat value or pattern value.\""
, "/build/llvm-toolchain-snapshot-7~svn329677/lib/Transforms/Scalar/LoopIdiomRecognize.cpp"
, 860, __extension__ __PRETTY_FUNCTION__))
       "Expected either splat value or pattern value.")(static_cast <bool> ((SplatValue || PatternValue) &&
 "Expected either splat value or pattern value.") ? void (0) :
 __assert_fail ("(SplatValue || PatternValue) && \"Expected either splat value or pattern value.\""
, "/build/llvm-toolchain-snapshot-7~svn329677/lib/Transforms/Scalar/LoopIdiomRecognize.cpp"
, 860, __extension__ __PRETTY_FUNCTION__));

// The trip count of the loop and the base pointer of the addrec SCEV is
// guaranteed to be loop invariant, which means that it should dominate the
// header.  This allows us to insert code for it in the preheader.
unsigned DestAS = DestPtr->getType()->getPointerAddressSpace();
BasicBlock *Preheader = CurLoop->getLoopPreheader();
IRBuilder<> Builder(Preheader->getTerminator());
SCEVExpander Expander(*SE, *DL, "loop-idiom");

Type *DestInt8PtrTy = Builder.getInt8PtrTy(DestAS);
Type *IntPtr = Builder.getIntPtrTy(*DL, DestAS);

const SCEV *Start = Ev->getStart();
// Handle negative strided loops.
if (NegStride)
  Start = getStartForNegStride(Start, BECount, IntPtr, StoreSize, SE);

// TODO: ideally we should still be able to generate memset if SCEV expander
// is taught to generate the dependencies at the latest point.
if (!isSafeToExpand(Start, *SE))
  return false;

// Okay, we have a strided store "p[i]" of a splattable value.  We can turn
// this into a memset in the loop preheader now if we want.  However, this
// would be unsafe to do if there is anything else in the loop that may read
// or write to the aliased location.  Check for any overlap by generating the
// base pointer and checking the region.
Value *BasePtr =
    Expander.expandCodeFor(Start, DestInt8PtrTy, Preheader->getTerminator());
if (mayLoopAccessLocation(BasePtr, ModRefInfo::ModRef, CurLoop, BECount,
                          StoreSize, *AA, Stores)) {
  Expander.clear();
  // If we generated new code for the base pointer, clean up.
  RecursivelyDeleteTriviallyDeadInstructions(BasePtr, TLI);
  return false;
}

if (avoidLIRForMultiBlockLoop(/*IsMemset=*/true, IsLoopMemset))
  return false;

// Okay, everything looks good, insert the memset.

const SCEV *NumBytesS =
    getNumBytes(BECount, IntPtr, StoreSize, CurLoop, DL, SE);

// TODO: ideally we should still be able to generate memset if SCEV expander
// is taught to generate the dependencies at the latest point.
if (!isSafeToExpand(NumBytesS, *SE))
  return false;

Value *NumBytes =
    Expander.expandCodeFor(NumBytesS, IntPtr, Preheader->getTerminator());

CallInst *NewCall;
if (SplatValue) {
  NewCall =
      Builder.CreateMemSet(BasePtr, SplatValue, NumBytes, StoreAlignment);
} else {
  // Everything is emitted in default address space
  Type *Int8PtrTy = DestInt8PtrTy;

  Module *M = TheStore->getModule();
  Value *MSP =
      M->getOrInsertFunction("memset_pattern16", Builder.getVoidTy(),
                             Int8PtrTy, Int8PtrTy, IntPtr);
  inferLibFuncAttributes(*M->getFunction("memset_pattern16"), *TLI);

  // Otherwise we should form a memset_pattern16.  PatternValue is known to be
  // an constant array of 16-bytes.  Plop the value into a mergable global.
  GlobalVariable *GV = new GlobalVariable(*M, PatternValue->getType(), true,
                                          GlobalValue::PrivateLinkage,
                                          PatternValue, ".memset_pattern");
  GV->setUnnamedAddr(GlobalValue::UnnamedAddr::Global); // Ok to merge these.
  GV->setAlignment(16);
  Value *PatternPtr = ConstantExpr::getBitCast(GV, Int8PtrTy);
  NewCall = Builder.CreateCall(MSP, {BasePtr, PatternPtr, NumBytes});
}

DEBUG(dbgs() << "  Formed memset: " << *NewCall << "\n"do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-idiom")) { dbgs() << "  Formed memset: " <<
 *NewCall << "\n" << "    from store to: " <<
 *Ev << " at: " << *TheStore << "\n"; } } while
 (false)
             << "    from store to: " << *Ev << " at: " << *TheStore << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-idiom")) { dbgs() << "  Formed memset: " <<
 *NewCall << "\n" << "    from store to: " <<
 *Ev << " at: " << *TheStore << "\n"; } } while
 (false);
NewCall->setDebugLoc(TheStore->getDebugLoc());

// Okay, the memset has been formed.  Zap the original store and anything that
// feeds into it.
for (auto *I : Stores)
  deleteDeadInstruction(I);
++NumMemSet;
return true;
949}

951/// If the stored value is a strided load in the same loop with the same stride
952/// this may be transformable into a memcpy.  This kicks in for stuff like
953/// for (i) A[i] = B[i];
954bool LoopIdiomRecognize::processLoopStoreOfLoopLoad(StoreInst *SI,
                                                  const SCEV *BECount) {
assert(SI->isUnordered() && "Expected only non-volatile non-ordered stores.")(static_cast <bool> (SI->isUnordered() && "Expected only non-volatile non-ordered stores."
) ? void (0) : __assert_fail ("SI->isUnordered() && \"Expected only non-volatile non-ordered stores.\""
, "/build/llvm-toolchain-snapshot-7~svn329677/lib/Transforms/Scalar/LoopIdiomRecognize.cpp"
, 956, __extension__ __PRETTY_FUNCTION__));

Value *StorePtr = SI->getPointerOperand();
const SCEVAddRecExpr *StoreEv = cast<SCEVAddRecExpr>(SE->getSCEV(StorePtr));
APInt Stride = getStoreStride(StoreEv);
unsigned StoreSize = DL->getTypeStoreSize(SI->getValueOperand()->getType());
bool NegStride = StoreSize == -Stride;

// The store must be feeding a non-volatile load.
LoadInst *LI = cast<LoadInst>(SI->getValueOperand());
assert(LI->isUnordered() && "Expected only non-volatile non-ordered loads.")(static_cast <bool> (LI->isUnordered() && "Expected only non-volatile non-ordered loads."
) ? void (0) : __assert_fail ("LI->isUnordered() && \"Expected only non-volatile non-ordered loads.\""
, "/build/llvm-toolchain-snapshot-7~svn329677/lib/Transforms/Scalar/LoopIdiomRecognize.cpp"
, 966, __extension__ __PRETTY_FUNCTION__));

// See if the pointer expression is an AddRec like {base,+,1} on the current
// loop, which indicates a strided load.  If we have something else, it's a
// random load we can't handle.
const SCEVAddRecExpr *LoadEv =
    cast<SCEVAddRecExpr>(SE->getSCEV(LI->getPointerOperand()));

// The trip count of the loop and the base pointer of the addrec SCEV is
// guaranteed to be loop invariant, which means that it should dominate the
// header.  This allows us to insert code for it in the preheader.
BasicBlock *Preheader = CurLoop->getLoopPreheader();
IRBuilder<> Builder(Preheader->getTerminator());
SCEVExpander Expander(*SE, *DL, "loop-idiom");

const SCEV *StrStart = StoreEv->getStart();
unsigned StrAS = SI->getPointerAddressSpace();
Type *IntPtrTy = Builder.getIntPtrTy(*DL, StrAS);

// Handle negative strided loops.
if (NegStride)
  StrStart = getStartForNegStride(StrStart, BECount, IntPtrTy, StoreSize, SE);

// Okay, we have a strided store "p[i]" of a loaded value.  We can turn
// this into a memcpy in the loop preheader now if we want.  However, this
// would be unsafe to do if there is anything else in the loop that may read
// or write the memory region we're storing to.  This includes the load that
// feeds the stores.  Check for an alias by generating the base address and
// checking everything.
Value *StoreBasePtr = Expander.expandCodeFor(
    StrStart, Builder.getInt8PtrTy(StrAS), Preheader->getTerminator());

SmallPtrSet<Instruction *, 1> Stores;
Stores.insert(SI);
if (mayLoopAccessLocation(StoreBasePtr, ModRefInfo::ModRef, CurLoop, BECount,
                          StoreSize, *AA, Stores)) {
  Expander.clear();
  // If we generated new code for the base pointer, clean up.
  RecursivelyDeleteTriviallyDeadInstructions(StoreBasePtr, TLI);
  return false;
}

const SCEV *LdStart = LoadEv->getStart();
unsigned LdAS = LI->getPointerAddressSpace();

// Handle negative strided loops.
if (NegStride)
  LdStart = getStartForNegStride(LdStart, BECount, IntPtrTy, StoreSize, SE);

// For a memcpy, we have to make sure that the input array is not being
// mutated by the loop.
Value *LoadBasePtr = Expander.expandCodeFor(
    LdStart, Builder.getInt8PtrTy(LdAS), Preheader->getTerminator());

if (mayLoopAccessLocation(LoadBasePtr, ModRefInfo::Mod, CurLoop, BECount,
                          StoreSize, *AA, Stores)) {
  Expander.clear();
  // If we generated new code for the base pointer, clean up.
  RecursivelyDeleteTriviallyDeadInstructions(LoadBasePtr, TLI);
  RecursivelyDeleteTriviallyDeadInstructions(StoreBasePtr, TLI);
  return false;
}

if (avoidLIRForMultiBlockLoop())
  return false;

// Okay, everything is safe, we can transform this!

const SCEV *NumBytesS =
    getNumBytes(BECount, IntPtrTy, StoreSize, CurLoop, DL, SE);

Value *NumBytes =
    Expander.expandCodeFor(NumBytesS, IntPtrTy, Preheader->getTerminator());

CallInst *NewCall = nullptr;
// Check whether to generate an unordered atomic memcpy:
//  If the load or store are atomic, then they must neccessarily be unordered
//  by previous checks.
if (!SI->isAtomic() && !LI->isAtomic())
  NewCall = Builder.CreateMemCpy(StoreBasePtr, SI->getAlignment(),
                                 LoadBasePtr, LI->getAlignment(), NumBytes);
else {
  // We cannot allow unaligned ops for unordered load/store, so reject
  // anything where the alignment isn't at least the element size.
  unsigned Align = std::min(SI->getAlignment(), LI->getAlignment());
  if (Align < StoreSize)
    return false;

  // If the element.atomic memcpy is not lowered into explicit
  // loads/stores later, then it will be lowered into an element-size
  // specific lib call. If the lib call doesn't exist for our store size, then
  // we shouldn't generate the memcpy.
  if (StoreSize > TTI->getAtomicMemIntrinsicMaxElementSize())
    return false;

  // Create the call.
  // Note that unordered atomic loads/stores are *required* by the spec to
  // have an alignment but non-atomic loads/stores may not.
  NewCall = Builder.CreateElementUnorderedAtomicMemCpy(
      StoreBasePtr, SI->getAlignment(), LoadBasePtr, LI->getAlignment(),
      NumBytes, StoreSize);
}
NewCall->setDebugLoc(SI->getDebugLoc());

DEBUG(dbgs() << "  Formed memcpy: " << *NewCall << "\n"do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-idiom")) { dbgs() << "  Formed memcpy: " <<
 *NewCall << "\n" << "    from load ptr=" <<
 *LoadEv << " at: " << *LI << "\n" <<
 "    from store ptr=" << *StoreEv << " at: " <<
 *SI << "\n"; } } while (false)
             << "    from load ptr=" << *LoadEv << " at: " << *LI << "\n"do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-idiom")) { dbgs() << "  Formed memcpy: " <<
 *NewCall << "\n" << "    from load ptr=" <<
 *LoadEv << " at: " << *LI << "\n" <<
 "    from store ptr=" << *StoreEv << " at: " <<
 *SI << "\n"; } } while (false)
             << "    from store ptr=" << *StoreEv << " at: " << *SI << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-idiom")) { dbgs() << "  Formed memcpy: " <<
 *NewCall << "\n" << "    from load ptr=" <<
 *LoadEv << " at: " << *LI << "\n" <<
 "    from store ptr=" << *StoreEv << " at: " <<
 *SI << "\n"; } } while (false);

// Okay, the memcpy has been formed.  Zap the original store and anything that
// feeds into it.
deleteDeadInstruction(SI);
++NumMemCpy;
return true;
1079}

1081// When compiling for codesize we avoid idiom recognition for a multi-block loop
1082// unless it is a loop_memset idiom or a memset/memcpy idiom in a nested loop.
1083//
1084bool LoopIdiomRecognize::avoidLIRForMultiBlockLoop(bool IsMemset,
                                                 bool IsLoopMemset) {
if (ApplyCodeSizeHeuristics && CurLoop->getNumBlocks() > 1) {
  if (!CurLoop->getParentLoop() && (!IsMemset || !IsLoopMemset)) {
    DEBUG(dbgs() << "  " << CurLoop->getHeader()->getParent()->getName()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-idiom")) { dbgs() << "  " << CurLoop->getHeader
()->getParent()->getName() << " : LIR " << (
IsMemset ? "Memset" : "Memcpy") << " avoided: multi-block top-level loop\n"
; } } while (false)
                 << " : LIR " << (IsMemset ? "Memset" : "Memcpy")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-idiom")) { dbgs() << "  " << CurLoop->getHeader
()->getParent()->getName() << " : LIR " << (
IsMemset ? "Memset" : "Memcpy") << " avoided: multi-block top-level loop\n"
; } } while (false)
                 << " avoided: multi-block top-level loop\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("loop-idiom")) { dbgs() << "  " << CurLoop->getHeader
()->getParent()->getName() << " : LIR " << (
IsMemset ? "Memset" : "Memcpy") << " avoided: multi-block top-level loop\n"
; } } while (false);
    return true;
  }
}

return false;
1096}

1098bool LoopIdiomRecognize::runOnNoncountableLoop() {
return recognizePopcount() || recognizeAndInsertCTLZ();
10
←
Calling 'LoopIdiomRecognize::recognizeAndInsertCTLZ'→
1100}

1102/// Check if the given conditional branch is based on the comparison between
1103/// a variable and zero, and if the variable is non-zero, the control yields to
1104/// the loop entry. If the branch matches the behavior, the variable involved
1105/// in the comparison is returned. This function will be called to see if the
1106/// precondition and postcondition of the loop are in desirable form.
1107static Value *matchCondition(BranchInst *BI, BasicBlock *LoopEntry) {
if (!BI || !BI->isConditional())
  return nullptr;

ICmpInst *Cond = dyn_cast<ICmpInst>(BI->getCondition());
if (!Cond)
  return nullptr;

ConstantInt *CmpZero = dyn_cast<ConstantInt>(Cond->getOperand(1));
if (!CmpZero || !CmpZero->isZero())
  return nullptr;

ICmpInst::Predicate Pred = Cond->getPredicate();
if ((Pred == ICmpInst::ICMP_NE && BI->getSuccessor(0) == LoopEntry) ||
    (Pred == ICmpInst::ICMP_EQ && BI->getSuccessor(1) == LoopEntry))
  return Cond->getOperand(0);

return nullptr;
1125}

1127// Check if the recurrence variable `VarX` is in the right form to create
1128// the idiom. Returns the value coerced to a PHINode if so.
1129static PHINode *getRecurrenceVar(Value *VarX, Instruction *DefX,
                               BasicBlock *LoopEntry) {
auto *PhiX = dyn_cast<PHINode>(VarX);
if (PhiX && PhiX->getParent() == LoopEntry &&
    (PhiX->getOperand(0) == DefX || PhiX->getOperand(1) == DefX))
  return PhiX;
return nullptr;
1136}

1138/// Return true iff the idiom is detected in the loop.
1139///
1140/// Additionally:
1141/// 1) \p CntInst is set to the instruction counting the population bit.
1142/// 2) \p CntPhi is set to the corresponding phi node.
1143/// 3) \p Var is set to the value whose population bits are being counted.
1144///
1145/// The core idiom we are trying to detect is:
1146/// \code
1147///    if (x0 != 0)
1148///      goto loop-exit // the precondition of the loop
1149///    cnt0 = init-val;
1150///    do {
1151///       x1 = phi (x0, x2);
1152///       cnt1 = phi(cnt0, cnt2);
1153///
1154///       cnt2 = cnt1 + 1;
1155///        ...
1156///       x2 = x1 & (x1 - 1);
1157///        ...
1158///    } while(x != 0);
1159///
1160/// loop-exit:
1161/// \endcode
1162static bool detectPopcountIdiom(Loop *CurLoop, BasicBlock *PreCondBB,
                              Instruction *&CntInst, PHINode *&CntPhi,
                              Value *&Var) {
// step 1: Check to see if the look-back branch match this pattern:
//    "if (a!=0) goto loop-entry".
BasicBlock *LoopEntry;
Instruction *DefX2, *CountInst;
Value *VarX1, *VarX0;
PHINode *PhiX, *CountPhi;

DefX2 = CountInst = nullptr;
VarX1 = VarX0 = nullptr;
PhiX = CountPhi = nullptr;
LoopEntry = *(CurLoop->block_begin());

// step 1: Check if the loop-back branch is in desirable form.
{
  if (Value *T = matchCondition(
          dyn_cast<BranchInst>(LoopEntry->getTerminator()), LoopEntry))
    DefX2 = dyn_cast<Instruction>(T);
  else
    return false;
}

// step 2: detect instructions corresponding to "x2 = x1 & (x1 - 1)"
{
  if (!DefX2 || DefX2->getOpcode() != Instruction::And)
    return false;

  BinaryOperator *SubOneOp;

  if ((SubOneOp = dyn_cast<BinaryOperator>(DefX2->getOperand(0))))
    VarX1 = DefX2->getOperand(1);
  else {
    VarX1 = DefX2->getOperand(0);
    SubOneOp = dyn_cast<BinaryOperator>(DefX2->getOperand(1));
  }
  if (!SubOneOp)
    return false;

  Instruction *SubInst = cast<Instruction>(SubOneOp);
  ConstantInt *Dec = dyn_cast<ConstantInt>(SubInst->getOperand(1));
  if (!Dec ||
      !((SubInst->getOpcode() == Instruction::Sub && Dec->isOne()) ||
        (SubInst->getOpcode() == Instruction::Add &&
         Dec->isMinusOne()))) {
    return false;
  }
}

// step 3: Check the recurrence of variable X
PhiX = getRecurrenceVar(VarX1, DefX2, LoopEntry);
if (!PhiX)
  return false;

// step 4: Find the instruction which count the population: cnt2 = cnt1 + 1
{
  CountInst = nullptr;
  for (BasicBlock::iterator Iter = LoopEntry->getFirstNonPHI()->getIterator(),
                            IterE = LoopEntry->end();
       Iter != IterE; Iter++) {
    Instruction *Inst = &*Iter;
    if (Inst->getOpcode() != Instruction::Add)
      continue;

    ConstantInt *Inc = dyn_cast<ConstantInt>(Inst->getOperand(1));
    if (!Inc || !Inc->isOne())
      continue;

    PHINode *Phi = getRecurrenceVar(Inst->getOperand(0), Inst, LoopEntry);
    if (!Phi)
      continue;

    // Check if the result of the instruction is live of the loop.
    bool LiveOutLoop = false;
    for (User *U : Inst->users()) {
      if ((cast<Instruction>(U))->getParent() != LoopEntry) {
        LiveOutLoop = true;
        break;
      }
    }

    if (LiveOutLoop) {
      CountInst = Inst;
      CountPhi = Phi;
      break;
    }
  }

  if (!CountInst)
    return false;
}

// step 5: check if the precondition is in this form:
//   "if (x != 0) goto loop-head ; else goto somewhere-we-don't-care;"
{
  auto *PreCondBr = dyn_cast<BranchInst>(PreCondBB->getTerminator());
  Value *T = matchCondition(PreCondBr, CurLoop->getLoopPreheader());
  if (T != PhiX->getOperand(0) && T != PhiX->getOperand(1))
    return false;

  CntInst = CountInst;
  CntPhi = CountPhi;
  Var = T;
}

return true;
1269}

1271/// Return true if the idiom is detected in the loop.
1272///
1273/// Additionally:
1274/// 1) \p CntInst is set to the instruction Counting Leading Zeros (CTLZ)
1275///       or nullptr if there is no such.
1276/// 2) \p CntPhi is set to the corresponding phi node
1277///       or nullptr if there is no such.
1278/// 3) \p Var is set to the value whose CTLZ could be used.
1279/// 4) \p DefX is set to the instruction calculating Loop exit condition.
1280///
1281/// The core idiom we are trying to detect is:
1282/// \code
1283///    if (x0 == 0)
1284///      goto loop-exit // the precondition of the loop
1285///    cnt0 = init-val;
1286///    do {
1287///       x = phi (x0, x.next);   //PhiX
1288///       cnt = phi(cnt0, cnt.next);
1289///
1290///       cnt.next = cnt + 1;
1291///        ...
1292///       x.next = x >> 1;   // DefX
1293///        ...
1294///    } while(x.next != 0);
1295///
1296/// loop-exit:
1297/// \endcode
1298static bool detectCTLZIdiom(Loop *CurLoop, PHINode *&PhiX,
                          Instruction *&CntInst, PHINode *&CntPhi,
                          Instruction *&DefX) {
BasicBlock *LoopEntry;
Value *VarX = nullptr;

DefX = nullptr;
PhiX = nullptr;
CntInst = nullptr;
CntPhi = nullptr;
LoopEntry = *(CurLoop->block_begin());

// step 1: Check if the loop-back branch is in desirable form.
if (Value *T = matchCondition(
        dyn_cast<BranchInst>(LoopEntry->getTerminator()), LoopEntry))
  DefX = dyn_cast<Instruction>(T);
else
  return false;

// step 2: detect instructions corresponding to "x.next = x >> 1"
if (!DefX || DefX->getOpcode() != Instruction::AShr)
  return false;
ConstantInt *Shft = dyn_cast<ConstantInt>(DefX->getOperand(1));
if (!Shft || !Shft->isOne())
  return false;
VarX = DefX->getOperand(0);

// step 3: Check the recurrence of variable X
PhiX = getRecurrenceVar(VarX, DefX, LoopEntry);
if (!PhiX)
  return false;

// step 4: Find the instruction which count the CTLZ: cnt.next = cnt + 1
// TODO: We can skip the step. If loop trip count is known (CTLZ),
//       then all uses of "cnt.next" could be optimized to the trip count
//       plus "cnt0". Currently it is not optimized.
//       This step could be used to detect POPCNT instruction:
//       cnt.next = cnt + (x.next & 1)
for (BasicBlock::iterator Iter = LoopEntry->getFirstNonPHI()->getIterator(),
                          IterE = LoopEntry->end();
     Iter != IterE; Iter++) {
  Instruction *Inst = &*Iter;
  if (Inst->getOpcode() != Instruction::Add)
    continue;

  ConstantInt *Inc = dyn_cast<ConstantInt>(Inst->getOperand(1));
  if (!Inc || !Inc->isOne())
    continue;

  PHINode *Phi = getRecurrenceVar(Inst->getOperand(0), Inst, LoopEntry);
  if (!Phi)
    continue;

  CntInst = Inst;
  CntPhi = Phi;
  break;
}
if (!CntInst)
  return false;

return true;
1359}

1361/// Recognize CTLZ idiom in a non-countable loop and convert the loop
1362/// to countable (with CTLZ trip count).
1363/// If CTLZ inserted as a new trip count returns true; otherwise, returns false.
1364bool LoopIdiomRecognize::recognizeAndInsertCTLZ() {
// Give up if the loop has multiple blocks or multiple backedges.
if (CurLoop->getNumBackEdges() != 1 || CurLoop->getNumBlocks() != 1)
11
←
Assuming the condition is false→
12
←
Assuming the condition is false→
13
←
Taking false branch→
  return false;

Instruction *CntInst, *DefX;
PHINode *CntPhi, *PhiX;
if (!detectCTLZIdiom(CurLoop, PhiX, CntInst, CntPhi, DefX))
14
←
Taking false branch→
  return false;

bool IsCntPhiUsedOutsideLoop = false;
for (User *U : CntPhi->users())
  if (!CurLoop->contains(dyn_cast<Instruction>(U))) {
    IsCntPhiUsedOutsideLoop = true;
    break;
  }
bool IsCntInstUsedOutsideLoop = false;
for (User *U : CntInst->users())
  if (!CurLoop->contains(dyn_cast<Instruction>(U))) {
    IsCntInstUsedOutsideLoop = true;
    break;
  }
// If both CntInst and CntPhi are used outside the loop the profitability
// is questionable.
if (IsCntInstUsedOutsideLoop && IsCntPhiUsedOutsideLoop)
  return false;

// For some CPUs result of CTLZ(X) intrinsic is undefined
// when X is 0. If we can not guarantee X != 0, we need to check this
// when expand.
bool ZeroCheck = false;
// It is safe to assume Preheader exist as it was checked in
// parent function RunOnLoop.
BasicBlock *PH = CurLoop->getLoopPreheader();
Value *InitX = PhiX->getIncomingValueForBlock(PH);
15
←
Calling 'PHINode::getIncomingValueForBlock'→
19
←
Returning from 'PHINode::getIncomingValueForBlock'→
20
←
'InitX' initialized here→
// If we check X != 0 before entering the loop we don't need a zero
// check in CTLZ intrinsic, but only if Cnt Phi is not used outside of the
// loop (if it is used we count CTLZ(X >> 1)).
if (!IsCntPhiUsedOutsideLoop)
21
←
Taking true branch→
  if (BasicBlock *PreCondBB = PH->getSinglePredecessor())
22
←
Assuming 'PreCondBB' is non-null→
23
←
Taking true branch→
    if (BranchInst *PreCondBr =
24
←
Assuming 'PreCondBr' is non-null→
25
←
Taking true branch→
        dyn_cast<BranchInst>(PreCondBB->getTerminator())) {
      if (matchCondition(PreCondBr, PH) == InitX)
26
←
Assuming the condition is true→
27
←
Assuming pointer value is null→
28
←
Taking true branch→
        ZeroCheck = true;
    }

// Check if CTLZ intrinsic is profitable. Assume it is always profitable
// if we delete the loop (the loop has only 6 instructions):
//  %n.addr.0 = phi [ %n, %entry ], [ %shr, %while.cond ]
//  %i.0 = phi [ %i0, %entry ], [ %inc, %while.cond ]
//  %shr = ashr %n.addr.0, 1
//  %tobool = icmp eq %shr, 0
//  %inc = add nsw %i.0, 1
//  br i1 %tobool

IRBuilder<> Builder(PH->getTerminator());
SmallVector<const Value *, 2> Ops =
    {InitX, ZeroCheck ? Builder.getTrue() : Builder.getFalse()};
29
←
'?' condition is true→
ArrayRef<const Value *> Args(Ops);
if (CurLoop->getHeader()->size() != 6 &&
30
←
Assuming the condition is true→
    TTI->getIntrinsicCost(Intrinsic::ctlz, InitX->getType(), Args) >
31
←
Called C++ object pointer is null
        TargetTransformInfo::TCC_Basic)
  return false;

const DebugLoc DL = DefX->getDebugLoc();
transformLoopToCountable(PH, CntInst, CntPhi, InitX, DL, ZeroCheck,
                         IsCntPhiUsedOutsideLoop);
return true;
1432}

1434/// Recognizes a population count idiom in a non-countable loop.
1435///
1436/// If detected, transforms the relevant code to issue the popcount intrinsic
1437/// function call, and returns true; otherwise, returns false.
1438bool LoopIdiomRecognize::recognizePopcount() {
if (TTI->getPopcntSupport(32) != TargetTransformInfo::PSK_FastHardware)
  return false;

// Counting population are usually conducted by few arithmetic instructions.
// Such instructions can be easily "absorbed" by vacant slots in a
// non-compact loop. Therefore, recognizing popcount idiom only makes sense
// in a compact loop.

// Give up if the loop has multiple blocks or multiple backedges.
if (CurLoop->getNumBackEdges() != 1 || CurLoop->getNumBlocks() != 1)
  return false;

BasicBlock *LoopBody = *(CurLoop->block_begin());
if (LoopBody->size() >= 20) {
  // The loop is too big, bail out.
  return false;
}

// It should have a preheader containing nothing but an unconditional branch.
BasicBlock *PH = CurLoop->getLoopPreheader();
if (!PH || &PH->front() != PH->getTerminator())
  return false;
auto *EntryBI = dyn_cast<BranchInst>(PH->getTerminator());
if (!EntryBI || EntryBI->isConditional())
  return false;

// It should have a precondition block where the generated popcount instrinsic
// function can be inserted.
auto *PreCondBB = PH->getSinglePredecessor();
if (!PreCondBB)
  return false;
auto *PreCondBI = dyn_cast<BranchInst>(PreCondBB->getTerminator());
if (!PreCondBI || PreCondBI->isUnconditional())
  return false;

Instruction *CntInst;
PHINode *CntPhi;
Value *Val;
if (!detectPopcountIdiom(CurLoop, PreCondBB, CntInst, CntPhi, Val))
  return false;

transformLoopToPopcount(PreCondBB, CntInst, CntPhi, Val);
return true;
1482}

1484static CallInst *createPopcntIntrinsic(IRBuilder<> &IRBuilder, Value *Val,
                                     const DebugLoc &DL) {
Value *Ops[] = {Val};
Type *Tys[] = {Val->getType()};

Module *M = IRBuilder.GetInsertBlock()->getParent()->getParent();
Value *Func = Intrinsic::getDeclaration(M, Intrinsic::ctpop, Tys);
CallInst *CI = IRBuilder.CreateCall(Func, Ops);
CI->setDebugLoc(DL);

return CI;
1495}

1497static CallInst *createCTLZIntrinsic(IRBuilder<> &IRBuilder, Value *Val,
                                   const DebugLoc &DL, bool ZeroCheck) {
Value *Ops[] = {Val, ZeroCheck ? IRBuilder.getTrue() : IRBuilder.getFalse()};
Type *Tys[] = {Val->getType()};

Module *M = IRBuilder.GetInsertBlock()->getParent()->getParent();
Value *Func = Intrinsic::getDeclaration(M, Intrinsic::ctlz, Tys);
CallInst *CI = IRBuilder.CreateCall(Func, Ops);
CI->setDebugLoc(DL);

return CI;
1508}

1510/// Transform the following loop:
1511/// loop:
1512///   CntPhi = PHI [Cnt0, CntInst]
1513///   PhiX = PHI [InitX, DefX]
1514///   CntInst = CntPhi + 1
1515///   DefX = PhiX >> 1
1516///   LOOP_BODY
1517///   Br: loop if (DefX != 0)
1518/// Use(CntPhi) or Use(CntInst)
1519///
1520/// Into:
1521/// If CntPhi used outside the loop:
1522///   CountPrev = BitWidth(InitX) - CTLZ(InitX >> 1)
1523///   Count = CountPrev + 1
1524/// else
1525///   Count = BitWidth(InitX) - CTLZ(InitX)
1526/// loop:
1527///   CntPhi = PHI [Cnt0, CntInst]
1528///   PhiX = PHI [InitX, DefX]
1529///   PhiCount = PHI [Count, Dec]
1530///   CntInst = CntPhi + 1
1531///   DefX = PhiX >> 1
1532///   Dec = PhiCount - 1
1533///   LOOP_BODY
1534///   Br: loop if (Dec != 0)
1535/// Use(CountPrev + Cnt0) // Use(CntPhi)
1536/// or
1537/// Use(Count + Cnt0) // Use(CntInst)
1538///
1539/// If LOOP_BODY is empty the loop will be deleted.
1540/// If CntInst and DefX are not used in LOOP_BODY they will be removed.
1541void LoopIdiomRecognize::transformLoopToCountable(
  BasicBlock *Preheader, Instruction *CntInst, PHINode *CntPhi, Value *InitX,
  const DebugLoc DL, bool ZeroCheck, bool IsCntPhiUsedOutsideLoop) {
BranchInst *PreheaderBr = dyn_cast<BranchInst>(Preheader->getTerminator());

// Step 1: Insert the CTLZ instruction at the end of the preheader block
//   Count = BitWidth - CTLZ(InitX);
// If there are uses of CntPhi create:
//   CountPrev = BitWidth - CTLZ(InitX >> 1);
IRBuilder<> Builder(PreheaderBr);
Builder.SetCurrentDebugLocation(DL);
Value *CTLZ, *Count, *CountPrev, *NewCount, *InitXNext;

if (IsCntPhiUsedOutsideLoop)
  InitXNext = Builder.CreateAShr(InitX,
                                 ConstantInt::get(InitX->getType(), 1));
else
  InitXNext = InitX;
CTLZ = createCTLZIntrinsic(Builder, InitXNext, DL, ZeroCheck);
Count = Builder.CreateSub(
    ConstantInt::get(CTLZ->getType(),
                     CTLZ->getType()->getIntegerBitWidth()),
    CTLZ);
if (IsCntPhiUsedOutsideLoop) {
  CountPrev = Count;
  Count = Builder.CreateAdd(
      CountPrev,
      ConstantInt::get(CountPrev->getType(), 1));
}
if (IsCntPhiUsedOutsideLoop)
  NewCount = Builder.CreateZExtOrTrunc(CountPrev,
      cast<IntegerType>(CntInst->getType()));
else
  NewCount = Builder.CreateZExtOrTrunc(Count,
      cast<IntegerType>(CntInst->getType()));

// If the CTLZ counter's initial value is not zero, insert Add Inst.
Value *CntInitVal = CntPhi->getIncomingValueForBlock(Preheader);
ConstantInt *InitConst = dyn_cast<ConstantInt>(CntInitVal);
if (!InitConst || !InitConst->isZero())
  NewCount = Builder.CreateAdd(NewCount, CntInitVal);

// Step 2: Insert new IV and loop condition:
// loop:
//   ...
//   PhiCount = PHI [Count, Dec]
//   ...
//   Dec = PhiCount - 1
//   ...
//   Br: loop if (Dec != 0)
BasicBlock *Body = *(CurLoop->block_begin());
auto *LbBr = dyn_cast<BranchInst>(Body->getTerminator());
ICmpInst *LbCond = cast<ICmpInst>(LbBr->getCondition());
Type *Ty = Count->getType();

PHINode *TcPhi = PHINode::Create(Ty, 2, "tcphi", &Body->front());

Builder.SetInsertPoint(LbCond);
Instruction *TcDec = cast<Instruction>(
    Builder.CreateSub(TcPhi, ConstantInt::get(Ty, 1),
                      "tcdec", false, true));

TcPhi->addIncoming(Count, Preheader);
TcPhi->addIncoming(TcDec, Body);

CmpInst::Predicate Pred =
    (LbBr->getSuccessor(0) == Body) ? CmpInst::ICMP_NE : CmpInst::ICMP_EQ;
LbCond->setPredicate(Pred);
LbCond->setOperand(0, TcDec);
LbCond->setOperand(1, ConstantInt::get(Ty, 0));

// Step 3: All the references to the original counter outside
//  the loop are replaced with the NewCount -- the value returned from
//  __builtin_ctlz(x).
if (IsCntPhiUsedOutsideLoop)
  CntPhi->replaceUsesOutsideBlock(NewCount, Body);
else
  CntInst->replaceUsesOutsideBlock(NewCount, Body);

// step 4: Forget the "non-computable" trip-count SCEV associated with the
//   loop. The loop would otherwise not be deleted even if it becomes empty.
SE->forgetLoop(CurLoop);
1623}

1625void LoopIdiomRecognize::transformLoopToPopcount(BasicBlock *PreCondBB,
                                               Instruction *CntInst,
                                               PHINode *CntPhi, Value *Var) {
BasicBlock *PreHead = CurLoop->getLoopPreheader();
auto *PreCondBr = dyn_cast<BranchInst>(PreCondBB->getTerminator());
const DebugLoc DL = CntInst->getDebugLoc();

// Assuming before transformation, the loop is following:
//  if (x) // the precondition
//     do { cnt++; x &= x - 1; } while(x);

// Step 1: Insert the ctpop instruction at the end of the precondition block
IRBuilder<> Builder(PreCondBr);
Value *PopCnt, *PopCntZext, *NewCount, *TripCnt;
{
  PopCnt = createPopcntIntrinsic(Builder, Var, DL);
  NewCount = PopCntZext =
      Builder.CreateZExtOrTrunc(PopCnt, cast<IntegerType>(CntPhi->getType()));

  if (NewCount != PopCnt)
    (cast<Instruction>(NewCount))->setDebugLoc(DL);

  // TripCnt is exactly the number of iterations the loop has
  TripCnt = NewCount;

  // If the population counter's initial value is not zero, insert Add Inst.
  Value *CntInitVal = CntPhi->getIncomingValueForBlock(PreHead);
  ConstantInt *InitConst = dyn_cast<ConstantInt>(CntInitVal);
  if (!InitConst || !InitConst->isZero()) {
    NewCount = Builder.CreateAdd(NewCount, CntInitVal);
    (cast<Instruction>(NewCount))->setDebugLoc(DL);
  }
}

// Step 2: Replace the precondition from "if (x == 0) goto loop-exit" to
//   "if (NewCount == 0) loop-exit". Without this change, the intrinsic
//   function would be partial dead code, and downstream passes will drag
//   it back from the precondition block to the preheader.
{
  ICmpInst *PreCond = cast<ICmpInst>(PreCondBr->getCondition());

  Value *Opnd0 = PopCntZext;
  Value *Opnd1 = ConstantInt::get(PopCntZext->getType(), 0);
  if (PreCond->getOperand(0) != Var)
    std::swap(Opnd0, Opnd1);

  ICmpInst *NewPreCond = cast<ICmpInst>(
      Builder.CreateICmp(PreCond->getPredicate(), Opnd0, Opnd1));
  PreCondBr->setCondition(NewPreCond);

  RecursivelyDeleteTriviallyDeadInstructions(PreCond, TLI);
}

// Step 3: Note that the population count is exactly the trip count of the
// loop in question, which enable us to convert the loop from noncountable
// loop into a countable one. The benefit is twofold:
//
//  - If the loop only counts population, the entire loop becomes dead after
//    the transformation. It is a lot easier to prove a countable loop dead
//    than to prove a noncountable one. (In some C dialects, an infinite loop
//    isn't dead even if it computes nothing useful. In general, DCE needs
//    to prove a noncountable loop finite before safely delete it.)
//
//  - If the loop also performs something else, it remains alive.
//    Since it is transformed to countable form, it can be aggressively
//    optimized by some optimizations which are in general not applicable
//    to a noncountable loop.
//
// After this step, this loop (conceptually) would look like following:
//   newcnt = __builtin_ctpop(x);
//   t = newcnt;
//   if (x)
//     do { cnt++; x &= x-1; t--) } while (t > 0);
BasicBlock *Body = *(CurLoop->block_begin());
{
  auto *LbBr = dyn_cast<BranchInst>(Body->getTerminator());
  ICmpInst *LbCond = cast<ICmpInst>(LbBr->getCondition());
  Type *Ty = TripCnt->getType();

  PHINode *TcPhi = PHINode::Create(Ty, 2, "tcphi", &Body->front());

  Builder.SetInsertPoint(LbCond);
  Instruction *TcDec = cast<Instruction>(
      Builder.CreateSub(TcPhi, ConstantInt::get(Ty, 1),
                        "tcdec", false, true));

  TcPhi->addIncoming(TripCnt, PreHead);
  TcPhi->addIncoming(TcDec, Body);

  CmpInst::Predicate Pred =
      (LbBr->getSuccessor(0) == Body) ? CmpInst::ICMP_UGT : CmpInst::ICMP_SLE;
  LbCond->setPredicate(Pred);
  LbCond->setOperand(0, TcDec);
  LbCond->setOperand(1, ConstantInt::get(Ty, 0));
}

// Step 4: All the references to the original population counter outside
//  the loop are replaced with the NewCount -- the value returned from
//  __builtin_ctpop().
CntInst->replaceUsesOutsideBlock(NewCount, Body);

// step 5: Forget the "non-computable" trip-count SCEV associated with the
//   loop. The loop would otherwise not be deleted even if it becomes empty.
SE->forgetLoop(CurLoop);
1729}

←

/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h

1//===- llvm/Instructions.h - Instruction subclass definitions ---*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file exposes the class definitions of all of the subclasses of the
11// Instruction class.  This is meant to be an easy way to get access to all
12// instruction subclasses.
13//
14//===----------------------------------------------------------------------===//

16#ifndef LLVM_IR_INSTRUCTIONS_H
17#define LLVM_IR_INSTRUCTIONS_H

19#include "llvm/ADT/ArrayRef.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/Constant.h"
31#include "llvm/IR/DerivedTypes.h"
32#include "llvm/IR/Function.h"
33#include "llvm/IR/InstrTypes.h"
34#include "llvm/IR/Instruction.h"
35#include "llvm/IR/OperandTraits.h"
36#include "llvm/IR/Type.h"
37#include "llvm/IR/Use.h"
38#include "llvm/IR/User.h"
39#include "llvm/IR/Value.h"
40#include "llvm/Support/AtomicOrdering.h"
41#include "llvm/Support/Casting.h"
42#include "llvm/Support/ErrorHandling.h"
43#include <cassert>
44#include <cstddef>
45#include <cstdint>
46#include <iterator>

48namespace llvm {

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

55//===----------------------------------------------------------------------===//
56//                                AllocaInst Class
57//===----------------------------------------------------------------------===//

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

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

AllocaInst *cloneImpl() const;

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

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

AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize, unsigned Align,
           const Twine &Name = "", Instruction *InsertBefore = nullptr);
AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize, unsigned 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());
}

/// 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.
unsigned getAlignment() const {
  return (1u << (getSubclassDataFromInstruction() & 31)) >> 1;
}
void setAlignment(unsigned Align);

/// 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 getSubclassDataFromInstruction() & 32;
}

/// Specify whether this alloca is used to represent the arguments to a call.
void setUsedWithInAlloca(bool V) {
  setInstructionSubclassData((getSubclassDataFromInstruction() & ~32) |
                             (V ? 32 : 0));
}

/// Return true if this alloca is used as a swifterror argument to a call.
bool isSwiftError() const {
  return getSubclassDataFromInstruction() & 64;
}

/// Specify whether this alloca is used to represent a swifterror.
void setSwiftError(bool V) {
  setInstructionSubclassData((getSubclassDataFromInstruction() & ~64) |
                             (V ? 64 : 0));
}

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

150private:
// Shadow Instruction::setInstructionSubclassData with a private forwarding
// method so that subclasses cannot accidentally use it.
void setInstructionSubclassData(unsigned short D) {
  Instruction::setInstructionSubclassData(D);
}
156};

158//===----------------------------------------------------------------------===//
159//                                LoadInst Class
160//===----------------------------------------------------------------------===//

162/// An instruction for reading from memory. This uses the SubclassData field in
163/// Value to store whether or not the load is volatile.
164class LoadInst : public UnaryInstruction {
void AssertOK();

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

LoadInst *cloneImpl() const;

173public:
LoadInst(Value *Ptr, const Twine &NameStr, Instruction *InsertBefore);
LoadInst(Value *Ptr, const Twine &NameStr, BasicBlock *InsertAtEnd);
LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile = false,
         Instruction *InsertBefore = nullptr);
LoadInst(Value *Ptr, const Twine &NameStr, bool isVolatile = false,
         Instruction *InsertBefore = nullptr)
    : LoadInst(cast<PointerType>(Ptr->getType())->getElementType(), Ptr,
               NameStr, isVolatile, InsertBefore) {}
LoadInst(Value *Ptr, const Twine &NameStr, bool isVolatile,
         BasicBlock *InsertAtEnd);
LoadInst(Value *Ptr, const Twine &NameStr, bool isVolatile, unsigned Align,
         Instruction *InsertBefore = nullptr)
    : LoadInst(cast<PointerType>(Ptr->getType())->getElementType(), Ptr,
               NameStr, isVolatile, Align, InsertBefore) {}
LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
         unsigned Align, Instruction *InsertBefore = nullptr);
LoadInst(Value *Ptr, const Twine &NameStr, bool isVolatile,
         unsigned Align, BasicBlock *InsertAtEnd);
LoadInst(Value *Ptr, const Twine &NameStr, bool isVolatile, unsigned Align,
         AtomicOrdering Order, SyncScope::ID SSID = SyncScope::System,
         Instruction *InsertBefore = nullptr)
    : LoadInst(cast<PointerType>(Ptr->getType())->getElementType(), Ptr,
               NameStr, isVolatile, Align, Order, SSID, InsertBefore) {}
LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
         unsigned Align, AtomicOrdering Order,
         SyncScope::ID SSID = SyncScope::System,
         Instruction *InsertBefore = nullptr);
LoadInst(Value *Ptr, const Twine &NameStr, bool isVolatile,
         unsigned Align, AtomicOrdering Order, SyncScope::ID SSID,
         BasicBlock *InsertAtEnd);
LoadInst(Value *Ptr, const char *NameStr, Instruction *InsertBefore);
LoadInst(Value *Ptr, const char *NameStr, BasicBlock *InsertAtEnd);
LoadInst(Type *Ty, Value *Ptr, const char *NameStr = nullptr,
         bool isVolatile = false, Instruction *InsertBefore = nullptr);
explicit LoadInst(Value *Ptr, const char *NameStr = nullptr,
                  bool isVolatile = false,
                  Instruction *InsertBefore = nullptr)
    : LoadInst(cast<PointerType>(Ptr->getType())->getElementType(), Ptr,
               NameStr, isVolatile, InsertBefore) {}
LoadInst(Value *Ptr, const char *NameStr, bool isVolatile,
         BasicBlock *InsertAtEnd);

/// Return true if this is a load from a volatile memory location.
bool isVolatile() const { return getSubclassDataFromInstruction() & 1; }

/// Specify whether this is a volatile load or not.
void setVolatile(bool V) {
  setInstructionSubclassData((getSubclassDataFromInstruction() & ~1) |
                             (V ? 1 : 0));
}

/// Return the alignment of the access that is being performed.
unsigned getAlignment() const {
  return (1 << ((getSubclassDataFromInstruction() >> 1) & 31)) >> 1;
}

void setAlignment(unsigned Align);

/// Returns the ordering constraint of this load instruction.
AtomicOrdering getOrdering() const {
  return AtomicOrdering((getSubclassDataFromInstruction() >> 7) & 7);
}

/// Sets the ordering constraint of this load instruction.  May not be Release
/// or AcquireRelease.
void setOrdering(AtomicOrdering Ordering) {
  setInstructionSubclassData((getSubclassDataFromInstruction() & ~(7 << 7)) |
                             ((unsigned)Ordering << 7));
}

/// 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 ||
          getOrdering() == AtomicOrdering::Unordered) &&
         !isVolatile();
}

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

288private:
// Shadow Instruction::setInstructionSubclassData with a private forwarding
// method so that subclasses cannot accidentally use it.
void setInstructionSubclassData(unsigned short D) {
  Instruction::setInstructionSubclassData(D);
}

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

301//===----------------------------------------------------------------------===//
302//                                StoreInst Class
303//===----------------------------------------------------------------------===//

305/// An instruction for storing to memory.
306class StoreInst : public Instruction {
void AssertOK();

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

StoreInst *cloneImpl() const;

315public:
StoreInst(Value *Val, Value *Ptr, Instruction *InsertBefore);
StoreInst(Value *Val, Value *Ptr, BasicBlock *InsertAtEnd);
StoreInst(Value *Val, Value *Ptr, bool isVolatile = false,
          Instruction *InsertBefore = nullptr);
StoreInst(Value *Val, Value *Ptr, bool isVolatile, BasicBlock *InsertAtEnd);
StoreInst(Value *Val, Value *Ptr, bool isVolatile,
          unsigned Align, Instruction *InsertBefore = nullptr);
StoreInst(Value *Val, Value *Ptr, bool isVolatile,
          unsigned Align, BasicBlock *InsertAtEnd);
StoreInst(Value *Val, Value *Ptr, bool isVolatile,
          unsigned Align, AtomicOrdering Order,
          SyncScope::ID SSID = SyncScope::System,
          Instruction *InsertBefore = nullptr);
StoreInst(Value *Val, Value *Ptr, bool isVolatile,
          unsigned 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 getSubclassDataFromInstruction() & 1; }

/// Specify whether this is a volatile store or not.
void setVolatile(bool V) {
  setInstructionSubclassData((getSubclassDataFromInstruction() & ~1) |
                             (V ? 1 : 0));
}

/// 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
unsigned getAlignment() const {
  return (1 << ((getSubclassDataFromInstruction() >> 1) & 31)) >> 1;
}

void setAlignment(unsigned Align);

/// Returns the ordering constraint of this store instruction.
AtomicOrdering getOrdering() const {
  return AtomicOrdering((getSubclassDataFromInstruction() >> 7) & 7);
}

/// Sets the ordering constraint of this store instruction.  May not be
/// Acquire or AcquireRelease.
void setOrdering(AtomicOrdering Ordering) {
  setInstructionSubclassData((getSubclassDataFromInstruction() & ~(7 << 7)) |
                             ((unsigned)Ordering << 7));
}

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

416private:
// Shadow Instruction::setInstructionSubclassData with a private forwarding
// method so that subclasses cannot accidentally use it.
void setInstructionSubclassData(unsigned short D) {
  Instruction::setInstructionSubclassData(D);
}

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

429template <>
430struct OperandTraits<StoreInst> : public FixedNumOperandTraits<StoreInst, 2> {
431};

433DEFINE_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 { (static_cast <bool> (i_nocapture
 < OperandTraits<StoreInst>::operands(this) &&
 "getOperand() out of range!") ? void (0) : __assert_fail ("i_nocapture < OperandTraits<StoreInst>::operands(this) && \"getOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 433, __extension__ __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) { (static_cast
 <bool> (i_nocapture < OperandTraits<StoreInst>
::operands(this) && "setOperand() out of range!") ? void
 (0) : __assert_fail ("i_nocapture < OperandTraits<StoreInst>::operands(this) && \"setOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 433, __extension__ __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); }

435//===----------------------------------------------------------------------===//
436//                                FenceInst Class
437//===----------------------------------------------------------------------===//

439/// An instruction for ordering other memory operations.
440class FenceInst : public Instruction {
void Init(AtomicOrdering Ordering, SyncScope::ID SSID);

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

FenceInst *cloneImpl() const;

449public:
// 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 AtomicOrdering(getSubclassDataFromInstruction() >> 1);
}

/// Sets the ordering constraint of this fence instruction.  May only be
/// Acquire, Release, AcquireRelease, or SequentiallyConsistent.
void setOrdering(AtomicOrdering Ordering) {
  setInstructionSubclassData((getSubclassDataFromInstruction() & 1) |
                             ((unsigned)Ordering << 1));
}

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

493private:
// Shadow Instruction::setInstructionSubclassData with a private forwarding
// method so that subclasses cannot accidentally use it.
void setInstructionSubclassData(unsigned short D) {
  Instruction::setInstructionSubclassData(D);
}

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

506//===----------------------------------------------------------------------===//
507//                                AtomicCmpXchgInst Class
508//===----------------------------------------------------------------------===//

510/// an instruction that atomically checks whether a
511/// specified value is in a memory location, and, if it is, stores a new value
512/// there.  Returns the value that was loaded.
513///
514class AtomicCmpXchgInst : public Instruction {
void Init(Value *Ptr, Value *Cmp, Value *NewVal,
          AtomicOrdering SuccessOrdering, AtomicOrdering FailureOrdering,
          SyncScope::ID SSID);

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

AtomicCmpXchgInst *cloneImpl() const;

525public:
AtomicCmpXchgInst(Value *Ptr, Value *Cmp, Value *NewVal,
                  AtomicOrdering SuccessOrdering,
                  AtomicOrdering FailureOrdering,
                  SyncScope::ID SSID, Instruction *InsertBefore = nullptr);
AtomicCmpXchgInst(Value *Ptr, Value *Cmp, Value *NewVal,
                  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);
}

/// Return true if this is a cmpxchg from a volatile memory
/// location.
///
bool isVolatile() const {
  return getSubclassDataFromInstruction() & 1;
}

/// Specify whether this is a volatile cmpxchg.
///
void setVolatile(bool V) {
   setInstructionSubclassData((getSubclassDataFromInstruction() & ~1) |
                              (unsigned)V);
}

/// Return true if this cmpxchg may spuriously fail.
bool isWeak() const {
  return getSubclassDataFromInstruction() & 0x100;
}

void setWeak(bool IsWeak) {
  setInstructionSubclassData((getSubclassDataFromInstruction() & ~0x100) |
                             (IsWeak << 8));
}

/// 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 AtomicOrdering((getSubclassDataFromInstruction() >> 2) & 7);
}

/// Sets the success ordering constraint of this cmpxchg instruction.
void setSuccessOrdering(AtomicOrdering Ordering) {
  assert(Ordering != AtomicOrdering::NotAtomic &&(static_cast <bool> (Ordering != AtomicOrdering::NotAtomic
 && "CmpXchg instructions can only be atomic.") ? void
 (0) : __assert_fail ("Ordering != AtomicOrdering::NotAtomic && \"CmpXchg instructions can only be atomic.\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 575, __extension__ __PRETTY_FUNCTION__))
         "CmpXchg instructions can only be atomic.")(static_cast <bool> (Ordering != AtomicOrdering::NotAtomic
 && "CmpXchg instructions can only be atomic.") ? void
 (0) : __assert_fail ("Ordering != AtomicOrdering::NotAtomic && \"CmpXchg instructions can only be atomic.\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 575, __extension__ __PRETTY_FUNCTION__));
  setInstructionSubclassData((getSubclassDataFromInstruction() & ~0x1c) |
                             ((unsigned)Ordering << 2));
}

/// Returns the failure ordering constraint of this cmpxchg instruction.
AtomicOrdering getFailureOrdering() const {
  return AtomicOrdering((getSubclassDataFromInstruction() >> 5) & 7);
}

/// Sets the failure ordering constraint of this cmpxchg instruction.
void setFailureOrdering(AtomicOrdering Ordering) {
  assert(Ordering != AtomicOrdering::NotAtomic &&(static_cast <bool> (Ordering != AtomicOrdering::NotAtomic
 && "CmpXchg instructions can only be atomic.") ? void
 (0) : __assert_fail ("Ordering != AtomicOrdering::NotAtomic && \"CmpXchg instructions can only be atomic.\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 588, __extension__ __PRETTY_FUNCTION__))
         "CmpXchg instructions can only be atomic.")(static_cast <bool> (Ordering != AtomicOrdering::NotAtomic
 && "CmpXchg instructions can only be atomic.") ? void
 (0) : __assert_fail ("Ordering != AtomicOrdering::NotAtomic && \"CmpXchg instructions can only be atomic.\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 588, __extension__ __PRETTY_FUNCTION__));
  setInstructionSubclassData((getSubclassDataFromInstruction() & ~0xe0) |
                             ((unsigned)Ordering << 5));
}

/// 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-7~svn329677/include/llvm/IR/Instructions.h"
, 629);
  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));
}

649private:
// Shadow Instruction::setInstructionSubclassData with a private forwarding
// method so that subclasses cannot accidentally use it.
void setInstructionSubclassData(unsigned short D) {
  Instruction::setInstructionSubclassData(D);
}

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

662template <>
663struct OperandTraits<AtomicCmpXchgInst> :
  public FixedNumOperandTraits<AtomicCmpXchgInst, 3> {
665};

667DEFINE_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 { (static_cast <bool> (i_nocapture <
 OperandTraits<AtomicCmpXchgInst>::operands(this) &&
 "getOperand() out of range!") ? void (0) : __assert_fail ("i_nocapture < OperandTraits<AtomicCmpXchgInst>::operands(this) && \"getOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 667, __extension__ __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) { (static_cast <bool> (i_nocapture
 < OperandTraits<AtomicCmpXchgInst>::operands(this) &&
 "setOperand() out of range!") ? void (0) : __assert_fail ("i_nocapture < OperandTraits<AtomicCmpXchgInst>::operands(this) && \"setOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 667, __extension__ __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
); }

669//===----------------------------------------------------------------------===//
670//                                AtomicRMWInst Class
671//===----------------------------------------------------------------------===//

673/// an instruction that atomically reads a memory location,
674/// combines it with another value, and then stores the result back.  Returns
675/// the old value.
676///
677class AtomicRMWInst : public Instruction {
678protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

AtomicRMWInst *cloneImpl() const;

684public:
/// 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 {
  /// *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,

  FIRST_BINOP = Xchg,
  LAST_BINOP = UMin,
  BAD_BINOP
};

AtomicRMWInst(BinOp Operation, Value *Ptr, Value *Val,
              AtomicOrdering Ordering, SyncScope::ID SSID,
              Instruction *InsertBefore = nullptr);
AtomicRMWInst(BinOp Operation, Value *Ptr, Value *Val,
              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);
}

BinOp getOperation() const {
  return static_cast<BinOp>(getSubclassDataFromInstruction() >> 5);
}

void setOperation(BinOp Operation) {
  unsigned short SubclassData = getSubclassDataFromInstruction();
  setInstructionSubclassData((SubclassData & 31) |
                             (Operation << 5));
}

/// Return true if this is a RMW on a volatile memory location.
///
bool isVolatile() const {
  return getSubclassDataFromInstruction() & 1;
}

/// Specify whether this is a volatile RMW or not.
///
void setVolatile(bool V) {
   setInstructionSubclassData((getSubclassDataFromInstruction() & ~1) |
                              (unsigned)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 AtomicOrdering((getSubclassDataFromInstruction() >> 2) & 7);
}

/// Sets the ordering constraint of this rmw instruction.
void setOrdering(AtomicOrdering Ordering) {
  assert(Ordering != AtomicOrdering::NotAtomic &&(static_cast <bool> (Ordering != AtomicOrdering::NotAtomic
 && "atomicrmw instructions can only be atomic.") ? void
 (0) : __assert_fail ("Ordering != AtomicOrdering::NotAtomic && \"atomicrmw instructions can only be atomic.\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 764, __extension__ __PRETTY_FUNCTION__))
         "atomicrmw instructions can only be atomic.")(static_cast <bool> (Ordering != AtomicOrdering::NotAtomic
 && "atomicrmw instructions can only be atomic.") ? void
 (0) : __assert_fail ("Ordering != AtomicOrdering::NotAtomic && \"atomicrmw instructions can only be atomic.\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 764, __extension__ __PRETTY_FUNCTION__));
  setInstructionSubclassData((getSubclassDataFromInstruction() & ~(7 << 2)) |
                             ((unsigned)Ordering << 2));
}

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

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

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

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

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

815template <>
816struct OperandTraits<AtomicRMWInst>
  : public FixedNumOperandTraits<AtomicRMWInst,2> {
818};

820DEFINE_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 { (static_cast <bool> (i_nocapture
 < OperandTraits<AtomicRMWInst>::operands(this) &&
 "getOperand() out of range!") ? void (0) : __assert_fail ("i_nocapture < OperandTraits<AtomicRMWInst>::operands(this) && \"getOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 820, __extension__ __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) { (static_cast
 <bool> (i_nocapture < OperandTraits<AtomicRMWInst
>::operands(this) && "setOperand() out of range!")
 ? void (0) : __assert_fail ("i_nocapture < OperandTraits<AtomicRMWInst>::operands(this) && \"setOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 820, __extension__ __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); }

822//===----------------------------------------------------------------------===//
823//                             GetElementPtrInst Class
824//===----------------------------------------------------------------------===//

826// checkGEPType - Simple wrapper function to give a better assertion failure
827// message on bad indexes for a gep instruction.
828//
829inline Type *checkGEPType(Type *Ty) {
assert(Ty && "Invalid GetElementPtrInst indices for type!")(static_cast <bool> (Ty && "Invalid GetElementPtrInst indices for type!"
) ? void (0) : __assert_fail ("Ty && \"Invalid GetElementPtrInst indices for type!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 830, __extension__ __PRETTY_FUNCTION__));
return Ty;
832}

834/// an instruction for type-safe pointer arithmetic to
835/// access elements of arrays and structs
836///
837class 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);

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

GetElementPtrInst *cloneImpl() const;

862public:
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((static_cast <bool> (PointeeType == cast<PointerType
>(Ptr->getType()->getScalarType())->getElementType
()) ? void (0) : __assert_fail ("PointeeType == cast<PointerType>(Ptr->getType()->getScalarType())->getElementType()"
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 874, __extension__ __PRETTY_FUNCTION__))
        PointeeType ==(static_cast <bool> (PointeeType == cast<PointerType
>(Ptr->getType()->getScalarType())->getElementType
()) ? void (0) : __assert_fail ("PointeeType == cast<PointerType>(Ptr->getType()->getScalarType())->getElementType()"
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 874, __extension__ __PRETTY_FUNCTION__))
        cast<PointerType>(Ptr->getType()->getScalarType())->getElementType())(static_cast <bool> (PointeeType == cast<PointerType
>(Ptr->getType()->getScalarType())->getElementType
()) ? void (0) : __assert_fail ("PointeeType == cast<PointerType>(Ptr->getType()->getScalarType())->getElementType()"
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 874, __extension__ __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((static_cast <bool> (PointeeType == cast<PointerType
>(Ptr->getType()->getScalarType())->getElementType
()) ? void (0) : __assert_fail ("PointeeType == cast<PointerType>(Ptr->getType()->getScalarType())->getElementType()"
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 890, __extension__ __PRETTY_FUNCTION__))
        PointeeType ==(static_cast <bool> (PointeeType == cast<PointerType
>(Ptr->getType()->getScalarType())->getElementType
()) ? void (0) : __assert_fail ("PointeeType == cast<PointerType>(Ptr->getType()->getScalarType())->getElementType()"
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 890, __extension__ __PRETTY_FUNCTION__))
        cast<PointerType>(Ptr->getType()->getScalarType())->getElementType())(static_cast <bool> (PointeeType == cast<PointerType
>(Ptr->getType()->getScalarType())->getElementType
()) ? void (0) : __assert_fail ("PointeeType == cast<PointerType>(Ptr->getType()->getScalarType())->getElementType()"
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 890, __extension__ __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 ==(static_cast <bool> (ResultElementType == cast<PointerType
>(getType()->getScalarType())->getElementType()) ? void
 (0) : __assert_fail ("ResultElementType == cast<PointerType>(getType()->getScalarType())->getElementType()"
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 941, __extension__ __PRETTY_FUNCTION__))
         cast<PointerType>(getType()->getScalarType())->getElementType())(static_cast <bool> (ResultElementType == cast<PointerType
>(getType()->getScalarType())->getElementType()) ? void
 (0) : __assert_fail ("ResultElementType == cast<PointerType>(getType()->getScalarType())->getElementType()"
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 941, __extension__ __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 type of the element that would be loaded with
/// a load instruction with the specified parameters.
///
/// Null is returned if the indices are invalid for the specified
/// pointer 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);

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(Value *Ptr, ArrayRef<Value *> IdxList) {
  return getGEPReturnType(
    cast<PointerType>(Ptr->getType()->getScalarType())->getElementType(),
    Ptr, IdxList);
}
static Type *getGEPReturnType(Type *ElTy, Value *Ptr,
                              ArrayRef<Value *> IdxList) {
  Type *PtrTy = PointerType::get(checkGEPType(getIndexedType(ElTy, IdxList)),
                                 Ptr->getType()->getPointerAddressSpace());
  // Vector GEP
  if (Ptr->getType()->isVectorTy()) {
    unsigned NumElem = Ptr->getType()->getVectorNumElements();
    return VectorType::get(PtrTy, NumElem);
  }
  for (Value *Index : IdxList)
    if (Index->getType()->isVectorTy()) {
      unsigned NumElem = Index->getType()->getVectorNumElements();
      return VectorType::get(PtrTy, NumElem);
    }
  // 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));
}
1063};

1065template <>
1066struct OperandTraits<GetElementPtrInst> :
public VariadicOperandTraits<GetElementPtrInst, 1> {
1068};

1070GetElementPtrInst::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 ==(static_cast <bool> (ResultElementType == cast<PointerType
>(getType()->getScalarType())->getElementType()) ? void
 (0) : __assert_fail ("ResultElementType == cast<PointerType>(getType()->getScalarType())->getElementType()"
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 1080, __extension__ __PRETTY_FUNCTION__))
       cast<PointerType>(getType()->getScalarType())->getElementType())(static_cast <bool> (ResultElementType == cast<PointerType
>(getType()->getScalarType())->getElementType()) ? void
 (0) : __assert_fail ("ResultElementType == cast<PointerType>(getType()->getScalarType())->getElementType()"
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 1080, __extension__ __PRETTY_FUNCTION__));
init(Ptr, IdxList, NameStr);
1082}

1084GetElementPtrInst::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 ==(static_cast <bool> (ResultElementType == cast<PointerType
>(getType()->getScalarType())->getElementType()) ? void
 (0) : __assert_fail ("ResultElementType == cast<PointerType>(getType()->getScalarType())->getElementType()"
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 1094, __extension__ __PRETTY_FUNCTION__))
       cast<PointerType>(getType()->getScalarType())->getElementType())(static_cast <bool> (ResultElementType == cast<PointerType
>(getType()->getScalarType())->getElementType()) ? void
 (0) : __assert_fail ("ResultElementType == cast<PointerType>(getType()->getScalarType())->getElementType()"
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 1094, __extension__ __PRETTY_FUNCTION__));
init(Ptr, IdxList, NameStr);
1096}

1098DEFINE_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 { (static_cast <bool> (i_nocapture <
 OperandTraits<GetElementPtrInst>::operands(this) &&
 "getOperand() out of range!") ? void (0) : __assert_fail ("i_nocapture < OperandTraits<GetElementPtrInst>::operands(this) && \"getOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 1098, __extension__ __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) { (static_cast <bool> (i_nocapture
 < OperandTraits<GetElementPtrInst>::operands(this) &&
 "setOperand() out of range!") ? void (0) : __assert_fail ("i_nocapture < OperandTraits<GetElementPtrInst>::operands(this) && \"setOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 1098, __extension__ __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
); }

1100//===----------------------------------------------------------------------===//
1101//                               ICmpInst Class
1102//===----------------------------------------------------------------------===//

1104/// This instruction compares its operands according to the predicate given
1105/// to the constructor. It only operates on integers or pointers. The operands
1106/// must be identical types.
1107/// Represent an integer comparison operator.
1108class ICmpInst: public CmpInst {
void AssertOK() {
  assert(isIntPredicate() &&(static_cast <bool> (isIntPredicate() && "Invalid ICmp predicate value"
) ? void (0) : __assert_fail ("isIntPredicate() && \"Invalid ICmp predicate value\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 1111, __extension__ __PRETTY_FUNCTION__))
         "Invalid ICmp predicate value")(static_cast <bool> (isIntPredicate() && "Invalid ICmp predicate value"
) ? void (0) : __assert_fail ("isIntPredicate() && \"Invalid ICmp predicate value\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 1111, __extension__ __PRETTY_FUNCTION__));
  assert(getOperand(0)->getType() == getOperand(1)->getType() &&(static_cast <bool> (getOperand(0)->getType() == getOperand
(1)->getType() && "Both operands to ICmp instruction are not of the same type!"
) ? 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-7~svn329677/include/llvm/IR/Instructions.h"
, 1113, __extension__ __PRETTY_FUNCTION__))
        "Both operands to ICmp instruction are not of the same type!")(static_cast <bool> (getOperand(0)->getType() == getOperand
(1)->getType() && "Both operands to ICmp instruction are not of the same type!"
) ? 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-7~svn329677/include/llvm/IR/Instructions.h"
, 1113, __extension__ __PRETTY_FUNCTION__));
  // Check that the operands are the right type
  assert((getOperand(0)->getType()->isIntOrIntVectorTy() ||(static_cast <bool> ((getOperand(0)->getType()->isIntOrIntVectorTy
() || getOperand(0)->getType()->isPtrOrPtrVectorTy()) &&
 "Invalid operand types for ICmp instruction") ? void (0) : __assert_fail
 ("(getOperand(0)->getType()->isIntOrIntVectorTy() || getOperand(0)->getType()->isPtrOrPtrVectorTy()) && \"Invalid operand types for ICmp instruction\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 1117, __extension__ __PRETTY_FUNCTION__))
          getOperand(0)->getType()->isPtrOrPtrVectorTy()) &&(static_cast <bool> ((getOperand(0)->getType()->isIntOrIntVectorTy
() || getOperand(0)->getType()->isPtrOrPtrVectorTy()) &&
 "Invalid operand types for ICmp instruction") ? void (0) : __assert_fail
 ("(getOperand(0)->getType()->isIntOrIntVectorTy() || getOperand(0)->getType()->isPtrOrPtrVectorTy()) && \"Invalid operand types for ICmp instruction\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 1117, __extension__ __PRETTY_FUNCTION__))
         "Invalid operand types for ICmp instruction")(static_cast <bool> ((getOperand(0)->getType()->isIntOrIntVectorTy
() || getOperand(0)->getType()->isPtrOrPtrVectorTy()) &&
 "Invalid operand types for ICmp instruction") ? void (0) : __assert_fail
 ("(getOperand(0)->getType()->isIntOrIntVectorTy() || getOperand(0)->getType()->isPtrOrPtrVectorTy()) && \"Invalid operand types for ICmp instruction\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 1117, __extension__ __PRETTY_FUNCTION__));
}

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

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

1127public:
/// 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) {
1138#ifndef NDEBUG
AssertOK();
1140#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) {
1153#ifndef NDEBUG
AssertOK();
1155#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) {
1166#ifndef NDEBUG
AssertOK();
1168#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);
}

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

1242//===----------------------------------------------------------------------===//
1243//                               FCmpInst Class
1244//===----------------------------------------------------------------------===//

1246/// This instruction compares its operands according to the predicate given
1247/// to the constructor. It only operates on floating point values or packed
1248/// vectors of floating point values. The operands must be identical types.
1249/// Represents a floating point comparison operator.
1250class FCmpInst: public CmpInst {
void AssertOK() {
  assert(isFPPredicate() && "Invalid FCmp predicate value")(static_cast <bool> (isFPPredicate() && "Invalid FCmp predicate value"
) ? void (0) : __assert_fail ("isFPPredicate() && \"Invalid FCmp predicate value\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 1252, __extension__ __PRETTY_FUNCTION__));
  assert(getOperand(0)->getType() == getOperand(1)->getType() &&(static_cast <bool> (getOperand(0)->getType() == getOperand
(1)->getType() && "Both operands to FCmp instruction are not of the same type!"
) ? 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-7~svn329677/include/llvm/IR/Instructions.h"
, 1254, __extension__ __PRETTY_FUNCTION__))
         "Both operands to FCmp instruction are not of the same type!")(static_cast <bool> (getOperand(0)->getType() == getOperand
(1)->getType() && "Both operands to FCmp instruction are not of the same type!"
) ? 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-7~svn329677/include/llvm/IR/Instructions.h"
, 1254, __extension__ __PRETTY_FUNCTION__));
  // Check that the operands are the right type
  assert(getOperand(0)->getType()->isFPOrFPVectorTy() &&(static_cast <bool> (getOperand(0)->getType()->isFPOrFPVectorTy
() && "Invalid operand types for FCmp instruction") ?
 void (0) : __assert_fail ("getOperand(0)->getType()->isFPOrFPVectorTy() && \"Invalid operand types for FCmp instruction\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 1257, __extension__ __PRETTY_FUNCTION__))
         "Invalid operand types for FCmp instruction")(static_cast <bool> (getOperand(0)->getType()->isFPOrFPVectorTy
() && "Invalid operand types for FCmp instruction") ?
 void (0) : __assert_fail ("getOperand(0)->getType()->isFPOrFPVectorTy() && \"Invalid operand types for FCmp instruction\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 1257, __extension__ __PRETTY_FUNCTION__));
}

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

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

1267public:
/// 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
) : CmpInst(makeCmpResultType(LHS->getType()),
            Instruction::FCmp, pred, LHS, RHS, NameStr) {
  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));
}
1347};

1349class CallInst;
1350class InvokeInst;

1352template <class T> struct CallBaseParent { using type = Instruction; };

1354template <> struct CallBaseParent<InvokeInst> { using type = TerminatorInst; };

1356//===----------------------------------------------------------------------===//
1357/// Base class for all callable instructions (InvokeInst and CallInst)
1358/// Holds everything related to calling a function, abstracting from the base
1359/// type @p BaseInstTy and the concrete instruction @p InstTy
1360///
1361template <class InstTy>
1362class CallBase : public CallBaseParent<InstTy>::type,
               public OperandBundleUser<InstTy, User::op_iterator> {
1364protected:
AttributeList Attrs; ///< parameter attributes for callable
FunctionType *FTy;
using BaseInstTy = typename CallBaseParent<InstTy>::type;

template <class... ArgsTy>
CallBase(AttributeList const &A, FunctionType *FT, ArgsTy &&... Args)
    : BaseInstTy(std::forward<ArgsTy>(Args)...), Attrs(A), FTy(FT) {}
bool hasDescriptor() const { return Value::HasDescriptor; }

using BaseInstTy::BaseInstTy;

using OperandBundleUser<InstTy,
                        User::op_iterator>::isFnAttrDisallowedByOpBundle;
using OperandBundleUser<InstTy, User::op_iterator>::getNumTotalBundleOperands;
using OperandBundleUser<InstTy, User::op_iterator>::bundleOperandHasAttr;
using Instruction::getSubclassDataFromInstruction;
using Instruction::setInstructionSubclassData;

1383public:
using Instruction::getContext;
using OperandBundleUser<InstTy, User::op_iterator>::hasOperandBundles;
using OperandBundleUser<InstTy,
                        User::op_iterator>::getBundleOperandsStartIndex;

static bool classof(const Instruction *I) {
  llvm_unreachable(::llvm::llvm_unreachable_internal("CallBase is not meant to be used as part of the classof hierarchy"
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 1391)
      "CallBase is not meant to be used as part of the classof hierarchy")::llvm::llvm_unreachable_internal("CallBase is not meant to be used as part of the classof hierarchy"
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 1391);
}

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

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

FunctionType *getFunctionType() const { return FTy; }

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

/// Return the number of call arguments.
///
unsigned getNumArgOperands() const {
  return getNumOperands() - getNumTotalBundleOperands() - InstTy::ArgOffset;
}

/// getArgOperand/setArgOperand - Return/set the i-th call argument.
///
Value *getArgOperand(unsigned i) const {
  assert(i < getNumArgOperands() && "Out of bounds!")(static_cast <bool> (i < getNumArgOperands() &&
 "Out of bounds!") ? void (0) : __assert_fail ("i < getNumArgOperands() && \"Out of bounds!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 1419, __extension__ __PRETTY_FUNCTION__));
  return getOperand(i);
}
void setArgOperand(unsigned i, Value *v) {
  assert(i < getNumArgOperands() && "Out of bounds!")(static_cast <bool> (i < getNumArgOperands() &&
 "Out of bounds!") ? void (0) : __assert_fail ("i < getNumArgOperands() && \"Out of bounds!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 1423, __extension__ __PRETTY_FUNCTION__));
  setOperand(i, v);
}

/// Return the iterator pointing to the beginning of the argument list.
User::op_iterator arg_begin() { return op_begin(); }

/// Return the iterator pointing to the end of the argument list.
User::op_iterator arg_end() {
  // [ call args ], [ operand bundles ], callee
  return op_end() - getNumTotalBundleOperands() - InstTy::ArgOffset;
}

/// Iteration adapter for range-for loops.
iterator_range<User::op_iterator> arg_operands() {
  return make_range(arg_begin(), arg_end());
}

/// Return the iterator pointing to the beginning of the argument list.
User::const_op_iterator arg_begin() const { return op_begin(); }

/// Return the iterator pointing to the end of the argument list.
User::const_op_iterator arg_end() const {
  // [ call args ], [ operand bundles ], callee
  return op_end() - getNumTotalBundleOperands() - InstTy::ArgOffset;
}

/// Iteration adapter for range-for loops.
iterator_range<User::const_op_iterator> arg_operands() const {
  return make_range(arg_begin(), arg_end());
}

/// Wrappers for getting the \c Use of a call argument.
const Use &getArgOperandUse(unsigned i) const {
  assert(i < getNumArgOperands() && "Out of bounds!")(static_cast <bool> (i < getNumArgOperands() &&
 "Out of bounds!") ? void (0) : __assert_fail ("i < getNumArgOperands() && \"Out of bounds!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 1457, __extension__ __PRETTY_FUNCTION__));
  return User::getOperandUse(i);
}
Use &getArgOperandUse(unsigned i) {
  assert(i < getNumArgOperands() && "Out of bounds!")(static_cast <bool> (i < getNumArgOperands() &&
 "Out of bounds!") ? void (0) : __assert_fail ("i < getNumArgOperands() && \"Out of bounds!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 1461, __extension__ __PRETTY_FUNCTION__));
  return User::getOperandUse(i);
}

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

  if (Attrs.hasAttrSomewhere(Attribute::Returned, &Index) && Index)
    return getArgOperand(Index - AttributeList::FirstArgIndex);
  if (const Function *F = getCalledFunction())
    if (F->getAttributes().hasAttrSomewhere(Attribute::Returned, &Index) &&
        Index)
      return getArgOperand(Index - AttributeList::FirstArgIndex);

  return nullptr;
}

User::op_iterator op_begin() {
  return OperandTraits<CallBase>::op_begin(this);
}

User::const_op_iterator op_begin() const {
  return OperandTraits<CallBase>::op_begin(const_cast<CallBase *>(this));
}

User::op_iterator op_end() { return OperandTraits<CallBase>::op_end(this); }

User::const_op_iterator op_end() const {
  return OperandTraits<CallBase>::op_end(const_cast<CallBase *>(this));
}

Value *getOperand(unsigned i_nocapture) const {
  assert(i_nocapture < OperandTraits<CallBase>::operands(this) &&(static_cast <bool> (i_nocapture < OperandTraits<
CallBase>::operands(this) && "getOperand() out of range!"
) ? void (0) : __assert_fail ("i_nocapture < OperandTraits<CallBase>::operands(this) && \"getOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 1496, __extension__ __PRETTY_FUNCTION__))
         "getOperand() out of range!")(static_cast <bool> (i_nocapture < OperandTraits<
CallBase>::operands(this) && "getOperand() out of range!"
) ? void (0) : __assert_fail ("i_nocapture < OperandTraits<CallBase>::operands(this) && \"getOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 1496, __extension__ __PRETTY_FUNCTION__));
  return cast_or_null<Value>(OperandTraits<CallBase>::op_begin(
                                 const_cast<CallBase *>(this))[i_nocapture]
                                 .get());
}

void setOperand(unsigned i_nocapture, Value *Val_nocapture) {
  assert(i_nocapture < OperandTraits<CallBase>::operands(this) &&(static_cast <bool> (i_nocapture < OperandTraits<
CallBase>::operands(this) && "setOperand() out of range!"
) ? void (0) : __assert_fail ("i_nocapture < OperandTraits<CallBase>::operands(this) && \"setOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 1504, __extension__ __PRETTY_FUNCTION__))
         "setOperand() out of range!")(static_cast <bool> (i_nocapture < OperandTraits<
CallBase>::operands(this) && "setOperand() out of range!"
) ? void (0) : __assert_fail ("i_nocapture < OperandTraits<CallBase>::operands(this) && \"setOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 1504, __extension__ __PRETTY_FUNCTION__));
  OperandTraits<CallBase>::op_begin(this)[i_nocapture] = Val_nocapture;
}

unsigned getNumOperands() const {
  return OperandTraits<CallBase>::operands(this);
}
template <int Idx_nocapture> Use &Op() {
  return User::OpFrom<Idx_nocapture>(this);
}
template <int Idx_nocapture> const Use &Op() const {
  return User::OpFrom<Idx_nocapture>(this);
}

/// Return the function called, or null if this is an
/// indirect function invocation.
///
Function *getCalledFunction() const {
  return dyn_cast<Function>(Op<-InstTy::ArgOffset>());
}

/// Determine whether this call has the given attribute.
bool hasFnAttr(Attribute::AttrKind Kind) const {
  assert(Kind != Attribute::NoBuiltin &&(static_cast <bool> (Kind != Attribute::NoBuiltin &&
 "Use CallBase::isNoBuiltin() to check for Attribute::NoBuiltin"
) ? void (0) : __assert_fail ("Kind != Attribute::NoBuiltin && \"Use CallBase::isNoBuiltin() to check for Attribute::NoBuiltin\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 1528, __extension__ __PRETTY_FUNCTION__))
         "Use CallBase::isNoBuiltin() to check for Attribute::NoBuiltin")(static_cast <bool> (Kind != Attribute::NoBuiltin &&
 "Use CallBase::isNoBuiltin() to check for Attribute::NoBuiltin"
) ? void (0) : __assert_fail ("Kind != Attribute::NoBuiltin && \"Use CallBase::isNoBuiltin() to check for Attribute::NoBuiltin\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 1528, __extension__ __PRETTY_FUNCTION__));
  return hasFnAttrImpl(Kind);
}

/// Determine whether this call has the given attribute.
bool hasFnAttr(StringRef Kind) const { return hasFnAttrImpl(Kind); }

/// getCallingConv/setCallingConv - Get or set the calling convention of this
/// function call.
CallingConv::ID getCallingConv() const {
  return static_cast<CallingConv::ID>(getSubclassDataFromInstruction() >> 2);
}
void setCallingConv(CallingConv::ID CC) {
  auto ID = static_cast<unsigned>(CC);
  assert(!(ID & ~CallingConv::MaxID) && "Unsupported calling convention")(static_cast <bool> (!(ID & ~CallingConv::MaxID) &&
 "Unsupported calling convention") ? void (0) : __assert_fail
 ("!(ID & ~CallingConv::MaxID) && \"Unsupported calling convention\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 1542, __extension__ __PRETTY_FUNCTION__));
  setInstructionSubclassData((getSubclassDataFromInstruction() & 3) |
                             (ID << 2));
}


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

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

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

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

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

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

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

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

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

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

/// Determine whether the return value has the given attribute.
bool hasRetAttr(Attribute::AttrKind Kind) const {
  if (Attrs.hasAttribute(AttributeList::ReturnIndex, Kind))
    return true;

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

/// Determine whether the argument or parameter has the given attribute.
bool paramHasAttr(unsigned ArgNo, Attribute::AttrKind Kind) const {
  assert(ArgNo < getNumArgOperands() && "Param index out of bounds!")(static_cast <bool> (ArgNo < getNumArgOperands() &&
 "Param index out of bounds!") ? void (0) : __assert_fail ("ArgNo < getNumArgOperands() && \"Param index out of bounds!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 1636, __extension__ __PRETTY_FUNCTION__));

  if (Attrs.hasParamAttribute(ArgNo, Kind))
    return true;
  if (const Function *F = getCalledFunction())
    return F->getAttributes().hasParamAttribute(ArgNo, Kind);
  return false;
}

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

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

/// Get the attribute of a given kind from a given arg
Attribute getParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) const {
  assert(ArgNo < getNumArgOperands() && "Out of bounds")(static_cast <bool> (ArgNo < getNumArgOperands() &&
 "Out of bounds") ? void (0) : __assert_fail ("ArgNo < getNumArgOperands() && \"Out of bounds\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 1657, __extension__ __PRETTY_FUNCTION__));
  return getAttributes().getParamAttr(ArgNo, Kind);
}

/// Get the attribute of a given kind from a given arg
Attribute getParamAttr(unsigned ArgNo, StringRef Kind) const {
  assert(ArgNo < getNumArgOperands() && "Out of bounds")(static_cast <bool> (ArgNo < getNumArgOperands() &&
 "Out of bounds") ? void (0) : __assert_fail ("ArgNo < getNumArgOperands() && \"Out of bounds\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 1663, __extension__ __PRETTY_FUNCTION__));
  return getAttributes().getParamAttr(ArgNo, Kind);
}
/// Return true if the data operand at index \p i has the attribute \p
/// A.
///
/// Data operands include call arguments and values used in operand bundles,
/// but does not include the callee operand.  This routine dispatches to the
/// underlying AttributeList or the OperandBundleUser as appropriate.
///
/// The index \p i is interpreted as
///
///  \p i == Attribute::ReturnIndex  -> the return value
///  \p i in [1, arg_size + 1)  -> argument number (\p i - 1)
///  \p i in [arg_size + 1, data_operand_size + 1) -> bundle operand at index
///     (\p i - 1) in the operand list.
bool dataOperandHasImpliedAttr(unsigned i, Attribute::AttrKind Kind) const {
  // There are getNumOperands() - (InstTy::ArgOffset - 1) data operands.
  // The last operand is the callee.
  assert(i < (getNumOperands() - InstTy::ArgOffset + 1) &&(static_cast <bool> (i < (getNumOperands() - InstTy::
ArgOffset + 1) && "Data operand index out of bounds!"
) ? void (0) : __assert_fail ("i < (getNumOperands() - InstTy::ArgOffset + 1) && \"Data operand index out of bounds!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 1683, __extension__ __PRETTY_FUNCTION__))
         "Data operand index out of bounds!")(static_cast <bool> (i < (getNumOperands() - InstTy::
ArgOffset + 1) && "Data operand index out of bounds!"
) ? void (0) : __assert_fail ("i < (getNumOperands() - InstTy::ArgOffset + 1) && \"Data operand index out of bounds!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 1683, __extension__ __PRETTY_FUNCTION__));

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/// Determine if the invoke is convergent
bool isConvergent() const { return hasFnAttr(Attribute::Convergent); }
void setConvergent() {
  addAttribute(AttributeList::FunctionIndex, Attribute::Convergent);
}
void setNotConvergent() {
  removeAttribute(AttributeList::FunctionIndex, Attribute::Convergent);
}

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

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

/// Determine if any call argument is an aggregate passed by value.
bool hasByValArgument() const {
  return Attrs.hasAttrSomewhere(Attribute::ByVal);
}
/// Get a pointer to the function that is invoked by this
/// instruction.
const Value *getCalledValue() const { return Op<-InstTy::ArgOffset>(); }
Value *getCalledValue() { return Op<-InstTy::ArgOffset>(); }

/// Set the function called.
void setCalledFunction(Value* Fn) {
  setCalledFunction(
      cast<FunctionType>(cast<PointerType>(Fn->getType())->getElementType()),
      Fn);
}
void setCalledFunction(FunctionType *FTy, Value *Fn) {
  this->FTy = FTy;
  assert(FTy == cast<FunctionType>((static_cast <bool> (FTy == cast<FunctionType>( cast
<PointerType>(Fn->getType())->getElementType())) ?
 void (0) : __assert_fail ("FTy == cast<FunctionType>( cast<PointerType>(Fn->getType())->getElementType())"
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 1850, __extension__ __PRETTY_FUNCTION__))
                    cast<PointerType>(Fn->getType())->getElementType()))(static_cast <bool> (FTy == cast<FunctionType>( cast
<PointerType>(Fn->getType())->getElementType())) ?
 void (0) : __assert_fail ("FTy == cast<FunctionType>( cast<PointerType>(Fn->getType())->getElementType())"
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 1850, __extension__ __PRETTY_FUNCTION__));
  Op<-InstTy::ArgOffset>() = Fn;
}

1854protected:
template <typename AttrKind> bool hasFnAttrImpl(AttrKind Kind) const {
  if (Attrs.hasAttribute(AttributeList::FunctionIndex, Kind))
    return true;

  // Operand bundles override attributes on the called function, but don't
  // override attributes directly present on the call instruction.
  if (isFnAttrDisallowedByOpBundle(Kind))
    return false;

  if (const Function *F = getCalledFunction())
    return F->getAttributes().hasAttribute(AttributeList::FunctionIndex,
                                           Kind);
  return false;
}
1869};

1871//===----------------------------------------------------------------------===//
1872/// This class represents a function call, abstracting a target
1873/// machine's calling convention.  This class uses low bit of the SubClassData
1874/// field to indicate whether or not this is a tail call.  The rest of the bits
1875/// hold the calling convention of the call.
1876///
1877class CallInst : public CallBase<CallInst> {
friend class OperandBundleUser<CallInst, User::op_iterator>;

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(Value *Func, ArrayRef<Value *> Args,
                ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr,
                Instruction *InsertBefore)
    : CallInst(cast<FunctionType>(
                   cast<PointerType>(Func->getType())->getElementType()),
               Func, Args, Bundles, NameStr, InsertBefore) {}

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

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

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

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

void init(Value *Func, ArrayRef<Value *> Args,
          ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr) {
  init(cast<FunctionType>(
           cast<PointerType>(Func->getType())->getElementType()),
       Func, Args, Bundles, NameStr);
}
void init(FunctionType *FTy, Value *Func, ArrayRef<Value *> Args,
          ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr);
void init(Value *Func, const Twine &NameStr);

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

CallInst *cloneImpl() const;

1925public:
static constexpr int ArgOffset = 1;

static CallInst *Create(Value *Func, ArrayRef<Value *> Args,
                        ArrayRef<OperandBundleDef> Bundles = None,
                        const Twine &NameStr = "",
                        Instruction *InsertBefore = nullptr) {
  return Create(cast<FunctionType>(
                    cast<PointerType>(Func->getType())->getElementType()),
                Func, Args, Bundles, NameStr, InsertBefore);
}

static CallInst *Create(Value *Func, ArrayRef<Value *> Args,
                        const Twine &NameStr,
                        Instruction *InsertBefore = nullptr) {
  return Create(cast<FunctionType>(
                    cast<PointerType>(Func->getType())->getElementType()),
                Func, Args, None, NameStr, InsertBefore);
}

static CallInst *Create(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
                        const Twine &NameStr,
                        Instruction *InsertBefore = nullptr) {
  return new (unsigned(Args.size() + 1))
      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 unsigned TotalOps =
      unsigned(Args.size()) + CountBundleInputs(Bundles) + 1;
  const unsigned DescriptorBytes = Bundles.size() * sizeof(BundleOpInfo);

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

static CallInst *Create(Value *Func, ArrayRef<Value *> Args,
                        ArrayRef<OperandBundleDef> Bundles,
                        const Twine &NameStr, BasicBlock *InsertAtEnd) {
  const unsigned TotalOps =
      unsigned(Args.size()) + CountBundleInputs(Bundles) + 1;
  const unsigned DescriptorBytes = Bundles.size() * sizeof(BundleOpInfo);

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

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

static CallInst *Create(Value *F, const Twine &NameStr = "",
                        Instruction *InsertBefore = nullptr) {
  return new (1) CallInst(F, NameStr, InsertBefore);
}

static CallInst *Create(Value *F, const Twine &NameStr,
                        BasicBlock *InsertAtEnd) {
  return new (1) CallInst(F, 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);

/// 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 {
  TCK_None = 0,
  TCK_Tail = 1,
  TCK_MustTail = 2,
  TCK_NoTail = 3
};
TailCallKind getTailCallKind() const {
  return TailCallKind(getSubclassDataFromInstruction() & 3);
}

bool isTailCall() const {
  unsigned Kind = getSubclassDataFromInstruction() & 3;
  return Kind == TCK_Tail || Kind == TCK_MustTail;
}

bool isMustTailCall() const {
  return (getSubclassDataFromInstruction() & 3) == TCK_MustTail;
}

bool isNoTailCall() const {
  return (getSubclassDataFromInstruction() & 3) == TCK_NoTail;
}

void setTailCall(bool isTC = true) {
  setInstructionSubclassData((getSubclassDataFromInstruction() & ~3) |
                             unsigned(isTC ? TCK_Tail : TCK_None));
}

void setTailCallKind(TailCallKind TCK) {
  setInstructionSubclassData((getSubclassDataFromInstruction() & ~3) |
                             unsigned(TCK));
}

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

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

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

2089private:
// Shadow Instruction::setInstructionSubclassData with a private forwarding
// method so that subclasses cannot accidentally use it.
void setInstructionSubclassData(unsigned short D) {
  Instruction::setInstructionSubclassData(D);
}
2095};

2097template <>
2098struct OperandTraits<CallBase<CallInst>>
  : public VariadicOperandTraits<CallBase<CallInst>, 1> {};

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

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

2126//===----------------------------------------------------------------------===//
2127//                               SelectInst Class
2128//===----------------------------------------------------------------------===//

2130/// This class represents the LLVM 'select' instruction.
2131///
2132class 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")(static_cast <bool> (!areInvalidOperands(C, S1, S2) &&
 "Invalid operands for select") ? void (0) : __assert_fail ("!areInvalidOperands(C, S1, S2) && \"Invalid operands for select\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 2150, __extension__ __PRETTY_FUNCTION__));
  Op<0>() = C;
  Op<1>() = S1;
  Op<2>() = S2;
}

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

SelectInst *cloneImpl() const;

2162public:
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; }

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

2210template <>
2211struct OperandTraits<SelectInst> : public FixedNumOperandTraits<SelectInst, 3> {
2212};

2214DEFINE_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 { (static_cast <bool
> (i_nocapture < OperandTraits<SelectInst>::operands
(this) && "getOperand() out of range!") ? void (0) : __assert_fail
 ("i_nocapture < OperandTraits<SelectInst>::operands(this) && \"getOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 2214, __extension__ __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) { (static_cast
 <bool> (i_nocapture < OperandTraits<SelectInst>
::operands(this) && "setOperand() out of range!") ? void
 (0) : __assert_fail ("i_nocapture < OperandTraits<SelectInst>::operands(this) && \"setOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 2214, __extension__ __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); }

2216//===----------------------------------------------------------------------===//
2217//                                VAArgInst Class
2218//===----------------------------------------------------------------------===//

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

VAArgInst *cloneImpl() const;

2230public:
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));
}
2254};

2256//===----------------------------------------------------------------------===//
2257//                                ExtractElementInst Class
2258//===----------------------------------------------------------------------===//

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

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

ExtractElementInst *cloneImpl() const;

2275public:
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));
}
2311};

2313template <>
2314struct OperandTraits<ExtractElementInst> :
public FixedNumOperandTraits<ExtractElementInst, 2> {
2316};

2318DEFINE_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 {
 (static_cast <bool> (i_nocapture < OperandTraits<
ExtractElementInst>::operands(this) && "getOperand() out of range!"
) ? void (0) : __assert_fail ("i_nocapture < OperandTraits<ExtractElementInst>::operands(this) && \"getOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 2318, __extension__ __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) { (static_cast <bool> (i_nocapture
 < OperandTraits<ExtractElementInst>::operands(this)
 && "setOperand() out of range!") ? void (0) : __assert_fail
 ("i_nocapture < OperandTraits<ExtractElementInst>::operands(this) && \"setOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 2318, __extension__ __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
); }

2320//===----------------------------------------------------------------------===//
2321//                                InsertElementInst Class
2322//===----------------------------------------------------------------------===//

2324/// This instruction inserts a single (scalar)
2325/// element into a VectorType value
2326///
2327class 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);

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

InsertElementInst *cloneImpl() const;

2340public:
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));
}
2374};

2376template <>
2377struct OperandTraits<InsertElementInst> :
public FixedNumOperandTraits<InsertElementInst, 3> {
2379};

2381DEFINE_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 { (static_cast <bool> (i_nocapture <
 OperandTraits<InsertElementInst>::operands(this) &&
 "getOperand() out of range!") ? void (0) : __assert_fail ("i_nocapture < OperandTraits<InsertElementInst>::operands(this) && \"getOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 2381, __extension__ __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) { (static_cast <bool> (i_nocapture
 < OperandTraits<InsertElementInst>::operands(this) &&
 "setOperand() out of range!") ? void (0) : __assert_fail ("i_nocapture < OperandTraits<InsertElementInst>::operands(this) && \"setOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 2381, __extension__ __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
); }

2383//===----------------------------------------------------------------------===//
2384//                           ShuffleVectorInst Class
2385//===----------------------------------------------------------------------===//

2387/// This instruction constructs a fixed permutation of two
2388/// input vectors.
2389///
2390class ShuffleVectorInst : public Instruction {
2391protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

ShuffleVectorInst *cloneImpl() const;

2397public:
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);

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

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

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

Constant *getMask() const {
  return cast<Constant>(getOperand(2));
}

/// Return the shuffle mask value for the specified element of the mask.
/// Return -1 if the element is undef.
static int getMaskValue(Constant *Mask, unsigned Elt);

/// Return the shuffle mask value of this instruction for the given element
/// index. Return -1 if the element is undef.
int getMaskValue(unsigned Elt) const {
  return getMaskValue(getMask(), Elt);
}

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

/// Return the mask for this instruction as a vector of integers. Undefined
/// elements of the mask are returned as -1.
void getShuffleMask(SmallVectorImpl<int> &Result) const {
  return getShuffleMask(getMask(), Result);
}

SmallVector<int, 16> getShuffleMask() const {
  SmallVector<int, 16> Mask;
  getShuffleMask(Mask);
  return Mask;
}

/// 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 &&(static_cast <bool> (Idx >= 0 && Idx < (int
)InVecNumElts * 2 && "shufflevector mask index out of range"
) ? void (0) : __assert_fail ("Idx >= 0 && Idx < (int)InVecNumElts * 2 && \"shufflevector mask index out of range\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 2462, __extension__ __PRETTY_FUNCTION__))
           "shufflevector mask index out of range")(static_cast <bool> (Idx >= 0 && Idx < (int
)InVecNumElts * 2 && "shufflevector mask index out of range"
) ? void (0) : __assert_fail ("Idx >= 0 && Idx < (int)InVecNumElts * 2 && \"shufflevector mask index out of range\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 2462, __extension__ __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));
}
2473};

2475template <>
2476struct OperandTraits<ShuffleVectorInst> :
public FixedNumOperandTraits<ShuffleVectorInst, 3> {
2478};

2480DEFINE_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 { (static_cast <bool> (i_nocapture <
 OperandTraits<ShuffleVectorInst>::operands(this) &&
 "getOperand() out of range!") ? void (0) : __assert_fail ("i_nocapture < OperandTraits<ShuffleVectorInst>::operands(this) && \"getOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 2480, __extension__ __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) { (static_cast <bool> (i_nocapture
 < OperandTraits<ShuffleVectorInst>::operands(this) &&
 "setOperand() out of range!") ? void (0) : __assert_fail ("i_nocapture < OperandTraits<ShuffleVectorInst>::operands(this) && \"setOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 2480, __extension__ __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
); }

2482//===----------------------------------------------------------------------===//
2483//                                ExtractValueInst Class
2484//===----------------------------------------------------------------------===//

2486/// This instruction extracts a struct member or array
2487/// element value from an aggregate value.
2488///
2489class 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);

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

ExtractValueInst *cloneImpl() const;

2514public:
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));
}
2573};

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

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

2593//===----------------------------------------------------------------------===//
2594//                                InsertValueInst Class
2595//===----------------------------------------------------------------------===//

2597/// This instruction inserts a struct field of array element
2598/// value into an aggregate value.
2599///
2600class 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);

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

InsertValueInst *cloneImpl() const;

2634public:
// 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));
}
2704};

2706template <>
2707struct OperandTraits<InsertValueInst> :
public FixedNumOperandTraits<InsertValueInst, 2> {
2709};

2711InsertValueInst::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);
2720}

2722InsertValueInst::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);
2731}

2733DEFINE_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 { (static_cast <bool
> (i_nocapture < OperandTraits<InsertValueInst>::
operands(this) && "getOperand() out of range!") ? void
 (0) : __assert_fail ("i_nocapture < OperandTraits<InsertValueInst>::operands(this) && \"getOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 2733, __extension__ __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) { (static_cast <bool> (i_nocapture <
 OperandTraits<InsertValueInst>::operands(this) &&
 "setOperand() out of range!") ? void (0) : __assert_fail ("i_nocapture < OperandTraits<InsertValueInst>::operands(this) && \"setOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 2733, __extension__ __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); }

2735//===----------------------------------------------------------------------===//
2736//                               PHINode Class
2737//===----------------------------------------------------------------------===//

2739// PHINode - The PHINode class is used to represent the magical mystical PHI
2740// node, that can not exist in nature, but can be synthesized in a computer
2741// scientist's overactive imagination.
2742//
2743class 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);
}

2767protected:
// 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);
}

2780public:
/// 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() {
  Use::UserRef *ref =
    reinterpret_cast<Use::UserRef*>(op_begin() + ReservedSpace);
  return reinterpret_cast<block_iterator>(ref + 1);
}

const_block_iterator block_begin() const {
  const Use::UserRef *ref =
    reinterpret_cast<const Use::UserRef*>(op_begin() + ReservedSpace);
  return reinterpret_cast<const_block_iterator>(ref + 1);
}

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!")(static_cast <bool> (V && "PHI node got a null value!"
) ? void (0) : __assert_fail ("V && \"PHI node got a null value!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 2845, __extension__ __PRETTY_FUNCTION__));
  assert(getType() == V->getType() &&(static_cast <bool> (getType() == V->getType() &&
 "All operands to PHI node must be the same type as the PHI node!"
) ? 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-7~svn329677/include/llvm/IR/Instructions.h"
, 2847, __extension__ __PRETTY_FUNCTION__))
         "All operands to PHI node must be the same type as the PHI node!")(static_cast <bool> (getType() == V->getType() &&
 "All operands to PHI node must be the same type as the PHI node!"
) ? 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-7~svn329677/include/llvm/IR/Instructions.h"
, 2847, __extension__ __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?")(static_cast <bool> (this == U.getUser() && "Iterator doesn't point to PHI's Uses?"
) ? void (0) : __assert_fail ("this == U.getUser() && \"Iterator doesn't point to PHI's Uses?\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 2869, __extension__ __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!")(static_cast <bool> (BB && "PHI node got a null basic block!"
) ? void (0) : __assert_fail ("BB && \"PHI node got a null basic block!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 2881, __extension__ __PRETTY_FUNCTION__));
  block_begin()[i] = BB;
}

/// 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!")(static_cast <bool> (Idx >= 0 && "Invalid basic block argument to remove!"
) ? void (0) : __assert_fail ("Idx >= 0 && \"Invalid basic block argument to remove!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 2908, __extension__ __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!")(static_cast <bool> (Idx >= 0 && "Invalid basic block argument!"
) ? void (0) : __assert_fail ("Idx >= 0 && \"Invalid basic block argument!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 2924, __extension__ __PRETTY_FUNCTION__));
16
←
Within the expansion of the macro 'assert':
→
a
Assuming 'Idx' is >= 0
  return getIncomingValue(Idx);
17
←
Calling 'PHINode::getIncomingValue'→
18
←
Returning from 'PHINode::getIncomingValue'→
}

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

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

2945private:
void growOperands();
2947};

2949template <>
2950struct OperandTraits<PHINode> : public HungoffOperandTraits<2> {
2951};

2953DEFINE_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 { (static_cast <bool> (i_nocapture < OperandTraits
<PHINode>::operands(this) && "getOperand() out of range!"
) ? void (0) : __assert_fail ("i_nocapture < OperandTraits<PHINode>::operands(this) && \"getOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 2953, __extension__ __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) { (static_cast
 <bool> (i_nocapture < OperandTraits<PHINode>::
operands(this) && "setOperand() out of range!") ? void
 (0) : __assert_fail ("i_nocapture < OperandTraits<PHINode>::operands(this) && \"setOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 2953, __extension__ __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); }

2955//===----------------------------------------------------------------------===//
2956//                           LandingPadInst Class
2957//===----------------------------------------------------------------------===//

2959//===---------------------------------------------------------------------------
2960/// The landingpad instruction holds all of the information
2961/// necessary to generate correct exception handling. The landingpad instruction
2962/// cannot be moved from the top of a landing pad block, which itself is
2963/// accessible only from the 'unwind' edge of an invoke. This uses the
2964/// SubclassData field in Value to store whether or not the landingpad is a
2965/// cleanup.
2966///
2967class LandingPadInst : public Instruction {
/// The number of operands actually allocated.  NumOperands is
/// the number actually in use.
unsigned ReservedSpace;

LandingPadInst(const LandingPadInst &LP);

2974public:
enum ClauseType { Catch, Filter };

2977private:
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);

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

LandingPadInst *cloneImpl() const;

2997public:
/// 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 getSubclassDataFromInstruction() & 1; }

/// Indicate that this landingpad instruction is a cleanup.
void setCleanup(bool V) {
  setInstructionSubclassData((getSubclassDataFromInstruction() & ~1) |
                             (V ? 1 : 0));
}

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

3055template <>
3056struct OperandTraits<LandingPadInst> : public HungoffOperandTraits<1> {
3057};

3059DEFINE_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 { (static_cast <bool
> (i_nocapture < OperandTraits<LandingPadInst>::operands
(this) && "getOperand() out of range!") ? void (0) : __assert_fail
 ("i_nocapture < OperandTraits<LandingPadInst>::operands(this) && \"getOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 3059, __extension__ __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) { (static_cast <bool> (i_nocapture <
 OperandTraits<LandingPadInst>::operands(this) &&
 "setOperand() out of range!") ? void (0) : __assert_fail ("i_nocapture < OperandTraits<LandingPadInst>::operands(this) && \"setOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 3059, __extension__ __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); }

3061//===----------------------------------------------------------------------===//
3062//                               ReturnInst Class
3063//===----------------------------------------------------------------------===//

3065//===---------------------------------------------------------------------------
3066/// Return a value (possibly void), from a function.  Execution
3067/// does not continue in this function any longer.
3068///
3069class ReturnInst : public TerminatorInst {
ReturnInst(const ReturnInst &RI);

3072private:
// 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);

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

ReturnInst *cloneImpl() const;

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

3128private:
friend TerminatorInst;

BasicBlock *getSuccessor(unsigned idx) const {
  llvm_unreachable("ReturnInst has no successors!")::llvm::llvm_unreachable_internal("ReturnInst has no successors!"
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 3132);
}

void setSuccessor(unsigned idx, BasicBlock *B) {
  llvm_unreachable("ReturnInst has no successors!")::llvm::llvm_unreachable_internal("ReturnInst has no successors!"
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 3136);
}
3138};

3140template <>
3141struct OperandTraits<ReturnInst> : public VariadicOperandTraits<ReturnInst> {
3142};

3144DEFINE_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 { (static_cast <bool
> (i_nocapture < OperandTraits<ReturnInst>::operands
(this) && "getOperand() out of range!") ? void (0) : __assert_fail
 ("i_nocapture < OperandTraits<ReturnInst>::operands(this) && \"getOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 3144, __extension__ __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) { (static_cast
 <bool> (i_nocapture < OperandTraits<ReturnInst>
::operands(this) && "setOperand() out of range!") ? void
 (0) : __assert_fail ("i_nocapture < OperandTraits<ReturnInst>::operands(this) && \"setOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 3144, __extension__ __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); }

3146//===----------------------------------------------------------------------===//
3147//                               BranchInst Class
3148//===----------------------------------------------------------------------===//

3150//===---------------------------------------------------------------------------
3151/// Conditional or Unconditional Branch instruction.
3152///
3153class BranchInst : public TerminatorInst {
/// 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();

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

BranchInst *cloneImpl() const;

3181public:
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!")(static_cast <bool> (isConditional() && "Cannot get condition of an uncond branch!"
) ? void (0) : __assert_fail ("isConditional() && \"Cannot get condition of an uncond branch!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 3208, __extension__ __PRETTY_FUNCTION__));
  return Op<-3>();
}

void setCondition(Value *V) {
  assert(isConditional() && "Cannot set condition of unconditional branch!")(static_cast <bool> (isConditional() && "Cannot set condition of unconditional branch!"
) ? void (0) : __assert_fail ("isConditional() && \"Cannot set condition of unconditional branch!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 3213, __extension__ __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!")(static_cast <bool> (i < getNumSuccessors() &&
 "Successor # out of range for Branch!") ? void (0) : __assert_fail
 ("i < getNumSuccessors() && \"Successor # out of range for Branch!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 3220, __extension__ __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!")(static_cast <bool> (idx < getNumSuccessors() &&
 "Successor # out of range for Branch!") ? void (0) : __assert_fail
 ("idx < getNumSuccessors() && \"Successor # out of range for Branch!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 3225, __extension__ __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();

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

3245template <>
3246struct OperandTraits<BranchInst> : public VariadicOperandTraits<BranchInst, 1> {
3247};

3249DEFINE_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 { (static_cast <bool
> (i_nocapture < OperandTraits<BranchInst>::operands
(this) && "getOperand() out of range!") ? void (0) : __assert_fail
 ("i_nocapture < OperandTraits<BranchInst>::operands(this) && \"getOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 3249, __extension__ __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) { (static_cast
 <bool> (i_nocapture < OperandTraits<BranchInst>
::operands(this) && "setOperand() out of range!") ? void
 (0) : __assert_fail ("i_nocapture < OperandTraits<BranchInst>::operands(this) && \"setOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 3249, __extension__ __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); }

3251//===----------------------------------------------------------------------===//
3252//                               SwitchInst Class
3253//===----------------------------------------------------------------------===//

3255//===---------------------------------------------------------------------------
3256/// Multiway switch
3257///
3258class SwitchInst : public TerminatorInst {
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();

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

SwitchInst *cloneImpl() const;

3295public:
// -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() &&(static_cast <bool> ((unsigned)Index < SI->getNumCases
() && "Index out the number of cases.") ? void (0) : __assert_fail
 ("(unsigned)Index < SI->getNumCases() && \"Index out the number of cases.\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 3326, __extension__ __PRETTY_FUNCTION__))
           "Index out the number of cases.")(static_cast <bool> ((unsigned)Index < SI->getNumCases
() && "Index out the number of cases.") ? void (0) : __assert_fail
 ("(unsigned)Index < SI->getNumCases() && \"Index out the number of cases.\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 3326, __extension__ __PRETTY_FUNCTION__));
    return reinterpret_cast<ConstantIntT *>(SI->getOperand(2 + Index * 2));
  }

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

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

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

  bool operator==(const CaseHandleImpl &RHS) const {
    assert(SI == RHS.SI && "Incompatible operators.")(static_cast <bool> (SI == RHS.SI && "Incompatible operators."
) ? void (0) : __assert_fail ("SI == RHS.SI && \"Incompatible operators.\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 3350, __extension__ __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() &&(static_cast <bool> ((unsigned)Index < SI->getNumCases
() && "Index out the number of cases.") ? void (0) : __assert_fail
 ("(unsigned)Index < SI->getNumCases() && \"Index out the number of cases.\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 3368, __extension__ __PRETTY_FUNCTION__))
           "Index out the number of cases.")(static_cast <bool> ((unsigned)Index < SI->getNumCases
() && "Index out the number of cases.") ? void (0) : __assert_fail
 ("(unsigned)Index < SI->getNumCases() && \"Index out the number of cases.\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 3368, __extension__ __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
  /// TerminatorInst's successor index.
  static CaseIteratorImpl fromSuccessorIndex(SwitchInstT *SI,
                                             unsigned SuccessorIndex) {
    assert(SuccessorIndex < SI->getNumSuccessors() &&(static_cast <bool> (SuccessorIndex < SI->getNumSuccessors
() && "Successor index # out of range!") ? void (0) :
 __assert_fail ("SuccessorIndex < SI->getNumSuccessors() && \"Successor index # out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 3401, __extension__ __PRETTY_FUNCTION__))
           "Successor index # out of range!")(static_cast <bool> (SuccessorIndex < SI->getNumSuccessors
() && "Successor index # out of range!") ? void (0) :
 __assert_fail ("SuccessorIndex < SI->getNumSuccessors() && \"Successor index # out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 3401, __extension__ __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 &&(static_cast <bool> (Case.Index + N >= 0 && (
unsigned)(Case.Index + N) <= Case.SI->getNumCases() &&
 "Case.Index out the number of cases.") ? 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-7~svn329677/include/llvm/IR/Instructions.h"
, 3417, __extension__ __PRETTY_FUNCTION__))
           (unsigned)(Case.Index + N) <= Case.SI->getNumCases() &&(static_cast <bool> (Case.Index + N >= 0 && (
unsigned)(Case.Index + N) <= Case.SI->getNumCases() &&
 "Case.Index out the number of cases.") ? 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-7~svn329677/include/llvm/IR/Instructions.h"
, 3417, __extension__ __PRETTY_FUNCTION__))
           "Case.Index out the number of cases.")(static_cast <bool> (Case.Index + N >= 0 && (
unsigned)(Case.Index + N) <= Case.SI->getNumCases() &&
 "Case.Index out the number of cases.") ? 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-7~svn329677/include/llvm/IR/Instructions.h"
, 3417, __extension__ __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 &&(static_cast <bool> (Case.Index - N >= 0 && (
unsigned)(Case.Index - N) <= Case.SI->getNumCases() &&
 "Case.Index out the number of cases.") ? 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-7~svn329677/include/llvm/IR/Instructions.h"
, 3426, __extension__ __PRETTY_FUNCTION__))
           (unsigned)(Case.Index - N) <= Case.SI->getNumCases() &&(static_cast <bool> (Case.Index - N >= 0 && (
unsigned)(Case.Index - N) <= Case.SI->getNumCases() &&
 "Case.Index out the number of cases.") ? 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-7~svn329677/include/llvm/IR/Instructions.h"
, 3426, __extension__ __PRETTY_FUNCTION__))
           "Case.Index out the number of cases.")(static_cast <bool> (Case.Index - N >= 0 && (
unsigned)(Case.Index - N) <= Case.SI->getNumCases() &&
 "Case.Index out the number of cases.") ? 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-7~svn329677/include/llvm/IR/Instructions.h"
, 3426, __extension__ __PRETTY_FUNCTION__));
    Case.Index -= N;
    return *this;
  }
  ptrdiff_t operator-(const CaseIteratorImpl &RHS) const {
    assert(Case.SI == RHS.Case.SI && "Incompatible operators.")(static_cast <bool> (Case.SI == RHS.Case.SI && "Incompatible operators."
) ? void (0) : __assert_fail ("Case.SI == RHS.Case.SI && \"Incompatible operators.\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 3431, __extension__ __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.")(static_cast <bool> (Case.SI == RHS.Case.SI && "Incompatible operators."
) ? void (0) : __assert_fail ("Case.SI == RHS.Case.SI && \"Incompatible operators.\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 3438, __extension__ __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!")(static_cast <bool> (idx < getNumSuccessors() &&
"Successor idx out of range for switch!") ? void (0) : __assert_fail
 ("idx < getNumSuccessors() &&\"Successor idx out of range for switch!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 3585, __extension__ __PRETTY_FUNCTION__));
  return cast<BasicBlock>(getOperand(idx*2+1));
}
void setSuccessor(unsigned idx, BasicBlock *NewSucc) {
  assert(idx < getNumSuccessors() && "Successor # out of range for switch!")(static_cast <bool> (idx < getNumSuccessors() &&
 "Successor # out of range for switch!") ? void (0) : __assert_fail
 ("idx < getNumSuccessors() && \"Successor # out of range for switch!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 3589, __extension__ __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));
}
3600};

3602template <>
3603struct OperandTraits<SwitchInst> : public HungoffOperandTraits<2> {
3604};

3606DEFINE_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 { (static_cast <bool
> (i_nocapture < OperandTraits<SwitchInst>::operands
(this) && "getOperand() out of range!") ? void (0) : __assert_fail
 ("i_nocapture < OperandTraits<SwitchInst>::operands(this) && \"getOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 3606, __extension__ __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) { (static_cast
 <bool> (i_nocapture < OperandTraits<SwitchInst>
::operands(this) && "setOperand() out of range!") ? void
 (0) : __assert_fail ("i_nocapture < OperandTraits<SwitchInst>::operands(this) && \"setOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 3606, __extension__ __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); }

3608//===----------------------------------------------------------------------===//
3609//                             IndirectBrInst Class
3610//===----------------------------------------------------------------------===//

3612//===---------------------------------------------------------------------------
3613/// Indirect Branch Instruction.
3614///
3615class IndirectBrInst : public TerminatorInst {
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();

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

IndirectBrInst *cloneImpl() const;

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

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

3700template <>
3701struct OperandTraits<IndirectBrInst> : public HungoffOperandTraits<1> {
3702};

3704DEFINE_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 { (static_cast <bool
> (i_nocapture < OperandTraits<IndirectBrInst>::operands
(this) && "getOperand() out of range!") ? void (0) : __assert_fail
 ("i_nocapture < OperandTraits<IndirectBrInst>::operands(this) && \"getOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 3704, __extension__ __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) { (static_cast <bool> (i_nocapture <
 OperandTraits<IndirectBrInst>::operands(this) &&
 "setOperand() out of range!") ? void (0) : __assert_fail ("i_nocapture < OperandTraits<IndirectBrInst>::operands(this) && \"setOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 3704, __extension__ __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); }

3706//===----------------------------------------------------------------------===//
3707//                               InvokeInst Class
3708//===----------------------------------------------------------------------===//

3710/// Invoke instruction.  The SubclassData field is used to hold the
3711/// calling convention of the call.
3712///
3713class InvokeInst : public CallBase<InvokeInst> {
friend class OperandBundleUser<InvokeInst, User::op_iterator>;

InvokeInst(const InvokeInst &BI);

/// Construct an InvokeInst given a range of arguments.
///
/// Construct an InvokeInst from a range of arguments
inline InvokeInst(Value *Func, BasicBlock *IfNormal, BasicBlock *IfException,
                  ArrayRef<Value *> Args, ArrayRef<OperandBundleDef> Bundles,
                  unsigned Values, const Twine &NameStr,
                  Instruction *InsertBefore)
    : InvokeInst(cast<FunctionType>(
                     cast<PointerType>(Func->getType())->getElementType()),
                 Func, IfNormal, IfException, Args, Bundles, Values, NameStr,
                 InsertBefore) {}

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


void init(Value *Func, BasicBlock *IfNormal, BasicBlock *IfException,
          ArrayRef<Value *> Args, ArrayRef<OperandBundleDef> Bundles,
          const Twine &NameStr) {
  init(cast<FunctionType>(
           cast<PointerType>(Func->getType())->getElementType()),
       Func, IfNormal, IfException, Args, Bundles, NameStr);
}

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

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

InvokeInst *cloneImpl() const;

3761public:
static constexpr int ArgOffset = 3;
static InvokeInst *Create(Value *Func, BasicBlock *IfNormal,
                          BasicBlock *IfException, ArrayRef<Value *> Args,
                          const Twine &NameStr,
                          Instruction *InsertBefore = nullptr) {
  return Create(cast<FunctionType>(
                    cast<PointerType>(Func->getType())->getElementType()),
                Func, IfNormal, IfException, Args, None, NameStr,
                InsertBefore);
}

static InvokeInst *Create(Value *Func, BasicBlock *IfNormal,
                          BasicBlock *IfException, ArrayRef<Value *> Args,
                          ArrayRef<OperandBundleDef> Bundles = None,
                          const Twine &NameStr = "",
                          Instruction *InsertBefore = nullptr) {
  return Create(cast<FunctionType>(
                    cast<PointerType>(Func->getType())->getElementType()),
                Func, IfNormal, IfException, Args, Bundles, NameStr,
                InsertBefore);
}

static InvokeInst *Create(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
                          BasicBlock *IfException, ArrayRef<Value *> Args,
                          const Twine &NameStr,
                          Instruction *InsertBefore = nullptr) {
  unsigned Values = unsigned(Args.size()) + 3;
  return new (Values) InvokeInst(Ty, Func, IfNormal, IfException, Args, None,
                                 Values, 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) {
  unsigned Values = unsigned(Args.size()) + CountBundleInputs(Bundles) + 3;
  unsigned DescriptorBytes = Bundles.size() * sizeof(BundleOpInfo);

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

static InvokeInst *Create(Value *Func,
                          BasicBlock *IfNormal, BasicBlock *IfException,
                          ArrayRef<Value *> Args, const Twine &NameStr,
                          BasicBlock *InsertAtEnd) {
  unsigned Values = unsigned(Args.size()) + 3;
  return new (Values) InvokeInst(Func, IfNormal, IfException, Args, None,
                                 Values, NameStr, InsertAtEnd);
}

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

  return new (Values, DescriptorBytes)
      InvokeInst(Func, IfNormal, IfException, Args, Bundles, Values, 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);

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

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

/// Return the function called, or null if this is an
/// indirect function invocation.
///
Function *getCalledFunction() const {
  return dyn_cast<Function>(Op<-3>());
}

/// Get a pointer to the function that is invoked by this
/// instruction
const Value *getCalledValue() const { return Op<-3>(); }
      Value *getCalledValue()       { return Op<-3>(); }

/// Set the function called.
void setCalledFunction(Value* Fn) {
  setCalledFunction(
      cast<FunctionType>(cast<PointerType>(Fn->getType())->getElementType()),
      Fn);
}
void setCalledFunction(FunctionType *FTy, Value *Fn) {
  this->FTy = FTy;
  assert(FTy == cast<FunctionType>((static_cast <bool> (FTy == cast<FunctionType>( cast
<PointerType>(Fn->getType())->getElementType())) ?
 void (0) : __assert_fail ("FTy == cast<FunctionType>( cast<PointerType>(Fn->getType())->getElementType())"
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 3866, __extension__ __PRETTY_FUNCTION__))
                    cast<PointerType>(Fn->getType())->getElementType()))(static_cast <bool> (FTy == cast<FunctionType>( cast
<PointerType>(Fn->getType())->getElementType())) ?
 void (0) : __assert_fail ("FTy == cast<FunctionType>( cast<PointerType>(Fn->getType())->getElementType())"
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 3866, __extension__ __PRETTY_FUNCTION__));
  Op<-3>() = Fn;
}

// get*Dest - Return the destination basic blocks...
BasicBlock *getNormalDest() const {
  return cast<BasicBlock>(Op<-2>());
}
BasicBlock *getUnwindDest() const {
  return cast<BasicBlock>(Op<-1>());
}
void setNormalDest(BasicBlock *B) {
  Op<-2>() = reinterpret_cast<Value*>(B);
}
void setUnwindDest(BasicBlock *B) {
  Op<-1>() = 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!")(static_cast <bool> (i < 2 && "Successor # out of range for invoke!"
) ? void (0) : __assert_fail ("i < 2 && \"Successor # out of range for invoke!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 3889, __extension__ __PRETTY_FUNCTION__));
  return i == 0 ? getNormalDest() : getUnwindDest();
}

void setSuccessor(unsigned idx, BasicBlock *NewSucc) {
  assert(idx < 2 && "Successor # out of range for invoke!")(static_cast <bool> (idx < 2 && "Successor # out of range for invoke!"
) ? void (0) : __assert_fail ("idx < 2 && \"Successor # out of range for invoke!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 3894, __extension__ __PRETTY_FUNCTION__));
  *(&Op<-2>() + idx) = reinterpret_cast<Value*>(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));
}

3908private:

// Shadow Instruction::setInstructionSubclassData with a private forwarding
// method so that subclasses cannot accidentally use it.
void setInstructionSubclassData(unsigned short D) {
  Instruction::setInstructionSubclassData(D);
}
3915};

3917template <>
3918struct OperandTraits<CallBase<InvokeInst>>
  : public VariadicOperandTraits<CallBase<InvokeInst>, 3> {};

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

3932InvokeInst::InvokeInst(Value *Func, BasicBlock *IfNormal,
                     BasicBlock *IfException, ArrayRef<Value *> Args,
                     ArrayRef<OperandBundleDef> Bundles, unsigned Values,
                     const Twine &NameStr, BasicBlock *InsertAtEnd)
  : CallBase<InvokeInst>(
        cast<FunctionType>(
            cast<PointerType>(Func->getType())->getElementType())
            ->getReturnType(),
        Instruction::Invoke,
        OperandTraits<CallBase<InvokeInst>>::op_end(this) - Values, Values,
        InsertAtEnd) {
init(Func, IfNormal, IfException, Args, Bundles, NameStr);
3944}


3947//===----------------------------------------------------------------------===//
3948//                              ResumeInst Class
3949//===----------------------------------------------------------------------===//

3951//===---------------------------------------------------------------------------
3952/// Resume the propagation of an exception.
3953///
3954class ResumeInst : public TerminatorInst {
ResumeInst(const ResumeInst &RI);

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

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

ResumeInst *cloneImpl() const;

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

3991private:
friend TerminatorInst;

BasicBlock *getSuccessor(unsigned idx) const {
  llvm_unreachable("ResumeInst has no successors!")::llvm::llvm_unreachable_internal("ResumeInst has no successors!"
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 3995);
}

void setSuccessor(unsigned idx, BasicBlock *NewSucc) {
  llvm_unreachable("ResumeInst has no successors!")::llvm::llvm_unreachable_internal("ResumeInst has no successors!"
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 3999);
}
4001};

4003template <>
4004struct OperandTraits<ResumeInst> :
  public FixedNumOperandTraits<ResumeInst, 1> {
4006};

4008DEFINE_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 { (static_cast <bool
> (i_nocapture < OperandTraits<ResumeInst>::operands
(this) && "getOperand() out of range!") ? void (0) : __assert_fail
 ("i_nocapture < OperandTraits<ResumeInst>::operands(this) && \"getOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 4008, __extension__ __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) { (static_cast
 <bool> (i_nocapture < OperandTraits<ResumeInst>
::operands(this) && "setOperand() out of range!") ? void
 (0) : __assert_fail ("i_nocapture < OperandTraits<ResumeInst>::operands(this) && \"setOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 4008, __extension__ __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); }

4010//===----------------------------------------------------------------------===//
4011//                         CatchSwitchInst Class
4012//===----------------------------------------------------------------------===//
4013class CatchSwitchInst : public TerminatorInst {
/// 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);

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

CatchSwitchInst *cloneImpl() const;

4051public:
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 getSubclassDataFromInstruction() & 1; }
bool unwindsToCaller() const { return !hasUnwindDest(); }
BasicBlock *getUnwindDest() const {
  if (hasUnwindDest())
    return cast<BasicBlock>(getOperand(1));
  return nullptr;
}
void setUnwindDest(BasicBlock *UnwindDest) {
  assert(UnwindDest)(static_cast <bool> (UnwindDest) ? void (0) : __assert_fail
 ("UnwindDest", "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 4083, __extension__ __PRETTY_FUNCTION__));
  assert(hasUnwindDest())(static_cast <bool> (hasUnwindDest()) ? void (0) : __assert_fail
 ("hasUnwindDest()", "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 4084, __extension__ __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;
}

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

4102public:
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() &&(static_cast <bool> (Idx < getNumSuccessors() &&
 "Successor # out of range for catchswitch!") ? void (0) : __assert_fail
 ("Idx < getNumSuccessors() && \"Successor # out of range for catchswitch!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 4161, __extension__ __PRETTY_FUNCTION__))
         "Successor # out of range for catchswitch!")(static_cast <bool> (Idx < getNumSuccessors() &&
 "Successor # out of range for catchswitch!") ? void (0) : __assert_fail
 ("Idx < getNumSuccessors() && \"Successor # out of range for catchswitch!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 4161, __extension__ __PRETTY_FUNCTION__));
  return cast<BasicBlock>(getOperand(Idx + 1));
}
void setSuccessor(unsigned Idx, BasicBlock *NewSucc) {
  assert(Idx < getNumSuccessors() &&(static_cast <bool> (Idx < getNumSuccessors() &&
 "Successor # out of range for catchswitch!") ? void (0) : __assert_fail
 ("Idx < getNumSuccessors() && \"Successor # out of range for catchswitch!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 4166, __extension__ __PRETTY_FUNCTION__))
         "Successor # out of range for catchswitch!")(static_cast <bool> (Idx < getNumSuccessors() &&
 "Successor # out of range for catchswitch!") ? void (0) : __assert_fail
 ("Idx < getNumSuccessors() && \"Successor # out of range for catchswitch!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 4166, __extension__ __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));
}
4177};

4179template <>
4180struct OperandTraits<CatchSwitchInst> : public HungoffOperandTraits<2> {};

4182DEFINE_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 { (static_cast <bool
> (i_nocapture < OperandTraits<CatchSwitchInst>::
operands(this) && "getOperand() out of range!") ? void
 (0) : __assert_fail ("i_nocapture < OperandTraits<CatchSwitchInst>::operands(this) && \"getOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 4182, __extension__ __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) { (static_cast <bool> (i_nocapture <
 OperandTraits<CatchSwitchInst>::operands(this) &&
 "setOperand() out of range!") ? void (0) : __assert_fail ("i_nocapture < OperandTraits<CatchSwitchInst>::operands(this) && \"setOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 4182, __extension__ __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); }

4184//===----------------------------------------------------------------------===//
4185//                               CleanupPadInst Class
4186//===----------------------------------------------------------------------===//
4187class CleanupPadInst : public FuncletPadInst {
4188private:
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) {}

4200public:
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));
}
4223};

4225//===----------------------------------------------------------------------===//
4226//                               CatchPadInst Class
4227//===----------------------------------------------------------------------===//
4228class CatchPadInst : public FuncletPadInst {
4229private:
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) {}

4241public:
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)(static_cast <bool> (CatchSwitch) ? void (0) : __assert_fail
 ("CatchSwitch", "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 4262, __extension__ __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));
}
4273};

4275//===----------------------------------------------------------------------===//
4276//                               CatchReturnInst Class
4277//===----------------------------------------------------------------------===//

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

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

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

CatchReturnInst *cloneImpl() const;

4292public:
static CatchReturnInst *Create(Value *CatchPad, BasicBlock *BB,
                               Instruction *InsertBefore = nullptr) {
  assert(CatchPad)(static_cast <bool> (CatchPad) ? void (0) : __assert_fail
 ("CatchPad", "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 4295, __extension__ __PRETTY_FUNCTION__));
  assert(BB)(static_cast <bool> (BB) ? void (0) : __assert_fail ("BB"
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 4296, __extension__ __PRETTY_FUNCTION__));
  return new (2) CatchReturnInst(CatchPad, BB, InsertBefore);
}

static CatchReturnInst *Create(Value *CatchPad, BasicBlock *BB,
                               BasicBlock *InsertAtEnd) {
  assert(CatchPad)(static_cast <bool> (CatchPad) ? void (0) : __assert_fail
 ("CatchPad", "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 4302, __extension__ __PRETTY_FUNCTION__));
  assert(BB)(static_cast <bool> (BB) ? void (0) : __assert_fail ("BB"
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 4303, __extension__ __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)(static_cast <bool> (CatchPad) ? void (0) : __assert_fail
 ("CatchPad", "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 4313, __extension__ __PRETTY_FUNCTION__));
  Op<0>() = CatchPad;
}

BasicBlock *getSuccessor() const { return cast<BasicBlock>(Op<1>()); }
void setSuccessor(BasicBlock *NewSucc) {
  assert(NewSucc)(static_cast <bool> (NewSucc) ? void (0) : __assert_fail
 ("NewSucc", "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 4319, __extension__ __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));
}

4338private:
friend TerminatorInst;

BasicBlock *getSuccessor(unsigned Idx) const {
  assert(Idx < getNumSuccessors() && "Successor # out of range for catchret!")(static_cast <bool> (Idx < getNumSuccessors() &&
 "Successor # out of range for catchret!") ? void (0) : __assert_fail
 ("Idx < getNumSuccessors() && \"Successor # out of range for catchret!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 4342, __extension__ __PRETTY_FUNCTION__));
  return getSuccessor();
}

void setSuccessor(unsigned Idx, BasicBlock *B) {
  assert(Idx < getNumSuccessors() && "Successor # out of range for catchret!")(static_cast <bool> (Idx < getNumSuccessors() &&
 "Successor # out of range for catchret!") ? void (0) : __assert_fail
 ("Idx < getNumSuccessors() && \"Successor # out of range for catchret!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 4347, __extension__ __PRETTY_FUNCTION__));
  setSuccessor(B);
}
4350};

4352template <>
4353struct OperandTraits<CatchReturnInst>
  : public FixedNumOperandTraits<CatchReturnInst, 2> {};

4356DEFINE_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 { (static_cast <bool
> (i_nocapture < OperandTraits<CatchReturnInst>::
operands(this) && "getOperand() out of range!") ? void
 (0) : __assert_fail ("i_nocapture < OperandTraits<CatchReturnInst>::operands(this) && \"getOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 4356, __extension__ __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) { (static_cast <bool> (i_nocapture <
 OperandTraits<CatchReturnInst>::operands(this) &&
 "setOperand() out of range!") ? void (0) : __assert_fail ("i_nocapture < OperandTraits<CatchReturnInst>::operands(this) && \"setOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 4356, __extension__ __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); }

4358//===----------------------------------------------------------------------===//
4359//                               CleanupReturnInst Class
4360//===----------------------------------------------------------------------===//

4362class CleanupReturnInst : public TerminatorInst {
4363private:
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);

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

CleanupReturnInst *cloneImpl() const;

4378public:
static CleanupReturnInst *Create(Value *CleanupPad,
                                 BasicBlock *UnwindBB = nullptr,
                                 Instruction *InsertBefore = nullptr) {
  assert(CleanupPad)(static_cast <bool> (CleanupPad) ? void (0) : __assert_fail
 ("CleanupPad", "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 4382, __extension__ __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)(static_cast <bool> (CleanupPad) ? void (0) : __assert_fail
 ("CleanupPad", "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 4392, __extension__ __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 getSubclassDataFromInstruction() & 1; }
bool unwindsToCaller() const { return !hasUnwindDest(); }

/// Convenience accessor.
CleanupPadInst *getCleanupPad() const {
  return cast<CleanupPadInst>(Op<0>());
}
void setCleanupPad(CleanupPadInst *CleanupPad) {
  assert(CleanupPad)(static_cast <bool> (CleanupPad) ? void (0) : __assert_fail
 ("CleanupPad", "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 4411, __extension__ __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)(static_cast <bool> (NewDest) ? void (0) : __assert_fail
 ("NewDest", "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 4421, __extension__ __PRETTY_FUNCTION__));
  assert(hasUnwindDest())(static_cast <bool> (hasUnwindDest()) ? void (0) : __assert_fail
 ("hasUnwindDest()", "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 4422, __extension__ __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));
}

4434private:
friend TerminatorInst;

BasicBlock *getSuccessor(unsigned Idx) const {
  assert(Idx == 0)(static_cast <bool> (Idx == 0) ? void (0) : __assert_fail
 ("Idx == 0", "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 4438, __extension__ __PRETTY_FUNCTION__));
  return getUnwindDest();
}

void setSuccessor(unsigned Idx, BasicBlock *B) {
  assert(Idx == 0)(static_cast <bool> (Idx == 0) ? void (0) : __assert_fail
 ("Idx == 0", "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 4443, __extension__ __PRETTY_FUNCTION__));
  setUnwindDest(B);
}

// Shadow Instruction::setInstructionSubclassData with a private forwarding
// method so that subclasses cannot accidentally use it.
void setInstructionSubclassData(unsigned short D) {
  Instruction::setInstructionSubclassData(D);
}
4452};

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

4458DEFINE_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 { (static_cast <bool> (i_nocapture <
 OperandTraits<CleanupReturnInst>::operands(this) &&
 "getOperand() out of range!") ? void (0) : __assert_fail ("i_nocapture < OperandTraits<CleanupReturnInst>::operands(this) && \"getOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 4458, __extension__ __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) { (static_cast <bool> (i_nocapture
 < OperandTraits<CleanupReturnInst>::operands(this) &&
 "setOperand() out of range!") ? void (0) : __assert_fail ("i_nocapture < OperandTraits<CleanupReturnInst>::operands(this) && \"setOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 4458, __extension__ __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
); }

4460//===----------------------------------------------------------------------===//
4461//                           UnreachableInst Class
4462//===----------------------------------------------------------------------===//

4464//===---------------------------------------------------------------------------
4465/// This function has undefined behavior.  In particular, the
4466/// presence of this instruction indicates some higher level knowledge that the
4467/// end of the block cannot be reached.
4468///
4469class UnreachableInst : public TerminatorInst {
4470protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

UnreachableInst *cloneImpl() const;

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

4495private:
friend TerminatorInst;

BasicBlock *getSuccessor(unsigned idx) const {
  llvm_unreachable("UnreachableInst has no successors!")::llvm::llvm_unreachable_internal("UnreachableInst has no successors!"
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 4499);
}

void setSuccessor(unsigned idx, BasicBlock *B) {
  llvm_unreachable("UnreachableInst has no successors!")::llvm::llvm_unreachable_internal("UnreachableInst has no successors!"
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/IR/Instructions.h"
, 4503);
}
4505};

4507//===----------------------------------------------------------------------===//
4508//                                 TruncInst Class
4509//===----------------------------------------------------------------------===//

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

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

4520public:
/// 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));
}
4544};

4546//===----------------------------------------------------------------------===//
4547//                                 ZExtInst Class
4548//===----------------------------------------------------------------------===//

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

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

4559public:
/// 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));
}
4583};

4585//===----------------------------------------------------------------------===//
4586//                                 SExtInst Class
4587//===----------------------------------------------------------------------===//

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

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

4598public:
/// 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));
}
4622};

4624//===----------------------------------------------------------------------===//
4625//                                 FPTruncInst Class
4626//===----------------------------------------------------------------------===//

4628/// This class represents a truncation of floating point types.
4629class FPTruncInst : public CastInst {
4630protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

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

4637public:
/// 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));
}
4661};

4663//===----------------------------------------------------------------------===//
4664//                                 FPExtInst Class
4665//===----------------------------------------------------------------------===//

4667/// This class represents an extension of floating point types.
4668class FPExtInst : public CastInst {
4669protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

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

4676public:
/// 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));
}
4700};

4702//===----------------------------------------------------------------------===//
4703//                                 UIToFPInst Class
4704//===----------------------------------------------------------------------===//

4706/// This class represents a cast unsigned integer to floating point.
4707class UIToFPInst : public CastInst {
4708protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

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

4715public:
/// 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));
}
4739};

4741//===----------------------------------------------------------------------===//
4742//                                 SIToFPInst Class
4743//===----------------------------------------------------------------------===//

4745/// This class represents a cast from signed integer to floating point.
4746class SIToFPInst : public CastInst {
4747protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

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

4754public:
/// 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));
}
4778};

4780//===----------------------------------------------------------------------===//
4781//                                 FPToUIInst Class
4782//===----------------------------------------------------------------------===//

4784/// This class represents a cast from floating point to unsigned integer
4785class FPToUIInst  : public CastInst {
4786protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

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

4793public:
/// 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));
}
4817};

4819//===----------------------------------------------------------------------===//
4820//                                 FPToSIInst Class
4821//===----------------------------------------------------------------------===//

4823/// This class represents a cast from floating point to signed integer.
4824class FPToSIInst  : public CastInst {
4825protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

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

4832public:
/// 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));
}
4856};

4858//===----------------------------------------------------------------------===//
4859//                                 IntToPtrInst Class
4860//===----------------------------------------------------------------------===//

4862/// This class represents a cast from an integer to a pointer.
4863class IntToPtrInst : public CastInst {
4864public:
// 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));
}
4899};

4901//===----------------------------------------------------------------------===//
4902//                                 PtrToIntInst Class
4903//===----------------------------------------------------------------------===//

4905/// This class represents a cast from a pointer to an integer.
4906class PtrToIntInst : public CastInst {
4907protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

/// Clone an identical PtrToIntInst.
PtrToIntInst *cloneImpl() const;

4914public:
/// 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));
}
4950};

4952//===----------------------------------------------------------------------===//
4953//                             BitCastInst Class
4954//===----------------------------------------------------------------------===//

4956/// This class represents a no-op cast from one type to another.
4957class BitCastInst : public CastInst {
4958protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

/// Clone an identical BitCastInst.
BitCastInst *cloneImpl() const;

4965public:
/// 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));
}
4989};

4991//===----------------------------------------------------------------------===//
4992//                          AddrSpaceCastInst Class
4993//===----------------------------------------------------------------------===//

4995/// This class represents a conversion between pointers from one address space
4996/// to another.
4997class AddrSpaceCastInst : public CastInst {
4998protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

/// Clone an identical AddrSpaceCastInst.
AddrSpaceCastInst *cloneImpl() const;

5005public:
/// 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();
}
5054};

5056/// A helper function that returns the pointer operand of a load or store
5057/// instruction. Returns nullptr if not load or store.
5058inline Value *getLoadStorePointerOperand(Value *V) {
if (auto *Load = dyn_cast<LoadInst>(V))
  return Load->getPointerOperand();
if (auto *Store = dyn_cast<StoreInst>(V))
  return Store->getPointerOperand();
return nullptr;
5064}

5066/// A helper function that returns the pointer operand of a load, store
5067/// or GEP instruction. Returns nullptr if not load, store, or GEP.
5068inline Value *getPointerOperand(Value *V) {
if (auto *Ptr = getLoadStorePointerOperand(V))
  return Ptr;
if (auto *Gep = dyn_cast<GetElementPtrInst>(V))
  return Gep->getPointerOperand();
return nullptr;
5074}

5076} // end namespace llvm

5078#endif // LLVM_IR_INSTRUCTIONS_H