LCOV - code coverage report
Current view: top level - include/llvm/IR - CallSite.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 171 176 97.2 %
Date: 2018-02-19 03:08:00 Functions: 91 93 97.8 %
Legend: Lines: hit not hit

          Line data    Source code
       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   396420554 :   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   136844601 :       if (II->getOpcode() == Instruction::Call)
      77             :         return CallSiteBase(static_cast<CallTy*>(II));
      78    90779428 :       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      486633 :   bool isInvoke() const { return getInstruction() && !I.getInt(); }
      91             : 
      92             :   InstrTy *getInstruction() const { return I.getPointer(); }
      93             :   InstrTy *operator->() const { return I.getPointer(); }
      94       96014 :   explicit operator bool() const { return I.getPointer(); }
      95             : 
      96             :   /// Get the basic block containing the call site.
      97       97350 :   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    56546449 :     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         709 :   bool isIndirectCall() const {
     113             :     const Value *V = getCalledValue();
     114         709 :     if (!V)
     115             :       return false;
     116         709 :     if (isa<FunTy>(V) || isa<Constant>(V))
     117             :       return false;
     118             :     if (const CallInst *CI = dyn_cast<CallInst>(getInstruction())) {
     119          94 :       if (CI->isInlineAsm())
     120             :         return false;
     121             :     }
     122             :     return true;
     123             :   }
     124             : 
     125             :   /// Set the callee to the specified value.
     126          94 :   void setCalledFunction(Value *V) {
     127             :     assert(getInstruction() && "Not a call or invoke instruction!");
     128             :     *getCallee() = V;
     129          94 :   }
     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       70756 :       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      388984 :   bool isArgOperand(const Use *U) const {
     157             :     assert(getInstruction() == U->getUser());
     158      388984 :     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        2792 :   bool isBundleOperand(const Use *U) const {
     168             :     assert(getInstruction() == U->getUser());
     169        2792 :     if (!hasOperandBundles())
     170             :       return false;
     171           3 :     unsigned OperandNo = U - (*this)->op_begin();
     172           2 :     return getBundleOperandsStartIndex() <= OperandNo &&
     173           1 :            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      314085 :   bool isDataOperand(const Use *U) const {
     183      314085 :     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     5875220 :     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         221 :     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        5708 :     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     3764850 :   iterator_range<IterTy> args() const {
     216     7529700 :     return make_range(arg_begin(), arg_end());
     217             :   }
     218     1140992 :   bool arg_empty() const { return arg_end() == arg_begin(); }
     219     7178332 :   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      775002 :     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     3212703 :     return (*this)->op_begin();
     248             :   }
     249     2825202 :   IterTy data_operands_end() const {
     250             :     assert(getInstruction() && "Not a call or invoke instruction!");
     251     5650404 :     return (*this)->op_end() - (isCall() ? 1 : 3);
     252             :   }
     253         222 :   iterator_range<IterTy> data_ops() const {
     254         444 :     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      297411 :   Type *getType() const { return (*this)->getType(); }
     265             : 
     266             :   /// Return the caller function for this call site.
     267     2581007 :   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      364174 :     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           4 :     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      333997 :   unsigned getNumArgOperands() const {
     294      667994 :     CALLSITE_DELEGATE_GETTER(getNumArgOperands());
     295             :   }
     296             : 
     297     2464157 :   ValTy *getArgOperand(unsigned i) const {
     298     4928314 :     CALLSITE_DELEGATE_GETTER(getArgOperand(i));
     299             :   }
     300             : 
     301      968963 :   ValTy *getReturnedArgOperand() const {
     302      968963 :     CALLSITE_DELEGATE_GETTER(getReturnedArgOperand());
     303             :   }
     304             : 
     305             :   bool isInlineAsm() const {
     306        1920 :     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     3089154 :     CALLSITE_DELEGATE_GETTER(getCallingConv());
     314             :   }
     315             :   /// Set the calling convention of the call.
     316      257977 :   void setCallingConv(CallingConv::ID CC) {
     317      303585 :     CALLSITE_DELEGATE_SETTER(setCallingConv(CC));
     318      257977 :   }
     319             : 
     320             :   FunctionType *getFunctionType() const {
     321      782691 :     CALLSITE_DELEGATE_GETTER(getFunctionType());
     322             :   }
     323             : 
     324             :   void mutateFunctionType(FunctionType *Ty) const {
     325         555 :     CALLSITE_DELEGATE_SETTER(mutateFunctionType(Ty));
     326             :   }
     327             : 
     328             :   /// Get the parameter attributes of the call.
     329             :   AttributeList getAttributes() const {
     330      986290 :     CALLSITE_DELEGATE_GETTER(getAttributes());
     331             :   }
     332             :   /// Set the parameter attributes of the call.
     333             :   void setAttributes(AttributeList PAL) {
     334      435135 :     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           5 :   void addAttribute(unsigned i, Attribute Attr) {
     342           5 :     CALLSITE_DELEGATE_SETTER(addAttribute(i, Attr));
     343           5 :   }
     344             : 
     345          49 :   void addParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) {
     346          49 :     CALLSITE_DELEGATE_SETTER(addParamAttr(ArgNo, Kind));
     347          49 :   }
     348             : 
     349           6 :   void removeAttribute(unsigned i, Attribute::AttrKind Kind) {
     350           6 :     CALLSITE_DELEGATE_SETTER(removeAttribute(i, Kind));
     351           6 :   }
     352             : 
     353           0 :   void removeAttribute(unsigned i, StringRef Kind) {
     354           0 :     CALLSITE_DELEGATE_SETTER(removeAttribute(i, Kind));
     355           0 :   }
     356             : 
     357           7 :   void removeParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) {
     358           7 :     CALLSITE_DELEGATE_SETTER(removeParamAttr(ArgNo, Kind));
     359           7 :   }
     360             : 
     361             :   /// Return true if this function has the given attribute.
     362     2403228 :   bool hasFnAttr(Attribute::AttrKind Kind) const {
     363     4806456 :     CALLSITE_DELEGATE_GETTER(hasFnAttr(Kind));
     364             :   }
     365             : 
     366             :   /// Return true if this function has the given attribute.
     367         796 :   bool hasFnAttr(StringRef Kind) const {
     368        1592 :     CALLSITE_DELEGATE_GETTER(hasFnAttr(Kind));
     369             :   }
     370             : 
     371             :   /// Return true if this return value has the given attribute.
     372     1552809 :   bool hasRetAttr(Attribute::AttrKind Kind) const {
     373     1552809 :     CALLSITE_DELEGATE_GETTER(hasRetAttr(Kind));
     374             :   }
     375             : 
     376             :   /// Return true if the call or the callee has the given attribute.
     377    16453529 :   bool paramHasAttr(unsigned ArgNo, Attribute::AttrKind Kind) const {
     378    16453529 :     CALLSITE_DELEGATE_GETTER(paramHasAttr(ArgNo, Kind));
     379             :   }
     380             : 
     381        1064 :   Attribute getAttribute(unsigned i, Attribute::AttrKind Kind) const {
     382        2128 :     CALLSITE_DELEGATE_GETTER(getAttribute(i, Kind));
     383             :   }
     384             : 
     385           0 :   Attribute getAttribute(unsigned i, StringRef Kind) const {
     386           0 :     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     2691449 :   bool dataOperandHasImpliedAttr(unsigned i, Attribute::AttrKind Kind) const {
     397     2691449 :     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      535671 :   unsigned getParamAlignment(unsigned ArgNo) const {
     407     1071342 :     CALLSITE_DELEGATE_GETTER(getParamAlignment(ArgNo));
     408             :   }
     409             : 
     410             :   /// Extract the number of dereferenceable bytes for a call or parameter
     411             :   /// (0=unknown).
     412       61857 :   uint64_t getDereferenceableBytes(unsigned i) const {
     413      123714 :     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        2153 :   uint64_t getDereferenceableOrNullBytes(unsigned i) const {
     419        4306 :     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    18174885 :   bool isNoBuiltin() const {
     429    18174885 :     CALLSITE_DELEGATE_GETTER(isNoBuiltin());
     430             :   }
     431             : 
     432             :   /// Return true if the call requires strict floating point semantics.
     433     9288832 :   bool isStrictFP() const {
     434    18577664 :     CALLSITE_DELEGATE_GETTER(isStrictFP());
     435             :   }
     436             : 
     437             :   /// Return true if the call should not be inlined.
     438      391861 :   bool isNoInline() const {
     439      783722 :     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     8894713 :   bool doesNotAccessMemory() const {
     447    17789426 :     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    13018756 :   bool onlyReadsMemory() const {
     455    13018756 :     CALLSITE_DELEGATE_GETTER(onlyReadsMemory());
     456             :   }
     457           5 :   void setOnlyReadsMemory() {
     458           5 :     CALLSITE_DELEGATE_SETTER(setOnlyReadsMemory());
     459           5 :   }
     460             : 
     461             :   /// Determine if the call does not access or only writes memory.
     462     8742362 :   bool doesNotReadMemory() const {
     463     8742362 :     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     8951910 :   bool onlyAccessesArgMemory() const {
     472    17903820 :     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     2074798 :   bool onlyAccessesInaccessibleMemory() const {
     481     4149596 :     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     2074633 :   bool onlyAccessesInaccessibleMemOrArgMem() const {
     490     4149266 :     CALLSITE_DELEGATE_GETTER(onlyAccessesInaccessibleMemOrArgMem());
     491             :   }
     492             :   void setOnlyAccessesInaccessibleMemOrArgMem() {
     493             :     CALLSITE_DELEGATE_SETTER(setOnlyAccessesInaccessibleMemOrArgMem());
     494             :   }
     495             : 
     496             :   /// Determine if the call cannot return.
     497      521038 :   bool doesNotReturn() const {
     498     1042076 :     CALLSITE_DELEGATE_GETTER(doesNotReturn());
     499             :   }
     500          48 :   void setDoesNotReturn() {
     501          48 :     CALLSITE_DELEGATE_SETTER(setDoesNotReturn());
     502          48 :   }
     503             : 
     504             :   /// Determine if the call cannot unwind.
     505      562803 :   bool doesNotThrow() const {
     506     1125606 :     CALLSITE_DELEGATE_GETTER(doesNotThrow());
     507             :   }
     508          25 :   void setDoesNotThrow() {
     509          25 :     CALLSITE_DELEGATE_SETTER(setDoesNotThrow());
     510          25 :   }
     511             : 
     512             :   /// Determine if the call can be duplicated.
     513       57818 :   bool cannotDuplicate() const {
     514      115636 :     CALLSITE_DELEGATE_GETTER(cannotDuplicate());
     515             :   }
     516          16 :   void setCannotDuplicate() {
     517          16 :     CALLSITE_DELEGATE_SETTER(setCannotDuplicate());
     518          16 :   }
     519             : 
     520             :   /// Determine if the call is convergent.
     521     3042402 :   bool isConvergent() const {
     522     6084804 :     CALLSITE_DELEGATE_GETTER(isConvergent());
     523             :   }
     524             :   void setConvergent() {
     525             :     CALLSITE_DELEGATE_SETTER(setConvergent());
     526             :   }
     527           2 :   void setNotConvergent() {
     528           2 :     CALLSITE_DELEGATE_SETTER(setNotConvergent());
     529           2 :   }
     530             : 
     531      644249 :   unsigned getNumOperandBundles() const {
     532      644249 :     CALLSITE_DELEGATE_GETTER(getNumOperandBundles());
     533             :   }
     534             : 
     535    17884423 :   bool hasOperandBundles() const {
     536    35768846 :     CALLSITE_DELEGATE_GETTER(hasOperandBundles());
     537             :   }
     538             : 
     539           1 :   unsigned getBundleOperandsStartIndex() const {
     540           2 :     CALLSITE_DELEGATE_GETTER(getBundleOperandsStartIndex());
     541             :   }
     542             : 
     543           1 :   unsigned getBundleOperandsEndIndex() const {
     544           2 :     CALLSITE_DELEGATE_GETTER(getBundleOperandsEndIndex());
     545             :   }
     546             : 
     547             :   unsigned getNumTotalBundleOperands() const {
     548             :     CALLSITE_DELEGATE_GETTER(getNumTotalBundleOperands());
     549             :   }
     550             : 
     551        3348 :   OperandBundleUse getOperandBundleAt(unsigned Index) const {
     552        3348 :     CALLSITE_DELEGATE_GETTER(getOperandBundleAt(Index));
     553             :   }
     554             : 
     555             :   Optional<OperandBundleUse> getOperandBundle(StringRef Name) const {
     556             :     CALLSITE_DELEGATE_GETTER(getOperandBundle(Name));
     557             :   }
     558             : 
     559       92975 :   Optional<OperandBundleUse> getOperandBundle(uint32_t ID) const {
     560       92975 :     CALLSITE_DELEGATE_GETTER(getOperandBundle(ID));
     561             :   }
     562             : 
     563         769 :   unsigned countOperandBundlesOfType(uint32_t ID) const {
     564         769 :     CALLSITE_DELEGATE_GETTER(countOperandBundlesOfType(ID));
     565             :   }
     566             : 
     567      492360 :   bool isBundleOperand(unsigned Idx) const {
     568      492360 :     CALLSITE_DELEGATE_GETTER(isBundleOperand(Idx));
     569             :   }
     570             : 
     571             :   IterTy arg_begin() const {
     572    29634453 :     CALLSITE_DELEGATE_GETTER(arg_begin());
     573             :   }
     574             : 
     575    18223854 :   IterTy arg_end() const {
     576    36447708 :     CALLSITE_DELEGATE_GETTER(arg_end());
     577             :   }
     578             : 
     579             : #undef CALLSITE_DELEGATE_GETTER
     580             : #undef CALLSITE_DELEGATE_SETTER
     581             : 
     582        2103 :   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        2103 :     if (isCall())
     587        2073 :       cast<CallInst>(II)->getOperandBundlesAsDefs(Defs);
     588             :     else
     589          30 :       cast<InvokeInst>(II)->getOperandBundlesAsDefs(Defs);
     590        2103 :   }
     591             : 
     592             :   /// Determine whether this data operand is not captured.
     593             :   bool doesNotCapture(unsigned OpNo) const {
     594     2646050 :     return dataOperandHasImpliedAttr(OpNo + 1, Attribute::NoCapture);
     595             :   }
     596             : 
     597             :   /// Determine whether this argument is passed by value.
     598             :   bool isByValArgument(unsigned ArgNo) const {
     599     2310747 :     return paramHasAttr(ArgNo, Attribute::ByVal);
     600             :   }
     601             : 
     602             :   /// Determine whether this argument is passed in an alloca.
     603             :   bool isInAllocaArgument(unsigned ArgNo) const {
     604      281454 :     return paramHasAttr(ArgNo, Attribute::InAlloca);
     605             :   }
     606             : 
     607             :   /// Determine whether this argument is passed by value or in an alloca.
     608          10 :   bool isByValOrInAllocaArgument(unsigned ArgNo) const {
     609          19 :     return paramHasAttr(ArgNo, Attribute::ByVal) ||
     610          19 :            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      570337 :   bool hasInAllocaArgument() const {
     616      570337 :     return !arg_empty() && paramHasAttr(arg_size() - 1, Attribute::InAlloca);
     617             :   }
     618             : 
     619             :   bool doesNotAccessMemory(unsigned OpNo) const {
     620       33309 :     return dataOperandHasImpliedAttr(OpNo + 1, Attribute::ReadNone);
     621             :   }
     622             : 
     623        4395 :   bool onlyReadsMemory(unsigned OpNo) const {
     624        8085 :     return dataOperandHasImpliedAttr(OpNo + 1, Attribute::ReadOnly) ||
     625        8085 :            dataOperandHasImpliedAttr(OpNo + 1, Attribute::ReadNone);
     626             :   }
     627             : 
     628        2134 :   bool doesNotReadMemory(unsigned OpNo) const {
     629        4005 :     return dataOperandHasImpliedAttr(OpNo + 1, Attribute::WriteOnly) ||
     630        4005 :            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       61615 :   bool isReturnNonNull() const {
     637       61615 :     if (hasRetAttr(Attribute::NonNull))
     638             :       return true;
     639       64258 :     else if (getDereferenceableBytes(AttributeList::ReturnIndex) > 0 &&
     640             :              getType()->getPointerAddressSpace() == 0)
     641             :       return true;
     642             : 
     643             :     return false;
     644             :   }
     645             : 
     646             :   /// Returns true if this CallSite passes the given Value* as an argument to
     647             :   /// the called function.
     648             :   bool hasArgument(const Value *Arg) const {
     649             :     for (arg_iterator AI = this->arg_begin(), E = this->arg_end(); AI != E;
     650             :          ++AI)
     651             :       if (AI->get() == Arg)
     652             :         return true;
     653             :     return false;
     654             :   }
     655             : 
     656             : private:
     657             :   IterTy getCallee() const {
     658    59665058 :     if (isCall()) // Skip Callee
     659    56489347 :       return cast<CallInst>(getInstruction())->op_end() - 1;
     660             :     else // Skip BB, BB, Callee
     661     3175711 :       return cast<InvokeInst>(getInstruction())->op_end() - 3;
     662             :   }
     663             : };
     664             : 
     665             : class CallSite : public CallSiteBase<Function, BasicBlock, Value, User, Use,
     666             :                                      Instruction, CallInst, InvokeInst,
     667             :                                      User::op_iterator> {
     668             : public:
     669             :   CallSite() = default;
     670             :   CallSite(CallSiteBase B) : CallSiteBase(B) {}
     671             :   CallSite(CallInst *CI) : CallSiteBase(CI) {}
     672             :   CallSite(InvokeInst *II) : CallSiteBase(II) {}
     673             :   explicit CallSite(Instruction *II) : CallSiteBase(II) {}
     674             :   explicit CallSite(Value *V) : CallSiteBase(V) {}
     675             : 
     676             :   bool operator==(const CallSite &CS) const { return I == CS.I; }
     677             :   bool operator!=(const CallSite &CS) const { return I != CS.I; }
     678             :   bool operator<(const CallSite &CS) const {
     679             :     return getInstruction() < CS.getInstruction();
     680             :   }
     681             : 
     682             : private:
     683             :   friend struct DenseMapInfo<CallSite>;
     684             : 
     685             :   User::op_iterator getCallee() const;
     686             : };
     687             : 
     688             : template <> struct DenseMapInfo<CallSite> {
     689             :   using BaseInfo = DenseMapInfo<decltype(CallSite::I)>;
     690             : 
     691             :   static CallSite getEmptyKey() {
     692             :     CallSite CS;
     693             :     CS.I = BaseInfo::getEmptyKey();
     694             :     return CS;
     695             :   }
     696             : 
     697             :   static CallSite getTombstoneKey() {
     698             :     CallSite CS;
     699             :     CS.I = BaseInfo::getTombstoneKey();
     700             :     return CS;
     701             :   }
     702             : 
     703             :   static unsigned getHashValue(const CallSite &CS) {
     704             :     return BaseInfo::getHashValue(CS.I);
     705             :   }
     706             : 
     707             :   static bool isEqual(const CallSite &LHS, const CallSite &RHS) {
     708             :     return LHS == RHS;
     709             :   }
     710             : };
     711             : 
     712             : /// Establish a view to a call site for examination.
     713             : class ImmutableCallSite : public CallSiteBase<> {
     714             : public:
     715             :   ImmutableCallSite() = default;
     716             :   ImmutableCallSite(const CallInst *CI) : CallSiteBase(CI) {}
     717             :   ImmutableCallSite(const InvokeInst *II) : CallSiteBase(II) {}
     718             :   explicit ImmutableCallSite(const Instruction *II) : CallSiteBase(II) {}
     719             :   explicit ImmutableCallSite(const Value *V) : CallSiteBase(V) {}
     720             :   ImmutableCallSite(CallSite CS) : CallSiteBase(CS.getInstruction()) {}
     721             : };
     722             : 
     723             : } // end namespace llvm
     724             : 
     725             : #endif // LLVM_IR_CALLSITE_H

Generated by: LCOV version 1.13