LLVM  6.0.0svn
Instructions.h
Go to the documentation of this file.
1 //===- llvm/Instructions.h - Instruction subclass definitions ---*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file exposes the class definitions of all of the subclasses of the
11 // Instruction class. This is meant to be an easy way to get access to all
12 // instruction subclasses.
13 //
14 //===----------------------------------------------------------------------===//
15 
16 #ifndef LLVM_IR_INSTRUCTIONS_H
17 #define LLVM_IR_INSTRUCTIONS_H
18 
19 #include "llvm/ADT/ArrayRef.h"
20 #include "llvm/ADT/None.h"
21 #include "llvm/ADT/STLExtras.h"
22 #include "llvm/ADT/SmallVector.h"
23 #include "llvm/ADT/StringRef.h"
24 #include "llvm/ADT/Twine.h"
25 #include "llvm/ADT/iterator.h"
27 #include "llvm/IR/Attributes.h"
28 #include "llvm/IR/BasicBlock.h"
29 #include "llvm/IR/CallingConv.h"
30 #include "llvm/IR/Constant.h"
31 #include "llvm/IR/DerivedTypes.h"
32 #include "llvm/IR/Function.h"
33 #include "llvm/IR/InstrTypes.h"
34 #include "llvm/IR/Instruction.h"
35 #include "llvm/IR/OperandTraits.h"
36 #include "llvm/IR/Type.h"
37 #include "llvm/IR/Use.h"
38 #include "llvm/IR/User.h"
39 #include "llvm/IR/Value.h"
41 #include "llvm/Support/Casting.h"
43 #include <cassert>
44 #include <cstddef>
45 #include <cstdint>
46 #include <iterator>
47 
48 namespace llvm {
49 
50 class APInt;
51 class ConstantInt;
52 class DataLayout;
53 class LLVMContext;
54 
55 //===----------------------------------------------------------------------===//
56 // AllocaInst Class
57 //===----------------------------------------------------------------------===//
58 
59 /// an instruction to allocate memory on the stack
60 class AllocaInst : public UnaryInstruction {
61  Type *AllocatedType;
62 
63 protected:
64  // Note: Instruction needs to be a friend here to call cloneImpl.
65  friend class Instruction;
66 
67  AllocaInst *cloneImpl() const;
68 
69 public:
70  explicit AllocaInst(Type *Ty, unsigned AddrSpace,
71  Value *ArraySize = nullptr,
72  const Twine &Name = "",
73  Instruction *InsertBefore = nullptr);
74  AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize,
75  const Twine &Name, BasicBlock *InsertAtEnd);
76 
77  AllocaInst(Type *Ty, unsigned AddrSpace,
78  const Twine &Name, Instruction *InsertBefore = nullptr);
79  AllocaInst(Type *Ty, unsigned AddrSpace,
80  const Twine &Name, BasicBlock *InsertAtEnd);
81 
82  AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize, unsigned Align,
83  const Twine &Name = "", Instruction *InsertBefore = nullptr);
84  AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize, unsigned Align,
85  const Twine &Name, BasicBlock *InsertAtEnd);
86 
87  /// Return true if there is an allocation size parameter to the allocation
88  /// instruction that is not 1.
89  bool isArrayAllocation() const;
90 
91  /// Get the number of elements allocated. For a simple allocation of a single
92  /// element, this will return a constant 1 value.
93  const Value *getArraySize() const { return getOperand(0); }
94  Value *getArraySize() { return getOperand(0); }
95 
96  /// Overload to return most specific pointer type.
97  PointerType *getType() const {
98  return cast<PointerType>(Instruction::getType());
99  }
100 
101  /// Return the type that is being allocated by the instruction.
102  Type *getAllocatedType() const { return AllocatedType; }
103  /// for use only in special circumstances that need to generically
104  /// transform a whole instruction (eg: IR linking and vectorization).
105  void setAllocatedType(Type *Ty) { AllocatedType = Ty; }
106 
107  /// Return the alignment of the memory that is being allocated by the
108  /// instruction.
109  unsigned getAlignment() const {
110  return (1u << (getSubclassDataFromInstruction() & 31)) >> 1;
111  }
112  void setAlignment(unsigned Align);
113 
114  /// Return true if this alloca is in the entry block of the function and is a
115  /// constant size. If so, the code generator will fold it into the
116  /// prolog/epilog code, so it is basically free.
117  bool isStaticAlloca() const;
118 
119  /// Return true if this alloca is used as an inalloca argument to a call. Such
120  /// allocas are never considered static even if they are in the entry block.
121  bool isUsedWithInAlloca() const {
122  return getSubclassDataFromInstruction() & 32;
123  }
124 
125  /// Specify whether this alloca is used to represent the arguments to a call.
126  void setUsedWithInAlloca(bool V) {
127  setInstructionSubclassData((getSubclassDataFromInstruction() & ~32) |
128  (V ? 32 : 0));
129  }
130 
131  /// Return true if this alloca is used as a swifterror argument to a call.
132  bool isSwiftError() const {
133  return getSubclassDataFromInstruction() & 64;
134  }
135 
136  /// Specify whether this alloca is used to represent a swifterror.
137  void setSwiftError(bool V) {
138  setInstructionSubclassData((getSubclassDataFromInstruction() & ~64) |
139  (V ? 64 : 0));
140  }
141 
142  // Methods for support type inquiry through isa, cast, and dyn_cast:
143  static bool classof(const Instruction *I) {
144  return (I->getOpcode() == Instruction::Alloca);
145  }
146  static bool classof(const Value *V) {
147  return isa<Instruction>(V) && classof(cast<Instruction>(V));
148  }
149 
150 private:
151  // Shadow Instruction::setInstructionSubclassData with a private forwarding
152  // method so that subclasses cannot accidentally use it.
153  void setInstructionSubclassData(unsigned short D) {
155  }
156 };
157 
158 //===----------------------------------------------------------------------===//
159 // LoadInst Class
160 //===----------------------------------------------------------------------===//
161 
162 /// An instruction for reading from memory. This uses the SubclassData field in
163 /// Value to store whether or not the load is volatile.
164 class LoadInst : public UnaryInstruction {
165  void AssertOK();
166 
167 protected:
168  // Note: Instruction needs to be a friend here to call cloneImpl.
169  friend class Instruction;
170 
171  LoadInst *cloneImpl() const;
172 
173 public:
174  LoadInst(Value *Ptr, const Twine &NameStr, Instruction *InsertBefore);
175  LoadInst(Value *Ptr, const Twine &NameStr, BasicBlock *InsertAtEnd);
176  LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile = false,
177  Instruction *InsertBefore = nullptr);
178  LoadInst(Value *Ptr, const Twine &NameStr, bool isVolatile = false,
179  Instruction *InsertBefore = nullptr)
180  : LoadInst(cast<PointerType>(Ptr->getType())->getElementType(), Ptr,
181  NameStr, isVolatile, InsertBefore) {}
182  LoadInst(Value *Ptr, const Twine &NameStr, bool isVolatile,
183  BasicBlock *InsertAtEnd);
184  LoadInst(Value *Ptr, const Twine &NameStr, bool isVolatile, unsigned Align,
185  Instruction *InsertBefore = nullptr)
186  : LoadInst(cast<PointerType>(Ptr->getType())->getElementType(), Ptr,
187  NameStr, isVolatile, Align, InsertBefore) {}
188  LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
189  unsigned Align, Instruction *InsertBefore = nullptr);
190  LoadInst(Value *Ptr, const Twine &NameStr, bool isVolatile,
191  unsigned Align, BasicBlock *InsertAtEnd);
192  LoadInst(Value *Ptr, const Twine &NameStr, bool isVolatile, unsigned Align,
194  Instruction *InsertBefore = nullptr)
195  : LoadInst(cast<PointerType>(Ptr->getType())->getElementType(), Ptr,
196  NameStr, isVolatile, Align, Order, SSID, InsertBefore) {}
197  LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
198  unsigned Align, AtomicOrdering Order,
200  Instruction *InsertBefore = nullptr);
201  LoadInst(Value *Ptr, const Twine &NameStr, bool isVolatile,
202  unsigned Align, AtomicOrdering Order, SyncScope::ID SSID,
203  BasicBlock *InsertAtEnd);
204  LoadInst(Value *Ptr, const char *NameStr, Instruction *InsertBefore);
205  LoadInst(Value *Ptr, const char *NameStr, BasicBlock *InsertAtEnd);
206  LoadInst(Type *Ty, Value *Ptr, const char *NameStr = nullptr,
207  bool isVolatile = false, Instruction *InsertBefore = nullptr);
208  explicit LoadInst(Value *Ptr, const char *NameStr = nullptr,
209  bool isVolatile = false,
210  Instruction *InsertBefore = nullptr)
211  : LoadInst(cast<PointerType>(Ptr->getType())->getElementType(), Ptr,
212  NameStr, isVolatile, InsertBefore) {}
213  LoadInst(Value *Ptr, const char *NameStr, bool isVolatile,
214  BasicBlock *InsertAtEnd);
215 
216  /// Return true if this is a load from a volatile memory location.
217  bool isVolatile() const { return getSubclassDataFromInstruction() & 1; }
218 
219  /// Specify whether this is a volatile load or not.
220  void setVolatile(bool V) {
221  setInstructionSubclassData((getSubclassDataFromInstruction() & ~1) |
222  (V ? 1 : 0));
223  }
224 
225  /// Return the alignment of the access that is being performed.
226  unsigned getAlignment() const {
227  return (1 << ((getSubclassDataFromInstruction() >> 1) & 31)) >> 1;
228  }
229 
230  void setAlignment(unsigned Align);
231 
232  /// Returns the ordering constraint of this load instruction.
234  return AtomicOrdering((getSubclassDataFromInstruction() >> 7) & 7);
235  }
236 
237  /// Sets the ordering constraint of this load instruction. May not be Release
238  /// or AcquireRelease.
239  void setOrdering(AtomicOrdering Ordering) {
240  setInstructionSubclassData((getSubclassDataFromInstruction() & ~(7 << 7)) |
241  ((unsigned)Ordering << 7));
242  }
243 
244  /// Returns the synchronization scope ID of this load instruction.
246  return SSID;
247  }
248 
249  /// Sets the synchronization scope ID of this load instruction.
251  this->SSID = SSID;
252  }
253 
254  /// Sets the ordering constraint and the synchronization scope ID of this load
255  /// instruction.
256  void setAtomic(AtomicOrdering Ordering,
258  setOrdering(Ordering);
259  setSyncScopeID(SSID);
260  }
261 
262  bool isSimple() const { return !isAtomic() && !isVolatile(); }
263 
264  bool isUnordered() const {
265  return (getOrdering() == AtomicOrdering::NotAtomic ||
266  getOrdering() == AtomicOrdering::Unordered) &&
267  !isVolatile();
268  }
269 
271  const Value *getPointerOperand() const { return getOperand(0); }
272  static unsigned getPointerOperandIndex() { return 0U; }
273  Type *getPointerOperandType() const { return getPointerOperand()->getType(); }
274 
275  /// Returns the address space of the pointer operand.
276  unsigned getPointerAddressSpace() const {
277  return getPointerOperandType()->getPointerAddressSpace();
278  }
279 
280  // Methods for support type inquiry through isa, cast, and dyn_cast:
281  static bool classof(const Instruction *I) {
282  return I->getOpcode() == Instruction::Load;
283  }
284  static bool classof(const Value *V) {
285  return isa<Instruction>(V) && classof(cast<Instruction>(V));
286  }
287 
288 private:
289  // Shadow Instruction::setInstructionSubclassData with a private forwarding
290  // method so that subclasses cannot accidentally use it.
291  void setInstructionSubclassData(unsigned short D) {
293  }
294 
295  /// The synchronization scope ID of this load instruction. Not quite enough
296  /// room in SubClassData for everything, so synchronization scope ID gets its
297  /// own field.
298  SyncScope::ID SSID;
299 };
300 
301 //===----------------------------------------------------------------------===//
302 // StoreInst Class
303 //===----------------------------------------------------------------------===//
304 
305 /// An instruction for storing to memory.
306 class StoreInst : public Instruction {
307  void AssertOK();
308 
309 protected:
310  // Note: Instruction needs to be a friend here to call cloneImpl.
311  friend class Instruction;
312 
313  StoreInst *cloneImpl() const;
314 
315 public:
316  StoreInst(Value *Val, Value *Ptr, Instruction *InsertBefore);
317  StoreInst(Value *Val, Value *Ptr, BasicBlock *InsertAtEnd);
318  StoreInst(Value *Val, Value *Ptr, bool isVolatile = false,
319  Instruction *InsertBefore = nullptr);
320  StoreInst(Value *Val, Value *Ptr, bool isVolatile, BasicBlock *InsertAtEnd);
321  StoreInst(Value *Val, Value *Ptr, bool isVolatile,
322  unsigned Align, Instruction *InsertBefore = nullptr);
323  StoreInst(Value *Val, Value *Ptr, bool isVolatile,
324  unsigned Align, BasicBlock *InsertAtEnd);
325  StoreInst(Value *Val, Value *Ptr, bool isVolatile,
326  unsigned Align, AtomicOrdering Order,
328  Instruction *InsertBefore = nullptr);
329  StoreInst(Value *Val, Value *Ptr, bool isVolatile,
330  unsigned Align, AtomicOrdering Order, SyncScope::ID SSID,
331  BasicBlock *InsertAtEnd);
332 
333  // allocate space for exactly two operands
334  void *operator new(size_t s) {
335  return User::operator new(s, 2);
336  }
337 
338  /// Return true if this is a store to a volatile memory location.
339  bool isVolatile() const { return getSubclassDataFromInstruction() & 1; }
340 
341  /// Specify whether this is a volatile store or not.
342  void setVolatile(bool V) {
343  setInstructionSubclassData((getSubclassDataFromInstruction() & ~1) |
344  (V ? 1 : 0));
345  }
346 
347  /// Transparently provide more efficient getOperand methods.
349 
350  /// Return the alignment of the access that is being performed
351  unsigned getAlignment() const {
352  return (1 << ((getSubclassDataFromInstruction() >> 1) & 31)) >> 1;
353  }
354 
355  void setAlignment(unsigned Align);
356 
357  /// Returns the ordering constraint of this store instruction.
359  return AtomicOrdering((getSubclassDataFromInstruction() >> 7) & 7);
360  }
361 
362  /// Sets the ordering constraint of this store instruction. May not be
363  /// Acquire or AcquireRelease.
364  void setOrdering(AtomicOrdering Ordering) {
365  setInstructionSubclassData((getSubclassDataFromInstruction() & ~(7 << 7)) |
366  ((unsigned)Ordering << 7));
367  }
368 
369  /// Returns the synchronization scope ID of this store instruction.
371  return SSID;
372  }
373 
374  /// Sets the synchronization scope ID of this store instruction.
376  this->SSID = SSID;
377  }
378 
379  /// Sets the ordering constraint and the synchronization scope ID of this
380  /// store instruction.
381  void setAtomic(AtomicOrdering Ordering,
383  setOrdering(Ordering);
384  setSyncScopeID(SSID);
385  }
386 
387  bool isSimple() const { return !isAtomic() && !isVolatile(); }
388 
389  bool isUnordered() const {
390  return (getOrdering() == AtomicOrdering::NotAtomic ||
391  getOrdering() == AtomicOrdering::Unordered) &&
392  !isVolatile();
393  }
394 
395  Value *getValueOperand() { return getOperand(0); }
396  const Value *getValueOperand() const { return getOperand(0); }
397 
399  const Value *getPointerOperand() const { return getOperand(1); }
400  static unsigned getPointerOperandIndex() { return 1U; }
401  Type *getPointerOperandType() const { return getPointerOperand()->getType(); }
402 
403  /// Returns the address space of the pointer operand.
404  unsigned getPointerAddressSpace() const {
405  return getPointerOperandType()->getPointerAddressSpace();
406  }
407 
408  // Methods for support type inquiry through isa, cast, and dyn_cast:
409  static bool classof(const Instruction *I) {
410  return I->getOpcode() == Instruction::Store;
411  }
412  static bool classof(const Value *V) {
413  return isa<Instruction>(V) && classof(cast<Instruction>(V));
414  }
415 
416 private:
417  // Shadow Instruction::setInstructionSubclassData with a private forwarding
418  // method so that subclasses cannot accidentally use it.
419  void setInstructionSubclassData(unsigned short D) {
421  }
422 
423  /// The synchronization scope ID of this store instruction. Not quite enough
424  /// room in SubClassData for everything, so synchronization scope ID gets its
425  /// own field.
426  SyncScope::ID SSID;
427 };
428 
429 template <>
430 struct OperandTraits<StoreInst> : public FixedNumOperandTraits<StoreInst, 2> {
431 };
432 
434 
435 //===----------------------------------------------------------------------===//
436 // FenceInst Class
437 //===----------------------------------------------------------------------===//
438 
439 /// An instruction for ordering other memory operations.
440 class FenceInst : public Instruction {
441  void Init(AtomicOrdering Ordering, SyncScope::ID SSID);
442 
443 protected:
444  // Note: Instruction needs to be a friend here to call cloneImpl.
445  friend class Instruction;
446 
447  FenceInst *cloneImpl() const;
448 
449 public:
450  // Ordering may only be Acquire, Release, AcquireRelease, or
451  // SequentiallyConsistent.
454  Instruction *InsertBefore = nullptr);
456  BasicBlock *InsertAtEnd);
457 
458  // allocate space for exactly zero operands
459  void *operator new(size_t s) {
460  return User::operator new(s, 0);
461  }
462 
463  /// Returns the ordering constraint of this fence instruction.
466  }
467 
468  /// Sets the ordering constraint of this fence instruction. May only be
469  /// Acquire, Release, AcquireRelease, or SequentiallyConsistent.
470  void setOrdering(AtomicOrdering Ordering) {
471  setInstructionSubclassData((getSubclassDataFromInstruction() & 1) |
472  ((unsigned)Ordering << 1));
473  }
474 
475  /// Returns the synchronization scope ID of this fence instruction.
477  return SSID;
478  }
479 
480  /// Sets the synchronization scope ID of this fence instruction.
482  this->SSID = SSID;
483  }
484 
485  // Methods for support type inquiry through isa, cast, and dyn_cast:
486  static bool classof(const Instruction *I) {
487  return I->getOpcode() == Instruction::Fence;
488  }
489  static bool classof(const Value *V) {
490  return isa<Instruction>(V) && classof(cast<Instruction>(V));
491  }
492 
493 private:
494  // Shadow Instruction::setInstructionSubclassData with a private forwarding
495  // method so that subclasses cannot accidentally use it.
496  void setInstructionSubclassData(unsigned short D) {
498  }
499 
500  /// The synchronization scope ID of this fence instruction. Not quite enough
501  /// room in SubClassData for everything, so synchronization scope ID gets its
502  /// own field.
503  SyncScope::ID SSID;
504 };
505 
506 //===----------------------------------------------------------------------===//
507 // AtomicCmpXchgInst Class
508 //===----------------------------------------------------------------------===//
509 
510 /// an instruction that atomically checks whether a
511 /// specified value is in a memory location, and, if it is, stores a new value
512 /// there. Returns the value that was loaded.
513 ///
515  void Init(Value *Ptr, Value *Cmp, Value *NewVal,
516  AtomicOrdering SuccessOrdering, AtomicOrdering FailureOrdering,
517  SyncScope::ID SSID);
518 
519 protected:
520  // Note: Instruction needs to be a friend here to call cloneImpl.
521  friend class Instruction;
522 
523  AtomicCmpXchgInst *cloneImpl() const;
524 
525 public:
526  AtomicCmpXchgInst(Value *Ptr, Value *Cmp, Value *NewVal,
527  AtomicOrdering SuccessOrdering,
528  AtomicOrdering FailureOrdering,
529  SyncScope::ID SSID, Instruction *InsertBefore = nullptr);
530  AtomicCmpXchgInst(Value *Ptr, Value *Cmp, Value *NewVal,
531  AtomicOrdering SuccessOrdering,
532  AtomicOrdering FailureOrdering,
533  SyncScope::ID SSID, BasicBlock *InsertAtEnd);
534 
535  // allocate space for exactly three operands
536  void *operator new(size_t s) {
537  return User::operator new(s, 3);
538  }
539 
540  /// Return true if this is a cmpxchg from a volatile memory
541  /// location.
542  ///
543  bool isVolatile() const {
544  return getSubclassDataFromInstruction() & 1;
545  }
546 
547  /// Specify whether this is a volatile cmpxchg.
548  ///
549  void setVolatile(bool V) {
550  setInstructionSubclassData((getSubclassDataFromInstruction() & ~1) |
551  (unsigned)V);
552  }
553 
554  /// Return true if this cmpxchg may spuriously fail.
555  bool isWeak() const {
556  return getSubclassDataFromInstruction() & 0x100;
557  }
558 
559  void setWeak(bool IsWeak) {
560  setInstructionSubclassData((getSubclassDataFromInstruction() & ~0x100) |
561  (IsWeak << 8));
562  }
563 
564  /// Transparently provide more efficient getOperand methods.
566 
567  /// Returns the success ordering constraint of this cmpxchg instruction.
569  return AtomicOrdering((getSubclassDataFromInstruction() >> 2) & 7);
570  }
571 
572  /// Sets the success ordering constraint of this cmpxchg instruction.
574  assert(Ordering != AtomicOrdering::NotAtomic &&
575  "CmpXchg instructions can only be atomic.");
576  setInstructionSubclassData((getSubclassDataFromInstruction() & ~0x1c) |
577  ((unsigned)Ordering << 2));
578  }
579 
580  /// Returns the failure ordering constraint of this cmpxchg instruction.
582  return AtomicOrdering((getSubclassDataFromInstruction() >> 5) & 7);
583  }
584 
585  /// Sets the failure ordering constraint of this cmpxchg instruction.
587  assert(Ordering != AtomicOrdering::NotAtomic &&
588  "CmpXchg instructions can only be atomic.");
589  setInstructionSubclassData((getSubclassDataFromInstruction() & ~0xe0) |
590  ((unsigned)Ordering << 5));
591  }
592 
593  /// Returns the synchronization scope ID of this cmpxchg instruction.
595  return SSID;
596  }
597 
598  /// Sets the synchronization scope ID of this cmpxchg instruction.
600  this->SSID = SSID;
601  }
602 
604  const Value *getPointerOperand() const { return getOperand(0); }
605  static unsigned getPointerOperandIndex() { return 0U; }
606 
608  const Value *getCompareOperand() const { return getOperand(1); }
609 
611  const Value *getNewValOperand() const { return getOperand(2); }
612 
613  /// Returns the address space of the pointer operand.
614  unsigned getPointerAddressSpace() const {
615  return getPointerOperand()->getType()->getPointerAddressSpace();
616  }
617 
618  /// Returns the strongest permitted ordering on failure, given the
619  /// desired ordering on success.
620  ///
621  /// If the comparison in a cmpxchg operation fails, there is no atomic store
622  /// so release semantics cannot be provided. So this function drops explicit
623  /// Release requests from the AtomicOrdering. A SequentiallyConsistent
624  /// operation would remain SequentiallyConsistent.
625  static AtomicOrdering
627  switch (SuccessOrdering) {
628  default:
629  llvm_unreachable("invalid cmpxchg success ordering");
638  }
639  }
640 
641  // Methods for support type inquiry through isa, cast, and dyn_cast:
642  static bool classof(const Instruction *I) {
643  return I->getOpcode() == Instruction::AtomicCmpXchg;
644  }
645  static bool classof(const Value *V) {
646  return isa<Instruction>(V) && classof(cast<Instruction>(V));
647  }
648 
649 private:
650  // Shadow Instruction::setInstructionSubclassData with a private forwarding
651  // method so that subclasses cannot accidentally use it.
652  void setInstructionSubclassData(unsigned short D) {
654  }
655 
656  /// The synchronization scope ID of this cmpxchg instruction. Not quite
657  /// enough room in SubClassData for everything, so synchronization scope ID
658  /// gets its own field.
659  SyncScope::ID SSID;
660 };
661 
662 template <>
664  public FixedNumOperandTraits<AtomicCmpXchgInst, 3> {
665 };
666 
668 
669 //===----------------------------------------------------------------------===//
670 // AtomicRMWInst Class
671 //===----------------------------------------------------------------------===//
672 
673 /// an instruction that atomically reads a memory location,
674 /// combines it with another value, and then stores the result back. Returns
675 /// the old value.
676 ///
677 class AtomicRMWInst : public Instruction {
678 protected:
679  // Note: Instruction needs to be a friend here to call cloneImpl.
680  friend class Instruction;
681 
682  AtomicRMWInst *cloneImpl() const;
683 
684 public:
685  /// This enumeration lists the possible modifications atomicrmw can make. In
686  /// the descriptions, 'p' is the pointer to the instruction's memory location,
687  /// 'old' is the initial value of *p, and 'v' is the other value passed to the
688  /// instruction. These instructions always return 'old'.
689  enum BinOp {
690  /// *p = v
692  /// *p = old + v
694  /// *p = old - v
696  /// *p = old & v
698  /// *p = ~(old & v)
700  /// *p = old | v
701  Or,
702  /// *p = old ^ v
704  /// *p = old >signed v ? old : v
706  /// *p = old <signed v ? old : v
708  /// *p = old >unsigned v ? old : v
710  /// *p = old <unsigned v ? old : v
712 
713  FIRST_BINOP = Xchg,
714  LAST_BINOP = UMin,
715  BAD_BINOP
716  };
717 
718  AtomicRMWInst(BinOp Operation, Value *Ptr, Value *Val,
719  AtomicOrdering Ordering, SyncScope::ID SSID,
720  Instruction *InsertBefore = nullptr);
721  AtomicRMWInst(BinOp Operation, Value *Ptr, Value *Val,
722  AtomicOrdering Ordering, SyncScope::ID SSID,
723  BasicBlock *InsertAtEnd);
724 
725  // allocate space for exactly two operands
726  void *operator new(size_t s) {
727  return User::operator new(s, 2);
728  }
729 
730  BinOp getOperation() const {
731  return static_cast<BinOp>(getSubclassDataFromInstruction() >> 5);
732  }
733 
734  void setOperation(BinOp Operation) {
735  unsigned short SubclassData = getSubclassDataFromInstruction();
736  setInstructionSubclassData((SubclassData & 31) |
737  (Operation << 5));
738  }
739 
740  /// Return true if this is a RMW on a volatile memory location.
741  ///
742  bool isVolatile() const {
743  return getSubclassDataFromInstruction() & 1;
744  }
745 
746  /// Specify whether this is a volatile RMW or not.
747  ///
748  void setVolatile(bool V) {
749  setInstructionSubclassData((getSubclassDataFromInstruction() & ~1) |
750  (unsigned)V);
751  }
752 
753  /// Transparently provide more efficient getOperand methods.
755 
756  /// Returns the ordering constraint of this rmw instruction.
758  return AtomicOrdering((getSubclassDataFromInstruction() >> 2) & 7);
759  }
760 
761  /// Sets the ordering constraint of this rmw instruction.
762  void setOrdering(AtomicOrdering Ordering) {
763  assert(Ordering != AtomicOrdering::NotAtomic &&
764  "atomicrmw instructions can only be atomic.");
765  setInstructionSubclassData((getSubclassDataFromInstruction() & ~(7 << 2)) |
766  ((unsigned)Ordering << 2));
767  }
768 
769  /// Returns the synchronization scope ID of this rmw instruction.
771  return SSID;
772  }
773 
774  /// Sets the synchronization scope ID of this rmw instruction.
776  this->SSID = SSID;
777  }
778 
780  const Value *getPointerOperand() const { return getOperand(0); }
781  static unsigned getPointerOperandIndex() { return 0U; }
782 
783  Value *getValOperand() { return getOperand(1); }
784  const Value *getValOperand() const { return getOperand(1); }
785 
786  /// Returns the address space of the pointer operand.
787  unsigned getPointerAddressSpace() const {
788  return getPointerOperand()->getType()->getPointerAddressSpace();
789  }
790 
791  // Methods for support type inquiry through isa, cast, and dyn_cast:
792  static bool classof(const Instruction *I) {
793  return I->getOpcode() == Instruction::AtomicRMW;
794  }
795  static bool classof(const Value *V) {
796  return isa<Instruction>(V) && classof(cast<Instruction>(V));
797  }
798 
799 private:
800  void Init(BinOp Operation, Value *Ptr, Value *Val,
801  AtomicOrdering Ordering, SyncScope::ID SSID);
802 
803  // Shadow Instruction::setInstructionSubclassData with a private forwarding
804  // method so that subclasses cannot accidentally use it.
805  void setInstructionSubclassData(unsigned short D) {
807  }
808 
809  /// The synchronization scope ID of this rmw instruction. Not quite enough
810  /// room in SubClassData for everything, so synchronization scope ID gets its
811  /// own field.
812  SyncScope::ID SSID;
813 };
814 
815 template <>
817  : public FixedNumOperandTraits<AtomicRMWInst,2> {
818 };
819 
821 
822 //===----------------------------------------------------------------------===//
823 // GetElementPtrInst Class
824 //===----------------------------------------------------------------------===//
825 
826 // checkGEPType - Simple wrapper function to give a better assertion failure
827 // message on bad indexes for a gep instruction.
828 //
830  assert(Ty && "Invalid GetElementPtrInst indices for type!");
831  return Ty;
832 }
833 
834 /// an instruction for type-safe pointer arithmetic to
835 /// access elements of arrays and structs
836 ///
838  Type *SourceElementType;
839  Type *ResultElementType;
840 
842 
843  /// Constructors - Create a getelementptr instruction with a base pointer an
844  /// list of indices. The first ctor can optionally insert before an existing
845  /// instruction, the second appends the new instruction to the specified
846  /// BasicBlock.
847  inline GetElementPtrInst(Type *PointeeType, Value *Ptr,
848  ArrayRef<Value *> IdxList, unsigned Values,
849  const Twine &NameStr, Instruction *InsertBefore);
850  inline GetElementPtrInst(Type *PointeeType, Value *Ptr,
851  ArrayRef<Value *> IdxList, unsigned Values,
852  const Twine &NameStr, BasicBlock *InsertAtEnd);
853 
854  void init(Value *Ptr, ArrayRef<Value *> IdxList, const Twine &NameStr);
855 
856 protected:
857  // Note: Instruction needs to be a friend here to call cloneImpl.
858  friend class Instruction;
859 
860  GetElementPtrInst *cloneImpl() const;
861 
862 public:
863  static GetElementPtrInst *Create(Type *PointeeType, Value *Ptr,
864  ArrayRef<Value *> IdxList,
865  const Twine &NameStr = "",
866  Instruction *InsertBefore = nullptr) {
867  unsigned Values = 1 + unsigned(IdxList.size());
868  if (!PointeeType)
869  PointeeType =
870  cast<PointerType>(Ptr->getType()->getScalarType())->getElementType();
871  else
872  assert(
873  PointeeType ==
874  cast<PointerType>(Ptr->getType()->getScalarType())->getElementType());
875  return new (Values) GetElementPtrInst(PointeeType, Ptr, IdxList, Values,
876  NameStr, InsertBefore);
877  }
878 
879  static GetElementPtrInst *Create(Type *PointeeType, Value *Ptr,
880  ArrayRef<Value *> IdxList,
881  const Twine &NameStr,
882  BasicBlock *InsertAtEnd) {
883  unsigned Values = 1 + unsigned(IdxList.size());
884  if (!PointeeType)
885  PointeeType =
886  cast<PointerType>(Ptr->getType()->getScalarType())->getElementType();
887  else
888  assert(
889  PointeeType ==
890  cast<PointerType>(Ptr->getType()->getScalarType())->getElementType());
891  return new (Values) GetElementPtrInst(PointeeType, Ptr, IdxList, Values,
892  NameStr, InsertAtEnd);
893  }
894 
895  /// Create an "inbounds" getelementptr. See the documentation for the
896  /// "inbounds" flag in LangRef.html for details.
898  ArrayRef<Value *> IdxList,
899  const Twine &NameStr = "",
900  Instruction *InsertBefore = nullptr){
901  return CreateInBounds(nullptr, Ptr, IdxList, NameStr, InsertBefore);
902  }
903 
904  static GetElementPtrInst *
905  CreateInBounds(Type *PointeeType, Value *Ptr, ArrayRef<Value *> IdxList,
906  const Twine &NameStr = "",
907  Instruction *InsertBefore = nullptr) {
909  Create(PointeeType, Ptr, IdxList, NameStr, InsertBefore);
910  GEP->setIsInBounds(true);
911  return GEP;
912  }
913 
915  ArrayRef<Value *> IdxList,
916  const Twine &NameStr,
917  BasicBlock *InsertAtEnd) {
918  return CreateInBounds(nullptr, Ptr, IdxList, NameStr, InsertAtEnd);
919  }
920 
921  static GetElementPtrInst *CreateInBounds(Type *PointeeType, Value *Ptr,
922  ArrayRef<Value *> IdxList,
923  const Twine &NameStr,
924  BasicBlock *InsertAtEnd) {
926  Create(PointeeType, Ptr, IdxList, NameStr, InsertAtEnd);
927  GEP->setIsInBounds(true);
928  return GEP;
929  }
930 
931  /// Transparently provide more efficient getOperand methods.
933 
934  Type *getSourceElementType() const { return SourceElementType; }
935 
936  void setSourceElementType(Type *Ty) { SourceElementType = Ty; }
937  void setResultElementType(Type *Ty) { ResultElementType = Ty; }
938 
940  assert(ResultElementType ==
941  cast<PointerType>(getType()->getScalarType())->getElementType());
942  return ResultElementType;
943  }
944 
945  /// Returns the address space of this instruction's pointer type.
946  unsigned getAddressSpace() const {
947  // Note that this is always the same as the pointer operand's address space
948  // and that is cheaper to compute, so cheat here.
949  return getPointerAddressSpace();
950  }
951 
952  /// Returns the type of the element that would be loaded with
953  /// a load instruction with the specified parameters.
954  ///
955  /// Null is returned if the indices are invalid for the specified
956  /// pointer type.
957  ///
958  static Type *getIndexedType(Type *Ty, ArrayRef<Value *> IdxList);
959  static Type *getIndexedType(Type *Ty, ArrayRef<Constant *> IdxList);
960  static Type *getIndexedType(Type *Ty, ArrayRef<uint64_t> IdxList);
961 
962  inline op_iterator idx_begin() { return op_begin()+1; }
963  inline const_op_iterator idx_begin() const { return op_begin()+1; }
964  inline op_iterator idx_end() { return op_end(); }
965  inline const_op_iterator idx_end() const { return op_end(); }
966 
968  return make_range(idx_begin(), idx_end());
969  }
970 
972  return make_range(idx_begin(), idx_end());
973  }
974 
976  return getOperand(0);
977  }
978  const Value *getPointerOperand() const {
979  return getOperand(0);
980  }
981  static unsigned getPointerOperandIndex() {
982  return 0U; // get index for modifying correct operand.
983  }
984 
985  /// Method to return the pointer operand as a
986  /// PointerType.
988  return getPointerOperand()->getType();
989  }
990 
991  /// Returns the address space of the pointer operand.
992  unsigned getPointerAddressSpace() const {
993  return getPointerOperandType()->getPointerAddressSpace();
994  }
995 
996  /// Returns the pointer type returned by the GEP
997  /// instruction, which may be a vector of pointers.
998  static Type *getGEPReturnType(Value *Ptr, ArrayRef<Value *> IdxList) {
999  return getGEPReturnType(
1000  cast<PointerType>(Ptr->getType()->getScalarType())->getElementType(),
1001  Ptr, IdxList);
1002  }
1003  static Type *getGEPReturnType(Type *ElTy, Value *Ptr,
1004  ArrayRef<Value *> IdxList) {
1005  Type *PtrTy = PointerType::get(checkGEPType(getIndexedType(ElTy, IdxList)),
1006  Ptr->getType()->getPointerAddressSpace());
1007  // Vector GEP
1008  if (Ptr->getType()->isVectorTy()) {
1009  unsigned NumElem = Ptr->getType()->getVectorNumElements();
1010  return VectorType::get(PtrTy, NumElem);
1011  }
1012  for (Value *Index : IdxList)
1013  if (Index->getType()->isVectorTy()) {
1014  unsigned NumElem = Index->getType()->getVectorNumElements();
1015  return VectorType::get(PtrTy, NumElem);
1016  }
1017  // Scalar GEP
1018  return PtrTy;
1019  }
1020 
1021  unsigned getNumIndices() const { // Note: always non-negative
1022  return getNumOperands() - 1;
1023  }
1024 
1025  bool hasIndices() const {
1026  return getNumOperands() > 1;
1027  }
1028 
1029  /// Return true if all of the indices of this GEP are
1030  /// zeros. If so, the result pointer and the first operand have the same
1031  /// value, just potentially different types.
1032  bool hasAllZeroIndices() const;
1033 
1034  /// Return true if all of the indices of this GEP are
1035  /// constant integers. If so, the result pointer and the first operand have
1036  /// a constant offset between them.
1037  bool hasAllConstantIndices() const;
1038 
1039  /// Set or clear the inbounds flag on this GEP instruction.
1040  /// See LangRef.html for the meaning of inbounds on a getelementptr.
1041  void setIsInBounds(bool b = true);
1042 
1043  /// Determine whether the GEP has the inbounds flag.
1044  bool isInBounds() const;
1045 
1046  /// Accumulate the constant address offset of this GEP if possible.
1047  ///
1048  /// This routine accepts an APInt into which it will accumulate the constant
1049  /// offset of this GEP if the GEP is in fact constant. If the GEP is not
1050  /// all-constant, it returns false and the value of the offset APInt is
1051  /// undefined (it is *not* preserved!). The APInt passed into this routine
1052  /// must be at least as wide as the IntPtr type for the address space of
1053  /// the base GEP pointer.
1054  bool accumulateConstantOffset(const DataLayout &DL, APInt &Offset) const;
1055 
1056  // Methods for support type inquiry through isa, cast, and dyn_cast:
1057  static bool classof(const Instruction *I) {
1058  return (I->getOpcode() == Instruction::GetElementPtr);
1059  }
1060  static bool classof(const Value *V) {
1061  return isa<Instruction>(V) && classof(cast<Instruction>(V));
1062  }
1063 };
1064 
1065 template <>
1067  public VariadicOperandTraits<GetElementPtrInst, 1> {
1068 };
1069 
1070 GetElementPtrInst::GetElementPtrInst(Type *PointeeType, Value *Ptr,
1071  ArrayRef<Value *> IdxList, unsigned Values,
1072  const Twine &NameStr,
1073  Instruction *InsertBefore)
1074  : Instruction(getGEPReturnType(PointeeType, Ptr, IdxList), GetElementPtr,
1076  Values, InsertBefore),
1077  SourceElementType(PointeeType),
1078  ResultElementType(getIndexedType(PointeeType, IdxList)) {
1079  assert(ResultElementType ==
1080  cast<PointerType>(getType()->getScalarType())->getElementType());
1081  init(Ptr, IdxList, NameStr);
1082 }
1083 
1084 GetElementPtrInst::GetElementPtrInst(Type *PointeeType, Value *Ptr,
1085  ArrayRef<Value *> IdxList, unsigned Values,
1086  const Twine &NameStr,
1087  BasicBlock *InsertAtEnd)
1088  : Instruction(getGEPReturnType(PointeeType, Ptr, IdxList), GetElementPtr,
1090  Values, InsertAtEnd),
1091  SourceElementType(PointeeType),
1092  ResultElementType(getIndexedType(PointeeType, IdxList)) {
1093  assert(ResultElementType ==
1094  cast<PointerType>(getType()->getScalarType())->getElementType());
1095  init(Ptr, IdxList, NameStr);
1096 }
1097 
1098 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(GetElementPtrInst, Value)
1099 
1100 //===----------------------------------------------------------------------===//
1101 // ICmpInst Class
1102 //===----------------------------------------------------------------------===//
1103 
1104 /// This instruction compares its operands according to the predicate given
1105 /// to the constructor. It only operates on integers or pointers. The operands
1106 /// must be identical types.
1107 /// Represent an integer comparison operator.
1108 class ICmpInst: public CmpInst {
1109  void AssertOK() {
1110  assert(isIntPredicate() &&
1111  "Invalid ICmp predicate value");
1112  assert(getOperand(0)->getType() == getOperand(1)->getType() &&
1113  "Both operands to ICmp instruction are not of the same type!");
1114  // Check that the operands are the right type
1115  assert((getOperand(0)->getType()->isIntOrIntVectorTy() ||
1116  getOperand(0)->getType()->isPtrOrPtrVectorTy()) &&
1117  "Invalid operand types for ICmp instruction");
1118  }
1119 
1120 protected:
1121  // Note: Instruction needs to be a friend here to call cloneImpl.
1122  friend class Instruction;
1123 
1124  /// Clone an identical ICmpInst
1125  ICmpInst *cloneImpl() const;
1126 
1127 public:
1128  /// Constructor with insert-before-instruction semantics.
1130  Instruction *InsertBefore, ///< Where to insert
1131  Predicate pred, ///< The predicate to use for the comparison
1132  Value *LHS, ///< The left-hand-side of the expression
1133  Value *RHS, ///< The right-hand-side of the expression
1134  const Twine &NameStr = "" ///< Name of the instruction
1135  ) : CmpInst(makeCmpResultType(LHS->getType()),
1136  Instruction::ICmp, pred, LHS, RHS, NameStr,
1137  InsertBefore) {
1138 #ifndef NDEBUG
1139  AssertOK();
1140 #endif
1141  }
1142 
1143  /// Constructor with insert-at-end semantics.
1145  BasicBlock &InsertAtEnd, ///< Block to insert into.
1146  Predicate pred, ///< The predicate to use for the comparison
1147  Value *LHS, ///< The left-hand-side of the expression
1148  Value *RHS, ///< The right-hand-side of the expression
1149  const Twine &NameStr = "" ///< Name of the instruction
1150  ) : CmpInst(makeCmpResultType(LHS->getType()),
1151  Instruction::ICmp, pred, LHS, RHS, NameStr,
1152  &InsertAtEnd) {
1153 #ifndef NDEBUG
1154  AssertOK();
1155 #endif
1156  }
1157 
1158  /// Constructor with no-insertion semantics
1160  Predicate pred, ///< The predicate to use for the comparison
1161  Value *LHS, ///< The left-hand-side of the expression
1162  Value *RHS, ///< The right-hand-side of the expression
1163  const Twine &NameStr = "" ///< Name of the instruction
1164  ) : CmpInst(makeCmpResultType(LHS->getType()),
1165  Instruction::ICmp, pred, LHS, RHS, NameStr) {
1166 #ifndef NDEBUG
1167  AssertOK();
1168 #endif
1169  }
1170 
1171  /// For example, EQ->EQ, SLE->SLE, UGT->SGT, etc.
1172  /// @returns the predicate that would be the result if the operand were
1173  /// regarded as signed.
1174  /// Return the signed version of the predicate
1176  return getSignedPredicate(getPredicate());
1177  }
1178 
1179  /// This is a static version that you can use without an instruction.
1180  /// Return the signed version of the predicate.
1181  static Predicate getSignedPredicate(Predicate pred);
1182 
1183  /// For example, EQ->EQ, SLE->ULE, UGT->UGT, etc.
1184  /// @returns the predicate that would be the result if the operand were
1185  /// regarded as unsigned.
1186  /// Return the unsigned version of the predicate
1188  return getUnsignedPredicate(getPredicate());
1189  }
1190 
1191  /// This is a static version that you can use without an instruction.
1192  /// Return the unsigned version of the predicate.
1193  static Predicate getUnsignedPredicate(Predicate pred);
1194 
1195  /// Return true if this predicate is either EQ or NE. This also
1196  /// tests for commutativity.
1197  static bool isEquality(Predicate P) {
1198  return P == ICMP_EQ || P == ICMP_NE;
1199  }
1200 
1201  /// Return true if this predicate is either EQ or NE. This also
1202  /// tests for commutativity.
1203  bool isEquality() const {
1204  return isEquality(getPredicate());
1205  }
1206 
1207  /// @returns true if the predicate of this ICmpInst is commutative
1208  /// Determine if this relation is commutative.
1209  bool isCommutative() const { return isEquality(); }
1210 
1211  /// Return true if the predicate is relational (not EQ or NE).
1212  ///
1213  bool isRelational() const {
1214  return !isEquality();
1215  }
1216 
1217  /// Return true if the predicate is relational (not EQ or NE).
1218  ///
1219  static bool isRelational(Predicate P) {
1220  return !isEquality(P);
1221  }
1222 
1223  /// Exchange the two operands to this instruction in such a way that it does
1224  /// not modify the semantics of the instruction. The predicate value may be
1225  /// changed to retain the same result if the predicate is order dependent
1226  /// (e.g. ult).
1227  /// Swap operands and adjust predicate.
1228  void swapOperands() {
1229  setPredicate(getSwappedPredicate());
1230  Op<0>().swap(Op<1>());
1231  }
1232 
1233  // Methods for support type inquiry through isa, cast, and dyn_cast:
1234  static bool classof(const Instruction *I) {
1235  return I->getOpcode() == Instruction::ICmp;
1236  }
1237  static bool classof(const Value *V) {
1238  return isa<Instruction>(V) && classof(cast<Instruction>(V));
1239  }
1240 };
1241 
1242 //===----------------------------------------------------------------------===//
1243 // FCmpInst Class
1244 //===----------------------------------------------------------------------===//
1245 
1246 /// This instruction compares its operands according to the predicate given
1247 /// to the constructor. It only operates on floating point values or packed
1248 /// vectors of floating point values. The operands must be identical types.
1249 /// Represents a floating point comparison operator.
1250 class FCmpInst: public CmpInst {
1251  void AssertOK() {
1252  assert(isFPPredicate() && "Invalid FCmp predicate value");
1253  assert(getOperand(0)->getType() == getOperand(1)->getType() &&
1254  "Both operands to FCmp instruction are not of the same type!");
1255  // Check that the operands are the right type
1256  assert(getOperand(0)->getType()->isFPOrFPVectorTy() &&
1257  "Invalid operand types for FCmp instruction");
1258  }
1259 
1260 protected:
1261  // Note: Instruction needs to be a friend here to call cloneImpl.
1262  friend class Instruction;
1263 
1264  /// Clone an identical FCmpInst
1265  FCmpInst *cloneImpl() const;
1266 
1267 public:
1268  /// Constructor with insert-before-instruction semantics.
1270  Instruction *InsertBefore, ///< Where to insert
1271  Predicate pred, ///< The predicate to use for the comparison
1272  Value *LHS, ///< The left-hand-side of the expression
1273  Value *RHS, ///< The right-hand-side of the expression
1274  const Twine &NameStr = "" ///< Name of the instruction
1275  ) : CmpInst(makeCmpResultType(LHS->getType()),
1276  Instruction::FCmp, pred, LHS, RHS, NameStr,
1277  InsertBefore) {
1278  AssertOK();
1279  }
1280 
1281  /// Constructor with insert-at-end semantics.
1283  BasicBlock &InsertAtEnd, ///< Block to insert into.
1284  Predicate pred, ///< The predicate to use for the comparison
1285  Value *LHS, ///< The left-hand-side of the expression
1286  Value *RHS, ///< The right-hand-side of the expression
1287  const Twine &NameStr = "" ///< Name of the instruction
1288  ) : CmpInst(makeCmpResultType(LHS->getType()),
1289  Instruction::FCmp, pred, LHS, RHS, NameStr,
1290  &InsertAtEnd) {
1291  AssertOK();
1292  }
1293 
1294  /// Constructor with no-insertion semantics
1296  Predicate pred, ///< The predicate to use for the comparison
1297  Value *LHS, ///< The left-hand-side of the expression
1298  Value *RHS, ///< The right-hand-side of the expression
1299  const Twine &NameStr = "" ///< Name of the instruction
1300  ) : CmpInst(makeCmpResultType(LHS->getType()),
1301  Instruction::FCmp, pred, LHS, RHS, NameStr) {
1302  AssertOK();
1303  }
1304 
1305  /// @returns true if the predicate of this instruction is EQ or NE.
1306  /// Determine if this is an equality predicate.
1307  static bool isEquality(Predicate Pred) {
1308  return Pred == FCMP_OEQ || Pred == FCMP_ONE || Pred == FCMP_UEQ ||
1309  Pred == FCMP_UNE;
1310  }
1311 
1312  /// @returns true if the predicate of this instruction is EQ or NE.
1313  /// Determine if this is an equality predicate.
1314  bool isEquality() const { return isEquality(getPredicate()); }
1315 
1316  /// @returns true if the predicate of this instruction is commutative.
1317  /// Determine if this is a commutative predicate.
1318  bool isCommutative() const {
1319  return isEquality() ||
1320  getPredicate() == FCMP_FALSE ||
1321  getPredicate() == FCMP_TRUE ||
1322  getPredicate() == FCMP_ORD ||
1323  getPredicate() == FCMP_UNO;
1324  }
1325 
1326  /// @returns true if the predicate is relational (not EQ or NE).
1327  /// Determine if this a relational predicate.
1328  bool isRelational() const { return !isEquality(); }
1329 
1330  /// Exchange the two operands to this instruction in such a way that it does
1331  /// not modify the semantics of the instruction. The predicate value may be
1332  /// changed to retain the same result if the predicate is order dependent
1333  /// (e.g. ult).
1334  /// Swap operands and adjust predicate.
1335  void swapOperands() {
1336  setPredicate(getSwappedPredicate());
1337  Op<0>().swap(Op<1>());
1338  }
1339 
1340  /// Methods for support type inquiry through isa, cast, and dyn_cast:
1341  static bool classof(const Instruction *I) {
1342  return I->getOpcode() == Instruction::FCmp;
1343  }
1344  static bool classof(const Value *V) {
1345  return isa<Instruction>(V) && classof(cast<Instruction>(V));
1346  }
1347 };
1348 
1349 //===----------------------------------------------------------------------===//
1350 /// This class represents a function call, abstracting a target
1351 /// machine's calling convention. This class uses low bit of the SubClassData
1352 /// field to indicate whether or not this is a tail call. The rest of the bits
1353 /// hold the calling convention of the call.
1354 ///
1355 class CallInst : public Instruction,
1356  public OperandBundleUser<CallInst, User::op_iterator> {
1358 
1359  AttributeList Attrs; ///< parameter attributes for call
1360  FunctionType *FTy;
1361 
1362  CallInst(const CallInst &CI);
1363 
1364  /// Construct a CallInst given a range of arguments.
1365  /// Construct a CallInst from a range of arguments
1366  inline CallInst(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
1367  ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr,
1368  Instruction *InsertBefore);
1369 
1370  inline CallInst(Value *Func, ArrayRef<Value *> Args,
1371  ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr,
1372  Instruction *InsertBefore)
1373  : CallInst(cast<FunctionType>(
1374  cast<PointerType>(Func->getType())->getElementType()),
1375  Func, Args, Bundles, NameStr, InsertBefore) {}
1376 
1377  inline CallInst(Value *Func, ArrayRef<Value *> Args, const Twine &NameStr,
1378  Instruction *InsertBefore)
1379  : CallInst(Func, Args, None, NameStr, InsertBefore) {}
1380 
1381  /// Construct a CallInst given a range of arguments.
1382  /// Construct a CallInst from a range of arguments
1383  inline CallInst(Value *Func, ArrayRef<Value *> Args,
1384  ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr,
1385  BasicBlock *InsertAtEnd);
1386 
1387  explicit CallInst(Value *F, const Twine &NameStr,
1388  Instruction *InsertBefore);
1389 
1390  CallInst(Value *F, const Twine &NameStr, BasicBlock *InsertAtEnd);
1391 
1392  void init(Value *Func, ArrayRef<Value *> Args,
1393  ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr) {
1394  init(cast<FunctionType>(
1395  cast<PointerType>(Func->getType())->getElementType()),
1396  Func, Args, Bundles, NameStr);
1397  }
1398  void init(FunctionType *FTy, Value *Func, ArrayRef<Value *> Args,
1399  ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr);
1400  void init(Value *Func, const Twine &NameStr);
1401 
1402  bool hasDescriptor() const { return HasDescriptor; }
1403 
1404 protected:
1405  // Note: Instruction needs to be a friend here to call cloneImpl.
1406  friend class Instruction;
1407 
1408  CallInst *cloneImpl() const;
1409 
1410 public:
1411  static CallInst *Create(Value *Func, ArrayRef<Value *> Args,
1412  ArrayRef<OperandBundleDef> Bundles = None,
1413  const Twine &NameStr = "",
1414  Instruction *InsertBefore = nullptr) {
1415  return Create(cast<FunctionType>(
1416  cast<PointerType>(Func->getType())->getElementType()),
1417  Func, Args, Bundles, NameStr, InsertBefore);
1418  }
1419 
1420  static CallInst *Create(Value *Func, ArrayRef<Value *> Args,
1421  const Twine &NameStr,
1422  Instruction *InsertBefore = nullptr) {
1423  return Create(cast<FunctionType>(
1424  cast<PointerType>(Func->getType())->getElementType()),
1425  Func, Args, None, NameStr, InsertBefore);
1426  }
1427 
1428  static CallInst *Create(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
1429  const Twine &NameStr,
1430  Instruction *InsertBefore = nullptr) {
1431  return new (unsigned(Args.size() + 1))
1432  CallInst(Ty, Func, Args, None, NameStr, InsertBefore);
1433  }
1434 
1435  static CallInst *Create(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
1436  ArrayRef<OperandBundleDef> Bundles = None,
1437  const Twine &NameStr = "",
1438  Instruction *InsertBefore = nullptr) {
1439  const unsigned TotalOps =
1440  unsigned(Args.size()) + CountBundleInputs(Bundles) + 1;
1441  const unsigned DescriptorBytes = Bundles.size() * sizeof(BundleOpInfo);
1442 
1443  return new (TotalOps, DescriptorBytes)
1444  CallInst(Ty, Func, Args, Bundles, NameStr, InsertBefore);
1445  }
1446 
1447  static CallInst *Create(Value *Func, ArrayRef<Value *> Args,
1449  const Twine &NameStr, BasicBlock *InsertAtEnd) {
1450  const unsigned TotalOps =
1451  unsigned(Args.size()) + CountBundleInputs(Bundles) + 1;
1452  const unsigned DescriptorBytes = Bundles.size() * sizeof(BundleOpInfo);
1453 
1454  return new (TotalOps, DescriptorBytes)
1455  CallInst(Func, Args, Bundles, NameStr, InsertAtEnd);
1456  }
1457 
1458  static CallInst *Create(Value *Func, ArrayRef<Value *> Args,
1459  const Twine &NameStr, BasicBlock *InsertAtEnd) {
1460  return new (unsigned(Args.size() + 1))
1461  CallInst(Func, Args, None, NameStr, InsertAtEnd);
1462  }
1463 
1464  static CallInst *Create(Value *F, const Twine &NameStr = "",
1465  Instruction *InsertBefore = nullptr) {
1466  return new(1) CallInst(F, NameStr, InsertBefore);
1467  }
1468 
1469  static CallInst *Create(Value *F, const Twine &NameStr,
1470  BasicBlock *InsertAtEnd) {
1471  return new(1) CallInst(F, NameStr, InsertAtEnd);
1472  }
1473 
1474  /// Create a clone of \p CI with a different set of operand bundles and
1475  /// insert it before \p InsertPt.
1476  ///
1477  /// The returned call instruction is identical \p CI in every way except that
1478  /// the operand bundles for the new instruction are set to the operand bundles
1479  /// in \p Bundles.
1480  static CallInst *Create(CallInst *CI, ArrayRef<OperandBundleDef> Bundles,
1481  Instruction *InsertPt = nullptr);
1482 
1483  /// Generate the IR for a call to malloc:
1484  /// 1. Compute the malloc call's argument as the specified type's size,
1485  /// possibly multiplied by the array size if the array size is not
1486  /// constant 1.
1487  /// 2. Call malloc with that argument.
1488  /// 3. Bitcast the result of the malloc call to the specified type.
1489  static Instruction *CreateMalloc(Instruction *InsertBefore,
1490  Type *IntPtrTy, Type *AllocTy,
1491  Value *AllocSize, Value *ArraySize = nullptr,
1492  Function* MallocF = nullptr,
1493  const Twine &Name = "");
1494  static Instruction *CreateMalloc(BasicBlock *InsertAtEnd,
1495  Type *IntPtrTy, Type *AllocTy,
1496  Value *AllocSize, Value *ArraySize = nullptr,
1497  Function* MallocF = nullptr,
1498  const Twine &Name = "");
1499  static Instruction *CreateMalloc(Instruction *InsertBefore,
1500  Type *IntPtrTy, Type *AllocTy,
1501  Value *AllocSize, Value *ArraySize = nullptr,
1502  ArrayRef<OperandBundleDef> Bundles = None,
1503  Function* MallocF = nullptr,
1504  const Twine &Name = "");
1505  static Instruction *CreateMalloc(BasicBlock *InsertAtEnd,
1506  Type *IntPtrTy, Type *AllocTy,
1507  Value *AllocSize, Value *ArraySize = nullptr,
1508  ArrayRef<OperandBundleDef> Bundles = None,
1509  Function* MallocF = nullptr,
1510  const Twine &Name = "");
1511  /// Generate the IR for a call to the builtin free function.
1512  static Instruction *CreateFree(Value *Source,
1513  Instruction *InsertBefore);
1514  static Instruction *CreateFree(Value *Source,
1515  BasicBlock *InsertAtEnd);
1516  static Instruction *CreateFree(Value *Source,
1518  Instruction *InsertBefore);
1519  static Instruction *CreateFree(Value *Source,
1521  BasicBlock *InsertAtEnd);
1522 
1523  FunctionType *getFunctionType() const { return FTy; }
1524 
1526  mutateType(FTy->getReturnType());
1527  this->FTy = FTy;
1528  }
1529 
1530  // Note that 'musttail' implies 'tail'.
1531  enum TailCallKind { TCK_None = 0, TCK_Tail = 1, TCK_MustTail = 2,
1532  TCK_NoTail = 3 };
1535  }
1536 
1537  bool isTailCall() const {
1538  unsigned Kind = getSubclassDataFromInstruction() & 3;
1539  return Kind == TCK_Tail || Kind == TCK_MustTail;
1540  }
1541 
1542  bool isMustTailCall() const {
1543  return (getSubclassDataFromInstruction() & 3) == TCK_MustTail;
1544  }
1545 
1546  bool isNoTailCall() const {
1547  return (getSubclassDataFromInstruction() & 3) == TCK_NoTail;
1548  }
1549 
1550  void setTailCall(bool isTC = true) {
1551  setInstructionSubclassData((getSubclassDataFromInstruction() & ~3) |
1552  unsigned(isTC ? TCK_Tail : TCK_None));
1553  }
1554 
1556  setInstructionSubclassData((getSubclassDataFromInstruction() & ~3) |
1557  unsigned(TCK));
1558  }
1559 
1560  /// Provide fast operand accessors
1562 
1563  /// Return the number of call arguments.
1564  ///
1565  unsigned getNumArgOperands() const {
1566  return getNumOperands() - getNumTotalBundleOperands() - 1;
1567  }
1568 
1569  /// getArgOperand/setArgOperand - Return/set the i-th call argument.
1570  ///
1571  Value *getArgOperand(unsigned i) const {
1572  assert(i < getNumArgOperands() && "Out of bounds!");
1573  return getOperand(i);
1574  }
1575  void setArgOperand(unsigned i, Value *v) {
1576  assert(i < getNumArgOperands() && "Out of bounds!");
1577  setOperand(i, v);
1578  }
1579 
1580  /// Return the iterator pointing to the beginning of the argument list.
1582 
1583  /// Return the iterator pointing to the end of the argument list.
1585  // [ call args ], [ operand bundles ], callee
1586  return op_end() - getNumTotalBundleOperands() - 1;
1587  }
1588 
1589  /// Iteration adapter for range-for loops.
1591  return make_range(arg_begin(), arg_end());
1592  }
1593 
1594  /// Return the iterator pointing to the beginning of the argument list.
1595  const_op_iterator arg_begin() const { return op_begin(); }
1596 
1597  /// Return the iterator pointing to the end of the argument list.
1599  // [ call args ], [ operand bundles ], callee
1600  return op_end() - getNumTotalBundleOperands() - 1;
1601  }
1602 
1603  /// Iteration adapter for range-for loops.
1605  return make_range(arg_begin(), arg_end());
1606  }
1607 
1608  /// Wrappers for getting the \c Use of a call argument.
1609  const Use &getArgOperandUse(unsigned i) const {
1610  assert(i < getNumArgOperands() && "Out of bounds!");
1611  return getOperandUse(i);
1612  }
1613  Use &getArgOperandUse(unsigned i) {
1614  assert(i < getNumArgOperands() && "Out of bounds!");
1615  return getOperandUse(i);
1616  }
1617 
1618  /// If one of the arguments has the 'returned' attribute, return its
1619  /// operand value. Otherwise, return nullptr.
1620  Value *getReturnedArgOperand() const;
1621 
1622  /// getCallingConv/setCallingConv - Get or set the calling convention of this
1623  /// function call.
1625  return static_cast<CallingConv::ID>(getSubclassDataFromInstruction() >> 2);
1626  }
1628  auto ID = static_cast<unsigned>(CC);
1629  assert(!(ID & ~CallingConv::MaxID) && "Unsupported calling convention");
1630  setInstructionSubclassData((getSubclassDataFromInstruction() & 3) |
1631  (ID << 2));
1632  }
1633 
1634  /// Return the parameter attributes for this call.
1635  ///
1636  AttributeList getAttributes() const { return Attrs; }
1637 
1638  /// Set the parameter attributes for this call.
1639  ///
1641 
1642  /// adds the attribute to the list of attributes.
1643  void addAttribute(unsigned i, Attribute::AttrKind Kind);
1644 
1645  /// adds the attribute to the list of attributes.
1646  void addAttribute(unsigned i, Attribute Attr);
1647 
1648  /// Adds the attribute to the indicated argument
1649  void addParamAttr(unsigned ArgNo, Attribute::AttrKind Kind);
1650 
1651  /// Adds the attribute to the indicated argument
1652  void addParamAttr(unsigned ArgNo, Attribute Attr);
1653 
1654  /// removes the attribute from the list of attributes.
1655  void removeAttribute(unsigned i, Attribute::AttrKind Kind);
1656 
1657  /// removes the attribute from the list of attributes.
1658  void removeAttribute(unsigned i, StringRef Kind);
1659 
1660  /// Removes the attribute from the given argument
1661  void removeParamAttr(unsigned ArgNo, Attribute::AttrKind Kind);
1662 
1663  /// Removes the attribute from the given argument
1664  void removeParamAttr(unsigned ArgNo, StringRef Kind);
1665 
1666  /// adds the dereferenceable attribute to the list of attributes.
1667  void addDereferenceableAttr(unsigned i, uint64_t Bytes);
1668 
1669  /// adds the dereferenceable_or_null attribute to the list of
1670  /// attributes.
1671  void addDereferenceableOrNullAttr(unsigned i, uint64_t Bytes);
1672 
1673  /// Determine whether this call has the given attribute.
1674  bool hasFnAttr(Attribute::AttrKind Kind) const {
1675  assert(Kind != Attribute::NoBuiltin &&
1676  "Use CallInst::isNoBuiltin() to check for Attribute::NoBuiltin");
1677  return hasFnAttrImpl(Kind);
1678  }
1679 
1680  /// Determine whether this call has the given attribute.
1681  bool hasFnAttr(StringRef Kind) const {
1682  return hasFnAttrImpl(Kind);
1683  }
1684 
1685  /// Determine whether the return value has the given attribute.
1686  bool hasRetAttr(Attribute::AttrKind Kind) const;
1687 
1688  /// Determine whether the argument or parameter has the given attribute.
1689  bool paramHasAttr(unsigned ArgNo, Attribute::AttrKind Kind) const;
1690 
1691  /// Get the attribute of a given kind at a position.
1692  Attribute getAttribute(unsigned i, Attribute::AttrKind Kind) const {
1693  return getAttributes().getAttribute(i, Kind);
1694  }
1695 
1696  /// Get the attribute of a given kind at a position.
1697  Attribute getAttribute(unsigned i, StringRef Kind) const {
1698  return getAttributes().getAttribute(i, Kind);
1699  }
1700 
1701  /// Get the attribute of a given kind from a given arg
1702  Attribute getParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) const {
1703  assert(ArgNo < getNumArgOperands() && "Out of bounds");
1704  return getAttributes().getParamAttr(ArgNo, Kind);
1705  }
1706 
1707  /// Get the attribute of a given kind from a given arg
1708  Attribute getParamAttr(unsigned ArgNo, StringRef Kind) const {
1709  assert(ArgNo < getNumArgOperands() && "Out of bounds");
1710  return getAttributes().getParamAttr(ArgNo, Kind);
1711  }
1712 
1713  /// Return true if the data operand at index \p i has the attribute \p
1714  /// A.
1715  ///
1716  /// Data operands include call arguments and values used in operand bundles,
1717  /// but does not include the callee operand. This routine dispatches to the
1718  /// underlying AttributeList or the OperandBundleUser as appropriate.
1719  ///
1720  /// The index \p i is interpreted as
1721  ///
1722  /// \p i == Attribute::ReturnIndex -> the return value
1723  /// \p i in [1, arg_size + 1) -> argument number (\p i - 1)
1724  /// \p i in [arg_size + 1, data_operand_size + 1) -> bundle operand at index
1725  /// (\p i - 1) in the operand list.
1726  bool dataOperandHasImpliedAttr(unsigned i, Attribute::AttrKind Kind) const;
1727 
1728  /// Extract the alignment of the return value.
1729  unsigned getRetAlignment() const { return Attrs.getRetAlignment(); }
1730 
1731  /// Extract the alignment for a call or parameter (0=unknown).
1732  unsigned getParamAlignment(unsigned ArgNo) const {
1733  return Attrs.getParamAlignment(ArgNo);
1734  }
1735 
1736  /// Extract the number of dereferenceable bytes for a call or
1737  /// parameter (0=unknown).
1738  uint64_t getDereferenceableBytes(unsigned i) const {
1739  return Attrs.getDereferenceableBytes(i);
1740  }
1741 
1742  /// Extract the number of dereferenceable_or_null bytes for a call or
1743  /// parameter (0=unknown).
1744  uint64_t getDereferenceableOrNullBytes(unsigned i) const {
1745  return Attrs.getDereferenceableOrNullBytes(i);
1746  }
1747 
1748  /// @brief Determine if the return value is marked with NoAlias attribute.
1749  bool returnDoesNotAlias() const {
1750  return Attrs.hasAttribute(AttributeList::ReturnIndex, Attribute::NoAlias);
1751  }
1752 
1753  /// Return true if the call should not be treated as a call to a
1754  /// builtin.
1755  bool isNoBuiltin() const {
1756  return hasFnAttrImpl(Attribute::NoBuiltin) &&
1757  !hasFnAttrImpl(Attribute::Builtin);
1758  }
1759 
1760  /// Determine if the call requires strict floating point semantics.
1761  bool isStrictFP() const { return hasFnAttr(Attribute::StrictFP); }
1762 
1763  /// Return true if the call should not be inlined.
1764  bool isNoInline() const { return hasFnAttr(Attribute::NoInline); }
1765  void setIsNoInline() {
1766  addAttribute(AttributeList::FunctionIndex, Attribute::NoInline);
1767  }
1768 
1769  /// Return true if the call can return twice
1770  bool canReturnTwice() const {
1771  return hasFnAttr(Attribute::ReturnsTwice);
1772  }
1774  addAttribute(AttributeList::FunctionIndex, Attribute::ReturnsTwice);
1775  }
1776 
1777  /// Determine if the call does not access memory.
1778  bool doesNotAccessMemory() const {
1779  return hasFnAttr(Attribute::ReadNone);
1780  }
1782  addAttribute(AttributeList::FunctionIndex, Attribute::ReadNone);
1783  }
1784 
1785  /// Determine if the call does not access or only reads memory.
1786  bool onlyReadsMemory() const {
1787  return doesNotAccessMemory() || hasFnAttr(Attribute::ReadOnly);
1788  }
1790  addAttribute(AttributeList::FunctionIndex, Attribute::ReadOnly);
1791  }
1792 
1793  /// Determine if the call does not access or only writes memory.
1794  bool doesNotReadMemory() const {
1795  return doesNotAccessMemory() || hasFnAttr(Attribute::WriteOnly);
1796  }
1798  addAttribute(AttributeList::FunctionIndex, Attribute::WriteOnly);
1799  }
1800 
1801  /// @brief Determine if the call can access memmory only using pointers based
1802  /// on its arguments.
1803  bool onlyAccessesArgMemory() const {
1804  return hasFnAttr(Attribute::ArgMemOnly);
1805  }
1807  addAttribute(AttributeList::FunctionIndex, Attribute::ArgMemOnly);
1808  }
1809 
1810  /// @brief Determine if the function may only access memory that is
1811  /// inaccessible from the IR.
1813  return hasFnAttr(Attribute::InaccessibleMemOnly);
1814  }
1816  addAttribute(AttributeList::FunctionIndex, Attribute::InaccessibleMemOnly);
1817  }
1818 
1819  /// @brief Determine if the function may only access memory that is
1820  /// either inaccessible from the IR or pointed to by its arguments.
1822  return hasFnAttr(Attribute::InaccessibleMemOrArgMemOnly);
1823  }
1825  addAttribute(AttributeList::FunctionIndex, Attribute::InaccessibleMemOrArgMemOnly);
1826  }
1827 
1828  /// Determine if the call cannot return.
1829  bool doesNotReturn() const { return hasFnAttr(Attribute::NoReturn); }
1831  addAttribute(AttributeList::FunctionIndex, Attribute::NoReturn);
1832  }
1833 
1834  /// Determine if the call cannot unwind.
1835  bool doesNotThrow() const { return hasFnAttr(Attribute::NoUnwind); }
1837  addAttribute(AttributeList::FunctionIndex, Attribute::NoUnwind);
1838  }
1839 
1840  /// Determine if the call cannot be duplicated.
1841  bool cannotDuplicate() const {return hasFnAttr(Attribute::NoDuplicate); }
1843  addAttribute(AttributeList::FunctionIndex, Attribute::NoDuplicate);
1844  }
1845 
1846  /// Determine if the call is convergent
1847  bool isConvergent() const { return hasFnAttr(Attribute::Convergent); }
1848  void setConvergent() {
1850  }
1853  }
1854 
1855  /// Determine if the call returns a structure through first
1856  /// pointer argument.
1857  bool hasStructRetAttr() const {
1858  if (getNumArgOperands() == 0)
1859  return false;
1860 
1861  // Be friendly and also check the callee.
1862  return paramHasAttr(0, Attribute::StructRet);
1863  }
1864 
1865  /// Determine if any call argument is an aggregate passed by value.
1866  bool hasByValArgument() const {
1867  return Attrs.hasAttrSomewhere(Attribute::ByVal);
1868  }
1869 
1870  /// Return the function called, or null if this is an
1871  /// indirect function invocation.
1872  ///
1874  return dyn_cast<Function>(Op<-1>());
1875  }
1876 
1877  /// Get a pointer to the function that is invoked by this
1878  /// instruction.
1879  const Value *getCalledValue() const { return Op<-1>(); }
1880  Value *getCalledValue() { return Op<-1>(); }
1881 
1882  /// Set the function called.
1884  setCalledFunction(
1885  cast<FunctionType>(cast<PointerType>(Fn->getType())->getElementType()),
1886  Fn);
1887  }
1889  this->FTy = FTy;
1890  assert(FTy == cast<FunctionType>(
1891  cast<PointerType>(Fn->getType())->getElementType()));
1892  Op<-1>() = Fn;
1893  }
1894 
1895  /// Check if this call is an inline asm statement.
1896  bool isInlineAsm() const {
1897  return isa<InlineAsm>(Op<-1>());
1898  }
1899 
1900  // Methods for support type inquiry through isa, cast, and dyn_cast:
1901  static bool classof(const Instruction *I) {
1902  return I->getOpcode() == Instruction::Call;
1903  }
1904  static bool classof(const Value *V) {
1905  return isa<Instruction>(V) && classof(cast<Instruction>(V));
1906  }
1907 
1908 private:
1909  template <typename AttrKind> bool hasFnAttrImpl(AttrKind Kind) const {
1910  if (Attrs.hasAttribute(AttributeList::FunctionIndex, Kind))
1911  return true;
1912 
1913  // Operand bundles override attributes on the called function, but don't
1914  // override attributes directly present on the call instruction.
1915  if (isFnAttrDisallowedByOpBundle(Kind))
1916  return false;
1917 
1918  if (const Function *F = getCalledFunction())
1919  return F->getAttributes().hasAttribute(AttributeList::FunctionIndex,
1920  Kind);
1921  return false;
1922  }
1923 
1924  // Shadow Instruction::setInstructionSubclassData with a private forwarding
1925  // method so that subclasses cannot accidentally use it.
1926  void setInstructionSubclassData(unsigned short D) {
1928  }
1929 };
1930 
1931 template <>
1932 struct OperandTraits<CallInst> : public VariadicOperandTraits<CallInst, 1> {
1933 };
1934 
1935 CallInst::CallInst(Value *Func, ArrayRef<Value *> Args,
1936  ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr,
1937  BasicBlock *InsertAtEnd)
1938  : Instruction(
1939  cast<FunctionType>(cast<PointerType>(Func->getType())
1940  ->getElementType())->getReturnType(),
1942  (Args.size() + CountBundleInputs(Bundles) + 1),
1943  unsigned(Args.size() + CountBundleInputs(Bundles) + 1), InsertAtEnd) {
1944  init(Func, Args, Bundles, NameStr);
1945 }
1946 
1947 CallInst::CallInst(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
1948  ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr,
1949  Instruction *InsertBefore)
1952  (Args.size() + CountBundleInputs(Bundles) + 1),
1953  unsigned(Args.size() + CountBundleInputs(Bundles) + 1),
1954  InsertBefore) {
1955  init(Ty, Func, Args, Bundles, NameStr);
1956 }
1957 
1958 // Note: if you get compile errors about private methods then
1959 // please update your code to use the high-level operand
1960 // interfaces. See line 943 above.
1962 
1963 //===----------------------------------------------------------------------===//
1964 // SelectInst Class
1965 //===----------------------------------------------------------------------===//
1966 
1967 /// This class represents the LLVM 'select' instruction.
1968 ///
1969 class SelectInst : public Instruction {
1970  SelectInst(Value *C, Value *S1, Value *S2, const Twine &NameStr,
1971  Instruction *InsertBefore)
1973  &Op<0>(), 3, InsertBefore) {
1974  init(C, S1, S2);
1975  setName(NameStr);
1976  }
1977 
1978  SelectInst(Value *C, Value *S1, Value *S2, const Twine &NameStr,
1979  BasicBlock *InsertAtEnd)
1981  &Op<0>(), 3, InsertAtEnd) {
1982  init(C, S1, S2);
1983  setName(NameStr);
1984  }
1985 
1986  void init(Value *C, Value *S1, Value *S2) {
1987  assert(!areInvalidOperands(C, S1, S2) && "Invalid operands for select");
1988  Op<0>() = C;
1989  Op<1>() = S1;
1990  Op<2>() = S2;
1991  }
1992 
1993 protected:
1994  // Note: Instruction needs to be a friend here to call cloneImpl.
1995  friend class Instruction;
1996 
1997  SelectInst *cloneImpl() const;
1998 
1999 public:
2000  static SelectInst *Create(Value *C, Value *S1, Value *S2,
2001  const Twine &NameStr = "",
2002  Instruction *InsertBefore = nullptr,
2003  Instruction *MDFrom = nullptr) {
2004  SelectInst *Sel = new(3) SelectInst(C, S1, S2, NameStr, InsertBefore);
2005  if (MDFrom)
2006  Sel->copyMetadata(*MDFrom);
2007  return Sel;
2008  }
2009 
2010  static SelectInst *Create(Value *C, Value *S1, Value *S2,
2011  const Twine &NameStr,
2012  BasicBlock *InsertAtEnd) {
2013  return new(3) SelectInst(C, S1, S2, NameStr, InsertAtEnd);
2014  }
2015 
2016  const Value *getCondition() const { return Op<0>(); }
2017  const Value *getTrueValue() const { return Op<1>(); }
2018  const Value *getFalseValue() const { return Op<2>(); }
2019  Value *getCondition() { return Op<0>(); }
2020  Value *getTrueValue() { return Op<1>(); }
2021  Value *getFalseValue() { return Op<2>(); }
2022 
2023  void setCondition(Value *V) { Op<0>() = V; }
2024  void setTrueValue(Value *V) { Op<1>() = V; }
2025  void setFalseValue(Value *V) { Op<2>() = V; }
2026 
2027  /// Return a string if the specified operands are invalid
2028  /// for a select operation, otherwise return null.
2029  static const char *areInvalidOperands(Value *Cond, Value *True, Value *False);
2030 
2031  /// Transparently provide more efficient getOperand methods.
2033 
2035  return static_cast<OtherOps>(Instruction::getOpcode());
2036  }
2037 
2038  // Methods for support type inquiry through isa, cast, and dyn_cast:
2039  static bool classof(const Instruction *I) {
2040  return I->getOpcode() == Instruction::Select;
2041  }
2042  static bool classof(const Value *V) {
2043  return isa<Instruction>(V) && classof(cast<Instruction>(V));
2044  }
2045 };
2046 
2047 template <>
2048 struct OperandTraits<SelectInst> : public FixedNumOperandTraits<SelectInst, 3> {
2049 };
2050 
2052 
2053 //===----------------------------------------------------------------------===//
2054 // VAArgInst Class
2055 //===----------------------------------------------------------------------===//
2056 
2057 /// This class represents the va_arg llvm instruction, which returns
2058 /// an argument of the specified type given a va_list and increments that list
2059 ///
2060 class VAArgInst : public UnaryInstruction {
2061 protected:
2062  // Note: Instruction needs to be a friend here to call cloneImpl.
2063  friend class Instruction;
2064 
2065  VAArgInst *cloneImpl() const;
2066 
2067 public:
2068  VAArgInst(Value *List, Type *Ty, const Twine &NameStr = "",
2069  Instruction *InsertBefore = nullptr)
2070  : UnaryInstruction(Ty, VAArg, List, InsertBefore) {
2071  setName(NameStr);
2072  }
2073 
2074  VAArgInst(Value *List, Type *Ty, const Twine &NameStr,
2075  BasicBlock *InsertAtEnd)
2076  : UnaryInstruction(Ty, VAArg, List, InsertAtEnd) {
2077  setName(NameStr);
2078  }
2079 
2081  const Value *getPointerOperand() const { return getOperand(0); }
2082  static unsigned getPointerOperandIndex() { return 0U; }
2083 
2084  // Methods for support type inquiry through isa, cast, and dyn_cast:
2085  static bool classof(const Instruction *I) {
2086  return I->getOpcode() == VAArg;
2087  }
2088  static bool classof(const Value *V) {
2089  return isa<Instruction>(V) && classof(cast<Instruction>(V));
2090  }
2091 };
2092 
2093 //===----------------------------------------------------------------------===//
2094 // ExtractElementInst Class
2095 //===----------------------------------------------------------------------===//
2096 
2097 /// This instruction extracts a single (scalar)
2098 /// element from a VectorType value
2099 ///
2101  ExtractElementInst(Value *Vec, Value *Idx, const Twine &NameStr = "",
2102  Instruction *InsertBefore = nullptr);
2103  ExtractElementInst(Value *Vec, Value *Idx, const Twine &NameStr,
2104  BasicBlock *InsertAtEnd);
2105 
2106 protected:
2107  // Note: Instruction needs to be a friend here to call cloneImpl.
2108  friend class Instruction;
2109 
2110  ExtractElementInst *cloneImpl() const;
2111 
2112 public:
2113  static ExtractElementInst *Create(Value *Vec, Value *Idx,
2114  const Twine &NameStr = "",
2115  Instruction *InsertBefore = nullptr) {
2116  return new(2) ExtractElementInst(Vec, Idx, NameStr, InsertBefore);
2117  }
2118 
2119  static ExtractElementInst *Create(Value *Vec, Value *Idx,
2120  const Twine &NameStr,
2121  BasicBlock *InsertAtEnd) {
2122  return new(2) ExtractElementInst(Vec, Idx, NameStr, InsertAtEnd);
2123  }
2124 
2125  /// Return true if an extractelement instruction can be
2126  /// formed with the specified operands.
2127  static bool isValidOperands(const Value *Vec, const Value *Idx);
2128 
2129  Value *getVectorOperand() { return Op<0>(); }
2130  Value *getIndexOperand() { return Op<1>(); }
2131  const Value *getVectorOperand() const { return Op<0>(); }
2132  const Value *getIndexOperand() const { return Op<1>(); }
2133 
2135  return cast<VectorType>(getVectorOperand()->getType());
2136  }
2137 
2138  /// Transparently provide more efficient getOperand methods.
2140 
2141  // Methods for support type inquiry through isa, cast, and dyn_cast:
2142  static bool classof(const Instruction *I) {
2143  return I->getOpcode() == Instruction::ExtractElement;
2144  }
2145  static bool classof(const Value *V) {
2146  return isa<Instruction>(V) && classof(cast<Instruction>(V));
2147  }
2148 };
2149 
2150 template <>
2152  public FixedNumOperandTraits<ExtractElementInst, 2> {
2153 };
2154 
2155 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ExtractElementInst, Value)
2156 
2157 //===----------------------------------------------------------------------===//
2158 // InsertElementInst Class
2159 //===----------------------------------------------------------------------===//
2160 
2161 /// This instruction inserts a single (scalar)
2162 /// element into a VectorType value
2163 ///
2165  InsertElementInst(Value *Vec, Value *NewElt, Value *Idx,
2166  const Twine &NameStr = "",
2167  Instruction *InsertBefore = nullptr);
2168  InsertElementInst(Value *Vec, Value *NewElt, Value *Idx, const Twine &NameStr,
2169  BasicBlock *InsertAtEnd);
2170 
2171 protected:
2172  // Note: Instruction needs to be a friend here to call cloneImpl.
2173  friend class Instruction;
2174 
2175  InsertElementInst *cloneImpl() const;
2176 
2177 public:
2178  static InsertElementInst *Create(Value *Vec, Value *NewElt, Value *Idx,
2179  const Twine &NameStr = "",
2180  Instruction *InsertBefore = nullptr) {
2181  return new(3) InsertElementInst(Vec, NewElt, Idx, NameStr, InsertBefore);
2182  }
2183 
2184  static InsertElementInst *Create(Value *Vec, Value *NewElt, Value *Idx,
2185  const Twine &NameStr,
2186  BasicBlock *InsertAtEnd) {
2187  return new(3) InsertElementInst(Vec, NewElt, Idx, NameStr, InsertAtEnd);
2188  }
2189 
2190  /// Return true if an insertelement instruction can be
2191  /// formed with the specified operands.
2192  static bool isValidOperands(const Value *Vec, const Value *NewElt,
2193  const Value *Idx);
2194 
2195  /// Overload to return most specific vector type.
2196  ///
2197  VectorType *getType() const {
2198  return cast<VectorType>(Instruction::getType());
2199  }
2200 
2201  /// Transparently provide more efficient getOperand methods.
2203 
2204  // Methods for support type inquiry through isa, cast, and dyn_cast:
2205  static bool classof(const Instruction *I) {
2206  return I->getOpcode() == Instruction::InsertElement;
2207  }
2208  static bool classof(const Value *V) {
2209  return isa<Instruction>(V) && classof(cast<Instruction>(V));
2210  }
2211 };
2212 
2213 template <>
2215  public FixedNumOperandTraits<InsertElementInst, 3> {
2216 };
2217 
2218 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(InsertElementInst, Value)
2219 
2220 //===----------------------------------------------------------------------===//
2221 // ShuffleVectorInst Class
2222 //===----------------------------------------------------------------------===//
2223 
2224 /// This instruction constructs a fixed permutation of two
2225 /// input vectors.
2226 ///
2228 protected:
2229  // Note: Instruction needs to be a friend here to call cloneImpl.
2230  friend class Instruction;
2231 
2232  ShuffleVectorInst *cloneImpl() const;
2233 
2234 public:
2236  const Twine &NameStr = "",
2237  Instruction *InsertBefor = nullptr);
2239  const Twine &NameStr, BasicBlock *InsertAtEnd);
2240 
2241  // allocate space for exactly three operands
2242  void *operator new(size_t s) {
2243  return User::operator new(s, 3);
2244  }
2245 
2246  /// Return true if a shufflevector instruction can be
2247  /// formed with the specified operands.
2248  static bool isValidOperands(const Value *V1, const Value *V2,
2249  const Value *Mask);
2250 
2251  /// Overload to return most specific vector type.
2252  ///
2253  VectorType *getType() const {
2254  return cast<VectorType>(Instruction::getType());
2255  }
2256 
2257  /// Transparently provide more efficient getOperand methods.
2259 
2260  Constant *getMask() const {
2261  return cast<Constant>(getOperand(2));
2262  }
2263 
2264  /// Return the shuffle mask value for the specified element of the mask.
2265  /// Return -1 if the element is undef.
2266  static int getMaskValue(Constant *Mask, unsigned Elt);
2267 
2268  /// Return the shuffle mask value of this instruction for the given element
2269  /// index. Return -1 if the element is undef.
2270  int getMaskValue(unsigned Elt) const {
2271  return getMaskValue(getMask(), Elt);
2272  }
2273 
2274  /// Convert the input shuffle mask operand to a vector of integers. Undefined
2275  /// elements of the mask are returned as -1.
2276  static void getShuffleMask(Constant *Mask, SmallVectorImpl<int> &Result);
2277 
2278  /// Return the mask for this instruction as a vector of integers. Undefined
2279  /// elements of the mask are returned as -1.
2280  void getShuffleMask(SmallVectorImpl<int> &Result) const {
2281  return getShuffleMask(getMask(), Result);
2282  }
2283 
2286  getShuffleMask(Mask);
2287  return Mask;
2288  }
2289 
2290  /// Change values in a shuffle permute mask assuming the two vector operands
2291  /// of length InVecNumElts have swapped position.
2293  unsigned InVecNumElts) {
2294  for (int &Idx : Mask) {
2295  if (Idx == -1)
2296  continue;
2297  Idx = Idx < (int)InVecNumElts ? Idx + InVecNumElts : Idx - InVecNumElts;
2298  assert(Idx >= 0 && Idx < (int)InVecNumElts * 2 &&
2299  "shufflevector mask index out of range");
2300  }
2301  }
2302 
2303  // Methods for support type inquiry through isa, cast, and dyn_cast:
2304  static bool classof(const Instruction *I) {
2305  return I->getOpcode() == Instruction::ShuffleVector;
2306  }
2307  static bool classof(const Value *V) {
2308  return isa<Instruction>(V) && classof(cast<Instruction>(V));
2309  }
2310 };
2311 
2312 template <>
2314  public FixedNumOperandTraits<ShuffleVectorInst, 3> {
2315 };
2316 
2317 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ShuffleVectorInst, Value)
2318 
2319 //===----------------------------------------------------------------------===//
2320 // ExtractValueInst Class
2321 //===----------------------------------------------------------------------===//
2322 
2323 /// This instruction extracts a struct member or array
2324 /// element value from an aggregate value.
2325 ///
2327  SmallVector<unsigned, 4> Indices;
2328 
2329  ExtractValueInst(const ExtractValueInst &EVI);
2330 
2331  /// Constructors - Create a extractvalue instruction with a base aggregate
2332  /// value and a list of indices. The first ctor can optionally insert before
2333  /// an existing instruction, the second appends the new instruction to the
2334  /// specified BasicBlock.
2335  inline ExtractValueInst(Value *Agg,
2336  ArrayRef<unsigned> Idxs,
2337  const Twine &NameStr,
2338  Instruction *InsertBefore);
2339  inline ExtractValueInst(Value *Agg,
2340  ArrayRef<unsigned> Idxs,
2341  const Twine &NameStr, BasicBlock *InsertAtEnd);
2342 
2343  void init(ArrayRef<unsigned> Idxs, const Twine &NameStr);
2344 
2345 protected:
2346  // Note: Instruction needs to be a friend here to call cloneImpl.
2347  friend class Instruction;
2348 
2349  ExtractValueInst *cloneImpl() const;
2350 
2351 public:
2353  ArrayRef<unsigned> Idxs,
2354  const Twine &NameStr = "",
2355  Instruction *InsertBefore = nullptr) {
2356  return new
2357  ExtractValueInst(Agg, Idxs, NameStr, InsertBefore);
2358  }
2359 
2361  ArrayRef<unsigned> Idxs,
2362  const Twine &NameStr,
2363  BasicBlock *InsertAtEnd) {
2364  return new ExtractValueInst(Agg, Idxs, NameStr, InsertAtEnd);
2365  }
2366 
2367  /// Returns the type of the element that would be extracted
2368  /// with an extractvalue instruction with the specified parameters.
2369  ///
2370  /// Null is returned if the indices are invalid for the specified type.
2371  static Type *getIndexedType(Type *Agg, ArrayRef<unsigned> Idxs);
2372 
2373  using idx_iterator = const unsigned*;
2374 
2375  inline idx_iterator idx_begin() const { return Indices.begin(); }
2376  inline idx_iterator idx_end() const { return Indices.end(); }
2378  return make_range(idx_begin(), idx_end());
2379  }
2380 
2382  return getOperand(0);
2383  }
2384  const Value *getAggregateOperand() const {
2385  return getOperand(0);
2386  }
2387  static unsigned getAggregateOperandIndex() {
2388  return 0U; // get index for modifying correct operand
2389  }
2390 
2392  return Indices;
2393  }
2394 
2395  unsigned getNumIndices() const {
2396  return (unsigned)Indices.size();
2397  }
2398 
2399  bool hasIndices() const {
2400  return true;
2401  }
2402 
2403  // Methods for support type inquiry through isa, cast, and dyn_cast:
2404  static bool classof(const Instruction *I) {
2405  return I->getOpcode() == Instruction::ExtractValue;
2406  }
2407  static bool classof(const Value *V) {
2408  return isa<Instruction>(V) && classof(cast<Instruction>(V));
2409  }
2410 };
2411 
2412 ExtractValueInst::ExtractValueInst(Value *Agg,
2413  ArrayRef<unsigned> Idxs,
2414  const Twine &NameStr,
2415  Instruction *InsertBefore)
2416  : UnaryInstruction(checkGEPType(getIndexedType(Agg->getType(), Idxs)),
2417  ExtractValue, Agg, InsertBefore) {
2418  init(Idxs, NameStr);
2419 }
2420 
2421 ExtractValueInst::ExtractValueInst(Value *Agg,
2422  ArrayRef<unsigned> Idxs,
2423  const Twine &NameStr,
2424  BasicBlock *InsertAtEnd)
2425  : UnaryInstruction(checkGEPType(getIndexedType(Agg->getType(), Idxs)),
2426  ExtractValue, Agg, InsertAtEnd) {
2427  init(Idxs, NameStr);
2428 }
2429 
2430 //===----------------------------------------------------------------------===//
2431 // InsertValueInst Class
2432 //===----------------------------------------------------------------------===//
2433 
2434 /// This instruction inserts a struct field of array element
2435 /// value into an aggregate value.
2436 ///
2438  SmallVector<unsigned, 4> Indices;
2439 
2440  InsertValueInst(const InsertValueInst &IVI);
2441 
2442  /// Constructors - Create a insertvalue instruction with a base aggregate
2443  /// value, a value to insert, and a list of indices. The first ctor can
2444  /// optionally insert before an existing instruction, the second appends
2445  /// the new instruction to the specified BasicBlock.
2446  inline InsertValueInst(Value *Agg, Value *Val,
2447  ArrayRef<unsigned> Idxs,
2448  const Twine &NameStr,
2449  Instruction *InsertBefore);
2450  inline InsertValueInst(Value *Agg, Value *Val,
2451  ArrayRef<unsigned> Idxs,
2452  const Twine &NameStr, BasicBlock *InsertAtEnd);
2453 
2454  /// Constructors - These two constructors are convenience methods because one
2455  /// and two index insertvalue instructions are so common.
2456  InsertValueInst(Value *Agg, Value *Val, unsigned Idx,
2457  const Twine &NameStr = "",
2458  Instruction *InsertBefore = nullptr);
2459  InsertValueInst(Value *Agg, Value *Val, unsigned Idx, const Twine &NameStr,
2460  BasicBlock *InsertAtEnd);
2461 
2462  void init(Value *Agg, Value *Val, ArrayRef<unsigned> Idxs,
2463  const Twine &NameStr);
2464 
2465 protected:
2466  // Note: Instruction needs to be a friend here to call cloneImpl.
2467  friend class Instruction;
2468 
2469  InsertValueInst *cloneImpl() const;
2470 
2471 public:
2472  // allocate space for exactly two operands
2473  void *operator new(size_t s) {
2474  return User::operator new(s, 2);
2475  }
2476 
2477  static InsertValueInst *Create(Value *Agg, Value *Val,
2478  ArrayRef<unsigned> Idxs,
2479  const Twine &NameStr = "",
2480  Instruction *InsertBefore = nullptr) {
2481  return new InsertValueInst(Agg, Val, Idxs, NameStr, InsertBefore);
2482  }
2483 
2484  static InsertValueInst *Create(Value *Agg, Value *Val,
2485  ArrayRef<unsigned> Idxs,
2486  const Twine &NameStr,
2487  BasicBlock *InsertAtEnd) {
2488  return new InsertValueInst(Agg, Val, Idxs, NameStr, InsertAtEnd);
2489  }
2490 
2491  /// Transparently provide more efficient getOperand methods.
2493 
2494  using idx_iterator = const unsigned*;
2495 
2496  inline idx_iterator idx_begin() const { return Indices.begin(); }
2497  inline idx_iterator idx_end() const { return Indices.end(); }
2499  return make_range(idx_begin(), idx_end());
2500  }
2501 
2503  return getOperand(0);
2504  }
2505  const Value *getAggregateOperand() const {
2506  return getOperand(0);
2507  }
2508  static unsigned getAggregateOperandIndex() {
2509  return 0U; // get index for modifying correct operand
2510  }
2511 
2513  return getOperand(1);
2514  }
2516  return getOperand(1);
2517  }
2518  static unsigned getInsertedValueOperandIndex() {
2519  return 1U; // get index for modifying correct operand
2520  }
2521 
2523  return Indices;
2524  }
2525 
2526  unsigned getNumIndices() const {
2527  return (unsigned)Indices.size();
2528  }
2529 
2530  bool hasIndices() const {
2531  return true;
2532  }
2533 
2534  // Methods for support type inquiry through isa, cast, and dyn_cast:
2535  static bool classof(const Instruction *I) {
2536  return I->getOpcode() == Instruction::InsertValue;
2537  }
2538  static bool classof(const Value *V) {
2539  return isa<Instruction>(V) && classof(cast<Instruction>(V));
2540  }
2541 };
2542 
2543 template <>
2545  public FixedNumOperandTraits<InsertValueInst, 2> {
2546 };
2547 
2548 InsertValueInst::InsertValueInst(Value *Agg,
2549  Value *Val,
2550  ArrayRef<unsigned> Idxs,
2551  const Twine &NameStr,
2552  Instruction *InsertBefore)
2553  : Instruction(Agg->getType(), InsertValue,
2555  2, InsertBefore) {
2556  init(Agg, Val, Idxs, NameStr);
2557 }
2558 
2559 InsertValueInst::InsertValueInst(Value *Agg,
2560  Value *Val,
2561  ArrayRef<unsigned> Idxs,
2562  const Twine &NameStr,
2563  BasicBlock *InsertAtEnd)
2564  : Instruction(Agg->getType(), InsertValue,
2566  2, InsertAtEnd) {
2567  init(Agg, Val, Idxs, NameStr);
2568 }
2569 
2571 
2572 //===----------------------------------------------------------------------===//
2573 // PHINode Class
2574 //===----------------------------------------------------------------------===//
2575 
2576 // PHINode - The PHINode class is used to represent the magical mystical PHI
2577 // node, that can not exist in nature, but can be synthesized in a computer
2578 // scientist's overactive imagination.
2579 //
2580 class PHINode : public Instruction {
2581  /// The number of operands actually allocated. NumOperands is
2582  /// the number actually in use.
2583  unsigned ReservedSpace;
2584 
2585  PHINode(const PHINode &PN);
2586 
2587  explicit PHINode(Type *Ty, unsigned NumReservedValues,
2588  const Twine &NameStr = "",
2589  Instruction *InsertBefore = nullptr)
2590  : Instruction(Ty, Instruction::PHI, nullptr, 0, InsertBefore),
2591  ReservedSpace(NumReservedValues) {
2592  setName(NameStr);
2593  allocHungoffUses(ReservedSpace);
2594  }
2595 
2596  PHINode(Type *Ty, unsigned NumReservedValues, const Twine &NameStr,
2597  BasicBlock *InsertAtEnd)
2598  : Instruction(Ty, Instruction::PHI, nullptr, 0, InsertAtEnd),
2599  ReservedSpace(NumReservedValues) {
2600  setName(NameStr);
2601  allocHungoffUses(ReservedSpace);
2602  }
2603 
2604 protected:
2605  // Note: Instruction needs to be a friend here to call cloneImpl.
2606  friend class Instruction;
2607 
2608  PHINode *cloneImpl() const;
2609 
2610  // allocHungoffUses - this is more complicated than the generic
2611  // User::allocHungoffUses, because we have to allocate Uses for the incoming
2612  // values and pointers to the incoming blocks, all in one allocation.
2613  void allocHungoffUses(unsigned N) {
2614  User::allocHungoffUses(N, /* IsPhi */ true);
2615  }
2616 
2617 public:
2618  /// Constructors - NumReservedValues is a hint for the number of incoming
2619  /// edges that this phi node will have (use 0 if you really have no idea).
2620  static PHINode *Create(Type *Ty, unsigned NumReservedValues,
2621  const Twine &NameStr = "",
2622  Instruction *InsertBefore = nullptr) {
2623  return new PHINode(Ty, NumReservedValues, NameStr, InsertBefore);
2624  }
2625 
2626  static PHINode *Create(Type *Ty, unsigned NumReservedValues,
2627  const Twine &NameStr, BasicBlock *InsertAtEnd) {
2628  return new PHINode(Ty, NumReservedValues, NameStr, InsertAtEnd);
2629  }
2630 
2631  /// Provide fast operand accessors
2633 
2634  // Block iterator interface. This provides access to the list of incoming
2635  // basic blocks, which parallels the list of incoming values.
2636 
2639 
2641  Use::UserRef *ref =
2642  reinterpret_cast<Use::UserRef*>(op_begin() + ReservedSpace);
2643  return reinterpret_cast<block_iterator>(ref + 1);
2644  }
2645 
2647  const Use::UserRef *ref =
2648  reinterpret_cast<const Use::UserRef*>(op_begin() + ReservedSpace);
2649  return reinterpret_cast<const_block_iterator>(ref + 1);
2650  }
2651 
2653  return block_begin() + getNumOperands();
2654  }
2655 
2657  return block_begin() + getNumOperands();
2658  }
2659 
2661  return make_range(block_begin(), block_end());
2662  }
2663 
2665  return make_range(block_begin(), block_end());
2666  }
2667 
2669 
2671 
2672  /// Return the number of incoming edges
2673  ///
2674  unsigned getNumIncomingValues() const { return getNumOperands(); }
2675 
2676  /// Return incoming value number x
2677  ///
2678  Value *getIncomingValue(unsigned i) const {
2679  return getOperand(i);
2680  }
2681  void setIncomingValue(unsigned i, Value *V) {
2682  assert(V && "PHI node got a null value!");
2683  assert(getType() == V->getType() &&
2684  "All operands to PHI node must be the same type as the PHI node!");
2685  setOperand(i, V);
2686  }
2687 
2688  static unsigned getOperandNumForIncomingValue(unsigned i) {
2689  return i;
2690  }
2691 
2692  static unsigned getIncomingValueNumForOperand(unsigned i) {
2693  return i;
2694  }
2695 
2696  /// Return incoming basic block number @p i.
2697  ///
2698  BasicBlock *getIncomingBlock(unsigned i) const {
2699  return block_begin()[i];
2700  }
2701 
2702  /// Return incoming basic block corresponding
2703  /// to an operand of the PHI.
2704  ///
2705  BasicBlock *getIncomingBlock(const Use &U) const {
2706  assert(this == U.getUser() && "Iterator doesn't point to PHI's Uses?");
2707  return getIncomingBlock(unsigned(&U - op_begin()));
2708  }
2709 
2710  /// Return incoming basic block corresponding
2711  /// to value use iterator.
2712  ///
2714  return getIncomingBlock(I.getUse());
2715  }
2716 
2717  void setIncomingBlock(unsigned i, BasicBlock *BB) {
2718  assert(BB && "PHI node got a null basic block!");
2719  block_begin()[i] = BB;
2720  }
2721 
2722  /// Add an incoming value to the end of the PHI list
2723  ///
2724  void addIncoming(Value *V, BasicBlock *BB) {
2725  if (getNumOperands() == ReservedSpace)
2726  growOperands(); // Get more space!
2727  // Initialize some new operands.
2729  setIncomingValue(getNumOperands() - 1, V);
2730  setIncomingBlock(getNumOperands() - 1, BB);
2731  }
2732 
2733  /// Remove an incoming value. This is useful if a
2734  /// predecessor basic block is deleted. The value removed is returned.
2735  ///
2736  /// If the last incoming value for a PHI node is removed (and DeletePHIIfEmpty
2737  /// is true), the PHI node is destroyed and any uses of it are replaced with
2738  /// dummy values. The only time there should be zero incoming values to a PHI
2739  /// node is when the block is dead, so this strategy is sound.
2740  ///
2741  Value *removeIncomingValue(unsigned Idx, bool DeletePHIIfEmpty = true);
2742 
2743  Value *removeIncomingValue(const BasicBlock *BB, bool DeletePHIIfEmpty=true) {
2744  int Idx = getBasicBlockIndex(BB);
2745  assert(Idx >= 0 && "Invalid basic block argument to remove!");
2746  return removeIncomingValue(Idx, DeletePHIIfEmpty);
2747  }
2748 
2749  /// Return the first index of the specified basic
2750  /// block in the value list for this PHI. Returns -1 if no instance.
2751  ///
2752  int getBasicBlockIndex(const BasicBlock *BB) const {
2753  for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
2754  if (block_begin()[i] == BB)
2755  return i;
2756  return -1;
2757  }
2758 
2760  int Idx = getBasicBlockIndex(BB);
2761  assert(Idx >= 0 && "Invalid basic block argument!");
2762  return getIncomingValue(Idx);
2763  }
2764 
2765  /// If the specified PHI node always merges together the
2766  /// same value, return the value, otherwise return null.
2767  Value *hasConstantValue() const;
2768 
2769  /// Whether the specified PHI node always merges
2770  /// together the same value, assuming undefs are equal to a unique
2771  /// non-undef value.
2772  bool hasConstantOrUndefValue() const;
2773 
2774  /// Methods for support type inquiry through isa, cast, and dyn_cast:
2775  static bool classof(const Instruction *I) {
2776  return I->getOpcode() == Instruction::PHI;
2777  }
2778  static bool classof(const Value *V) {
2779  return isa<Instruction>(V) && classof(cast<Instruction>(V));
2780  }
2781 
2782 private:
2783  void growOperands();
2784 };
2785 
2786 template <>
2788 };
2789 
2791 
2792 //===----------------------------------------------------------------------===//
2793 // LandingPadInst Class
2794 //===----------------------------------------------------------------------===//
2795 
2796 //===---------------------------------------------------------------------------
2797 /// The landingpad instruction holds all of the information
2798 /// necessary to generate correct exception handling. The landingpad instruction
2799 /// cannot be moved from the top of a landing pad block, which itself is
2800 /// accessible only from the 'unwind' edge of an invoke. This uses the
2801 /// SubclassData field in Value to store whether or not the landingpad is a
2802 /// cleanup.
2803 ///
2804 class LandingPadInst : public Instruction {
2805  /// The number of operands actually allocated. NumOperands is
2806  /// the number actually in use.
2807  unsigned ReservedSpace;
2808 
2809  LandingPadInst(const LandingPadInst &LP);
2810 
2811 public:
2813 
2814 private:
2815  explicit LandingPadInst(Type *RetTy, unsigned NumReservedValues,
2816  const Twine &NameStr, Instruction *InsertBefore);
2817  explicit LandingPadInst(Type *RetTy, unsigned NumReservedValues,
2818  const Twine &NameStr, BasicBlock *InsertAtEnd);
2819 
2820  // Allocate space for exactly zero operands.
2821  void *operator new(size_t s) {
2822  return User::operator new(s);
2823  }
2824 
2825  void growOperands(unsigned Size);
2826  void init(unsigned NumReservedValues, const Twine &NameStr);
2827 
2828 protected:
2829  // Note: Instruction needs to be a friend here to call cloneImpl.
2830  friend class Instruction;
2831 
2832  LandingPadInst *cloneImpl() const;
2833 
2834 public:
2835  /// Constructors - NumReservedClauses is a hint for the number of incoming
2836  /// clauses that this landingpad will have (use 0 if you really have no idea).
2837  static LandingPadInst *Create(Type *RetTy, unsigned NumReservedClauses,
2838  const Twine &NameStr = "",
2839  Instruction *InsertBefore = nullptr);
2840  static LandingPadInst *Create(Type *RetTy, unsigned NumReservedClauses,
2841  const Twine &NameStr, BasicBlock *InsertAtEnd);
2842 
2843  /// Provide fast operand accessors
2845 
2846  /// Return 'true' if this landingpad instruction is a
2847  /// cleanup. I.e., it should be run when unwinding even if its landing pad
2848  /// doesn't catch the exception.
2849  bool isCleanup() const { return getSubclassDataFromInstruction() & 1; }
2850 
2851  /// Indicate that this landingpad instruction is a cleanup.
2852  void setCleanup(bool V) {
2853  setInstructionSubclassData((getSubclassDataFromInstruction() & ~1) |
2854  (V ? 1 : 0));
2855  }
2856 
2857  /// Add a catch or filter clause to the landing pad.
2858  void addClause(Constant *ClauseVal);
2859 
2860  /// Get the value of the clause at index Idx. Use isCatch/isFilter to
2861  /// determine what type of clause this is.
2862  Constant *getClause(unsigned Idx) const {
2863  return cast<Constant>(getOperandList()[Idx]);
2864  }
2865 
2866  /// Return 'true' if the clause and index Idx is a catch clause.
2867  bool isCatch(unsigned Idx) const {
2868  return !isa<ArrayType>(getOperandList()[Idx]->getType());
2869  }
2870 
2871  /// Return 'true' if the clause and index Idx is a filter clause.
2872  bool isFilter(unsigned Idx) const {
2873  return isa<ArrayType>(getOperandList()[Idx]->getType());
2874  }
2875 
2876  /// Get the number of clauses for this landing pad.
2877  unsigned getNumClauses() const { return getNumOperands(); }
2878 
2879  /// Grow the size of the operand list to accommodate the new
2880  /// number of clauses.
2881  void reserveClauses(unsigned Size) { growOperands(Size); }
2882 
2883  // Methods for support type inquiry through isa, cast, and dyn_cast:
2884  static bool classof(const Instruction *I) {
2885  return I->getOpcode() == Instruction::LandingPad;
2886  }
2887  static bool classof(const Value *V) {
2888  return isa<Instruction>(V) && classof(cast<Instruction>(V));
2889  }
2890 };
2891 
2892 template <>
2894 };
2895 
2897 
2898 //===----------------------------------------------------------------------===//
2899 // ReturnInst Class
2900 //===----------------------------------------------------------------------===//
2901 
2902 //===---------------------------------------------------------------------------
2903 /// Return a value (possibly void), from a function. Execution
2904 /// does not continue in this function any longer.
2905 ///
2906 class ReturnInst : public TerminatorInst {
2907  ReturnInst(const ReturnInst &RI);
2908 
2909 private:
2910  // ReturnInst constructors:
2911  // ReturnInst() - 'ret void' instruction
2912  // ReturnInst( null) - 'ret void' instruction
2913  // ReturnInst(Value* X) - 'ret X' instruction
2914  // ReturnInst( null, Inst *I) - 'ret void' instruction, insert before I
2915  // ReturnInst(Value* X, Inst *I) - 'ret X' instruction, insert before I
2916  // ReturnInst( null, BB *B) - 'ret void' instruction, insert @ end of B
2917  // ReturnInst(Value* X, BB *B) - 'ret X' instruction, insert @ end of B
2918  //
2919  // NOTE: If the Value* passed is of type void then the constructor behaves as
2920  // if it was passed NULL.
2921  explicit ReturnInst(LLVMContext &C, Value *retVal = nullptr,
2922  Instruction *InsertBefore = nullptr);
2923  ReturnInst(LLVMContext &C, Value *retVal, BasicBlock *InsertAtEnd);
2924  explicit ReturnInst(LLVMContext &C, BasicBlock *InsertAtEnd);
2925 
2926 protected:
2927  // Note: Instruction needs to be a friend here to call cloneImpl.
2928  friend class Instruction;
2929 
2930  ReturnInst *cloneImpl() const;
2931 
2932 public:
2933  static ReturnInst* Create(LLVMContext &C, Value *retVal = nullptr,
2934  Instruction *InsertBefore = nullptr) {
2935  return new(!!retVal) ReturnInst(C, retVal, InsertBefore);
2936  }
2937 
2938  static ReturnInst* Create(LLVMContext &C, Value *retVal,
2939  BasicBlock *InsertAtEnd) {
2940  return new(!!retVal) ReturnInst(C, retVal, InsertAtEnd);
2941  }
2942 
2943  static ReturnInst* Create(LLVMContext &C, BasicBlock *InsertAtEnd) {
2944  return new(0) ReturnInst(C, InsertAtEnd);
2945  }
2946 
2947  /// Provide fast operand accessors
2949 
2950  /// Convenience accessor. Returns null if there is no return value.
2952  return getNumOperands() != 0 ? getOperand(0) : nullptr;
2953  }
2954 
2955  unsigned getNumSuccessors() const { return 0; }
2956 
2957  // Methods for support type inquiry through isa, cast, and dyn_cast:
2958  static bool classof(const Instruction *I) {
2959  return (I->getOpcode() == Instruction::Ret);
2960  }
2961  static bool classof(const Value *V) {
2962  return isa<Instruction>(V) && classof(cast<Instruction>(V));
2963  }
2964 
2965 private:
2966  friend TerminatorInst;
2967 
2968  BasicBlock *getSuccessor(unsigned idx) const {
2969  llvm_unreachable("ReturnInst has no successors!");
2970  }
2971 
2972  void setSuccessor(unsigned idx, BasicBlock *B) {
2973  llvm_unreachable("ReturnInst has no successors!");
2974  }
2975 };
2976 
2977 template <>
2978 struct OperandTraits<ReturnInst> : public VariadicOperandTraits<ReturnInst> {
2979 };
2980 
2982 
2983 //===----------------------------------------------------------------------===//
2984 // BranchInst Class
2985 //===----------------------------------------------------------------------===//
2986 
2987 //===---------------------------------------------------------------------------
2988 /// Conditional or Unconditional Branch instruction.
2989 ///
2990 class BranchInst : public TerminatorInst {
2991  /// Ops list - Branches are strange. The operands are ordered:
2992  /// [Cond, FalseDest,] TrueDest. This makes some accessors faster because
2993  /// they don't have to check for cond/uncond branchness. These are mostly
2994  /// accessed relative from op_end().
2995  BranchInst(const BranchInst &BI);
2996  // BranchInst constructors (where {B, T, F} are blocks, and C is a condition):
2997  // BranchInst(BB *B) - 'br B'
2998  // BranchInst(BB* T, BB *F, Value *C) - 'br C, T, F'
2999  // BranchInst(BB* B, Inst *I) - 'br B' insert before I
3000  // BranchInst(BB* T, BB *F, Value *C, Inst *I) - 'br C, T, F', insert before I
3001  // BranchInst(BB* B, BB *I) - 'br B' insert at end
3002  // BranchInst(BB* T, BB *F, Value *C, BB *I) - 'br C, T, F', insert at end
3003  explicit BranchInst(BasicBlock *IfTrue, Instruction *InsertBefore = nullptr);
3004  BranchInst(BasicBlock *IfTrue, BasicBlock *IfFalse, Value *Cond,
3005  Instruction *InsertBefore = nullptr);
3006  BranchInst(BasicBlock *IfTrue, BasicBlock *InsertAtEnd);
3007  BranchInst(BasicBlock *IfTrue, BasicBlock *IfFalse, Value *Cond,
3008  BasicBlock *InsertAtEnd);
3009 
3010  void AssertOK();
3011 
3012 protected:
3013  // Note: Instruction needs to be a friend here to call cloneImpl.
3014  friend class Instruction;
3015 
3016  BranchInst *cloneImpl() const;
3017 
3018 public:
3019  static BranchInst *Create(BasicBlock *IfTrue,
3020  Instruction *InsertBefore = nullptr) {
3021  return new(1) BranchInst(IfTrue, InsertBefore);
3022  }
3023 
3024  static BranchInst *Create(BasicBlock *IfTrue, BasicBlock *IfFalse,
3025  Value *Cond, Instruction *InsertBefore = nullptr) {
3026  return new(3) BranchInst(IfTrue, IfFalse, Cond, InsertBefore);
3027  }
3028 
3029  static BranchInst *Create(BasicBlock *IfTrue, BasicBlock *InsertAtEnd) {
3030  return new(1) BranchInst(IfTrue, InsertAtEnd);
3031  }
3032 
3033  static BranchInst *Create(BasicBlock *IfTrue, BasicBlock *IfFalse,
3034  Value *Cond, BasicBlock *InsertAtEnd) {
3035  return new(3) BranchInst(IfTrue, IfFalse, Cond, InsertAtEnd);
3036  }
3037 
3038  /// Transparently provide more efficient getOperand methods.
3040 
3041  bool isUnconditional() const { return getNumOperands() == 1; }
3042  bool isConditional() const { return getNumOperands() == 3; }
3043 
3044  Value *getCondition() const {
3045  assert(isConditional() && "Cannot get condition of an uncond branch!");
3046  return Op<-3>();
3047  }
3048 
3049  void setCondition(Value *V) {
3050  assert(isConditional() && "Cannot set condition of unconditional branch!");
3051  Op<-3>() = V;
3052  }
3053 
3054  unsigned getNumSuccessors() const { return 1+isConditional(); }
3055 
3056  BasicBlock *getSuccessor(unsigned i) const {
3057  assert(i < getNumSuccessors() && "Successor # out of range for Branch!");
3058  return cast_or_null<BasicBlock>((&Op<-1>() - i)->get());
3059  }
3060 
3061  void setSuccessor(unsigned idx, BasicBlock *NewSucc) {
3062  assert(idx < getNumSuccessors() && "Successor # out of range for Branch!");
3063  *(&Op<-1>() - idx) = NewSucc;
3064  }
3065 
3066  /// Swap the successors of this branch instruction.
3067  ///
3068  /// Swaps the successors of the branch instruction. This also swaps any
3069  /// branch weight metadata associated with the instruction so that it
3070  /// continues to map correctly to each operand.
3071  void swapSuccessors();
3072 
3073  // Methods for support type inquiry through isa, cast, and dyn_cast:
3074  static bool classof(const Instruction *I) {
3075  return (I->getOpcode() == Instruction::Br);
3076  }
3077  static bool classof(const Value *V) {
3078  return isa<Instruction>(V) && classof(cast<Instruction>(V));
3079  }
3080 };
3081 
3082 template <>
3083 struct OperandTraits<BranchInst> : public VariadicOperandTraits<BranchInst, 1> {
3084 };
3085 
3087 
3088 //===----------------------------------------------------------------------===//
3089 // SwitchInst Class
3090 //===----------------------------------------------------------------------===//
3091 
3092 //===---------------------------------------------------------------------------
3093 /// Multiway switch
3094 ///
3095 class SwitchInst : public TerminatorInst {
3096  unsigned ReservedSpace;
3097 
3098  // Operand[0] = Value to switch on
3099  // Operand[1] = Default basic block destination
3100  // Operand[2n ] = Value to match
3101  // Operand[2n+1] = BasicBlock to go to on match
3102  SwitchInst(const SwitchInst &SI);
3103 
3104  /// Create a new switch instruction, specifying a value to switch on and a
3105  /// default destination. The number of additional cases can be specified here
3106  /// to make memory allocation more efficient. This constructor can also
3107  /// auto-insert before another instruction.
3108  SwitchInst(Value *Value, BasicBlock *Default, unsigned NumCases,
3109  Instruction *InsertBefore);
3110 
3111  /// Create a new switch instruction, specifying a value to switch on and a
3112  /// default destination. The number of additional cases can be specified here
3113  /// to make memory allocation more efficient. This constructor also
3114  /// auto-inserts at the end of the specified BasicBlock.
3115  SwitchInst(Value *Value, BasicBlock *Default, unsigned NumCases,
3116  BasicBlock *InsertAtEnd);
3117 
3118  // allocate space for exactly zero operands
3119  void *operator new(size_t s) {
3120  return User::operator new(s);
3121  }
3122 
3123  void init(Value *Value, BasicBlock *Default, unsigned NumReserved);
3124  void growOperands();
3125 
3126 protected:
3127  // Note: Instruction needs to be a friend here to call cloneImpl.
3128  friend class Instruction;
3129 
3130  SwitchInst *cloneImpl() const;
3131 
3132 public:
3133  // -2
3134  static const unsigned DefaultPseudoIndex = static_cast<unsigned>(~0L-1);
3135 
3136  template <typename CaseHandleT> class CaseIteratorImpl;
3137 
3138  /// A handle to a particular switch case. It exposes a convenient interface
3139  /// to both the case value and the successor block.
3140  ///
3141  /// We define this as a template and instantiate it to form both a const and
3142  /// non-const handle.
3143  template <typename SwitchInstT, typename ConstantIntT, typename BasicBlockT>
3145  // Directly befriend both const and non-const iterators.
3146  friend class SwitchInst::CaseIteratorImpl<
3147  CaseHandleImpl<SwitchInstT, ConstantIntT, BasicBlockT>>;
3148 
3149  protected:
3150  // Expose the switch type we're parameterized with to the iterator.
3151  using SwitchInstType = SwitchInstT;
3152 
3153  SwitchInstT *SI;
3155 
3156  CaseHandleImpl() = default;
3157  CaseHandleImpl(SwitchInstT *SI, ptrdiff_t Index) : SI(SI), Index(Index) {}
3158 
3159  public:
3160  /// Resolves case value for current case.
3161  ConstantIntT *getCaseValue() const {
3162  assert((unsigned)Index < SI->getNumCases() &&
3163  "Index out the number of cases.");
3164  return reinterpret_cast<ConstantIntT *>(SI->getOperand(2 + Index * 2));
3165  }
3166 
3167  /// Resolves successor for current case.
3168  BasicBlockT *getCaseSuccessor() const {
3169  assert(((unsigned)Index < SI->getNumCases() ||
3170  (unsigned)Index == DefaultPseudoIndex) &&
3171  "Index out the number of cases.");
3172  return SI->getSuccessor(getSuccessorIndex());
3173  }
3174 
3175  /// Returns number of current case.
3176  unsigned getCaseIndex() const { return Index; }
3177 
3178  /// Returns TerminatorInst's successor index for current case successor.
3179  unsigned getSuccessorIndex() const {
3180  assert(((unsigned)Index == DefaultPseudoIndex ||
3181  (unsigned)Index < SI->getNumCases()) &&
3182  "Index out the number of cases.");
3183  return (unsigned)Index != DefaultPseudoIndex ? Index + 1 : 0;
3184  }
3185 
3186  bool operator==(const CaseHandleImpl &RHS) const {
3187  assert(SI == RHS.SI && "Incompatible operators.");
3188  return Index == RHS.Index;
3189  }
3190  };
3191 
3192  using ConstCaseHandle =
3194 
3196  : public CaseHandleImpl<SwitchInst, ConstantInt, BasicBlock> {
3198 
3199  public:
3200  CaseHandle(SwitchInst *SI, ptrdiff_t Index) : CaseHandleImpl(SI, Index) {}
3201 
3202  /// Sets the new value for current case.
3204  assert((unsigned)Index < SI->getNumCases() &&
3205  "Index out the number of cases.");
3206  SI->setOperand(2 + Index*2, reinterpret_cast<Value*>(V));
3207  }
3208 
3209  /// Sets the new successor for current case.
3211  SI->setSuccessor(getSuccessorIndex(), S);
3212  }
3213  };
3214 
3215  template <typename CaseHandleT>
3216  class CaseIteratorImpl
3217  : public iterator_facade_base<CaseIteratorImpl<CaseHandleT>,
3218  std::random_access_iterator_tag,
3219  CaseHandleT> {
3220  using SwitchInstT = typename CaseHandleT::SwitchInstType;
3221 
3222  CaseHandleT Case;
3223 
3224  public:
3225  /// Default constructed iterator is in an invalid state until assigned to
3226  /// a case for a particular switch.
3227  CaseIteratorImpl() = default;
3228 
3229  /// Initializes case iterator for given SwitchInst and for given
3230  /// case number.
3231  CaseIteratorImpl(SwitchInstT *SI, unsigned CaseNum) : Case(SI, CaseNum) {}
3232 
3233  /// Initializes case iterator for given SwitchInst and for given
3234  /// TerminatorInst's successor index.
3235  static CaseIteratorImpl fromSuccessorIndex(SwitchInstT *SI,
3236  unsigned SuccessorIndex) {
3237  assert(SuccessorIndex < SI->getNumSuccessors() &&
3238  "Successor index # out of range!");
3239  return SuccessorIndex != 0 ? CaseIteratorImpl(SI, SuccessorIndex - 1)
3240  : CaseIteratorImpl(SI, DefaultPseudoIndex);
3241  }
3242 
3243  /// Support converting to the const variant. This will be a no-op for const
3244  /// variant.
3246  return CaseIteratorImpl<ConstCaseHandle>(Case.SI, Case.Index);
3247  }
3248 
3250  // Check index correctness after addition.
3251  // Note: Index == getNumCases() means end().
3252  assert(Case.Index + N >= 0 &&
3253  (unsigned)(Case.Index + N) <= Case.SI->getNumCases() &&
3254  "Case.Index out the number of cases.");
3255  Case.Index += N;
3256  return *this;
3257  }
3259  // Check index correctness after subtraction.
3260  // Note: Case.Index == getNumCases() means end().
3261  assert(Case.Index - N >= 0 &&
3262  (unsigned)(Case.Index - N) <= Case.SI->getNumCases() &&
3263  "Case.Index out the number of cases.");
3264  Case.Index -= N;
3265  return *this;
3266  }
3268  assert(Case.SI == RHS.Case.SI && "Incompatible operators.");
3269  return Case.Index - RHS.Case.Index;
3270  }
3271  bool operator==(const CaseIteratorImpl &RHS) const {
3272  return Case == RHS.Case;
3273  }
3274  bool operator<(const CaseIteratorImpl &RHS) const {
3275  assert(Case.SI == RHS.Case.SI && "Incompatible operators.");
3276  return Case.Index < RHS.Case.Index;
3277  }
3278  CaseHandleT &operator*() { return Case; }
3279  const CaseHandleT &operator*() const { return Case; }
3280  };
3281 
3284 
3285  static SwitchInst *Create(Value *Value, BasicBlock *Default,
3286  unsigned NumCases,
3287  Instruction *InsertBefore = nullptr) {
3288  return new SwitchInst(Value, Default, NumCases, InsertBefore);
3289  }
3290 
3291  static SwitchInst *Create(Value *Value, BasicBlock *Default,
3292  unsigned NumCases, BasicBlock *InsertAtEnd) {
3293  return new SwitchInst(Value, Default, NumCases, InsertAtEnd);
3294  }
3295 
3296  /// Provide fast operand accessors
3298 
3299  // Accessor Methods for Switch stmt
3300  Value *getCondition() const { return getOperand(0); }
3301  void setCondition(Value *V) { setOperand(0, V); }
3302 
3304  return cast<BasicBlock>(getOperand(1));
3305  }
3306 
3307  void setDefaultDest(BasicBlock *DefaultCase) {
3308  setOperand(1, reinterpret_cast<Value*>(DefaultCase));
3309  }
3310 
3311  /// Return the number of 'cases' in this switch instruction, excluding the
3312  /// default case.
3313  unsigned getNumCases() const {
3314  return getNumOperands()/2 - 1;
3315  }
3316 
3317  /// Returns a read/write iterator that points to the first case in the
3318  /// SwitchInst.
3320  return CaseIt(this, 0);
3321  }
3322 
3323  /// Returns a read-only iterator that points to the first case in the
3324  /// SwitchInst.
3326  return ConstCaseIt(this, 0);
3327  }
3328 
3329  /// Returns a read/write iterator that points one past the last in the
3330  /// SwitchInst.
3332  return CaseIt(this, getNumCases());
3333  }
3334 
3335  /// Returns a read-only iterator that points one past the last in the
3336  /// SwitchInst.
3338  return ConstCaseIt(this, getNumCases());
3339  }
3340 
3341  /// Iteration adapter for range-for loops.
3343  return make_range(case_begin(), case_end());
3344  }
3345 
3346  /// Constant iteration adapter for range-for loops.
3348  return make_range(case_begin(), case_end());
3349  }
3350 
3351  /// Returns an iterator that points to the default case.
3352  /// Note: this iterator allows to resolve successor only. Attempt
3353  /// to resolve case value causes an assertion.
3354  /// Also note, that increment and decrement also causes an assertion and
3355  /// makes iterator invalid.
3357  return CaseIt(this, DefaultPseudoIndex);
3358  }
3360  return ConstCaseIt(this, DefaultPseudoIndex);
3361  }
3362 
3363  /// Search all of the case values for the specified constant. If it is
3364  /// explicitly handled, return the case iterator of it, otherwise return
3365  /// default case iterator to indicate that it is handled by the default
3366  /// handler.
3369  cases(), [C](CaseHandle &Case) { return Case.getCaseValue() == C; });
3370  if (I != case_end())
3371  return I;
3372 
3373  return case_default();
3374  }
3376  ConstCaseIt I = llvm::find_if(cases(), [C](ConstCaseHandle &Case) {
3377  return Case.getCaseValue() == C;
3378  });
3379  if (I != case_end())
3380  return I;
3381 
3382  return case_default();
3383  }
3384 
3385  /// Finds the unique case value for a given successor. Returns null if the
3386  /// successor is not found, not unique, or is the default case.
3388  if (BB == getDefaultDest())
3389  return nullptr;
3390 
3391  ConstantInt *CI = nullptr;
3392  for (auto Case : cases()) {
3393  if (Case.getCaseSuccessor() != BB)
3394  continue;
3395 
3396  if (CI)
3397  return nullptr; // Multiple cases lead to BB.
3398 
3399  CI = Case.getCaseValue();
3400  }
3401 
3402  return CI;
3403  }
3404 
3405  /// Add an entry to the switch instruction.
3406  /// Note:
3407  /// This action invalidates case_end(). Old case_end() iterator will
3408  /// point to the added case.
3409  void addCase(ConstantInt *OnVal, BasicBlock *Dest);
3410 
3411  /// This method removes the specified case and its successor from the switch
3412  /// instruction. Note that this operation may reorder the remaining cases at
3413  /// index idx and above.
3414  /// Note:
3415  /// This action invalidates iterators for all cases following the one removed,
3416  /// including the case_end() iterator. It returns an iterator for the next
3417  /// case.
3418  CaseIt removeCase(CaseIt I);
3419 
3420  unsigned getNumSuccessors() const { return getNumOperands()/2; }
3421  BasicBlock *getSuccessor(unsigned idx) const {
3422  assert(idx < getNumSuccessors() &&"Successor idx out of range for switch!");
3423  return cast<BasicBlock>(getOperand(idx*2+1));
3424  }
3425  void setSuccessor(unsigned idx, BasicBlock *NewSucc) {
3426  assert(idx < getNumSuccessors() && "Successor # out of range for switch!");
3427  setOperand(idx * 2 + 1, NewSucc);
3428  }
3429 
3430  // Methods for support type inquiry through isa, cast, and dyn_cast:
3431  static bool classof(const Instruction *I) {
3432  return I->getOpcode() == Instruction::Switch;
3433  }
3434  static bool classof(const Value *V) {
3435  return isa<Instruction>(V) && classof(cast<Instruction>(V));
3436  }
3437 };
3438 
3439 template <>
3441 };
3442 
3443 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(SwitchInst, Value)
3444 
3445 //===----------------------------------------------------------------------===//
3446 // IndirectBrInst Class
3447 //===----------------------------------------------------------------------===//
3448 
3449 //===---------------------------------------------------------------------------
3450 /// Indirect Branch Instruction.
3451 ///
3453  unsigned ReservedSpace;
3454 
3455  // Operand[0] = Address to jump to
3456  // Operand[n+1] = n-th destination
3457  IndirectBrInst(const IndirectBrInst &IBI);
3458 
3459  /// Create a new indirectbr instruction, specifying an
3460  /// Address to jump to. The number of expected destinations can be specified
3461  /// here to make memory allocation more efficient. This constructor can also
3462  /// autoinsert before another instruction.
3463  IndirectBrInst(Value *Address, unsigned NumDests, Instruction *InsertBefore);
3464 
3465  /// Create a new indirectbr instruction, specifying an
3466  /// Address to jump to. The number of expected destinations can be specified
3467  /// here to make memory allocation more efficient. This constructor also
3468  /// autoinserts at the end of the specified BasicBlock.
3469  IndirectBrInst(Value *Address, unsigned NumDests, BasicBlock *InsertAtEnd);
3470 
3471  // allocate space for exactly zero operands
3472  void *operator new(size_t s) {
3473  return User::operator new(s);
3474  }
3475 
3476  void init(Value *Address, unsigned NumDests);
3477  void growOperands();
3478 
3479 protected:
3480  // Note: Instruction needs to be a friend here to call cloneImpl.
3481  friend class Instruction;
3482 
3483  IndirectBrInst *cloneImpl() const;
3484 
3485 public:
3486  static IndirectBrInst *Create(Value *Address, unsigned NumDests,
3487  Instruction *InsertBefore = nullptr) {
3488  return new IndirectBrInst(Address, NumDests, InsertBefore);
3489  }
3490 
3491  static IndirectBrInst *Create(Value *Address, unsigned NumDests,
3492  BasicBlock *InsertAtEnd) {
3493  return new IndirectBrInst(Address, NumDests, InsertAtEnd);
3494  }
3495 
3496  /// Provide fast operand accessors.
3498 
3499  // Accessor Methods for IndirectBrInst instruction.
3500  Value *getAddress() { return getOperand(0); }
3501  const Value *getAddress() const { return getOperand(0); }
3502  void setAddress(Value *V) { setOperand(0, V); }
3503 
3504  /// return the number of possible destinations in this
3505  /// indirectbr instruction.
3506  unsigned getNumDestinations() const { return getNumOperands()-1; }
3507 
3508  /// Return the specified destination.
3509  BasicBlock *getDestination(unsigned i) { return getSuccessor(i); }
3510  const BasicBlock *getDestination(unsigned i) const { return getSuccessor(i); }
3511 
3512  /// Add a destination.
3513  ///
3514  void addDestination(BasicBlock *Dest);
3515 
3516  /// This method removes the specified successor from the
3517  /// indirectbr instruction.
3518  void removeDestination(unsigned i);
3519 
3520  unsigned getNumSuccessors() const { return getNumOperands()-1; }
3521  BasicBlock *getSuccessor(unsigned i) const {
3522  return cast<BasicBlock>(getOperand(i+1));
3523  }
3524  void setSuccessor(unsigned i, BasicBlock *NewSucc) {
3525  setOperand(i + 1, NewSucc);
3526  }
3527 
3528  // Methods for support type inquiry through isa, cast, and dyn_cast:
3529  static bool classof(const Instruction *I) {
3530  return I->getOpcode() == Instruction::IndirectBr;
3531  }
3532  static bool classof(const Value *V) {
3533  return isa<Instruction>(V) && classof(cast<Instruction>(V));
3534  }
3535 };
3536 
3537 template <>
3539 };
3540 
3541 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(IndirectBrInst, Value)
3542 
3543 //===----------------------------------------------------------------------===//
3544 // InvokeInst Class
3545 //===----------------------------------------------------------------------===//
3546 
3547 /// Invoke instruction. The SubclassData field is used to hold the
3548 /// calling convention of the call.
3549 ///
3553 
3555  FunctionType *FTy;
3556 
3557  InvokeInst(const InvokeInst &BI);
3558 
3559  /// Construct an InvokeInst given a range of arguments.
3560  ///
3561  /// Construct an InvokeInst from a range of arguments
3562  inline InvokeInst(Value *Func, BasicBlock *IfNormal, BasicBlock *IfException,
3563  ArrayRef<Value *> Args, ArrayRef<OperandBundleDef> Bundles,
3564  unsigned Values, const Twine &NameStr,
3565  Instruction *InsertBefore)
3566  : InvokeInst(cast<FunctionType>(
3567  cast<PointerType>(Func->getType())->getElementType()),
3568  Func, IfNormal, IfException, Args, Bundles, Values, NameStr,
3569  InsertBefore) {}
3570 
3571  inline InvokeInst(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
3572  BasicBlock *IfException, ArrayRef<Value *> Args,
3573  ArrayRef<OperandBundleDef> Bundles, unsigned Values,
3574  const Twine &NameStr, Instruction *InsertBefore);
3575  /// Construct an InvokeInst given a range of arguments.
3576  ///
3577  /// Construct an InvokeInst from a range of arguments
3578  inline InvokeInst(Value *Func, BasicBlock *IfNormal, BasicBlock *IfException,
3580  unsigned Values, const Twine &NameStr,
3581  BasicBlock *InsertAtEnd);
3582 
3583  bool hasDescriptor() const { return HasDescriptor; }
3584 
3585  void init(Value *Func, BasicBlock *IfNormal, BasicBlock *IfException,
3587  const Twine &NameStr) {
3588  init(cast<FunctionType>(
3589  cast<PointerType>(Func->getType())->getElementType()),
3590  Func, IfNormal, IfException, Args, Bundles, NameStr);
3591  }
3592 
3593  void init(FunctionType *FTy, Value *Func, BasicBlock *IfNormal,
3594  BasicBlock *IfException, ArrayRef<Value *> Args,
3595  ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr);
3596 
3597 protected:
3598  // Note: Instruction needs to be a friend here to call cloneImpl.
3599  friend class Instruction;
3600 
3601  InvokeInst *cloneImpl() const;
3602 
3603 public:
3604  static InvokeInst *Create(Value *Func, BasicBlock *IfNormal,
3605  BasicBlock *IfException, ArrayRef<Value *> Args,
3606  const Twine &NameStr,
3607  Instruction *InsertBefore = nullptr) {
3608  return Create(cast<FunctionType>(
3609  cast<PointerType>(Func->getType())->getElementType()),
3610  Func, IfNormal, IfException, Args, None, NameStr,
3611  InsertBefore);
3612  }
3613 
3614  static InvokeInst *Create(Value *Func, BasicBlock *IfNormal,
3615  BasicBlock *IfException, ArrayRef<Value *> Args,
3616  ArrayRef<OperandBundleDef> Bundles = None,
3617  const Twine &NameStr = "",
3618  Instruction *InsertBefore = nullptr) {
3619  return Create(cast<FunctionType>(
3620  cast<PointerType>(Func->getType())->getElementType()),
3621  Func, IfNormal, IfException, Args, Bundles, NameStr,
3622  InsertBefore);
3623  }
3624 
3625  static InvokeInst *Create(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
3626  BasicBlock *IfException, ArrayRef<Value *> Args,
3627  const Twine &NameStr,
3628  Instruction *InsertBefore = nullptr) {
3629  unsigned Values = unsigned(Args.size()) + 3;
3630  return new (Values) InvokeInst(Ty, Func, IfNormal, IfException, Args, None,
3631  Values, NameStr, InsertBefore);
3632  }
3633 
3634  static InvokeInst *Create(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
3635  BasicBlock *IfException, ArrayRef<Value *> Args,
3636  ArrayRef<OperandBundleDef> Bundles = None,
3637  const Twine &NameStr = "",
3638  Instruction *InsertBefore = nullptr) {
3639  unsigned Values = unsigned(Args.size()) + CountBundleInputs(Bundles) + 3;
3640  unsigned DescriptorBytes = Bundles.size() * sizeof(BundleOpInfo);
3641 
3642  return new (Values, DescriptorBytes)
3643  InvokeInst(Ty, Func, IfNormal, IfException, Args, Bundles, Values,
3644  NameStr, InsertBefore);
3645  }
3646 
3647  static InvokeInst *Create(Value *Func,
3648  BasicBlock *IfNormal, BasicBlock *IfException,
3649  ArrayRef<Value *> Args, const Twine &NameStr,
3650  BasicBlock *InsertAtEnd) {
3651  unsigned Values = unsigned(Args.size()) + 3;
3652  return new (Values) InvokeInst(Func, IfNormal, IfException, Args, None,
3653  Values, NameStr, InsertAtEnd);
3654  }
3655 
3656  static InvokeInst *Create(Value *Func, BasicBlock *IfNormal,
3657  BasicBlock *IfException, ArrayRef<Value *> Args,
3659  const Twine &NameStr, BasicBlock *InsertAtEnd) {
3660  unsigned Values = unsigned(Args.size()) + CountBundleInputs(Bundles) + 3;
3661  unsigned DescriptorBytes = Bundles.size() * sizeof(BundleOpInfo);
3662 
3663  return new (Values, DescriptorBytes)
3664  InvokeInst(Func, IfNormal, IfException, Args, Bundles, Values, NameStr,
3665  InsertAtEnd);
3666  }
3667 
3668  /// Create a clone of \p II with a different set of operand bundles and
3669  /// insert it before \p InsertPt.
3670  ///
3671  /// The returned invoke instruction is identical to \p II in every way except
3672  /// that the operand bundles for the new instruction are set to the operand
3673  /// bundles in \p Bundles.
3674  static InvokeInst *Create(InvokeInst *II, ArrayRef<OperandBundleDef> Bundles,
3675  Instruction *InsertPt = nullptr);
3676 
3677  /// Provide fast operand accessors
3679 
3680  FunctionType *getFunctionType() const { return FTy; }
3681 
3683  mutateType(FTy->getReturnType());
3684  this->FTy = FTy;
3685  }
3686 
3687  /// Return the number of invoke arguments.
3688  ///
3689  unsigned getNumArgOperands() const {
3690  return getNumOperands() - getNumTotalBundleOperands() - 3;
3691  }
3692 
3693  /// getArgOperand/setArgOperand - Return/set the i-th invoke argument.
3694  ///
3695  Value *getArgOperand(unsigned i) const {
3696  assert(i < getNumArgOperands() && "Out of bounds!");
3697  return getOperand(i);
3698  }
3699  void setArgOperand(unsigned i, Value *v) {
3700  assert(i < getNumArgOperands() && "Out of bounds!");
3701  setOperand(i, v);
3702  }
3703 
3704  /// Return the iterator pointing to the beginning of the argument list.
3706 
3707  /// Return the iterator pointing to the end of the argument list.
3709  // [ invoke args ], [ operand bundles ], normal dest, unwind dest, callee
3710  return op_end() - getNumTotalBundleOperands() - 3;
3711  }
3712 
3713  /// Iteration adapter for range-for loops.
3715  return make_range(arg_begin(), arg_end());
3716  }
3717 
3718  /// Return the iterator pointing to the beginning of the argument list.
3719  const_op_iterator arg_begin() const { return op_begin(); }
3720 
3721  /// Return the iterator pointing to the end of the argument list.
3723  // [ invoke args ], [ operand bundles ], normal dest, unwind dest, callee
3724  return op_end() - getNumTotalBundleOperands() - 3;
3725  }
3726 
3727  /// Iteration adapter for range-for loops.
3729  return make_range(arg_begin(), arg_end());
3730  }
3731 
3732  /// Wrappers for getting the \c Use of a invoke argument.
3733  const Use &getArgOperandUse(unsigned i) const {
3734  assert(i < getNumArgOperands() && "Out of bounds!");
3735  return getOperandUse(i);
3736  }
3737  Use &getArgOperandUse(unsigned i) {
3738  assert(i < getNumArgOperands() && "Out of bounds!");
3739  return getOperandUse(i);
3740  }
3741 
3742  /// If one of the arguments has the 'returned' attribute, return its
3743  /// operand value. Otherwise, return nullptr.
3744  Value *getReturnedArgOperand() const;
3745 
3746  /// getCallingConv/setCallingConv - Get or set the calling convention of this
3747  /// function call.
3749  return static_cast<CallingConv::ID>(getSubclassDataFromInstruction());
3750  }
3752  auto ID = static_cast<unsigned>(CC);
3753  assert(!(ID & ~CallingConv::MaxID) && "Unsupported calling convention");
3754  setInstructionSubclassData(ID);
3755  }
3756 
3757  /// Return the parameter attributes for this invoke.
3758  ///
3759  AttributeList getAttributes() const { return Attrs; }
3760 
3761  /// Set the parameter attributes for this invoke.
3762  ///
3764 
3765  /// adds the attribute to the list of attributes.
3766  void addAttribute(unsigned i, Attribute::AttrKind Kind);
3767 
3768  /// adds the attribute to the list of attributes.
3769  void addAttribute(unsigned i, Attribute Attr);
3770 
3771  /// Adds the attribute to the indicated argument
3772  void addParamAttr(unsigned ArgNo, Attribute::AttrKind Kind);
3773 
3774  /// removes the attribute from the list of attributes.
3775  void removeAttribute(unsigned i, Attribute::AttrKind Kind);
3776 
3777  /// removes the attribute from the list of attributes.
3778  void removeAttribute(unsigned i, StringRef Kind);
3779 
3780  /// Removes the attribute from the given argument
3781  void removeParamAttr(unsigned ArgNo, Attribute::AttrKind Kind);
3782 
3783  /// adds the dereferenceable attribute to the list of attributes.
3784  void addDereferenceableAttr(unsigned i, uint64_t Bytes);
3785 
3786  /// adds the dereferenceable_or_null attribute to the list of
3787  /// attributes.
3788  void addDereferenceableOrNullAttr(unsigned i, uint64_t Bytes);
3789 
3790  /// Determine whether this call has the given attribute.
3791  bool hasFnAttr(Attribute::AttrKind Kind) const {
3792  assert(Kind != Attribute::NoBuiltin &&
3793  "Use CallInst::isNoBuiltin() to check for Attribute::NoBuiltin");
3794  return hasFnAttrImpl(Kind);
3795  }
3796 
3797  /// Determine whether this call has the given attribute.
3798  bool hasFnAttr(StringRef Kind) const {
3799  return hasFnAttrImpl(Kind);
3800  }
3801 
3802  /// Determine whether the return value has the given attribute.
3803  bool hasRetAttr(Attribute::AttrKind Kind) const;
3804 
3805  /// Determine whether the argument or parameter has the given attribute.
3806  bool paramHasAttr(unsigned ArgNo, Attribute::AttrKind Kind) const;
3807 
3808  /// Get the attribute of a given kind at a position.
3809  Attribute getAttribute(unsigned i, Attribute::AttrKind Kind) const {
3810  return getAttributes().getAttribute(i, Kind);
3811  }
3812 
3813  /// Get the attribute of a given kind at a position.
3814  Attribute getAttribute(unsigned i, StringRef Kind) const {
3815  return getAttributes().getAttribute(i, Kind);
3816  }
3817 
3818  /// Return true if the data operand at index \p i has the attribute \p
3819  /// A.
3820  ///
3821  /// Data operands include invoke arguments and values used in operand bundles,
3822  /// but does not include the invokee operand, or the two successor blocks.
3823  /// This routine dispatches to the underlying AttributeList or the
3824  /// OperandBundleUser as appropriate.
3825  ///
3826  /// The index \p i is interpreted as
3827  ///
3828  /// \p i == Attribute::ReturnIndex -> the return value
3829  /// \p i in [1, arg_size + 1) -> argument number (\p i - 1)
3830  /// \p i in [arg_size + 1, data_operand_size + 1) -> bundle operand at index
3831  /// (\p i - 1) in the operand list.
3832  bool dataOperandHasImpliedAttr(unsigned i, Attribute::AttrKind Kind) const;
3833 
3834  /// Extract the alignment of the return value.
3835  unsigned getRetAlignment() const { return Attrs.getRetAlignment(); }
3836 
3837  /// Extract the alignment for a call or parameter (0=unknown).
3838  unsigned getParamAlignment(unsigned ArgNo) const {
3839  return Attrs.getParamAlignment(ArgNo);
3840  }
3841 
3842  /// Extract the number of dereferenceable bytes for a call or
3843  /// parameter (0=unknown).
3844  uint64_t getDereferenceableBytes(unsigned i) const {
3845  return Attrs.getDereferenceableBytes(i);
3846  }
3847 
3848  /// Extract the number of dereferenceable_or_null bytes for a call or
3849  /// parameter (0=unknown).
3850  uint64_t getDereferenceableOrNullBytes(unsigned i) const {
3851  return Attrs.getDereferenceableOrNullBytes(i);
3852  }
3853 
3854  /// @brief Determine if the return value is marked with NoAlias attribute.
3855  bool returnDoesNotAlias() const {
3856  return Attrs.hasAttribute(AttributeList::ReturnIndex, Attribute::NoAlias);
3857  }
3858 
3859  /// Return true if the call should not be treated as a call to a
3860  /// builtin.
3861  bool isNoBuiltin() const {
3862  // We assert in hasFnAttr if one passes in Attribute::NoBuiltin, so we have
3863  // to check it by hand.
3864  return hasFnAttrImpl(Attribute::NoBuiltin) &&
3865  !hasFnAttrImpl(Attribute::Builtin);
3866  }
3867 
3868  /// Determine if the call requires strict floating point semantics.
3869  bool isStrictFP() const { return hasFnAttr(Attribute::StrictFP); }
3870 
3871  /// Return true if the call should not be inlined.
3872  bool isNoInline() const { return hasFnAttr(Attribute::NoInline); }
3873  void setIsNoInline() {
3874  addAttribute(AttributeList::FunctionIndex, Attribute::NoInline);
3875  }
3876 
3877  /// Determine if the call does not access memory.
3878  bool doesNotAccessMemory() const {
3879  return hasFnAttr(Attribute::ReadNone);
3880  }
3882  addAttribute(AttributeList::FunctionIndex, Attribute::ReadNone);
3883  }
3884 
3885  /// Determine if the call does not access or only reads memory.
3886  bool onlyReadsMemory() const {
3887  return doesNotAccessMemory() || hasFnAttr(Attribute::ReadOnly);
3888  }
3890  addAttribute(AttributeList::FunctionIndex, Attribute::ReadOnly);
3891  }
3892 
3893  /// Determine if the call does not access or only writes memory.
3894  bool doesNotReadMemory() const {
3895  return doesNotAccessMemory() || hasFnAttr(Attribute::WriteOnly);
3896  }
3898  addAttribute(AttributeList::FunctionIndex, Attribute::WriteOnly);
3899  }
3900 
3901  /// @brief Determine if the call access memmory only using it's pointer
3902  /// arguments.
3903  bool onlyAccessesArgMemory() const {
3904  return hasFnAttr(Attribute::ArgMemOnly);
3905  }
3907  addAttribute(AttributeList::FunctionIndex, Attribute::ArgMemOnly);
3908  }
3909 
3910  /// @brief Determine if the function may only access memory that is
3911  /// inaccessible from the IR.
3913  return hasFnAttr(Attribute::InaccessibleMemOnly);
3914  }
3916  addAttribute(AttributeList::FunctionIndex, Attribute::InaccessibleMemOnly);
3917  }
3918 
3919  /// @brief Determine if the function may only access memory that is
3920  /// either inaccessible from the IR or pointed to by its arguments.
3922  return hasFnAttr(Attribute::InaccessibleMemOrArgMemOnly);
3923  }
3925  addAttribute(AttributeList::FunctionIndex, Attribute::InaccessibleMemOrArgMemOnly);
3926  }
3927 
3928  /// Determine if the call cannot return.
3929  bool doesNotReturn() const { return hasFnAttr(Attribute::NoReturn); }
3931  addAttribute(AttributeList::FunctionIndex, Attribute::NoReturn);
3932  }
3933 
3934  /// Determine if the call cannot unwind.
3935  bool doesNotThrow() const { return hasFnAttr(Attribute::NoUnwind); }
3937  addAttribute(AttributeList::FunctionIndex, Attribute::NoUnwind);
3938  }
3939 
3940  /// Determine if the invoke cannot be duplicated.
3941  bool cannotDuplicate() const {return hasFnAttr(Attribute::NoDuplicate); }
3943  addAttribute(AttributeList::FunctionIndex, Attribute::NoDuplicate);
3944  }
3945 
3946  /// Determine if the invoke is convergent
3947  bool isConvergent() const { return hasFnAttr(Attribute::Convergent); }
3948  void setConvergent() {
3950  }
3953  }
3954 
3955  /// Determine if the call returns a structure through first
3956  /// pointer argument.
3957  bool hasStructRetAttr() const {
3958  if (getNumArgOperands() == 0)
3959  return false;
3960 
3961  // Be friendly and also check the callee.
3962  return paramHasAttr(0, Attribute::StructRet);
3963  }
3964 
3965  /// Determine if any call argument is an aggregate passed by value.
3966  bool hasByValArgument() const {
3967  return Attrs.hasAttrSomewhere(Attribute::ByVal);
3968  }
3969 
3970  /// Return the function called, or null if this is an
3971  /// indirect function invocation.
3972  ///
3974  return dyn_cast<Function>(Op<-3>());
3975  }
3976 
3977  /// Get a pointer to the function that is invoked by this
3978  /// instruction
3979  const Value *getCalledValue() const { return Op<-3>(); }
3980  Value *getCalledValue() { return Op<-3>(); }
3981 
3982  /// Set the function called.
3983  void setCalledFunction(Value* Fn) {
3984  setCalledFunction(
3985  cast<FunctionType>(cast<PointerType>(Fn->getType())->getElementType()),
3986  Fn);
3987  }
3988  void setCalledFunction(FunctionType *FTy, Value *Fn) {
3989  this->FTy = FTy;
3990  assert(FTy == cast<FunctionType>(
3991  cast<PointerType>(Fn->getType())->getElementType()));
3992  Op<-3>() = Fn;
3993  }
3994 
3995  // get*Dest - Return the destination basic blocks...
3997  return cast<BasicBlock>(Op<-2>());
3998  }
4000  return cast<BasicBlock>(Op<-1>());
4001  }
4003  Op<-2>() = reinterpret_cast<Value*>(B);
4004  }
4006  Op<-1>() = reinterpret_cast<Value*>(B);
4007  }
4008 
4009  /// Get the landingpad instruction from the landing pad
4010  /// block (the unwind destination).
4011  LandingPadInst *getLandingPadInst() const;
4012 
4013  BasicBlock *getSuccessor(unsigned i) const {
4014  assert(i < 2 && "Successor # out of range for invoke!");
4015  return i == 0 ? getNormalDest() : getUnwindDest();
4016  }
4017 
4018  void setSuccessor(unsigned idx, BasicBlock *NewSucc) {
4019  assert(idx < 2 && "Successor # out of range for invoke!");
4020  *(&Op<-2>() + idx) = reinterpret_cast<Value*>(NewSucc);
4021  }
4022 
4023  unsigned getNumSuccessors() const { return 2; }
4024 
4025  // Methods for support type inquiry through isa, cast, and dyn_cast:
4026  static bool classof(const Instruction *I) {
4027  return (I->getOpcode() == Instruction::Invoke);
4028  }
4029  static bool classof(const Value *V) {
4030  return isa<Instruction>(V) && classof(cast<Instruction>(V));
4031  }
4032 
4033 private:
4034  template <typename AttrKind> bool hasFnAttrImpl(AttrKind Kind) const {
4035  if (Attrs.hasAttribute(AttributeList::FunctionIndex, Kind))
4036  return true;
4037 
4038  // Operand bundles override attributes on the called function, but don't
4039  // override attributes directly present on the invoke instruction.
4040  if (isFnAttrDisallowedByOpBundle(Kind))
4041  return false;
4042 
4043  if (const Function *F = getCalledFunction())
4044  return F->getAttributes().hasAttribute(AttributeList::FunctionIndex,
4045  Kind);
4046  return false;
4047  }
4048 
4049  // Shadow Instruction::setInstructionSubclassData with a private forwarding
4050  // method so that subclasses cannot accidentally use it.
4051  void setInstructionSubclassData(unsigned short D) {
4053  }
4054 };
4055 
4056 template <>
4057 struct OperandTraits<InvokeInst> : public VariadicOperandTraits<InvokeInst, 3> {
4058 };
4059 
4060 InvokeInst::InvokeInst(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
4061  BasicBlock *IfException, ArrayRef<Value *> Args,
4062  ArrayRef<OperandBundleDef> Bundles, unsigned Values,
4063  const Twine &NameStr, Instruction *InsertBefore)
4064  : TerminatorInst(Ty->getReturnType(), Instruction::Invoke,
4065  OperandTraits<InvokeInst>::op_end(this) - Values, Values,
4066  InsertBefore) {
4067  init(Ty, Func, IfNormal, IfException, Args, Bundles, NameStr);
4068 }
4069 
4070 InvokeInst::InvokeInst(Value *Func, BasicBlock *IfNormal,
4071  BasicBlock *IfException, ArrayRef<Value *> Args,
4072  ArrayRef<OperandBundleDef> Bundles, unsigned Values,
4073  const Twine &NameStr, BasicBlock *InsertAtEnd)
4074  : TerminatorInst(
4075  cast<FunctionType>(cast<PointerType>(Func->getType())
4076  ->getElementType())->getReturnType(),
4077  Instruction::Invoke, OperandTraits<InvokeInst>::op_end(this) - Values,
4078  Values, InsertAtEnd) {
4079  init(Func, IfNormal, IfException, Args, Bundles, NameStr);
4080 }
4081 
4082 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(InvokeInst, Value)
4083 
4084 //===----------------------------------------------------------------------===//
4085 // ResumeInst Class
4086 //===----------------------------------------------------------------------===//
4087 
4088 //===---------------------------------------------------------------------------
4089 /// Resume the propagation of an exception.
4090 ///
4091 class ResumeInst : public TerminatorInst {
4092  ResumeInst(const ResumeInst &RI);
4093 
4094  explicit ResumeInst(Value *Exn, Instruction *InsertBefore=nullptr);
4095  ResumeInst(Value *Exn, BasicBlock *InsertAtEnd);
4096 
4097 protected:
4098  // Note: Instruction needs to be a friend here to call cloneImpl.
4099  friend class Instruction;
4100 
4101  ResumeInst *cloneImpl() const;
4102 
4103 public:
4104  static ResumeInst *Create(Value *Exn, Instruction *InsertBefore = nullptr) {
4105  return new(1) ResumeInst(Exn, InsertBefore);
4106  }
4107 
4108  static ResumeInst *Create(Value *Exn, BasicBlock *InsertAtEnd) {
4109  return new(1) ResumeInst(Exn, InsertAtEnd);
4110  }
4111 
4112  /// Provide fast operand accessors
4114 
4115  /// Convenience accessor.
4116  Value *getValue() const { return Op<0>(); }
4117 
4118  unsigned getNumSuccessors() const { return 0; }
4119 
4120  // Methods for support type inquiry through isa, cast, and dyn_cast:
4121  static bool classof(const Instruction *I) {
4122  return I->getOpcode() == Instruction::Resume;
4123  }
4124  static bool classof(const Value *V) {
4125  return isa<Instruction>(V) && classof(cast<Instruction>(V));
4126  }
4127 
4128 private:
4129  friend TerminatorInst;
4130 
4131  BasicBlock *getSuccessor(unsigned idx) const {
4132  llvm_unreachable("ResumeInst has no successors!");
4133  }
4134 
4135  void setSuccessor(unsigned idx, BasicBlock *NewSucc) {
4136  llvm_unreachable("ResumeInst has no successors!");
4137  }
4138 };
4139 
4140 template <>
4142  public FixedNumOperandTraits<ResumeInst, 1> {
4143 };
4144 
4145 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ResumeInst, Value)
4146 
4147 //===----------------------------------------------------------------------===//
4148 // CatchSwitchInst Class
4149 //===----------------------------------------------------------------------===//
4151  /// The number of operands actually allocated. NumOperands is
4152  /// the number actually in use.
4153  unsigned ReservedSpace;
4154 
4155  // Operand[0] = Outer scope
4156  // Operand[1] = Unwind block destination
4157  // Operand[n] = BasicBlock to go to on match
4158  CatchSwitchInst(const CatchSwitchInst &CSI);
4159 
4160  /// Create a new switch instruction, specifying a
4161  /// default destination. The number of additional handlers can be specified
4162  /// here to make memory allocation more efficient.
4163  /// This constructor can also autoinsert before another instruction.
4164  CatchSwitchInst(Value *ParentPad, BasicBlock *UnwindDest,
4165  unsigned NumHandlers, const Twine &NameStr,
4166  Instruction *InsertBefore);
4167 
4168  /// Create a new switch instruction, specifying a
4169  /// default destination. The number of additional handlers can be specified
4170  /// here to make memory allocation more efficient.
4171  /// This constructor also autoinserts at the end of the specified BasicBlock.
4172  CatchSwitchInst(Value *ParentPad, BasicBlock *UnwindDest,
4173  unsigned NumHandlers, const Twine &NameStr,
4174  BasicBlock *InsertAtEnd);
4175 
4176  // allocate space for exactly zero operands
4177  void *operator new(size_t s) { return User::operator new(s); }
4178 
4179  void init(Value *ParentPad, BasicBlock *UnwindDest, unsigned NumReserved);
4180  void growOperands(unsigned Size);
4181 
4182 protected:
4183  // Note: Instruction needs to be a friend here to call cloneImpl.
4184  friend class Instruction;
4185 
4186  CatchSwitchInst *cloneImpl() const;
4187 
4188 public:
4189  static CatchSwitchInst *Create(Value *ParentPad, BasicBlock *UnwindDest,
4190  unsigned NumHandlers,
4191  const Twine &NameStr = "",
4192  Instruction *InsertBefore = nullptr) {
4193  return new CatchSwitchInst(ParentPad, UnwindDest, NumHandlers, NameStr,
4194  InsertBefore);
4195  }
4196 
4197  static CatchSwitchInst *Create(Value *ParentPad, BasicBlock *UnwindDest,
4198  unsigned NumHandlers, const Twine &NameStr,
4199  BasicBlock *InsertAtEnd) {
4200  return new CatchSwitchInst(ParentPad, UnwindDest, NumHandlers, NameStr,
4201  InsertAtEnd);
4202  }
4203 
4204  /// Provide fast operand accessors
4206 
4207  // Accessor Methods for CatchSwitch stmt
4208  Value *getParentPad() const { return getOperand(0); }
4209  void setParentPad(Value *ParentPad) { setOperand(0, ParentPad); }
4210 
4211  // Accessor Methods for CatchSwitch stmt
4212  bool hasUnwindDest() const { return getSubclassDataFromInstruction() & 1; }
4213  bool unwindsToCaller() const { return !hasUnwindDest(); }
4215  if (hasUnwindDest())
4216  return cast<BasicBlock>(getOperand(1));
4217  return nullptr;
4218  }
4219  void setUnwindDest(BasicBlock *UnwindDest) {
4220  assert(UnwindDest);
4221  assert(hasUnwindDest());
4222  setOperand(1, UnwindDest);
4223  }
4224 
4225  /// return the number of 'handlers' in this catchswitch
4226  /// instruction, except the default handler
4227  unsigned getNumHandlers() const {
4228  if (hasUnwindDest())
4229  return getNumOperands() - 2;
4230  return getNumOperands() - 1;
4231  }
4232 
4233 private:
4234  static BasicBlock *handler_helper(Value *V) { return cast<BasicBlock>(V); }
4235  static const BasicBlock *handler_helper(const Value *V) {
4236  return cast<BasicBlock>(V);
4237  }
4238 
4239 public:
4240  using DerefFnTy = BasicBlock *(*)(Value *);
4243  using ConstDerefFnTy = const BasicBlock *(*)(const Value *);
4244  using const_handler_iterator =
4247 
4248  /// Returns an iterator that points to the first handler in CatchSwitchInst.
4250  op_iterator It = op_begin() + 1;
4251  if (hasUnwindDest())
4252  ++It;
4253  return handler_iterator(It, DerefFnTy(handler_helper));
4254  }
4255 
4256  /// Returns an iterator that points to the first handler in the
4257  /// CatchSwitchInst.
4258  const_handler_iterator handler_begin() const {
4259  const_op_iterator It = op_begin() + 1;
4260  if (hasUnwindDest())
4261  ++It;
4262  return const_handler_iterator(It, ConstDerefFnTy(handler_helper));
4263  }
4264 
4265  /// Returns a read-only iterator that points one past the last
4266  /// handler in the CatchSwitchInst.
4268  return handler_iterator(op_end(), DerefFnTy(handler_helper));
4269  }
4270 
4271  /// Returns an iterator that points one past the last handler in the
4272  /// CatchSwitchInst.
4273  const_handler_iterator handler_end() const {
4274  return const_handler_iterator(op_end(), ConstDerefFnTy(handler_helper));
4275  }
4276 
4277  /// iteration adapter for range-for loops.
4279  return make_range(handler_begin(), handler_end());
4280  }
4281 
4282  /// iteration adapter for range-for loops.
4284  return make_range(handler_begin(), handler_end());
4285  }
4286 
4287  /// Add an entry to the switch instruction...
4288  /// Note:
4289  /// This action invalidates handler_end(). Old handler_end() iterator will
4290  /// point to the added handler.
4291  void addHandler(BasicBlock *Dest);
4292 
4293  void removeHandler(handler_iterator HI);
4294 
4295  unsigned getNumSuccessors() const { return getNumOperands() - 1; }
4296  BasicBlock *getSuccessor(unsigned Idx) const {
4297  assert(Idx < getNumSuccessors() &&
4298  "Successor # out of range for catchswitch!");
4299  return cast<BasicBlock>(getOperand(Idx + 1));
4300  }
4301  void setSuccessor(unsigned Idx, BasicBlock *NewSucc) {
4302  assert(Idx < getNumSuccessors() &&
4303  "Successor # out of range for catchswitch!");
4304  setOperand(Idx + 1, NewSucc);
4305  }
4306 
4307  // Methods for support type inquiry through isa, cast, and dyn_cast:
4308  static bool classof(const Instruction *I) {
4309  return I->getOpcode() == Instruction::CatchSwitch;
4310  }
4311  static bool classof(const Value *V) {
4312  return isa<Instruction>(V) && classof(cast<Instruction>(V));
4313  }
4314 };
4315 
4316 template <>
4318 
4319 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CatchSwitchInst, Value)
4320 
4321 //===----------------------------------------------------------------------===//
4322 // CleanupPadInst Class
4323 //===----------------------------------------------------------------------===//
4325 private:
4326  explicit CleanupPadInst(Value *ParentPad, ArrayRef<Value *> Args,
4327  unsigned Values, const Twine &NameStr,
4328  Instruction *InsertBefore)
4329  : FuncletPadInst(Instruction::CleanupPad, ParentPad, Args, Values,
4330  NameStr, InsertBefore) {}
4331  explicit CleanupPadInst(Value *ParentPad, ArrayRef<Value *> Args,
4332  unsigned Values, const Twine &NameStr,
4333  BasicBlock *InsertAtEnd)
4334  : FuncletPadInst(Instruction::CleanupPad, ParentPad, Args, Values,
4335  NameStr, InsertAtEnd) {}
4336 
4337 public:
4338  static CleanupPadInst *Create(Value *ParentPad, ArrayRef<Value *> Args = None,
4339  const Twine &NameStr = "",
4340  Instruction *InsertBefore = nullptr) {
4341  unsigned Values = 1 + Args.size();
4342  return new (Values)
4343  CleanupPadInst(ParentPad, Args, Values, NameStr, InsertBefore);
4344  }
4345 
4346  static CleanupPadInst *Create(Value *ParentPad, ArrayRef<Value *> Args,
4347  const Twine &NameStr, BasicBlock *InsertAtEnd) {
4348  unsigned Values = 1 + Args.size();
4349  return new (Values)
4350  CleanupPadInst(ParentPad, Args, Values, NameStr, InsertAtEnd);
4351  }
4352 
4353  /// Methods for support type inquiry through isa, cast, and dyn_cast:
4354  static bool classof(const Instruction *I) {
4355  return I->getOpcode() == Instruction::CleanupPad;
4356  }
4357  static bool classof(const Value *V) {
4358  return isa<Instruction>(V) && classof(cast<Instruction>(V));
4359  }
4360 };
4361 
4362 //===----------------------------------------------------------------------===//
4363 // CatchPadInst Class
4364 //===----------------------------------------------------------------------===//
4366 private:
4367  explicit CatchPadInst(Value *CatchSwitch, ArrayRef<Value *> Args,
4368  unsigned Values, const Twine &NameStr,
4369  Instruction *InsertBefore)
4370  : FuncletPadInst(Instruction::CatchPad, CatchSwitch, Args, Values,
4371  NameStr, InsertBefore) {}
4372  explicit CatchPadInst(Value *CatchSwitch, ArrayRef<Value *> Args,
4373  unsigned Values, const Twine &NameStr,
4374  BasicBlock *InsertAtEnd)
4375  : FuncletPadInst(Instruction::CatchPad, CatchSwitch, Args, Values,
4376  NameStr, InsertAtEnd) {}
4377 
4378 public:
4379  static CatchPadInst *Create(Value *CatchSwitch, ArrayRef<Value *> Args,
4380  const Twine &NameStr = "",
4381  Instruction *InsertBefore = nullptr) {
4382  unsigned Values = 1 + Args.size();
4383  return new (Values)
4384  CatchPadInst(CatchSwitch, Args, Values, NameStr, InsertBefore);
4385  }
4386 
4387  static CatchPadInst *Create(Value *CatchSwitch, ArrayRef<Value *> Args,
4388  const Twine &NameStr, BasicBlock *InsertAtEnd) {
4389  unsigned Values = 1 + Args.size();
4390  return new (Values)
4391  CatchPadInst(CatchSwitch, Args, Values, NameStr, InsertAtEnd);
4392  }
4393 
4394  /// Convenience accessors
4395  CatchSwitchInst *getCatchSwitch() const {
4396  return cast<CatchSwitchInst>(Op<-1>());
4397  }
4398  void setCatchSwitch(Value *CatchSwitch) {
4399  assert(CatchSwitch);
4400  Op<-1>() = CatchSwitch;
4401  }
4402 
4403  /// Methods for support type inquiry through isa, cast, and dyn_cast:
4404  static bool classof(const Instruction *I) {
4405  return I->getOpcode() == Instruction::CatchPad;
4406  }
4407  static bool classof(const Value *V) {
4408  return isa<Instruction>(V) && classof(cast<Instruction>(V));
4409  }
4410 };
4411 
4412 //===----------------------------------------------------------------------===//
4413 // CatchReturnInst Class
4414 //===----------------------------------------------------------------------===//
4415 
4417  CatchReturnInst(const CatchReturnInst &RI);
4418  CatchReturnInst(Value *CatchPad, BasicBlock *BB, Instruction *InsertBefore);
4419  CatchReturnInst(Value *CatchPad, BasicBlock *BB, BasicBlock *InsertAtEnd);
4420 
4421  void init(Value *CatchPad, BasicBlock *BB);
4422 
4423 protected:
4424  // Note: Instruction needs to be a friend here to call cloneImpl.
4425  friend class Instruction;
4426 
4427  CatchReturnInst *cloneImpl() const;
4428 
4429 public:
4430  static CatchReturnInst *Create(Value *CatchPad, BasicBlock *BB,
4431  Instruction *InsertBefore = nullptr) {
4432  assert(CatchPad);
4433  assert(BB);
4434  return new (2) CatchReturnInst(CatchPad, BB, InsertBefore);
4435  }
4436 
4437  static CatchReturnInst *Create(Value *CatchPad, BasicBlock *BB,
4438  BasicBlock *InsertAtEnd) {
4439  assert(CatchPad);
4440  assert(BB);
4441  return new (2) CatchReturnInst(CatchPad, BB, InsertAtEnd);
4442  }
4443 
4444  /// Provide fast operand accessors
4446 
4447  /// Convenience accessors.
4448  CatchPadInst *getCatchPad() const { return cast<CatchPadInst>(Op<0>()); }
4449  void setCatchPad(CatchPadInst *CatchPad) {
4450  assert(CatchPad);
4451  Op<0>() = CatchPad;
4452  }
4453 
4454  BasicBlock *getSuccessor() const { return cast<BasicBlock>(Op<1>()); }
4455  void setSuccessor(BasicBlock *NewSucc) {
4456  assert(NewSucc);
4457  Op<1>() = NewSucc;
4458  }
4459  unsigned getNumSuccessors() const { return 1; }
4460 
4461  /// Get the parentPad of this catchret's catchpad's catchswitch.
4462  /// The successor block is implicitly a member of this funclet.
4463  Value *getCatchSwitchParentPad() const {
4464  return getCatchPad()->getCatchSwitch()->getParentPad();
4465  }
4466 
4467  // Methods for support type inquiry through isa, cast, and dyn_cast:
4468  static bool classof(const Instruction *I) {
4469  return (I->getOpcode() == Instruction::CatchRet);
4470  }
4471  static bool classof(const Value *V) {
4472  return isa<Instruction>(V) && classof(cast<Instruction>(V));
4473  }
4474 
4475 private:
4476  friend TerminatorInst;
4477 
4478  BasicBlock *getSuccessor(unsigned Idx) const {
4479  assert(Idx < getNumSuccessors() && "Successor # out of range for catchret!");
4480  return getSuccessor();
4481  }
4482 
4483  void setSuccessor(unsigned Idx, BasicBlock *B) {
4484  assert(Idx < getNumSuccessors() && "Successor # out of range for catchret!");
4485  setSuccessor(B);
4486  }
4487 };
4488 
4489 template <>
4491  : public FixedNumOperandTraits<CatchReturnInst, 2> {};
4492 
4493 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CatchReturnInst, Value)
4494 
4495 //===----------------------------------------------------------------------===//
4496 // CleanupReturnInst Class
4497 //===----------------------------------------------------------------------===//
4498 
4500 private:
4502  CleanupReturnInst(Value *CleanupPad, BasicBlock *UnwindBB, unsigned Values,
4503  Instruction *InsertBefore = nullptr);
4504  CleanupReturnInst(Value *CleanupPad, BasicBlock *UnwindBB, unsigned Values,
4505  BasicBlock *InsertAtEnd);
4506 
4507  void init(Value *CleanupPad, BasicBlock *UnwindBB);
4508 
4509 protected:
4510  // Note: Instruction needs to be a friend here to call cloneImpl.
4511  friend class Instruction;
4512 
4513  CleanupReturnInst *cloneImpl() const;
4514 
4515 public:
4516  static CleanupReturnInst *Create(Value *CleanupPad,
4517  BasicBlock *UnwindBB = nullptr,
4518  Instruction *InsertBefore = nullptr) {
4519  assert(CleanupPad);
4520  unsigned Values = 1;
4521  if (UnwindBB)
4522  ++Values;
4523  return new (Values)
4524  CleanupReturnInst(CleanupPad, UnwindBB, Values, InsertBefore);
4525  }
4526 
4527  static CleanupReturnInst *Create(Value *CleanupPad, BasicBlock *UnwindBB,
4528  BasicBlock *InsertAtEnd) {
4529  assert(CleanupPad);
4530  unsigned Values = 1;
4531  if (UnwindBB)
4532  ++Values;
4533  return new (Values)
4534  CleanupReturnInst(CleanupPad, UnwindBB, Values, InsertAtEnd);
4535  }
4536 
4537  /// Provide fast operand accessors
4539 
4540  bool hasUnwindDest() const { return getSubclassDataFromInstruction() & 1; }
4541  bool unwindsToCaller() const { return !hasUnwindDest(); }
4542 
4543  /// Convenience accessor.
4545  return cast<CleanupPadInst>(Op<0>());
4546  }
4547  void setCleanupPad(CleanupPadInst *CleanupPad) {
4548  assert(CleanupPad);
4549  Op<0>() = CleanupPad;
4550  }
4551 
4552  unsigned getNumSuccessors() const { return hasUnwindDest() ? 1 : 0; }
4553 
4555  return hasUnwindDest() ? cast<BasicBlock>(Op<1>()) : nullptr;
4556  }
4557  void setUnwindDest(BasicBlock *NewDest) {
4558  assert(NewDest);
4559  assert(hasUnwindDest());
4560  Op<1>() = NewDest;
4561  }
4562 
4563  // Methods for support type inquiry through isa, cast, and dyn_cast:
4564  static bool classof(const Instruction *I) {
4565  return (I->getOpcode() == Instruction::CleanupRet);
4566  }
4567  static bool classof(const Value *V) {
4568  return isa<Instruction>(V) && classof(cast<Instruction>(V));
4569  }
4570 
4571 private:
4572  friend TerminatorInst;
4573 
4574  BasicBlock *getSuccessor(unsigned Idx) const {
4575  assert(Idx == 0);
4576  return getUnwindDest();
4577  }
4578 
4579  void setSuccessor(unsigned Idx, BasicBlock *B) {
4580  assert(Idx == 0);
4581  setUnwindDest(B);
4582  }
4583 
4584  // Shadow Instruction::setInstructionSubclassData with a private forwarding
4585  // method so that subclasses cannot accidentally use it.
4586  void setInstructionSubclassData(unsigned short D) {
4588  }
4589 };
4590 
4591 template <>
4593  : public VariadicOperandTraits<CleanupReturnInst, /*MINARITY=*/1> {};
4594 
4595 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CleanupReturnInst, Value)
4596 
4597 //===----------------------------------------------------------------------===//
4598 // UnreachableInst Class
4599 //===----------------------------------------------------------------------===//
4600 
4601 //===---------------------------------------------------------------------------
4602 /// This function has undefined behavior. In particular, the
4603 /// presence of this instruction indicates some higher level knowledge that the
4604 /// end of the block cannot be reached.
4605 ///
4607 protected:
4608  // Note: Instruction needs to be a friend here to call cloneImpl.
4609  friend class Instruction;
4610 
4611  UnreachableInst *cloneImpl() const;
4612 
4613 public:
4614  explicit UnreachableInst(LLVMContext &C, Instruction *InsertBefore = nullptr);
4615  explicit UnreachableInst(LLVMContext &C, BasicBlock *InsertAtEnd);
4616 
4617  // allocate space for exactly zero operands
4618  void *operator new(size_t s) {
4619  return User::operator new(s, 0);
4620  }
4621 
4622  unsigned getNumSuccessors() const { return 0; }
4623 
4624  // Methods for support type inquiry through isa, cast, and dyn_cast:
4625  static bool classof(const Instruction *I) {
4626  return I->getOpcode() == Instruction::Unreachable;
4627  }
4628  static bool classof(const Value *V) {
4629  return isa<Instruction>(V) && classof(cast<Instruction>(V));
4630  }
4631 
4632 private:
4633  friend TerminatorInst;
4634 
4635  BasicBlock *getSuccessor(unsigned idx) const {
4636  llvm_unreachable("UnreachableInst has no successors!");
4637  }
4638 
4639  void setSuccessor(unsigned idx, BasicBlock *B) {
4640  llvm_unreachable("UnreachableInst has no successors!");
4641  }
4642 };
4643 
4644 //===----------------------------------------------------------------------===//
4645 // TruncInst Class
4646 //===----------------------------------------------------------------------===//
4647 
4648 /// This class represents a truncation of integer types.
4649 class TruncInst : public CastInst {
4650 protected:
4651  // Note: Instruction needs to be a friend here to call cloneImpl.
4652  friend class Instruction;
4653 
4654  /// Clone an identical TruncInst
4655  TruncInst *cloneImpl() const;
4656 
4657 public:
4658  /// Constructor with insert-before-instruction semantics
4659  TruncInst(
4660  Value *S, ///< The value to be truncated
4661  Type *Ty, ///< The (smaller) type to truncate to
4662  const Twine &NameStr = "", ///< A name for the new instruction
4663  Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
4664  );
4665 
4666  /// Constructor with insert-at-end-of-block semantics
4667  TruncInst(
4668  Value *S, ///< The value to be truncated
4669  Type *Ty, ///< The (smaller) type to truncate to
4670  const Twine &NameStr, ///< A name for the new instruction
4671  BasicBlock *InsertAtEnd ///< The block to insert the instruction into
4672  );
4673 
4674  /// Methods for support type inquiry through isa, cast, and dyn_cast:
4675  static bool classof(const Instruction *I) {
4676  return I->getOpcode() == Trunc;
4677  }
4678  static bool classof(const Value *V) {
4679  return isa<Instruction>(V) && classof(cast<Instruction>(V));
4680  }
4681 };
4682 
4683 //===----------------------------------------------------------------------===//
4684 // ZExtInst Class
4685 //===----------------------------------------------------------------------===//
4686 
4687 /// This class represents zero extension of integer types.
4688 class ZExtInst : public CastInst {
4689 protected:
4690  // Note: Instruction needs to be a friend here to call cloneImpl.
4691  friend class Instruction;
4692 
4693  /// Clone an identical ZExtInst
4694  ZExtInst *cloneImpl() const;
4695 
4696 public:
4697  /// Constructor with insert-before-instruction semantics
4698  ZExtInst(
4699  Value *S, ///< The value to be zero extended
4700  Type *Ty, ///< The type to zero extend to
4701  const Twine &NameStr = "", ///< A name for the new instruction
4702  Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
4703  );
4704 
4705  /// Constructor with insert-at-end semantics.
4706  ZExtInst(
4707  Value *S, ///< The value to be zero extended
4708  Type *Ty, ///< The type to zero extend to
4709  const Twine &NameStr, ///< A name for the new instruction
4710  BasicBlock *InsertAtEnd ///< The block to insert the instruction into
4711  );
4712 
4713  /// Methods for support type inquiry through isa, cast, and dyn_cast:
4714  static bool classof(const Instruction *I) {
4715  return I->getOpcode() == ZExt;
4716  }
4717  static bool classof(const Value *V) {
4718  return isa<Instruction>(V) && classof(cast<Instruction>(V));
4719  }
4720 };
4721 
4722 //===----------------------------------------------------------------------===//
4723 // SExtInst Class
4724 //===----------------------------------------------------------------------===//
4725 
4726 /// This class represents a sign extension of integer types.
4727 class SExtInst : public CastInst {
4728 protected:
4729  // Note: Instruction needs to be a friend here to call cloneImpl.
4730  friend class Instruction;
4731 
4732  /// Clone an identical SExtInst
4733  SExtInst *cloneImpl() const;
4734 
4735 public:
4736  /// Constructor with insert-before-instruction semantics
4737  SExtInst(
4738  Value *S, ///< The value to be sign extended
4739  Type *Ty, ///< The type to sign extend to
4740  const Twine &NameStr = "", ///< A name for the new instruction
4741  Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
4742  );
4743 
4744  /// Constructor with insert-at-end-of-block semantics
4745  SExtInst(
4746  Value *S, ///< The value to be sign extended
4747  Type *Ty, ///< The type to sign extend to
4748  const Twine &NameStr, ///< A name for the new instruction
4749  BasicBlock *InsertAtEnd ///< The block to insert the instruction into
4750  );
4751 
4752  /// Methods for support type inquiry through isa, cast, and dyn_cast:
4753  static bool classof(const Instruction *I) {
4754  return I->getOpcode() == SExt;
4755  }
4756  static bool classof(const Value *V) {
4757  return isa<Instruction>(V) && classof(cast<Instruction>(V));
4758  }
4759 };
4760 
4761 //===----------------------------------------------------------------------===//
4762 // FPTruncInst Class
4763 //===----------------------------------------------------------------------===//
4764 
4765 /// This class represents a truncation of floating point types.
4766 class FPTruncInst : public CastInst {
4767 protected:
4768  // Note: Instruction needs to be a friend here to call cloneImpl.
4769  friend class Instruction;
4770 
4771  /// Clone an identical FPTruncInst
4772  FPTruncInst *cloneImpl() const;
4773 
4774 public:
4775  /// Constructor with insert-before-instruction semantics
4776  FPTruncInst(
4777  Value *S, ///< The value to be truncated
4778  Type *Ty, ///< The type to truncate to
4779  const Twine &NameStr = "", ///< A name for the new instruction
4780  Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
4781  );
4782 
4783  /// Constructor with insert-before-instruction semantics
4784  FPTruncInst(
4785  Value *S, ///< The value to be truncated
4786  Type *Ty, ///< The type to truncate to
4787  const Twine &NameStr, ///< A name for the new instruction
4788  BasicBlock *InsertAtEnd ///< The block to insert the instruction into
4789  );
4790 
4791  /// Methods for support type inquiry through isa, cast, and dyn_cast:
4792  static bool classof(const Instruction *I) {
4793  return I->getOpcode() == FPTrunc;
4794  }
4795  static bool classof(const Value *V) {
4796  return isa<Instruction>(V) && classof(cast<Instruction>(V));
4797  }
4798 };
4799 
4800 //===----------------------------------------------------------------------===//
4801 // FPExtInst Class
4802 //===----------------------------------------------------------------------===//
4803 
4804 /// This class represents an extension of floating point types.
4805 class FPExtInst : public CastInst {
4806 protected:
4807  // Note: Instruction needs to be a friend here to call cloneImpl.
4808  friend class Instruction;
4809 
4810  /// Clone an identical FPExtInst
4811  FPExtInst *cloneImpl() const;
4812 
4813 public:
4814  /// Constructor with insert-before-instruction semantics
4815  FPExtInst(
4816  Value *S, ///< The value to be extended
4817  Type *Ty, ///< The type to extend to
4818  const Twine &NameStr = "", ///< A name for the new instruction
4819  Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
4820  );
4821 
4822  /// Constructor with insert-at-end-of-block semantics
4823  FPExtInst(
4824  Value *S, ///< The value to be extended
4825  Type *Ty, ///< The type to extend to
4826  const Twine &NameStr, ///< A name for the new instruction
4827  BasicBlock *InsertAtEnd ///< The block to insert the instruction into
4828  );
4829 
4830  /// Methods for support type inquiry through isa, cast, and dyn_cast:
4831  static bool classof(const Instruction *I) {
4832  return I->getOpcode() == FPExt;
4833  }
4834  static bool classof(const Value *V) {
4835  return isa<Instruction>(V) && classof(cast<Instruction>(V));
4836  }
4837 };
4838 
4839 //===----------------------------------------------------------------------===//
4840 // UIToFPInst Class
4841 //===----------------------------------------------------------------------===//
4842 
4843 /// This class represents a cast unsigned integer to floating point.
4844 class UIToFPInst : public CastInst {
4845 protected:
4846  // Note: Instruction needs to be a friend here to call cloneImpl.
4847  friend class Instruction;
4848 
4849  /// Clone an identical UIToFPInst
4850  UIToFPInst *cloneImpl() const;
4851 
4852 public:
4853  /// Constructor with insert-before-instruction semantics
4854  UIToFPInst(
4855  Value *S, ///< The value to be converted
4856  Type *Ty, ///< The type to convert to
4857  const Twine &NameStr = "", ///< A name for the new instruction
4858  Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
4859  );
4860 
4861  /// Constructor with insert-at-end-of-block semantics
4862  UIToFPInst(
4863  Value *S, ///< The value to be converted
4864  Type *Ty, ///< The type to convert to
4865  const Twine &NameStr, ///< A name for the new instruction
4866  BasicBlock *InsertAtEnd ///< The block to insert the instruction into
4867  );
4868 
4869  /// Methods for support type inquiry through isa, cast, and dyn_cast:
4870  static bool classof(const Instruction *I) {
4871  return I->getOpcode() == UIToFP;
4872  }
4873  static bool classof(const Value *V) {
4874  return isa<Instruction>(V) && classof(cast<Instruction>(V));
4875  }
4876 };
4877 
4878 //===----------------------------------------------------------------------===//
4879 // SIToFPInst Class
4880 //===----------------------------------------------------------------------===//
4881 
4882 /// This class represents a cast from signed integer to floating point.
4883 class SIToFPInst : public CastInst {
4884 protected:
4885  // Note: Instruction needs to be a friend here to call cloneImpl.
4886  friend class Instruction;
4887 
4888  /// Clone an identical SIToFPInst
4889  SIToFPInst *cloneImpl() const;
4890 
4891 public:
4892  /// Constructor with insert-before-instruction semantics
4893  SIToFPInst(
4894  Value *S, ///< The value to be converted
4895  Type *Ty, ///< The type to convert to
4896  const Twine &NameStr = "", ///< A name for the new instruction
4897  Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
4898  );
4899 
4900  /// Constructor with insert-at-end-of-block semantics
4901  SIToFPInst(
4902  Value *S, ///< The value to be converted
4903  Type *Ty, ///< The type to convert to
4904  const Twine &NameStr, ///< A name for the new instruction
4905  BasicBlock *InsertAtEnd ///< The block to insert the instruction into
4906  );
4907 
4908  /// Methods for support type inquiry through isa, cast, and dyn_cast:
4909  static bool classof(const Instruction *I) {
4910  return I->getOpcode() == SIToFP;
4911  }
4912  static bool classof(const Value *V) {
4913  return isa<Instruction>(V) && classof(cast<Instruction>(V));
4914  }
4915 };
4916 
4917 //===----------------------------------------------------------------------===//
4918 // FPToUIInst Class
4919 //===----------------------------------------------------------------------===//
4920 
4921 /// This class represents a cast from floating point to unsigned integer
4922 class FPToUIInst : public CastInst {
4923 protected:
4924  // Note: Instruction needs to be a friend here to call cloneImpl.
4925  friend class Instruction;
4926 
4927  /// Clone an identical FPToUIInst
4928  FPToUIInst *cloneImpl() const;
4929 
4930 public:
4931  /// Constructor with insert-before-instruction semantics
4932  FPToUIInst(
4933  Value *S, ///< The value to be converted
4934  Type *Ty, ///< The type to convert to
4935  const Twine &NameStr = "", ///< A name for the new instruction
4936  Instruction *InsertBefore = nullptr ///< Where to insert the new instruction
4937  );
4938 
4939  /// Constructor with insert-at-end-of-block semantics
4940  FPToUIInst(
4941  Value *S, ///< The value to be converted
4942  Type *Ty, ///< The type to convert to
4943  const Twine &NameStr, ///< A name for the new instruction
4944  BasicB