/build/llvm-toolchain-snapshot-13~++20210722111111+b115c038d2d4/llvm/lib/Target/X86/X86PartialReduction.cpp

Bug Summary

File:	llvm/lib/Target/X86/X86PartialReduction.cpp
Warning:	line 289, column 26 Division by zero

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name X86PartialReduction.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/llvm-toolchain-snapshot-13~++20210722111111+b115c038d2d4/build-llvm/lib/Target/X86 -resource-dir /usr/lib/llvm-13/lib/clang/13.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-13~++20210722111111+b115c038d2d4/build-llvm/lib/Target/X86 -I /build/llvm-toolchain-snapshot-13~++20210722111111+b115c038d2d4/llvm/lib/Target/X86 -I /build/llvm-toolchain-snapshot-13~++20210722111111+b115c038d2d4/build-llvm/include -I /build/llvm-toolchain-snapshot-13~++20210722111111+b115c038d2d4/llvm/include -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-13/lib/clang/13.0.0/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 -O2 -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 -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/build/llvm-toolchain-snapshot-13~++20210722111111+b115c038d2d4/build-llvm/lib/Target/X86 -fdebug-prefix-map=/build/llvm-toolchain-snapshot-13~++20210722111111+b115c038d2d4=. -ferror-limit 19 -fvisibility hidden -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2021-07-23-023125-8721-1 -x c++ /build/llvm-toolchain-snapshot-13~++20210722111111+b115c038d2d4/llvm/lib/Target/X86/X86PartialReduction.cpp

/build/llvm-toolchain-snapshot-13~++20210722111111+b115c038d2d4/llvm/lib/Target/X86/X86PartialReduction.cpp

→

1//===-- X86PartialReduction.cpp -------------------------------------------===//
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 looks for add instructions used by a horizontal reduction to see
10// if we might be able to use pmaddwd or psadbw. Some cases of this require
11// cross basic block knowledge and can't be done in SelectionDAG.
12//
13//===----------------------------------------------------------------------===//
14 
15#include "X86.h"
16#include "llvm/Analysis/ValueTracking.h"
17#include "llvm/CodeGen/TargetPassConfig.h"
18#include "llvm/IR/Constants.h"
19#include "llvm/IR/Instructions.h"
20#include "llvm/IR/IntrinsicsX86.h"
21#include "llvm/IR/IRBuilder.h"
22#include "llvm/IR/Operator.h"
23#include "llvm/Pass.h"
24#include "X86TargetMachine.h"
25 
26using namespace llvm;
27 
28#define DEBUG_TYPE"x86-partial-reduction" "x86-partial-reduction"
29 
30namespace {
31 
32class X86PartialReduction : public FunctionPass {
33  const DataLayout *DL;
34  const X86Subtarget *ST;
35 
36public:
37  static char ID; // Pass identification, replacement for typeid.
38 
39  X86PartialReduction() : FunctionPass(ID) { }
40 
41  bool runOnFunction(Function &Fn) override;
42 
43  void getAnalysisUsage(AnalysisUsage &AU) const override {
44    AU.setPreservesCFG();
45  }
46 
47  StringRef getPassName() const override {
48    return "X86 Partial Reduction";
49  }
50 
51private:
52  bool tryMAddReplacement(Instruction *Op);
53  bool trySADReplacement(Instruction *Op);
54};
55}
56 
57FunctionPass *llvm::createX86PartialReductionPass() {
58  return new X86PartialReduction();
59}
60 
61char X86PartialReduction::ID = 0;
62 
63INITIALIZE_PASS(X86PartialReduction, DEBUG_TYPE,static void *initializeX86PartialReductionPassOnce(PassRegistry
 &Registry) { PassInfo *PI = new PassInfo( "X86 Partial Reduction"
, "x86-partial-reduction", &X86PartialReduction::ID, PassInfo
::NormalCtor_t(callDefaultCtor<X86PartialReduction>), false
, false); Registry.registerPass(*PI, true); return PI; } static
 llvm::once_flag InitializeX86PartialReductionPassFlag; void llvm
::initializeX86PartialReductionPass(PassRegistry &Registry
) { llvm::call_once(InitializeX86PartialReductionPassFlag, initializeX86PartialReductionPassOnce
, std::ref(Registry)); }
64                "X86 Partial Reduction", false, false)static void *initializeX86PartialReductionPassOnce(PassRegistry
 &Registry) { PassInfo *PI = new PassInfo( "X86 Partial Reduction"
, "x86-partial-reduction", &X86PartialReduction::ID, PassInfo
::NormalCtor_t(callDefaultCtor<X86PartialReduction>), false
, false); Registry.registerPass(*PI, true); return PI; } static
 llvm::once_flag InitializeX86PartialReductionPassFlag; void llvm
::initializeX86PartialReductionPass(PassRegistry &Registry
) { llvm::call_once(InitializeX86PartialReductionPassFlag, initializeX86PartialReductionPassOnce
, std::ref(Registry)); }
65 
66bool X86PartialReduction::tryMAddReplacement(Instruction *Op) {
67  if (!ST->hasSSE2())
68    return false;
69 
70  // Need at least 8 elements.
71  if (cast<FixedVectorType>(Op->getType())->getNumElements() < 8)
72    return false;
73 
74  // Element type should be i32.
75  if (!cast<VectorType>(Op->getType())->getElementType()->isIntegerTy(32))
76    return false;
77 
78  auto *Mul = dyn_cast<BinaryOperator>(Op);
79  if (!Mul || Mul->getOpcode() != Instruction::Mul)
80    return false;
81 
82  Value *LHS = Mul->getOperand(0);
83  Value *RHS = Mul->getOperand(1);
84 
85  // LHS and RHS should be only used once or if they are the same then only
86  // used twice. Only check this when SSE4.1 is enabled and we have zext/sext
87  // instructions, otherwise we use punpck to emulate zero extend in stages. The
88  // trunc/ we need to do likely won't introduce new instructions in that case.
89  if (ST->hasSSE41()) {
90    if (LHS == RHS) {
91      if (!isa<Constant>(LHS) && !LHS->hasNUses(2))
92        return false;
93    } else {
94      if (!isa<Constant>(LHS) && !LHS->hasOneUse())
95        return false;
96      if (!isa<Constant>(RHS) && !RHS->hasOneUse())
97        return false;
98    }
99  }
100 
101  auto CanShrinkOp = [&](Value *Op) {
102    auto IsFreeTruncation = [&](Value *Op) {
103      if (auto *Cast = dyn_cast<CastInst>(Op)) {
104        if (Cast->getParent() == Mul->getParent() &&
105            (Cast->getOpcode() == Instruction::SExt ||
106             Cast->getOpcode() == Instruction::ZExt) &&
107            Cast->getOperand(0)->getType()->getScalarSizeInBits() <= 16)
108          return true;
109      }
110 
111      return isa<Constant>(Op);
112    };
113 
114    // If the operation can be freely truncated and has enough sign bits we
115    // can shrink.
116    if (IsFreeTruncation(Op) &&
117        ComputeNumSignBits(Op, *DL, 0, nullptr, Mul) > 16)
118      return true;
119 
120    // SelectionDAG has limited support for truncating through an add or sub if
121    // the inputs are freely truncatable.
122    if (auto *BO = dyn_cast<BinaryOperator>(Op)) {
123      if (BO->getParent() == Mul->getParent() &&
124          IsFreeTruncation(BO->getOperand(0)) &&
125          IsFreeTruncation(BO->getOperand(1)) &&
126          ComputeNumSignBits(Op, *DL, 0, nullptr, Mul) > 16)
127        return true;
128    }
129 
130    return false;
131  };
132 
133  // Both Ops need to be shrinkable.
134  if (!CanShrinkOp(LHS) && !CanShrinkOp(RHS))
135    return false;
136 
137  IRBuilder<> Builder(Mul);
138 
139  auto *MulTy = cast<FixedVectorType>(Op->getType());
140  unsigned NumElts = MulTy->getNumElements();
141 
142  // Extract even elements and odd elements and add them together. This will
143  // be pattern matched by SelectionDAG to pmaddwd. This instruction will be
144  // half the original width.
145  SmallVector<int, 16> EvenMask(NumElts / 2);
146  SmallVector<int, 16> OddMask(NumElts / 2);
147  for (int i = 0, e = NumElts / 2; i != e; ++i) {
148    EvenMask[i] = i * 2;
149    OddMask[i] = i * 2 + 1;
150  }
151  // Creating a new mul so the replaceAllUsesWith below doesn't replace the
152  // uses in the shuffles we're creating.
153  Value *NewMul = Builder.CreateMul(Mul->getOperand(0), Mul->getOperand(1));
154  Value *EvenElts = Builder.CreateShuffleVector(NewMul, NewMul, EvenMask);
155  Value *OddElts = Builder.CreateShuffleVector(NewMul, NewMul, OddMask);
156  Value *MAdd = Builder.CreateAdd(EvenElts, OddElts);
157 
158  // Concatenate zeroes to extend back to the original type.
159  SmallVector<int, 32> ConcatMask(NumElts);
160  std::iota(ConcatMask.begin(), ConcatMask.end(), 0);
161  Value *Zero = Constant::getNullValue(MAdd->getType());
162  Value *Concat = Builder.CreateShuffleVector(MAdd, Zero, ConcatMask);
163 
164  Mul->replaceAllUsesWith(Concat);
165  Mul->eraseFromParent();
166 
167  return true;
168}
169 
170bool X86PartialReduction::trySADReplacement(Instruction *Op) {
171  if (!ST->hasSSE2())
12
←
Calling 'X86Subtarget::hasSSE2'→
14
←
Returning from 'X86Subtarget::hasSSE2'→
15
←
Taking false branch→
172    return false;
173 
174  // TODO: There's nothing special about i32, any integer type above i16 should
175  // work just as well.
176  if (!cast<VectorType>(Op->getType())->getElementType()->isIntegerTy(32))
16
←
The object is a 'VectorType'→
17
←
Assuming the condition is false→
18
←
Taking false branch→
177    return false;
178 
179  // Operand should be a select.
180  auto *SI = dyn_cast<SelectInst>(Op);
19
←
Assuming 'Op' is a 'SelectInst'→
181  if (!SI19.1
'SI' is non-null
19.1
'SI' is non-null
19.1
'SI' is non-null
)
20
←
Taking false branch→
182    return false;
183 
184  // Select needs to implement absolute value.
185  Value *LHS, *RHS;
186  auto SPR = matchSelectPattern(SI, LHS, RHS);
187  if (SPR.Flavor != SPF_ABS)
21
←
Assuming field 'Flavor' is equal to SPF_ABS→
22
←
Taking false branch→
188    return false;
189 
190  // Need a subtract of two values.
191  auto *Sub = dyn_cast<BinaryOperator>(LHS);
23
←
Assuming 'LHS' is a 'BinaryOperator'→
192  if (!Sub23.1
'Sub' is non-null
23.1
'Sub' is non-null
23.1
'Sub' is non-null
 || Sub->getOpcode() != Instruction::Sub)
24
←
Assuming the condition is false→
25
←
Taking false branch→
193    return false;
194 
195  // Look for zero extend from i8.
196  auto getZeroExtendedVal = [](Value *Op) -> Value * {
197    if (auto *ZExt = dyn_cast<ZExtInst>(Op))
27
←
Assuming 'ZExt' is non-null→
28
←
Taking true branch→
40
←
Assuming 'ZExt' is non-null→
41
←
Taking true branch→
198      if (cast<VectorType>(ZExt->getOperand(0)->getType())
29
←
The object is a 'VectorType'→
30
←
Assuming the condition is true→
31
←
Taking true branch→
42
←
The object is a 'VectorType'→
43
←
Assuming the condition is true→
44
←
Taking true branch→
199              ->getElementType()
200              ->isIntegerTy(8))
201        return ZExt->getOperand(0);
32
←
Calling 'UnaryInstruction::getOperand'→
36
←
Returning from 'UnaryInstruction::getOperand'→
37
←
Returning pointer, which participates in a condition later→
45
←
Calling 'UnaryInstruction::getOperand'→
49
←
Returning from 'UnaryInstruction::getOperand'→
50
←
Returning pointer, which participates in a condition later→
202 
203    return nullptr;
204  };
205 
206  // Both operands of the subtract should be extends from vXi8.
207  Value *Op0 = getZeroExtendedVal(Sub->getOperand(0));
26
←
Calling 'operator()'→
38
←
Returning from 'operator()'→
208  Value *Op1 = getZeroExtendedVal(Sub->getOperand(1));
39
←
Calling 'operator()'→
51
←
Returning from 'operator()'→
209  if (!Op051.1
'Op0' is non-null
51.1
'Op0' is non-null
51.1
'Op0' is non-null
 || !Op151.2
'Op1' is non-null
51.2
'Op1' is non-null
51.2
'Op1' is non-null
)
52
←
Taking false branch→
210    return false;
211 
212  IRBuilder<> Builder(SI);
213 
214  auto *OpTy = cast<FixedVectorType>(Op->getType());
53
←
The object is a 'FixedVectorType'→
215  unsigned NumElts = OpTy->getNumElements();
216 
217  unsigned IntrinsicNumElts;
218  Intrinsic::ID IID;
219  if (ST->hasBWI() && NumElts >= 64) {
54
←
Assuming the condition is false→
220    IID = Intrinsic::x86_avx512_psad_bw_512;
221    IntrinsicNumElts = 64;
222  } else if (ST->hasAVX2() && NumElts >= 32) {
223    IID = Intrinsic::x86_avx2_psad_bw;
224    IntrinsicNumElts = 32;
225  } else {
226    IID = Intrinsic::x86_sse2_psad_bw;
227    IntrinsicNumElts = 16;
228  }
229 
230  Function *PSADBWFn = Intrinsic::getDeclaration(SI->getModule(), IID);
231 
232  if (NumElts < 16) {
55
←
Assuming 'NumElts' is >= 16→
56
←
Taking false branch→
233    // Pad input with zeroes.
234    SmallVector<int, 32> ConcatMask(16);
235    for (unsigned i = 0; i != NumElts; ++i)
236      ConcatMask[i] = i;
237    for (unsigned i = NumElts; i != 16; ++i)
238      ConcatMask[i] = (i % NumElts) + NumElts;
239 
240    Value *Zero = Constant::getNullValue(Op0->getType());
241    Op0 = Builder.CreateShuffleVector(Op0, Zero, ConcatMask);
242    Op1 = Builder.CreateShuffleVector(Op1, Zero, ConcatMask);
243    NumElts = 16;
244  }
245 
246  // Intrinsics produce vXi64 and need to be casted to vXi32.
247  auto *I32Ty =
248      FixedVectorType::get(Builder.getInt32Ty(), IntrinsicNumElts / 4);
249 
250  assert(NumElts % IntrinsicNumElts == 0 && "Unexpected number of elements!")(static_cast <bool> (NumElts % IntrinsicNumElts == 0 &&
 "Unexpected number of elements!") ? void (0) : __assert_fail
 ("NumElts % IntrinsicNumElts == 0 && \"Unexpected number of elements!\""
, "/build/llvm-toolchain-snapshot-13~++20210722111111+b115c038d2d4/llvm/lib/Target/X86/X86PartialReduction.cpp"
, 250, __extension__ __PRETTY_FUNCTION__));
57
←
Assuming the condition is true→
58
←
'?' condition is true→
251  unsigned NumSplits = NumElts / IntrinsicNumElts;
252 
253  // First collect the pieces we need.
254  SmallVector<Value *, 4> Ops(NumSplits);
255  for (unsigned i = 0; i != NumSplits; ++i) {
59
←
Assuming 'i' is not equal to 'NumSplits'→
60
←
Loop condition is true.  Entering loop body→
61
←
Assuming 'i' is equal to 'NumSplits'→
62
←
Loop condition is false. Execution continues on line 264→
256    SmallVector<int, 64> ExtractMask(IntrinsicNumElts);
257    std::iota(ExtractMask.begin(), ExtractMask.end(), i * IntrinsicNumElts);
258    Value *ExtractOp0 = Builder.CreateShuffleVector(Op0, Op0, ExtractMask);
259    Value *ExtractOp1 = Builder.CreateShuffleVector(Op1, Op0, ExtractMask);
260    Ops[i] = Builder.CreateCall(PSADBWFn, {ExtractOp0, ExtractOp1});
261    Ops[i] = Builder.CreateBitCast(Ops[i], I32Ty);
262  }
263 
264  assert(isPowerOf2_32(NumSplits) && "Expected power of 2 splits")(static_cast <bool> (isPowerOf2_32(NumSplits) &&
 "Expected power of 2 splits") ? void (0) : __assert_fail ("isPowerOf2_32(NumSplits) && \"Expected power of 2 splits\""
, "/build/llvm-toolchain-snapshot-13~++20210722111111+b115c038d2d4/llvm/lib/Target/X86/X86PartialReduction.cpp"
, 264, __extension__ __PRETTY_FUNCTION__));
63
←
'?' condition is true→
265  unsigned Stages = Log2_32(NumSplits);
266  for (unsigned s = Stages; s > 0; --s) {
64
←
Assuming 's' is <= 0→
65
←
Loop condition is false. Execution continues on line 278→
267    unsigned NumConcatElts =
268        cast<FixedVectorType>(Ops[0]->getType())->getNumElements() * 2;
269    for (unsigned i = 0; i != 1U << (s - 1); ++i) {
270      SmallVector<int, 64> ConcatMask(NumConcatElts);
271      std::iota(ConcatMask.begin(), ConcatMask.end(), 0);
272      Ops[i] = Builder.CreateShuffleVector(Ops[i*2], Ops[i*2+1], ConcatMask);
273    }
274  }
275 
276  // At this point the final value should be in Ops[0]. Now we need to adjust
277  // it to the final original type.
278  NumElts = cast<FixedVectorType>(OpTy)->getNumElements();
66
←
'OpTy' is a 'FixedVectorType'→
279  if (NumElts66.1
'NumElts' is not equal to 2
66.1
'NumElts' is not equal to 2
66.1
'NumElts' is not equal to 2
 == 2) {
67
←
Taking false branch→
280    // Extract down to 2 elements.
281    Ops[0] = Builder.CreateShuffleVector(Ops[0], Ops[0], ArrayRef<int>{0, 1});
282  } else if (NumElts67.1
'NumElts' is >= 8
67.1
'NumElts' is >= 8
67.1
'NumElts' is >= 8
 >= 8) {
68
←
Taking true branch→
283    SmallVector<int, 32> ConcatMask(NumElts);
284    unsigned SubElts =
70
←
'SubElts' initialized here→
285        cast<FixedVectorType>(Ops[0]->getType())->getNumElements();
69
←
The object is a 'FixedVectorType'→
286    for (unsigned i = 0; i != SubElts; ++i)
71
←
Assuming 'i' is equal to 'SubElts'→
72
←
Loop condition is false. Execution continues on line 288→
287      ConcatMask[i] = i;
288    for (unsigned i = SubElts; i72.1
'i' is not equal to 'NumElts'
72.1
'i' is not equal to 'NumElts'
72.1
'i' is not equal to 'NumElts'
 != NumElts; ++i)
73
←
Loop condition is true.  Entering loop body→
289      ConcatMask[i] = (i % SubElts) + SubElts;
74
←
Division by zero
290 
291    Value *Zero = Constant::getNullValue(Ops[0]->getType());
292    Ops[0] = Builder.CreateShuffleVector(Ops[0], Zero, ConcatMask);
293  }
294 
295  SI->replaceAllUsesWith(Ops[0]);
296  SI->eraseFromParent();
297 
298  return true;
299}
300 
301// Walk backwards from the ExtractElementInst and determine if it is the end of
302// a horizontal reduction. Return the input to the reduction if we find one.
303static Value *matchAddReduction(const ExtractElementInst &EE) {
304  // Make sure we're extracting index 0.
305  auto *Index = dyn_cast<ConstantInt>(EE.getIndexOperand());
306  if (!Index || !Index->isNullValue())
307    return nullptr;
308 
309  const auto *BO = dyn_cast<BinaryOperator>(EE.getVectorOperand());
310  if (!BO || BO->getOpcode() != Instruction::Add || !BO->hasOneUse())
311    return nullptr;
312 
313  unsigned NumElems = cast<FixedVectorType>(BO->getType())->getNumElements();
314  // Ensure the reduction size is a power of 2.
315  if (!isPowerOf2_32(NumElems))
316    return nullptr;
317 
318  const Value *Op = BO;
319  unsigned Stages = Log2_32(NumElems);
320  for (unsigned i = 0; i != Stages; ++i) {
321    const auto *BO = dyn_cast<BinaryOperator>(Op);
322    if (!BO || BO->getOpcode() != Instruction::Add)
323      return nullptr;
324 
325    // If this isn't the first add, then it should only have 2 users, the
326    // shuffle and another add which we checked in the previous iteration.
327    if (i != 0 && !BO->hasNUses(2))
328      return nullptr;
329 
330    Value *LHS = BO->getOperand(0);
331    Value *RHS = BO->getOperand(1);
332 
333    auto *Shuffle = dyn_cast<ShuffleVectorInst>(LHS);
334    if (Shuffle) {
335      Op = RHS;
336    } else {
337      Shuffle = dyn_cast<ShuffleVectorInst>(RHS);
338      Op = LHS;
339    }
340 
341    // The first operand of the shuffle should be the same as the other operand
342    // of the bin op.
343    if (!Shuffle || Shuffle->getOperand(0) != Op)
344      return nullptr;
345 
346    // Verify the shuffle has the expected (at this stage of the pyramid) mask.
347    unsigned MaskEnd = 1 << i;
348    for (unsigned Index = 0; Index < MaskEnd; ++Index)
349      if (Shuffle->getMaskValue(Index) != (int)(MaskEnd + Index))
350        return nullptr;
351  }
352 
353  return const_cast<Value *>(Op);
354}
355 
356// See if this BO is reachable from this Phi by walking forward through single
357// use BinaryOperators with the same opcode. If we get back then we know we've
358// found a loop and it is safe to step through this Add to find more leaves.
359static bool isReachableFromPHI(PHINode *Phi, BinaryOperator *BO) {
360  // The PHI itself should only have one use.
361  if (!Phi->hasOneUse())
362    return false;
363 
364  Instruction *U = cast<Instruction>(*Phi->user_begin());
365  if (U == BO)
366    return true;
367 
368  while (U->hasOneUse() && U->getOpcode() == BO->getOpcode())
369    U = cast<Instruction>(*U->user_begin());
370 
371  return U == BO;
372}
373 
374// Collect all the leaves of the tree of adds that feeds into the horizontal
375// reduction. Root is the Value that is used by the horizontal reduction.
376// We look through single use phis, single use adds, or adds that are used by
377// a phi that forms a loop with the add.
378static void collectLeaves(Value *Root, SmallVectorImpl<Instruction *> &Leaves) {
379  SmallPtrSet<Value *, 8> Visited;
380  SmallVector<Value *, 8> Worklist;
381  Worklist.push_back(Root);
382 
383  while (!Worklist.empty()) {
384    Value *V = Worklist.pop_back_val();
385     if (!Visited.insert(V).second)
386       continue;
387 
388    if (auto *PN = dyn_cast<PHINode>(V)) {
389      // PHI node should have single use unless it is the root node, then it
390      // has 2 uses.
391      if (!PN->hasNUses(PN == Root ? 2 : 1))
392        break;
393 
394      // Push incoming values to the worklist.
395      append_range(Worklist, PN->incoming_values());
396 
397      continue;
398    }
399 
400    if (auto *BO = dyn_cast<BinaryOperator>(V)) {
401      if (BO->getOpcode() == Instruction::Add) {
402        // Simple case. Single use, just push its operands to the worklist.
403        if (BO->hasNUses(BO == Root ? 2 : 1)) {
404          append_range(Worklist, BO->operands());
405          continue;
406        }
407 
408        // If there is additional use, make sure it is an unvisited phi that
409        // gets us back to this node.
410        if (BO->hasNUses(BO == Root ? 3 : 2)) {
411          PHINode *PN = nullptr;
412          for (auto *U : Root->users())
413            if (auto *P = dyn_cast<PHINode>(U))
414              if (!Visited.count(P))
415                PN = P;
416 
417          // If we didn't find a 2-input PHI then this isn't a case we can
418          // handle.
419          if (!PN || PN->getNumIncomingValues() != 2)
420            continue;
421 
422          // Walk forward from this phi to see if it reaches back to this add.
423          if (!isReachableFromPHI(PN, BO))
424            continue;
425 
426          // The phi forms a loop with this Add, push its operands.
427          append_range(Worklist, BO->operands());
428        }
429      }
430    }
431 
432    // Not an add or phi, make it a leaf.
433    if (auto *I = dyn_cast<Instruction>(V)) {
434      if (!V->hasNUses(I == Root ? 2 : 1))
435        continue;
436 
437      // Add this as a leaf.
438      Leaves.push_back(I);
439    }
440  }
441}
442 
443bool X86PartialReduction::runOnFunction(Function &F) {
444  if (skipFunction(F))
1
Assuming the condition is false→
2
←
Taking false branch→
445    return false;
446 
447  auto *TPC = getAnalysisIfAvailable<TargetPassConfig>();
448  if (!TPC)
3
←
Assuming 'TPC' is non-null→
4
←
Taking false branch→
449    return false;
450 
451  auto &TM = TPC->getTM<X86TargetMachine>();
452  ST = TM.getSubtargetImpl(F);
453 
454  DL = &F.getParent()->getDataLayout();
455 
456  bool MadeChange = false;
457  for (auto &BB : F) {
458    for (auto &I : BB) {
459      auto *EE = dyn_cast<ExtractElementInst>(&I);
5
←
Assuming the object is a 'ExtractElementInst'→
460      if (!EE5.1
'EE' is non-null
5.1
'EE' is non-null
5.1
'EE' is non-null
)
6
←
Taking false branch→
461        continue;
462 
463      // First find a reduction tree.
464      // FIXME: Do we need to handle other opcodes than Add?
465      Value *Root = matchAddReduction(*EE);
466      if (!Root6.1
'Root' is non-null
6.1
'Root' is non-null
6.1
'Root' is non-null
)
7
←
Taking false branch→
467        continue;
468 
469      SmallVector<Instruction *, 8> Leaves;
470      collectLeaves(Root, Leaves);
471 
472      for (Instruction *I : Leaves) {
8
←
Assuming '__begin3' is not equal to '__end3'→
473        if (tryMAddReplacement(I)) {
9
←
Taking false branch→
474          MadeChange = true;
475          continue;
476        }
477 
478        // Don't do SAD matching on the root node. SelectionDAG already
479        // has support for that and currently generates better code.
480        if (I != Root && trySADReplacement(I))
10
←
Assuming 'I' is not equal to 'Root'→
11
←
Calling 'X86PartialReduction::trySADReplacement'→
481          MadeChange = true;
482      }
483    }
484  }
485 
486  return MadeChange;
487}

←

/build/llvm-toolchain-snapshot-13~++20210722111111+b115c038d2d4/llvm/lib/Target/X86/X86Subtarget.h

→

1//===-- X86Subtarget.h - Define Subtarget for the X86 ----------*- 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 declares the X86 specific subclass of TargetSubtargetInfo.
10//
11//===----------------------------------------------------------------------===//

13#ifndef LLVM_LIB_TARGET_X86_X86SUBTARGET_H
14#define LLVM_LIB_TARGET_X86_X86SUBTARGET_H

16#include "X86FrameLowering.h"
17#include "X86ISelLowering.h"
18#include "X86InstrInfo.h"
19#include "X86SelectionDAGInfo.h"
20#include "llvm/ADT/Triple.h"
21#include "llvm/CodeGen/TargetSubtargetInfo.h"
22#include "llvm/IR/CallingConv.h"
23#include <climits>
24#include <memory>

26#define GET_SUBTARGETINFO_HEADER
27#include "X86GenSubtargetInfo.inc"

29namespace llvm {

31class CallLowering;
32class GlobalValue;
33class InstructionSelector;
34class LegalizerInfo;
35class RegisterBankInfo;
36class StringRef;
37class TargetMachine;

39/// The X86 backend supports a number of different styles of PIC.
40///
41namespace PICStyles {

43enum class Style {
StubPIC,          // Used on i386-darwin in pic mode.
GOT,              // Used on 32 bit elf on when in pic mode.
RIPRel,           // Used on X86-64 when in pic mode.
None              // Set when not in pic mode.
48};

50} // end namespace PICStyles

52class X86Subtarget final : public X86GenSubtargetInfo {
// NOTE: Do not add anything new to this list. Coarse, CPU name based flags
// are not a good idea. We should be migrating away from these.
enum X86ProcFamilyEnum {
  Others,
  IntelAtom,
  IntelSLM
};

enum X86SSEEnum {
  NoSSE, SSE1, SSE2, SSE3, SSSE3, SSE41, SSE42, AVX, AVX2, AVX512F
};

enum X863DNowEnum {
  NoThreeDNow, MMX, ThreeDNow, ThreeDNowA
};

/// X86 processor family: Intel Atom, and others
X86ProcFamilyEnum X86ProcFamily = Others;

/// Which PIC style to use
PICStyles::Style PICStyle;

const TargetMachine &TM;

/// SSE1, SSE2, SSE3, SSSE3, SSE41, SSE42, or none supported.
X86SSEEnum X86SSELevel = NoSSE;

/// MMX, 3DNow, 3DNow Athlon, or none supported.
X863DNowEnum X863DNowLevel = NoThreeDNow;

/// True if the processor supports X87 instructions.
bool HasX87 = false;

/// True if the processor supports CMPXCHG8B.
bool HasCmpxchg8b = false;

/// True if this processor has NOPL instruction
/// (generally pentium pro+).
bool HasNOPL = false;

/// True if this processor has conditional move instructions
/// (generally pentium pro+).
bool HasCMov = false;

/// True if the processor supports X86-64 instructions.
bool HasX86_64 = false;

/// True if the processor supports POPCNT.
bool HasPOPCNT = false;

/// True if the processor supports SSE4A instructions.
bool HasSSE4A = false;

/// Target has AES instructions
bool HasAES = false;
bool HasVAES = false;

/// Target has FXSAVE/FXRESTOR instructions
bool HasFXSR = false;

/// Target has XSAVE instructions
bool HasXSAVE = false;

/// Target has XSAVEOPT instructions
bool HasXSAVEOPT = false;

/// Target has XSAVEC instructions
bool HasXSAVEC = false;

/// Target has XSAVES instructions
bool HasXSAVES = false;

/// Target has carry-less multiplication
bool HasPCLMUL = false;
bool HasVPCLMULQDQ = false;

/// Target has Galois Field Arithmetic instructions
bool HasGFNI = false;

/// Target has 3-operand fused multiply-add
bool HasFMA = false;

/// Target has 4-operand fused multiply-add
bool HasFMA4 = false;

/// Target has XOP instructions
bool HasXOP = false;

/// Target has TBM instructions.
bool HasTBM = false;

/// Target has LWP instructions
bool HasLWP = false;

/// True if the processor has the MOVBE instruction.
bool HasMOVBE = false;

/// True if the processor has the RDRAND instruction.
bool HasRDRAND = false;

/// Processor has 16-bit floating point conversion instructions.
bool HasF16C = false;

/// Processor has FS/GS base insturctions.
bool HasFSGSBase = false;

/// Processor has LZCNT instruction.
bool HasLZCNT = false;

/// Processor has BMI1 instructions.
bool HasBMI = false;

/// Processor has BMI2 instructions.
bool HasBMI2 = false;

/// Processor has VBMI instructions.
bool HasVBMI = false;

/// Processor has VBMI2 instructions.
bool HasVBMI2 = false;

/// Processor has Integer Fused Multiply Add
bool HasIFMA = false;

/// Processor has RTM instructions.
bool HasRTM = false;

/// Processor has ADX instructions.
bool HasADX = false;

/// Processor has SHA instructions.
bool HasSHA = false;

/// Processor has PRFCHW instructions.
bool HasPRFCHW = false;

/// Processor has RDSEED instructions.
bool HasRDSEED = false;

/// Processor has LAHF/SAHF instructions in 64-bit mode.
bool HasLAHFSAHF64 = false;

/// Processor has MONITORX/MWAITX instructions.
bool HasMWAITX = false;

/// Processor has Cache Line Zero instruction
bool HasCLZERO = false;

/// Processor has Cache Line Demote instruction
bool HasCLDEMOTE = false;

/// Processor has MOVDIRI instruction (direct store integer).
bool HasMOVDIRI = false;

/// Processor has MOVDIR64B instruction (direct store 64 bytes).
bool HasMOVDIR64B = false;

/// Processor has ptwrite instruction.
bool HasPTWRITE = false;

/// Processor has Prefetch with intent to Write instruction
bool HasPREFETCHWT1 = false;

/// True if SHLD instructions are slow.
bool IsSHLDSlow = false;

/// True if the PMULLD instruction is slow compared to PMULLW/PMULHW and
//  PMULUDQ.
bool IsPMULLDSlow = false;

/// True if the PMADDWD instruction is slow compared to PMULLD.
bool IsPMADDWDSlow = false;

/// True if unaligned memory accesses of 16-bytes are slow.
bool IsUAMem16Slow = false;

/// True if unaligned memory accesses of 32-bytes are slow.
bool IsUAMem32Slow = false;

/// True if SSE operations can have unaligned memory operands.
/// This may require setting a configuration bit in the processor.
bool HasSSEUnalignedMem = false;

/// True if this processor has the CMPXCHG16B instruction;
/// this is true for most x86-64 chips, but not the first AMD chips.
bool HasCmpxchg16b = false;

/// True if the LEA instruction should be used for adjusting
/// the stack pointer. This is an optimization for Intel Atom processors.
bool UseLeaForSP = false;

/// True if POPCNT instruction has a false dependency on the destination register.
bool HasPOPCNTFalseDeps = false;

/// True if LZCNT/TZCNT instructions have a false dependency on the destination register.
bool HasLZCNTFalseDeps = false;

/// True if its preferable to combine to a single cross-lane shuffle
/// using a variable mask over multiple fixed shuffles.
bool HasFastVariableCrossLaneShuffle = false;

/// True if its preferable to combine to a single per-lane shuffle
/// using a variable mask over multiple fixed shuffles.
bool HasFastVariablePerLaneShuffle = false;

/// True if vzeroupper instructions should be inserted after code that uses
/// ymm or zmm registers.
bool InsertVZEROUPPER = false;

/// True if there is no performance penalty for writing NOPs with up to
/// 7 bytes.
bool HasFast7ByteNOP = false;

/// True if there is no performance penalty for writing NOPs with up to
/// 11 bytes.
bool HasFast11ByteNOP = false;

/// True if there is no performance penalty for writing NOPs with up to
/// 15 bytes.
bool HasFast15ByteNOP = false;

/// True if gather is reasonably fast. This is true for Skylake client and
/// all AVX-512 CPUs.
bool HasFastGather = false;

/// True if hardware SQRTSS instruction is at least as fast (latency) as
/// RSQRTSS followed by a Newton-Raphson iteration.
bool HasFastScalarFSQRT = false;

/// True if hardware SQRTPS/VSQRTPS instructions are at least as fast
/// (throughput) as RSQRTPS/VRSQRTPS followed by a Newton-Raphson iteration.
bool HasFastVectorFSQRT = false;

/// True if 8-bit divisions are significantly faster than
/// 32-bit divisions and should be used when possible.
bool HasSlowDivide32 = false;

/// True if 32-bit divides are significantly faster than
/// 64-bit divisions and should be used when possible.
bool HasSlowDivide64 = false;

/// True if LZCNT instruction is fast.
bool HasFastLZCNT = false;

/// True if SHLD based rotate is fast.
bool HasFastSHLDRotate = false;

/// True if the processor supports macrofusion.
bool HasMacroFusion = false;

/// True if the processor supports branch fusion.
bool HasBranchFusion = false;

/// True if the processor has enhanced REP MOVSB/STOSB.
bool HasERMSB = false;

/// True if the processor has fast short REP MOV.
bool HasFSRM = false;

/// True if the short functions should be padded to prevent
/// a stall when returning too early.
bool PadShortFunctions = false;

/// True if two memory operand instructions should use a temporary register
/// instead.
bool SlowTwoMemOps = false;

/// True if the LEA instruction inputs have to be ready at address generation
/// (AG) time.
bool LEAUsesAG = false;

/// True if the LEA instruction with certain arguments is slow
bool SlowLEA = false;

/// True if the LEA instruction has all three source operands: base, index,
/// and offset or if the LEA instruction uses base and index registers where
/// the base is EBP, RBP,or R13
bool Slow3OpsLEA = false;

/// True if INC and DEC instructions are slow when writing to flags
bool SlowIncDec = false;

/// Processor has AVX-512 PreFetch Instructions
bool HasPFI = false;

/// Processor has AVX-512 Exponential and Reciprocal Instructions
bool HasERI = false;

/// Processor has AVX-512 Conflict Detection Instructions
bool HasCDI = false;

/// Processor has AVX-512 population count Instructions
bool HasVPOPCNTDQ = false;

/// Processor has AVX-512 Doubleword and Quadword instructions
bool HasDQI = false;

/// Processor has AVX-512 Byte and Word instructions
bool HasBWI = false;

/// Processor has AVX-512 Vector Length eXtenstions
bool HasVLX = false;

/// Processor has PKU extenstions
bool HasPKU = false;

/// Processor has AVX-512 Vector Neural Network Instructions
bool HasVNNI = false;

/// Processor has AVX Vector Neural Network Instructions
bool HasAVXVNNI = false;

/// Processor has AVX-512 bfloat16 floating-point extensions
bool HasBF16 = false;

/// Processor supports ENQCMD instructions
bool HasENQCMD = false;

/// Processor has AVX-512 Bit Algorithms instructions
bool HasBITALG = false;

/// Processor has AVX-512 vp2intersect instructions
bool HasVP2INTERSECT = false;

/// Processor supports CET SHSTK - Control-Flow Enforcement Technology
/// using Shadow Stack
bool HasSHSTK = false;

/// Processor supports Invalidate Process-Context Identifier
bool HasINVPCID = false;

/// Processor has Software Guard Extensions
bool HasSGX = false;

/// Processor supports Flush Cache Line instruction
bool HasCLFLUSHOPT = false;

/// Processor supports Cache Line Write Back instruction
bool HasCLWB = false;

/// Processor supports Write Back No Invalidate instruction
bool HasWBNOINVD = false;

/// Processor support RDPID instruction
bool HasRDPID = false;

/// Processor supports WaitPKG instructions
bool HasWAITPKG = false;

/// Processor supports PCONFIG instruction
bool HasPCONFIG = false;

/// Processor support key locker instructions
bool HasKL = false;

/// Processor support key locker wide instructions
bool HasWIDEKL = false;

/// Processor supports HRESET instruction
bool HasHRESET = false;

/// Processor supports SERIALIZE instruction
bool HasSERIALIZE = false;

/// Processor supports TSXLDTRK instruction
bool HasTSXLDTRK = false;

/// Processor has AMX support
bool HasAMXTILE = false;
bool HasAMXBF16 = false;
bool HasAMXINT8 = false;

/// Processor supports User Level Interrupt instructions
bool HasUINTR = false;

/// Processor has a single uop BEXTR implementation.
bool HasFastBEXTR = false;

/// Try harder to combine to horizontal vector ops if they are fast.
bool HasFastHorizontalOps = false;

/// Prefer a left/right scalar logical shifts pair over a shift+and pair.
bool HasFastScalarShiftMasks = false;

/// Prefer a left/right vector logical shifts pair over a shift+and pair.
bool HasFastVectorShiftMasks = false;

/// Prefer a movbe over a single-use load + bswap / single-use bswap + store.
bool HasFastMOVBE = false;

/// Use a retpoline thunk rather than indirect calls to block speculative
/// execution.
bool UseRetpolineIndirectCalls = false;

/// Use a retpoline thunk or remove any indirect branch to block speculative
/// execution.
bool UseRetpolineIndirectBranches = false;

/// Deprecated flag, query `UseRetpolineIndirectCalls` and
/// `UseRetpolineIndirectBranches` instead.
bool DeprecatedUseRetpoline = false;

/// When using a retpoline thunk, call an externally provided thunk rather
/// than emitting one inside the compiler.
bool UseRetpolineExternalThunk = false;

/// Prevent generation of indirect call/branch instructions from memory,
/// and force all indirect call/branch instructions from a register to be
/// preceded by an LFENCE. Also decompose RET instructions into a
/// POP+LFENCE+JMP sequence.
bool UseLVIControlFlowIntegrity = false;

/// Enable Speculative Execution Side Effect Suppression
bool UseSpeculativeExecutionSideEffectSuppression = false;

/// Insert LFENCE instructions to prevent data speculatively injected into
/// loads from being used maliciously.
bool UseLVILoadHardening = false;

/// Use software floating point for code generation.
bool UseSoftFloat = false;

/// Use alias analysis during code generation.
bool UseAA = false;

/// The minimum alignment known to hold of the stack frame on
/// entry to the function and which must be maintained by every function.
Align stackAlignment = Align(4);

Align TileConfigAlignment = Align(4);

/// Max. memset / memcpy size that is turned into rep/movs, rep/stos ops.
///
// FIXME: this is a known good value for Yonah. How about others?
unsigned MaxInlineSizeThreshold = 128;

/// Indicates target prefers 128 bit instructions.
bool Prefer128Bit = false;

/// Indicates target prefers 256 bit instructions.
bool Prefer256Bit = false;

/// Indicates target prefers AVX512 mask registers.
bool PreferMaskRegisters = false;

/// Use Goldmont specific floating point div/sqrt costs.
bool UseGLMDivSqrtCosts = false;

/// What processor and OS we're targeting.
Triple TargetTriple;

/// GlobalISel related APIs.
std::unique_ptr<CallLowering> CallLoweringInfo;
std::unique_ptr<LegalizerInfo> Legalizer;
std::unique_ptr<RegisterBankInfo> RegBankInfo;
std::unique_ptr<InstructionSelector> InstSelector;

510private:
/// Override the stack alignment.
MaybeAlign StackAlignOverride;

/// Preferred vector width from function attribute.
unsigned PreferVectorWidthOverride;

/// Resolved preferred vector width from function attribute and subtarget
/// features.
unsigned PreferVectorWidth = UINT32_MAX(4294967295U);

/// Required vector width from function attribute.
unsigned RequiredVectorWidth;

/// True if compiling for 64-bit, false for 16-bit or 32-bit.
bool In64BitMode = false;

/// True if compiling for 32-bit, false for 16-bit or 64-bit.
bool In32BitMode = false;

/// True if compiling for 16-bit, false for 32-bit or 64-bit.
bool In16BitMode = false;

X86SelectionDAGInfo TSInfo;
// Ordering here is important. X86InstrInfo initializes X86RegisterInfo which
// X86TargetLowering needs.
X86InstrInfo InstrInfo;
X86TargetLowering TLInfo;
X86FrameLowering FrameLowering;

540public:
/// This constructor initializes the data members to match that
/// of the specified triple.
///
X86Subtarget(const Triple &TT, StringRef CPU, StringRef TuneCPU, StringRef FS,
             const X86TargetMachine &TM, MaybeAlign StackAlignOverride,
             unsigned PreferVectorWidthOverride,
             unsigned RequiredVectorWidth);

const X86TargetLowering *getTargetLowering() const override {
  return &TLInfo;
}

const X86InstrInfo *getInstrInfo() const override { return &InstrInfo; }

const X86FrameLowering *getFrameLowering() const override {
  return &FrameLowering;
}

const X86SelectionDAGInfo *getSelectionDAGInfo() const override {
  return &TSInfo;
}

const X86RegisterInfo *getRegisterInfo() const override {
  return &getInstrInfo()->getRegisterInfo();
}

unsigned getTileConfigSize() const { return 64; }
Align getTileConfigAlignment() const { return TileConfigAlignment; }

/// Returns the minimum alignment known to hold of the
/// stack frame on entry to the function and which must be maintained by every
/// function for this subtarget.
Align getStackAlignment() const { return stackAlignment; }

/// Returns the maximum memset / memcpy size
/// that still makes it profitable to inline the call.
unsigned getMaxInlineSizeThreshold() const { return MaxInlineSizeThreshold; }

/// ParseSubtargetFeatures - Parses features string setting specified
/// subtarget options.  Definition of function is auto generated by tblgen.
void ParseSubtargetFeatures(StringRef CPU, StringRef TuneCPU, StringRef FS);

/// Methods used by Global ISel
const CallLowering *getCallLowering() const override;
InstructionSelector *getInstructionSelector() const override;
const LegalizerInfo *getLegalizerInfo() const override;
const RegisterBankInfo *getRegBankInfo() const override;

589private:
/// Initialize the full set of dependencies so we can use an initializer
/// list for X86Subtarget.
X86Subtarget &initializeSubtargetDependencies(StringRef CPU,
                                              StringRef TuneCPU,
                                              StringRef FS);
void initSubtargetFeatures(StringRef CPU, StringRef TuneCPU, StringRef FS);

597public:
/// Is this x86_64? (disregarding specific ABI / programming model)
bool is64Bit() const {
  return In64BitMode;
}

bool is32Bit() const {
  return In32BitMode;
}

bool is16Bit() const {
  return In16BitMode;
}

/// Is this x86_64 with the ILP32 programming model (x32 ABI)?
bool isTarget64BitILP32() const {
  return In64BitMode && (TargetTriple.isX32() || TargetTriple.isOSNaCl());
}

/// Is this x86_64 with the LP64 programming model (standard AMD64, no x32)?
bool isTarget64BitLP64() const {
  return In64BitMode && (!TargetTriple.isX32() && !TargetTriple.isOSNaCl());
}

PICStyles::Style getPICStyle() const { return PICStyle; }
void setPICStyle(PICStyles::Style Style)  { PICStyle = Style; }

bool hasX87() const { return HasX87; }
bool hasCmpxchg8b() const { return HasCmpxchg8b; }
bool hasNOPL() const { return HasNOPL; }
// SSE codegen depends on cmovs, and all SSE1+ processors support them.
// All 64-bit processors support cmov.
bool hasCMov() const { return HasCMov || X86SSELevel >= SSE1 || is64Bit(); }
bool hasSSE1() const { return X86SSELevel >= SSE1; }
bool hasSSE2() const { return X86SSELevel12.1
Field 'X86SSELevel' is >= SSE2
1
Field 'X86SSELevel' is >= SSE2
1
Field 'X86SSELevel' is >= SSE2
 >= SSE2; }
13
←
Returning the value 1, which participates in a condition later→
bool hasSSE3() const { return X86SSELevel >= SSE3; }
bool hasSSSE3() const { return X86SSELevel >= SSSE3; }
bool hasSSE41() const { return X86SSELevel >= SSE41; }
bool hasSSE42() const { return X86SSELevel >= SSE42; }
bool hasAVX() const { return X86SSELevel >= AVX; }
bool hasAVX2() const { return X86SSELevel >= AVX2; }
bool hasAVX512() const { return X86SSELevel >= AVX512F; }
bool hasInt256() const { return hasAVX2(); }
bool hasSSE4A() const { return HasSSE4A; }
bool hasMMX() const { return X863DNowLevel >= MMX; }
bool has3DNow() const { return X863DNowLevel >= ThreeDNow; }
bool has3DNowA() const { return X863DNowLevel >= ThreeDNowA; }
bool hasPOPCNT() const { return HasPOPCNT; }
bool hasAES() const { return HasAES; }
bool hasVAES() const { return HasVAES; }
bool hasFXSR() const { return HasFXSR; }
bool hasXSAVE() const { return HasXSAVE; }
bool hasXSAVEOPT() const { return HasXSAVEOPT; }
bool hasXSAVEC() const { return HasXSAVEC; }
bool hasXSAVES() const { return HasXSAVES; }
bool hasPCLMUL() const { return HasPCLMUL; }
bool hasVPCLMULQDQ() const { return HasVPCLMULQDQ; }
bool hasGFNI() const { return HasGFNI; }
// Prefer FMA4 to FMA - its better for commutation/memory folding and
// has equal or better performance on all supported targets.
bool hasFMA() const { return HasFMA; }
bool hasFMA4() const { return HasFMA4; }
bool hasAnyFMA() const { return hasFMA() || hasFMA4(); }
bool hasXOP() const { return HasXOP; }
bool hasTBM() const { return HasTBM; }
bool hasLWP() const { return HasLWP; }
bool hasMOVBE() const { return HasMOVBE; }
bool hasRDRAND() const { return HasRDRAND; }
bool hasF16C() const { return HasF16C; }
bool hasFSGSBase() const { return HasFSGSBase; }
bool hasLZCNT() const { return HasLZCNT; }
bool hasBMI() const { return HasBMI; }
bool hasBMI2() const { return HasBMI2; }
bool hasVBMI() const { return HasVBMI; }
bool hasVBMI2() const { return HasVBMI2; }
bool hasIFMA() const { return HasIFMA; }
bool hasRTM() const { return HasRTM; }
bool hasADX() const { return HasADX; }
bool hasSHA() const { return HasSHA; }
bool hasPRFCHW() const { return HasPRFCHW; }
bool hasPREFETCHWT1() const { return HasPREFETCHWT1; }
bool hasPrefetchW() const {
  // The PREFETCHW instruction was added with 3DNow but later CPUs gave it
  // its own CPUID bit as part of deprecating 3DNow. Intel eventually added
  // it and KNL has another that prefetches to L2 cache. We assume the
  // L1 version exists if the L2 version does.
  return has3DNow() || hasPRFCHW() || hasPREFETCHWT1();
}
bool hasSSEPrefetch() const {
  // We implicitly enable these when we have a write prefix supporting cache
  // level OR if we have prfchw, but don't already have a read prefetch from
  // 3dnow.
  return hasSSE1() || (hasPRFCHW() && !has3DNow()) || hasPREFETCHWT1();
}
bool hasRDSEED() const { return HasRDSEED; }
bool hasLAHFSAHF() const { return HasLAHFSAHF64 || !is64Bit(); }
bool hasMWAITX() const { return HasMWAITX; }
bool hasCLZERO() const { return HasCLZERO; }
bool hasCLDEMOTE() const { return HasCLDEMOTE; }
bool hasMOVDIRI() const { return HasMOVDIRI; }
bool hasMOVDIR64B() const { return HasMOVDIR64B; }
bool hasPTWRITE() const { return HasPTWRITE; }
bool isSHLDSlow() const { return IsSHLDSlow; }
bool isPMULLDSlow() const { return IsPMULLDSlow; }
bool isPMADDWDSlow() const { return IsPMADDWDSlow; }
bool isUnalignedMem16Slow() const { return IsUAMem16Slow; }
bool isUnalignedMem32Slow() const { return IsUAMem32Slow; }
bool hasSSEUnalignedMem() const { return HasSSEUnalignedMem; }
bool hasCmpxchg16b() const { return HasCmpxchg16b && is64Bit(); }
bool useLeaForSP() const { return UseLeaForSP; }
bool hasPOPCNTFalseDeps() const { return HasPOPCNTFalseDeps; }
bool hasLZCNTFalseDeps() const { return HasLZCNTFalseDeps; }
bool hasFastVariableCrossLaneShuffle() const {
  return HasFastVariableCrossLaneShuffle;
}
bool hasFastVariablePerLaneShuffle() const {
  return HasFastVariablePerLaneShuffle;
}
bool insertVZEROUPPER() const { return InsertVZEROUPPER; }
bool hasFastGather() const { return HasFastGather; }
bool hasFastScalarFSQRT() const { return HasFastScalarFSQRT; }
bool hasFastVectorFSQRT() const { return HasFastVectorFSQRT; }
bool hasFastLZCNT() const { return HasFastLZCNT; }
bool hasFastSHLDRotate() const { return HasFastSHLDRotate; }
bool hasFastBEXTR() const { return HasFastBEXTR; }
bool hasFastHorizontalOps() const { return HasFastHorizontalOps; }
bool hasFastScalarShiftMasks() const { return HasFastScalarShiftMasks; }
bool hasFastVectorShiftMasks() const { return HasFastVectorShiftMasks; }
bool hasFastMOVBE() const { return HasFastMOVBE; }
bool hasMacroFusion() const { return HasMacroFusion; }
bool hasBranchFusion() const { return HasBranchFusion; }
bool hasERMSB() const { return HasERMSB; }
bool hasFSRM() const { return HasFSRM; }
bool hasSlowDivide32() const { return HasSlowDivide32; }
bool hasSlowDivide64() const { return HasSlowDivide64; }
bool padShortFunctions() const { return PadShortFunctions; }
bool slowTwoMemOps() const { return SlowTwoMemOps; }
bool LEAusesAG() const { return LEAUsesAG; }
bool slowLEA() const { return SlowLEA; }
bool slow3OpsLEA() const { return Slow3OpsLEA; }
bool slowIncDec() const { return SlowIncDec; }
bool hasCDI() const { return HasCDI; }
bool hasVPOPCNTDQ() const { return HasVPOPCNTDQ; }
bool hasPFI() const { return HasPFI; }
bool hasERI() const { return HasERI; }
bool hasDQI() const { return HasDQI; }
bool hasBWI() const { return HasBWI; }
bool hasVLX() const { return HasVLX; }
bool hasPKU() const { return HasPKU; }
bool hasVNNI() const { return HasVNNI; }
bool hasBF16() const { return HasBF16; }
bool hasVP2INTERSECT() const { return HasVP2INTERSECT; }
bool hasBITALG() const { return HasBITALG; }
bool hasSHSTK() const { return HasSHSTK; }
bool hasCLFLUSHOPT() const { return HasCLFLUSHOPT; }
bool hasCLWB() const { return HasCLWB; }
bool hasWBNOINVD() const { return HasWBNOINVD; }
bool hasRDPID() const { return HasRDPID; }
bool hasWAITPKG() const { return HasWAITPKG; }
bool hasPCONFIG() const { return HasPCONFIG; }
bool hasSGX() const { return HasSGX; }
bool hasINVPCID() const { return HasINVPCID; }
bool hasENQCMD() const { return HasENQCMD; }
bool hasKL() const { return HasKL; }
bool hasWIDEKL() const { return HasWIDEKL; }
bool hasHRESET() const { return HasHRESET; }
bool hasSERIALIZE() const { return HasSERIALIZE; }
bool hasTSXLDTRK() const { return HasTSXLDTRK; }
bool hasUINTR() const { return HasUINTR; }
bool useRetpolineIndirectCalls() const { return UseRetpolineIndirectCalls; }
bool useRetpolineIndirectBranches() const {
  return UseRetpolineIndirectBranches;
}
bool hasAVXVNNI() const { return HasAVXVNNI; }
bool hasAMXTILE() const { return HasAMXTILE; }
bool hasAMXBF16() const { return HasAMXBF16; }
bool hasAMXINT8() const { return HasAMXINT8; }
bool useRetpolineExternalThunk() const { return UseRetpolineExternalThunk; }

// These are generic getters that OR together all of the thunk types
// supported by the subtarget. Therefore useIndirectThunk*() will return true
// if any respective thunk feature is enabled.
bool useIndirectThunkCalls() const {
  return useRetpolineIndirectCalls() || useLVIControlFlowIntegrity();
}
bool useIndirectThunkBranches() const {
  return useRetpolineIndirectBranches() || useLVIControlFlowIntegrity();
}

bool preferMaskRegisters() const { return PreferMaskRegisters; }
bool useGLMDivSqrtCosts() const { return UseGLMDivSqrtCosts; }
bool useLVIControlFlowIntegrity() const { return UseLVIControlFlowIntegrity; }
bool useLVILoadHardening() const { return UseLVILoadHardening; }
bool useSpeculativeExecutionSideEffectSuppression() const {
  return UseSpeculativeExecutionSideEffectSuppression;
}

unsigned getPreferVectorWidth() const { return PreferVectorWidth; }
unsigned getRequiredVectorWidth() const { return RequiredVectorWidth; }

// Helper functions to determine when we should allow widening to 512-bit
// during codegen.
// TODO: Currently we're always allowing widening on CPUs without VLX,
// because for many cases we don't have a better option.
bool canExtendTo512DQ() const {
  return hasAVX512() && (!hasVLX() || getPreferVectorWidth() >= 512);
}
bool canExtendTo512BW() const  {
  return hasBWI() && canExtendTo512DQ();
}

// If there are no 512-bit vectors and we prefer not to use 512-bit registers,
// disable them in the legalizer.
bool useAVX512Regs() const {
  return hasAVX512() && (canExtendTo512DQ() || RequiredVectorWidth > 256);
}

bool useBWIRegs() const {
  return hasBWI() && useAVX512Regs();
}

bool isXRaySupported() const override { return is64Bit(); }

/// TODO: to be removed later and replaced with suitable properties
bool isAtom() const { return X86ProcFamily == IntelAtom; }
bool isSLM() const { return X86ProcFamily == IntelSLM; }
bool useSoftFloat() const { return UseSoftFloat; }
bool useAA() const override { return UseAA; }

/// Use mfence if we have SSE2 or we're on x86-64 (even if we asked for
/// no-sse2). There isn't any reason to disable it if the target processor
/// supports it.
bool hasMFence() const { return hasSSE2() || is64Bit(); }

const Triple &getTargetTriple() const { return TargetTriple; }

bool isTargetDarwin() const { return TargetTriple.isOSDarwin(); }
bool isTargetFreeBSD() const { return TargetTriple.isOSFreeBSD(); }
bool isTargetDragonFly() const { return TargetTriple.isOSDragonFly(); }
bool isTargetSolaris() const { return TargetTriple.isOSSolaris(); }
bool isTargetPS4() const { return TargetTriple.isPS4CPU(); }

bool isTargetELF() const { return TargetTriple.isOSBinFormatELF(); }
bool isTargetCOFF() const { return TargetTriple.isOSBinFormatCOFF(); }
bool isTargetMachO() const { return TargetTriple.isOSBinFormatMachO(); }

bool isTargetLinux() const { return TargetTriple.isOSLinux(); }
bool isTargetKFreeBSD() const { return TargetTriple.isOSKFreeBSD(); }
bool isTargetGlibc() const { return TargetTriple.isOSGlibc(); }
bool isTargetAndroid() const { return TargetTriple.isAndroid(); }
bool isTargetNaCl() const { return TargetTriple.isOSNaCl(); }
bool isTargetNaCl32() const { return isTargetNaCl() && !is64Bit(); }
bool isTargetNaCl64() const { return isTargetNaCl() && is64Bit(); }
bool isTargetMCU() const { return TargetTriple.isOSIAMCU(); }
bool isTargetFuchsia() const { return TargetTriple.isOSFuchsia(); }

bool isTargetWindowsMSVC() const {
  return TargetTriple.isWindowsMSVCEnvironment();
}

bool isTargetWindowsCoreCLR() const {
  return TargetTriple.isWindowsCoreCLREnvironment();
}

bool isTargetWindowsCygwin() const {
  return TargetTriple.isWindowsCygwinEnvironment();
}

bool isTargetWindowsGNU() const {
  return TargetTriple.isWindowsGNUEnvironment();
}

bool isTargetWindowsItanium() const {
  return TargetTriple.isWindowsItaniumEnvironment();
}

bool isTargetCygMing() const { return TargetTriple.isOSCygMing(); }

bool isOSWindows() const { return TargetTriple.isOSWindows(); }

bool isTargetWin64() const { return In64BitMode && isOSWindows(); }

bool isTargetWin32() const { return !In64BitMode && isOSWindows(); }

bool isPICStyleGOT() const { return PICStyle == PICStyles::Style::GOT; }
bool isPICStyleRIPRel() const { return PICStyle == PICStyles::Style::RIPRel; }

bool isPICStyleStubPIC() const {
  return PICStyle == PICStyles::Style::StubPIC;
}

bool isPositionIndependent() const;

bool isCallingConvWin64(CallingConv::ID CC) const {
  switch (CC) {
  // On Win64, all these conventions just use the default convention.
  case CallingConv::C:
  case CallingConv::Fast:
  case CallingConv::Tail:
  case CallingConv::Swift:
  case CallingConv::SwiftTail:
  case CallingConv::X86_FastCall:
  case CallingConv::X86_StdCall:
  case CallingConv::X86_ThisCall:
  case CallingConv::X86_VectorCall:
  case CallingConv::Intel_OCL_BI:
    return isTargetWin64();
  // This convention allows using the Win64 convention on other targets.
  case CallingConv::Win64:
    return true;
  // This convention allows using the SysV convention on Windows targets.
  case CallingConv::X86_64_SysV:
    return false;
  // Otherwise, who knows what this is.
  default:
    return false;
  }
}

/// Classify a global variable reference for the current subtarget according
/// to how we should reference it in a non-pcrel context.
unsigned char classifyLocalReference(const GlobalValue *GV) const;

unsigned char classifyGlobalReference(const GlobalValue *GV,
                                      const Module &M) const;
unsigned char classifyGlobalReference(const GlobalValue *GV) const;

/// Classify a global function reference for the current subtarget.
unsigned char classifyGlobalFunctionReference(const GlobalValue *GV,
                                              const Module &M) const;
unsigned char classifyGlobalFunctionReference(const GlobalValue *GV) const;

/// Classify a blockaddress reference for the current subtarget according to
/// how we should reference it in a non-pcrel context.
unsigned char classifyBlockAddressReference() const;

/// Return true if the subtarget allows calls to immediate address.
bool isLegalToCallImmediateAddr() const;

/// If we are using indirect thunks, we need to expand indirectbr to avoid it
/// lowering to an actual indirect jump.
bool enableIndirectBrExpand() const override {
  return useIndirectThunkBranches();
}

/// Enable the MachineScheduler pass for all X86 subtargets.
bool enableMachineScheduler() const override { return true; }

bool enableEarlyIfConversion() const override;

void getPostRAMutations(std::vector<std::unique_ptr<ScheduleDAGMutation>>
                            &Mutations) const override;

AntiDepBreakMode getAntiDepBreakMode() const override {
  return TargetSubtargetInfo::ANTIDEP_CRITICAL;
}

bool enableAdvancedRASplitCost() const override { return false; }
955};

957} // end namespace llvm

959#endif // LLVM_LIB_TARGET_X86_X86SUBTARGET_H

←

/build/llvm-toolchain-snapshot-13~++20210722111111+b115c038d2d4/llvm/include/llvm/IR/InstrTypes.h

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

15#ifndef LLVM_IR_INSTRTYPES_H
16#define LLVM_IR_INSTRTYPES_H

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

47namespace llvm {

49namespace Intrinsic {
50typedef unsigned ID;
51}

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

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

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

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

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

91template <>
92struct OperandTraits<UnaryInstruction> :
public FixedNumOperandTraits<UnaryInstruction, 1> {
94};

96DEFINE_TRANSPARENT_OPERAND_ACCESSORS(UnaryInstruction, Value)UnaryInstruction::op_iterator UnaryInstruction::op_begin() { return
 OperandTraits<UnaryInstruction>::op_begin(this); } UnaryInstruction
::const_op_iterator UnaryInstruction::op_begin() const { return
 OperandTraits<UnaryInstruction>::op_begin(const_cast<
UnaryInstruction*>(this)); } UnaryInstruction::op_iterator
 UnaryInstruction::op_end() { return OperandTraits<UnaryInstruction
>::op_end(this); } UnaryInstruction::const_op_iterator UnaryInstruction
::op_end() const { return OperandTraits<UnaryInstruction>
::op_end(const_cast<UnaryInstruction*>(this)); } Value *
UnaryInstruction::getOperand(unsigned i_nocapture) const { (static_cast
 <bool> (i_nocapture < OperandTraits<UnaryInstruction
>::operands(this) && "getOperand() out of range!")
 ? void (0) : __assert_fail ("i_nocapture < OperandTraits<UnaryInstruction>::operands(this) && \"getOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-13~++20210722111111+b115c038d2d4/llvm/include/llvm/IR/InstrTypes.h"
, 96, __extension__ __PRETTY_FUNCTION__)); return cast_or_null
<Value>( OperandTraits<UnaryInstruction>::op_begin
(const_cast<UnaryInstruction*>(this))[i_nocapture].get(
)); } void UnaryInstruction::setOperand(unsigned i_nocapture,
 Value *Val_nocapture) { (static_cast <bool> (i_nocapture
 < OperandTraits<UnaryInstruction>::operands(this) &&
 "setOperand() out of range!") ? void (0) : __assert_fail ("i_nocapture < OperandTraits<UnaryInstruction>::operands(this) && \"setOperand() out of range!\""
, "/build/llvm-toolchain-snapshot-13~++20210722111111+b115c038d2d4/llvm/include/llvm/IR/InstrTypes.h"
, 96, __extension__ __PRETTY_FUNCTION__)); OperandTraits<UnaryInstruction
>::op_begin(this)[i_nocapture] = Val_nocapture; } unsigned
 UnaryInstruction::getNumOperands() const { return OperandTraits
<UnaryInstruction>::operands(this); } template <int Idx_nocapture
> Use &UnaryInstruction::Op() { return this->OpFrom
<Idx_nocapture>(this); } template <int Idx_nocapture
> const Use &UnaryInstruction::Op() const { return this
->OpFrom<Idx_nocapture>(this); }
33
←
'?' condition is true→
34
←
The object is a 'Value'→
35
←
Returning pointer, which participates in a condition later→
46
←
'?' condition is true→
47
←
The object is a 'Value'→
48
←
Returning pointer, which participates in a condition later→

98//===----------------------------------------------------------------------===//
99//                                UnaryOperator Class
100//===----------------------------------------------------------------------===//

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

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

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

UnaryOperator *cloneImpl() const;

116public:

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

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

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

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

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

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

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

185//===----------------------------------------------------------------------===//
186//                           BinaryOperator Class
187//===----------------------------------------------------------------------===//

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

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

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

BinaryOperator *cloneImpl() const;

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

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

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

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

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

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

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

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

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

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

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

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

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

369#undef DEFINE_HELPERS

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

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

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

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

413template <>
414struct OperandTraits<BinaryOperator> :
public FixedNumOperandTraits<BinaryOperator, 2> {
416};

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

420//===----------------------------------------------------------------------===//
421//                               CastInst Class
422//===----------------------------------------------------------------------===//

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

704//===----------------------------------------------------------------------===//
705//                               CmpInst Class
706//===----------------------------------------------------------------------===//

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

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

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

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

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

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

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

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

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

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

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

static StringRef getPredicateName(Predicate P);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1047// FIXME: these are redundant if CmpInst < BinaryOperator
1048template <>
1049struct OperandTraits<CmpInst> : public FixedNumOperandTraits<CmpInst, 2> {
1050};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1140using OperandBundleDef = OperandBundleDefT<Value *>;
1141using ConstOperandBundleDef = OperandBundleDefT<const Value *>;

1143//===----------------------------------------------------------------------===//
1144//                               CallBase Class
1145//===----------------------------------------------------------------------===//

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

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

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

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

using Instruction::Instruction;

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

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

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

1202public:
using Instruction::getContext;

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

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

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

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

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

FunctionType *getFunctionType() const { return FTy; }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/// Determine whether this call has the given attribute. If it does not
/// then determine if the called function has the attribute, but only if
/// the attribute is allowed for the call.
bool hasFnAttr(Attribute::AttrKind Kind) const {
  assert(Kind != Attribute::NoBuiltin &&(static_cast <bool> (Kind != Attribute::NoBuiltin &&
 "Use CallBase::isNoBuiltin() to check for Attribute::NoBuiltin"
) ? void (0) : __assert_fail ("Kind != Attribute::NoBuiltin && \"Use CallBase::isNoBuiltin() to check for Attribute::NoBuiltin\""
, "/build/llvm-toolchain-snapshot-13~++20210722111111+b115c038d2d4/llvm/include/llvm/IR/InstrTypes.h"
, 1479, __extension__ __PRETTY_FUNCTION__))
         "Use CallBase::isNoBuiltin() to check for Attribute::NoBuiltin")(static_cast <bool> (Kind != Attribute::NoBuiltin &&
 "Use CallBase::isNoBuiltin() to check for Attribute::NoBuiltin"
) ? void (0) : __assert_fail ("Kind != Attribute::NoBuiltin && \"Use CallBase::isNoBuiltin() to check for Attribute::NoBuiltin\""
, "/build/llvm-toolchain-snapshot-13~++20210722111111+b115c038d2d4/llvm/include/llvm/IR/InstrTypes.h"
, 1479, __extension__ __PRETTY_FUNCTION__));
  return hasFnAttrImpl(Kind);
}

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

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

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

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

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

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

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

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

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

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

/// Removes the attributes from the given argument
void removeParamAttrs(unsigned ArgNo, const AttrBuilder &Attrs) {
  AttributeList PAL = getAttributes();
  PAL = PAL.removeParamAttributes(getContext(), ArgNo, Attrs);
  setAttributes(PAL);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

MaybeAlign getParamStackAlign(unsigned ArgNo) const {
  return Attrs.getParamStackAlignment(ArgNo);
}

/// Extract the byval type for a call or parameter.
Type *getParamByValType(unsigned ArgNo) const {
  if (auto *Ty = Attrs.getParamByValType(ArgNo))
    return Ty;
  if (const Function *F = getCalledFunction())
    return F->getAttributes().getParamByValType(ArgNo);
  return nullptr;
}

/// Extract the preallocated type for a call or parameter.
Type *getParamPreallocatedType(unsigned ArgNo) const {
  if (auto *Ty = Attrs.getParamPreallocatedType(ArgNo))
    return Ty;
  if (const Function *F = getCalledFunction())
    return F->getAttributes().getParamPreallocatedType(ArgNo);
  return nullptr;
}

/// Extract the preallocated type for a call or parameter.
Type *getParamInAllocaType(unsigned ArgNo) const {
  if (auto *Ty = Attrs.getParamInAllocaType(ArgNo))
    return Ty;
  if (const Function *F = getCalledFunction())
    return F->getAttributes().getParamInAllocaType(ArgNo);
  return nullptr;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  return Count;
}

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

  return Count;
}

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

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

  return None;
}

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

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

  return None;
}

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

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

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

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

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

  return false;
}

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

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

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

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

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

/// Is the function attribute A disallowed by some operand bundle on
/// this operand bundle user?
bool isFnAttrDisallowedByOpBundle(Attribute::AttrKind A) const {
  switch (A) {
  default:
    return false;

  case Attribute::InaccessibleMemOrArgMemOnly:
    return hasReadingOperandBundles();

  case Attribute::InaccessibleMemOnly:
    return hasReadingOperandBundles();

  case Attribute::ArgMemOnly:
    return hasReadingOperandBundles();

  case Attribute::ReadNone:
    return hasReadingOperandBundles();

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template <typename AttrKind> bool hasFnAttrImpl(AttrKind Kind) const {
  if (Attrs.hasFnAttribute(Kind))
    return true;

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

  return hasFnAttrOnCalledFunction(Kind);
}

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

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

2294template <>
2295struct OperandTraits<CallBase> : public VariadicOperandTraits<CallBase, 1> {};

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

2299//===----------------------------------------------------------------------===//
2300//                           FuncletPadInst Class
2301//===----------------------------------------------------------------------===//
2302class FuncletPadInst : public Instruction {
2303private:
FuncletPadInst(const FuncletPadInst &CPI);

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

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

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

FuncletPadInst *cloneImpl() const;

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

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

/// Convenience accessors

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

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

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

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

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

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

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

2369} // end namespace llvm

2371#endif // LLVM_IR_INSTRTYPES_H