TargetLibraryInfo.h revision 243eb9ecbbc6775e346e94025bd255bbceac9fca
1//===-- llvm/Target/TargetLibraryInfo.h - Library information ---*- 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#ifndef LLVM_TARGET_TARGETLIBRARYINFO_H 11#define LLVM_TARGET_TARGETLIBRARYINFO_H 12 13#include "llvm/Pass.h" 14#include "llvm/ADT/DenseMap.h" 15 16namespace llvm { 17 class Triple; 18 19 namespace LibFunc { 20 enum Func { 21 /// double acos(double x); 22 acos, 23 /// long double acosl(long double x); 24 acosl, 25 /// float acosf(float x); 26 acosf, 27 /// double asin(double x); 28 asin, 29 /// long double asinl(long double x); 30 asinl, 31 /// float asinf(float x); 32 asinf, 33 /// double atan(double x); 34 atan, 35 /// long double atanl(long double x); 36 atanl, 37 /// float atanf(float x); 38 atanf, 39 /// double atan2(double y, double x); 40 atan2, 41 /// long double atan2l(long double y, long double x); 42 atan2l, 43 /// float atan2f(float y, float x); 44 atan2f, 45 /// double ceil(double x); 46 ceil, 47 /// long double ceill(long double x); 48 ceill, 49 /// float ceilf(float x); 50 ceilf, 51 /// double copysign(double x, double y); 52 copysign, 53 /// float copysignf(float x, float y); 54 copysignf, 55 /// long double copysignl(long double x, long double y); 56 copysignl, 57 /// double cos(double x); 58 cos, 59 /// long double cosl(long double x); 60 cosl, 61 /// float cosf(float x); 62 cosf, 63 /// double cosh(double x); 64 cosh, 65 /// long double coshl(long double x); 66 coshl, 67 /// float coshf(float x); 68 coshf, 69 /// double exp(double x); 70 exp, 71 /// long double expl(long double x); 72 expl, 73 /// float expf(float x); 74 expf, 75 /// double exp2(double x); 76 exp2, 77 /// long double exp2l(long double x); 78 exp2l, 79 /// float exp2f(float x); 80 exp2f, 81 /// double expm1(double x); 82 expm1, 83 /// long double expm1l(long double x); 84 expm1l, 85 /// float expm1f(float x); 86 expl1f, 87 /// double fabs(double x); 88 fabs, 89 /// long double fabsl(long double x); 90 fabsl, 91 /// float fabsf(float x); 92 fabsf, 93 /// double floor(double x); 94 floor, 95 /// long double floorl(long double x); 96 floorl, 97 /// float floorf(float x); 98 floorf, 99 /// int fiprintf(FILE *stream, const char *format, ...); 100 fiprintf, 101 /// double fmod(double x, double y); 102 fmod, 103 /// long double fmodl(long double x, long double y); 104 fmodl, 105 /// float fmodf(float x, float y); 106 fmodf, 107 /// int fputs(const char *s, FILE *stream); 108 fputs, 109 /// size_t fwrite(const void *ptr, size_t size, size_t nitems, 110 /// FILE *stream); 111 fwrite, 112 /// int iprintf(const char *format, ...); 113 iprintf, 114 /// double log(double x); 115 log, 116 /// long double logl(long double x); 117 logl, 118 /// float logf(float x); 119 logf, 120 /// double log2(double x); 121 log2, 122 /// double long double log2l(long double x); 123 log2l, 124 /// float log2f(float x); 125 log2f, 126 /// double log10(double x); 127 log10, 128 /// long double log10l(long double x); 129 log10l, 130 /// float log10f(float x); 131 log10f, 132 /// double log1p(double x); 133 log1p, 134 /// long double log1pl(long double x); 135 log1pl, 136 /// float log1pf(float x); 137 log1pf, 138 /// void *memcpy(void *s1, const void *s2, size_t n); 139 memcpy, 140 /// void *memmove(void *s1, const void *s2, size_t n); 141 memmove, 142 /// void *memset(void *b, int c, size_t len); 143 memset, 144 /// void memset_pattern16(void *b, const void *pattern16, size_t len); 145 memset_pattern16, 146 /// double nearbyint(double x); 147 nearbyint, 148 /// float nearbyintf(float x); 149 nearbyintf, 150 /// long double nearbyintl(long double x); 151 nearbyintl, 152 /// double pow(double x, double y); 153 pow, 154 /// float powf(float x, float y); 155 powf, 156 /// long double powl(long double x, long double y); 157 powl, 158 /// double rint(double x); 159 rint, 160 /// float rintf(float x); 161 rintf, 162 /// long dobule rintl(long double x); 163 rintl, 164 /// double sin(double x); 165 sin, 166 /// long double sinl(long double x); 167 sinl, 168 /// float sinf(float x); 169 sinf, 170 /// double sinh(double x); 171 sinh, 172 /// long double sinhl(long double x); 173 sinhl, 174 /// float sinhf(float x); 175 sinhf, 176 /// int siprintf(char *str, const char *format, ...); 177 siprintf, 178 /// double sqrt(double x); 179 sqrt, 180 /// long double sqrtl(long double x); 181 sqrtl, 182 /// float sqrtf(float x); 183 sqrtf, 184 /// double tan(double x); 185 tan, 186 /// long double tanl(long double x); 187 tanl, 188 /// float tanf(float x); 189 tanf, 190 /// double tanh(double x); 191 tanh, 192 /// long double tanhl(long double x); 193 tanhl, 194 /// float tanhf(float x); 195 tanhf, 196 /// double trunc(double x); 197 trunc, 198 /// float truncf(float x); 199 truncf, 200 /// long double truncl(long double x); 201 truncl, 202 203 NumLibFuncs 204 }; 205 } 206 207/// TargetLibraryInfo - This immutable pass captures information about what 208/// library functions are available for the current target, and allows a 209/// frontend to disable optimizations through -fno-builtin etc. 210class TargetLibraryInfo : public ImmutablePass { 211 unsigned char AvailableArray[(LibFunc::NumLibFuncs+3)/4]; 212 llvm::DenseMap<unsigned, std::string> CustomNames; 213 static const char* StandardNames[LibFunc::NumLibFuncs]; 214 215 enum AvailabilityState { 216 StandardName = 3, // (memset to all ones) 217 CustomName = 1, 218 Unavailable = 0 // (memset to all zeros) 219 }; 220 void setState(LibFunc::Func F, AvailabilityState State) { 221 AvailableArray[F/4] &= ~(3 << 2*(F&3)); 222 AvailableArray[F/4] |= State << 2*(F&3); 223 } 224 AvailabilityState getState(LibFunc::Func F) const { 225 return static_cast<AvailabilityState>((AvailableArray[F/4] >> 2*(F&3)) & 3); 226 } 227 228public: 229 static char ID; 230 TargetLibraryInfo(); 231 TargetLibraryInfo(const Triple &T); 232 explicit TargetLibraryInfo(const TargetLibraryInfo &TLI); 233 234 /// has - This function is used by optimizations that want to match on or form 235 /// a given library function. 236 bool has(LibFunc::Func F) const { 237 return getState(F) != Unavailable; 238 } 239 240 StringRef getName(LibFunc::Func F) const { 241 AvailabilityState State = getState(F); 242 if (State == Unavailable) 243 return StringRef(); 244 if (State == StandardName) 245 return StandardNames[F]; 246 assert(State == CustomName); 247 return CustomNames.find(F)->second; 248 } 249 250 /// setUnavailable - this can be used by whatever sets up TargetLibraryInfo to 251 /// ban use of specific library functions. 252 void setUnavailable(LibFunc::Func F) { 253 setState(F, Unavailable); 254 } 255 256 void setAvailable(LibFunc::Func F) { 257 setState(F, StandardName); 258 } 259 260 void setAvailableWithName(LibFunc::Func F, StringRef Name) { 261 if (StandardNames[F] != Name) { 262 setState(F, CustomName); 263 CustomNames[F] = Name; 264 assert(CustomNames.find(F) != CustomNames.end()); 265 } else { 266 setState(F, StandardName); 267 } 268 } 269 270 /// disableAllFunctions - This disables all builtins, which is used for 271 /// options like -fno-builtin. 272 void disableAllFunctions(); 273}; 274 275} // end namespace llvm 276 277#endif 278