/build/source/llvm/lib/Target/AMDGPU/AMDGPUPromoteAlloca.cpp

Bug Summary

File:	build/source/llvm/lib/Target/AMDGPU/AMDGPUPromoteAlloca.cpp
Warning:	line 483, column 39 Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name AMDGPUPromoteAlloca.cpp -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/source/build-llvm/tools/clang/stage2-bins -resource-dir /usr/lib/llvm-16/lib/clang/16 -I lib/Target/AMDGPU -I /build/source/llvm/lib/Target/AMDGPU -I include -I /build/source/llvm/include -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -D _FORTIFY_SOURCE=2 -D NDEBUG -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-16/lib/clang/16/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fmacro-prefix-map=/build/source/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fmacro-prefix-map=/build/source/= -fcoverage-prefix-map=/build/source/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fcoverage-prefix-map=/build/source/= -source-date-epoch 1672697298 -O2 -Wno-unused-command-line-argument -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -Wno-misleading-indentation -std=c++17 -fdeprecated-macro -fdebug-compilation-dir=/build/source/build-llvm/tools/clang/stage2-bins -fdebug-prefix-map=/build/source/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fdebug-prefix-map=/build/source/= -ferror-limit 19 -fvisibility=hidden -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcolor-diagnostics -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2023-01-03-004743-16233-1 -x c++ /build/source/llvm/lib/Target/AMDGPU/AMDGPUPromoteAlloca.cpp

/build/source/llvm/lib/Target/AMDGPU/AMDGPUPromoteAlloca.cpp

→

1//===-- AMDGPUPromoteAlloca.cpp - Promote Allocas -------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This pass eliminates allocas by either converting them into vectors or
10// by migrating them to local address space.
11//
12//===----------------------------------------------------------------------===//

14#include "AMDGPU.h"
15#include "GCNSubtarget.h"
16#include "Utils/AMDGPUBaseInfo.h"
17#include "llvm/Analysis/CaptureTracking.h"
18#include "llvm/Analysis/ValueTracking.h"
19#include "llvm/CodeGen/TargetPassConfig.h"
20#include "llvm/IR/IRBuilder.h"
21#include "llvm/IR/IntrinsicInst.h"
22#include "llvm/IR/IntrinsicsAMDGPU.h"
23#include "llvm/IR/IntrinsicsR600.h"
24#include "llvm/Pass.h"
25#include "llvm/Target/TargetMachine.h"

27#define DEBUG_TYPE"amdgpu-promote-alloca" "amdgpu-promote-alloca"

29using namespace llvm;

31namespace {

33static cl::opt<bool> DisablePromoteAllocaToVector(
"disable-promote-alloca-to-vector",
cl::desc("Disable promote alloca to vector"),
cl::init(false));

38static cl::opt<bool> DisablePromoteAllocaToLDS(
"disable-promote-alloca-to-lds",
cl::desc("Disable promote alloca to LDS"),
cl::init(false));

43static cl::opt<unsigned> PromoteAllocaToVectorLimit(
"amdgpu-promote-alloca-to-vector-limit",
cl::desc("Maximum byte size to consider promote alloca to vector"),
cl::init(0));

48// FIXME: This can create globals so should be a module pass.
49class AMDGPUPromoteAlloca : public FunctionPass {
50public:
static char ID;

AMDGPUPromoteAlloca() : FunctionPass(ID) {}

bool runOnFunction(Function &F) override;

StringRef getPassName() const override { return "AMDGPU Promote Alloca"; }

bool handleAlloca(AllocaInst &I, bool SufficientLDS);

void getAnalysisUsage(AnalysisUsage &AU) const override {
  AU.setPreservesCFG();
  FunctionPass::getAnalysisUsage(AU);
}
65};

67class AMDGPUPromoteAllocaImpl {
68private:
const TargetMachine &TM;
Module *Mod = nullptr;
const DataLayout *DL = nullptr;

// FIXME: This should be per-kernel.
uint32_t LocalMemLimit = 0;
uint32_t CurrentLocalMemUsage = 0;
unsigned MaxVGPRs;

bool IsAMDGCN = false;
bool IsAMDHSA = false;

std::pair<Value *, Value *> getLocalSizeYZ(IRBuilder<> &Builder);
Value *getWorkitemID(IRBuilder<> &Builder, unsigned N);

/// BaseAlloca is the alloca root the search started from.
/// Val may be that alloca or a recursive user of it.
bool collectUsesWithPtrTypes(Value *BaseAlloca,
                             Value *Val,
                             std::vector<Value*> &WorkList) const;

/// Val is a derived pointer from Alloca. OpIdx0/OpIdx1 are the operand
/// indices to an instruction with 2 pointer inputs (e.g. select, icmp).
/// Returns true if both operands are derived from the same alloca. Val should
/// be the same value as one of the input operands of UseInst.
bool binaryOpIsDerivedFromSameAlloca(Value *Alloca, Value *Val,
                                     Instruction *UseInst,
                                     int OpIdx0, int OpIdx1) const;

/// Check whether we have enough local memory for promotion.
bool hasSufficientLocalMem(const Function &F);

bool handleAlloca(AllocaInst &I, bool SufficientLDS);

103public:
AMDGPUPromoteAllocaImpl(TargetMachine &TM) : TM(TM) {}
bool run(Function &F);
106};

108class AMDGPUPromoteAllocaToVector : public FunctionPass {
109public:
static char ID;

AMDGPUPromoteAllocaToVector() : FunctionPass(ID) {}

bool runOnFunction(Function &F) override;

StringRef getPassName() const override {
  return "AMDGPU Promote Alloca to vector";
}

void getAnalysisUsage(AnalysisUsage &AU) const override {
  AU.setPreservesCFG();
  FunctionPass::getAnalysisUsage(AU);
}
124};

126} // end anonymous namespace

128char AMDGPUPromoteAlloca::ID = 0;
129char AMDGPUPromoteAllocaToVector::ID = 0;

131INITIALIZE_PASS_BEGIN(AMDGPUPromoteAlloca, DEBUG_TYPE,static void *initializeAMDGPUPromoteAllocaPassOnce(PassRegistry
 &Registry) {
                    "AMDGPU promote alloca to vector or LDS", false, false)static void *initializeAMDGPUPromoteAllocaPassOnce(PassRegistry
 &Registry) {
133// Move LDS uses from functions to kernels before promote alloca for accurate
134// estimation of LDS available
135INITIALIZE_PASS_DEPENDENCY(AMDGPULowerModuleLDS)initializeAMDGPULowerModuleLDSPass(Registry);
136INITIALIZE_PASS_END(AMDGPUPromoteAlloca, DEBUG_TYPE,PassInfo *PI = new PassInfo( "AMDGPU promote alloca to vector or LDS"
, "amdgpu-promote-alloca", &AMDGPUPromoteAlloca::ID, PassInfo
::NormalCtor_t(callDefaultCtor<AMDGPUPromoteAlloca>), false
, false); Registry.registerPass(*PI, true); return PI; } static
 llvm::once_flag InitializeAMDGPUPromoteAllocaPassFlag; void llvm
::initializeAMDGPUPromoteAllocaPass(PassRegistry &Registry
) { llvm::call_once(InitializeAMDGPUPromoteAllocaPassFlag, initializeAMDGPUPromoteAllocaPassOnce
, std::ref(Registry)); }
                  "AMDGPU promote alloca to vector or LDS", false, false)PassInfo *PI = new PassInfo( "AMDGPU promote alloca to vector or LDS"
, "amdgpu-promote-alloca", &AMDGPUPromoteAlloca::ID, PassInfo
::NormalCtor_t(callDefaultCtor<AMDGPUPromoteAlloca>), false
, false); Registry.registerPass(*PI, true); return PI; } static
 llvm::once_flag InitializeAMDGPUPromoteAllocaPassFlag; void llvm
::initializeAMDGPUPromoteAllocaPass(PassRegistry &Registry
) { llvm::call_once(InitializeAMDGPUPromoteAllocaPassFlag, initializeAMDGPUPromoteAllocaPassOnce
, std::ref(Registry)); }

139INITIALIZE_PASS(AMDGPUPromoteAllocaToVector, DEBUG_TYPE "-to-vector",static void *initializeAMDGPUPromoteAllocaToVectorPassOnce(PassRegistry
 &Registry) { PassInfo *PI = new PassInfo( "AMDGPU promote alloca to vector"
, "amdgpu-promote-alloca" "-to-vector", &AMDGPUPromoteAllocaToVector
::ID, PassInfo::NormalCtor_t(callDefaultCtor<AMDGPUPromoteAllocaToVector
>), false, false); Registry.registerPass(*PI, true); return
 PI; } static llvm::once_flag InitializeAMDGPUPromoteAllocaToVectorPassFlag
; void llvm::initializeAMDGPUPromoteAllocaToVectorPass(PassRegistry
 &Registry) { llvm::call_once(InitializeAMDGPUPromoteAllocaToVectorPassFlag
, initializeAMDGPUPromoteAllocaToVectorPassOnce, std::ref(Registry
)); }
              "AMDGPU promote alloca to vector", false, false)static void *initializeAMDGPUPromoteAllocaToVectorPassOnce(PassRegistry
 &Registry) { PassInfo *PI = new PassInfo( "AMDGPU promote alloca to vector"
, "amdgpu-promote-alloca" "-to-vector", &AMDGPUPromoteAllocaToVector
::ID, PassInfo::NormalCtor_t(callDefaultCtor<AMDGPUPromoteAllocaToVector
>), false, false); Registry.registerPass(*PI, true); return
 PI; } static llvm::once_flag InitializeAMDGPUPromoteAllocaToVectorPassFlag
; void llvm::initializeAMDGPUPromoteAllocaToVectorPass(PassRegistry
 &Registry) { llvm::call_once(InitializeAMDGPUPromoteAllocaToVectorPassFlag
, initializeAMDGPUPromoteAllocaToVectorPassOnce, std::ref(Registry
)); }

142char &llvm::AMDGPUPromoteAllocaID = AMDGPUPromoteAlloca::ID;
143char &llvm::AMDGPUPromoteAllocaToVectorID = AMDGPUPromoteAllocaToVector::ID;

145bool AMDGPUPromoteAlloca::runOnFunction(Function &F) {
if (skipFunction(F))
  return false;

if (auto *TPC = getAnalysisIfAvailable<TargetPassConfig>()) {
  return AMDGPUPromoteAllocaImpl(TPC->getTM<TargetMachine>()).run(F);
}
return false;
153}

155PreservedAnalyses AMDGPUPromoteAllocaPass::run(Function &F,
                                             FunctionAnalysisManager &AM) {
bool Changed = AMDGPUPromoteAllocaImpl(TM).run(F);
if (Changed) {
  PreservedAnalyses PA;
  PA.preserveSet<CFGAnalyses>();
  return PA;
}
return PreservedAnalyses::all();
164}

166bool AMDGPUPromoteAllocaImpl::run(Function &F) {
Mod = F.getParent();
DL = &Mod->getDataLayout();

const Triple &TT = TM.getTargetTriple();
IsAMDGCN = TT.getArch() == Triple::amdgcn;
IsAMDHSA = TT.getOS() == Triple::AMDHSA;

const AMDGPUSubtarget &ST = AMDGPUSubtarget::get(TM, F);
if (!ST.isPromoteAllocaEnabled())
  return false;

if (IsAMDGCN) {
  const GCNSubtarget &ST = TM.getSubtarget<GCNSubtarget>(F);
  MaxVGPRs = ST.getMaxNumVGPRs(ST.getWavesPerEU(F).first);
  // A non-entry function has only 32 caller preserved registers.
  // Do not promote alloca which will force spilling.
  if (!AMDGPU::isEntryFunctionCC(F.getCallingConv()))
    MaxVGPRs = std::min(MaxVGPRs, 32u);
} else {
  MaxVGPRs = 128;
}

bool SufficientLDS = hasSufficientLocalMem(F);
bool Changed = false;
BasicBlock &EntryBB = *F.begin();

SmallVector<AllocaInst *, 16> Allocas;
for (Instruction &I : EntryBB) {
  if (AllocaInst *AI = dyn_cast<AllocaInst>(&I))
    Allocas.push_back(AI);
}

for (AllocaInst *AI : Allocas) {
  if (handleAlloca(*AI, SufficientLDS))
    Changed = true;
}

return Changed;
205}

207std::pair<Value *, Value *>
208AMDGPUPromoteAllocaImpl::getLocalSizeYZ(IRBuilder<> &Builder) {
Function &F = *Builder.GetInsertBlock()->getParent();
const AMDGPUSubtarget &ST = AMDGPUSubtarget::get(TM, F);

if (!IsAMDHSA) {
  Function *LocalSizeYFn
    = Intrinsic::getDeclaration(Mod, Intrinsic::r600_read_local_size_y);
  Function *LocalSizeZFn
    = Intrinsic::getDeclaration(Mod, Intrinsic::r600_read_local_size_z);

  CallInst *LocalSizeY = Builder.CreateCall(LocalSizeYFn, {});
  CallInst *LocalSizeZ = Builder.CreateCall(LocalSizeZFn, {});

  ST.makeLIDRangeMetadata(LocalSizeY);
  ST.makeLIDRangeMetadata(LocalSizeZ);

  return std::pair(LocalSizeY, LocalSizeZ);
}

// We must read the size out of the dispatch pointer.
assert(IsAMDGCN)(static_cast <bool> (IsAMDGCN) ? void (0) : __assert_fail
 ("IsAMDGCN", "llvm/lib/Target/AMDGPU/AMDGPUPromoteAlloca.cpp"
, 228, __extension__ __PRETTY_FUNCTION__));

// We are indexing into this struct, and want to extract the workgroup_size_*
// fields.
//
//   typedef struct hsa_kernel_dispatch_packet_s {
//     uint16_t header;
//     uint16_t setup;
//     uint16_t workgroup_size_x ;
//     uint16_t workgroup_size_y;
//     uint16_t workgroup_size_z;
//     uint16_t reserved0;
//     uint32_t grid_size_x ;
//     uint32_t grid_size_y ;
//     uint32_t grid_size_z;
//
//     uint32_t private_segment_size;
//     uint32_t group_segment_size;
//     uint64_t kernel_object;
//
// #ifdef HSA_LARGE_MODEL
//     void *kernarg_address;
// #elif defined HSA_LITTLE_ENDIAN
//     void *kernarg_address;
//     uint32_t reserved1;
// #else
//     uint32_t reserved1;
//     void *kernarg_address;
// #endif
//     uint64_t reserved2;
//     hsa_signal_t completion_signal; // uint64_t wrapper
//   } hsa_kernel_dispatch_packet_t
//
Function *DispatchPtrFn
  = Intrinsic::getDeclaration(Mod, Intrinsic::amdgcn_dispatch_ptr);

CallInst *DispatchPtr = Builder.CreateCall(DispatchPtrFn, {});
DispatchPtr->addRetAttr(Attribute::NoAlias);
DispatchPtr->addRetAttr(Attribute::NonNull);
F.removeFnAttr("amdgpu-no-dispatch-ptr");

// Size of the dispatch packet struct.
DispatchPtr->addDereferenceableRetAttr(64);

Type *I32Ty = Type::getInt32Ty(Mod->getContext());
Value *CastDispatchPtr = Builder.CreateBitCast(
  DispatchPtr, PointerType::get(I32Ty, AMDGPUAS::CONSTANT_ADDRESS));

// We could do a single 64-bit load here, but it's likely that the basic
// 32-bit and extract sequence is already present, and it is probably easier
// to CSE this. The loads should be mergeable later anyway.
Value *GEPXY = Builder.CreateConstInBoundsGEP1_64(I32Ty, CastDispatchPtr, 1);
LoadInst *LoadXY = Builder.CreateAlignedLoad(I32Ty, GEPXY, Align(4));

Value *GEPZU = Builder.CreateConstInBoundsGEP1_64(I32Ty, CastDispatchPtr, 2);
LoadInst *LoadZU = Builder.CreateAlignedLoad(I32Ty, GEPZU, Align(4));

MDNode *MD = MDNode::get(Mod->getContext(), std::nullopt);
LoadXY->setMetadata(LLVMContext::MD_invariant_load, MD);
LoadZU->setMetadata(LLVMContext::MD_invariant_load, MD);
ST.makeLIDRangeMetadata(LoadZU);

// Extract y component. Upper half of LoadZU should be zero already.
Value *Y = Builder.CreateLShr(LoadXY, 16);

return std::pair(Y, LoadZU);
294}

296Value *AMDGPUPromoteAllocaImpl::getWorkitemID(IRBuilder<> &Builder,
                                            unsigned N) {
Function *F = Builder.GetInsertBlock()->getParent();
const AMDGPUSubtarget &ST = AMDGPUSubtarget::get(TM, *F);
Intrinsic::ID IntrID = Intrinsic::not_intrinsic;
StringRef AttrName;

switch (N) {
case 0:
  IntrID = IsAMDGCN ? (Intrinsic::ID)Intrinsic::amdgcn_workitem_id_x
                    : (Intrinsic::ID)Intrinsic::r600_read_tidig_x;
  AttrName = "amdgpu-no-workitem-id-x";
  break;
case 1:
  IntrID = IsAMDGCN ? (Intrinsic::ID)Intrinsic::amdgcn_workitem_id_y
                    : (Intrinsic::ID)Intrinsic::r600_read_tidig_y;
  AttrName = "amdgpu-no-workitem-id-y";
  break;

case 2:
  IntrID = IsAMDGCN ? (Intrinsic::ID)Intrinsic::amdgcn_workitem_id_z
                    : (Intrinsic::ID)Intrinsic::r600_read_tidig_z;
  AttrName = "amdgpu-no-workitem-id-z";
  break;
default:
  llvm_unreachable("invalid dimension")::llvm::llvm_unreachable_internal("invalid dimension", "llvm/lib/Target/AMDGPU/AMDGPUPromoteAlloca.cpp"
, 321);
}

Function *WorkitemIdFn = Intrinsic::getDeclaration(Mod, IntrID);
CallInst *CI = Builder.CreateCall(WorkitemIdFn);
ST.makeLIDRangeMetadata(CI);
F->removeFnAttr(AttrName);

return CI;
330}

332static FixedVectorType *arrayTypeToVecType(ArrayType *ArrayTy) {
return FixedVectorType::get(ArrayTy->getElementType(),
                            ArrayTy->getNumElements());
335}

337static Value *
338calculateVectorIndex(Value *Ptr,
                   const std::map<GetElementPtrInst *, Value *> &GEPIdx) {
auto *GEP = dyn_cast<GetElementPtrInst>(Ptr->stripPointerCasts());
if (!GEP)
  return ConstantInt::getNullValue(Type::getInt32Ty(Ptr->getContext()));

auto I = GEPIdx.find(GEP);
assert(I != GEPIdx.end() && "Must have entry for GEP!")(static_cast <bool> (I != GEPIdx.end() && "Must have entry for GEP!"
) ? void (0) : __assert_fail ("I != GEPIdx.end() && \"Must have entry for GEP!\""
, "llvm/lib/Target/AMDGPU/AMDGPUPromoteAlloca.cpp", 345, __extension__
 __PRETTY_FUNCTION__));
return I->second;
347}

349static Value *GEPToVectorIndex(GetElementPtrInst *GEP, AllocaInst *Alloca,
                             Type *VecElemTy, const DataLayout &DL) {
// TODO: Extracting a "multiple of X" from a GEP might be a useful generic
// helper.
unsigned BW = DL.getIndexTypeSizeInBits(GEP->getType());
MapVector<Value *, APInt> VarOffsets;
APInt ConstOffset(BW, 0);
if (GEP->getPointerOperand()->stripPointerCasts() != Alloca ||
    !GEP->collectOffset(DL, BW, VarOffsets, ConstOffset))
  return nullptr;

unsigned VecElemSize = DL.getTypeAllocSize(VecElemTy);
if (VarOffsets.size() > 1)
  return nullptr;

if (VarOffsets.size() == 1) {
  // Only handle cases where we don't need to insert extra arithmetic
  // instructions.
  const auto &VarOffset = VarOffsets.front();
  if (!ConstOffset.isZero() || VarOffset.second != VecElemSize)
    return nullptr;
  return VarOffset.first;
}

APInt Quot;
uint64_t Rem;
APInt::udivrem(ConstOffset, VecElemSize, Quot, Rem);
if (Rem != 0)
  return nullptr;

return ConstantInt::get(GEP->getContext(), Quot);
380}

382static bool tryPromoteAllocaToVector(AllocaInst *Alloca, const DataLayout &DL,
                                   unsigned MaxVGPRs) {

if (DisablePromoteAllocaToVector) {
1
Assuming the condition is false→
2
←
Taking false branch→
  LLVM_DEBUG(dbgs() << "  Promotion alloca to vector is disabled\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("amdgpu-promote-alloca")) { dbgs() << "  Promotion alloca to vector is disabled\n"
; } } while (false);
  return false;
}

Type *AllocaTy = Alloca->getAllocatedType();
auto *VectorTy = dyn_cast<FixedVectorType>(AllocaTy);
3
←
Assuming 'AllocaTy' is not a 'CastReturnType'→
if (auto *ArrayTy4.1
'ArrayTy' is non-null
1
'ArrayTy' is non-null
 = dyn_cast<ArrayType>(AllocaTy)) {
4
←
Assuming 'AllocaTy' is a 'CastReturnType'→
  if (VectorType::isValidElementType(ArrayTy->getElementType()) &&
5
←
Assuming the condition is true→
7
←
Taking true branch→
      ArrayTy->getNumElements() > 0)
6
←
Assuming the condition is true→
    VectorTy = arrayTypeToVecType(ArrayTy);
}

// Use up to 1/4 of available register budget for vectorization.
unsigned Limit = PromoteAllocaToVectorLimit ? PromoteAllocaToVectorLimit * 8
8
←
Assuming the condition is false→
9
←
'?' condition is false→
                                            : (MaxVGPRs * 32);

if (DL.getTypeSizeInBits(AllocaTy) * 4 > Limit) {
10
←
Assuming the condition is false→
  LLVM_DEBUG(dbgs() << "  Alloca too big for vectorization with "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("amdgpu-promote-alloca")) { dbgs() << "  Alloca too big for vectorization with "
 << MaxVGPRs << " registers available\n"; } } while
 (false)
                    << MaxVGPRs << " registers available\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("amdgpu-promote-alloca")) { dbgs() << "  Alloca too big for vectorization with "
 << MaxVGPRs << " registers available\n"; } } while
 (false);
  return false;
}

LLVM_DEBUG(dbgs() << "Alloca candidate for vectorization\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("amdgpu-promote-alloca")) { dbgs() << "Alloca candidate for vectorization\n"
; } } while (false);
11
←
Taking false branch→
12
←
Assuming 'DebugFlag' is false→

// FIXME: There is no reason why we can't support larger arrays, we
// are just being conservative for now.
// FIXME: We also reject alloca's of the form [ 2 x [ 2 x i32 ]] or equivalent. Potentially these
// could also be promoted but we don't currently handle this case
if (!VectorTy || VectorTy->getNumElements() > 16 ||
13
←
Assuming 'VectorTy' is non-null→
14
←
Assuming the condition is false→
16
←
Taking false branch→
    VectorTy->getNumElements() < 2) {
15
←
Assuming the condition is false→
  LLVM_DEBUG(dbgs() << "  Cannot convert type to vector\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("amdgpu-promote-alloca")) { dbgs() << "  Cannot convert type to vector\n"
; } } while (false);
  return false;
}

std::map<GetElementPtrInst*, Value*> GEPVectorIdx;
SmallVector<Instruction *> WorkList;
SmallVector<Use *, 8> Uses;
for (Use &U : Alloca->uses())
  Uses.push_back(&U);

Type *VecEltTy = VectorTy->getElementType();
while (!Uses.empty()) {
17
←
Loop condition is true.  Entering loop body→
  Use *U = Uses.pop_back_val();
  Instruction *Inst = dyn_cast<Instruction>(U->getUser());
18
←
Assuming the object is not a 'CastReturnType'→
19
←
'Inst' initialized to a null pointer value→

  if (Value *Ptr29.1
'Ptr' is null
1
'Ptr' is null
 = getLoadStorePointerOperand(Inst)) {
20
←
Calling 'getLoadStorePointerOperand'→
29
←
Returning from 'getLoadStorePointerOperand'→
30
←
Taking false branch→
    // This is a store of the pointer, not to the pointer.
    if (isa<StoreInst>(Inst) &&
        U->getOperandNo() != StoreInst::getPointerOperandIndex())
      return false;

    Type *AccessTy = getLoadStoreType(Inst);
    Ptr = Ptr->stripPointerCasts();

    // Alloca already accessed as vector, leave alone.
    if (Ptr == Alloca && DL.getTypeStoreSize(Alloca->getAllocatedType()) ==
                             DL.getTypeStoreSize(AccessTy))
      continue;

    // Check that this is a simple access of a vector element.
    bool IsSimple = isa<LoadInst>(Inst) ? cast<LoadInst>(Inst)->isSimple()
                                        : cast<StoreInst>(Inst)->isSimple();
    if (!IsSimple ||
        !CastInst::isBitOrNoopPointerCastable(VecEltTy, AccessTy, DL))
      return false;

    WorkList.push_back(Inst);
    continue;
  }

  if (isa<BitCastInst>(Inst)) {
31
←
Assuming 'Inst' is not a 'BitCastInst'→
32
←
Taking false branch→
    // Look through bitcasts.
    for (Use &U : Inst->uses())
      Uses.push_back(&U);
    continue;
  }

  if (auto *GEP = dyn_cast<GetElementPtrInst>(Inst)) {
33
←
Assuming 'GEP' is null→
34
←
Taking false branch→
    // If we can't compute a vector index from this GEP, then we can't
    // promote this alloca to vector.
    Value *Index = GEPToVectorIndex(GEP, Alloca, VecEltTy, DL);
    if (!Index) {
      LLVM_DEBUG(dbgs() << "  Cannot compute vector index for GEP " << *GEPdo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("amdgpu-promote-alloca")) { dbgs() << "  Cannot compute vector index for GEP "
 << *GEP << '\n'; } } while (false)
                        << '\n')do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("amdgpu-promote-alloca")) { dbgs() << "  Cannot compute vector index for GEP "
 << *GEP << '\n'; } } while (false);
      return false;
    }

    GEPVectorIdx[GEP] = Index;
    for (Use &U : Inst->uses())
      Uses.push_back(&U);
    continue;
  }

  // Ignore assume-like intrinsics and comparisons used in assumes.
  if (isAssumeLikeIntrinsic(Inst))
35
←
Assuming the condition is false→
    continue;

  if (isa<ICmpInst>(Inst) && all_of(Inst->users(), [](User *U) {
36
←
Assuming 'Inst' is a 'class llvm::ICmpInst &'→
37
←
Called C++ object pointer is null
        return isAssumeLikeIntrinsic(cast<Instruction>(U));
      }))
    continue;

  // Unknown user.
  return false;
}

LLVM_DEBUG(dbgs() << "  Converting alloca to vector " << *AllocaTy << " -> "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("amdgpu-promote-alloca")) { dbgs() << "  Converting alloca to vector "
 << *AllocaTy << " -> " << *VectorTy <<
 '\n'; } } while (false)
                  << *VectorTy << '\n')do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("amdgpu-promote-alloca")) { dbgs() << "  Converting alloca to vector "
 << *AllocaTy << " -> " << *VectorTy <<
 '\n'; } } while (false);

for (Instruction *Inst : WorkList) {
  IRBuilder<> Builder(Inst);
  switch (Inst->getOpcode()) {
  case Instruction::Load: {
    Value *Ptr = cast<LoadInst>(Inst)->getPointerOperand();
    Value *Index = calculateVectorIndex(Ptr, GEPVectorIdx);
    Type *VecPtrTy = VectorTy->getPointerTo(Alloca->getAddressSpace());
    Value *BitCast = Builder.CreateBitCast(Alloca, VecPtrTy);
    Value *VecValue = Builder.CreateLoad(VectorTy, BitCast);
    Value *ExtractElement = Builder.CreateExtractElement(VecValue, Index);
    if (Inst->getType() != VecEltTy)
      ExtractElement = Builder.CreateBitOrPointerCast(ExtractElement, Inst->getType());
    Inst->replaceAllUsesWith(ExtractElement);
    Inst->eraseFromParent();
    break;
  }
  case Instruction::Store: {
    StoreInst *SI = cast<StoreInst>(Inst);
    Value *Ptr = SI->getPointerOperand();
    Value *Index = calculateVectorIndex(Ptr, GEPVectorIdx);
    Type *VecPtrTy = VectorTy->getPointerTo(Alloca->getAddressSpace());
    Value *BitCast = Builder.CreateBitCast(Alloca, VecPtrTy);
    Value *VecValue = Builder.CreateLoad(VectorTy, BitCast);
    Value *Elt = SI->getValueOperand();
    if (Elt->getType() != VecEltTy)
      Elt = Builder.CreateBitOrPointerCast(Elt, VecEltTy);
    Value *NewVecValue = Builder.CreateInsertElement(VecValue, Elt, Index);
    Builder.CreateStore(NewVecValue, BitCast);
    Inst->eraseFromParent();
    break;
  }

  default:
    llvm_unreachable("Inconsistency in instructions promotable to vector")::llvm::llvm_unreachable_internal("Inconsistency in instructions promotable to vector"
, "llvm/lib/Target/AMDGPU/AMDGPUPromoteAlloca.cpp", 528);
  }
}
return true;
532}

534static bool isCallPromotable(CallInst *CI) {
IntrinsicInst *II = dyn_cast<IntrinsicInst>(CI);
if (!II)
  return false;

switch (II->getIntrinsicID()) {
case Intrinsic::memcpy:
case Intrinsic::memmove:
case Intrinsic::memset:
case Intrinsic::lifetime_start:
case Intrinsic::lifetime_end:
case Intrinsic::invariant_start:
case Intrinsic::invariant_end:
case Intrinsic::launder_invariant_group:
case Intrinsic::strip_invariant_group:
case Intrinsic::objectsize:
  return true;
default:
  return false;
}
554}

556bool AMDGPUPromoteAllocaImpl::binaryOpIsDerivedFromSameAlloca(
  Value *BaseAlloca, Value *Val, Instruction *Inst, int OpIdx0,
  int OpIdx1) const {
// Figure out which operand is the one we might not be promoting.
Value *OtherOp = Inst->getOperand(OpIdx0);
if (Val == OtherOp)
  OtherOp = Inst->getOperand(OpIdx1);

if (isa<ConstantPointerNull>(OtherOp))
  return true;

Value *OtherObj = getUnderlyingObject(OtherOp);
if (!isa<AllocaInst>(OtherObj))
  return false;

// TODO: We should be able to replace undefs with the right pointer type.

// TODO: If we know the other base object is another promotable
// alloca, not necessarily this alloca, we can do this. The
// important part is both must have the same address space at
// the end.
if (OtherObj != BaseAlloca) {
  LLVM_DEBUG(do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("amdgpu-promote-alloca")) { dbgs() << "Found a binary instruction with another alloca object\n"
; } } while (false)
      dbgs() << "Found a binary instruction with another alloca object\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("amdgpu-promote-alloca")) { dbgs() << "Found a binary instruction with another alloca object\n"
; } } while (false);
  return false;
}

return true;
584}

586bool AMDGPUPromoteAllocaImpl::collectUsesWithPtrTypes(
  Value *BaseAlloca, Value *Val, std::vector<Value *> &WorkList) const {

for (User *User : Val->users()) {
  if (is_contained(WorkList, User))
    continue;

  if (CallInst *CI = dyn_cast<CallInst>(User)) {
    if (!isCallPromotable(CI))
      return false;

    WorkList.push_back(User);
    continue;
  }

  Instruction *UseInst = cast<Instruction>(User);
  if (UseInst->getOpcode() == Instruction::PtrToInt)
    return false;

  if (LoadInst *LI = dyn_cast<LoadInst>(UseInst)) {
    if (LI->isVolatile())
      return false;

    continue;
  }

  if (StoreInst *SI = dyn_cast<StoreInst>(UseInst)) {
    if (SI->isVolatile())
      return false;

    // Reject if the stored value is not the pointer operand.
    if (SI->getPointerOperand() != Val)
      return false;
  } else if (AtomicRMWInst *RMW = dyn_cast<AtomicRMWInst>(UseInst)) {
    if (RMW->isVolatile())
      return false;
  } else if (AtomicCmpXchgInst *CAS = dyn_cast<AtomicCmpXchgInst>(UseInst)) {
    if (CAS->isVolatile())
      return false;
  }

  // Only promote a select if we know that the other select operand
  // is from another pointer that will also be promoted.
  if (ICmpInst *ICmp = dyn_cast<ICmpInst>(UseInst)) {
    if (!binaryOpIsDerivedFromSameAlloca(BaseAlloca, Val, ICmp, 0, 1))
      return false;

    // May need to rewrite constant operands.
    WorkList.push_back(ICmp);
  }

  if (UseInst->getOpcode() == Instruction::AddrSpaceCast) {
    // Give up if the pointer may be captured.
    if (PointerMayBeCaptured(UseInst, true, true))
      return false;
    // Don't collect the users of this.
    WorkList.push_back(User);
    continue;
  }

  // Do not promote vector/aggregate type instructions. It is hard to track
  // their users.
  if (isa<InsertValueInst>(User) || isa<InsertElementInst>(User))
    return false;

  if (!User->getType()->isPointerTy())
    continue;

  if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(UseInst)) {
    // Be conservative if an address could be computed outside the bounds of
    // the alloca.
    if (!GEP->isInBounds())
      return false;
  }

  // Only promote a select if we know that the other select operand is from
  // another pointer that will also be promoted.
  if (SelectInst *SI = dyn_cast<SelectInst>(UseInst)) {
    if (!binaryOpIsDerivedFromSameAlloca(BaseAlloca, Val, SI, 1, 2))
      return false;
  }

  // Repeat for phis.
  if (PHINode *Phi = dyn_cast<PHINode>(UseInst)) {
    // TODO: Handle more complex cases. We should be able to replace loops
    // over arrays.
    switch (Phi->getNumIncomingValues()) {
    case 1:
      break;
    case 2:
      if (!binaryOpIsDerivedFromSameAlloca(BaseAlloca, Val, Phi, 0, 1))
        return false;
      break;
    default:
      return false;
    }
  }

  WorkList.push_back(User);
  if (!collectUsesWithPtrTypes(BaseAlloca, User, WorkList))
    return false;
}

return true;
690}

692bool AMDGPUPromoteAllocaImpl::hasSufficientLocalMem(const Function &F) {

FunctionType *FTy = F.getFunctionType();
const AMDGPUSubtarget &ST = AMDGPUSubtarget::get(TM, F);

// If the function has any arguments in the local address space, then it's
// possible these arguments require the entire local memory space, so
// we cannot use local memory in the pass.
for (Type *ParamTy : FTy->params()) {
  PointerType *PtrTy = dyn_cast<PointerType>(ParamTy);
  if (PtrTy && PtrTy->getAddressSpace() == AMDGPUAS::LOCAL_ADDRESS) {
    LocalMemLimit = 0;
    LLVM_DEBUG(dbgs() << "Function has local memory argument. Promoting to "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("amdgpu-promote-alloca")) { dbgs() << "Function has local memory argument. Promoting to "
 "local memory disabled.\n"; } } while (false)
                         "local memory disabled.\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("amdgpu-promote-alloca")) { dbgs() << "Function has local memory argument. Promoting to "
 "local memory disabled.\n"; } } while (false);
    return false;
  }
}

LocalMemLimit = ST.getLocalMemorySize();
if (LocalMemLimit == 0)
  return false;

SmallVector<const Constant *, 16> Stack;
SmallPtrSet<const Constant *, 8> VisitedConstants;
SmallPtrSet<const GlobalVariable *, 8> UsedLDS;

auto visitUsers = [&](const GlobalVariable *GV, const Constant *Val) -> bool {
  for (const User *U : Val->users()) {
    if (const Instruction *Use = dyn_cast<Instruction>(U)) {
      if (Use->getParent()->getParent() == &F)
        return true;
    } else {
      const Constant *C = cast<Constant>(U);
      if (VisitedConstants.insert(C).second)
        Stack.push_back(C);
    }
  }

  return false;
};

for (GlobalVariable &GV : Mod->globals()) {
  if (GV.getAddressSpace() != AMDGPUAS::LOCAL_ADDRESS)
    continue;

  if (visitUsers(&GV, &GV)) {
    UsedLDS.insert(&GV);
    Stack.clear();
    continue;
  }

  // For any ConstantExpr uses, we need to recursively search the users until
  // we see a function.
  while (!Stack.empty()) {
    const Constant *C = Stack.pop_back_val();
    if (visitUsers(&GV, C)) {
      UsedLDS.insert(&GV);
      Stack.clear();
      break;
    }
  }
}

const DataLayout &DL = Mod->getDataLayout();
SmallVector<std::pair<uint64_t, Align>, 16> AllocatedSizes;
AllocatedSizes.reserve(UsedLDS.size());

for (const GlobalVariable *GV : UsedLDS) {
  Align Alignment =
      DL.getValueOrABITypeAlignment(GV->getAlign(), GV->getValueType());
  uint64_t AllocSize = DL.getTypeAllocSize(GV->getValueType());

  // HIP uses an extern unsized array in local address space for dynamically
  // allocated shared memory.  In that case, we have to disable the promotion.
  if (GV->hasExternalLinkage() && AllocSize == 0) {
    LocalMemLimit = 0;
    LLVM_DEBUG(dbgs() << "Function has a reference to externally allocated "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("amdgpu-promote-alloca")) { dbgs() << "Function has a reference to externally allocated "
 "local memory. Promoting to local memory " "disabled.\n"; } }
 while (false)
                         "local memory. Promoting to local memory "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("amdgpu-promote-alloca")) { dbgs() << "Function has a reference to externally allocated "
 "local memory. Promoting to local memory " "disabled.\n"; } }
 while (false)
                         "disabled.\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("amdgpu-promote-alloca")) { dbgs() << "Function has a reference to externally allocated "
 "local memory. Promoting to local memory " "disabled.\n"; } }
 while (false);
    return false;
  }

  AllocatedSizes.emplace_back(AllocSize, Alignment);
}

// Sort to try to estimate the worst case alignment padding
//
// FIXME: We should really do something to fix the addresses to a more optimal
// value instead
llvm::sort(AllocatedSizes, llvm::less_second());

// Check how much local memory is being used by global objects
CurrentLocalMemUsage = 0;

// FIXME: Try to account for padding here. The real padding and address is
// currently determined from the inverse order of uses in the function when
// legalizing, which could also potentially change. We try to estimate the
// worst case here, but we probably should fix the addresses earlier.
for (auto Alloc : AllocatedSizes) {
  CurrentLocalMemUsage = alignTo(CurrentLocalMemUsage, Alloc.second);
  CurrentLocalMemUsage += Alloc.first;
}

unsigned MaxOccupancy = ST.getOccupancyWithLocalMemSize(CurrentLocalMemUsage,
                                                        F);

// Restrict local memory usage so that we don't drastically reduce occupancy,
// unless it is already significantly reduced.

// TODO: Have some sort of hint or other heuristics to guess occupancy based
// on other factors..
unsigned OccupancyHint = ST.getWavesPerEU(F).second;
if (OccupancyHint == 0)
  OccupancyHint = 7;

// Clamp to max value.
OccupancyHint = std::min(OccupancyHint, ST.getMaxWavesPerEU());

// Check the hint but ignore it if it's obviously wrong from the existing LDS
// usage.
MaxOccupancy = std::min(OccupancyHint, MaxOccupancy);


// Round up to the next tier of usage.
unsigned MaxSizeWithWaveCount
  = ST.getMaxLocalMemSizeWithWaveCount(MaxOccupancy, F);

// Program is possibly broken by using more local mem than available.
if (CurrentLocalMemUsage > MaxSizeWithWaveCount)
  return false;

LocalMemLimit = MaxSizeWithWaveCount;

LLVM_DEBUG(dbgs() << F.getName() << " uses " << CurrentLocalMemUsagedo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("amdgpu-promote-alloca")) { dbgs() << F.getName() <<
 " uses " << CurrentLocalMemUsage << " bytes of LDS\n"
 << "  Rounding size to " << MaxSizeWithWaveCount
 << " with a maximum occupancy of " << MaxOccupancy
 << '\n' << " and " << (LocalMemLimit - CurrentLocalMemUsage
) << " available for promotion\n"; } } while (false)
                  << " bytes of LDS\n"do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("amdgpu-promote-alloca")) { dbgs() << F.getName() <<
 " uses " << CurrentLocalMemUsage << " bytes of LDS\n"
 << "  Rounding size to " << MaxSizeWithWaveCount
 << " with a maximum occupancy of " << MaxOccupancy
 << '\n' << " and " << (LocalMemLimit - CurrentLocalMemUsage
) << " available for promotion\n"; } } while (false)
                  << "  Rounding size to " << MaxSizeWithWaveCountdo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("amdgpu-promote-alloca")) { dbgs() << F.getName() <<
 " uses " << CurrentLocalMemUsage << " bytes of LDS\n"
 << "  Rounding size to " << MaxSizeWithWaveCount
 << " with a maximum occupancy of " << MaxOccupancy
 << '\n' << " and " << (LocalMemLimit - CurrentLocalMemUsage
) << " available for promotion\n"; } } while (false)
                  << " with a maximum occupancy of " << MaxOccupancy << '\n'do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("amdgpu-promote-alloca")) { dbgs() << F.getName() <<
 " uses " << CurrentLocalMemUsage << " bytes of LDS\n"
 << "  Rounding size to " << MaxSizeWithWaveCount
 << " with a maximum occupancy of " << MaxOccupancy
 << '\n' << " and " << (LocalMemLimit - CurrentLocalMemUsage
) << " available for promotion\n"; } } while (false)
                  << " and " << (LocalMemLimit - CurrentLocalMemUsage)do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("amdgpu-promote-alloca")) { dbgs() << F.getName() <<
 " uses " << CurrentLocalMemUsage << " bytes of LDS\n"
 << "  Rounding size to " << MaxSizeWithWaveCount
 << " with a maximum occupancy of " << MaxOccupancy
 << '\n' << " and " << (LocalMemLimit - CurrentLocalMemUsage
) << " available for promotion\n"; } } while (false)
                  << " available for promotion\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("amdgpu-promote-alloca")) { dbgs() << F.getName() <<
 " uses " << CurrentLocalMemUsage << " bytes of LDS\n"
 << "  Rounding size to " << MaxSizeWithWaveCount
 << " with a maximum occupancy of " << MaxOccupancy
 << '\n' << " and " << (LocalMemLimit - CurrentLocalMemUsage
) << " available for promotion\n"; } } while (false);

return true;
833}

835// FIXME: Should try to pick the most likely to be profitable allocas first.
836bool AMDGPUPromoteAllocaImpl::handleAlloca(AllocaInst &I, bool SufficientLDS) {
// Array allocations are probably not worth handling, since an allocation of
// the array type is the canonical form.
if (!I.isStaticAlloca() || I.isArrayAllocation())
  return false;

const DataLayout &DL = Mod->getDataLayout();
IRBuilder<> Builder(&I);

// First try to replace the alloca with a vector
Type *AllocaTy = I.getAllocatedType();

LLVM_DEBUG(dbgs() << "Trying to promote " << I << '\n')do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("amdgpu-promote-alloca")) { dbgs() << "Trying to promote "
 << I << '\n'; } } while (false);

if (tryPromoteAllocaToVector(&I, DL, MaxVGPRs))
  return true; // Promoted to vector.

if (DisablePromoteAllocaToLDS)
  return false;

const Function &ContainingFunction = *I.getParent()->getParent();
CallingConv::ID CC = ContainingFunction.getCallingConv();

// Don't promote the alloca to LDS for shader calling conventions as the work
// item ID intrinsics are not supported for these calling conventions.
// Furthermore not all LDS is available for some of the stages.
switch (CC) {
case CallingConv::AMDGPU_KERNEL:
case CallingConv::SPIR_KERNEL:
  break;
default:
  LLVM_DEBUG(do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("amdgpu-promote-alloca")) { dbgs() << " promote alloca to LDS not supported with calling convention.\n"
; } } while (false)
      dbgs()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("amdgpu-promote-alloca")) { dbgs() << " promote alloca to LDS not supported with calling convention.\n"
; } } while (false)
      << " promote alloca to LDS not supported with calling convention.\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("amdgpu-promote-alloca")) { dbgs() << " promote alloca to LDS not supported with calling convention.\n"
; } } while (false);
  return false;
}

// Not likely to have sufficient local memory for promotion.
if (!SufficientLDS)
  return false;

const AMDGPUSubtarget &ST = AMDGPUSubtarget::get(TM, ContainingFunction);
unsigned WorkGroupSize = ST.getFlatWorkGroupSizes(ContainingFunction).second;

Align Alignment =
    DL.getValueOrABITypeAlignment(I.getAlign(), I.getAllocatedType());

// FIXME: This computed padding is likely wrong since it depends on inverse
// usage order.
//
// FIXME: It is also possible that if we're allowed to use all of the memory
// could end up using more than the maximum due to alignment padding.

uint32_t NewSize = alignTo(CurrentLocalMemUsage, Alignment);
uint32_t AllocSize = WorkGroupSize * DL.getTypeAllocSize(AllocaTy);
NewSize += AllocSize;

if (NewSize > LocalMemLimit) {
  LLVM_DEBUG(dbgs() << "  " << AllocSizedo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("amdgpu-promote-alloca")) { dbgs() << "  " << AllocSize
 << " bytes of local memory not available to promote\n"
; } } while (false)
                    << " bytes of local memory not available to promote\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("amdgpu-promote-alloca")) { dbgs() << "  " << AllocSize
 << " bytes of local memory not available to promote\n"
; } } while (false);
  return false;
}

CurrentLocalMemUsage = NewSize;

std::vector<Value*> WorkList;

if (!collectUsesWithPtrTypes(&I, &I, WorkList)) {
  LLVM_DEBUG(dbgs() << " Do not know how to convert all uses\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("amdgpu-promote-alloca")) { dbgs() << " Do not know how to convert all uses\n"
; } } while (false);
  return false;
}

LLVM_DEBUG(dbgs() << "Promoting alloca to local memory\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("amdgpu-promote-alloca")) { dbgs() << "Promoting alloca to local memory\n"
; } } while (false);

Function *F = I.getParent()->getParent();

Type *GVTy = ArrayType::get(I.getAllocatedType(), WorkGroupSize);
GlobalVariable *GV = new GlobalVariable(
    *Mod, GVTy, false, GlobalValue::InternalLinkage, PoisonValue::get(GVTy),
    Twine(F->getName()) + Twine('.') + I.getName(), nullptr,
    GlobalVariable::NotThreadLocal, AMDGPUAS::LOCAL_ADDRESS);
GV->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
GV->setAlignment(I.getAlign());

Value *TCntY, *TCntZ;

std::tie(TCntY, TCntZ) = getLocalSizeYZ(Builder);
Value *TIdX = getWorkitemID(Builder, 0);
Value *TIdY = getWorkitemID(Builder, 1);
Value *TIdZ = getWorkitemID(Builder, 2);

Value *Tmp0 = Builder.CreateMul(TCntY, TCntZ, "", true, true);
Tmp0 = Builder.CreateMul(Tmp0, TIdX);
Value *Tmp1 = Builder.CreateMul(TIdY, TCntZ, "", true, true);
Value *TID = Builder.CreateAdd(Tmp0, Tmp1);
TID = Builder.CreateAdd(TID, TIdZ);

Value *Indices[] = {
  Constant::getNullValue(Type::getInt32Ty(Mod->getContext())),
  TID
};

Value *Offset = Builder.CreateInBoundsGEP(GVTy, GV, Indices);
I.mutateType(Offset->getType());
I.replaceAllUsesWith(Offset);
I.eraseFromParent();

SmallVector<IntrinsicInst *> DeferredIntrs;

for (Value *V : WorkList) {
  CallInst *Call = dyn_cast<CallInst>(V);
  if (!Call) {
    if (ICmpInst *CI = dyn_cast<ICmpInst>(V)) {
      Value *Src0 = CI->getOperand(0);
      PointerType *NewTy = PointerType::getWithSamePointeeType(
          cast<PointerType>(Src0->getType()), AMDGPUAS::LOCAL_ADDRESS);

      if (isa<ConstantPointerNull>(CI->getOperand(0)))
        CI->setOperand(0, ConstantPointerNull::get(NewTy));

      if (isa<ConstantPointerNull>(CI->getOperand(1)))
        CI->setOperand(1, ConstantPointerNull::get(NewTy));

      continue;
    }

    // The operand's value should be corrected on its own and we don't want to
    // touch the users.
    if (isa<AddrSpaceCastInst>(V))
      continue;

    PointerType *NewTy = PointerType::getWithSamePointeeType(
        cast<PointerType>(V->getType()), AMDGPUAS::LOCAL_ADDRESS);

    // FIXME: It doesn't really make sense to try to do this for all
    // instructions.
    V->mutateType(NewTy);

    // Adjust the types of any constant operands.
    if (SelectInst *SI = dyn_cast<SelectInst>(V)) {
      if (isa<ConstantPointerNull>(SI->getOperand(1)))
        SI->setOperand(1, ConstantPointerNull::get(NewTy));

      if (isa<ConstantPointerNull>(SI->getOperand(2)))
        SI->setOperand(2, ConstantPointerNull::get(NewTy));
    } else if (PHINode *Phi = dyn_cast<PHINode>(V)) {
      for (unsigned I = 0, E = Phi->getNumIncomingValues(); I != E; ++I) {
        if (isa<ConstantPointerNull>(Phi->getIncomingValue(I)))
          Phi->setIncomingValue(I, ConstantPointerNull::get(NewTy));
      }
    }

    continue;
  }

  IntrinsicInst *Intr = cast<IntrinsicInst>(Call);
  Builder.SetInsertPoint(Intr);
  switch (Intr->getIntrinsicID()) {
  case Intrinsic::lifetime_start:
  case Intrinsic::lifetime_end:
    // These intrinsics are for address space 0 only
    Intr->eraseFromParent();
    continue;
  case Intrinsic::memcpy:
  case Intrinsic::memmove:
    // These have 2 pointer operands. In case if second pointer also needs
    // to be replaced we defer processing of these intrinsics until all
    // other values are processed.
    DeferredIntrs.push_back(Intr);
    continue;
  case Intrinsic::memset: {
    MemSetInst *MemSet = cast<MemSetInst>(Intr);
    Builder.CreateMemSet(
        MemSet->getRawDest(), MemSet->getValue(), MemSet->getLength(),
        MaybeAlign(MemSet->getDestAlignment()), MemSet->isVolatile());
    Intr->eraseFromParent();
    continue;
  }
  case Intrinsic::invariant_start:
  case Intrinsic::invariant_end:
  case Intrinsic::launder_invariant_group:
  case Intrinsic::strip_invariant_group:
    Intr->eraseFromParent();
    // FIXME: I think the invariant marker should still theoretically apply,
    // but the intrinsics need to be changed to accept pointers with any
    // address space.
    continue;
  case Intrinsic::objectsize: {
    Value *Src = Intr->getOperand(0);
    Function *ObjectSize = Intrinsic::getDeclaration(
        Mod, Intrinsic::objectsize,
        {Intr->getType(),
         PointerType::getWithSamePointeeType(
             cast<PointerType>(Src->getType()), AMDGPUAS::LOCAL_ADDRESS)});

    CallInst *NewCall = Builder.CreateCall(
        ObjectSize,
        {Src, Intr->getOperand(1), Intr->getOperand(2), Intr->getOperand(3)});
    Intr->replaceAllUsesWith(NewCall);
    Intr->eraseFromParent();
    continue;
  }
  default:
    Intr->print(errs());
    llvm_unreachable("Don't know how to promote alloca intrinsic use.")::llvm::llvm_unreachable_internal("Don't know how to promote alloca intrinsic use."
, "llvm/lib/Target/AMDGPU/AMDGPUPromoteAlloca.cpp", 1040);
  }
}

for (IntrinsicInst *Intr : DeferredIntrs) {
  Builder.SetInsertPoint(Intr);
  Intrinsic::ID ID = Intr->getIntrinsicID();
  assert(ID == Intrinsic::memcpy || ID == Intrinsic::memmove)(static_cast <bool> (ID == Intrinsic::memcpy || ID == Intrinsic
::memmove) ? void (0) : __assert_fail ("ID == Intrinsic::memcpy || ID == Intrinsic::memmove"
, "llvm/lib/Target/AMDGPU/AMDGPUPromoteAlloca.cpp", 1047, __extension__
 __PRETTY_FUNCTION__));

  MemTransferInst *MI = cast<MemTransferInst>(Intr);
  auto *B =
    Builder.CreateMemTransferInst(ID, MI->getRawDest(), MI->getDestAlign(),
                                  MI->getRawSource(), MI->getSourceAlign(),
                                  MI->getLength(), MI->isVolatile());

  for (unsigned I = 0; I != 2; ++I) {
    if (uint64_t Bytes = Intr->getParamDereferenceableBytes(I)) {
      B->addDereferenceableParamAttr(I, Bytes);
    }
  }

  Intr->eraseFromParent();
}

return true;
1065}

1067bool handlePromoteAllocaToVector(AllocaInst &I, unsigned MaxVGPRs) {
// Array allocations are probably not worth handling, since an allocation of
// the array type is the canonical form.
if (!I.isStaticAlloca() || I.isArrayAllocation())
  return false;

LLVM_DEBUG(dbgs() << "Trying to promote " << I << '\n')do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("amdgpu-promote-alloca")) { dbgs() << "Trying to promote "
 << I << '\n'; } } while (false);

Module *Mod = I.getParent()->getParent()->getParent();
return tryPromoteAllocaToVector(&I, Mod->getDataLayout(), MaxVGPRs);
1077}

1079bool promoteAllocasToVector(Function &F, TargetMachine &TM) {
if (DisablePromoteAllocaToVector)
  return false;

const AMDGPUSubtarget &ST = AMDGPUSubtarget::get(TM, F);
if (!ST.isPromoteAllocaEnabled())
  return false;

unsigned MaxVGPRs;
if (TM.getTargetTriple().getArch() == Triple::amdgcn) {
  const GCNSubtarget &ST = TM.getSubtarget<GCNSubtarget>(F);
  MaxVGPRs = ST.getMaxNumVGPRs(ST.getWavesPerEU(F).first);
  // A non-entry function has only 32 caller preserved registers.
  // Do not promote alloca which will force spilling.
  if (!AMDGPU::isEntryFunctionCC(F.getCallingConv()))
    MaxVGPRs = std::min(MaxVGPRs, 32u);
} else {
  MaxVGPRs = 128;
}

bool Changed = false;
BasicBlock &EntryBB = *F.begin();

SmallVector<AllocaInst *, 16> Allocas;
for (Instruction &I : EntryBB) {
  if (AllocaInst *AI = dyn_cast<AllocaInst>(&I))
    Allocas.push_back(AI);
}

for (AllocaInst *AI : Allocas) {
  if (handlePromoteAllocaToVector(*AI, MaxVGPRs))
    Changed = true;
}

return Changed;
1114}

1116bool AMDGPUPromoteAllocaToVector::runOnFunction(Function &F) {
if (skipFunction(F))
  return false;
if (auto *TPC = getAnalysisIfAvailable<TargetPassConfig>()) {
  return promoteAllocasToVector(F, TPC->getTM<TargetMachine>());
}
return false;
1123}

1125PreservedAnalyses
1126AMDGPUPromoteAllocaToVectorPass::run(Function &F, FunctionAnalysisManager &AM) {
bool Changed = promoteAllocasToVector(F, TM);
if (Changed) {
  PreservedAnalyses PA;
  PA.preserveSet<CFGAnalyses>();
  return PA;
}
return PreservedAnalyses::all();
1134}

1136FunctionPass *llvm::createAMDGPUPromoteAlloca() {
return new AMDGPUPromoteAlloca();
1138}

1140FunctionPass *llvm::createAMDGPUPromoteAllocaToVector() {
return new AMDGPUPromoteAllocaToVector();
1142}

←

/build/source/llvm/include/llvm/IR/Instructions.h

1//===- llvm/Instructions.h - Instruction subclass definitions ---*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file exposes the class definitions of all of the subclasses of the
10// Instruction class.  This is meant to be an easy way to get access to all
11// instruction subclasses.
12//
13//===----------------------------------------------------------------------===//

15#ifndef LLVM_IR_INSTRUCTIONS_H
16#define LLVM_IR_INSTRUCTIONS_H

18#include "llvm/ADT/ArrayRef.h"
19#include "llvm/ADT/Bitfields.h"
20#include "llvm/ADT/MapVector.h"
21#include "llvm/ADT/STLExtras.h"
22#include "llvm/ADT/SmallVector.h"
23#include "llvm/ADT/Twine.h"
24#include "llvm/ADT/iterator.h"
25#include "llvm/ADT/iterator_range.h"
26#include "llvm/IR/CFG.h"
27#include "llvm/IR/Constant.h"
28#include "llvm/IR/DerivedTypes.h"
29#include "llvm/IR/InstrTypes.h"
30#include "llvm/IR/Instruction.h"
31#include "llvm/IR/OperandTraits.h"
32#include "llvm/IR/Use.h"
33#include "llvm/IR/User.h"
34#include "llvm/Support/AtomicOrdering.h"
35#include "llvm/Support/ErrorHandling.h"
36#include <cassert>
37#include <cstddef>
38#include <cstdint>
39#include <iterator>
40#include <optional>

42namespace llvm {

44class APFloat;
45class APInt;
46class BasicBlock;
47class ConstantInt;
48class DataLayout;
49class StringRef;
50class Type;
51class Value;

53//===----------------------------------------------------------------------===//
54//                                AllocaInst Class
55//===----------------------------------------------------------------------===//

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

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

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

AllocaInst *cloneImpl() const;

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

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

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

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

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

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

/// Return the address space for the allocation.
unsigned getAddressSpace() const {
  return getType()->getAddressSpace();
}

/// Get allocation size in bits. Returns std::nullopt if size can't be
/// determined, e.g. in case of a VLA.
std::optional<TypeSize> getAllocationSizeInBits(const DataLayout &DL) const;

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

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

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

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

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

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

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

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

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

167//===----------------------------------------------------------------------===//
168//                                LoadInst Class
169//===----------------------------------------------------------------------===//

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

void AssertOK();

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

LoadInst *cloneImpl() const;

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

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

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

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

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

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

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

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

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

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

bool isUnordered() const {
  return (getOrdering() == AtomicOrdering::NotAtomic ||
          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));
}

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

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

292//===----------------------------------------------------------------------===//
293//                                StoreInst Class
294//===----------------------------------------------------------------------===//

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

void AssertOK();

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

StoreInst *cloneImpl() const;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

421template <>
422struct OperandTraits<StoreInst> : public FixedNumOperandTraits<StoreInst, 2> {
423};

425DEFINE_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!\""
, "llvm/include/llvm/IR/Instructions.h", 425, __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!\""
, "llvm/include/llvm/IR/Instructions.h", 425, __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); }

427//===----------------------------------------------------------------------===//
428//                                FenceInst Class
429//===----------------------------------------------------------------------===//

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

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

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

FenceInst *cloneImpl() const;

443public:
// 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); }
void operator delete(void *Ptr) { User::operator delete(Ptr); }

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

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

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

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

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

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

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

499//===----------------------------------------------------------------------===//
500//                                AtomicCmpXchgInst Class
501//===----------------------------------------------------------------------===//

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

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

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

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

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

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

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

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

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

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

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

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

static bool isValidSuccessOrdering(AtomicOrdering Ordering) {
  return Ordering != AtomicOrdering::NotAtomic &&
         Ordering != AtomicOrdering::Unordered;
}

static bool isValidFailureOrdering(AtomicOrdering Ordering) {
  return Ordering != AtomicOrdering::NotAtomic &&
         Ordering != AtomicOrdering::Unordered &&
         Ordering != AtomicOrdering::AcquireRelease &&
         Ordering != AtomicOrdering::Release;
}

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

/// Sets the success ordering constraint of this cmpxchg instruction.
void setSuccessOrdering(AtomicOrdering Ordering) {
  assert(isValidSuccessOrdering(Ordering) &&(static_cast <bool> (isValidSuccessOrdering(Ordering) &&
 "invalid CmpXchg success ordering") ? void (0) : __assert_fail
 ("isValidSuccessOrdering(Ordering) && \"invalid CmpXchg success ordering\""
, "llvm/include/llvm/IR/Instructions.h", 599, __extension__ __PRETTY_FUNCTION__
))
         "invalid CmpXchg success ordering")(static_cast <bool> (isValidSuccessOrdering(Ordering) &&
 "invalid CmpXchg success ordering") ? void (0) : __assert_fail
 ("isValidSuccessOrdering(Ordering) && \"invalid CmpXchg success ordering\""
, "llvm/include/llvm/IR/Instructions.h", 599, __extension__ __PRETTY_FUNCTION__
));
  setSubclassData<SuccessOrderingField>(Ordering);
}

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

/// Sets the failure ordering constraint of this cmpxchg instruction.
void setFailureOrdering(AtomicOrdering Ordering) {
  assert(isValidFailureOrdering(Ordering) &&(static_cast <bool> (isValidFailureOrdering(Ordering) &&
 "invalid CmpXchg failure ordering") ? void (0) : __assert_fail
 ("isValidFailureOrdering(Ordering) && \"invalid CmpXchg failure ordering\""
, "llvm/include/llvm/IR/Instructions.h", 611, __extension__ __PRETTY_FUNCTION__
))
         "invalid CmpXchg failure ordering")(static_cast <bool> (isValidFailureOrdering(Ordering) &&
 "invalid CmpXchg failure ordering") ? void (0) : __assert_fail
 ("isValidFailureOrdering(Ordering) && \"invalid CmpXchg failure ordering\""
, "llvm/include/llvm/IR/Instructions.h", 611, __extension__ __PRETTY_FUNCTION__
));
  setSubclassData<FailureOrderingField>(Ordering);
}

/// Returns a single ordering which is at least as strong as both the
/// success and failure orderings for this cmpxchg.
AtomicOrdering getMergedOrdering() const {
  if (getFailureOrdering() == AtomicOrdering::SequentiallyConsistent)
    return AtomicOrdering::SequentiallyConsistent;
  if (getFailureOrdering() == AtomicOrdering::Acquire) {
    if (getSuccessOrdering() == AtomicOrdering::Monotonic)
      return AtomicOrdering::Acquire;
    if (getSuccessOrdering() == AtomicOrdering::Release)
      return AtomicOrdering::AcquireRelease;
  }
  return getSuccessOrdering();
}

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

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

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

699template <>
700struct OperandTraits<AtomicCmpXchgInst> :
  public FixedNumOperandTraits<AtomicCmpXchgInst, 3> {
702};

704DEFINE_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!\""
, "llvm/include/llvm/IR/Instructions.h", 704, __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!\""
, "llvm/include/llvm/IR/Instructions.h", 704, __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
); }

706//===----------------------------------------------------------------------===//
707//                                AtomicRMWInst Class
708//===----------------------------------------------------------------------===//

710/// an instruction that atomically reads a memory location,
711/// combines it with another value, and then stores the result back.  Returns
712/// the old value.
713///
714class AtomicRMWInst : public Instruction {
715protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

AtomicRMWInst *cloneImpl() const;

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

  /// *p = old + v
  FAdd,

  /// *p = old - v
  FSub,

  /// *p = maxnum(old, v)
  /// \p maxnum matches the behavior of \p llvm.maxnum.*.
  FMax,

  /// *p = minnum(old, v)
  /// \p minnum matches the behavior of \p llvm.minnum.*.
  FMin,

  FIRST_BINOP = Xchg,
  LAST_BINOP = FMin,
  BAD_BINOP
};

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

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

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

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

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

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

static StringRef getOperationName(BinOp Op);

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

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

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

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

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

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

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

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

/// Sets the ordering constraint of this rmw instruction.
void setOrdering(AtomicOrdering Ordering) {
  assert(Ordering != AtomicOrdering::NotAtomic &&(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.\""
, "llvm/include/llvm/IR/Instructions.h", 849, __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.\""
, "llvm/include/llvm/IR/Instructions.h", 849, __extension__ __PRETTY_FUNCTION__
));
  assert(Ordering != AtomicOrdering::Unordered &&(static_cast <bool> (Ordering != AtomicOrdering::Unordered
 && "atomicrmw instructions cannot be unordered.") ? void
 (0) : __assert_fail ("Ordering != AtomicOrdering::Unordered && \"atomicrmw instructions cannot be unordered.\""
, "llvm/include/llvm/IR/Instructions.h", 851, __extension__ __PRETTY_FUNCTION__
))
         "atomicrmw instructions cannot be unordered.")(static_cast <bool> (Ordering != AtomicOrdering::Unordered
 && "atomicrmw instructions cannot be unordered.") ? void
 (0) : __assert_fail ("Ordering != AtomicOrdering::Unordered && \"atomicrmw instructions cannot be unordered.\""
, "llvm/include/llvm/IR/Instructions.h", 851, __extension__ __PRETTY_FUNCTION__
));
  setSubclassData<AtomicOrderingField>(Ordering);
}

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

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

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

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

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

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

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

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

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

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

906template <>
907struct OperandTraits<AtomicRMWInst>
  : public FixedNumOperandTraits<AtomicRMWInst,2> {
909};

911DEFINE_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!\""
, "llvm/include/llvm/IR/Instructions.h", 911, __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!\""
, "llvm/include/llvm/IR/Instructions.h", 911, __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
); }

913//===----------------------------------------------------------------------===//
914//                             GetElementPtrInst Class
915//===----------------------------------------------------------------------===//

917// checkGEPType - Simple wrapper function to give a better assertion failure
918// message on bad indexes for a gep instruction.
919//
920inline 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!\""
, "llvm/include/llvm/IR/Instructions.h", 921, __extension__ __PRETTY_FUNCTION__
));
return Ty;
923}

925/// an instruction for type-safe pointer arithmetic to
926/// access elements of arrays and structs
927///
928class 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);

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

GetElementPtrInst *cloneImpl() const;

953public:
static GetElementPtrInst *Create(Type *PointeeType, Value *Ptr,
                                 ArrayRef<Value *> IdxList,
                                 const Twine &NameStr = "",
                                 Instruction *InsertBefore = nullptr) {
  unsigned Values = 1 + unsigned(IdxList.size());
  assert(PointeeType && "Must specify element type")(static_cast <bool> (PointeeType && "Must specify element type"
) ? void (0) : __assert_fail ("PointeeType && \"Must specify element type\""
, "llvm/include/llvm/IR/Instructions.h", 959, __extension__ __PRETTY_FUNCTION__
));
  assert(cast<PointerType>(Ptr->getType()->getScalarType())(static_cast <bool> (cast<PointerType>(Ptr->getType
()->getScalarType()) ->isOpaqueOrPointeeTypeMatches(PointeeType
)) ? void (0) : __assert_fail ("cast<PointerType>(Ptr->getType()->getScalarType()) ->isOpaqueOrPointeeTypeMatches(PointeeType)"
, "llvm/include/llvm/IR/Instructions.h", 961, __extension__ __PRETTY_FUNCTION__
))
             ->isOpaqueOrPointeeTypeMatches(PointeeType))(static_cast <bool> (cast<PointerType>(Ptr->getType
()->getScalarType()) ->isOpaqueOrPointeeTypeMatches(PointeeType
)) ? void (0) : __assert_fail ("cast<PointerType>(Ptr->getType()->getScalarType()) ->isOpaqueOrPointeeTypeMatches(PointeeType)"
, "llvm/include/llvm/IR/Instructions.h", 961, __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());
  assert(PointeeType && "Must specify element type")(static_cast <bool> (PointeeType && "Must specify element type"
) ? void (0) : __assert_fail ("PointeeType && \"Must specify element type\""
, "llvm/include/llvm/IR/Instructions.h", 971, __extension__ __PRETTY_FUNCTION__
));
  assert(cast<PointerType>(Ptr->getType()->getScalarType())(static_cast <bool> (cast<PointerType>(Ptr->getType
()->getScalarType()) ->isOpaqueOrPointeeTypeMatches(PointeeType
)) ? void (0) : __assert_fail ("cast<PointerType>(Ptr->getType()->getScalarType()) ->isOpaqueOrPointeeTypeMatches(PointeeType)"
, "llvm/include/llvm/IR/Instructions.h", 973, __extension__ __PRETTY_FUNCTION__
))
             ->isOpaqueOrPointeeTypeMatches(PointeeType))(static_cast <bool> (cast<PointerType>(Ptr->getType
()->getScalarType()) ->isOpaqueOrPointeeTypeMatches(PointeeType
)) ? void (0) : __assert_fail ("cast<PointerType>(Ptr->getType()->getScalarType()) ->isOpaqueOrPointeeTypeMatches(PointeeType)"
, "llvm/include/llvm/IR/Instructions.h", 973, __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(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(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(cast<PointerType>(getType()->getScalarType())(static_cast <bool> (cast<PointerType>(getType()->
getScalarType()) ->isOpaqueOrPointeeTypeMatches(ResultElementType
)) ? void (0) : __assert_fail ("cast<PointerType>(getType()->getScalarType()) ->isOpaqueOrPointeeTypeMatches(ResultElementType)"
, "llvm/include/llvm/IR/Instructions.h", 1010, __extension__ __PRETTY_FUNCTION__
))
             ->isOpaqueOrPointeeTypeMatches(ResultElementType))(static_cast <bool> (cast<PointerType>(getType()->
getScalarType()) ->isOpaqueOrPointeeTypeMatches(ResultElementType
)) ? void (0) : __assert_fail ("cast<PointerType>(getType()->getScalarType()) ->isOpaqueOrPointeeTypeMatches(ResultElementType)"
, "llvm/include/llvm/IR/Instructions.h", 1010, __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 result type of a getelementptr with the given source
/// element type and indexes.
///
/// Null is returned if the indices are invalid for the specified
/// source element type.
static Type *getIndexedType(Type *Ty, ArrayRef<Value *> IdxList);
static Type *getIndexedType(Type *Ty, ArrayRef<Constant *> IdxList);
static Type *getIndexedType(Type *Ty, ArrayRef<uint64_t> IdxList);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/// Accumulate the constant address offset of this GEP if possible.
///
/// This routine accepts an APInt into which it will accumulate the constant
/// offset of this GEP if the GEP is in fact constant. If the GEP is not
/// all-constant, it returns false and the value of the offset APInt is
/// undefined (it is *not* preserved!). The APInt passed into this routine
/// must be at least as wide as the IntPtr type for the address space of
/// the base GEP pointer.
bool accumulateConstantOffset(const DataLayout &DL, APInt &Offset) const;
bool collectOffset(const DataLayout &DL, unsigned BitWidth,
                   MapVector<Value *, APInt> &VariableOffsets,
                   APInt &ConstantOffset) 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));
}
1140};

1142template <>
1143struct OperandTraits<GetElementPtrInst> :
public VariadicOperandTraits<GetElementPtrInst, 1> {
1145};

1147GetElementPtrInst::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(cast<PointerType>(getType()->getScalarType())(static_cast <bool> (cast<PointerType>(getType()->
getScalarType()) ->isOpaqueOrPointeeTypeMatches(ResultElementType
)) ? void (0) : __assert_fail ("cast<PointerType>(getType()->getScalarType()) ->isOpaqueOrPointeeTypeMatches(ResultElementType)"
, "llvm/include/llvm/IR/Instructions.h", 1157, __extension__ __PRETTY_FUNCTION__
))
           ->isOpaqueOrPointeeTypeMatches(ResultElementType))(static_cast <bool> (cast<PointerType>(getType()->
getScalarType()) ->isOpaqueOrPointeeTypeMatches(ResultElementType
)) ? void (0) : __assert_fail ("cast<PointerType>(getType()->getScalarType()) ->isOpaqueOrPointeeTypeMatches(ResultElementType)"
, "llvm/include/llvm/IR/Instructions.h", 1157, __extension__ __PRETTY_FUNCTION__
));
init(Ptr, IdxList, NameStr);
1159}

1161GetElementPtrInst::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(cast<PointerType>(getType()->getScalarType())(static_cast <bool> (cast<PointerType>(getType()->
getScalarType()) ->isOpaqueOrPointeeTypeMatches(ResultElementType
)) ? void (0) : __assert_fail ("cast<PointerType>(getType()->getScalarType()) ->isOpaqueOrPointeeTypeMatches(ResultElementType)"
, "llvm/include/llvm/IR/Instructions.h", 1171, __extension__ __PRETTY_FUNCTION__
))
           ->isOpaqueOrPointeeTypeMatches(ResultElementType))(static_cast <bool> (cast<PointerType>(getType()->
getScalarType()) ->isOpaqueOrPointeeTypeMatches(ResultElementType
)) ? void (0) : __assert_fail ("cast<PointerType>(getType()->getScalarType()) ->isOpaqueOrPointeeTypeMatches(ResultElementType)"
, "llvm/include/llvm/IR/Instructions.h", 1171, __extension__ __PRETTY_FUNCTION__
));
init(Ptr, IdxList, NameStr);
1173}

1175DEFINE_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!\""
, "llvm/include/llvm/IR/Instructions.h", 1175, __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!\""
, "llvm/include/llvm/IR/Instructions.h", 1175, __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
); }

1177//===----------------------------------------------------------------------===//
1178//                               ICmpInst Class
1179//===----------------------------------------------------------------------===//

1181/// This instruction compares its operands according to the predicate given
1182/// to the constructor. It only operates on integers or pointers. The operands
1183/// must be identical types.
1184/// Represent an integer comparison operator.
1185class ICmpInst: public CmpInst {
void AssertOK() {
  assert(isIntPredicate() &&(static_cast <bool> (isIntPredicate() && "Invalid ICmp predicate value"
) ? void (0) : __assert_fail ("isIntPredicate() && \"Invalid ICmp predicate value\""
, "llvm/include/llvm/IR/Instructions.h", 1188, __extension__ __PRETTY_FUNCTION__
))
         "Invalid ICmp predicate value")(static_cast <bool> (isIntPredicate() && "Invalid ICmp predicate value"
) ? void (0) : __assert_fail ("isIntPredicate() && \"Invalid ICmp predicate value\""
, "llvm/include/llvm/IR/Instructions.h", 1188, __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!\""
, "llvm/include/llvm/IR/Instructions.h", 1190, __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!\""
, "llvm/include/llvm/IR/Instructions.h", 1190, __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\""
, "llvm/include/llvm/IR/Instructions.h", 1194, __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\""
, "llvm/include/llvm/IR/Instructions.h", 1194, __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\""
, "llvm/include/llvm/IR/Instructions.h", 1194, __extension__ __PRETTY_FUNCTION__
));
}

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

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

1204public:
/// 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) {
1215#ifndef NDEBUG
AssertOK();
1217#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) {
1230#ifndef NDEBUG
AssertOK();
1232#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) {
1243#ifndef NDEBUG
AssertOK();
1245#endif
}

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

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

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

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

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

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

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

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

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

/// Return true if the predicate is SGT or UGT.
///
static bool isGT(Predicate P) {
  return P == ICMP_SGT || P == ICMP_UGT;
}

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

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

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

/// Returns the sequence of all ICmp predicates.
///
static auto predicates() { return ICmpPredicates(); }

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

/// Return result of `LHS Pred RHS` comparison.
static bool compare(const APInt &LHS, const APInt &RHS,
                    ICmpInst::Predicate Pred);

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

1351//===----------------------------------------------------------------------===//
1352//                               FCmpInst Class
1353//===----------------------------------------------------------------------===//

1355/// This instruction compares its operands according to the predicate given
1356/// to the constructor. It only operates on floating point values or packed
1357/// vectors of floating point values. The operands must be identical types.
1358/// Represents a floating point comparison operator.
1359class 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\""
, "llvm/include/llvm/IR/Instructions.h", 1361, __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!\""
, "llvm/include/llvm/IR/Instructions.h", 1363, __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!\""
, "llvm/include/llvm/IR/Instructions.h", 1363, __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\""
, "llvm/include/llvm/IR/Instructions.h", 1366, __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\""
, "llvm/include/llvm/IR/Instructions.h", 1366, __extension__ __PRETTY_FUNCTION__
));
}

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

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

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

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

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

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

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

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

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

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

/// Returns the sequence of all FCmp predicates.
///
static auto predicates() { return FCmpPredicates(); }

/// Return result of `LHS Pred RHS` comparison.
static bool compare(const APFloat &LHS, const APFloat &RHS,
                    FCmpInst::Predicate Pred);

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

1467//===----------------------------------------------------------------------===//
1468/// This class represents a function call, abstracting a target
1469/// machine's calling convention.  This class uses low bit of the SubClassData
1470/// field to indicate whether or not this is a tail call.  The rest of the bits
1471/// hold the calling convention of the call.
1472///
1473class CallInst : public CallBase {
CallInst(const CallInst &CI);

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

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

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

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

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

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

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

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

CallInst *cloneImpl() const;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/// 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 = std::nullopt,
             Function *MallocF = nullptr, const Twine &Name = "");
static Instruction *
CreateMalloc(BasicBlock *InsertAtEnd, Type *IntPtrTy, Type *AllocTy,
             Value *AllocSize, Value *ArraySize = nullptr,
             ArrayRef<OperandBundleDef> Bundles = std::nullopt,
             Function *MallocF = nullptr, const Twine &Name = "");
/// Generate the IR for a call to the builtin free function.
static Instruction *CreateFree(Value *Source, Instruction *InsertBefore);
static Instruction *CreateFree(Value *Source, BasicBlock *InsertAtEnd);
static Instruction *CreateFree(Value *Source,
                               ArrayRef<OperandBundleDef> Bundles,
                               Instruction *InsertBefore);
static Instruction *CreateFree(Value *Source,
                               ArrayRef<OperandBundleDef> Bundles,
                               BasicBlock *InsertAtEnd);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1728//===----------------------------------------------------------------------===//
1729//                               SelectInst Class
1730//===----------------------------------------------------------------------===//

1732/// This class represents the LLVM 'select' instruction.
1733///
1734class 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\""
, "llvm/include/llvm/IR/Instructions.h", 1752, __extension__ __PRETTY_FUNCTION__
));
  Op<0>() = C;
  Op<1>() = S1;
  Op<2>() = S2;
}

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

SelectInst *cloneImpl() const;

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

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

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

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

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

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

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

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

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

1816template <>
1817struct OperandTraits<SelectInst> : public FixedNumOperandTraits<SelectInst, 3> {
1818};

1820DEFINE_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!\""
, "llvm/include/llvm/IR/Instructions.h", 1820, __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!\""
, "llvm/include/llvm/IR/Instructions.h", 1820, __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); }

1822//===----------------------------------------------------------------------===//
1823//                                VAArgInst Class
1824//===----------------------------------------------------------------------===//

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

VAArgInst *cloneImpl() const;

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

1862//===----------------------------------------------------------------------===//
1863//                                ExtractElementInst Class
1864//===----------------------------------------------------------------------===//

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

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

ExtractElementInst *cloneImpl() const;

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

1919template <>
1920struct OperandTraits<ExtractElementInst> :
public FixedNumOperandTraits<ExtractElementInst, 2> {
1922};

1924DEFINE_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!\""
, "llvm/include/llvm/IR/Instructions.h", 1924, __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!\""
, "llvm/include/llvm/IR/Instructions.h", 1924, __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
); }

1926//===----------------------------------------------------------------------===//
1927//                                InsertElementInst Class
1928//===----------------------------------------------------------------------===//

1930/// This instruction inserts a single (scalar)
1931/// element into a VectorType value
1932///
1933class 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);

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

InsertElementInst *cloneImpl() const;

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

1982template <>
1983struct OperandTraits<InsertElementInst> :
public FixedNumOperandTraits<InsertElementInst, 3> {
1985};

1987DEFINE_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!\""
, "llvm/include/llvm/IR/Instructions.h", 1987, __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!\""
, "llvm/include/llvm/IR/Instructions.h", 1987, __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
); }

1989//===----------------------------------------------------------------------===//
1990//                           ShuffleVectorInst Class
1991//===----------------------------------------------------------------------===//

1993constexpr int UndefMaskElem = -1;

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

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

ShuffleVectorInst *cloneImpl() const;

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

void *operator new(size_t S) { return User::operator new(S, 2); }
void operator delete(void *Ptr) { return User::operator delete(Ptr); }

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

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

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

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

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

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

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

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

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

void setShuffleMask(ArrayRef<int> Mask);

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

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

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

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

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

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

  // Not possible to express a shuffle mask for a scalable vector for this
  // case.
  if (isa<ScalableVectorType>(Mask->getType()))
    return false;

  SmallVector<int, 16> MaskAsInts;
  getShuffleMask(Mask, MaskAsInts);
  return isIdentityMask(MaskAsInts);
}

/// Return true if this shuffle chooses elements from exactly one source
/// vector without lane crossings and does not change the number of elements
/// from its input vectors.
/// Example: shufflevector <4 x n> A, <4 x n> B, <4,undef,6,undef>
bool isIdentity() const {
  // Not possible to express a shuffle mask for a scalable vector for this
  // case.
  if (isa<ScalableVectorType>(getType()))
    return false;

  return !changesLength() && isIdentityMask(ShuffleMask);
}

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

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

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

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

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

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

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

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

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

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

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

/// Return true if this shuffle mask is a splice mask, concatenating the two
/// inputs together and then extracts an original width vector starting from
/// the splice index.
/// Example: shufflevector <4 x n> A, <4 x n> B, <1,2,3,4>
static bool isSpliceMask(ArrayRef<int> Mask, int &Index);
static bool isSpliceMask(const Constant *Mask, int &Index) {
  assert(Mask->getType()->isVectorTy() && "Shuffle needs vector constant.")(static_cast <bool> (Mask->getType()->isVectorTy(
) && "Shuffle needs vector constant.") ? void (0) : __assert_fail
 ("Mask->getType()->isVectorTy() && \"Shuffle needs vector constant.\""
, "llvm/include/llvm/IR/Instructions.h", 2299, __extension__ __PRETTY_FUNCTION__
));
  SmallVector<int, 16> MaskAsInts;
  getShuffleMask(Mask, MaskAsInts);
  return isSpliceMask(MaskAsInts, Index);
}

/// Return true if this shuffle splices two inputs without changing the length
/// of the vectors. This operation concatenates the two inputs together and
/// then extracts an original width vector starting from the splice index.
/// Example: shufflevector <4 x n> A, <4 x n> B, <1,2,3,4>
bool isSplice(int &Index) const {
  return !changesLength() && isSpliceMask(ShuffleMask, Index);
}

/// Return true if this shuffle mask is an extract subvector mask.
/// A valid extract subvector mask returns a smaller vector from a single
/// source operand. The base extraction index is returned as well.
static bool isExtractSubvectorMask(ArrayRef<int> Mask, int NumSrcElts,
                                   int &Index);
static bool isExtractSubvectorMask(const Constant *Mask, int NumSrcElts,
                                   int &Index) {
  assert(Mask->getType()->isVectorTy() && "Shuffle needs vector constant.")(static_cast <bool> (Mask->getType()->isVectorTy(
) && "Shuffle needs vector constant.") ? void (0) : __assert_fail
 ("Mask->getType()->isVectorTy() && \"Shuffle needs vector constant.\""
, "llvm/include/llvm/IR/Instructions.h", 2320, __extension__ __PRETTY_FUNCTION__
));
  // Not possible to express a shuffle mask for a scalable vector for this
  // case.
  if (isa<ScalableVectorType>(Mask->getType()))
    return false;
  SmallVector<int, 16> MaskAsInts;
  getShuffleMask(Mask, MaskAsInts);
  return isExtractSubvectorMask(MaskAsInts, NumSrcElts, Index);
}

/// Return true if this shuffle mask is an extract subvector mask.
bool isExtractSubvectorMask(int &Index) const {
  // Not possible to express a shuffle mask for a scalable vector for this
  // case.
  if (isa<ScalableVectorType>(getType()))
    return false;

  int NumSrcElts =
      cast<FixedVectorType>(Op<0>()->getType())->getNumElements();
  return isExtractSubvectorMask(ShuffleMask, NumSrcElts, Index);
}

/// Return true if this shuffle mask is an insert subvector mask.
/// A valid insert subvector mask inserts the lowest elements of a second
/// source operand into an in-place first source operand operand.
/// Both the sub vector width and the insertion index is returned.
static bool isInsertSubvectorMask(ArrayRef<int> Mask, int NumSrcElts,
                                  int &NumSubElts, int &Index);
static bool isInsertSubvectorMask(const Constant *Mask, int NumSrcElts,
                                  int &NumSubElts, int &Index) {
  assert(Mask->getType()->isVectorTy() && "Shuffle needs vector constant.")(static_cast <bool> (Mask->getType()->isVectorTy(
) && "Shuffle needs vector constant.") ? void (0) : __assert_fail
 ("Mask->getType()->isVectorTy() && \"Shuffle needs vector constant.\""
, "llvm/include/llvm/IR/Instructions.h", 2350, __extension__ __PRETTY_FUNCTION__
));
  // Not possible to express a shuffle mask for a scalable vector for this
  // case.
  if (isa<ScalableVectorType>(Mask->getType()))
    return false;
  SmallVector<int, 16> MaskAsInts;
  getShuffleMask(Mask, MaskAsInts);
  return isInsertSubvectorMask(MaskAsInts, NumSrcElts, NumSubElts, Index);
}

/// Return true if this shuffle mask is an insert subvector mask.
bool isInsertSubvectorMask(int &NumSubElts, int &Index) const {
  // Not possible to express a shuffle mask for a scalable vector for this
  // case.
  if (isa<ScalableVectorType>(getType()))
    return false;

  int NumSrcElts =
      cast<FixedVectorType>(Op<0>()->getType())->getNumElements();
  return isInsertSubvectorMask(ShuffleMask, NumSrcElts, NumSubElts, Index);
}

/// Return true if this shuffle mask replicates each of the \p VF elements
/// in a vector \p ReplicationFactor times.
/// For example, the mask for \p ReplicationFactor=3 and \p VF=4 is:
///   <0,0,0,1,1,1,2,2,2,3,3,3>
static bool isReplicationMask(ArrayRef<int> Mask, int &ReplicationFactor,
                              int &VF);
static bool isReplicationMask(const Constant *Mask, int &ReplicationFactor,
                              int &VF) {
  assert(Mask->getType()->isVectorTy() && "Shuffle needs vector constant.")(static_cast <bool> (Mask->getType()->isVectorTy(
) && "Shuffle needs vector constant.") ? void (0) : __assert_fail
 ("Mask->getType()->isVectorTy() && \"Shuffle needs vector constant.\""
, "llvm/include/llvm/IR/Instructions.h", 2380, __extension__ __PRETTY_FUNCTION__
));
  // Not possible to express a shuffle mask for a scalable vector for this
  // case.
  if (isa<ScalableVectorType>(Mask->getType()))
    return false;
  SmallVector<int, 16> MaskAsInts;
  getShuffleMask(Mask, MaskAsInts);
  return isReplicationMask(MaskAsInts, ReplicationFactor, VF);
}

/// Return true if this shuffle mask is a replication mask.
bool isReplicationMask(int &ReplicationFactor, int &VF) const;

/// Return true if this shuffle mask represents "clustered" mask of size VF,
/// i.e. each index between [0..VF) is used exactly once in each submask of
/// size VF.
/// For example, the mask for \p VF=4 is:
/// 0, 1, 2, 3, 3, 2, 0, 1 - "clustered", because each submask of size 4
/// (0,1,2,3 and 3,2,0,1) uses indices [0..VF) exactly one time.
/// 0, 1, 2, 3, 3, 3, 1, 0 - not "clustered", because
///                          element 3 is used twice in the second submask
///                          (3,3,1,0) and index 2 is not used at all.
static bool isOneUseSingleSourceMask(ArrayRef<int> Mask, int VF);

/// Return true if this shuffle mask is a one-use-single-source("clustered")
/// mask.
bool isOneUseSingleSourceMask(int VF) const;

/// 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\""
, "llvm/include/llvm/IR/Instructions.h", 2417, __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\""
, "llvm/include/llvm/IR/Instructions.h", 2417, __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));
}
2428};

2430template <>
2431struct OperandTraits<ShuffleVectorInst>
  : public FixedNumOperandTraits<ShuffleVectorInst, 2> {};

2434DEFINE_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!\""
, "llvm/include/llvm/IR/Instructions.h", 2434, __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!\""
, "llvm/include/llvm/IR/Instructions.h", 2434, __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
); }

2436//===----------------------------------------------------------------------===//
2437//                                ExtractValueInst Class
2438//===----------------------------------------------------------------------===//

2440/// This instruction extracts a struct member or array
2441/// element value from an aggregate value.
2442///
2443class 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);

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

ExtractValueInst *cloneImpl() const;

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

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

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

2547//===----------------------------------------------------------------------===//
2548//                                InsertValueInst Class
2549//===----------------------------------------------------------------------===//

2551/// This instruction inserts a struct field of array element
2552/// value into an aggregate value.
2553///
2554class 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);

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

InsertValueInst *cloneImpl() const;

2588public:
// allocate space for exactly two operands
void *operator new(size_t S) { return User::operator new(S, 2); }
void operator delete(void *Ptr) { User::operator delete(Ptr); }

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

2659template <>
2660struct OperandTraits<InsertValueInst> :
public FixedNumOperandTraits<InsertValueInst, 2> {
2662};

2664InsertValueInst::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);
2673}

2675InsertValueInst::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);
2684}

2686DEFINE_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!\""
, "llvm/include/llvm/IR/Instructions.h", 2686, __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!\""
, "llvm/include/llvm/IR/Instructions.h", 2686, __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
); }

2688//===----------------------------------------------------------------------===//
2689//                               PHINode Class
2690//===----------------------------------------------------------------------===//

2692// PHINode - The PHINode class is used to represent the magical mystical PHI
2693// node, that can not exist in nature, but can be synthesized in a computer
2694// scientist's overactive imagination.
2695//
2696class 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) {
  assert(!Ty->isTokenTy() && "PHI nodes cannot have token type!")(static_cast <bool> (!Ty->isTokenTy() && "PHI nodes cannot have token type!"
) ? void (0) : __assert_fail ("!Ty->isTokenTy() && \"PHI nodes cannot have token type!\""
, "llvm/include/llvm/IR/Instructions.h", 2708, __extension__ __PRETTY_FUNCTION__
));
  setName(NameStr);
  allocHungoffUses(ReservedSpace);
}

PHINode(Type *Ty, unsigned NumReservedValues, const Twine &NameStr,
        BasicBlock *InsertAtEnd)
  : Instruction(Ty, Instruction::PHI, nullptr, 0, InsertAtEnd),
    ReservedSpace(NumReservedValues) {
  assert(!Ty->isTokenTy() && "PHI nodes cannot have token type!")(static_cast <bool> (!Ty->isTokenTy() && "PHI nodes cannot have token type!"
) ? void (0) : __assert_fail ("!Ty->isTokenTy() && \"PHI nodes cannot have token type!\""
, "llvm/include/llvm/IR/Instructions.h", 2717, __extension__ __PRETTY_FUNCTION__
));
  setName(NameStr);
  allocHungoffUses(ReservedSpace);
}

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

2735public:
/// 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.
// Please note that we are not providing non-const iterators for blocks to
// force all updates go through an interface function.

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

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

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

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!\""
, "llvm/include/llvm/IR/Instructions.h", 2786, __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!\""
, "llvm/include/llvm/IR/Instructions.h", 2788, __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!\""
, "llvm/include/llvm/IR/Instructions.h", 2788, __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?\""
, "llvm/include/llvm/IR/Instructions.h", 2810, __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) {
  const_cast<block_iterator>(block_begin())[i] = BB;
}

/// Copies the basic blocks from \p BBRange to the incoming basic block list
/// of this PHINode, starting at \p ToIdx.
void copyIncomingBlocks(iterator_range<const_block_iterator> BBRange,
                        uint32_t ToIdx = 0) {
  copy(BBRange, const_cast<block_iterator>(block_begin()) + ToIdx);
}

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

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

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

Value *removeIncomingValue(const BasicBlock *BB, bool DeletePHIIfEmpty=true) {
  int Idx = getBasicBlockIndex(BB);
  assert(Idx >= 0 && "Invalid basic block argument to remove!")(static_cast <bool> (Idx >= 0 && "Invalid basic block argument to remove!"
) ? void (0) : __assert_fail ("Idx >= 0 && \"Invalid basic block argument to remove!\""
, "llvm/include/llvm/IR/Instructions.h", 2863, __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!\""
, "llvm/include/llvm/IR/Instructions.h", 2879, __extension__ __PRETTY_FUNCTION__
));
  return getIncomingValue(Idx);
}

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

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

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

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

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

2922private:
void growOperands();
2924};

2926template <>
2927struct OperandTraits<PHINode> : public HungoffOperandTraits<2> {
2928};

2930DEFINE_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!\""
, "llvm/include/llvm/IR/Instructions.h", 2930, __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!\""
, "llvm/include/llvm/IR/Instructions.h", 2930, __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); }

2932//===----------------------------------------------------------------------===//
2933//                           LandingPadInst Class
2934//===----------------------------------------------------------------------===//

2936//===---------------------------------------------------------------------------
2937/// The landingpad instruction holds all of the information
2938/// necessary to generate correct exception handling. The landingpad instruction
2939/// cannot be moved from the top of a landing pad block, which itself is
2940/// accessible only from the 'unwind' edge of an invoke. This uses the
2941/// SubclassData field in Value to store whether or not the landingpad is a
2942/// cleanup.
2943///
2944class LandingPadInst : public Instruction {
using CleanupField = BoolBitfieldElementT<0>;

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

LandingPadInst(const LandingPadInst &LP);

2953public:
enum ClauseType { Catch, Filter };

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

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

LandingPadInst *cloneImpl() const;

2974public:
void operator delete(void *Ptr) { User::operator delete(Ptr); }

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

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

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

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

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

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

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

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

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

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

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

3031template <>
3032struct OperandTraits<LandingPadInst> : public HungoffOperandTraits<1> {
3033};

3035DEFINE_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!\""
, "llvm/include/llvm/IR/Instructions.h", 3035, __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!\""
, "llvm/include/llvm/IR/Instructions.h", 3035, __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
); }

3037//===----------------------------------------------------------------------===//
3038//                               ReturnInst Class
3039//===----------------------------------------------------------------------===//

3041//===---------------------------------------------------------------------------
3042/// Return a value (possibly void), from a function.  Execution
3043/// does not continue in this function any longer.
3044///
3045class ReturnInst : public Instruction {
ReturnInst(const ReturnInst &RI);

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

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

ReturnInst *cloneImpl() const;

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

3104private:
BasicBlock *getSuccessor(unsigned idx) const {
  llvm_unreachable("ReturnInst has no successors!")::llvm::llvm_unreachable_internal("ReturnInst has no successors!"
, "llvm/include/llvm/IR/Instructions.h", 3106);
}

void setSuccessor(unsigned idx, BasicBlock *B) {
  llvm_unreachable("ReturnInst has no successors!")::llvm::llvm_unreachable_internal("ReturnInst has no successors!"
, "llvm/include/llvm/IR/Instructions.h", 3110);
}
3112};

3114template <>
3115struct OperandTraits<ReturnInst> : public VariadicOperandTraits<ReturnInst> {
3116};

3118DEFINE_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!\""
, "llvm/include/llvm/IR/Instructions.h", 3118, __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!\""
, "llvm/include/llvm/IR/Instructions.h", 3118, __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); }

3120//===----------------------------------------------------------------------===//
3121//                               BranchInst Class
3122//===----------------------------------------------------------------------===//

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

void AssertOK();

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

BranchInst *cloneImpl() const;

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

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

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

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

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

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

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

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

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

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

Value *getCondition() const {
  assert(isConditional() && "Cannot get condition of an uncond branch!")(static_cast <bool> (isConditional() && "Cannot get condition of an uncond branch!"
) ? void (0) : __assert_fail ("isConditional() && \"Cannot get condition of an uncond branch!\""
, "llvm/include/llvm/IR/Instructions.h", 3209, __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!\""
, "llvm/include/llvm/IR/Instructions.h", 3214, __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!\""
, "llvm/include/llvm/IR/Instructions.h", 3221, __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!\""
, "llvm/include/llvm/IR/Instructions.h", 3226, __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();

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

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

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

3258template <>
3259struct OperandTraits<BranchInst> : public VariadicOperandTraits<BranchInst, 1> {
3260};

3262DEFINE_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!\""
, "llvm/include/llvm/IR/Instructions.h", 3262, __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!\""
, "llvm/include/llvm/IR/Instructions.h", 3262, __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); }

3264//===----------------------------------------------------------------------===//
3265//                               SwitchInst Class
3266//===----------------------------------------------------------------------===//

3268//===---------------------------------------------------------------------------
3269/// Multiway switch
3270///
3271class SwitchInst : public Instruction {
unsigned ReservedSpace;

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

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

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

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

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

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

SwitchInst *cloneImpl() const;

3306public:
void operator delete(void *Ptr) { User::operator delete(Ptr); }

// -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.\""
, "llvm/include/llvm/IR/Instructions.h", 3339, __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.\""
, "llvm/include/llvm/IR/Instructions.h", 3339, __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.\""
, "llvm/include/llvm/IR/Instructions.h", 3347, __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.\""
, "llvm/include/llvm/IR/Instructions.h", 3347, __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.\""
, "llvm/include/llvm/IR/Instructions.h", 3347, __extension__ __PRETTY_FUNCTION__
));
    return SI->getSuccessor(getSuccessorIndex());
  }

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

  /// Returns successor index for current case successor.
  unsigned getSuccessorIndex() const {
    assert(((unsigned)Index == DefaultPseudoIndex ||(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.\""
, "llvm/include/llvm/IR/Instructions.h", 3358, __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.\""
, "llvm/include/llvm/IR/Instructions.h", 3358, __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.\""
, "llvm/include/llvm/IR/Instructions.h", 3358, __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.\""
, "llvm/include/llvm/IR/Instructions.h", 3363, __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) 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.\""
, "llvm/include/llvm/IR/Instructions.h", 3381, __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.\""
, "llvm/include/llvm/IR/Instructions.h", 3381, __extension__ __PRETTY_FUNCTION__
));
    SI->setOperand(2 + Index*2, reinterpret_cast<Value*>(V));
  }

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

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

  CaseHandleT Case;

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

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

  /// Initializes case iterator for given SwitchInst and for given
  /// successor index.
  static CaseIteratorImpl fromSuccessorIndex(SwitchInstT *SI,
                                             unsigned SuccessorIndex) {
    assert(SuccessorIndex < SI->getNumSuccessors() &&(static_cast <bool> (SuccessorIndex < SI->getNumSuccessors
() && "Successor index # out of range!") ? void (0) :
 __assert_fail ("SuccessorIndex < SI->getNumSuccessors() && \"Successor index # out of range!\""
, "llvm/include/llvm/IR/Instructions.h", 3414, __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!\""
, "llvm/include/llvm/IR/Instructions.h", 3414, __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.\""
, "llvm/include/llvm/IR/Instructions.h", 3430, __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.\""
, "llvm/include/llvm/IR/Instructions.h", 3430, __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.\""
, "llvm/include/llvm/IR/Instructions.h", 3430, __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.\""
, "llvm/include/llvm/IR/Instructions.h", 3439, __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.\""
, "llvm/include/llvm/IR/Instructions.h", 3439, __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.\""
, "llvm/include/llvm/IR/Instructions.h", 3439, __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.\""
, "llvm/include/llvm/IR/Instructions.h", 3444, __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.\""
, "llvm/include/llvm/IR/Instructions.h", 3451, __extension__ __PRETTY_FUNCTION__
));
    return Case.Index < RHS.Case.Index;
  }
  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) {
  return CaseIt(
      this,
      const_cast<const SwitchInst *>(this)->findCaseValue(C)->getCaseIndex());
}
ConstCaseIt findCaseValue(const ConstantInt *C) const {
  ConstCaseIt I = llvm::find_if(cases(), [C](const 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!\""
, "llvm/include/llvm/IR/Instructions.h", 3594, __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!\""
, "llvm/include/llvm/IR/Instructions.h", 3598, __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));
}
3609};

3611/// A wrapper class to simplify modification of SwitchInst cases along with
3612/// their prof branch_weights metadata.
3613class SwitchInstProfUpdateWrapper {
SwitchInst &SI;
std::optional<SmallVector<uint32_t, 8>> Weights;
bool Changed = false;

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

MDNode *buildProfBranchWeightsMD();

void init();

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

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

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

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

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

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

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

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

3656template <>
3657struct OperandTraits<SwitchInst> : public HungoffOperandTraits<2> {
3658};

3660DEFINE_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!\""
, "llvm/include/llvm/IR/Instructions.h", 3660, __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!\""
, "llvm/include/llvm/IR/Instructions.h", 3660, __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); }

3662//===----------------------------------------------------------------------===//
3663//                             IndirectBrInst Class
3664//===----------------------------------------------------------------------===//

3666//===---------------------------------------------------------------------------
3667/// Indirect Branch Instruction.
3668///
3669class IndirectBrInst : public Instruction {
unsigned ReservedSpace;

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

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

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

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

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

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

IndirectBrInst *cloneImpl() const;

3700public:
void operator delete(void *Ptr) { User::operator delete(Ptr); }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

3791template <>
3792struct OperandTraits<IndirectBrInst> : public HungoffOperandTraits<1> {
3793};

3795DEFINE_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!\""
, "llvm/include/llvm/IR/Instructions.h", 3795, __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!\""
, "llvm/include/llvm/IR/Instructions.h", 3795, __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
); }

3797//===----------------------------------------------------------------------===//
3798//                               InvokeInst Class
3799//===----------------------------------------------------------------------===//

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

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

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

InvokeInst(const InvokeInst &BI);

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

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

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

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

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

InvokeInst *cloneImpl() const;

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

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

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

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

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

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

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

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

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

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

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

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

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

BasicBlock *getSuccessor(unsigned i) const {
  assert(i < 2 && "Successor # out of range for invoke!")(static_cast <bool> (i < 2 && "Successor # out of range for invoke!"
) ? void (0) : __assert_fail ("i < 2 && \"Successor # out of range for invoke!\""
, "llvm/include/llvm/IR/Instructions.h", 3954, __extension__ __PRETTY_FUNCTION__
));
  return i == 0 ? getNormalDest() : getUnwindDest();
}

void setSuccessor(unsigned i, BasicBlock *NewSucc) {
  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!\""
, "llvm/include/llvm/IR/Instructions.h", 3959, __extension__ __PRETTY_FUNCTION__
));
  if (i == 0)
    setNormalDest(NewSucc);
  else
    setUnwindDest(NewSucc);
}

unsigned getNumSuccessors() const { return 2; }

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

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

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

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

4005//===----------------------------------------------------------------------===//
4006//                              CallBrInst Class
4007//===----------------------------------------------------------------------===//

4009/// CallBr instruction, tracking function calls that may not return control but
4010/// instead transfer it to a third location. The SubclassData field is used to
4011/// hold the calling convention of the call.
4012///
4013class CallBrInst : public CallBase {

unsigned NumIndirectDests;

CallBrInst(const CallBrInst &BI);

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

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

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

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

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

CallBrInst *cloneImpl() const;

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

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

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

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

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

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

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

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

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

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

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

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

/// getIndirectDestLabel - Return the i-th indirect dest label.
///
Value *getIndirectDestLabel(unsigned i) const {
  assert(i < getNumIndirectDests() && "Out of bounds!")(static_cast <bool> (i < getNumIndirectDests() &&
 "Out of bounds!") ? void (0) : __assert_fail ("i < getNumIndirectDests() && \"Out of bounds!\""
, "llvm/include/llvm/IR/Instructions.h", 4157, __extension__ __PRETTY_FUNCTION__
));
  return getOperand(i + arg_size() + getNumTotalBundleOperands() + 1);
}

Value *getIndirectDestLabelUse(unsigned i) const {
  assert(i < getNumIndirectDests() && "Out of bounds!")(static_cast <bool> (i < getNumIndirectDests() &&
 "Out of bounds!") ? void (0) : __assert_fail ("i < getNumIndirectDests() && \"Out of bounds!\""
, "llvm/include/llvm/IR/Instructions.h", 4162, __extension__ __PRETTY_FUNCTION__
));
  return getOperandUse(i + arg_size() + getNumTotalBundleOperands() + 1);
}

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

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

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

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

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

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

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

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

4239//===----------------------------------------------------------------------===//
4240//                              ResumeInst Class
4241//===----------------------------------------------------------------------===//

4243//===---------------------------------------------------------------------------
4244/// Resume the propagation of an exception.
4245///
4246class ResumeInst : public Instruction {
ResumeInst(const ResumeInst &RI);

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

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

ResumeInst *cloneImpl() const;

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

4283private:
BasicBlock *getSuccessor(unsigned idx) const {
  llvm_unreachable("ResumeInst has no successors!")::llvm::llvm_unreachable_internal("ResumeInst has no successors!"
, "llvm/include/llvm/IR/Instructions.h", 4285);
}

void setSuccessor(unsigned idx, BasicBlock *NewSucc) {
  llvm_unreachable("ResumeInst has no successors!")::llvm::llvm_unreachable_internal("ResumeInst has no successors!"
, "llvm/include/llvm/IR/Instructions.h", 4289);
}
4291};

4293template <>
4294struct OperandTraits<ResumeInst> :
  public FixedNumOperandTraits<ResumeInst, 1> {
4296};

4298DEFINE_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!\""
, "llvm/include/llvm/IR/Instructions.h", 4298, __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!\""
, "llvm/include/llvm/IR/Instructions.h", 4298, __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); }

4300//===----------------------------------------------------------------------===//
4301//                         CatchSwitchInst Class
4302//===----------------------------------------------------------------------===//
4303class CatchSwitchInst : public Instruction {
using UnwindDestField = BoolBitfieldElementT<0>;

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

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

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

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

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

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

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

CatchSwitchInst *cloneImpl() const;

4343public:
void operator delete(void *Ptr) { return User::operator delete(Ptr); }

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

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

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

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

// Accessor Methods for CatchSwitch stmt
bool hasUnwindDest() const { return getSubclassData<UnwindDestField>(); }
bool unwindsToCaller() const { return !hasUnwindDest(); }
BasicBlock *getUnwindDest() const {
  if (hasUnwindDest())
    return cast<BasicBlock>(getOperand(1));
  return nullptr;
}
void setUnwindDest(BasicBlock *UnwindDest) {
  assert(UnwindDest)(static_cast <bool> (UnwindDest) ? void (0) : __assert_fail
 ("UnwindDest", "llvm/include/llvm/IR/Instructions.h", 4377, __extension__
 __PRETTY_FUNCTION__));
  assert(hasUnwindDest())(static_cast <bool> (hasUnwindDest()) ? void (0) : __assert_fail
 ("hasUnwindDest()", "llvm/include/llvm/IR/Instructions.h", 4378
, __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;
}

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

4396public:
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!\""
, "llvm/include/llvm/IR/Instructions.h", 4455, __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!\""
, "llvm/include/llvm/IR/Instructions.h", 4455, __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!\""
, "llvm/include/llvm/IR/Instructions.h", 4460, __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!\""
, "llvm/include/llvm/IR/Instructions.h", 4460, __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));
}
4471};

4473template <>
4474struct OperandTraits<CatchSwitchInst> : public HungoffOperandTraits<2> {};

4476DEFINE_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!\""
, "llvm/include/llvm/IR/Instructions.h", 4476, __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!\""
, "llvm/include/llvm/IR/Instructions.h", 4476, __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
); }

4478//===----------------------------------------------------------------------===//
4479//                               CleanupPadInst Class
4480//===----------------------------------------------------------------------===//
4481class CleanupPadInst : public FuncletPadInst {
4482private:
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) {}

4494public:
static CleanupPadInst *Create(Value *ParentPad,
                              ArrayRef<Value *> Args = std::nullopt,
                              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));
}
4518};

4520//===----------------------------------------------------------------------===//
4521//                               CatchPadInst Class
4522//===----------------------------------------------------------------------===//
4523class CatchPadInst : public FuncletPadInst {
4524private:
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) {}

4536public:
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", "llvm/include/llvm/IR/Instructions.h", 4557,
 __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));
}
4568};

4570//===----------------------------------------------------------------------===//
4571//                               CatchReturnInst Class
4572//===----------------------------------------------------------------------===//

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

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

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

CatchReturnInst *cloneImpl() const;

4587public:
static CatchReturnInst *Create(Value *CatchPad, BasicBlock *BB,
                               Instruction *InsertBefore = nullptr) {
  assert(CatchPad)(static_cast <bool> (CatchPad) ? void (0) : __assert_fail
 ("CatchPad", "llvm/include/llvm/IR/Instructions.h", 4590, __extension__
 __PRETTY_FUNCTION__));
  assert(BB)(static_cast <bool> (BB) ? void (0) : __assert_fail ("BB"
, "llvm/include/llvm/IR/Instructions.h", 4591, __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", "llvm/include/llvm/IR/Instructions.h", 4597, __extension__
 __PRETTY_FUNCTION__));
  assert(BB)(static_cast <bool> (BB) ? void (0) : __assert_fail ("BB"
, "llvm/include/llvm/IR/Instructions.h", 4598, __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", "llvm/include/llvm/IR/Instructions.h", 4608, __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", "llvm/include/llvm/IR/Instructions.h", 4614, __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));
}

4633private:
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!\""
, "llvm/include/llvm/IR/Instructions.h", 4635, __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!\""
, "llvm/include/llvm/IR/Instructions.h", 4640, __extension__ __PRETTY_FUNCTION__
));
  setSuccessor(B);
}
4643};

4645template <>
4646struct OperandTraits<CatchReturnInst>
  : public FixedNumOperandTraits<CatchReturnInst, 2> {};

4649DEFINE_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!\""
, "llvm/include/llvm/IR/Instructions.h", 4649, __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!\""
, "llvm/include/llvm/IR/Instructions.h", 4649, __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
); }

4651//===----------------------------------------------------------------------===//
4652//                               CleanupReturnInst Class
4653//===----------------------------------------------------------------------===//

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

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

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

CleanupReturnInst *cloneImpl() const;

4673public:
static CleanupReturnInst *Create(Value *CleanupPad,
                                 BasicBlock *UnwindBB = nullptr,
                                 Instruction *InsertBefore = nullptr) {
  assert(CleanupPad)(static_cast <bool> (CleanupPad) ? void (0) : __assert_fail
 ("CleanupPad", "llvm/include/llvm/IR/Instructions.h", 4677, __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", "llvm/include/llvm/IR/Instructions.h", 4687, __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 getSubclassData<UnwindDestField>(); }
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", "llvm/include/llvm/IR/Instructions.h", 4706, __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", "llvm/include/llvm/IR/Instructions.h", 4716, __extension__
 __PRETTY_FUNCTION__));
  assert(hasUnwindDest())(static_cast <bool> (hasUnwindDest()) ? void (0) : __assert_fail
 ("hasUnwindDest()", "llvm/include/llvm/IR/Instructions.h", 4717
, __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));
}

4729private:
BasicBlock *getSuccessor(unsigned Idx) const {
  assert(Idx == 0)(static_cast <bool> (Idx == 0) ? void (0) : __assert_fail
 ("Idx == 0", "llvm/include/llvm/IR/Instructions.h", 4731, __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", "llvm/include/llvm/IR/Instructions.h", 4736, __extension__
 __PRETTY_FUNCTION__));
  setUnwindDest(B);
}

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

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

4752DEFINE_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!\""
, "llvm/include/llvm/IR/Instructions.h", 4752, __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!\""
, "llvm/include/llvm/IR/Instructions.h", 4752, __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
); }

4754//===----------------------------------------------------------------------===//
4755//                           UnreachableInst Class
4756//===----------------------------------------------------------------------===//

4758//===---------------------------------------------------------------------------
4759/// This function has undefined behavior.  In particular, the
4760/// presence of this instruction indicates some higher level knowledge that the
4761/// end of the block cannot be reached.
4762///
4763class UnreachableInst : public Instruction {
4764protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

UnreachableInst *cloneImpl() const;

4770public:
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); }
void operator delete(void *Ptr) { User::operator delete(Ptr); }

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

4788private:
BasicBlock *getSuccessor(unsigned idx) const {
  llvm_unreachable("UnreachableInst has no successors!")::llvm::llvm_unreachable_internal("UnreachableInst has no successors!"
, "llvm/include/llvm/IR/Instructions.h", 4790);
}

void setSuccessor(unsigned idx, BasicBlock *B) {
  llvm_unreachable("UnreachableInst has no successors!")::llvm::llvm_unreachable_internal("UnreachableInst has no successors!"
, "llvm/include/llvm/IR/Instructions.h", 4794);
}
4796};

4798//===----------------------------------------------------------------------===//
4799//                                 TruncInst Class
4800//===----------------------------------------------------------------------===//

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

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

4811public:
/// 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));
}
4835};

4837//===----------------------------------------------------------------------===//
4838//                                 ZExtInst Class
4839//===----------------------------------------------------------------------===//

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

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

4850public:
/// 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));
}
4874};

4876//===----------------------------------------------------------------------===//
4877//                                 SExtInst Class
4878//===----------------------------------------------------------------------===//

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

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

4889public:
/// 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));
}
4913};

4915//===----------------------------------------------------------------------===//
4916//                                 FPTruncInst Class
4917//===----------------------------------------------------------------------===//

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

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

4928public:
/// 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));
}
4952};

4954//===----------------------------------------------------------------------===//
4955//                                 FPExtInst Class
4956//===----------------------------------------------------------------------===//

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

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

4967public:
/// 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));
}
4991};

4993//===----------------------------------------------------------------------===//
4994//                                 UIToFPInst Class
4995//===----------------------------------------------------------------------===//

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

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

5006public:
/// 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));
}
5030};

5032//===----------------------------------------------------------------------===//
5033//                                 SIToFPInst Class
5034//===----------------------------------------------------------------------===//

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

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

5045public:
/// 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));
}
5069};

5071//===----------------------------------------------------------------------===//
5072//                                 FPToUIInst Class
5073//===----------------------------------------------------------------------===//

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

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

5084public:
/// 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));
}
5108};

5110//===----------------------------------------------------------------------===//
5111//                                 FPToSIInst Class
5112//===----------------------------------------------------------------------===//

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

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

5123public:
/// 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));
}
5147};

5149//===----------------------------------------------------------------------===//
5150//                                 IntToPtrInst Class
5151//===----------------------------------------------------------------------===//

5153/// This class represents a cast from an integer to a pointer.
5154class IntToPtrInst : public CastInst {
5155public:
// 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));
}
5190};

5192//===----------------------------------------------------------------------===//
5193//                                 PtrToIntInst Class
5194//===----------------------------------------------------------------------===//

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

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

5205public:
/// 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));
}
5241};

5243//===----------------------------------------------------------------------===//
5244//                             BitCastInst Class
5245//===----------------------------------------------------------------------===//

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

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

5256public:
/// 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));
}
5280};

5282//===----------------------------------------------------------------------===//
5283//                          AddrSpaceCastInst Class
5284//===----------------------------------------------------------------------===//

5286/// This class represents a conversion between pointers from one address space
5287/// to another.
5288class AddrSpaceCastInst : public CastInst {
5289protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

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

5296public:
/// 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();
}
5345};

5347//===----------------------------------------------------------------------===//
5348//                          Helper functions
5349//===----------------------------------------------------------------------===//

5351/// A helper function that returns the pointer operand of a load or store
5352/// instruction. Returns nullptr if not load or store.
5353inline const Value *getLoadStorePointerOperand(const Value *V) {
if (auto *Load = dyn_cast<LoadInst>(V))
22
←
Assuming 'Load' is null→
23
←
Taking false branch→
  return Load->getPointerOperand();
if (auto *Store = dyn_cast<StoreInst>(V))
24
←
Assuming 'Store' is null→
25
←
Taking false branch→
  return Store->getPointerOperand();
return nullptr;
26
←
Returning null pointer, which participates in a condition later→
5359}
5360inline Value *getLoadStorePointerOperand(Value *V) {
return const_cast<Value *>(
28
←
Returning null pointer, which participates in a condition later→
    getLoadStorePointerOperand(static_cast<const Value *>(V)));
21
←
Calling 'getLoadStorePointerOperand'→
27
←
Returning from 'getLoadStorePointerOperand'→
5363}

5365/// A helper function that returns the pointer operand of a load, store
5366/// or GEP instruction. Returns nullptr if not load, store, or GEP.
5367inline const Value *getPointerOperand(const Value *V) {
if (auto *Ptr = getLoadStorePointerOperand(V))
  return Ptr;
if (auto *Gep = dyn_cast<GetElementPtrInst>(V))
  return Gep->getPointerOperand();
return nullptr;
5373}
5374inline Value *getPointerOperand(Value *V) {
return const_cast<Value *>(getPointerOperand(static_cast<const Value *>(V)));
5376}

5378/// A helper function that returns the alignment of load or store instruction.
5379inline Align getLoadStoreAlignment(Value *I) {
assert((isa<LoadInst>(I) || isa<StoreInst>(I)) &&(static_cast <bool> ((isa<LoadInst>(I) || isa<
StoreInst>(I)) && "Expected Load or Store instruction"
) ? void (0) : __assert_fail ("(isa<LoadInst>(I) || isa<StoreInst>(I)) && \"Expected Load or Store instruction\""
, "llvm/include/llvm/IR/Instructions.h", 5381, __extension__ __PRETTY_FUNCTION__
))
       "Expected Load or Store instruction")(static_cast <bool> ((isa<LoadInst>(I) || isa<
StoreInst>(I)) && "Expected Load or Store instruction"
) ? void (0) : __assert_fail ("(isa<LoadInst>(I) || isa<StoreInst>(I)) && \"Expected Load or Store instruction\""
, "llvm/include/llvm/IR/Instructions.h", 5381, __extension__ __PRETTY_FUNCTION__
));
if (auto *LI = dyn_cast<LoadInst>(I))
  return LI->getAlign();
return cast<StoreInst>(I)->getAlign();
5385}

5387/// A helper function that returns the address space of the pointer operand of
5388/// load or store instruction.
5389inline unsigned getLoadStoreAddressSpace(Value *I) {
assert((isa<LoadInst>(I) || isa<StoreInst>(I)) &&(static_cast <bool> ((isa<LoadInst>(I) || isa<
StoreInst>(I)) && "Expected Load or Store instruction"
) ? void (0) : __assert_fail ("(isa<LoadInst>(I) || isa<StoreInst>(I)) && \"Expected Load or Store instruction\""
, "llvm/include/llvm/IR/Instructions.h", 5391, __extension__ __PRETTY_FUNCTION__
))
       "Expected Load or Store instruction")(static_cast <bool> ((isa<LoadInst>(I) || isa<
StoreInst>(I)) && "Expected Load or Store instruction"
) ? void (0) : __assert_fail ("(isa<LoadInst>(I) || isa<StoreInst>(I)) && \"Expected Load or Store instruction\""
, "llvm/include/llvm/IR/Instructions.h", 5391, __extension__ __PRETTY_FUNCTION__
));
if (auto *LI = dyn_cast<LoadInst>(I))
  return LI->getPointerAddressSpace();
return cast<StoreInst>(I)->getPointerAddressSpace();
5395}

5397/// A helper function that returns the type of a load or store instruction.
5398inline Type *getLoadStoreType(Value *I) {
assert((isa<LoadInst>(I) || isa<StoreInst>(I)) &&(static_cast <bool> ((isa<LoadInst>(I) || isa<
StoreInst>(I)) && "Expected Load or Store instruction"
) ? void (0) : __assert_fail ("(isa<LoadInst>(I) || isa<StoreInst>(I)) && \"Expected Load or Store instruction\""
, "llvm/include/llvm/IR/Instructions.h", 5400, __extension__ __PRETTY_FUNCTION__
))
       "Expected Load or Store instruction")(static_cast <bool> ((isa<LoadInst>(I) || isa<
StoreInst>(I)) && "Expected Load or Store instruction"
) ? void (0) : __assert_fail ("(isa<LoadInst>(I) || isa<StoreInst>(I)) && \"Expected Load or Store instruction\""
, "llvm/include/llvm/IR/Instructions.h", 5400, __extension__ __PRETTY_FUNCTION__
));
if (auto *LI = dyn_cast<LoadInst>(I))
  return LI->getType();
return cast<StoreInst>(I)->getValueOperand()->getType();
5404}

5406/// A helper function that returns an atomic operation's sync scope; returns
5407/// std::nullopt if it is not an atomic operation.
5408inline std::optional<SyncScope::ID> getAtomicSyncScopeID(const Instruction *I) {
if (!I->isAtomic())
  return std::nullopt;
if (auto *AI = dyn_cast<LoadInst>(I))
  return AI->getSyncScopeID();
if (auto *AI = dyn_cast<StoreInst>(I))
  return AI->getSyncScopeID();
if (auto *AI = dyn_cast<FenceInst>(I))
  return AI->getSyncScopeID();
if (auto *AI = dyn_cast<AtomicCmpXchgInst>(I))
  return AI->getSyncScopeID();
if (auto *AI = dyn_cast<AtomicRMWInst>(I))
  return AI->getSyncScopeID();
llvm_unreachable("unhandled atomic operation")::llvm::llvm_unreachable_internal("unhandled atomic operation"
, "llvm/include/llvm/IR/Instructions.h", 5421);
5422}

5424//===----------------------------------------------------------------------===//
5425//                              FreezeInst Class
5426//===----------------------------------------------------------------------===//

5428/// This class represents a freeze function that returns random concrete
5429/// value if an operand is either a poison value or an undef value
5430class FreezeInst : public UnaryInstruction {
5431protected:
// Note: Instruction needs to be a friend here to call cloneImpl.
friend class Instruction;

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

5438public:
explicit FreezeInst(Value *S,
                    const Twine &NameStr = "",
                    Instruction *InsertBefore = nullptr);
FreezeInst(Value *S, const Twine &NameStr, BasicBlock *InsertAtEnd);

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

5453} // end namespace llvm

5455#endif // LLVM_IR_INSTRUCTIONS_H