CallSite.h revision 08e78b18b8ef2c939ee95469662c98e23846d860
1//===-- llvm/Support/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. 12// 13// NOTE: This class is supposed to have "value semantics". So it should be 14// passed by value, not by reference; it should not be "new"ed or "delete"d. It 15// is efficiently copyable, assignable and constructable, with cost equivalent 16// to copying a pointer (notice that it has only a single data member). 17// 18//===----------------------------------------------------------------------===// 19 20#ifndef LLVM_SUPPORT_CALLSITE_H 21#define LLVM_SUPPORT_CALLSITE_H 22 23#include "llvm/Instruction.h" 24#include "llvm/BasicBlock.h" 25#include "llvm/ParameterAttributes.h" 26 27namespace llvm { 28 29class CallInst; 30class InvokeInst; 31class ParamAttrsList; 32 33class CallSite { 34 Instruction *I; 35public: 36 CallSite() : I(0) {} 37 CallSite(CallInst *CI) : I(reinterpret_cast<Instruction*>(CI)) {} 38 CallSite(InvokeInst *II) : I(reinterpret_cast<Instruction*>(II)) {} 39 CallSite(Instruction *C); 40 CallSite(const CallSite &CS) : I(CS.I) {} 41 CallSite &operator=(const CallSite &CS) { I = CS.I; return *this; } 42 43 /// CallSite::get - This static method is sort of like a constructor. It will 44 /// create an appropriate call site for a Call or Invoke instruction, but it 45 /// can also create a null initialized CallSite object for something which is 46 /// NOT a call site. 47 /// 48 static CallSite get(Value *V) { 49 if (Instruction *I = dyn_cast<Instruction>(V)) { 50 if (I->getOpcode() == Instruction::Call) 51 return CallSite(reinterpret_cast<CallInst*>(I)); 52 else if (I->getOpcode() == Instruction::Invoke) 53 return CallSite(reinterpret_cast<InvokeInst*>(I)); 54 } 55 return CallSite(); 56 } 57 58 /// getCallingConv/setCallingConv - get or set the calling convention of the 59 /// call. 60 unsigned getCallingConv() const; 61 void setCallingConv(unsigned CC); 62 63 /// getParamAttrs/setParamAttrs - get or set the parameter attributes of 64 /// the call. 65 const ParamAttrsList *getParamAttrs() const; 66 void setParamAttrs(const ParamAttrsList *PAL); 67 68 /// paramHasAttr - whether the call or the callee has the given attribute. 69 bool paramHasAttr(uint16_t i, ParameterAttributes attr) const; 70 71 /// @brief Extract the alignment for a call or parameter (0=unknown). 72 uint16_t getParamAlignment(uint16_t i) const; 73 74 /// @brief Determine if the call does not access memory. 75 bool doesNotAccessMemory() const; 76 77 /// @brief Determine if the call does not access or only reads memory. 78 bool onlyReadsMemory() const; 79 80 /// @brief Determine if the call cannot unwind. 81 bool doesNotThrow() const; 82 void setDoesNotThrow(bool doesNotThrow = true); 83 84 /// getType - Return the type of the instruction that generated this call site 85 /// 86 const Type *getType() const { return I->getType(); } 87 88 /// getInstruction - Return the instruction this call site corresponds to 89 /// 90 Instruction *getInstruction() const { return I; } 91 92 /// getCaller - Return the caller function for this call site 93 /// 94 Function *getCaller() const { return I->getParent()->getParent(); } 95 96 /// getCalledValue - Return the pointer to function that is being called... 97 /// 98 Value *getCalledValue() const { 99 assert(I && "Not a call or invoke instruction!"); 100 return I->getOperand(0); 101 } 102 103 /// getCalledFunction - Return the function being called if this is a direct 104 /// call, otherwise return null (if it's an indirect call). 105 /// 106 Function *getCalledFunction() const { 107 return dyn_cast<Function>(getCalledValue()); 108 } 109 110 /// setCalledFunction - Set the callee to the specified value... 111 /// 112 void setCalledFunction(Value *V) { 113 assert(I && "Not a call or invoke instruction!"); 114 I->setOperand(0, V); 115 } 116 117 Value *getArgument(unsigned ArgNo) const { 118 assert(arg_begin() + ArgNo < arg_end() && "Argument # out of range!"); 119 return *(arg_begin()+ArgNo); 120 } 121 122 void setArgument(unsigned ArgNo, Value* newVal) { 123 assert(I && "Not a call or invoke instruction!"); 124 assert(arg_begin() + ArgNo < arg_end() && "Argument # out of range!"); 125 if (I->getOpcode() == Instruction::Call) 126 I->setOperand(ArgNo+1, newVal); // Skip Function 127 else 128 I->setOperand(ArgNo+3, newVal); // Skip Function, BB, BB 129 } 130 131 /// arg_iterator - The type of iterator to use when looping over actual 132 /// arguments at this call site... 133 typedef User::op_iterator arg_iterator; 134 135 /// arg_begin/arg_end - Return iterators corresponding to the actual argument 136 /// list for a call site. 137 /// 138 arg_iterator arg_begin() const { 139 assert(I && "Not a call or invoke instruction!"); 140 if (I->getOpcode() == Instruction::Call) 141 return I->op_begin()+1; // Skip Function 142 else 143 return I->op_begin()+3; // Skip Function, BB, BB 144 } 145 arg_iterator arg_end() const { return I->op_end(); } 146 bool arg_empty() const { return arg_end() == arg_begin(); } 147 unsigned arg_size() const { return unsigned(arg_end() - arg_begin()); } 148 149 bool operator<(const CallSite &CS) const { 150 return getInstruction() < CS.getInstruction(); 151 } 152}; 153 154} // End llvm namespace 155 156#endif 157