include/llvm/IR/CallSite.h

   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