LLVM  14.0.0git
InstrTypes.h
Go to the documentation of this file.
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 //===----------------------------------------------------------------------===//
14 
15 #ifndef LLVM_IR_INSTRTYPES_H
16 #define LLVM_IR_INSTRTYPES_H
17 
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"
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"
39 #include <algorithm>
40 #include <cassert>
41 #include <cstddef>
42 #include <cstdint>
43 #include <iterator>
44 #include <string>
45 #include <vector>
46 
47 namespace llvm {
48 
49 namespace Intrinsic {
50 typedef unsigned ID;
51 }
52 
53 //===----------------------------------------------------------------------===//
54 // UnaryInstruction Class
55 //===----------------------------------------------------------------------===//
56 
57 class UnaryInstruction : public Instruction {
58 protected:
59  UnaryInstruction(Type *Ty, unsigned iType, Value *V,
60  Instruction *IB = nullptr)
61  : Instruction(Ty, iType, &Op<0>(), 1, IB) {
62  Op<0>() = V;
63  }
64  UnaryInstruction(Type *Ty, unsigned iType, Value *V, BasicBlock *IAE)
65  : Instruction(Ty, iType, &Op<0>(), 1, IAE) {
66  Op<0>() = V;
67  }
68 
69 public:
70  // allocate space for exactly one operand
71  void *operator new(size_t S) { return User::operator new(S, 1); }
72  void operator delete(void *Ptr) { User::operator delete(Ptr); }
73 
74  /// Transparently provide more efficient getOperand methods.
76 
77  // Methods for support type inquiry through isa, cast, and dyn_cast:
78  static bool classof(const Instruction *I) {
79  return I->isUnaryOp() ||
80  I->getOpcode() == Instruction::Alloca ||
81  I->getOpcode() == Instruction::Load ||
82  I->getOpcode() == Instruction::VAArg ||
83  I->getOpcode() == Instruction::ExtractValue ||
84  (I->getOpcode() >= CastOpsBegin && I->getOpcode() < CastOpsEnd);
85  }
86  static bool classof(const Value *V) {
87  return isa<Instruction>(V) && classof(cast<Instruction>(V));
88  }
89 };
90 
91 template <>
93  public FixedNumOperandTraits<UnaryInstruction, 1> {
94 };
95 
97 
98 //===----------------------------------------------------------------------===//
99 // UnaryOperator Class
100 //===----------------------------------------------------------------------===//
101 
103  void AssertOK();
104 
105 protected:
106  UnaryOperator(UnaryOps iType, Value *S, Type *Ty,
107  const Twine &Name, Instruction *InsertBefore);
108  UnaryOperator(UnaryOps iType, Value *S, Type *Ty,
109  const Twine &Name, BasicBlock *InsertAtEnd);
110 
111  // Note: Instruction needs to be a friend here to call cloneImpl.
112  friend class Instruction;
113 
114  UnaryOperator *cloneImpl() const;
115 
116 public:
117 
118  /// Construct a unary instruction, given the opcode and an operand.
119  /// Optionally (if InstBefore is specified) insert the instruction
120  /// into a BasicBlock right before the specified instruction. The specified
121  /// Instruction is allowed to be a dereferenced end iterator.
122  ///
123  static UnaryOperator *Create(UnaryOps Op, Value *S,
124  const Twine &Name = Twine(),
125  Instruction *InsertBefore = nullptr);
126 
127  /// Construct a unary instruction, given the opcode and an operand.
128  /// Also automatically insert this instruction to the end of the
129  /// BasicBlock specified.
130  ///
131  static UnaryOperator *Create(UnaryOps Op, Value *S,
132  const Twine &Name,
133  BasicBlock *InsertAtEnd);
134 
135  /// These methods just forward to Create, and are useful when you
136  /// statically know what type of instruction you're going to create. These
137  /// helpers just save some typing.
138 #define HANDLE_UNARY_INST(N, OPC, CLASS) \
139  static UnaryOperator *Create##OPC(Value *V, const Twine &Name = "") {\
140  return Create(Instruction::OPC, V, Name);\
141  }
142 #include "llvm/IR/Instruction.def"
143 #define HANDLE_UNARY_INST(N, OPC, CLASS) \
144  static UnaryOperator *Create##OPC(Value *V, const Twine &Name, \
145  BasicBlock *BB) {\
146  return Create(Instruction::OPC, V, Name, BB);\
147  }
148 #include "llvm/IR/Instruction.def"
149 #define HANDLE_UNARY_INST(N, OPC, CLASS) \
150  static UnaryOperator *Create##OPC(Value *V, const Twine &Name, \
151  Instruction *I) {\
152  return Create(Instruction::OPC, V, Name, I);\
153  }
154 #include "llvm/IR/Instruction.def"
155 
156  static UnaryOperator *
158  const Twine &Name = "",
159  Instruction *InsertBefore = nullptr) {
160  UnaryOperator *UO = Create(Opc, V, Name, InsertBefore);
161  UO->copyIRFlags(CopyO);
162  return UO;
163  }
164 
166  const Twine &Name = "",
167  Instruction *InsertBefore = nullptr) {
168  return CreateWithCopiedFlags(Instruction::FNeg, Op, FMFSource, Name,
169  InsertBefore);
170  }
171 
172  UnaryOps getOpcode() const {
173  return static_cast<UnaryOps>(Instruction::getOpcode());
174  }
175 
176  // Methods for support type inquiry through isa, cast, and dyn_cast:
177  static bool classof(const Instruction *I) {
178  return I->isUnaryOp();
179  }
180  static bool classof(const Value *V) {
181  return isa<Instruction>(V) && classof(cast<Instruction>(V));
182  }
183 };
184 
185 //===----------------------------------------------------------------------===//
186 // BinaryOperator Class
187 //===----------------------------------------------------------------------===//
188 
189 class BinaryOperator : public Instruction {
190  void AssertOK();
191 
192 protected:
193  BinaryOperator(BinaryOps iType, Value *S1, Value *S2, Type *Ty,
194  const Twine &Name, Instruction *InsertBefore);
195  BinaryOperator(BinaryOps iType, Value *S1, Value *S2, Type *Ty,
196  const Twine &Name, BasicBlock *InsertAtEnd);
197 
198  // Note: Instruction needs to be a friend here to call cloneImpl.
199  friend class Instruction;
200 
201  BinaryOperator *cloneImpl() const;
202 
203 public:
204  // allocate space for exactly two operands
205  void *operator new(size_t S) { return User::operator new(S, 2); }
206  void operator delete(void *Ptr) { User::operator delete(Ptr); }
207 
208  /// Transparently provide more efficient getOperand methods.
210 
211  /// Construct a binary instruction, given the opcode and the two
212  /// operands. Optionally (if InstBefore is specified) insert the instruction
213  /// into a BasicBlock right before the specified instruction. The specified
214  /// Instruction is allowed to be a dereferenced end iterator.
215  ///
216  static BinaryOperator *Create(BinaryOps Op, Value *S1, Value *S2,
217  const Twine &Name = Twine(),
218  Instruction *InsertBefore = nullptr);
219 
220  /// Construct a binary instruction, given the opcode and the two
221  /// operands. Also automatically insert this instruction to the end of the
222  /// BasicBlock specified.
223  ///
224  static BinaryOperator *Create(BinaryOps Op, Value *S1, Value *S2,
225  const Twine &Name, BasicBlock *InsertAtEnd);
226 
227  /// These methods just forward to Create, and are useful when you
228  /// statically know what type of instruction you're going to create. These
229  /// helpers just save some typing.
230 #define HANDLE_BINARY_INST(N, OPC, CLASS) \
231  static BinaryOperator *Create##OPC(Value *V1, Value *V2, \
232  const Twine &Name = "") {\
233  return Create(Instruction::OPC, V1, V2, Name);\
234  }
235 #include "llvm/IR/Instruction.def"
236 #define HANDLE_BINARY_INST(N, OPC, CLASS) \
237  static BinaryOperator *Create##OPC(Value *V1, Value *V2, \
238  const Twine &Name, BasicBlock *BB) {\
239  return Create(Instruction::OPC, V1, V2, Name, BB);\
240  }
241 #include "llvm/IR/Instruction.def"
242 #define HANDLE_BINARY_INST(N, OPC, CLASS) \
243  static BinaryOperator *Create##OPC(Value *V1, Value *V2, \
244  const Twine &Name, Instruction *I) {\
245  return Create(Instruction::OPC, V1, V2, Name, I);\
246  }
247 #include "llvm/IR/Instruction.def"
248 
249  static BinaryOperator *
251  const Twine &Name = "",
252  Instruction *InsertBefore = nullptr) {
253  BinaryOperator *BO = Create(Opc, V1, V2, Name, InsertBefore);
254  BO->copyIRFlags(CopyO);
255  return BO;
256  }
257 
259  Instruction *FMFSource,
260  const Twine &Name = "") {
261  return CreateWithCopiedFlags(Instruction::FAdd, V1, V2, FMFSource, Name);
262  }
264  Instruction *FMFSource,
265  const Twine &Name = "") {
266  return CreateWithCopiedFlags(Instruction::FSub, V1, V2, FMFSource, Name);
267  }
269  Instruction *FMFSource,
270  const Twine &Name = "") {
271  return CreateWithCopiedFlags(Instruction::FMul, V1, V2, FMFSource, Name);
272  }
274  Instruction *FMFSource,
275  const Twine &Name = "") {
276  return CreateWithCopiedFlags(Instruction::FDiv, V1, V2, FMFSource, Name);
277  }
279  Instruction *FMFSource,
280  const Twine &Name = "") {
281  return CreateWithCopiedFlags(Instruction::FRem, V1, V2, FMFSource, Name);
282  }
283 
285  const Twine &Name = "") {
286  BinaryOperator *BO = Create(Opc, V1, V2, Name);
287  BO->setHasNoSignedWrap(true);
288  return BO;
289  }
291  const Twine &Name, BasicBlock *BB) {
292  BinaryOperator *BO = Create(Opc, V1, V2, Name, BB);
293  BO->setHasNoSignedWrap(true);
294  return BO;
295  }
297  const Twine &Name, Instruction *I) {
298  BinaryOperator *BO = Create(Opc, V1, V2, Name, I);
299  BO->setHasNoSignedWrap(true);
300  return BO;
301  }
302 
304  const Twine &Name = "") {
305  BinaryOperator *BO = Create(Opc, V1, V2, Name);
306  BO->setHasNoUnsignedWrap(true);
307  return BO;
308  }
310  const Twine &Name, BasicBlock *BB) {
311  BinaryOperator *BO = Create(Opc, V1, V2, Name, BB);
312  BO->setHasNoUnsignedWrap(true);
313  return BO;
314  }
316  const Twine &Name, Instruction *I) {
317  BinaryOperator *BO = Create(Opc, V1, V2, Name, I);
318  BO->setHasNoUnsignedWrap(true);
319  return BO;
320  }
321 
323  const Twine &Name = "") {
324  BinaryOperator *BO = Create(Opc, V1, V2, Name);
325  BO->setIsExact(true);
326  return BO;
327  }
329  const Twine &Name, BasicBlock *BB) {
330  BinaryOperator *BO = Create(Opc, V1, V2, Name, BB);
331  BO->setIsExact(true);
332  return BO;
333  }
335  const Twine &Name, Instruction *I) {
336  BinaryOperator *BO = Create(Opc, V1, V2, Name, I);
337  BO->setIsExact(true);
338  return BO;
339  }
340 
341 #define DEFINE_HELPERS(OPC, NUWNSWEXACT) \
342  static BinaryOperator *Create##NUWNSWEXACT##OPC(Value *V1, Value *V2, \
343  const Twine &Name = "") { \
344  return Create##NUWNSWEXACT(Instruction::OPC, V1, V2, Name); \
345  } \
346  static BinaryOperator *Create##NUWNSWEXACT##OPC( \
347  Value *V1, Value *V2, const Twine &Name, BasicBlock *BB) { \
348  return Create##NUWNSWEXACT(Instruction::OPC, V1, V2, Name, BB); \
349  } \
350  static BinaryOperator *Create##NUWNSWEXACT##OPC( \
351  Value *V1, Value *V2, const Twine &Name, Instruction *I) { \
352  return Create##NUWNSWEXACT(Instruction::OPC, V1, V2, Name, I); \
353  }
354 
355  DEFINE_HELPERS(Add, NSW) // CreateNSWAdd
356  DEFINE_HELPERS(Add, NUW) // CreateNUWAdd
357  DEFINE_HELPERS(Sub, NSW) // CreateNSWSub
358  DEFINE_HELPERS(Sub, NUW) // CreateNUWSub
359  DEFINE_HELPERS(Mul, NSW) // CreateNSWMul
360  DEFINE_HELPERS(Mul, NUW) // CreateNUWMul
361  DEFINE_HELPERS(Shl, NSW) // CreateNSWShl
362  DEFINE_HELPERS(Shl, NUW) // CreateNUWShl
363 
364  DEFINE_HELPERS(SDiv, Exact) // CreateExactSDiv
365  DEFINE_HELPERS(UDiv, Exact) // CreateExactUDiv
366  DEFINE_HELPERS(AShr, Exact) // CreateExactAShr
367  DEFINE_HELPERS(LShr, Exact) // CreateExactLShr
368 
369 #undef DEFINE_HELPERS
370 
371  /// Helper functions to construct and inspect unary operations (NEG and NOT)
372  /// via binary operators SUB and XOR:
373  ///
374  /// Create the NEG and NOT instructions out of SUB and XOR instructions.
375  ///
376  static BinaryOperator *CreateNeg(Value *Op, const Twine &Name = "",
377  Instruction *InsertBefore = nullptr);
378  static BinaryOperator *CreateNeg(Value *Op, const Twine &Name,
379  BasicBlock *InsertAtEnd);
380  static BinaryOperator *CreateNSWNeg(Value *Op, const Twine &Name = "",
381  Instruction *InsertBefore = nullptr);
382  static BinaryOperator *CreateNSWNeg(Value *Op, const Twine &Name,
383  BasicBlock *InsertAtEnd);
384  static BinaryOperator *CreateNUWNeg(Value *Op, const Twine &Name = "",
385  Instruction *InsertBefore = nullptr);
386  static BinaryOperator *CreateNUWNeg(Value *Op, const Twine &Name,
387  BasicBlock *InsertAtEnd);
388  static BinaryOperator *CreateNot(Value *Op, const Twine &Name = "",
389  Instruction *InsertBefore = nullptr);
390  static BinaryOperator *CreateNot(Value *Op, const Twine &Name,
391  BasicBlock *InsertAtEnd);
392 
394  return static_cast<BinaryOps>(Instruction::getOpcode());
395  }
396 
397  /// Exchange the two operands to this instruction.
398  /// This instruction is safe to use on any binary instruction and
399  /// does not modify the semantics of the instruction. If the instruction
400  /// cannot be reversed (ie, it's a Div), then return true.
401  ///
402  bool swapOperands();
403 
404  // Methods for support type inquiry through isa, cast, and dyn_cast:
405  static bool classof(const Instruction *I) {
406  return I->isBinaryOp();
407  }
408  static bool classof(const Value *V) {
409  return isa<Instruction>(V) && classof(cast<Instruction>(V));
410  }
411 };
412 
413 template <>
415  public FixedNumOperandTraits<BinaryOperator, 2> {
416 };
417 
419 
420 //===----------------------------------------------------------------------===//
421 // CastInst Class
422 //===----------------------------------------------------------------------===//
423 
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.
430 class CastInst : public UnaryInstruction {
431 protected:
432  /// Constructor with insert-before-instruction semantics for subclasses
433  CastInst(Type *Ty, unsigned iType, Value *S,
434  const Twine &NameStr = "", Instruction *InsertBefore = nullptr)
435  : UnaryInstruction(Ty, iType, S, InsertBefore) {
436  setName(NameStr);
437  }
438  /// Constructor with insert-at-end-of-block semantics for subclasses
439  CastInst(Type *Ty, unsigned iType, Value *S,
440  const Twine &NameStr, BasicBlock *InsertAtEnd)
441  : UnaryInstruction(Ty, iType, S, InsertAtEnd) {
442  setName(NameStr);
443  }
444 
445 public:
446  /// Provides a way to construct any of the CastInst subclasses using an
447  /// opcode instead of the subclass's constructor. The opcode must be in the
448  /// CastOps category (Instruction::isCast(opcode) returns true). This
449  /// constructor has insert-before-instruction semantics to automatically
450  /// insert the new CastInst before InsertBefore (if it is non-null).
451  /// Construct any of the CastInst subclasses
452  static CastInst *Create(
453  Instruction::CastOps, ///< The opcode of the cast instruction
454  Value *S, ///< The value to be casted (operand 0)
455  Type *Ty, ///< The type to which cast should be made
456  const Twine &Name = "", ///< Name for the instruction
457  Instruction *InsertBefore = nullptr ///< Place to insert the instruction
458  );
459  /// Provides a way to construct any of the CastInst subclasses using an
460  /// opcode instead of the subclass's constructor. The opcode must be in the
461  /// CastOps category. This constructor has insert-at-end-of-block semantics
462  /// to automatically insert the new CastInst at the end of InsertAtEnd (if
463  /// its non-null).
464  /// Construct any of the CastInst subclasses
465  static CastInst *Create(
466  Instruction::CastOps, ///< The opcode for the cast instruction
467  Value *S, ///< The value to be casted (operand 0)
468  Type *Ty, ///< The type to which operand is casted
469  const Twine &Name, ///< The name for the instruction
470  BasicBlock *InsertAtEnd ///< The block to insert the instruction into
471  );
472 
473  /// Create a ZExt or BitCast cast instruction
474  static CastInst *CreateZExtOrBitCast(
475  Value *S, ///< The value to be casted (operand 0)
476  Type *Ty, ///< The type to which cast should be made
477  const Twine &Name = "", ///< Name for the instruction
478  Instruction *InsertBefore = nullptr ///< Place to insert the instruction
479  );
480 
481  /// Create a ZExt or BitCast cast instruction
482  static CastInst *CreateZExtOrBitCast(
483  Value *S, ///< The value to be casted (operand 0)
484  Type *Ty, ///< The type to which operand is casted
485  const Twine &Name, ///< The name for the instruction
486  BasicBlock *InsertAtEnd ///< The block to insert the instruction into
487  );
488 
489  /// Create a SExt or BitCast cast instruction
490  static CastInst *CreateSExtOrBitCast(
491  Value *S, ///< The value to be casted (operand 0)
492  Type *Ty, ///< The type to which cast should be made
493  const Twine &Name = "", ///< Name for the instruction
494  Instruction *InsertBefore = nullptr ///< Place to insert the instruction
495  );
496 
497  /// Create a SExt or BitCast cast instruction
498  static CastInst *CreateSExtOrBitCast(
499  Value *S, ///< The value to be casted (operand 0)
500  Type *Ty, ///< The type to which operand is casted
501  const Twine &Name, ///< The name for the instruction
502  BasicBlock *InsertAtEnd ///< The block to insert the instruction into
503  );
504 
505  /// Create a BitCast AddrSpaceCast, or a PtrToInt cast instruction.
506  static CastInst *CreatePointerCast(
507  Value *S, ///< The pointer value to be casted (operand 0)
508  Type *Ty, ///< The type to which operand is casted
509  const Twine &Name, ///< The name for the instruction
510  BasicBlock *InsertAtEnd ///< The block to insert the instruction into
511  );
512 
513  /// Create a BitCast, AddrSpaceCast or a PtrToInt cast instruction.
514  static CastInst *CreatePointerCast(
515  Value *S, ///< The pointer value to be casted (operand 0)
516  Type *Ty, ///< The type to which cast should be made
517  const Twine &Name = "", ///< Name for the instruction
518  Instruction *InsertBefore = nullptr ///< Place to insert the instruction
519  );
520 
521  /// Create a BitCast or an AddrSpaceCast cast instruction.
522  static CastInst *CreatePointerBitCastOrAddrSpaceCast(
523  Value *S, ///< The pointer value to be casted (operand 0)
524  Type *Ty, ///< The type to which operand is casted
525  const Twine &Name, ///< The name for the instruction
526  BasicBlock *InsertAtEnd ///< The block to insert the instruction into
527  );
528 
529  /// Create a BitCast or an AddrSpaceCast cast instruction.
530  static CastInst *CreatePointerBitCastOrAddrSpaceCast(
531  Value *S, ///< The pointer value to be casted (operand 0)
532  Type *Ty, ///< The type to which cast should be made
533  const Twine &Name = "", ///< Name for the instruction
534  Instruction *InsertBefore = nullptr ///< Place to insert the instruction
535  );
536 
537  /// Create a BitCast, a PtrToInt, or an IntToPTr cast instruction.
538  ///
539  /// If the value is a pointer type and the destination an integer type,
540  /// creates a PtrToInt cast. If the value is an integer type and the
541  /// destination a pointer type, creates an IntToPtr cast. Otherwise, creates
542  /// a bitcast.
543  static CastInst *CreateBitOrPointerCast(
544  Value *S, ///< The pointer value to be casted (operand 0)
545  Type *Ty, ///< The type to which cast should be made
546  const Twine &Name = "", ///< Name for the instruction
547  Instruction *InsertBefore = nullptr ///< Place to insert the instruction
548  );
549 
550  /// Create a ZExt, BitCast, or Trunc for int -> int casts.
551  static CastInst *CreateIntegerCast(
552  Value *S, ///< The pointer value to be casted (operand 0)
553  Type *Ty, ///< The type to which cast should be made
554  bool isSigned, ///< Whether to regard S as signed or not
555  const Twine &Name = "", ///< Name for the instruction
556  Instruction *InsertBefore = nullptr ///< Place to insert the instruction
557  );
558 
559  /// Create a ZExt, BitCast, or Trunc for int -> int casts.
560  static CastInst *CreateIntegerCast(
561  Value *S, ///< The integer value to be casted (operand 0)
562  Type *Ty, ///< The integer type to which operand is casted
563  bool isSigned, ///< Whether to regard S as signed or not
564  const Twine &Name, ///< The name for the instruction
565  BasicBlock *InsertAtEnd ///< The block to insert the instruction into
566  );
567 
568  /// Create an FPExt, BitCast, or FPTrunc for fp -> fp casts
569  static CastInst *CreateFPCast(
570  Value *S, ///< The floating point value to be casted
571  Type *Ty, ///< The floating point type to cast to
572  const Twine &Name = "", ///< Name for the instruction
573  Instruction *InsertBefore = nullptr ///< Place to insert the instruction
574  );
575 
576  /// Create an FPExt, BitCast, or FPTrunc for fp -> fp casts
577  static CastInst *CreateFPCast(
578  Value *S, ///< The floating point value to be casted
579  Type *Ty, ///< The floating point type to cast to
580  const Twine &Name, ///< The name for the instruction
581  BasicBlock *InsertAtEnd ///< The block to insert the instruction into
582  );
583 
584  /// Create a Trunc or BitCast cast instruction
585  static CastInst *CreateTruncOrBitCast(
586  Value *S, ///< The value to be casted (operand 0)
587  Type *Ty, ///< The type to which cast should be made
588  const Twine &Name = "", ///< Name for the instruction
589  Instruction *InsertBefore = nullptr ///< Place to insert the instruction
590  );
591 
592  /// Create a Trunc or BitCast cast instruction
593  static CastInst *CreateTruncOrBitCast(
594  Value *S, ///< The value to be casted (operand 0)
595  Type *Ty, ///< The type to which operand is casted
596  const Twine &Name, ///< The name for the instruction
597  BasicBlock *InsertAtEnd ///< The block to insert the instruction into
598  );
599 
600  /// Check whether a bitcast between these types is valid
601  static bool isBitCastable(
602  Type *SrcTy, ///< The Type from which the value should be cast.
603  Type *DestTy ///< The Type to which the value should be cast.
604  );
605 
606  /// Check whether a bitcast, inttoptr, or ptrtoint cast between these
607  /// types is valid and a no-op.
608  ///
609  /// This ensures that any pointer<->integer cast has enough bits in the
610  /// integer and any other cast is a bitcast.
611  static bool isBitOrNoopPointerCastable(
612  Type *SrcTy, ///< The Type from which the value should be cast.
613  Type *DestTy, ///< The Type to which the value should be cast.
614  const DataLayout &DL);
615 
616  /// Returns the opcode necessary to cast Val into Ty using usual casting
617  /// rules.
618  /// Infer the opcode for cast operand and type
619  static Instruction::CastOps getCastOpcode(
620  const Value *Val, ///< The value to cast
621  bool SrcIsSigned, ///< Whether to treat the source as signed
622  Type *Ty, ///< The Type to which the value should be casted
623  bool DstIsSigned ///< Whether to treate the dest. as signed
624  );
625 
626  /// There are several places where we need to know if a cast instruction
627  /// only deals with integer source and destination types. To simplify that
628  /// logic, this method is provided.
629  /// @returns true iff the cast has only integral typed operand and dest type.
630  /// Determine if this is an integer-only cast.
631  bool isIntegerCast() const;
632 
633  /// A lossless cast is one that does not alter the basic value. It implies
634  /// a no-op cast but is more stringent, preventing things like int->float,
635  /// long->double, or int->ptr.
636  /// @returns true iff the cast is lossless.
637  /// Determine if this is a lossless cast.
638  bool isLosslessCast() const;
639 
640  /// A no-op cast is one that can be effected without changing any bits.
641  /// It implies that the source and destination types are the same size. The
642  /// DataLayout argument is to determine the pointer size when examining casts
643  /// involving Integer and Pointer types. They are no-op casts if the integer
644  /// is the same size as the pointer. However, pointer size varies with
645  /// platform. Note that a precondition of this method is that the cast is
646  /// legal - i.e. the instruction formed with these operands would verify.
647  static bool isNoopCast(
648  Instruction::CastOps Opcode, ///< Opcode of cast
649  Type *SrcTy, ///< SrcTy of cast
650  Type *DstTy, ///< DstTy of cast
651  const DataLayout &DL ///< DataLayout to get the Int Ptr type from.
652  );
653 
654  /// Determine if this cast is a no-op cast.
655  ///
656  /// \param DL is the DataLayout to determine pointer size.
657  bool isNoopCast(const DataLayout &DL) const;
658 
659  /// Determine how a pair of casts can be eliminated, if they can be at all.
660  /// This is a helper function for both CastInst and ConstantExpr.
661  /// @returns 0 if the CastInst pair can't be eliminated, otherwise
662  /// returns Instruction::CastOps value for a cast that can replace
663  /// the pair, casting SrcTy to DstTy.
664  /// Determine if a cast pair is eliminable
665  static unsigned isEliminableCastPair(
666  Instruction::CastOps firstOpcode, ///< Opcode of first cast
667  Instruction::CastOps secondOpcode, ///< Opcode of second cast
668  Type *SrcTy, ///< SrcTy of 1st cast
669  Type *MidTy, ///< DstTy of 1st cast & SrcTy of 2nd cast
670  Type *DstTy, ///< DstTy of 2nd cast
671  Type *SrcIntPtrTy, ///< Integer type corresponding to Ptr SrcTy, or null
672  Type *MidIntPtrTy, ///< Integer type corresponding to Ptr MidTy, or null
673  Type *DstIntPtrTy ///< Integer type corresponding to Ptr DstTy, or null
674  );
675 
676  /// Return the opcode of this CastInst
679  }
680 
681  /// Return the source type, as a convenience
682  Type* getSrcTy() const { return getOperand(0)->getType(); }
683  /// Return the destination type, as a convenience
684  Type* getDestTy() const { return getType(); }
685 
686  /// This method can be used to determine if a cast from SrcTy to DstTy using
687  /// Opcode op is valid or not.
688  /// @returns true iff the proposed cast is valid.
689  /// Determine if a cast is valid without creating one.
690  static bool castIsValid(Instruction::CastOps op, Type *SrcTy, Type *DstTy);
691  static bool castIsValid(Instruction::CastOps op, Value *S, Type *DstTy) {
692  return castIsValid(op, S->getType(), DstTy);
693  }
694 
695  /// Methods for support type inquiry through isa, cast, and dyn_cast:
696  static bool classof(const Instruction *I) {
697  return I->isCast();
698  }
699  static bool classof(const Value *V) {
700  return isa<Instruction>(V) && classof(cast<Instruction>(V));
701  }
702 };
703 
704 //===----------------------------------------------------------------------===//
705 // CmpInst Class
706 //===----------------------------------------------------------------------===//
707 
708 /// This class is the base class for the comparison instructions.
709 /// Abstract base class of comparison instructions.
710 class CmpInst : public Instruction {
711 public:
712  /// This enumeration lists the possible predicates for CmpInst subclasses.
713  /// Values in the range 0-31 are reserved for FCmpInst, while values in the
714  /// range 32-64 are reserved for ICmpInst. This is necessary to ensure the
715  /// predicate values are not overlapping between the classes.
716  ///
717  /// Some passes (e.g. InstCombine) depend on the bit-wise characteristics of
718  /// FCMP_* values. Changing the bit patterns requires a potential change to
719  /// those passes.
720  enum Predicate : unsigned {
721  // Opcode U L G E Intuitive operation
722  FCMP_FALSE = 0, ///< 0 0 0 0 Always false (always folded)
723  FCMP_OEQ = 1, ///< 0 0 0 1 True if ordered and equal
724  FCMP_OGT = 2, ///< 0 0 1 0 True if ordered and greater than
725  FCMP_OGE = 3, ///< 0 0 1 1 True if ordered and greater than or equal
726  FCMP_OLT = 4, ///< 0 1 0 0 True if ordered and less than
727  FCMP_OLE = 5, ///< 0 1 0 1 True if ordered and less than or equal
728  FCMP_ONE = 6, ///< 0 1 1 0 True if ordered and operands are unequal
729  FCMP_ORD = 7, ///< 0 1 1 1 True if ordered (no nans)
730  FCMP_UNO = 8, ///< 1 0 0 0 True if unordered: isnan(X) | isnan(Y)
731  FCMP_UEQ = 9, ///< 1 0 0 1 True if unordered or equal
732  FCMP_UGT = 10, ///< 1 0 1 0 True if unordered or greater than
733  FCMP_UGE = 11, ///< 1 0 1 1 True if unordered, greater than, or equal
734  FCMP_ULT = 12, ///< 1 1 0 0 True if unordered or less than
735  FCMP_ULE = 13, ///< 1 1 0 1 True if unordered, less than, or equal
736  FCMP_UNE = 14, ///< 1 1 1 0 True if unordered or not equal
737  FCMP_TRUE = 15, ///< 1 1 1 1 Always true (always folded)
741  ICMP_EQ = 32, ///< equal
742  ICMP_NE = 33, ///< not equal
743  ICMP_UGT = 34, ///< unsigned greater than
744  ICMP_UGE = 35, ///< unsigned greater or equal
745  ICMP_ULT = 36, ///< unsigned less than
746  ICMP_ULE = 37, ///< unsigned less or equal
747  ICMP_SGT = 38, ///< signed greater than
748  ICMP_SGE = 39, ///< signed greater or equal
749  ICMP_SLT = 40, ///< signed less than
750  ICMP_SLE = 41, ///< signed less or equal
754  };
755  using PredicateField =
757 
758 protected:
760  Value *LHS, Value *RHS, const Twine &Name = "",
761  Instruction *InsertBefore = nullptr,
762  Instruction *FlagsSource = nullptr);
763 
765  Value *LHS, Value *RHS, const Twine &Name,
766  BasicBlock *InsertAtEnd);
767 
768 public:
769  // allocate space for exactly two operands
770  void *operator new(size_t S) { return User::operator new(S, 2); }
771  void operator delete(void *Ptr) { User::operator delete(Ptr); }
772 
773  /// Construct a compare instruction, given the opcode, the predicate and
774  /// the two operands. Optionally (if InstBefore is specified) insert the
775  /// instruction into a BasicBlock right before the specified instruction.
776  /// The specified Instruction is allowed to be a dereferenced end iterator.
777  /// Create a CmpInst
778  static CmpInst *Create(OtherOps Op,
779  Predicate predicate, Value *S1,
780  Value *S2, const Twine &Name = "",
781  Instruction *InsertBefore = nullptr);
782 
783  /// Construct a compare instruction, given the opcode, the predicate and the
784  /// two operands. Also automatically insert this instruction to the end of
785  /// the BasicBlock specified.
786  /// Create a CmpInst
787  static CmpInst *Create(OtherOps Op, Predicate predicate, Value *S1,
788  Value *S2, const Twine &Name, BasicBlock *InsertAtEnd);
789 
790  /// Get the opcode casted to the right type
791  OtherOps getOpcode() const {
792  return static_cast<OtherOps>(Instruction::getOpcode());
793  }
794 
795  /// Return the predicate for this instruction.
796  Predicate getPredicate() const { return getSubclassData<PredicateField>(); }
797 
798  /// Set the predicate for this instruction to the specified value.
799  void setPredicate(Predicate P) { setSubclassData<PredicateField>(P); }
800 
801  static bool isFPPredicate(Predicate P) {
802  static_assert(FIRST_FCMP_PREDICATE == 0,
803  "FIRST_FCMP_PREDICATE is required to be 0");
804  return P <= LAST_FCMP_PREDICATE;
805  }
806 
807  static bool isIntPredicate(Predicate P) {
809  }
810 
812 
813  bool isFPPredicate() const { return isFPPredicate(getPredicate()); }
814  bool isIntPredicate() const { return isIntPredicate(getPredicate()); }
815 
816  /// For example, EQ -> NE, UGT -> ULE, SLT -> SGE,
817  /// OEQ -> UNE, UGT -> OLE, OLT -> UGE, etc.
818  /// @returns the inverse predicate for the instruction's current predicate.
819  /// Return the inverse of the instruction's predicate.
822  }
823 
824  /// For example, EQ -> NE, UGT -> ULE, SLT -> SGE,
825  /// OEQ -> UNE, UGT -> OLE, OLT -> UGE, etc.
826  /// @returns the inverse predicate for predicate provided in \p pred.
827  /// Return the inverse of a given predicate
829 
830  /// For example, EQ->EQ, SLE->SGE, ULT->UGT,
831  /// OEQ->OEQ, ULE->UGE, OLT->OGT, etc.
832  /// @returns the predicate that would be the result of exchanging the two
833  /// operands of the CmpInst instruction without changing the result
834  /// produced.
835  /// Return the predicate as if the operands were swapped
838  }
839 
840  /// This is a static version that you can use without an instruction
841  /// available.
842  /// Return the predicate as if the operands were swapped.
844 
845  /// This is a static version that you can use without an instruction
846  /// available.
847  /// @returns true if the comparison predicate is strict, false otherwise.
848  static bool isStrictPredicate(Predicate predicate);
849 
850  /// @returns true if the comparison predicate is strict, false otherwise.
851  /// Determine if this instruction is using an strict comparison predicate.
853 
854  /// This is a static version that you can use without an instruction
855  /// available.
856  /// @returns true if the comparison predicate is non-strict, false otherwise.
857  static bool isNonStrictPredicate(Predicate predicate);
858 
859  /// @returns true if the comparison predicate is non-strict, false otherwise.
860  /// Determine if this instruction is using an non-strict comparison predicate.
861  bool isNonStrictPredicate() const {
863  }
864 
865  /// For example, SGE -> SGT, SLE -> SLT, ULE -> ULT, UGE -> UGT.
866  /// Returns the strict version of non-strict comparisons.
869  }
870 
871  /// This is a static version that you can use without an instruction
872  /// available.
873  /// @returns the strict version of comparison provided in \p pred.
874  /// If \p pred is not a strict comparison predicate, returns \p pred.
875  /// Returns the strict version of non-strict comparisons.
877 
878  /// For example, SGT -> SGE, SLT -> SLE, ULT -> ULE, UGT -> UGE.
879  /// Returns the non-strict version of strict comparisons.
882  }
883 
884  /// This is a static version that you can use without an instruction
885  /// available.
886  /// @returns the non-strict version of comparison provided in \p pred.
887  /// If \p pred is not a strict comparison predicate, returns \p pred.
888  /// Returns the non-strict version of strict comparisons.
890 
891  /// This is a static version that you can use without an instruction
892  /// available.
893  /// Return the flipped strictness of predicate
895 
896  /// For predicate of kind "is X or equal to 0" returns the predicate "is X".
897  /// For predicate of kind "is X" returns the predicate "is X or equal to 0".
898  /// does not support other kind of predicates.
899  /// @returns the predicate that does not contains is equal to zero if
900  /// it had and vice versa.
901  /// Return the flipped strictness of predicate
904  }
905 
906  /// Provide more efficient getOperand methods.
908 
909  /// This is just a convenience that dispatches to the subclasses.
910  /// Swap the operands and adjust predicate accordingly to retain
911  /// the same comparison.
912  void swapOperands();
913 
914  /// This is just a convenience that dispatches to the subclasses.
915  /// Determine if this CmpInst is commutative.
916  bool isCommutative() const;
917 
918  /// Determine if this is an equals/not equals predicate.
919  /// This is a static version that you can use without an instruction
920  /// available.
921  static bool isEquality(Predicate pred);
922 
923  /// Determine if this is an equals/not equals predicate.
924  bool isEquality() const { return isEquality(getPredicate()); }
925 
926  /// Return true if the predicate is relational (not EQ or NE).
927  static bool isRelational(Predicate P) { return !isEquality(P); }
928 
929  /// Return true if the predicate is relational (not EQ or NE).
930  bool isRelational() const { return !isEquality(); }
931 
932  /// @returns true if the comparison is signed, false otherwise.
933  /// Determine if this instruction is using a signed comparison.
934  bool isSigned() const {
935  return isSigned(getPredicate());
936  }
937 
938  /// @returns true if the comparison is unsigned, false otherwise.
939  /// Determine if this instruction is using an unsigned comparison.
940  bool isUnsigned() const {
941  return isUnsigned(getPredicate());
942  }
943 
944  /// For example, ULT->SLT, ULE->SLE, UGT->SGT, UGE->SGE, SLT->Failed assert
945  /// @returns the signed version of the unsigned predicate pred.
946  /// return the signed version of a predicate
948 
949  /// For example, ULT->SLT, ULE->SLE, UGT->SGT, UGE->SGE, SLT->Failed assert
950  /// @returns the signed version of the predicate for this instruction (which
951  /// has to be an unsigned predicate).
952  /// return the signed version of a predicate
955  }
956 
957  /// For example, SLT->ULT, SLE->ULE, SGT->UGT, SGE->UGE, ULT->Failed assert
958  /// @returns the unsigned version of the signed predicate pred.
960 
961  /// For example, SLT->ULT, SLE->ULE, SGT->UGT, SGE->UGE, ULT->Failed assert
962  /// @returns the unsigned version of the predicate for this instruction (which
963  /// has to be an signed predicate).
964  /// return the unsigned version of a predicate
967  }
968 
969  /// For example, SLT->ULT, ULT->SLT, SLE->ULE, ULE->SLE, EQ->Failed assert
970  /// @returns the unsigned version of the signed predicate pred or
971  /// the signed version of the signed predicate pred.
973 
974  /// For example, SLT->ULT, ULT->SLT, SLE->ULE, ULE->SLE, EQ->Failed assert
975  /// @returns the unsigned version of the signed predicate pred or
976  /// the signed version of the signed predicate pred.
979  }
980 
981  /// This is just a convenience.
982  /// Determine if this is true when both operands are the same.
983  bool isTrueWhenEqual() const {
984  return isTrueWhenEqual(getPredicate());
985  }
986 
987  /// This is just a convenience.
988  /// Determine if this is false when both operands are the same.
989  bool isFalseWhenEqual() const {
990  return isFalseWhenEqual(getPredicate());
991  }
992 
993  /// @returns true if the predicate is unsigned, false otherwise.
994  /// Determine if the predicate is an unsigned operation.
995  static bool isUnsigned(Predicate predicate);
996 
997  /// @returns true if the predicate is signed, false otherwise.
998  /// Determine if the predicate is an signed operation.
999  static bool isSigned(Predicate predicate);
1000 
1001  /// Determine if the predicate is an ordered operation.
1002  static bool isOrdered(Predicate predicate);
1003 
1004  /// Determine if the predicate is an unordered operation.
1005  static bool isUnordered(Predicate predicate);
1006 
1007  /// Determine if the predicate is true when comparing a value with itself.
1008  static bool isTrueWhenEqual(Predicate predicate);
1009 
1010  /// Determine if the predicate is false when comparing a value with itself.
1011  static bool isFalseWhenEqual(Predicate predicate);
1012 
1013  /// Determine if Pred1 implies Pred2 is true when two compares have matching
1014  /// operands.
1015  static bool isImpliedTrueByMatchingCmp(Predicate Pred1, Predicate Pred2);
1016 
1017  /// Determine if Pred1 implies Pred2 is false when two compares have matching
1018  /// operands.
1019  static bool isImpliedFalseByMatchingCmp(Predicate Pred1, Predicate Pred2);
1020 
1021  /// Methods for support type inquiry through isa, cast, and dyn_cast:
1022  static bool classof(const Instruction *I) {
1023  return I->getOpcode() == Instruction::ICmp ||
1024  I->getOpcode() == Instruction::FCmp;
1025  }
1026  static bool classof(const Value *V) {
1027  return isa<Instruction>(V) && classof(cast<Instruction>(V));
1028  }
1029 
1030  /// Create a result type for fcmp/icmp
1031  static Type* makeCmpResultType(Type* opnd_type) {
1032  if (VectorType* vt = dyn_cast<VectorType>(opnd_type)) {
1033  return VectorType::get(Type::getInt1Ty(opnd_type->getContext()),
1034  vt->getElementCount());
1035  }
1036  return Type::getInt1Ty(opnd_type->getContext());
1037  }
1038 
1039 private:
1040  // Shadow Value::setValueSubclassData with a private forwarding method so that
1041  // subclasses cannot accidentally use it.
1042  void setValueSubclassData(unsigned short D) {
1044  }
1045 };
1046 
1047 // FIXME: these are redundant if CmpInst < BinaryOperator
1048 template <>
1049 struct OperandTraits<CmpInst> : public FixedNumOperandTraits<CmpInst, 2> {
1050 };
1051 
1053 
1054 /// A lightweight accessor for an operand bundle meant to be passed
1055 /// around by value.
1058 
1059  OperandBundleUse() = default;
1061  : Inputs(Inputs), Tag(Tag) {}
1062 
1063  /// Return true if the operand at index \p Idx in this operand bundle
1064  /// has the attribute A.
1065  bool operandHasAttr(unsigned Idx, Attribute::AttrKind A) const {
1066  if (isDeoptOperandBundle())
1067  if (A == Attribute::ReadOnly || A == Attribute::NoCapture)
1068  return Inputs[Idx]->getType()->isPointerTy();
1069 
1070  // Conservative answer: no operands have any attributes.
1071  return false;
1072  }
1073 
1074  /// Return the tag of this operand bundle as a string.
1076  return Tag->getKey();
1077  }
1078 
1079  /// Return the tag of this operand bundle as an integer.
1080  ///
1081  /// Operand bundle tags are interned by LLVMContextImpl::getOrInsertBundleTag,
1082  /// and this function returns the unique integer getOrInsertBundleTag
1083  /// associated the tag of this operand bundle to.
1084  uint32_t getTagID() const {
1085  return Tag->getValue();
1086  }
1087 
1088  /// Return true if this is a "deopt" operand bundle.
1089  bool isDeoptOperandBundle() const {
1090  return getTagID() == LLVMContext::OB_deopt;
1091  }
1092 
1093  /// Return true if this is a "funclet" operand bundle.
1094  bool isFuncletOperandBundle() const {
1095  return getTagID() == LLVMContext::OB_funclet;
1096  }
1097 
1098  /// Return true if this is a "cfguardtarget" operand bundle.
1100  return getTagID() == LLVMContext::OB_cfguardtarget;
1101  }
1102 
1103 private:
1104  /// Pointer to an entry in LLVMContextImpl::getOrInsertBundleTag.
1106 };
1107 
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.
1114 template <typename InputTy> class OperandBundleDefT {
1115  std::string Tag;
1116  std::vector<InputTy> Inputs;
1117 
1118 public:
1119  explicit OperandBundleDefT(std::string Tag, std::vector<InputTy> Inputs)
1120  : Tag(std::move(Tag)), Inputs(std::move(Inputs)) {}
1121  explicit OperandBundleDefT(std::string Tag, ArrayRef<InputTy> Inputs)
1122  : Tag(std::move(Tag)), Inputs(Inputs) {}
1123 
1124  explicit OperandBundleDefT(const OperandBundleUse &OBU) {
1125  Tag = std::string(OBU.getTagName());
1126  llvm::append_range(Inputs, OBU.Inputs);
1127  }
1128 
1129  ArrayRef<InputTy> inputs() const { return Inputs; }
1130 
1131  using input_iterator = typename std::vector<InputTy>::const_iterator;
1132 
1133  size_t input_size() const { return Inputs.size(); }
1134  input_iterator input_begin() const { return Inputs.begin(); }
1135  input_iterator input_end() const { return Inputs.end(); }
1136 
1137  StringRef getTag() const { return Tag; }
1138 };
1139 
1142 
1143 //===----------------------------------------------------------------------===//
1144 // CallBase Class
1145 //===----------------------------------------------------------------------===//
1146 
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.
1161 class CallBase : public Instruction {
1162 protected:
1163  // The first two bits are reserved by CallInst for fast retrieval,
1165  using CallingConvField =
1168  static_assert(
1169  Bitfield::areContiguous<CallInstReservedField, CallingConvField>(),
1170  "Bitfields must be contiguous");
1171 
1172  /// The last operand is the called operand.
1173  static constexpr int CalledOperandOpEndIdx = -1;
1174 
1175  AttributeList Attrs; ///< parameter attributes for callable
1177 
1178  template <class... ArgsTy>
1179  CallBase(AttributeList const &A, FunctionType *FT, ArgsTy &&... Args)
1180  : Instruction(std::forward<ArgsTy>(Args)...), Attrs(A), FTy(FT) {}
1181 
1183 
1184  bool hasDescriptor() const { return Value::HasDescriptor; }
1185 
1186  unsigned getNumSubclassExtraOperands() const {
1187  switch (getOpcode()) {
1188  case Instruction::Call:
1189  return 0;
1190  case Instruction::Invoke:
1191  return 2;
1192  case Instruction::CallBr:
1194  }
1195  llvm_unreachable("Invalid opcode!");
1196  }
1197 
1198  /// Get the number of extra operands for instructions that don't have a fixed
1199  /// number of extra operands.
1200  unsigned getNumSubclassExtraOperandsDynamic() const;
1201 
1202 public:
1204 
1205  /// Create a clone of \p CB with a different set of operand bundles and
1206  /// insert it before \p InsertPt.
1207  ///
1208  /// The returned call instruction is identical \p CB in every way except that
1209  /// the operand bundles for the new instruction are set to the operand bundles
1210  /// in \p Bundles.
1211  static CallBase *Create(CallBase *CB, ArrayRef<OperandBundleDef> Bundles,
1212  Instruction *InsertPt = nullptr);
1213 
1214  /// Create a clone of \p CB with the operand bundle with the tag matching
1215  /// \p Bundle's tag replaced with Bundle, and insert it before \p InsertPt.
1216  ///
1217  /// The returned call instruction is identical \p CI in every way except that
1218  /// the specified operand bundle has been replaced.
1219  static CallBase *Create(CallBase *CB,
1220  OperandBundleDef Bundle,
1221  Instruction *InsertPt = nullptr);
1222 
1223  /// Create a clone of \p CB with operand bundle \p OB added.
1226  Instruction *InsertPt = nullptr);
1227 
1228  /// Create a clone of \p CB with operand bundle \p ID removed.
1230  Instruction *InsertPt = nullptr);
1231 
1232  static bool classof(const Instruction *I) {
1233  return I->getOpcode() == Instruction::Call ||
1234  I->getOpcode() == Instruction::Invoke ||
1235  I->getOpcode() == Instruction::CallBr;
1236  }
1237  static bool classof(const Value *V) {
1238  return isa<Instruction>(V) && classof(cast<Instruction>(V));
1239  }
1240 
1241  FunctionType *getFunctionType() const { return FTy; }
1242 
1245  this->FTy = FTy;
1246  }
1247 
1249 
1250  /// data_operands_begin/data_operands_end - Return iterators iterating over
1251  /// the call / invoke argument list and bundle operands. For invokes, this is
1252  /// the set of instruction operands except the invoke target and the two
1253  /// successor blocks; and for calls this is the set of instruction operands
1254  /// except the call target.
1257  return const_cast<CallBase *>(this)->data_operands_begin();
1258  }
1260  // Walk from the end of the operands over the called operand and any
1261  // subclass operands.
1262  return op_end() - getNumSubclassExtraOperands() - 1;
1263  }
1265  return const_cast<CallBase *>(this)->data_operands_end();
1266  }
1269  }
1272  }
1273  bool data_operands_empty() const {
1274  return data_operands_end() == data_operands_begin();
1275  }
1276  unsigned data_operands_size() const {
1277  return std::distance(data_operands_begin(), data_operands_end());
1278  }
1279 
1280  bool isDataOperand(const Use *U) const {
1281  assert(this == U->getUser() &&
1282  "Only valid to query with a use of this instruction!");
1283  return data_operands_begin() <= U && U < data_operands_end();
1284  }
1286  return isDataOperand(&UI.getUse());
1287  }
1288 
1289  /// Given a value use iterator, return the data operand corresponding to it.
1290  /// Iterator must actually correspond to a data operand.
1292  return getDataOperandNo(&UI.getUse());
1293  }
1294 
1295  /// Given a use for a data operand, get the data operand number that
1296  /// corresponds to it.
1297  unsigned getDataOperandNo(const Use *U) const {
1298  assert(isDataOperand(U) && "Data operand # out of range!");
1299  return U - data_operands_begin();
1300  }
1301 
1302  /// Return the iterator pointing to the beginning of the argument list.
1305  return const_cast<CallBase *>(this)->arg_begin();
1306  }
1307 
1308  /// Return the iterator pointing to the end of the argument list.
1310  // From the end of the data operands, walk backwards past the bundle
1311  // operands.
1313  }
1315  return const_cast<CallBase *>(this)->arg_end();
1316  }
1317 
1318  /// Iteration adapter for range-for loops.
1320  return make_range(arg_begin(), arg_end());
1321  }
1323  return make_range(arg_begin(), arg_end());
1324  }
1325  bool arg_empty() const { return arg_end() == arg_begin(); }
1326  unsigned arg_size() const { return arg_end() - arg_begin(); }
1327 
1328  // Legacy API names that duplicate the above and will be removed once users
1329  // are migrated.
1331  return make_range(arg_begin(), arg_end());
1332  }
1334  return make_range(arg_begin(), arg_end());
1335  }
1336  unsigned getNumArgOperands() const { return arg_size(); }
1337 
1338  Value *getArgOperand(unsigned i) const {
1339  assert(i < getNumArgOperands() && "Out of bounds!");
1340  return getOperand(i);
1341  }
1342 
1343  void setArgOperand(unsigned i, Value *v) {
1344  assert(i < getNumArgOperands() && "Out of bounds!");
1345  setOperand(i, v);
1346  }
1347 
1348  /// Wrappers for getting the \c Use of a call argument.
1349  const Use &getArgOperandUse(unsigned i) const {
1350  assert(i < getNumArgOperands() && "Out of bounds!");
1351  return User::getOperandUse(i);
1352  }
1353  Use &getArgOperandUse(unsigned i) {
1354  assert(i < getNumArgOperands() && "Out of bounds!");
1355  return User::getOperandUse(i);
1356  }
1357 
1358  bool isArgOperand(const Use *U) const {
1359  assert(this == U->getUser() &&
1360  "Only valid to query with a use of this instruction!");
1361  return arg_begin() <= U && U < arg_end();
1362  }
1364  return isArgOperand(&UI.getUse());
1365  }
1366 
1367  /// Given a use for a arg operand, get the arg operand number that
1368  /// corresponds to it.
1369  unsigned getArgOperandNo(const Use *U) const {
1370  assert(isArgOperand(U) && "Arg operand # out of range!");
1371  return U - arg_begin();
1372  }
1373 
1374  /// Given a value use iterator, return the arg operand number corresponding to
1375  /// it. Iterator must actually correspond to a data operand.
1377  return getArgOperandNo(&UI.getUse());
1378  }
1379 
1380  /// Returns true if this CallSite passes the given Value* as an argument to
1381  /// the called function.
1382  bool hasArgument(const Value *V) const {
1383  return llvm::is_contained(args(), V);
1384  }
1385 
1386  Value *getCalledOperand() const { return Op<CalledOperandOpEndIdx>(); }
1387 
1388  const Use &getCalledOperandUse() const { return Op<CalledOperandOpEndIdx>(); }
1389  Use &getCalledOperandUse() { return Op<CalledOperandOpEndIdx>(); }
1390 
1391  /// Returns the function called, or null if this is an
1392  /// indirect function invocation.
1394  return dyn_cast_or_null<Function>(getCalledOperand());
1395  }
1396 
1397  /// Return true if the callsite is an indirect call.
1398  bool isIndirectCall() const;
1399 
1400  /// Determine whether the passed iterator points to the callee operand's Use.
1402  return isCallee(&UI.getUse());
1403  }
1404 
1405  /// Determine whether this Use is the callee operand's Use.
1406  bool isCallee(const Use *U) const { return &getCalledOperandUse() == U; }
1407 
1408  /// Helper to get the caller (the parent function).
1409  Function *getCaller();
1410  const Function *getCaller() const {
1411  return const_cast<CallBase *>(this)->getCaller();
1412  }
1413 
1414  /// Tests if this call site must be tail call optimized. Only a CallInst can
1415  /// be tail call optimized.
1416  bool isMustTailCall() const;
1417 
1418  /// Tests if this call site is marked as a tail call.
1419  bool isTailCall() const;
1420 
1421  /// Returns the intrinsic ID of the intrinsic called or
1422  /// Intrinsic::not_intrinsic if the called function is not an intrinsic, or if
1423  /// this is an indirect call.
1424  Intrinsic::ID getIntrinsicID() const;
1425 
1426  void setCalledOperand(Value *V) { Op<CalledOperandOpEndIdx>() = V; }
1427 
1428  /// Sets the function called, including updating the function type.
1431  }
1432 
1433  /// Sets the function called, including updating the function type.
1436  }
1437 
1438  /// Sets the function called, including updating to the specified function
1439  /// type.
1441  this->FTy = FTy;
1442  assert(cast<PointerType>(Fn->getType())->isOpaqueOrPointeeTypeMatches(FTy));
1443  // This function doesn't mutate the return type, only the function
1444  // type. Seems broken, but I'm just gonna stick an assert in for now.
1445  assert(getType() == FTy->getReturnType());
1446  setCalledOperand(Fn);
1447  }
1448 
1450  return getSubclassData<CallingConvField>();
1451  }
1452 
1454  setSubclassData<CallingConvField>(CC);
1455  }
1456 
1457  /// Check if this call is an inline asm statement.
1458  bool isInlineAsm() const { return isa<InlineAsm>(getCalledOperand()); }
1459 
1460  /// \name Attribute API
1461  ///
1462  /// These methods access and modify attributes on this call (including
1463  /// looking through to the attributes on the called function when necessary).
1464  ///@{
1465 
1466  /// Return the parameter attributes for this call.
1467  ///
1468  AttributeList getAttributes() const { return Attrs; }
1469 
1470  /// Set the parameter attributes for this call.
1471  ///
1473 
1474  /// Determine whether this call has the given attribute. If it does not
1475  /// then determine if the called function has the attribute, but only if
1476  /// the attribute is allowed for the call.
1478  assert(Kind != Attribute::NoBuiltin &&
1479  "Use CallBase::isNoBuiltin() to check for Attribute::NoBuiltin");
1480  return hasFnAttrImpl(Kind);
1481  }
1482 
1483  /// Determine whether this call has the given attribute. If it does not
1484  /// then determine if the called function has the attribute, but only if
1485  /// the attribute is allowed for the call.
1486  bool hasFnAttr(StringRef Kind) const { return hasFnAttrImpl(Kind); }
1487 
1488  /// adds the attribute to the list of attributes.
1490  AttributeList PAL = getAttributes();
1491  PAL = PAL.addAttribute(getContext(), i, Kind);
1492  setAttributes(PAL);
1493  }
1494 
1495  /// adds the attribute to the list of attributes.
1496  void addAttribute(unsigned i, Attribute Attr) {
1497  AttributeList PAL = getAttributes();
1498  PAL = PAL.addAttribute(getContext(), i, Attr);
1499  setAttributes(PAL);
1500  }
1501 
1502  /// Adds the attribute to the indicated argument
1503  void addParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) {
1504  assert(ArgNo < getNumArgOperands() && "Out of bounds");
1505  AttributeList PAL = getAttributes();
1506  PAL = PAL.addParamAttribute(getContext(), ArgNo, Kind);
1507  setAttributes(PAL);
1508  }
1509 
1510  /// Adds the attribute to the indicated argument
1511  void addParamAttr(unsigned ArgNo, Attribute Attr) {
1512  assert(ArgNo < getNumArgOperands() && "Out of bounds");
1513  AttributeList PAL = getAttributes();
1514  PAL = PAL.addParamAttribute(getContext(), ArgNo, Attr);
1515  setAttributes(PAL);
1516  }
1517 
1518  /// removes the attribute from the list of attributes.
1520  AttributeList PAL = getAttributes();
1521  PAL = PAL.removeAttribute(getContext(), i, Kind);
1522  setAttributes(PAL);
1523  }
1524 
1525  /// removes the attribute from the list of attributes.
1526  void removeAttribute(unsigned i, StringRef Kind) {
1527  AttributeList PAL = getAttributes();
1528  PAL = PAL.removeAttribute(getContext(), i, Kind);
1529  setAttributes(PAL);
1530  }
1531 
1532  void removeAttributes(unsigned i, const AttrBuilder &Attrs) {
1533  AttributeList PAL = getAttributes();
1534  PAL = PAL.removeAttributes(getContext(), i, Attrs);
1535  setAttributes(PAL);
1536  }
1537 
1538  /// Removes the attribute from the given argument
1539  void removeParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) {
1540  assert(ArgNo < getNumArgOperands() && "Out of bounds");
1541  AttributeList PAL = getAttributes();
1542  PAL = PAL.removeParamAttribute(getContext(), ArgNo, Kind);
1543  setAttributes(PAL);
1544  }
1545 
1546  /// Removes the attribute from the given argument
1547  void removeParamAttr(unsigned ArgNo, StringRef Kind) {
1548  assert(ArgNo < getNumArgOperands() && "Out of bounds");
1549  AttributeList PAL = getAttributes();
1550  PAL = PAL.removeParamAttribute(getContext(), ArgNo, Kind);
1551  setAttributes(PAL);
1552  }
1553 
1554  /// Removes the attributes from the given argument
1555  void removeParamAttrs(unsigned ArgNo, const AttrBuilder &Attrs) {
1556  AttributeList PAL = getAttributes();
1557  PAL = PAL.removeParamAttributes(getContext(), ArgNo, Attrs);
1558  setAttributes(PAL);
1559  }
1560 
1561  /// adds the dereferenceable attribute to the list of attributes.
1562  void addDereferenceableAttr(unsigned i, uint64_t Bytes) {
1563  AttributeList PAL = getAttributes();
1564  PAL = PAL.addDereferenceableAttr(getContext(), i, Bytes);
1565  setAttributes(PAL);
1566  }
1567 
1568  /// adds the dereferenceable_or_null attribute to the list of
1569  /// attributes.
1570  void addDereferenceableOrNullAttr(unsigned i, uint64_t Bytes) {
1571  AttributeList PAL = getAttributes();
1572  PAL = PAL.addDereferenceableOrNullAttr(getContext(), i, Bytes);
1573  setAttributes(PAL);
1574  }
1575 
1576  /// Determine whether the return value has the given attribute.
1578  return hasRetAttrImpl(Kind);
1579  }
1580  /// Determine whether the return value has the given attribute.
1581  bool hasRetAttr(StringRef Kind) const { return hasRetAttrImpl(Kind); }
1582 
1583  /// Determine whether the argument or parameter has the given attribute.
1584  bool paramHasAttr(unsigned ArgNo, Attribute::AttrKind Kind) const;
1585 
1586  /// Get the attribute of a given kind at a position.
1588  return getAttributes().getAttribute(i, Kind);
1589  }
1590 
1591  /// Get the attribute of a given kind at a position.
1593  return getAttributes().getAttribute(i, Kind);
1594  }
1595 
1596  /// Get the attribute of a given kind from a given arg
1598  assert(ArgNo < getNumArgOperands() && "Out of bounds");
1599  return getAttributes().getParamAttr(ArgNo, Kind);
1600  }
1601 
1602  /// Get the attribute of a given kind from a given arg
1603  Attribute getParamAttr(unsigned ArgNo, StringRef Kind) const {
1604  assert(ArgNo < getNumArgOperands() && "Out of bounds");
1605  return getAttributes().getParamAttr(ArgNo, Kind);
1606  }
1607 
1608  /// Return true if the data operand at index \p i has the attribute \p
1609  /// A.
1610  ///
1611  /// Data operands include call arguments and values used in operand bundles,
1612  /// but does not include the callee operand. This routine dispatches to the
1613  /// underlying AttributeList or the OperandBundleUser as appropriate.
1614  ///
1615  /// The index \p i is interpreted as
1616  ///
1617  /// \p i == Attribute::ReturnIndex -> the return value
1618  /// \p i in [1, arg_size + 1) -> argument number (\p i - 1)
1619  /// \p i in [arg_size + 1, data_operand_size + 1) -> bundle operand at index
1620  /// (\p i - 1) in the operand list.
1622  // Note that we have to add one because `i` isn't zero-indexed.
1624  "Data operand index out of bounds!");
1625 
1626  // The attribute A can either be directly specified, if the operand in
1627  // question is a call argument; or be indirectly implied by the kind of its
1628  // containing operand bundle, if the operand is a bundle operand.
1629 
1631  return hasRetAttr(Kind);
1632 
1633  // FIXME: Avoid these i - 1 calculations and update the API to use
1634  // zero-based indices.
1635  if (i < (getNumArgOperands() + 1))
1636  return paramHasAttr(i - 1, Kind);
1637 
1639  "Must be either a call argument or an operand bundle!");
1640  return bundleOperandHasAttr(i - 1, Kind);
1641  }
1642 
1643  /// Determine whether this data operand is not captured.
1644  // FIXME: Once this API is no longer duplicated in `CallSite`, rename this to
1645  // better indicate that this may return a conservative answer.
1646  bool doesNotCapture(unsigned OpNo) const {
1647  return dataOperandHasImpliedAttr(OpNo + 1, Attribute::NoCapture);
1648  }
1649 
1650  /// Determine whether this argument is passed by value.
1651  bool isByValArgument(unsigned ArgNo) const {
1652  return paramHasAttr(ArgNo, Attribute::ByVal);
1653  }
1654 
1655  /// Determine whether this argument is passed in an alloca.
1656  bool isInAllocaArgument(unsigned ArgNo) const {
1657  return paramHasAttr(ArgNo, Attribute::InAlloca);
1658  }
1659 
1660  /// Determine whether this argument is passed by value, in an alloca, or is
1661  /// preallocated.
1662  bool isPassPointeeByValueArgument(unsigned ArgNo) const {
1663  return paramHasAttr(ArgNo, Attribute::ByVal) ||
1664  paramHasAttr(ArgNo, Attribute::InAlloca) ||
1665  paramHasAttr(ArgNo, Attribute::Preallocated);
1666  }
1667 
1668  /// Determine whether passing undef to this argument is undefined behavior.
1669  /// If passing undef to this argument is UB, passing poison is UB as well
1670  /// because poison is more undefined than undef.
1671  bool isPassingUndefUB(unsigned ArgNo) const {
1672  return paramHasAttr(ArgNo, Attribute::NoUndef) ||
1673  // dereferenceable implies noundef.
1674  paramHasAttr(ArgNo, Attribute::Dereferenceable) ||
1675  // dereferenceable implies noundef, and null is a well-defined value.
1676  paramHasAttr(ArgNo, Attribute::DereferenceableOrNull);
1677  }
1678 
1679  /// Determine if there are is an inalloca argument. Only the last argument can
1680  /// have the inalloca attribute.
1681  bool hasInAllocaArgument() const {
1682  return !arg_empty() && paramHasAttr(arg_size() - 1, Attribute::InAlloca);
1683  }
1684 
1685  // FIXME: Once this API is no longer duplicated in `CallSite`, rename this to
1686  // better indicate that this may return a conservative answer.
1687  bool doesNotAccessMemory(unsigned OpNo) const {
1688  return dataOperandHasImpliedAttr(OpNo + 1, Attribute::ReadNone);
1689  }
1690 
1691  // FIXME: Once this API is no longer duplicated in `CallSite`, rename this to
1692  // better indicate that this may return a conservative answer.
1693  bool onlyReadsMemory(unsigned OpNo) const {
1694  return dataOperandHasImpliedAttr(OpNo + 1, Attribute::ReadOnly) ||
1695  dataOperandHasImpliedAttr(OpNo + 1, Attribute::ReadNone);
1696  }
1697 
1698  // FIXME: Once this API is no longer duplicated in `CallSite`, rename this to
1699  // better indicate that this may return a conservative answer.
1700  bool doesNotReadMemory(unsigned OpNo) const {
1701  return dataOperandHasImpliedAttr(OpNo + 1, Attribute::WriteOnly) ||
1702  dataOperandHasImpliedAttr(OpNo + 1, Attribute::ReadNone);
1703  }
1704 
1705  /// Extract the alignment of the return value.
1707 
1708  /// Extract the alignment for a call or parameter (0=unknown).
1709  MaybeAlign getParamAlign(unsigned ArgNo) const {
1710  return Attrs.getParamAlignment(ArgNo);
1711  }
1712 
1713  MaybeAlign getParamStackAlign(unsigned ArgNo) const {
1714  return Attrs.getParamStackAlignment(ArgNo);
1715  }
1716 
1717  /// Extract the byval type for a call or parameter.
1718  Type *getParamByValType(unsigned ArgNo) const {
1719  if (auto *Ty = Attrs.getParamByValType(ArgNo))
1720  return Ty;
1721  if (const Function *F = getCalledFunction())
1722  return F->getAttributes().getParamByValType(ArgNo);
1723  return nullptr;
1724  }
1725 
1726  /// Extract the preallocated type for a call or parameter.
1727  Type *getParamPreallocatedType(unsigned ArgNo) const {
1728  if (auto *Ty = Attrs.getParamPreallocatedType(ArgNo))
1729  return Ty;
1730  if (const Function *F = getCalledFunction())
1731  return F->getAttributes().getParamPreallocatedType(ArgNo);
1732  return nullptr;
1733  }
1734 
1735  /// Extract the preallocated type for a call or parameter.
1736  Type *getParamInAllocaType(unsigned ArgNo) const {
1737  if (auto *Ty = Attrs.getParamInAllocaType(ArgNo))
1738  return Ty;
1739  if (const Function *F = getCalledFunction())
1740  return F->getAttributes().getParamInAllocaType(ArgNo);
1741  return nullptr;
1742  }
1743 
1744  /// Extract the number of dereferenceable bytes for a call or
1745  /// parameter (0=unknown).
1746  uint64_t getDereferenceableBytes(unsigned i) const {
1748  }
1749 
1750  /// Extract the number of dereferenceable_or_null bytes for a call or
1751  /// parameter (0=unknown).
1752  uint64_t getDereferenceableOrNullBytes(unsigned i) const {
1754  }
1755 
1756  /// Return true if the return value is known to be not null.
1757  /// This may be because it has the nonnull attribute, or because at least
1758  /// one byte is dereferenceable and the pointer is in addrspace(0).
1759  bool isReturnNonNull() const;
1760 
1761  /// Determine if the return value is marked with NoAlias attribute.
1762  bool returnDoesNotAlias() const {
1763  return Attrs.hasAttribute(AttributeList::ReturnIndex, Attribute::NoAlias);
1764  }
1765 
1766  /// If one of the arguments has the 'returned' attribute, returns its
1767  /// operand value. Otherwise, return nullptr.
1768  Value *getReturnedArgOperand() const;
1769 
1770  /// Return true if the call should not be treated as a call to a
1771  /// builtin.
1772  bool isNoBuiltin() const {
1773  return hasFnAttrImpl(Attribute::NoBuiltin) &&
1774  !hasFnAttrImpl(Attribute::Builtin);
1775  }
1776 
1777  /// Determine if the call requires strict floating point semantics.
1778  bool isStrictFP() const { return hasFnAttr(Attribute::StrictFP); }
1779 
1780  /// Return true if the call should not be inlined.
1781  bool isNoInline() const { return hasFnAttr(Attribute::NoInline); }
1782  void setIsNoInline() {
1783  addAttribute(AttributeList::FunctionIndex, Attribute::NoInline);
1784  }
1785  /// Determine if the call does not access memory.
1786  bool doesNotAccessMemory() const { return hasFnAttr(Attribute::ReadNone); }
1788  addAttribute(AttributeList::FunctionIndex, Attribute::ReadNone);
1789  }
1790 
1791  /// Determine if the call does not access or only reads memory.
1792  bool onlyReadsMemory() const {
1794  }
1795 
1798  }
1799 
1800  /// Determine if the call does not access or only writes memory.
1801  bool doesNotReadMemory() const {
1802  return doesNotAccessMemory() || hasFnAttr(Attribute::WriteOnly);
1803  }
1805  addAttribute(AttributeList::FunctionIndex, Attribute::WriteOnly);
1806  }
1807 
1808  /// Determine if the call can access memmory only using pointers based
1809  /// on its arguments.
1810  bool onlyAccessesArgMemory() const {
1811  return hasFnAttr(Attribute::ArgMemOnly);
1812  }
1814  addAttribute(AttributeList::FunctionIndex, Attribute::ArgMemOnly);
1815  }
1816 
1817  /// Determine if the function may only access memory that is
1818  /// inaccessible from the IR.
1820  return hasFnAttr(Attribute::InaccessibleMemOnly);
1821  }
1823  addAttribute(AttributeList::FunctionIndex, Attribute::InaccessibleMemOnly);
1824  }
1825 
1826  /// Determine if the function may only access memory that is
1827  /// either inaccessible from the IR or pointed to by its arguments.
1829  return hasFnAttr(Attribute::InaccessibleMemOrArgMemOnly);
1830  }
1833  Attribute::InaccessibleMemOrArgMemOnly);
1834  }
1835  /// Determine if the call cannot return.
1836  bool doesNotReturn() const { return hasFnAttr(Attribute::NoReturn); }
1838  addAttribute(AttributeList::FunctionIndex, Attribute::NoReturn);
1839  }
1840 
1841  /// Determine if the call should not perform indirect branch tracking.
1842  bool doesNoCfCheck() const { return hasFnAttr(Attribute::NoCfCheck); }
1843 
1844  /// Determine if the call cannot unwind.
1845  bool doesNotThrow() const { return hasFnAttr(Attribute::NoUnwind); }
1847  addAttribute(AttributeList::FunctionIndex, Attribute::NoUnwind);
1848  }
1849 
1850  /// Determine if the invoke cannot be duplicated.
1851  bool cannotDuplicate() const { return hasFnAttr(Attribute::NoDuplicate); }
1853  addAttribute(AttributeList::FunctionIndex, Attribute::NoDuplicate);
1854  }
1855 
1856  /// Determine if the call cannot be tail merged.
1857  bool cannotMerge() const { return hasFnAttr(Attribute::NoMerge); }
1859  addAttribute(AttributeList::FunctionIndex, Attribute::NoMerge);
1860  }
1861 
1862  /// Determine if the invoke is convergent
1864  void setConvergent() {
1866  }
1869  }
1870 
1871  /// Determine if the call returns a structure through first
1872  /// pointer argument.
1873  bool hasStructRetAttr() const {
1874  if (getNumArgOperands() == 0)
1875  return false;
1876 
1877  // Be friendly and also check the callee.
1878  return paramHasAttr(0, Attribute::StructRet);
1879  }
1880 
1881  /// Determine if any call argument is an aggregate passed by value.
1882  bool hasByValArgument() const {
1883  return Attrs.hasAttrSomewhere(Attribute::ByVal);
1884  }
1885 
1886  ///@{
1887  // End of attribute API.
1888 
1889  /// \name Operand Bundle API
1890  ///
1891  /// This group of methods provides the API to access and manipulate operand
1892  /// bundles on this call.
1893  /// @{
1894 
1895  /// Return the number of operand bundles associated with this User.
1896  unsigned getNumOperandBundles() const {
1897  return std::distance(bundle_op_info_begin(), bundle_op_info_end());
1898  }
1899 
1900  /// Return true if this User has any operand bundles.
1901  bool hasOperandBundles() const { return getNumOperandBundles() != 0; }
1902 
1903  /// Return the index of the first bundle operand in the Use array.
1904  unsigned getBundleOperandsStartIndex() const {
1905  assert(hasOperandBundles() && "Don't call otherwise!");
1906  return bundle_op_info_begin()->Begin;
1907  }
1908 
1909  /// Return the index of the last bundle operand in the Use array.
1910  unsigned getBundleOperandsEndIndex() const {
1911  assert(hasOperandBundles() && "Don't call otherwise!");
1912  return bundle_op_info_end()[-1].End;
1913  }
1914 
1915  /// Return true if the operand at index \p Idx is a bundle operand.
1916  bool isBundleOperand(unsigned Idx) const {
1917  return hasOperandBundles() && Idx >= getBundleOperandsStartIndex() &&
1918  Idx < getBundleOperandsEndIndex();
1919  }
1920 
1921  /// Returns true if the use is a bundle operand.
1922  bool isBundleOperand(const Use *U) const {
1923  assert(this == U->getUser() &&
1924  "Only valid to query with a use of this instruction!");
1925  return hasOperandBundles() && isBundleOperand(U - op_begin());
1926  }
1928  return isBundleOperand(&UI.getUse());
1929  }
1930 
1931  /// Return the total number operands (not operand bundles) used by
1932  /// every operand bundle in this OperandBundleUser.
1933  unsigned getNumTotalBundleOperands() const {
1934  if (!hasOperandBundles())
1935  return 0;
1936 
1937  unsigned Begin = getBundleOperandsStartIndex();
1938  unsigned End = getBundleOperandsEndIndex();
1939 
1940  assert(Begin <= End && "Should be!");
1941  return End - Begin;
1942  }
1943 
1944  /// Return the operand bundle at a specific index.
1946  assert(Index < getNumOperandBundles() && "Index out of bounds!");
1948  }
1949 
1950  /// Return the number of operand bundles with the tag Name attached to
1951  /// this instruction.
1953  unsigned Count = 0;
1954  for (unsigned i = 0, e = getNumOperandBundles(); i != e; ++i)
1955  if (getOperandBundleAt(i).getTagName() == Name)
1956  Count++;
1957 
1958  return Count;
1959  }
1960 
1961  /// Return the number of operand bundles with the tag ID attached to
1962  /// this instruction.
1964  unsigned Count = 0;
1965  for (unsigned i = 0, e = getNumOperandBundles(); i != e; ++i)
1966  if (getOperandBundleAt(i).getTagID() == ID)
1967  Count++;
1968 
1969  return Count;
1970  }
1971 
1972  /// Return an operand bundle by name, if present.
1973  ///
1974  /// It is an error to call this for operand bundle types that may have
1975  /// multiple instances of them on the same instruction.
1977  assert(countOperandBundlesOfType(Name) < 2 && "Precondition violated!");
1978 
1979  for (unsigned i = 0, e = getNumOperandBundles(); i != e; ++i) {
1981  if (U.getTagName() == Name)
1982  return U;
1983  }
1984 
1985  return None;
1986  }
1987 
1988  /// Return an operand bundle by tag ID, if present.
1989  ///
1990  /// It is an error to call this for operand bundle types that may have
1991  /// multiple instances of them on the same instruction.
1993  assert(countOperandBundlesOfType(ID) < 2 && "Precondition violated!");
1994 
1995  for (unsigned i = 0, e = getNumOperandBundles(); i != e; ++i) {
1997  if (U.getTagID() == ID)
1998  return U;
1999  }
2000 
2001  return None;
2002  }
2003 
2004  /// Return the list of operand bundles attached to this instruction as
2005  /// a vector of OperandBundleDefs.
2006  ///
2007  /// This function copies the OperandBundeUse instances associated with this
2008  /// OperandBundleUser to a vector of OperandBundleDefs. Note:
2009  /// OperandBundeUses and OperandBundleDefs are non-trivially *different*
2010  /// representations of operand bundles (see documentation above).
2012 
2013  /// Return the operand bundle for the operand at index OpIdx.
2014  ///
2015  /// It is an error to call this with an OpIdx that does not correspond to an
2016  /// bundle operand.
2019  }
2020 
2021  /// Return true if this operand bundle user has operand bundles that
2022  /// may read from the heap.
2023  bool hasReadingOperandBundles() const;
2024 
2025  /// Return true if this operand bundle user has operand bundles that
2026  /// may write to the heap.
2028  for (auto &BOI : bundle_op_infos()) {
2029  if (BOI.Tag->second == LLVMContext::OB_deopt ||
2030  BOI.Tag->second == LLVMContext::OB_funclet)
2031  continue;
2032 
2033  // This instruction has an operand bundle that is not known to us.
2034  // Assume the worst.
2035  return true;
2036  }
2037 
2038  return false;
2039  }
2040 
2041  /// Return true if the bundle operand at index \p OpIdx has the
2042  /// attribute \p A.
2043  bool bundleOperandHasAttr(unsigned OpIdx, Attribute::AttrKind A) const {
2044  auto &BOI = getBundleOpInfoForOperand(OpIdx);
2045  auto OBU = operandBundleFromBundleOpInfo(BOI);
2046  return OBU.operandHasAttr(OpIdx - BOI.Begin, A);
2047  }
2048 
2049  /// Return true if \p Other has the same sequence of operand bundle
2050  /// tags with the same number of operands on each one of them as this
2051  /// OperandBundleUser.
2052  bool hasIdenticalOperandBundleSchema(const CallBase &Other) const {
2053  if (getNumOperandBundles() != Other.getNumOperandBundles())
2054  return false;
2055 
2057  Other.bundle_op_info_begin());
2058  }
2059 
2060  /// Return true if this operand bundle user contains operand bundles
2061  /// with tags other than those specified in \p IDs.
2063  for (unsigned i = 0, e = getNumOperandBundles(); i != e; ++i) {
2065  if (!is_contained(IDs, ID))
2066  return true;
2067  }
2068  return false;
2069  }
2070 
2071  /// Is the function attribute S disallowed by some operand bundle on
2072  /// this operand bundle user?
2074  // Operand bundles only possibly disallow readnone, readonly and argmemonly
2075  // attributes. All String attributes are fine.
2076  return false;
2077  }
2078 
2079  /// Is the function attribute A disallowed by some operand bundle on
2080  /// this operand bundle user?
2082  switch (A) {
2083  default:
2084  return false;
2085 
2086  case Attribute::InaccessibleMemOrArgMemOnly:
2087  return hasReadingOperandBundles();
2088 
2089  case Attribute::InaccessibleMemOnly:
2090  return hasReadingOperandBundles();
2091 
2092  case Attribute::ArgMemOnly:
2093  return hasReadingOperandBundles();
2094 
2095  case Attribute::ReadNone:
2096  return hasReadingOperandBundles();
2097 
2098  case Attribute::ReadOnly:
2099  return hasClobberingOperandBundles();
2100  }
2101 
2102  llvm_unreachable("switch has a default case!");
2103  }
2104 
2105  /// Used to keep track of an operand bundle. See the main comment on
2106  /// OperandBundleUser above.
2107  struct BundleOpInfo {
2108  /// The operand bundle tag, interned by
2109  /// LLVMContextImpl::getOrInsertBundleTag.
2111 
2112  /// The index in the Use& vector where operands for this operand
2113  /// bundle starts.
2115 
2116  /// The index in the Use& vector where operands for this operand
2117  /// bundle ends.
2119 
2120  bool operator==(const BundleOpInfo &Other) const {
2121  return Tag == Other.Tag && Begin == Other.Begin && End == Other.End;
2122  }
2123  };
2124 
2125  /// Simple helper function to map a BundleOpInfo to an
2126  /// OperandBundleUse.
2129  auto begin = op_begin();
2130  ArrayRef<Use> Inputs(begin + BOI.Begin, begin + BOI.End);
2131  return OperandBundleUse(BOI.Tag, Inputs);
2132  }
2133 
2136 
2137  /// Return the start of the list of BundleOpInfo instances associated
2138  /// with this OperandBundleUser.
2139  ///
2140  /// OperandBundleUser uses the descriptor area co-allocated with the host User
2141  /// to store some meta information about which operands are "normal" operands,
2142  /// and which ones belong to some operand bundle.
2143  ///
2144  /// The layout of an operand bundle user is
2145  ///
2146  /// +-----------uint32_t End-------------------------------------+
2147  /// | |
2148  /// | +--------uint32_t Begin--------------------+ |
2149  /// | | | |
2150  /// ^ ^ v v
2151  /// |------|------|----|----|----|----|----|---------|----|---------|----|-----
2152  /// | BOI0 | BOI1 | .. | DU | U0 | U1 | .. | BOI0_U0 | .. | BOI1_U0 | .. | Un
2153  /// |------|------|----|----|----|----|----|---------|----|---------|----|-----
2154  /// v v ^ ^
2155  /// | | | |
2156  /// | +--------uint32_t Begin------------+ |
2157  /// | |
2158  /// +-----------uint32_t End-----------------------------+
2159  ///
2160  ///
2161  /// BOI0, BOI1 ... are descriptions of operand bundles in this User's use
2162  /// list. These descriptions are installed and managed by this class, and
2163  /// they're all instances of OperandBundleUser<T>::BundleOpInfo.
2164  ///
2165  /// DU is an additional descriptor installed by User's 'operator new' to keep
2166  /// track of the 'BOI0 ... BOIN' co-allocation. OperandBundleUser does not
2167  /// access or modify DU in any way, it's an implementation detail private to
2168  /// User.
2169  ///
2170  /// The regular Use& vector for the User starts at U0. The operand bundle
2171  /// uses are part of the Use& vector, just like normal uses. In the diagram
2172  /// above, the operand bundle uses start at BOI0_U0. Each instance of
2173  /// BundleOpInfo has information about a contiguous set of uses constituting
2174  /// an operand bundle, and the total set of operand bundle uses themselves
2175  /// form a contiguous set of uses (i.e. there are no gaps between uses
2176  /// corresponding to individual operand bundles).
2177  ///
2178  /// This class does not know the location of the set of operand bundle uses
2179  /// within the use list -- that is decided by the User using this class via
2180  /// the BeginIdx argument in populateBundleOperandInfos.
2181  ///
2182  /// Currently operand bundle users with hung-off operands are not supported.
2184  if (!hasDescriptor())
2185  return nullptr;
2186 
2187  uint8_t *BytesBegin = getDescriptor().begin();
2188  return reinterpret_cast<bundle_op_iterator>(BytesBegin);
2189  }
2190 
2191  /// Return the start of the list of BundleOpInfo instances associated
2192  /// with this OperandBundleUser.
2194  auto *NonConstThis = const_cast<CallBase *>(this);
2195  return NonConstThis->bundle_op_info_begin();
2196  }
2197 
2198  /// Return the end of the list of BundleOpInfo instances associated
2199  /// with this OperandBundleUser.
2201  if (!hasDescriptor())
2202  return nullptr;
2203 
2204  uint8_t *BytesEnd = getDescriptor().end();
2205  return reinterpret_cast<bundle_op_iterator>(BytesEnd);
2206  }
2207 
2208  /// Return the end of the list of BundleOpInfo instances associated
2209  /// with this OperandBundleUser.
2211  auto *NonConstThis = const_cast<CallBase *>(this);
2212  return NonConstThis->bundle_op_info_end();
2213  }
2214 
2215  /// Return the range [\p bundle_op_info_begin, \p bundle_op_info_end).
2218  }
2219 
2220  /// Return the range [\p bundle_op_info_begin, \p bundle_op_info_end).
2223  }
2224 
2225  /// Populate the BundleOpInfo instances and the Use& vector from \p
2226  /// Bundles. Return the op_iterator pointing to the Use& one past the last
2227  /// last bundle operand use.
2228  ///
2229  /// Each \p OperandBundleDef instance is tracked by a OperandBundleInfo
2230  /// instance allocated in this User's descriptor.
2232  const unsigned BeginIndex);
2233 
2234 public:
2235  /// Return the BundleOpInfo for the operand at index OpIdx.
2236  ///
2237  /// It is an error to call this with an OpIdx that does not correspond to an
2238  /// bundle operand.
2239  BundleOpInfo &getBundleOpInfoForOperand(unsigned OpIdx);
2240  const BundleOpInfo &getBundleOpInfoForOperand(unsigned OpIdx) const {
2241  return const_cast<CallBase *>(this)->getBundleOpInfoForOperand(OpIdx);
2242  }
2243 
2244 protected:
2245  /// Return the total number of values used in \p Bundles.
2247  unsigned Total = 0;
2248  for (auto &B : Bundles)
2249  Total += B.input_size();
2250  return Total;
2251  }
2252 
2253  /// @}
2254  // End of operand bundle API.
2255 
2256 private:
2257  bool hasFnAttrOnCalledFunction(Attribute::AttrKind Kind) const;
2258  bool hasFnAttrOnCalledFunction(StringRef Kind) const;
2259 
2260  template <typename AttrKind> bool hasFnAttrImpl(AttrKind Kind) const {
2261  if (Attrs.hasFnAttribute(Kind))
2262  return true;
2263 
2264  // Operand bundles override attributes on the called function, but don't
2265  // override attributes directly present on the call instruction.
2267  return false;
2268 
2269  return hasFnAttrOnCalledFunction(Kind);
2270  }
2271 
2272  /// Determine whether the return value has the given attribute. Supports
2273  /// Attribute::AttrKind and StringRef as \p AttrKind types.
2274  template <typename AttrKind> bool hasRetAttrImpl(AttrKind Kind) const {
2276  return true;
2277 
2278  // Look at the callee, if available.
2279  if (const Function *F = getCalledFunction())
2280  return F->getAttributes().hasAttribute(AttributeList::ReturnIndex, Kind);
2281  return false;
2282  }
2283 };
2284 
2285 template <>
2286 struct OperandTraits<CallBase> : public VariadicOperandTraits<CallBase, 1> {};
2287 
2289 
2290 //===----------------------------------------------------------------------===//
2291 // FuncletPadInst Class
2292 //===----------------------------------------------------------------------===//
2293 class FuncletPadInst : public Instruction {
2294 private:
2295  FuncletPadInst(const FuncletPadInst &CPI);
2296 
2297  explicit FuncletPadInst(Instruction::FuncletPadOps Op, Value *ParentPad,
2298  ArrayRef<Value *> Args, unsigned Values,
2299  const Twine &NameStr, Instruction *InsertBefore);
2300  explicit FuncletPadInst(Instruction::FuncletPadOps Op, Value *ParentPad,
2301  ArrayRef<Value *> Args, unsigned Values,
2302  const Twine &NameStr, BasicBlock *InsertAtEnd);
2303 
2304  void init(Value *ParentPad, ArrayRef<Value *> Args, const Twine &NameStr);
2305 
2306 protected:
2307  // Note: Instruction needs to be a friend here to call cloneImpl.
2308  friend class Instruction;
2309  friend class CatchPadInst;
2310  friend class CleanupPadInst;
2311 
2312  FuncletPadInst *cloneImpl() const;
2313 
2314 public:
2315  /// Provide fast operand accessors
2317 
2318  /// getNumArgOperands - Return the number of funcletpad arguments.
2319  ///
2320  unsigned getNumArgOperands() const { return getNumOperands() - 1; }
2321 
2322  /// Convenience accessors
2323 
2324  /// Return the outer EH-pad this funclet is nested within.
2325  ///
2326  /// Note: This returns the associated CatchSwitchInst if this FuncletPadInst
2327  /// is a CatchPadInst.
2328  Value *getParentPad() const { return Op<-1>(); }
2329  void setParentPad(Value *ParentPad) {
2330  assert(ParentPad);
2331  Op<-1>() = ParentPad;
2332  }
2333 
2334  /// getArgOperand/setArgOperand - Return/set the i-th funcletpad argument.
2335  ///
2336  Value *getArgOperand(unsigned i) const { return getOperand(i); }
2337  void setArgOperand(unsigned i, Value *v) { setOperand(i, v); }
2338 
2339  /// arg_operands - iteration adapter for range-for loops.
2340  op_range arg_operands() { return op_range(op_begin(), op_end() - 1); }
2341 
2342  /// arg_operands - iteration adapter for range-for loops.
2344  return const_op_range(op_begin(), op_end() - 1);
2345  }
2346 
2347  // Methods for support type inquiry through isa, cast, and dyn_cast:
2348  static bool classof(const Instruction *I) { return I->isFuncletPad(); }
2349  static bool classof(const Value *V) {
2350  return isa<Instruction>(V) && classof(cast<Instruction>(V));
2351  }
2352 };
2353 
2354 template <>
2356  : public VariadicOperandTraits<FuncletPadInst, /*MINARITY=*/1> {};
2357 
2359 
2360 } // end namespace llvm
2361 
2362 #endif // LLVM_IR_INSTRTYPES_H
llvm::CallBase::bundle_op_info_end
const_bundle_op_iterator bundle_op_info_end() const
Return the end of the list of BundleOpInfo instances associated with this OperandBundleUser.
Definition: InstrTypes.h:2210
i
i
Definition: README.txt:29
llvm::AttributeList::getParamInAllocaType
Type * getParamInAllocaType(unsigned ArgNo) const
Return the inalloca type for the specified function parameter.
Definition: Attributes.cpp:1455
llvm::CallBase::getNumOperandBundles
unsigned getNumOperandBundles() const
Return the number of operand bundles associated with this User.
Definition: InstrTypes.h:1896
llvm::CmpInst::FCMP_ULE
@ FCMP_ULE
1 1 0 1 True if unordered, less than, or equal
Definition: InstrTypes.h:735
llvm::CallBase::hasStructRetAttr
bool hasStructRetAttr() const
Determine if the call returns a structure through first pointer argument.
Definition: InstrTypes.h:1873
llvm::CmpInst::DECLARE_TRANSPARENT_OPERAND_ACCESSORS
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)
Provide more efficient getOperand methods.
llvm::CallBase::returnDoesNotAlias
bool returnDoesNotAlias() const
Determine if the return value is marked with NoAlias attribute.
Definition: InstrTypes.h:1762
llvm::Value::const_user_iterator
user_iterator_impl< const User > const_user_iterator
Definition: Value.h:392
llvm::OperandBundleDefT::inputs
ArrayRef< InputTy > inputs() const
Definition: InstrTypes.h:1129
llvm::CallBase::bundle_op_info_begin
const_bundle_op_iterator bundle_op_info_begin() const
Return the start of the list of BundleOpInfo instances associated with this OperandBundleUser.
Definition: InstrTypes.h:2193
llvm::BinaryOperator::DECLARE_TRANSPARENT_OPERAND_ACCESSORS
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)
Transparently provide more efficient getOperand methods.
llvm::CallBase::getOperandBundleForOperand
OperandBundleUse getOperandBundleForOperand(unsigned OpIdx) const
Return the operand bundle for the operand at index OpIdx.
Definition: InstrTypes.h:2017
llvm::CmpInst::getSwappedPredicate
Predicate getSwappedPredicate() const
For example, EQ->EQ, SLE->SGE, ULT->UGT, OEQ->OEQ, ULE->UGE, OLT->OGT, etc.
Definition: InstrTypes.h:836
llvm::CallBase::arg_begin
User::const_op_iterator arg_begin() const
Definition: InstrTypes.h:1304
llvm
---------------------— PointerInfo ------------------------------------—
Definition: AllocatorList.h:23
llvm::CallBase::isNoBuiltin
bool isNoBuiltin() const
Return true if the call should not be treated as a call to a builtin.
Definition: InstrTypes.h:1772
llvm::CallBase::getOperandBundlesAsDefs
void getOperandBundlesAsDefs(SmallVectorImpl< OperandBundleDef > &Defs) const
Return the list of operand bundles attached to this instruction as a vector of OperandBundleDefs.
Definition: Instructions.cpp:365
llvm::Type::getInt1Ty
static IntegerType * getInt1Ty(LLVMContext &C)
Definition: Type.cpp:200
llvm::CallBase::DECLARE_TRANSPARENT_OPERAND_ACCESSORS
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)
llvm::CmpInst::ICMP_EQ
@ ICMP_EQ
equal
Definition: InstrTypes.h:741
llvm::CallBase::getBundleOperandsEndIndex
unsigned getBundleOperandsEndIndex() const
Return the index of the last bundle operand in the Use array.
Definition: InstrTypes.h:1910
llvm::make_range
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
Definition: iterator_range.h:53
llvm::StringMapEntry< uint32_t >
llvm::CallBase::getOperandBundle
Optional< OperandBundleUse > getOperandBundle(StringRef Name) const
Return an operand bundle by name, if present.
Definition: InstrTypes.h:1976
Optional.h
llvm::AttributeList::hasFnAttribute
bool hasFnAttribute(Attribute::AttrKind Kind) const
Equivalent to hasAttribute(AttributeList::FunctionIndex, Kind) but may be faster.
Definition: Attributes.cpp:1400
llvm::DataLayout
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:112
llvm::Instruction::UnaryOps
UnaryOps
Definition: Instruction.h:780
llvm::CallBase::arg_end
User::const_op_iterator arg_end() const
Definition: InstrTypes.h:1314
llvm::CallBase::isBundleOperand
bool isBundleOperand(const Use *U) const
Returns true if the use is a bundle operand.
Definition: InstrTypes.h:1922
llvm::AttributeList::hasAttrSomewhere
bool hasAttrSomewhere(Attribute::AttrKind Kind, unsigned *Index=nullptr) const
Return true if the specified attribute is set for at least one parameter or for the return value.
Definition: Attributes.cpp:1413
llvm::CmpInst::Predicate
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
Definition: InstrTypes.h:720
llvm::CmpInst::getUnsignedPredicate
Predicate getUnsignedPredicate()
For example, SLT->ULT, SLE->ULE, SGT->UGT, SGE->UGE, ULT->Failed assert.
Definition: InstrTypes.h:965
llvm::CallBase::doesNotReturn
bool doesNotReturn() const
Determine if the call cannot return.
Definition: InstrTypes.h:1836
llvm::CallBase::removeOperandBundle
static CallBase * removeOperandBundle(CallBase *CB, uint32_t ID, Instruction *InsertPt=nullptr)
Create a clone of CB with operand bundle ID removed.
Definition: Instructions.cpp:456
llvm::BinaryOperator::Instruction
friend class Instruction
Definition: InstrTypes.h:199
llvm::CallBase::getArgOperandUse
Use & getArgOperandUse(unsigned i)
Definition: InstrTypes.h:1353
llvm::AttributeList::addDereferenceableOrNullAttr
LLVM_NODISCARD AttributeList addDereferenceableOrNullAttr(LLVMContext &C, unsigned Index, uint64_t Bytes) const
Add the dereferenceable_or_null attribute to the attribute set at the given index.
Definition: Attributes.cpp:1347
llvm::Function
Definition: Function.h:61
llvm::CallBase::hasInAllocaArgument
bool hasInAllocaArgument() const
Determine if there are is an inalloca argument.
Definition: InstrTypes.h:1681
llvm::Attribute
Definition: Attributes.h:52
StringRef.h
llvm::CmpInst::swapOperands
void swapOperands()
This is just a convenience that dispatches to the subclasses.
Definition: Instructions.cpp:3741
P
This currently compiles esp xmm0 movsd esp eax eax esp ret We should use not the dag combiner This is because dagcombine2 needs to be able to see through the X86ISD::Wrapper which DAGCombine can t really do The code for turning x load into a single vector load is target independent and should be moved to the dag combiner The code for turning x load into a vector load can only handle a direct load from a global or a direct load from the stack It should be generalized to handle any load from P
Definition: README-SSE.txt:411
llvm::CallBase::mutateFunctionType
void mutateFunctionType(FunctionType *FTy)
Definition: InstrTypes.h:1243
llvm::BinaryOperator::CreateWithCopiedFlags
static BinaryOperator * CreateWithCopiedFlags(BinaryOps Opc, Value *V1, Value *V2, Instruction *CopyO, const Twine &Name="", Instruction *InsertBefore=nullptr)
Definition: InstrTypes.h:250
llvm::VariadicOperandTraits
VariadicOperandTraits - determine the allocation regime of the Use array when it is a prefix to the U...
Definition: OperandTraits.h:68
llvm::BinaryOperator::CreateNot
static BinaryOperator * CreateNot(Value *Op, const Twine &Name="", Instruction *InsertBefore=nullptr)
Definition: Instructions.cpp:2694
llvm::CallBase::getCalledOperandUse
Use & getCalledOperandUse()
Definition: InstrTypes.h:1389
llvm::CallBase::BundleOpInfo::Tag
StringMapEntry< uint32_t > * Tag
The operand bundle tag, interned by LLVMContextImpl::getOrInsertBundleTag.
Definition: InstrTypes.h:2110
llvm::CallBase::setCalledFunction
void setCalledFunction(Function *Fn)
Sets the function called, including updating the function type.
Definition: InstrTypes.h:1429
llvm::BinaryOperator::CreateFRemFMF
static BinaryOperator * CreateFRemFMF(Value *V1, Value *V2, Instruction *FMFSource, const Twine &Name="")
Definition: InstrTypes.h:278
llvm::CallBase::getNumTotalBundleOperands
unsigned getNumTotalBundleOperands() const
Return the total number operands (not operand bundles) used by every operand bundle in this OperandBu...
Definition: InstrTypes.h:1933
llvm::AttributeList::getParamPreallocatedType
Type * getParamPreallocatedType(unsigned ArgNo) const
Return the preallocated type for the specified function parameter.
Definition: Attributes.cpp:1451
llvm::CallBase::setIsNoInline
void setIsNoInline()
Definition: InstrTypes.h:1782
llvm::UnaryInstruction::DECLARE_TRANSPARENT_OPERAND_ACCESSORS
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)
Transparently provide more efficient getOperand methods.
llvm::FuncletPadInst::getNumArgOperands
unsigned getNumArgOperands() const
getNumArgOperands - Return the number of funcletpad arguments.
Definition: InstrTypes.h:2320
op
#define op(i)
llvm::CmpInst::getFlippedSignednessPredicate
Predicate getFlippedSignednessPredicate()
For example, SLT->ULT, ULT->SLT, SLE->ULE, ULE->SLE, EQ->Failed assert.
Definition: InstrTypes.h:977
llvm::AttributeList::addParamAttribute
LLVM_NODISCARD AttributeList addParamAttribute(LLVMContext &C, unsigned ArgNo, Attribute::AttrKind Kind) const
Add an argument attribute to the list.
Definition: Attributes.h:480
llvm::BinaryOperator::CreateFDivFMF
static BinaryOperator * CreateFDivFMF(Value *V1, Value *V2, Instruction *FMFSource, const Twine &Name="")
Definition: InstrTypes.h:273
llvm::CallBase::isInlineAsm
bool isInlineAsm() const
Check if this call is an inline asm statement.
Definition: InstrTypes.h:1458
llvm::CmpInst::FCMP_ONE
@ FCMP_ONE
0 1 1 0 True if ordered and operands are unequal
Definition: InstrTypes.h:728
llvm::CallBase::getAttribute
Attribute getAttribute(unsigned i, Attribute::AttrKind Kind) const
Get the attribute of a given kind at a position.
Definition: InstrTypes.h:1587
llvm::CallBase::Attrs
AttributeList Attrs
parameter attributes for callable
Definition: InstrTypes.h:1175
ErrorHandling.h
llvm::CallBase::getDereferenceableOrNullBytes
uint64_t getDereferenceableOrNullBytes(unsigned i) const
Extract the number of dereferenceable_or_null bytes for a call or parameter (0=unknown).
Definition: InstrTypes.h:1752
llvm::CmpInst::makeCmpResultType
static Type * makeCmpResultType(Type *opnd_type)
Create a result type for fcmp/icmp.
Definition: InstrTypes.h:1031
llvm::CallBase::setNotConvergent
void setNotConvergent()
Definition: InstrTypes.h:1867
llvm::AttributeList::addAttribute
LLVM_NODISCARD AttributeList addAttribute(LLVMContext &C, unsigned Index, Attribute::AttrKind Kind) const
Add an attribute to the attribute set at the given index.
Definition: Attributes.cpp:1212
llvm::CallBase::setDoesNotReadMemory
void setDoesNotReadMemory()
Definition: InstrTypes.h:1804
llvm::CmpInst::ICMP_NE
@ ICMP_NE
not equal
Definition: InstrTypes.h:742
llvm::CmpInst::getInversePredicate
Predicate getInversePredicate() const
For example, EQ -> NE, UGT -> ULE, SLT -> SGE, OEQ -> UNE, UGT -> OLE, OLT -> UGE,...
Definition: InstrTypes.h:820
llvm::BinaryOperator::CreateNSW
static BinaryOperator * CreateNSW(BinaryOps Opc, Value *V1, Value *V2, const Twine &Name, BasicBlock *BB)
Definition: InstrTypes.h:290
llvm::BinaryOperator::DEFINE_HELPERS
DEFINE_HELPERS(Add, NSW) DEFINE_HELPERS(Add
llvm::CmpInst::isCommutative
bool isCommutative() const
This is just a convenience that dispatches to the subclasses.
Definition: Instructions.cpp:3748
llvm::CallBase::hasFnAttr
bool hasFnAttr(Attribute::AttrKind Kind) const
Determine whether this call has the given attribute.
Definition: InstrTypes.h:1477
llvm::CallBase::getArgOperandUse
const Use & getArgOperandUse(unsigned i) const
Wrappers for getting the Use of a call argument.
Definition: InstrTypes.h:1349
llvm::AttributeList::getParamByValType
Type * getParamByValType(unsigned ArgNo) const
Return the byval type for the specified function parameter.
Definition: Attributes.cpp:1439
llvm::AttributeList::addDereferenceableAttr
LLVM_NODISCARD AttributeList addDereferenceableAttr(LLVMContext &C, unsigned Index, uint64_t Bytes) const
Add the dereferenceable attribute to the attribute set at the given index.
Definition: Attributes.cpp:1338
llvm::CmpInst::getFlippedStrictnessPredicate
Predicate getFlippedStrictnessPredicate() const
For predicate of kind "is X or equal to 0" returns the predicate "is X".
Definition: InstrTypes.h:902
llvm::CallBase::addOperandBundle
static CallBase * addOperandBundle(CallBase *CB, uint32_t ID, OperandBundleDef OB, Instruction *InsertPt=nullptr)
Create a clone of CB with operand bundle OB added.
Definition: Instructions.cpp:444
llvm::CallBase::isStrictFP
bool isStrictFP() const
Determine if the call requires strict floating point semantics.
Definition: InstrTypes.h:1778
llvm::CmpInst::ICMP_SGT
@ ICMP_SGT
signed greater than
Definition: InstrTypes.h:747
llvm::CallBase::isInAllocaArgument
bool isInAllocaArgument(unsigned ArgNo) const
Determine whether this argument is passed in an alloca.
Definition: InstrTypes.h:1656
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
llvm::CmpInst::isFalseWhenEqual
bool isFalseWhenEqual() const
This is just a convenience.
Definition: InstrTypes.h:989
llvm::CallBase::isPassingUndefUB
bool isPassingUndefUB(unsigned ArgNo) const
Determine whether passing undef to this argument is undefined behavior.
Definition: InstrTypes.h:1671
llvm::CallBase::removeAttributes
void removeAttributes(unsigned i, const AttrBuilder &Attrs)
Definition: InstrTypes.h:1532
llvm::AttributeList
Definition: Attributes.h:398
llvm::CallBase::getAttributes
AttributeList getAttributes() const
Return the parameter attributes for this call.
Definition: InstrTypes.h:1468
DEFINE_TRANSPARENT_OPERAND_ACCESSORS
#define DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CLASS, VALUECLASS)
Macro for generating out-of-class operand accessor definitions.
Definition: OperandTraits.h:125
llvm::OperandBundleDefT
A container for an operand bundle being viewed as a set of values rather than a set of uses.
Definition: InstrTypes.h:1114
llvm::CallBase::getFunctionType
FunctionType * getFunctionType() const
Definition: InstrTypes.h:1241
llvm::sys::path::begin
const_iterator begin(StringRef path, Style style=Style::native)
Get begin iterator over path.
Definition: Path.cpp:224
llvm::CallBase::isCallee
bool isCallee(Value::const_user_iterator UI) const
Determine whether the passed iterator points to the callee operand's Use.
Definition: InstrTypes.h:1401
llvm::CallBase::bundle_op_infos
iterator_range< bundle_op_iterator > bundle_op_infos()
Return the range [bundle_op_info_begin, bundle_op_info_end).
Definition: InstrTypes.h:2216
llvm::CallBase::hasArgument
bool hasArgument(const Value *V) const
Returns true if this CallSite passes the given Value* as an argument to the called function.
Definition: InstrTypes.h:1382
llvm::CallBase::hasDescriptor
bool hasDescriptor() const
Definition: InstrTypes.h:1184
llvm::CallBase::getDataOperandNo
unsigned getDataOperandNo(const Use *U) const
Given a use for a data operand, get the data operand number that corresponds to it.
Definition: InstrTypes.h:1297
llvm::CallBase::isMustTailCall
bool isMustTailCall() const
Tests if this call site must be tail call optimized.
Definition: Instructions.cpp:298
llvm::Instruction::setHasNoUnsignedWrap
void setHasNoUnsignedWrap(bool b=true)
Set or clear the nuw flag on this instruction, which must be an operator which supports this flag.
Definition: Instruction.cpp:124
llvm::Optional
Definition: APInt.h:33
llvm::BinaryOperator::CreateNUW
static BinaryOperator * CreateNUW(BinaryOps Opc, Value *V1, Value *V2, const Twine &Name, BasicBlock *BB)
Definition: InstrTypes.h:309
llvm::CallBase::getDereferenceableBytes
uint64_t getDereferenceableBytes(unsigned i) const
Extract the number of dereferenceable bytes for a call or parameter (0=unknown).
Definition: InstrTypes.h:1746
llvm::MCID::Convergent
@ Convergent
Definition: MCInstrDesc.h:182
llvm::CastInst::CastInst
CastInst(Type *Ty, unsigned iType, Value *S, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Constructor with insert-before-instruction semantics for subclasses.
Definition: InstrTypes.h:433
llvm::CastInst::castIsValid
static bool castIsValid(Instruction::CastOps op, Value *S, Type *DstTy)
Definition: InstrTypes.h:691
llvm::CmpInst::getOpcode
OtherOps getOpcode() const
Get the opcode casted to the right type.
Definition: InstrTypes.h:791
llvm::OperandBundleDefT::OperandBundleDefT
OperandBundleDefT(std::string Tag, std::vector< InputTy > Inputs)
Definition: InstrTypes.h:1119
llvm::CmpInst::ICMP_SLE
@ ICMP_SLE
signed less or equal
Definition: InstrTypes.h:750
llvm::CallBase::isByValArgument
bool isByValArgument(unsigned ArgNo) const
Determine whether this argument is passed by value.
Definition: InstrTypes.h:1651
llvm::CallBase::getNumArgOperands
unsigned getNumArgOperands() const
Definition: InstrTypes.h:1336
STLExtras.h
llvm::CallBase::arg_begin
User::op_iterator arg_begin()
Return the iterator pointing to the beginning of the argument list.
Definition: InstrTypes.h:1303
llvm::CmpInst::getPredicateName
static StringRef getPredicateName(Predicate P)
Definition: Instructions.cpp:3795
llvm::BinaryOperator::CreateNeg
NUW NUW NUW NUW Exact static Exact BinaryOperator * CreateNeg(Value *Op, const Twine &Name="", Instruction *InsertBefore=nullptr)
Helper functions to construct and inspect unary operations (NEG and NOT) via binary operators SUB and...
Definition: Instructions.cpp:2654
llvm::UnaryOperator
Definition: InstrTypes.h:102
llvm::CallBase::setDoesNotThrow
void setDoesNotThrow()
Definition: InstrTypes.h:1846
llvm::Value::setValueSubclassData
void setValueSubclassData(unsigned short D)
Definition: Value.h:845
llvm::CallBase::isFnAttrDisallowedByOpBundle
bool isFnAttrDisallowedByOpBundle(StringRef S) const
Is the function attribute S disallowed by some operand bundle on this operand bundle user?
Definition: InstrTypes.h:2073
llvm::CallBase::addParamAttr
void addParamAttr(unsigned ArgNo, Attribute::AttrKind Kind)
Adds the attribute to the indicated argument.
Definition: InstrTypes.h:1503
llvm::Instruction::setIsExact
void setIsExact(bool b=true)
Set or clear the exact flag on this instruction, which must be an operator which supports this flag.
Definition: Instruction.cpp:132
llvm::CallBase::doesNotReadMemory
bool doesNotReadMemory(unsigned OpNo) const
Definition: InstrTypes.h:1700
llvm::FuncletPadInst::arg_operands
op_range arg_operands()
arg_operands - iteration adapter for range-for loops.
Definition: InstrTypes.h:2340
llvm::CmpInst::FCMP_OGT
@ FCMP_OGT
0 0 1 0 True if ordered and greater than
Definition: InstrTypes.h:724
llvm::CallBase::isCallee
bool isCallee(const Use *U) const
Determine whether this Use is the callee operand's Use.
Definition: InstrTypes.h:1406
llvm::CastInst::getDestTy
Type * getDestTy() const
Return the destination type, as a convenience.
Definition: InstrTypes.h:684
F
#define F(x, y, z)
Definition: MD5.cpp:56
llvm::CallBase::setOnlyAccessesArgMemory
void setOnlyAccessesArgMemory()
Definition: InstrTypes.h:1813
llvm::CallBase::getOperandBundle
Optional< OperandBundleUse > getOperandBundle(uint32_t ID) const
Return an operand bundle by tag ID, if present.
Definition: InstrTypes.h:1992
llvm::CallBase::getArgOperandNo
unsigned getArgOperandNo(Value::const_user_iterator UI) const
Given a value use iterator, return the arg operand number corresponding to it.
Definition: InstrTypes.h:1376
llvm::BasicBlock
LLVM Basic Block Representation.
Definition: BasicBlock.h:58
llvm::lltok::equal
@ equal
Definition: LLToken.h:25
llvm::AttributeList::hasAttribute
bool hasAttribute(unsigned Index, Attribute::AttrKind Kind) const
Return true if the attribute exists at the given index.
Definition: Attributes.cpp:1387
llvm::CallBase::hasIdenticalOperandBundleSchema
bool hasIdenticalOperandBundleSchema(const CallBase &Other) const
Return true if Other has the same sequence of operand bundle tags with the same number of operands on...
Definition: InstrTypes.h:2052
llvm::CallBase::getParamStackAlign
MaybeAlign getParamStackAlign(unsigned ArgNo) const
Definition: InstrTypes.h:1713
llvm::CallBase::getAttribute
Attribute getAttribute(unsigned i, StringRef Kind) const
Get the attribute of a given kind at a position.
Definition: InstrTypes.h:1592
llvm::CmpInst::FCMP_ULT
@ FCMP_ULT
1 1 0 0 True if unordered or less than
Definition: InstrTypes.h:734
llvm::BinaryOperator::CreateNUW
static BinaryOperator * CreateNUW(BinaryOps Opc, Value *V1, Value *V2, const Twine &Name, Instruction *I)
Definition: InstrTypes.h:315
llvm::CallBase::setOnlyAccessesInaccessibleMemory
void setOnlyAccessesInaccessibleMemory()
Definition: InstrTypes.h:1822
llvm::User::getOperandUse
const Use & getOperandUse(unsigned i) const
Definition: User.h:182
Instruction.h
llvm::UnaryOperator::getOpcode
UnaryOps getOpcode() const
Definition: InstrTypes.h:172
llvm::CallBase::isDataOperand
bool isDataOperand(Value::const_user_iterator UI) const
Definition: InstrTypes.h:1285
llvm::AttributeList::getParamStackAlignment
MaybeAlign getParamStackAlignment(unsigned ArgNo) const
Return the stack alignment for the specified function parameter.
Definition: Attributes.cpp:1435
llvm::BinaryOperator::swapOperands
bool swapOperands()
Exchange the two operands to this instruction.
Definition: Instructions.cpp:2712
llvm::CallBase::getParamAttr
Attribute getParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) const
Get the attribute of a given kind from a given arg.
Definition: InstrTypes.h:1597
llvm::FuncletPadInst::getArgOperand
Value * getArgOperand(unsigned i) const
getArgOperand/setArgOperand - Return/set the i-th funcletpad argument.
Definition: InstrTypes.h:2336
llvm::Intrinsic::getType
FunctionType * getType(LLVMContext &Context, ID id, ArrayRef< Type * > Tys=None)
Return the function type for an intrinsic.
Definition: Function.cpp:1292
llvm::CallBase::removeParamAttr
void removeParamAttr(unsigned ArgNo, Attribute::AttrKind Kind)
Removes the attribute from the given argument.
Definition: InstrTypes.h:1539
llvm::Instruction::getOpcode
unsigned getOpcode() const
Returns a member of one of the enums like Instruction::Add.
Definition: Instruction.h:160
llvm::CallBase::isFnAttrDisallowedByOpBundle
bool isFnAttrDisallowedByOpBundle(Attribute::AttrKind A) const
Is the function attribute A disallowed by some operand bundle on this operand bundle user?
Definition: InstrTypes.h:2081
llvm::CallBase::hasByValArgument
bool hasByValArgument() const
Determine if any call argument is an aggregate passed by value.
Definition: InstrTypes.h:1882
llvm::CallBase::data_operands_size
unsigned data_operands_size() const
Definition: InstrTypes.h:1276
llvm::CallBase::setDoesNotReturn
void setDoesNotReturn()
Definition: InstrTypes.h:1837
llvm::SPII::Load
@ Load
Definition: SparcInstrInfo.h:32
llvm::OperandTraits
Compile-time customization of User operands.
Definition: User.h:42
llvm::CmpInst::isFPPredicate
bool isFPPredicate() const
Definition: InstrTypes.h:813
Constants.h
llvm::CmpInst::FIRST_FCMP_PREDICATE
@ FIRST_FCMP_PREDICATE
Definition: InstrTypes.h:738
llvm::CmpInst::classof
static bool classof(const Instruction *I)
Methods for support type inquiry through isa, cast, and dyn_cast:
Definition: InstrTypes.h:1022
llvm::CallBase::addAttribute
void addAttribute(unsigned i, Attribute Attr)
adds the attribute to the list of attributes.
Definition: InstrTypes.h:1496
llvm::OperandBundleUse::isDeoptOperandBundle
bool isDeoptOperandBundle() const
Return true if this is a "deopt" operand bundle.
Definition: InstrTypes.h:1089
llvm::CmpInst::getNonStrictPredicate
Predicate getNonStrictPredicate() const
For example, SGT -> SGE, SLT -> SLE, ULT -> ULE, UGT -> UGE.
Definition: InstrTypes.h:880
llvm::Instruction::setHasNoSignedWrap
void setHasNoSignedWrap(bool b=true)
Set or clear the nsw flag on this instruction, which must be an operator which supports this flag.
Definition: Instruction.cpp:128
llvm::AttributeList::removeAttributes
LLVM_NODISCARD AttributeList removeAttributes(LLVMContext &C, unsigned Index, const AttrBuilder &AttrsToRemove) const
Remove the specified attributes at the specified index from this attribute list.
Definition: Attributes.cpp:1316
llvm::CallBase::getCalledOperandUse
const Use & getCalledOperandUse() const
Definition: InstrTypes.h:1388
llvm::AttributeList::removeParamAttributes
LLVM_NODISCARD AttributeList removeParamAttributes(LLVMContext &C, unsigned ArgNo, const AttrBuilder &AttrsToRemove) const
Remove the specified attribute at the specified arg index from this attribute list.
Definition: Attributes.h:544
llvm::CmpInst::isRelational
static bool isRelational(Predicate P)
Return true if the predicate is relational (not EQ or NE).
Definition: InstrTypes.h:927
llvm::CmpInst::getSignedPredicate
Predicate getSignedPredicate()
For example, ULT->SLT, ULE->SLE, UGT->SGT, UGE->SGE, SLT->Failed assert.
Definition: InstrTypes.h:953
llvm::CmpInst::ICMP_ULE
@ ICMP_ULE
unsigned less or equal
Definition: InstrTypes.h:746
llvm::CallBase::getBundleOpInfoForOperand
BundleOpInfo & getBundleOpInfoForOperand(unsigned OpIdx)
Return the BundleOpInfo for the operand at index OpIdx.
Definition: Instructions.cpp:397
Twine.h
llvm::CallBase::getCalledFunction
Function * getCalledFunction() const
Returns the function called, or null if this is an indirect function invocation.
Definition: InstrTypes.h:1393
llvm::OperandBundleDefT::input_iterator
typename std::vector< InputTy >::const_iterator input_iterator
Definition: InstrTypes.h:1131
llvm::CallBase::setAttributes
void setAttributes(AttributeList A)
Set the parameter attributes for this call.
Definition: InstrTypes.h:1472
llvm::BinaryOperator::CreateNSW
static BinaryOperator * CreateNSW(BinaryOps Opc, Value *V1, Value *V2, const Twine &Name="")
Definition: InstrTypes.h:284
llvm::BinaryOperator::BinaryOperator
BinaryOperator(BinaryOps iType, Value *S1, Value *S2, Type *Ty, const Twine &Name, Instruction *InsertBefore)
Definition: Instructions.cpp:2544
llvm::CmpInst::FIRST_ICMP_PREDICATE
@ FIRST_ICMP_PREDICATE
Definition: InstrTypes.h:751
llvm::CmpInst::FCMP_UGE
@ FCMP_UGE
1 0 1 1 True if unordered, greater than, or equal
Definition: InstrTypes.h:733
llvm::Instruction::OtherOps
OtherOps
Definition: Instruction.h:815
llvm::CmpInst::classof
static bool classof(const Value *V)
Definition: InstrTypes.h:1026
llvm::FuncletPadInst::classof
static bool classof(const Value *V)
Definition: InstrTypes.h:2349
llvm::BinaryOperator::CreateExact
static BinaryOperator * CreateExact(BinaryOps Opc, Value *V1, Value *V2, const Twine &Name="")
Definition: InstrTypes.h:322
llvm::CallBase::isConvergent
bool isConvergent() const
Determine if the invoke is convergent.
Definition: InstrTypes.h:1863
llvm::CallBase::operandBundleFromBundleOpInfo
OperandBundleUse operandBundleFromBundleOpInfo(const BundleOpInfo &BOI) const
Simple helper function to map a BundleOpInfo to an OperandBundleUse.
Definition: InstrTypes.h:2128
llvm::MaybeAlign
This struct is a compact representation of a valid (power of two) or undefined (0) alignment.
Definition: Alignment.h:109
B
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
llvm::Instruction::CastOps
CastOps
Definition: Instruction.h:801
llvm::BinaryOperator::getOpcode
BinaryOps getOpcode() const
Definition: InstrTypes.h:393
llvm::CallBase::setDoesNotAccessMemory
void setDoesNotAccessMemory()
Definition: InstrTypes.h:1787
llvm::CmpInst::FCMP_UNO
@ FCMP_UNO
1 0 0 0 True if unordered: isnan(X) | isnan(Y)
Definition: InstrTypes.h:730
llvm::Instruction
Definition: Instruction.h:45
llvm::User::getDescriptor
ArrayRef< const uint8_t > getDescriptor() const
Returns the descriptor co-allocated with this User instance.
Definition: User.cpp:93
llvm::CallBase::BundleOpInfo::Begin
uint32_t Begin
The index in the Use& vector where operands for this operand bundle starts.
Definition: InstrTypes.h:2114
llvm::AttributeList::getRetAlignment
MaybeAlign getRetAlignment() const
Return the alignment of the return value.
Definition: Attributes.cpp:1427
llvm::CallBase::isArgOperand
bool isArgOperand(Value::const_user_iterator UI) const
Definition: InstrTypes.h:1363
llvm::UnaryOperator::CreateWithCopiedFlags
static UnaryOperator * CreateWithCopiedFlags(UnaryOps Opc, Value *V, Instruction *CopyO, const Twine &Name="", Instruction *InsertBefore=nullptr)
Definition: InstrTypes.h:157
OperandTraits.h
llvm::CallBase::bundle_op_info_begin
bundle_op_iterator bundle_op_info_begin()
Return the start of the list of BundleOpInfo instances associated with this OperandBundleUser.
Definition: InstrTypes.h:2183
llvm::CallBase::getParamByValType
Type * getParamByValType(unsigned ArgNo) const
Extract the byval type for a call or parameter.
Definition: InstrTypes.h:1718
llvm::CallBase::data_operands_begin
User::const_op_iterator data_operands_begin() const
Definition: InstrTypes.h:1256
llvm::FunctionCallee::getFunctionType
FunctionType * getFunctionType()
Definition: DerivedTypes.h:181
llvm::CmpInst::FCMP_OEQ
@ FCMP_OEQ
0 0 0 1 True if ordered and equal
Definition: InstrTypes.h:723
llvm::CallBase::BundleOpInfo
Used to keep track of an operand bundle.
Definition: InstrTypes.h:2107
llvm::CmpInst::FCMP_OLT
@ FCMP_OLT
0 1 0 0 True if ordered and less than
Definition: InstrTypes.h:726
llvm::AttributeList::removeParamAttribute
LLVM_NODISCARD AttributeList removeParamAttribute(LLVMContext &C, unsigned ArgNo, Attribute::AttrKind Kind) const
Remove the specified attribute at the specified arg index from this attribute list.
Definition: Attributes.h:529
StringMap.h
llvm::CallBase::isDataOperand
bool isDataOperand(const Use *U) const
Definition: InstrTypes.h:1280
llvm::CallBase::data_operands_end
User::op_iterator data_operands_end()
Definition: InstrTypes.h:1259
llvm::MCID::Call
@ Call
Definition: MCInstrDesc.h:153
llvm::CastInst::getSrcTy
Type * getSrcTy() const
Return the source type, as a convenience.
Definition: InstrTypes.h:682
llvm::CallBase::getCallingConv
CallingConv::ID getCallingConv() const
Definition: InstrTypes.h:1449
llvm::BinaryOperator::CreateExact
static BinaryOperator * CreateExact(BinaryOps Opc, Value *V1, Value *V2, const Twine &Name, BasicBlock *BB)
Definition: InstrTypes.h:328
llvm::None
const NoneType None
Definition: None.h:23
llvm::UnaryInstruction::UnaryInstruction
UnaryInstruction(Type *Ty, unsigned iType, Value *V, BasicBlock *IAE)
Definition: InstrTypes.h:64
llvm::lltok::Kind
Kind
Definition: LLToken.h:18
llvm::CallingConv::ID
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
Definition: CallingConv.h:24
llvm::CallBase::onlyReadsMemory
bool onlyReadsMemory(unsigned OpNo) const
Definition: InstrTypes.h:1693
Type.h
llvm::codeview::ClassOptions::Intrinsic
@ Intrinsic
llvm::CallBase::getCaller
Function * getCaller()
Helper to get the caller (the parent function).
Definition: Instructions.cpp:282
llvm::UnaryInstruction
Definition: InstrTypes.h:57
llvm::OperandBundleUse::getTagID
uint32_t getTagID() const
Return the tag of this operand bundle as an integer.
Definition: InstrTypes.h:1084
llvm::BinaryOperator::CreateNSW
static BinaryOperator * CreateNSW(BinaryOps Opc, Value *V1, Value *V2, const Twine &Name, Instruction *I)
Definition: InstrTypes.h:296
llvm::CallBase::isBundleOperand
bool isBundleOperand(Value::const_user_iterator UI) const
Definition: InstrTypes.h:1927
llvm::CmpInst::FCMP_FALSE
@ FCMP_FALSE
0 0 0 0 Always false (always folded)
Definition: InstrTypes.h:722
llvm::CallBase::FTy
FunctionType * FTy
Definition: InstrTypes.h:1176
llvm::CmpInst::isStrictPredicate
bool isStrictPredicate() const
Definition: InstrTypes.h:852
llvm::CmpInst
This class is the base class for the comparison instructions.
Definition: InstrTypes.h:710
llvm::OperandBundleUse::isFuncletOperandBundle
bool isFuncletOperandBundle() const
Return true if this is a "funclet" operand bundle.
Definition: InstrTypes.h:1094
llvm::CallBase::getReturnedArgOperand
Value * getReturnedArgOperand() const
If one of the arguments has the 'returned' attribute, returns its operand value.
Definition: Instructions.cpp:329
llvm::BinaryOperator::classof
static bool classof(const Value *V)
Definition: InstrTypes.h:408
llvm::CallBase::bundleOperandHasAttr
bool bundleOperandHasAttr(unsigned OpIdx, Attribute::AttrKind A) const
Return true if the bundle operand at index OpIdx has the attribute A.
Definition: InstrTypes.h:2043
llvm::VectorType
Base class of all SIMD vector types.
Definition: DerivedTypes.h:388
llvm::Value::Value
Value(Type *Ty, unsigned scid)
Definition: Value.cpp:53
llvm::AttributeList::ReturnIndex
@ ReturnIndex
Definition: Attributes.h:401
llvm::CleanupPadInst
Definition: Instructions.h:4428
llvm::CallBase::getBundleOperandsStartIndex
unsigned getBundleOperandsStartIndex() const
Return the index of the first bundle operand in the Use array.
Definition: InstrTypes.h:1904
llvm::OperandBundleDefT::input_end
input_iterator input_end() const
Definition: InstrTypes.h:1135
llvm::CallBase::addDereferenceableAttr
void addDereferenceableAttr(unsigned i, uint64_t Bytes)
adds the dereferenceable attribute to the list of attributes.
Definition: InstrTypes.h:1562
llvm::Value::mutateType
void mutateType(Type *Ty)
Mutate the type of this Value to be of the specified type.
Definition: Value.h:793
llvm::CallBase::getCaller
const Function * getCaller() const
Definition: InstrTypes.h:1410
llvm::CallBase::isTailCall
bool isTailCall() const
Tests if this call site is marked as a tail call.
Definition: Instructions.cpp:305
llvm::LLVMContext::OB_cfguardtarget
@ OB_cfguardtarget
Definition: LLVMContext.h:93
llvm::UnaryOperator::CreateFNegFMF
static UnaryOperator * CreateFNegFMF(Value *Op, Instruction *FMFSource, const Twine &Name="", Instruction *InsertBefore=nullptr)
Definition: InstrTypes.h:165
llvm::CallBase::doesNotAccessMemory
bool doesNotAccessMemory(unsigned OpNo) const
Definition: InstrTypes.h:1687
llvm::CallingConv::MaxID
@ MaxID
The highest possible calling convention ID. Must be some 2^k - 1.
Definition: CallingConv.h:256
llvm::OperandBundleDefT::OperandBundleDefT
OperandBundleDefT(std::string Tag, ArrayRef< InputTy > Inputs)
Definition: InstrTypes.h:1121
llvm::CallBase::countOperandBundlesOfType
unsigned countOperandBundlesOfType(StringRef Name) const
Return the number of operand bundles with the tag Name attached to this instruction.
Definition: InstrTypes.h:1952
Index
uint32_t Index
Definition: ELFObjHandler.cpp:84
llvm::CallBase::getRetAlign
MaybeAlign getRetAlign() const
Extract the alignment of the return value.
Definition: InstrTypes.h:1706
llvm::CallBase::bundle_op_infos
iterator_range< const_bundle_op_iterator > bundle_op_infos() const
Return the range [bundle_op_info_begin, bundle_op_info_end).
Definition: InstrTypes.h:2221
llvm::BinaryOperator::CreateFMulFMF
static BinaryOperator * CreateFMulFMF(Value *V1, Value *V2, Instruction *FMFSource, const Twine &Name="")
Definition: InstrTypes.h:268
llvm::UnaryOperator::classof
static bool classof(const Value *V)
Definition: InstrTypes.h:180
llvm::OperandBundleUse::isCFGuardTargetOperandBundle
bool isCFGuardTargetOperandBundle() const
Return true if this is a "cfguardtarget" operand bundle.
Definition: InstrTypes.h:1099
llvm::FuncletPadInst::classof
static bool classof(const Instruction *I)
Definition: InstrTypes.h:2348
D
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
llvm::CmpInst::isIntPredicate
static bool isIntPredicate(Predicate P)
Definition: InstrTypes.h:807
llvm::CallBase::data_ops
iterator_range< User::op_iterator > data_ops()
Definition: InstrTypes.h:1267
llvm::OperandBundleDefT::input_size
size_t input_size() const
Definition: InstrTypes.h:1133
llvm::AttributeList::getDereferenceableBytes
uint64_t getDereferenceableBytes(unsigned Index) const
Get the number of dereferenceable bytes (or zero if unknown).
Definition: Attributes.cpp:1467
llvm::CmpInst::CmpInst
CmpInst(Type *ty, Instruction::OtherOps op, Predicate pred, Value *LHS, Value *RHS, const Twine &Name="", Instruction *InsertBefore=nullptr, Instruction *FlagsSource=nullptr)
Definition: Instructions.cpp:3683
llvm::OperandBundleUse::OperandBundleUse
OperandBundleUse(StringMapEntry< uint32_t > *Tag, ArrayRef< Use > Inputs)
Definition: InstrTypes.h:1060
llvm::numbers::e
constexpr double e
Definition: MathExtras.h:57
llvm::CallBase::removeAttribute
void removeAttribute(unsigned i, Attribute::AttrKind Kind)
removes the attribute from the list of attributes.
Definition: InstrTypes.h:1519
llvm::CallBase::getNumSubclassExtraOperands
unsigned getNumSubclassExtraOperands() const
Definition: InstrTypes.h:1186
I
#define I(x, y, z)
Definition: MD5.cpp:59
llvm::AttrBuilder
Definition: Attributes.h:814
llvm::Attribute::AttrKind
AttrKind
This enumeration lists the attributes that can be associated with parameters, function results,...
Definition: Attributes.h:71
llvm::CallBase::data_ops
iterator_range< User::const_op_iterator > data_ops() const
Definition: InstrTypes.h:1270
llvm::cl::init
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:443
llvm::AttributeList::getParamAlignment
MaybeAlign getParamAlignment(unsigned ArgNo) const
Return the alignment for the specified function parameter.
Definition: Attributes.cpp:1431
llvm::CallBase::cannotMerge
bool cannotMerge() const
Determine if the call cannot be tail merged.
Definition: InstrTypes.h:1857
llvm::is_contained
bool is_contained(R &&Range, const E &Element)
Wrapper function around std::find to detect if an element exists in a container.
Definition: STLExtras.h:1612
ArrayRef.h
llvm::CallBase::doesNotCapture
bool doesNotCapture(unsigned OpNo) const
Determine whether this data operand is not captured.
Definition: InstrTypes.h:1646
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::FuncletPadInst::setArgOperand
void setArgOperand(unsigned i, Value *v)
Definition: InstrTypes.h:2337
llvm::move
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1605
llvm::CallBase::hasOperandBundles
bool hasOperandBundles() const
Return true if this User has any operand bundles.
Definition: InstrTypes.h:1901
llvm::CmpInst::FCMP_OGE
@ FCMP_OGE
0 0 1 1 True if ordered and greater than or equal
Definition: InstrTypes.h:725
llvm::CmpInst::ICMP_UGE
@ ICMP_UGE
unsigned greater or equal
Definition: InstrTypes.h:744
iterator_range.h
llvm::CmpInst::BAD_ICMP_PREDICATE
@ BAD_ICMP_PREDICATE
Definition: InstrTypes.h:753
llvm::CallBase::getNumSubclassExtraOperandsDynamic
unsigned getNumSubclassExtraOperandsDynamic() const
Get the number of extra operands for instructions that don't have a fixed number of extra operands.
Definition: Instructions.cpp:284
llvm::CastInst::classof
static bool classof(const Instruction *I)
Methods for support type inquiry through isa, cast, and dyn_cast:
Definition: InstrTypes.h:696
llvm::CallBase::Create
static CallBase * Create(CallBase *CB, ArrayRef< OperandBundleDef > Bundles, Instruction *InsertPt=nullptr)
Create a clone of CB with a different set of operand bundles and insert it before InsertPt.
Definition: Instructions.cpp:255
llvm::CallBase::getBundleOpInfoForOperand
const BundleOpInfo & getBundleOpInfoForOperand(unsigned OpIdx) const
Definition: InstrTypes.h:2240
llvm::CallBase::arg_end
User::op_iterator arg_end()
Return the iterator pointing to the end of the argument list.
Definition: InstrTypes.h:1309
llvm::User::setOperand
void setOperand(unsigned i, Value *Val)
Definition: User.h:174
llvm::CallBase::addDereferenceableOrNullAttr
void addDereferenceableOrNullAttr(unsigned i, uint64_t Bytes)
adds the dereferenceable_or_null attribute to the list of attributes.
Definition: InstrTypes.h:1570
llvm::Instruction::FuncletPadOps
FuncletPadOps
Definition: Instruction.h:808
llvm::CmpInst::ICMP_SLT
@ ICMP_SLT
signed less than
Definition: InstrTypes.h:749
llvm::CmpInst::isIntPredicate
bool isIntPredicate() const
Definition: InstrTypes.h:814
llvm::CallBase::getIntrinsicID
Intrinsic::ID getIntrinsicID() const
Returns the intrinsic ID of the intrinsic called or Intrinsic::not_intrinsic if the called function i...
Definition: Instructions.cpp:311
llvm::CallBase::addParamAttr
void addParamAttr(unsigned ArgNo, Attribute Attr)
Adds the attribute to the indicated argument.
Definition: InstrTypes.h:1511
llvm::UnaryInstruction::UnaryInstruction
UnaryInstruction(Type *Ty, unsigned iType, Value *V, Instruction *IB=nullptr)
Definition: InstrTypes.h:59
llvm::CallBase::onlyAccessesArgMemory
bool onlyAccessesArgMemory() const
Determine if the call can access memmory only using pointers based on its arguments.
Definition: InstrTypes.h:1810
llvm::ArrayRef
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: APInt.h:32
llvm::CallBase::classof
static bool classof(const Instruction *I)
Definition: InstrTypes.h:1232
llvm::BinaryOperator
Definition: InstrTypes.h:189
None.h
llvm::CallBase::getParamAlign
MaybeAlign getParamAlign(unsigned ArgNo) const
Extract the alignment for a call or parameter (0=unknown).
Definition: InstrTypes.h:1709
llvm::LLVMContext::OB_deopt
@ OB_deopt
Definition: LLVMContext.h:90
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
llvm::CallBase::getParamPreallocatedType
Type * getParamPreallocatedType(unsigned ArgNo) const
Extract the preallocated type for a call or parameter.
Definition: InstrTypes.h:1727
llvm::CallBase::getOperandBundleAt
OperandBundleUse getOperandBundleAt(unsigned Index) const
Return the operand bundle at a specific index.
Definition: InstrTypes.h:1945
llvm::CmpInst::ICMP_ULT
@ ICMP_ULT
unsigned less than
Definition: InstrTypes.h:745
llvm::CallBase::cannotDuplicate
bool cannotDuplicate() const
Determine if the invoke cannot be duplicated.
Definition: InstrTypes.h:1851
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:136
llvm::Value::getType
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:256
llvm::User::op_iterator
Use * op_iterator
Definition: User.h:229
llvm::CallBase::hasClobberingOperandBundles
bool hasClobberingOperandBundles() const
Return true if this operand bundle user has operand bundles that may write to the heap.
Definition: InstrTypes.h:2027
llvm::Bitfield::Element::NextBit
static constexpr unsigned NextBit
Definition: Bitfields.h:231
uint32_t
llvm::OperandBundleUse
A lightweight accessor for an operand bundle meant to be passed around by value.
Definition: InstrTypes.h:1056
llvm::append_range
void append_range(Container &C, Range &&R)
Wrapper function to append a range to a container.
Definition: STLExtras.h:1744
llvm::Value::getContext
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:979
DL
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
Definition: AArch64SLSHardening.cpp:76
llvm::BinaryOperator::classof
static bool classof(const Instruction *I)
Definition: InstrTypes.h:405
S
add sub stmia L5 ldr r0 bl L_printf $stub Instead of a and a wouldn t it be better to do three moves *Return an aggregate type is even return S
Definition: README.txt:210
llvm::CastInst
This is the base class for all instructions that perform data casts.
Definition: InstrTypes.h:430
llvm::CallBase::BundleOpInfo::End
uint32_t End
The index in the Use& vector where operands for this operand bundle ends.
Definition: InstrTypes.h:2118
llvm::CallBase::hasFnAttr
bool hasFnAttr(StringRef Kind) const
Determine whether this call has the given attribute.
Definition: InstrTypes.h:1486
llvm::CallBase::hasRetAttr
bool hasRetAttr(Attribute::AttrKind Kind) const
Determine whether the return value has the given attribute.
Definition: InstrTypes.h:1577
llvm::CallBase::dataOperandHasImpliedAttr
bool dataOperandHasImpliedAttr(unsigned i, Attribute::AttrKind Kind) const
Return true if the data operand at index i has the attribute A.
Definition: InstrTypes.h:1621
llvm::Type::getContext
LLVMContext & getContext() const
Return the LLVMContext in which this type was uniqued.
Definition: Type.h:127
llvm::CallBase::paramHasAttr
bool paramHasAttr(unsigned ArgNo, Attribute::AttrKind Kind) const
Determine whether the argument or parameter has the given attribute.
Definition: Instructions.cpp:343
llvm::CallBase::setArgOperand
void setArgOperand(unsigned i, Value *v)
Definition: InstrTypes.h:1343
llvm::CallBase::setConvergent
void setConvergent()
Definition: InstrTypes.h:1864
llvm::CallBase::doesNotThrow
bool doesNotThrow() const
Determine if the call cannot unwind.
Definition: InstrTypes.h:1845
llvm::OperandBundleUse::Inputs
ArrayRef< Use > Inputs
Definition: InstrTypes.h:1057
llvm::FunctionCallee::getCallee
Value * getCallee()
Definition: DerivedTypes.h:183
llvm::CallBase::hasOperandBundlesOtherThan
bool hasOperandBundlesOtherThan(ArrayRef< uint32_t > IDs) const
Return true if this operand bundle user contains operand bundles with tags other than those specified...
Definition: InstrTypes.h:2062
CallingConv.h
llvm::CmpInst::isRelational
bool isRelational() const
Return true if the predicate is relational (not EQ or NE).
Definition: InstrTypes.h:930
llvm::CallBase::removeParamAttrs
void removeParamAttrs(unsigned ArgNo, const AttrBuilder &Attrs)
Removes the attributes from the given argument.
Definition: InstrTypes.h:1555
Attributes.h
llvm::CallBase::onlyAccessesInaccessibleMemory
bool onlyAccessesInaccessibleMemory() const
Determine if the function may only access memory that is inaccessible from the IR.
Definition: InstrTypes.h:1819
llvm::CmpInst::isImpliedFalseByMatchingCmp
static bool isImpliedFalseByMatchingCmp(Predicate Pred1, Predicate Pred2)
Determine if Pred1 implies Pred2 is false when two compares have matching operands.
Definition: Instructions.cpp:4093
llvm::CmpInst::FCMP_UGT
@ FCMP_UGT
1 0 1 0 True if unordered or greater than
Definition: InstrTypes.h:732
llvm::NVPTX::PTXLdStInstCode::V2
@ V2
Definition: NVPTX.h:123
llvm::UnaryInstruction::classof
static bool classof(const Instruction *I)
Definition: InstrTypes.h:78
llvm::OperandBundleDefT::OperandBundleDefT
OperandBundleDefT(const OperandBundleUse &OBU)
Definition: InstrTypes.h:1124
llvm::Twine
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:83
llvm::CallBase::countOperandBundlesOfType
unsigned countOperandBundlesOfType(uint32_t ID) const
Return the number of operand bundles with the tag ID attached to this instruction.
Definition: InstrTypes.h:1963
llvm::Instruction::Instruction
Instruction(const Instruction &)=delete
llvm::CallBase::getParamAttr
Attribute getParamAttr(unsigned ArgNo, StringRef Kind) const
Get the attribute of a given kind from a given arg.
Definition: InstrTypes.h:1603
llvm::CallBase::CountBundleInputs
static unsigned CountBundleInputs(ArrayRef< OperandBundleDef > Bundles)
Return the total number of values used in Bundles.
Definition: InstrTypes.h:2246
llvm::CmpInst::isImpliedTrueByMatchingCmp
static bool isImpliedTrueByMatchingCmp(Predicate Pred1, Predicate Pred2)
Determine if Pred1 implies Pred2 is true when two compares have matching operands.
Definition: Instructions.cpp:4068
llvm::CallBase::isBundleOperand
bool isBundleOperand(unsigned Idx) const
Return true if the operand at index Idx is a bundle operand.
Definition: InstrTypes.h:1916
llvm::CallBase::setCalledFunction
void setCalledFunction(FunctionCallee Fn)
Sets the function called, including updating the function type.
Definition: InstrTypes.h:1434
llvm::CallBase::CallBase
CallBase(AttributeList const &A, FunctionType *FT, ArgsTy &&... Args)
Definition: InstrTypes.h:1179
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:52
std
Definition: BitVector.h:838
llvm::CallBase::getDataOperandNo
unsigned getDataOperandNo(Value::const_user_iterator UI) const
Given a value use iterator, return the data operand corresponding to it.
Definition: InstrTypes.h:1291
llvm::OperandBundleDefT::getTag
StringRef getTag() const
Definition: InstrTypes.h:1137
llvm::CallBase::isArgOperand
bool isArgOperand(const Use *U) const
Definition: InstrTypes.h:1358
llvm::BinaryOperator::CreateFAddFMF
static BinaryOperator * CreateFAddFMF(Value *V1, Value *V2, Instruction *FMFSource, const Twine &Name="")
Definition: InstrTypes.h:258
llvm::CallBase::data_operands_empty
bool data_operands_empty() const
Definition: InstrTypes.h:1273
llvm::CmpInst::isNonStrictPredicate
bool isNonStrictPredicate() const
Definition: InstrTypes.h:861
llvm::CallBase::bundle_op_info_end
bundle_op_iterator bundle_op_info_end()
Return the end of the list of BundleOpInfo instances associated with this OperandBundleUser.
Definition: InstrTypes.h:2200
llvm::BinaryOperator::CreateNUW
static BinaryOperator * CreateNUW(BinaryOps Opc, Value *V1, Value *V2, const Twine &Name="")
Definition: InstrTypes.h:303
llvm::AMDGPU::SendMsg::Op
Op
Definition: SIDefines.h:314
llvm::CallBase::isNoInline
bool isNoInline() const
Return true if the call should not be inlined.
Definition: InstrTypes.h:1781
llvm::CallBase::arg_size
unsigned arg_size() const
Definition: InstrTypes.h:1326
llvm::CallBase::setCannotMerge
void setCannotMerge()
Definition: InstrTypes.h:1858
llvm::AttributeList::getAttribute
Attribute getAttribute(unsigned Index, Attribute::AttrKind Kind) const
Return the attribute object that exists at the given index.
Definition: Attributes.cpp:1418
llvm::CmpInst::isUnsigned
bool isUnsigned() const
Definition: InstrTypes.h:940
llvm::CallBase::data_operands_end
User::const_op_iterator data_operands_end() const
Definition: InstrTypes.h:1264
llvm::CallBase::isReturnNonNull
bool isReturnNonNull() const
Return true if the return value is known to be not null.
Definition: Instructions.cpp:317
Casting.h
llvm::CallBase::arg_operands
iterator_range< User::const_op_iterator > arg_operands() const
Definition: InstrTypes.h:1333
llvm::OperandBundleDefT::input_begin
input_iterator input_begin() const
Definition: InstrTypes.h:1134
Function.h
llvm::BinaryOperator::CreateNSWNeg
static BinaryOperator * CreateNSWNeg(Value *Op, const Twine &Name="", Instruction *InsertBefore=nullptr)
Definition: Instructions.cpp:2670
llvm::CallBase::BundleOpInfo::operator==
bool operator==(const BundleOpInfo &Other) const
Definition: InstrTypes.h:2120
llvm::CallBase::classof
static bool classof(const Value *V)
Definition: InstrTypes.h:1237
llvm::AttributeList::removeAttribute
LLVM_NODISCARD AttributeList removeAttribute(LLVMContext &C, unsigned Index, Attribute::AttrKind Kind) const
Remove the specified attribute at the specified index from this attribute list.
Definition: Attributes.cpp:1289
llvm::CastInst::classof
static bool classof(const Value *V)
Definition: InstrTypes.h:699
llvm::CmpInst::isSigned
bool isSigned() const
Definition: InstrTypes.h:934
llvm::CallBase::isIndirectCall
bool isIndirectCall() const
Return true if the callsite is an indirect call.
Definition: Instructions.cpp:289
llvm::Value::HasDescriptor
unsigned HasDescriptor
Definition: Value.h:122
llvm::OperandBundleUse::operandHasAttr
bool operandHasAttr(unsigned Idx, Attribute::AttrKind A) const
Return true if the operand at index Idx in this operand bundle has the attribute A.
Definition: InstrTypes.h:1065
llvm::Function::getFunctionType
FunctionType * getFunctionType() const
Returns the FunctionType for me.
Definition: Function.h:175
llvm::CallBase::arg_empty
bool arg_empty() const
Definition: InstrTypes.h:1325
llvm::CmpInst::isEquality
bool isEquality() const
Determine if this is an equals/not equals predicate.
Definition: InstrTypes.h:924
llvm::CallBase::getArgOperandNo
unsigned getArgOperandNo(const Use *U) const
Given a use for a arg operand, get the arg operand number that corresponds to it.
Definition: InstrTypes.h:1369
llvm::orc::ReadOnly
static constexpr sys::Memory::ProtectionFlags ReadOnly
Definition: DebugObjectManagerPlugin.cpp:111
llvm::Bitfield::Element
Describes an element of a Bitfield.
Definition: Bitfields.h:223
llvm::CallBase::removeAttribute
void removeAttribute(unsigned i, StringRef Kind)
removes the attribute from the list of attributes.
Definition: InstrTypes.h:1526
llvm::CmpInst::ICMP_SGE
@ ICMP_SGE
signed greater or equal
Definition: InstrTypes.h:748
llvm::CallBase::populateBundleOperandInfos
op_iterator populateBundleOperandInfos(ArrayRef< OperandBundleDef > Bundles, const unsigned BeginIndex)
Populate the BundleOpInfo instances and the Use& vector from Bundles.
Definition: Instructions.cpp:372
llvm::MCID::Add
@ Add
Definition: MCInstrDesc.h:183
llvm::CmpInst::setPredicate
void setPredicate(Predicate P)
Set the predicate for this instruction to the specified value.
Definition: InstrTypes.h:799
llvm::CallBase::setOnlyAccessesInaccessibleMemOrArgMem
void setOnlyAccessesInaccessibleMemOrArgMem()
Definition: InstrTypes.h:1831
llvm::CmpInst::getStrictPredicate
Predicate getStrictPredicate() const
For example, SGE -> SGT, SLE -> SLT, ULE -> ULT, UGE -> UGT.
Definition: InstrTypes.h:867
llvm::CallBase::getCalledOperand
Value * getCalledOperand() const
Definition: InstrTypes.h:1386
llvm::CallBase::doesNoCfCheck
bool doesNoCfCheck() const
Determine if the call should not perform indirect branch tracking.
Definition: InstrTypes.h:1842
llvm::CallBase::args
iterator_range< User::const_op_iterator > args() const
Definition: InstrTypes.h:1322
llvm::CmpInst::isTrueWhenEqual
bool isTrueWhenEqual() const
This is just a convenience.
Definition: InstrTypes.h:983
llvm::CallBase::setCalledOperand
void setCalledOperand(Value *V)
Definition: InstrTypes.h:1426
llvm::CmpInst::Create
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.
Definition: Instructions.cpp:3711
llvm::AttributeList::getDereferenceableOrNullBytes
uint64_t getDereferenceableOrNullBytes(unsigned Index) const
Get the number of dereferenceable_or_null bytes (or zero if unknown).
Definition: Attributes.cpp:1471
DECLARE_TRANSPARENT_OPERAND_ACCESSORS
#define DECLARE_TRANSPARENT_OPERAND_ACCESSORS(VALUECLASS)
Macro for generating in-class operand accessor declarations.
Definition: OperandTraits.h:110
llvm::CatchPadInst
Definition: Instructions.h:4469
Predicate
llvm::AttributeList::FunctionIndex
@ FunctionIndex
Definition: Attributes.h:402
llvm::Instruction::BinaryOps
BinaryOps
Definition: Instruction.h:787
llvm::CmpInst::isFPPredicate
static bool isFPPredicate(Predicate P)
Definition: InstrTypes.h:801
llvm::OperandBundleUse::getTagName
StringRef getTagName() const
Return the tag of this operand bundle as a string.
Definition: InstrTypes.h:1075
llvm::CallBase::hasRetAttr
bool hasRetAttr(StringRef Kind) const
Determine whether the return value has the given attribute.
Definition: InstrTypes.h:1581
llvm::FuncletPadInst
Definition: InstrTypes.h:2293
User.h
llvm::CallBase::doesNotReadMemory
bool doesNotReadMemory() const
Determine if the call does not access or only writes memory.
Definition: InstrTypes.h:1801
llvm::CmpInst::ICMP_UGT
@ ICMP_UGT
unsigned greater than
Definition: InstrTypes.h:743
llvm::User::op_begin
op_iterator op_begin()
Definition: User.h:234
llvm::UnaryInstruction::classof
static bool classof(const Value *V)
Definition: InstrTypes.h:86
llvm::CmpInst::FCMP_UNE
@ FCMP_UNE
1 1 1 0 True if unordered or not equal
Definition: InstrTypes.h:736
llvm::CallBase::getArgOperand
Value * getArgOperand(unsigned i) const
Definition: InstrTypes.h:1338
llvm::CallBase::CalledOperandOpEndIdx
static constexpr int CalledOperandOpEndIdx
The last operand is the called operand.
Definition: InstrTypes.h:1173
llvm::CastInst::getOpcode
Instruction::CastOps getOpcode() const
Return the opcode of this CastInst.
Definition: InstrTypes.h:677
llvm::X86II::OB
@ OB
Definition: X86BaseInfo.h:796
llvm::CallBase::data_operands_begin
User::op_iterator data_operands_begin()
data_operands_begin/data_operands_end - Return iterators iterating over the call / invoke argument li...
Definition: InstrTypes.h:1255
llvm::LLVMContext::OB_funclet
@ OB_funclet
Definition: LLVMContext.h:91
llvm::CmpInst::getPredicate
Predicate getPredicate() const
Return the predicate for this instruction.
Definition: InstrTypes.h:796
llvm::BinaryOperator::CreateNUWNeg
static BinaryOperator * CreateNUWNeg(Value *Op, const Twine &Name="", Instruction *InsertBefore=nullptr)
Definition: Instructions.cpp:2682
llvm::BinaryOperator::cloneImpl
BinaryOperator * cloneImpl() const
Definition: Instructions.cpp:4430
llvm::iterator_range
A range adaptor for a pair of iterators.
Definition: iterator_range.h:30
llvm::FunctionCallee
A handy container for a FunctionType+Callee-pointer pair, which can be passed around as a single enti...
Definition: DerivedTypes.h:164
llvm::FixedNumOperandTraits
FixedNumOperandTraits - determine the allocation regime of the Use array when it is a prefix to the U...
Definition: OperandTraits.h:30
llvm::CmpInst::isOrdered
static bool isOrdered(Predicate predicate)
Determine if the predicate is an ordered operation.
Definition: Instructions.cpp:4034
llvm::Instruction::copyIRFlags
void copyIRFlags(const Value *V, bool IncludeWrapFlags=true)
Convenience method to copy supported exact, fast-math, and (optionally) wrapping flags from V to this...
Definition: Instruction.cpp:289
llvm::CmpInst::FCMP_OLE
@ FCMP_OLE
0 1 0 1 True if ordered and less than or equal
Definition: InstrTypes.h:727
llvm::SmallVectorImpl
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:43
llvm::CallBase::addAttribute
void addAttribute(unsigned i, Attribute::AttrKind Kind)
adds the attribute to the list of attributes.
Definition: InstrTypes.h:1489
llvm::CallBase::removeParamAttr
void removeParamAttr(unsigned ArgNo, StringRef Kind)
Removes the attribute from the given argument.
Definition: InstrTypes.h:1547
llvm::CmpInst::LAST_FCMP_PREDICATE
@ LAST_FCMP_PREDICATE
Definition: InstrTypes.h:739
llvm::CallBase
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
Definition: InstrTypes.h:1161
llvm::BinaryOperator::CreateExact
static BinaryOperator * CreateExact(BinaryOps Opc, Value *V1, Value *V2, const Twine &Name, Instruction *I)
Definition: InstrTypes.h:334
DerivedTypes.h
llvm::CastInst::CastInst
CastInst(Type *Ty, unsigned iType, Value *S, const Twine &NameStr, BasicBlock *InsertAtEnd)
Constructor with insert-at-end-of-block semantics for subclasses.
Definition: InstrTypes.h:439
pred
hexagon gen pred
Definition: HexagonGenPredicate.cpp:134
llvm::CmpInst::isUnordered
static bool isUnordered(Predicate predicate)
Determine if the predicate is an unordered operation.
Definition: Instructions.cpp:4043
llvm::CallBase::isPassPointeeByValueArgument
bool isPassPointeeByValueArgument(unsigned ArgNo) const
Determine whether this argument is passed by value, in an alloca, or is preallocated.
Definition: InstrTypes.h:1662
llvm::CallBase::setCalledFunction
void setCalledFunction(FunctionType *FTy, Value *Fn)
Sets the function called, including updating to the specified function type.
Definition: InstrTypes.h:1440
BB
Common register allocation spilling lr str ldr sxth r3 ldr mla r4 can lr mov lr str ldr sxth r3 mla r4 and then merge mul and lr str ldr sxth r3 mla r4 It also increase the likelihood the store may become dead bb27 Successors according to LLVM BB
Definition: README.txt:39
llvm::User::Op
Use & Op()
Definition: User.h:133
llvm::CallBase::onlyAccessesInaccessibleMemOrArgMem
bool onlyAccessesInaccessibleMemOrArgMem() const
Determine if the function may only access memory that is either inaccessible from the IR or pointed t...
Definition: InstrTypes.h:1828
llvm::CallBase::onlyReadsMemory
bool onlyReadsMemory() const
Determine if the call does not access or only reads memory.
Definition: InstrTypes.h:1792
LLVMContext.h
llvm::CallBase::getParamInAllocaType
Type * getParamInAllocaType(unsigned ArgNo) const
Extract the preallocated type for a call or parameter.
Definition: InstrTypes.h:1736
llvm::AMDGPU::HSAMD::Kernel::Key::Args
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
Definition: AMDGPUMetadata.h:389
llvm::User::getOperand
Value * getOperand(unsigned i) const
Definition: User.h:169
llvm::FuncletPadInst::getParentPad
Value * getParentPad() const
Convenience accessors.
Definition: InstrTypes.h:2328
llvm::CallBase::setCannotDuplicate
void setCannotDuplicate()
Definition: InstrTypes.h:1852
llvm::CallBase::arg_operands
iterator_range< User::op_iterator > arg_operands()
Definition: InstrTypes.h:1330
llvm::BinaryOperator::Create
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.
Definition: Instructions.cpp:2638
llvm::CmpInst::FCMP_TRUE
@ FCMP_TRUE
1 1 1 1 Always true (always folded)
Definition: InstrTypes.h:737
llvm::FuncletPadInst::setParentPad
void setParentPad(Value *ParentPad)
Definition: InstrTypes.h:2329
Value.h
llvm::FunctionType::getReturnType
Type * getReturnType() const
Definition: DerivedTypes.h:123
llvm::Value
LLVM Value Representation.
Definition: Value.h:75
llvm::FuncletPadInst::arg_operands
const_op_range arg_operands() const
arg_operands - iteration adapter for range-for loops.
Definition: InstrTypes.h:2343
llvm::CallBase::hasReadingOperandBundles
bool hasReadingOperandBundles() const
Return true if this operand bundle user has operand bundles that may read from the heap.
Definition: Instructions.cpp:473
llvm::VectorType::get
static VectorType * get(Type *ElementType, ElementCount EC)
This static method is the primary way to construct an VectorType.
Definition: Type.cpp:634
llvm::CmpInst::PredicateField
Bitfield::Element< Predicate, 0, 6, LAST_ICMP_PREDICATE > PredicateField
Definition: InstrTypes.h:756
llvm::AttributeList::getParamAttr
Attribute getParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) const
Return the attribute object that exists at the arg index.
Definition: Attributes.h:679
llvm::CmpInst::BAD_FCMP_PREDICATE
@ BAD_FCMP_PREDICATE
Definition: InstrTypes.h:740
llvm::UnaryOperator::classof
static bool classof(const Instruction *I)
Definition: InstrTypes.h:177
llvm::BinaryOperator::CreateFSubFMF
static BinaryOperator * CreateFSubFMF(Value *V1, Value *V2, Instruction *FMFSource, const Twine &Name="")
Definition: InstrTypes.h:263
llvm::Instruction::BasicBlock
friend class BasicBlock
Various leaf nodes.
Definition: Instruction.h:824
llvm::CmpInst::FCMP_ORD
@ FCMP_ORD
0 1 1 1 True if ordered (no nans)
Definition: InstrTypes.h:729
llvm::CallBase::args
iterator_range< User::op_iterator > args()
Iteration adapter for range-for loops.
Definition: InstrTypes.h:1319
Other
Optional< std::vector< StOtherPiece > > Other
Definition: ELFYAML.cpp:1172
llvm::CmpInst::FCMP_UEQ
@ FCMP_UEQ
1 0 0 1 True if unordered or equal
Definition: InstrTypes.h:731
llvm::CallBase::setCallingConv
void setCallingConv(CallingConv::ID CC)
Definition: InstrTypes.h:1453
llvm::FunctionType
Class to represent function types.
Definition: DerivedTypes.h:102
llvm::Use
A Use represents the edge between a Value definition and its users.
Definition: Use.h:44
llvm::CallBase::doesNotAccessMemory
bool doesNotAccessMemory() const
Determine if the call does not access memory.
Definition: InstrTypes.h:1786
llvm::Intrinsic::ID
unsigned ID
Definition: TargetTransformInfo.h:38
llvm::User::op_end
op_iterator op_end()
Definition: User.h:236
llvm::CallBase::setOnlyReadsMemory
void setOnlyReadsMemory()
Definition: InstrTypes.h:1796
llvm::CmpInst::LAST_ICMP_PREDICATE
@ LAST_ICMP_PREDICATE
Definition: InstrTypes.h:752