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