Line data Source code
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 689097638 : 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 451267292 : if (II->getOpcode() == Instruction::Call)
77 : return CallSiteBase(static_cast<CallTy*>(II));
78 375082220 : 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 64070896 : bool isCall() const { return I.getInt(); }
88 :
89 : /// Return true if a InvokeInst is enclosed.
90 1001299 : bool isInvoke() const { return getInstruction() && !I.getInt(); }
91 :
92 330645709 : InstrTy *getInstruction() const { return I.getPointer(); }
93 12177049 : InstrTy *operator->() const { return I.getPointer(); }
94 1204254 : explicit operator bool() const { return I.getPointer(); }
95 :
96 : /// Get the basic block containing the call site.
97 1405227 : 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 108594989 : 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 836 : bool isIndirectCall() const {
113 : const Value *V = getCalledValue();
114 836 : if (!V)
115 : return false;
116 836 : if (isa<FunTy>(V) || isa<Constant>(V))
117 : return false;
118 : if (const CallInst *CI = dyn_cast<CallInst>(getInstruction())) {
119 126 : if (CI->isInlineAsm())
120 7 : return false;
121 : }
122 : return true;
123 : }
124 52 :
125 : /// Set the callee to the specified value.
126 52 : void setCalledFunction(Value *V) {
127 : assert(getInstruction() && "Not a call or invoke instruction!");
128 52 : *getCallee() = V;
129 : }
130 :
131 24 : /// Return the intrinsic ID of the intrinsic called by this CallSite,
132 0 : /// 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 12242790 : return F->getIntrinsicID();
137 : // Don't use Intrinsic::not_intrinsic, as it will require pulling
138 113 : // Intrinsics.h into every header that uses CallSite.
139 : return static_cast<Intrinsic::ID>(0);
140 113 : }
141 :
142 : /// Determine whether the passed iterator points to the callee operand's Use.
143 33 : bool isCallee(Value::const_user_iterator UI) const {
144 0 : 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 497023 : bool isArgOperand(const Use *U) const {
157 : assert(getInstruction() == U->getUser());
158 497023 : 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 3751 : bool isBundleOperand(const Use *U) const {
168 : assert(getInstruction() == U->getUser());
169 3751 : if (!hasOperandBundles())
170 : return false;
171 1 : unsigned OperandNo = U - (*this)->op_begin();
172 2 : return getBundleOperandsStartIndex() <= OperandNo &&
173 1 : 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 181210 : bool isDataOperand(const Use *U) const {
183 181210 : 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 6744042 : 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 258 : 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 141358 : 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 3788217 : iterator_range<IterTy> args() const {
216 3788217 : return make_range(arg_begin(), arg_end());
217 : }
218 1804050 : bool arg_empty() const { return arg_end() == arg_begin(); }
219 6965347 : 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 460161 : 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 5741221 : return (*this)->op_begin();
248 : }
249 5281060 : IterTy data_operands_end() const {
250 : assert(getInstruction() && "Not a call or invoke instruction!");
251 10562120 : return (*this)->op_end() - (isCall() ? 1 : 3);
252 : }
253 226 : iterator_range<IterTy> data_ops() const {
254 226 : 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 2194594 : Type *getType() const { return (*this)->getType(); }
265 :
266 : /// Return the caller function for this call site.
267 12324270 : 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 992928 : 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 3 : 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 1633681 : unsigned getNumArgOperands() const {
294 1633681 : CALLSITE_DELEGATE_GETTER(getNumArgOperands());
295 : }
296 :
297 3478929 : ValTy *getArgOperand(unsigned i) const {
298 3478929 : CALLSITE_DELEGATE_GETTER(getArgOperand(i));
299 : }
300 :
301 2588431 : ValTy *getReturnedArgOperand() const {
302 2588431 : CALLSITE_DELEGATE_GETTER(getReturnedArgOperand());
303 : }
304 :
305 : bool isInlineAsm() const {
306 703 : 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 4663532 : CALLSITE_DELEGATE_GETTER(getCallingConv());
314 : }
315 : /// Set the calling convention of the call.
316 2660493 : void setCallingConv(CallingConv::ID CC) {
317 2660493 : CALLSITE_DELEGATE_SETTER(setCallingConv(CC));
318 2660493 : }
319 :
320 : FunctionType *getFunctionType() const {
321 2799112 : CALLSITE_DELEGATE_GETTER(getFunctionType());
322 : }
323 :
324 : void mutateFunctionType(FunctionType *Ty) const {
325 592 : CALLSITE_DELEGATE_SETTER(mutateFunctionType(Ty));
326 : }
327 :
328 : /// Get the parameter attributes of the call.
329 : AttributeList getAttributes() const {
330 1286204 : CALLSITE_DELEGATE_GETTER(getAttributes());
331 : }
332 : /// Set the parameter attributes of the call.
333 : void setAttributes(AttributeList PAL) {
334 2810007 : 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 12 : void addAttribute(unsigned i, Attribute Attr) {
342 12 : CALLSITE_DELEGATE_SETTER(addAttribute(i, Attr));
343 12 : }
344 :
345 54 : void addParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) {
346 54 : CALLSITE_DELEGATE_SETTER(addParamAttr(ArgNo, Kind));
347 54 : }
348 :
349 6 : void removeAttribute(unsigned i, Attribute::AttrKind Kind) {
350 6 : CALLSITE_DELEGATE_SETTER(removeAttribute(i, Kind));
351 6 : }
352 :
353 0 : void removeAttribute(unsigned i, StringRef Kind) {
354 0 : CALLSITE_DELEGATE_SETTER(removeAttribute(i, Kind));
355 0 : }
356 :
357 100 : void removeParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) {
358 100 : CALLSITE_DELEGATE_SETTER(removeParamAttr(ArgNo, Kind));
359 100 : }
360 :
361 : /// Return true if this function has the given attribute.
362 9066219 : bool hasFnAttr(Attribute::AttrKind Kind) const {
363 9066219 : CALLSITE_DELEGATE_GETTER(hasFnAttr(Kind));
364 : }
365 :
366 : /// Return true if this function has the given attribute.
367 794 : bool hasFnAttr(StringRef Kind) const {
368 794 : CALLSITE_DELEGATE_GETTER(hasFnAttr(Kind));
369 : }
370 :
371 : /// Return true if this return value has the given attribute.
372 8079776 : bool hasRetAttr(Attribute::AttrKind Kind) const {
373 8079776 : CALLSITE_DELEGATE_GETTER(hasRetAttr(Kind));
374 : }
375 :
376 : /// Return true if the call or the callee has the given attribute.
377 55103012 : bool paramHasAttr(unsigned ArgNo, Attribute::AttrKind Kind) const {
378 55103012 : CALLSITE_DELEGATE_GETTER(paramHasAttr(ArgNo, Kind));
379 : }
380 :
381 1320 : Attribute getAttribute(unsigned i, Attribute::AttrKind Kind) const {
382 1320 : CALLSITE_DELEGATE_GETTER(getAttribute(i, Kind));
383 : }
384 :
385 0 : Attribute getAttribute(unsigned i, StringRef Kind) const {
386 0 : 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 5277586 : bool dataOperandHasImpliedAttr(unsigned i, Attribute::AttrKind Kind) const {
397 5277586 : 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 4107692 : unsigned getParamAlignment(unsigned ArgNo) const {
407 4107692 : CALLSITE_DELEGATE_GETTER(getParamAlignment(ArgNo));
408 : }
409 :
410 : /// Extract the number of dereferenceable bytes for a call or parameter
411 : /// (0=unknown).
412 161891 : uint64_t getDereferenceableBytes(unsigned i) const {
413 161891 : 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 17367 : uint64_t getDereferenceableOrNullBytes(unsigned i) const {
419 17367 : 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 24776288 : bool isNoBuiltin() const {
429 24776288 : CALLSITE_DELEGATE_GETTER(isNoBuiltin());
430 : }
431 4261064 :
432 4261064 : /// Return true if the call requires strict floating point semantics.
433 : bool isStrictFP() const {
434 6366026 : CALLSITE_DELEGATE_GETTER(isStrictFP());
435 6366026 : }
436 :
437 : /// Return true if the call should not be inlined.
438 512031 : bool isNoInline() const {
439 11017486 : CALLSITE_DELEGATE_GETTER(isNoInline());
440 10505455 : }
441 : void setIsNoInline(bool Value = true) {
442 4222216 : CALLSITE_DELEGATE_SETTER(setIsNoInline(Value));
443 4222216 : }
444 :
445 6283239 : /// Determine if the call does not access memory.
446 16972667 : bool doesNotAccessMemory() const {
447 10689428 : 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 17169387 : bool onlyReadsMemory() const {
455 17169387 : CALLSITE_DELEGATE_GETTER(onlyReadsMemory());
456 : }
457 11 : void setOnlyReadsMemory() {
458 11 : CALLSITE_DELEGATE_SETTER(setOnlyReadsMemory());
459 11 : }
460 :
461 : /// Determine if the call does not access or only writes memory.
462 10266453 : bool doesNotReadMemory() const {
463 10266453 : 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 10493473 : bool onlyAccessesArgMemory() const {
472 10493473 : 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 2674562 : bool onlyAccessesInaccessibleMemory() const {
481 2674562 : 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 2674249 : bool onlyAccessesInaccessibleMemOrArgMem() const {
490 2674249 : CALLSITE_DELEGATE_GETTER(onlyAccessesInaccessibleMemOrArgMem());
491 : }
492 : void setOnlyAccessesInaccessibleMemOrArgMem() {
493 : CALLSITE_DELEGATE_SETTER(setOnlyAccessesInaccessibleMemOrArgMem());
494 : }
495 :
496 : /// Determine if the call cannot return.
497 4788513 : bool doesNotReturn() const {
498 4788513 : CALLSITE_DELEGATE_GETTER(doesNotReturn());
499 : }
500 57 : void setDoesNotReturn() {
501 57 : CALLSITE_DELEGATE_SETTER(setDoesNotReturn());
502 57 : }
503 :
504 : /// Determine if the call cannot unwind.
505 1679697 : bool doesNotThrow() const {
506 1679697 : CALLSITE_DELEGATE_GETTER(doesNotThrow());
507 : }
508 33 : void setDoesNotThrow() {
509 33 : CALLSITE_DELEGATE_SETTER(setDoesNotThrow());
510 33 : }
511 :
512 : /// Determine if the call can be duplicated.
513 81925 : bool cannotDuplicate() const {
514 81925 : CALLSITE_DELEGATE_GETTER(cannotDuplicate());
515 : }
516 54 : void setCannotDuplicate() {
517 54 : CALLSITE_DELEGATE_SETTER(setCannotDuplicate());
518 54 : }
519 :
520 : /// Determine if the call is convergent.
521 3460038 : bool isConvergent() const {
522 3460038 : CALLSITE_DELEGATE_GETTER(isConvergent());
523 : }
524 : void setConvergent() {
525 : CALLSITE_DELEGATE_SETTER(setConvergent());
526 : }
527 3 : void setNotConvergent() {
528 3 : CALLSITE_DELEGATE_SETTER(setNotConvergent());
529 3 : }
530 :
531 2507995 : unsigned getNumOperandBundles() const {
532 2507995 : CALLSITE_DELEGATE_GETTER(getNumOperandBundles());
533 : }
534 :
535 24135766 : bool hasOperandBundles() const {
536 24135766 : CALLSITE_DELEGATE_GETTER(hasOperandBundles());
537 : }
538 :
539 1 : unsigned getBundleOperandsStartIndex() const {
540 1 : CALLSITE_DELEGATE_GETTER(getBundleOperandsStartIndex());
541 : }
542 :
543 1 : unsigned getBundleOperandsEndIndex() const {
544 1 : CALLSITE_DELEGATE_GETTER(getBundleOperandsEndIndex());
545 : }
546 :
547 : unsigned getNumTotalBundleOperands() const {
548 : CALLSITE_DELEGATE_GETTER(getNumTotalBundleOperands());
549 : }
550 :
551 5005 : OperandBundleUse getOperandBundleAt(unsigned Index) const {
552 5005 : CALLSITE_DELEGATE_GETTER(getOperandBundleAt(Index));
553 : }
554 :
555 : Optional<OperandBundleUse> getOperandBundle(StringRef Name) const {
556 : CALLSITE_DELEGATE_GETTER(getOperandBundle(Name));
557 : }
558 :
559 1400762 : Optional<OperandBundleUse> getOperandBundle(uint32_t ID) const {
560 1400762 : CALLSITE_DELEGATE_GETTER(getOperandBundle(ID));
561 : }
562 312 :
563 1568 : unsigned countOperandBundlesOfType(uint32_t ID) const {
564 1256 : CALLSITE_DELEGATE_GETTER(countOperandBundlesOfType(ID));
565 624 : }
566 624 :
567 185504 : bool isBundleOperand(unsigned Idx) const {
568 185504 : CALLSITE_DELEGATE_GETTER(isBundleOperand(Idx));
569 : }
570 :
571 : IterTy arg_begin() const {
572 45120923 : CALLSITE_DELEGATE_GETTER(arg_begin());
573 : }
574 :
575 27235827 : IterTy arg_end() const {
576 27235827 : CALLSITE_DELEGATE_GETTER(arg_end());
577 : }
578 12383 :
579 5099 : #undef CALLSITE_DELEGATE_GETTER
580 : #undef CALLSITE_DELEGATE_SETTER
581 7290934 :
582 7293867 : 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 2933 : if (isCall())
587 2814 : cast<CallInst>(II)->getOperandBundlesAsDefs(Defs);
588 : else
589 119 : cast<InvokeInst>(II)->getOperandBundlesAsDefs(Defs);
590 2933 : }
591 :
592 : /// Determine whether this data operand is not captured.
593 : bool doesNotCapture(unsigned OpNo) const {
594 5252762 : return dataOperandHasImpliedAttr(OpNo + 1, Attribute::NoCapture);
595 : }
596 :
597 : /// Determine whether this argument is passed by value.
598 : bool isByValArgument(unsigned ArgNo) const {
599 4853787 : return paramHasAttr(ArgNo, Attribute::ByVal);
600 : }
601 :
602 : /// Determine whether this argument is passed in an alloca.
603 : bool isInAllocaArgument(unsigned ArgNo) const {
604 326280 : return paramHasAttr(ArgNo, Attribute::InAlloca);
605 : }
606 :
607 : /// Determine whether this argument is passed by value or in an alloca.
608 10 : bool isByValOrInAllocaArgument(unsigned ArgNo) const {
609 10 : return paramHasAttr(ArgNo, Attribute::ByVal) ||
610 10 : 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 1169726 : bool hasInAllocaArgument() const {
616 1169726 : return !arg_empty() && paramHasAttr(arg_size() - 1, Attribute::InAlloca);
617 : }
618 :
619 : bool doesNotAccessMemory(unsigned OpNo) const {
620 9456 : return dataOperandHasImpliedAttr(OpNo + 1, Attribute::ReadNone);
621 634129 : }
622 634129 :
623 5747 : bool onlyReadsMemory(unsigned OpNo) const {
624 5747 : return dataOperandHasImpliedAttr(OpNo + 1, Attribute::ReadOnly) ||
625 5747 : dataOperandHasImpliedAttr(OpNo + 1, Attribute::ReadNone);
626 : }
627 :
628 2577 : bool doesNotReadMemory(unsigned OpNo) const {
629 2577 : return dataOperandHasImpliedAttr(OpNo + 1, Attribute::WriteOnly) ||
630 2577 : 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 127821 : bool isReturnNonNull() const {
637 127821 : if (hasRetAttr(Attribute::NonNull))
638 : return true;
639 131503 : else if (getDereferenceableBytes(AttributeList::ReturnIndex) > 0 &&
640 8162 : !NullPointerIsDefined(getCaller(),
641 : getType()->getPointerAddressSpace()))
642 8158 : 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 87646868 : if (isCall()) // Skip Callee
660 73133249 : return cast<CallInst>(getInstruction())->op_end() - 1;
661 : else // Skip BB, BB, Callee
662 14513619 : return cast<InvokeInst>(getInstruction())->op_end() - 3;
663 : }
664 : };
665 16466159 :
666 15010857 : class CallSite : public CallSiteBase<Function, BasicBlock, Value, User, Use,
667 : Instruction, CallInst, InvokeInst,
668 1455302 : User::op_iterator> {
669 : public:
670 : CallSite() = default;
671 4222215 : CallSite(CallSiteBase B) : CallSiteBase(B) {}
672 4222215 : CallSite(CallInst *CI) : CallSiteBase(CI) {}
673 : CallSite(InvokeInst *II) : CallSiteBase(II) {}
674 0 : explicit CallSite(Instruction *II) : CallSiteBase(II) {}
675 : explicit CallSite(Value *V) : CallSiteBase(V) {}
676 :
677 722 : bool operator==(const CallSite &CS) const { return I == CS.I; }
678 : bool operator!=(const CallSite &CS) const { return I != CS.I; }
679 : bool operator<(const CallSite &CS) const {
680 : return getInstruction() < CS.getInstruction();
681 : }
682 :
683 465 : private:
684 462 : friend struct DenseMapInfo<CallSite>;
685 :
686 3 : User::op_iterator getCallee() const;
687 : };
688 :
689 : template <> struct DenseMapInfo<CallSite> {
690 : using BaseInfo = DenseMapInfo<decltype(CallSite::I)>;
691 :
692 : static CallSite getEmptyKey() {
693 : CallSite CS;
694 : CS.I = BaseInfo::getEmptyKey();
695 : return CS;
696 : }
697 :
698 : static CallSite getTombstoneKey() {
699 : CallSite CS;
700 : CS.I = BaseInfo::getTombstoneKey();
701 : return CS;
702 : }
703 :
704 : static unsigned getHashValue(const CallSite &CS) {
705 : return BaseInfo::getHashValue(CS.I);
706 : }
707 :
708 : static bool isEqual(const CallSite &LHS, const CallSite &RHS) {
709 : return LHS == RHS;
710 : }
711 : };
712 :
713 : /// Establish a view to a call site for examination.
714 : class ImmutableCallSite : public CallSiteBase<> {
715 : public:
716 : ImmutableCallSite() = default;
717 : ImmutableCallSite(const CallInst *CI) : CallSiteBase(CI) {}
718 : ImmutableCallSite(const InvokeInst *II) : CallSiteBase(II) {}
719 : explicit ImmutableCallSite(const Instruction *II) : CallSiteBase(II) {}
720 : explicit ImmutableCallSite(const Value *V) : CallSiteBase(V) {}
721 : ImmutableCallSite(CallSite CS) : CallSiteBase(CS.getInstruction()) {}
722 : };
723 :
724 : } // end namespace llvm
725 :
726 : #endif // LLVM_IR_CALLSITE_H
|
