1 //===- LibCallSemantics.h - Describe library semantics --------------------===// 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 interfaces that can be used to describe language specific 11 // runtime library interfaces (e.g. libc, libm, etc) to LLVM optimizers. 12 // 13 //===----------------------------------------------------------------------===// 14 15 #ifndef LLVM_ANALYSIS_LIBCALLSEMANTICS_H 16 #define LLVM_ANALYSIS_LIBCALLSEMANTICS_H 17 18 #include "llvm/Analysis/AliasAnalysis.h" 19 20 namespace llvm { 21 class InvokeInst; 22 23 /// LibCallLocationInfo - This struct describes a set of memory locations that 24 /// are accessed by libcalls. Identification of a location is doing with a 25 /// simple callback function. 26 /// 27 /// For example, the LibCallInfo may be set up to model the behavior of 28 /// standard libm functions. The location that they may be interested in is 29 /// an abstract location that represents errno for the current target. In 30 /// this case, a location for errno is anything such that the predicate 31 /// returns true. On Mac OS X, this predicate would return true if the 32 /// pointer is the result of a call to "__error()". 33 /// 34 /// Locations can also be defined in a constant-sensitive way. For example, 35 /// it is possible to define a location that returns true iff it is passed 36 /// into the call as a specific argument. This is useful for modeling things 37 /// like "printf", which can store to memory, but only through pointers passed 38 /// with a '%n' constraint. 39 /// 40 struct LibCallLocationInfo { 41 // TODO: Flags: isContextSensitive etc. 42 43 /// isLocation - Return a LocResult if the specified pointer refers to this 44 /// location for the specified call site. This returns "Yes" if we can tell 45 /// that the pointer *does definitely* refer to the location, "No" if we can 46 /// tell that the location *definitely does not* refer to the location, and 47 /// returns "Unknown" if we cannot tell for certain. 48 enum LocResult { 49 Yes, No, Unknown 50 }; 51 LocResult (*isLocation)(ImmutableCallSite CS, const MemoryLocation &Loc); 52 }; 53 54 /// LibCallFunctionInfo - Each record in the array of FunctionInfo structs 55 /// records the behavior of one libcall that is known by the optimizer. This 56 /// captures things like the side effects of the call. Side effects are 57 /// modeled both universally (in the readnone/readonly) sense, but also 58 /// potentially against a set of abstract locations defined by the optimizer. 59 /// This allows an optimizer to define that some libcall (e.g. sqrt) is 60 /// side-effect free except that it might modify errno (thus, the call is 61 /// *not* universally readonly). Or it might say that the side effects 62 /// are unknown other than to say that errno is not modified. 63 /// 64 struct LibCallFunctionInfo { 65 /// Name - This is the name of the libcall this describes. 66 const char *Name; 67 68 /// TODO: Constant folding function: Constant* vector -> Constant*. 69 70 /// UniversalBehavior - This captures the absolute mod/ref behavior without 71 /// any specific context knowledge. For example, if the function is known 72 /// to be readonly, this would be set to 'ref'. If known to be readnone, 73 /// this is set to NoModRef. 74 AliasAnalysis::ModRefResult UniversalBehavior; 75 76 /// LocationMRInfo - This pair captures info about whether a specific 77 /// location is modified or referenced by a libcall. 78 struct LocationMRInfo { 79 /// LocationID - ID # of the accessed location or ~0U for array end. 80 unsigned LocationID; 81 /// MRInfo - Mod/Ref info for this location. 82 AliasAnalysis::ModRefResult MRInfo; 83 }; 84 85 /// DetailsType - Indicate the sense of the LocationDetails array. This 86 /// controls how the LocationDetails array is interpreted. 87 enum { 88 /// DoesOnly - If DetailsType is set to DoesOnly, then we know that the 89 /// *only* mod/ref behavior of this function is captured by the 90 /// LocationDetails array. If we are trying to say that 'sqrt' can only 91 /// modify errno, we'd have the {errnoloc,mod} in the LocationDetails 92 /// array and have DetailsType set to DoesOnly. 93 DoesOnly, 94 95 /// DoesNot - If DetailsType is set to DoesNot, then the sense of the 96 /// LocationDetails array is completely inverted. This means that we *do 97 /// not* know everything about the side effects of this libcall, but we do 98 /// know things that the libcall cannot do. This is useful for complex 99 /// functions like 'ctime' which have crazy mod/ref behavior, but are 100 /// known to never read or write errno. In this case, we'd have 101 /// {errnoloc,modref} in the LocationDetails array and DetailsType would 102 /// be set to DoesNot, indicating that ctime does not read or write the 103 /// errno location. 104 DoesNot 105 } DetailsType; 106 107 /// LocationDetails - This is a pointer to an array of LocationMRInfo 108 /// structs which indicates the behavior of the libcall w.r.t. specific 109 /// locations. For example, if this libcall is known to only modify 110 /// 'errno', it would have a LocationDetails array with the errno ID and 111 /// 'mod' in it. See the DetailsType field for how this is interpreted. 112 /// 113 /// In the "DoesOnly" case, this information is 'may' information for: there 114 /// is no guarantee that the specified side effect actually does happen, 115 /// just that it could. In the "DoesNot" case, this is 'must not' info. 116 /// 117 /// If this pointer is null, no details are known. 118 /// 119 const LocationMRInfo *LocationDetails; 120 }; 121 122 123 /// LibCallInfo - Abstract interface to query about library call information. 124 /// Instances of this class return known information about some set of 125 /// libcalls. 126 /// 127 class LibCallInfo { 128 // Implementation details of this object, private. 129 mutable void *Impl; 130 mutable const LibCallLocationInfo *Locations; 131 mutable unsigned NumLocations; 132 public: LibCallInfo()133 LibCallInfo() : Impl(nullptr), Locations(nullptr), NumLocations(0) {} 134 virtual ~LibCallInfo(); 135 136 //===------------------------------------------------------------------===// 137 // Accessor Methods: Efficient access to contained data. 138 //===------------------------------------------------------------------===// 139 140 /// getLocationInfo - Return information about the specified LocationID. 141 const LibCallLocationInfo &getLocationInfo(unsigned LocID) const; 142 143 144 /// getFunctionInfo - Return the LibCallFunctionInfo object corresponding to 145 /// the specified function if we have it. If not, return null. 146 const LibCallFunctionInfo *getFunctionInfo(const Function *F) const; 147 148 149 //===------------------------------------------------------------------===// 150 // Implementation Methods: Subclasses should implement these. 151 //===------------------------------------------------------------------===// 152 153 /// getLocationInfo - Return descriptors for the locations referenced by 154 /// this set of libcalls. getLocationInfo(const LibCallLocationInfo * & Array)155 virtual unsigned getLocationInfo(const LibCallLocationInfo *&Array) const { 156 return 0; 157 } 158 159 /// getFunctionInfoArray - Return an array of descriptors that describe the 160 /// set of libcalls represented by this LibCallInfo object. This array is 161 /// terminated by an entry with a NULL name. 162 virtual const LibCallFunctionInfo *getFunctionInfoArray() const = 0; 163 }; 164 165 enum class EHPersonality { 166 Unknown, 167 GNU_Ada, 168 GNU_C, 169 GNU_CXX, 170 GNU_ObjC, 171 MSVC_X86SEH, 172 MSVC_Win64SEH, 173 MSVC_CXX, 174 }; 175 176 /// \brief See if the given exception handling personality function is one 177 /// that we understand. If so, return a description of it; otherwise return 178 /// Unknown. 179 EHPersonality classifyEHPersonality(const Value *Pers); 180 181 /// \brief Returns true if this personality function catches asynchronous 182 /// exceptions. isAsynchronousEHPersonality(EHPersonality Pers)183 inline bool isAsynchronousEHPersonality(EHPersonality Pers) { 184 // The two SEH personality functions can catch asynch exceptions. We assume 185 // unknown personalities don't catch asynch exceptions. 186 switch (Pers) { 187 case EHPersonality::MSVC_X86SEH: 188 case EHPersonality::MSVC_Win64SEH: 189 return true; 190 default: return false; 191 } 192 llvm_unreachable("invalid enum"); 193 } 194 195 /// \brief Returns true if this is an MSVC personality function. isMSVCEHPersonality(EHPersonality Pers)196 inline bool isMSVCEHPersonality(EHPersonality Pers) { 197 // The two SEH personality functions can catch asynch exceptions. We assume 198 // unknown personalities don't catch asynch exceptions. 199 switch (Pers) { 200 case EHPersonality::MSVC_CXX: 201 case EHPersonality::MSVC_X86SEH: 202 case EHPersonality::MSVC_Win64SEH: 203 return true; 204 default: return false; 205 } 206 llvm_unreachable("invalid enum"); 207 } 208 209 /// \brief Return true if this personality may be safely removed if there 210 /// are no invoke instructions remaining in the current function. isNoOpWithoutInvoke(EHPersonality Pers)211 inline bool isNoOpWithoutInvoke(EHPersonality Pers) { 212 switch (Pers) { 213 case EHPersonality::Unknown: 214 return false; 215 // All known personalities currently have this behavior 216 default: return true; 217 } 218 llvm_unreachable("invalid enum"); 219 } 220 221 bool canSimplifyInvokeNoUnwind(const Function *F); 222 223 } // end namespace llvm 224 225 #endif 226