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