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 Return true if the call should not be treated as a call to a 221 /// builtin. isNoBuiltin()222 bool isNoBuiltin() const { 223 CALLSITE_DELEGATE_GETTER(isNoBuiltin()); 224 } 225 226 /// @brief Return true if the call should not be inlined. isNoInline()227 bool isNoInline() const { 228 CALLSITE_DELEGATE_GETTER(isNoInline()); 229 } 230 void setIsNoInline(bool Value = true) { 231 CALLSITE_DELEGATE_SETTER(setIsNoInline(Value)); 232 } 233 234 /// @brief Determine if the call does not access memory. doesNotAccessMemory()235 bool doesNotAccessMemory() const { 236 CALLSITE_DELEGATE_GETTER(doesNotAccessMemory()); 237 } setDoesNotAccessMemory()238 void setDoesNotAccessMemory() { 239 CALLSITE_DELEGATE_SETTER(setDoesNotAccessMemory()); 240 } 241 242 /// @brief Determine if the call does not access or only reads memory. onlyReadsMemory()243 bool onlyReadsMemory() const { 244 CALLSITE_DELEGATE_GETTER(onlyReadsMemory()); 245 } setOnlyReadsMemory()246 void setOnlyReadsMemory() { 247 CALLSITE_DELEGATE_SETTER(setOnlyReadsMemory()); 248 } 249 250 /// @brief Determine if the call cannot return. doesNotReturn()251 bool doesNotReturn() const { 252 CALLSITE_DELEGATE_GETTER(doesNotReturn()); 253 } setDoesNotReturn()254 void setDoesNotReturn() { 255 CALLSITE_DELEGATE_SETTER(setDoesNotReturn()); 256 } 257 258 /// @brief Determine if the call cannot unwind. doesNotThrow()259 bool doesNotThrow() const { 260 CALLSITE_DELEGATE_GETTER(doesNotThrow()); 261 } setDoesNotThrow()262 void setDoesNotThrow() { 263 CALLSITE_DELEGATE_SETTER(setDoesNotThrow()); 264 } 265 266 #undef CALLSITE_DELEGATE_GETTER 267 #undef CALLSITE_DELEGATE_SETTER 268 269 /// @brief Determine whether this argument is not captured. doesNotCapture(unsigned ArgNo)270 bool doesNotCapture(unsigned ArgNo) const { 271 return paramHasAttr(ArgNo + 1, Attribute::NoCapture); 272 } 273 274 /// @brief Determine whether this argument is passed by value. isByValArgument(unsigned ArgNo)275 bool isByValArgument(unsigned ArgNo) const { 276 return paramHasAttr(ArgNo + 1, Attribute::ByVal); 277 } 278 279 /// @brief Determine whether this argument is passed in an alloca. isInAllocaArgument(unsigned ArgNo)280 bool isInAllocaArgument(unsigned ArgNo) const { 281 return paramHasAttr(ArgNo + 1, Attribute::InAlloca); 282 } 283 284 /// @brief Determine whether this argument is passed by value or in an alloca. isByValOrInAllocaArgument(unsigned ArgNo)285 bool isByValOrInAllocaArgument(unsigned ArgNo) const { 286 return paramHasAttr(ArgNo + 1, Attribute::ByVal) || 287 paramHasAttr(ArgNo + 1, Attribute::InAlloca); 288 } 289 290 /// @brief Determine if there are is an inalloca argument. Only the last 291 /// argument can have the inalloca attribute. hasInAllocaArgument()292 bool hasInAllocaArgument() const { 293 return paramHasAttr(arg_size(), Attribute::InAlloca); 294 } 295 doesNotAccessMemory(unsigned ArgNo)296 bool doesNotAccessMemory(unsigned ArgNo) const { 297 return paramHasAttr(ArgNo + 1, Attribute::ReadNone); 298 } 299 onlyReadsMemory(unsigned ArgNo)300 bool onlyReadsMemory(unsigned ArgNo) const { 301 return paramHasAttr(ArgNo + 1, Attribute::ReadOnly) || 302 paramHasAttr(ArgNo + 1, Attribute::ReadNone); 303 } 304 305 /// hasArgument - Returns true if this CallSite passes the given Value* as an 306 /// argument to the called function. hasArgument(const Value * Arg)307 bool hasArgument(const Value *Arg) const { 308 for (arg_iterator AI = this->arg_begin(), E = this->arg_end(); AI != E; 309 ++AI) 310 if (AI->get() == Arg) 311 return true; 312 return false; 313 } 314 315 private: getArgumentEndOffset()316 unsigned getArgumentEndOffset() const { 317 if (isCall()) 318 return 1; // Skip Callee 319 else 320 return 3; // Skip BB, BB, Callee 321 } 322 getCallee()323 IterTy getCallee() const { 324 if (isCall()) // Skip Callee 325 return cast<CallInst>(getInstruction())->op_end() - 1; 326 else // Skip BB, BB, Callee 327 return cast<InvokeInst>(getInstruction())->op_end() - 3; 328 } 329 }; 330 331 class CallSite : public CallSiteBase<Function, Value, User, Instruction, 332 CallInst, InvokeInst, User::op_iterator> { 333 typedef CallSiteBase<Function, Value, User, Instruction, 334 CallInst, InvokeInst, User::op_iterator> Base; 335 public: CallSite()336 CallSite() {} CallSite(Base B)337 CallSite(Base B) : Base(B) {} CallSite(Value * V)338 CallSite(Value* V) : Base(V) {} CallSite(CallInst * CI)339 CallSite(CallInst *CI) : Base(CI) {} CallSite(InvokeInst * II)340 CallSite(InvokeInst *II) : Base(II) {} CallSite(Instruction * II)341 CallSite(Instruction *II) : Base(II) {} 342 343 bool operator==(const CallSite &CS) const { return I == CS.I; } 344 bool operator!=(const CallSite &CS) const { return I != CS.I; } 345 bool operator<(const CallSite &CS) const { 346 return getInstruction() < CS.getInstruction(); 347 } 348 349 private: 350 User::op_iterator getCallee() const; 351 }; 352 353 /// ImmutableCallSite - establish a view to a call site for examination 354 class ImmutableCallSite : public CallSiteBase<> { 355 typedef CallSiteBase<> Base; 356 public: ImmutableCallSite(const Value * V)357 ImmutableCallSite(const Value* V) : Base(V) {} ImmutableCallSite(const CallInst * CI)358 ImmutableCallSite(const CallInst *CI) : Base(CI) {} ImmutableCallSite(const InvokeInst * II)359 ImmutableCallSite(const InvokeInst *II) : Base(II) {} ImmutableCallSite(const Instruction * II)360 ImmutableCallSite(const Instruction *II) : Base(II) {} ImmutableCallSite(CallSite CS)361 ImmutableCallSite(CallSite CS) : Base(CS.getInstruction()) {} 362 }; 363 364 } // End llvm namespace 365 366 #endif 367