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