Home | History | Annotate | Download | only in Support 
      1 //===-- llvm/Support/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_SUPPORT_CALLSITE_H
     27 #define LLVM_SUPPORT_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(0, 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   ///
    107   bool isCallee(value_use_iterator<UserTy> UI) const {
    108     return getCallee() == &UI.getUse();
    109   }
    110 
    111   ValTy *getArgument(unsigned ArgNo) const {
    112     assert(arg_begin() + ArgNo < arg_end() && "Argument # out of range!");
    113     return *(arg_begin() + ArgNo);
    114   }
    115 
    116   void setArgument(unsigned ArgNo, Value* newVal) {
    117     assert(getInstruction() && "Not a call or invoke instruction!");
    118     assert(arg_begin() + ArgNo < arg_end() && "Argument # out of range!");
    119     getInstruction()->setOperand(ArgNo, newVal);
    120   }
    121 
    122   /// Given a value use iterator, returns the argument that corresponds to it.
    123   /// Iterator must actually correspond to an argument.
    124   unsigned getArgumentNo(value_use_iterator<UserTy> I) const {
    125     assert(getInstruction() && "Not a call or invoke instruction!");
    126     assert(arg_begin() <= &I.getUse() && &I.getUse() < arg_end()
    127            && "Argument # out of range!");
    128     return &I.getUse() - arg_begin();
    129   }
    130 
    131   /// arg_iterator - The type of iterator to use when looping over actual
    132   /// arguments at this call site.
    133   typedef IterTy arg_iterator;
    134 
    135   /// arg_begin/arg_end - Return iterators corresponding to the actual argument
    136   /// list for a call site.
    137   IterTy arg_begin() const {
    138     assert(getInstruction() && "Not a call or invoke instruction!");
    139     // Skip non-arguments
    140     return (*this)->op_begin();
    141   }
    142 
    143   IterTy arg_end() const { return (*this)->op_end() - getArgumentEndOffset(); }
    144   bool arg_empty() const { return arg_end() == arg_begin(); }
    145   unsigned arg_size() const { return unsigned(arg_end() - arg_begin()); }
    146 
    147   /// getType - Return the type of the instruction that generated this call site
    148   ///
    149   Type *getType() const { return (*this)->getType(); }
    150 
    151   /// getCaller - Return the caller function for this call site
    152   ///
    153   FunTy *getCaller() const { return (*this)->getParent()->getParent(); }
    154 
    155 #define CALLSITE_DELEGATE_GETTER(METHOD) \
    156   InstrTy *II = getInstruction();    \
    157   return isCall()                        \
    158     ? cast<CallInst>(II)->METHOD         \
    159     : cast<InvokeInst>(II)->METHOD
    160 
    161 #define CALLSITE_DELEGATE_SETTER(METHOD) \
    162   InstrTy *II = getInstruction();    \
    163   if (isCall())                          \
    164     cast<CallInst>(II)->METHOD;          \
    165   else                                   \
    166     cast<InvokeInst>(II)->METHOD
    167 
    168   /// getCallingConv/setCallingConv - get or set the calling convention of the
    169   /// call.
    170   CallingConv::ID getCallingConv() const {
    171     CALLSITE_DELEGATE_GETTER(getCallingConv());
    172   }
    173   void setCallingConv(CallingConv::ID CC) {
    174     CALLSITE_DELEGATE_SETTER(setCallingConv(CC));
    175   }
    176 
    177   /// getAttributes/setAttributes - get or set the parameter attributes of
    178   /// the call.
    179   const AttributeSet &getAttributes() const {
    180     CALLSITE_DELEGATE_GETTER(getAttributes());
    181   }
    182   void setAttributes(const AttributeSet &PAL) {
    183     CALLSITE_DELEGATE_SETTER(setAttributes(PAL));
    184   }
    185 
    186   /// \brief Return true if this function has the given attribute.
    187   bool hasFnAttr(Attribute::AttrKind A) const {
    188     CALLSITE_DELEGATE_GETTER(hasFnAttr(A));
    189   }
    190 
    191   /// \brief Return true if the call or the callee has the given attribute.
    192   bool paramHasAttr(unsigned i, Attribute::AttrKind A) const {
    193     CALLSITE_DELEGATE_GETTER(paramHasAttr(i, A));
    194   }
    195 
    196   /// @brief Extract the alignment for a call or parameter (0=unknown).
    197   uint16_t getParamAlignment(uint16_t i) const {
    198     CALLSITE_DELEGATE_GETTER(getParamAlignment(i));
    199   }
    200 
    201   /// \brief Return true if the call should not be treated as a call to a
    202   /// builtin.
    203   bool isNoBuiltin() const {
    204     CALLSITE_DELEGATE_GETTER(isNoBuiltin());
    205   }
    206 
    207   /// @brief Return true if the call should not be inlined.
    208   bool isNoInline() const {
    209     CALLSITE_DELEGATE_GETTER(isNoInline());
    210   }
    211   void setIsNoInline(bool Value = true) {
    212     CALLSITE_DELEGATE_SETTER(setIsNoInline(Value));
    213   }
    214 
    215   /// @brief Determine if the call does not access memory.
    216   bool doesNotAccessMemory() const {
    217     CALLSITE_DELEGATE_GETTER(doesNotAccessMemory());
    218   }
    219   void setDoesNotAccessMemory() {
    220     CALLSITE_DELEGATE_SETTER(setDoesNotAccessMemory());
    221   }
    222 
    223   /// @brief Determine if the call does not access or only reads memory.
    224   bool onlyReadsMemory() const {
    225     CALLSITE_DELEGATE_GETTER(onlyReadsMemory());
    226   }
    227   void setOnlyReadsMemory() {
    228     CALLSITE_DELEGATE_SETTER(setOnlyReadsMemory());
    229   }
    230 
    231   /// @brief Determine if the call cannot return.
    232   bool doesNotReturn() const {
    233     CALLSITE_DELEGATE_GETTER(doesNotReturn());
    234   }
    235   void setDoesNotReturn() {
    236     CALLSITE_DELEGATE_SETTER(setDoesNotReturn());
    237   }
    238 
    239   /// @brief Determine if the call cannot unwind.
    240   bool doesNotThrow() const {
    241     CALLSITE_DELEGATE_GETTER(doesNotThrow());
    242   }
    243   void setDoesNotThrow() {
    244     CALLSITE_DELEGATE_SETTER(setDoesNotThrow());
    245   }
    246 
    247 #undef CALLSITE_DELEGATE_GETTER
    248 #undef CALLSITE_DELEGATE_SETTER
    249 
    250   /// @brief Determine whether this argument is not captured.
    251   bool doesNotCapture(unsigned ArgNo) const {
    252     return paramHasAttr(ArgNo + 1, Attribute::NoCapture);
    253   }
    254 
    255   /// @brief Determine whether this argument is passed by value.
    256   bool isByValArgument(unsigned ArgNo) const {
    257     return paramHasAttr(ArgNo + 1, Attribute::ByVal);
    258   }
    259 
    260   bool doesNotAccessMemory(unsigned ArgNo) const {
    261     return paramHasAttr(ArgNo + 1, Attribute::ReadNone);
    262   }
    263 
    264   bool onlyReadsMemory(unsigned ArgNo) const {
    265     return paramHasAttr(ArgNo + 1, Attribute::ReadOnly) ||
    266            paramHasAttr(ArgNo + 1, Attribute::ReadNone);
    267   }
    268 
    269   /// hasArgument - Returns true if this CallSite passes the given Value* as an
    270   /// argument to the called function.
    271   bool hasArgument(const Value *Arg) const {
    272     for (arg_iterator AI = this->arg_begin(), E = this->arg_end(); AI != E;
    273          ++AI)
    274       if (AI->get() == Arg)
    275         return true;
    276     return false;
    277   }
    278 
    279 private:
    280   unsigned getArgumentEndOffset() const {
    281     if (isCall())
    282       return 1; // Skip Callee
    283     else
    284       return 3; // Skip BB, BB, Callee
    285   }
    286 
    287   IterTy getCallee() const {
    288     if (isCall()) // Skip Callee
    289       return cast<CallInst>(getInstruction())->op_end() - 1;
    290     else // Skip BB, BB, Callee
    291       return cast<InvokeInst>(getInstruction())->op_end() - 3;
    292   }
    293 };
    294 
    295 class CallSite : public CallSiteBase<Function, Value, User, Instruction,
    296                                      CallInst, InvokeInst, User::op_iterator> {
    297   typedef CallSiteBase<Function, Value, User, Instruction,
    298                        CallInst, InvokeInst, User::op_iterator> Base;
    299 public:
    300   CallSite() {}
    301   CallSite(Base B) : Base(B) {}
    302   CallSite(Value* V) : Base(V) {}
    303   CallSite(CallInst *CI) : Base(CI) {}
    304   CallSite(InvokeInst *II) : Base(II) {}
    305   CallSite(Instruction *II) : Base(II) {}
    306 
    307   bool operator==(const CallSite &CS) const { return I == CS.I; }
    308   bool operator!=(const CallSite &CS) const { return I != CS.I; }
    309   bool operator<(const CallSite &CS) const {
    310     return getInstruction() < CS.getInstruction();
    311   }
    312 
    313 private:
    314   User::op_iterator getCallee() const;
    315 };
    316 
    317 /// ImmutableCallSite - establish a view to a call site for examination
    318 class ImmutableCallSite : public CallSiteBase<> {
    319   typedef CallSiteBase<> Base;
    320 public:
    321   ImmutableCallSite(const Value* V) : Base(V) {}
    322   ImmutableCallSite(const CallInst *CI) : Base(CI) {}
    323   ImmutableCallSite(const InvokeInst *II) : Base(II) {}
    324   ImmutableCallSite(const Instruction *II) : Base(II) {}
    325   ImmutableCallSite(CallSite CS) : Base(CS.getInstruction()) {}
    326 };
    327 
    328 } // End llvm namespace
    329 
    330 #endif
    331