CallSite.h revision ece2c04d532d46405c085769d03173b392813eb3
1//===-- llvm/Support/CallSite.h - Abstract Call & Invoke instrs -*- C++ -*-===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file was developed by the LLVM research group and is distributed under 6// the University of Illinois Open Source 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(const CallSite &CS) : I(CS.I) {} 40 CallSite &operator=(const CallSite &CS) { I = CS.I; return *this; } 41 42 /// CallSite::get - This static method is sort of like a constructor. It will 43 /// create an appropriate call site for a Call or Invoke instruction, but it 44 /// can also create a null initialized CallSite object for something which is 45 /// NOT a call site. 46 /// 47 static CallSite get(Value *V) { 48 if (Instruction *I = dyn_cast<Instruction>(V)) { 49 if (I->getOpcode() == Instruction::Call) 50 return CallSite(reinterpret_cast<CallInst*>(I)); 51 else if (I->getOpcode() == Instruction::Invoke) 52 return CallSite(reinterpret_cast<InvokeInst*>(I)); 53 } 54 return CallSite(); 55 } 56 57 /// getCallingConv/setCallingConv - get or set the calling convention of the 58 /// call. 59 unsigned getCallingConv() const; 60 void setCallingConv(unsigned CC); 61 62 /// getParamAttrs/setParamAttrs - get or set the parameter attributes of 63 /// the call. 64 const ParamAttrsList *getParamAttrs() const; 65 void setParamAttrs(const ParamAttrsList *PAL); 66 67 /// paramHasAttr - whether the call or the callee has the given attribute. 68 bool paramHasAttr(uint16_t i, ParameterAttributes attr) const; 69 70 /// @brief Determine if the call does not access memory. 71 bool doesNotAccessMemory() const; 72 73 /// @brief Determine if the call does not access or only reads memory. 74 bool onlyReadsMemory() const; 75 76 /// @brief Determine if the call cannot unwind. 77 bool isNoUnwind() const; 78 79 /// getType - Return the type of the instruction that generated this call site 80 /// 81 const Type *getType() const { return I->getType(); } 82 83 /// getInstruction - Return the instruction this call site corresponds to 84 /// 85 Instruction *getInstruction() const { return I; } 86 87 /// getCaller - Return the caller function for this call site 88 /// 89 Function *getCaller() const { return I->getParent()->getParent(); } 90 91 /// getCalledValue - Return the pointer to function that is being called... 92 /// 93 Value *getCalledValue() const { 94 assert(I && "Not a call or invoke instruction!"); 95 return I->getOperand(0); 96 } 97 98 /// getCalledFunction - Return the function being called if this is a direct 99 /// call, otherwise return null (if it's an indirect call). 100 /// 101 Function *getCalledFunction() const { 102 return dyn_cast<Function>(getCalledValue()); 103 } 104 105 /// setCalledFunction - Set the callee to the specified value... 106 /// 107 void setCalledFunction(Value *V) { 108 assert(I && "Not a call or invoke instruction!"); 109 I->setOperand(0, V); 110 } 111 112 Value *getArgument(unsigned ArgNo) const { 113 assert(arg_begin() + ArgNo < arg_end() && "Argument # out of range!"); 114 return *(arg_begin()+ArgNo); 115 } 116 117 /// arg_iterator - The type of iterator to use when looping over actual 118 /// arguments at this call site... 119 typedef User::op_iterator arg_iterator; 120 121 /// arg_begin/arg_end - Return iterators corresponding to the actual argument 122 /// list for a call site. 123 /// 124 arg_iterator arg_begin() const { 125 assert(I && "Not a call or invoke instruction!"); 126 if (I->getOpcode() == Instruction::Call) 127 return I->op_begin()+1; // Skip Function 128 else 129 return I->op_begin()+3; // Skip Function, BB, BB 130 } 131 arg_iterator arg_end() const { return I->op_end(); } 132 bool arg_empty() const { return arg_end() == arg_begin(); } 133 unsigned arg_size() const { return unsigned(arg_end() - arg_begin()); } 134 135 bool operator<(const CallSite &CS) const { 136 return getInstruction() < CS.getInstruction(); 137 } 138}; 139 140} // End llvm namespace 141 142#endif 143