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