TargetLibraryInfo.h revision 6a7df9aae620801d97da72d718e9aff76eebac9b 
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      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.
219class 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
238public:
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
288