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 16 namespace 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 expm1f, 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 double rintl(long double x); 163 rintl, 164 /// double round(double x); 165 round, 166 /// float roundf(float x); 167 roundf, 168 /// long double roundl(long double x); 169 roundl, 170 /// double sin(double x); 171 sin, 172 /// long double sinl(long double x); 173 sinl, 174 /// float sinf(float x); 175 sinf, 176 /// double sinh(double x); 177 sinh, 178 /// long double sinhl(long double x); 179 sinhl, 180 /// float sinhf(float x); 181 sinhf, 182 /// int siprintf(char *str, const char *format, ...); 183 siprintf, 184 /// double sqrt(double x); 185 sqrt, 186 /// long double sqrtl(long double x); 187 sqrtl, 188 /// float sqrtf(float x); 189 sqrtf, 190 /// double tan(double x); 191 tan, 192 /// long double tanl(long double x); 193 tanl, 194 /// float tanf(float x); 195 tanf, 196 /// double tanh(double x); 197 tanh, 198 /// long double tanhl(long double x); 199 tanhl, 200 /// float tanhf(float x); 201 tanhf, 202 /// double trunc(double x); 203 trunc, 204 /// float truncf(float x); 205 truncf, 206 /// long double truncl(long double x); 207 truncl, 208 /// int __cxa_atexit(void (*f)(void *), void *p, void *d); 209 cxa_atexit, 210 /// void __cxa_guard_abort(guard_t *guard); 211 /// guard_t is int64_t in Itanium ABI or int32_t on ARM eabi. 212 cxa_guard_abort, 213 /// int __cxa_guard_acquire(guard_t *guard); 214 cxa_guard_acquire, 215 /// void __cxa_guard_release(guard_t *guard); 216 cxa_guard_release, 217 218 NumLibFuncs 219 }; 220 } 221 222 /// TargetLibraryInfo - This immutable pass captures information about what 223 /// library functions are available for the current target, and allows a 224 /// frontend to disable optimizations through -fno-builtin etc. 225 class TargetLibraryInfo : public ImmutablePass { 226 virtual void anchor(); 227 unsigned char AvailableArray[(LibFunc::NumLibFuncs+3)/4]; 228 llvm::DenseMap<unsigned, std::string> CustomNames; 229 static const char* StandardNames[LibFunc::NumLibFuncs]; 230 231 enum AvailabilityState { 232 StandardName = 3, // (memset to all ones) 233 CustomName = 1, 234 Unavailable = 0 // (memset to all zeros) 235 }; 236 void setState(LibFunc::Func F, AvailabilityState State) { 237 AvailableArray[F/4] &= ~(3 << 2*(F&3)); 238 AvailableArray[F/4] |= State << 2*(F&3); 239 } 240 AvailabilityState getState(LibFunc::Func F) const { 241 return static_cast<AvailabilityState>((AvailableArray[F/4] >> 2*(F&3)) & 3); 242 } 243 244 public: 245 static char ID; 246 TargetLibraryInfo(); 247 TargetLibraryInfo(const Triple &T); 248 explicit TargetLibraryInfo(const TargetLibraryInfo &TLI); 249 250 /// has - This function is used by optimizations that want to match on or form 251 /// a given library function. 252 bool has(LibFunc::Func F) const { 253 return getState(F) != Unavailable; 254 } 255 256 StringRef getName(LibFunc::Func F) const { 257 AvailabilityState State = getState(F); 258 if (State == Unavailable) 259 return StringRef(); 260 if (State == StandardName) 261 return StandardNames[F]; 262 assert(State == CustomName); 263 return CustomNames.find(F)->second; 264 } 265 266 /// setUnavailable - this can be used by whatever sets up TargetLibraryInfo to 267 /// ban use of specific library functions. 268 void setUnavailable(LibFunc::Func F) { 269 setState(F, Unavailable); 270 } 271 272 void setAvailable(LibFunc::Func F) { 273 setState(F, StandardName); 274 } 275 276 void setAvailableWithName(LibFunc::Func F, StringRef Name) { 277 if (StandardNames[F] != Name) { 278 setState(F, CustomName); 279 CustomNames[F] = Name; 280 assert(CustomNames.find(F) != CustomNames.end()); 281 } else { 282 setState(F, StandardName); 283 } 284 } 285 286 /// disableAllFunctions - This disables all builtins, which is used for 287 /// options like -fno-builtin. 288 void disableAllFunctions(); 289 }; 290 291 } // end namespace llvm 292 293 #endif 294
