1 //===- CallSite.h - Abstract Call & Invoke instrs ---------------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file defines the CallSite class, which is a handy wrapper for code that 11 // wants to treat Call and Invoke instructions in a generic way. When in non- 12 // mutation context (e.g. an analysis) ImmutableCallSite should be used. 13 // Finally, when some degree of customization is necessary between these two 14 // extremes, CallSiteBase<> can be supplied with fine-tuned parameters. 15 // 16 // NOTE: These classes are supposed to have "value semantics". So they should be 17 // passed by value, not by reference; they should not be "new"ed or "delete"d. 18 // They are efficiently copyable, assignable and constructable, with cost 19 // equivalent to copying a pointer (notice that they have only a single data 20 // member). The internal representation carries a flag which indicates which of 21 // the two variants is enclosed. This allows for cheaper checks when various 22 // accessors of CallSite are employed. 23 // 24 //===----------------------------------------------------------------------===// 25 26 #ifndef LLVM_IR_CALLSITE_H 27 #define LLVM_IR_CALLSITE_H 28 29 #include "llvm/ADT/Optional.h" 30 #include "llvm/ADT/PointerIntPair.h" 31 #include "llvm/ADT/iterator_range.h" 32 #include "llvm/IR/Attributes.h" 33 #include "llvm/IR/CallingConv.h" 34 #include "llvm/IR/Function.h" 35 #include "llvm/IR/InstrTypes.h" 36 #include "llvm/IR/Instruction.h" 37 #include "llvm/IR/Instructions.h" 38 #include "llvm/IR/Use.h" 39 #include "llvm/IR/User.h" 40 #include "llvm/IR/Value.h" 41 #include "llvm/Support/Casting.h" 42 #include <cassert> 43 #include <cstdint> 44 #include <iterator> 45 46 namespace llvm { 47 48 namespace Intrinsic { 49 enum ID : unsigned; 50 } 51 52 template <typename FunTy = const Function, 53 typename BBTy = const BasicBlock, 54 typename ValTy = const Value, 55 typename UserTy = const User, 56 typename UseTy = const Use, 57 typename InstrTy = const Instruction, 58 typename CallTy = const CallInst, 59 typename InvokeTy = const InvokeInst, 60 typename IterTy = User::const_op_iterator> 61 class CallSiteBase { 62 protected: 63 PointerIntPair<InstrTy*, 1, bool> I; 64 65 CallSiteBase() = default; 66 CallSiteBase(CallTy *CI) : I(CI, true) { assert(CI); } 67 CallSiteBase(InvokeTy *II) : I(II, false) { assert(II); } 68 explicit CallSiteBase(ValTy *II) { *this = get(II); } 69 70 private: 71 /// This static method is like a constructor. It will create an appropriate 72 /// call site for a Call or Invoke instruction, but it can also create a null 73 /// initialized CallSiteBase object for something which is NOT a call site. 74 static CallSiteBase get(ValTy *V) { 75 if (InstrTy *II = dyn_cast<InstrTy>(V)) { 76 if (II->getOpcode() == Instruction::Call) 77 return CallSiteBase(static_cast<CallTy*>(II)); 78 else if (II->getOpcode() == Instruction::Invoke) 79 return CallSiteBase(static_cast<InvokeTy*>(II)); 80 } 81 return CallSiteBase(); 82 } 83 84 public: 85 /// Return true if a CallInst is enclosed. Note that !isCall() does not mean 86 /// an InvokeInst is enclosed. It may also signify a NULL instruction pointer. 87 bool isCall() const { return I.getInt(); } 88 89 /// Return true if a InvokeInst is enclosed. 90 bool isInvoke() const { return getInstruction() && !I.getInt(); } 91 92 InstrTy *getInstruction() const { return I.getPointer(); } 93 InstrTy *operator->() const { return I.getPointer(); } 94 explicit operator bool() const { return I.getPointer(); } 95 96 /// Get the basic block containing the call site. 97 BBTy* getParent() const { return getInstruction()->getParent(); } 98 99 /// Return the pointer to function that is being called. 100 ValTy *getCalledValue() const { 101 assert(getInstruction() && "Not a call or invoke instruction!"); 102 return *getCallee(); 103 } 104 105 /// Return the function being called if this is a direct call, otherwise 106 /// return null (if it's an indirect call). 107 FunTy *getCalledFunction() const { 108 return dyn_cast<FunTy>(getCalledValue()); 109 } 110 111 /// Return true if the callsite is an indirect call. 112 bool isIndirectCall() const { 113 const Value *V = getCalledValue(); 114 if (!V) 115 return false; 116 if (isa<FunTy>(V) || isa<Constant>(V)) 117 return false; 118 if (const CallInst *CI = dyn_cast<CallInst>(getInstruction())) { 119 if (CI->isInlineAsm()) 120 return false; 121 } 122 return true; 123 } 124 125 /// Set the callee to the specified value. 126 void setCalledFunction(Value *V) { 127 assert(getInstruction() && "Not a call or invoke instruction!"); 128 *getCallee() = V; 129 } 130 131 /// Return the intrinsic ID of the intrinsic called by this CallSite, 132 /// or Intrinsic::not_intrinsic if the called function is not an 133 /// intrinsic, or if this CallSite is an indirect call. 134 Intrinsic::ID getIntrinsicID() const { 135 if (auto *F = getCalledFunction()) 136 return F->getIntrinsicID(); 137 // Don't use Intrinsic::not_intrinsic, as it will require pulling 138 // Intrinsics.h into every header that uses CallSite. 139 return static_cast<Intrinsic::ID>(0); 140 } 141 142 /// Determine whether the passed iterator points to the callee operand's Use. 143 bool isCallee(Value::const_user_iterator UI) const { 144 return isCallee(&UI.getUse()); 145 } 146 147 /// Determine whether this Use is the callee operand's Use. 148 bool isCallee(const Use *U) const { return getCallee() == U; } 149 150 /// Determine whether the passed iterator points to an argument operand. 151 bool isArgOperand(Value::const_user_iterator UI) const { 152 return isArgOperand(&UI.getUse()); 153 } 154 155 /// Determine whether the passed use points to an argument operand. 156 bool isArgOperand(const Use *U) const { 157 assert(getInstruction() == U->getUser()); 158 return arg_begin() <= U && U < arg_end(); 159 } 160 161 /// Determine whether the passed iterator points to a bundle operand. 162 bool isBundleOperand(Value::const_user_iterator UI) const { 163 return isBundleOperand(&UI.getUse()); 164 } 165 166 /// Determine whether the passed use points to a bundle operand. 167 bool isBundleOperand(const Use *U) const { 168 assert(getInstruction() == U->getUser()); 169 if (!hasOperandBundles()) 170 return false; 171 unsigned OperandNo = U - (*this)->op_begin(); 172 return getBundleOperandsStartIndex() <= OperandNo && 173 OperandNo < getBundleOperandsEndIndex(); 174 } 175 176 /// Determine whether the passed iterator points to a data operand. 177 bool isDataOperand(Value::const_user_iterator UI) const { 178 return isDataOperand(&UI.getUse()); 179 } 180 181 /// Determine whether the passed use points to a data operand. 182 bool isDataOperand(const Use *U) const { 183 return data_operands_begin() <= U && U < data_operands_end(); 184 } 185 186 ValTy *getArgument(unsigned ArgNo) const { 187 assert(arg_begin() + ArgNo < arg_end() && "Argument # out of range!"); 188 return *(arg_begin() + ArgNo); 189 } 190 191 void setArgument(unsigned ArgNo, Value* newVal) { 192 assert(getInstruction() && "Not a call or invoke instruction!"); 193 assert(arg_begin() + ArgNo < arg_end() && "Argument # out of range!"); 194 getInstruction()->setOperand(ArgNo, newVal); 195 } 196 197 /// Given a value use iterator, returns the argument that corresponds to it. 198 /// Iterator must actually correspond to an argument. 199 unsigned getArgumentNo(Value::const_user_iterator I) const { 200 return getArgumentNo(&I.getUse()); 201 } 202 203 /// Given a use for an argument, get the argument number that corresponds to 204 /// it. 205 unsigned getArgumentNo(const Use *U) const { 206 assert(getInstruction() && "Not a call or invoke instruction!"); 207 assert(isArgOperand(U) && "Argument # out of range!"); 208 return U - arg_begin(); 209 } 210 211 /// The type of iterator to use when looping over actual arguments at this 212 /// call site. 213 using arg_iterator = IterTy; 214 215 iterator_range<IterTy> args() const { 216 return make_range(arg_begin(), arg_end()); 217 } 218 bool arg_empty() const { return arg_end() == arg_begin(); } 219 unsigned arg_size() const { return unsigned(arg_end() - arg_begin()); } 220 221 /// Given a value use iterator, return the data operand corresponding to it. 222 /// Iterator must actually correspond to a data operand. 223 unsigned getDataOperandNo(Value::const_user_iterator UI) const { 224 return getDataOperandNo(&UI.getUse()); 225 } 226 227 /// Given a use for a data operand, get the data operand number that 228 /// corresponds to it. 229 unsigned getDataOperandNo(const Use *U) const { 230 assert(getInstruction() && "Not a call or invoke instruction!"); 231 assert(isDataOperand(U) && "Data operand # out of range!"); 232 return U - data_operands_begin(); 233 } 234 235 /// Type of iterator to use when looping over data operands at this call site 236 /// (see below). 237 using data_operand_iterator = IterTy; 238 239 /// data_operands_begin/data_operands_end - Return iterators iterating over 240 /// the call / invoke argument list and bundle operands. For invokes, this is 241 /// the set of instruction operands except the invoke target and the two 242 /// successor blocks; and for calls this is the set of instruction operands 243 /// except the call target. 244 245 IterTy data_operands_begin() const { 246 assert(getInstruction() && "Not a call or invoke instruction!"); 247 return (*this)->op_begin(); 248 } 249 IterTy data_operands_end() const { 250 assert(getInstruction() && "Not a call or invoke instruction!"); 251 return (*this)->op_end() - (isCall() ? 1 : 3); 252 } 253 iterator_range<IterTy> data_ops() const { 254 return make_range(data_operands_begin(), data_operands_end()); 255 } 256 bool data_operands_empty() const { 257 return data_operands_end() == data_operands_begin(); 258 } 259 unsigned data_operands_size() const { 260 return std::distance(data_operands_begin(), data_operands_end()); 261 } 262 263 /// Return the type of the instruction that generated this call site. 264 Type *getType() const { return (*this)->getType(); } 265 266 /// Return the caller function for this call site. 267 FunTy *getCaller() const { return (*this)->getParent()->getParent(); } 268 269 /// Tests if this call site must be tail call optimized. Only a CallInst can 270 /// be tail call optimized. 271 bool isMustTailCall() const { 272 return isCall() && cast<CallInst>(getInstruction())->isMustTailCall(); 273 } 274 275 /// Tests if this call site is marked as a tail call. 276 bool isTailCall() const { 277 return isCall() && cast<CallInst>(getInstruction())->isTailCall(); 278 } 279 280 #define CALLSITE_DELEGATE_GETTER(METHOD) \ 281 InstrTy *II = getInstruction(); \ 282 return isCall() \ 283 ? cast<CallInst>(II)->METHOD \ 284 : cast<InvokeInst>(II)->METHOD 285 286 #define CALLSITE_DELEGATE_SETTER(METHOD) \ 287 InstrTy *II = getInstruction(); \ 288 if (isCall()) \ 289 cast<CallInst>(II)->METHOD; \ 290 else \ 291 cast<InvokeInst>(II)->METHOD 292 293 unsigned getNumArgOperands() const { 294 CALLSITE_DELEGATE_GETTER(getNumArgOperands()); 295 } 296 297 ValTy *getArgOperand(unsigned i) const { 298 CALLSITE_DELEGATE_GETTER(getArgOperand(i)); 299 } 300 301 ValTy *getReturnedArgOperand() const { 302 CALLSITE_DELEGATE_GETTER(getReturnedArgOperand()); 303 } 304 305 bool isInlineAsm() const { 306 if (isCall()) 307 return cast<CallInst>(getInstruction())->isInlineAsm(); 308 return false; 309 } 310 311 /// Get the calling convention of the call. 312 CallingConv::ID getCallingConv() const { 313 CALLSITE_DELEGATE_GETTER(getCallingConv()); 314 } 315 /// Set the calling convention of the call. 316 void setCallingConv(CallingConv::ID CC) { 317 CALLSITE_DELEGATE_SETTER(setCallingConv(CC)); 318 } 319 320 FunctionType *getFunctionType() const { 321 CALLSITE_DELEGATE_GETTER(getFunctionType()); 322 } 323 324 void mutateFunctionType(FunctionType *Ty) const { 325 CALLSITE_DELEGATE_SETTER(mutateFunctionType(Ty)); 326 } 327 328 /// Get the parameter attributes of the call. 329 AttributeList getAttributes() const { 330 CALLSITE_DELEGATE_GETTER(getAttributes()); 331 } 332 /// Set the parameter attributes of the call. 333 void setAttributes(AttributeList PAL) { 334 CALLSITE_DELEGATE_SETTER(setAttributes(PAL)); 335 } 336 337 void addAttribute(unsigned i, Attribute::AttrKind Kind) { 338 CALLSITE_DELEGATE_SETTER(addAttribute(i, Kind)); 339 } 340 341 void addAttribute(unsigned i, Attribute Attr) { 342 CALLSITE_DELEGATE_SETTER(addAttribute(i, Attr)); 343 } 344 345 void addParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) { 346 CALLSITE_DELEGATE_SETTER(addParamAttr(ArgNo, Kind)); 347 } 348 349 void removeAttribute(unsigned i, Attribute::AttrKind Kind) { 350 CALLSITE_DELEGATE_SETTER(removeAttribute(i, Kind)); 351 } 352 353 void removeAttribute(unsigned i, StringRef Kind) { 354 CALLSITE_DELEGATE_SETTER(removeAttribute(i, Kind)); 355 } 356 357 void removeParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) { 358 CALLSITE_DELEGATE_SETTER(removeParamAttr(ArgNo, Kind)); 359 } 360 361 /// Return true if this function has the given attribute. 362 bool hasFnAttr(Attribute::AttrKind Kind) const { 363 CALLSITE_DELEGATE_GETTER(hasFnAttr(Kind)); 364 } 365 366 /// Return true if this function has the given attribute. 367 bool hasFnAttr(StringRef Kind) const { 368 CALLSITE_DELEGATE_GETTER(hasFnAttr(Kind)); 369 } 370 371 /// Return true if this return value has the given attribute. 372 bool hasRetAttr(Attribute::AttrKind Kind) const { 373 CALLSITE_DELEGATE_GETTER(hasRetAttr(Kind)); 374 } 375 376 /// Return true if the call or the callee has the given attribute. 377 bool paramHasAttr(unsigned ArgNo, Attribute::AttrKind Kind) const { 378 CALLSITE_DELEGATE_GETTER(paramHasAttr(ArgNo, Kind)); 379 } 380 381 Attribute getAttribute(unsigned i, Attribute::AttrKind Kind) const { 382 CALLSITE_DELEGATE_GETTER(getAttribute(i, Kind)); 383 } 384 385 Attribute getAttribute(unsigned i, StringRef Kind) const { 386 CALLSITE_DELEGATE_GETTER(getAttribute(i, Kind)); 387 } 388 389 /// Return true if the data operand at index \p i directly or indirectly has 390 /// the attribute \p A. 391 /// 392 /// Normal call or invoke arguments have per operand attributes, as specified 393 /// in the attribute set attached to this instruction, while operand bundle 394 /// operands may have some attributes implied by the type of its containing 395 /// operand bundle. 396 bool dataOperandHasImpliedAttr(unsigned i, Attribute::AttrKind Kind) const { 397 CALLSITE_DELEGATE_GETTER(dataOperandHasImpliedAttr(i, Kind)); 398 } 399 400 /// Extract the alignment of the return value. 401 unsigned getRetAlignment() const { 402 CALLSITE_DELEGATE_GETTER(getRetAlignment()); 403 } 404 405 /// Extract the alignment for a call or parameter (0=unknown). 406 unsigned getParamAlignment(unsigned ArgNo) const { 407 CALLSITE_DELEGATE_GETTER(getParamAlignment(ArgNo)); 408 } 409 410 /// Extract the number of dereferenceable bytes for a call or parameter 411 /// (0=unknown). 412 uint64_t getDereferenceableBytes(unsigned i) const { 413 CALLSITE_DELEGATE_GETTER(getDereferenceableBytes(i)); 414 } 415 416 /// Extract the number of dereferenceable_or_null bytes for a call or 417 /// parameter (0=unknown). 418 uint64_t getDereferenceableOrNullBytes(unsigned i) const { 419 CALLSITE_DELEGATE_GETTER(getDereferenceableOrNullBytes(i)); 420 } 421 422 /// Determine if the return value is marked with NoAlias attribute. 423 bool returnDoesNotAlias() const { 424 CALLSITE_DELEGATE_GETTER(returnDoesNotAlias()); 425 } 426 427 /// Return true if the call should not be treated as a call to a builtin. 428 bool isNoBuiltin() const { 429 CALLSITE_DELEGATE_GETTER(isNoBuiltin()); 430 } 431 432 /// Return true if the call requires strict floating point semantics. 433 bool isStrictFP() const { 434 CALLSITE_DELEGATE_GETTER(isStrictFP()); 435 } 436 437 /// Return true if the call should not be inlined. 438 bool isNoInline() const { 439 CALLSITE_DELEGATE_GETTER(isNoInline()); 440 } 441 void setIsNoInline(bool Value = true) { 442 CALLSITE_DELEGATE_SETTER(setIsNoInline(Value)); 443 } 444 445 /// Determine if the call does not access memory. 446 bool doesNotAccessMemory() const { 447 CALLSITE_DELEGATE_GETTER(doesNotAccessMemory()); 448 } 449 void setDoesNotAccessMemory() { 450 CALLSITE_DELEGATE_SETTER(setDoesNotAccessMemory()); 451 } 452 453 /// Determine if the call does not access or only reads memory. 454 bool onlyReadsMemory() const { 455 CALLSITE_DELEGATE_GETTER(onlyReadsMemory()); 456 } 457 void setOnlyReadsMemory() { 458 CALLSITE_DELEGATE_SETTER(setOnlyReadsMemory()); 459 } 460 461 /// Determine if the call does not access or only writes memory. 462 bool doesNotReadMemory() const { 463 CALLSITE_DELEGATE_GETTER(doesNotReadMemory()); 464 } 465 void setDoesNotReadMemory() { 466 CALLSITE_DELEGATE_SETTER(setDoesNotReadMemory()); 467 } 468 469 /// Determine if the call can access memmory only using pointers based 470 /// on its arguments. 471 bool onlyAccessesArgMemory() const { 472 CALLSITE_DELEGATE_GETTER(onlyAccessesArgMemory()); 473 } 474 void setOnlyAccessesArgMemory() { 475 CALLSITE_DELEGATE_SETTER(setOnlyAccessesArgMemory()); 476 } 477 478 /// Determine if the function may only access memory that is 479 /// inaccessible from the IR. 480 bool onlyAccessesInaccessibleMemory() const { 481 CALLSITE_DELEGATE_GETTER(onlyAccessesInaccessibleMemory()); 482 } 483 void setOnlyAccessesInaccessibleMemory() { 484 CALLSITE_DELEGATE_SETTER(setOnlyAccessesInaccessibleMemory()); 485 } 486 487 /// Determine if the function may only access memory that is 488 /// either inaccessible from the IR or pointed to by its arguments. 489 bool onlyAccessesInaccessibleMemOrArgMem() const { 490 CALLSITE_DELEGATE_GETTER(onlyAccessesInaccessibleMemOrArgMem()); 491 } 492 void setOnlyAccessesInaccessibleMemOrArgMem() { 493 CALLSITE_DELEGATE_SETTER(setOnlyAccessesInaccessibleMemOrArgMem()); 494 } 495 496 /// Determine if the call cannot return. 497 bool doesNotReturn() const { 498 CALLSITE_DELEGATE_GETTER(doesNotReturn()); 499 } 500 void setDoesNotReturn() { 501 CALLSITE_DELEGATE_SETTER(setDoesNotReturn()); 502 } 503 504 /// Determine if the call cannot unwind. 505 bool doesNotThrow() const { 506 CALLSITE_DELEGATE_GETTER(doesNotThrow()); 507 } 508 void setDoesNotThrow() { 509 CALLSITE_DELEGATE_SETTER(setDoesNotThrow()); 510 } 511 512 /// Determine if the call can be duplicated. 513 bool cannotDuplicate() const { 514 CALLSITE_DELEGATE_GETTER(cannotDuplicate()); 515 } 516 void setCannotDuplicate() { 517 CALLSITE_DELEGATE_SETTER(setCannotDuplicate()); 518 } 519 520 /// Determine if the call is convergent. 521 bool isConvergent() const { 522 CALLSITE_DELEGATE_GETTER(isConvergent()); 523 } 524 void setConvergent() { 525 CALLSITE_DELEGATE_SETTER(setConvergent()); 526 } 527 void setNotConvergent() { 528 CALLSITE_DELEGATE_SETTER(setNotConvergent()); 529 } 530 531 unsigned getNumOperandBundles() const { 532 CALLSITE_DELEGATE_GETTER(getNumOperandBundles()); 533 } 534 535 bool hasOperandBundles() const { 536 CALLSITE_DELEGATE_GETTER(hasOperandBundles()); 537 } 538 539 unsigned getBundleOperandsStartIndex() const { 540 CALLSITE_DELEGATE_GETTER(getBundleOperandsStartIndex()); 541 } 542 543 unsigned getBundleOperandsEndIndex() const { 544 CALLSITE_DELEGATE_GETTER(getBundleOperandsEndIndex()); 545 } 546 547 unsigned getNumTotalBundleOperands() const { 548 CALLSITE_DELEGATE_GETTER(getNumTotalBundleOperands()); 549 } 550 551 OperandBundleUse getOperandBundleAt(unsigned Index) const { 552 CALLSITE_DELEGATE_GETTER(getOperandBundleAt(Index)); 553 } 554 555 Optional<OperandBundleUse> getOperandBundle(StringRef Name) const { 556 CALLSITE_DELEGATE_GETTER(getOperandBundle(Name)); 557 } 558 559 Optional<OperandBundleUse> getOperandBundle(uint32_t ID) const { 560 CALLSITE_DELEGATE_GETTER(getOperandBundle(ID)); 561 } 562 563 unsigned countOperandBundlesOfType(uint32_t ID) const { 564 CALLSITE_DELEGATE_GETTER(countOperandBundlesOfType(ID)); 565 } 566 567 bool isBundleOperand(unsigned Idx) const { 568 CALLSITE_DELEGATE_GETTER(isBundleOperand(Idx)); 569 } 570 571 IterTy arg_begin() const { 572 CALLSITE_DELEGATE_GETTER(arg_begin()); 573 } 574 575 IterTy arg_end() const { 576 CALLSITE_DELEGATE_GETTER(arg_end()); 577 } 578 579 #undef CALLSITE_DELEGATE_GETTER 580 #undef CALLSITE_DELEGATE_SETTER 581 582 void getOperandBundlesAsDefs(SmallVectorImpl<OperandBundleDef> &Defs) const { 583 const Instruction *II = getInstruction(); 584 // Since this is actually a getter that "looks like" a setter, don't use the 585 // above macros to avoid confusion. 586 if (isCall()) 587 cast<CallInst>(II)->getOperandBundlesAsDefs(Defs); 588 else 589 cast<InvokeInst>(II)->getOperandBundlesAsDefs(Defs); 590 } 591 592 /// Determine whether this data operand is not captured. 593 bool doesNotCapture(unsigned OpNo) const { 594 return dataOperandHasImpliedAttr(OpNo + 1, Attribute::NoCapture); 595 } 596 597 /// Determine whether this argument is passed by value. 598 bool isByValArgument(unsigned ArgNo) const { 599 return paramHasAttr(ArgNo, Attribute::ByVal); 600 } 601 602 /// Determine whether this argument is passed in an alloca. 603 bool isInAllocaArgument(unsigned ArgNo) const { 604 return paramHasAttr(ArgNo, Attribute::InAlloca); 605 } 606 607 /// Determine whether this argument is passed by value or in an alloca. 608 bool isByValOrInAllocaArgument(unsigned ArgNo) const { 609 return paramHasAttr(ArgNo, Attribute::ByVal) || 610 paramHasAttr(ArgNo, Attribute::InAlloca); 611 } 612 613 /// Determine if there are is an inalloca argument. Only the last argument can 614 /// have the inalloca attribute. 615 bool hasInAllocaArgument() const { 616 return !arg_empty() && paramHasAttr(arg_size() - 1, Attribute::InAlloca); 617 } 618 619 bool doesNotAccessMemory(unsigned OpNo) const { 620 return dataOperandHasImpliedAttr(OpNo + 1, Attribute::ReadNone); 621 } 622 623 bool onlyReadsMemory(unsigned OpNo) const { 624 return dataOperandHasImpliedAttr(OpNo + 1, Attribute::ReadOnly) || 625 dataOperandHasImpliedAttr(OpNo + 1, Attribute::ReadNone); 626 } 627 628 bool doesNotReadMemory(unsigned OpNo) const { 629 return dataOperandHasImpliedAttr(OpNo + 1, Attribute::WriteOnly) || 630 dataOperandHasImpliedAttr(OpNo + 1, Attribute::ReadNone); 631 } 632 633 /// Return true if the return value is known to be not null. 634 /// This may be because it has the nonnull attribute, or because at least 635 /// one byte is dereferenceable and the pointer is in addrspace(0). 636 bool isReturnNonNull() const { 637 if (hasRetAttr(Attribute::NonNull)) 638 return true; 639 else if (getDereferenceableBytes(AttributeList::ReturnIndex) > 0 && 640 !NullPointerIsDefined(getCaller(), 641 getType()->getPointerAddressSpace())) 642 return true; 643 644 return false; 645 } 646 647 /// Returns true if this CallSite passes the given Value* as an argument to 648 /// the called function. 649 bool hasArgument(const Value *Arg) const { 650 for (arg_iterator AI = this->arg_begin(), E = this->arg_end(); AI != E; 651 ++AI) 652 if (AI->get() == Arg) 653 return true; 654 return false; 655 } 656 657 private: 658 IterTy getCallee() const { 659 if (isCall()) // Skip Callee 660 return cast<CallInst>(getInstruction())->op_end() - 1; 661 else // Skip BB, BB, Callee 662 return cast<InvokeInst>(getInstruction())->op_end() - 3; 663 } 664 }; 665 666 class CallSite : public CallSiteBase<Function, BasicBlock, Value, User, Use, 667 Instruction, CallInst, InvokeInst, 668 User::op_iterator> { 669 public: 670 CallSite() = default; 671 CallSite(CallSiteBase B) : CallSiteBase(B) {} 672 CallSite(CallInst *CI) : CallSiteBase(CI) {} 673 CallSite(InvokeInst *II) : CallSiteBase(II) {} 674 explicit CallSite(Instruction *II) : CallSiteBase(II) {} 675 explicit CallSite(Value *V) : CallSiteBase(V) {} 676 677 bool operator==(const CallSite &CS) const { return I == CS.I; } 678 bool operator!=(const CallSite &CS) const { return I != CS.I; } 679 bool operator<(const CallSite &CS) const { 680 return getInstruction() < CS.getInstruction(); 681 } 682 683 private: 684 friend struct DenseMapInfo<CallSite>; 685 686 User::op_iterator getCallee() const; 687 }; 688 689 template <> struct DenseMapInfo<CallSite> { 690 using BaseInfo = DenseMapInfo<decltype(CallSite::I)>; 691 692 static CallSite getEmptyKey() { 693 CallSite CS; 694 CS.I = BaseInfo::getEmptyKey(); 695 return CS; 696 } 697 698 static CallSite getTombstoneKey() { 699 CallSite CS; 700 CS.I = BaseInfo::getTombstoneKey(); 701 return CS; 702 } 703 704 static unsigned getHashValue(const CallSite &CS) { 705 return BaseInfo::getHashValue(CS.I); 706 } 707 708 static bool isEqual(const CallSite &LHS, const CallSite &RHS) { 709 return LHS == RHS; 710 } 711 }; 712 713 /// Establish a view to a call site for examination. 714 class ImmutableCallSite : public CallSiteBase<> { 715 public: 716 ImmutableCallSite() = default; 717 ImmutableCallSite(const CallInst *CI) : CallSiteBase(CI) {} 718 ImmutableCallSite(const InvokeInst *II) : CallSiteBase(II) {} 719 explicit ImmutableCallSite(const Instruction *II) : CallSiteBase(II) {} 720 explicit ImmutableCallSite(const Value *V) : CallSiteBase(V) {} 721 ImmutableCallSite(CallSite CS) : CallSiteBase(CS.getInstruction()) {} 722 }; 723 724 } // end namespace llvm 725 726 #endif // LLVM_IR_CALLSITE_H 727