Upstream status: https://github.com/D-Programming-GDC/gcc/pull/25 Backport of https://github.com/dlang/dmd/pull/22829 https://github.com/dlang/phobos/pull/10980 https://github.com/dlang/phobos/pull/8412 to gdc-11 with additional gdc specific changes. Also regenerates the autotools. From c09aace3abc9e63ad93b23daa4d1d98a1e19e2c7 Mon Sep 17 00:00:00 2001 From: Iain Buclaw Date: Fri, 18 Mar 2022 19:03:19 +0100 Subject: [PATCH 1/4] phobos: Add preliminary support for GNU/Hurd https://github.com/dlang/phobos/pull/8412 --- libphobos/src/std/datetime/systime.d | 27 +++++++++++++++++++++++++++ libphobos/src/std/file.d | 4 ++++ libphobos/src/std/parallelism.d | 5 +++++ 3 files changed, 36 insertions(+) diff --git a/libphobos/src/std/datetime/systime.d b/libphobos/src/std/datetime/systime.d index 913d360c6..fd3526de6 100644 --- a/libphobos/src/std/datetime/systime.d +++ b/libphobos/src/std/datetime/systime.d @@ -326,6 +326,33 @@ public: hnsecsToUnixEpoch; } } + else version (Hurd) + { + static if (clockType == ClockType.second) + return unixTimeToStdTime(core.stdc.time.time(null)); + else + { + import core.sys.hurd.time : CLOCK_REALTIME_COARSE; + import core.sys.posix.time : clock_gettime, CLOCK_REALTIME; + static if (clockType == ClockType.coarse) alias clockArg = CLOCK_REALTIME_COARSE; + else static if (clockType == ClockType.normal) alias clockArg = CLOCK_REALTIME; + else static if (clockType == ClockType.precise) alias clockArg = CLOCK_REALTIME; + else static assert(0, "Previous static if is wrong."); + timespec ts = void; + immutable error = clock_gettime(clockArg, &ts); + // Posix clock_gettime called with a valid address and valid clock_id is only + // permitted to fail if the number of seconds does not fit in time_t. If tv_sec + // is long or larger overflow won't happen before 292 billion years A.D. + static if (ts.tv_sec.max < long.max) + { + if (error) + throw new TimeException("Call to clock_gettime() failed"); + } + return convert!("seconds", "hnsecs")(ts.tv_sec) + + ts.tv_nsec / 100 + + hnsecsToUnixEpoch; + } + } else static assert(0, "Unsupported OS"); } else static assert(0, "Unsupported OS"); diff --git a/libphobos/src/std/file.d b/libphobos/src/std/file.d index 99530cbbe..620a068f6 100644 --- a/libphobos/src/std/file.d +++ b/libphobos/src/std/file.d @@ -2863,6 +2863,10 @@ else version (NetBSD) // Only Solaris 10 and later return readLink(format("/proc/%d/path/a.out", getpid())); } + else version (Hurd) + { + return readLink("/proc/self/exe"); + } else static assert(0, "thisExePath is not supported on this platform"); } diff --git a/libphobos/src/std/parallelism.d b/libphobos/src/std/parallelism.d index 61d5cea55..03b196c61 100644 --- a/libphobos/src/std/parallelism.d +++ b/libphobos/src/std/parallelism.d @@ -1011,6 +1011,11 @@ uint totalCPUsImpl() @nogc nothrow @trusted import core.sys.posix.unistd : _SC_NPROCESSORS_ONLN, sysconf; return cast(uint) sysconf(_SC_NPROCESSORS_ONLN); } + else version (Hurd) + { + import core.sys.posix.unistd : _SC_NPROCESSORS_ONLN, sysconf; + return cast(uint) sysconf(_SC_NPROCESSORS_ONLN); + } else { static assert(0, "Don't know how to get N CPUs on this OS."); -- 2.52.0 From 2a34e1604a6b4cb0142d5bee9973624a6abd4711 Mon Sep 17 00:00:00 2001 From: Yelninei Date: Sun, 19 Apr 2026 09:39:31 +0000 Subject: [PATCH 2/4] druntime: Backport support for GNU/Hurd. --- libphobos/libdruntime/core/stdc/config.d | 2 + libphobos/libdruntime/core/stdc/errno.d | 107 + libphobos/libdruntime/core/stdc/limits.d | 14 + libphobos/libdruntime/core/sys/hurd/config.d | 30 + libphobos/libdruntime/core/sys/hurd/dlfcn.d | 114 + libphobos/libdruntime/core/sys/hurd/elf.d | 2535 +++++++++++++++++ libphobos/libdruntime/core/sys/hurd/errno.d | 21 + .../libdruntime/core/sys/hurd/execinfo.d | 16 + libphobos/libdruntime/core/sys/hurd/link.d | 134 + .../libdruntime/core/sys/hurd/sys/types.d | 22 + libphobos/libdruntime/core/sys/hurd/time.d | 15 + libphobos/libdruntime/core/sys/hurd/unistd.d | 30 + libphobos/libdruntime/core/sys/linux/stdio.d | 1 + libphobos/libdruntime/core/sys/posix/dirent.d | 47 +- libphobos/libdruntime/core/sys/posix/fcntl.d | 129 +- .../libdruntime/core/sys/posix/netinet/in_.d | 58 +- libphobos/libdruntime/core/sys/posix/poll.d | 35 +- .../libdruntime/core/sys/posix/pthread.d | 218 +- .../libdruntime/core/sys/posix/semaphore.d | 32 +- libphobos/libdruntime/core/sys/posix/signal.d | 243 +- libphobos/libdruntime/core/sys/posix/spawn.d | 42 + .../libdruntime/core/sys/posix/sys/ipc.d | 53 +- .../libdruntime/core/sys/posix/sys/mman.d | 44 +- .../libdruntime/core/sys/posix/sys/msg.d | 44 + .../libdruntime/core/sys/posix/sys/resource.d | 66 +- .../libdruntime/core/sys/posix/sys/shm.d | 34 +- .../libdruntime/core/sys/posix/sys/socket.d | 174 +- .../libdruntime/core/sys/posix/sys/stat.d | 104 +- .../libdruntime/core/sys/posix/sys/statvfs.d | 153 +- .../libdruntime/core/sys/posix/sys/types.d | 653 +++-- libphobos/libdruntime/core/sys/posix/sys/un.d | 9 + .../libdruntime/core/sys/posix/sys/utsname.d | 39 +- .../libdruntime/core/sys/posix/sys/wait.d | 23 +- .../libdruntime/core/sys/posix/termios.d | 116 +- libphobos/libdruntime/core/sys/posix/time.d | 4 + libphobos/libdruntime/core/time.d | 25 + libphobos/libdruntime/gc/os.d | 2 +- libphobos/libdruntime/gcc/backtrace.d | 2 + libphobos/libdruntime/gcc/sections/elf.d | 9 + libphobos/src/std/mmfile.d | 2 +- 40 files changed, 4999 insertions(+), 402 deletions(-) create mode 100644 libphobos/libdruntime/core/sys/hurd/config.d create mode 100644 libphobos/libdruntime/core/sys/hurd/dlfcn.d create mode 100644 libphobos/libdruntime/core/sys/hurd/elf.d create mode 100644 libphobos/libdruntime/core/sys/hurd/errno.d create mode 100644 libphobos/libdruntime/core/sys/hurd/execinfo.d create mode 100644 libphobos/libdruntime/core/sys/hurd/link.d create mode 100644 libphobos/libdruntime/core/sys/hurd/sys/types.d create mode 100644 libphobos/libdruntime/core/sys/hurd/time.d create mode 100644 libphobos/libdruntime/core/sys/hurd/unistd.d diff --git a/libphobos/libdruntime/core/stdc/config.d b/libphobos/libdruntime/core/stdc/config.d index 44bb7077b..54eeb26e2 100644 --- a/libphobos/libdruntime/core/stdc/config.d +++ b/libphobos/libdruntime/core/stdc/config.d @@ -231,6 +231,8 @@ else version (DigitalMars) alias real c_long_double; else version (Darwin) alias real c_long_double; + else version (Hurd) + alias real c_long_double; } } diff --git a/libphobos/libdruntime/core/stdc/errno.d b/libphobos/libdruntime/core/stdc/errno.d index 57bc15da6..f6b0518c4 100644 --- a/libphobos/libdruntime/core/stdc/errno.d +++ b/libphobos/libdruntime/core/stdc/errno.d @@ -2079,6 +2079,113 @@ else version (Haiku) enum B_NO_TRANSLATOR = (B_TRANSLATION_ERROR_BASE + 1); enum B_ILLEGAL_DATA = (B_TRANSLATION_ERROR_BASE + 2); } +else version (Hurd) +{ + enum EPERM = 0x40000001; /* Operation not permitted */ + enum ENOENT = 0x40000002; /* No such file or directory */ + enum ESRCH = 0x40000003; /* No such process */ + enum EINTR = 0x40000004; /* Interrupted system call */ + enum EIO = 0x40000005; /* Input/output error */ + enum ENXIO = 0x40000006; /* No such device or address */ + enum E2BIG = 0x40000007; /* Argument list too long */ + enum ENOEXEC = 0x40000008; /*enum Exec format error */ + enum EBADF = 0x40000009; /* Bad file descriptor */ + enum ECHILD = 0x4000000a; /* No child processes */ + enum EDEADLK = 0x4000000b; /* Resource deadlock avoided */ + enum ENOMEM = 0x4000000c; /* Cannot allocate memory */ + enum EACCES = 0x4000000d; /* Permission denied */ + enum EFAULT = 0x4000000e; /* Bad address */ + enum ENOTBLK = 0x4000000f; /* Block device required */ + enum EBUSY = 0x40000010; /* Device or resource busy */ + enum EEXIST = 0x40000011; /* File exists */ + enum EXDEV = 0x40000012; /* Invalid cross-device link */ + enum ENODEV = 0x40000013; /* No such device */ + enum ENOTDIR = 0x40000014; /* Not a directory */ + enum EISDIR = 0x40000015; /* Is a directory */ + enum EINVAL = 0x40000016; /* Invalid argument */ + enum EMFILE = 0x40000018; /* Too many open files */ + enum ENFILE = 0x40000017; /* Too many open files in system */ + enum ENOTTY = 0x40000019; /* Inappropriate ioctl for device */ + enum ETXTBSY = 0x4000001a; /* Text file busy */ + enum EFBIG = 0x4000001b; /* File too large */ + enum ENOSPC = 0x4000001c; /* No space left on device */ + enum ESPIPE = 0x4000001d; /* Illegal seek */ + enum EROFS = 0x4000001e; /* Read-only file system */ + enum EMLINK = 0x4000001f; /* Too many links */ + enum EPIPE = 0x40000020; /* Broken pipe */ + enum EDOM = 0x40000021; /* Numerical argument out of domain */ + enum ERANGE = 0x40000022; /* Numerical result out of range */ + enum EAGAIN = 0x40000023; /* Resource temporarily unavailable */ + enum EINPROGRESS = 0x40000024; /* Operation now in progress */ + enum EALREADY = 0x40000025; /* Operation already in progress */ + enum ENOTSOCK = 0x40000026; /* Socket operation on non-socket */ + enum EMSGSIZE = 0x40000028; /* Message too long */ + enum EPROTOTYPE = 0x40000029; /* Protocol wrong type for socket */ + enum ENOPROTOOPT = 0x4000002a; /* Protocol not available */ + enum EPROTONOSUPPORT = 0x4000002b; /* Protocol not supported */ + enum ESOCKTNOSUPPORT = 0x4000002c; /* Socket type not supported */ + enum EOPNOTSUPP = 0x4000002d; /* Operation not supported */ + enum EPFNOSUPPORT = 0x4000002e; /* Protocol family not supported */ + enum EAFNOSUPPORT = 0x4000002f; /* Address family not supported by protocol */ + enum EADDRINUSE = 0x40000030; /* Address already in use */ + enum EADDRNOTAVAIL = 0x40000031; /* Cannot assign requested address */ + enum ENETDOWN = 0x40000032; /* Network is down */ + enum ENETUNREACH = 0x40000033; /* Network is unreachable */ + enum ENETRESET = 0x40000034; /* Network dropped connection on reset */ + enum ECONNABORTED = 0x40000035; /* Software caused connection abort */ + enum ECONNRESET = 0x40000036; /* Connection reset by peer */ + enum ENOBUFS = 0x40000037; /* No buffer space available */ + enum EISCONN = 0x40000038; /* Transport endpoint is already connected */ + enum ENOTCONN = 0x40000039; /* Transport endpoint is not connected */ + enum EDESTADDRREQ = 0x40000027; /* Destination address required */ + enum ESHUTDOWN = 0x4000003a; /* Cannot send after transport endpoint shutdown */ + enum ETOOMANYREFS = 0x4000003b; /* Too many references: cannot splice */ + enum ETIMEDOUT = 0x4000003c; /* Connection timed out */ + enum ECONNREFUSED = 0x4000003d; /* Connection refused */ + enum ELOOP = 0x4000003e; /* Too many levels of symbolic links */ + enum ENAMETOOLONG = 0x4000003f; /* File name too long */ + enum EHOSTDOWN = 0x40000040; /* Host is down */ + enum EHOSTUNREACH = 0x40000041; /* No route to host */ + enum ENOTEMPTY = 0x40000042; /* Directory not empty */ + enum EPROCLIM = 0x40000043; /* Too many processes */ + enum EUSERS = 0x40000044; /* Too many users */ + enum EDQUOT = 0x40000045; /* Disk quota exceeded */ + enum ESTALE = 0x40000046; /* Stale file handle */ + enum EREMOTE = 0x40000047; /* Object is remote */ + enum EBADRPC = 0x40000048; /* RPC struct is bad */ + enum ERPCMISMATCH = 0x40000049; /* RPC version wrong */ + enum EPROGUNAVAIL = 0x4000004a; /* RPC program not available */ + enum EPROGMISMATCH = 0x4000004b; /* RPC program version wrong */ + enum EPROCUNAVAIL = 0x4000004c; /* RPC bad procedure for program */ + enum ENOLCK = 0x4000004d; /* No locks available */ + enum EFTYPE = 0x4000004f; /* Inappropriate file type or format */ + enum EAUTH = 0x40000050; /* Authentication error */ + enum ENEEDAUTH = 0x40000051; /* Need authenticator */ + enum ENOSYS = 0x4000004e; /* Function not implemented */ + enum ELIBEXEC = 0x40000053; /* Cannot exec a shared library directly */ + enum ENOTSUP = 0x40000076; /* Not supported */ + enum EILSEQ = 0x4000006a; /* Invalid or incomplete multibyte or wide character */ + enum EBACKGROUND = 0x40000064; /* Inappropriate operation for background process */ + enum EDIED = 0x40000065; /* Translator died */ + enum ED = 0x40000066; /* ? */ + enum EGREGIOUS = 0x40000067; /* You really blew it this time */ + enum EIEIO = 0x40000068; /* Computer bought the farm */ + enum EGRATUITOUS = 0x40000069; /* Gratuitous error */ + enum EBADMSG = 0x4000006b; /* Bad message */ + enum EIDRM = 0x4000006c; /* Identifier removed */ + enum EMULTIHOP = 0x4000006d; /* Multihop attempted */ + enum ENODATA = 0x4000006e; /* No data available */ + enum ENOLINK = 0x4000006f; /* Link has been severed */ + enum ENOMSG = 0x40000070; /* No message of desired type */ + enum ENOSR = 0x40000071; /* Out of streams resources */ + enum ENOSTR = 0x40000072; /* Device not a stream */ + enum EOVERFLOW = 0x40000073; /* Value too large for defined data type */ + enum EPROTO = 0x40000074; /* Protocol error */ + enum ETIME = 0x40000075; /* Timer expired */ + enum ECANCELED = 0x40000077; /* Operation canceled */ + enum EOWNERDEAD = 0x40000078; /* Owner died */ + enum ENOTRECOVERABLE = 0x40000079; /* State not recoverable */ + } else { static assert(false, "Unsupported platform"); diff --git a/libphobos/libdruntime/core/stdc/limits.d b/libphobos/libdruntime/core/stdc/limits.d index f3f88006a..e67b0cb22 100644 --- a/libphobos/libdruntime/core/stdc/limits.d +++ b/libphobos/libdruntime/core/stdc/limits.d @@ -182,3 +182,17 @@ else version (Windows) /// enum PIPE_BUF = 5120; } +else version (Hurd) +{ + // no arbitrary fixed limits + /// + // enum MAX_CANON + /// + // enum MAX_INPUT + /// + enum NAME_MAX = 255; + /// + // enum PATH_MAX + /// + // enum PIPE_BUF +} diff --git a/libphobos/libdruntime/core/sys/hurd/config.d b/libphobos/libdruntime/core/sys/hurd/config.d new file mode 100644 index 000000000..109990d54 --- /dev/null +++ b/libphobos/libdruntime/core/sys/hurd/config.d @@ -0,0 +1,30 @@ +/** + * D header file for GNU/Hurd. + * + * Copyright: Copyright (c) 2026 D Language Foundation + * License: $(HTTP www.boost.org/LICENSE_1_0.txt, Boost License 1.0). + */ +module core.sys.hurd.config; + +version (Hurd): + +public import core.sys.posix.config; + +// man 7 feature_test_macros +// http://www.gnu.org/software/libc/manual/html_node/Feature-Test-Macros.html +enum _GNU_SOURCE = true; +// deduced +// http://sourceware.org/git/?p=glibc.git;a=blob;f=include/features.h +enum _DEFAULT_SOURCE = true; +enum _ATFILE_SOURCE = true; + +// _BSD_SOURCE and _SVID_SOURCE are deprecated aliases for _DEFAULT_SOURCE. +deprecated("use _DEFAULT_SOURCE") +{ + enum _BSD_SOURCE = true; + enum _SVID_SOURCE = true; +} + +enum __USE_MISC = _DEFAULT_SOURCE; +enum __USE_ATFILE = _ATFILE_SOURCE; +enum __USE_GNU = _GNU_SOURCE; diff --git a/libphobos/libdruntime/core/sys/hurd/dlfcn.d b/libphobos/libdruntime/core/sys/hurd/dlfcn.d new file mode 100644 index 000000000..430857621 --- /dev/null +++ b/libphobos/libdruntime/core/sys/hurd/dlfcn.d @@ -0,0 +1,114 @@ +/** + * D header file for GNU/Hurd. + * + * Copyright: Copyright (c) 2026 D Language Foundation + * License: $(HTTP www.boost.org/LICENSE_1_0.txt, Boost License 1.0). + * $(LINK2 http://sourceware.org/git/?p=glibc.git;a=blob;f=dlfcn/dlfcn.h, glibc dlfcn/dlfcn.h) + */ +module core.sys.hurd.dlfcn; + +version (Hurd): +extern (C): +nothrow: +@nogc: +@system: + + +public import core.sys.posix.dlfcn; +import core.sys.hurd.config; + +// + +// http://sourceware.org/git/?p=glibc.git;a=blob;f=bits/dlfcn.h +// enum RTLD_LAZY = 0x00001; // POSIX +// enum RTLD_NOW = 0x00002; // POSIX +enum RTLD_BINDING_MASK = 0x3; +enum RTLD_NOLOAD = 0x00004; +enum RTLD_DEEPBIND = 0x00008; + +// enum RTLD_GLOBAL = 0x00100; // POSIX +// enum RTLD_LOCAL = 0; // POSIX +enum RTLD_NODELETE = 0x01000; + +static if (__USE_GNU) +{ + RT DL_CALL_FCT(RT, Args...)(RT function(Args) fctp, auto ref Args args) + { + _dl_mcount_wrapper_check(cast(void*)fctp); + return fctp(args); + } + + void _dl_mcount_wrapper_check(void* __selfpc); +} +// + +static if (__USE_GNU) +{ + enum RTLD_NEXT = cast(void *)-1L; + enum RTLD_DEFAULT = cast(void *)0; + alias c_long Lmid_t; + enum LM_ID_BASE = 0; + enum LM_ID_NEWLM = -1; +} + +// void* dlopen(const scope char* __file, int __mode); // POSIX +// int dlclose(void* __handle); // POSIX +// void* dlsym(void* __handle, const scope char* __name); // POSIX + +static if (__USE_GNU) +{ + void* dlmopen(Lmid_t __nsid, const scope char* __file, int __mode); + void* dlvsym(void* __handle, const scope char* __name, const scope char* __version); +} + +// char* dlerror(); // POSIX + +static if (__USE_GNU) +{ + struct Dl_info + { + const(char)* dli_fname; + void* dli_fbase; + const(char)* dli_sname; + void* dli_saddr; + } + + int dladdr(const scope void* __address, Dl_info* __info); + int dladdr1(void* __address, Dl_info* __info, void** __extra_info, int __flags); + + enum + { + RTLD_DL_SYMENT = 1, + RTLD_DL_LINKMAP = 2, + } + + int dlinfo(void* __handle, int __request, void* __arg); + + enum + { + RTLD_DI_LMID = 1, + RTLD_DI_LINKMAP = 2, + RTLD_DI_CONFIGADDR = 3, + RTLD_DI_SERINFO = 4, + RTLD_DI_SERINFOSIZE = 5, + RTLD_DI_ORIGIN = 6, + RTLD_DI_PROFILENAME = 7, + RTLD_DI_PROFILEOUT = 8, + RTLD_DI_TLS_MODID = 9, + RTLD_DI_TLS_DATA = 10, + RTLD_DI_MAX = 10, + } + + struct Dl_serpath + { + char* dls_name; + uint dls_flags; + } + + struct Dl_serinfo + { + size_t dls_size; + uint dls_cnt; + Dl_serpath[1] dls_serpath; + } +} diff --git a/libphobos/libdruntime/core/sys/hurd/elf.d b/libphobos/libdruntime/core/sys/hurd/elf.d new file mode 100644 index 000000000..782e94376 --- /dev/null +++ b/libphobos/libdruntime/core/sys/hurd/elf.d @@ -0,0 +1,2535 @@ +/** + * D header file for GNU/Hurd. + * + * Copyright: Copyright (c) 2026 D Language Foundation + * License: $(HTTP www.boost.org/LICENSE_1_0.txt, Boost License 1.0). + * $(LINK2 http://sourceware.org/git/?p=glibc.git;a=blob;f=elf/elf.h, glibc elf/elf.h) + */ +module core.sys.hurd.elf; + +version (Hurd): +extern (C): +pure: +nothrow: +@system: + +import core.stdc.stdint; + +alias uint16_t Elf32_Half; +alias uint16_t Elf64_Half; + +alias uint32_t Elf32_Word; +alias int32_t Elf32_Sword; +alias uint32_t Elf64_Word; +alias int32_t Elf64_Sword; + +alias uint64_t Elf32_Xword; +alias int64_t Elf32_Sxword; +alias uint64_t Elf64_Xword; +alias int64_t Elf64_Sxword; + +alias uint32_t Elf32_Addr; +alias uint64_t Elf64_Addr; + +alias uint32_t Elf32_Off; +alias uint64_t Elf64_Off; + +alias uint16_t Elf32_Section; +alias uint16_t Elf64_Section; + +alias Elf32_Half Elf32_Versym; +alias Elf64_Half Elf64_Versym; + + +enum EI_NIDENT = 16; + +struct Elf32_Ehdr +{ + char[EI_NIDENT] e_ident = 0; + Elf32_Half e_type; + Elf32_Half e_machine; + Elf32_Word e_version; + Elf32_Addr e_entry; + Elf32_Off e_phoff; + Elf32_Off e_shoff; + Elf32_Word e_flags; + Elf32_Half e_ehsize; + Elf32_Half e_phentsize; + Elf32_Half e_phnum; + Elf32_Half e_shentsize; + Elf32_Half e_shnum; + Elf32_Half e_shstrndx; +} + +struct Elf64_Ehdr +{ + char[EI_NIDENT] e_ident = 0; + Elf64_Half e_type; + Elf64_Half e_machine; + Elf64_Word e_version; + Elf64_Addr e_entry; + Elf64_Off e_phoff; + Elf64_Off e_shoff; + Elf64_Word e_flags; + Elf64_Half e_ehsize; + Elf64_Half e_phentsize; + Elf64_Half e_phnum; + Elf64_Half e_shentsize; + Elf64_Half e_shnum; + Elf64_Half e_shstrndx; +} + +enum EI_MAG0 = 0; +enum ELFMAG0 = 0x7f; + +enum EI_MAG1 = 1; +enum ELFMAG1 = 'E'; + +enum EI_MAG2 = 2; +enum ELFMAG2 = 'L'; + +enum EI_MAG3 = 3; +enum ELFMAG3 = 'F'; +enum ELFMAG = "\177ELF"; +enum SELFMAG = 4; + +enum EI_CLASS = 4; +enum ELFCLASSNONE = 0; +enum ELFCLASS32 = 1; +enum ELFCLASS64 = 2; +enum ELFCLASSNUM = 3; + +enum EI_DATA = 5; +enum ELFDATANONE = 0; +enum ELFDATA2LSB = 1; +enum ELFDATA2MSB = 2; +enum ELFDATANUM = 3; + +enum EI_VERSION = 6; + +enum EI_OSABI = 7; +enum ELFOSABI_NONE = 0; +enum ELFOSABI_SYSV = 0; +enum ELFOSABI_HPUX = 1; +enum ELFOSABI_NETBSD = 2; +enum ELFOSABI_GNU = 3; +enum ELFOSABI_LINUX = ELFOSABI_GNU; +enum ELFOSABI_SOLARIS = 6; +enum ELFOSABI_AIX = 7; +enum ELFOSABI_IRIX = 8; +enum ELFOSABI_FREEBSD = 9; +enum ELFOSABI_TRU64 = 10; +enum ELFOSABI_MODESTO = 11; +enum ELFOSABI_OPENBSD = 12; +enum ELFOSABI_ARM_AEABI = 64; +enum ELFOSABI_ARM = 97; +enum ELFOSABI_STANDALONE = 255; +enum ELFOSABI_DRAGONFLYBSD = ELFOSABI_NONE; + +enum EI_ABIVERSION = 8; + +enum EI_PAD = 9; + +enum ET_NONE = 0; +enum ET_REL = 1; +enum ET_EXEC = 2; +enum ET_DYN = 3; +enum ET_CORE = 4; +enum ET_NUM = 5; +enum ET_LOOS = 0xfe00; +enum ET_HIOS = 0xfeff; +enum ET_LOPROC = 0xff00; +enum ET_HIPROC = 0xffff; + +enum EM_NONE = 0; +enum EM_M32 = 1; +enum EM_SPARC = 2; +enum EM_386 = 3; +enum EM_68K = 4; +enum EM_88K = 5; +enum EM_860 = 7; +enum EM_MIPS = 8; +enum EM_S370 = 9; +enum EM_MIPS_RS3_LE = 10; + +enum EM_PARISC = 15; +enum EM_VPP500 = 17; +enum EM_SPARC32PLUS = 18; +enum EM_960 = 19; +enum EM_PPC = 20; +enum EM_PPC64 = 21; +enum EM_S390 = 22; + +enum EM_V800 = 36; +enum EM_FR20 = 37; +enum EM_RH32 = 38; +enum EM_RCE = 39; +enum EM_ARM = 40; +enum EM_FAKE_ALPHA = 41; +enum EM_SH = 42; +enum EM_SPARCV9 = 43; +enum EM_TRICORE = 44; +enum EM_ARC = 45; +enum EM_H8_300 = 46; +enum EM_H8_300H = 47; +enum EM_H8S = 48; +enum EM_H8_500 = 49; +enum EM_IA_64 = 50; +enum EM_MIPS_X = 51; +enum EM_COLDFIRE = 52; +enum EM_68HC12 = 53; +enum EM_MMA = 54; +enum EM_PCP = 55; +enum EM_NCPU = 56; +enum EM_NDR1 = 57; +enum EM_STARCORE = 58; +enum EM_ME16 = 59; +enum EM_ST100 = 60; +enum EM_TINYJ = 61; +enum EM_X86_64 = 62; +enum EM_PDSP = 63; + +enum EM_FX66 = 66; +enum EM_ST9PLUS = 67; +enum EM_ST7 = 68; +enum EM_68HC16 = 69; +enum EM_68HC11 = 70; +enum EM_68HC08 = 71; +enum EM_68HC05 = 72; +enum EM_SVX = 73; +enum EM_ST19 = 74; +enum EM_VAX = 75; +enum EM_CRIS = 76; +enum EM_JAVELIN = 77; +enum EM_FIREPATH = 78; +enum EM_ZSP = 79; +enum EM_MMIX = 80; +enum EM_HUANY = 81; +enum EM_PRISM = 82; +enum EM_AVR = 83; +enum EM_FR30 = 84; +enum EM_D10V = 85; +enum EM_D30V = 86; +enum EM_V850 = 87; +enum EM_M32R = 88; +enum EM_MN10300 = 89; +enum EM_MN10200 = 90; +enum EM_PJ = 91; +enum EM_OPENRISC = 92; +enum EM_ARC_A5 = 93; +enum EM_XTENSA = 94; +enum EM_AARCH64 = 183; +enum EM_TILEPRO = 188; +enum EM_TILEGX = 191; +enum EM_NUM = 192; + +enum EM_ALPHA = 0x9026; + +enum EV_NONE = 0; +enum EV_CURRENT = 1; +enum EV_NUM = 2; + +struct Elf32_Shdr +{ + Elf32_Word sh_name; + Elf32_Word sh_type; + Elf32_Word sh_flags; + Elf32_Addr sh_addr; + Elf32_Off sh_offset; + Elf32_Word sh_size; + Elf32_Word sh_link; + Elf32_Word sh_info; + Elf32_Word sh_addralign; + Elf32_Word sh_entsize; +} + +struct Elf64_Shdr +{ + Elf64_Word sh_name; + Elf64_Word sh_type; + Elf64_Xword sh_flags; + Elf64_Addr sh_addr; + Elf64_Off sh_offset; + Elf64_Xword sh_size; + Elf64_Word sh_link; + Elf64_Word sh_info; + Elf64_Xword sh_addralign; + Elf64_Xword sh_entsize; +} + +enum SHN_UNDEF = 0; +enum SHN_LORESERVE = 0xff00; +enum SHN_LOPROC = 0xff00; +enum SHN_BEFORE = 0xff00; +enum SHN_AFTER = 0xff01; +enum SHN_HIPROC = 0xff1f; +enum SHN_LOOS = 0xff20; +enum SHN_HIOS = 0xff3f; +enum SHN_ABS = 0xfff1; +enum SHN_COMMON = 0xfff2; +enum SHN_XINDEX = 0xffff; +enum SHN_HIRESERVE = 0xffff; + +enum SHT_NULL = 0; +enum SHT_PROGBITS = 1; +enum SHT_SYMTAB = 2; +enum SHT_STRTAB = 3; +enum SHT_RELA = 4; +enum SHT_HASH = 5; +enum SHT_DYNAMIC = 6; +enum SHT_NOTE = 7; +enum SHT_NOBITS = 8; +enum SHT_REL = 9; +enum SHT_SHLIB = 10; +enum SHT_DYNSYM = 11; +enum SHT_INIT_ARRAY = 14; +enum SHT_FINI_ARRAY = 15; +enum SHT_PREINIT_ARRAY = 16; +enum SHT_GROUP = 17; +enum SHT_SYMTAB_SHNDX = 18; +enum SHT_NUM = 19; +enum SHT_LOOS = 0x60000000; +enum SHT_GNU_ATTRIBUTES = 0x6ffffff5; +enum SHT_GNU_HASH = 0x6ffffff6; +enum SHT_GNU_LIBLIST = 0x6ffffff7; +enum SHT_CHECKSUM = 0x6ffffff8; +enum SHT_LOSUNW = 0x6ffffffa; +enum SHT_SUNW_move = 0x6ffffffa; +enum SHT_SUNW_COMDAT = 0x6ffffffb; +enum SHT_SUNW_syminfo = 0x6ffffffc; +enum SHT_GNU_verdef = 0x6ffffffd; +enum SHT_GNU_verneed = 0x6ffffffe; +enum SHT_GNU_versym = 0x6fffffff; +enum SHT_HISUNW = 0x6fffffff; +enum SHT_HIOS = 0x6fffffff; +enum SHT_LOPROC = 0x70000000; +enum SHT_HIPROC = 0x7fffffff; +enum SHT_LOUSER = 0x80000000; +enum SHT_HIUSER = 0x8fffffff; + +enum SHF_WRITE = (1 << 0); +enum SHF_ALLOC = (1 << 1); +enum SHF_EXECINSTR = (1 << 2); +enum SHF_MERGE = (1 << 4); +enum SHF_STRINGS = (1 << 5); +enum SHF_INFO_LINK = (1 << 6); +enum SHF_LINK_ORDER = (1 << 7); +enum SHF_OS_NONCONFORMING = (1 << 8); +enum SHF_GROUP = (1 << 9); +enum SHF_TLS = (1 << 10); +enum SHF_COMPRESSED = (1 << 11); +enum SHF_MASKOS = 0x0ff00000; +enum SHF_MASKPROC = 0xf0000000; +enum SHF_ORDERED = (1 << 30); +enum SHF_EXCLUDE = (1 << 31); +enum GRP_COMDAT = 0x1; + +struct Elf32_Sym +{ + Elf32_Word st_name; + Elf32_Addr st_value; + Elf32_Word st_size; + ubyte st_info; + ubyte st_other; + Elf32_Section st_shndx; +} + +struct Elf64_Sym +{ + Elf64_Word st_name; + ubyte st_info; + ubyte st_other; + Elf64_Section st_shndx; + Elf64_Addr st_value; + Elf64_Xword st_size; +} + +struct Elf32_Syminfo +{ + Elf32_Half si_boundto; + Elf32_Half si_flags; +} + +struct Elf64_Syminfo +{ + Elf64_Half si_boundto; + Elf64_Half si_flags; +} +enum SYMINFO_BT_SELF = 0xffff; +enum SYMINFO_BT_PARENT = 0xfffe; +enum SYMINFO_BT_LOWRESERVE = 0xff00; +enum SYMINFO_FLG_DIRECT = 0x0001; +enum SYMINFO_FLG_PASSTHRU = 0x0002; +enum SYMINFO_FLG_COPY = 0x0004; +enum SYMINFO_FLG_LAZYLOAD = 0x0008; +enum SYMINFO_NONE = 0; +enum SYMINFO_CURRENT = 1; +enum SYMINFO_NUM = 2; + +extern (D) +{ + auto ELF32_ST_BIND(T)(T val) { return cast(ubyte)val >> 4; } + auto ELF32_ST_TYPE(T)(T val) { return val & 0xf; } + auto ELF32_ST_INFO(B, T)(B bind, T type) { return (bind << 4) + (type & 0xf); } + alias ELF32_ST_BIND ELF64_ST_BIND; + alias ELF32_ST_TYPE ELF64_ST_TYPE; + alias ELF32_ST_INFO ELF64_ST_INFO; +} + +enum STB_LOCAL = 0; +enum STB_GLOBAL = 1; +enum STB_WEAK = 2; +enum STB_NUM = 3; +enum STB_LOOS = 10; +enum STB_GNU_UNIQUE = 10; +enum STB_HIOS = 12; +enum STB_LOPROC = 13; +enum STB_HIPROC = 15; + +enum STT_NOTYPE = 0; +enum STT_OBJECT = 1; +enum STT_FUNC = 2; +enum STT_SECTION = 3; +enum STT_FILE = 4; +enum STT_COMMON = 5; +enum STT_TLS = 6; +enum STT_NUM = 7; +enum STT_LOOS = 10; +enum STT_GNU_IFUNC = 10; +enum STT_HIOS = 12; +enum STT_LOPROC = 13; +enum STT_HIPROC = 15; + +enum STN_UNDEF = 0; + +extern (D) +{ + auto ELF32_ST_VISIBILITY(O)(O o) { return o & 0x03; } + alias ELF32_ST_VISIBILITY ELF64_ST_VISIBILITY; +} +enum STV_DEFAULT = 0; +enum STV_INTERNAL = 1; +enum STV_HIDDEN = 2; +enum STV_PROTECTED = 3; + +struct Elf32_Rel +{ + Elf32_Addr r_offset; + Elf32_Word r_info; +} + +struct Elf64_Rel +{ + Elf64_Addr r_offset; + Elf64_Xword r_info; +} + +struct Elf32_Rela +{ + Elf32_Addr r_offset; + Elf32_Word r_info; + Elf32_Sword r_addend; +} + +struct Elf64_Rela +{ + Elf64_Addr r_offset; + Elf64_Xword r_info; + Elf64_Sxword r_addend; +} + +extern (D) +{ + auto ELF32_R_SYM(V)(V val) { return val >> 8; } + auto ELF32_R_TYPE(V)(V val) { return val & 0xff; } + auto ELF32_R_INFO(S, T)(S sym, T type) { return (sym << 8) + (type & 0xff); } + + auto ELF64_R_SYM(I)(I i) { return i >> 32; } + auto ELF64_R_TYPE(I)(I i) { return i & 0xffffffff; } + auto ELF64_R_INFO(S, T)(S sym, T type) { return (sym << 32) + (type); } +} + +struct Elf32_Phdr +{ + Elf32_Word p_type; + Elf32_Off p_offset; + Elf32_Addr p_vaddr; + Elf32_Addr p_paddr; + Elf32_Word p_filesz; + Elf32_Word p_memsz; + Elf32_Word p_flags; + Elf32_Word p_align; +} + +struct Elf64_Phdr +{ + Elf64_Word p_type; + Elf64_Word p_flags; + Elf64_Off p_offset; + Elf64_Addr p_vaddr; + Elf64_Addr p_paddr; + Elf64_Xword p_filesz; + Elf64_Xword p_memsz; + Elf64_Xword p_align; +} + +enum PN_XNUM = 0xffff; + +enum PT_NULL = 0; +enum PT_LOAD = 1; +enum PT_DYNAMIC = 2; +enum PT_INTERP = 3; +enum PT_NOTE = 4; +enum PT_SHLIB = 5; +enum PT_PHDR = 6; +enum PT_TLS = 7; +enum PT_NUM = 8; +enum PT_LOOS = 0x60000000; +enum PT_GNU_EH_FRAME = 0x6474e550; +enum PT_GNU_STACK = 0x6474e551; +enum PT_GNU_RELRO = 0x6474e552; +enum PT_LOSUNW = 0x6ffffffa; +enum PT_SUNWBSS = 0x6ffffffa; +enum PT_SUNWSTACK = 0x6ffffffb; +enum PT_HISUNW = 0x6fffffff; +enum PT_HIOS = 0x6fffffff; +enum PT_LOPROC = 0x70000000; +enum PT_HIPROC = 0x7fffffff; + +enum PF_X = (1 << 0); +enum PF_W = (1 << 1); +enum PF_R = (1 << 2); +enum PF_MASKOS = 0x0ff00000; +enum PF_MASKPROC = 0xf0000000; + +enum NT_PRSTATUS = 1; +enum NT_FPREGSET = 2; +enum NT_PRPSINFO = 3; +enum NT_PRXREG = 4; +enum NT_TASKSTRUCT = 4; +enum NT_PLATFORM = 5; +enum NT_AUXV = 6; +enum NT_GWINDOWS = 7; +enum NT_ASRS = 8; +enum NT_PSTATUS = 10; +enum NT_PSINFO = 13; +enum NT_PRCRED = 14; +enum NT_UTSNAME = 15; +enum NT_LWPSTATUS = 16; +enum NT_LWPSINFO = 17; +enum NT_PRFPXREG = 20; +enum NT_SIGINFO = 0x53494749; +enum NT_FILE = 0x46494c45; +enum NT_PRXFPREG = 0x46e62b7f; +enum NT_PPC_VMX = 0x100; +enum NT_PPC_SPE = 0x101; +enum NT_PPC_VSX = 0x102; +enum NT_386_TLS = 0x200; +enum NT_386_IOPERM = 0x201; +enum NT_X86_XSTATE = 0x202; +enum NT_S390_HIGH_GPRS = 0x300; +enum NT_S390_TIMER = 0x301; +enum NT_S390_TODCMP = 0x302; +enum NT_S390_TODPREG = 0x303; +enum NT_S390_CTRS = 0x304; +enum NT_S390_PREFIX = 0x305; +enum NT_S390_LAST_BREAK = 0x306; +enum NT_S390_SYSTEM_CALL = 0x307; +enum NT_S390_TDB = 0x308; +enum NT_ARM_VFP = 0x400; +enum NT_ARM_TLS = 0x401; +enum NT_ARM_HW_BREAK = 0x402; +enum NT_ARM_HW_WATCH = 0x403; + +enum NT_VERSION = 1; + +struct Elf32_Dyn +{ + Elf32_Sword d_tag; + union _d_un + { + Elf32_Word d_val; + Elf32_Addr d_ptr; + } _d_un d_un; +} + +struct Elf64_Dyn +{ + Elf64_Sxword d_tag; + union _d_un + { + Elf64_Xword d_val; + Elf64_Addr d_ptr; + } _d_un d_un; +} + +enum DT_NULL = 0; +enum DT_NEEDED = 1; +enum DT_PLTRELSZ = 2; +enum DT_PLTGOT = 3; +enum DT_HASH = 4; +enum DT_STRTAB = 5; +enum DT_SYMTAB = 6; +enum DT_RELA = 7; +enum DT_RELASZ = 8; +enum DT_RELAENT = 9; +enum DT_STRSZ = 10; +enum DT_SYMENT = 11; +enum DT_INIT = 12; +enum DT_FINI = 13; +enum DT_SONAME = 14; +enum DT_RPATH = 15; +enum DT_SYMBOLIC = 16; +enum DT_REL = 17; +enum DT_RELSZ = 18; +enum DT_RELENT = 19; +enum DT_PLTREL = 20; +enum DT_DEBUG = 21; +enum DT_TEXTREL = 22; +enum DT_JMPREL = 23; +enum DT_BIND_NOW = 24; +enum DT_INIT_ARRAY = 25; +enum DT_FINI_ARRAY = 26; +enum DT_INIT_ARRAYSZ = 27; +enum DT_FINI_ARRAYSZ = 28; +enum DT_RUNPATH = 29; +enum DT_FLAGS = 30; +enum DT_ENCODING = 32; +enum DT_PREINIT_ARRAY = 32; +enum DT_PREINIT_ARRAYSZ = 33; +enum DT_NUM = 34; +enum DT_LOOS = 0x6000000d; +enum DT_HIOS = 0x6ffff000; +enum DT_LOPROC = 0x70000000; +enum DT_HIPROC = 0x7fffffff; +enum DT_PROCNUM = DT_MIPS_NUM; +enum DT_VALRNGLO = 0x6ffffd00; +enum DT_GNU_PRELINKED = 0x6ffffdf5; +enum DT_GNU_CONFLICTSZ = 0x6ffffdf6; +enum DT_GNU_LIBLISTSZ = 0x6ffffdf7; +enum DT_CHECKSUM = 0x6ffffdf8; +enum DT_PLTPADSZ = 0x6ffffdf9; +enum DT_MOVEENT = 0x6ffffdfa; +enum DT_MOVESZ = 0x6ffffdfb; +enum DT_FEATURE_1 = 0x6ffffdfc; +enum DT_POSFLAG_1 = 0x6ffffdfd; +enum DT_SYMINSZ = 0x6ffffdfe; +enum DT_SYMINENT = 0x6ffffdff; +enum DT_VALRNGHI = 0x6ffffdff; +extern (D) auto DT_VALTAGIDX(T)(T tag) +{ + return DT_VALRNGHI - tag; +} +enum DT_VALNUM = 12; +enum DT_ADDRRNGLO = 0x6ffffe00; +enum DT_GNU_HASH = 0x6ffffef5; +enum DT_TLSDESC_PLT = 0x6ffffef6; +enum DT_TLSDESC_GOT = 0x6ffffef7; +enum DT_GNU_CONFLICT = 0x6ffffef8; +enum DT_GNU_LIBLIST = 0x6ffffef9; +enum DT_CONFIG = 0x6ffffefa; +enum DT_DEPAUDIT = 0x6ffffefb; +enum DT_AUDIT = 0x6ffffefc; +enum DT_PLTPAD = 0x6ffffefd; +enum DT_MOVETAB = 0x6ffffefe; +enum DT_SYMINFO = 0x6ffffeff; +enum DT_ADDRRNGHI = 0x6ffffeff; +extern (D) auto DT_ADDRTAGIDX(T)(T tag) +{ + return DT_ADDRRNGHI - tag; +} +enum DT_ADDRNUM = 11; +enum DT_VERSYM = 0x6ffffff0; + +enum DT_RELACOUNT = 0x6ffffff9; +enum DT_RELCOUNT = 0x6ffffffa; +enum DT_FLAGS_1 = 0x6ffffffb; +enum DT_VERDEF = 0x6ffffffc; +enum DT_VERDEFNUM = 0x6ffffffd; +enum DT_VERNEED = 0x6ffffffe; +enum DT_VERNEEDNUM = 0x6fffffff; +extern (D) auto DT_VERSIONTAGIDX(T)(T tag) +{ + return DT_VERNEEDNUM - tag; +} +enum DT_VERSIONTAGNUM = 16; +enum DT_AUXILIARY = 0x7ffffffd; +enum DT_FILTER = 0x7fffffff; +extern (D) auto DT_EXTRATAGIDX(T)(T tag) +{ + return cast(Elf32_Word)(-(cast(Elf32_Sword)(tag) <<1>>1)-1); +} +enum DT_EXTRANUM = 3; +enum DF_ORIGIN = 0x00000001; +enum DF_SYMBOLIC = 0x00000002; +enum DF_TEXTREL = 0x00000004; +enum DF_BIND_NOW = 0x00000008; +enum DF_STATIC_TLS = 0x00000010; +enum DF_1_NOW = 0x00000001; +enum DF_1_GLOBAL = 0x00000002; +enum DF_1_GROUP = 0x00000004; +enum DF_1_NODELETE = 0x00000008; +enum DF_1_LOADFLTR = 0x00000010; +enum DF_1_INITFIRST = 0x00000020; +enum DF_1_NOOPEN = 0x00000040; +enum DF_1_ORIGIN = 0x00000080; +enum DF_1_DIRECT = 0x00000100; +enum DF_1_TRANS = 0x00000200; +enum DF_1_INTERPOSE = 0x00000400; +enum DF_1_NODEFLIB = 0x00000800; +enum DF_1_NODUMP = 0x00001000; +enum DF_1_CONFALT = 0x00002000; +enum DF_1_ENDFILTEE = 0x00004000; +enum DF_1_DISPRELDNE = 0x00008000; +enum DF_1_DISPRELPND = 0x00010000; +enum DF_1_NODIRECT = 0x00020000; +enum DF_1_IGNMULDEF = 0x00040000; +enum DF_1_NOKSYMS = 0x00080000; +enum DF_1_NOHDR = 0x00100000; +enum DF_1_EDITED = 0x00200000; +enum DF_1_NORELOC = 0x00400000; +enum DF_1_SYMINTPOSE = 0x00800000; +enum DF_1_GLOBAUDIT = 0x01000000; +enum DF_1_SINGLETON = 0x02000000; +enum DTF_1_PARINIT = 0x00000001; +enum DTF_1_CONFEXP = 0x00000002; +enum DF_P1_LAZYLOAD = 0x00000001; +enum DF_P1_GROUPPERM = 0x00000002; + +struct Elf32_Verdef +{ + Elf32_Half vd_version; + Elf32_Half vd_flags; + Elf32_Half vd_ndx; + Elf32_Half vd_cnt; + Elf32_Word vd_hash; + Elf32_Word vd_aux; + Elf32_Word vd_next; +} + +struct Elf64_Verdef +{ + Elf64_Half vd_version; + Elf64_Half vd_flags; + Elf64_Half vd_ndx; + Elf64_Half vd_cnt; + Elf64_Word vd_hash; + Elf64_Word vd_aux; + Elf64_Word vd_next; +} +enum VER_DEF_NONE = 0; +enum VER_DEF_CURRENT = 1; +enum VER_DEF_NUM = 2; +enum VER_FLG_BASE = 0x1; +enum VER_FLG_WEAK = 0x2; +enum VER_NDX_LOCAL = 0; +enum VER_NDX_GLOBAL = 1; +enum VER_NDX_LORESERVE = 0xff00; +enum VER_NDX_ELIMINATE = 0xff01; + +struct Elf32_Verdaux +{ + Elf32_Word vda_name; + Elf32_Word vda_next; +} + +struct Elf64_Verdaux +{ + Elf64_Word vda_name; + Elf64_Word vda_next; +} + +struct Elf32_Verneed +{ + Elf32_Half vn_version; + Elf32_Half vn_cnt; + Elf32_Word vn_file; + Elf32_Word vn_aux; + Elf32_Word vn_next; +} + +struct Elf64_Verneed +{ + Elf64_Half vn_version; + Elf64_Half vn_cnt; + Elf64_Word vn_file; + Elf64_Word vn_aux; + Elf64_Word vn_next; +} +enum VER_NEED_NONE = 0; +enum VER_NEED_CURRENT = 1; +enum VER_NEED_NUM = 2; + +struct Elf32_Vernaux +{ + Elf32_Word vna_hash; + Elf32_Half vna_flags; + Elf32_Half vna_other; + Elf32_Word vna_name; + Elf32_Word vna_next; +} + +struct Elf64_Vernaux +{ + Elf64_Word vna_hash; + Elf64_Half vna_flags; + Elf64_Half vna_other; + Elf64_Word vna_name; + Elf64_Word vna_next; +} +// duplicate +// enum VER_FLG_WEAK = 0x2; + +struct Elf32_auxv_t +{ + uint32_t a_type; + union _a_un + { + uint32_t a_val; + } _a_un a_un; +} + +struct Elf64_auxv_t +{ + uint64_t a_type; + union _a_un + { + uint64_t a_val; + } _a_un a_un; +} + +enum AT_NULL = 0; +enum AT_IGNORE = 1; +enum AT_EXECFD = 2; +enum AT_PHDR = 3; +enum AT_PHENT = 4; +enum AT_PHNUM = 5; +enum AT_PAGESZ = 6; +enum AT_BASE = 7; +enum AT_FLAGS = 8; +enum AT_ENTRY = 9; +enum AT_NOTELF = 10; +enum AT_UID = 11; +enum AT_EUID = 12; +enum AT_GID = 13; +enum AT_EGID = 14; +enum AT_CLKTCK = 17; +enum AT_PLATFORM = 15; +enum AT_HWCAP = 16; +enum AT_FPUCW = 18; +enum AT_DCACHEBSIZE = 19; +enum AT_ICACHEBSIZE = 20; +enum AT_UCACHEBSIZE = 21; +enum AT_IGNOREPPC = 22; + +enum AT_SECURE = 23; + +enum AT_BASE_PLATFORM = 24; + +enum AT_RANDOM = 25; + +enum AT_HWCAP2 = 26; + +enum AT_EXECFN = 31; +enum AT_SYSINFO = 32; +enum AT_SYSINFO_EHDR = 33; + +enum AT_L1I_CACHESHAPE = 34; +enum AT_L1D_CACHESHAPE = 35; +enum AT_L2_CACHESHAPE = 36; +enum AT_L3_CACHESHAPE = 37; + +struct Elf32_Nhdr +{ + Elf32_Word n_namesz; + Elf32_Word n_descsz; + Elf32_Word n_type; +} + +struct Elf64_Nhdr +{ + Elf64_Word n_namesz; + Elf64_Word n_descsz; + Elf64_Word n_type; +} +enum ELF_NOTE_SOLARIS = "SUNW Solaris"; +enum ELF_NOTE_GNU = "GNU"; +enum ELF_NOTE_PAGESIZE_HINT = 1; +enum NT_GNU_ABI_TAG = 1; +enum ELF_NOTE_ABI = NT_GNU_ABI_TAG; +enum ELF_NOTE_OS_LINUX = 0; +enum ELF_NOTE_OS_GNU = 1; +enum ELF_NOTE_OS_SOLARIS2 = 2; +enum ELF_NOTE_OS_FREEBSD = 3; +enum NT_GNU_HWCAP = 2; +enum NT_GNU_BUILD_ID = 3; +enum NT_GNU_GOLD_VERSION = 4; +struct Elf32_Move +{ + Elf32_Xword m_value; + Elf32_Word m_info; + Elf32_Word m_poffset; + Elf32_Half m_repeat; + Elf32_Half m_stride; +} + +struct Elf64_Move +{ + Elf64_Xword m_value; + Elf64_Xword m_info; + Elf64_Xword m_poffset; + Elf64_Half m_repeat; + Elf64_Half m_stride; +} +extern (D) +{ + auto ELF32_M_SYM(I)(I info) { return info >> 8; } + auto ELF32_M_SIZE(I)(I info) { return cast(ubyte)info; } + auto ELF32_M_INFO(S, SZ)(S sym, SZ size) { return (sym << 8) + cast(ubyte)size; } +} + +alias ELF32_M_SYM ELF64_M_SYM; +alias ELF32_M_SIZE ELF64_M_SIZE; +alias ELF32_M_INFO ELF64_M_INFO; +enum EF_CPU32 = 0x00810000; + +enum R_68K_NONE = 0; +enum R_68K_32 = 1; +enum R_68K_16 = 2; +enum R_68K_8 = 3; +enum R_68K_PC32 = 4; +enum R_68K_PC16 = 5; +enum R_68K_PC8 = 6; +enum R_68K_GOT32 = 7; +enum R_68K_GOT16 = 8; +enum R_68K_GOT8 = 9; +enum R_68K_GOT32O = 10; +enum R_68K_GOT16O = 11; +enum R_68K_GOT8O = 12; +enum R_68K_PLT32 = 13; +enum R_68K_PLT16 = 14; +enum R_68K_PLT8 = 15; +enum R_68K_PLT32O = 16; +enum R_68K_PLT16O = 17; +enum R_68K_PLT8O = 18; +enum R_68K_COPY = 19; +enum R_68K_GLOB_DAT = 20; +enum R_68K_JMP_SLOT = 21; +enum R_68K_RELATIVE = 22; +enum R_68K_TLS_GD32 = 25; +enum R_68K_TLS_GD16 = 26; +enum R_68K_TLS_GD8 = 27; +enum R_68K_TLS_LDM32 = 28; +enum R_68K_TLS_LDM16 = 29; +enum R_68K_TLS_LDM8 = 30; +enum R_68K_TLS_LDO32 = 31; +enum R_68K_TLS_LDO16 = 32; +enum R_68K_TLS_LDO8 = 33; +enum R_68K_TLS_IE32 = 34; +enum R_68K_TLS_IE16 = 35; +enum R_68K_TLS_IE8 = 36; +enum R_68K_TLS_LE32 = 37; +enum R_68K_TLS_LE16 = 38; +enum R_68K_TLS_LE8 = 39; +enum R_68K_TLS_DTPMOD32 = 40; +enum R_68K_TLS_DTPREL32 = 41; +enum R_68K_TLS_TPREL32 = 42; +enum R_68K_NUM = 43; + +enum R_386_NONE = 0; +enum R_386_32 = 1; +enum R_386_PC32 = 2; +enum R_386_GOT32 = 3; +enum R_386_PLT32 = 4; +enum R_386_COPY = 5; +enum R_386_GLOB_DAT = 6; +enum R_386_JMP_SLOT = 7; +enum R_386_RELATIVE = 8; +enum R_386_GOTOFF = 9; +enum R_386_GOTPC = 10; +enum R_386_32PLT = 11; +enum R_386_TLS_TPOFF = 14; +enum R_386_TLS_IE = 15; +enum R_386_TLS_GOTIE = 16; +enum R_386_TLS_LE = 17; +enum R_386_TLS_GD = 18; +enum R_386_TLS_LDM = 19; +enum R_386_16 = 20; +enum R_386_PC16 = 21; +enum R_386_8 = 22; +enum R_386_PC8 = 23; +enum R_386_TLS_GD_32 = 24; +enum R_386_TLS_GD_PUSH = 25; +enum R_386_TLS_GD_CALL = 26; +enum R_386_TLS_GD_POP = 27; +enum R_386_TLS_LDM_32 = 28; +enum R_386_TLS_LDM_PUSH = 29; +enum R_386_TLS_LDM_CALL = 30; +enum R_386_TLS_LDM_POP = 31; +enum R_386_TLS_LDO_32 = 32; +enum R_386_TLS_IE_32 = 33; +enum R_386_TLS_LE_32 = 34; +enum R_386_TLS_DTPMOD32 = 35; +enum R_386_TLS_DTPOFF32 = 36; +enum R_386_TLS_TPOFF32 = 37; +enum R_386_SIZE32 = 38; +enum R_386_TLS_GOTDESC = 39; +enum R_386_TLS_DESC_CALL = 40; +enum R_386_TLS_DESC = 41; +enum R_386_IRELATIVE = 42; +enum R_386_NUM = 43; + +enum STT_SPARC_REGISTER = 13; + +enum EF_SPARCV9_MM = 3; +enum EF_SPARCV9_TSO = 0; +enum EF_SPARCV9_PSO = 1; +enum EF_SPARCV9_RMO = 2; +enum EF_SPARC_LEDATA = 0x800000; +enum EF_SPARC_EXT_MASK = 0xFFFF00; +enum EF_SPARC_32PLUS = 0x000100; +enum EF_SPARC_SUN_US1 = 0x000200; +enum EF_SPARC_HAL_R1 = 0x000400; +enum EF_SPARC_SUN_US3 = 0x000800; + +enum R_SPARC_NONE = 0; +enum R_SPARC_8 = 1; +enum R_SPARC_16 = 2; +enum R_SPARC_32 = 3; +enum R_SPARC_DISP8 = 4; +enum R_SPARC_DISP16 = 5; +enum R_SPARC_DISP32 = 6; +enum R_SPARC_WDISP30 = 7; +enum R_SPARC_WDISP22 = 8; +enum R_SPARC_HI22 = 9; +enum R_SPARC_22 = 10; +enum R_SPARC_13 = 11; +enum R_SPARC_LO10 = 12; +enum R_SPARC_GOT10 = 13; +enum R_SPARC_GOT13 = 14; +enum R_SPARC_GOT22 = 15; +enum R_SPARC_PC10 = 16; +enum R_SPARC_PC22 = 17; +enum R_SPARC_WPLT30 = 18; +enum R_SPARC_COPY = 19; +enum R_SPARC_GLOB_DAT = 20; +enum R_SPARC_JMP_SLOT = 21; +enum R_SPARC_RELATIVE = 22; +enum R_SPARC_UA32 = 23; + +enum R_SPARC_PLT32 = 24; +enum R_SPARC_HIPLT22 = 25; +enum R_SPARC_LOPLT10 = 26; +enum R_SPARC_PCPLT32 = 27; +enum R_SPARC_PCPLT22 = 28; +enum R_SPARC_PCPLT10 = 29; +enum R_SPARC_10 = 30; +enum R_SPARC_11 = 31; +enum R_SPARC_64 = 32; +enum R_SPARC_OLO10 = 33; +enum R_SPARC_HH22 = 34; +enum R_SPARC_HM10 = 35; +enum R_SPARC_LM22 = 36; +enum R_SPARC_PC_HH22 = 37; +enum R_SPARC_PC_HM10 = 38; +enum R_SPARC_PC_LM22 = 39; +enum R_SPARC_WDISP16 = 40; +enum R_SPARC_WDISP19 = 41; +enum R_SPARC_GLOB_JMP = 42; +enum R_SPARC_7 = 43; +enum R_SPARC_5 = 44; +enum R_SPARC_6 = 45; +enum R_SPARC_DISP64 = 46; +enum R_SPARC_PLT64 = 47; +enum R_SPARC_HIX22 = 48; +enum R_SPARC_LOX10 = 49; +enum R_SPARC_H44 = 50; +enum R_SPARC_M44 = 51; +enum R_SPARC_L44 = 52; +enum R_SPARC_REGISTER = 53; +enum R_SPARC_UA64 = 54; +enum R_SPARC_UA16 = 55; +enum R_SPARC_TLS_GD_HI22 = 56; +enum R_SPARC_TLS_GD_LO10 = 57; +enum R_SPARC_TLS_GD_ADD = 58; +enum R_SPARC_TLS_GD_CALL = 59; +enum R_SPARC_TLS_LDM_HI22 = 60; +enum R_SPARC_TLS_LDM_LO10 = 61; +enum R_SPARC_TLS_LDM_ADD = 62; +enum R_SPARC_TLS_LDM_CALL = 63; +enum R_SPARC_TLS_LDO_HIX22 = 64; +enum R_SPARC_TLS_LDO_LOX10 = 65; +enum R_SPARC_TLS_LDO_ADD = 66; +enum R_SPARC_TLS_IE_HI22 = 67; +enum R_SPARC_TLS_IE_LO10 = 68; +enum R_SPARC_TLS_IE_LD = 69; +enum R_SPARC_TLS_IE_LDX = 70; +enum R_SPARC_TLS_IE_ADD = 71; +enum R_SPARC_TLS_LE_HIX22 = 72; +enum R_SPARC_TLS_LE_LOX10 = 73; +enum R_SPARC_TLS_DTPMOD32 = 74; +enum R_SPARC_TLS_DTPMOD64 = 75; +enum R_SPARC_TLS_DTPOFF32 = 76; +enum R_SPARC_TLS_DTPOFF64 = 77; +enum R_SPARC_TLS_TPOFF32 = 78; +enum R_SPARC_TLS_TPOFF64 = 79; +enum R_SPARC_GOTDATA_HIX22 = 80; +enum R_SPARC_GOTDATA_LOX10 = 81; +enum R_SPARC_GOTDATA_OP_HIX22 = 82; +enum R_SPARC_GOTDATA_OP_LOX10 = 83; +enum R_SPARC_GOTDATA_OP = 84; +enum R_SPARC_H34 = 85; +enum R_SPARC_SIZE32 = 86; +enum R_SPARC_SIZE64 = 87; +enum R_SPARC_WDISP10 = 88; +enum R_SPARC_JMP_IREL = 248; +enum R_SPARC_IRELATIVE = 249; +enum R_SPARC_GNU_VTINHERIT = 250; +enum R_SPARC_GNU_VTENTRY = 251; +enum R_SPARC_REV32 = 252; +enum R_SPARC_NUM = 253; + +enum DT_SPARC_REGISTER = 0x70000001; +enum DT_SPARC_NUM = 2; + +enum EF_MIPS_NOREORDER = 1; +enum EF_MIPS_PIC = 2; +enum EF_MIPS_CPIC = 4; +enum EF_MIPS_XGOT = 8; +enum EF_MIPS_64BIT_WHIRL = 16; +enum EF_MIPS_ABI2 = 32; +enum EF_MIPS_ABI_ON32 = 64; +enum EF_MIPS_ARCH = 0xf0000000; + +enum EF_MIPS_ARCH_1 = 0x00000000; +enum EF_MIPS_ARCH_2 = 0x10000000; +enum EF_MIPS_ARCH_3 = 0x20000000; +enum EF_MIPS_ARCH_4 = 0x30000000; +enum EF_MIPS_ARCH_5 = 0x40000000; +enum EF_MIPS_ARCH_32 = 0x50000000; +enum EF_MIPS_ARCH_64 = 0x60000000; +enum EF_MIPS_ARCH_32R2 = 0x70000000; +enum EF_MIPS_ARCH_64R2 = 0x80000000; + +enum E_MIPS_ARCH_1 = EF_MIPS_ARCH_1; +enum E_MIPS_ARCH_2 = EF_MIPS_ARCH_2; +enum E_MIPS_ARCH_3 = EF_MIPS_ARCH_3; +enum E_MIPS_ARCH_4 = EF_MIPS_ARCH_4; +enum E_MIPS_ARCH_5 = EF_MIPS_ARCH_5; +enum E_MIPS_ARCH_32 = EF_MIPS_ARCH_32; +enum E_MIPS_ARCH_64 = EF_MIPS_ARCH_64; + +enum SHN_MIPS_ACOMMON = 0xff00; +enum SHN_MIPS_TEXT = 0xff01; +enum SHN_MIPS_DATA = 0xff02; +enum SHN_MIPS_SCOMMON = 0xff03; +enum SHN_MIPS_SUNDEFINED = 0xff04; + +enum SHT_MIPS_LIBLIST = 0x70000000; +enum SHT_MIPS_MSYM = 0x70000001; +enum SHT_MIPS_CONFLICT = 0x70000002; +enum SHT_MIPS_GPTAB = 0x70000003; +enum SHT_MIPS_UCODE = 0x70000004; +enum SHT_MIPS_DEBUG = 0x70000005; +enum SHT_MIPS_REGINFO = 0x70000006; +enum SHT_MIPS_PACKAGE = 0x70000007; +enum SHT_MIPS_PACKSYM = 0x70000008; +enum SHT_MIPS_RELD = 0x70000009; +enum SHT_MIPS_IFACE = 0x7000000b; +enum SHT_MIPS_CONTENT = 0x7000000c; +enum SHT_MIPS_OPTIONS = 0x7000000d; +enum SHT_MIPS_SHDR = 0x70000010; +enum SHT_MIPS_FDESC = 0x70000011; +enum SHT_MIPS_EXTSYM = 0x70000012; +enum SHT_MIPS_DENSE = 0x70000013; +enum SHT_MIPS_PDESC = 0x70000014; +enum SHT_MIPS_LOCSYM = 0x70000015; +enum SHT_MIPS_AUXSYM = 0x70000016; +enum SHT_MIPS_OPTSYM = 0x70000017; +enum SHT_MIPS_LOCSTR = 0x70000018; +enum SHT_MIPS_LINE = 0x70000019; +enum SHT_MIPS_RFDESC = 0x7000001a; +enum SHT_MIPS_DELTASYM = 0x7000001b; +enum SHT_MIPS_DELTAINST = 0x7000001c; +enum SHT_MIPS_DELTACLASS = 0x7000001d; +enum SHT_MIPS_DWARF = 0x7000001e; +enum SHT_MIPS_DELTADECL = 0x7000001f; +enum SHT_MIPS_SYMBOL_LIB = 0x70000020; +enum SHT_MIPS_EVENTS = 0x70000021; +enum SHT_MIPS_TRANSLATE = 0x70000022; +enum SHT_MIPS_PIXIE = 0x70000023; +enum SHT_MIPS_XLATE = 0x70000024; +enum SHT_MIPS_XLATE_DEBUG = 0x70000025; +enum SHT_MIPS_WHIRL = 0x70000026; +enum SHT_MIPS_EH_REGION = 0x70000027; +enum SHT_MIPS_XLATE_OLD = 0x70000028; +enum SHT_MIPS_PDR_EXCEPTION = 0x70000029; + +enum SHF_MIPS_GPREL = 0x10000000; +enum SHF_MIPS_MERGE = 0x20000000; +enum SHF_MIPS_ADDR = 0x40000000; +enum SHF_MIPS_STRINGS = 0x80000000; +enum SHF_MIPS_NOSTRIP = 0x08000000; +enum SHF_MIPS_LOCAL = 0x04000000; +enum SHF_MIPS_NAMES = 0x02000000; +enum SHF_MIPS_NODUPE = 0x01000000; +enum STO_MIPS_DEFAULT = 0x0; +enum STO_MIPS_INTERNAL = 0x1; +enum STO_MIPS_HIDDEN = 0x2; +enum STO_MIPS_PROTECTED = 0x3; +enum STO_MIPS_PLT = 0x8; +enum STO_MIPS_SC_ALIGN_UNUSED = 0xff; +enum STB_MIPS_SPLIT_COMMON = 13; + +union Elf32_gptab +{ + struct _gt_header + { + Elf32_Word gt_current_g_value; + Elf32_Word gt_unused; + } _gt_header gt_header; + struct _gt_entry + { + Elf32_Word gt_g_value; + Elf32_Word gt_bytes; + } _gt_entry gt_entry; +} + +struct Elf32_RegInfo +{ + Elf32_Word ri_gprmask; + Elf32_Word[4] ri_cprmask; + Elf32_Sword ri_gp_value; +} + +struct Elf_Options +{ + ubyte kind; + ubyte size; + Elf32_Section section; + Elf32_Word info; +} + +enum ODK_NULL = 0; +enum ODK_REGINFO = 1; +enum ODK_EXCEPTIONS = 2; +enum ODK_PAD = 3; +enum ODK_HWPATCH = 4; +enum ODK_FILL = 5; +enum ODK_TAGS = 6; +enum ODK_HWAND = 7; +enum ODK_HWOR = 8; + +enum OEX_FPU_MIN = 0x1f; +enum OEX_FPU_MAX = 0x1f00; +enum OEX_PAGE0 = 0x10000; +enum OEX_SMM = 0x20000; +enum OEX_FPDBUG = 0x40000; +enum OEX_PRECISEFP = OEX_FPDBUG; +enum OEX_DISMISS = 0x80000; + +enum OEX_FPU_INVAL = 0x10; +enum OEX_FPU_DIV0 = 0x08; +enum OEX_FPU_OFLO = 0x04; +enum OEX_FPU_UFLO = 0x02; +enum OEX_FPU_INEX = 0x01; + +enum OHW_R4KEOP = 0x1; +enum OHW_R8KPFETCH = 0x2; +enum OHW_R5KEOP = 0x4; +enum OHW_R5KCVTL = 0x8; + +enum OPAD_PREFIX = 0x1; +enum OPAD_POSTFIX = 0x2; +enum OPAD_SYMBOL = 0x4; + +struct Elf_Options_Hw +{ + Elf32_Word hwp_flags1; + Elf32_Word hwp_flags2; +} + +enum OHWA0_R4KEOP_CHECKED = 0x00000001; +enum OHWA1_R4KEOP_CLEAN = 0x00000002; + +enum R_MIPS_NONE = 0; +enum R_MIPS_16 = 1; +enum R_MIPS_32 = 2; +enum R_MIPS_REL32 = 3; +enum R_MIPS_26 = 4; +enum R_MIPS_HI16 = 5; +enum R_MIPS_LO16 = 6; +enum R_MIPS_GPREL16 = 7; +enum R_MIPS_LITERAL = 8; +enum R_MIPS_GOT16 = 9; +enum R_MIPS_PC16 = 10; +enum R_MIPS_CALL16 = 11; +enum R_MIPS_GPREL32 = 12; + +enum R_MIPS_SHIFT5 = 16; +enum R_MIPS_SHIFT6 = 17; +enum R_MIPS_64 = 18; +enum R_MIPS_GOT_DISP = 19; +enum R_MIPS_GOT_PAGE = 20; +enum R_MIPS_GOT_OFST = 21; +enum R_MIPS_GOT_HI16 = 22; +enum R_MIPS_GOT_LO16 = 23; +enum R_MIPS_SUB = 24; +enum R_MIPS_INSERT_A = 25; +enum R_MIPS_INSERT_B = 26; +enum R_MIPS_DELETE = 27; +enum R_MIPS_HIGHER = 28; +enum R_MIPS_HIGHEST = 29; +enum R_MIPS_CALL_HI16 = 30; +enum R_MIPS_CALL_LO16 = 31; +enum R_MIPS_SCN_DISP = 32; +enum R_MIPS_REL16 = 33; +enum R_MIPS_ADD_IMMEDIATE = 34; +enum R_MIPS_PJUMP = 35; +enum R_MIPS_RELGOT = 36; +enum R_MIPS_JALR = 37; +enum R_MIPS_TLS_DTPMOD32 = 38; +enum R_MIPS_TLS_DTPREL32 = 39; +enum R_MIPS_TLS_DTPMOD64 = 40; +enum R_MIPS_TLS_DTPREL64 = 41; +enum R_MIPS_TLS_GD = 42; +enum R_MIPS_TLS_LDM = 43; +enum R_MIPS_TLS_DTPREL_HI16 = 44; +enum R_MIPS_TLS_DTPREL_LO16 = 45; +enum R_MIPS_TLS_GOTTPREL = 46; +enum R_MIPS_TLS_TPREL32 = 47; +enum R_MIPS_TLS_TPREL64 = 48; +enum R_MIPS_TLS_TPREL_HI16 = 49; +enum R_MIPS_TLS_TPREL_LO16 = 50; +enum R_MIPS_GLOB_DAT = 51; +enum R_MIPS_COPY = 126; +enum R_MIPS_JUMP_SLOT = 127; +enum R_MIPS_NUM = 128; + +enum PT_MIPS_REGINFO = 0x70000000; +enum PT_MIPS_RTPROC = 0x70000001; +enum PT_MIPS_OPTIONS = 0x70000002; + +enum PF_MIPS_LOCAL = 0x10000000; + +enum DT_MIPS_RLD_VERSION = 0x70000001; +enum DT_MIPS_TIME_STAMP = 0x70000002; +enum DT_MIPS_ICHECKSUM = 0x70000003; +enum DT_MIPS_IVERSION = 0x70000004; +enum DT_MIPS_FLAGS = 0x70000005; +enum DT_MIPS_BASE_ADDRESS = 0x70000006; +enum DT_MIPS_MSYM = 0x70000007; +enum DT_MIPS_CONFLICT = 0x70000008; +enum DT_MIPS_LIBLIST = 0x70000009; +enum DT_MIPS_LOCAL_GOTNO = 0x7000000a; +enum DT_MIPS_CONFLICTNO = 0x7000000b; +enum DT_MIPS_LIBLISTNO = 0x70000010; +enum DT_MIPS_SYMTABNO = 0x70000011; +enum DT_MIPS_UNREFEXTNO = 0x70000012; +enum DT_MIPS_GOTSYM = 0x70000013; +enum DT_MIPS_HIPAGENO = 0x70000014; +enum DT_MIPS_RLD_MAP = 0x70000016; +enum DT_MIPS_DELTA_CLASS = 0x70000017; +enum DT_MIPS_DELTA_CLASS_NO = 0x70000018; +enum DT_MIPS_DELTA_INSTANCE = 0x70000019; +enum DT_MIPS_DELTA_INSTANCE_NO = 0x7000001a; +enum DT_MIPS_DELTA_RELOC = 0x7000001b; +enum DT_MIPS_DELTA_RELOC_NO = 0x7000001c; +enum DT_MIPS_DELTA_SYM = 0x7000001d; +enum DT_MIPS_DELTA_SYM_NO = 0x7000001e; +enum DT_MIPS_DELTA_CLASSSYM = 0x70000020; +enum DT_MIPS_DELTA_CLASSSYM_NO = 0x70000021; +enum DT_MIPS_CXX_FLAGS = 0x70000022; +enum DT_MIPS_PIXIE_INIT = 0x70000023; +enum DT_MIPS_SYMBOL_LIB = 0x70000024; +enum DT_MIPS_LOCALPAGE_GOTIDX = 0x70000025; +enum DT_MIPS_LOCAL_GOTIDX = 0x70000026; +enum DT_MIPS_HIDDEN_GOTIDX = 0x70000027; +enum DT_MIPS_PROTECTED_GOTIDX = 0x70000028; +enum DT_MIPS_OPTIONS = 0x70000029; +enum DT_MIPS_INTERFACE = 0x7000002a; +enum DT_MIPS_DYNSTR_ALIGN = 0x7000002b; +enum DT_MIPS_INTERFACE_SIZE = 0x7000002c; +enum DT_MIPS_RLD_TEXT_RESOLVE_ADDR = 0x7000002d; +enum DT_MIPS_PERF_SUFFIX = 0x7000002e; +enum DT_MIPS_COMPACT_SIZE = 0x7000002f; +enum DT_MIPS_GP_VALUE = 0x70000030; +enum DT_MIPS_AUX_DYNAMIC = 0x70000031; +enum DT_MIPS_PLTGOT = 0x70000032; +enum DT_MIPS_RWPLT = 0x70000034; +enum DT_MIPS_NUM = 0x35; + +enum RHF_NONE = 0; +enum RHF_QUICKSTART = (1 << 0); +enum RHF_NOTPOT = (1 << 1); +enum RHF_NO_LIBRARY_REPLACEMENT = (1 << 2); +enum RHF_NO_MOVE = (1 << 3); +enum RHF_SGI_ONLY = (1 << 4); +enum RHF_GUARANTEE_INIT = (1 << 5); +enum RHF_DELTA_C_PLUS_PLUS = (1 << 6); +enum RHF_GUARANTEE_START_INIT = (1 << 7); +enum RHF_PIXIE = (1 << 8); +enum RHF_DEFAULT_DELAY_LOAD = (1 << 9); +enum RHF_REQUICKSTART = (1 << 10); +enum RHF_REQUICKSTARTED = (1 << 11); +enum RHF_CORD = (1 << 12); +enum RHF_NO_UNRES_UNDEF = (1 << 13); +enum RHF_RLD_ORDER_SAFE = (1 << 14); + +struct Elf32_Lib +{ + Elf32_Word l_name; + Elf32_Word l_time_stamp; + Elf32_Word l_checksum; + Elf32_Word l_version; + Elf32_Word l_flags; +} + +struct Elf64_Lib +{ + Elf64_Word l_name; + Elf64_Word l_time_stamp; + Elf64_Word l_checksum; + Elf64_Word l_version; + Elf64_Word l_flags; +} + +enum LL_NONE = 0; +enum LL_EXACT_MATCH = (1 << 0); +enum LL_IGNORE_INT_VER = (1 << 1); +enum LL_REQUIRE_MINOR = (1 << 2); +enum LL_EXPORTS = (1 << 3); +enum LL_DELAY_LOAD = (1 << 4); +enum LL_DELTA = (1 << 5); + +alias Elf32_Addr Elf32_Conflict; + +enum EF_PARISC_TRAPNIL = 0x00010000; +enum EF_PARISC_EXT = 0x00020000; +enum EF_PARISC_LSB = 0x00040000; +enum EF_PARISC_WIDE = 0x00080000; +enum EF_PARISC_NO_KABP = 0x00100000; +enum EF_PARISC_LAZYSWAP = 0x00400000; +enum EF_PARISC_ARCH = 0x0000ffff; + +enum EFA_PARISC_1_0 = 0x020b; +enum EFA_PARISC_1_1 = 0x0210; +enum EFA_PARISC_2_0 = 0x0214; + +enum SHN_PARISC_ANSI_COMMON = 0xff00; +enum SHN_PARISC_HUGE_COMMON = 0xff01; + +enum SHT_PARISC_EXT = 0x70000000; +enum SHT_PARISC_UNWIND = 0x70000001; +enum SHT_PARISC_DOC = 0x70000002; + +enum SHF_PARISC_SHORT = 0x20000000; +enum SHF_PARISC_HUGE = 0x40000000; +enum SHF_PARISC_SBP = 0x80000000; + +enum STT_PARISC_MILLICODE = 13; + +enum STT_HP_OPAQUE = (STT_LOOS + 0x1); +enum STT_HP_STUB = (STT_LOOS + 0x2); + +enum R_PARISC_NONE = 0; +enum R_PARISC_DIR32 = 1; +enum R_PARISC_DIR21L = 2; +enum R_PARISC_DIR17R = 3; +enum R_PARISC_DIR17F = 4; +enum R_PARISC_DIR14R = 6; +enum R_PARISC_PCREL32 = 9; +enum R_PARISC_PCREL21L = 10; +enum R_PARISC_PCREL17R = 11; +enum R_PARISC_PCREL17F = 12; +enum R_PARISC_PCREL14R = 14; +enum R_PARISC_DPREL21L = 18; +enum R_PARISC_DPREL14R = 22; +enum R_PARISC_GPREL21L = 26; +enum R_PARISC_GPREL14R = 30; +enum R_PARISC_LTOFF21L = 34; +enum R_PARISC_LTOFF14R = 38; +enum R_PARISC_SECREL32 = 41; +enum R_PARISC_SEGBASE = 48; +enum R_PARISC_SEGREL32 = 49; +enum R_PARISC_PLTOFF21L = 50; +enum R_PARISC_PLTOFF14R = 54; +enum R_PARISC_LTOFF_FPTR32 = 57; +enum R_PARISC_LTOFF_FPTR21L = 58; +enum R_PARISC_LTOFF_FPTR14R = 62; +enum R_PARISC_FPTR64 = 64; +enum R_PARISC_PLABEL32 = 65; +enum R_PARISC_PLABEL21L = 66; +enum R_PARISC_PLABEL14R = 70; +enum R_PARISC_PCREL64 = 72; +enum R_PARISC_PCREL22F = 74; +enum R_PARISC_PCREL14WR = 75; +enum R_PARISC_PCREL14DR = 76; +enum R_PARISC_PCREL16F = 77; +enum R_PARISC_PCREL16WF = 78; +enum R_PARISC_PCREL16DF = 79; +enum R_PARISC_DIR64 = 80; +enum R_PARISC_DIR14WR = 83; +enum R_PARISC_DIR14DR = 84; +enum R_PARISC_DIR16F = 85; +enum R_PARISC_DIR16WF = 86; +enum R_PARISC_DIR16DF = 87; +enum R_PARISC_GPREL64 = 88; +enum R_PARISC_GPREL14WR = 91; +enum R_PARISC_GPREL14DR = 92; +enum R_PARISC_GPREL16F = 93; +enum R_PARISC_GPREL16WF = 94; +enum R_PARISC_GPREL16DF = 95; +enum R_PARISC_LTOFF64 = 96; +enum R_PARISC_LTOFF14WR = 99; +enum R_PARISC_LTOFF14DR = 100; +enum R_PARISC_LTOFF16F = 101; +enum R_PARISC_LTOFF16WF = 102; +enum R_PARISC_LTOFF16DF = 103; +enum R_PARISC_SECREL64 = 104; +enum R_PARISC_SEGREL64 = 112; +enum R_PARISC_PLTOFF14WR = 115; +enum R_PARISC_PLTOFF14DR = 116; +enum R_PARISC_PLTOFF16F = 117; +enum R_PARISC_PLTOFF16WF = 118; +enum R_PARISC_PLTOFF16DF = 119; +enum R_PARISC_LTOFF_FPTR64 = 120; +enum R_PARISC_LTOFF_FPTR14WR = 123; +enum R_PARISC_LTOFF_FPTR14DR = 124; +enum R_PARISC_LTOFF_FPTR16F = 125; +enum R_PARISC_LTOFF_FPTR16WF = 126; +enum R_PARISC_LTOFF_FPTR16DF = 127; +enum R_PARISC_LORESERVE = 128; +enum R_PARISC_COPY = 128; +enum R_PARISC_IPLT = 129; +enum R_PARISC_EPLT = 130; +enum R_PARISC_TPREL32 = 153; +enum R_PARISC_TPREL21L = 154; +enum R_PARISC_TPREL14R = 158; +enum R_PARISC_LTOFF_TP21L = 162; +enum R_PARISC_LTOFF_TP14R = 166; +enum R_PARISC_LTOFF_TP14F = 167; +enum R_PARISC_TPREL64 = 216; +enum R_PARISC_TPREL14WR = 219; +enum R_PARISC_TPREL14DR = 220; +enum R_PARISC_TPREL16F = 221; +enum R_PARISC_TPREL16WF = 222; +enum R_PARISC_TPREL16DF = 223; +enum R_PARISC_LTOFF_TP64 = 224; +enum R_PARISC_LTOFF_TP14WR = 227; +enum R_PARISC_LTOFF_TP14DR = 228; +enum R_PARISC_LTOFF_TP16F = 229; +enum R_PARISC_LTOFF_TP16WF = 230; +enum R_PARISC_LTOFF_TP16DF = 231; +enum R_PARISC_GNU_VTENTRY = 232; +enum R_PARISC_GNU_VTINHERIT = 233; +enum R_PARISC_TLS_GD21L = 234; +enum R_PARISC_TLS_GD14R = 235; +enum R_PARISC_TLS_GDCALL = 236; +enum R_PARISC_TLS_LDM21L = 237; +enum R_PARISC_TLS_LDM14R = 238; +enum R_PARISC_TLS_LDMCALL = 239; +enum R_PARISC_TLS_LDO21L = 240; +enum R_PARISC_TLS_LDO14R = 241; +enum R_PARISC_TLS_DTPMOD32 = 242; +enum R_PARISC_TLS_DTPMOD64 = 243; +enum R_PARISC_TLS_DTPOFF32 = 244; +enum R_PARISC_TLS_DTPOFF64 = 245; +enum R_PARISC_TLS_LE21L = R_PARISC_TPREL21L; +enum R_PARISC_TLS_LE14R = R_PARISC_TPREL14R; +enum R_PARISC_TLS_IE21L = R_PARISC_LTOFF_TP21L; +enum R_PARISC_TLS_IE14R = R_PARISC_LTOFF_TP14R; +enum R_PARISC_TLS_TPREL32 = R_PARISC_TPREL32; +enum R_PARISC_TLS_TPREL64 = R_PARISC_TPREL64; +enum R_PARISC_HIRESERVE = 255; + +enum PT_HP_TLS = (PT_LOOS + 0x0); +enum PT_HP_CORE_NONE = (PT_LOOS + 0x1); +enum PT_HP_CORE_VERSION = (PT_LOOS + 0x2); +enum PT_HP_CORE_KERNEL = (PT_LOOS + 0x3); +enum PT_HP_CORE_COMM = (PT_LOOS + 0x4); +enum PT_HP_CORE_PROC = (PT_LOOS + 0x5); +enum PT_HP_CORE_LOADABLE = (PT_LOOS + 0x6); +enum PT_HP_CORE_STACK = (PT_LOOS + 0x7); +enum PT_HP_CORE_SHM = (PT_LOOS + 0x8); +enum PT_HP_CORE_MMF = (PT_LOOS + 0x9); +enum PT_HP_PARALLEL = (PT_LOOS + 0x10); +enum PT_HP_FASTBIND = (PT_LOOS + 0x11); +enum PT_HP_OPT_ANNOT = (PT_LOOS + 0x12); +enum PT_HP_HSL_ANNOT = (PT_LOOS + 0x13); +enum PT_HP_STACK = (PT_LOOS + 0x14); + +enum PT_PARISC_ARCHEXT = 0x70000000; +enum PT_PARISC_UNWIND = 0x70000001; + +enum PF_PARISC_SBP = 0x08000000; + +enum PF_HP_PAGE_SIZE = 0x00100000; +enum PF_HP_FAR_SHARED = 0x00200000; +enum PF_HP_NEAR_SHARED = 0x00400000; +enum PF_HP_CODE = 0x01000000; +enum PF_HP_MODIFY = 0x02000000; +enum PF_HP_LAZYSWAP = 0x04000000; +enum PF_HP_SBP = 0x08000000; + +enum EF_ALPHA_32BIT = 1; +enum EF_ALPHA_CANRELAX = 2; +enum SHT_ALPHA_DEBUG = 0x70000001; +enum SHT_ALPHA_REGINFO = 0x70000002; + +enum SHF_ALPHA_GPREL = 0x10000000; +enum STO_ALPHA_NOPV = 0x80; +enum STO_ALPHA_STD_GPLOAD = 0x88; + +enum R_ALPHA_NONE = 0; +enum R_ALPHA_REFLONG = 1; +enum R_ALPHA_REFQUAD = 2; +enum R_ALPHA_GPREL32 = 3; +enum R_ALPHA_LITERAL = 4; +enum R_ALPHA_LITUSE = 5; +enum R_ALPHA_GPDISP = 6; +enum R_ALPHA_BRADDR = 7; +enum R_ALPHA_HINT = 8; +enum R_ALPHA_SREL16 = 9; +enum R_ALPHA_SREL32 = 10; +enum R_ALPHA_SREL64 = 11; +enum R_ALPHA_GPRELHIGH = 17; +enum R_ALPHA_GPRELLOW = 18; +enum R_ALPHA_GPREL16 = 19; +enum R_ALPHA_COPY = 24; +enum R_ALPHA_GLOB_DAT = 25; +enum R_ALPHA_JMP_SLOT = 26; +enum R_ALPHA_RELATIVE = 27; +enum R_ALPHA_TLS_GD_HI = 28; +enum R_ALPHA_TLSGD = 29; +enum R_ALPHA_TLS_LDM = 30; +enum R_ALPHA_DTPMOD64 = 31; +enum R_ALPHA_GOTDTPREL = 32; +enum R_ALPHA_DTPREL64 = 33; +enum R_ALPHA_DTPRELHI = 34; +enum R_ALPHA_DTPRELLO = 35; +enum R_ALPHA_DTPREL16 = 36; +enum R_ALPHA_GOTTPREL = 37; +enum R_ALPHA_TPREL64 = 38; +enum R_ALPHA_TPRELHI = 39; +enum R_ALPHA_TPRELLO = 40; +enum R_ALPHA_TPREL16 = 41; +enum R_ALPHA_NUM = 46; +enum LITUSE_ALPHA_ADDR = 0; +enum LITUSE_ALPHA_BASE = 1; +enum LITUSE_ALPHA_BYTOFF = 2; +enum LITUSE_ALPHA_JSR = 3; +enum LITUSE_ALPHA_TLS_GD = 4; +enum LITUSE_ALPHA_TLS_LDM = 5; +enum DT_ALPHA_PLTRO = (DT_LOPROC + 0); +enum DT_ALPHA_NUM = 1; +enum EF_PPC_EMB = 0x80000000; +enum EF_PPC_RELOCATABLE = 0x00010000; +enum EF_PPC_RELOCATABLE_LIB = 0x00008000; +enum R_PPC_NONE = 0; +enum R_PPC_ADDR32 = 1; +enum R_PPC_ADDR24 = 2; +enum R_PPC_ADDR16 = 3; +enum R_PPC_ADDR16_LO = 4; +enum R_PPC_ADDR16_HI = 5; +enum R_PPC_ADDR16_HA = 6; +enum R_PPC_ADDR14 = 7; +enum R_PPC_ADDR14_BRTAKEN = 8; +enum R_PPC_ADDR14_BRNTAKEN = 9; +enum R_PPC_REL24 = 10; +enum R_PPC_REL14 = 11; +enum R_PPC_REL14_BRTAKEN = 12; +enum R_PPC_REL14_BRNTAKEN = 13; +enum R_PPC_GOT16 = 14; +enum R_PPC_GOT16_LO = 15; +enum R_PPC_GOT16_HI = 16; +enum R_PPC_GOT16_HA = 17; +enum R_PPC_PLTREL24 = 18; +enum R_PPC_COPY = 19; +enum R_PPC_GLOB_DAT = 20; +enum R_PPC_JMP_SLOT = 21; +enum R_PPC_RELATIVE = 22; +enum R_PPC_LOCAL24PC = 23; +enum R_PPC_UADDR32 = 24; +enum R_PPC_UADDR16 = 25; +enum R_PPC_REL32 = 26; +enum R_PPC_PLT32 = 27; +enum R_PPC_PLTREL32 = 28; +enum R_PPC_PLT16_LO = 29; +enum R_PPC_PLT16_HI = 30; +enum R_PPC_PLT16_HA = 31; +enum R_PPC_SDAREL16 = 32; +enum R_PPC_SECTOFF = 33; +enum R_PPC_SECTOFF_LO = 34; +enum R_PPC_SECTOFF_HI = 35; +enum R_PPC_SECTOFF_HA = 36; +enum R_PPC_TLS = 67; +enum R_PPC_DTPMOD32 = 68; +enum R_PPC_TPREL16 = 69; +enum R_PPC_TPREL16_LO = 70; +enum R_PPC_TPREL16_HI = 71; +enum R_PPC_TPREL16_HA = 72; +enum R_PPC_TPREL32 = 73; +enum R_PPC_DTPREL16 = 74; +enum R_PPC_DTPREL16_LO = 75; +enum R_PPC_DTPREL16_HI = 76; +enum R_PPC_DTPREL16_HA = 77; +enum R_PPC_DTPREL32 = 78; +enum R_PPC_GOT_TLSGD16 = 79; +enum R_PPC_GOT_TLSGD16_LO = 80; +enum R_PPC_GOT_TLSGD16_HI = 81; +enum R_PPC_GOT_TLSGD16_HA = 82; +enum R_PPC_GOT_TLSLD16 = 83; +enum R_PPC_GOT_TLSLD16_LO = 84; +enum R_PPC_GOT_TLSLD16_HI = 85; +enum R_PPC_GOT_TLSLD16_HA = 86; +enum R_PPC_GOT_TPREL16 = 87; +enum R_PPC_GOT_TPREL16_LO = 88; +enum R_PPC_GOT_TPREL16_HI = 89; +enum R_PPC_GOT_TPREL16_HA = 90; +enum R_PPC_GOT_DTPREL16 = 91; +enum R_PPC_GOT_DTPREL16_LO = 92; +enum R_PPC_GOT_DTPREL16_HI = 93; +enum R_PPC_GOT_DTPREL16_HA = 94; +enum R_PPC_EMB_NADDR32 = 101; +enum R_PPC_EMB_NADDR16 = 102; +enum R_PPC_EMB_NADDR16_LO = 103; +enum R_PPC_EMB_NADDR16_HI = 104; +enum R_PPC_EMB_NADDR16_HA = 105; +enum R_PPC_EMB_SDAI16 = 106; +enum R_PPC_EMB_SDA2I16 = 107; +enum R_PPC_EMB_SDA2REL = 108; +enum R_PPC_EMB_SDA21 = 109; +enum R_PPC_EMB_MRKREF = 110; +enum R_PPC_EMB_RELSEC16 = 111; +enum R_PPC_EMB_RELST_LO = 112; +enum R_PPC_EMB_RELST_HI = 113; +enum R_PPC_EMB_RELST_HA = 114; +enum R_PPC_EMB_BIT_FLD = 115; +enum R_PPC_EMB_RELSDA = 116; +enum R_PPC_DIAB_SDA21_LO = 180; +enum R_PPC_DIAB_SDA21_HI = 181; +enum R_PPC_DIAB_SDA21_HA = 182; +enum R_PPC_DIAB_RELSDA_LO = 183; +enum R_PPC_DIAB_RELSDA_HI = 184; +enum R_PPC_DIAB_RELSDA_HA = 185; +enum R_PPC_IRELATIVE = 248; +enum R_PPC_REL16 = 249; +enum R_PPC_REL16_LO = 250; +enum R_PPC_REL16_HI = 251; +enum R_PPC_REL16_HA = 252; +enum R_PPC_TOC16 = 255; +enum DT_PPC_GOT = (DT_LOPROC + 0); +enum DT_PPC_NUM = 1; +enum R_PPC64_NONE = R_PPC_NONE; +enum R_PPC64_ADDR32 = R_PPC_ADDR32; +enum R_PPC64_ADDR24 = R_PPC_ADDR24; +enum R_PPC64_ADDR16 = R_PPC_ADDR16; +enum R_PPC64_ADDR16_LO = R_PPC_ADDR16_LO; +enum R_PPC64_ADDR16_HI = R_PPC_ADDR16_HI; +enum R_PPC64_ADDR16_HA = R_PPC_ADDR16_HA; +enum R_PPC64_ADDR14 = R_PPC_ADDR14; +enum R_PPC64_ADDR14_BRTAKEN = R_PPC_ADDR14_BRTAKEN; +enum R_PPC64_ADDR14_BRNTAKEN = R_PPC_ADDR14_BRNTAKEN; +enum R_PPC64_REL24 = R_PPC_REL24; +enum R_PPC64_REL14 = R_PPC_REL14; +enum R_PPC64_REL14_BRTAKEN = R_PPC_REL14_BRTAKEN; +enum R_PPC64_REL14_BRNTAKEN = R_PPC_REL14_BRNTAKEN; +enum R_PPC64_GOT16 = R_PPC_GOT16; +enum R_PPC64_GOT16_LO = R_PPC_GOT16_LO; +enum R_PPC64_GOT16_HI = R_PPC_GOT16_HI; +enum R_PPC64_GOT16_HA = R_PPC_GOT16_HA; + +enum R_PPC64_COPY = R_PPC_COPY; +enum R_PPC64_GLOB_DAT = R_PPC_GLOB_DAT; +enum R_PPC64_JMP_SLOT = R_PPC_JMP_SLOT; +enum R_PPC64_RELATIVE = R_PPC_RELATIVE; + +enum R_PPC64_UADDR32 = R_PPC_UADDR32; +enum R_PPC64_UADDR16 = R_PPC_UADDR16; +enum R_PPC64_REL32 = R_PPC_REL32; +enum R_PPC64_PLT32 = R_PPC_PLT32; +enum R_PPC64_PLTREL32 = R_PPC_PLTREL32; +enum R_PPC64_PLT16_LO = R_PPC_PLT16_LO; +enum R_PPC64_PLT16_HI = R_PPC_PLT16_HI; +enum R_PPC64_PLT16_HA = R_PPC_PLT16_HA; + +enum R_PPC64_SECTOFF = R_PPC_SECTOFF; +enum R_PPC64_SECTOFF_LO = R_PPC_SECTOFF_LO; +enum R_PPC64_SECTOFF_HI = R_PPC_SECTOFF_HI; +enum R_PPC64_SECTOFF_HA = R_PPC_SECTOFF_HA; +enum R_PPC64_ADDR30 = 37; +enum R_PPC64_ADDR64 = 38; +enum R_PPC64_ADDR16_HIGHER = 39; +enum R_PPC64_ADDR16_HIGHERA = 40; +enum R_PPC64_ADDR16_HIGHEST = 41; +enum R_PPC64_ADDR16_HIGHESTA = 42; +enum R_PPC64_UADDR64 = 43; +enum R_PPC64_REL64 = 44; +enum R_PPC64_PLT64 = 45; +enum R_PPC64_PLTREL64 = 46; +enum R_PPC64_TOC16 = 47; +enum R_PPC64_TOC16_LO = 48; +enum R_PPC64_TOC16_HI = 49; +enum R_PPC64_TOC16_HA = 50; +enum R_PPC64_TOC = 51; +enum R_PPC64_PLTGOT16 = 52; +enum R_PPC64_PLTGOT16_LO = 53; +enum R_PPC64_PLTGOT16_HI = 54; +enum R_PPC64_PLTGOT16_HA = 55; + +enum R_PPC64_ADDR16_DS = 56; +enum R_PPC64_ADDR16_LO_DS = 57; +enum R_PPC64_GOT16_DS = 58; +enum R_PPC64_GOT16_LO_DS = 59; +enum R_PPC64_PLT16_LO_DS = 60; +enum R_PPC64_SECTOFF_DS = 61; +enum R_PPC64_SECTOFF_LO_DS = 62; +enum R_PPC64_TOC16_DS = 63; +enum R_PPC64_TOC16_LO_DS = 64; +enum R_PPC64_PLTGOT16_DS = 65; +enum R_PPC64_PLTGOT16_LO_DS = 66; +enum R_PPC64_TLS = 67; +enum R_PPC64_DTPMOD64 = 68; +enum R_PPC64_TPREL16 = 69; +enum R_PPC64_TPREL16_LO = 70; +enum R_PPC64_TPREL16_HI = 71; +enum R_PPC64_TPREL16_HA = 72; +enum R_PPC64_TPREL64 = 73; +enum R_PPC64_DTPREL16 = 74; +enum R_PPC64_DTPREL16_LO = 75; +enum R_PPC64_DTPREL16_HI = 76; +enum R_PPC64_DTPREL16_HA = 77; +enum R_PPC64_DTPREL64 = 78; +enum R_PPC64_GOT_TLSGD16 = 79; +enum R_PPC64_GOT_TLSGD16_LO = 80; +enum R_PPC64_GOT_TLSGD16_HI = 81; +enum R_PPC64_GOT_TLSGD16_HA = 82; +enum R_PPC64_GOT_TLSLD16 = 83; +enum R_PPC64_GOT_TLSLD16_LO = 84; +enum R_PPC64_GOT_TLSLD16_HI = 85; +enum R_PPC64_GOT_TLSLD16_HA = 86; +enum R_PPC64_GOT_TPREL16_DS = 87; +enum R_PPC64_GOT_TPREL16_LO_DS = 88; +enum R_PPC64_GOT_TPREL16_HI = 89; +enum R_PPC64_GOT_TPREL16_HA = 90; +enum R_PPC64_GOT_DTPREL16_DS = 91; +enum R_PPC64_GOT_DTPREL16_LO_DS = 92; +enum R_PPC64_GOT_DTPREL16_HI = 93; +enum R_PPC64_GOT_DTPREL16_HA = 94; +enum R_PPC64_TPREL16_DS = 95; +enum R_PPC64_TPREL16_LO_DS = 96; +enum R_PPC64_TPREL16_HIGHER = 97; +enum R_PPC64_TPREL16_HIGHERA = 98; +enum R_PPC64_TPREL16_HIGHEST = 99; +enum R_PPC64_TPREL16_HIGHESTA = 100; +enum R_PPC64_DTPREL16_DS = 101; +enum R_PPC64_DTPREL16_LO_DS = 102; +enum R_PPC64_DTPREL16_HIGHER = 103; +enum R_PPC64_DTPREL16_HIGHERA = 104; +enum R_PPC64_DTPREL16_HIGHEST = 105; +enum R_PPC64_DTPREL16_HIGHESTA = 106; +enum R_PPC64_JMP_IREL = 247; +enum R_PPC64_IRELATIVE = 248; +enum R_PPC64_REL16 = 249; +enum R_PPC64_REL16_LO = 250; +enum R_PPC64_REL16_HI = 251; +enum R_PPC64_REL16_HA = 252; +enum DT_PPC64_GLINK = (DT_LOPROC + 0); +enum DT_PPC64_OPD = (DT_LOPROC + 1); +enum DT_PPC64_OPDSZ = (DT_LOPROC + 2); +enum DT_PPC64_NUM = 3; +enum EF_ARM_RELEXEC = 0x01; +enum EF_ARM_HASENTRY = 0x02; +enum EF_ARM_INTERWORK = 0x04; +enum EF_ARM_APCS_26 = 0x08; +enum EF_ARM_APCS_FLOAT = 0x10; +enum EF_ARM_PIC = 0x20; +enum EF_ARM_ALIGN8 = 0x40; +enum EF_ARM_NEW_ABI = 0x80; +enum EF_ARM_OLD_ABI = 0x100; +enum EF_ARM_SOFT_FLOAT = 0x200; +enum EF_ARM_VFP_FLOAT = 0x400; +enum EF_ARM_MAVERICK_FLOAT = 0x800; + +enum EF_ARM_ABI_FLOAT_SOFT = 0x200; +enum EF_ARM_ABI_FLOAT_HARD = 0x400; +enum EF_ARM_SYMSARESORTED = 0x04; +enum EF_ARM_DYNSYMSUSESEGIDX = 0x08; +enum EF_ARM_MAPSYMSFIRST = 0x10; +enum EF_ARM_EABIMASK = 0XFF000000; +enum EF_ARM_BE8 = 0x00800000; +enum EF_ARM_LE8 = 0x00400000; + +extern (D) auto EF_ARM_EABI_VERSION(F)(F flags) { return flags & EF_ARM_EABIMASK; } +enum EF_ARM_EABI_UNKNOWN = 0x00000000; +enum EF_ARM_EABI_VER1 = 0x01000000; +enum EF_ARM_EABI_VER2 = 0x02000000; +enum EF_ARM_EABI_VER3 = 0x03000000; +enum EF_ARM_EABI_VER4 = 0x04000000; +enum EF_ARM_EABI_VER5 = 0x05000000; +enum STT_ARM_TFUNC = STT_LOPROC; +enum STT_ARM_16BIT = STT_HIPROC; +enum SHF_ARM_ENTRYSECT = 0x10000000; +enum SHF_ARM_COMDEF = 0x80000000; +enum PF_ARM_SB = 0x10000000; +enum PF_ARM_PI = 0x20000000; +enum PF_ARM_ABS = 0x40000000; +enum PT_ARM_EXIDX = (PT_LOPROC + 1); +enum SHT_ARM_EXIDX = (SHT_LOPROC + 1); +enum SHT_ARM_PREEMPTMAP = (SHT_LOPROC + 2); +enum SHT_ARM_ATTRIBUTES = (SHT_LOPROC + 3); + +enum R_AARCH64_NONE = 0; +enum R_AARCH64_ABS64 = 257; +enum R_AARCH64_ABS32 = 258; +enum R_AARCH64_COPY = 1024; +enum R_AARCH64_GLOB_DAT = 1025; +enum R_AARCH64_JUMP_SLOT = 1026; +enum R_AARCH64_RELATIVE = 1027; +enum R_AARCH64_TLS_DTPMOD64 = 1028; +enum R_AARCH64_TLS_DTPREL64 = 1029; +enum R_AARCH64_TLS_TPREL64 = 1030; +enum R_AARCH64_TLSDESC = 1031; + +enum R_ARM_NONE = 0; +enum R_ARM_PC24 = 1; +enum R_ARM_ABS32 = 2; +enum R_ARM_REL32 = 3; +enum R_ARM_PC13 = 4; +enum R_ARM_ABS16 = 5; +enum R_ARM_ABS12 = 6; +enum R_ARM_THM_ABS5 = 7; +enum R_ARM_ABS8 = 8; +enum R_ARM_SBREL32 = 9; +enum R_ARM_THM_PC22 = 10; +enum R_ARM_THM_PC8 = 11; +enum R_ARM_AMP_VCALL9 = 12; +enum R_ARM_SWI24 = 13; +enum R_ARM_TLS_DESC = 13; +enum R_ARM_THM_SWI8 = 14; +enum R_ARM_XPC25 = 15; +enum R_ARM_THM_XPC22 = 16; +enum R_ARM_TLS_DTPMOD32 = 17; +enum R_ARM_TLS_DTPOFF32 = 18; +enum R_ARM_TLS_TPOFF32 = 19; +enum R_ARM_COPY = 20; +enum R_ARM_GLOB_DAT = 21; +enum R_ARM_JUMP_SLOT = 22; +enum R_ARM_RELATIVE = 23; +enum R_ARM_GOTOFF = 24; +enum R_ARM_GOTPC = 25; +enum R_ARM_GOT32 = 26; +enum R_ARM_PLT32 = 27; +enum R_ARM_ALU_PCREL_7_0 = 32; +enum R_ARM_ALU_PCREL_15_8 = 33; +enum R_ARM_ALU_PCREL_23_15 = 34; +enum R_ARM_LDR_SBREL_11_0 = 35; +enum R_ARM_ALU_SBREL_19_12 = 36; +enum R_ARM_ALU_SBREL_27_20 = 37; +enum R_ARM_TLS_GOTDESC = 90; +enum R_ARM_TLS_CALL = 91; +enum R_ARM_TLS_DESCSEQ = 92; +enum R_ARM_THM_TLS_CALL = 93; +enum R_ARM_GNU_VTENTRY = 100; +enum R_ARM_GNU_VTINHERIT = 101; +enum R_ARM_THM_PC11 = 102; +enum R_ARM_THM_PC9 = 103; +enum R_ARM_TLS_GD32 = 104; +enum R_ARM_TLS_LDM32 = 105; +enum R_ARM_TLS_LDO32 = 106; +enum R_ARM_TLS_IE32 = 107; +enum R_ARM_TLS_LE32 = 108; +enum R_ARM_THM_TLS_DESCSEQ = 129; +enum R_ARM_IRELATIVE = 160; +enum R_ARM_RXPC25 = 249; +enum R_ARM_RSBREL32 = 250; +enum R_ARM_THM_RPC22 = 251; +enum R_ARM_RREL32 = 252; +enum R_ARM_RABS22 = 253; +enum R_ARM_RPC24 = 254; +enum R_ARM_RBASE = 255; +enum R_ARM_NUM = 256; +enum EF_IA_64_MASKOS = 0x0000000f; +enum EF_IA_64_ABI64 = 0x00000010; +enum EF_IA_64_ARCH = 0xff000000; +enum PT_IA_64_ARCHEXT = (PT_LOPROC + 0); +enum PT_IA_64_UNWIND = (PT_LOPROC + 1); +enum PT_IA_64_HP_OPT_ANOT = (PT_LOOS + 0x12); +enum PT_IA_64_HP_HSL_ANOT = (PT_LOOS + 0x13); +enum PT_IA_64_HP_STACK = (PT_LOOS + 0x14); +enum PF_IA_64_NORECOV = 0x80000000; +enum SHT_IA_64_EXT = (SHT_LOPROC + 0); +enum SHT_IA_64_UNWIND = (SHT_LOPROC + 1); +enum SHF_IA_64_SHORT = 0x10000000; +enum SHF_IA_64_NORECOV = 0x20000000; +enum DT_IA_64_PLT_RESERVE = (DT_LOPROC + 0); +enum DT_IA_64_NUM = 1; +enum R_IA64_NONE = 0x00; +enum R_IA64_IMM14 = 0x21; +enum R_IA64_IMM22 = 0x22; +enum R_IA64_IMM64 = 0x23; +enum R_IA64_DIR32MSB = 0x24; +enum R_IA64_DIR32LSB = 0x25; +enum R_IA64_DIR64MSB = 0x26; +enum R_IA64_DIR64LSB = 0x27; +enum R_IA64_GPREL22 = 0x2a; +enum R_IA64_GPREL64I = 0x2b; +enum R_IA64_GPREL32MSB = 0x2c; +enum R_IA64_GPREL32LSB = 0x2d; +enum R_IA64_GPREL64MSB = 0x2e; +enum R_IA64_GPREL64LSB = 0x2f; +enum R_IA64_LTOFF22 = 0x32; +enum R_IA64_LTOFF64I = 0x33; +enum R_IA64_PLTOFF22 = 0x3a; +enum R_IA64_PLTOFF64I = 0x3b; +enum R_IA64_PLTOFF64MSB = 0x3e; +enum R_IA64_PLTOFF64LSB = 0x3f; +enum R_IA64_FPTR64I = 0x43; +enum R_IA64_FPTR32MSB = 0x44; +enum R_IA64_FPTR32LSB = 0x45; +enum R_IA64_FPTR64MSB = 0x46; +enum R_IA64_FPTR64LSB = 0x47; +enum R_IA64_PCREL60B = 0x48; +enum R_IA64_PCREL21B = 0x49; +enum R_IA64_PCREL21M = 0x4a; +enum R_IA64_PCREL21F = 0x4b; +enum R_IA64_PCREL32MSB = 0x4c; +enum R_IA64_PCREL32LSB = 0x4d; +enum R_IA64_PCREL64MSB = 0x4e; +enum R_IA64_PCREL64LSB = 0x4f; +enum R_IA64_LTOFF_FPTR22 = 0x52; +enum R_IA64_LTOFF_FPTR64I = 0x53; +enum R_IA64_LTOFF_FPTR32MSB = 0x54; +enum R_IA64_LTOFF_FPTR32LSB = 0x55; +enum R_IA64_LTOFF_FPTR64MSB = 0x56; +enum R_IA64_LTOFF_FPTR64LSB = 0x57; +enum R_IA64_SEGREL32MSB = 0x5c; +enum R_IA64_SEGREL32LSB = 0x5d; +enum R_IA64_SEGREL64MSB = 0x5e; +enum R_IA64_SEGREL64LSB = 0x5f; +enum R_IA64_SECREL32MSB = 0x64; +enum R_IA64_SECREL32LSB = 0x65; +enum R_IA64_SECREL64MSB = 0x66; +enum R_IA64_SECREL64LSB = 0x67; +enum R_IA64_REL32MSB = 0x6c; +enum R_IA64_REL32LSB = 0x6d; +enum R_IA64_REL64MSB = 0x6e; +enum R_IA64_REL64LSB = 0x6f; +enum R_IA64_LTV32MSB = 0x74; +enum R_IA64_LTV32LSB = 0x75; +enum R_IA64_LTV64MSB = 0x76; +enum R_IA64_LTV64LSB = 0x77; +enum R_IA64_PCREL21BI = 0x79; +enum R_IA64_PCREL22 = 0x7a; +enum R_IA64_PCREL64I = 0x7b; +enum R_IA64_IPLTMSB = 0x80; +enum R_IA64_IPLTLSB = 0x81; +enum R_IA64_COPY = 0x84; +enum R_IA64_SUB = 0x85; +enum R_IA64_LTOFF22X = 0x86; +enum R_IA64_LDXMOV = 0x87; +enum R_IA64_TPREL14 = 0x91; +enum R_IA64_TPREL22 = 0x92; +enum R_IA64_TPREL64I = 0x93; +enum R_IA64_TPREL64MSB = 0x96; +enum R_IA64_TPREL64LSB = 0x97; +enum R_IA64_LTOFF_TPREL22 = 0x9a; +enum R_IA64_DTPMOD64MSB = 0xa6; +enum R_IA64_DTPMOD64LSB = 0xa7; +enum R_IA64_LTOFF_DTPMOD22 = 0xaa; +enum R_IA64_DTPREL14 = 0xb1; +enum R_IA64_DTPREL22 = 0xb2; +enum R_IA64_DTPREL64I = 0xb3; +enum R_IA64_DTPREL32MSB = 0xb4; +enum R_IA64_DTPREL32LSB = 0xb5; +enum R_IA64_DTPREL64MSB = 0xb6; +enum R_IA64_DTPREL64LSB = 0xb7; +enum R_IA64_LTOFF_DTPREL22 = 0xba; +enum EF_SH_MACH_MASK = 0x1f; +enum EF_SH_UNKNOWN = 0x0; +enum EF_SH1 = 0x1; +enum EF_SH2 = 0x2; +enum EF_SH3 = 0x3; +enum EF_SH_DSP = 0x4; +enum EF_SH3_DSP = 0x5; +enum EF_SH4AL_DSP = 0x6; +enum EF_SH3E = 0x8; +enum EF_SH4 = 0x9; +enum EF_SH2E = 0xb; +enum EF_SH4A = 0xc; +enum EF_SH2A = 0xd; +enum EF_SH4_NOFPU = 0x10; +enum EF_SH4A_NOFPU = 0x11; +enum EF_SH4_NOMMU_NOFPU = 0x12; +enum EF_SH2A_NOFPU = 0x13; +enum EF_SH3_NOMMU = 0x14; +enum EF_SH2A_SH4_NOFPU = 0x15; +enum EF_SH2A_SH3_NOFPU = 0x16; +enum EF_SH2A_SH4 = 0x17; +enum EF_SH2A_SH3E = 0x18; +enum R_SH_NONE = 0; +enum R_SH_DIR32 = 1; +enum R_SH_REL32 = 2; +enum R_SH_DIR8WPN = 3; +enum R_SH_IND12W = 4; +enum R_SH_DIR8WPL = 5; +enum R_SH_DIR8WPZ = 6; +enum R_SH_DIR8BP = 7; +enum R_SH_DIR8W = 8; +enum R_SH_DIR8L = 9; +enum R_SH_SWITCH16 = 25; +enum R_SH_SWITCH32 = 26; +enum R_SH_USES = 27; +enum R_SH_COUNT = 28; +enum R_SH_ALIGN = 29; +enum R_SH_CODE = 30; +enum R_SH_DATA = 31; +enum R_SH_LABEL = 32; +enum R_SH_SWITCH8 = 33; +enum R_SH_GNU_VTINHERIT = 34; +enum R_SH_GNU_VTENTRY = 35; +enum R_SH_TLS_GD_32 = 144; +enum R_SH_TLS_LD_32 = 145; +enum R_SH_TLS_LDO_32 = 146; +enum R_SH_TLS_IE_32 = 147; +enum R_SH_TLS_LE_32 = 148; +enum R_SH_TLS_DTPMOD32 = 149; +enum R_SH_TLS_DTPOFF32 = 150; +enum R_SH_TLS_TPOFF32 = 151; +enum R_SH_GOT32 = 160; +enum R_SH_PLT32 = 161; +enum R_SH_COPY = 162; +enum R_SH_GLOB_DAT = 163; +enum R_SH_JMP_SLOT = 164; +enum R_SH_RELATIVE = 165; +enum R_SH_GOTOFF = 166; +enum R_SH_GOTPC = 167; +enum R_SH_NUM = 256; + +enum EF_S390_HIGH_GPRS = 0x00000001; + +enum R_390_NONE = 0; +enum R_390_8 = 1; +enum R_390_12 = 2; +enum R_390_16 = 3; +enum R_390_32 = 4; +enum R_390_PC32 = 5; +enum R_390_GOT12 = 6; +enum R_390_GOT32 = 7; +enum R_390_PLT32 = 8; +enum R_390_COPY = 9; +enum R_390_GLOB_DAT = 10; +enum R_390_JMP_SLOT = 11; +enum R_390_RELATIVE = 12; +enum R_390_GOTOFF32 = 13; +enum R_390_GOTPC = 14; +enum R_390_GOT16 = 15; +enum R_390_PC16 = 16; +enum R_390_PC16DBL = 17; +enum R_390_PLT16DBL = 18; +enum R_390_PC32DBL = 19; +enum R_390_PLT32DBL = 20; +enum R_390_GOTPCDBL = 21; +enum R_390_64 = 22; +enum R_390_PC64 = 23; +enum R_390_GOT64 = 24; +enum R_390_PLT64 = 25; +enum R_390_GOTENT = 26; +enum R_390_GOTOFF16 = 27; +enum R_390_GOTOFF64 = 28; +enum R_390_GOTPLT12 = 29; +enum R_390_GOTPLT16 = 30; +enum R_390_GOTPLT32 = 31; +enum R_390_GOTPLT64 = 32; +enum R_390_GOTPLTENT = 33; +enum R_390_PLTOFF16 = 34; +enum R_390_PLTOFF32 = 35; +enum R_390_PLTOFF64 = 36; +enum R_390_TLS_LOAD = 37; +enum R_390_TLS_GDCALL = 38; +enum R_390_TLS_LDCALL = 39; +enum R_390_TLS_GD32 = 40; +enum R_390_TLS_GD64 = 41; +enum R_390_TLS_GOTIE12 = 42; +enum R_390_TLS_GOTIE32 = 43; +enum R_390_TLS_GOTIE64 = 44; +enum R_390_TLS_LDM32 = 45; +enum R_390_TLS_LDM64 = 46; +enum R_390_TLS_IE32 = 47; +enum R_390_TLS_IE64 = 48; +enum R_390_TLS_IEENT = 49; +enum R_390_TLS_LE32 = 50; +enum R_390_TLS_LE64 = 51; +enum R_390_TLS_LDO32 = 52; +enum R_390_TLS_LDO64 = 53; +enum R_390_TLS_DTPMOD = 54; +enum R_390_TLS_DTPOFF = 55; +enum R_390_TLS_TPOFF = 56; +enum R_390_20 = 57; +enum R_390_GOT20 = 58; +enum R_390_GOTPLT20 = 59; +enum R_390_TLS_GOTIE20 = 60; +enum R_390_IRELATIVE = 61; +enum R_390_NUM = 62; +enum R_CRIS_NONE = 0; +enum R_CRIS_8 = 1; +enum R_CRIS_16 = 2; +enum R_CRIS_32 = 3; +enum R_CRIS_8_PCREL = 4; +enum R_CRIS_16_PCREL = 5; +enum R_CRIS_32_PCREL = 6; +enum R_CRIS_GNU_VTINHERIT = 7; +enum R_CRIS_GNU_VTENTRY = 8; +enum R_CRIS_COPY = 9; +enum R_CRIS_GLOB_DAT = 10; +enum R_CRIS_JUMP_SLOT = 11; +enum R_CRIS_RELATIVE = 12; +enum R_CRIS_16_GOT = 13; +enum R_CRIS_32_GOT = 14; +enum R_CRIS_16_GOTPLT = 15; +enum R_CRIS_32_GOTPLT = 16; +enum R_CRIS_32_GOTREL = 17; +enum R_CRIS_32_PLT_GOTREL = 18; +enum R_CRIS_32_PLT_PCREL = 19; + +enum R_CRIS_NUM = 20; +enum R_X86_64_NONE = 0; +enum R_X86_64_64 = 1; +enum R_X86_64_PC32 = 2; +enum R_X86_64_GOT32 = 3; +enum R_X86_64_PLT32 = 4; +enum R_X86_64_COPY = 5; +enum R_X86_64_GLOB_DAT = 6; +enum R_X86_64_JUMP_SLOT = 7; +enum R_X86_64_RELATIVE = 8; +enum R_X86_64_GOTPCREL = 9; +enum R_X86_64_32 = 10; +enum R_X86_64_32S = 11; +enum R_X86_64_16 = 12; +enum R_X86_64_PC16 = 13; +enum R_X86_64_8 = 14; +enum R_X86_64_PC8 = 15; +enum R_X86_64_DTPMOD64 = 16; +enum R_X86_64_DTPOFF64 = 17; +enum R_X86_64_TPOFF64 = 18; +enum R_X86_64_TLSGD = 19; +enum R_X86_64_TLSLD = 20; +enum R_X86_64_DTPOFF32 = 21; +enum R_X86_64_GOTTPOFF = 22; +enum R_X86_64_TPOFF32 = 23; +enum R_X86_64_PC64 = 24; +enum R_X86_64_GOTOFF64 = 25; +enum R_X86_64_GOTPC32 = 26; +enum R_X86_64_GOT64 = 27; +enum R_X86_64_GOTPCREL64 = 28; +enum R_X86_64_GOTPC64 = 29; +enum R_X86_64_GOTPLT64 = 30; +enum R_X86_64_PLTOFF64 = 31; +enum R_X86_64_SIZE32 = 32; +enum R_X86_64_SIZE64 = 33; +enum R_X86_64_GOTPC32_TLSDESC = 34; +enum R_X86_64_TLSDESC_CALL = 35; +enum R_X86_64_TLSDESC = 36; +enum R_X86_64_IRELATIVE = 37; +enum R_X86_64_RELATIVE64 = 38; + +enum R_X86_64_NUM = 39; +enum R_MN10300_NONE = 0; +enum R_MN10300_32 = 1; +enum R_MN10300_16 = 2; +enum R_MN10300_8 = 3; +enum R_MN10300_PCREL32 = 4; +enum R_MN10300_PCREL16 = 5; +enum R_MN10300_PCREL8 = 6; +enum R_MN10300_GNU_VTINHERIT = 7; +enum R_MN10300_GNU_VTENTRY = 8; +enum R_MN10300_24 = 9; +enum R_MN10300_GOTPC32 = 10; +enum R_MN10300_GOTPC16 = 11; +enum R_MN10300_GOTOFF32 = 12; +enum R_MN10300_GOTOFF24 = 13; +enum R_MN10300_GOTOFF16 = 14; +enum R_MN10300_PLT32 = 15; +enum R_MN10300_PLT16 = 16; +enum R_MN10300_GOT32 = 17; +enum R_MN10300_GOT24 = 18; +enum R_MN10300_GOT16 = 19; +enum R_MN10300_COPY = 20; +enum R_MN10300_GLOB_DAT = 21; +enum R_MN10300_JMP_SLOT = 22; +enum R_MN10300_RELATIVE = 23; +enum R_MN10300_TLS_GD = 24; +enum R_MN10300_TLS_LD = 25; +enum R_MN10300_TLS_LDO = 26; +enum R_MN10300_TLS_GOTIE = 27; +enum R_MN10300_TLS_IE = 28; +enum R_MN10300_TLS_LE = 29; +enum R_MN10300_TLS_DTPMOD = 30; +enum R_MN10300_TLS_DTPOFF = 31; +enum R_MN10300_TLS_TPOFF = 32; +enum R_MN10300_SYM_DIFF = 33; +enum R_MN10300_ALIGN = 34; +enum R_MN10300_NUM = 35; +enum R_M32R_NONE = 0; +enum R_M32R_16 = 1; +enum R_M32R_32 = 2; +enum R_M32R_24 = 3; +enum R_M32R_10_PCREL = 4; +enum R_M32R_18_PCREL = 5; +enum R_M32R_26_PCREL = 6; +enum R_M32R_HI16_ULO = 7; +enum R_M32R_HI16_SLO = 8; +enum R_M32R_LO16 = 9; +enum R_M32R_SDA16 = 10; +enum R_M32R_GNU_VTINHERIT = 11; +enum R_M32R_GNU_VTENTRY = 12; +enum R_M32R_16_RELA = 33; +enum R_M32R_32_RELA = 34; +enum R_M32R_24_RELA = 35; +enum R_M32R_10_PCREL_RELA = 36; +enum R_M32R_18_PCREL_RELA = 37; +enum R_M32R_26_PCREL_RELA = 38; +enum R_M32R_HI16_ULO_RELA = 39; +enum R_M32R_HI16_SLO_RELA = 40; +enum R_M32R_LO16_RELA = 41; +enum R_M32R_SDA16_RELA = 42; +enum R_M32R_RELA_GNU_VTINHERIT = 43; +enum R_M32R_RELA_GNU_VTENTRY = 44; +enum R_M32R_REL32 = 45; + +enum R_M32R_GOT24 = 48; +enum R_M32R_26_PLTREL = 49; +enum R_M32R_COPY = 50; +enum R_M32R_GLOB_DAT = 51; +enum R_M32R_JMP_SLOT = 52; +enum R_M32R_RELATIVE = 53; +enum R_M32R_GOTOFF = 54; +enum R_M32R_GOTPC24 = 55; +enum R_M32R_GOT16_HI_ULO = 56; +enum R_M32R_GOT16_HI_SLO = 57; +enum R_M32R_GOT16_LO = 58; +enum R_M32R_GOTPC_HI_ULO = 59; +enum R_M32R_GOTPC_HI_SLO = 60; +enum R_M32R_GOTPC_LO = 61; +enum R_M32R_GOTOFF_HI_ULO = 62; +enum R_M32R_GOTOFF_HI_SLO = 63; +enum R_M32R_GOTOFF_LO = 64; +enum R_M32R_NUM = 256; +enum R_TILEPRO_NONE = 0; +enum R_TILEPRO_32 = 1; +enum R_TILEPRO_16 = 2; +enum R_TILEPRO_8 = 3; +enum R_TILEPRO_32_PCREL = 4; +enum R_TILEPRO_16_PCREL = 5; +enum R_TILEPRO_8_PCREL = 6; +enum R_TILEPRO_LO16 = 7; +enum R_TILEPRO_HI16 = 8; +enum R_TILEPRO_HA16 = 9; +enum R_TILEPRO_COPY = 10; +enum R_TILEPRO_GLOB_DAT = 11; +enum R_TILEPRO_JMP_SLOT = 12; +enum R_TILEPRO_RELATIVE = 13; +enum R_TILEPRO_BROFF_X1 = 14; +enum R_TILEPRO_JOFFLONG_X1 = 15; +enum R_TILEPRO_JOFFLONG_X1_PLT = 16; +enum R_TILEPRO_IMM8_X0 = 17; +enum R_TILEPRO_IMM8_Y0 = 18; +enum R_TILEPRO_IMM8_X1 = 19; +enum R_TILEPRO_IMM8_Y1 = 20; +enum R_TILEPRO_MT_IMM15_X1 = 21; +enum R_TILEPRO_MF_IMM15_X1 = 22; +enum R_TILEPRO_IMM16_X0 = 23; +enum R_TILEPRO_IMM16_X1 = 24; +enum R_TILEPRO_IMM16_X0_LO = 25; +enum R_TILEPRO_IMM16_X1_LO = 26; +enum R_TILEPRO_IMM16_X0_HI = 27; +enum R_TILEPRO_IMM16_X1_HI = 28; +enum R_TILEPRO_IMM16_X0_HA = 29; +enum R_TILEPRO_IMM16_X1_HA = 30; +enum R_TILEPRO_IMM16_X0_PCREL = 31; +enum R_TILEPRO_IMM16_X1_PCREL = 32; +enum R_TILEPRO_IMM16_X0_LO_PCREL = 33; +enum R_TILEPRO_IMM16_X1_LO_PCREL = 34; +enum R_TILEPRO_IMM16_X0_HI_PCREL = 35; +enum R_TILEPRO_IMM16_X1_HI_PCREL = 36; +enum R_TILEPRO_IMM16_X0_HA_PCREL = 37; +enum R_TILEPRO_IMM16_X1_HA_PCREL = 38; +enum R_TILEPRO_IMM16_X0_GOT = 39; +enum R_TILEPRO_IMM16_X1_GOT = 40; +enum R_TILEPRO_IMM16_X0_GOT_LO = 41; +enum R_TILEPRO_IMM16_X1_GOT_LO = 42; +enum R_TILEPRO_IMM16_X0_GOT_HI = 43; +enum R_TILEPRO_IMM16_X1_GOT_HI = 44; +enum R_TILEPRO_IMM16_X0_GOT_HA = 45; +enum R_TILEPRO_IMM16_X1_GOT_HA = 46; +enum R_TILEPRO_MMSTART_X0 = 47; +enum R_TILEPRO_MMEND_X0 = 48; +enum R_TILEPRO_MMSTART_X1 = 49; +enum R_TILEPRO_MMEND_X1 = 50; +enum R_TILEPRO_SHAMT_X0 = 51; +enum R_TILEPRO_SHAMT_X1 = 52; +enum R_TILEPRO_SHAMT_Y0 = 53; +enum R_TILEPRO_SHAMT_Y1 = 54; +enum R_TILEPRO_DEST_IMM8_X1 = 55; +enum R_TILEPRO_TLS_GD_CALL = 60; +enum R_TILEPRO_IMM8_X0_TLS_GD_ADD = 61; +enum R_TILEPRO_IMM8_X1_TLS_GD_ADD = 62; +enum R_TILEPRO_IMM8_Y0_TLS_GD_ADD = 63; +enum R_TILEPRO_IMM8_Y1_TLS_GD_ADD = 64; +enum R_TILEPRO_TLS_IE_LOAD = 65; +enum R_TILEPRO_IMM16_X0_TLS_GD = 66; +enum R_TILEPRO_IMM16_X1_TLS_GD = 67; +enum R_TILEPRO_IMM16_X0_TLS_GD_LO = 68; +enum R_TILEPRO_IMM16_X1_TLS_GD_LO = 69; +enum R_TILEPRO_IMM16_X0_TLS_GD_HI = 70; +enum R_TILEPRO_IMM16_X1_TLS_GD_HI = 71; +enum R_TILEPRO_IMM16_X0_TLS_GD_HA = 72; +enum R_TILEPRO_IMM16_X1_TLS_GD_HA = 73; +enum R_TILEPRO_IMM16_X0_TLS_IE = 74; +enum R_TILEPRO_IMM16_X1_TLS_IE = 75; +enum R_TILEPRO_IMM16_X0_TLS_IE_LO = 76; +enum R_TILEPRO_IMM16_X1_TLS_IE_LO = 77; +enum R_TILEPRO_IMM16_X0_TLS_IE_HI = 78; +enum R_TILEPRO_IMM16_X1_TLS_IE_HI = 79; +enum R_TILEPRO_IMM16_X0_TLS_IE_HA = 80; +enum R_TILEPRO_IMM16_X1_TLS_IE_HA = 81; +enum R_TILEPRO_TLS_DTPMOD32 = 82; +enum R_TILEPRO_TLS_DTPOFF32 = 83; +enum R_TILEPRO_TLS_TPOFF32 = 84; +enum R_TILEPRO_IMM16_X0_TLS_LE = 85; +enum R_TILEPRO_IMM16_X1_TLS_LE = 86; +enum R_TILEPRO_IMM16_X0_TLS_LE_LO = 87; +enum R_TILEPRO_IMM16_X1_TLS_LE_LO = 88; +enum R_TILEPRO_IMM16_X0_TLS_LE_HI = 89; +enum R_TILEPRO_IMM16_X1_TLS_LE_HI = 90; +enum R_TILEPRO_IMM16_X0_TLS_LE_HA = 91; +enum R_TILEPRO_IMM16_X1_TLS_LE_HA = 92; + +enum R_TILEPRO_GNU_VTINHERIT = 128; +enum R_TILEPRO_GNU_VTENTRY = 129; + +enum R_TILEPRO_NUM = 130; +enum R_TILEGX_NONE = 0; +enum R_TILEGX_64 = 1; +enum R_TILEGX_32 = 2; +enum R_TILEGX_16 = 3; +enum R_TILEGX_8 = 4; +enum R_TILEGX_64_PCREL = 5; +enum R_TILEGX_32_PCREL = 6; +enum R_TILEGX_16_PCREL = 7; +enum R_TILEGX_8_PCREL = 8; +enum R_TILEGX_HW0 = 9; +enum R_TILEGX_HW1 = 10; +enum R_TILEGX_HW2 = 11; +enum R_TILEGX_HW3 = 12; +enum R_TILEGX_HW0_LAST = 13; +enum R_TILEGX_HW1_LAST = 14; +enum R_TILEGX_HW2_LAST = 15; +enum R_TILEGX_COPY = 16; +enum R_TILEGX_GLOB_DAT = 17; +enum R_TILEGX_JMP_SLOT = 18; +enum R_TILEGX_RELATIVE = 19; +enum R_TILEGX_BROFF_X1 = 20; +enum R_TILEGX_JUMPOFF_X1 = 21; +enum R_TILEGX_JUMPOFF_X1_PLT = 22; +enum R_TILEGX_IMM8_X0 = 23; +enum R_TILEGX_IMM8_Y0 = 24; +enum R_TILEGX_IMM8_X1 = 25; +enum R_TILEGX_IMM8_Y1 = 26; +enum R_TILEGX_DEST_IMM8_X1 = 27; +enum R_TILEGX_MT_IMM14_X1 = 28; +enum R_TILEGX_MF_IMM14_X1 = 29; +enum R_TILEGX_MMSTART_X0 = 30; +enum R_TILEGX_MMEND_X0 = 31; +enum R_TILEGX_SHAMT_X0 = 32; +enum R_TILEGX_SHAMT_X1 = 33; +enum R_TILEGX_SHAMT_Y0 = 34; +enum R_TILEGX_SHAMT_Y1 = 35; +enum R_TILEGX_IMM16_X0_HW0 = 36; +enum R_TILEGX_IMM16_X1_HW0 = 37; +enum R_TILEGX_IMM16_X0_HW1 = 38; +enum R_TILEGX_IMM16_X1_HW1 = 39; +enum R_TILEGX_IMM16_X0_HW2 = 40; +enum R_TILEGX_IMM16_X1_HW2 = 41; +enum R_TILEGX_IMM16_X0_HW3 = 42; +enum R_TILEGX_IMM16_X1_HW3 = 43; +enum R_TILEGX_IMM16_X0_HW0_LAST = 44; +enum R_TILEGX_IMM16_X1_HW0_LAST = 45; +enum R_TILEGX_IMM16_X0_HW1_LAST = 46; +enum R_TILEGX_IMM16_X1_HW1_LAST = 47; +enum R_TILEGX_IMM16_X0_HW2_LAST = 48; +enum R_TILEGX_IMM16_X1_HW2_LAST = 49; +enum R_TILEGX_IMM16_X0_HW0_PCREL = 50; +enum R_TILEGX_IMM16_X1_HW0_PCREL = 51; +enum R_TILEGX_IMM16_X0_HW1_PCREL = 52; +enum R_TILEGX_IMM16_X1_HW1_PCREL = 53; +enum R_TILEGX_IMM16_X0_HW2_PCREL = 54; +enum R_TILEGX_IMM16_X1_HW2_PCREL = 55; +enum R_TILEGX_IMM16_X0_HW3_PCREL = 56; +enum R_TILEGX_IMM16_X1_HW3_PCREL = 57; +enum R_TILEGX_IMM16_X0_HW0_LAST_PCREL = 58; +enum R_TILEGX_IMM16_X1_HW0_LAST_PCREL = 59; +enum R_TILEGX_IMM16_X0_HW1_LAST_PCREL = 60; +enum R_TILEGX_IMM16_X1_HW1_LAST_PCREL = 61; +enum R_TILEGX_IMM16_X0_HW2_LAST_PCREL = 62; +enum R_TILEGX_IMM16_X1_HW2_LAST_PCREL = 63; +enum R_TILEGX_IMM16_X0_HW0_GOT = 64; +enum R_TILEGX_IMM16_X1_HW0_GOT = 65; +enum R_TILEGX_IMM16_X0_HW0_PLT_PCREL = 66; +enum R_TILEGX_IMM16_X1_HW0_PLT_PCREL = 67; +enum R_TILEGX_IMM16_X0_HW1_PLT_PCREL = 68; +enum R_TILEGX_IMM16_X1_HW1_PLT_PCREL = 69; +enum R_TILEGX_IMM16_X0_HW2_PLT_PCREL = 70; +enum R_TILEGX_IMM16_X1_HW2_PLT_PCREL = 71; +enum R_TILEGX_IMM16_X0_HW0_LAST_GOT = 72; +enum R_TILEGX_IMM16_X1_HW0_LAST_GOT = 73; +enum R_TILEGX_IMM16_X0_HW1_LAST_GOT = 74; +enum R_TILEGX_IMM16_X1_HW1_LAST_GOT = 75; +enum R_TILEGX_IMM16_X0_HW3_PLT_PCREL = 76; +enum R_TILEGX_IMM16_X1_HW3_PLT_PCREL = 77; +enum R_TILEGX_IMM16_X0_HW0_TLS_GD = 78; +enum R_TILEGX_IMM16_X1_HW0_TLS_GD = 79; +enum R_TILEGX_IMM16_X0_HW0_TLS_LE = 80; +enum R_TILEGX_IMM16_X1_HW0_TLS_LE = 81; +enum R_TILEGX_IMM16_X0_HW0_LAST_TLS_LE = 82; +enum R_TILEGX_IMM16_X1_HW0_LAST_TLS_LE = 83; +enum R_TILEGX_IMM16_X0_HW1_LAST_TLS_LE = 84; +enum R_TILEGX_IMM16_X1_HW1_LAST_TLS_LE = 85; +enum R_TILEGX_IMM16_X0_HW0_LAST_TLS_GD = 86; +enum R_TILEGX_IMM16_X1_HW0_LAST_TLS_GD = 87; +enum R_TILEGX_IMM16_X0_HW1_LAST_TLS_GD = 88; +enum R_TILEGX_IMM16_X1_HW1_LAST_TLS_GD = 89; +enum R_TILEGX_IMM16_X0_HW0_TLS_IE = 92; +enum R_TILEGX_IMM16_X1_HW0_TLS_IE = 93; +enum R_TILEGX_IMM16_X0_HW0_LAST_PLT_PCREL = 94; +enum R_TILEGX_IMM16_X1_HW0_LAST_PLT_PCREL = 95; +enum R_TILEGX_IMM16_X0_HW1_LAST_PLT_PCREL = 96; +enum R_TILEGX_IMM16_X1_HW1_LAST_PLT_PCREL = 97; +enum R_TILEGX_IMM16_X0_HW2_LAST_PLT_PCREL = 98; +enum R_TILEGX_IMM16_X1_HW2_LAST_PLT_PCREL = 99; +enum R_TILEGX_IMM16_X0_HW0_LAST_TLS_IE = 100; +enum R_TILEGX_IMM16_X1_HW0_LAST_TLS_IE = 101; +enum R_TILEGX_IMM16_X0_HW1_LAST_TLS_IE = 102; +enum R_TILEGX_IMM16_X1_HW1_LAST_TLS_IE = 103; +enum R_TILEGX_TLS_DTPMOD64 = 106; +enum R_TILEGX_TLS_DTPOFF64 = 107; +enum R_TILEGX_TLS_TPOFF64 = 108; +enum R_TILEGX_TLS_DTPMOD32 = 109; +enum R_TILEGX_TLS_DTPOFF32 = 110; +enum R_TILEGX_TLS_TPOFF32 = 111; +enum R_TILEGX_TLS_GD_CALL = 112; +enum R_TILEGX_IMM8_X0_TLS_GD_ADD = 113; +enum R_TILEGX_IMM8_X1_TLS_GD_ADD = 114; +enum R_TILEGX_IMM8_Y0_TLS_GD_ADD = 115; +enum R_TILEGX_IMM8_Y1_TLS_GD_ADD = 116; +enum R_TILEGX_TLS_IE_LOAD = 117; +enum R_TILEGX_IMM8_X0_TLS_ADD = 118; +enum R_TILEGX_IMM8_X1_TLS_ADD = 119; +enum R_TILEGX_IMM8_Y0_TLS_ADD = 120; +enum R_TILEGX_IMM8_Y1_TLS_ADD = 121; + +enum R_TILEGX_GNU_VTINHERIT = 128; +enum R_TILEGX_GNU_VTENTRY = 129; + +enum R_TILEGX_NUM = 130; diff --git a/libphobos/libdruntime/core/sys/hurd/errno.d b/libphobos/libdruntime/core/sys/hurd/errno.d new file mode 100644 index 000000000..db9c83c90 --- /dev/null +++ b/libphobos/libdruntime/core/sys/hurd/errno.d @@ -0,0 +1,21 @@ +/** + * D header file for GNU/Hurd + * + * Copyright: Copyright (c) 2026 D Language Foundation + * License: $(HTTP www.boost.org/LICENSE_1_0.txt, Boost License 1.0). + * $(LINK2 http://sourceware.org/git/?p=glibc.git;a=blob;f=stdlib/errno.h, glibc stdlib/errno.h) + */ +module core.sys.hurd.errno; + +version (Hurd): +extern (C): +nothrow: + +public import core.stdc.errno; +import core.sys.hurd.config; + +static if (_GNU_SOURCE) +{ + extern __gshared char* program_invocation_name, program_invocation_short_name; + alias error_t = int; +} diff --git a/libphobos/libdruntime/core/sys/hurd/execinfo.d b/libphobos/libdruntime/core/sys/hurd/execinfo.d new file mode 100644 index 000000000..4afeffa8f --- /dev/null +++ b/libphobos/libdruntime/core/sys/hurd/execinfo.d @@ -0,0 +1,16 @@ +/** + * D header file for GNU/Hurd. + * + * Copyright: Copyright (c) 2026 D Language Foundation + * License: $(HTTP www.boost.org/LICENSE_1_0.txt, Boost License 1.0). + */ +module core.sys.hurd.execinfo; + +version (Hurd): +extern (C): +nothrow: +@nogc: + +int backtrace(void** buffer, int size); +char** backtrace_symbols(const(void*)* buffer, int size); +void backtrace_symbols_fd(const(void*)* buffer, int size, int fd); diff --git a/libphobos/libdruntime/core/sys/hurd/link.d b/libphobos/libdruntime/core/sys/hurd/link.d new file mode 100644 index 000000000..e9df0fc0b --- /dev/null +++ b/libphobos/libdruntime/core/sys/hurd/link.d @@ -0,0 +1,134 @@ +/** + * D header file for GNU/Hurd. + * Copyright: Copyright (c) 2026 D Language Foundation + * License: $(HTTP www.boost.org/LICENSE_1_0.txt, Boost License 1.0). + * + * $(LINK2 http://sourceware.org/git/?p=glibc.git;a=blob;f=elf/link.h, glibc elf/link.h) + */ +module core.sys.hurd.link; + +version (Hurd): +extern (C): +nothrow: +@system: + +version (X86) version = X86_Any; +version (X86_64) version = X86_Any; + +import core.stdc.stdint : uintptr_t, uint32_t, uint64_t; +import core.sys.hurd.config : __WORDSIZE; +import core.sys.hurd.dlfcn : Lmid_t; +import core.sys.hurd.elf; + +version (X86_Any) +{ + // http://sourceware.org/git/?p=glibc.git;a=blob;f=bits/elfclass.h + alias __WORDSIZE __ELF_NATIVE_CLASS; + alias uint32_t Elf_Symndx; +} +else + static assert(0, "unimplemented"); +// + +template ElfW(string type) +{ + mixin("alias Elf"~__ELF_NATIVE_CLASS.stringof~"_"~type~" ElfW;"); +} + +enum +{ + RT_CONSISTENT, + RT_ADD, + RT_DELETE, +} + +struct r_debug +{ + int r_version; + link_map* r_map; + ElfW!"Addr" r_brk; + typeof(RT_CONSISTENT) r_state; + ElfW!"Addr" r_ldbase; +} + +extern r_debug _r_debug; +extern ElfW!"Dyn"* _DYNAMIC; + +struct link_map +{ + ElfW!"Addr" l_addr; + char* l_name; + ElfW!"Dyn"* l_ld; + link_map* l_next, l_prev; +} + +enum +{ + LA_ACT_CONSISTENT, + LA_ACT_ADD, + LA_ACT_DELETE, +} + +enum +{ + LA_SER_ORIG = 0x01, + LA_SER_LIBPATH = 0x02, + LA_SER_RUNPATH = 0x04, + LA_SER_CONFIG = 0x08, + LA_SER_DEFAULT = 0x40, + LA_SER_SECURE = 0x80, +} + + +enum +{ + LA_FLG_BINDTO = 0x01, + LA_FLG_BINDFROM = 0x02, +} + + +enum +{ + LA_SYMB_NOPLTENTER = 0x01, + LA_SYMB_NOPLTEXIT = 0x02, + LA_SYMB_STRUCTCALL = 0x04, + LA_SYMB_DLSYM = 0x08, + LA_SYMB_ALTVALUE = 0x10, +} + +struct dl_phdr_info +{ + ElfW!"Addr" dlpi_addr; + const(char)* dlpi_name; + const(ElfW!"Phdr")* dlpi_phdr; + ElfW!"Half" dlpi_phnum; + + // check the SIZE argument of the dl_iterate_phdr callback whether + // the following members are available + ulong dlpi_adds; + ulong dlpi_subs; + + size_t dlpi_tls_modid; + void *dlpi_tls_data; +} + +private alias extern(C) int function(dl_phdr_info*, size_t, void *) dl_iterate_phdr_cb; +private alias extern(C) int function(dl_phdr_info*, size_t, void *) @nogc dl_iterate_phdr_cb_ngc; +extern int dl_iterate_phdr(dl_iterate_phdr_cb __callback, void*__data); +extern int dl_iterate_phdr(dl_iterate_phdr_cb_ngc __callback, void*__data) @nogc; + +// ld.so auditing interfaces prototypes have to be defined by the auditing DSO. +extern uint la_version(uint __version); +extern void la_activity(uintptr_t *__cookie, uint __flag); +extern char* la_objsearch(const(char)* __name, uintptr_t* __cookie, + uint __flag); +extern uint la_objopen(link_map* __map, Lmid_t __lmid, + uintptr_t* __cookie); +extern void la_preinit(uintptr_t* __cookie); +extern uintptr_t la_symbind32(Elf32_Sym* __sym, uint __ndx, + uintptr_t* __refcook, uintptr_t* __defcook, + uint *__flags, const(char)* __symname); +extern uintptr_t la_symbind64(Elf64_Sym* __sym, uint __ndx, + uintptr_t* __refcook, uintptr_t* __defcook, + uint* __flags, const(char)* __symname); +extern uint la_objclose(uintptr_t *__cookie); diff --git a/libphobos/libdruntime/core/sys/hurd/sys/types.d b/libphobos/libdruntime/core/sys/hurd/sys/types.d new file mode 100644 index 000000000..a523a8df3 --- /dev/null +++ b/libphobos/libdruntime/core/sys/hurd/sys/types.d @@ -0,0 +1,22 @@ +/** + * D header file for Hurd extensions to POSIX's sys/types.h. + * + * Copyright: Copyright (c) 2026 D Language Foundation + * License: $(HTTP www.boost.org/LICENSE_1_0.txt, Boost License 1.0). + */ + +module core.sys.hurd.sys.types; + +import core.sys.posix.config; + +version (Hurd): +extern(C): +@nogc: +nothrow: + +static if (__WORDSIZE == 32) + alias ushort ipc_pid_t; +else + alias int ipc_pid_t; + +alias fsid_t = ulong; diff --git a/libphobos/libdruntime/core/sys/hurd/time.d b/libphobos/libdruntime/core/sys/hurd/time.d new file mode 100644 index 000000000..12031e599 --- /dev/null +++ b/libphobos/libdruntime/core/sys/hurd/time.d @@ -0,0 +1,15 @@ +/** + * D header file for Hurd extensions to POSIX's time.h. + * + * Copyright: Copyright (c) 2026 D Language Foundation + * License: $(HTTP www.boost.org/LICENSE_1_0.txt, Boost License 1.0). + */ +module core.sys.hurd.time; + +public import core.sys.posix.time; + +version (Hurd): + +enum CLOCK_MONOTONIC_RAW = 4; +enum CLOCK_REALTIME_COARSE = 5; +enum CLOCK_MONOTONIC_COARSE = 6; diff --git a/libphobos/libdruntime/core/sys/hurd/unistd.d b/libphobos/libdruntime/core/sys/hurd/unistd.d new file mode 100644 index 000000000..a351134cd --- /dev/null +++ b/libphobos/libdruntime/core/sys/hurd/unistd.d @@ -0,0 +1,30 @@ +/** + * D header file for GNU/Hurd. + * + * Copyright: Copyright (c) 2026 D Language Foundation + * License: $(HTTP www.boost.org/LICENSE_1_0.txt, Boost License 1.0). + */ +module core.sys.hurd.unistd; + +public import core.sys.posix.unistd; + +version (Hurd): +extern(C): +nothrow: +@nogc: + + +// Additional seek constants for sparse file handling +// from Hurds's unistd.h, stdio.h +enum { + /// Offset is relative to the next location containing data + SEEK_DATA = 3, + /// Offset is relative to the next hole (or EOF if file is not sparse) + SEEK_HOLE = 4 +} + +/// Prompt for a password without echoing it. +char* getpass(const(char)* prompt); + +/// Close all open file descriptors greater or equal to `lowfd` +void closefrom(int lowfd); diff --git a/libphobos/libdruntime/core/sys/linux/stdio.d b/libphobos/libdruntime/core/sys/linux/stdio.d index ab8971b48..7bdfca69c 100644 --- a/libphobos/libdruntime/core/sys/linux/stdio.d +++ b/libphobos/libdruntime/core/sys/linux/stdio.d @@ -6,6 +6,7 @@ * Authors: Danny Milosavljevic */ module core.sys.linux.stdio; +version (linux): version (CRuntime_Glibc): public import core.sys.posix.stdio; import core.sys.posix.sys.types : ssize_t, off64_t = off_t; diff --git a/libphobos/libdruntime/core/sys/posix/dirent.d b/libphobos/libdruntime/core/sys/posix/dirent.d index 8a2440e1f..06a7e0280 100644 --- a/libphobos/libdruntime/core/sys/posix/dirent.d +++ b/libphobos/libdruntime/core/sys/posix/dirent.d @@ -27,6 +27,12 @@ else version (TVOS) else version (WatchOS) version = Darwin; +version (CRuntime_Glibc) +{ + version (linux) + version = linuxGlibc; +} + version (Posix): extern (C): nothrow: @@ -50,7 +56,7 @@ dirent* readdir(DIR*); void rewinddir(DIR*); */ -version (CRuntime_Glibc) +version (linuxGlibc) { // NOTE: The following constants are non-standard Linux definitions // for dirent.d_type. @@ -440,6 +446,45 @@ else version (CRuntime_UClibc) dirent* readdir(DIR*); } } +else version (Hurd) +{ + enum + { + DT_UNKNOWN = 0, + DT_FIFO = 1, + DT_CHR = 2, + DT_DIR = 4, + DT_BLK = 6, + DT_REG = 8, + DT_LNK = 10, + DT_SOCK = 12, + DT_WHT = 14 + } + + struct dirent + { + ino_t d_ino; + ushort d_reclen; + ubyte d_type; + ubyte d_namlen; + char[1] d_name = 0; + } + + struct DIR + { + // Managed by OS + } + + static if ( __USE_FILE_OFFSET64 ) + { + dirent* readdir64(DIR*); + alias readdir64 readdir; + } + else + { + dirent* readdir(DIR*); + } +} else { static assert(false, "Unsupported platform"); diff --git a/libphobos/libdruntime/core/sys/posix/fcntl.d b/libphobos/libdruntime/core/sys/posix/fcntl.d index 59df921ba..739d950f3 100644 --- a/libphobos/libdruntime/core/sys/posix/fcntl.d +++ b/libphobos/libdruntime/core/sys/posix/fcntl.d @@ -28,6 +28,12 @@ else version (TVOS) else version (WatchOS) version = Darwin; +version (CRuntime_Glibc) +{ + version (linux) + version = linuxGlibc; +} + version (ARM) version = ARM_Any; version (AArch64) version = ARM_Any; version (HPPA) version = HPPA_Any; @@ -101,7 +107,7 @@ int creat(const scope char*, mode_t); int fcntl(int, int, ...); int open(const scope char*, int, ...); */ -version (CRuntime_Glibc) +version (linuxGlibc) { enum F_DUPFD = 0; enum F_GETFD = 1; @@ -1057,6 +1063,127 @@ else version (CRuntime_UClibc) enum AT_SYMLINK_NOFOLLOW = 0x100; enum AT_FDCWD = -100; } +else version (Hurd) +{ + enum F_DUPFD = 0; + enum F_GETFD = 1; + enum F_SETFD = 2; + enum F_GETFL = 3; + enum F_SETFL = 4; + enum F_GETOWN = 5; + enum F_SETOWN = 6; + + static if ( __USE_FILE_OFFSET64 ) + { + enum F_GETLK = F_GETLK64; + enum F_SETLK = F_SETLK64; + enum F_SETLKW = F_SETLKW64; + } + else + { + enum F_GETLK = 7; + enum F_SETLK = 8; + enum F_SETLKW = 9; + } + enum F_GETLK64 = 10; + enum F_SETLK64 = 11; + enum F_SETLKW64 = 12; + + enum F_DUPFD_CLOEXEC = 1030; + + enum FD_CLOEXEC = 1; + + enum F_RDLCK = 1; + enum F_WRLCK = 2; + enum F_UNLCK = 3; + + enum O_CREAT = 0x0010; + enum O_EXCL = 0x0020; + enum O_NOCTTY = 0; + enum O_TRUNC = 0x00010000; + + enum O_APPEND = 0x0100; + enum O_DSYNC = O_SYNC; + enum O_NONBLOCK = 0x0004; + enum O_RSYNC = O_SYNC; + + + enum O_ACCMODE = O_RDWR; + enum O_RDONLY = 0x0001; + enum O_WRONLY = 0x0002; + enum O_RDWR = (O_RDONLY|O_WRONLY); + + enum O_SYNC = O_FSYNC; + enum O_FSYNC = 0x0400; + + enum O_READ = O_RDONLY; + enum O_WRITE = O_WRONLY; + enum O_EXEC = 0x0004; + enum O_NORW = 0; + enum O_LARGEFILE = 0; + enum O_NOLINK = 0x0040; + enum O_NOTRANS = 0x0080; + enum O_NOFOLLOW = 0x00100000; + enum O_DIRECTORY = 0x00200000; + enum O_ASYNC = 0x0200; + enum O_NOATIME = 0x0800; + enum O_SHLOCK = 0x00020000; + enum O_EXLOCK = 0x00040000; + enum O_NDELAY = O_NONBLOCK; + enum O_HURD = (0xffff | O_EXLOCK | O_SHLOCK); + enum O_CLOEXEC = 0x00400000; + enum O_TMPFILE = 0x00800000; + enum O_IGNORE_CTTY = 0x00080000; + + + version (X86) + { + struct flock + { + int l_type; + int l_whence; + off_t l_start; + off_t l_len; + pid_t l_pid; + } + } + else version (X86_64) + { + struct flock + { + short l_type; + short l_whence; + off_t l_start; + off_t l_len; + pid_t l_pid; + } + } + else + { + static assert(false, "Unsupported platform"); + } + + enum AT_FDCWD = -100; + + enum AT_EACCESS = 0x200; + enum AT_SYMLINK_NOFOLLOW = 0x100; + enum AT_SYMLINK_FOLLOW = 0x400; + enum AT_REMOVEDIR = 0x200; + + static if ( __USE_FILE_OFFSET64 ) + { + int creat64(const scope char*, mode_t); + alias creat64 creat; + + int open64(const scope char*, int, ...); + alias open64 open; + } + else + { + int creat(const scope char*, mode_t); + int open(const scope char*, int, ...); + } +} else { static assert(false, "Unsupported platform"); diff --git a/libphobos/libdruntime/core/sys/posix/netinet/in_.d b/libphobos/libdruntime/core/sys/posix/netinet/in_.d index a58fa850d..818c36b66 100644 --- a/libphobos/libdruntime/core/sys/posix/netinet/in_.d +++ b/libphobos/libdruntime/core/sys/posix/netinet/in_.d @@ -85,18 +85,31 @@ version (CRuntime_Glibc) //{ // in_addr_t s_addr; //} + version (linux) + { + private enum __SOCK_SIZE__ = 16; - private enum __SOCK_SIZE__ = 16; + struct sockaddr_in + { + sa_family_t sin_family; + in_port_t sin_port; + in_addr sin_addr; - struct sockaddr_in + /* Pad to size of `struct sockaddr'. */ + ubyte[__SOCK_SIZE__ - sa_family_t.sizeof - + in_port_t.sizeof - in_addr.sizeof] __pad; + } + } + else version (Hurd) { - sa_family_t sin_family; - in_port_t sin_port; - in_addr sin_addr; - - /* Pad to size of `struct sockaddr'. */ - ubyte[__SOCK_SIZE__ - sa_family_t.sizeof - - in_port_t.sizeof - in_addr.sizeof] __pad; + struct sockaddr_in + { + ubyte sin_len; + sa_family_t sin_family; + in_port_t sin_port; + in_addr sin_addr; + ubyte[8] sin_zero; + } } enum @@ -513,13 +526,28 @@ version (CRuntime_Glibc) } } - struct sockaddr_in6 + version (linux) { - sa_family_t sin6_family; - in_port_t sin6_port; - uint32_t sin6_flowinfo; - in6_addr sin6_addr; - uint32_t sin6_scope_id; + struct sockaddr_in6 + { + ushort sin6_family; + uint16_t sin6_port; + uint32_t sin6_flowinfo; + in6_addr sin6_addr; + uint32_t sin6_scope_id; + } + } + else version (Hurd) + { + struct sockaddr_in6 + { + uint8_t sin6_len; + sa_family_t sin6_family; + uint16_t sin6_port; + uint32_t sin6_flowinfo; + in6_addr sin6_addr; + uint32_t sin6_scope_id; + } } extern __gshared immutable in6_addr in6addr_any; diff --git a/libphobos/libdruntime/core/sys/posix/poll.d b/libphobos/libdruntime/core/sys/posix/poll.d index fdc41764a..6f0587e3d 100644 --- a/libphobos/libdruntime/core/sys/posix/poll.d +++ b/libphobos/libdruntime/core/sys/posix/poll.d @@ -25,6 +25,12 @@ else version (TVOS) else version (WatchOS) version = Darwin; +version (CRuntime_Glibc) +{ + version (linux) + version = linuxGlibc; +} + version (Posix): extern (C): nothrow: @@ -58,7 +64,7 @@ POLLNVAL int poll(pollfd[], nfds_t, int); */ -version (CRuntime_Glibc) +version (linuxGlibc) { struct pollfd { @@ -363,3 +369,30 @@ else version (CRuntime_UClibc) int poll(pollfd*, nfds_t, int); } +else version (Hurd) +{ + struct pollfd + { + int fd; + short events; + short revents; + } + + alias c_ulong nfds_t; + + enum + { + POLLIN = 0x001, + POLLRDNORM = POLLIN, + POLLRDBAND = POLLPRI, + POLLPRI = 0x002, + POLLOUT = 0x004, + POLLWRNORM = POLLOUT, + POLLWRBAND = POLLOUT, + POLLERR = 0x008, /* ocatal 010 */ + POLLHUP = 0x010, /* ocatal 020 */ + POLLNVAL = 0x020, /* ocatal 040 */ + } + + int poll(pollfd*, nfds_t, int); +} diff --git a/libphobos/libdruntime/core/sys/posix/pthread.d b/libphobos/libdruntime/core/sys/posix/pthread.d index 395ed0f7e..081602789 100644 --- a/libphobos/libdruntime/core/sys/posix/pthread.d +++ b/libphobos/libdruntime/core/sys/posix/pthread.d @@ -105,41 +105,83 @@ void pthread_testcancel(); */ version (CRuntime_Glibc) { - enum + version (linux) { - PTHREAD_CANCEL_ENABLE, - PTHREAD_CANCEL_DISABLE - } + enum + { + PTHREAD_CANCEL_ENABLE, + PTHREAD_CANCEL_DISABLE + } - enum - { - PTHREAD_CANCEL_DEFERRED, - PTHREAD_CANCEL_ASYNCHRONOUS - } + enum + { + PTHREAD_CANCEL_DEFERRED, + PTHREAD_CANCEL_ASYNCHRONOUS + } - enum PTHREAD_CANCELED = cast(void*) -1; + enum PTHREAD_CANCELED = cast(void*) -1; - //enum pthread_mutex_t PTHREAD_COND_INITIALIZER = { __LOCK_ALT_INITIALIZER, 0, "", 0 }; + //enum pthread_mutex_t PTHREAD_COND_INITIALIZER = { __LOCK_ALT_INITIALIZER, 0, "", 0 }; - enum - { - PTHREAD_CREATE_JOINABLE, - PTHREAD_CREATE_DETACHED - } + enum + { + PTHREAD_CREATE_JOINABLE, + PTHREAD_CREATE_DETACHED + } - enum - { - PTHREAD_INHERIT_SCHED, - PTHREAD_EXPLICIT_SCHED - } + enum + { + PTHREAD_INHERIT_SCHED, + PTHREAD_EXPLICIT_SCHED + } - enum PTHREAD_MUTEX_INITIALIZER = pthread_mutex_t.init; - enum PTHREAD_ONCE_INIT = pthread_once_t.init; + enum PTHREAD_MUTEX_INITIALIZER = pthread_mutex_t.init; + enum PTHREAD_ONCE_INIT = pthread_once_t.init; - enum + enum + { + PTHREAD_PROCESS_PRIVATE, + PTHREAD_PROCESS_SHARED + } + } + else version (Hurd) { - PTHREAD_PROCESS_PRIVATE, - PTHREAD_PROCESS_SHARED + enum + { + PTHREAD_CANCEL_DISABLE, + PTHREAD_CANCEL_ENABLE, + } + + enum + { + PTHREAD_CANCEL_DEFERRED, + PTHREAD_CANCEL_ASYNCHRONOUS + } + + enum PTHREAD_CANCELED = cast(void*) -1; + + // enum __pthread_cond PTHREAD_COND_INITIALIZER = { __PTHREAD_SPIN_LOCK_INITIALIZER, NULL, NULL, 0, NULL } + + enum + { + PTHREAD_CREATE_JOINABLE = 0, + PTHREAD_CREATE_DETACHED, + } + + enum + { + PTHREAD_EXPLICIT_SCHED = 0, + PTHREAD_INHERIT_SCHED , + } + + enum PTHREAD_MUTEX_INITIALIZER = pthread_mutex_t.init; + enum PTHREAD_ONCE_INIT = pthread_once_t.init; + + enum + { + PTHREAD_PROCESS_PRIVATE = 0, + PTHREAD_PROCESS_SHARED, + } } } else version (Darwin) @@ -456,32 +498,70 @@ alias void function(void*) _pthread_cleanup_routine; alias void function(void*) @nogc _pthread_cleanup_routine_nogc; version (CRuntime_Glibc) { - struct _pthread_cleanup_buffer + version (linux) { - _pthread_cleanup_routine __routine; - void* __arg; - int __canceltype; - _pthread_cleanup_buffer* __prev; - } + struct _pthread_cleanup_buffer + { + _pthread_cleanup_routine __routine; + void* __arg; + int __canceltype; + _pthread_cleanup_buffer* __prev; + } - void _pthread_cleanup_push(_pthread_cleanup_buffer*, _pthread_cleanup_routine, void*); - void _pthread_cleanup_push(_pthread_cleanup_buffer*, _pthread_cleanup_routine_nogc, void*) @nogc; - void _pthread_cleanup_pop(_pthread_cleanup_buffer*, int); + void _pthread_cleanup_push(_pthread_cleanup_buffer*, _pthread_cleanup_routine, void*); + void _pthread_cleanup_push(_pthread_cleanup_buffer*, _pthread_cleanup_routine_nogc, void*) @nogc; + void _pthread_cleanup_pop(_pthread_cleanup_buffer*, int); - struct pthread_cleanup - { - _pthread_cleanup_buffer buffer = void; + struct pthread_cleanup + { + _pthread_cleanup_buffer buffer = void; - extern (D) void push(F: _pthread_cleanup_routine)(F routine, void* arg ) + extern (D) void push(F: _pthread_cleanup_routine)(F routine, void* arg ) + { + _pthread_cleanup_push( &buffer, routine, arg ); + } + + extern (D) void pop()( int execute ) + { + _pthread_cleanup_pop( &buffer, execute ); + } + } + } + else version (Hurd) + { + struct __pthread_cancelation_handler { - _pthread_cleanup_push( &buffer, routine, arg ); + _pthread_cleanup_routine __handler; + void* __arg; + __pthread_cancelation_handler* __next; } - extern (D) void pop()( int execute ) + private __pthread_cancelation_handler** __pthread_get_cleanup_stack(); + + struct pthread_cleanup { - _pthread_cleanup_pop( &buffer, execute ); + __pthread_cancelation_handler** handlers = void; + __pthread_cancelation_handler handler = void; + + extern (D) void push(F: _pthread_cleanup_routine)(F routine, void* arg) + { + handlers = __pthread_get_cleanup_stack(); + handler = __pthread_cancelation_handler(routine, arg, *handlers); + *handlers = &handler; + } + extern (D) void pop()(int execute) + { + if (execute) + handler.__handler(handler.__arg); + *handlers = handler.__next; + } } } + else + { + static assert(false, "Unsupported platform"); + } + } else version (Darwin) { @@ -1043,9 +1123,24 @@ int pthread_setconcurrency(int); version (CRuntime_Glibc) { - enum PTHREAD_MUTEX_NORMAL = 0; - enum PTHREAD_MUTEX_RECURSIVE = 1; - enum PTHREAD_MUTEX_ERRORCHECK = 2; + + version(linux) + { + enum PTHREAD_MUTEX_NORMAL = 0; + enum PTHREAD_MUTEX_RECURSIVE = 1; + enum PTHREAD_MUTEX_ERRORCHECK = 2; + } + else version(Hurd) + { + enum PTHREAD_MUTEX_NORMAL = 0; + enum PTHREAD_MUTEX_ERRORCHECK = 1; + enum PTHREAD_MUTEX_RECURSIVE = 2; + + } + else + { + static assert(false, "Unsupported platform"); + } enum PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL; int pthread_attr_getguardsize(const scope pthread_attr_t*, size_t*); @@ -1379,6 +1474,22 @@ else version (Solaris) int pthread_mutexattr_setprioceiling(pthread_mutexattr_t*, int); int pthread_mutexattr_setprotocol(pthread_mutexattr_t*, int); } +else version (Hurd) +{ + enum + { + PTHREAD_PRIO_NONE = 0, + PTHREAD_PRIO_INHERIT, + PTHREAD_PRIO_PROTECT, + } + + int pthread_mutex_getprioceiling(const scope pthread_mutex_t*, int*); + int pthread_mutex_setprioceiling(pthread_mutex_t*, int, int*); + int pthread_mutexattr_getprioceiling(const scope pthread_mutexattr_t*, int*); + int pthread_mutexattr_getprotocol(const scope pthread_mutexattr_t*, int*); + int pthread_mutexattr_setprioceiling(pthread_mutexattr_t*, int); + int pthread_mutexattr_setprotocol(pthread_mutexattr_t*, int); +} // // Scheduling (TPS) @@ -1400,10 +1511,21 @@ int pthread_setschedprio(pthread_t, int); version (CRuntime_Glibc) { - enum + version (linux) { - PTHREAD_SCOPE_SYSTEM, - PTHREAD_SCOPE_PROCESS + enum + { + PTHREAD_SCOPE_SYSTEM, + PTHREAD_SCOPE_PROCESS + } + } + else version (Hurd) + { + enum + { + PTHREAD_SCOPE_SYSTEM = 0, + PTHREAD_SCOPE_PROCESS, + } } int pthread_attr_getinheritsched(const scope pthread_attr_t*, int*); diff --git a/libphobos/libdruntime/core/sys/posix/semaphore.d b/libphobos/libdruntime/core/sys/posix/semaphore.d index 4f6f63988..cea0ee596 100644 --- a/libphobos/libdruntime/core/sys/posix/semaphore.d +++ b/libphobos/libdruntime/core/sys/posix/semaphore.d @@ -52,19 +52,31 @@ int sem_wait(sem_t*); version (CRuntime_Glibc) { - private alias int __atomic_lock_t; - - private struct _pthread_fastlock + version(linux) { - c_long __status; - __atomic_lock_t __spinlock; - } + private alias int __atomic_lock_t; - struct sem_t + private struct _pthread_fastlock + { + c_long __status; + __atomic_lock_t __spinlock; + } + + struct sem_t + { + _pthread_fastlock __sem_lock; + int __sem_value; + void* __sem_waiting; + } + } + else version (Hurd) { - _pthread_fastlock __sem_lock; - int __sem_value; - void* __sem_waiting; + private enum __SIZEOF_SEM_T = 20; + union sem_t + { + byte[__SIZEOF_SEM_T] __size; + c_long __align; + } } enum SEM_FAILED = cast(sem_t*) null; diff --git a/libphobos/libdruntime/core/sys/posix/signal.d b/libphobos/libdruntime/core/sys/posix/signal.d index 0dce8c53f..55e62876f 100644 --- a/libphobos/libdruntime/core/sys/posix/signal.d +++ b/libphobos/libdruntime/core/sys/posix/signal.d @@ -25,6 +25,12 @@ else version (TVOS) else version (WatchOS) version = Darwin; +version (CRuntime_Glibc) +{ + version (linux) + version = linuxGlibc; +} + version (ARM) version = ARM_Any; version (AArch64) version = ARM_Any; version (HPPA) version = HPPA_Any; @@ -166,6 +172,9 @@ else version (NetBSD) enum SIGRTMIN = 33; enum SIGRTMAX = 63; } +else version (Hurd) +{ +} else version (linux) { // Note: CRuntime_Bionic switched to calling these functions @@ -529,12 +538,30 @@ else version (Solaris) enum SIGUSR2 = 17; enum SIGURG = 21; } +else version (Hurd) +{ + enum SIGALRM = 14; + enum SIGBUS = 10; + enum SIGCHLD = 20; + enum SIGCONT = 19; + enum SIGHUP = 1; + enum SIGKILL = 9; + enum SIGPIPE = 13; + enum SIGQUIT = 3; + enum SIGSTOP = 17; + enum SIGTSTP = 18; + enum SIGTTIN = 21; + enum SIGTTOU = 22; + enum SIGUSR1 = 30; + enum SIGUSR2 = 31; + enum SIGURG = 16; +} else { static assert(false, "Unsupported platform"); } -version (CRuntime_Glibc) +version (linuxGlibc) { version (SystemZ) { @@ -782,6 +809,26 @@ else version (Darwin) int sa_flags; } } +else version (Hurd) +{ + struct sigaction_t + { + static if ( true /* __USE_POSIX199309 */ ) + { + union + { + sigfn_t sa_handler; + sigactfn_t sa_sigaction; + } + } + else + { + sigfn_t sa_handler; + } + sigset_t sa_mask; + int sa_flags; + } +} else { static assert(false, "Unsupported platform"); @@ -850,7 +897,7 @@ int sigwait(const scope sigset_t*, int*); nothrow @nogc { -version (CRuntime_Glibc) +version (linuxGlibc) { enum SIG_HOLD = cast(sigfn_t2) 1; @@ -1939,6 +1986,53 @@ else version (CRuntime_UClibc) int sigsuspend(const scope sigset_t*); int sigwait(const scope sigset_t*, int*); } +else version(Hurd) +{ + enum SIG_HOLD = cast(sigfn_t2) 2; + + alias c_ulong sigset_t; + + enum SA_NOCLDSTOP = 0x0008; // (CX|XSI) + + enum SIG_BLOCK = 1; + enum SIG_UNBLOCK = 2; + enum SIG_SETMASK = 3; + + struct siginfo_t + { + int si_signo; + int si_errno; + int si_code; + + pid_t si_pid; + uid_t si_uid; + void* si_addr; + int si_status; + c_long si_band; + sigval si_value; + } + + enum + { + SI_ASYNCIO = -4, + SI_MESGQ, + SI_TIMER, + SI_QUEUE, + SI_USER + } + + int kill(pid_t, int); + int sigaction(int, const scope sigaction_t*, sigaction_t*); + int sigaddset(sigset_t*, int); + int sigdelset(sigset_t*, int); + int sigemptyset(sigset_t*); + int sigfillset(sigset_t*); + int sigismember(const scope sigset_t*, int); + int sigpending(sigset_t*); + int sigprocmask(int, const scope sigset_t*, sigset_t*); + int sigsuspend(const scope sigset_t*); + int sigwait(const scope sigset_t*, int*); +} else { static assert(false, "Unsupported platform"); @@ -2038,7 +2132,7 @@ int sigpause(int); int sigrelse(int); */ -version (CRuntime_Glibc) +version (linuxGlibc) { version (X86_Any) { @@ -3408,6 +3502,123 @@ else version (CRuntime_UClibc) int sigpause(int); int sigrelse(int); } +else version(Hurd) +{ + enum SIGPOLL = 23; + enum SIGPROF = 27; + enum SIGSYS = 12; + enum SIGTRAP = 5; + enum SIGVTALRM = 26; + enum SIGXCPU = 24; + enum SIGXFSZ = 25; + + enum + { + SA_ONSTACK = 0x0001, + SA_RESETHAND = 0x0004, + SA_RESTART = 0x0002, + SA_SIGINFO = 0x0040, + // SA_NOCLDWAIT = , + SA_NODEFER = 0x00010, + } + + enum SS_ONSTACK = 0x0001; + enum SS_DISABLE = 0x0004; + enum MINSIGSTKSZ = 8192; + enum SIGSTKSZ = (MINSIGSTKSZ + 32768); + + struct stack_t + { + void* ss_sp; + int ss_flags; + size_t ss_size; + } + + struct sigstack + { + void* ss_sp; + int ss_onstack; + } + + enum + { + ILL_ILLOPC = 1, + ILL_ILLOPN, + ILL_ILLADR, + ILL_ILLTRP, + ILL_PRVOPC, + ILL_PRVREG, + ILL_COPROC, + ILL_BADSTK + } + + enum + { + FPE_INTDIV = 1, + FPE_INTOVF, + FPE_FLTDIV, + FPE_FLTOVF, + FPE_FLTUND, + FPE_FLTRES, + FPE_FLTINV, + FPE_FLTSUB + } + + enum + { + SEGV_MAPERR = 1, + SEGV_ACCERR + } + + enum + { + BUS_ADRALN = 1, + BUS_ADRERR, + BUS_OBJERR + } + + enum + { + TRAP_BRKPT = 1, + TRAP_TRACE + } + + enum + { + CLD_EXITED = 1, + CLD_KILLED, + CLD_DUMPED, + CLD_TRAPPED, + CLD_STOPPED, + CLD_CONTINUED + } + + enum + { + POLL_IN = 1, + POLL_OUT, + POLL_MSG, + POLL_ERR, + POLL_PRI, + POLL_HUP + } + + sigfn_t bsd_signal(int sig, sigfn_t func); + sigfn_t sigset(int sig, sigfn_t func); + + nothrow: + @nogc: + sigfn_t2 bsd_signal(int sig, sigfn_t2 func); + sigfn_t2 sigset(int sig, sigfn_t2 func); + + int killpg(pid_t, int); + int sigaltstack(const scope stack_t*, stack_t*); + int sighold(int); + int sigignore(int); + int siginterrupt(int, int); + int sigpause(int); + int sigrelse(int); +} else { static assert(false, "Unsupported platform"); @@ -3485,6 +3696,14 @@ else version (Solaris) alias timespec timestruc_t; } +else version (Hurd) +{ + struct timespec + { + time_t tv_sec; + c_long tv_nsec; + } +} else { static assert(false, "Unsupported platform"); @@ -3511,7 +3730,7 @@ int sigwaitinfo(const scope sigset_t*, siginfo_t*); nothrow: @nogc: -version (CRuntime_Glibc) +version (linuxGlibc) { private enum __SIGEV_MAX_SIZE = 64; @@ -3721,6 +3940,22 @@ else version (CRuntime_UClibc) int sigtimedwait(const scope sigset_t*, siginfo_t*, const scope timespec*); int sigwaitinfo(const scope sigset_t*, siginfo_t*); } +else version (Hurd) +{ + struct sigevent + { + sigval sigev_value; + int sigev_signo; + int sigev_notify; + + void function(sigval) sigev_notify_function; + void* sigev_notify_attributes; + } + + int sigqueue(pid_t, int, const sigval); + int sigtimedwait(const scope sigset_t*, siginfo_t*, const scope timespec*); + int sigwaitinfo(const scope sigset_t*, siginfo_t*); +} else { static assert(false, "Unsupported platform"); diff --git a/libphobos/libdruntime/core/sys/posix/spawn.d b/libphobos/libdruntime/core/sys/posix/spawn.d index 86b175173..5b68f49eb 100644 --- a/libphobos/libdruntime/core/sys/posix/spawn.d +++ b/libphobos/libdruntime/core/sys/posix/spawn.d @@ -34,6 +34,8 @@ OpenBSD: https://github.com/openbsd/src/blob/master/include/spawn.h DragonFlyBSD: https://github.com/DragonFlyBSD/DragonFlyBSD/blob/master/include/spawn.h Solaris: https://github.com/illumos/illumos-gate/blob/master/usr/src/head/spawn.h + +Hurd: https://sourceware.org/git/?p=glibc.git;a=blob;f=posix/spawn.h;hb=HEAD */ version (OSX) // macOS and iOS only as this API is prohibited on WatchOS and TVOS @@ -371,5 +373,45 @@ else version (Solaris) int posix_spawnattr_setsigignore_np(posix_spawnattr_t* attr, const sigset_t* sigignore); } } +else version (Hurd) +{ + // Source: https://sourceware.org/git/?p=glibc.git;a=blob;f=posix/spawn.h;hb=HEAD + enum + { + POSIX_SPAWN_RESETIDS = 0x01, + POSIX_SPAWN_SETPGROUP = 0x02, + POSIX_SPAWN_SETSIGDEF = 0x04, + POSIX_SPAWN_SETSIGMASK = 0x08, + POSIX_SPAWN_SETSCHEDPARAM = 0x10, + POSIX_SPAWN_SETSCHEDULER = 0x20, + } + import core.sys.posix.config : _GNU_SOURCE; + static if (_GNU_SOURCE) + { + enum + { + POSIX_SPAWN_USEVFORK = 0x40, + POSIX_SPAWN_SETSID = 0x80 + } + } + struct posix_spawnattr_t + { + short __flags; + pid_t __pgrp; + sigset_t __sd; + sigset_t __ss; + sched_param __sp; + int __policy; + int[16] __pad; + } + private struct __spawn_action; + struct posix_spawn_file_actions_t + { + int __allocated; + int __used; + __spawn_action* __actions; + int[16] __pad; + } +} else static assert(0, "Unsupported OS"); diff --git a/libphobos/libdruntime/core/sys/posix/sys/ipc.d b/libphobos/libdruntime/core/sys/posix/sys/ipc.d index d397a28ec..e710dc641 100644 --- a/libphobos/libdruntime/core/sys/posix/sys/ipc.d +++ b/libphobos/libdruntime/core/sys/posix/sys/ipc.d @@ -26,6 +26,12 @@ else version (TVOS) else version (WatchOS) version = Darwin; +version (CRuntime_Glibc) +{ + version (linux) + version = linuxGlibc; +} + version (Posix): extern (C) nothrow @nogc: @system: @@ -56,7 +62,7 @@ IPC_STAT key_t ftok(const scope char*, int); */ -version (CRuntime_Glibc) +version (linuxGlibc) { struct ipc_perm { @@ -273,3 +279,48 @@ else version (CRuntime_UClibc) key_t ftok(const scope char*, int); } +else version (Hurd) +{ + version (X86) + { + struct ipc_perm + { + key_t __key; + ushort uid; + ushort gid; + ushort cuid; + ushort cgid; + ushort mode; + ushort __seq; + } + } + else version (X86_64) + { + struct ipc_perm + { + key_t __key; + uid_t uid; + gid_t gid; + uid_t cuid; + gid_t cgid; + mode_t mode; + ushort __seq; + } + } + else + { + static assert(false, "Unsupported platform"); + } + + enum IPC_CREAT = 0x0200; // 01000 + enum IPC_EXCL = 0x0400; // 02000 + enum IPC_NOWAIT = 0x0800; // 04000 + + enum key_t IPC_PRIVATE = 0; + + enum IPC_RMID = 0; + enum IPC_SET = 1; + enum IPC_STAT = 2; + + key_t ftok(const scope char*, int); +} diff --git a/libphobos/libdruntime/core/sys/posix/sys/mman.d b/libphobos/libdruntime/core/sys/posix/sys/mman.d index a74a21369..df63e9560 100644 --- a/libphobos/libdruntime/core/sys/posix/sys/mman.d +++ b/libphobos/libdruntime/core/sys/posix/sys/mman.d @@ -26,6 +26,12 @@ else version (TVOS) else version (WatchOS) version = Darwin; +version (CRuntime_Glibc) +{ + version (linux) + version = linuxGlibc; +} + version (ARM) version = ARM_Any; version (AArch64) version = ARM_Any; version (HPPA) version = HPPA_Any; @@ -65,7 +71,7 @@ POSIX_MADV_WILLNEED POSIX_MADV_DONTNEED */ -version (CRuntime_Glibc) +version (linuxGlibc) { version (Alpha) private enum __POSIX_MADV_DONTNEED = 6; @@ -160,6 +166,16 @@ else version (CRuntime_UClibc) } int posix_madvise(void *__addr, size_t __len, int __advice); } +else version (Hurd) +{ + enum POSIX_MADV_NORMAL = 0; + enum POSIX_MADV_RANDOM = 1; + enum POSIX_MADV_SEQUENTIAL = 2; + enum POSIX_MADV_WILLNEED = 3; + enum POSIX_MADV_DONTNEED = 4; + + int posix_madvise(void *__addr, size_t __len, int __advice); +} else { static assert(false, "Unsupported platform"); @@ -175,7 +191,7 @@ PROT_EXEC PROT_NONE */ -version (CRuntime_Glibc) +version (linuxGlibc) { enum PROT_NONE = 0x0; enum PROT_READ = 0x1; @@ -245,6 +261,13 @@ else version (CRuntime_UClibc) enum PROT_WRITE = 0x2; enum PROT_EXEC = 0x4; } +else version (Hurd) +{ + enum PROT_NONE = 0x00; + enum PROT_READ = 0x04; + enum PROT_WRITE = 0x02; + enum PROT_EXEC = 0x01; +} else { static assert(false, "Unsupported platform"); @@ -341,7 +364,7 @@ MS_INVALIDATE (MF|SIO) int msync(void*, size_t, int); (MF|SIO) */ -version (CRuntime_Glibc) +version (linuxGlibc) { enum MAP_SHARED = 0x01; enum MAP_PRIVATE = 0x02; @@ -564,6 +587,21 @@ else version (CRuntime_UClibc) int msync(void*, size_t, int); } + else version (Hurd) +{ + enum MAP_SHARED = 0x0010; + enum MAP_PRIVATE = 0x0000; + enum MAP_FIXED = 0x0100; + enum MAP_ANON = 0x0002; + + enum MAP_FAILED = cast(void*)-1; + + enum MS_ASYNC = 1; + enum MS_INVALIDATE = 0; + enum MS_SYNC = 2; + + int msync(void*, size_t, int); + } else { static assert(false, "Unsupported platform"); diff --git a/libphobos/libdruntime/core/sys/posix/sys/msg.d b/libphobos/libdruntime/core/sys/posix/sys/msg.d index 4760f2e22..f9ad3e110 100644 --- a/libphobos/libdruntime/core/sys/posix/sys/msg.d +++ b/libphobos/libdruntime/core/sys/posix/sys/msg.d @@ -173,6 +173,50 @@ version (linux) } } } +else version (Hurd) +{ + import core.sys.hurd.sys.types; + enum MSG_STAT = 11; + enum MSG_INFO = 12; + + enum MSG_NOERROR = 1 << 12; // octal!10000 + enum MSG_EXCEPT = 2 << 12; // octal!20000 + + struct msginfo + { + int msgpool; + int msgmap; + int msgmax; + int msgmnb; + int msgmni; + int msgssz; + int msgtql; + ushort msgseg; + } + + alias ushort msgqnum_t; + alias ushort msglen_t; + + private struct msg; + private struct __wait_queue; + + struct msqid_ds + { + ipc_perm msg_perm; + msg *__msg_first; + msg *__msg_last; + time_t msg_stime; + time_t msg_rtime; + time_t msg_ctime; + __wait_queue *__wwait; + __wait_queue *__rwait; + ushort __msg_cbytes; + msgqnum_t msg_qnum; + msglen_t msg_qbytes; + ipc_pid_t msg_lspid; + ipc_pid_t msg_lrpid; + } +} else { // https://sourceware.org/git/?p=glibc.git;a=blob;f=bits/msq.h diff --git a/libphobos/libdruntime/core/sys/posix/sys/resource.d b/libphobos/libdruntime/core/sys/posix/sys/resource.d index c5d584c58..afa159636 100644 --- a/libphobos/libdruntime/core/sys/posix/sys/resource.d +++ b/libphobos/libdruntime/core/sys/posix/sys/resource.d @@ -22,6 +22,12 @@ else version (TVOS) else version (WatchOS) version = Darwin; +version (CRuntime_Glibc) +{ + version (linux) + version = linuxGlibc; +} + nothrow @nogc extern(C): @system: @@ -83,7 +89,7 @@ int setrlimit(int, const rlimit*); */ -version (CRuntime_Glibc) +version (linuxGlibc) { // rusage and some other constants in the Bionic section below really // come from the linux kernel headers, but they're all mixed right now. @@ -629,6 +635,64 @@ else version (CRuntime_UClibc) RLIMIT_AS = 9, } } +else version (Hurd) +{ + enum + { + PRIO_PROCESS = 0, + PRIO_PGRP = 1, + PRIO_USER = 2, + } + + static if (__USE_FILE_OFFSET64) + alias ulong rlim_t; + else + alias c_ulong rlim_t; + + static if (__USE_FILE_OFFSET64) + enum RLIM_INFINITY = 0xffffffffffffffffUL; + else + enum RLIM_INFINITY = cast(c_ulong)(~0UL); + + enum RLIM_SAVED_MAX = RLIM_INFINITY; + enum RLIM_SAVED_CUR = RLIM_INFINITY; + + enum + { + RUSAGE_SELF = 0, + RUSAGE_CHILDREN = -1, + } + + struct rusage + { + timeval ru_utime; + timeval ru_stime; + c_long ru_maxrss; + c_long ru_ixrss; + c_long ru_idrss; + c_long ru_isrss; + c_long ru_minflt; + c_long ru_majflt; + c_long ru_nswap; + c_long ru_inblock; + c_long ru_oublock; + c_long ru_msgsnd; + c_long ru_msgrcv; + c_long ru_nsignals; + c_long ru_nvcsw; + c_long ru_nivcsw; + } + enum + { + RLIMIT_CORE = 4, + RLIMIT_CPU = 0, + RLIMIT_DATA = 2, + RLIMIT_FSIZE = 1, + RLIMIT_NOFILE = 8, + RLIMIT_STACK = 3, + RLIMIT_AS = 10, + } +} else static assert (false, "Unsupported platform"); struct rlimit diff --git a/libphobos/libdruntime/core/sys/posix/sys/shm.d b/libphobos/libdruntime/core/sys/posix/sys/shm.d index 2e85096ba..befceb2bf 100644 --- a/libphobos/libdruntime/core/sys/posix/sys/shm.d +++ b/libphobos/libdruntime/core/sys/posix/sys/shm.d @@ -27,6 +27,12 @@ else version (TVOS) else version (WatchOS) version = Darwin; +version (CRuntime_Glibc) +{ + version (linux) + version = linuxGlibc; +} + version (Posix): extern (C) nothrow @nogc: @system: @@ -60,7 +66,7 @@ int shmdt(const scope void*); int shmget(key_t, size_t, int); */ -version (CRuntime_Glibc) +version (linuxGlibc) { enum SHM_RDONLY = 0x01000; // 010000 enum SHM_RND = 0x02000; // 020000 @@ -215,6 +221,32 @@ else version (DragonFlyBSD) else version (Darwin) { +} +else version (Hurd) +{ + import core.sys.hurd.sys.types; + enum SHM_RDONLY = 0x01000; // 010000 + enum SHM_RND = 0x02000; // 020000 + enum SHM_REMAP = 0x4000; // 040000 + + alias short shmatt_t; + + private struct __vm_area_struct; + + struct shmid_ds + { + ipc_perm shm_perm; + size_t shm_segsz; + time_t shm_atime; + time_t shm_dtime; + time_t shm_ctime; + ipc_pid_t shm_cpid; + ipc_pid_t shm_lpid; + shmatt_t shm_nattch; + private ushort __shm_npages; + private c_ulong* __shm_pages; + private __vm_area_struct* __attaches; + } } else version (CRuntime_UClibc) { diff --git a/libphobos/libdruntime/core/sys/posix/sys/socket.d b/libphobos/libdruntime/core/sys/posix/sys/socket.d index 430d0c0d1..a87447080 100644 --- a/libphobos/libdruntime/core/sys/posix/sys/socket.d +++ b/libphobos/libdruntime/core/sys/posix/sys/socket.d @@ -27,6 +27,12 @@ else version (TVOS) else version (WatchOS) version = Darwin; +version (CRuntime_Glibc) +{ + version (linux) + version = linuxGlibc; +} + version (ARM) version = ARM_Any; version (AArch64) version = ARM_Any; version (HPPA) version = HPPA_Any; @@ -158,7 +164,7 @@ int sockatmark(int); int socketpair(int, int, int, ref int[2]); */ -version (CRuntime_Glibc) + version (linuxGlibc) { // Some of the constants below and from the Bionic section are really from // the linux kernel headers. @@ -2186,6 +2192,172 @@ else version (CRuntime_UClibc) int sockatmark(int); int socketpair(int, int, int, ref int[2]); } +else version (Hurd) +{ + alias uint socklen_t; + alias ubyte sa_family_t; + + struct sockaddr + { + ubyte ss_len; + sa_family_t sa_family; + byte[14] sa_data; + } + + private enum : size_t + { + _SS_SIZE = 128, + _SS_PADSIZE = _SS_SIZE - c_ulong.sizeof - sa_family_t.sizeof - ubyte.sizeof, + } + + struct sockaddr_storage + { + ubyte ss_len; + sa_family_t ss_family; + byte[_SS_PADSIZE] __ss_padding; + c_ulong __ss_align; + } + struct msghdr + { + void* msg_name; + socklen_t msg_namelen; + iovec* msg_iov; + int msg_iovlen; + void* msg_control; + socklen_t msg_controllen; + int msg_flags; + } + + struct cmsghdr + { + socklen_t cmsg_len; + int cmsg_level; + int cmsg_type; + } + enum : uint + { + SCM_RIGHTS = 0x01 + } + + extern (D) inout(ubyte)* CMSG_DATA( return scope inout(cmsghdr)* cmsg ) pure nothrow @nogc { return cast(ubyte*)( cmsg + 1 ); } + private inout(cmsghdr)* __cmsg_nxthdr(inout(msghdr)*, inout(cmsghdr)*) pure nothrow @nogc; + extern (D) inout(cmsghdr)* CMSG_NXTHDR(inout(msghdr)* msg, inout(cmsghdr)* cmsg) pure nothrow @nogc + { + return __cmsg_nxthdr(msg, cmsg); + } + + extern (D) inout(cmsghdr)* CMSG_FIRSTHDR( inout(msghdr)* mhdr ) pure nothrow @nogc + { + return ( cast(size_t)mhdr.msg_controllen >= cmsghdr.sizeof + ? cast(inout(cmsghdr)*) mhdr.msg_control + : cast(inout(cmsghdr)*) null ); + } + + extern (D) + { + size_t CMSG_ALIGN( size_t len ) pure nothrow @nogc + { + return (len + size_t.sizeof - 1) & cast(size_t) (~(size_t.sizeof - 1)); + } + + size_t CMSG_LEN( size_t len ) pure nothrow @nogc + { + return CMSG_ALIGN(cmsghdr.sizeof) + len; + } + } + + extern (D) size_t CMSG_SPACE(size_t len) pure nothrow @nogc + { + return CMSG_ALIGN(len) + CMSG_ALIGN(cmsghdr.sizeof); + } + struct linger + { + int l_onoff; + int l_linger; + } + + enum + { + SOCK_DGRAM = 2, + SOCK_RDM = 4, + SOCK_SEQPACKET = 5, + SOCK_STREAM = 1, + } + enum + { + SOL_SOCKET = 0xffff + } + enum + { + SO_ACCEPTCONN = 0x0002, + SO_BROADCAST = 0x0020, + SO_DEBUG = 0x0001, + SO_DONTROUTE = 0x0010, + SO_ERROR = 0x1007, + SO_KEEPALIVE = 0x0008, + SO_LINGER = 0x0080, + SO_OOBINLINE = 0x0100, + SO_RCVBUF = 0x1002, + SO_RCVLOWAT = 0x1004, + SO_RCVTIMEO = 0x1006, + SO_REUSEADDR = 0x0004, + SO_REUSEPORT = 0x0200, + SO_SNDBUF = 0x1002, + SO_SNDLOWAT = 0x1003, + SO_SNDTIMEO = 0x1005, + SO_TYPE = 0x1008 + } + enum + { + SOMAXCONN = 128 + } + enum : uint + { + MSG_CTRUNC = 0x20, + MSG_DONTROUTE = 0x04, + MSG_EOR = 0x08, + MSG_OOB = 0x01, + MSG_PEEK = 0x02, + MSG_TRUNC = 0x10, + MSG_WAITALL = 0x40, + MSG_NOSIGNAL = 0x0400 + } + + enum + { + AF_INET = 2, + AF_LOCAL = 1, + AF_UNIX = AF_LOCAL, + AF_UNSPEC = 0, + AF_APPLETALK = 16, + AF_IPX = 23 + } + enum + { + SHUT_RD = 0, + SHUT_WR = 1, + SHUT_RDWR = 2 + } + + int accept(int, scope sockaddr*, scope socklen_t*); + int bind(int, const scope sockaddr*, socklen_t); + int connect(int, const scope sockaddr*, socklen_t); + int getpeername(int, scope sockaddr*, scope socklen_t*); + int getsockname(int, scope sockaddr*, scope socklen_t*); + int getsockopt(int, int, int, scope void*, scope socklen_t*); + int listen(int, int) @safe; + ssize_t recv(int, scope void*, size_t, int); + ssize_t recvfrom(int, scope void*, size_t, int, scope sockaddr*, scope socklen_t*); + ssize_t recvmsg(int, scope msghdr*, int); + ssize_t send(int, const scope void*, size_t, int); + ssize_t sendmsg(int, const scope msghdr*, int); + ssize_t sendto(int, const scope void*, size_t, int, const scope sockaddr*, socklen_t); + int setsockopt(int, int, int, const scope void*, socklen_t); + int shutdown(int, int) @safe; + int socket(int, int, int) @safe; + int sockatmark(int) @safe; + int socketpair(int, int, int, ref int[2]) @safe; +} else { static assert(false, "Unsupported platform"); diff --git a/libphobos/libdruntime/core/sys/posix/sys/stat.d b/libphobos/libdruntime/core/sys/posix/sys/stat.d index 7d0b1708e..0b96b696a 100644 --- a/libphobos/libdruntime/core/sys/posix/sys/stat.d +++ b/libphobos/libdruntime/core/sys/posix/sys/stat.d @@ -28,6 +28,12 @@ else version (TVOS) else version (WatchOS) version = Darwin; +version (CRuntime_Glibc) +{ + version (linux) + version = linuxGlibc; +} + version (RISCV32) version = RISCV_Any; version (RISCV64) version = RISCV_Any; version (SPARC) version = SPARC_Any; @@ -93,7 +99,7 @@ int stat(const scope char*, stat*); mode_t umask(mode_t); */ -version (CRuntime_Glibc) +version (linuxGlibc) { version (X86) { @@ -2188,6 +2194,102 @@ else version (CRuntime_UClibc) ref const(timespec)[2] times, int flags); int futimens(int fd, ref const(timespec)[2] times); } +else version (Hurd) +{ + import core.sys.hurd.sys.types; + static if (__USE_FILE_OFFSET64) + private enum SPARE_SIZE = 8; + else + private enum SPARE_SIZE = 11; + + struct stat_t + { + int st_fstype; /* File system type. */ + fsid_t st_fsid; /* File system ID. */ + alias st_dev = st_fsid; + ino_t st_ino; /* File number. */ + uint st_gen; + dev_t st_rdev; + mode_t st_mode; + nlink_t st_nlink; + uid_t st_uid; + gid_t st_gid; + off_t st_size; + + static if (_DEFAULT_SOURCE || _XOPEN_SOURCE >= 700) + { + timespec st_atim; + timespec st_mtim; + timespec st_ctim; + extern(D) @safe @property inout pure nothrow + { + ref inout(time_t) st_atime() return { return st_atim.tv_sec; } + ref inout(time_t) st_mtime() return { return st_mtim.tv_sec; } + ref inout(time_t) st_ctime() return { return st_ctim.tv_sec; } + } + } + else + { + time_t st_atime; + c_ulong st_atimensec; + time_t st_mtime; + c_ulong st_mtimensec; + time_t st_ctime; + c_ulong st_ctimensec; + } + + blksize_t st_blksize; + blkcnt_t st_blocks; + + uid_t st_author; + uint st_flags; + int[SPARE_SIZE] st_spare; + } + version (X86) static assert(stat_t.sizeof == 128); + version (X86_64) static assert(stat_t.sizeof == 176); + + enum S_ISUID = 0x800; // octal 0004000 + enum S_ISGID = 0x400; // octal 0002000 + enum S_ISVTX = 0x200; // octal 0001000 + + enum UTIME_NOW = -1; + enum UTIME_OMIT = -2; + + enum S_IRUSR = 0x100; // octal 0400 + enum S_IWUSR = 0x080; // octal 0200 + enum S_IXUSR = 0x040; // octal 0100 + enum S_IRWXU = S_IRUSR | S_IWUSR | S_IXUSR; + + enum S_IRGRP = S_IRUSR >> 3; + enum S_IWGRP = S_IWUSR >> 3; + enum S_IXGRP = S_IXUSR >> 3; + enum S_IRWXG = S_IRWXU >> 3; + + enum S_IROTH = S_IRGRP >> 3; + enum S_IWOTH = S_IWGRP >> 3; + enum S_IXOTH = S_IXGRP >> 3; + enum S_IRWXO = S_IRWXG >> 3; + + private + { + extern (D) bool S_ISTYPE( mode_t mode, uint mask ) + { + return ( mode & S_IFMT ) == mask; + } + } + + extern (D) bool S_ISBLK( mode_t mode ) { return S_ISTYPE( mode, S_IFBLK ); } + extern (D) bool S_ISCHR( mode_t mode ) { return S_ISTYPE( mode, S_IFCHR ); } + extern (D) bool S_ISDIR( mode_t mode ) { return S_ISTYPE( mode, S_IFDIR ); } + extern (D) bool S_ISFIFO( mode_t mode ) { return S_ISTYPE( mode, S_IFIFO ); } + extern (D) bool S_ISREG( mode_t mode ) { return S_ISTYPE( mode, S_IFREG ); } + extern (D) bool S_ISLNK( mode_t mode ) { return S_ISTYPE( mode, S_IFLNK ); } + extern (D) bool S_ISSOCK( mode_t mode ) { return S_ISTYPE( mode, S_IFSOCK ); } + + int utimensat(int dirfd, const char *pathname, + ref const(timespec)[2] times, int flags); + int futimens(int fd, ref const(timespec)[2] times); +} else { static assert(false, "Unsupported platform"); diff --git a/libphobos/libdruntime/core/sys/posix/sys/statvfs.d b/libphobos/libdruntime/core/sys/posix/sys/statvfs.d index 49c84508b..e4d053414 100644 --- a/libphobos/libdruntime/core/sys/posix/sys/statvfs.d +++ b/libphobos/libdruntime/core/sys/posix/sys/statvfs.d @@ -19,71 +19,118 @@ nothrow: @system: version (CRuntime_Glibc) { - static if (__WORDSIZE == 32) + version (linux) { - version=_STATVFSBUF_F_UNUSED; - } - struct statvfs_t - { - c_ulong f_bsize; - c_ulong f_frsize; - fsblkcnt_t f_blocks; - fsblkcnt_t f_bfree; - fsblkcnt_t f_bavail; - fsfilcnt_t f_files; - fsfilcnt_t f_ffree; - fsfilcnt_t f_favail; - c_ulong f_fsid; - version (_STATVFSBUF_F_UNUSED) + static if (__WORDSIZE == 32) { - int __f_unused; + version=_STATVFSBUF_F_UNUSED; + } + struct statvfs_t + { + c_ulong f_bsize; + c_ulong f_frsize; + fsblkcnt_t f_blocks; + fsblkcnt_t f_bfree; + fsblkcnt_t f_bavail; + fsfilcnt_t f_files; + fsfilcnt_t f_ffree; + fsfilcnt_t f_favail; + c_ulong f_fsid; + version (_STATVFSBUF_F_UNUSED) + { + int __f_unused; + } + c_ulong f_flag; + c_ulong f_namemax; + int[6] __f_spare; + } + /* Definitions for the flag in `f_flag'. These definitions should be + kept in sync with the definitions in . */ + static if (__USE_GNU) + { + enum FFlag + { + ST_RDONLY = 1, /* Mount read-only. */ + ST_NOSUID = 2, + ST_NODEV = 4, /* Disallow access to device special files. */ + ST_NOEXEC = 8, /* Disallow program execution. */ + ST_SYNCHRONOUS = 16, /* Writes are synced at once. */ + ST_MANDLOCK = 64, /* Allow mandatory locks on an FS. */ + ST_WRITE = 128, /* Write on file/directory/symlink. */ + ST_APPEND = 256, /* Append-only file. */ + ST_IMMUTABLE = 512, /* Immutable file. */ + ST_NOATIME = 1024, /* Do not update access times. */ + ST_NODIRATIME = 2048, /* Do not update directory access times. */ + ST_RELATIME = 4096 /* Update atime relative to mtime/ctime. */ + + } + } /* Use GNU. */ + else + { // Posix defined: + enum FFlag + { + ST_RDONLY = 1, /* Mount read-only. */ + ST_NOSUID = 2 + } + } + + static if ( __USE_FILE_OFFSET64 ) + { + int statvfs64 (const char * file, statvfs_t* buf); + alias statvfs64 statvfs; + + int fstatvfs64 (int fildes, statvfs_t *buf) @trusted; + alias fstatvfs64 fstatvfs; + } + else + { + int statvfs (const char * file, statvfs_t* buf); + int fstatvfs (int fildes, statvfs_t *buf); } - c_ulong f_flag; - c_ulong f_namemax; - int[6] __f_spare; } - /* Definitions for the flag in `f_flag'. These definitions should be - kept in sync with the definitions in . */ - static if (__USE_GNU) + else version (Hurd) { - enum FFlag + import core.sys.hurd.sys.types; + struct statvfs_t { - ST_RDONLY = 1, /* Mount read-only. */ - ST_NOSUID = 2, - ST_NODEV = 4, /* Disallow access to device special files. */ - ST_NOEXEC = 8, /* Disallow program execution. */ - ST_SYNCHRONOUS = 16, /* Writes are synced at once. */ - ST_MANDLOCK = 64, /* Allow mandatory locks on an FS. */ - ST_WRITE = 128, /* Write on file/directory/symlink. */ - ST_APPEND = 256, /* Append-only file. */ - ST_IMMUTABLE = 512, /* Immutable file. */ - ST_NOATIME = 1024, /* Do not update access times. */ - ST_NODIRATIME = 2048, /* Do not update directory access times. */ - ST_RELATIME = 4096 /* Update atime relative to mtime/ctime. */ - + uint f_type; + c_ulong f_bsize; + fsblkcnt_t f_blocks; + fsblkcnt_t f_bfree; + fsblkcnt_t f_bavail; + fsfilcnt_t f_files; + fsfilcnt_t f_ffree; + fsid_t f_fsid; + c_ulong f_namelen; + fsfilcnt_t f_favail; + c_ulong f_frsize; + c_ulong f_flag; + uint[3] f_spare; } - } /* Use GNU. */ - else - { // Posix defined: + enum FFlag { - ST_RDONLY = 1, /* Mount read-only. */ - ST_NOSUID = 2 + ST_RDONLY = 1, + ST_NOSUID = 2, + ST_NOEXEC = 8, + ST_SYNCHRONOUS = 16, + ST_NOATIME = 32, + ST_RELATIME = 64, } - } - static if ( __USE_FILE_OFFSET64 ) - { - int statvfs64 (const char * file, statvfs_t* buf); - alias statvfs64 statvfs; + static if ( __USE_FILE_OFFSET64 ) + { + int statvfs64 (const char * file, statvfs_t* buf); + alias statvfs = statvfs64; - int fstatvfs64 (int fildes, statvfs_t *buf) @trusted; - alias fstatvfs64 fstatvfs; - } - else - { - int statvfs (const char * file, statvfs_t* buf); - int fstatvfs (int fildes, statvfs_t *buf); + int fstatvfs64 (int fildes, statvfs_t *buf) @trusted; + alias fstatvfs = fstatvfs64; + } + else + { + int statvfs (const char * file, statvfs_t* buf); + int fstatvfs (int fildes, statvfs_t *buf); + } } } diff --git a/libphobos/libdruntime/core/sys/posix/sys/types.d b/libphobos/libdruntime/core/sys/posix/sys/types.d index 529df1bae..f6c60c33e 100644 --- a/libphobos/libdruntime/core/sys/posix/sys/types.d +++ b/libphobos/libdruntime/core/sys/posix/sys/types.d @@ -28,6 +28,12 @@ else version (TVOS) else version (WatchOS) version = Darwin; +version (CRuntime_Glibc) +{ + version (linux) + version = linuxGlibc; +} + version (Posix): extern (C): @system: @@ -86,7 +92,7 @@ time_t uid_t */ -version (CRuntime_Glibc) +version (linuxGlibc) { static if ( __USE_FILE_OFFSET64 ) { @@ -372,6 +378,32 @@ else version (CRuntime_UClibc) alias slong_t time_t; alias uint uid_t; } +else version (Hurd) +{ + static if ( __USE_FILE_OFFSET64 ) + { + alias long blkcnt_t; + alias ulong ino_t; + alias long off_t; + } + else + { + alias slong_t blkcnt_t; + alias ulong_t ino_t; + alias slong_t off_t; + } + alias slong_t blksize_t; + alias ulong_t dev_t; + alias uint gid_t; + alias uint mode_t; + alias ulong_t nlink_t; + alias int pid_t; + //size_t (defined in core.stdc.stddef) + alias c_long ssize_t; + alias uint uid_t; + + alias slong_t time_t; +} else { static assert(false, "Unsupported platform"); @@ -390,7 +422,7 @@ suseconds_t useconds_t */ -version (CRuntime_Glibc) +version (linuxGlibc) { static if ( __USE_FILE_OFFSET64 ) { @@ -530,6 +562,24 @@ else version (CRuntime_UClibc) alias slong_t suseconds_t; alias uint useconds_t; } +else version (Hurd) +{ + static if ( __USE_FILE_OFFSET64 ) + { + alias ulong fsblkcnt_t; + alias ulong fsfilcnt_t; + } + else + { + alias ulong_t fsblkcnt_t; + alias ulong_t fsfilcnt_t; + } + alias slong_t clock_t; + alias uint id_t; + alias int key_t; + alias slong_t suseconds_t; + alias uint useconds_t; +} else { static assert(false, "Unsupported platform"); @@ -553,21 +603,84 @@ pthread_t version (CRuntime_Glibc) { - version (X86) + version (linux) { - enum __SIZEOF_PTHREAD_ATTR_T = 36; - enum __SIZEOF_PTHREAD_MUTEX_T = 24; - enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4; - enum __SIZEOF_PTHREAD_COND_T = 48; - enum __SIZEOF_PTHREAD_CONDATTR_T = 4; - enum __SIZEOF_PTHREAD_RWLOCK_T = 32; - enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8; - enum __SIZEOF_PTHREAD_BARRIER_T = 20; - enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4; - } - else version (X86_64) - { - static if (__WORDSIZE == 64) + version (X86) + { + enum __SIZEOF_PTHREAD_ATTR_T = 36; + enum __SIZEOF_PTHREAD_MUTEX_T = 24; + enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4; + enum __SIZEOF_PTHREAD_COND_T = 48; + enum __SIZEOF_PTHREAD_CONDATTR_T = 4; + enum __SIZEOF_PTHREAD_RWLOCK_T = 32; + enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8; + enum __SIZEOF_PTHREAD_BARRIER_T = 20; + enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4; + } + else version (X86_64) + { + static if (__WORDSIZE == 64) + { + enum __SIZEOF_PTHREAD_ATTR_T = 56; + enum __SIZEOF_PTHREAD_MUTEX_T = 40; + enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4; + enum __SIZEOF_PTHREAD_COND_T = 48; + enum __SIZEOF_PTHREAD_CONDATTR_T = 4; + enum __SIZEOF_PTHREAD_RWLOCK_T = 56; + enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8; + enum __SIZEOF_PTHREAD_BARRIER_T = 32; + enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4; + } + else + { + enum __SIZEOF_PTHREAD_ATTR_T = 32; + enum __SIZEOF_PTHREAD_MUTEX_T = 32; + enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4; + enum __SIZEOF_PTHREAD_COND_T = 48; + enum __SIZEOF_PTHREAD_CONDATTR_T = 4; + enum __SIZEOF_PTHREAD_RWLOCK_T = 44; + enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8; + enum __SIZEOF_PTHREAD_BARRIER_T = 20; + enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4; + } + } + else version (AArch64) + { + enum __SIZEOF_PTHREAD_ATTR_T = 64; + enum __SIZEOF_PTHREAD_MUTEX_T = 48; + enum __SIZEOF_PTHREAD_MUTEXATTR_T = 8; + enum __SIZEOF_PTHREAD_COND_T = 48; + enum __SIZEOF_PTHREAD_CONDATTR_T = 8; + enum __SIZEOF_PTHREAD_RWLOCK_T = 56; + enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8; + enum __SIZEOF_PTHREAD_BARRIER_T = 32; + enum __SIZEOF_PTHREAD_BARRIERATTR_T = 8; + } + else version (ARM) + { + enum __SIZEOF_PTHREAD_ATTR_T = 36; + enum __SIZEOF_PTHREAD_MUTEX_T = 24; + enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4; + enum __SIZEOF_PTHREAD_COND_T = 48; + enum __SIZEOF_PTHREAD_CONDATTR_T = 4; + enum __SIZEOF_PTHREAD_RWLOCK_T = 32; + enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8; + enum __SIZEOF_PTHREAD_BARRIER_T = 20; + enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4; + } + else version (HPPA) + { + enum __SIZEOF_PTHREAD_ATTR_T = 36; + enum __SIZEOF_PTHREAD_MUTEX_T = 48; + enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4; + enum __SIZEOF_PTHREAD_COND_T = 48; + enum __SIZEOF_PTHREAD_CONDATTR_T = 4; + enum __SIZEOF_PTHREAD_RWLOCK_T = 64; + enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8; + enum __SIZEOF_PTHREAD_BARRIER_T = 48; + enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4; + } + else version (IA64) { enum __SIZEOF_PTHREAD_ATTR_T = 56; enum __SIZEOF_PTHREAD_MUTEX_T = 40; @@ -579,249 +692,277 @@ version (CRuntime_Glibc) enum __SIZEOF_PTHREAD_BARRIER_T = 32; enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4; } - else + else version (MIPS32) { - enum __SIZEOF_PTHREAD_ATTR_T = 32; - enum __SIZEOF_PTHREAD_MUTEX_T = 32; + enum __SIZEOF_PTHREAD_ATTR_T = 36; + enum __SIZEOF_PTHREAD_MUTEX_T = 24; enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4; enum __SIZEOF_PTHREAD_COND_T = 48; enum __SIZEOF_PTHREAD_CONDATTR_T = 4; - enum __SIZEOF_PTHREAD_RWLOCK_T = 44; + enum __SIZEOF_PTHREAD_RWLOCK_T = 32; enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8; enum __SIZEOF_PTHREAD_BARRIER_T = 20; enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4; } + else version (MIPS64) + { + enum __SIZEOF_PTHREAD_ATTR_T = 56; + enum __SIZEOF_PTHREAD_MUTEX_T = 40; + enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4; + enum __SIZEOF_PTHREAD_COND_T = 48; + enum __SIZEOF_PTHREAD_CONDATTR_T = 4; + enum __SIZEOF_PTHREAD_RWLOCK_T = 56; + enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8; + enum __SIZEOF_PTHREAD_BARRIER_T = 32; + enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4; + } + else version (PPC) + { + enum __SIZEOF_PTHREAD_ATTR_T = 36; + enum __SIZEOF_PTHREAD_MUTEX_T = 24; + enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4; + enum __SIZEOF_PTHREAD_COND_T = 48; + enum __SIZEOF_PTHREAD_CONDATTR_T = 4; + enum __SIZEOF_PTHREAD_RWLOCK_T = 32; + enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8; + enum __SIZEOF_PTHREAD_BARRIER_T = 20; + enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4; + } + else version (PPC64) + { + enum __SIZEOF_PTHREAD_ATTR_T = 56; + enum __SIZEOF_PTHREAD_MUTEX_T = 40; + enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4; + enum __SIZEOF_PTHREAD_COND_T = 48; + enum __SIZEOF_PTHREAD_CONDATTR_T = 4; + enum __SIZEOF_PTHREAD_RWLOCK_T = 56; + enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8; + enum __SIZEOF_PTHREAD_BARRIER_T = 32; + enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4; + } + else version (RISCV32) + { + enum __SIZEOF_PTHREAD_ATTR_T = 36; + enum __SIZEOF_PTHREAD_MUTEX_T = 24; + enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4; + enum __SIZEOF_PTHREAD_COND_T = 48; + enum __SIZEOF_PTHREAD_CONDATTR_T = 4; + enum __SIZEOF_PTHREAD_RWLOCK_T = 32; + enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8; + enum __SIZEOF_PTHREAD_BARRIER_T = 20; + enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4; + } + else version (RISCV64) + { + enum __SIZEOF_PTHREAD_ATTR_T = 56; + enum __SIZEOF_PTHREAD_MUTEX_T = 40; + enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4; + enum __SIZEOF_PTHREAD_COND_T = 48; + enum __SIZEOF_PTHREAD_CONDATTR_T = 4; + enum __SIZEOF_PTHREAD_RWLOCK_T = 56; + enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8; + enum __SIZEOF_PTHREAD_BARRIER_T = 32; + enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4; + } + else version (SPARC) + { + enum __SIZEOF_PTHREAD_ATTR_T = 36; + enum __SIZEOF_PTHREAD_MUTEX_T = 24; + enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4; + enum __SIZEOF_PTHREAD_COND_T = 48; + enum __SIZEOF_PTHREAD_CONDATTR_T = 4; + enum __SIZEOF_PTHREAD_RWLOCK_T = 32; + enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8; + enum __SIZEOF_PTHREAD_BARRIER_T = 20; + enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4; + } + else version (SPARC64) + { + enum __SIZEOF_PTHREAD_ATTR_T = 56; + enum __SIZEOF_PTHREAD_MUTEX_T = 40; + enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4; + enum __SIZEOF_PTHREAD_COND_T = 48; + enum __SIZEOF_PTHREAD_CONDATTR_T = 4; + enum __SIZEOF_PTHREAD_RWLOCK_T = 56; + enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8; + enum __SIZEOF_PTHREAD_BARRIER_T = 32; + enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4; + } + else version (S390) + { + enum __SIZEOF_PTHREAD_ATTR_T = 36; + enum __SIZEOF_PTHREAD_MUTEX_T = 24; + enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4; + enum __SIZEOF_PTHREAD_COND_T = 48; + enum __SIZEOF_PTHREAD_CONDATTR_T = 4; + enum __SIZEOF_PTHREAD_RWLOCK_T = 32; + enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8; + enum __SIZEOF_PTHREAD_BARRIER_T = 20; + enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4; + } + else version (SystemZ) + { + enum __SIZEOF_PTHREAD_ATTR_T = 56; + enum __SIZEOF_PTHREAD_MUTEX_T = 40; + enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4; + enum __SIZEOF_PTHREAD_COND_T = 48; + enum __SIZEOF_PTHREAD_CONDATTR_T = 4; + enum __SIZEOF_PTHREAD_RWLOCK_T = 56; + enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8; + enum __SIZEOF_PTHREAD_BARRIER_T = 32; + enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4; + } + else + { + static assert (false, "Unsupported platform"); + } + + union pthread_attr_t + { + byte[__SIZEOF_PTHREAD_ATTR_T] __size; + c_long __align; + } + + private alias int __atomic_lock_t; + + private struct _pthread_fastlock + { + c_long __status; + __atomic_lock_t __spinlock; + } + + private alias void* _pthread_descr; + + union pthread_cond_t + { + byte[__SIZEOF_PTHREAD_COND_T] __size; + long __align; + } + + union pthread_condattr_t + { + byte[__SIZEOF_PTHREAD_CONDATTR_T] __size; + int __align; + } + + alias uint pthread_key_t; + + union pthread_mutex_t + { + byte[__SIZEOF_PTHREAD_MUTEX_T] __size; + c_long __align; + } + + union pthread_mutexattr_t + { + byte[__SIZEOF_PTHREAD_MUTEXATTR_T] __size; + int __align; + } + + alias int pthread_once_t; + + struct pthread_rwlock_t + { + byte[__SIZEOF_PTHREAD_RWLOCK_T] __size; + c_long __align; + } + + struct pthread_rwlockattr_t + { + byte[__SIZEOF_PTHREAD_RWLOCKATTR_T] __size; + c_long __align; + } + + alias c_ulong pthread_t; } - else version (AArch64) - { - enum __SIZEOF_PTHREAD_ATTR_T = 64; - enum __SIZEOF_PTHREAD_MUTEX_T = 48; - enum __SIZEOF_PTHREAD_MUTEXATTR_T = 8; - enum __SIZEOF_PTHREAD_COND_T = 48; - enum __SIZEOF_PTHREAD_CONDATTR_T = 8; - enum __SIZEOF_PTHREAD_RWLOCK_T = 56; - enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8; - enum __SIZEOF_PTHREAD_BARRIER_T = 32; - enum __SIZEOF_PTHREAD_BARRIERATTR_T = 8; - } - else version (ARM) - { - enum __SIZEOF_PTHREAD_ATTR_T = 36; - enum __SIZEOF_PTHREAD_MUTEX_T = 24; - enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4; - enum __SIZEOF_PTHREAD_COND_T = 48; - enum __SIZEOF_PTHREAD_CONDATTR_T = 4; - enum __SIZEOF_PTHREAD_RWLOCK_T = 32; - enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8; - enum __SIZEOF_PTHREAD_BARRIER_T = 20; - enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4; - } - else version (HPPA) - { - enum __SIZEOF_PTHREAD_ATTR_T = 36; - enum __SIZEOF_PTHREAD_MUTEX_T = 48; - enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4; - enum __SIZEOF_PTHREAD_COND_T = 48; - enum __SIZEOF_PTHREAD_CONDATTR_T = 4; - enum __SIZEOF_PTHREAD_RWLOCK_T = 64; - enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8; - enum __SIZEOF_PTHREAD_BARRIER_T = 48; - enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4; - } - else version (IA64) - { - enum __SIZEOF_PTHREAD_ATTR_T = 56; - enum __SIZEOF_PTHREAD_MUTEX_T = 40; - enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4; - enum __SIZEOF_PTHREAD_COND_T = 48; - enum __SIZEOF_PTHREAD_CONDATTR_T = 4; - enum __SIZEOF_PTHREAD_RWLOCK_T = 56; - enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8; - enum __SIZEOF_PTHREAD_BARRIER_T = 32; - enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4; - } - else version (MIPS32) - { - enum __SIZEOF_PTHREAD_ATTR_T = 36; - enum __SIZEOF_PTHREAD_MUTEX_T = 24; - enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4; - enum __SIZEOF_PTHREAD_COND_T = 48; - enum __SIZEOF_PTHREAD_CONDATTR_T = 4; - enum __SIZEOF_PTHREAD_RWLOCK_T = 32; - enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8; - enum __SIZEOF_PTHREAD_BARRIER_T = 20; - enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4; - } - else version (MIPS64) - { - enum __SIZEOF_PTHREAD_ATTR_T = 56; - enum __SIZEOF_PTHREAD_MUTEX_T = 40; - enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4; - enum __SIZEOF_PTHREAD_COND_T = 48; - enum __SIZEOF_PTHREAD_CONDATTR_T = 4; - enum __SIZEOF_PTHREAD_RWLOCK_T = 56; - enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8; - enum __SIZEOF_PTHREAD_BARRIER_T = 32; - enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4; - } - else version (PPC) - { - enum __SIZEOF_PTHREAD_ATTR_T = 36; - enum __SIZEOF_PTHREAD_MUTEX_T = 24; - enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4; - enum __SIZEOF_PTHREAD_COND_T = 48; - enum __SIZEOF_PTHREAD_CONDATTR_T = 4; - enum __SIZEOF_PTHREAD_RWLOCK_T = 32; - enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8; - enum __SIZEOF_PTHREAD_BARRIER_T = 20; - enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4; - } - else version (PPC64) - { - enum __SIZEOF_PTHREAD_ATTR_T = 56; - enum __SIZEOF_PTHREAD_MUTEX_T = 40; - enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4; - enum __SIZEOF_PTHREAD_COND_T = 48; - enum __SIZEOF_PTHREAD_CONDATTR_T = 4; - enum __SIZEOF_PTHREAD_RWLOCK_T = 56; - enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8; - enum __SIZEOF_PTHREAD_BARRIER_T = 32; - enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4; - } - else version (RISCV32) - { - enum __SIZEOF_PTHREAD_ATTR_T = 36; - enum __SIZEOF_PTHREAD_MUTEX_T = 24; - enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4; - enum __SIZEOF_PTHREAD_COND_T = 48; - enum __SIZEOF_PTHREAD_CONDATTR_T = 4; - enum __SIZEOF_PTHREAD_RWLOCK_T = 32; - enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8; - enum __SIZEOF_PTHREAD_BARRIER_T = 20; - enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4; - } - else version (RISCV64) - { - enum __SIZEOF_PTHREAD_ATTR_T = 56; - enum __SIZEOF_PTHREAD_MUTEX_T = 40; - enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4; - enum __SIZEOF_PTHREAD_COND_T = 48; - enum __SIZEOF_PTHREAD_CONDATTR_T = 4; - enum __SIZEOF_PTHREAD_RWLOCK_T = 56; - enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8; - enum __SIZEOF_PTHREAD_BARRIER_T = 32; - enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4; - } - else version (SPARC) - { - enum __SIZEOF_PTHREAD_ATTR_T = 36; - enum __SIZEOF_PTHREAD_MUTEX_T = 24; - enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4; - enum __SIZEOF_PTHREAD_COND_T = 48; - enum __SIZEOF_PTHREAD_CONDATTR_T = 4; - enum __SIZEOF_PTHREAD_RWLOCK_T = 32; - enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8; - enum __SIZEOF_PTHREAD_BARRIER_T = 20; - enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4; - } - else version (SPARC64) - { - enum __SIZEOF_PTHREAD_ATTR_T = 56; - enum __SIZEOF_PTHREAD_MUTEX_T = 40; - enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4; - enum __SIZEOF_PTHREAD_COND_T = 48; - enum __SIZEOF_PTHREAD_CONDATTR_T = 4; - enum __SIZEOF_PTHREAD_RWLOCK_T = 56; - enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8; - enum __SIZEOF_PTHREAD_BARRIER_T = 32; - enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4; - } - else version (S390) - { - enum __SIZEOF_PTHREAD_ATTR_T = 36; - enum __SIZEOF_PTHREAD_MUTEX_T = 24; - enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4; - enum __SIZEOF_PTHREAD_COND_T = 48; - enum __SIZEOF_PTHREAD_CONDATTR_T = 4; - enum __SIZEOF_PTHREAD_RWLOCK_T = 32; - enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8; - enum __SIZEOF_PTHREAD_BARRIER_T = 20; - enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4; - } - else version (SystemZ) - { - enum __SIZEOF_PTHREAD_ATTR_T = 56; - enum __SIZEOF_PTHREAD_MUTEX_T = 40; - enum __SIZEOF_PTHREAD_MUTEXATTR_T = 4; - enum __SIZEOF_PTHREAD_COND_T = 48; - enum __SIZEOF_PTHREAD_CONDATTR_T = 4; - enum __SIZEOF_PTHREAD_RWLOCK_T = 56; - enum __SIZEOF_PTHREAD_RWLOCKATTR_T = 8; - enum __SIZEOF_PTHREAD_BARRIER_T = 32; - enum __SIZEOF_PTHREAD_BARRIERATTR_T = 4; - } - else + else version (Hurd) { - static assert (false, "Unsupported platform"); - } + import core.sys.hurd.sys.types; + import core.sys.posix.time: clockid_t; - union pthread_attr_t - { - byte[__SIZEOF_PTHREAD_ATTR_T] __size; - c_long __align; - } + private struct __sched_param + { + int __sched_priority; + } - private alias int __atomic_lock_t; + private struct __pthread; - private struct _pthread_fastlock - { - c_long __status; - __atomic_lock_t __spinlock; - } + struct pthread_attr_t + { + __sched_param schedparam; + void* stackaddr; + size_t __stacksize; + size_t __guardsize; + int __detachstate; + int __inheritsched; + int __contentionscope; + int __schedpolicy; + } - private alias void* _pthread_descr; + struct pthread_cond_t + { + pthread_spinlock_t __lock; + __pthread *__queue; + pthread_condattr_t *__attr; + uint __wrefs; + void *__data; + } - union pthread_cond_t - { - byte[__SIZEOF_PTHREAD_COND_T] __size; - long __align; - } + struct pthread_condattr_t + { + int __pshared; + clockid_t __clock; + } - union pthread_condattr_t - { - byte[__SIZEOF_PTHREAD_CONDATTR_T] __size; - int __align; - } + alias int pthread_key_t; - alias uint pthread_key_t; + struct pthread_mutex_t + { + uint __lock; + uint __owner_id; + uint __cnt; + int __shpid; + int __type; + int __flags; + union + { + uint[2] __reserved; + void *__pointer_aligned; + } + } - union pthread_mutex_t - { - byte[__SIZEOF_PTHREAD_MUTEX_T] __size; - c_long __align; - } + struct pthread_mutexattr_t + { + int __prioceiling; + int __protocol; + int __pshared; + int __mutex_type; + } - union pthread_mutexattr_t - { - byte[__SIZEOF_PTHREAD_MUTEXATTR_T] __size; - int __align; - } + struct pthread_once_t + { + int __run; + pthread_spinlock_t __lock; + } - alias int pthread_once_t; + struct pthread_rwlock_t + { + pthread_spinlock_t __held; + pthread_spinlock_t __lock; + int __readers; + __pthread *__readerqueue; + __pthread *__writerqueue; + pthread_rwlockattr_t *__attr; + void *__data; + } - struct pthread_rwlock_t - { - byte[__SIZEOF_PTHREAD_RWLOCK_T] __size; - c_long __align; - } + struct pthread_rwlockattr_t + { + int __pshared; + } - struct pthread_rwlockattr_t - { - byte[__SIZEOF_PTHREAD_RWLOCKATTR_T] __size; - c_long __align; + alias c_long pthread_t; } - - alias c_ulong pthread_t; } else version (CRuntime_Musl) { @@ -1426,17 +1567,37 @@ pthread_barrierattr_t version (CRuntime_Glibc) { - struct pthread_barrier_t - { - byte[__SIZEOF_PTHREAD_BARRIER_T] __size; - c_long __align; - } + version (linux) + { + struct pthread_barrier_t + { + byte[__SIZEOF_PTHREAD_BARRIER_T] __size; + c_long __align; + } - struct pthread_barrierattr_t - { - byte[__SIZEOF_PTHREAD_BARRIERATTR_T] __size; - int __align; - } + struct pthread_barrierattr_t + { + byte[__SIZEOF_PTHREAD_BARRIERATTR_T] __size; + int __align; + } + } + else version (Hurd) + { + struct pthread_barrier_t + { + pthread_spinlock_t __lock; + __pthread *__queue; + uint __pending; + uint __count; + pthread_barrierattr_t *__attr; + void *__data; + } + + struct pthread_barrierattr_t + { + int __pshared; + } + } } else version (FreeBSD) { diff --git a/libphobos/libdruntime/core/sys/posix/sys/un.d b/libphobos/libdruntime/core/sys/posix/sys/un.d index 5030e16f2..2b09052a0 100644 --- a/libphobos/libdruntime/core/sys/posix/sys/un.d +++ b/libphobos/libdruntime/core/sys/posix/sys/un.d @@ -105,3 +105,12 @@ else version (Solaris) byte[108] sun_path; } } +else version (Hurd) +{ + struct sockaddr_un + { + ubyte sun_len; + sa_family_t sun_family; + byte[108] sun_path; + } +} diff --git a/libphobos/libdruntime/core/sys/posix/sys/utsname.d b/libphobos/libdruntime/core/sys/posix/sys/utsname.d index 0abbf14df..af705ddc5 100644 --- a/libphobos/libdruntime/core/sys/posix/sys/utsname.d +++ b/libphobos/libdruntime/core/sys/posix/sys/utsname.d @@ -20,19 +20,36 @@ nothrow: version (CRuntime_Glibc) { - private enum utsNameLength = 65; - - struct utsname + version(linux) { - char[utsNameLength] sysname = 0; - char[utsNameLength] nodename = 0; - char[utsNameLength] release = 0; - char[utsNameLength] version_ = 0; - // TODO Deprecate after version_ has been in an official release. - alias update = version_; - char[utsNameLength] machine = 0; + private enum utsNameLength = 65; + struct utsname + { + char[utsNameLength] sysname = 0; + char[utsNameLength] nodename = 0; + char[utsNameLength] release = 0; + char[utsNameLength] version_ = 0; + // TODO Deprecate after version_ has been in an official release. + alias update = version_; + char[utsNameLength] machine = 0; + + char[utsNameLength] __domainname = 0; + } + } - char[utsNameLength] __domainname = 0; + else version(Hurd) + { + private enum utsNameLength = 1024; + struct utsname + { + char[utsNameLength] sysname = 0; + char[utsNameLength] nodename = 0; + char[utsNameLength] release = 0; + char[utsNameLength] version_ = 0; + // TODO Deprecate after version_ has been in an official release. + alias update = version_; + char[utsNameLength] machine = 0; + } } int uname(utsname* __name); diff --git a/libphobos/libdruntime/core/sys/posix/sys/wait.d b/libphobos/libdruntime/core/sys/posix/sys/wait.d index dada64f5e..e770eddfd 100644 --- a/libphobos/libdruntime/core/sys/posix/sys/wait.d +++ b/libphobos/libdruntime/core/sys/posix/sys/wait.d @@ -28,6 +28,11 @@ else version (TVOS) else version (WatchOS) version = Darwin; +version (CRuntime_Glibc) +{ + version (linux) + version = linuxGlibc; +} version (Posix): extern (C) nothrow @nogc: @system: @@ -310,7 +315,7 @@ enum idtype_t int waitid(idtype_t, id_t, siginfo_t*, int); */ -version (CRuntime_Glibc) +version (linuxGlibc) { enum WEXITED = 4; enum WSTOPPED = 2; @@ -465,6 +470,22 @@ else version (CRuntime_UClibc) int waitid(idtype_t, id_t, siginfo_t*, int); } +else version (Hurd) +{ + enum WEXITED = 16; + enum WSTOPPED = WUNTRACED; + enum WCONTINUED = 4; + enum WNOWAIT = 8; + + enum idtype_t + { + P_ALL, + P_PID, + P_PGID + } + + int waitid(idtype_t, id_t, siginfo_t*, int); +} else { static assert(false, "Unsupported platform"); diff --git a/libphobos/libdruntime/core/sys/posix/termios.d b/libphobos/libdruntime/core/sys/posix/termios.d index 5de678506..304508111 100644 --- a/libphobos/libdruntime/core/sys/posix/termios.d +++ b/libphobos/libdruntime/core/sys/posix/termios.d @@ -26,6 +26,12 @@ else version (TVOS) else version (WatchOS) version = Darwin; +version (CRuntime_Glibc) +{ + version (linux) + version = linuxGlibc; +} + version (Posix): extern (C): @@ -142,7 +148,7 @@ int tcsendbreak(int, int); int tcsetattr(int, int, const scope termios*); */ -version (CRuntime_Glibc) +version (linuxGlibc) { alias ubyte cc_t; alias uint speed_t; @@ -1040,6 +1046,114 @@ else version (CRuntime_UClibc) int tcsendbreak(int, int); int tcsetattr(int, int, const scope termios*); } +else version (Hurd) +{ + alias ubyte cc_t; + alias uint speed_t; + alias uint tcflag_t; + + enum NCCS = 20; + + struct termios + { + tcflag_t c_iflag; + tcflag_t c_oflag; + tcflag_t c_cflag; + tcflag_t c_lflag; + cc_t[NCCS] c_cc; + speed_t c_ispeed; + speed_t c_ospeed; + } + + enum VEOF = 0; + enum VEOL = 1; + enum VERASE = 3; + enum VINTR = 8; + enum VKILL = 5; + enum VMIN = 16; + enum VQUIT = 9; + enum VSTART = 12; + enum VSTOP = 13; + enum VSUSP = 10; + enum VTIME = 17; + + enum BRKINT = 0x0000002; + enum ICRNL = 0x0000100; + enum IGNBRK = 0x0000001; + enum IGNCR = 0x0000080; + enum IGNPAR = 0x0000004; + enum INLCR = 0x0000040; + enum INPCK = 0x0000010; + enum ISTRIP = 0x0000020; + enum IXOFF = 0x0000400; + enum IXON = 0x0000200; + enum PARMRK = 0x0000008; + + enum OPOST = 0x0000001; + + enum B0 = 0; + enum B50 = 50; + enum B75 = 75; + enum B110 = 110; + enum B134 = 134; + enum B150 = 150; + enum B200 = 200; + enum B300 = 300; + enum B600 = 600; + enum B1200 = 1200; + enum B1800 = 1800; + enum B2400 = 2400; + enum B4800 = 4800; + enum B9600 = 9600; + enum B19200 = 19200; + enum B38400 = 38400; + + enum CSIZE = 0x0000300; + enum CS5 = 0x0000000; + enum CS6 = 0x0000100; + enum CS7 = 0x0000200; + enum CS8 = 0x0000300; + enum CSTOPB = 0x0000400; + enum CREAD = 0x0000800; + enum PARENB = 0x0001000; + enum PARODD = 0x0002000; + enum HUPCL = 0x0004000; + enum CLOCAL = 0x0008000; + + enum ECHO = 0x00000008; + enum ECHOE = 0x00000002; + enum ECHOK = 0x00000004; + enum ECHONL = 0x00000010; + enum ICANON = 0x00000100; + enum IEXTEN = 0x00000400; + enum ISIG = 0x00000080; + enum NOFLSH = 0x80000000; + enum TOSTOP = 0x00400000; + + enum TCSANOW = 0; + enum TCSADRAIN = 1; + enum TCSAFLUSH = 2; + + enum TCIFLUSH = 0; + enum TCOFLUSH = 1; + enum TCIOFLUSH = 2; + + enum TCIOFF = 3; + enum TCION = 4; + enum TCOOFF = 1; + enum TCOON = 2; + + speed_t cfgetispeed(const scope termios*); + speed_t cfgetospeed(const scope termios*); + int cfsetispeed(termios*, speed_t); + int cfsetospeed(termios*, speed_t); + int tcdrain(int); + int tcflow(int, int); + int tcflush(int, int); + int tcgetattr(int, termios*); + int tcsendbreak(int, int); + int tcsetattr(int, int, const scope termios*); +} // // XOpen (XSI) diff --git a/libphobos/libdruntime/core/sys/posix/time.d b/libphobos/libdruntime/core/sys/posix/time.d index 52a6f92be..3305efa9c 100644 --- a/libphobos/libdruntime/core/sys/posix/time.d +++ b/libphobos/libdruntime/core/sys/posix/time.d @@ -155,6 +155,10 @@ else version (Solaris) { enum CLOCK_MONOTONIC = 4; } +else version (Hurd) +{ + enum CLOCK_MONOTONIC = 1; +} else { static assert(0); diff --git a/libphobos/libdruntime/core/time.d b/libphobos/libdruntime/core/time.d index e7744c85f..ef8aab4ac 100644 --- a/libphobos/libdruntime/core/time.d +++ b/libphobos/libdruntime/core/time.d @@ -350,6 +350,17 @@ else version (Solaris) enum ClockType second = 6, threadCPUTime = 7, } +else version (Hurd) enum ClockType +{ + normal = 0, + coarse = 2, + precise = 3, + // processCPUTime = 4, + raw = 5, + second = 6, + // threadCPUTime = 7, + +} else { // It needs to be decided (and implemented in an appropriate version branch @@ -449,6 +460,20 @@ version (Posix) case second: assert(0); } } + else version (Hurd) + { + import core.sys.hurd.time; + with(ClockType) final switch (clockType) + { + case coarse: return CLOCK_MONOTONIC_COARSE; + case normal: return CLOCK_MONOTONIC; + case precise: return CLOCK_MONOTONIC; + // case processCPUTime: return CLOCK_PROCESS_CPUTIME_ID; + case raw: return CLOCK_MONOTONIC_RAW; + // case threadCPUTime: return CLOCK_THREAD_CPUTIME_ID; + case second: assert(0); + } + } else // It needs to be decided (and implemented in an appropriate // version branch here) which clock types new platforms are going diff --git a/libphobos/libdruntime/gc/os.d b/libphobos/libdruntime/gc/os.d index 337f134e6..6ee9f8b3e 100644 --- a/libphobos/libdruntime/gc/os.d +++ b/libphobos/libdruntime/gc/os.d @@ -44,7 +44,7 @@ else version (Posix) version (DragonFlyBSD) import core.sys.dragonflybsd.sys.mman : MAP_ANON; version (NetBSD) import core.sys.netbsd.sys.mman : MAP_ANON; version (OpenBSD) import core.sys.openbsd.sys.mman : MAP_ANON; - version (CRuntime_Glibc) import core.sys.linux.sys.mman : MAP_ANON; + version (CRuntime_Glibc) version (linux) import core.sys.linux.sys.mman : MAP_ANON; version (Darwin) import core.sys.darwin.sys.mman : MAP_ANON; version (CRuntime_UClibc) import core.sys.linux.sys.mman : MAP_ANON; import core.stdc.stdlib; diff --git a/libphobos/libdruntime/gcc/backtrace.d b/libphobos/libdruntime/gcc/backtrace.d index 8f5582d74..4897d7fc5 100644 --- a/libphobos/libdruntime/gcc/backtrace.d +++ b/libphobos/libdruntime/gcc/backtrace.d @@ -428,6 +428,8 @@ private: import core.sys.openbsd.dlfcn; else version (Solaris) import core.sys.solaris.dlfcn; + else version (Hurd) + import core.sys.hurd.dlfcn; else version (Posix) import core.sys.posix.dlfcn; diff --git a/libphobos/libdruntime/gcc/sections/elf.d b/libphobos/libdruntime/gcc/sections/elf.d index 3480fb947..cfbc030a2 100644 --- a/libphobos/libdruntime/gcc/sections/elf.d +++ b/libphobos/libdruntime/gcc/sections/elf.d @@ -82,6 +82,12 @@ else version (Solaris) import core.sys.solaris.sys.elf; import core.sys.solaris.sys.link; } +else version (Hurd) +{ + import core.sys.hurd.dlfcn; + import core.sys.hurd.elf; + import core.sys.hurd.link; +} else { static assert(0, "unimplemented"); @@ -781,6 +787,8 @@ version (Shared) strtab = cast(const(char)*)(info.dlpi_addr + dyn.d_un.d_ptr); // relocate else version (Solaris) strtab = cast(const(char)*)(info.dlpi_addr + dyn.d_un.d_ptr); // relocate + else version (Hurd) + strtab = cast(const(char)*)(dyn.d_un.d_ptr); else static assert(0, "unimplemented"); break; @@ -916,6 +924,7 @@ bool findDSOInfoForAddr(in void* addr, dl_phdr_info* result=null) nothrow @nogc else version (NetBSD) enum IterateManually = true; else version (OpenBSD) enum IterateManually = true; else version (Solaris) enum IterateManually = true; + else version (Hurd) enum IterateManually = true; else enum IterateManually = false; static if (IterateManually) diff --git a/libphobos/src/std/mmfile.d b/libphobos/src/std/mmfile.d index 453e2ec74..79c2399a2 100644 --- a/libphobos/src/std/mmfile.d +++ b/libphobos/src/std/mmfile.d @@ -343,7 +343,7 @@ class MmFile else { fd = -1; - version (CRuntime_Glibc) import core.sys.linux.sys.mman : MAP_ANON; + version (CRuntime_Glibc) version (linux) import core.sys.linux.sys.mman : MAP_ANON; flags |= MAP_ANON; } this.size = size; -- 2.52.0 From 63b3cb1572480e3d67cd6228e99db3532d36ef30 Mon Sep 17 00:00:00 2001 From: Yelninei Date: Sat, 18 Apr 2026 18:37:31 +0000 Subject: [PATCH 3/4] libphobos: Support GNU/Hurd --- libphobos/configure.tgt | 3 +++ libphobos/libdruntime/Makefile.am | 10 ++++++++++ libphobos/libdruntime/config/common/threadasm.S | 2 +- libphobos/libdruntime/config/x86/switchcontext.S | 8 ++++---- libphobos/m4/druntime/os.m4 | 5 +++++ 5 files changed, 23 insertions(+), 5 deletions(-) diff --git a/libphobos/configure.tgt b/libphobos/configure.tgt index 0643daeb6..e20af4f83 100644 --- a/libphobos/configure.tgt +++ b/libphobos/configure.tgt @@ -61,6 +61,9 @@ case "${target}" in x86_64-*-linux* | i?86-*-linux*) LIBPHOBOS_SUPPORTED=yes ;; + x86_64-*-gnu* | i?86-*-gnu*) + LIBPHOBOS_SUPPORTED=yes + ;; x86_64-*-netbsd* | i?86-*-netbsd*) LIBPHOBOS_SUPPORTED=yes ;; diff --git a/libphobos/libdruntime/Makefile.am b/libphobos/libdruntime/Makefile.am index a2e2bff9e..1640eb32c 100644 --- a/libphobos/libdruntime/Makefile.am +++ b/libphobos/libdruntime/Makefile.am @@ -37,6 +37,7 @@ ALL_DRUNTIME_INSTALL_DSOURCES = $(DRUNTIME_DSOURCES) \ $(DRUNTIME_DSOURCES_LINUX) $(DRUNTIME_DSOURCES_NETBSD) \ $(DRUNTIME_DSOURCES_OPENBSD) $(DRUNTIME_DSOURCES_POSIX) \ $(DRUNTIME_DSOURCES_SOLARIS) $(DRUNTIME_DSOURCES_WINDOWS) \ + $(DRUNTIME_DSOURCES_HURD) \ $(DRUNTIME_DSOURCES_GENERATED) $(DRUNTIME_DISOURCES) \ $(DRUNTIME_DSOURCES_STDCXX) @@ -75,6 +76,9 @@ endif if DRUNTIME_OS_SOLARIS DRUNTIME_SOURCES_CONFIGURED += $(DRUNTIME_DSOURCES_SOLARIS) endif +if DRUNTIME_OS_HURD + DRUNTIME_SOURCES_CONFIGURED += $(DRUNTIME_DSOURCES_HURD) +endif # CPU specific sources if DRUNTIME_CPU_AARCH64 DRUNTIME_SOURCES_CONFIGURED += config/aarch64/switchcontext.S @@ -317,6 +321,12 @@ DRUNTIME_DSOURCES_SOLARIS = core/sys/solaris/dlfcn.d \ core/sys/solaris/sys/procset.d core/sys/solaris/sys/types.d \ core/sys/solaris/time.d +DRUNTIME_DSOURCES_HURD = core/sys/hurd/config.d \ + core/sys/hurd/dlfcn.d core/sys/hurd/elf.d \ + core/sys/hurd/errno.d core/sys/hurd/execinfo.d \ + core/sys/hurd/link.d core/sys/hurd/sys/types.d \ + core/sys/hurd/time.d core/sys/hurd/unistd.d + DRUNTIME_DSOURCES_WINDOWS = core/sys/windows/accctrl.d \ core/sys/windows/aclapi.d core/sys/windows/aclui.d \ core/sys/windows/basetsd.d core/sys/windows/basetyps.d \ diff --git a/libphobos/libdruntime/config/common/threadasm.S b/libphobos/libdruntime/config/common/threadasm.S index 35462170e..6ef1fece6 100644 --- a/libphobos/libdruntime/config/common/threadasm.S +++ b/libphobos/libdruntime/config/common/threadasm.S @@ -22,7 +22,7 @@ a copy of the GCC Runtime Library Exception along with this program; see the files COPYING3 and COPYING.RUNTIME respectively. If not, see . */ -#if (__linux__ || __FreeBSD__ || __NetBSD__ || __OpenBSD__ || __DragonFly__) && __ELF__ +#if (__linux__ || __FreeBSD__ || __NetBSD__ || __OpenBSD__ || __DragonFly__ || __GNU__) && __ELF__ /* * Mark the resulting object file as not requiring execution permissions on * stack memory. The absence of this section would mark the whole resulting diff --git a/libphobos/libdruntime/config/x86/switchcontext.S b/libphobos/libdruntime/config/x86/switchcontext.S index 9f4befdb4..40a6c1868 100644 --- a/libphobos/libdruntime/config/x86/switchcontext.S +++ b/libphobos/libdruntime/config/x86/switchcontext.S @@ -108,7 +108,7 @@ CSYM(fiber_switchContext): # endif /* defined(__ELF__) */ -# if defined(__MACH__) +# if defined(__APPLE__) # if defined(__i386__) @@ -177,7 +177,7 @@ LASFDE1: .p2align 2,0 LEFDE1: -# endif /* defined(__MACH__) && defined(__i386__) */ +# endif /* defined(__APPLE__) && defined(__i386__) */ # if defined(__x86_64__) && !defined(__ILP32__) @@ -247,8 +247,8 @@ LASFDE1: .p2align 3,0 LEFDE1: -# endif /* defined(__MACH__) && defined(__x86_64__) && !defined(__ILP32__) */ +# endif /* defined(__APPLE__) && defined(__x86_64__) && !defined(__ILP32__) */ -# endif /* defined (__MACH__) */ +# endif /* defined(__APPLE__) */ #endif /* !defined(__CET__) */ diff --git a/libphobos/m4/druntime/os.m4 b/libphobos/m4/druntime/os.m4 index 351558dbc..2745a8c09 100644 --- a/libphobos/m4/druntime/os.m4 +++ b/libphobos/m4/druntime/os.m4 @@ -88,6 +88,9 @@ AC_DEFUN([DRUNTIME_OS_SOURCES], mingw*) druntime_target_os_parsed="mingw" ;; *solaris*) druntime_target_os_parsed="solaris" + ;; + gnu*) druntime_target_os_parsed="hurd" + ;; esac AM_CONDITIONAL([DRUNTIME_OS_AIX], [test "$druntime_target_os_parsed" = "aix"]) @@ -109,6 +112,8 @@ AC_DEFUN([DRUNTIME_OS_SOURCES], [test "$druntime_target_os_parsed" = "mingw"]) AM_CONDITIONAL([DRUNTIME_OS_SOLARIS], [test "$druntime_target_os_parsed" = "solaris"]) + AM_CONDITIONAL([DRUNTIME_OS_HURD], + [test "$druntime_target_os_parsed" = "hurd"]) druntime_target_posix="no" case "$druntime_cv_target_os" in -- 2.52.0 From 92591bb61ad458f1570dce3902f79f0cd0e58545 Mon Sep 17 00:00:00 2001 From: Yelninei Date: Sat, 18 Apr 2026 18:40:30 +0000 Subject: [PATCH 4/4] libphobos: Regenerate autotools --- libphobos/configure | 21 ++++- libphobos/libdruntime/Makefile.in | 125 ++++++++++++++++++++---------- 2 files changed, 101 insertions(+), 45 deletions(-) diff --git a/libphobos/configure b/libphobos/configure index b1c8ecb56..8cb7cab8f 100755 --- a/libphobos/configure +++ b/libphobos/configure @@ -666,6 +666,8 @@ DCFG_ARM_EABI_UNWINDER DCFG_THREAD_MODEL DRUNTIME_OS_POSIX_FALSE DRUNTIME_OS_POSIX_TRUE +DRUNTIME_OS_HURD_FALSE +DRUNTIME_OS_HURD_TRUE DRUNTIME_OS_SOLARIS_FALSE DRUNTIME_OS_SOLARIS_TRUE DRUNTIME_OS_MINGW_FALSE @@ -11750,7 +11752,7 @@ else lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2 lt_status=$lt_dlunknown cat > conftest.$ac_ext <<_LT_EOF -#line 11753 "configure" +#line 11755 "configure" #include "confdefs.h" #if HAVE_DLFCN_H @@ -11856,7 +11858,7 @@ else lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2 lt_status=$lt_dlunknown cat > conftest.$ac_ext <<_LT_EOF -#line 11859 "configure" +#line 11861 "configure" #include "confdefs.h" #if HAVE_DLFCN_H @@ -14250,6 +14252,9 @@ fi mingw*) druntime_target_os_parsed="mingw" ;; *solaris*) druntime_target_os_parsed="solaris" + ;; + gnu*) druntime_target_os_parsed="hurd" + ;; esac if test "$druntime_target_os_parsed" = "aix"; then DRUNTIME_OS_AIX_TRUE= @@ -14331,6 +14336,14 @@ else DRUNTIME_OS_SOLARIS_FALSE= fi + if test "$druntime_target_os_parsed" = "hurd"; then + DRUNTIME_OS_HURD_TRUE= + DRUNTIME_OS_HURD_FALSE='#' +else + DRUNTIME_OS_HURD_TRUE='#' + DRUNTIME_OS_HURD_FALSE= +fi + druntime_target_posix="no" case "$druntime_cv_target_os" in @@ -15806,6 +15819,10 @@ if test -z "${DRUNTIME_OS_SOLARIS_TRUE}" && test -z "${DRUNTIME_OS_SOLARIS_FALSE as_fn_error $? "conditional \"DRUNTIME_OS_SOLARIS\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi +if test -z "${DRUNTIME_OS_HURD_TRUE}" && test -z "${DRUNTIME_OS_HURD_FALSE}"; then + as_fn_error $? "conditional \"DRUNTIME_OS_HURD\" was never defined. +Usually this means the macro was only invoked conditionally." "$LINENO" 5 +fi if test -z "${DRUNTIME_OS_POSIX_TRUE}" && test -z "${DRUNTIME_OS_POSIX_FALSE}"; then as_fn_error $? "conditional \"DRUNTIME_OS_POSIX\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 diff --git a/libphobos/libdruntime/Makefile.in b/libphobos/libdruntime/Makefile.in index cb2e372bc..7b8b86d3e 100644 --- a/libphobos/libdruntime/Makefile.in +++ b/libphobos/libdruntime/Makefile.in @@ -121,15 +121,16 @@ target_triplet = @target@ @DRUNTIME_OS_MINGW_TRUE@ config/mingw/msvc.c @DRUNTIME_OS_SOLARIS_TRUE@am__append_10 = $(DRUNTIME_DSOURCES_SOLARIS) +@DRUNTIME_OS_HURD_TRUE@am__append_11 = $(DRUNTIME_DSOURCES_HURD) # CPU specific sources -@DRUNTIME_CPU_AARCH64_TRUE@am__append_11 = config/aarch64/switchcontext.S -@DRUNTIME_CPU_ARM_TRUE@am__append_12 = config/arm/switchcontext.S -@DRUNTIME_CPU_MIPS_TRUE@am__append_13 = config/mips/switchcontext.S -@DRUNTIME_CPU_POWERPC_TRUE@am__append_14 = config/powerpc/switchcontext.S -@DRUNTIME_CPU_X86_TRUE@@DRUNTIME_OS_MINGW_TRUE@am__append_15 = config/mingw/switchcontext.S -@DRUNTIME_CPU_X86_TRUE@@DRUNTIME_OS_MINGW_FALSE@am__append_16 = config/x86/switchcontext.S -@DRUNTIME_CPU_SYSTEMZ_TRUE@am__append_17 = config/systemz/get_tls_offset.S -@DRUNTIME_CPU_S390_TRUE@am__append_18 = config/s390/get_tls_offset.S +@DRUNTIME_CPU_AARCH64_TRUE@am__append_12 = config/aarch64/switchcontext.S +@DRUNTIME_CPU_ARM_TRUE@am__append_13 = config/arm/switchcontext.S +@DRUNTIME_CPU_MIPS_TRUE@am__append_14 = config/mips/switchcontext.S +@DRUNTIME_CPU_POWERPC_TRUE@am__append_15 = config/powerpc/switchcontext.S +@DRUNTIME_CPU_X86_TRUE@@DRUNTIME_OS_MINGW_TRUE@am__append_16 = config/mingw/switchcontext.S +@DRUNTIME_CPU_X86_TRUE@@DRUNTIME_OS_MINGW_FALSE@am__append_17 = config/x86/switchcontext.S +@DRUNTIME_CPU_SYSTEMZ_TRUE@am__append_18 = config/systemz/get_tls_offset.S +@DRUNTIME_CPU_S390_TRUE@am__append_19 = config/s390/get_tls_offset.S subdir = libdruntime ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 am__aclocal_m4_deps = $(top_srcdir)/../config/acx.m4 \ @@ -445,47 +446,55 @@ am__objects_21 = core/sys/solaris/dlfcn.lo core/sys/solaris/elf.lo \ core/sys/solaris/sys/procset.lo core/sys/solaris/sys/types.lo \ core/sys/solaris/time.lo @DRUNTIME_OS_SOLARIS_TRUE@am__objects_22 = $(am__objects_21) -@DRUNTIME_CPU_AARCH64_TRUE@am__objects_23 = config/aarch64/libgdruntime_la-switchcontext.lo -@DRUNTIME_CPU_ARM_TRUE@am__objects_24 = config/arm/libgdruntime_la-switchcontext.lo -@DRUNTIME_CPU_MIPS_TRUE@am__objects_25 = config/mips/libgdruntime_la-switchcontext.lo -@DRUNTIME_CPU_POWERPC_TRUE@am__objects_26 = config/powerpc/libgdruntime_la-switchcontext.lo -@DRUNTIME_CPU_X86_TRUE@@DRUNTIME_OS_MINGW_TRUE@am__objects_27 = config/mingw/libgdruntime_la-switchcontext.lo -@DRUNTIME_CPU_X86_TRUE@@DRUNTIME_OS_MINGW_FALSE@am__objects_28 = config/x86/libgdruntime_la-switchcontext.lo -@DRUNTIME_CPU_SYSTEMZ_TRUE@am__objects_29 = config/systemz/libgdruntime_la-get_tls_offset.lo -@DRUNTIME_CPU_S390_TRUE@am__objects_30 = config/s390/libgdruntime_la-get_tls_offset.lo -am__objects_31 = $(am__objects_4) $(am__objects_6) $(am__objects_8) \ +am__objects_23 = core/sys/hurd/config.lo core/sys/hurd/dlfcn.lo \ + core/sys/hurd/elf.lo core/sys/hurd/errno.lo \ + core/sys/hurd/execinfo.lo core/sys/hurd/link.lo \ + core/sys/hurd/sys/types.lo core/sys/hurd/time.lo \ + core/sys/hurd/unistd.lo +@DRUNTIME_OS_HURD_TRUE@am__objects_24 = $(am__objects_23) +@DRUNTIME_CPU_AARCH64_TRUE@am__objects_25 = config/aarch64/libgdruntime_la-switchcontext.lo +@DRUNTIME_CPU_ARM_TRUE@am__objects_26 = config/arm/libgdruntime_la-switchcontext.lo +@DRUNTIME_CPU_MIPS_TRUE@am__objects_27 = config/mips/libgdruntime_la-switchcontext.lo +@DRUNTIME_CPU_POWERPC_TRUE@am__objects_28 = config/powerpc/libgdruntime_la-switchcontext.lo +@DRUNTIME_CPU_X86_TRUE@@DRUNTIME_OS_MINGW_TRUE@am__objects_29 = config/mingw/libgdruntime_la-switchcontext.lo +@DRUNTIME_CPU_X86_TRUE@@DRUNTIME_OS_MINGW_FALSE@am__objects_30 = config/x86/libgdruntime_la-switchcontext.lo +@DRUNTIME_CPU_SYSTEMZ_TRUE@am__objects_31 = config/systemz/libgdruntime_la-get_tls_offset.lo +@DRUNTIME_CPU_S390_TRUE@am__objects_32 = config/s390/libgdruntime_la-get_tls_offset.lo +am__objects_33 = $(am__objects_4) $(am__objects_6) $(am__objects_8) \ $(am__objects_10) $(am__objects_12) $(am__objects_14) \ $(am__objects_16) $(am__objects_18) $(am__objects_20) \ - $(am__objects_22) $(am__objects_23) $(am__objects_24) \ - $(am__objects_25) $(am__objects_26) $(am__objects_27) \ - $(am__objects_28) $(am__objects_29) $(am__objects_30) -am__objects_32 = gcc/config.lo gcc/libbacktrace.lo -am__objects_33 = $(am__objects_1) $(am__objects_2) $(am__objects_31) \ + $(am__objects_22) $(am__objects_24) $(am__objects_25) \ + $(am__objects_26) $(am__objects_27) $(am__objects_28) \ + $(am__objects_29) $(am__objects_30) $(am__objects_31) \ $(am__objects_32) -am_libgdruntime_la_OBJECTS = $(am__objects_33) +am__objects_34 = gcc/config.lo gcc/libbacktrace.lo +am__objects_35 = $(am__objects_1) $(am__objects_2) $(am__objects_33) \ + $(am__objects_34) +am_libgdruntime_la_OBJECTS = $(am__objects_35) libgdruntime_la_OBJECTS = $(am_libgdruntime_la_OBJECTS) am__DEPENDENCIES_2 = $(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1) -am__objects_34 = core/stdc/libgdruntime_convenience_la-errno_.lo -@DRUNTIME_OS_MINGW_TRUE@am__objects_35 = $(am__objects_19) \ +am__objects_36 = core/stdc/libgdruntime_convenience_la-errno_.lo +@DRUNTIME_OS_MINGW_TRUE@am__objects_37 = $(am__objects_19) \ @DRUNTIME_OS_MINGW_TRUE@ config/mingw/libgdruntime_convenience_la-msvc.lo -@DRUNTIME_CPU_AARCH64_TRUE@am__objects_36 = config/aarch64/libgdruntime_convenience_la-switchcontext.lo -@DRUNTIME_CPU_ARM_TRUE@am__objects_37 = config/arm/libgdruntime_convenience_la-switchcontext.lo -@DRUNTIME_CPU_MIPS_TRUE@am__objects_38 = config/mips/libgdruntime_convenience_la-switchcontext.lo -@DRUNTIME_CPU_POWERPC_TRUE@am__objects_39 = config/powerpc/libgdruntime_convenience_la-switchcontext.lo -@DRUNTIME_CPU_X86_TRUE@@DRUNTIME_OS_MINGW_TRUE@am__objects_40 = config/mingw/libgdruntime_convenience_la-switchcontext.lo -@DRUNTIME_CPU_X86_TRUE@@DRUNTIME_OS_MINGW_FALSE@am__objects_41 = config/x86/libgdruntime_convenience_la-switchcontext.lo -@DRUNTIME_CPU_SYSTEMZ_TRUE@am__objects_42 = config/systemz/libgdruntime_convenience_la-get_tls_offset.lo -@DRUNTIME_CPU_S390_TRUE@am__objects_43 = config/s390/libgdruntime_convenience_la-get_tls_offset.lo -am__objects_44 = $(am__objects_4) $(am__objects_6) $(am__objects_8) \ +@DRUNTIME_CPU_AARCH64_TRUE@am__objects_38 = config/aarch64/libgdruntime_convenience_la-switchcontext.lo +@DRUNTIME_CPU_ARM_TRUE@am__objects_39 = config/arm/libgdruntime_convenience_la-switchcontext.lo +@DRUNTIME_CPU_MIPS_TRUE@am__objects_40 = config/mips/libgdruntime_convenience_la-switchcontext.lo +@DRUNTIME_CPU_POWERPC_TRUE@am__objects_41 = config/powerpc/libgdruntime_convenience_la-switchcontext.lo +@DRUNTIME_CPU_X86_TRUE@@DRUNTIME_OS_MINGW_TRUE@am__objects_42 = config/mingw/libgdruntime_convenience_la-switchcontext.lo +@DRUNTIME_CPU_X86_TRUE@@DRUNTIME_OS_MINGW_FALSE@am__objects_43 = config/x86/libgdruntime_convenience_la-switchcontext.lo +@DRUNTIME_CPU_SYSTEMZ_TRUE@am__objects_44 = config/systemz/libgdruntime_convenience_la-get_tls_offset.lo +@DRUNTIME_CPU_S390_TRUE@am__objects_45 = config/s390/libgdruntime_convenience_la-get_tls_offset.lo +am__objects_46 = $(am__objects_4) $(am__objects_6) $(am__objects_8) \ $(am__objects_10) $(am__objects_12) $(am__objects_14) \ - $(am__objects_16) $(am__objects_18) $(am__objects_35) \ - $(am__objects_22) $(am__objects_36) $(am__objects_37) \ - $(am__objects_38) $(am__objects_39) $(am__objects_40) \ - $(am__objects_41) $(am__objects_42) $(am__objects_43) -am__objects_45 = $(am__objects_1) $(am__objects_34) $(am__objects_44) \ - $(am__objects_32) -am__objects_46 = $(am__objects_45) -am_libgdruntime_convenience_la_OBJECTS = $(am__objects_46) + $(am__objects_16) $(am__objects_18) $(am__objects_37) \ + $(am__objects_22) $(am__objects_24) $(am__objects_38) \ + $(am__objects_39) $(am__objects_40) $(am__objects_41) \ + $(am__objects_42) $(am__objects_43) $(am__objects_44) \ + $(am__objects_45) +am__objects_47 = $(am__objects_1) $(am__objects_36) $(am__objects_46) \ + $(am__objects_34) +am__objects_48 = $(am__objects_47) +am_libgdruntime_convenience_la_OBJECTS = $(am__objects_48) libgdruntime_convenience_la_OBJECTS = \ $(am_libgdruntime_convenience_la_OBJECTS) AM_V_P = $(am__v_P_@AM_V@) @@ -747,6 +756,7 @@ ALL_DRUNTIME_INSTALL_DSOURCES = $(DRUNTIME_DSOURCES) \ $(DRUNTIME_DSOURCES_LINUX) $(DRUNTIME_DSOURCES_NETBSD) \ $(DRUNTIME_DSOURCES_OPENBSD) $(DRUNTIME_DSOURCES_POSIX) \ $(DRUNTIME_DSOURCES_SOLARIS) $(DRUNTIME_DSOURCES_WINDOWS) \ + $(DRUNTIME_DSOURCES_HURD) \ $(DRUNTIME_DSOURCES_GENERATED) $(DRUNTIME_DISOURCES) \ $(DRUNTIME_DSOURCES_STDCXX) @@ -758,7 +768,7 @@ DRUNTIME_SOURCES_CONFIGURED = $(am__append_1) $(am__append_2) \ $(am__append_9) $(am__append_10) $(am__append_11) \ $(am__append_12) $(am__append_13) $(am__append_14) \ $(am__append_15) $(am__append_16) $(am__append_17) \ - $(am__append_18) + $(am__append_18) $(am__append_19) # Provide __start_minfo, __stop_minfo if linker doesn't. @DRUNTIME_OS_MINFO_BRACKETING_FALSE@DRTSTUFF = gcc/drtbegin.o gcc/drtend.o @@ -954,6 +964,12 @@ DRUNTIME_DSOURCES_SOLARIS = core/sys/solaris/dlfcn.d \ core/sys/solaris/sys/procset.d core/sys/solaris/sys/types.d \ core/sys/solaris/time.d +DRUNTIME_DSOURCES_HURD = core/sys/hurd/config.d \ + core/sys/hurd/dlfcn.d core/sys/hurd/elf.d \ + core/sys/hurd/errno.d core/sys/hurd/execinfo.d \ + core/sys/hurd/link.d core/sys/hurd/sys/types.d \ + core/sys/hurd/time.d core/sys/hurd/unistd.d + DRUNTIME_DSOURCES_WINDOWS = core/sys/windows/accctrl.d \ core/sys/windows/aclapi.d core/sys/windows/aclui.d \ core/sys/windows/basetsd.d core/sys/windows/basetyps.d \ @@ -1771,6 +1787,21 @@ core/sys/solaris/sys/priocntl.lo: \ core/sys/solaris/sys/procset.lo: core/sys/solaris/sys/$(am__dirstamp) core/sys/solaris/sys/types.lo: core/sys/solaris/sys/$(am__dirstamp) core/sys/solaris/time.lo: core/sys/solaris/$(am__dirstamp) +core/sys/hurd/$(am__dirstamp): + @$(MKDIR_P) core/sys/hurd + @: > core/sys/hurd/$(am__dirstamp) +core/sys/hurd/config.lo: core/sys/hurd/$(am__dirstamp) +core/sys/hurd/dlfcn.lo: core/sys/hurd/$(am__dirstamp) +core/sys/hurd/elf.lo: core/sys/hurd/$(am__dirstamp) +core/sys/hurd/errno.lo: core/sys/hurd/$(am__dirstamp) +core/sys/hurd/execinfo.lo: core/sys/hurd/$(am__dirstamp) +core/sys/hurd/link.lo: core/sys/hurd/$(am__dirstamp) +core/sys/hurd/sys/$(am__dirstamp): + @$(MKDIR_P) core/sys/hurd/sys + @: > core/sys/hurd/sys/$(am__dirstamp) +core/sys/hurd/sys/types.lo: core/sys/hurd/sys/$(am__dirstamp) +core/sys/hurd/time.lo: core/sys/hurd/$(am__dirstamp) +core/sys/hurd/unistd.lo: core/sys/hurd/$(am__dirstamp) config/aarch64/$(am__dirstamp): @$(MKDIR_P) config/aarch64 @: > config/aarch64/$(am__dirstamp) @@ -1885,6 +1916,10 @@ mostlyclean-compile: -rm -f core/sys/freebsd/netinet/*.lo -rm -f core/sys/freebsd/sys/*.$(OBJEXT) -rm -f core/sys/freebsd/sys/*.lo + -rm -f core/sys/hurd/*.$(OBJEXT) + -rm -f core/sys/hurd/*.lo + -rm -f core/sys/hurd/sys/*.$(OBJEXT) + -rm -f core/sys/hurd/sys/*.lo -rm -f core/sys/linux/*.$(OBJEXT) -rm -f core/sys/linux/*.lo -rm -f core/sys/linux/netinet/*.$(OBJEXT) @@ -2049,6 +2084,8 @@ clean-libtool: -rm -rf core/sys/freebsd/.libs core/sys/freebsd/_libs -rm -rf core/sys/freebsd/netinet/.libs core/sys/freebsd/netinet/_libs -rm -rf core/sys/freebsd/sys/.libs core/sys/freebsd/sys/_libs + -rm -rf core/sys/hurd/.libs core/sys/hurd/_libs + -rm -rf core/sys/hurd/sys/.libs core/sys/hurd/sys/_libs -rm -rf core/sys/linux/.libs core/sys/linux/_libs -rm -rf core/sys/linux/netinet/.libs core/sys/linux/netinet/_libs -rm -rf core/sys/linux/sys/.libs core/sys/linux/sys/_libs @@ -2205,6 +2242,8 @@ distclean-generic: -rm -f core/sys/freebsd/$(am__dirstamp) -rm -f core/sys/freebsd/netinet/$(am__dirstamp) -rm -f core/sys/freebsd/sys/$(am__dirstamp) + -rm -f core/sys/hurd/$(am__dirstamp) + -rm -f core/sys/hurd/sys/$(am__dirstamp) -rm -f core/sys/linux/$(am__dirstamp) -rm -f core/sys/linux/netinet/$(am__dirstamp) -rm -f core/sys/linux/sys/$(am__dirstamp) -- 2.52.0