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