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 ceil(double x);
  40       ceil,
  41       /// long double ceill(long double x);
  42       ceill,
  43       /// float ceilf(float x);
  44       ceilf,
  45       /// double cos(double x);
  46       cos,
  47       /// long double cosl(long double x);
  48       cosl,
  49       /// float cosf(float x);
  50       cosf,
  51       /// double cosh(double x);
  52       cosh,
  53       /// long double coshl(long double x);
  54       coshl,
  55       /// float coshf(float x);
  56       coshf,
  57       /// double exp(double x);
  58       exp,
  59       /// long double expl(long double x);
  60       expl,
  61       /// float expf(float x);
  62       expf,
  63       /// double exp2(double x);
  64       exp2,
  65       /// long double exp2l(long double x);
  66       exp2l,
  67       /// float exp2f(float x);
  68       exp2f,
  69       /// double expm1(double x);
  70       expm1,
  71       /// long double expm1l(long double x);
  72       expm1l,
  73       /// float expm1f(float x);
  74       expl1f,
  75       /// double fabs(double x);
  76       fabs,
  77       /// long double fabsl(long double x);
  78       fabsl,
  79       /// float fabsf(float x);
  80       fabsf,
  81       /// double floor(double x);
  82       floor,
  83       /// long double floorl(long double x);
  84       floorl,
  85       /// float floorf(float x);
  86       floorf,
  87       /// int fiprintf(FILE *stream, const char *format, ...);
  88       fiprintf,
  89       /// int fputs(const char *s, FILE *stream);
  90       fputs,
  91       /// size_t fwrite(const void *ptr, size_t size, size_t nitems,
  92       /// FILE *stream);
  93       fwrite,
  94       /// int iprintf(const char *format, ...);
  95       iprintf,
  96       /// double log(double x);
  97       log,
  98       /// long double logl(long double x);
  99       logl,
 100       /// float logf(float x);
 101       logf,
 102       /// double log2(double x);
 103       log2,
 104       /// double long double log2l(long double x);
 105       log2l,
 106       /// float log2f(float x);
 107       log2f,
 108       /// double log10(double x);
 109       log10,
 110       /// long double log10l(long double x);
 111       log10l,
 112       /// float log10f(float x);
 113       log10f,
 114       /// double log1p(double x);
 115       log1p,
 116       /// long double log1pl(long double x);
 117       log1pl,
 118       /// float log1pf(float x);
 119       log1pf,
 120       /// void *memcpy(void *s1, const void *s2, size_t n);
 121       memcpy,
 122       /// void *memmove(void *s1, const void *s2, size_t n);
 123       memmove,
 124       /// void *memset(void *b, int c, size_t len);
 125       memset,
 126       /// void memset_pattern16(void *b, const void *pattern16, size_t len);
 127       memset_pattern16,
 128       /// double pow(double x, double y);
 129       pow,
 130       /// float powf(float x, float y);
 131       powf,
 132       /// long double powl(long double x, long double y);
 133       powl,
 134       /// int siprintf(char *str, const char *format, ...);
 135       siprintf,
 136       /// double sqrt(double x);
 137       sqrt,
 138       /// long double sqrtl(long double x);
 139       sqrtl,
 140       /// float sqrtf(float x);
 141       sqrtf,
 142
 143       NumLibFuncs
 144     };
 145   }
 146
 147 /// TargetLibraryInfo - This immutable pass captures information about what
 148 /// library functions are available for the current target, and allows a
 149 /// frontend to disable optimizations through -fno-builtin etc.
 150 class TargetLibraryInfo : public ImmutablePass {
 151   unsigned char AvailableArray[(LibFunc::NumLibFuncs+3)/4];
 152   llvm::DenseMap<unsigned, std::string> CustomNames;
 153   static const char* StandardNames[LibFunc::NumLibFuncs];
 154
 155   enum AvailabilityState {
 156     StandardName = 3, // (memset to all ones)
 157     CustomName = 1,
 158     Unavailable = 0  // (memset to all zeros)
 159   };
 160   void setState(LibFunc::Func F, AvailabilityState State) {
 161     AvailableArray[F/4] &= ~(3 << 2*(F&3));
 162     AvailableArray[F/4] |= State << 2*(F&3);
 163   }
 164   AvailabilityState getState(LibFunc::Func F) const {
 165     return static_cast<AvailabilityState>((AvailableArray[F/4] >> 2*(F&3)) & 3);
 166   }
 167
 168 public:
 169   static char ID;
 170   TargetLibraryInfo();
 171   TargetLibraryInfo(const Triple &T);
 172   explicit TargetLibraryInfo(const TargetLibraryInfo &TLI);
 173
 174   /// has - This function is used by optimizations that want to match on or form
 175   /// a given library function.
 176   bool has(LibFunc::Func F) const {
 177     return getState(F) != Unavailable;
 178   }
 179
 180   StringRef getName(LibFunc::Func F) const {
 181     AvailabilityState State = getState(F);
 182     if (State == Unavailable)
 183       return StringRef();
 184     if (State == StandardName)
 185       return StandardNames[F];
 186     assert(State == CustomName);
 187     return CustomNames.find(F)->second;
 188   }
 189
 190   /// setUnavailable - this can be used by whatever sets up TargetLibraryInfo to
 191   /// ban use of specific library functions.
 192   void setUnavailable(LibFunc::Func F) {
 193     setState(F, Unavailable);
 194   }
 195
 196   void setAvailable(LibFunc::Func F) {
 197     setState(F, StandardName);
 198   }
 199
 200   void setAvailableWithName(LibFunc::Func F, StringRef Name) {
 201     if (StandardNames[F] != Name) {
 202       setState(F, CustomName);
 203       CustomNames[F] = Name;
 204       assert(CustomNames.find(F) != CustomNames.end());
 205     } else {
 206       setState(F, StandardName);
 207     }
 208   }
 209
 210   /// disableAllFunctions - This disables all builtins, which is used for
 211   /// options like -fno-builtin.
 212   void disableAllFunctions();
 213 };
 214
 215 } // end namespace llvm
 216
 217 #endif