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/Optional.h" |
30 | #include "llvm/ADT/PointerIntPair.h" |
31 | #include "llvm/ADT/iterator_range.h" |
32 | #include "llvm/IR/Attributes.h" |
33 | #include "llvm/IR/CallingConv.h" |
34 | #include "llvm/IR/Function.h" |
35 | #include "llvm/IR/InstrTypes.h" |
36 | #include "llvm/IR/Instruction.h" |
37 | #include "llvm/IR/Instructions.h" |
38 | #include "llvm/IR/Use.h" |
39 | #include "llvm/IR/User.h" |
40 | #include "llvm/IR/Value.h" |
41 | #include "llvm/Support/Casting.h" |
42 | #include <cassert> |
43 | #include <cstdint> |
44 | #include <iterator> |
45 | |
46 | namespace llvm { |
47 | |
48 | namespace Intrinsic { |
49 | enum ID : unsigned; |
50 | } |
51 | |
52 | template <typename FunTy = const Function, |
53 | typename BBTy = const BasicBlock, |
54 | typename ValTy = const Value, |
55 | typename UserTy = const User, |
56 | typename UseTy = const Use, |
57 | typename InstrTy = const Instruction, |
58 | typename CallTy = const CallInst, |
59 | typename InvokeTy = const InvokeInst, |
60 | typename IterTy = User::const_op_iterator> |
61 | class CallSiteBase { |
62 | protected: |
63 | PointerIntPair<InstrTy*, 1, bool> I; |
64 | |
65 | CallSiteBase() = default; |
66 | CallSiteBase(CallTy *CI) : I(CI, true) { assert(CI); } |
67 | CallSiteBase(InvokeTy *II) : I(II, false) { assert(II); } |
68 | explicit CallSiteBase(ValTy *II) { *this = get(II); } |
69 | |
70 | private: |
71 | /// This static method is like a constructor. It will create an appropriate |
72 | /// call site for a Call or Invoke instruction, but it can also create a null |
73 | /// initialized CallSiteBase object for something which is NOT a call site. |
74 | static CallSiteBase get(ValTy *V) { |
75 | if (InstrTy *II = dyn_cast<InstrTy>(V)) { |
76 | if (II->getOpcode() == Instruction::Call) |
77 | return CallSiteBase(static_cast<CallTy*>(II)); |
78 | else if (II->getOpcode() == Instruction::Invoke) |
79 | return CallSiteBase(static_cast<InvokeTy*>(II)); |
80 | } |
81 | return CallSiteBase(); |
82 | } |
83 | |
84 | public: |
85 | /// Return true if a CallInst is enclosed. Note that !isCall() does not mean |
86 | /// an InvokeInst is enclosed. It may also signify a NULL instruction pointer. |
87 | bool isCall() const { return I.getInt(); } |
88 | |
89 | /// Return true if a InvokeInst is enclosed. |
90 | bool isInvoke() const { return getInstruction() && !I.getInt(); } |
91 | |
92 | InstrTy *getInstruction() const { return I.getPointer(); } |
93 | InstrTy *operator->() const { return I.getPointer(); } |
94 | explicit operator bool() const { return I.getPointer(); } |
95 | |
96 | /// Get the basic block containing the call site. |
97 | BBTy* getParent() const { return getInstruction()->getParent(); } |
98 | |
99 | /// Return the pointer to function that is being called. |
100 | ValTy *getCalledValue() const { |
101 | assert(getInstruction() && "Not a call or invoke instruction!" ); |
102 | return *getCallee(); |
103 | } |
104 | |
105 | /// Return the function being called if this is a direct call, otherwise |
106 | /// return null (if it's an indirect call). |
107 | FunTy *getCalledFunction() const { |
108 | return dyn_cast<FunTy>(getCalledValue()); |
109 | } |
110 | |
111 | /// Return true if the callsite is an indirect call. |
112 | bool isIndirectCall() const { |
113 | const Value *V = getCalledValue(); |
114 | if (!V) |
115 | return false; |
116 | if (isa<FunTy>(V) || isa<Constant>(V)) |
117 | return false; |
118 | if (const CallInst *CI = dyn_cast<CallInst>(getInstruction())) { |
119 | if (CI->isInlineAsm()) |
120 | return false; |
121 | } |
122 | return true; |
123 | } |
124 | |
125 | /// Set the callee to the specified value. |
126 | void setCalledFunction(Value *V) { |
127 | assert(getInstruction() && "Not a call or invoke instruction!" ); |
128 | *getCallee() = V; |
129 | } |
130 | |
131 | /// Return the intrinsic ID of the intrinsic called by this CallSite, |
132 | /// or Intrinsic::not_intrinsic if the called function is not an |
133 | /// intrinsic, or if this CallSite is an indirect call. |
134 | Intrinsic::ID getIntrinsicID() const { |
135 | if (auto *F = getCalledFunction()) |
136 | return F->getIntrinsicID(); |
137 | // Don't use Intrinsic::not_intrinsic, as it will require pulling |
138 | // Intrinsics.h into every header that uses CallSite. |
139 | return static_cast<Intrinsic::ID>(0); |
140 | } |
141 | |
142 | /// Determine whether the passed iterator points to the callee operand's Use. |
143 | bool isCallee(Value::const_user_iterator UI) const { |
144 | return isCallee(&UI.getUse()); |
145 | } |
146 | |
147 | /// Determine whether this Use is the callee operand's Use. |
148 | bool isCallee(const Use *U) const { return getCallee() == U; } |
149 | |
150 | /// Determine whether the passed iterator points to an argument operand. |
151 | bool isArgOperand(Value::const_user_iterator UI) const { |
152 | return isArgOperand(&UI.getUse()); |
153 | } |
154 | |
155 | /// Determine whether the passed use points to an argument operand. |
156 | bool isArgOperand(const Use *U) const { |
157 | assert(getInstruction() == U->getUser()); |
158 | return arg_begin() <= U && U < arg_end(); |
159 | } |
160 | |
161 | /// Determine whether the passed iterator points to a bundle operand. |
162 | bool isBundleOperand(Value::const_user_iterator UI) const { |
163 | return isBundleOperand(&UI.getUse()); |
164 | } |
165 | |
166 | /// Determine whether the passed use points to a bundle operand. |
167 | bool isBundleOperand(const Use *U) const { |
168 | assert(getInstruction() == U->getUser()); |
169 | if (!hasOperandBundles()) |
170 | return false; |
171 | unsigned OperandNo = U - (*this)->op_begin(); |
172 | return getBundleOperandsStartIndex() <= OperandNo && |
173 | OperandNo < getBundleOperandsEndIndex(); |
174 | } |
175 | |
176 | /// Determine whether the passed iterator points to a data operand. |
177 | bool isDataOperand(Value::const_user_iterator UI) const { |
178 | return isDataOperand(&UI.getUse()); |
179 | } |
180 | |
181 | /// Determine whether the passed use points to a data operand. |
182 | bool isDataOperand(const Use *U) const { |
183 | return data_operands_begin() <= U && U < data_operands_end(); |
184 | } |
185 | |
186 | ValTy *getArgument(unsigned ArgNo) const { |
187 | assert(arg_begin() + ArgNo < arg_end() && "Argument # out of range!" ); |
188 | return *(arg_begin() + ArgNo); |
189 | } |
190 | |
191 | void setArgument(unsigned ArgNo, Value* newVal) { |
192 | assert(getInstruction() && "Not a call or invoke instruction!" ); |
193 | assert(arg_begin() + ArgNo < arg_end() && "Argument # out of range!" ); |
194 | getInstruction()->setOperand(ArgNo, newVal); |
195 | } |
196 | |
197 | /// Given a value use iterator, returns the argument that corresponds to it. |
198 | /// Iterator must actually correspond to an argument. |
199 | unsigned getArgumentNo(Value::const_user_iterator I) const { |
200 | return getArgumentNo(&I.getUse()); |
201 | } |
202 | |
203 | /// Given a use for an argument, get the argument number that corresponds to |
204 | /// it. |
205 | unsigned getArgumentNo(const Use *U) const { |
206 | assert(getInstruction() && "Not a call or invoke instruction!" ); |
207 | assert(isArgOperand(U) && "Argument # out of range!" ); |
208 | return U - arg_begin(); |
209 | } |
210 | |
211 | /// The type of iterator to use when looping over actual arguments at this |
212 | /// call site. |
213 | using arg_iterator = IterTy; |
214 | |
215 | iterator_range<IterTy> args() const { |
216 | return make_range(arg_begin(), arg_end()); |
217 | } |
218 | bool arg_empty() const { return arg_end() == arg_begin(); } |
219 | unsigned arg_size() const { return unsigned(arg_end() - arg_begin()); } |
220 | |
221 | /// Given a value use iterator, return the data operand corresponding to it. |
222 | /// Iterator must actually correspond to a data operand. |
223 | unsigned getDataOperandNo(Value::const_user_iterator UI) const { |
224 | return getDataOperandNo(&UI.getUse()); |
225 | } |
226 | |
227 | /// Given a use for a data operand, get the data operand number that |
228 | /// corresponds to it. |
229 | unsigned getDataOperandNo(const Use *U) const { |
230 | assert(getInstruction() && "Not a call or invoke instruction!" ); |
231 | assert(isDataOperand(U) && "Data operand # out of range!" ); |
232 | return U - data_operands_begin(); |
233 | } |
234 | |
235 | /// Type of iterator to use when looping over data operands at this call site |
236 | /// (see below). |
237 | using data_operand_iterator = IterTy; |
238 | |
239 | /// data_operands_begin/data_operands_end - Return iterators iterating over |
240 | /// the call / invoke argument list and bundle operands. For invokes, this is |
241 | /// the set of instruction operands except the invoke target and the two |
242 | /// successor blocks; and for calls this is the set of instruction operands |
243 | /// except the call target. |
244 | |
245 | IterTy data_operands_begin() const { |
246 | assert(getInstruction() && "Not a call or invoke instruction!" ); |
247 | return (*this)->op_begin(); |
248 | } |
249 | IterTy data_operands_end() const { |
250 | assert(getInstruction() && "Not a call or invoke instruction!" ); |
251 | return (*this)->op_end() - (isCall() ? 1 : 3); |
252 | } |
253 | iterator_range<IterTy> data_ops() const { |
254 | return make_range(data_operands_begin(), data_operands_end()); |
255 | } |
256 | bool data_operands_empty() const { |
257 | return data_operands_end() == data_operands_begin(); |
258 | } |
259 | unsigned data_operands_size() const { |
260 | return std::distance(data_operands_begin(), data_operands_end()); |
261 | } |
262 | |
263 | /// Return the type of the instruction that generated this call site. |
264 | Type *getType() const { return (*this)->getType(); } |
265 | |
266 | /// Return the caller function for this call site. |
267 | FunTy *getCaller() const { return (*this)->getParent()->getParent(); } |
268 | |
269 | /// Tests if this call site must be tail call optimized. Only a CallInst can |
270 | /// be tail call optimized. |
271 | bool isMustTailCall() const { |
272 | return isCall() && cast<CallInst>(getInstruction())->isMustTailCall(); |
273 | } |
274 | |
275 | /// Tests if this call site is marked as a tail call. |
276 | bool isTailCall() const { |
277 | return isCall() && cast<CallInst>(getInstruction())->isTailCall(); |
278 | } |
279 | |
280 | #define CALLSITE_DELEGATE_GETTER(METHOD) \ |
281 | InstrTy *II = getInstruction(); \ |
282 | return isCall() \ |
283 | ? cast<CallInst>(II)->METHOD \ |
284 | : cast<InvokeInst>(II)->METHOD |
285 | |
286 | #define CALLSITE_DELEGATE_SETTER(METHOD) \ |
287 | InstrTy *II = getInstruction(); \ |
288 | if (isCall()) \ |
289 | cast<CallInst>(II)->METHOD; \ |
290 | else \ |
291 | cast<InvokeInst>(II)->METHOD |
292 | |
293 | unsigned getNumArgOperands() const { |
294 | CALLSITE_DELEGATE_GETTER(getNumArgOperands()); |
295 | } |
296 | |
297 | ValTy *getArgOperand(unsigned i) const { |
298 | CALLSITE_DELEGATE_GETTER(getArgOperand(i)); |
299 | } |
300 | |
301 | ValTy *getReturnedArgOperand() const { |
302 | CALLSITE_DELEGATE_GETTER(getReturnedArgOperand()); |
303 | } |
304 | |
305 | bool isInlineAsm() const { |
306 | if (isCall()) |
307 | return cast<CallInst>(getInstruction())->isInlineAsm(); |
308 | return false; |
309 | } |
310 | |
311 | /// Get the calling convention of the call. |
312 | CallingConv::ID getCallingConv() const { |
313 | CALLSITE_DELEGATE_GETTER(getCallingConv()); |
314 | } |
315 | /// Set the calling convention of the call. |
316 | void setCallingConv(CallingConv::ID CC) { |
317 | CALLSITE_DELEGATE_SETTER(setCallingConv(CC)); |
318 | } |
319 | |
320 | FunctionType *getFunctionType() const { |
321 | CALLSITE_DELEGATE_GETTER(getFunctionType()); |
322 | } |
323 | |
324 | void mutateFunctionType(FunctionType *Ty) const { |
325 | CALLSITE_DELEGATE_SETTER(mutateFunctionType(Ty)); |
326 | } |
327 | |
328 | /// Get the parameter attributes of the call. |
329 | AttributeList getAttributes() const { |
330 | CALLSITE_DELEGATE_GETTER(getAttributes()); |
331 | } |
332 | /// Set the parameter attributes of the call. |
333 | void setAttributes(AttributeList PAL) { |
334 | CALLSITE_DELEGATE_SETTER(setAttributes(PAL)); |
335 | } |
336 | |
337 | void addAttribute(unsigned i, Attribute::AttrKind Kind) { |
338 | CALLSITE_DELEGATE_SETTER(addAttribute(i, Kind)); |
339 | } |
340 | |
341 | void addAttribute(unsigned i, Attribute Attr) { |
342 | CALLSITE_DELEGATE_SETTER(addAttribute(i, Attr)); |
343 | } |
344 | |
345 | void addParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) { |
346 | CALLSITE_DELEGATE_SETTER(addParamAttr(ArgNo, Kind)); |
347 | } |
348 | |
349 | void removeAttribute(unsigned i, Attribute::AttrKind Kind) { |
350 | CALLSITE_DELEGATE_SETTER(removeAttribute(i, Kind)); |
351 | } |
352 | |
353 | void removeAttribute(unsigned i, StringRef Kind) { |
354 | CALLSITE_DELEGATE_SETTER(removeAttribute(i, Kind)); |
355 | } |
356 | |
357 | void removeParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) { |
358 | CALLSITE_DELEGATE_SETTER(removeParamAttr(ArgNo, Kind)); |
359 | } |
360 | |
361 | /// Return true if this function has the given attribute. |
362 | bool hasFnAttr(Attribute::AttrKind Kind) const { |
363 | CALLSITE_DELEGATE_GETTER(hasFnAttr(Kind)); |
364 | } |
365 | |
366 | /// Return true if this function has the given attribute. |
367 | bool hasFnAttr(StringRef Kind) const { |
368 | CALLSITE_DELEGATE_GETTER(hasFnAttr(Kind)); |
369 | } |
370 | |
371 | /// Return true if this return value has the given attribute. |
372 | bool hasRetAttr(Attribute::AttrKind Kind) const { |
373 | CALLSITE_DELEGATE_GETTER(hasRetAttr(Kind)); |
374 | } |
375 | |
376 | /// Return true if the call or the callee has the given attribute. |
377 | bool paramHasAttr(unsigned ArgNo, Attribute::AttrKind Kind) const { |
378 | CALLSITE_DELEGATE_GETTER(paramHasAttr(ArgNo, Kind)); |
379 | } |
380 | |
381 | Attribute getAttribute(unsigned i, Attribute::AttrKind Kind) const { |
382 | CALLSITE_DELEGATE_GETTER(getAttribute(i, Kind)); |
383 | } |
384 | |
385 | Attribute getAttribute(unsigned i, StringRef Kind) const { |
386 | CALLSITE_DELEGATE_GETTER(getAttribute(i, Kind)); |
387 | } |
388 | |
389 | /// Return true if the data operand at index \p i directly or indirectly has |
390 | /// the attribute \p A. |
391 | /// |
392 | /// Normal call or invoke arguments have per operand attributes, as specified |
393 | /// in the attribute set attached to this instruction, while operand bundle |
394 | /// operands may have some attributes implied by the type of its containing |
395 | /// operand bundle. |
396 | bool dataOperandHasImpliedAttr(unsigned i, Attribute::AttrKind Kind) const { |
397 | CALLSITE_DELEGATE_GETTER(dataOperandHasImpliedAttr(i, Kind)); |
398 | } |
399 | |
400 | /// Extract the alignment of the return value. |
401 | unsigned getRetAlignment() const { |
402 | CALLSITE_DELEGATE_GETTER(getRetAlignment()); |
403 | } |
404 | |
405 | /// Extract the alignment for a call or parameter (0=unknown). |
406 | unsigned getParamAlignment(unsigned ArgNo) const { |
407 | CALLSITE_DELEGATE_GETTER(getParamAlignment(ArgNo)); |
408 | } |
409 | |
410 | /// Extract the number of dereferenceable bytes for a call or parameter |
411 | /// (0=unknown). |
412 | uint64_t getDereferenceableBytes(unsigned i) const { |
413 | CALLSITE_DELEGATE_GETTER(getDereferenceableBytes(i)); |
414 | } |
415 | |
416 | /// Extract the number of dereferenceable_or_null bytes for a call or |
417 | /// parameter (0=unknown). |
418 | uint64_t getDereferenceableOrNullBytes(unsigned i) const { |
419 | CALLSITE_DELEGATE_GETTER(getDereferenceableOrNullBytes(i)); |
420 | } |
421 | |
422 | /// Determine if the return value is marked with NoAlias attribute. |
423 | bool returnDoesNotAlias() const { |
424 | CALLSITE_DELEGATE_GETTER(returnDoesNotAlias()); |
425 | } |
426 | |
427 | /// Return true if the call should not be treated as a call to a builtin. |
428 | bool isNoBuiltin() const { |
429 | CALLSITE_DELEGATE_GETTER(isNoBuiltin()); |
430 | } |
431 | |
432 | /// Return true if the call requires strict floating point semantics. |
433 | bool isStrictFP() const { |
434 | CALLSITE_DELEGATE_GETTER(isStrictFP()); |
435 | } |
436 | |
437 | /// Return true if the call should not be inlined. |
438 | bool isNoInline() const { |
439 | CALLSITE_DELEGATE_GETTER(isNoInline()); |
440 | } |
441 | void setIsNoInline(bool Value = true) { |
442 | CALLSITE_DELEGATE_SETTER(setIsNoInline(Value)); |
443 | } |
444 | |
445 | /// Determine if the call does not access memory. |
446 | bool doesNotAccessMemory() const { |
447 | CALLSITE_DELEGATE_GETTER(doesNotAccessMemory()); |
448 | } |
449 | void setDoesNotAccessMemory() { |
450 | CALLSITE_DELEGATE_SETTER(setDoesNotAccessMemory()); |
451 | } |
452 | |
453 | /// Determine if the call does not access or only reads memory. |
454 | bool onlyReadsMemory() const { |
455 | CALLSITE_DELEGATE_GETTER(onlyReadsMemory()); |
456 | } |
457 | void setOnlyReadsMemory() { |
458 | CALLSITE_DELEGATE_SETTER(setOnlyReadsMemory()); |
459 | } |
460 | |
461 | /// Determine if the call does not access or only writes memory. |
462 | bool doesNotReadMemory() const { |
463 | CALLSITE_DELEGATE_GETTER(doesNotReadMemory()); |
464 | } |
465 | void setDoesNotReadMemory() { |
466 | CALLSITE_DELEGATE_SETTER(setDoesNotReadMemory()); |
467 | } |
468 | |
469 | /// Determine if the call can access memmory only using pointers based |
470 | /// on its arguments. |
471 | bool onlyAccessesArgMemory() const { |
472 | CALLSITE_DELEGATE_GETTER(onlyAccessesArgMemory()); |
473 | } |
474 | void setOnlyAccessesArgMemory() { |
475 | CALLSITE_DELEGATE_SETTER(setOnlyAccessesArgMemory()); |
476 | } |
477 | |
478 | /// Determine if the function may only access memory that is |
479 | /// inaccessible from the IR. |
480 | bool onlyAccessesInaccessibleMemory() const { |
481 | CALLSITE_DELEGATE_GETTER(onlyAccessesInaccessibleMemory()); |
482 | } |
483 | void setOnlyAccessesInaccessibleMemory() { |
484 | CALLSITE_DELEGATE_SETTER(setOnlyAccessesInaccessibleMemory()); |
485 | } |
486 | |
487 | /// Determine if the function may only access memory that is |
488 | /// either inaccessible from the IR or pointed to by its arguments. |
489 | bool onlyAccessesInaccessibleMemOrArgMem() const { |
490 | CALLSITE_DELEGATE_GETTER(onlyAccessesInaccessibleMemOrArgMem()); |
491 | } |
492 | void setOnlyAccessesInaccessibleMemOrArgMem() { |
493 | CALLSITE_DELEGATE_SETTER(setOnlyAccessesInaccessibleMemOrArgMem()); |
494 | } |
495 | |
496 | /// Determine if the call cannot return. |
497 | bool doesNotReturn() const { |
498 | CALLSITE_DELEGATE_GETTER(doesNotReturn()); |
499 | } |
500 | void setDoesNotReturn() { |
501 | CALLSITE_DELEGATE_SETTER(setDoesNotReturn()); |
502 | } |
503 | |
504 | /// Determine if the call cannot unwind. |
505 | bool doesNotThrow() const { |
506 | CALLSITE_DELEGATE_GETTER(doesNotThrow()); |
507 | } |
508 | void setDoesNotThrow() { |
509 | CALLSITE_DELEGATE_SETTER(setDoesNotThrow()); |
510 | } |
511 | |
512 | /// Determine if the call can be duplicated. |
513 | bool cannotDuplicate() const { |
514 | CALLSITE_DELEGATE_GETTER(cannotDuplicate()); |
515 | } |
516 | void setCannotDuplicate() { |
517 | CALLSITE_DELEGATE_SETTER(setCannotDuplicate()); |
518 | } |
519 | |
520 | /// Determine if the call is convergent. |
521 | bool isConvergent() const { |
522 | CALLSITE_DELEGATE_GETTER(isConvergent()); |
523 | } |
524 | void setConvergent() { |
525 | CALLSITE_DELEGATE_SETTER(setConvergent()); |
526 | } |
527 | void setNotConvergent() { |
528 | CALLSITE_DELEGATE_SETTER(setNotConvergent()); |
529 | } |
530 | |
531 | unsigned getNumOperandBundles() const { |
532 | CALLSITE_DELEGATE_GETTER(getNumOperandBundles()); |
533 | } |
534 | |
535 | bool hasOperandBundles() const { |
536 | CALLSITE_DELEGATE_GETTER(hasOperandBundles()); |
537 | } |
538 | |
539 | unsigned getBundleOperandsStartIndex() const { |
540 | CALLSITE_DELEGATE_GETTER(getBundleOperandsStartIndex()); |
541 | } |
542 | |
543 | unsigned getBundleOperandsEndIndex() const { |
544 | CALLSITE_DELEGATE_GETTER(getBundleOperandsEndIndex()); |
545 | } |
546 | |
547 | unsigned getNumTotalBundleOperands() const { |
548 | CALLSITE_DELEGATE_GETTER(getNumTotalBundleOperands()); |
549 | } |
550 | |
551 | OperandBundleUse getOperandBundleAt(unsigned Index) const { |
552 | CALLSITE_DELEGATE_GETTER(getOperandBundleAt(Index)); |
553 | } |
554 | |
555 | Optional<OperandBundleUse> getOperandBundle(StringRef Name) const { |
556 | CALLSITE_DELEGATE_GETTER(getOperandBundle(Name)); |
557 | } |
558 | |
559 | Optional<OperandBundleUse> getOperandBundle(uint32_t ID) const { |
560 | CALLSITE_DELEGATE_GETTER(getOperandBundle(ID)); |
561 | } |
562 | |
563 | unsigned countOperandBundlesOfType(uint32_t ID) const { |
564 | CALLSITE_DELEGATE_GETTER(countOperandBundlesOfType(ID)); |
565 | } |
566 | |
567 | bool isBundleOperand(unsigned Idx) const { |
568 | CALLSITE_DELEGATE_GETTER(isBundleOperand(Idx)); |
569 | } |
570 | |
571 | IterTy arg_begin() const { |
572 | CALLSITE_DELEGATE_GETTER(arg_begin()); |
573 | } |
574 | |
575 | IterTy arg_end() const { |
576 | CALLSITE_DELEGATE_GETTER(arg_end()); |
577 | } |
578 | |
579 | #undef CALLSITE_DELEGATE_GETTER |
580 | #undef CALLSITE_DELEGATE_SETTER |
581 | |
582 | void getOperandBundlesAsDefs(SmallVectorImpl<OperandBundleDef> &Defs) const { |
583 | const Instruction *II = getInstruction(); |
584 | // Since this is actually a getter that "looks like" a setter, don't use the |
585 | // above macros to avoid confusion. |
586 | if (isCall()) |
587 | cast<CallInst>(II)->getOperandBundlesAsDefs(Defs); |
588 | else |
589 | cast<InvokeInst>(II)->getOperandBundlesAsDefs(Defs); |
590 | } |
591 | |
592 | /// Determine whether this data operand is not captured. |
593 | bool doesNotCapture(unsigned OpNo) const { |
594 | return dataOperandHasImpliedAttr(OpNo + 1, Attribute::NoCapture); |
595 | } |
596 | |
597 | /// Determine whether this argument is passed by value. |
598 | bool isByValArgument(unsigned ArgNo) const { |
599 | return paramHasAttr(ArgNo, Attribute::ByVal); |
600 | } |
601 | |
602 | /// Determine whether this argument is passed in an alloca. |
603 | bool isInAllocaArgument(unsigned ArgNo) const { |
604 | return paramHasAttr(ArgNo, Attribute::InAlloca); |
605 | } |
606 | |
607 | /// Determine whether this argument is passed by value or in an alloca. |
608 | bool isByValOrInAllocaArgument(unsigned ArgNo) const { |
609 | return paramHasAttr(ArgNo, Attribute::ByVal) || |
610 | paramHasAttr(ArgNo, Attribute::InAlloca); |
611 | } |
612 | |
613 | /// Determine if there are is an inalloca argument. Only the last argument can |
614 | /// have the inalloca attribute. |
615 | bool hasInAllocaArgument() const { |
616 | return !arg_empty() && paramHasAttr(arg_size() - 1, Attribute::InAlloca); |
617 | } |
618 | |
619 | bool doesNotAccessMemory(unsigned OpNo) const { |
620 | return dataOperandHasImpliedAttr(OpNo + 1, Attribute::ReadNone); |
621 | } |
622 | |
623 | bool onlyReadsMemory(unsigned OpNo) const { |
624 | return dataOperandHasImpliedAttr(OpNo + 1, Attribute::ReadOnly) || |
625 | dataOperandHasImpliedAttr(OpNo + 1, Attribute::ReadNone); |
626 | } |
627 | |
628 | bool doesNotReadMemory(unsigned OpNo) const { |
629 | return dataOperandHasImpliedAttr(OpNo + 1, Attribute::WriteOnly) || |
630 | dataOperandHasImpliedAttr(OpNo + 1, Attribute::ReadNone); |
631 | } |
632 | |
633 | /// Return true if the return value is known to be not null. |
634 | /// This may be because it has the nonnull attribute, or because at least |
635 | /// one byte is dereferenceable and the pointer is in addrspace(0). |
636 | bool isReturnNonNull() const { |
637 | if (hasRetAttr(Attribute::NonNull)) |
638 | return true; |
639 | else if (getDereferenceableBytes(AttributeList::ReturnIndex) > 0 && |
640 | !NullPointerIsDefined(getCaller(), |
641 | getType()->getPointerAddressSpace())) |
642 | return true; |
643 | |
644 | return false; |
645 | } |
646 | |
647 | /// Returns true if this CallSite passes the given Value* as an argument to |
648 | /// the called function. |
649 | bool hasArgument(const Value *Arg) const { |
650 | for (arg_iterator AI = this->arg_begin(), E = this->arg_end(); AI != E; |
651 | ++AI) |
652 | if (AI->get() == Arg) |
653 | return true; |
654 | return false; |
655 | } |
656 | |
657 | private: |
658 | IterTy getCallee() const { |
659 | return cast<CallBase>(getInstruction())->op_end() - 1; |
660 | } |
661 | }; |
662 | |
663 | class CallSite : public CallSiteBase<Function, BasicBlock, Value, User, Use, |
664 | Instruction, CallInst, InvokeInst, |
665 | User::op_iterator> { |
666 | public: |
667 | CallSite() = default; |
668 | CallSite(CallSiteBase B) : CallSiteBase(B) {} |
669 | CallSite(CallInst *CI) : CallSiteBase(CI) {} |
670 | CallSite(InvokeInst *II) : CallSiteBase(II) {} |
671 | explicit CallSite(Instruction *II) : CallSiteBase(II) {} |
672 | explicit CallSite(Value *V) : CallSiteBase(V) {} |
673 | |
674 | bool operator==(const CallSite &CS) const { return I == CS.I; } |
675 | bool operator!=(const CallSite &CS) const { return I != CS.I; } |
676 | bool operator<(const CallSite &CS) const { |
677 | return getInstruction() < CS.getInstruction(); |
678 | } |
679 | |
680 | private: |
681 | friend struct DenseMapInfo<CallSite>; |
682 | |
683 | User::op_iterator getCallee() const; |
684 | }; |
685 | |
686 | template <> struct DenseMapInfo<CallSite> { |
687 | using BaseInfo = DenseMapInfo<decltype(CallSite::I)>; |
688 | |
689 | static CallSite getEmptyKey() { |
690 | CallSite CS; |
691 | CS.I = BaseInfo::getEmptyKey(); |
692 | return CS; |
693 | } |
694 | |
695 | static CallSite getTombstoneKey() { |
696 | CallSite CS; |
697 | CS.I = BaseInfo::getTombstoneKey(); |
698 | return CS; |
699 | } |
700 | |
701 | static unsigned getHashValue(const CallSite &CS) { |
702 | return BaseInfo::getHashValue(CS.I); |
703 | } |
704 | |
705 | static bool isEqual(const CallSite &LHS, const CallSite &RHS) { |
706 | return LHS == RHS; |
707 | } |
708 | }; |
709 | |
710 | /// Establish a view to a call site for examination. |
711 | class ImmutableCallSite : public CallSiteBase<> { |
712 | public: |
713 | ImmutableCallSite() = default; |
714 | ImmutableCallSite(const CallInst *CI) : CallSiteBase(CI) {} |
715 | ImmutableCallSite(const InvokeInst *II) : CallSiteBase(II) {} |
716 | explicit ImmutableCallSite(const Instruction *II) : CallSiteBase(II) {} |
717 | explicit ImmutableCallSite(const Value *V) : CallSiteBase(V) {} |
718 | ImmutableCallSite(CallSite CS) : CallSiteBase(CS.getInstruction()) {} |
719 | }; |
720 | |
721 | } // end namespace llvm |
722 | |
723 | #endif // LLVM_IR_CALLSITE_H |
724 | |