[libc] Use entrypoints.txt as the single source of list of functions for a platform.
[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 }
91
92 def MathErrHandlingMacro : MacroDef<"math_errhandling"> {
93   let Defn = [{
94     #ifndef math_errhandling
95     #ifdef __FAST_MATH__
96     #define math_errhandling 0
97     #elif defined __NO_MATH_ERRNO__
98     #define math_errhandling (MATH_ERREXCEPT)
99     #else
100     #define math_errhandling (MATH_ERRNO | MATH_ERREXCEPT)
101     #endif
102     #endif // math_errhandling not defined
103   }];
104 }
105
106 def IsFiniteMacro : MacroDef<"isfinite"> {
107   let Defn = [{
108     #define isfinite(x) __builtin_isfinite(x)
109   }];
110 }
111
112 def IsInfMacro : MacroDef<"isinf"> {
113   let Defn = [{
114     #define isinf(x) __builtin_isinf(x)
115   }];
116 }
117
118 def IsNanMacro : MacroDef<"isnan"> {
119   let Defn = [{
120     #define isnan(x) __builtin_isnan(x)
121   }];
122 }
123
124 def FloatT : TypeDecl<"float_t"> {
125   let Decl = [{
126     #define __need_float_t
127     #include <__llvm-libc-stdc-types.h>
128   }];
129 }
130
131 def DoubleT : TypeDecl<"double_t"> {
132   let Decl = [{
133     #define __need_double_t
134     #include <__llvm-libc-stdc-types.h>
135   }];
136 }
137
138 def MathAPI : PublicAPI<"math.h"> {
139   let Macros = [
140     SimpleMacroDef<"MATH_ERRNO", "1">,
141     SimpleMacroDef<"MATH_ERREXCEPT", "2">,
142     MathErrHandlingMacro,
143
144     SimpleMacroDef<"INFINITY", "__builtin_inff()">,
145     SimpleMacroDef<"NAN", "__builtin_nanf(\"\")">,
146
147     IsFiniteMacro,
148     IsInfMacro,
149     IsNanMacro,
150   ];
151   let TypeDeclarations = [
152     DoubleT,
153     FloatT,
154   ];
155 }
156
157 def StringAPI : PublicAPI<"string.h"> {
158   let TypeDeclarations = [
159     SizeT,
160   ];
161
162   let Macros = [
163     NullMacro,
164   ];
165 }
166
167 def StdIOAPI : PublicAPI<"stdio.h"> {
168   let TypeDeclarations = [
169     SizeT,
170     FILE,
171   ];
172 }
173
174 def StdlibAPI : PublicAPI<"stdlib.h"> {
175 }
176
177 def ErrnoAPI : PublicAPI<"errno.h"> {
178   let Macros = [
179     ErrnoMacro,
180     // We largely depend on linux/errno.h to give us the
181     // various error macro definitions. However, some libc
182     // implementations have chosen to provide definitions
183     // for some of the error macros to account for the ones
184     // missing in linux/errno.h. There is no harm in doing
185     // the same here if we define the macros only when they
186     // are not already defined.
187     MacroDefineIfNot<"ENOTSUP", "EOPNOTSUPP">,
188     MacroDefineIfNot<"ECANCELED", "125">,
189     MacroDefineIfNot<"EOWNERDEAD", "130">,
190     MacroDefineIfNot<"ENOTRECOVERABLE", "131">,
191     MacroDefineIfNot<"ERFKILL", "132">,
192     MacroDefineIfNot<"EHWPOISON", "133">,
193   ];
194 }
195
196 def SysMManAPI : PublicAPI<"sys/mman.h"> {
197   let Macros = [
198     SimpleMacroDef<"PROT_NONE", "0">,
199     SimpleMacroDef<"PROT_READ", "1">,
200     SimpleMacroDef<"PROT_WRITE", "2">,
201     SimpleMacroDef<"PROT_EXEC", "4">,
202
203     SimpleMacroDef<"MAP_FIXED", "1">,
204     SimpleMacroDef<"MAP_PRIVATE", "2">,
205     SimpleMacroDef<"MAP_SHARED", "4">,
206
207     SimpleMacroDef<"MAP_FAILED", "((void*)-1)">,
208
209     // TODO: The value of 0x20 is good for x86_64, but has to be extended
210     // in some manner to accommodate other machine architectures.
211     SimpleMacroDef<"MAP_ANONYMOUS", "0x20">
212
213     // TODO: Add other MAP_* macros used by Linux.
214   ];
215
216   let TypeDeclarations = [
217     SizeT,
218     OffT,
219   ];
220 }
221
222 def StructSigactionDefn : TypeDecl<"struct sigaction"> {
223   let Decl = [{
224     struct __sigaction {
225       union {
226         void (*sa_handler)(int);
227         void (*sa_action)(int, siginfo_t *, void *);
228       };
229       sigset_t sa_mask;
230       int sa_flags;
231       void (*sa_restorer)(void);
232     };
233   }];
234 }
235
236 def SighandlerTDefn : TypeDecl<"__sighandler_t"> {
237   let Decl = [{
238     typedef void(*__sighandler_t)(int);
239   }];
240 }
241
242 def SignalAPI : PublicAPI<"signal.h"> {
243   let TypeDeclarations = [
244     StructSigactionDefn,
245     SighandlerTDefn,
246   ];
247 }
248
249 def OnceFlag : TypeDecl<"once_flag"> {
250   let Decl = [{
251     typedef unsigned int once_flag;
252   }];
253 }
254
255 def MtxT : TypeDecl<"mtx_t"> {
256   let Decl = [{
257     typedef struct {
258       unsigned char __internal_data[4];
259       int __mtx_type;
260     } mtx_t;
261   }];
262 }
263
264 def ThreadStartT : TypeDecl<"thrd_start_t"> {
265   let Decl = "typedef int (*thrd_start_t)(void *);";
266 }
267
268 def CallOnceFuncT : TypeDecl<"__call_once_func_t"> {
269   let Decl = [{
270     typedef void(*__call_once_func_t)(void);
271   }];
272 }
273
274 def ThreadsAPI : PublicAPI<"threads.h"> {
275   let Macros = [
276     SimpleMacroDef<"ONCE_FLAG_INIT", "0">,
277   ];
278
279   let TypeDeclarations = [
280     OnceFlag,
281     CallOnceFuncT,
282     MtxT,
283     ThreadStartT,
284   ];
285
286   let Enumerations = [
287     "mtx_plain",
288     "mtx_recursive",
289     "mtx_timed",
290     "thrd_timedout",
291     "thrd_success",
292     "thrd_busy",
293     "thrd_error",
294     "thrd_nomem",
295   ];
296 }
297
298 def UniStdAPI : PublicAPI<"unistd.h"> {
299   let TypeDeclarations = [
300     SSizeT,
301     SizeT,
302   ];
303 }