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