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       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       /// int __cxa_atexit(void (*f)(void *), void *p, void *d);
 203       cxa_atexit,
 204       /// void __cxa_guard_abort(guard_t *guard);
 205       /// guard_t is int64_t in Itanium ABI or int32_t on ARM eabi.
 206       cxa_guard_abort,
 207       /// int __cxa_guard_acquire(guard_t *guard);
 208       cxa_guard_acquire,
 209       /// void __cxa_guard_release(guard_t *guard);
 210       cxa_guard_release,
 211
 212       NumLibFuncs
 213     };
 214   }
 215
 216 /// TargetLibraryInfo - This immutable pass captures information about what
 217 /// library functions are available for the current target, and allows a
 218 /// frontend to disable optimizations through -fno-builtin etc.
 219 class TargetLibraryInfo : public ImmutablePass {
 220   virtual void anchor();
 221   unsigned char AvailableArray[(LibFunc::NumLibFuncs+3)/4];
 222   llvm::DenseMap<unsigned, std::string> CustomNames;
 223   static const char* StandardNames[LibFunc::NumLibFuncs];
 224
 225   enum AvailabilityState {
 226     StandardName = 3, // (memset to all ones)
 227     CustomName = 1,
 228     Unavailable = 0  // (memset to all zeros)
 229   };
 230   void setState(LibFunc::Func F, AvailabilityState State) {
 231     AvailableArray[F/4] &= ~(3 << 2*(F&3));
 232     AvailableArray[F/4] |= State << 2*(F&3);
 233   }
 234   AvailabilityState getState(LibFunc::Func F) const {
 235     return static_cast<AvailabilityState>((AvailableArray[F/4] >> 2*(F&3)) & 3);
 236   }
 237
 238 public:
 239   static char ID;
 240   TargetLibraryInfo();
 241   TargetLibraryInfo(const Triple &T);
 242   explicit TargetLibraryInfo(const TargetLibraryInfo &TLI);
 243
 244   /// has - This function is used by optimizations that want to match on or form
 245   /// a given library function.
 246   bool has(LibFunc::Func F) const {
 247     return getState(F) != Unavailable;
 248   }
 249
 250   StringRef getName(LibFunc::Func F) const {
 251     AvailabilityState State = getState(F);
 252     if (State == Unavailable)
 253       return StringRef();
 254     if (State == StandardName)
 255       return StandardNames[F];
 256     assert(State == CustomName);
 257     return CustomNames.find(F)->second;
 258   }
 259
 260   /// setUnavailable - this can be used by whatever sets up TargetLibraryInfo to
 261   /// ban use of specific library functions.
 262   void setUnavailable(LibFunc::Func F) {
 263     setState(F, Unavailable);
 264   }
 265
 266   void setAvailable(LibFunc::Func F) {
 267     setState(F, StandardName);
 268   }
 269
 270   void setAvailableWithName(LibFunc::Func F, StringRef Name) {
 271     if (StandardNames[F] != Name) {
 272       setState(F, CustomName);
 273       CustomNames[F] = Name;
 274       assert(CustomNames.find(F) != CustomNames.end());
 275     } else {
 276       setState(F, StandardName);
 277     }
 278   }
 279
 280   /// disableAllFunctions - This disables all builtins, which is used for
 281   /// options like -fno-builtin.
 282   void disableAllFunctions();
 283 };
 284
 285 } // end namespace llvm
 286
 287 #endif