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