Home | History | Annotate | Download | only in IR 
      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/PointerIntPair.h"
     30 #include "llvm/IR/Attributes.h"
     31 #include "llvm/IR/CallingConv.h"
     32 #include "llvm/IR/Instructions.h"
     33 
     34 namespace llvm {
     35 
     36 class CallInst;
     37 class InvokeInst;
     38 
     39 template <typename FunTy = const Function,
     40           typename ValTy = const Value,
     41           typename UserTy = const User,
     42           typename InstrTy = const Instruction,
     43           typename CallTy = const CallInst,
     44           typename InvokeTy = const InvokeInst,
     45           typename IterTy = User::const_op_iterator>
     46 class CallSiteBase {
     47 protected:
     48   PointerIntPair<InstrTy*, 1, bool> I;
     49 public:
     50   CallSiteBase() : I(nullptr, false) {}
     51   CallSiteBase(CallTy *CI) : I(CI, true) { assert(CI); }
     52   CallSiteBase(InvokeTy *II) : I(II, false) { assert(II); }
     53   CallSiteBase(ValTy *II) { *this = get(II); }
     54 protected:
     55   /// CallSiteBase::get - This static method is sort of like a constructor.  It
     56   /// will create an appropriate call site for a Call or Invoke instruction, but
     57   /// it can also create a null initialized CallSiteBase object for something
     58   /// which is NOT a call site.
     59   ///
     60   static CallSiteBase get(ValTy *V) {
     61     if (InstrTy *II = dyn_cast<InstrTy>(V)) {
     62       if (II->getOpcode() == Instruction::Call)
     63         return CallSiteBase(static_cast<CallTy*>(II));
     64       else if (II->getOpcode() == Instruction::Invoke)
     65         return CallSiteBase(static_cast<InvokeTy*>(II));
     66     }
     67     return CallSiteBase();
     68   }
     69 public:
     70   /// isCall - true if a CallInst is enclosed.
     71   /// Note that !isCall() does not mean it is an InvokeInst enclosed,
     72   /// it also could signify a NULL Instruction pointer.
     73   bool isCall() const { return I.getInt(); }
     74 
     75   /// isInvoke - true if a InvokeInst is enclosed.
     76   ///
     77   bool isInvoke() const { return getInstruction() && !I.getInt(); }
     78 
     79   InstrTy *getInstruction() const { return I.getPointer(); }
     80   InstrTy *operator->() const { return I.getPointer(); }
     81   LLVM_EXPLICIT operator bool() const { return I.getPointer(); }
     82 
     83   /// getCalledValue - Return the pointer to function that is being called.
     84   ///
     85   ValTy *getCalledValue() const {
     86     assert(getInstruction() && "Not a call or invoke instruction!");
     87     return *getCallee();
     88   }
     89 
     90   /// getCalledFunction - Return the function being called if this is a direct
     91   /// call, otherwise return null (if it's an indirect call).
     92   ///
     93   FunTy *getCalledFunction() const {
     94     return dyn_cast<FunTy>(getCalledValue());
     95   }
     96 
     97   /// setCalledFunction - Set the callee to the specified value.
     98   ///
     99   void setCalledFunction(Value *V) {
    100     assert(getInstruction() && "Not a call or invoke instruction!");
    101     *getCallee() = V;
    102   }
    103 
    104   /// isCallee - Determine whether the passed iterator points to the
    105   /// callee operand's Use.
    106   bool isCallee(Value::const_user_iterator UI) const {
    107     return isCallee(&UI.getUse());
    108   }
    109 
    110   /// Determine whether this Use is the callee operand's Use.
    111   bool isCallee(const Use *U) const { return getCallee() == U; }
    112 
    113   ValTy *getArgument(unsigned ArgNo) const {
    114     assert(arg_begin() + ArgNo < arg_end() && "Argument # out of range!");
    115     return *(arg_begin() + ArgNo);
    116   }
    117 
    118   void setArgument(unsigned ArgNo, Value* newVal) {
    119     assert(getInstruction() && "Not a call or invoke instruction!");
    120     assert(arg_begin() + ArgNo < arg_end() && "Argument # out of range!");
    121     getInstruction()->setOperand(ArgNo, newVal);
    122   }
    123 
    124   /// Given a value use iterator, returns the argument that corresponds to it.
    125   /// Iterator must actually correspond to an argument.
    126   unsigned getArgumentNo(Value::const_user_iterator I) const {
    127     return getArgumentNo(&I.getUse());
    128   }
    129 
    130   /// Given a use for an argument, get the argument number that corresponds to
    131   /// it.
    132   unsigned getArgumentNo(const Use *U) const {
    133     assert(getInstruction() && "Not a call or invoke instruction!");
    134     assert(arg_begin() <= U && U < arg_end()
    135            && "Argument # out of range!");
    136     return U - arg_begin();
    137   }
    138 
    139   /// arg_iterator - The type of iterator to use when looping over actual
    140   /// arguments at this call site.
    141   typedef IterTy arg_iterator;
    142 
    143   /// arg_begin/arg_end - Return iterators corresponding to the actual argument
    144   /// list for a call site.
    145   IterTy arg_begin() const {
    146     assert(getInstruction() && "Not a call or invoke instruction!");
    147     // Skip non-arguments
    148     return (*this)->op_begin();
    149   }
    150 
    151   IterTy arg_end() const { return (*this)->op_end() - getArgumentEndOffset(); }
    152   bool arg_empty() const { return arg_end() == arg_begin(); }
    153   unsigned arg_size() const { return unsigned(arg_end() - arg_begin()); }
    154 
    155   /// getType - Return the type of the instruction that generated this call site
    156   ///
    157   Type *getType() const { return (*this)->getType(); }
    158 
    159   /// getCaller - Return the caller function for this call site
    160   ///
    161   FunTy *getCaller() const { return (*this)->getParent()->getParent(); }
    162 
    163   /// \brief Tests if this call site must be tail call optimized.  Only a
    164   /// CallInst can be tail call optimized.
    165   bool isMustTailCall() const {
    166     return isCall() && cast<CallInst>(getInstruction())->isMustTailCall();
    167   }
    168 
    169   /// \brief Tests if this call site is marked as a tail call.
    170   bool isTailCall() const {
    171     return isCall() && cast<CallInst>(getInstruction())->isTailCall();
    172   }
    173 
    174 #define CALLSITE_DELEGATE_GETTER(METHOD) \
    175   InstrTy *II = getInstruction();    \
    176   return isCall()                        \
    177     ? cast<CallInst>(II)->METHOD         \
    178     : cast<InvokeInst>(II)->METHOD
    179 
    180 #define CALLSITE_DELEGATE_SETTER(METHOD) \
    181   InstrTy *II = getInstruction();    \
    182   if (isCall())                          \
    183     cast<CallInst>(II)->METHOD;          \
    184   else                                   \
    185     cast<InvokeInst>(II)->METHOD
    186 
    187   /// getCallingConv/setCallingConv - get or set the calling convention of the
    188   /// call.
    189   CallingConv::ID getCallingConv() const {
    190     CALLSITE_DELEGATE_GETTER(getCallingConv());
    191   }
    192   void setCallingConv(CallingConv::ID CC) {
    193     CALLSITE_DELEGATE_SETTER(setCallingConv(CC));
    194   }
    195 
    196   /// getAttributes/setAttributes - get or set the parameter attributes of
    197   /// the call.
    198   const AttributeSet &getAttributes() const {
    199     CALLSITE_DELEGATE_GETTER(getAttributes());
    200   }
    201   void setAttributes(const AttributeSet &PAL) {
    202     CALLSITE_DELEGATE_SETTER(setAttributes(PAL));
    203   }
    204 
    205   /// \brief Return true if this function has the given attribute.
    206   bool hasFnAttr(Attribute::AttrKind A) const {
    207     CALLSITE_DELEGATE_GETTER(hasFnAttr(A));
    208   }
    209 
    210   /// \brief Return true if the call or the callee has the given attribute.
    211   bool paramHasAttr(unsigned i, Attribute::AttrKind A) const {
    212     CALLSITE_DELEGATE_GETTER(paramHasAttr(i, A));
    213   }
    214 
    215   /// @brief Extract the alignment for a call or parameter (0=unknown).
    216   uint16_t getParamAlignment(uint16_t i) const {
    217     CALLSITE_DELEGATE_GETTER(getParamAlignment(i));
    218   }
    219 
    220   /// \brief Return true if the call should not be treated as a call to a
    221   /// builtin.
    222   bool isNoBuiltin() const {
    223     CALLSITE_DELEGATE_GETTER(isNoBuiltin());
    224   }
    225 
    226   /// @brief Return true if the call should not be inlined.
    227   bool isNoInline() const {
    228     CALLSITE_DELEGATE_GETTER(isNoInline());
    229   }
    230   void setIsNoInline(bool Value = true) {
    231     CALLSITE_DELEGATE_SETTER(setIsNoInline(Value));
    232   }
    233 
    234   /// @brief Determine if the call does not access memory.
    235   bool doesNotAccessMemory() const {
    236     CALLSITE_DELEGATE_GETTER(doesNotAccessMemory());
    237   }
    238   void setDoesNotAccessMemory() {
    239     CALLSITE_DELEGATE_SETTER(setDoesNotAccessMemory());
    240   }
    241 
    242   /// @brief Determine if the call does not access or only reads memory.
    243   bool onlyReadsMemory() const {
    244     CALLSITE_DELEGATE_GETTER(onlyReadsMemory());
    245   }
    246   void setOnlyReadsMemory() {
    247     CALLSITE_DELEGATE_SETTER(setOnlyReadsMemory());
    248   }
    249 
    250   /// @brief Determine if the call cannot return.
    251   bool doesNotReturn() const {
    252     CALLSITE_DELEGATE_GETTER(doesNotReturn());
    253   }
    254   void setDoesNotReturn() {
    255     CALLSITE_DELEGATE_SETTER(setDoesNotReturn());
    256   }
    257 
    258   /// @brief Determine if the call cannot unwind.
    259   bool doesNotThrow() const {
    260     CALLSITE_DELEGATE_GETTER(doesNotThrow());
    261   }
    262   void setDoesNotThrow() {
    263     CALLSITE_DELEGATE_SETTER(setDoesNotThrow());
    264   }
    265 
    266 #undef CALLSITE_DELEGATE_GETTER
    267 #undef CALLSITE_DELEGATE_SETTER
    268 
    269   /// @brief Determine whether this argument is not captured.
    270   bool doesNotCapture(unsigned ArgNo) const {
    271     return paramHasAttr(ArgNo + 1, Attribute::NoCapture);
    272   }
    273 
    274   /// @brief Determine whether this argument is passed by value.
    275   bool isByValArgument(unsigned ArgNo) const {
    276     return paramHasAttr(ArgNo + 1, Attribute::ByVal);
    277   }
    278 
    279   /// @brief Determine whether this argument is passed in an alloca.
    280   bool isInAllocaArgument(unsigned ArgNo) const {
    281     return paramHasAttr(ArgNo + 1, Attribute::InAlloca);
    282   }
    283 
    284   /// @brief Determine whether this argument is passed by value or in an alloca.
    285   bool isByValOrInAllocaArgument(unsigned ArgNo) const {
    286     return paramHasAttr(ArgNo + 1, Attribute::ByVal) ||
    287            paramHasAttr(ArgNo + 1, Attribute::InAlloca);
    288   }
    289 
    290   /// @brief Determine if there are is an inalloca argument.  Only the last
    291   /// argument can have the inalloca attribute.
    292   bool hasInAllocaArgument() const {
    293     return paramHasAttr(arg_size(), Attribute::InAlloca);
    294   }
    295 
    296   bool doesNotAccessMemory(unsigned ArgNo) const {
    297     return paramHasAttr(ArgNo + 1, Attribute::ReadNone);
    298   }
    299 
    300   bool onlyReadsMemory(unsigned ArgNo) const {
    301     return paramHasAttr(ArgNo + 1, Attribute::ReadOnly) ||
    302            paramHasAttr(ArgNo + 1, Attribute::ReadNone);
    303   }
    304 
    305   /// hasArgument - Returns true if this CallSite passes the given Value* as an
    306   /// argument to the called function.
    307   bool hasArgument(const Value *Arg) const {
    308     for (arg_iterator AI = this->arg_begin(), E = this->arg_end(); AI != E;
    309          ++AI)
    310       if (AI->get() == Arg)
    311         return true;
    312     return false;
    313   }
    314 
    315 private:
    316   unsigned getArgumentEndOffset() const {
    317     if (isCall())
    318       return 1; // Skip Callee
    319     else
    320       return 3; // Skip BB, BB, Callee
    321   }
    322 
    323   IterTy getCallee() const {
    324     if (isCall()) // Skip Callee
    325       return cast<CallInst>(getInstruction())->op_end() - 1;
    326     else // Skip BB, BB, Callee
    327       return cast<InvokeInst>(getInstruction())->op_end() - 3;
    328   }
    329 };
    330 
    331 class CallSite : public CallSiteBase<Function, Value, User, Instruction,
    332                                      CallInst, InvokeInst, User::op_iterator> {
    333   typedef CallSiteBase<Function, Value, User, Instruction,
    334                        CallInst, InvokeInst, User::op_iterator> Base;
    335 public:
    336   CallSite() {}
    337   CallSite(Base B) : Base(B) {}
    338   CallSite(Value* V) : Base(V) {}
    339   CallSite(CallInst *CI) : Base(CI) {}
    340   CallSite(InvokeInst *II) : Base(II) {}
    341   CallSite(Instruction *II) : Base(II) {}
    342 
    343   bool operator==(const CallSite &CS) const { return I == CS.I; }
    344   bool operator!=(const CallSite &CS) const { return I != CS.I; }
    345   bool operator<(const CallSite &CS) const {
    346     return getInstruction() < CS.getInstruction();
    347   }
    348 
    349 private:
    350   User::op_iterator getCallee() const;
    351 };
    352 
    353 /// ImmutableCallSite - establish a view to a call site for examination
    354 class ImmutableCallSite : public CallSiteBase<> {
    355   typedef CallSiteBase<> Base;
    356 public:
    357   ImmutableCallSite(const Value* V) : Base(V) {}
    358   ImmutableCallSite(const CallInst *CI) : Base(CI) {}
    359   ImmutableCallSite(const InvokeInst *II) : Base(II) {}
    360   ImmutableCallSite(const Instruction *II) : Base(II) {}
    361   ImmutableCallSite(CallSite CS) : Base(CS.getInstruction()) {}
    362 };
    363 
    364 } // End llvm namespace
    365 
    366 #endif
    367