LLVM 17.0.0git
Instructions.h
Go to the documentation of this file.
1//===- llvm/Instructions.h - Instruction subclass definitions ---*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file exposes the class definitions of all of the subclasses of the
10// Instruction class. This is meant to be an easy way to get access to all
11// instruction subclasses.
12//
13//===----------------------------------------------------------------------===//
14
15#ifndef LLVM_IR_INSTRUCTIONS_H
16#define LLVM_IR_INSTRUCTIONS_H
17
18#include "llvm/ADT/ArrayRef.h"
19#include "llvm/ADT/Bitfields.h"
20#include "llvm/ADT/MapVector.h"
21#include "llvm/ADT/STLExtras.h"
23#include "llvm/ADT/Twine.h"
24#include "llvm/ADT/iterator.h"
26#include "llvm/IR/CFG.h"
27#include "llvm/IR/Constant.h"
29#include "llvm/IR/InstrTypes.h"
30#include "llvm/IR/Instruction.h"
32#include "llvm/IR/Use.h"
33#include "llvm/IR/User.h"
36#include <cassert>
37#include <cstddef>
38#include <cstdint>
39#include <iterator>
40#include <optional>
41
42namespace llvm {
43
44class APFloat;
45class APInt;
46class BasicBlock;
47class ConstantInt;
48class DataLayout;
49class StringRef;
50class Type;
51class Value;
52
53//===----------------------------------------------------------------------===//
54// AllocaInst Class
55//===----------------------------------------------------------------------===//
56
57/// an instruction to allocate memory on the stack
59 Type *AllocatedType;
60
61 using AlignmentField = AlignmentBitfieldElementT<0>;
62 using UsedWithInAllocaField = BoolBitfieldElementT<AlignmentField::NextBit>;
64 static_assert(Bitfield::areContiguous<AlignmentField, UsedWithInAllocaField,
65 SwiftErrorField>(),
66 "Bitfields must be contiguous");
67
68protected:
69 // Note: Instruction needs to be a friend here to call cloneImpl.
70 friend class Instruction;
71
72 AllocaInst *cloneImpl() const;
73
74public:
75 explicit AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize,
76 const Twine &Name, Instruction *InsertBefore);
77 AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize,
78 const Twine &Name, BasicBlock *InsertAtEnd);
79
80 AllocaInst(Type *Ty, unsigned AddrSpace, const Twine &Name,
81 Instruction *InsertBefore);
82 AllocaInst(Type *Ty, unsigned AddrSpace,
83 const Twine &Name, BasicBlock *InsertAtEnd);
84
85 AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize, Align Align,
86 const Twine &Name = "", Instruction *InsertBefore = nullptr);
87 AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize, Align Align,
88 const Twine &Name, BasicBlock *InsertAtEnd);
89
90 /// Return true if there is an allocation size parameter to the allocation
91 /// instruction that is not 1.
92 bool isArrayAllocation() const;
93
94 /// Get the number of elements allocated. For a simple allocation of a single
95 /// element, this will return a constant 1 value.
96 const Value *getArraySize() const { return getOperand(0); }
97 Value *getArraySize() { return getOperand(0); }
98
99 /// Overload to return most specific pointer type.
101 return cast<PointerType>(Instruction::getType());
102 }
103
104 /// Return the address space for the allocation.
105 unsigned getAddressSpace() const {
106 return getType()->getAddressSpace();
107 }
108
109 /// Get allocation size in bytes. Returns std::nullopt if size can't be
110 /// determined, e.g. in case of a VLA.
111 std::optional<TypeSize> getAllocationSize(const DataLayout &DL) const;
112
113 /// Get allocation size in bits. Returns std::nullopt if size can't be
114 /// determined, e.g. in case of a VLA.
115 std::optional<TypeSize> getAllocationSizeInBits(const DataLayout &DL) const;
116
117 /// Return the type that is being allocated by the instruction.
118 Type *getAllocatedType() const { return AllocatedType; }
119 /// for use only in special circumstances that need to generically
120 /// transform a whole instruction (eg: IR linking and vectorization).
121 void setAllocatedType(Type *Ty) { AllocatedType = Ty; }
122
123 /// Return the alignment of the memory that is being allocated by the
124 /// instruction.
125 Align getAlign() const {
126 return Align(1ULL << getSubclassData<AlignmentField>());
127 }
128
130 setSubclassData<AlignmentField>(Log2(Align));
131 }
132
133 /// Return true if this alloca is in the entry block of the function and is a
134 /// constant size. If so, the code generator will fold it into the
135 /// prolog/epilog code, so it is basically free.
136 bool isStaticAlloca() const;
137
138 /// Return true if this alloca is used as an inalloca argument to a call. Such
139 /// allocas are never considered static even if they are in the entry block.
140 bool isUsedWithInAlloca() const {
141 return getSubclassData<UsedWithInAllocaField>();
142 }
143
144 /// Specify whether this alloca is used to represent the arguments to a call.
145 void setUsedWithInAlloca(bool V) {
146 setSubclassData<UsedWithInAllocaField>(V);
147 }
148
149 /// Return true if this alloca is used as a swifterror argument to a call.
150 bool isSwiftError() const { return getSubclassData<SwiftErrorField>(); }
151 /// Specify whether this alloca is used to represent a swifterror.
152 void setSwiftError(bool V) { setSubclassData<SwiftErrorField>(V); }
153
154 // Methods for support type inquiry through isa, cast, and dyn_cast:
155 static bool classof(const Instruction *I) {
156 return (I->getOpcode() == Instruction::Alloca);
157 }
158 static bool classof(const Value *V) {
159 return isa<Instruction>(V) && classof(cast<Instruction>(V));
160 }
161
162private:
163 // Shadow Instruction::setInstructionSubclassData with a private forwarding
164 // method so that subclasses cannot accidentally use it.
165 template <typename Bitfield>
166 void setSubclassData(typename Bitfield::Type Value) {
167 Instruction::setSubclassData<Bitfield>(Value);
168 }
169};
170
171//===----------------------------------------------------------------------===//
172// LoadInst Class
173//===----------------------------------------------------------------------===//
174
175/// An instruction for reading from memory. This uses the SubclassData field in
176/// Value to store whether or not the load is volatile.
178 using VolatileField = BoolBitfieldElementT<0>;
181 static_assert(
182 Bitfield::areContiguous<VolatileField, AlignmentField, OrderingField>(),
183 "Bitfields must be contiguous");
184
185 void AssertOK();
186
187protected:
188 // Note: Instruction needs to be a friend here to call cloneImpl.
189 friend class Instruction;
190
191 LoadInst *cloneImpl() const;
192
193public:
194 LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr,
195 Instruction *InsertBefore);
196 LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, BasicBlock *InsertAtEnd);
197 LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
198 Instruction *InsertBefore);
199 LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
200 BasicBlock *InsertAtEnd);
201 LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
202 Align Align, Instruction *InsertBefore = nullptr);
203 LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
204 Align Align, BasicBlock *InsertAtEnd);
205 LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
208 Instruction *InsertBefore = nullptr);
209 LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
211 BasicBlock *InsertAtEnd);
212
213 /// Return true if this is a load from a volatile memory location.
214 bool isVolatile() const { return getSubclassData<VolatileField>(); }
215
216 /// Specify whether this is a volatile load or not.
217 void setVolatile(bool V) { setSubclassData<VolatileField>(V); }
218
219 /// Return the alignment of the access that is being performed.
220 Align getAlign() const {
221 return Align(1ULL << (getSubclassData<AlignmentField>()));
222 }
223
225 setSubclassData<AlignmentField>(Log2(Align));
226 }
227
228 /// Returns the ordering constraint of this load instruction.
230 return getSubclassData<OrderingField>();
231 }
232 /// Sets the ordering constraint of this load instruction. May not be Release
233 /// or AcquireRelease.
235 setSubclassData<OrderingField>(Ordering);
236 }
237
238 /// Returns the synchronization scope ID of this load instruction.
240 return SSID;
241 }
242
243 /// Sets the synchronization scope ID of this load instruction.
245 this->SSID = SSID;
246 }
247
248 /// Sets the ordering constraint and the synchronization scope ID of this load
249 /// instruction.
252 setOrdering(Ordering);
253 setSyncScopeID(SSID);
254 }
255
256 bool isSimple() const { return !isAtomic() && !isVolatile(); }
257
258 bool isUnordered() const {
261 !isVolatile();
262 }
263
265 const Value *getPointerOperand() const { return getOperand(0); }
266 static unsigned getPointerOperandIndex() { return 0U; }
268
269 /// Returns the address space of the pointer operand.
270 unsigned getPointerAddressSpace() const {
272 }
273
274 // Methods for support type inquiry through isa, cast, and dyn_cast:
275 static bool classof(const Instruction *I) {
276 return I->getOpcode() == Instruction::Load;
277 }
278 static bool classof(const Value *V) {
279 return isa<Instruction>(V) && classof(cast<Instruction>(V));
280 }
281
282private:
283 // Shadow Instruction::setInstructionSubclassData with a private forwarding
284 // method so that subclasses cannot accidentally use it.
285 template <typename Bitfield>
286 void setSubclassData(typename Bitfield::Type Value) {
287 Instruction::setSubclassData<Bitfield>(Value);
288 }
289
290 /// The synchronization scope ID of this load instruction. Not quite enough
291 /// room in SubClassData for everything, so synchronization scope ID gets its
292 /// own field.
293 SyncScope::ID SSID;
294};
295
296//===----------------------------------------------------------------------===//
297// StoreInst Class
298//===----------------------------------------------------------------------===//
299
300/// An instruction for storing to memory.
301class StoreInst : public Instruction {
302 using VolatileField = BoolBitfieldElementT<0>;
305 static_assert(
306 Bitfield::areContiguous<VolatileField, AlignmentField, OrderingField>(),
307 "Bitfields must be contiguous");
308
309 void AssertOK();
310
311protected:
312 // Note: Instruction needs to be a friend here to call cloneImpl.
313 friend class Instruction;
314
315 StoreInst *cloneImpl() const;
316
317public:
318 StoreInst(Value *Val, Value *Ptr, Instruction *InsertBefore);
319 StoreInst(Value *Val, Value *Ptr, BasicBlock *InsertAtEnd);
320 StoreInst(Value *Val, Value *Ptr, bool isVolatile, Instruction *InsertBefore);
321 StoreInst(Value *Val, Value *Ptr, bool isVolatile, BasicBlock *InsertAtEnd);
323 Instruction *InsertBefore = nullptr);
325 BasicBlock *InsertAtEnd);
328 Instruction *InsertBefore = nullptr);
330 AtomicOrdering Order, SyncScope::ID SSID, BasicBlock *InsertAtEnd);
331
332 // allocate space for exactly two operands
333 void *operator new(size_t S) { return User::operator new(S, 2); }
334 void operator delete(void *Ptr) { User::operator delete(Ptr); }
335
336 /// Return true if this is a store to a volatile memory location.
337 bool isVolatile() const { return getSubclassData<VolatileField>(); }
338
339 /// Specify whether this is a volatile store or not.
340 void setVolatile(bool V) { setSubclassData<VolatileField>(V); }
341
342 /// Transparently provide more efficient getOperand methods.
344
345 Align getAlign() const {
346 return Align(1ULL << (getSubclassData<AlignmentField>()));
347 }
348
350 setSubclassData<AlignmentField>(Log2(Align));
351 }
352
353 /// Returns the ordering constraint of this store instruction.
355 return getSubclassData<OrderingField>();
356 }
357
358 /// Sets the ordering constraint of this store instruction. May not be
359 /// Acquire or AcquireRelease.
361 setSubclassData<OrderingField>(Ordering);
362 }
363
364 /// Returns the synchronization scope ID of this store instruction.
366 return SSID;
367 }
368
369 /// Sets the synchronization scope ID of this store instruction.
371 this->SSID = SSID;
372 }
373
374 /// Sets the ordering constraint and the synchronization scope ID of this
375 /// store instruction.
378 setOrdering(Ordering);
379 setSyncScopeID(SSID);
380 }
381
382 bool isSimple() const { return !isAtomic() && !isVolatile(); }
383
384 bool isUnordered() const {
387 !isVolatile();
388 }
389
391 const Value *getValueOperand() const { return getOperand(0); }
392
394 const Value *getPointerOperand() const { return getOperand(1); }
395 static unsigned getPointerOperandIndex() { return 1U; }
397
398 /// Returns the address space of the pointer operand.
399 unsigned getPointerAddressSpace() const {
401 }
402
403 // Methods for support type inquiry through isa, cast, and dyn_cast:
404 static bool classof(const Instruction *I) {
405 return I->getOpcode() == Instruction::Store;
406 }
407 static bool classof(const Value *V) {
408 return isa<Instruction>(V) && classof(cast<Instruction>(V));
409 }
410
411private:
412 // Shadow Instruction::setInstructionSubclassData with a private forwarding
413 // method so that subclasses cannot accidentally use it.
414 template <typename Bitfield>
415 void setSubclassData(typename Bitfield::Type Value) {
416 Instruction::setSubclassData<Bitfield>(Value);
417 }
418
419 /// The synchronization scope ID of this store instruction. Not quite enough
420 /// room in SubClassData for everything, so synchronization scope ID gets its
421 /// own field.
422 SyncScope::ID SSID;
423};
424
425template <>
426struct OperandTraits<StoreInst> : public FixedNumOperandTraits<StoreInst, 2> {
427};
428
430
431//===----------------------------------------------------------------------===//
432// FenceInst Class
433//===----------------------------------------------------------------------===//
434
435/// An instruction for ordering other memory operations.
436class FenceInst : public Instruction {
437 using OrderingField = AtomicOrderingBitfieldElementT<0>;
438
439 void Init(AtomicOrdering Ordering, SyncScope::ID SSID);
440
441protected:
442 // Note: Instruction needs to be a friend here to call cloneImpl.
443 friend class Instruction;
444
445 FenceInst *cloneImpl() const;
446
447public:
448 // Ordering may only be Acquire, Release, AcquireRelease, or
449 // SequentiallyConsistent.
452 Instruction *InsertBefore = nullptr);
454 BasicBlock *InsertAtEnd);
455
456 // allocate space for exactly zero operands
457 void *operator new(size_t S) { return User::operator new(S, 0); }
458 void operator delete(void *Ptr) { User::operator delete(Ptr); }
459
460 /// Returns the ordering constraint of this fence instruction.
462 return getSubclassData<OrderingField>();
463 }
464
465 /// Sets the ordering constraint of this fence instruction. May only be
466 /// Acquire, Release, AcquireRelease, or SequentiallyConsistent.
468 setSubclassData<OrderingField>(Ordering);
469 }
470
471 /// Returns the synchronization scope ID of this fence instruction.
473 return SSID;
474 }
475
476 /// Sets the synchronization scope ID of this fence instruction.
478 this->SSID = SSID;
479 }
480
481 // Methods for support type inquiry through isa, cast, and dyn_cast:
482 static bool classof(const Instruction *I) {
483 return I->getOpcode() == Instruction::Fence;
484 }
485 static bool classof(const Value *V) {
486 return isa<Instruction>(V) && classof(cast<Instruction>(V));
487 }
488
489private:
490 // Shadow Instruction::setInstructionSubclassData with a private forwarding
491 // method so that subclasses cannot accidentally use it.
492 template <typename Bitfield>
493 void setSubclassData(typename Bitfield::Type Value) {
494 Instruction::setSubclassData<Bitfield>(Value);
495 }
496
497 /// The synchronization scope ID of this fence instruction. Not quite enough
498 /// room in SubClassData for everything, so synchronization scope ID gets its
499 /// own field.
500 SyncScope::ID SSID;
501};
502
503//===----------------------------------------------------------------------===//
504// AtomicCmpXchgInst Class
505//===----------------------------------------------------------------------===//
506
507/// An instruction that atomically checks whether a
508/// specified value is in a memory location, and, if it is, stores a new value
509/// there. The value returned by this instruction is a pair containing the
510/// original value as first element, and an i1 indicating success (true) or
511/// failure (false) as second element.
512///
514 void Init(Value *Ptr, Value *Cmp, Value *NewVal, Align Align,
515 AtomicOrdering SuccessOrdering, AtomicOrdering FailureOrdering,
516 SyncScope::ID SSID);
517
518 template <unsigned Offset>
519 using AtomicOrderingBitfieldElement =
522
523protected:
524 // Note: Instruction needs to be a friend here to call cloneImpl.
525 friend class Instruction;
526
528
529public:
530 AtomicCmpXchgInst(Value *Ptr, Value *Cmp, Value *NewVal, Align Alignment,
531 AtomicOrdering SuccessOrdering,
532 AtomicOrdering FailureOrdering, SyncScope::ID SSID,
533 Instruction *InsertBefore = nullptr);
534 AtomicCmpXchgInst(Value *Ptr, Value *Cmp, Value *NewVal, Align Alignment,
535 AtomicOrdering SuccessOrdering,
536 AtomicOrdering FailureOrdering, SyncScope::ID SSID,
537 BasicBlock *InsertAtEnd);
538
539 // allocate space for exactly three operands
540 void *operator new(size_t S) { return User::operator new(S, 3); }
541 void operator delete(void *Ptr) { User::operator delete(Ptr); }
542
551 static_assert(
554 "Bitfields must be contiguous");
555
556 /// Return the alignment of the memory that is being allocated by the
557 /// instruction.
558 Align getAlign() const {
559 return Align(1ULL << getSubclassData<AlignmentField>());
560 }
561
563 setSubclassData<AlignmentField>(Log2(Align));
564 }
565
566 /// Return true if this is a cmpxchg from a volatile memory
567 /// location.
568 ///
569 bool isVolatile() const { return getSubclassData<VolatileField>(); }
570
571 /// Specify whether this is a volatile cmpxchg.
572 ///
573 void setVolatile(bool V) { setSubclassData<VolatileField>(V); }
574
575 /// Return true if this cmpxchg may spuriously fail.
576 bool isWeak() const { return getSubclassData<WeakField>(); }
577
578 void setWeak(bool IsWeak) { setSubclassData<WeakField>(IsWeak); }
579
580 /// Transparently provide more efficient getOperand methods.
582
584 return Ordering != AtomicOrdering::NotAtomic &&
585 Ordering != AtomicOrdering::Unordered;
586 }
587
589 return Ordering != AtomicOrdering::NotAtomic &&
590 Ordering != AtomicOrdering::Unordered &&
591 Ordering != AtomicOrdering::AcquireRelease &&
592 Ordering != AtomicOrdering::Release;
593 }
594
595 /// Returns the success ordering constraint of this cmpxchg instruction.
597 return getSubclassData<SuccessOrderingField>();
598 }
599
600 /// Sets the success ordering constraint of this cmpxchg instruction.
602 assert(isValidSuccessOrdering(Ordering) &&
603 "invalid CmpXchg success ordering");
604 setSubclassData<SuccessOrderingField>(Ordering);
605 }
606
607 /// Returns the failure ordering constraint of this cmpxchg instruction.
609 return getSubclassData<FailureOrderingField>();
610 }
611
612 /// Sets the failure ordering constraint of this cmpxchg instruction.
614 assert(isValidFailureOrdering(Ordering) &&
615 "invalid CmpXchg failure ordering");
616 setSubclassData<FailureOrderingField>(Ordering);
617 }
618
619 /// Returns a single ordering which is at least as strong as both the
620 /// success and failure orderings for this cmpxchg.
629 }
630 return getSuccessOrdering();
631 }
632
633 /// Returns the synchronization scope ID of this cmpxchg instruction.
635 return SSID;
636 }
637
638 /// Sets the synchronization scope ID of this cmpxchg instruction.
640 this->SSID = SSID;
641 }
642
644 const Value *getPointerOperand() const { return getOperand(0); }
645 static unsigned getPointerOperandIndex() { return 0U; }
646
648 const Value *getCompareOperand() const { return getOperand(1); }
649
651 const Value *getNewValOperand() const { return getOperand(2); }
652
653 /// Returns the address space of the pointer operand.
654 unsigned getPointerAddressSpace() const {
656 }
657
658 /// Returns the strongest permitted ordering on failure, given the
659 /// desired ordering on success.
660 ///
661 /// If the comparison in a cmpxchg operation fails, there is no atomic store
662 /// so release semantics cannot be provided. So this function drops explicit
663 /// Release requests from the AtomicOrdering. A SequentiallyConsistent
664 /// operation would remain SequentiallyConsistent.
665 static AtomicOrdering
667 switch (SuccessOrdering) {
668 default:
669 llvm_unreachable("invalid cmpxchg success ordering");
678 }
679 }
680
681 // Methods for support type inquiry through isa, cast, and dyn_cast:
682 static bool classof(const Instruction *I) {
683 return I->getOpcode() == Instruction::AtomicCmpXchg;
684 }
685 static bool classof(const Value *V) {
686 return isa<Instruction>(V) && classof(cast<Instruction>(V));
687 }
688
689private:
690 // Shadow Instruction::setInstructionSubclassData with a private forwarding
691 // method so that subclasses cannot accidentally use it.
692 template <typename Bitfield>
693 void setSubclassData(typename Bitfield::Type Value) {
694 Instruction::setSubclassData<Bitfield>(Value);
695 }
696
697 /// The synchronization scope ID of this cmpxchg instruction. Not quite
698 /// enough room in SubClassData for everything, so synchronization scope ID
699 /// gets its own field.
700 SyncScope::ID SSID;
701};
702
703template <>
705 public FixedNumOperandTraits<AtomicCmpXchgInst, 3> {
706};
707
709
710//===----------------------------------------------------------------------===//
711// AtomicRMWInst Class
712//===----------------------------------------------------------------------===//
713
714/// an instruction that atomically reads a memory location,
715/// combines it with another value, and then stores the result back. Returns
716/// the old value.
717///
719protected:
720 // Note: Instruction needs to be a friend here to call cloneImpl.
721 friend class Instruction;
722
723 AtomicRMWInst *cloneImpl() const;
724
725public:
726 /// This enumeration lists the possible modifications atomicrmw can make. In
727 /// the descriptions, 'p' is the pointer to the instruction's memory location,
728 /// 'old' is the initial value of *p, and 'v' is the other value passed to the
729 /// instruction. These instructions always return 'old'.
730 enum BinOp : unsigned {
731 /// *p = v
733 /// *p = old + v
735 /// *p = old - v
737 /// *p = old & v
739 /// *p = ~(old & v)
741 /// *p = old | v
743 /// *p = old ^ v
745 /// *p = old >signed v ? old : v
747 /// *p = old <signed v ? old : v
749 /// *p = old >unsigned v ? old : v
751 /// *p = old <unsigned v ? old : v
753
754 /// *p = old + v
756
757 /// *p = old - v
759
760 /// *p = maxnum(old, v)
761 /// \p maxnum matches the behavior of \p llvm.maxnum.*.
763
764 /// *p = minnum(old, v)
765 /// \p minnum matches the behavior of \p llvm.minnum.*.
767
768 /// Increment one up to a maximum value.
769 /// *p = (old u>= v) ? 0 : (old + 1)
771
772 /// Decrement one until a minimum value or zero.
773 /// *p = ((old == 0) || (old u> v)) ? v : (old - 1)
775
776 FIRST_BINOP = Xchg,
777 LAST_BINOP = UDecWrap,
778 BAD_BINOP
779 };
780
781private:
782 template <unsigned Offset>
783 using AtomicOrderingBitfieldElement =
786
787 template <unsigned Offset>
788 using BinOpBitfieldElement =
790
791public:
792 AtomicRMWInst(BinOp Operation, Value *Ptr, Value *Val, Align Alignment,
793 AtomicOrdering Ordering, SyncScope::ID SSID,
794 Instruction *InsertBefore = nullptr);
795 AtomicRMWInst(BinOp Operation, Value *Ptr, Value *Val, Align Alignment,
796 AtomicOrdering Ordering, SyncScope::ID SSID,
797 BasicBlock *InsertAtEnd);
798
799 // allocate space for exactly two operands
800 void *operator new(size_t S) { return User::operator new(S, 2); }
801 void operator delete(void *Ptr) { User::operator delete(Ptr); }
802
806 using OperationField = BinOpBitfieldElement<AtomicOrderingField::NextBit>;
810 "Bitfields must be contiguous");
811
812 BinOp getOperation() const { return getSubclassData<OperationField>(); }
813
814 static StringRef getOperationName(BinOp Op);
815
816 static bool isFPOperation(BinOp Op) {
817 switch (Op) {
822 return true;
823 default:
824 return false;
825 }
826 }
827
829 setSubclassData<OperationField>(Operation);
830 }
831
832 /// Return the alignment of the memory that is being allocated by the
833 /// instruction.
834 Align getAlign() const {
835 return Align(1ULL << getSubclassData<AlignmentField>());
836 }
837
839 setSubclassData<AlignmentField>(Log2(Align));
840 }
841
842 /// Return true if this is a RMW on a volatile memory location.
843 ///
844 bool isVolatile() const { return getSubclassData<VolatileField>(); }
845
846 /// Specify whether this is a volatile RMW or not.
847 ///
848 void setVolatile(bool V) { setSubclassData<VolatileField>(V); }
849
850 /// Transparently provide more efficient getOperand methods.
852
853 /// Returns the ordering constraint of this rmw instruction.
855 return getSubclassData<AtomicOrderingField>();
856 }
857
858 /// Sets the ordering constraint of this rmw instruction.
860 assert(Ordering != AtomicOrdering::NotAtomic &&
861 "atomicrmw instructions can only be atomic.");
862 assert(Ordering != AtomicOrdering::Unordered &&
863 "atomicrmw instructions cannot be unordered.");
864 setSubclassData<AtomicOrderingField>(Ordering);
865 }
866
867 /// Returns the synchronization scope ID of this rmw instruction.
869 return SSID;
870 }
871
872 /// Sets the synchronization scope ID of this rmw instruction.
874 this->SSID = SSID;
875 }
876
877 Value *getPointerOperand() { return getOperand(0); }
878 const Value *getPointerOperand() const { return getOperand(0); }
879 static unsigned getPointerOperandIndex() { return 0U; }
880
881 Value *getValOperand() { return getOperand(1); }
882 const Value *getValOperand() const { return getOperand(1); }
883
884 /// Returns the address space of the pointer operand.
885 unsigned getPointerAddressSpace() const {
887 }
888
890 return isFPOperation(getOperation());
891 }
892
893 // Methods for support type inquiry through isa, cast, and dyn_cast:
894 static bool classof(const Instruction *I) {
895 return I->getOpcode() == Instruction::AtomicRMW;
896 }
897 static bool classof(const Value *V) {
898 return isa<Instruction>(V) && classof(cast<Instruction>(V));
899 }
900
901private:
902 void Init(BinOp Operation, Value *Ptr, Value *Val, Align Align,
903 AtomicOrdering Ordering, SyncScope::ID SSID);
904
905 // Shadow Instruction::setInstructionSubclassData with a private forwarding
906 // method so that subclasses cannot accidentally use it.
907 template <typename Bitfield>
908 void setSubclassData(typename Bitfield::Type Value) {
909 Instruction::setSubclassData<Bitfield>(Value);
910 }
911
912 /// The synchronization scope ID of this rmw instruction. Not quite enough
913 /// room in SubClassData for everything, so synchronization scope ID gets its
914 /// own field.
915 SyncScope::ID SSID;
916};
917
918template <>
920 : public FixedNumOperandTraits<AtomicRMWInst,2> {
921};
922
924
925//===----------------------------------------------------------------------===//
926// GetElementPtrInst Class
927//===----------------------------------------------------------------------===//
928
929// checkGEPType - Simple wrapper function to give a better assertion failure
930// message on bad indexes for a gep instruction.
931//
933 assert(Ty && "Invalid GetElementPtrInst indices for type!");
934 return Ty;
935}
936
937/// an instruction for type-safe pointer arithmetic to
938/// access elements of arrays and structs
939///
941 Type *SourceElementType;
942 Type *ResultElementType;
943
945
946 /// Constructors - Create a getelementptr instruction with a base pointer an
947 /// list of indices. The first ctor can optionally insert before an existing
948 /// instruction, the second appends the new instruction to the specified
949 /// BasicBlock.
950 inline GetElementPtrInst(Type *PointeeType, Value *Ptr,
951 ArrayRef<Value *> IdxList, unsigned Values,
952 const Twine &NameStr, Instruction *InsertBefore);
953 inline GetElementPtrInst(Type *PointeeType, Value *Ptr,
954 ArrayRef<Value *> IdxList, unsigned Values,
955 const Twine &NameStr, BasicBlock *InsertAtEnd);
956
957 void init(Value *Ptr, ArrayRef<Value *> IdxList, const Twine &NameStr);
958
959protected:
960 // Note: Instruction needs to be a friend here to call cloneImpl.
961 friend class Instruction;
962
964
965public:
966 static GetElementPtrInst *Create(Type *PointeeType, Value *Ptr,
967 ArrayRef<Value *> IdxList,
968 const Twine &NameStr = "",
969 Instruction *InsertBefore = nullptr) {
970 unsigned Values = 1 + unsigned(IdxList.size());
971 assert(PointeeType && "Must specify element type");
972 assert(cast<PointerType>(Ptr->getType()->getScalarType())
973 ->isOpaqueOrPointeeTypeMatches(PointeeType));
974 return new (Values) GetElementPtrInst(PointeeType, Ptr, IdxList, Values,
975 NameStr, InsertBefore);
976 }
977
978 static GetElementPtrInst *Create(Type *PointeeType, Value *Ptr,
979 ArrayRef<Value *> IdxList,
980 const Twine &NameStr,
981 BasicBlock *InsertAtEnd) {
982 unsigned Values = 1 + unsigned(IdxList.size());
983 assert(PointeeType && "Must specify element type");
984 assert(cast<PointerType>(Ptr->getType()->getScalarType())
985 ->isOpaqueOrPointeeTypeMatches(PointeeType));
986 return new (Values) GetElementPtrInst(PointeeType, Ptr, IdxList, Values,
987 NameStr, InsertAtEnd);
988 }
989
990 /// Create an "inbounds" getelementptr. See the documentation for the
991 /// "inbounds" flag in LangRef.html for details.
992 static GetElementPtrInst *
994 const Twine &NameStr = "",
995 Instruction *InsertBefore = nullptr) {
997 Create(PointeeType, Ptr, IdxList, NameStr, InsertBefore);
998 GEP->setIsInBounds(true);
999 return GEP;
1000 }
1001
1003 ArrayRef<Value *> IdxList,
1004 const Twine &NameStr,
1005 BasicBlock *InsertAtEnd) {
1007 Create(PointeeType, Ptr, IdxList, NameStr, InsertAtEnd);
1008 GEP->setIsInBounds(true);
1009 return GEP;
1010 }
1011
1012 /// Transparently provide more efficient getOperand methods.
1014
1015 Type *getSourceElementType() const { return SourceElementType; }
1016
1017 void setSourceElementType(Type *Ty) { SourceElementType = Ty; }
1018 void setResultElementType(Type *Ty) { ResultElementType = Ty; }
1019
1021 assert(cast<PointerType>(getType()->getScalarType())
1022 ->isOpaqueOrPointeeTypeMatches(ResultElementType));
1023 return ResultElementType;
1024 }
1025
1026 /// Returns the address space of this instruction's pointer type.
1027 unsigned getAddressSpace() const {
1028 // Note that this is always the same as the pointer operand's address space
1029 // and that is cheaper to compute, so cheat here.
1030 return getPointerAddressSpace();
1031 }
1032
1033 /// Returns the result type of a getelementptr with the given source
1034 /// element type and indexes.
1035 ///
1036 /// Null is returned if the indices are invalid for the specified
1037 /// source element type.
1038 static Type *getIndexedType(Type *Ty, ArrayRef<Value *> IdxList);
1039 static Type *getIndexedType(Type *Ty, ArrayRef<Constant *> IdxList);
1040 static Type *getIndexedType(Type *Ty, ArrayRef<uint64_t> IdxList);
1041
1042 /// Return the type of the element at the given index of an indexable
1043 /// type. This is equivalent to "getIndexedType(Agg, {Zero, Idx})".
1044 ///
1045 /// Returns null if the type can't be indexed, or the given index is not
1046 /// legal for the given type.
1047 static Type *getTypeAtIndex(Type *Ty, Value *Idx);
1048 static Type *getTypeAtIndex(Type *Ty, uint64_t Idx);
1049
1050 inline op_iterator idx_begin() { return op_begin()+1; }
1051 inline const_op_iterator idx_begin() const { return op_begin()+1; }
1052 inline op_iterator idx_end() { return op_end(); }
1053 inline const_op_iterator idx_end() const { return op_end(); }
1054
1056 return make_range(idx_begin(), idx_end());
1057 }
1058
1060 return make_range(idx_begin(), idx_end());
1061 }
1062
1064 return getOperand(0);
1065 }
1066 const Value *getPointerOperand() const {
1067 return getOperand(0);
1068 }
1069 static unsigned getPointerOperandIndex() {
1070 return 0U; // get index for modifying correct operand.
1071 }
1072
1073 /// Method to return the pointer operand as a
1074 /// PointerType.
1076 return getPointerOperand()->getType();
1077 }
1078
1079 /// Returns the address space of the pointer operand.
1080 unsigned getPointerAddressSpace() const {
1082 }
1083
1084 /// Returns the pointer type returned by the GEP
1085 /// instruction, which may be a vector of pointers.
1087 ArrayRef<Value *> IdxList) {
1088 PointerType *OrigPtrTy = cast<PointerType>(Ptr->getType()->getScalarType());
1089 unsigned AddrSpace = OrigPtrTy->getAddressSpace();
1090 Type *ResultElemTy = checkGEPType(getIndexedType(ElTy, IdxList));
1091 Type *PtrTy = OrigPtrTy->isOpaque()
1092 ? PointerType::get(OrigPtrTy->getContext(), AddrSpace)
1093 : PointerType::get(ResultElemTy, AddrSpace);
1094 // Vector GEP
1095 if (auto *PtrVTy = dyn_cast<VectorType>(Ptr->getType())) {
1096 ElementCount EltCount = PtrVTy->getElementCount();
1097 return VectorType::get(PtrTy, EltCount);
1098 }
1099 for (Value *Index : IdxList)
1100 if (auto *IndexVTy = dyn_cast<VectorType>(Index->getType())) {
1101 ElementCount EltCount = IndexVTy->getElementCount();
1102 return VectorType::get(PtrTy, EltCount);
1103 }
1104 // Scalar GEP
1105 return PtrTy;
1106 }
1107
1108 unsigned getNumIndices() const { // Note: always non-negative
1109 return getNumOperands() - 1;
1110 }
1111
1112 bool hasIndices() const {
1113 return getNumOperands() > 1;
1114 }
1115
1116 /// Return true if all of the indices of this GEP are
1117 /// zeros. If so, the result pointer and the first operand have the same
1118 /// value, just potentially different types.
1119 bool hasAllZeroIndices() const;
1120
1121 /// Return true if all of the indices of this GEP are
1122 /// constant integers. If so, the result pointer and the first operand have
1123 /// a constant offset between them.
1124 bool hasAllConstantIndices() const;
1125
1126 /// Set or clear the inbounds flag on this GEP instruction.
1127 /// See LangRef.html for the meaning of inbounds on a getelementptr.
1128 void setIsInBounds(bool b = true);
1129
1130 /// Determine whether the GEP has the inbounds flag.
1131 bool isInBounds() const;
1132
1133 /// Accumulate the constant address offset of this GEP if possible.
1134 ///
1135 /// This routine accepts an APInt into which it will accumulate the constant
1136 /// offset of this GEP if the GEP is in fact constant. If the GEP is not
1137 /// all-constant, it returns false and the value of the offset APInt is
1138 /// undefined (it is *not* preserved!). The APInt passed into this routine
1139 /// must be at least as wide as the IntPtr type for the address space of
1140 /// the base GEP pointer.
1141 bool accumulateConstantOffset(const DataLayout &DL, APInt &Offset) const;
1142 bool collectOffset(const DataLayout &DL, unsigned BitWidth,
1143 MapVector<Value *, APInt> &VariableOffsets,
1144 APInt &ConstantOffset) const;
1145 // Methods for support type inquiry through isa, cast, and dyn_cast:
1146 static bool classof(const Instruction *I) {
1147 return (I->getOpcode() == Instruction::GetElementPtr);
1148 }
1149 static bool classof(const Value *V) {
1150 return isa<Instruction>(V) && classof(cast<Instruction>(V));
1151 }
1152};
1153
1154template <>
1156 public VariadicOperandTraits<GetElementPtrInst, 1> {
1157};
1158
1159GetElementPtrInst::GetElementPtrInst(Type *PointeeType, Value *Ptr,
1160 ArrayRef<Value *> IdxList, unsigned Values,
1161 const Twine &NameStr,
1162 Instruction *InsertBefore)
1163 : Instruction(getGEPReturnType(PointeeType, Ptr, IdxList), GetElementPtr,
1164 OperandTraits<GetElementPtrInst>::op_end(this) - Values,
1165 Values, InsertBefore),
1166 SourceElementType(PointeeType),
1167 ResultElementType(getIndexedType(PointeeType, IdxList)) {
1168 assert(cast<PointerType>(getType()->getScalarType())
1169 ->isOpaqueOrPointeeTypeMatches(ResultElementType));
1170 init(Ptr, IdxList, NameStr);
1171}
1172
1173GetElementPtrInst::GetElementPtrInst(Type *PointeeType, Value *Ptr,
1174 ArrayRef<Value *> IdxList, unsigned Values,
1175 const Twine &NameStr,
1176 BasicBlock *InsertAtEnd)
1177 : Instruction(getGEPReturnType(PointeeType, Ptr, IdxList), GetElementPtr,
1178 OperandTraits<GetElementPtrInst>::op_end(this) - Values,
1179 Values, InsertAtEnd),
1180 SourceElementType(PointeeType),
1181 ResultElementType(getIndexedType(PointeeType, IdxList)) {
1182 assert(cast<PointerType>(getType()->getScalarType())
1183 ->isOpaqueOrPointeeTypeMatches(ResultElementType));
1184 init(Ptr, IdxList, NameStr);
1185}
1186
1187DEFINE_TRANSPARENT_OPERAND_ACCESSORS(GetElementPtrInst, Value)
1188
1189//===----------------------------------------------------------------------===//
1190// ICmpInst Class
1191//===----------------------------------------------------------------------===//
1192
1193/// This instruction compares its operands according to the predicate given
1194/// to the constructor. It only operates on integers or pointers. The operands
1195/// must be identical types.
1196/// Represent an integer comparison operator.
1197class ICmpInst: public CmpInst {
1198 void AssertOK() {
1199 assert(isIntPredicate() &&
1200 "Invalid ICmp predicate value");
1201 assert(getOperand(0)->getType() == getOperand(1)->getType() &&
1202 "Both operands to ICmp instruction are not of the same type!");
1203 // Check that the operands are the right type
1204 assert((getOperand(0)->getType()->isIntOrIntVectorTy() ||
1205 getOperand(0)->getType()->isPtrOrPtrVectorTy()) &&
1206 "Invalid operand types for ICmp instruction");
1207 }
1208
1209protected:
1210 // Note: Instruction needs to be a friend here to call cloneImpl.
1211 friend class Instruction;
1212
1213 /// Clone an identical ICmpInst
1214 ICmpInst *cloneImpl() const;
1215
1216public:
1217 /// Constructor with insert-before-instruction semantics.
1219 Instruction *InsertBefore, ///< Where to insert
1220 Predicate pred, ///< The predicate to use for the comparison
1221 Value *LHS, ///< The left-hand-side of the expression
1222 Value *RHS, ///< The right-hand-side of the expression
1223 const Twine &NameStr = "" ///< Name of the instruction
1224 ) : CmpInst(makeCmpResultType(LHS->getType()),
1225 Instruction::ICmp, pred, LHS, RHS, NameStr,
1226 InsertBefore) {
1227#ifndef NDEBUG
1228 AssertOK();
1229#endif
1230 }
1231
1232 /// Constructor with insert-at-end semantics.
1234 BasicBlock &InsertAtEnd, ///< Block to insert into.
1235 Predicate pred, ///< The predicate to use for the comparison
1236 Value *LHS, ///< The left-hand-side of the expression
1237 Value *RHS, ///< The right-hand-side of the expression
1238 const Twine &NameStr = "" ///< Name of the instruction
1239 ) : CmpInst(makeCmpResultType(LHS->getType()),
1240 Instruction::ICmp, pred, LHS, RHS, NameStr,
1241 &InsertAtEnd) {
1242#ifndef NDEBUG
1243 AssertOK();
1244#endif
1245 }
1246
1247 /// Constructor with no-insertion semantics
1249 Predicate pred, ///< The predicate to use for the comparison
1250 Value *LHS, ///< The left-hand-side of the expression
1251 Value *RHS, ///< The right-hand-side of the expression
1252 const Twine &NameStr = "" ///< Name of the instruction
1253 ) : CmpInst(makeCmpResultType(LHS->getType()),
1254 Instruction::ICmp, pred, LHS, RHS, NameStr) {
1255#ifndef NDEBUG
1256 AssertOK();
1257#endif
1258 }
1259
1260 /// For example, EQ->EQ, SLE->SLE, UGT->SGT, etc.
1261 /// @returns the predicate that would be the result if the operand were
1262 /// regarded as signed.
1263 /// Return the signed version of the predicate
1265 return getSignedPredicate(getPredicate());
1266 }
1267
1268 /// This is a static version that you can use without an instruction.
1269 /// Return the signed version of the predicate.
1270 static Predicate getSignedPredicate(Predicate pred);
1271
1272 /// For example, EQ->EQ, SLE->ULE, UGT->UGT, etc.
1273 /// @returns the predicate that would be the result if the operand were
1274 /// regarded as unsigned.
1275 /// Return the unsigned version of the predicate
1277 return getUnsignedPredicate(getPredicate());
1278 }
1279
1280 /// This is a static version that you can use without an instruction.
1281 /// Return the unsigned version of the predicate.
1282 static Predicate getUnsignedPredicate(Predicate pred);
1283
1284 /// Return true if this predicate is either EQ or NE. This also
1285 /// tests for commutativity.
1286 static bool isEquality(Predicate P) {
1287 return P == ICMP_EQ || P == ICMP_NE;
1288 }
1289
1290 /// Return true if this predicate is either EQ or NE. This also
1291 /// tests for commutativity.
1292 bool isEquality() const {
1293 return isEquality(getPredicate());
1294 }
1295
1296 /// @returns true if the predicate of this ICmpInst is commutative
1297 /// Determine if this relation is commutative.
1298 bool isCommutative() const { return isEquality(); }
1299
1300 /// Return true if the predicate is relational (not EQ or NE).
1301 ///
1302 bool isRelational() const {
1303 return !isEquality();
1304 }
1305
1306 /// Return true if the predicate is relational (not EQ or NE).
1307 ///
1308 static bool isRelational(Predicate P) {
1309 return !isEquality(P);
1310 }
1311
1312 /// Return true if the predicate is SGT or UGT.
1313 ///
1314 static bool isGT(Predicate P) {
1315 return P == ICMP_SGT || P == ICMP_UGT;
1316 }
1317
1318 /// Return true if the predicate is SLT or ULT.
1319 ///
1320 static bool isLT(Predicate P) {
1321 return P == ICMP_SLT || P == ICMP_ULT;
1322 }
1323
1324 /// Return true if the predicate is SGE or UGE.
1325 ///
1326 static bool isGE(Predicate P) {
1327 return P == ICMP_SGE || P == ICMP_UGE;
1328 }
1329
1330 /// Return true if the predicate is SLE or ULE.
1331 ///
1332 static bool isLE(Predicate P) {
1333 return P == ICMP_SLE || P == ICMP_ULE;
1334 }
1335
1336 /// Returns the sequence of all ICmp predicates.
1337 ///
1338 static auto predicates() { return ICmpPredicates(); }
1339
1340 /// Exchange the two operands to this instruction in such a way that it does
1341 /// not modify the semantics of the instruction. The predicate value may be
1342 /// changed to retain the same result if the predicate is order dependent
1343 /// (e.g. ult).
1344 /// Swap operands and adjust predicate.
1346 setPredicate(getSwappedPredicate());
1347 Op<0>().swap(Op<1>());
1348 }
1349
1350 /// Return result of `LHS Pred RHS` comparison.
1351 static bool compare(const APInt &LHS, const APInt &RHS,
1352 ICmpInst::Predicate Pred);
1353
1354 // Methods for support type inquiry through isa, cast, and dyn_cast:
1355 static bool classof(const Instruction *I) {
1356 return I->getOpcode() == Instruction::ICmp;
1357 }
1358 static bool classof(const Value *V) {
1359 return isa<Instruction>(V) && classof(cast<Instruction>(V));
1360 }
1361};
1362
1363//===----------------------------------------------------------------------===//
1364// FCmpInst Class
1365//===----------------------------------------------------------------------===//
1366
1367/// This instruction compares its operands according to the predicate given
1368/// to the constructor. It only operates on floating point values or packed
1369/// vectors of floating point values. The operands must be identical types.
1370/// Represents a floating point comparison operator.
1371class FCmpInst: public CmpInst {
1372 void AssertOK() {
1373 assert(isFPPredicate() && "Invalid FCmp predicate value");
1374 assert(getOperand(0)->getType() == getOperand(1)->getType() &&
1375 "Both operands to FCmp instruction are not of the same type!");
1376 // Check that the operands are the right type
1377 assert(getOperand(0)->getType()->isFPOrFPVectorTy() &&
1378 "Invalid operand types for FCmp instruction");
1379 }
1380
1381protected:
1382 // Note: Instruction needs to be a friend here to call cloneImpl.
1383 friend class Instruction;
1384
1385 /// Clone an identical FCmpInst
1386 FCmpInst *cloneImpl() const;
1387
1388public:
1389 /// Constructor with insert-before-instruction semantics.
1391 Instruction *InsertBefore, ///< Where to insert
1392 Predicate pred, ///< The predicate to use for the comparison
1393 Value *LHS, ///< The left-hand-side of the expression
1394 Value *RHS, ///< The right-hand-side of the expression
1395 const Twine &NameStr = "" ///< Name of the instruction
1397 Instruction::FCmp, pred, LHS, RHS, NameStr,
1398 InsertBefore) {
1399 AssertOK();
1400 }
1401
1402 /// Constructor with insert-at-end semantics.
1404 BasicBlock &InsertAtEnd, ///< Block to insert into.
1405 Predicate pred, ///< The predicate to use for the comparison
1406 Value *LHS, ///< The left-hand-side of the expression
1407 Value *RHS, ///< The right-hand-side of the expression
1408 const Twine &NameStr = "" ///< Name of the instruction
1410 Instruction::FCmp, pred, LHS, RHS, NameStr,
1411 &InsertAtEnd) {
1412 AssertOK();
1413 }
1414
1415 /// Constructor with no-insertion semantics
1417 Predicate Pred, ///< The predicate to use for the comparison
1418 Value *LHS, ///< The left-hand-side of the expression
1419 Value *RHS, ///< The right-hand-side of the expression
1420 const Twine &NameStr = "", ///< Name of the instruction
1421 Instruction *FlagsSource = nullptr
1422 ) : CmpInst(makeCmpResultType(LHS->getType()), Instruction::FCmp, Pred, LHS,
1423 RHS, NameStr, nullptr, FlagsSource) {
1424 AssertOK();
1425 }
1426
1427 /// @returns true if the predicate of this instruction is EQ or NE.
1428 /// Determine if this is an equality predicate.
1429 static bool isEquality(Predicate Pred) {
1430 return Pred == FCMP_OEQ || Pred == FCMP_ONE || Pred == FCMP_UEQ ||
1431 Pred == FCMP_UNE;
1432 }
1433
1434 /// @returns true if the predicate of this instruction is EQ or NE.
1435 /// Determine if this is an equality predicate.
1436 bool isEquality() const { return isEquality(getPredicate()); }
1437
1438 /// @returns true if the predicate of this instruction is commutative.
1439 /// Determine if this is a commutative predicate.
1440 bool isCommutative() const {
1441 return isEquality() ||
1442 getPredicate() == FCMP_FALSE ||
1443 getPredicate() == FCMP_TRUE ||
1444 getPredicate() == FCMP_ORD ||
1446 }
1447
1448 /// @returns true if the predicate is relational (not EQ or NE).
1449 /// Determine if this a relational predicate.
1450 bool isRelational() const { return !isEquality(); }
1451
1452 /// Exchange the two operands to this instruction in such a way that it does
1453 /// not modify the semantics of the instruction. The predicate value may be
1454 /// changed to retain the same result if the predicate is order dependent
1455 /// (e.g. ult).
1456 /// Swap operands and adjust predicate.
1459 Op<0>().swap(Op<1>());
1460 }
1461
1462 /// Returns the sequence of all FCmp predicates.
1463 ///
1464 static auto predicates() { return FCmpPredicates(); }
1465
1466 /// Return result of `LHS Pred RHS` comparison.
1467 static bool compare(const APFloat &LHS, const APFloat &RHS,
1468 FCmpInst::Predicate Pred);
1469
1470 /// Methods for support type inquiry through isa, cast, and dyn_cast:
1471 static bool classof(const Instruction *I) {
1472 return I->getOpcode() == Instruction::FCmp;
1473 }
1474 static bool classof(const Value *V) {
1475 return isa<Instruction>(V) && classof(cast<Instruction>(V));
1476 }
1477};
1478
1479//===----------------------------------------------------------------------===//
1480/// This class represents a function call, abstracting a target
1481/// machine's calling convention. This class uses low bit of the SubClassData
1482/// field to indicate whether or not this is a tail call. The rest of the bits
1483/// hold the calling convention of the call.
1484///
1485class CallInst : public CallBase {
1486 CallInst(const CallInst &CI);
1487
1488 /// Construct a CallInst given a range of arguments.
1489 /// Construct a CallInst from a range of arguments
1490 inline CallInst(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
1491 ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr,
1492 Instruction *InsertBefore);
1493
1494 inline CallInst(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
1495 const Twine &NameStr, Instruction *InsertBefore)
1496 : CallInst(Ty, Func, Args, std::nullopt, NameStr, InsertBefore) {}
1497
1498 /// Construct a CallInst given a range of arguments.
1499 /// Construct a CallInst from a range of arguments
1500 inline CallInst(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
1501 ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr,
1502 BasicBlock *InsertAtEnd);
1503
1504 explicit CallInst(FunctionType *Ty, Value *F, const Twine &NameStr,
1505 Instruction *InsertBefore);
1506
1507 CallInst(FunctionType *ty, Value *F, const Twine &NameStr,
1508 BasicBlock *InsertAtEnd);
1509
1510 void init(FunctionType *FTy, Value *Func, ArrayRef<Value *> Args,
1511 ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr);
1512 void init(FunctionType *FTy, Value *Func, const Twine &NameStr);
1513
1514 /// Compute the number of operands to allocate.
1515 static int ComputeNumOperands(int NumArgs, int NumBundleInputs = 0) {
1516 // We need one operand for the called function, plus the input operand
1517 // counts provided.
1518 return 1 + NumArgs + NumBundleInputs;
1519 }
1520
1521protected:
1522 // Note: Instruction needs to be a friend here to call cloneImpl.
1523 friend class Instruction;
1524
1525 CallInst *cloneImpl() const;
1526
1527public:
1528 static CallInst *Create(FunctionType *Ty, Value *F, const Twine &NameStr = "",
1529 Instruction *InsertBefore = nullptr) {
1530 return new (ComputeNumOperands(0)) CallInst(Ty, F, NameStr, InsertBefore);
1531 }
1532
1534 const Twine &NameStr,
1535 Instruction *InsertBefore = nullptr) {
1536 return new (ComputeNumOperands(Args.size()))
1537 CallInst(Ty, Func, Args, std::nullopt, NameStr, InsertBefore);
1538 }
1539
1541 ArrayRef<OperandBundleDef> Bundles = std::nullopt,
1542 const Twine &NameStr = "",
1543 Instruction *InsertBefore = nullptr) {
1544 const int NumOperands =
1545 ComputeNumOperands(Args.size(), CountBundleInputs(Bundles));
1546 const unsigned DescriptorBytes = Bundles.size() * sizeof(BundleOpInfo);
1547
1548 return new (NumOperands, DescriptorBytes)
1549 CallInst(Ty, Func, Args, Bundles, NameStr, InsertBefore);
1550 }
1551
1552 static CallInst *Create(FunctionType *Ty, Value *F, const Twine &NameStr,
1553 BasicBlock *InsertAtEnd) {
1554 return new (ComputeNumOperands(0)) CallInst(Ty, F, NameStr, InsertAtEnd);
1555 }
1556
1558 const Twine &NameStr, BasicBlock *InsertAtEnd) {
1559 return new (ComputeNumOperands(Args.size()))
1560 CallInst(Ty, Func, Args, std::nullopt, NameStr, InsertAtEnd);
1561 }
1562
1565 const Twine &NameStr, BasicBlock *InsertAtEnd) {
1566 const int NumOperands =
1567 ComputeNumOperands(Args.size(), CountBundleInputs(Bundles));
1568 const unsigned DescriptorBytes = Bundles.size() * sizeof(BundleOpInfo);
1569
1570 return new (NumOperands, DescriptorBytes)
1571 CallInst(Ty, Func, Args, Bundles, NameStr, InsertAtEnd);
1572 }
1573
1574 static CallInst *Create(FunctionCallee Func, const Twine &NameStr = "",
1575 Instruction *InsertBefore = nullptr) {
1576 return Create(Func.getFunctionType(), Func.getCallee(), NameStr,
1577 InsertBefore);
1578 }
1579
1581 ArrayRef<OperandBundleDef> Bundles = std::nullopt,
1582 const Twine &NameStr = "",
1583 Instruction *InsertBefore = nullptr) {
1584 return Create(Func.getFunctionType(), Func.getCallee(), Args, Bundles,
1585 NameStr, InsertBefore);
1586 }
1587
1589 const Twine &NameStr,
1590 Instruction *InsertBefore = nullptr) {
1591 return Create(Func.getFunctionType(), Func.getCallee(), Args, NameStr,
1592 InsertBefore);
1593 }
1594
1595 static CallInst *Create(FunctionCallee Func, const Twine &NameStr,
1596 BasicBlock *InsertAtEnd) {
1597 return Create(Func.getFunctionType(), Func.getCallee(), NameStr,
1598 InsertAtEnd);
1599 }
1600
1602 const Twine &NameStr, BasicBlock *InsertAtEnd) {
1603 return Create(Func.getFunctionType(), Func.getCallee(), Args, NameStr,
1604 InsertAtEnd);
1605 }
1606
1609 const Twine &NameStr, BasicBlock *InsertAtEnd) {
1610 return Create(Func.getFunctionType(), Func.getCallee(), Args, Bundles,
1611 NameStr, InsertAtEnd);
1612 }
1613
1614 /// Create a clone of \p CI with a different set of operand bundles and
1615 /// insert it before \p InsertPt.
1616 ///
1617 /// The returned call instruction is identical \p CI in every way except that
1618 /// the operand bundles for the new instruction are set to the operand bundles
1619 /// in \p Bundles.
1621 Instruction *InsertPt = nullptr);
1622
1623 /// Generate the IR for a call to malloc:
1624 /// 1. Compute the malloc call's argument as the specified type's size,
1625 /// possibly multiplied by the array size if the array size is not
1626 /// constant 1.
1627 /// 2. Call malloc with that argument.
1628 /// 3. Bitcast the result of the malloc call to the specified type.
1629 static Instruction *CreateMalloc(Instruction *InsertBefore, Type *IntPtrTy,
1630 Type *AllocTy, Value *AllocSize,
1631 Value *ArraySize = nullptr,
1632 Function *MallocF = nullptr,
1633 const Twine &Name = "");
1634 static Instruction *CreateMalloc(BasicBlock *InsertAtEnd, Type *IntPtrTy,
1635 Type *AllocTy, Value *AllocSize,
1636 Value *ArraySize = nullptr,
1637 Function *MallocF = nullptr,
1638 const Twine &Name = "");
1639 static Instruction *
1640 CreateMalloc(Instruction *InsertBefore, Type *IntPtrTy, Type *AllocTy,
1641 Value *AllocSize, Value *ArraySize = nullptr,
1642 ArrayRef<OperandBundleDef> Bundles = std::nullopt,
1643 Function *MallocF = nullptr, const Twine &Name = "");
1644 static Instruction *
1645 CreateMalloc(BasicBlock *InsertAtEnd, Type *IntPtrTy, Type *AllocTy,
1646 Value *AllocSize, Value *ArraySize = nullptr,
1647 ArrayRef<OperandBundleDef> Bundles = std::nullopt,
1648 Function *MallocF = nullptr, const Twine &Name = "");
1649 /// Generate the IR for a call to the builtin free function.
1650 static Instruction *CreateFree(Value *Source, Instruction *InsertBefore);
1651 static Instruction *CreateFree(Value *Source, BasicBlock *InsertAtEnd);
1652 static Instruction *CreateFree(Value *Source,
1654 Instruction *InsertBefore);
1655 static Instruction *CreateFree(Value *Source,
1657 BasicBlock *InsertAtEnd);
1658
1659 // Note that 'musttail' implies 'tail'.
1660 enum TailCallKind : unsigned {
1667
1669 static_assert(
1670 Bitfield::areContiguous<TailCallKindField, CallBase::CallingConvField>(),
1671 "Bitfields must be contiguous");
1672
1674 return getSubclassData<TailCallKindField>();
1675 }
1676
1677 bool isTailCall() const {
1679 return Kind == TCK_Tail || Kind == TCK_MustTail;
1680 }
1681
1682 bool isMustTailCall() const { return getTailCallKind() == TCK_MustTail; }
1683
1684 bool isNoTailCall() const { return getTailCallKind() == TCK_NoTail; }
1685
1687 setSubclassData<TailCallKindField>(TCK);
1688 }
1689
1690 void setTailCall(bool IsTc = true) {
1692 }
1693
1694 /// Return true if the call can return twice
1695 bool canReturnTwice() const { return hasFnAttr(Attribute::ReturnsTwice); }
1696 void setCanReturnTwice() { addFnAttr(Attribute::ReturnsTwice); }
1697
1698 // Methods for support type inquiry through isa, cast, and dyn_cast:
1699 static bool classof(const Instruction *I) {
1700 return I->getOpcode() == Instruction::Call;
1701 }
1702 static bool classof(const Value *V) {
1703 return isa<Instruction>(V) && classof(cast<Instruction>(V));
1704 }
1705
1706 /// Updates profile metadata by scaling it by \p S / \p T.
1708
1709private:
1710 // Shadow Instruction::setInstructionSubclassData with a private forwarding
1711 // method so that subclasses cannot accidentally use it.
1712 template <typename Bitfield>
1713 void setSubclassData(typename Bitfield::Type Value) {
1714 Instruction::setSubclassData<Bitfield>(Value);
1715 }
1716};
1717
1718CallInst::CallInst(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
1719 ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr,
1720 BasicBlock *InsertAtEnd)
1721 : CallBase(Ty->getReturnType(), Instruction::Call,
1722 OperandTraits<CallBase>::op_end(this) -
1723 (Args.size() + CountBundleInputs(Bundles) + 1),
1724 unsigned(Args.size() + CountBundleInputs(Bundles) + 1),
1725 InsertAtEnd) {
1726 init(Ty, Func, Args, Bundles, NameStr);
1727}
1728
1729CallInst::CallInst(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
1730 ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr,
1731 Instruction *InsertBefore)
1732 : CallBase(Ty->getReturnType(), Instruction::Call,
1733 OperandTraits<CallBase>::op_end(this) -
1734 (Args.size() + CountBundleInputs(Bundles) + 1),
1735 unsigned(Args.size() + CountBundleInputs(Bundles) + 1),
1736 InsertBefore) {
1737 init(Ty, Func, Args, Bundles, NameStr);
1738}
1739
1740//===----------------------------------------------------------------------===//
1741// SelectInst Class
1742//===----------------------------------------------------------------------===//
1743
1744/// This class represents the LLVM 'select' instruction.
1745///
1746class SelectInst : public Instruction {
1747 SelectInst(Value *C, Value *S1, Value *S2, const Twine &NameStr,
1748 Instruction *InsertBefore)
1749 : Instruction(S1->getType(), Instruction::Select,
1750 &Op<0>(), 3, InsertBefore) {
1751 init(C, S1, S2);
1752 setName(NameStr);
1753 }
1754
1755 SelectInst(Value *C, Value *S1, Value *S2, const Twine &NameStr,
1756 BasicBlock *InsertAtEnd)
1757 : Instruction(S1->getType(), Instruction::Select,
1758 &Op<0>(), 3, InsertAtEnd) {
1759 init(C, S1, S2);
1760 setName(NameStr);
1761 }
1762
1763 void init(Value *C, Value *S1, Value *S2) {
1764 assert(!areInvalidOperands(C, S1, S2) && "Invalid operands for select");
1765 Op<0>() = C;
1766 Op<1>() = S1;
1767 Op<2>() = S2;
1768 }
1769
1770protected:
1771 // Note: Instruction needs to be a friend here to call cloneImpl.
1772 friend class Instruction;
1773
1774 SelectInst *cloneImpl() const;
1775
1776public:
1777 static SelectInst *Create(Value *C, Value *S1, Value *S2,
1778 const Twine &NameStr = "",
1779 Instruction *InsertBefore = nullptr,
1780 Instruction *MDFrom = nullptr) {
1781 SelectInst *Sel = new(3) SelectInst(C, S1, S2, NameStr, InsertBefore);
1782 if (MDFrom)
1783 Sel->copyMetadata(*MDFrom);
1784 return Sel;
1785 }
1786
1787 static SelectInst *Create(Value *C, Value *S1, Value *S2,
1788 const Twine &NameStr,
1789 BasicBlock *InsertAtEnd) {
1790 return new(3) SelectInst(C, S1, S2, NameStr, InsertAtEnd);
1791 }
1792
1793 const Value *getCondition() const { return Op<0>(); }
1794 const Value *getTrueValue() const { return Op<1>(); }
1795 const Value *getFalseValue() const { return Op<2>(); }
1796 Value *getCondition() { return Op<0>(); }
1797 Value *getTrueValue() { return Op<1>(); }
1798 Value *getFalseValue() { return Op<2>(); }
1799
1800 void setCondition(Value *V) { Op<0>() = V; }
1801 void setTrueValue(Value *V) { Op<1>() = V; }
1802 void setFalseValue(Value *V) { Op<2>() = V; }
1803
1804 /// Swap the true and false values of the select instruction.
1805 /// This doesn't swap prof metadata.
1806 void swapValues() { Op<1>().swap(Op<2>()); }
1807
1808 /// Return a string if the specified operands are invalid
1809 /// for a select operation, otherwise return null.
1810 static const char *areInvalidOperands(Value *Cond, Value *True, Value *False);
1811
1812 /// Transparently provide more efficient getOperand methods.
1814
1816 return static_cast<OtherOps>(Instruction::getOpcode());
1817 }
1818
1819 // Methods for support type inquiry through isa, cast, and dyn_cast:
1820 static bool classof(const Instruction *I) {
1821 return I->getOpcode() == Instruction::Select;
1822 }
1823 static bool classof(const Value *V) {
1824 return isa<Instruction>(V) && classof(cast<Instruction>(V));
1825 }
1826};
1827
1828template <>
1829struct OperandTraits<SelectInst> : public FixedNumOperandTraits<SelectInst, 3> {
1830};
1831
1833
1834//===----------------------------------------------------------------------===//
1835// VAArgInst Class
1836//===----------------------------------------------------------------------===//
1837
1838/// This class represents the va_arg llvm instruction, which returns
1839/// an argument of the specified type given a va_list and increments that list
1840///
1842protected:
1843 // Note: Instruction needs to be a friend here to call cloneImpl.
1844 friend class Instruction;
1845
1846 VAArgInst *cloneImpl() const;
1847
1848public:
1849 VAArgInst(Value *List, Type *Ty, const Twine &NameStr = "",
1850 Instruction *InsertBefore = nullptr)
1851 : UnaryInstruction(Ty, VAArg, List, InsertBefore) {
1852 setName(NameStr);
1853 }
1854
1855 VAArgInst(Value *List, Type *Ty, const Twine &NameStr,
1856 BasicBlock *InsertAtEnd)
1857 : UnaryInstruction(Ty, VAArg, List, InsertAtEnd) {
1858 setName(NameStr);
1859 }
1860
1861 Value *getPointerOperand() { return getOperand(0); }
1862 const Value *getPointerOperand() const { return getOperand(0); }
1863 static unsigned getPointerOperandIndex() { return 0U; }
1864
1865 // Methods for support type inquiry through isa, cast, and dyn_cast:
1866 static bool classof(const Instruction *I) {
1867 return I->getOpcode() == VAArg;
1868 }
1869 static bool classof(const Value *V) {
1870 return isa<Instruction>(V) && classof(cast<Instruction>(V));
1871 }
1872};
1873
1874//===----------------------------------------------------------------------===//
1875// ExtractElementInst Class
1876//===----------------------------------------------------------------------===//
1877
1878/// This instruction extracts a single (scalar)
1879/// element from a VectorType value
1880///
1882 ExtractElementInst(Value *Vec, Value *Idx, const Twine &NameStr = "",
1883 Instruction *InsertBefore = nullptr);
1884 ExtractElementInst(Value *Vec, Value *Idx, const Twine &NameStr,
1885 BasicBlock *InsertAtEnd);
1886
1887protected:
1888 // Note: Instruction needs to be a friend here to call cloneImpl.
1889 friend class Instruction;
1890
1892
1893public:
1895 const Twine &NameStr = "",
1896 Instruction *InsertBefore = nullptr) {
1897 return new(2) ExtractElementInst(Vec, Idx, NameStr, InsertBefore);
1898 }
1899
1901 const Twine &NameStr,
1902 BasicBlock *InsertAtEnd) {
1903 return new(2) ExtractElementInst(Vec, Idx, NameStr, InsertAtEnd);
1904 }
1905
1906 /// Return true if an extractelement instruction can be
1907 /// formed with the specified operands.
1908 static bool isValidOperands(const Value *Vec, const Value *Idx);
1909
1910 Value *getVectorOperand() { return Op<0>(); }
1911 Value *getIndexOperand() { return Op<1>(); }
1912 const Value *getVectorOperand() const { return Op<0>(); }
1913 const Value *getIndexOperand() const { return Op<1>(); }
1914
1916 return cast<VectorType>(getVectorOperand()->getType());
1917 }
1918
1919 /// Transparently provide more efficient getOperand methods.
1921
1922 // Methods for support type inquiry through isa, cast, and dyn_cast:
1923 static bool classof(const Instruction *I) {
1924 return I->getOpcode() == Instruction::ExtractElement;
1925 }
1926 static bool classof(const Value *V) {
1927 return isa<Instruction>(V) && classof(cast<Instruction>(V));
1928 }
1929};
1930
1931template <>
1933 public FixedNumOperandTraits<ExtractElementInst, 2> {
1934};
1935
1937
1938//===----------------------------------------------------------------------===//
1939// InsertElementInst Class
1940//===----------------------------------------------------------------------===//
1941
1942/// This instruction inserts a single (scalar)
1943/// element into a VectorType value
1944///
1946 InsertElementInst(Value *Vec, Value *NewElt, Value *Idx,
1947 const Twine &NameStr = "",
1948 Instruction *InsertBefore = nullptr);
1949 InsertElementInst(Value *Vec, Value *NewElt, Value *Idx, const Twine &NameStr,
1950 BasicBlock *InsertAtEnd);
1951
1952protected:
1953 // Note: Instruction needs to be a friend here to call cloneImpl.
1954 friend class Instruction;
1955
1956 InsertElementInst *cloneImpl() const;
1957
1958public:
1959 static InsertElementInst *Create(Value *Vec, Value *NewElt, Value *Idx,
1960 const Twine &NameStr = "",
1961 Instruction *InsertBefore = nullptr) {
1962 return new(3) InsertElementInst(Vec, NewElt, Idx, NameStr, InsertBefore);
1963 }
1964
1965 static InsertElementInst *Create(Value *Vec, Value *NewElt, Value *Idx,
1966 const Twine &NameStr,
1967 BasicBlock *InsertAtEnd) {
1968 return new(3) InsertElementInst(Vec, NewElt, Idx, NameStr, InsertAtEnd);
1969 }
1970
1971 /// Return true if an insertelement instruction can be
1972 /// formed with the specified operands.
1973 static bool isValidOperands(const Value *Vec, const Value *NewElt,
1974 const Value *Idx);
1975
1976 /// Overload to return most specific vector type.
1977 ///
1979 return cast<VectorType>(Instruction::getType());
1980 }
1981
1982 /// Transparently provide more efficient getOperand methods.
1984
1985 // Methods for support type inquiry through isa, cast, and dyn_cast:
1986 static bool classof(const Instruction *I) {
1987 return I->getOpcode() == Instruction::InsertElement;
1988 }
1989 static bool classof(const Value *V) {
1990 return isa<Instruction>(V) && classof(cast<Instruction>(V));
1991 }
1992};
1993
1994template <>
1996 public FixedNumOperandTraits<InsertElementInst, 3> {
1997};
1998
2000
2001//===----------------------------------------------------------------------===//
2002// ShuffleVectorInst Class
2003//===----------------------------------------------------------------------===//
2004
2005constexpr int PoisonMaskElem = -1;
2006
2007/// This instruction constructs a fixed permutation of two
2008/// input vectors.
2009///
2010/// For each element of the result vector, the shuffle mask selects an element
2011/// from one of the input vectors to copy to the result. Non-negative elements
2012/// in the mask represent an index into the concatenated pair of input vectors.
2013/// PoisonMaskElem (-1) specifies that the result element is poison.
2014///
2015/// For scalable vectors, all the elements of the mask must be 0 or -1. This
2016/// requirement may be relaxed in the future.
2018 SmallVector<int, 4> ShuffleMask;
2019 Constant *ShuffleMaskForBitcode;
2020
2021protected:
2022 // Note: Instruction needs to be a friend here to call cloneImpl.
2023 friend class Instruction;
2024
2025 ShuffleVectorInst *cloneImpl() const;
2026
2027public:
2028 ShuffleVectorInst(Value *V1, Value *Mask, const Twine &NameStr = "",
2029 Instruction *InsertBefore = nullptr);
2030 ShuffleVectorInst(Value *V1, Value *Mask, const Twine &NameStr,
2031 BasicBlock *InsertAtEnd);
2032 ShuffleVectorInst(Value *V1, ArrayRef<int> Mask, const Twine &NameStr = "",
2033 Instruction *InsertBefore = nullptr);
2034 ShuffleVectorInst(Value *V1, ArrayRef<int> Mask, const Twine &NameStr,
2035 BasicBlock *InsertAtEnd);
2036 ShuffleVectorInst(Value *V1, Value *V2, Value *Mask,
2037 const Twine &NameStr = "",
2038 Instruction *InsertBefor = nullptr);
2039 ShuffleVectorInst(Value *V1, Value *V2, Value *Mask,
2040 const Twine &NameStr, BasicBlock *InsertAtEnd);
2042 const Twine &NameStr = "",
2043 Instruction *InsertBefor = nullptr);
2045 const Twine &NameStr, BasicBlock *InsertAtEnd);
2046
2047 void *operator new(size_t S) { return User::operator new(S, 2); }
2048 void operator delete(void *Ptr) { return User::operator delete(Ptr); }
2049
2050 /// Swap the operands and adjust the mask to preserve the semantics
2051 /// of the instruction.
2052 void commute();
2053
2054 /// Return true if a shufflevector instruction can be
2055 /// formed with the specified operands.
2056 static bool isValidOperands(const Value *V1, const Value *V2,
2057 const Value *Mask);
2058 static bool isValidOperands(const Value *V1, const Value *V2,
2059 ArrayRef<int> Mask);
2060
2061 /// Overload to return most specific vector type.
2062 ///
2064 return cast<VectorType>(Instruction::getType());
2065 }
2066
2067 /// Transparently provide more efficient getOperand methods.
2069
2070 /// Return the shuffle mask value of this instruction for the given element
2071 /// index. Return PoisonMaskElem if the element is undef.
2072 int getMaskValue(unsigned Elt) const { return ShuffleMask[Elt]; }
2073
2074 /// Convert the input shuffle mask operand to a vector of integers. Undefined
2075 /// elements of the mask are returned as PoisonMaskElem.
2076 static void getShuffleMask(const Constant *Mask,
2077 SmallVectorImpl<int> &Result);
2078
2079 /// Return the mask for this instruction as a vector of integers. Undefined
2080 /// elements of the mask are returned as PoisonMaskElem.
2082 Result.assign(ShuffleMask.begin(), ShuffleMask.end());
2083 }
2084
2085 /// Return the mask for this instruction, for use in bitcode.
2086 ///
2087 /// TODO: This is temporary until we decide a new bitcode encoding for
2088 /// shufflevector.
2089 Constant *getShuffleMaskForBitcode() const { return ShuffleMaskForBitcode; }
2090
2091 static Constant *convertShuffleMaskForBitcode(ArrayRef<int> Mask,
2092 Type *ResultTy);
2093
2094 void setShuffleMask(ArrayRef<int> Mask);
2095
2096 ArrayRef<int> getShuffleMask() const { return ShuffleMask; }
2097
2098 /// Return true if this shuffle returns a vector with a different number of
2099 /// elements than its source vectors.
2100 /// Examples: shufflevector <4 x n> A, <4 x n> B, <1,2,3>
2101 /// shufflevector <4 x n> A, <4 x n> B, <1,2,3,4,5>
2102 bool changesLength() const {
2103 unsigned NumSourceElts = cast<VectorType>(Op<0>()->getType())
2104 ->getElementCount()
2105 .getKnownMinValue();
2106 unsigned NumMaskElts = ShuffleMask.size();
2107 return NumSourceElts != NumMaskElts;
2108 }
2109
2110 /// Return true if this shuffle returns a vector with a greater number of
2111 /// elements than its source vectors.
2112 /// Example: shufflevector <2 x n> A, <2 x n> B, <1,2,3>
2113 bool increasesLength() const {
2114 unsigned NumSourceElts = cast<VectorType>(Op<0>()->getType())
2115 ->getElementCount()
2116 .getKnownMinValue();
2117 unsigned NumMaskElts = ShuffleMask.size();
2118 return NumSourceElts < NumMaskElts;
2119 }
2120
2121 /// Return true if this shuffle mask chooses elements from exactly one source
2122 /// vector.
2123 /// Example: <7,5,undef,7>
2124 /// This assumes that vector operands are the same length as the mask.
2125 static bool isSingleSourceMask(ArrayRef<int> Mask);
2126 static bool isSingleSourceMask(const Constant *Mask) {
2127 assert(Mask->getType()->isVectorTy() && "Shuffle needs vector constant.");
2128 SmallVector<int, 16> MaskAsInts;
2129 getShuffleMask(Mask, MaskAsInts);
2130 return isSingleSourceMask(MaskAsInts);
2131 }
2132
2133 /// Return true if this shuffle chooses elements from exactly one source
2134 /// vector without changing the length of that vector.
2135 /// Example: shufflevector <4 x n> A, <4 x n> B, <3,0,undef,3>
2136 /// TODO: Optionally allow length-changing shuffles.
2137 bool isSingleSource() const {
2138 return !changesLength() && isSingleSourceMask(ShuffleMask);
2139 }
2140
2141 /// Return true if this shuffle mask chooses elements from exactly one source
2142 /// vector without lane crossings. A shuffle using this mask is not
2143 /// necessarily a no-op because it may change the number of elements from its
2144 /// input vectors or it may provide demanded bits knowledge via undef lanes.
2145 /// Example: <undef,undef,2,3>
2146 static bool isIdentityMask(ArrayRef<int> Mask);
2147 static bool isIdentityMask(const Constant *Mask) {
2148 assert(Mask->getType()->isVectorTy() && "Shuffle needs vector constant.");
2149
2150 // Not possible to express a shuffle mask for a scalable vector for this
2151 // case.
2152 if (isa<ScalableVectorType>(Mask->getType()))
2153 return false;
2154
2155 SmallVector<int, 16> MaskAsInts;
2156 getShuffleMask(Mask, MaskAsInts);
2157 return isIdentityMask(MaskAsInts);
2158 }
2159
2160 /// Return true if this shuffle chooses elements from exactly one source
2161 /// vector without lane crossings and does not change the number of elements
2162 /// from its input vectors.
2163 /// Example: shufflevector <4 x n> A, <4 x n> B, <4,undef,6,undef>
2164 bool isIdentity() const {
2165 // Not possible to express a shuffle mask for a scalable vector for this
2166 // case.
2167 if (isa<ScalableVectorType>(getType()))
2168 return false;
2169
2170 return !changesLength() && isIdentityMask(ShuffleMask);
2171 }
2172
2173 /// Return true if this shuffle lengthens exactly one source vector with
2174 /// undefs in the high elements.
2175 bool isIdentityWithPadding() const;
2176
2177 /// Return true if this shuffle extracts the first N elements of exactly one
2178 /// source vector.
2179 bool isIdentityWithExtract() const;
2180
2181 /// Return true if this shuffle concatenates its 2 source vectors. This
2182 /// returns false if either input is undefined. In that case, the shuffle is
2183 /// is better classified as an identity with padding operation.
2184 bool isConcat() const;
2185
2186 /// Return true if this shuffle mask chooses elements from its source vectors
2187 /// without lane crossings. A shuffle using this mask would be
2188 /// equivalent to a vector select with a constant condition operand.
2189 /// Example: <4,1,6,undef>
2190 /// This returns false if the mask does not choose from both input vectors.
2191 /// In that case, the shuffle is better classified as an identity shuffle.
2192 /// This assumes that vector operands are the same length as the mask
2193 /// (a length-changing shuffle can never be equivalent to a vector select).
2194 static bool isSelectMask(ArrayRef<int> Mask);
2195 static bool isSelectMask(const Constant *Mask) {
2196 assert(Mask->getType()->isVectorTy() && "Shuffle needs vector constant.");
2197 SmallVector<int, 16> MaskAsInts;
2198 getShuffleMask(Mask, MaskAsInts);
2199 return isSelectMask(MaskAsInts);
2200 }
2201
2202 /// Return true if this shuffle chooses elements from its source vectors
2203 /// without lane crossings and all operands have the same number of elements.
2204 /// In other words, this shuffle is equivalent to a vector select with a
2205 /// constant condition operand.
2206 /// Example: shufflevector <4 x n> A, <4 x n> B, <undef,1,6,3>
2207 /// This returns false if the mask does not choose from both input vectors.
2208 /// In that case, the shuffle is better classified as an identity shuffle.
2209 /// TODO: Optionally allow length-changing shuffles.
2210 bool isSelect() const {
2211 return !changesLength() && isSelectMask(ShuffleMask);
2212 }
2213
2214 /// Return true if this shuffle mask swaps the order of elements from exactly
2215 /// one source vector.
2216 /// Example: <7,6,undef,4>
2217 /// This assumes that vector operands are the same length as the mask.
2218 static bool isReverseMask(ArrayRef<int> Mask);
2219 static bool isReverseMask(const Constant *Mask) {
2220 assert(Mask->getType()->isVectorTy() && "Shuffle needs vector constant.");
2221 SmallVector<int, 16> MaskAsInts;
2222 getShuffleMask(Mask, MaskAsInts);
2223 return isReverseMask(MaskAsInts);
2224 }
2225
2226 /// Return true if this shuffle swaps the order of elements from exactly
2227 /// one source vector.
2228 /// Example: shufflevector <4 x n> A, <4 x n> B, <3,undef,1,undef>
2229 /// TODO: Optionally allow length-changing shuffles.
2230 bool isReverse() const {
2231 return !changesLength() && isReverseMask(ShuffleMask);
2232 }
2233
2234 /// Return true if this shuffle mask chooses all elements with the same value
2235 /// as the first element of exactly one source vector.
2236 /// Example: <4,undef,undef,4>
2237 /// This assumes that vector operands are the same length as the mask.
2238 static bool isZeroEltSplatMask(ArrayRef<int> Mask);
2239 static bool isZeroEltSplatMask(const Constant *Mask) {
2240 assert(Mask->getType()->isVectorTy() && "Shuffle needs vector constant.");
2241 SmallVector<int, 16> MaskAsInts;
2242 getShuffleMask(Mask, MaskAsInts);
2243 return isZeroEltSplatMask(MaskAsInts);
2244 }
2245
2246 /// Return true if all elements of this shuffle are the same value as the
2247 /// first element of exactly one source vector without changing the length
2248 /// of that vector.
2249 /// Example: shufflevector <4 x n> A, <4 x n> B, <undef,0,undef,0>
2250 /// TODO: Optionally allow length-changing shuffles.
2251 /// TODO: Optionally allow splats from other elements.
2252 bool isZeroEltSplat() const {
2253 return !changesLength() && isZeroEltSplatMask(ShuffleMask);
2254 }
2255
2256 /// Return true if this shuffle mask is a transpose mask.
2257 /// Transpose vector masks transpose a 2xn matrix. They read corresponding
2258 /// even- or odd-numbered vector elements from two n-dimensional source
2259 /// vectors and write each result into consecutive elements of an
2260 /// n-dimensional destination vector. Two shuffles are necessary to complete
2261 /// the transpose, one for the even elements and another for the odd elements.
2262 /// This description closely follows how the TRN1 and TRN2 AArch64
2263 /// instructions operate.
2264 ///
2265 /// For example, a simple 2x2 matrix can be transposed with:
2266 ///
2267 /// ; Original matrix
2268 /// m0 = < a, b >
2269 /// m1 = < c, d >
2270 ///
2271 /// ; Transposed matrix
2272 /// t0 = < a, c > = shufflevector m0, m1, < 0, 2 >
2273 /// t1 = < b, d > = shufflevector m0, m1, < 1, 3 >
2274 ///
2275 /// For matrices having greater than n columns, the resulting nx2 transposed
2276 /// matrix is stored in two result vectors such that one vector contains
2277 /// interleaved elements from all the even-numbered rows and the other vector
2278 /// contains interleaved elements from all the odd-numbered rows. For example,
2279 /// a 2x4 matrix can be transposed with:
2280 ///
2281 /// ; Original matrix
2282 /// m0 = < a, b, c, d >
2283 /// m1 = < e, f, g, h >
2284 ///
2285 /// ; Transposed matrix
2286 /// t0 = < a, e, c, g > = shufflevector m0, m1 < 0, 4, 2, 6 >
2287 /// t1 = < b, f, d, h > = shufflevector m0, m1 < 1, 5, 3, 7 >
2288 static bool isTransposeMask(ArrayRef<int> Mask);
2289 static bool isTransposeMask(const Constant *Mask) {
2290 assert(Mask->getType()->isVectorTy() && "Shuffle needs vector constant.");
2291 SmallVector<int, 16> MaskAsInts;
2292 getShuffleMask(Mask, MaskAsInts);
2293 return isTransposeMask(MaskAsInts);
2294 }
2295
2296 /// Return true if this shuffle transposes the elements of its inputs without
2297 /// changing the length of the vectors. This operation may also be known as a
2298 /// merge or interleave. See the description for isTransposeMask() for the
2299 /// exact specification.
2300 /// Example: shufflevector <4 x n> A, <4 x n> B, <0,4,2,6>
2301 bool isTranspose() const {
2302 return !changesLength() && isTransposeMask(ShuffleMask);
2303 }
2304
2305 /// Return true if this shuffle mask is a splice mask, concatenating the two
2306 /// inputs together and then extracts an original width vector starting from
2307 /// the splice index.
2308 /// Example: shufflevector <4 x n> A, <4 x n> B, <1,2,3,4>
2309 static bool isSpliceMask(ArrayRef<int> Mask, int &Index);
2310 static bool isSpliceMask(const Constant *Mask, int &Index) {
2311 assert(Mask->getType()->isVectorTy() && "Shuffle needs vector constant.");
2312 SmallVector<int, 16> MaskAsInts;
2313 getShuffleMask(Mask, MaskAsInts);
2314 return isSpliceMask(MaskAsInts, Index);
2315 }
2316
2317 /// Return true if this shuffle splices two inputs without changing the length
2318 /// of the vectors. This operation concatenates the two inputs together and
2319 /// then extracts an original width vector starting from the splice index.
2320 /// Example: shufflevector <4 x n> A, <4 x n> B, <1,2,3,4>
2321 bool isSplice(int &Index) const {
2322 return !changesLength() && isSpliceMask(ShuffleMask, Index);
2323 }
2324
2325 /// Return true if this shuffle mask is an extract subvector mask.
2326 /// A valid extract subvector mask returns a smaller vector from a single
2327 /// source operand. The base extraction index is returned as well.
2328 static bool isExtractSubvectorMask(ArrayRef<int> Mask, int NumSrcElts,
2329 int &Index);
2330 static bool isExtractSubvectorMask(const Constant *Mask, int NumSrcElts,
2331 int &Index) {
2332 assert(Mask->getType()->isVectorTy() && "Shuffle needs vector constant.");
2333 // Not possible to express a shuffle mask for a scalable vector for this
2334 // case.
2335 if (isa<ScalableVectorType>(Mask->getType()))
2336 return false;
2337 SmallVector<int, 16> MaskAsInts;
2338 getShuffleMask(Mask, MaskAsInts);
2339 return isExtractSubvectorMask(MaskAsInts, NumSrcElts, Index);
2340 }
2341
2342 /// Return true if this shuffle mask is an extract subvector mask.
2344 // Not possible to express a shuffle mask for a scalable vector for this
2345 // case.
2346 if (isa<ScalableVectorType>(getType()))
2347 return false;
2348
2349 int NumSrcElts =
2350 cast<FixedVectorType>(Op<0>()->getType())->getNumElements();
2351 return isExtractSubvectorMask(ShuffleMask, NumSrcElts, Index);
2352 }
2353
2354 /// Return true if this shuffle mask is an insert subvector mask.
2355 /// A valid insert subvector mask inserts the lowest elements of a second
2356 /// source operand into an in-place first source operand operand.
2357 /// Both the sub vector width and the insertion index is returned.
2358 static bool isInsertSubvectorMask(ArrayRef<int> Mask, int NumSrcElts,
2359 int &NumSubElts, int &Index);
2360 static bool isInsertSubvectorMask(const Constant *Mask, int NumSrcElts,
2361 int &NumSubElts, int &Index) {
2362 assert(Mask->getType()->isVectorTy() && "Shuffle needs vector constant.");
2363 // Not possible to express a shuffle mask for a scalable vector for this
2364 // case.
2365 if (isa<ScalableVectorType>(Mask->getType()))
2366 return false;
2367 SmallVector<int, 16> MaskAsInts;
2368 getShuffleMask(Mask, MaskAsInts);
2369 return isInsertSubvectorMask(MaskAsInts, NumSrcElts, NumSubElts, Index);
2370 }
2371
2372 /// Return true if this shuffle mask is an insert subvector mask.
2373 bool isInsertSubvectorMask(int &NumSubElts, int &Index) const {
2374 // Not possible to express a shuffle mask for a scalable vector for this
2375 // case.
2376 if (isa<ScalableVectorType>(getType()))
2377 return false;
2378
2379 int NumSrcElts =
2380 cast<FixedVectorType>(Op<0>()->getType())->getNumElements();
2381 return isInsertSubvectorMask(ShuffleMask, NumSrcElts, NumSubElts, Index);
2382 }
2383
2384 /// Return true if this shuffle mask replicates each of the \p VF elements
2385 /// in a vector \p ReplicationFactor times.
2386 /// For example, the mask for \p ReplicationFactor=3 and \p VF=4 is:
2387 /// <0,0,0,1,1,1,2,2,2,3,3,3>
2388 static bool isReplicationMask(ArrayRef<int> Mask, int &ReplicationFactor,
2389 int &VF);
2390 static bool isReplicationMask(const Constant *Mask, int &ReplicationFactor,
2391 int &VF) {
2392 assert(Mask->getType()->isVectorTy() && "Shuffle needs vector constant.");
2393 // Not possible to express a shuffle mask for a scalable vector for this
2394 // case.
2395 if (isa<ScalableVectorType>(Mask->getType()))
2396 return false;
2397 SmallVector<int, 16> MaskAsInts;
2398 getShuffleMask(Mask, MaskAsInts);
2399 return isReplicationMask(MaskAsInts, ReplicationFactor, VF);
2400 }
2401
2402 /// Return true if this shuffle mask is a replication mask.
2403 bool isReplicationMask(int &ReplicationFactor, int &VF) const;
2404
2405 /// Return true if this shuffle mask represents "clustered" mask of size VF,
2406 /// i.e. each index between [0..VF) is used exactly once in each submask of
2407 /// size VF.
2408 /// For example, the mask for \p VF=4 is:
2409 /// 0, 1, 2, 3, 3, 2, 0, 1 - "clustered", because each submask of size 4
2410 /// (0,1,2,3 and 3,2,0,1) uses indices [0..VF) exactly one time.
2411 /// 0, 1, 2, 3, 3, 3, 1, 0 - not "clustered", because
2412 /// element 3 is used twice in the second submask
2413 /// (3,3,1,0) and index 2 is not used at all.
2414 static bool isOneUseSingleSourceMask(ArrayRef<int> Mask, int VF);
2415
2416 /// Return true if this shuffle mask is a one-use-single-source("clustered")
2417 /// mask.
2418 bool isOneUseSingleSourceMask(int VF) const;
2419
2420 /// Change values in a shuffle permute mask assuming the two vector operands
2421 /// of length InVecNumElts have swapped position.
2423 unsigned InVecNumElts) {
2424 for (int &Idx : Mask) {
2425 if (Idx == -1)
2426 continue;
2427 Idx = Idx < (int)InVecNumElts ? Idx + InVecNumElts : Idx - InVecNumElts;
2428 assert(Idx >= 0 && Idx < (int)InVecNumElts * 2 &&
2429 "shufflevector mask index out of range");
2430 }
2431 }
2432
2433 /// Return if this shuffle interleaves its two input vectors together.
2434 bool isInterleave(unsigned Factor);
2435
2436 /// Return true if the mask interleaves one or more input vectors together.
2437 ///
2438 /// I.e. <0, LaneLen, ... , LaneLen*(Factor - 1), 1, LaneLen + 1, ...>
2439 /// E.g. For a Factor of 2 (LaneLen=4):
2440 /// <0, 4, 1, 5, 2, 6, 3, 7>
2441 /// E.g. For a Factor of 3 (LaneLen=4):
2442 /// <4, 0, 9, 5, 1, 10, 6, 2, 11, 7, 3, 12>
2443 /// E.g. For a Factor of 4 (LaneLen=2):
2444 /// <0, 2, 6, 4, 1, 3, 7, 5>
2445 ///
2446 /// NumInputElts is the total number of elements in the input vectors.
2447 ///
2448 /// StartIndexes are the first indexes of each vector being interleaved,
2449 /// substituting any indexes that were undef
2450 /// E.g. <4, -1, 2, 5, 1, 3> (Factor=3): StartIndexes=<4, 0, 2>
2451 ///
2452 /// Note that this does not check if the input vectors are consecutive:
2453 /// It will return true for masks such as
2454 /// <0, 4, 6, 1, 5, 7> (Factor=3, LaneLen=2)
2455 static bool isInterleaveMask(ArrayRef<int> Mask, unsigned Factor,
2456 unsigned NumInputElts,
2457 SmallVectorImpl<unsigned> &StartIndexes);
2458 static bool isInterleaveMask(ArrayRef<int> Mask, unsigned Factor,
2459 unsigned NumInputElts) {
2460 SmallVector<unsigned, 8> StartIndexes;
2461 return isInterleaveMask(Mask, Factor, NumInputElts, StartIndexes);
2462 }
2463
2464 // Methods for support type inquiry through isa, cast, and dyn_cast:
2465 static bool classof(const Instruction *I) {
2466 return I->getOpcode() == Instruction::ShuffleVector;
2467 }
2468 static bool classof(const Value *V) {
2469 return isa<Instruction>(V) && classof(cast<Instruction>(V));
2470 }
2471};
2472
2473template <>
2475 : public FixedNumOperandTraits<ShuffleVectorInst, 2> {};
2476
2478
2479//===----------------------------------------------------------------------===//
2480// ExtractValueInst Class
2481//===----------------------------------------------------------------------===//
2482
2483/// This instruction extracts a struct member or array
2484/// element value from an aggregate value.
2485///
2488
2490
2491 /// Constructors - Create a extractvalue instruction with a base aggregate
2492 /// value and a list of indices. The first ctor can optionally insert before
2493 /// an existing instruction, the second appends the new instruction to the
2494 /// specified BasicBlock.
2495 inline ExtractValueInst(Value *Agg,
2496 ArrayRef<unsigned> Idxs,
2497 const Twine &NameStr,
2498 Instruction *InsertBefore);
2499 inline ExtractValueInst(Value *Agg,
2500 ArrayRef<unsigned> Idxs,
2501 const Twine &NameStr, BasicBlock *InsertAtEnd);
2502
2503 void init(ArrayRef<unsigned> Idxs, const Twine &NameStr);
2504
2505protected:
2506 // Note: Instruction needs to be a friend here to call cloneImpl.
2507 friend class Instruction;
2508
2509 ExtractValueInst *cloneImpl() const;
2510
2511public:
2513 ArrayRef<unsigned> Idxs,
2514 const Twine &NameStr = "",
2515 Instruction *InsertBefore = nullptr) {
2516 return new
2517 ExtractValueInst(Agg, Idxs, NameStr, InsertBefore);
2518 }
2519
2521 ArrayRef<unsigned> Idxs,
2522 const Twine &NameStr,
2523 BasicBlock *InsertAtEnd) {
2524 return new ExtractValueInst(Agg, Idxs, NameStr, InsertAtEnd);
2525 }
2526
2527 /// Returns the type of the element that would be extracted
2528 /// with an extractvalue instruction with the specified parameters.
2529 ///
2530 /// Null is returned if the indices are invalid for the specified type.
2531 static Type *getIndexedType(Type *Agg, ArrayRef<unsigned> Idxs);
2532
2533 using idx_iterator = const unsigned*;
2534
2535 inline idx_iterator idx_begin() const { return Indices.begin(); }
2536 inline idx_iterator idx_end() const { return Indices.end(); }
2538 return make_range(idx_begin(), idx_end());
2539 }
2540
2542 return getOperand(0);
2543 }
2545 return getOperand(0);
2546 }
2547 static unsigned getAggregateOperandIndex() {
2548 return 0U; // get index for modifying correct operand
2549 }
2550
2552 return Indices;
2553 }
2554
2555 unsigned getNumIndices() const {
2556 return (unsigned)Indices.size();
2557 }
2558
2559 bool hasIndices() const {
2560 return true;
2561 }
2562
2563 // Methods for support type inquiry through isa, cast, and dyn_cast:
2564 static bool classof(const Instruction *I) {
2565 return I->getOpcode() == Instruction::ExtractValue;
2566 }
2567 static bool classof(const Value *V) {
2568 return isa<Instruction>(V) && classof(cast<Instruction>(V));
2569 }
2570};
2571
2572ExtractValueInst::ExtractValueInst(Value *Agg,
2573 ArrayRef<unsigned> Idxs,
2574 const Twine &NameStr,
2575 Instruction *InsertBefore)
2576 : UnaryInstruction(checkGEPType(getIndexedType(Agg->getType(), Idxs)),
2577 ExtractValue, Agg, InsertBefore) {
2578 init(Idxs, NameStr);
2579}
2580
2581ExtractValueInst::ExtractValueInst(Value *Agg,
2582 ArrayRef<unsigned> Idxs,
2583 const Twine &NameStr,
2584 BasicBlock *InsertAtEnd)
2585 : UnaryInstruction(checkGEPType(getIndexedType(Agg->getType(), Idxs)),
2586 ExtractValue, Agg, InsertAtEnd) {
2587 init(Idxs, NameStr);
2588}
2589
2590//===----------------------------------------------------------------------===//
2591// InsertValueInst Class
2592//===----------------------------------------------------------------------===//
2593
2594/// This instruction inserts a struct field of array element
2595/// value into an aggregate value.
2596///
2599
2600 InsertValueInst(const InsertValueInst &IVI);
2601
2602 /// Constructors - Create a insertvalue instruction with a base aggregate
2603 /// value, a value to insert, and a list of indices. The first ctor can
2604 /// optionally insert before an existing instruction, the second appends
2605 /// the new instruction to the specified BasicBlock.
2606 inline InsertValueInst(Value *Agg, Value *Val,
2607 ArrayRef<unsigned> Idxs,
2608 const Twine &NameStr,
2609 Instruction *InsertBefore);
2610 inline InsertValueInst(Value *Agg, Value *Val,
2611 ArrayRef<unsigned> Idxs,
2612 const Twine &NameStr, BasicBlock *InsertAtEnd);
2613
2614 /// Constructors - These two constructors are convenience methods because one
2615 /// and two index insertvalue instructions are so common.
2616 InsertValueInst(Value *Agg, Value *Val, unsigned Idx,
2617 const Twine &NameStr = "",
2618 Instruction *InsertBefore = nullptr);
2619 InsertValueInst(Value *Agg, Value *Val, unsigned Idx, const Twine &NameStr,
2620 BasicBlock *InsertAtEnd);
2621
2622 void init(Value *Agg, Value *Val, ArrayRef<unsigned> Idxs,
2623 const Twine &NameStr);
2624
2625protected:
2626 // Note: Instruction needs to be a friend here to call cloneImpl.
2627 friend class Instruction;
2628
2629 InsertValueInst *cloneImpl() const;
2630
2631public:
2632 // allocate space for exactly two operands
2633 void *operator new(size_t S) { return User::operator new(S, 2); }
2634 void operator delete(void *Ptr) { User::operator delete(Ptr); }
2635
2636 static InsertValueInst *Create(Value *Agg, Value *Val,
2637 ArrayRef<unsigned> Idxs,
2638 const Twine &NameStr = "",
2639 Instruction *InsertBefore = nullptr) {
2640 return new InsertValueInst(Agg, Val, Idxs, NameStr, InsertBefore);
2641 }
2642
2643 static InsertValueInst *Create(Value *Agg, Value *Val,
2644 ArrayRef<unsigned> Idxs,
2645 const Twine &NameStr,
2646 BasicBlock *InsertAtEnd) {
2647 return new InsertValueInst(Agg, Val, Idxs, NameStr, InsertAtEnd);
2648 }
2649
2650 /// Transparently provide more efficient getOperand methods.
2652
2653 using idx_iterator = const unsigned*;
2654
2655 inline idx_iterator idx_begin() const { return Indices.begin(); }
2656 inline idx_iterator idx_end() const { return Indices.end(); }
2658 return make_range(idx_begin(), idx_end());
2659 }
2660
2662 return getOperand(0);
2663 }
2665 return getOperand(0);
2666 }
2667 static unsigned getAggregateOperandIndex() {
2668 return 0U; // get index for modifying correct operand
2669 }
2670
2672 return getOperand(1);
2673 }
2675 return getOperand(1);
2676 }
2678 return 1U; // get index for modifying correct operand
2679 }
2680
2682 return Indices;
2683 }
2684
2685 unsigned getNumIndices() const {
2686 return (unsigned)Indices.size();
2687 }
2688
2689 bool hasIndices() const {
2690 return true;
2691 }
2692
2693 // Methods for support type inquiry through isa, cast, and dyn_cast:
2694 static bool classof(const Instruction *I) {
2695 return I->getOpcode() == Instruction::InsertValue;
2696 }
2697 static bool classof(const Value *V) {
2698 return isa<Instruction>(V) && classof(cast<Instruction>(V));
2699 }
2700};
2701
2702template <>
2704 public FixedNumOperandTraits<InsertValueInst, 2> {
2705};
2706
2707InsertValueInst::InsertValueInst(Value *Agg,
2708 Value *Val,
2709 ArrayRef<unsigned> Idxs,
2710 const Twine &NameStr,
2711 Instruction *InsertBefore)
2712 : Instruction(Agg->getType(), InsertValue,
2713 OperandTraits<InsertValueInst>::op_begin(this),
2714 2, InsertBefore) {
2715 init(Agg, Val, Idxs, NameStr);
2716}
2717
2718InsertValueInst::InsertValueInst(Value *Agg,
2719 Value *Val,
2720 ArrayRef<unsigned> Idxs,
2721 const Twine &NameStr,
2722 BasicBlock *InsertAtEnd)
2723 : Instruction(Agg->getType(), InsertValue,
2724 OperandTraits<InsertValueInst>::op_begin(this),
2725 2, InsertAtEnd) {
2726 init(Agg, Val, Idxs, NameStr);
2727}
2728
2729DEFINE_TRANSPARENT_OPERAND_ACCESSORS(InsertValueInst, Value)
2730
2731//===----------------------------------------------------------------------===//
2732// PHINode Class
2733//===----------------------------------------------------------------------===//
2734
2735// PHINode - The PHINode class is used to represent the magical mystical PHI
2736// node, that can not exist in nature, but can be synthesized in a computer
2737// scientist's overactive imagination.
2738//
2739class PHINode : public Instruction {
2740 /// The number of operands actually allocated. NumOperands is
2741 /// the number actually in use.
2742 unsigned ReservedSpace;
2743
2744 PHINode(const PHINode &PN);
2745
2746 explicit PHINode(Type *Ty, unsigned NumReservedValues,
2747 const Twine &NameStr = "",
2748 Instruction *InsertBefore = nullptr)
2749 : Instruction(Ty, Instruction::PHI, nullptr, 0, InsertBefore),
2750 ReservedSpace(NumReservedValues) {
2751 assert(!Ty->isTokenTy() && "PHI nodes cannot have token type!");
2752 setName(NameStr);
2753 allocHungoffUses(ReservedSpace);
2754 }
2755
2756 PHINode(Type *Ty, unsigned NumReservedValues, const Twine &NameStr,
2757 BasicBlock *InsertAtEnd)
2758 : Instruction(Ty, Instruction::PHI, nullptr, 0, InsertAtEnd),
2759 ReservedSpace(NumReservedValues) {
2760 assert(!Ty->isTokenTy() && "PHI nodes cannot have token type!");
2761 setName(NameStr);
2762 allocHungoffUses(ReservedSpace);
2763 }
2764
2765protected:
2766 // Note: Instruction needs to be a friend here to call cloneImpl.
2767 friend class Instruction;
2768
2769 PHINode *cloneImpl() const;
2770
2771 // allocHungoffUses - this is more complicated than the generic
2772 // User::allocHungoffUses, because we have to allocate Uses for the incoming
2773 // values and pointers to the incoming blocks, all in one allocation.
2774 void allocHungoffUses(unsigned N) {
2775 User::allocHungoffUses(N, /* IsPhi */ true);
2776 }
2777
2778public:
2779 /// Constructors - NumReservedValues is a hint for the number of incoming
2780 /// edges that this phi node will have (use 0 if you really have no idea).
2781 static PHINode *Create(Type *Ty, unsigned NumReservedValues,
2782 const Twine &NameStr = "",
2783 Instruction *InsertBefore = nullptr) {
2784 return new PHINode(Ty, NumReservedValues, NameStr, InsertBefore);
2785 }
2786
2787 static PHINode *Create(Type *Ty, unsigned NumReservedValues,
2788 const Twine &NameStr, BasicBlock *InsertAtEnd) {
2789 return new PHINode(Ty, NumReservedValues, NameStr, InsertAtEnd);
2790 }
2791
2792 /// Provide fast operand accessors
2794
2795 // Block iterator interface. This provides access to the list of incoming
2796 // basic blocks, which parallels the list of incoming values.
2797 // Please note that we are not providing non-const iterators for blocks to
2798 // force all updates go through an interface function.
2799
2802
2804 return reinterpret_cast<const_block_iterator>(op_begin() + ReservedSpace);
2805 }
2806
2808 return block_begin() + getNumOperands();
2809 }
2810
2812 return make_range(block_begin(), block_end());
2813 }
2814
2815 op_range incoming_values() { return operands(); }
2816
2817 const_op_range incoming_values() const { return operands(); }
2818
2819 /// Return the number of incoming edges
2820 ///
2821 unsigned getNumIncomingValues() const { return getNumOperands(); }
2822
2823 /// Return incoming value number x
2824 ///
2825 Value *getIncomingValue(unsigned i) const {
2826 return getOperand(i);
2827 }
2828 void setIncomingValue(unsigned i, Value *V) {
2829 assert(V && "PHI node got a null value!");
2830 assert(getType() == V->getType() &&
2831 "All operands to PHI node must be the same type as the PHI node!");
2832 setOperand(i, V);
2833 }
2834
2835 static unsigned getOperandNumForIncomingValue(unsigned i) {
2836 return i;
2837 }
2838
2839 static unsigned getIncomingValueNumForOperand(unsigned i) {
2840 return i;
2841 }
2842
2843 /// Return incoming basic block number @p i.
2844 ///
2845 BasicBlock *getIncomingBlock(unsigned i) const {
2846 return block_begin()[i];
2847 }
2848
2849 /// Return incoming basic block corresponding
2850 /// to an operand of the PHI.
2851 ///
2853 assert(this == U.getUser() && "Iterator doesn't point to PHI's Uses?");
2854 return getIncomingBlock(unsigned(&U - op_begin()));
2855 }
2856
2857 /// Return incoming basic block corresponding
2858 /// to value use iterator.
2859 ///
2861 return getIncomingBlock(I.getUse());
2862 }
2863
2864 void setIncomingBlock(unsigned i, BasicBlock *BB) {
2865 const_cast<block_iterator>(block_begin())[i] = BB;
2866 }
2867
2868 /// Copies the basic blocks from \p BBRange to the incoming basic block list
2869 /// of this PHINode, starting at \p ToIdx.
2871 uint32_t ToIdx = 0) {
2872 copy(BBRange, const_cast<block_iterator>(block_begin()) + ToIdx);
2873 }
2874
2875 /// Replace every incoming basic block \p Old to basic block \p New.
2877 assert(New && Old && "PHI node got a null basic block!");
2878 for (unsigned Op = 0, NumOps = getNumOperands(); Op != NumOps; ++Op)
2879 if (getIncomingBlock(Op) == Old)
2880 setIncomingBlock(Op, New);
2881 }
2882
2883 /// Add an incoming value to the end of the PHI list
2884 ///
2886 if (getNumOperands() == ReservedSpace)
2887 growOperands(); // Get more space!
2888 // Initialize some new operands.
2889 setNumHungOffUseOperands(getNumOperands() + 1);
2890 setIncomingValue(getNumOperands() - 1, V);
2891 setIncomingBlock(getNumOperands() - 1, BB);
2892 }
2893
2894 /// Remove an incoming value. This is useful if a
2895 /// predecessor basic block is deleted. The value removed is returned.
2896 ///
2897 /// If the last incoming value for a PHI node is removed (and DeletePHIIfEmpty
2898 /// is true), the PHI node is destroyed and any uses of it are replaced with
2899 /// dummy values. The only time there should be zero incoming values to a PHI
2900 /// node is when the block is dead, so this strategy is sound.
2901 ///
2902 Value *removeIncomingValue(unsigned Idx, bool DeletePHIIfEmpty = true);
2903
2904 Value *removeIncomingValue(const BasicBlock *BB, bool DeletePHIIfEmpty=true) {
2905 int Idx = getBasicBlockIndex(BB);
2906 assert(Idx >= 0 && "Invalid basic block argument to remove!");
2907 return removeIncomingValue(Idx, DeletePHIIfEmpty);
2908 }
2909
2910 /// Return the first index of the specified basic
2911 /// block in the value list for this PHI. Returns -1 if no instance.
2912 ///
2913 int getBasicBlockIndex(const BasicBlock *BB) const {
2914 for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
2915 if (block_begin()[i] == BB)
2916 return i;
2917 return -1;
2918 }
2919
2921 int Idx = getBasicBlockIndex(BB);
2922 assert(Idx >= 0 && "Invalid basic block argument!");
2923 return getIncomingValue(Idx);
2924 }
2925
2926 /// Set every incoming value(s) for block \p BB to \p V.
2928 assert(BB && "PHI node got a null basic block!");
2929 bool Found = false;
2930 for (unsigned Op = 0, NumOps = getNumOperands(); Op != NumOps; ++Op)
2931 if (getIncomingBlock(Op) == BB) {
2932 Found = true;
2933 setIncomingValue(Op, V);
2934 }
2935 (void)Found;
2936 assert(Found && "Invalid basic block argument to set!");
2937 }
2938
2939 /// If the specified PHI node always merges together the
2940 /// same value, return the value, otherwise return null.
2941 Value *hasConstantValue() const;
2942
2943 /// Whether the specified PHI node always merges
2944 /// together the same value, assuming undefs are equal to a unique
2945 /// non-undef value.
2946 bool hasConstantOrUndefValue() const;
2947
2948 /// If the PHI node is complete which means all of its parent's predecessors
2949 /// have incoming value in this PHI, return true, otherwise return false.
2950 bool isComplete() const {
2952 [this](const BasicBlock *Pred) {
2953 return getBasicBlockIndex(Pred) >= 0;
2954 });
2955 }
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::PHI;
2960 }
2961 static bool classof(const Value *V) {
2962 return isa<Instruction>(V) && classof(cast<Instruction>(V));
2963 }
2964
2965private:
2966 void growOperands();
2967};
2968
2969template <>
2971};
2972
2974
2975//===----------------------------------------------------------------------===//
2976// LandingPadInst Class
2977//===----------------------------------------------------------------------===//
2978
2979//===---------------------------------------------------------------------------
2980/// The landingpad instruction holds all of the information
2981/// necessary to generate correct exception handling. The landingpad instruction
2982/// cannot be moved from the top of a landing pad block, which itself is
2983/// accessible only from the 'unwind' edge of an invoke. This uses the
2984/// SubclassData field in Value to store whether or not the landingpad is a
2985/// cleanup.
2986///
2988 using CleanupField = BoolBitfieldElementT<0>;
2989
2990 /// The number of operands actually allocated. NumOperands is
2991 /// the number actually in use.
2992 unsigned ReservedSpace;
2993
2994 LandingPadInst(const LandingPadInst &LP);
2995
2996public:
2998
2999private:
3000 explicit LandingPadInst(Type *RetTy, unsigned NumReservedValues,
3001 const Twine &NameStr, Instruction *InsertBefore);
3002 explicit LandingPadInst(Type *RetTy, unsigned NumReservedValues,
3003 const Twine &NameStr, BasicBlock *InsertAtEnd);
3004
3005 // Allocate space for exactly zero operands.
3006 void *operator new(size_t S) { return User::operator new(S); }
3007
3008 void growOperands(unsigned Size);
3009 void init(unsigned NumReservedValues, const Twine &NameStr);
3010
3011protected:
3012 // Note: Instruction needs to be a friend here to call cloneImpl.
3013 friend class Instruction;
3014
3015 LandingPadInst *cloneImpl() const;
3016
3017public:
3018 void operator delete(void *Ptr) { User::operator delete(Ptr); }
3019
3020 /// Constructors - NumReservedClauses is a hint for the number of incoming
3021 /// clauses that this landingpad will have (use 0 if you really have no idea).
3022 static LandingPadInst *Create(Type *RetTy, unsigned NumReservedClauses,
3023 const Twine &NameStr = "",
3024 Instruction *InsertBefore = nullptr);
3025 static LandingPadInst *Create(Type *RetTy, unsigned NumReservedClauses,
3026 const Twine &NameStr, BasicBlock *InsertAtEnd);
3027
3028 /// Provide fast operand accessors
3030
3031 /// Return 'true' if this landingpad instruction is a
3032 /// cleanup. I.e., it should be run when unwinding even if its landing pad
3033 /// doesn't catch the exception.
3034 bool isCleanup() const { return getSubclassData<CleanupField>(); }
3035
3036 /// Indicate that this landingpad instruction is a cleanup.
3037 void setCleanup(bool V) { setSubclassData<CleanupField>(V); }
3038
3039 /// Add a catch or filter clause to the landing pad.
3040 void addClause(Constant *ClauseVal);
3041
3042 /// Get the value of the clause at index Idx. Use isCatch/isFilter to
3043 /// determine what type of clause this is.
3044 Constant *getClause(unsigned Idx) const {
3045 return cast<Constant>(getOperandList()[Idx]);
3046 }
3047
3048 /// Return 'true' if the clause and index Idx is a catch clause.
3049 bool isCatch(unsigned Idx) const {
3050 return !isa<ArrayType>(getOperandList()[Idx]->getType());
3051 }
3052
3053 /// Return 'true' if the clause and index Idx is a filter clause.
3054 bool isFilter(unsigned Idx) const {
3055 return isa<ArrayType>(getOperandList()[Idx]->getType());
3056 }
3057
3058 /// Get the number of clauses for this landing pad.
3059 unsigned getNumClauses() const { return getNumOperands(); }
3060
3061 /// Grow the size of the operand list to accommodate the new
3062 /// number of clauses.
3063 void reserveClauses(unsigned Size) { growOperands(Size); }
3064
3065 // Methods for support type inquiry through isa, cast, and dyn_cast:
3066 static bool classof(const Instruction *I) {
3067 return I->getOpcode() == Instruction::LandingPad;
3068 }
3069 static bool classof(const Value *V) {
3070 return isa<Instruction>(V) && classof(cast<Instruction>(V));
3071 }
3072};
3073
3074template <>
3076};
3077
3079
3080//===----------------------------------------------------------------------===//
3081// ReturnInst Class
3082//===----------------------------------------------------------------------===//
3083
3084//===---------------------------------------------------------------------------
3085/// Return a value (possibly void), from a function. Execution
3086/// does not continue in this function any longer.
3087///
3088class ReturnInst : public Instruction {
3089 ReturnInst(const ReturnInst &RI);
3090
3091private:
3092 // ReturnInst constructors:
3093 // ReturnInst() - 'ret void' instruction
3094 // ReturnInst( null) - 'ret void' instruction
3095 // ReturnInst(Value* X) - 'ret X' instruction
3096 // ReturnInst( null, Inst *I) - 'ret void' instruction, insert before I
3097 // ReturnInst(Value* X, Inst *I) - 'ret X' instruction, insert before I
3098 // ReturnInst( null, BB *B) - 'ret void' instruction, insert @ end of B
3099 // ReturnInst(Value* X, BB *B) - 'ret X' instruction, insert @ end of B
3100 //
3101 // NOTE: If the Value* passed is of type void then the constructor behaves as
3102 // if it was passed NULL.
3103 explicit ReturnInst(LLVMContext &C, Value *retVal = nullptr,
3104 Instruction *InsertBefore = nullptr);
3105 ReturnInst(LLVMContext &C, Value *retVal, BasicBlock *InsertAtEnd);
3106 explicit ReturnInst(LLVMContext &C, BasicBlock *InsertAtEnd);
3107
3108protected:
3109 // Note: Instruction needs to be a friend here to call cloneImpl.
3110 friend class Instruction;
3111
3112 ReturnInst *cloneImpl() const;
3113
3114public:
3115 static ReturnInst* Create(LLVMContext &C, Value *retVal = nullptr,
3116 Instruction *InsertBefore = nullptr) {
3117 return new(!!retVal) ReturnInst(C, retVal, InsertBefore);
3118 }
3119
3121 BasicBlock *InsertAtEnd) {
3122 return new(!!retVal) ReturnInst(C, retVal, InsertAtEnd);
3123 }
3124
3125 static ReturnInst* Create(LLVMContext &C, BasicBlock *InsertAtEnd) {
3126 return new(0) ReturnInst(C, InsertAtEnd);
3127 }
3128
3129 /// Provide fast operand accessors
3131
3132 /// Convenience accessor. Returns null if there is no return value.
3134 return getNumOperands() != 0 ? getOperand(0) : nullptr;
3135 }
3136
3137 unsigned getNumSuccessors() const { return 0; }
3138
3139 // Methods for support type inquiry through isa, cast, and dyn_cast:
3140 static bool classof(const Instruction *I) {
3141 return (I->getOpcode() == Instruction::Ret);
3142 }
3143 static bool classof(const Value *V) {
3144 return isa<Instruction>(V) && classof(cast<Instruction>(V));
3145 }
3146
3147private:
3148 BasicBlock *getSuccessor(unsigned idx) const {
3149 llvm_unreachable("ReturnInst has no successors!");
3150 }
3151
3152 void setSuccessor(unsigned idx, BasicBlock *B) {
3153 llvm_unreachable("ReturnInst has no successors!");
3154 }
3155};
3156
3157template <>
3158struct OperandTraits<ReturnInst> : public VariadicOperandTraits<ReturnInst> {
3159};
3160
3162
3163//===----------------------------------------------------------------------===//
3164// BranchInst Class
3165//===----------------------------------------------------------------------===//
3166
3167//===---------------------------------------------------------------------------
3168/// Conditional or Unconditional Branch instruction.
3169///
3170class BranchInst : public Instruction {
3171 /// Ops list - Branches are strange. The operands are ordered:
3172 /// [Cond, FalseDest,] TrueDest. This makes some accessors faster because
3173 /// they don't have to check for cond/uncond branchness. These are mostly
3174 /// accessed relative from op_end().
3175 BranchInst(const BranchInst &BI);
3176 // BranchInst constructors (where {B, T, F} are blocks, and C is a condition):
3177 // BranchInst(BB *B) - 'br B'
3178 // BranchInst(BB* T, BB *F, Value *C) - 'br C, T, F'
3179 // BranchInst(BB* B, Inst *I) - 'br B' insert before I
3180 // BranchInst(BB* T, BB *F, Value *C, Inst *I) - 'br C, T, F', insert before I
3181 // BranchInst(BB* B, BB *I) - 'br B' insert at end
3182 // BranchInst(BB* T, BB *F, Value *C, BB *I) - 'br C, T, F', insert at end
3183 explicit BranchInst(BasicBlock *IfTrue, Instruction *InsertBefore = nullptr);
3184 BranchInst(BasicBlock *IfTrue, BasicBlock *IfFalse, Value *Cond,
3185 Instruction *InsertBefore = nullptr);
3186 BranchInst(BasicBlock *IfTrue, BasicBlock *InsertAtEnd);
3187 BranchInst(BasicBlock *IfTrue, BasicBlock *IfFalse, Value *Cond,
3188 BasicBlock *InsertAtEnd);
3189
3190 void AssertOK();
3191
3192protected:
3193 // Note: Instruction needs to be a friend here to call cloneImpl.
3194 friend class Instruction;
3195
3196 BranchInst *cloneImpl() const;
3197
3198public:
3199 /// Iterator type that casts an operand to a basic block.
3200 ///
3201 /// This only makes sense because the successors are stored as adjacent
3202 /// operands for branch instructions.
3204 : iterator_adaptor_base<succ_op_iterator, value_op_iterator,
3205 std::random_access_iterator_tag, BasicBlock *,
3206 ptrdiff_t, BasicBlock *, BasicBlock *> {
3208
3209 BasicBlock *operator*() const { return cast<BasicBlock>(*I); }
3210 BasicBlock *operator->() const { return operator*(); }
3211 };
3212
3213 /// The const version of `succ_op_iterator`.
3215 : iterator_adaptor_base<const_succ_op_iterator, const_value_op_iterator,
3216 std::random_access_iterator_tag,
3217 const BasicBlock *, ptrdiff_t, const BasicBlock *,
3218 const BasicBlock *> {
3221
3222 const BasicBlock *operator*() const { return cast<BasicBlock>(*I); }
3223 const BasicBlock *operator->() const { return operator*(); }
3224 };
3225
3227 Instruction *InsertBefore = nullptr) {
3228 return new(1) BranchInst(IfTrue, InsertBefore);
3229 }
3230
3231 static BranchInst *Create(BasicBlock *IfTrue, BasicBlock *IfFalse,
3232 Value *Cond, Instruction *InsertBefore = nullptr) {
3233 return new(3) BranchInst(IfTrue, IfFalse, Cond, InsertBefore);
3234 }
3235
3236 static BranchInst *Create(BasicBlock *IfTrue, BasicBlock *InsertAtEnd) {
3237 return new(1) BranchInst(IfTrue, InsertAtEnd);
3238 }
3239
3240 static BranchInst *Create(BasicBlock *IfTrue, BasicBlock *IfFalse,
3241 Value *Cond, BasicBlock *InsertAtEnd) {
3242 return new(3) BranchInst(IfTrue, IfFalse, Cond, InsertAtEnd);
3243 }
3244
3245 /// Transparently provide more efficient getOperand methods.
3247
3248 bool isUnconditional() const { return getNumOperands() == 1; }
3249 bool isConditional() const { return getNumOperands() == 3; }
3250
3252 assert(isConditional() && "Cannot get condition of an uncond branch!");
3253 return Op<-3>();
3254 }
3255
3257 assert(isConditional() && "Cannot set condition of unconditional branch!");
3258 Op<-3>() = V;
3259 }
3260
3261 unsigned getNumSuccessors() const { return 1+isConditional(); }
3262
3263 BasicBlock *getSuccessor(unsigned i) const {
3264 assert(i < getNumSuccessors() && "Successor # out of range for Branch!");
3265 return cast_or_null<BasicBlock>((&Op<-1>() - i)->get());
3266 }
3267
3268 void setSuccessor(unsigned idx, BasicBlock *NewSucc) {
3269 assert(idx < getNumSuccessors() && "Successor # out of range for Branch!");
3270 *(&Op<-1>() - idx) = NewSucc;
3271 }
3272
3273 /// Swap the successors of this branch instruction.
3274 ///
3275 /// Swaps the successors of the branch instruction. This also swaps any
3276 /// branch weight metadata associated with the instruction so that it
3277 /// continues to map correctly to each operand.
3278 void swapSuccessors();
3279
3281 return make_range(
3282 succ_op_iterator(std::next(value_op_begin(), isConditional() ? 1 : 0)),
3283 succ_op_iterator(value_op_end()));
3284 }
3285
3288 std::next(value_op_begin(), isConditional() ? 1 : 0)),
3289 const_succ_op_iterator(value_op_end()));
3290 }
3291
3292 // Methods for support type inquiry through isa, cast, and dyn_cast:
3293 static bool classof(const Instruction *I) {
3294 return (I->getOpcode() == Instruction::Br);
3295 }
3296 static bool classof(const Value *V) {
3297 return isa<Instruction>(V) && classof(cast<Instruction>(V));
3298 }
3299};
3300
3301template <>
3302struct OperandTraits<BranchInst> : public VariadicOperandTraits<BranchInst, 1> {
3303};
3304
3306
3307//===----------------------------------------------------------------------===//
3308// SwitchInst Class
3309//===----------------------------------------------------------------------===//
3310
3311//===---------------------------------------------------------------------------
3312/// Multiway switch
3313///
3314class SwitchInst : public Instruction {
3315 unsigned ReservedSpace;
3316
3317 // Operand[0] = Value to switch on
3318 // Operand[1] = Default basic block destination
3319 // Operand[2n ] = Value to match
3320 // Operand[2n+1] = BasicBlock to go to on match
3321 SwitchInst(const SwitchInst &SI);
3322
3323 /// Create a new switch instruction, specifying a value to switch on and a
3324 /// default destination. The number of additional cases can be specified here
3325 /// to make memory allocation more efficient. This constructor can also
3326 /// auto-insert before another instruction.
3327 SwitchInst(Value *Value, BasicBlock *Default, unsigned NumCases,
3328 Instruction *InsertBefore);
3329
3330 /// Create a new switch instruction, specifying a value to switch on and a
3331 /// default destination. The number of additional cases can be specified here
3332 /// to make memory allocation more efficient. This constructor also
3333 /// auto-inserts at the end of the specified BasicBlock.
3334 SwitchInst(Value *Value, BasicBlock *Default, unsigned NumCases,
3335 BasicBlock *InsertAtEnd);
3336
3337 // allocate space for exactly zero operands
3338 void *operator new(size_t S) { return User::operator new(S); }
3339
3340 void init(Value *Value, BasicBlock *Default, unsigned NumReserved);
3341 void growOperands();
3342
3343protected:
3344 // Note: Instruction needs to be a friend here to call cloneImpl.
3345 friend class Instruction;
3346
3347 SwitchInst *cloneImpl() const;
3348
3349public:
3350 void operator delete(void *Ptr) { User::operator delete(Ptr); }
3351
3352 // -2
3353 static const unsigned DefaultPseudoIndex = static_cast<unsigned>(~0L-1);
3354
3355 template <typename CaseHandleT> class CaseIteratorImpl;
3356
3357 /// A handle to a particular switch case. It exposes a convenient interface
3358 /// to both the case value and the successor block.
3359 ///
3360 /// We define this as a template and instantiate it to form both a const and
3361 /// non-const handle.
3362 template <typename SwitchInstT, typename ConstantIntT, typename BasicBlockT>
3364 // Directly befriend both const and non-const iterators.
3365 friend class SwitchInst::CaseIteratorImpl<
3366 CaseHandleImpl<SwitchInstT, ConstantIntT, BasicBlockT>>;
3367
3368 protected:
3369 // Expose the switch type we're parameterized with to the iterator.
3370 using SwitchInstType = SwitchInstT;
3371
3372 SwitchInstT *SI;
3374
3375 CaseHandleImpl() = default;
3377
3378 public:
3379 /// Resolves case value for current case.
3380 ConstantIntT *getCaseValue() const {
3381 assert((unsigned)Index < SI->getNumCases() &&
3382 "Index out the number of cases.");
3383 return reinterpret_cast<ConstantIntT *>(SI->getOperand(2 + Index * 2));
3384 }
3385
3386 /// Resolves successor for current case.
3387 BasicBlockT *getCaseSuccessor() const {
3388 assert(((unsigned)Index < SI->getNumCases() ||
3389 (unsigned)Index == DefaultPseudoIndex) &&
3390 "Index out the number of cases.");
3391 return SI->getSuccessor(getSuccessorIndex());
3392 }
3393
3394 /// Returns number of current case.
3395 unsigned getCaseIndex() const { return Index; }
3396
3397 /// Returns successor index for current case successor.
3398 unsigned getSuccessorIndex() const {
3399 assert(((unsigned)Index == DefaultPseudoIndex ||
3400 (unsigned)Index < SI->getNumCases()) &&
3401 "Index out the number of cases.");
3402 return (unsigned)Index != DefaultPseudoIndex ? Index + 1 : 0;
3403 }
3404
3405 bool operator==(const CaseHandleImpl &RHS) const {
3406 assert(SI == RHS.SI && "Incompatible operators.");
3407 return Index == RHS.Index;
3408 }
3409 };
3410
3413
3415 : public CaseHandleImpl<SwitchInst, ConstantInt, BasicBlock> {
3417
3418 public:
3420
3421 /// Sets the new value for current case.
3422 void setValue(ConstantInt *V) const {
3423 assert((unsigned)Index < SI->getNumCases() &&
3424 "Index out the number of cases.");
3425 SI->setOperand(2 + Index*2, reinterpret_cast<Value*>(V));
3426 }
3427
3428 /// Sets the new successor for current case.
3429 void setSuccessor(BasicBlock *S) const {
3430 SI->setSuccessor(getSuccessorIndex(), S);
3431 }
3432 };
3433
3434 template <typename CaseHandleT>
3436 : public iterator_facade_base<CaseIteratorImpl<CaseHandleT>,
3437 std::random_access_iterator_tag,
3438 const CaseHandleT> {
3439 using SwitchInstT = typename CaseHandleT::SwitchInstType;
3440
3441 CaseHandleT Case;
3442
3443 public:
3444 /// Default constructed iterator is in an invalid state until assigned to
3445 /// a case for a particular switch.
3446 CaseIteratorImpl() = default;
3447
3448 /// Initializes case iterator for given SwitchInst and for given
3449 /// case number.
3450 CaseIteratorImpl(SwitchInstT *SI, unsigned CaseNum) : Case(SI, CaseNum) {}
3451
3452 /// Initializes case iterator for given SwitchInst and for given
3453 /// successor index.
3455 unsigned SuccessorIndex) {
3456 assert(SuccessorIndex < SI->getNumSuccessors() &&
3457 "Successor index # out of range!");
3458 return SuccessorIndex != 0 ? CaseIteratorImpl(SI, SuccessorIndex - 1)
3459 : CaseIteratorImpl(SI, DefaultPseudoIndex);
3460 }
3461
3462 /// Support converting to the const variant. This will be a no-op for const
3463 /// variant.
3465 return CaseIteratorImpl<ConstCaseHandle>(Case.SI, Case.Index);
3466 }
3467
3469 // Check index correctness after addition.
3470 // Note: Index == getNumCases() means end().
3471 assert(Case.Index + N >= 0 &&
3472 (unsigned)(Case.Index + N) <= Case.SI->getNumCases() &&
3473 "Case.Index out the number of cases.");
3474 Case.Index += N;
3475 return *this;
3476 }
3478 // Check index correctness after subtraction.
3479 // Note: Case.Index == getNumCases() means end().
3480 assert(Case.Index - N >= 0 &&
3481 (unsigned)(Case.Index - N) <= Case.SI->getNumCases() &&
3482 "Case.Index out the number of cases.");
3483 Case.Index -= N;
3484 return *this;
3485 }
3487 assert(Case.SI == RHS.Case.SI && "Incompatible operators.");
3488 return Case.Index - RHS.Case.Index;
3489 }
3490 bool operator==(const CaseIteratorImpl &RHS) const {
3491 return Case == RHS.Case;
3492 }
3493 bool operator<(const CaseIteratorImpl &RHS) const {
3494 assert(Case.SI == RHS.Case.SI && "Incompatible operators.");
3495 return Case.Index < RHS.Case.Index;
3496 }
3497 const CaseHandleT &operator*() const { return Case; }
3498 };
3499
3502
3504 unsigned NumCases,
3505 Instruction *InsertBefore = nullptr) {
3506 return new SwitchInst(Value, Default, NumCases, InsertBefore);
3507 }
3508
3510 unsigned NumCases, BasicBlock *InsertAtEnd) {
3511 return new SwitchInst(Value, Default, NumCases, InsertAtEnd);
3512 }
3513
3514 /// Provide fast operand accessors
3516
3517 // Accessor Methods for Switch stmt
3518 Value *getCondition() const { return getOperand(0); }
3519 void setCondition(Value *V) { setOperand(0, V); }
3520
3522 return cast<BasicBlock>(getOperand(1));
3523 }
3524
3525 void setDefaultDest(BasicBlock *DefaultCase) {
3526 setOperand(1, reinterpret_cast<Value*>(DefaultCase));
3527 }
3528
3529 /// Return the number of 'cases' in this switch instruction, excluding the
3530 /// default case.
3531 unsigned getNumCases() const {
3532 return getNumOperands()/2 - 1;
3533 }
3534
3535 /// Returns a read/write iterator that points to the first case in the
3536 /// SwitchInst.
3538 return CaseIt(this, 0);
3539 }
3540
3541 /// Returns a read-only iterator that points to the first case in the
3542 /// SwitchInst.
3544 return ConstCaseIt(this, 0);
3545 }
3546
3547 /// Returns a read/write iterator that points one past the last in the
3548 /// SwitchInst.
3550 return CaseIt(this, getNumCases());
3551 }
3552
3553 /// Returns a read-only iterator that points one past the last in the
3554 /// SwitchInst.
3556 return ConstCaseIt(this, getNumCases());
3557 }
3558
3559 /// Iteration adapter for range-for loops.
3561 return make_range(case_begin(), case_end());
3562 }
3563
3564 /// Constant iteration adapter for range-for loops.
3566 return make_range(case_begin(), case_end());
3567 }
3568
3569 /// Returns an iterator that points to the default case.
3570 /// Note: this iterator allows to resolve successor only. Attempt
3571 /// to resolve case value causes an assertion.
3572 /// Also note, that increment and decrement also causes an assertion and
3573 /// makes iterator invalid.
3575 return CaseIt(this, DefaultPseudoIndex);
3576 }
3578 return ConstCaseIt(this, DefaultPseudoIndex);
3579 }
3580
3581 /// Search all of the case values for the specified constant. If it is
3582 /// explicitly handled, return the case iterator of it, otherwise return
3583 /// default case iterator to indicate that it is handled by the default
3584 /// handler.
3586 return CaseIt(
3587 this,
3588 const_cast<const SwitchInst *>(this)->findCaseValue(C)->getCaseIndex());
3589 }
3591 ConstCaseIt I = llvm::find_if(cases(), [C](const ConstCaseHandle &Case) {
3592 return Case.getCaseValue() == C;
3593 });
3594 if (I != case_end())
3595 return I;
3596
3597 return case_default();
3598 }
3599
3600 /// Finds the unique case value for a given successor. Returns null if the
3601 /// successor is not found, not unique, or is the default case.
3603 if (BB == getDefaultDest())
3604 return nullptr;
3605
3606 ConstantInt *CI = nullptr;
3607 for (auto Case : cases()) {
3608 if (Case.getCaseSuccessor() != BB)
3609 continue;
3610
3611 if (CI)
3612 return nullptr; // Multiple cases lead to BB.
3613
3614 CI = Case.getCaseValue();
3615 }
3616
3617 return CI;
3618 }
3619
3620 /// Add an entry to the switch instruction.
3621 /// Note:
3622 /// This action invalidates case_end(). Old case_end() iterator will
3623 /// point to the added case.
3624 void addCase(ConstantInt *OnVal, BasicBlock *Dest);
3625
3626 /// This method removes the specified case and its successor from the switch
3627 /// instruction. Note that this operation may reorder the remaining cases at
3628 /// index idx and above.
3629 /// Note:
3630 /// This action invalidates iterators for all cases following the one removed,
3631 /// including the case_end() iterator. It returns an iterator for the next
3632 /// case.
3633 CaseIt removeCase(CaseIt I);
3634
3635 unsigned getNumSuccessors() const { return getNumOperands()/2; }
3636 BasicBlock *getSuccessor(unsigned idx) const {
3637 assert(idx < getNumSuccessors() &&"Successor idx out of range for switch!");
3638 return cast<BasicBlock>(getOperand(idx*2+1));
3639 }
3640 void setSuccessor(unsigned idx, BasicBlock *NewSucc) {
3641 assert(idx < getNumSuccessors() && "Successor # out of range for switch!");
3642 setOperand(idx * 2 + 1, NewSucc);
3643 }
3644
3645 // Methods for support type inquiry through isa, cast, and dyn_cast:
3646 static bool classof(const Instruction *I) {
3647 return I->getOpcode() == Instruction::Switch;
3648 }
3649 static bool classof(const Value *V) {
3650 return isa<Instruction>(V) && classof(cast<Instruction>(V));
3651 }
3652};
3653
3654/// A wrapper class to simplify modification of SwitchInst cases along with
3655/// their prof branch_weights metadata.
3657 SwitchInst &SI;
3658 std::optional<SmallVector<uint32_t, 8>> Weights;
3659 bool Changed = false;
3660
3661protected:
3663
3664 void init();
3665
3666public:
3667 using CaseWeightOpt = std::optional<uint32_t>;
3668 SwitchInst *operator->() { return &SI; }
3669 SwitchInst &operator*() { return SI; }
3670 operator SwitchInst *() { return &SI; }
3671
3673
3675 if (Changed)
3676 SI.setMetadata(LLVMContext::MD_prof, buildProfBranchWeightsMD());
3677 }
3678
3679 /// Delegate the call to the underlying SwitchInst::removeCase() and remove
3680 /// correspondent branch weight.
3682
3683 /// Delegate the call to the underlying SwitchInst::addCase() and set the
3684 /// specified branch weight for the added case.
3685 void addCase(ConstantInt *OnVal, BasicBlock *Dest, CaseWeightOpt W);
3686
3687 /// Delegate the call to the underlying SwitchInst::eraseFromParent() and mark
3688 /// this object to not touch the underlying SwitchInst in destructor.
3690
3691 void setSuccessorWeight(unsigned idx, CaseWeightOpt W);
3692 CaseWeightOpt getSuccessorWeight(unsigned idx);
3693
3694 static CaseWeightOpt getSuccessorWeight(const SwitchInst &SI, unsigned idx);
3695};
3696
3697template <>
3699};
3700
3702
3703//===----------------------------------------------------------------------===//
3704// IndirectBrInst Class
3705//===----------------------------------------------------------------------===//
3706
3707//===---------------------------------------------------------------------------
3708/// Indirect Branch Instruction.
3709///
3711 unsigned ReservedSpace;
3712
3713 // Operand[0] = Address to jump to
3714 // Operand[n+1] = n-th destination
3715 IndirectBrInst(const IndirectBrInst &IBI);
3716
3717 /// Create a new indirectbr instruction, specifying an
3718 /// Address to jump to. The number of expected destinations can be specified
3719 /// here to make memory allocation more efficient. This constructor can also
3720 /// autoinsert before another instruction.
3721 IndirectBrInst(Value *Address, unsigned NumDests, Instruction *InsertBefore);
3722
3723 /// Create a new indirectbr instruction, specifying an
3724 /// Address to jump to. The number of expected destinations can be specified
3725 /// here to make memory allocation more efficient. This constructor also
3726 /// autoinserts at the end of the specified BasicBlock.
3727 IndirectBrInst(Value *Address, unsigned NumDests, BasicBlock *InsertAtEnd);
3728
3729 // allocate space for exactly zero operands
3730 void *operator new(size_t S) { return User::operator new(S); }
3731
3732 void init(Value *Address, unsigned NumDests);
3733 void growOperands();
3734
3735protected:
3736 // Note: Instruction needs to be a friend here to call cloneImpl.
3737 friend class Instruction;
3738
3739 IndirectBrInst *cloneImpl() const;
3740
3741public:
3742 void operator delete(void *Ptr) { User::operator delete(Ptr); }
3743
3744 /// Iterator type that casts an operand to a basic block.
3745 ///
3746 /// This only makes sense because the successors are stored as adjacent
3747 /// operands for indirectbr instructions.
3749 : iterator_adaptor_base<succ_op_iterator, value_op_iterator,
3750 std::random_access_iterator_tag, BasicBlock *,
3751 ptrdiff_t, BasicBlock *, BasicBlock *> {
3753
3754 BasicBlock *operator*() const { return cast<BasicBlock>(*I); }
3755 BasicBlock *operator->() const { return operator*(); }
3756 };
3757
3758 /// The const version of `succ_op_iterator`.
3760 : iterator_adaptor_base<const_succ_op_iterator, const_value_op_iterator,
3761 std::random_access_iterator_tag,
3762 const BasicBlock *, ptrdiff_t, const BasicBlock *,
3763 const BasicBlock *> {
3766
3767 const BasicBlock *operator*() const { return cast<BasicBlock>(*I); }
3768 const BasicBlock *operator->() const { return operator*(); }
3769 };
3770
3771 static IndirectBrInst *Create(Value *Address, unsigned NumDests,
3772 Instruction *InsertBefore = nullptr) {
3773 return new IndirectBrInst(Address, NumDests, InsertBefore);
3774 }
3775
3776 static IndirectBrInst *Create(Value *Address, unsigned NumDests,
3777 BasicBlock *InsertAtEnd) {
3778 return new IndirectBrInst(Address, NumDests, InsertAtEnd);
3779 }
3780
3781 /// Provide fast operand accessors.
3783
3784 // Accessor Methods for IndirectBrInst instruction.
3785 Value *getAddress() { return getOperand(0); }
3786 const Value *getAddress() const { return getOperand(0); }
3787 void setAddress(Value *V) { setOperand(0, V); }
3788
3789 /// return the number of possible destinations in this
3790 /// indirectbr instruction.
3791 unsigned getNumDestinations() const { return getNumOperands()-1; }
3792
3793 /// Return the specified destination.
3794 BasicBlock *getDestination(unsigned i) { return getSuccessor(i); }
3795 const BasicBlock *getDestination(unsigned i) const { return getSuccessor(i); }
3796
3797 /// Add a destination.
3798 ///
3799 void addDestination(BasicBlock *Dest);
3800
3801 /// This method removes the specified successor from the
3802 /// indirectbr instruction.
3803 void removeDestination(unsigned i);
3804
3805 unsigned getNumSuccessors() const { return getNumOperands()-1; }
3806 BasicBlock *getSuccessor(unsigned i) const {
3807 return cast<BasicBlock>(getOperand(i+1));
3808 }
3809 void setSuccessor(unsigned i, BasicBlock *NewSucc) {
3810 setOperand(i + 1, NewSucc);
3811 }
3812
3814 return make_range(succ_op_iterator(std::next(value_op_begin())),
3815 succ_op_iterator(value_op_end()));
3816 }
3817
3819 return make_range(const_succ_op_iterator(std::next(value_op_begin())),
3820 const_succ_op_iterator(value_op_end()));
3821 }
3822
3823 // Methods for support type inquiry through isa, cast, and dyn_cast:
3824 static bool classof(const Instruction *I) {
3825 return I->getOpcode() == Instruction::IndirectBr;
3826 }
3827 static bool classof(const Value *V) {
3828 return isa<Instruction>(V) && classof(cast<Instruction>(V));
3829 }
3830};
3831
3832template <>
3834};
3835
3837
3838//===----------------------------------------------------------------------===//
3839// InvokeInst Class
3840//===----------------------------------------------------------------------===//
3841
3842/// Invoke instruction. The SubclassData field is used to hold the
3843/// calling convention of the call.
3844///
3845class InvokeInst : public CallBase {
3846 /// The number of operands for this call beyond the called function,
3847 /// arguments, and operand bundles.
3848 static constexpr int NumExtraOperands = 2;
3849
3850 /// The index from the end of the operand array to the normal destination.
3851 static constexpr int NormalDestOpEndIdx = -3;
3852
3853 /// The index from the end of the operand array to the unwind destination.
3854 static constexpr int UnwindDestOpEndIdx = -2;
3855
3856 InvokeInst(const InvokeInst &BI);
3857
3858 /// Construct an InvokeInst given a range of arguments.
3859 ///
3860 /// Construct an InvokeInst from a range of arguments
3861 inline InvokeInst(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
3862 BasicBlock *IfException, ArrayRef<Value *> Args,
3863 ArrayRef<OperandBundleDef> Bundles, int NumOperands,
3864 const Twine &NameStr, Instruction *InsertBefore);
3865
3866 inline InvokeInst(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
3867 BasicBlock *IfException, ArrayRef<Value *> Args,
3868 ArrayRef<OperandBundleDef> Bundles, int NumOperands,
3869 const Twine &NameStr, BasicBlock *InsertAtEnd);
3870
3871 void init(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
3872 BasicBlock *IfException, ArrayRef<Value *> Args,
3873 ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr);
3874
3875 /// Compute the number of operands to allocate.
3876 static int ComputeNumOperands(int NumArgs, int NumBundleInputs = 0) {
3877 // We need one operand for the called function, plus our extra operands and
3878 // the input operand counts provided.
3879 return 1 + NumExtraOperands + NumArgs + NumBundleInputs;
3880 }
3881
3882protected:
3883 // Note: Instruction needs to be a friend here to call cloneImpl.
3884 friend class Instruction;
3885
3886 InvokeInst *cloneImpl() const;
3887
3888public:
3889 static InvokeInst *Create(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
3890 BasicBlock *IfException, ArrayRef<Value *> Args,
3891 const Twine &NameStr,
3892 Instruction *InsertBefore = nullptr) {
3893 int NumOperands = ComputeNumOperands(Args.size());
3894 return new (NumOperands)
3895 InvokeInst(Ty, Func, IfNormal, IfException, Args, std::nullopt,
3896 NumOperands, NameStr, InsertBefore);
3897 }
3898
3899 static InvokeInst *Create(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
3900 BasicBlock *IfException, ArrayRef<Value *> Args,
3901 ArrayRef<OperandBundleDef> Bundles = std::nullopt,
3902 const Twine &NameStr = "",
3903 Instruction *InsertBefore = nullptr) {
3904 int NumOperands =
3905 ComputeNumOperands(Args.size(), CountBundleInputs(Bundles));
3906 unsigned DescriptorBytes = Bundles.size() * sizeof(BundleOpInfo);
3907
3908 return new (NumOperands, DescriptorBytes)
3909 InvokeInst(Ty, Func, IfNormal, IfException, Args, Bundles, NumOperands,
3910 NameStr, InsertBefore);
3911 }
3912
3913 static InvokeInst *Create(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
3914 BasicBlock *IfException, ArrayRef<Value *> Args,
3915 const Twine &NameStr, BasicBlock *InsertAtEnd) {
3916 int NumOperands = ComputeNumOperands(Args.size());
3917 return new (NumOperands)
3918 InvokeInst(Ty, Func, IfNormal, IfException, Args, std::nullopt,
3919 NumOperands, NameStr, InsertAtEnd);
3920 }
3921
3922 static InvokeInst *Create(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
3923 BasicBlock *IfException, ArrayRef<Value *> Args,
3925 const Twine &NameStr, BasicBlock *InsertAtEnd) {
3926 int NumOperands =
3927 ComputeNumOperands(Args.size(), CountBundleInputs(Bundles));
3928 unsigned DescriptorBytes = Bundles.size() * sizeof(BundleOpInfo);
3929
3930 return new (NumOperands, DescriptorBytes)
3931 InvokeInst(Ty, Func, IfNormal, IfException, Args, Bundles, NumOperands,
3932 NameStr, InsertAtEnd);
3933 }
3934
3936 BasicBlock *IfException, ArrayRef<Value *> Args,
3937 const Twine &NameStr,
3938 Instruction *InsertBefore = nullptr) {
3939 return Create(Func.getFunctionType(), Func.getCallee(), IfNormal,
3940 IfException, Args, std::nullopt, NameStr, InsertBefore);
3941 }
3942
3944 BasicBlock *IfException, ArrayRef<Value *> Args,
3945 ArrayRef<OperandBundleDef> Bundles = std::nullopt,
3946 const Twine &NameStr = "",
3947 Instruction *InsertBefore = nullptr) {
3948 return Create(Func.getFunctionType(), Func.getCallee(), IfNormal,
3949 IfException, Args, Bundles, NameStr, InsertBefore);
3950 }
3951
3953 BasicBlock *IfException, ArrayRef<Value *> Args,
3954 const Twine &NameStr, BasicBlock *InsertAtEnd) {
3955 return Create(Func.getFunctionType(), Func.getCallee(), IfNormal,
3956 IfException, Args, NameStr, InsertAtEnd);
3957 }
3958
3960 BasicBlock *IfException, ArrayRef<Value *> Args,
3962 const Twine &NameStr, BasicBlock *InsertAtEnd) {
3963 return Create(Func.getFunctionType(), Func.getCallee(), IfNormal,
3964 IfException, Args, Bundles, NameStr, InsertAtEnd);
3965 }
3966
3967 /// Create a clone of \p II with a different set of operand bundles and
3968 /// insert it before \p InsertPt.
3969 ///
3970 /// The returned invoke instruction is identical to \p II in every way except
3971 /// that the operand bundles for the new instruction are set to the operand
3972 /// bundles in \p Bundles.
3973 static InvokeInst *Create(InvokeInst *II, ArrayRef<OperandBundleDef> Bundles,
3974 Instruction *InsertPt = nullptr);
3975
3976 // get*Dest - Return the destination basic blocks...
3978 return cast<BasicBlock>(Op<NormalDestOpEndIdx>());
3979 }
3981 return cast<BasicBlock>(Op<UnwindDestOpEndIdx>());
3982 }
3984 Op<NormalDestOpEndIdx>() = reinterpret_cast<Value *>(B);
3985 }
3987 Op<UnwindDestOpEndIdx>() = reinterpret_cast<Value *>(B);
3988 }
3989
3990 /// Get the landingpad instruction from the landing pad
3991 /// block (the unwind destination).
3992 LandingPadInst *getLandingPadInst() const;
3993
3994 BasicBlock *getSuccessor(unsigned i) const {
3995 assert(i < 2 && "Successor # out of range for invoke!");
3996 return i == 0 ? getNormalDest() : getUnwindDest();
3997 }
3998
3999 void setSuccessor(unsigned i, BasicBlock *NewSucc) {
4000 assert(i < 2 && "Successor # out of range for invoke!");
4001 if (i == 0)
4002 setNormalDest(NewSucc);
4003 else
4004 setUnwindDest(NewSucc);
4005 }
4006
4007 unsigned getNumSuccessors() const { return 2; }
4008
4009 // Methods for support type inquiry through isa, cast, and dyn_cast:
4010 static bool classof(const Instruction *I) {
4011 return (I->getOpcode() == Instruction::Invoke);
4012 }
4013 static bool classof(const Value *V) {
4014 return isa<Instruction>(V) && classof(cast<Instruction>(V));
4015 }
4016
4017private:
4018 // Shadow Instruction::setInstructionSubclassData with a private forwarding
4019 // method so that subclasses cannot accidentally use it.
4020 template <typename Bitfield>
4021 void setSubclassData(typename Bitfield::Type Value) {
4022 Instruction::setSubclassData<Bitfield>(Value);
4023 }
4024};
4025
4026InvokeInst::InvokeInst(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
4027 BasicBlock *IfException, ArrayRef<Value *> Args,
4028 ArrayRef<OperandBundleDef> Bundles, int NumOperands,
4029 const Twine &NameStr, Instruction *InsertBefore)
4030 : CallBase(Ty->getReturnType(), Instruction::Invoke,
4031 OperandTraits<CallBase>::op_end(this) - NumOperands, NumOperands,
4032 InsertBefore) {
4033 init(Ty, Func, IfNormal, IfException, Args, Bundles, NameStr);
4034}
4035
4036InvokeInst::InvokeInst(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
4037 BasicBlock *IfException, ArrayRef<Value *> Args,
4038 ArrayRef<OperandBundleDef> Bundles, int NumOperands,
4039 const Twine &NameStr, BasicBlock *InsertAtEnd)
4040 : CallBase(Ty->getReturnType(), Instruction::Invoke,
4041 OperandTraits<CallBase>::op_end(this) - NumOperands, NumOperands,
4042 InsertAtEnd) {
4043 init(Ty, Func, IfNormal, IfException, Args, Bundles, NameStr);
4044}
4045
4046//===----------------------------------------------------------------------===//
4047// CallBrInst Class
4048//===----------------------------------------------------------------------===//
4049
4050/// CallBr instruction, tracking function calls that may not return control but
4051/// instead transfer it to a third location. The SubclassData field is used to
4052/// hold the calling convention of the call.
4053///
4054class CallBrInst : public CallBase {
4055
4056 unsigned NumIndirectDests;
4057
4058 CallBrInst(const CallBrInst &BI);
4059
4060 /// Construct a CallBrInst given a range of arguments.
4061 ///
4062 /// Construct a CallBrInst from a range of arguments
4063 inline CallBrInst(FunctionType *Ty, Value *Func, BasicBlock *DefaultDest,
4064 ArrayRef<BasicBlock *> IndirectDests,
4065 ArrayRef<Value *> Args,
4066 ArrayRef<OperandBundleDef> Bundles, int NumOperands,
4067 const Twine &NameStr, Instruction *InsertBefore);
4068
4069 inline CallBrInst(FunctionType *Ty, Value *Func, BasicBlock *DefaultDest,
4070 ArrayRef<BasicBlock *> IndirectDests,
4071 ArrayRef<Value *> Args,
4072 ArrayRef<OperandBundleDef> Bundles, int NumOperands,
4073 const Twine &NameStr, BasicBlock *InsertAtEnd);
4074
4075 void init(FunctionType *FTy, Value *Func, BasicBlock *DefaultDest,
4076 ArrayRef<BasicBlock *> IndirectDests, ArrayRef<Value *> Args,
4077 ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr);
4078
4079 /// Compute the number of operands to allocate.
4080 static int ComputeNumOperands(int NumArgs, int NumIndirectDests,
4081 int NumBundleInputs = 0) {
4082 // We need one operand for the called function, plus our extra operands and
4083 // the input operand counts provided.
4084 return 2 + NumIndirectDests + NumArgs + NumBundleInputs;
4085 }
4086
4087protected:
4088 // Note: Instruction needs to be a friend here to call cloneImpl.
4089 friend class Instruction;
4090
4091 CallBrInst *cloneImpl() const;
4092
4093public:
4095 BasicBlock *DefaultDest,
4096 ArrayRef<BasicBlock *> IndirectDests,
4097 ArrayRef<Value *> Args, const Twine &NameStr,
4098 Instruction *InsertBefore = nullptr) {
4099 int NumOperands = ComputeNumOperands(Args.size(), IndirectDests.size());
4100 return new (NumOperands)
4101 CallBrInst(Ty, Func, DefaultDest, IndirectDests, Args, std::nullopt,
4102 NumOperands, NameStr, InsertBefore);
4103 }
4104
4105 static CallBrInst *
4106 Create(FunctionType *Ty, Value *Func, BasicBlock *DefaultDest,
4107 ArrayRef<BasicBlock *> IndirectDests, ArrayRef<Value *> Args,
4108 ArrayRef<OperandBundleDef> Bundles = std::nullopt,
4109 const Twine &NameStr = "", Instruction *InsertBefore = nullptr) {
4110 int NumOperands = ComputeNumOperands(Args.size(), IndirectDests.size(),
4111 CountBundleInputs(Bundles));
4112 unsigned DescriptorBytes = Bundles.size() * sizeof(BundleOpInfo);
4113
4114 return new (NumOperands, DescriptorBytes)
4115 CallBrInst(Ty, Func, DefaultDest, IndirectDests, Args, Bundles,
4116 NumOperands, NameStr, InsertBefore);
4117 }
4118
4120 BasicBlock *DefaultDest,
4121 ArrayRef<BasicBlock *> IndirectDests,
4122 ArrayRef<Value *> Args, const Twine &NameStr,
4123 BasicBlock *InsertAtEnd) {
4124 int NumOperands = ComputeNumOperands(Args.size(), IndirectDests.size());
4125 return new (NumOperands)
4126 CallBrInst(Ty, Func, DefaultDest, IndirectDests, Args, std::nullopt,
4127 NumOperands, NameStr, InsertAtEnd);
4128 }
4129
4131 BasicBlock *DefaultDest,
4132 ArrayRef<BasicBlock *> IndirectDests,
4133 ArrayRef<Value *> Args,
4135 const Twine &NameStr, BasicBlock *InsertAtEnd) {
4136 int NumOperands = ComputeNumOperands(Args.size(), IndirectDests.size(),
4137 CountBundleInputs(Bundles));
4138 unsigned DescriptorBytes = Bundles.size() * sizeof(BundleOpInfo);
4139
4140 return new (NumOperands, DescriptorBytes)
4141 CallBrInst(Ty, Func, DefaultDest, IndirectDests, Args, Bundles,
4142 NumOperands, NameStr, InsertAtEnd);
4143 }
4144
4145 static CallBrInst *Create(FunctionCallee Func, BasicBlock *DefaultDest,
4146 ArrayRef<BasicBlock *> IndirectDests,
4147 ArrayRef<Value *> Args, const Twine &NameStr,
4148 Instruction *InsertBefore = nullptr) {
4149 return Create(Func.getFunctionType(), Func.getCallee(), DefaultDest,
4150 IndirectDests, Args, NameStr, InsertBefore);
4151 }
4152
4153 static CallBrInst *Create(FunctionCallee Func, BasicBlock *DefaultDest,
4154 ArrayRef<BasicBlock *> IndirectDests,
4155 ArrayRef<Value *> Args,
4156 ArrayRef<OperandBundleDef> Bundles = std::nullopt,
4157 const Twine &NameStr = "",
4158 Instruction *InsertBefore = nullptr) {
4159 return Create(Func.getFunctionType(), Func.getCallee(), DefaultDest,
4160 IndirectDests, Args, Bundles, NameStr, InsertBefore);
4161 }
4162
4163 static CallBrInst *Create(FunctionCallee Func, BasicBlock *DefaultDest,
4164 ArrayRef<BasicBlock *> IndirectDests,
4165 ArrayRef<Value *> Args, const Twine &NameStr,
4166 BasicBlock *InsertAtEnd) {
4167 return Create(Func.getFunctionType(), Func.getCallee(), DefaultDest,
4168 IndirectDests, Args, NameStr, InsertAtEnd);
4169 }
4170
4172 BasicBlock *DefaultDest,
4173 ArrayRef<BasicBlock *> IndirectDests,
4174 ArrayRef<Value *> Args,
4176 const Twine &NameStr, BasicBlock *InsertAtEnd) {
4177 return Create(Func.getFunctionType(), Func.getCallee(), DefaultDest,
4178 IndirectDests, Args, Bundles, NameStr, InsertAtEnd);
4179 }
4180
4181 /// Create a clone of \p CBI with a different set of operand bundles and
4182 /// insert it before \p InsertPt.
4183 ///
4184 /// The returned callbr instruction is identical to \p CBI in every way
4185 /// except that the operand bundles for the new instruction are set to the
4186 /// operand bundles in \p Bundles.
4187 static CallBrInst *Create(CallBrInst *CBI,
4189 Instruction *InsertPt = nullptr);
4190
4191 /// Return the number of callbr indirect dest labels.
4192 ///
4193 unsigned getNumIndirectDests() const { return NumIndirectDests; }
4194
4195 /// getIndirectDestLabel - Return the i-th indirect dest label.
4196 ///
4197 Value *getIndirectDestLabel(unsigned i) const {
4198 assert(i < getNumIndirectDests() && "Out of bounds!");
4199 return getOperand(i + arg_size() + getNumTotalBundleOperands() + 1);
4200 }
4201
4202 Value *getIndirectDestLabelUse(unsigned i) const {
4203 assert(i < getNumIndirectDests() && "Out of bounds!");
4204 return getOperandUse(i + arg_size() + getNumTotalBundleOperands() + 1);
4205 }
4206
4207 // Return the destination basic blocks...
4209 return cast<BasicBlock>(*(&Op<-1>() - getNumIndirectDests() - 1));
4210 }
4211 BasicBlock *getIndirectDest(unsigned i) const {
4212 return cast_or_null<BasicBlock>(*(&Op<-1>() - getNumIndirectDests() + i));
4213 }
4215 SmallVector<BasicBlock *, 16> IndirectDests;
4216 for (unsigned i = 0, e = getNumIndirectDests(); i < e; ++i)
4217 IndirectDests.push_back(getIndirectDest(i));
4218 return IndirectDests;
4219 }
4221 *(&Op<-1>() - getNumIndirectDests() - 1) = reinterpret_cast<Value *>(B);
4222 }
4223 void setIndirectDest(unsigned i, BasicBlock *B) {
4224 *(&Op<-1>() - getNumIndirectDests() + i) = reinterpret_cast<Value *>(B);
4225 }
4226
4227 BasicBlock *getSuccessor(unsigned i) const {
4228 assert(i < getNumSuccessors() + 1 &&
4229 "Successor # out of range for callbr!");
4230 return i == 0 ? getDefaultDest() : getIndirectDest(i - 1);
4231 }
4232
4233 void setSuccessor(unsigned i, BasicBlock *NewSucc) {
4234 assert(i < getNumIndirectDests() + 1 &&
4235 "Successor # out of range for callbr!");
4236 return i == 0 ? setDefaultDest(NewSucc) : setIndirectDest(i - 1, NewSucc);
4237 }
4238
4239 unsigned getNumSuccessors() const { return getNumIndirectDests() + 1; }
4240
4241 // Methods for support type inquiry through isa, cast, and dyn_cast:
4242 static bool classof(const Instruction *I) {
4243 return (I->getOpcode() == Instruction::CallBr);
4244 }
4245 static bool classof(const Value *V) {
4246 return isa<Instruction>(V) && classof(cast<Instruction>(V));
4247 }
4248
4249private:
4250 // Shadow Instruction::setInstructionSubclassData with a private forwarding
4251 // method so that subclasses cannot accidentally use it.
4252 template <typename Bitfield>
4253 void setSubclassData(typename Bitfield::Type Value) {
4254 Instruction::setSubclassData<Bitfield>(Value);
4255 }
4256};
4257
4258CallBrInst::CallBrInst(FunctionType *Ty, Value *Func, BasicBlock *DefaultDest,
4259 ArrayRef<BasicBlock *> IndirectDests,
4260 ArrayRef<Value *> Args,
4261 ArrayRef<OperandBundleDef> Bundles, int NumOperands,
4262 const Twine &NameStr, Instruction *InsertBefore)
4263 : CallBase(Ty->getReturnType(), Instruction::CallBr,
4264 OperandTraits<CallBase>::op_end(this) - NumOperands, NumOperands,
4265 InsertBefore) {
4266 init(Ty, Func, DefaultDest, IndirectDests, Args, Bundles, NameStr);
4267}
4268
4269CallBrInst::CallBrInst(FunctionType *Ty, Value *Func, BasicBlock *DefaultDest,
4270 ArrayRef<BasicBlock *> IndirectDests,
4271 ArrayRef<Value *> Args,
4272 ArrayRef<OperandBundleDef> Bundles, int NumOperands,
4273 const Twine &NameStr, BasicBlock *InsertAtEnd)
4274 : CallBase(Ty->getReturnType(), Instruction::CallBr,
4275 OperandTraits<CallBase>::op_end(this) - NumOperands, NumOperands,
4276 InsertAtEnd) {
4277 init(Ty, Func, DefaultDest, IndirectDests, Args, Bundles, NameStr);
4278}
4279
4280//===----------------------------------------------------------------------===//
4281// ResumeInst Class
4282//===----------------------------------------------------------------------===//
4283
4284//===---------------------------------------------------------------------------
4285/// Resume the propagation of an exception.
4286///
4287class ResumeInst : public Instruction {
4288 ResumeInst(const ResumeInst &RI);
4289
4290 explicit ResumeInst(Value *Exn, Instruction *InsertBefore=nullptr);
4291 ResumeInst(Value *Exn, BasicBlock *InsertAtEnd);
4292
4293protected:
4294 // Note: Instruction needs to be a friend here to call cloneImpl.
4295 friend class Instruction;
4296
4297 ResumeInst *cloneImpl() const;
4298
4299public:
4300 static ResumeInst *Create(Value *Exn, Instruction *InsertBefore = nullptr) {
4301 return new(1) ResumeInst(Exn, InsertBefore);
4302 }
4303
4304 static ResumeInst *Create(Value *Exn, BasicBlock *InsertAtEnd) {
4305 return new(1) ResumeInst(Exn, InsertAtEnd);
4306 }
4307
4308 /// Provide fast operand accessors
4310
4311 /// Convenience accessor.
4312 Value *getValue() const { return Op<0>(); }
4313
4314 unsigned getNumSuccessors() const { return 0; }
4315
4316 // Methods for support type inquiry through isa, cast, and dyn_cast:
4317 static bool classof(const Instruction *I) {
4318 return I->getOpcode() == Instruction::Resume;
4319 }
4320 static bool classof(const Value *V) {
4321 return isa<Instruction>(V) && classof(cast<Instruction>(V));
4322 }
4323
4324private:
4325 BasicBlock *getSuccessor(unsigned idx) const {
4326 llvm_unreachable("ResumeInst has no successors!");
4327 }
4328
4329 void setSuccessor(unsigned idx, BasicBlock *NewSucc) {
4330 llvm_unreachable("ResumeInst has no successors!");
4331 }
4332};
4333
4334template <>
4336 public FixedNumOperandTraits<ResumeInst, 1> {
4337};
4338
4340
4341//===----------------------------------------------------------------------===//
4342// CatchSwitchInst Class
4343//===----------------------------------------------------------------------===//
4345 using UnwindDestField = BoolBitfieldElementT<0>;
4346
4347 /// The number of operands actually allocated. NumOperands is
4348 /// the number actually in use.
4349 unsigned ReservedSpace;
4350
4351 // Operand[0] = Outer scope
4352 // Operand[1] = Unwind block destination
4353 // Operand[n] = BasicBlock to go to on match
4354 CatchSwitchInst(const CatchSwitchInst &CSI);
4355
4356 /// Create a new switch instruction, specifying a
4357 /// default destination. The number of additional handlers can be specified
4358 /// here to make memory allocation more efficient.
4359 /// This constructor can also autoinsert before another instruction.
4360 CatchSwitchInst(Value *ParentPad, BasicBlock *UnwindDest,
4361 unsigned NumHandlers, const Twine &NameStr,
4362 Instruction *InsertBefore);
4363
4364 /// Create a new switch instruction, specifying a
4365 /// default destination. The number of additional handlers can be specified
4366 /// here to make memory allocation more efficient.
4367 /// This constructor also autoinserts at the end of the specified BasicBlock.
4368 CatchSwitchInst(Value *ParentPad, BasicBlock *UnwindDest,
4369 unsigned NumHandlers, const Twine &NameStr,
4370 BasicBlock *InsertAtEnd);
4371
4372 // allocate space for exactly zero operands
4373 void *operator new(size_t S) { return User::operator new(S); }
4374
4375 void init(Value *ParentPad, BasicBlock *UnwindDest, unsigned NumReserved);
4376 void growOperands(unsigned Size);
4377
4378protected:
4379 // Note: Instruction needs to be a friend here to call cloneImpl.
4380 friend class Instruction;
4381
4382 CatchSwitchInst *cloneImpl() const;
4383
4384public:
4385 void operator delete(void *Ptr) { return User::operator delete(Ptr); }
4386
4387 static CatchSwitchInst *Create(Value *ParentPad, BasicBlock *UnwindDest,
4388 unsigned NumHandlers,
4389 const Twine &NameStr = "",
4390 Instruction *InsertBefore = nullptr) {
4391 return new CatchSwitchInst(ParentPad, UnwindDest, NumHandlers, NameStr,
4392 InsertBefore);
4393 }
4394
4395 static CatchSwitchInst *Create(Value *ParentPad, BasicBlock *UnwindDest,
4396 unsigned NumHandlers, const Twine &NameStr,
4397 BasicBlock *InsertAtEnd) {
4398 return new CatchSwitchInst(ParentPad, UnwindDest, NumHandlers, NameStr,
4399 InsertAtEnd);
4400 }
4401
4402 /// Provide fast operand accessors
4404
4405 // Accessor Methods for CatchSwitch stmt
4406 Value *getParentPad() const { return getOperand(0); }
4407 void setParentPad(Value *ParentPad) { setOperand(0, ParentPad); }
4408
4409 // Accessor Methods for CatchSwitch stmt
4410 bool hasUnwindDest() const { return getSubclassData<UnwindDestField>(); }
4411 bool unwindsToCaller() const { return !hasUnwindDest(); }
4413 if (hasUnwindDest())
4414 return cast<BasicBlock>(getOperand(1));
4415 return nullptr;
4416 }
4417 void setUnwindDest(BasicBlock *UnwindDest) {
4418 assert(UnwindDest);
4419 assert(hasUnwindDest());
4420 setOperand(1, UnwindDest);
4421 }
4422
4423 /// return the number of 'handlers' in this catchswitch
4424 /// instruction, except the default handler
4425 unsigned getNumHandlers() const {
4426 if (hasUnwindDest())
4427 return getNumOperands() - 2;
4428 return getNumOperands() - 1;
4429 }
4430
4431private:
4432 static BasicBlock *handler_helper(Value *V) { return cast<BasicBlock>(V); }
4433 static const BasicBlock *handler_helper(const Value *V) {
4434 return cast<BasicBlock>(V);
4435 }
4436
4437public:
4438 using DerefFnTy = BasicBlock *(*)(Value *);
4441 using ConstDerefFnTy = const BasicBlock *(*)(const Value *);
4445
4446 /// Returns an iterator that points to the first handler in CatchSwitchInst.
4448 op_iterator It = op_begin() + 1;
4449 if (hasUnwindDest())
4450 ++It;
4451 return handler_iterator(It, DerefFnTy(handler_helper));
4452 }
4453
4454 /// Returns an iterator that points to the first handler in the
4455 /// CatchSwitchInst.
4457 const_op_iterator It = op_begin() + 1;
4458 if (hasUnwindDest())
4459 ++It;
4460 return const_handler_iterator(It, ConstDerefFnTy(handler_helper));
4461 }
4462
4463 /// Returns a read-only iterator that points one past the last
4464 /// handler in the CatchSwitchInst.
4466 return handler_iterator(op_end(), DerefFnTy(handler_helper));
4467 }
4468
4469 /// Returns an iterator that points one past the last handler in the
4470 /// CatchSwitchInst.
4472 return