include/llvm/Target/TargetLibraryInfo.h

   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       /// void operator delete[](void*);
  22       ZdaPv,
  23       /// void operator delete(void*);
  24       ZdlPv,
  25       /// void *new[](unsigned int);
  26       Znaj,
  27       /// void *new[](unsigned int, nothrow);
  28       ZnajRKSt9nothrow_t,
  29       /// void *new[](unsigned long);
  30       Znam,
  31       /// void *new[](unsigned long, nothrow);
  32       ZnamRKSt9nothrow_t,
  33       /// void *new(unsigned int);
  34       Znwj,
  35       /// void *new(unsigned int, nothrow);
  36       ZnwjRKSt9nothrow_t,
  37       /// void *new(unsigned long);
  38       Znwm,
  39       /// void *new(unsigned long, nothrow);
  40       ZnwmRKSt9nothrow_t,
  41       /// int __cxa_atexit(void (*f)(void *), void *p, void *d);
  42       cxa_atexit,
  43       /// void __cxa_guard_abort(guard_t *guard);
  44       /// guard_t is int64_t in Itanium ABI or int32_t on ARM eabi.
  45       cxa_guard_abort,
  46       /// int __cxa_guard_acquire(guard_t *guard);
  47       cxa_guard_acquire,
  48       /// void __cxa_guard_release(guard_t *guard);
  49       cxa_guard_release,
  50       /// void *__memcpy_chk(void *s1, const void *s2, size_t n, size_t s1size);
  51       memcpy_chk,
  52       /// double acos(double x);
  53       acos,
  54       /// float acosf(float x);
  55       acosf,
  56       /// double acosh(double x);
  57       acosh,
  58       /// float acoshf(float x);
  59       acoshf,
  60       /// long double acoshl(long double x);
  61       acoshl,
  62       /// long double acosl(long double x);
  63       acosl,
  64       /// double asin(double x);
  65       asin,
  66       /// float asinf(float x);
  67       asinf,
  68       /// double asinh(double x);
  69       asinh,
  70       /// float asinhf(float x);
  71       asinhf,
  72       /// long double asinhl(long double x);
  73       asinhl,
  74       /// long double asinl(long double x);
  75       asinl,
  76       /// double atan(double x);
  77       atan,
  78       /// double atan2(double y, double x);
  79       atan2,
  80       /// float atan2f(float y, float x);
  81       atan2f,
  82       /// long double atan2l(long double y, long double x);
  83       atan2l,
  84       /// float atanf(float x);
  85       atanf,
  86       /// double atanh(double x);
  87       atanh,
  88       /// float atanhf(float x);
  89       atanhf,
  90       /// long double atanhl(long double x);
  91       atanhl,
  92       /// long double atanl(long double x);
  93       atanl,
  94       /// void *calloc(size_t count, size_t size);
  95       calloc,
  96       /// double cbrt(double x);
  97       cbrt,
  98       /// float cbrtf(float x);
  99       cbrtf,
 100       /// long double cbrtl(long double x);
 101       cbrtl,
 102       /// double ceil(double x);
 103       ceil,
 104       /// float ceilf(float x);
 105       ceilf,
 106       /// long double ceill(long double x);
 107       ceill,
 108       /// double copysign(double x, double y);
 109       copysign,
 110       /// float copysignf(float x, float y);
 111       copysignf,
 112       /// long double copysignl(long double x, long double y);
 113       copysignl,
 114       /// double cos(double x);
 115       cos,
 116       /// float cosf(float x);
 117       cosf,
 118       /// double cosh(double x);
 119       cosh,
 120       /// float coshf(float x);
 121       coshf,
 122       /// long double coshl(long double x);
 123       coshl,
 124       /// long double cosl(long double x);
 125       cosl,
 126       /// double exp(double x);
 127       exp,
 128       /// double exp10(double x);
 129       exp10,
 130       /// float exp10f(float x);
 131       exp10f,
 132       /// long double exp10l(long double x);
 133       exp10l,
 134       /// double exp2(double x);
 135       exp2,
 136       /// float exp2f(float x);
 137       exp2f,
 138       /// long double exp2l(long double x);
 139       exp2l,
 140       /// float expf(float x);
 141       expf,
 142       /// long double expl(long double x);
 143       expl,
 144       /// double expm1(double x);
 145       expm1,
 146       /// float expm1f(float x);
 147       expm1f,
 148       /// long double expm1l(long double x);
 149       expm1l,
 150       /// double fabs(double x);
 151       fabs,
 152       /// float fabsf(float x);
 153       fabsf,
 154       /// long double fabsl(long double x);
 155       fabsl,
 156       /// int fiprintf(FILE *stream, const char *format, ...);
 157       fiprintf,
 158       /// double floor(double x);
 159       floor,
 160       /// float floorf(float x);
 161       floorf,
 162       /// long double floorl(long double x);
 163       floorl,
 164       /// double fmod(double x, double y);
 165       fmod,
 166       /// float fmodf(float x, float y);
 167       fmodf,
 168       /// long double fmodl(long double x, long double y);
 169       fmodl,
 170       /// int fputc(int c, FILE *stream);
 171       fputc,
 172       /// int fputs(const char *s, FILE *stream);
 173       fputs,
 174       /// void free(void *ptr);
 175       free,
 176       /// size_t fwrite(const void *ptr, size_t size, size_t nitems,
 177       /// FILE *stream);
 178       fwrite,
 179       /// int iprintf(const char *format, ...);
 180       iprintf,
 181       /// double log(double x);
 182       log,
 183       /// double log10(double x);
 184       log10,
 185       /// float log10f(float x);
 186       log10f,
 187       /// long double log10l(long double x);
 188       log10l,
 189       /// double log1p(double x);
 190       log1p,
 191       /// float log1pf(float x);
 192       log1pf,
 193       /// long double log1pl(long double x);
 194       log1pl,
 195       /// double log2(double x);
 196       log2,
 197       /// float log2f(float x);
 198       log2f,
 199       /// double long double log2l(long double x);
 200       log2l,
 201       /// double logb(double x);
 202       logb,
 203       /// float logbf(float x);
 204       logbf,
 205       /// long double logbl(long double x);
 206       logbl,
 207       /// float logf(float x);
 208       logf,
 209       /// long double logl(long double x);
 210       logl,
 211       /// void *malloc(size_t size);
 212       malloc,
 213       /// void *memchr(const void *s, int c, size_t n);
 214       memchr,
 215       /// int memcmp(const void *s1, const void *s2, size_t n);
 216       memcmp,
 217       /// void *memcpy(void *s1, const void *s2, size_t n);
 218       memcpy,
 219       /// void *memmove(void *s1, const void *s2, size_t n);
 220       memmove,
 221       /// void *memset(void *b, int c, size_t len);
 222       memset,
 223       /// void memset_pattern16(void *b, const void *pattern16, size_t len);
 224       memset_pattern16,
 225       /// double nearbyint(double x);
 226       nearbyint,
 227       /// float nearbyintf(float x);
 228       nearbyintf,
 229       /// long double nearbyintl(long double x);
 230       nearbyintl,
 231       /// int posix_memalign(void **memptr, size_t alignment, size_t size);
 232       posix_memalign,
 233       /// double pow(double x, double y);
 234       pow,
 235       /// float powf(float x, float y);
 236       powf,
 237       /// long double powl(long double x, long double y);
 238       powl,
 239       /// int putchar(int c);
 240       putchar,
 241       /// int puts(const char *s);
 242       puts,
 243       /// void *realloc(void *ptr, size_t size);
 244       realloc,
 245       /// void *reallocf(void *ptr, size_t size);
 246       reallocf,
 247       /// double rint(double x);
 248       rint,
 249       /// float rintf(float x);
 250       rintf,
 251       /// long double rintl(long double x);
 252       rintl,
 253       /// double round(double x);
 254       round,
 255       /// float roundf(float x);
 256       roundf,
 257       /// long double roundl(long double x);
 258       roundl,
 259       /// double sin(double x);
 260       sin,
 261       /// float sinf(float x);
 262       sinf,
 263       /// double sinh(double x);
 264       sinh,
 265       /// float sinhf(float x);
 266       sinhf,
 267       /// long double sinhl(long double x);
 268       sinhl,
 269       /// long double sinl(long double x);
 270       sinl,
 271       /// int siprintf(char *str, const char *format, ...);
 272       siprintf,
 273       /// double sqrt(double x);
 274       sqrt,
 275       /// float sqrtf(float x);
 276       sqrtf,
 277       /// long double sqrtl(long double x);
 278       sqrtl,
 279       /// char *strcat(char *s1, const char *s2);
 280       strcat,
 281       /// char *strchr(const char *s, int c);
 282       strchr,
 283       /// char *strcpy(char *s1, const char *s2);
 284       strcpy,
 285       /// char *strdup(const char *s1);
 286       strdup,
 287       /// size_t strlen(const char *s);
 288       strlen,
 289       /// char *strncat(char *s1, const char *s2, size_t n);
 290       strncat,
 291       /// int strncmp(const char *s1, const char *s2, size_t n);
 292       strncmp,
 293       /// char *strncpy(char *s1, const char *s2, size_t n);
 294       strncpy,
 295       /// char *strndup(const char *s1, size_t n);
 296       strndup,
 297       /// size_t strnlen(const char *s, size_t maxlen);
 298       strnlen,
 299       /// double tan(double x);
 300       tan,
 301       /// float tanf(float x);
 302       tanf,
 303       /// double tanh(double x);
 304       tanh,
 305       /// float tanhf(float x);
 306       tanhf,
 307       /// long double tanhl(long double x);
 308       tanhl,
 309       /// long double tanl(long double x);
 310       tanl,
 311       /// double trunc(double x);
 312       trunc,
 313       /// float truncf(float x);
 314       truncf,
 315       /// long double truncl(long double x);
 316       truncl,
 317       /// void *valloc(size_t size);
 318       valloc,
 319
 320       NumLibFuncs
 321     };
 322   }
 323
 324 /// TargetLibraryInfo - This immutable pass captures information about what
 325 /// library functions are available for the current target, and allows a
 326 /// frontend to disable optimizations through -fno-builtin etc.
 327 class TargetLibraryInfo : public ImmutablePass {
 328   virtual void anchor();
 329   unsigned char AvailableArray[(LibFunc::NumLibFuncs+3)/4];
 330   llvm::DenseMap<unsigned, std::string> CustomNames;
 331   static const char* StandardNames[LibFunc::NumLibFuncs];
 332
 333   enum AvailabilityState {
 334     StandardName = 3, // (memset to all ones)
 335     CustomName = 1,
 336     Unavailable = 0  // (memset to all zeros)
 337   };
 338   void setState(LibFunc::Func F, AvailabilityState State) {
 339     AvailableArray[F/4] &= ~(3 << 2*(F&3));
 340     AvailableArray[F/4] |= State << 2*(F&3);
 341   }
 342   AvailabilityState getState(LibFunc::Func F) const {
 343     return static_cast<AvailabilityState>((AvailableArray[F/4] >> 2*(F&3)) & 3);
 344   }
 345
 346 public:
 347   static char ID;
 348   TargetLibraryInfo();
 349   TargetLibraryInfo(const Triple &T);
 350   explicit TargetLibraryInfo(const TargetLibraryInfo &TLI);
 351
 352   /// getLibFunc - Search for a particular function name.  If it is one of the
 353   /// known library functions, return true and set F to the corresponding value.
 354   bool getLibFunc(StringRef funcName, LibFunc::Func &F) const;
 355
 356   /// has - This function is used by optimizations that want to match on or form
 357   /// a given library function.
 358   bool has(LibFunc::Func F) const {
 359     return getState(F) != Unavailable;
 360   }
 361
 362   /// hasOptimizedCodeGen - Return true if the function is both available as
 363   /// a builtin and a candidate for optimized code generation.
 364   bool hasOptimizedCodeGen(LibFunc::Func F) const {
 365     if (getState(F) == Unavailable)
 366       return false;
 367     switch (F) {
 368     default: break;
 369     case LibFunc::copysign:  case LibFunc::copysignf:  case LibFunc::copysignl:
 370     case LibFunc::fabs:      case LibFunc::fabsf:      case LibFunc::fabsl:
 371     case LibFunc::sin:       case LibFunc::sinf:       case LibFunc::sinl:
 372     case LibFunc::cos:       case LibFunc::cosf:       case LibFunc::cosl:
 373     case LibFunc::sqrt:      case LibFunc::sqrtf:      case LibFunc::sqrtl:
 374     case LibFunc::floor:     case LibFunc::floorf:     case LibFunc::floorl:
 375     case LibFunc::nearbyint: case LibFunc::nearbyintf: case LibFunc::nearbyintl:
 376     case LibFunc::ceil:      case LibFunc::ceilf:      case LibFunc::ceill:
 377     case LibFunc::rint:      case LibFunc::rintf:      case LibFunc::rintl:
 378     case LibFunc::trunc:     case LibFunc::truncf:     case LibFunc::truncl:
 379     case LibFunc::log2:      case LibFunc::log2f:      case LibFunc::log2l:
 380     case LibFunc::exp2:      case LibFunc::exp2f:      case LibFunc::exp2l:
 381     case LibFunc::memcmp:
 382       return true;
 383     }
 384     return false;
 385   }
 386
 387   StringRef getName(LibFunc::Func F) const {
 388     AvailabilityState State = getState(F);
 389     if (State == Unavailable)
 390       return StringRef();
 391     if (State == StandardName)
 392       return StandardNames[F];
 393     assert(State == CustomName);
 394     return CustomNames.find(F)->second;
 395   }
 396
 397   /// setUnavailable - this can be used by whatever sets up TargetLibraryInfo to
 398   /// ban use of specific library functions.
 399   void setUnavailable(LibFunc::Func F) {
 400     setState(F, Unavailable);
 401   }
 402
 403   void setAvailable(LibFunc::Func F) {
 404     setState(F, StandardName);
 405   }
 406
 407   void setAvailableWithName(LibFunc::Func F, StringRef Name) {
 408     if (StandardNames[F] != Name) {
 409       setState(F, CustomName);
 410       CustomNames[F] = Name;
 411       assert(CustomNames.find(F) != CustomNames.end());
 412     } else {
 413       setState(F, StandardName);
 414     }
 415   }
 416
 417   /// disableAllFunctions - This disables all builtins, which is used for
 418   /// options like -fno-builtin.
 419   void disableAllFunctions();
 420 };
 421
 422 } // end namespace llvm
 423
 424 #endif