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/PointerIntPair.h" 30 #include "llvm/IR/Attributes.h" 31 #include "llvm/IR/CallingConv.h" 32 #include "llvm/IR/Instructions.h" 33 34 namespace llvm { 35 36 class CallInst; 37 class InvokeInst; 38 39 template <typename FunTy = const Function, 40 typename ValTy = const Value, 41 typename UserTy = const User, 42 typename InstrTy = const Instruction, 43 typename CallTy = const CallInst, 44 typename InvokeTy = const InvokeInst, 45 typename IterTy = User::const_op_iterator> 46 class CallSiteBase { 47 protected: 48 PointerIntPair<InstrTy*, 1, bool> I; 49 public: CallSiteBase()50 CallSiteBase() : I(nullptr, false) {} CallSiteBase(CallTy * CI)51 CallSiteBase(CallTy *CI) : I(CI, true) { assert(CI); } CallSiteBase(InvokeTy * II)52 CallSiteBase(InvokeTy *II) : I(II, false) { assert(II); } CallSiteBase(ValTy * II)53 CallSiteBase(ValTy *II) { *this = get(II); } 54 protected: 55 /// CallSiteBase::get - This static method is sort of like a constructor. It 56 /// will create an appropriate call site for a Call or Invoke instruction, but 57 /// it can also create a null initialized CallSiteBase object for something 58 /// which is NOT a call site. 59 /// get(ValTy * V)60 static CallSiteBase get(ValTy *V) { 61 if (InstrTy *II = dyn_cast<InstrTy>(V)) { 62 if (II->getOpcode() == Instruction::Call) 63 return CallSiteBase(static_cast<CallTy*>(II)); 64 else if (II->getOpcode() == Instruction::Invoke) 65 return CallSiteBase(static_cast<InvokeTy*>(II)); 66 } 67 return CallSiteBase(); 68 } 69 public: 70 /// isCall - true if a CallInst is enclosed. 71 /// Note that !isCall() does not mean it is an InvokeInst enclosed, 72 /// it also could signify a NULL Instruction pointer. isCall()73 bool isCall() const { return I.getInt(); } 74 75 /// isInvoke - true if a InvokeInst is enclosed. 76 /// isInvoke()77 bool isInvoke() const { return getInstruction() && !I.getInt(); } 78 getInstruction()79 InstrTy *getInstruction() const { return I.getPointer(); } 80 InstrTy *operator->() const { return I.getPointer(); } 81 LLVM_EXPLICIT operator bool() const { return I.getPointer(); } 82 83 /// getCalledValue - Return the pointer to function that is being called. 84 /// getCalledValue()85 ValTy *getCalledValue() const { 86 assert(getInstruction() && "Not a call or invoke instruction!"); 87 return *getCallee(); 88 } 89 90 /// getCalledFunction - Return the function being called if this is a direct 91 /// call, otherwise return null (if it's an indirect call). 92 /// getCalledFunction()93 FunTy *getCalledFunction() const { 94 return dyn_cast<FunTy>(getCalledValue()); 95 } 96 97 /// setCalledFunction - Set the callee to the specified value. 98 /// setCalledFunction(Value * V)99 void setCalledFunction(Value *V) { 100 assert(getInstruction() && "Not a call or invoke instruction!"); 101 *getCallee() = V; 102 } 103 104 /// isCallee - Determine whether the passed iterator points to the 105 /// callee operand's Use. isCallee(Value::const_user_iterator UI)106 bool isCallee(Value::const_user_iterator UI) const { 107 return isCallee(&UI.getUse()); 108 } 109 110 /// Determine whether this Use is the callee operand's Use. isCallee(const Use * U)111 bool isCallee(const Use *U) const { return getCallee() == U; } 112 getArgument(unsigned ArgNo)113 ValTy *getArgument(unsigned ArgNo) const { 114 assert(arg_begin() + ArgNo < arg_end() && "Argument # out of range!"); 115 return *(arg_begin() + ArgNo); 116 } 117 setArgument(unsigned ArgNo,Value * newVal)118 void setArgument(unsigned ArgNo, Value* newVal) { 119 assert(getInstruction() && "Not a call or invoke instruction!"); 120 assert(arg_begin() + ArgNo < arg_end() && "Argument # out of range!"); 121 getInstruction()->setOperand(ArgNo, newVal); 122 } 123 124 /// Given a value use iterator, returns the argument that corresponds to it. 125 /// Iterator must actually correspond to an argument. getArgumentNo(Value::const_user_iterator I)126 unsigned getArgumentNo(Value::const_user_iterator I) const { 127 return getArgumentNo(&I.getUse()); 128 } 129 130 /// Given a use for an argument, get the argument number that corresponds to 131 /// it. getArgumentNo(const Use * U)132 unsigned getArgumentNo(const Use *U) const { 133 assert(getInstruction() && "Not a call or invoke instruction!"); 134 assert(arg_begin() <= U && U < arg_end() 135 && "Argument # out of range!"); 136 return U - arg_begin(); 137 } 138 139 /// arg_iterator - The type of iterator to use when looping over actual 140 /// arguments at this call site. 141 typedef IterTy arg_iterator; 142 143 /// arg_begin/arg_end - Return iterators corresponding to the actual argument 144 /// list for a call site. arg_begin()145 IterTy arg_begin() const { 146 assert(getInstruction() && "Not a call or invoke instruction!"); 147 // Skip non-arguments 148 return (*this)->op_begin(); 149 } 150 arg_end()151 IterTy arg_end() const { return (*this)->op_end() - getArgumentEndOffset(); } arg_empty()152 bool arg_empty() const { return arg_end() == arg_begin(); } arg_size()153 unsigned arg_size() const { return unsigned(arg_end() - arg_begin()); } 154 155 /// getType - Return the type of the instruction that generated this call site 156 /// getType()157 Type *getType() const { return (*this)->getType(); } 158 159 /// getCaller - Return the caller function for this call site 160 /// getCaller()161 FunTy *getCaller() const { return (*this)->getParent()->getParent(); } 162 163 /// \brief Tests if this call site must be tail call optimized. Only a 164 /// CallInst can be tail call optimized. isMustTailCall()165 bool isMustTailCall() const { 166 return isCall() && cast<CallInst>(getInstruction())->isMustTailCall(); 167 } 168 169 /// \brief Tests if this call site is marked as a tail call. isTailCall()170 bool isTailCall() const { 171 return isCall() && cast<CallInst>(getInstruction())->isTailCall(); 172 } 173 174 #define CALLSITE_DELEGATE_GETTER(METHOD) \ 175 InstrTy *II = getInstruction(); \ 176 return isCall() \ 177 ? cast<CallInst>(II)->METHOD \ 178 : cast<InvokeInst>(II)->METHOD 179 180 #define CALLSITE_DELEGATE_SETTER(METHOD) \ 181 InstrTy *II = getInstruction(); \ 182 if (isCall()) \ 183 cast<CallInst>(II)->METHOD; \ 184 else \ 185 cast<InvokeInst>(II)->METHOD 186 187 /// getCallingConv/setCallingConv - get or set the calling convention of the 188 /// call. getCallingConv()189 CallingConv::ID getCallingConv() const { 190 CALLSITE_DELEGATE_GETTER(getCallingConv()); 191 } setCallingConv(CallingConv::ID CC)192 void setCallingConv(CallingConv::ID CC) { 193 CALLSITE_DELEGATE_SETTER(setCallingConv(CC)); 194 } 195 196 /// getAttributes/setAttributes - get or set the parameter attributes of 197 /// the call. getAttributes()198 const AttributeSet &getAttributes() const { 199 CALLSITE_DELEGATE_GETTER(getAttributes()); 200 } setAttributes(const AttributeSet & PAL)201 void setAttributes(const AttributeSet &PAL) { 202 CALLSITE_DELEGATE_SETTER(setAttributes(PAL)); 203 } 204 205 /// \brief Return true if this function has the given attribute. hasFnAttr(Attribute::AttrKind A)206 bool hasFnAttr(Attribute::AttrKind A) const { 207 CALLSITE_DELEGATE_GETTER(hasFnAttr(A)); 208 } 209 210 /// \brief Return true if the call or the callee has the given attribute. paramHasAttr(unsigned i,Attribute::AttrKind A)211 bool paramHasAttr(unsigned i, Attribute::AttrKind A) const { 212 CALLSITE_DELEGATE_GETTER(paramHasAttr(i, A)); 213 } 214 215 /// @brief Extract the alignment for a call or parameter (0=unknown). getParamAlignment(uint16_t i)216 uint16_t getParamAlignment(uint16_t i) const { 217 CALLSITE_DELEGATE_GETTER(getParamAlignment(i)); 218 } 219 220 /// @brief Extract the number of dereferenceable bytes for a call or 221 /// parameter (0=unknown). getDereferenceableBytes(uint16_t i)222 uint64_t getDereferenceableBytes(uint16_t i) const { 223 CALLSITE_DELEGATE_GETTER(getDereferenceableBytes(i)); 224 } 225 226 /// \brief Return true if the call should not be treated as a call to a 227 /// builtin. isNoBuiltin()228 bool isNoBuiltin() const { 229 CALLSITE_DELEGATE_GETTER(isNoBuiltin()); 230 } 231 232 /// @brief Return true if the call should not be inlined. isNoInline()233 bool isNoInline() const { 234 CALLSITE_DELEGATE_GETTER(isNoInline()); 235 } 236 void setIsNoInline(bool Value = true) { 237 CALLSITE_DELEGATE_SETTER(setIsNoInline(Value)); 238 } 239 240 /// @brief Determine if the call does not access memory. doesNotAccessMemory()241 bool doesNotAccessMemory() const { 242 CALLSITE_DELEGATE_GETTER(doesNotAccessMemory()); 243 } setDoesNotAccessMemory()244 void setDoesNotAccessMemory() { 245 CALLSITE_DELEGATE_SETTER(setDoesNotAccessMemory()); 246 } 247 248 /// @brief Determine if the call does not access or only reads memory. onlyReadsMemory()249 bool onlyReadsMemory() const { 250 CALLSITE_DELEGATE_GETTER(onlyReadsMemory()); 251 } setOnlyReadsMemory()252 void setOnlyReadsMemory() { 253 CALLSITE_DELEGATE_SETTER(setOnlyReadsMemory()); 254 } 255 256 /// @brief Determine if the call cannot return. doesNotReturn()257 bool doesNotReturn() const { 258 CALLSITE_DELEGATE_GETTER(doesNotReturn()); 259 } setDoesNotReturn()260 void setDoesNotReturn() { 261 CALLSITE_DELEGATE_SETTER(setDoesNotReturn()); 262 } 263 264 /// @brief Determine if the call cannot unwind. doesNotThrow()265 bool doesNotThrow() const { 266 CALLSITE_DELEGATE_GETTER(doesNotThrow()); 267 } setDoesNotThrow()268 void setDoesNotThrow() { 269 CALLSITE_DELEGATE_SETTER(setDoesNotThrow()); 270 } 271 272 #undef CALLSITE_DELEGATE_GETTER 273 #undef CALLSITE_DELEGATE_SETTER 274 275 /// @brief Determine whether this argument is not captured. doesNotCapture(unsigned ArgNo)276 bool doesNotCapture(unsigned ArgNo) const { 277 return paramHasAttr(ArgNo + 1, Attribute::NoCapture); 278 } 279 280 /// @brief Determine whether this argument is passed by value. isByValArgument(unsigned ArgNo)281 bool isByValArgument(unsigned ArgNo) const { 282 return paramHasAttr(ArgNo + 1, Attribute::ByVal); 283 } 284 285 /// @brief Determine whether this argument is passed in an alloca. isInAllocaArgument(unsigned ArgNo)286 bool isInAllocaArgument(unsigned ArgNo) const { 287 return paramHasAttr(ArgNo + 1, Attribute::InAlloca); 288 } 289 290 /// @brief Determine whether this argument is passed by value or in an alloca. isByValOrInAllocaArgument(unsigned ArgNo)291 bool isByValOrInAllocaArgument(unsigned ArgNo) const { 292 return paramHasAttr(ArgNo + 1, Attribute::ByVal) || 293 paramHasAttr(ArgNo + 1, Attribute::InAlloca); 294 } 295 296 /// @brief Determine if there are is an inalloca argument. Only the last 297 /// argument can have the inalloca attribute. hasInAllocaArgument()298 bool hasInAllocaArgument() const { 299 return paramHasAttr(arg_size(), Attribute::InAlloca); 300 } 301 doesNotAccessMemory(unsigned ArgNo)302 bool doesNotAccessMemory(unsigned ArgNo) const { 303 return paramHasAttr(ArgNo + 1, Attribute::ReadNone); 304 } 305 onlyReadsMemory(unsigned ArgNo)306 bool onlyReadsMemory(unsigned ArgNo) const { 307 return paramHasAttr(ArgNo + 1, Attribute::ReadOnly) || 308 paramHasAttr(ArgNo + 1, Attribute::ReadNone); 309 } 310 311 /// @brief Return true if the return value is known to be not null. 312 /// This may be because it has the nonnull attribute, or because at least 313 /// one byte is dereferenceable and the pointer is in addrspace(0). isReturnNonNull()314 bool isReturnNonNull() const { 315 if (paramHasAttr(0, Attribute::NonNull)) 316 return true; 317 else if (getDereferenceableBytes(0) > 0 && 318 getType()->getPointerAddressSpace() == 0) 319 return true; 320 321 return false; 322 } 323 324 /// hasArgument - Returns true if this CallSite passes the given Value* as an 325 /// argument to the called function. hasArgument(const Value * Arg)326 bool hasArgument(const Value *Arg) const { 327 for (arg_iterator AI = this->arg_begin(), E = this->arg_end(); AI != E; 328 ++AI) 329 if (AI->get() == Arg) 330 return true; 331 return false; 332 } 333 334 private: getArgumentEndOffset()335 unsigned getArgumentEndOffset() const { 336 if (isCall()) 337 return 1; // Skip Callee 338 else 339 return 3; // Skip BB, BB, Callee 340 } 341 getCallee()342 IterTy getCallee() const { 343 if (isCall()) // Skip Callee 344 return cast<CallInst>(getInstruction())->op_end() - 1; 345 else // Skip BB, BB, Callee 346 return cast<InvokeInst>(getInstruction())->op_end() - 3; 347 } 348 }; 349 350 class CallSite : public CallSiteBase<Function, Value, User, Instruction, 351 CallInst, InvokeInst, User::op_iterator> { 352 typedef CallSiteBase<Function, Value, User, Instruction, 353 CallInst, InvokeInst, User::op_iterator> Base; 354 public: CallSite()355 CallSite() {} CallSite(Base B)356 CallSite(Base B) : Base(B) {} CallSite(Value * V)357 CallSite(Value* V) : Base(V) {} CallSite(CallInst * CI)358 CallSite(CallInst *CI) : Base(CI) {} CallSite(InvokeInst * II)359 CallSite(InvokeInst *II) : Base(II) {} CallSite(Instruction * II)360 CallSite(Instruction *II) : Base(II) {} 361 362 bool operator==(const CallSite &CS) const { return I == CS.I; } 363 bool operator!=(const CallSite &CS) const { return I != CS.I; } 364 bool operator<(const CallSite &CS) const { 365 return getInstruction() < CS.getInstruction(); 366 } 367 368 private: 369 User::op_iterator getCallee() const; 370 }; 371 372 /// ImmutableCallSite - establish a view to a call site for examination 373 class ImmutableCallSite : public CallSiteBase<> { 374 typedef CallSiteBase<> Base; 375 public: ImmutableCallSite(const Value * V)376 ImmutableCallSite(const Value* V) : Base(V) {} ImmutableCallSite(const CallInst * CI)377 ImmutableCallSite(const CallInst *CI) : Base(CI) {} ImmutableCallSite(const InvokeInst * II)378 ImmutableCallSite(const InvokeInst *II) : Base(II) {} ImmutableCallSite(const Instruction * II)379 ImmutableCallSite(const Instruction *II) : Base(II) {} ImmutableCallSite(CallSite CS)380 ImmutableCallSite(CallSite CS) : Base(CS.getInstruction()) {} 381 }; 382 383 } // End llvm namespace 384 385 #endif 386