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