2014-03-04 11:01:28 +00:00
|
|
|
//===- CallSite.h - Abstract Call & Invoke instrs ---------------*- C++ -*-===//
|
2005-04-21 20:48:15 +00:00
|
|
|
//
|
2003-10-20 20:19:47 +00:00
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-29 19:59:42 +00:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2005-04-21 20:48:15 +00:00
|
|
|
//
|
2003-10-20 20:19:47 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2003-02-24 20:35:45 +00:00
|
|
|
//
|
|
|
|
// This file defines the CallSite class, which is a handy wrapper for code that
|
2010-04-01 08:21:08 +00:00
|
|
|
// wants to treat Call and Invoke instructions in a generic way. When in non-
|
|
|
|
// mutation context (e.g. an analysis) ImmutableCallSite should be used.
|
|
|
|
// Finally, when some degree of customization is necessary between these two
|
|
|
|
// extremes, CallSiteBase<> can be supplied with fine-tuned parameters.
|
2003-02-24 20:35:45 +00:00
|
|
|
//
|
2010-04-01 08:21:08 +00:00
|
|
|
// NOTE: These classes are supposed to have "value semantics". So they should be
|
|
|
|
// passed by value, not by reference; they should not be "new"ed or "delete"d.
|
|
|
|
// They are efficiently copyable, assignable and constructable, with cost
|
|
|
|
// equivalent to copying a pointer (notice that they have only a single data
|
|
|
|
// member). The internal representation carries a flag which indicates which of
|
|
|
|
// the two variants is enclosed. This allows for cheaper checks when various
|
|
|
|
// accessors of CallSite are employed.
|
2003-11-07 19:25:22 +00:00
|
|
|
//
|
2003-02-24 20:35:45 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2014-03-04 11:01:28 +00:00
|
|
|
#ifndef LLVM_IR_CALLSITE_H
|
|
|
|
#define LLVM_IR_CALLSITE_H
|
2003-02-24 20:35:45 +00:00
|
|
|
|
2009-01-11 22:33:22 +00:00
|
|
|
#include "llvm/ADT/PointerIntPair.h"
|
2015-06-16 20:24:25 +00:00
|
|
|
#include "llvm/ADT/iterator_range.h"
|
2013-01-02 11:36:10 +00:00
|
|
|
#include "llvm/IR/Attributes.h"
|
|
|
|
#include "llvm/IR/CallingConv.h"
|
|
|
|
#include "llvm/IR/Instructions.h"
|
2003-02-24 20:35:45 +00:00
|
|
|
|
2003-11-11 22:41:34 +00:00
|
|
|
namespace llvm {
|
|
|
|
|
2003-02-24 20:35:45 +00:00
|
|
|
class CallInst;
|
|
|
|
class InvokeInst;
|
|
|
|
|
2010-04-01 08:21:08 +00:00
|
|
|
template <typename FunTy = const Function,
|
2015-06-26 21:39:44 +00:00
|
|
|
typename BBTy = const BasicBlock,
|
2010-04-01 08:21:08 +00:00
|
|
|
typename ValTy = const Value,
|
|
|
|
typename UserTy = const User,
|
2015-09-24 19:14:18 +00:00
|
|
|
typename UseTy = const Use,
|
2010-04-01 08:21:08 +00:00
|
|
|
typename InstrTy = const Instruction,
|
|
|
|
typename CallTy = const CallInst,
|
|
|
|
typename InvokeTy = const InvokeInst,
|
|
|
|
typename IterTy = User::const_op_iterator>
|
|
|
|
class CallSiteBase {
|
|
|
|
protected:
|
|
|
|
PointerIntPair<InstrTy*, 1, bool> I;
|
2015-04-10 14:50:08 +00:00
|
|
|
|
2014-04-09 06:08:46 +00:00
|
|
|
CallSiteBase() : I(nullptr, false) {}
|
2010-07-28 10:44:59 +00:00
|
|
|
CallSiteBase(CallTy *CI) : I(CI, true) { assert(CI); }
|
|
|
|
CallSiteBase(InvokeTy *II) : I(II, false) { assert(II); }
|
2015-04-10 14:50:08 +00:00
|
|
|
explicit CallSiteBase(ValTy *II) { *this = get(II); }
|
|
|
|
|
|
|
|
private:
|
2010-04-01 08:21:08 +00:00
|
|
|
/// CallSiteBase::get - This static method is sort of like a constructor. It
|
|
|
|
/// will create an appropriate call site for a Call or Invoke instruction, but
|
|
|
|
/// it can also create a null initialized CallSiteBase object for something
|
|
|
|
/// which is NOT a call site.
|
2003-06-17 22:16:59 +00:00
|
|
|
///
|
2010-04-01 08:21:08 +00:00
|
|
|
static CallSiteBase get(ValTy *V) {
|
|
|
|
if (InstrTy *II = dyn_cast<InstrTy>(V)) {
|
|
|
|
if (II->getOpcode() == Instruction::Call)
|
2010-07-27 21:46:11 +00:00
|
|
|
return CallSiteBase(static_cast<CallTy*>(II));
|
2010-04-01 08:21:08 +00:00
|
|
|
else if (II->getOpcode() == Instruction::Invoke)
|
2010-07-27 21:46:11 +00:00
|
|
|
return CallSiteBase(static_cast<InvokeTy*>(II));
|
2003-06-17 22:16:59 +00:00
|
|
|
}
|
2010-04-01 08:21:08 +00:00
|
|
|
return CallSiteBase();
|
2003-06-17 22:16:59 +00:00
|
|
|
}
|
2015-09-22 11:14:39 +00:00
|
|
|
|
2010-09-18 11:48:36 +00:00
|
|
|
public:
|
2009-01-11 22:33:22 +00:00
|
|
|
/// isCall - true if a CallInst is enclosed.
|
|
|
|
/// Note that !isCall() does not mean it is an InvokeInst enclosed,
|
|
|
|
/// it also could signify a NULL Instruction pointer.
|
|
|
|
bool isCall() const { return I.getInt(); }
|
|
|
|
|
|
|
|
/// isInvoke - true if a InvokeInst is enclosed.
|
|
|
|
///
|
|
|
|
bool isInvoke() const { return getInstruction() && !I.getInt(); }
|
2003-11-05 20:25:33 +00:00
|
|
|
|
2010-04-01 08:21:08 +00:00
|
|
|
InstrTy *getInstruction() const { return I.getPointer(); }
|
|
|
|
InstrTy *operator->() const { return I.getPointer(); }
|
2015-02-15 22:00:20 +00:00
|
|
|
explicit operator bool() const { return I.getPointer(); }
|
2004-05-23 08:02:45 +00:00
|
|
|
|
2015-06-26 21:39:44 +00:00
|
|
|
/// Get the basic block containing the call site
|
|
|
|
BBTy* getParent() const { return getInstruction()->getParent(); }
|
|
|
|
|
2012-09-05 19:16:22 +00:00
|
|
|
/// getCalledValue - Return the pointer to function that is being called.
|
2003-02-24 20:35:45 +00:00
|
|
|
///
|
2010-04-01 08:21:08 +00:00
|
|
|
ValTy *getCalledValue() const {
|
2009-01-11 22:33:22 +00:00
|
|
|
assert(getInstruction() && "Not a call or invoke instruction!");
|
2010-03-24 13:21:49 +00:00
|
|
|
return *getCallee();
|
2003-10-23 19:33:49 +00:00
|
|
|
}
|
2003-02-24 20:35:45 +00:00
|
|
|
|
|
|
|
/// getCalledFunction - Return the function being called if this is a direct
|
|
|
|
/// call, otherwise return null (if it's an indirect call).
|
|
|
|
///
|
2010-04-01 08:21:08 +00:00
|
|
|
FunTy *getCalledFunction() const {
|
|
|
|
return dyn_cast<FunTy>(getCalledValue());
|
2004-11-18 17:46:57 +00:00
|
|
|
}
|
2003-02-24 20:35:45 +00:00
|
|
|
|
2012-09-05 19:16:22 +00:00
|
|
|
/// setCalledFunction - Set the callee to the specified value.
|
2003-06-17 22:16:59 +00:00
|
|
|
///
|
|
|
|
void setCalledFunction(Value *V) {
|
2009-01-11 22:33:22 +00:00
|
|
|
assert(getInstruction() && "Not a call or invoke instruction!");
|
2010-03-24 13:21:49 +00:00
|
|
|
*getCallee() = V;
|
2003-06-17 22:16:59 +00:00
|
|
|
}
|
|
|
|
|
2010-04-01 08:21:08 +00:00
|
|
|
/// isCallee - Determine whether the passed iterator points to the
|
|
|
|
/// callee operand's Use.
|
2014-03-09 03:16:01 +00:00
|
|
|
bool isCallee(Value::const_user_iterator UI) const {
|
|
|
|
return isCallee(&UI.getUse());
|
2010-04-01 08:21:08 +00:00
|
|
|
}
|
|
|
|
|
2014-03-09 03:16:01 +00:00
|
|
|
/// Determine whether this Use is the callee operand's Use.
|
|
|
|
bool isCallee(const Use *U) const { return getCallee() == U; }
|
|
|
|
|
2015-12-23 09:58:36 +00:00
|
|
|
/// \brief Determine whether the passed iterator points to an argument
|
|
|
|
/// operand.
|
|
|
|
bool isArgOperand(Value::const_user_iterator UI) const {
|
|
|
|
return isArgOperand(&UI.getUse());
|
|
|
|
}
|
|
|
|
|
|
|
|
/// \brief Determine whether the passed use points to an argument operand.
|
|
|
|
bool isArgOperand(const Use *U) const {
|
2015-12-24 02:31:20 +00:00
|
|
|
assert(getInstruction() == U->getUser());
|
2015-12-23 09:58:36 +00:00
|
|
|
return arg_begin() <= U && U < arg_end();
|
|
|
|
}
|
|
|
|
|
|
|
|
/// \brief Determine whether the passed iterator points to a bundle operand.
|
|
|
|
bool isBundleOperand(Value::const_user_iterator UI) const {
|
|
|
|
return isBundleOperand(&UI.getUse());
|
|
|
|
}
|
|
|
|
|
|
|
|
/// \brief Determine whether the passed use points to a bundle operand.
|
|
|
|
bool isBundleOperand(const Use *U) const {
|
2015-12-24 02:31:20 +00:00
|
|
|
assert(getInstruction() == U->getUser());
|
2015-12-23 09:58:36 +00:00
|
|
|
if (!hasOperandBundles())
|
|
|
|
return false;
|
2015-12-24 02:31:20 +00:00
|
|
|
unsigned OperandNo = U - (*this)->op_begin();
|
2015-12-23 09:58:36 +00:00
|
|
|
return getBundleOperandsStartIndex() <= OperandNo &&
|
|
|
|
OperandNo < getBundleOperandsEndIndex();
|
|
|
|
}
|
|
|
|
|
2015-12-23 09:58:41 +00:00
|
|
|
/// \brief Determine whether the passed iterator points to a data operand.
|
|
|
|
bool isDataOperand(Value::const_user_iterator UI) const {
|
|
|
|
return isDataOperand(&UI.getUse());
|
|
|
|
}
|
|
|
|
|
|
|
|
/// \brief Determine whether the passed use points to a data operand.
|
|
|
|
bool isDataOperand(const Use *U) const {
|
|
|
|
return data_operands_begin() <= U && U < data_operands_end();
|
|
|
|
}
|
|
|
|
|
2010-04-01 08:21:08 +00:00
|
|
|
ValTy *getArgument(unsigned ArgNo) const {
|
2004-11-13 23:28:10 +00:00
|
|
|
assert(arg_begin() + ArgNo < arg_end() && "Argument # out of range!");
|
2010-07-29 23:35:00 +00:00
|
|
|
return *(arg_begin() + ArgNo);
|
2004-11-13 23:28:10 +00:00
|
|
|
}
|
|
|
|
|
2008-02-18 00:10:55 +00:00
|
|
|
void setArgument(unsigned ArgNo, Value* newVal) {
|
2009-01-11 22:33:22 +00:00
|
|
|
assert(getInstruction() && "Not a call or invoke instruction!");
|
2008-02-18 00:10:55 +00:00
|
|
|
assert(arg_begin() + ArgNo < arg_end() && "Argument # out of range!");
|
2010-07-29 23:35:00 +00:00
|
|
|
getInstruction()->setOperand(ArgNo, newVal);
|
2008-02-18 00:10:55 +00:00
|
|
|
}
|
2008-07-08 08:50:32 +00:00
|
|
|
|
2010-03-24 13:21:49 +00:00
|
|
|
/// Given a value use iterator, returns the argument that corresponds to it.
|
|
|
|
/// Iterator must actually correspond to an argument.
|
2014-03-09 03:16:01 +00:00
|
|
|
unsigned getArgumentNo(Value::const_user_iterator I) const {
|
|
|
|
return getArgumentNo(&I.getUse());
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Given a use for an argument, get the argument number that corresponds to
|
|
|
|
/// it.
|
|
|
|
unsigned getArgumentNo(const Use *U) const {
|
2010-03-24 13:21:49 +00:00
|
|
|
assert(getInstruction() && "Not a call or invoke instruction!");
|
2015-12-23 09:58:36 +00:00
|
|
|
assert(isArgOperand(U) && "Argument # out of range!");
|
2014-03-09 03:16:01 +00:00
|
|
|
return U - arg_begin();
|
2010-03-24 13:21:49 +00:00
|
|
|
}
|
|
|
|
|
2003-02-24 20:35:45 +00:00
|
|
|
/// arg_iterator - The type of iterator to use when looping over actual
|
2012-09-05 19:16:22 +00:00
|
|
|
/// arguments at this call site.
|
2010-04-01 08:21:08 +00:00
|
|
|
typedef IterTy arg_iterator;
|
2003-02-24 20:35:45 +00:00
|
|
|
|
2015-06-16 20:24:25 +00:00
|
|
|
iterator_range<IterTy> args() const {
|
2015-12-06 05:08:07 +00:00
|
|
|
return make_range(arg_begin(), arg_end());
|
2015-06-16 20:24:25 +00:00
|
|
|
}
|
2007-10-01 16:01:23 +00:00
|
|
|
bool arg_empty() const { return arg_end() == arg_begin(); }
|
2004-06-05 00:17:13 +00:00
|
|
|
unsigned arg_size() const { return unsigned(arg_end() - arg_begin()); }
|
2015-03-05 18:26:34 +00:00
|
|
|
|
2015-12-23 09:58:41 +00:00
|
|
|
/// Given a value use iterator, returns the data operand that corresponds to
|
|
|
|
/// it.
|
|
|
|
/// Iterator must actually correspond to a data operand.
|
|
|
|
unsigned getDataOperandNo(Value::const_user_iterator UI) const {
|
|
|
|
return getDataOperandNo(&UI.getUse());
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Given a use for a data operand, get the data operand number that
|
|
|
|
/// corresponds to it.
|
|
|
|
unsigned getDataOperandNo(const Use *U) const {
|
|
|
|
assert(getInstruction() && "Not a call or invoke instruction!");
|
|
|
|
assert(isDataOperand(U) && "Data operand # out of range!");
|
|
|
|
return U - data_operands_begin();
|
|
|
|
}
|
|
|
|
|
2015-11-04 21:05:24 +00:00
|
|
|
/// Type of iterator to use when looping over data operands at this call site
|
|
|
|
/// (see below).
|
|
|
|
typedef IterTy data_operand_iterator;
|
|
|
|
|
|
|
|
/// data_operands_begin/data_operands_end - Return iterators iterating over
|
|
|
|
/// the call / invoke argument list and bundle operands. For invokes, this is
|
|
|
|
/// the set of instruction operands except the invoke target and the two
|
|
|
|
/// successor blocks; and for calls this is the set of instruction operands
|
|
|
|
/// except the call target.
|
|
|
|
|
|
|
|
IterTy data_operands_begin() const {
|
|
|
|
assert(getInstruction() && "Not a call or invoke instruction!");
|
|
|
|
return (*this)->op_begin();
|
|
|
|
}
|
|
|
|
IterTy data_operands_end() const {
|
|
|
|
assert(getInstruction() && "Not a call or invoke instruction!");
|
|
|
|
return (*this)->op_end() - (isCall() ? 1 : 3);
|
|
|
|
}
|
|
|
|
iterator_range<IterTy> data_ops() const {
|
2015-12-06 05:08:07 +00:00
|
|
|
return make_range(data_operands_begin(), data_operands_end());
|
2015-11-04 21:05:24 +00:00
|
|
|
}
|
|
|
|
bool data_operands_empty() const {
|
|
|
|
return data_operands_end() == data_operands_begin();
|
|
|
|
}
|
|
|
|
unsigned data_operands_size() const {
|
|
|
|
return std::distance(data_operands_begin(), data_operands_end());
|
|
|
|
}
|
|
|
|
|
2010-04-14 20:31:28 +00:00
|
|
|
/// getType - Return the type of the instruction that generated this call site
|
|
|
|
///
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *getType() const { return (*this)->getType(); }
|
2010-04-14 20:31:28 +00:00
|
|
|
|
|
|
|
/// getCaller - Return the caller function for this call site
|
|
|
|
///
|
2010-04-14 20:49:44 +00:00
|
|
|
FunTy *getCaller() const { return (*this)->getParent()->getParent(); }
|
2010-04-14 20:31:28 +00:00
|
|
|
|
2014-04-24 20:14:34 +00:00
|
|
|
/// \brief Tests if this call site must be tail call optimized. Only a
|
|
|
|
/// CallInst can be tail call optimized.
|
|
|
|
bool isMustTailCall() const {
|
|
|
|
return isCall() && cast<CallInst>(getInstruction())->isMustTailCall();
|
|
|
|
}
|
|
|
|
|
2014-05-05 23:59:03 +00:00
|
|
|
/// \brief Tests if this call site is marked as a tail call.
|
|
|
|
bool isTailCall() const {
|
|
|
|
return isCall() && cast<CallInst>(getInstruction())->isTailCall();
|
|
|
|
}
|
|
|
|
|
2010-04-14 21:47:32 +00:00
|
|
|
#define CALLSITE_DELEGATE_GETTER(METHOD) \
|
|
|
|
InstrTy *II = getInstruction(); \
|
|
|
|
return isCall() \
|
|
|
|
? cast<CallInst>(II)->METHOD \
|
|
|
|
: cast<InvokeInst>(II)->METHOD
|
|
|
|
|
|
|
|
#define CALLSITE_DELEGATE_SETTER(METHOD) \
|
|
|
|
InstrTy *II = getInstruction(); \
|
|
|
|
if (isCall()) \
|
|
|
|
cast<CallInst>(II)->METHOD; \
|
|
|
|
else \
|
|
|
|
cast<InvokeInst>(II)->METHOD
|
|
|
|
|
2015-06-26 21:39:44 +00:00
|
|
|
unsigned getNumArgOperands() const {
|
|
|
|
CALLSITE_DELEGATE_GETTER(getNumArgOperands());
|
|
|
|
}
|
|
|
|
|
2015-09-22 11:19:03 +00:00
|
|
|
ValTy *getArgOperand(unsigned i) const {
|
2015-06-26 21:39:44 +00:00
|
|
|
CALLSITE_DELEGATE_GETTER(getArgOperand(i));
|
|
|
|
}
|
|
|
|
|
2015-09-22 11:19:03 +00:00
|
|
|
bool isInlineAsm() const {
|
2015-06-26 21:39:44 +00:00
|
|
|
if (isCall())
|
|
|
|
return cast<CallInst>(getInstruction())->isInlineAsm();
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2010-04-14 21:47:32 +00:00
|
|
|
/// getCallingConv/setCallingConv - get or set the calling convention of the
|
|
|
|
/// call.
|
|
|
|
CallingConv::ID getCallingConv() const {
|
|
|
|
CALLSITE_DELEGATE_GETTER(getCallingConv());
|
|
|
|
}
|
|
|
|
void setCallingConv(CallingConv::ID CC) {
|
|
|
|
CALLSITE_DELEGATE_SETTER(setCallingConv(CC));
|
|
|
|
}
|
|
|
|
|
2015-04-23 21:36:23 +00:00
|
|
|
FunctionType *getFunctionType() const {
|
|
|
|
CALLSITE_DELEGATE_GETTER(getFunctionType());
|
|
|
|
}
|
|
|
|
|
|
|
|
void mutateFunctionType(FunctionType *Ty) const {
|
|
|
|
CALLSITE_DELEGATE_SETTER(mutateFunctionType(Ty));
|
|
|
|
}
|
|
|
|
|
2010-04-14 21:47:32 +00:00
|
|
|
/// getAttributes/setAttributes - get or set the parameter attributes of
|
|
|
|
/// the call.
|
2012-12-07 23:16:57 +00:00
|
|
|
const AttributeSet &getAttributes() const {
|
2010-04-14 21:47:32 +00:00
|
|
|
CALLSITE_DELEGATE_GETTER(getAttributes());
|
|
|
|
}
|
2012-12-07 23:16:57 +00:00
|
|
|
void setAttributes(const AttributeSet &PAL) {
|
2010-04-14 21:47:32 +00:00
|
|
|
CALLSITE_DELEGATE_SETTER(setAttributes(PAL));
|
|
|
|
}
|
|
|
|
|
2012-06-25 16:16:58 +00:00
|
|
|
/// \brief Return true if this function has the given attribute.
|
2012-12-22 00:37:52 +00:00
|
|
|
bool hasFnAttr(Attribute::AttrKind A) const {
|
2012-10-09 21:49:51 +00:00
|
|
|
CALLSITE_DELEGATE_GETTER(hasFnAttr(A));
|
2012-06-25 16:16:58 +00:00
|
|
|
}
|
|
|
|
|
2016-01-05 19:08:33 +00:00
|
|
|
/// \brief Return true if this function has the given attribute.
|
|
|
|
bool hasFnAttr(StringRef A) const {
|
|
|
|
CALLSITE_DELEGATE_GETTER(hasFnAttr(A));
|
|
|
|
}
|
|
|
|
|
2012-10-09 21:38:14 +00:00
|
|
|
/// \brief Return true if the call or the callee has the given attribute.
|
2012-12-22 00:37:52 +00:00
|
|
|
bool paramHasAttr(unsigned i, Attribute::AttrKind A) const {
|
2012-10-09 21:38:14 +00:00
|
|
|
CALLSITE_DELEGATE_GETTER(paramHasAttr(i, A));
|
2010-04-14 21:47:32 +00:00
|
|
|
}
|
|
|
|
|
2015-11-04 21:05:24 +00:00
|
|
|
/// \brief Return true if the data operand at index \p i directly or
|
|
|
|
/// indirectly has the attribute \p A.
|
|
|
|
///
|
|
|
|
/// Normal call or invoke arguments have per operand attributes, as specified
|
|
|
|
/// in the attribute set attached to this instruction, while operand bundle
|
|
|
|
/// operands may have some attributes implied by the type of its containing
|
|
|
|
/// operand bundle.
|
|
|
|
bool dataOperandHasImpliedAttr(unsigned i, Attribute::AttrKind A) const {
|
|
|
|
CALLSITE_DELEGATE_GETTER(dataOperandHasImpliedAttr(i, A));
|
|
|
|
}
|
|
|
|
|
2010-04-14 21:47:32 +00:00
|
|
|
/// @brief Extract the alignment for a call or parameter (0=unknown).
|
|
|
|
uint16_t getParamAlignment(uint16_t i) const {
|
|
|
|
CALLSITE_DELEGATE_GETTER(getParamAlignment(i));
|
|
|
|
}
|
|
|
|
|
2014-07-18 15:51:28 +00:00
|
|
|
/// @brief Extract the number of dereferenceable bytes for a call or
|
|
|
|
/// parameter (0=unknown).
|
|
|
|
uint64_t getDereferenceableBytes(uint16_t i) const {
|
|
|
|
CALLSITE_DELEGATE_GETTER(getDereferenceableBytes(i));
|
|
|
|
}
|
2015-09-22 11:14:39 +00:00
|
|
|
|
2015-05-06 17:41:54 +00:00
|
|
|
/// @brief Extract the number of dereferenceable_or_null bytes for a call or
|
|
|
|
/// parameter (0=unknown).
|
|
|
|
uint64_t getDereferenceableOrNullBytes(uint16_t i) const {
|
|
|
|
CALLSITE_DELEGATE_GETTER(getDereferenceableOrNullBytes(i));
|
|
|
|
}
|
2015-09-22 11:14:39 +00:00
|
|
|
|
2015-10-26 19:06:01 +00:00
|
|
|
/// @brief Determine if the parameter or return value is marked with NoAlias
|
|
|
|
/// attribute.
|
|
|
|
/// @param n The parameter to check. 1 is the first parameter, 0 is the return
|
|
|
|
bool doesNotAlias(unsigned n) const {
|
|
|
|
CALLSITE_DELEGATE_GETTER(doesNotAlias(n));
|
|
|
|
}
|
|
|
|
|
2013-06-27 00:25:01 +00:00
|
|
|
/// \brief Return true if the call should not be treated as a call to a
|
|
|
|
/// builtin.
|
|
|
|
bool isNoBuiltin() const {
|
|
|
|
CALLSITE_DELEGATE_GETTER(isNoBuiltin());
|
|
|
|
}
|
|
|
|
|
2010-04-14 21:47:32 +00:00
|
|
|
/// @brief Return true if the call should not be inlined.
|
|
|
|
bool isNoInline() const {
|
|
|
|
CALLSITE_DELEGATE_GETTER(isNoInline());
|
|
|
|
}
|
|
|
|
void setIsNoInline(bool Value = true) {
|
2010-07-06 03:52:37 +00:00
|
|
|
CALLSITE_DELEGATE_SETTER(setIsNoInline(Value));
|
2010-04-14 21:47:32 +00:00
|
|
|
}
|
2010-07-06 03:52:37 +00:00
|
|
|
|
2010-04-14 21:47:32 +00:00
|
|
|
/// @brief Determine if the call does not access memory.
|
|
|
|
bool doesNotAccessMemory() const {
|
|
|
|
CALLSITE_DELEGATE_GETTER(doesNotAccessMemory());
|
|
|
|
}
|
2012-10-09 23:40:31 +00:00
|
|
|
void setDoesNotAccessMemory() {
|
|
|
|
CALLSITE_DELEGATE_SETTER(setDoesNotAccessMemory());
|
2010-04-14 21:47:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// @brief Determine if the call does not access or only reads memory.
|
|
|
|
bool onlyReadsMemory() const {
|
|
|
|
CALLSITE_DELEGATE_GETTER(onlyReadsMemory());
|
|
|
|
}
|
2012-10-09 23:40:31 +00:00
|
|
|
void setOnlyReadsMemory() {
|
|
|
|
CALLSITE_DELEGATE_SETTER(setOnlyReadsMemory());
|
2010-04-14 21:47:32 +00:00
|
|
|
}
|
|
|
|
|
2015-07-11 10:30:36 +00:00
|
|
|
/// @brief Determine if the call can access memmory only using pointers based
|
|
|
|
/// on its arguments.
|
|
|
|
bool onlyAccessesArgMemory() const {
|
|
|
|
CALLSITE_DELEGATE_GETTER(onlyAccessesArgMemory());
|
|
|
|
}
|
|
|
|
void setOnlyAccessesArgMemory() {
|
|
|
|
CALLSITE_DELEGATE_SETTER(setOnlyAccessesArgMemory());
|
|
|
|
}
|
|
|
|
|
2010-04-14 21:47:32 +00:00
|
|
|
/// @brief Determine if the call cannot return.
|
|
|
|
bool doesNotReturn() const {
|
|
|
|
CALLSITE_DELEGATE_GETTER(doesNotReturn());
|
|
|
|
}
|
2012-10-09 23:40:31 +00:00
|
|
|
void setDoesNotReturn() {
|
|
|
|
CALLSITE_DELEGATE_SETTER(setDoesNotReturn());
|
2010-04-14 21:47:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// @brief Determine if the call cannot unwind.
|
|
|
|
bool doesNotThrow() const {
|
|
|
|
CALLSITE_DELEGATE_GETTER(doesNotThrow());
|
|
|
|
}
|
2012-10-09 23:40:31 +00:00
|
|
|
void setDoesNotThrow() {
|
|
|
|
CALLSITE_DELEGATE_SETTER(setDoesNotThrow());
|
2010-04-14 21:47:32 +00:00
|
|
|
}
|
|
|
|
|
2016-02-17 17:46:47 +00:00
|
|
|
/// @brief Determine if the call is convergent.
|
|
|
|
bool isConvergent() const {
|
|
|
|
CALLSITE_DELEGATE_GETTER(isConvergent());
|
|
|
|
}
|
|
|
|
void setConvergent() {
|
|
|
|
CALLSITE_DELEGATE_SETTER(setConvergent());
|
|
|
|
}
|
|
|
|
void setNotConvergent() {
|
|
|
|
CALLSITE_DELEGATE_SETTER(setNotConvergent());
|
|
|
|
}
|
|
|
|
|
2015-12-23 09:58:36 +00:00
|
|
|
unsigned getNumOperandBundles() const {
|
2015-09-24 19:14:18 +00:00
|
|
|
CALLSITE_DELEGATE_GETTER(getNumOperandBundles());
|
|
|
|
}
|
|
|
|
|
|
|
|
bool hasOperandBundles() const {
|
|
|
|
CALLSITE_DELEGATE_GETTER(hasOperandBundles());
|
|
|
|
}
|
|
|
|
|
2015-12-23 09:58:36 +00:00
|
|
|
unsigned getBundleOperandsStartIndex() const {
|
|
|
|
CALLSITE_DELEGATE_GETTER(getBundleOperandsStartIndex());
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned getBundleOperandsEndIndex() const {
|
|
|
|
CALLSITE_DELEGATE_GETTER(getBundleOperandsEndIndex());
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned getNumTotalBundleOperands() const {
|
2015-09-24 19:14:18 +00:00
|
|
|
CALLSITE_DELEGATE_GETTER(getNumTotalBundleOperands());
|
|
|
|
}
|
|
|
|
|
2015-11-07 01:56:04 +00:00
|
|
|
OperandBundleUse getOperandBundleAt(unsigned Index) const {
|
|
|
|
CALLSITE_DELEGATE_GETTER(getOperandBundleAt(Index));
|
2015-09-24 19:14:18 +00:00
|
|
|
}
|
|
|
|
|
2015-10-07 02:39:24 +00:00
|
|
|
Optional<OperandBundleUse> getOperandBundle(StringRef Name) const {
|
|
|
|
CALLSITE_DELEGATE_GETTER(getOperandBundle(Name));
|
|
|
|
}
|
|
|
|
|
2015-11-10 20:13:15 +00:00
|
|
|
Optional<OperandBundleUse> getOperandBundle(uint32_t ID) const {
|
|
|
|
CALLSITE_DELEGATE_GETTER(getOperandBundle(ID));
|
|
|
|
}
|
|
|
|
|
Introduce @llvm.experimental.deoptimize
Summary:
This intrinsic, together with deoptimization operand bundles, allow
frontends to express transfer of control and frame-local state from
one (typically more specialized, hence faster) version of a function
into another (typically more generic, hence slower) version.
In languages with a fully integrated managed runtime this intrinsic can
be used to implement "uncommon trap" like functionality. In unmanaged
languages like C and C++, this intrinsic can be used to represent the
slow paths of specialized functions.
Note: this change does not address how `@llvm.experimental_deoptimize`
is lowered. That will be done in a later change.
Reviewers: chandlerc, rnk, atrick, reames
Subscribers: llvm-commits, kmod, mjacob, maksfb, mcrosier, JosephTremoulet
Differential Revision: http://reviews.llvm.org/D17732
llvm-svn: 263281
2016-03-11 19:08:34 +00:00
|
|
|
unsigned countOperandBundlesOfType(uint32_t ID) const {
|
|
|
|
CALLSITE_DELEGATE_GETTER(countOperandBundlesOfType(ID));
|
|
|
|
}
|
|
|
|
|
2015-12-10 06:39:02 +00:00
|
|
|
IterTy arg_begin() const {
|
|
|
|
CALLSITE_DELEGATE_GETTER(arg_begin());
|
|
|
|
}
|
|
|
|
|
|
|
|
IterTy arg_end() const {
|
|
|
|
CALLSITE_DELEGATE_GETTER(arg_end());
|
|
|
|
}
|
|
|
|
|
2010-04-14 21:47:32 +00:00
|
|
|
#undef CALLSITE_DELEGATE_GETTER
|
|
|
|
#undef CALLSITE_DELEGATE_SETTER
|
|
|
|
|
2015-11-25 00:42:24 +00:00
|
|
|
void getOperandBundlesAsDefs(SmallVectorImpl<OperandBundleDef> &Defs) const {
|
|
|
|
const Instruction *II = getInstruction();
|
|
|
|
// Since this is actually a getter that "looks like" a setter, don't use the
|
|
|
|
// above macros to avoid confusion.
|
|
|
|
if (isCall())
|
|
|
|
cast<CallInst>(II)->getOperandBundlesAsDefs(Defs);
|
|
|
|
else
|
|
|
|
cast<InvokeInst>(II)->getOperandBundlesAsDefs(Defs);
|
|
|
|
}
|
|
|
|
|
2015-11-04 21:05:24 +00:00
|
|
|
/// @brief Determine whether this data operand is not captured.
|
|
|
|
bool doesNotCapture(unsigned OpNo) const {
|
|
|
|
return dataOperandHasImpliedAttr(OpNo + 1, Attribute::NoCapture);
|
2011-11-20 19:09:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// @brief Determine whether this argument is passed by value.
|
|
|
|
bool isByValArgument(unsigned ArgNo) const {
|
2012-12-19 07:18:57 +00:00
|
|
|
return paramHasAttr(ArgNo + 1, Attribute::ByVal);
|
2011-11-20 19:09:04 +00:00
|
|
|
}
|
|
|
|
|
2013-12-19 02:14:12 +00:00
|
|
|
/// @brief Determine whether this argument is passed in an alloca.
|
|
|
|
bool isInAllocaArgument(unsigned ArgNo) const {
|
|
|
|
return paramHasAttr(ArgNo + 1, Attribute::InAlloca);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// @brief Determine whether this argument is passed by value or in an alloca.
|
|
|
|
bool isByValOrInAllocaArgument(unsigned ArgNo) const {
|
|
|
|
return paramHasAttr(ArgNo + 1, Attribute::ByVal) ||
|
|
|
|
paramHasAttr(ArgNo + 1, Attribute::InAlloca);
|
|
|
|
}
|
|
|
|
|
2014-01-31 23:50:57 +00:00
|
|
|
/// @brief Determine if there are is an inalloca argument. Only the last
|
|
|
|
/// argument can have the inalloca attribute.
|
2013-12-19 02:14:12 +00:00
|
|
|
bool hasInAllocaArgument() const {
|
2014-01-31 23:50:57 +00:00
|
|
|
return paramHasAttr(arg_size(), Attribute::InAlloca);
|
2013-12-19 02:14:12 +00:00
|
|
|
}
|
|
|
|
|
2015-11-04 21:05:24 +00:00
|
|
|
bool doesNotAccessMemory(unsigned OpNo) const {
|
|
|
|
return dataOperandHasImpliedAttr(OpNo + 1, Attribute::ReadNone);
|
2013-07-06 00:29:58 +00:00
|
|
|
}
|
|
|
|
|
2015-11-04 21:05:24 +00:00
|
|
|
bool onlyReadsMemory(unsigned OpNo) const {
|
|
|
|
return dataOperandHasImpliedAttr(OpNo + 1, Attribute::ReadOnly) ||
|
|
|
|
dataOperandHasImpliedAttr(OpNo + 1, Attribute::ReadNone);
|
2013-07-06 00:29:58 +00:00
|
|
|
}
|
|
|
|
|
2014-07-18 15:51:28 +00:00
|
|
|
/// @brief Return true if the return value is known to be not null.
|
|
|
|
/// This may be because it has the nonnull attribute, or because at least
|
|
|
|
/// one byte is dereferenceable and the pointer is in addrspace(0).
|
|
|
|
bool isReturnNonNull() const {
|
|
|
|
if (paramHasAttr(0, Attribute::NonNull))
|
|
|
|
return true;
|
|
|
|
else if (getDereferenceableBytes(0) > 0 &&
|
|
|
|
getType()->getPointerAddressSpace() == 0)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2010-04-14 21:47:32 +00:00
|
|
|
/// hasArgument - Returns true if this CallSite passes the given Value* as an
|
|
|
|
/// argument to the called function.
|
|
|
|
bool hasArgument(const Value *Arg) const {
|
|
|
|
for (arg_iterator AI = this->arg_begin(), E = this->arg_end(); AI != E;
|
|
|
|
++AI)
|
|
|
|
if (AI->get() == Arg)
|
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2008-07-08 08:50:32 +00:00
|
|
|
private:
|
2010-04-01 08:21:08 +00:00
|
|
|
IterTy getCallee() const {
|
2010-08-05 21:25:49 +00:00
|
|
|
if (isCall()) // Skip Callee
|
|
|
|
return cast<CallInst>(getInstruction())->op_end() - 1;
|
|
|
|
else // Skip BB, BB, Callee
|
|
|
|
return cast<InvokeInst>(getInstruction())->op_end() - 3;
|
2010-04-01 08:21:08 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2015-09-24 19:14:18 +00:00
|
|
|
class CallSite : public CallSiteBase<Function, BasicBlock, Value, User, Use,
|
2015-06-26 21:39:44 +00:00
|
|
|
Instruction, CallInst, InvokeInst,
|
|
|
|
User::op_iterator> {
|
2010-04-01 08:21:08 +00:00
|
|
|
public:
|
|
|
|
CallSite() {}
|
2015-04-10 16:02:34 +00:00
|
|
|
CallSite(CallSiteBase B) : CallSiteBase(B) {}
|
|
|
|
CallSite(CallInst *CI) : CallSiteBase(CI) {}
|
|
|
|
CallSite(InvokeInst *II) : CallSiteBase(II) {}
|
|
|
|
explicit CallSite(Instruction *II) : CallSiteBase(II) {}
|
|
|
|
explicit CallSite(Value *V) : CallSiteBase(V) {}
|
2010-04-01 08:21:08 +00:00
|
|
|
|
|
|
|
bool operator==(const CallSite &CS) const { return I == CS.I; }
|
|
|
|
bool operator!=(const CallSite &CS) const { return I != CS.I; }
|
|
|
|
bool operator<(const CallSite &CS) const {
|
|
|
|
return getInstruction() < CS.getInstruction();
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
2010-03-24 13:21:49 +00:00
|
|
|
User::op_iterator getCallee() const;
|
2003-02-24 20:35:45 +00:00
|
|
|
};
|
|
|
|
|
2010-08-03 21:48:53 +00:00
|
|
|
/// ImmutableCallSite - establish a view to a call site for examination
|
|
|
|
class ImmutableCallSite : public CallSiteBase<> {
|
|
|
|
public:
|
2015-03-30 22:58:10 +00:00
|
|
|
ImmutableCallSite() {}
|
2015-04-10 16:02:34 +00:00
|
|
|
ImmutableCallSite(const CallInst *CI) : CallSiteBase(CI) {}
|
|
|
|
ImmutableCallSite(const InvokeInst *II) : CallSiteBase(II) {}
|
|
|
|
explicit ImmutableCallSite(const Instruction *II) : CallSiteBase(II) {}
|
|
|
|
explicit ImmutableCallSite(const Value *V) : CallSiteBase(V) {}
|
|
|
|
ImmutableCallSite(CallSite CS) : CallSiteBase(CS.getInstruction()) {}
|
2010-08-03 21:48:53 +00:00
|
|
|
};
|
|
|
|
|
2015-06-23 09:49:53 +00:00
|
|
|
} // End llvm namespace
|
2003-11-11 22:41:34 +00:00
|
|
|
|
2003-02-24 20:35:45 +00:00
|
|
|
#endif
|