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
46namespace llvm {
47
48namespace Intrinsic {
49enum ID : unsigned;
50}
51
52template <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>
61class CallSiteBase {
62protected:
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
70private:
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
84public:
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
657private:
658 IterTy getCallee() const {
659 return cast<CallBase>(getInstruction())->op_end() - 1;
660 }
661};
662
663class CallSite : public CallSiteBase<Function, BasicBlock, Value, User, Use,
664 Instruction, CallInst, InvokeInst,
665 User::op_iterator> {
666public:
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
680private:
681 friend struct DenseMapInfo<CallSite>;
682
683 User::op_iterator getCallee() const;
684};
685
686template <> 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.
711class ImmutableCallSite : public CallSiteBase<> {
712public:
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