40eec8f55c1c6c4d05faea18edbd67e5b66c0e75
[lldb.git] / libc / config / linux / api.td
1 include "config/public_api.td"
2
3 include "spec/gnu_ext.td"
4 include "spec/linux.td"
5 include "spec/llvm_libc_ext.td"
6 include "spec/posix.td"
7 include "spec/stdc.td"
8
9 def SizeT : TypeDecl<"size_t"> {
10   let Decl = [{
11     #define __need_size_t
12     #include <stddef.h>
13   }];
14 }
15
16 def SSizeT : TypeDecl<"ssize_t"> {
17   let Decl = [{
18     #define __need_ssize_t
19     #include <__posix-types.h>
20   }];
21 }
22
23 def OffT : TypeDecl<"off_t"> {
24   let Decl = [{
25     #define __need_off_t
26     #include <__posix-types.h>
27   }];
28 }
29
30 def FILE : TypeDecl<"FILE"> {
31   let Decl = [{
32     typedef struct FILE FILE;
33   }];
34 }
35
36 def AssertMacro : MacroDef<"assert"> {
37   let Defn = [{
38     #undef assert
39
40     #ifdef NDEBUG
41     #define assert(e) (void)0
42     #else
43
44     #ifdef __cplusplus
45     extern "C"
46     #endif
47     _Noreturn void __assert_fail(const char *, const char *, unsigned, const char *);
48
49     #define assert(e)  \
50       ((e) ? (void)0 : __assert_fail(#e, __FILE__, __LINE__, __PRETTY_FUNCTION__))
51
52     #endif
53   }];
54 }
55
56 def StaticAssertMacro : MacroDef<"static_assert"> {
57   let Defn = [{
58     #ifndef __cplusplus
59     #undef static_assert
60     #define static_assert _Static_assert
61     #endif
62   }];
63 }
64
65 def NullMacro : MacroDef<"NULL"> {
66   let Defn = [{
67     #define __need_NULL
68     #include <stddef.h>
69   }];
70 }
71
72 def ErrnoMacro : MacroDef<"errno"> {
73   let Defn = [{
74     #ifdef __cplusplus
75     extern "C"
76     #endif
77     int *__errno_location();
78     #define errno (*__errno_location())
79   }];
80 }
81
82 def AssertAPI : PublicAPI<"assert.h"> {
83   let Macros = [
84     AssertMacro,
85     StaticAssertMacro,
86   ];
87 }
88
89 def CTypeAPI : PublicAPI<"ctype.h"> {
90   let Functions = [
91     "isalnum",
92     "isalpha",
93     "isblank",
94     "iscntrl",
95     "isdigit",
96     "isgraph",
97     "islower",
98     "isprint",
99     "ispunct",
100     "isspace",
101     "isupper",
102     "isxdigit",
103     "tolower",
104     "toupper",
105   ];
106 }
107
108 def MathErrHandlingMacro : MacroDef<"math_errhandling"> {
109   let Defn = [{
110     #ifndef math_errhandling
111     #ifdef __FAST_MATH__
112     #define math_errhandling 0
113     #elif defined __NO_MATH_ERRNO__
114     #define math_errhandling (MATH_ERREXCEPT)
115     #else
116     #define math_errhandling (MATH_ERRNO | MATH_ERREXCEPT)
117     #endif
118     #endif // math_errhandling not defined
119   }];
120 }
121
122 def IsFiniteMacro : MacroDef<"isfinite"> {
123   let Defn = [{
124     #define isfinite(x) __builtin_isfinite(x)
125   }];
126 }
127
128 def IsInfMacro : MacroDef<"isinf"> {
129   let Defn = [{
130     #define isinf(x) __builtin_isinf(x)
131   }];
132 }
133
134 def IsNanMacro : MacroDef<"isnan"> {
135   let Defn = [{
136     #define isnan(x) __builtin_isnan(x)
137   }];
138 }
139
140 def FloatT : TypeDecl<"float_t"> {
141   let Decl = [{
142     #define __need_float_t
143     #include <__llvm-libc-stdc-types.h>
144   }];
145 }
146
147 def DoubleT : TypeDecl<"double_t"> {
148   let Decl = [{
149     #define __need_double_t
150     #include <__llvm-libc-stdc-types.h>
151   }];
152 }
153
154 def MathAPI : PublicAPI<"math.h"> {
155   let Macros = [
156     SimpleMacroDef<"MATH_ERRNO", "1">,
157     SimpleMacroDef<"MATH_ERREXCEPT", "2">,
158     MathErrHandlingMacro,
159
160     SimpleMacroDef<"INFINITY", "__builtin_inff()">,
161     SimpleMacroDef<"NAN", "__builtin_nanf(\"\")">,
162
163     IsFiniteMacro,
164     IsInfMacro,
165     IsNanMacro,
166   ];
167   let TypeDeclarations = [
168     DoubleT,
169     FloatT,
170   ];
171   let Functions = [
172    "copysign",
173    "copysignf",
174    "copysignl",
175    "ceil",
176    "ceilf",
177    "ceill",
178    "cosf",
179    "fabs",
180    "fabsf",
181    "fabsl",
182    "floor",
183    "floorf",
184    "floorl",
185    "fmax",
186    "fmaxf",
187    "fmaxl",
188    "fmin",
189    "fminf",
190    "fminl",
191    "frexp",
192    "frexpf",
193    "frexpl",
194    "hypotf",
195    "logb",
196    "logbf",
197    "logbl",
198    "modf",
199    "modff",
200    "modfl",
201    "expf",
202    "exp2f",
203    "remainderf",
204    "remainder",
205    "remainderl",
206    "remquof",
207    "remquo",
208    "remquol",
209    "round",
210    "roundf",
211    "roundl",
212    "sincosf",
213    "sinf",
214    "sqrt",
215    "sqrtf",
216    "sqrtl",
217    "trunc",
218    "truncf",
219    "truncl",
220   ];
221 }
222
223 def StringAPI : PublicAPI<"string.h"> {
224   let Functions = [
225     "bzero",
226     "memchr",
227     "memcmp",
228     "memcpy",
229     "memmove",
230     "memrchr",
231     "memset",
232     "strcat",
233     "strchr",
234     "strcmp",
235     "strcoll",
236     "strcpy",
237     "strcspn",  
238     "strerror",
239     "strlen",
240     "strncat",
241     "strncmp",
242     "strncpy",
243     "strnlen",
244     "strpbrk",
245     "strrchr",
246     "strspn",
247     "strstr",
248     "strtok",
249     "strtok_r",
250     "strxfrm",   
251   ];
252
253   let TypeDeclarations = [
254     SizeT,
255   ];
256
257   let Macros = [
258     NullMacro,
259   ];
260 }
261
262 def StdIOAPI : PublicAPI<"stdio.h"> {
263   let TypeDeclarations = [
264     SizeT,
265     FILE,
266   ];
267
268   let Functions = [
269     "fwrite",
270   ];
271 }
272
273 def StdlibAPI : PublicAPI<"stdlib.h"> {
274   let Functions = [
275     "_Exit",
276     "abort",
277   ];
278 }
279
280 def ErrnoAPI : PublicAPI<"errno.h"> {
281   let Macros = [
282     ErrnoMacro,
283     // We largely depend on linux/errno.h to give us the
284     // various error macro definitions. However, some libc
285     // implementations have chosen to provide definitions
286     // for some of the error macros to account for the ones
287     // missing in linux/errno.h. There is no harm in doing
288     // the same here if we define the macros only when they
289     // are not already defined.
290     MacroDefineIfNot<"ENOTSUP", "EOPNOTSUPP">,
291     MacroDefineIfNot<"ECANCELED", "125">,
292     MacroDefineIfNot<"EOWNERDEAD", "130">,
293     MacroDefineIfNot<"ENOTRECOVERABLE", "131">,
294     MacroDefineIfNot<"ERFKILL", "132">,
295     MacroDefineIfNot<"EHWPOISON", "133">,
296   ];
297 }
298
299 def SysMManAPI : PublicAPI<"sys/mman.h"> {
300   let Macros = [
301     SimpleMacroDef<"PROT_NONE", "0">,
302     SimpleMacroDef<"PROT_READ", "1">,
303     SimpleMacroDef<"PROT_WRITE", "2">,
304     SimpleMacroDef<"PROT_EXEC", "4">,
305
306     SimpleMacroDef<"MAP_FIXED", "1">,
307     SimpleMacroDef<"MAP_PRIVATE", "2">,
308     SimpleMacroDef<"MAP_SHARED", "4">,
309
310     SimpleMacroDef<"MAP_FAILED", "((void*)-1)">,
311
312     // TODO: The value of 0x20 is good for x86_64, but has to be extended
313     // in some manner to accommodate other machine architectures.
314     SimpleMacroDef<"MAP_ANONYMOUS", "0x20">
315
316     // TODO: Add other MAP_* macros used by Linux.
317   ];
318
319   let TypeDeclarations = [
320     SizeT,
321     OffT,
322   ];
323
324   let Functions = [
325     "mmap",
326     "munmap",
327   ];
328 }
329
330 def StructSigactionDefn : TypeDecl<"struct sigaction"> {
331   let Decl = [{
332     struct __sigaction {
333       union {
334         void (*sa_handler)(int);
335         void (*sa_action)(int, siginfo_t *, void *);
336       };
337       sigset_t sa_mask;
338       int sa_flags;
339       void (*sa_restorer)(void);
340     };
341   }];
342 }
343
344 def SighandlerTDefn : TypeDecl<"__sighandler_t"> {
345   let Decl = [{
346     typedef void(*__sighandler_t)(int);
347   }];
348 }
349
350 def SignalAPI : PublicAPI<"signal.h"> {
351   let TypeDeclarations = [
352     StructSigactionDefn,
353     SighandlerTDefn,
354   ];
355
356   let Functions = [
357     "raise",
358     "sigaction",
359     "sigdelset",
360     "sigprocmask",
361     "sigemptyset",
362     "sigaddset",
363     "sigfillset",
364     "signal",
365   ];
366 }
367
368 def OnceFlag : TypeDecl<"once_flag"> {
369   let Decl = [{
370     typedef unsigned int once_flag;
371   }];
372 }
373
374 def MtxT : TypeDecl<"mtx_t"> {
375   let Decl = [{
376     typedef struct {
377       unsigned char __internal_data[4];
378       int __mtx_type;
379     } mtx_t;
380   }];
381 }
382
383 def ThreadStartT : TypeDecl<"thrd_start_t"> {
384   let Decl = "typedef int (*thrd_start_t)(void *);";
385 }
386
387 def CallOnceFuncT : TypeDecl<"__call_once_func_t"> {
388   let Decl = [{
389     typedef void(*__call_once_func_t)(void);
390   }];
391 }
392
393 def ThreadsAPI : PublicAPI<"threads.h"> {
394   let Macros = [
395     SimpleMacroDef<"ONCE_FLAG_INIT", "0">,
396   ];
397
398   let TypeDeclarations = [
399     OnceFlag,
400     CallOnceFuncT,
401     MtxT,
402     ThreadStartT,
403   ];
404
405   let Enumerations = [
406     "mtx_plain",
407     "mtx_recursive",
408     "mtx_timed",
409     "thrd_timedout",
410     "thrd_success",
411     "thrd_busy",
412     "thrd_error",
413     "thrd_nomem",
414   ];
415
416   let Functions = [
417     "call_once",
418     "mtx_init",
419     "mtx_lock",
420     "mtx_unlock",
421     "thrd_create",
422     "thrd_join",
423   ];
424 }
425
426 def UniStdAPI : PublicAPI<"unistd.h"> {
427   let TypeDeclarations = [
428     SSizeT,
429     SizeT,
430   ];
431
432   let Functions = [
433     "write",
434   ];
435 }