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
34namespace llvm {
35
36class CallInst;
37class InvokeInst;
38
39template <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>
46class CallSiteBase {
47protected:
48  PointerIntPair<InstrTy*, 1, bool> I;
49public:
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); }
54protected:
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  }
69public:
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
315private:
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
331class 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;
335public:
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
349private:
350  User::op_iterator getCallee() const;
351};
352
353/// ImmutableCallSite - establish a view to a call site for examination
354class ImmutableCallSite : public CallSiteBase<> {
355  typedef CallSiteBase<> Base;
356public:
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