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