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       /// 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