blob: c8dfd3b687c97b37fbd79bf81737e6166a53d266 [file] [log] [blame]
include "config/public_api.td"
include "spec/gnu_ext.td"
include "spec/linux.td"
include "spec/llvm_libc_ext.td"
include "spec/posix.td"
include "spec/stdc.td"
def SizeT : TypeDecl<"size_t"> {
let Decl = [{
#define __need_size_t
#include <stddef.h>
}];
}
def SSizeT : TypeDecl<"ssize_t"> {
let Decl = [{
#define __need_ssize_t
#include <__posix-types.h>
}];
}
def StructTm: TypeDecl<"struct tm"> {
let Decl = [{
struct tm {
int tm_sec; // seconds after the minute
int tm_min; // minutes after the hour
int tm_hour; // hours since midnight
int tm_mday; // day of the month
int tm_mon; // months since January
int tm_year; // years since 1900
int tm_wday; // days since Sunday
int tm_yday; // days since January
int tm_isdst; // Daylight Saving Time flag
};
}];
}
def TimeT: TypeDecl<"time_t"> {
let Decl = [{
typedef long time_t;
}];
}
def OffT : TypeDecl<"off_t"> {
let Decl = [{
#define __need_off_t
#include <__posix-types.h>
}];
}
def FILE : TypeDecl<"FILE"> {
let Decl = [{
typedef struct FILE FILE;
}];
}
def AssertMacro : MacroDef<"assert"> {
let Defn = [{
#undef assert
#ifdef NDEBUG
#define assert(e) (void)0
#else
#ifdef __cplusplus
extern "C"
#endif
_Noreturn void __assert_fail(const char *, const char *, unsigned, const char *);
#define assert(e) \
((e) ? (void)0 : __assert_fail(#e, __FILE__, __LINE__, __PRETTY_FUNCTION__))
#endif
}];
}
def StaticAssertMacro : MacroDef<"static_assert"> {
let Defn = [{
#ifndef __cplusplus
#undef static_assert
#define static_assert _Static_assert
#endif
}];
}
def NullMacro : MacroDef<"NULL"> {
let Defn = [{
#define __need_NULL
#include <stddef.h>
}];
}
def ErrnoMacro : MacroDef<"errno"> {
let Defn = [{
#ifdef __cplusplus
extern "C"
#endif
int *__errno_location();
#define errno (*__errno_location())
}];
}
def AssertAPI : PublicAPI<"assert.h"> {
let Macros = [
AssertMacro,
StaticAssertMacro,
];
}
def CTypeAPI : PublicAPI<"ctype.h"> {
}
def MathErrHandlingMacro : MacroDef<"math_errhandling"> {
let Defn = [{
#ifndef math_errhandling
#ifdef __FAST_MATH__
#define math_errhandling 0
#elif defined __NO_MATH_ERRNO__
#define math_errhandling (MATH_ERREXCEPT)
#else
#define math_errhandling (MATH_ERRNO | MATH_ERREXCEPT)
#endif
#endif // math_errhandling not defined
}];
}
def IsFiniteMacro : MacroDef<"isfinite"> {
let Defn = [{
#define isfinite(x) __builtin_isfinite(x)
}];
}
def IsInfMacro : MacroDef<"isinf"> {
let Defn = [{
#define isinf(x) __builtin_isinf(x)
}];
}
def IsNanMacro : MacroDef<"isnan"> {
let Defn = [{
#define isnan(x) __builtin_isnan(x)
}];
}
def FloatT : TypeDecl<"float_t"> {
let Decl = [{
#define __need_float_t
#include <__llvm-libc-stdc-types.h>
}];
}
def DoubleT : TypeDecl<"double_t"> {
let Decl = [{
#define __need_double_t
#include <__llvm-libc-stdc-types.h>
}];
}
def MathAPI : PublicAPI<"math.h"> {
let Macros = [
SimpleMacroDef<"MATH_ERRNO", "1">,
SimpleMacroDef<"MATH_ERREXCEPT", "2">,
MathErrHandlingMacro,
SimpleMacroDef<"INFINITY", "__builtin_inff()">,
SimpleMacroDef<"NAN", "__builtin_nanf(\"\")">,
SimpleMacroDef<"FP_ILOGB0", "(-__INT_MAX__ - 1)">, // INT_MIN
SimpleMacroDef<"FP_ILOGBNAN", "__INT_MAX__">,
IsFiniteMacro,
IsInfMacro,
IsNanMacro,
];
let TypeDeclarations = [
DoubleT,
FloatT,
];
}
def FEnvT : TypeDecl<"fenv_t"> {
let Decl = [{
#ifdef __aarch64__
typedef struct {
unsigned char __control_word[4];
unsigned char __status_word[4];
} fenv_t;
#endif
#ifdef __x86_64__
typedef struct {
unsigned char __x86_status[28];
unsigned char __mxcsr[4];
} fenv_t;
#endif
}];
}
def FExceptT : TypeDecl<"fexcept_t"> {
let Decl = [{
typedef int fexcept_t;
}];
}
def FenvAPI: PublicAPI<"fenv.h"> {
let Macros = [
SimpleMacroDef<"FE_DIVBYZERO", "1">,
SimpleMacroDef<"FE_INEXACT", "2">,
SimpleMacroDef<"FE_INVALID", "4">,
SimpleMacroDef<"FE_OVERFLOW", "8">,
SimpleMacroDef<"FE_UNDERFLOW", "16">,
SimpleMacroDef<"FE_ALL_EXCEPT", "(FE_DIVBYZERO|FE_INEXACT|FE_INVALID|FE_OVERFLOW|FE_UNDERFLOW)">,
SimpleMacroDef<"FE_DOWNWARD", "1">,
SimpleMacroDef<"FE_TONEAREST", "2">,
SimpleMacroDef<"FE_TOWARDZERO", "4">,
SimpleMacroDef<"FE_UPWARD", "8">,
];
let TypeDeclarations = [
FEnvT,
FExceptT,
];
}
def StringAPI : PublicAPI<"string.h"> {
let TypeDeclarations = [
SizeT,
];
let Macros = [
NullMacro,
];
}
def StdIOAPI : PublicAPI<"stdio.h"> {
let TypeDeclarations = [
SizeT,
FILE,
];
}
def StdlibAPI : PublicAPI<"stdlib.h"> {
}
def TimeAPI : PublicAPI<"time.h"> {
let TypeDeclarations = [
StructTm,
TimeT,
];
let Functions = [
"gmtime",
"mktime",
];
}
def ErrnoAPI : PublicAPI<"errno.h"> {
let Macros = [
ErrnoMacro,
// We largely depend on linux/errno.h to give us the
// various error macro definitions. However, some libc
// implementations have chosen to provide definitions
// for some of the error macros to account for the ones
// missing in linux/errno.h. There is no harm in doing
// the same here if we define the macros only when they
// are not already defined.
MacroDefineIfNot<"ENOTSUP", "EOPNOTSUPP">,
MacroDefineIfNot<"ECANCELED", "125">,
MacroDefineIfNot<"EOWNERDEAD", "130">,
MacroDefineIfNot<"ENOTRECOVERABLE", "131">,
MacroDefineIfNot<"ERFKILL", "132">,
MacroDefineIfNot<"EHWPOISON", "133">,
];
}
def SysMManAPI : PublicAPI<"sys/mman.h"> {
let Macros = [
SimpleMacroDef<"PROT_NONE", "0">,
SimpleMacroDef<"PROT_READ", "1">,
SimpleMacroDef<"PROT_WRITE", "2">,
SimpleMacroDef<"PROT_EXEC", "4">,
SimpleMacroDef<"MAP_FIXED", "1">,
SimpleMacroDef<"MAP_PRIVATE", "2">,
SimpleMacroDef<"MAP_SHARED", "4">,
SimpleMacroDef<"MAP_FAILED", "((void*)-1)">,
// TODO: The value of 0x20 is good for x86_64, but has to be extended
// in some manner to accommodate other machine architectures.
SimpleMacroDef<"MAP_ANONYMOUS", "0x20">
// TODO: Add other MAP_* macros used by Linux.
];
let TypeDeclarations = [
SizeT,
OffT,
];
}
def StructSigactionDefn : TypeDecl<"struct sigaction"> {
let Decl = [{
struct __sigaction {
union {
void (*sa_handler)(int);
void (*sa_action)(int, siginfo_t *, void *);
};
sigset_t sa_mask;
int sa_flags;
void (*sa_restorer)(void);
};
}];
}
def SighandlerTDefn : TypeDecl<"__sighandler_t"> {
let Decl = [{
typedef void(*__sighandler_t)(int);
}];
}
def SignalAPI : PublicAPI<"signal.h"> {
let TypeDeclarations = [
StructSigactionDefn,
SighandlerTDefn,
];
}
def OnceFlag : TypeDecl<"once_flag"> {
let Decl = [{
typedef unsigned int once_flag;
}];
}
def MtxT : TypeDecl<"mtx_t"> {
let Decl = [{
typedef struct {
unsigned char __internal_data[4];
int __mtx_type;
} mtx_t;
}];
}
def ThreadStartT : TypeDecl<"thrd_start_t"> {
let Decl = "typedef int (*thrd_start_t)(void *);";
}
def CallOnceFuncT : TypeDecl<"__call_once_func_t"> {
let Decl = [{
typedef void(*__call_once_func_t)(void);
}];
}
def ThreadsAPI : PublicAPI<"threads.h"> {
let Macros = [
SimpleMacroDef<"ONCE_FLAG_INIT", "0">,
];
let TypeDeclarations = [
OnceFlag,
CallOnceFuncT,
MtxT,
ThreadStartT,
];
let Enumerations = [
"mtx_plain",
"mtx_recursive",
"mtx_timed",
"thrd_timedout",
"thrd_success",
"thrd_busy",
"thrd_error",
"thrd_nomem",
];
}
def UniStdAPI : PublicAPI<"unistd.h"> {
let TypeDeclarations = [
SSizeT,
SizeT,
];
}