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