diff --git a/CODEOWNERS b/CODEOWNERS index d0cba4caa4..4d60c4ee38 100644 --- a/CODEOWNERS +++ b/CODEOWNERS @@ -33,6 +33,7 @@ src/core/sys/darwin/* @jacob-carlborg @klickverbot @etcimon @MartinNowak src/core/sys/freebsd/* @redstar @MartinNowak @Calrama @jmdavis src/core/sys/linux/* @Burgos @redstar @MartinNowak src/core/sys/netbsd/* @nrTQgc @joakim-noah +src/core/sys/dragonflybsd/* @dkgroot src/core/sys/openbsd/* @redstar src/core/sys/osx/* @jacob-carlborg @klickverbot @etcimon @MartinNowak src/core/sys/posix/* @CyberShadow @MartinNowak @joakim-noah @redstar diff --git a/mak/COPY b/mak/COPY index e645779c49..d6e9c3310d 100644 --- a/mak/COPY +++ b/mak/COPY @@ -86,6 +86,24 @@ COPY=\ $(IMPDIR)\core\sys\freebsd\sys\mman.d \ $(IMPDIR)\core\sys\freebsd\time.d \ \ + $(IMPDIR)\core\sys\dragonflybsd\dlfcn.d \ + $(IMPDIR)\core\sys\dragonflybsd\execinfo.d \ + \ + $(IMPDIR)\core\sys\dragonflybsd\netinet\in_.d \ + \ + $(IMPDIR)\core\sys\dragonflybsd\sys\cdefs.d \ + $(IMPDIR)\core\sys\dragonflybsd\pthread_np.d \ + $(IMPDIR)\core\sys\dragonflybsd\sys\_bitset.d \ + $(IMPDIR)\core\sys\dragonflybsd\sys\_cpuset.d \ + $(IMPDIR)\core\sys\dragonflybsd\sys\elf.d \ + $(IMPDIR)\core\sys\dragonflybsd\sys\elf32.d \ + $(IMPDIR)\core\sys\dragonflybsd\sys\elf64.d \ + $(IMPDIR)\core\sys\dragonflybsd\sys\elf_common.d \ + $(IMPDIR)\core\sys\dragonflybsd\sys\event.d \ + $(IMPDIR)\core\sys\dragonflybsd\sys\link_elf.d \ + $(IMPDIR)\core\sys\dragonflybsd\sys\mman.d \ + $(IMPDIR)\core\sys\dragonflybsd\time.d \ + \ $(IMPDIR)\core\sys\linux\config.d \ $(IMPDIR)\core\sys\linux\dlfcn.d \ $(IMPDIR)\core\sys\linux\elf.d \ diff --git a/mak/SRCS b/mak/SRCS index 0a915726c9..8a877c9703 100644 --- a/mak/SRCS +++ b/mak/SRCS @@ -71,6 +71,21 @@ SRCS=\ src\core\sys\freebsd\sys\mman.d \ src\core\sys\freebsd\time.d \ \ + src\core\sys\dragonflybsd\dlfcn.d \ + src\core\sys\dragonflybsd\execinfo.d \ + src\core\sys\dragonflybsd\netinet\in_.d \ + src\core\sys\dragonflybsd\sys\_bitset.d \ + src\core\sys\dragonflybsd\sys\_cpuset.d \ + src\core\sys\dragonflybsd\sys\cdefs.d \ + src\core\sys\dragonflybsd\sys\elf_common.d \ + src\core\sys\dragonflybsd\sys\elf.d \ + src\core\sys\dragonflybsd\sys\elf32.d \ + src\core\sys\dragonflybsd\sys\elf64.d \ + src\core\sys\dragonflybsd\sys\event.d \ + src\core\sys\dragonflybsd\sys\link_elf.d \ + src\core\sys\dragonflybsd\sys\mman.d \ + src\core\sys\dragonflybsd\time.d \ + \ src\core\sys\linux\netinet\in_.d \ src\core\sys\linux\netinet\tcp.d \ src\core\sys\linux\stdio.d \ diff --git a/posix.mak b/posix.mak index 20eda61637..d79e236ce3 100644 --- a/posix.mak +++ b/posix.mak @@ -57,7 +57,7 @@ endif # build with shared library support # (defaults to true on supported platforms, can be overridden w/ make SHARED=0) -SHARED=$(if $(findstring $(OS),linux freebsd),1,) +SHARED=$(if $(findstring $(OS),linux freebsd dragonflybsd),1,) LINKDL=$(if $(findstring $(OS),linux),-L-ldl,) @@ -204,7 +204,7 @@ $(IMPDIR)/%.d : src/%.d ######################## Build DMD if non-existent ############################## $(DMD): - make -C $(DMD_DIR)/src -f posix.mak BUILD=$(BUILD) OS=$(OS) MODEL=$(MODEL) + $(MAKE) -C $(DMD_DIR)/src -f posix.mak BUILD=$(BUILD) OS=$(OS) MODEL=$(MODEL) ################### C/ASM Targets ############################ diff --git a/src/core/sys/dragonflybsd/dlfcn.d b/src/core/sys/dragonflybsd/dlfcn.d new file mode 100644 index 0000000000..3ffa1b93da --- /dev/null +++ b/src/core/sys/dragonflybsd/dlfcn.d @@ -0,0 +1,107 @@ +/** + * D header file for DragonFlyBSD + * + * Copyright: Copyright Martin Nowak 2012. + * License: $(WEB www.boost.org/LICENSE_1_0.txt, Boost License 1.0). + * Authors: Martin Nowak,Diederik de Groot(port:DragonFlyBSD) + * Copied: From core/sys/freebsd/sys + */ +module core.sys.dragonflybsd.dlfcn; + +version (DragonFlyBSD): + +public import core.sys.posix.dlfcn; + +extern (C) nothrow @nogc @system: + +/* + * Modes and flags for dlopen(). + */ +static assert(RTLD_LAZY == 1); +static assert(RTLD_NOW == 2); +enum RTLD_MODEMASK = 0x3; +static assert(RTLD_GLOBAL == 0x100); +static assert(RTLD_LOCAL == 0); +enum RTLD_TRACE = 0x200; +enum RTLD_NODELETE = 0x01000; +enum RTLD_NOLOAD = 0x02000; + +/* + * Request arguments for dlinfo(). + */ +enum RTLD_DI_LINKMAP = 2; /* Obtain link map. */ +enum RTLD_DI_SERINFO = 4; /* Obtain search path info. */ +enum RTLD_DI_SERINFOSIZE = 5; /* ... query for required space. */ +enum RTLD_DI_ORIGIN = 6; /* Obtain object origin */ +enum RTLD_DI_MAX = RTLD_DI_ORIGIN; + +/* + * Special handle arguments for dlsym()/dlinfo(). + */ +enum RTLD_NEXT = cast(void *)-1; /* Search subsequent objects. */ +enum RTLD_DEFAULT = cast(void *)-2; /* Use default search algorithm. */ +enum RTLD_SELF = cast(void *)-3; /* Search the caller itself. */ + +/* + * Structure filled in by dladdr(). + */ +struct Dl_info { + const(char) *dli_fname; /* Pathname of shared object. */ + void *dli_fbase; /* Base address of shared object. */ + const(char) *dli_sname; /* Name of nearest symbol. */ + void *dli_saddr; /* Address of nearest symbol. */ +}; + + +/* + * Structures, returned by the RTLD_DI_SERINFO dlinfo() request. + */ +struct Dl_serpath { + char * dls_name; /* single search path entry */ + uint dls_flags; /* path information */ +}; + +struct Dl_serinfo { + size_t dls_size; /* total buffer size */ + uint dls_cnt; /* number of path entries */ + Dl_serpath[1] dls_serpath; /* there may be more than one */ +}; + +/*- + * The actual type declared by this typedef is immaterial, provided that + * it is a function pointer. Its purpose is to provide a return type for + * dlfunc() which can be cast to a function pointer type without depending + * on behavior undefined by the C standard, which might trigger a compiler + * diagnostic. We intentionally declare a unique type signature to force + * a diagnostic should the application not cast the return value of dlfunc() + * appropriately. + */ +struct __dlfunc_arg { + int __dlfunc_dummy; +}; + +alias dlfunc_t = void function(__dlfunc_arg); + +private template __externC(RT, P...) +{ + alias __externC = extern(C) RT function(P) nothrow @nogc @system; +} + +/* XSI functions first. */ +static assert(is(typeof(&dlclose) == __externC!(int, void*))); +static assert(is(typeof(&dlerror) == __externC!(char*))); +static assert(is(typeof(&dlopen) == __externC!(void*, const char*, int))); +static assert(is(typeof(&dlsym) == __externC!(void*, void*, const char*))); + +void* fdlopen(int, int); +int dladdr(const(void)*, Dl_info*); +dlfunc_t dlfunc(void*, const(char)*); +int dlinfo(void*, int, void*); +/*void dllockinit(void* _context, + void* function(void* _context) _lock_create, + void function(void* _lock) _rlock_acquire, + void function(void* _lock) _wlock_acquire, + void function(void* _lock) _lock_release, + void function(void* _lock) _lock_destroy, + void function(void* _context) _context_destroy);*/ +void* dlvsym(void*, const(char)*, const(char)*); diff --git a/src/core/sys/dragonflybsd/execinfo.d b/src/core/sys/dragonflybsd/execinfo.d new file mode 100644 index 0000000000..9d2d615f78 --- /dev/null +++ b/src/core/sys/dragonflybsd/execinfo.d @@ -0,0 +1,133 @@ +/** + * DragonFlyBSD implementation of glibc's $(LINK2 http://www.gnu.org/software/libc/manual/html_node/Backtraces.html backtrace) facility. + * + * Copyright: Copyright Martin Nowak 2012. + * License: $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost License 1.0) + * Authors: Martin Nowak,Diederik de Groot(port:DragonFlyBSD) + * Copied: From core/sys/freebsd/sys + */ +module core.sys.dragonflybsd.execinfo; + +version (DragonFlyBSD): + +extern (C) nothrow @system: + +import core.sys.dragonflybsd.dlfcn; + +// Use extern (D) so that these functions don't collide with libexecinfo. + +extern (D) int backtrace(void** buffer, int size) +{ + import core.thread : thread_stackBottom; + + void** p, pend=cast(void**)thread_stackBottom(); + version (D_InlineAsm_X86) + asm nothrow @trusted { mov p[EBP], EBP; } + else version (D_InlineAsm_X86_64) + asm nothrow @trusted { mov p[RBP], RBP; } + else + static assert(false, "Architecture not supported."); + + int i; + for (; i < size && p < pend; ++i) + { + buffer[i] = *(p + 1); + auto pnext = cast(void**)*p; + if (pnext <= p) break; + p = pnext; + } + return i; +} + + +extern (D) char** backtrace_symbols(const(void*)* buffer, int size) +{ + static void* realloc(void* p, size_t len) nothrow + { + static import cstdlib=core.stdc.stdlib; + auto res = cstdlib.realloc(p, len); + if (res is null) cstdlib.free(p); + return res; + } + + if (size <= 0) return null; + + size_t pos = size * (char*).sizeof; + char** p = cast(char**)realloc(null, pos); + if (p is null) return null; + + Dl_info info; + foreach (i, addr; buffer[0 .. size]) + { + if (dladdr(addr, &info) == 0) + (cast(ubyte*)&info)[0 .. info.sizeof] = 0; + fixupDLInfo(addr, info); + + immutable len = formatStackFrame(null, 0, addr, info); + assert(len > 0); + + p = cast(char**)realloc(p, pos + len); + if (p is null) return null; + + formatStackFrame(cast(char*)p + pos, len, addr, info) == len || assert(0); + + p[i] = cast(char*)pos; + pos += len; + } + foreach (i; 0 .. size) + { + pos = cast(size_t)p[i]; + p[i] = cast(char*)p + pos; + } + return p; +} + + +extern (D) void backtrace_symbols_fd(const(void*)* buffer, int size, int fd) +{ + import core.sys.posix.unistd : write; + import core.stdc.stdlib : alloca; + + if (size <= 0) return; + + Dl_info info; + foreach (i, addr; buffer[0 .. size]) + { + if (dladdr(addr, &info) == 0) + (cast(ubyte*)&info)[0 .. info.sizeof] = 0; + fixupDLInfo(addr, info); + + enum maxAlloca = 1024; + enum min = (size_t a, size_t b) => a <= b ? a : b; + immutable len = min(formatStackFrame(null, 0, addr, info), maxAlloca); + assert(len > 0); + + auto p = cast(char*)alloca(len); + if (p is null) return; + + formatStackFrame(p, len, addr, info) >= len || assert(0); + p[len - 1] = '\n'; + write(fd, p, len); + } +} + + +private void fixupDLInfo(const(void)* addr, ref Dl_info info) +{ + if (info.dli_fname is null) info.dli_fname = "???"; + if (info.dli_fbase is null) info.dli_fbase = null; + if (info.dli_sname is null) info.dli_sname = "???"; + if (info.dli_saddr is null) info.dli_saddr = cast(void*)addr; +} + + +private size_t formatStackFrame(char* p, size_t plen, const(void)* addr, const ref Dl_info info) +{ + import core.stdc.stdio : snprintf; + + immutable off = addr - info.dli_saddr; + immutable len = snprintf(p, plen, "%p <%s+%zd> at %s", + addr, info.dli_sname, off, info.dli_fname); + assert(len > 0); + return cast(size_t)len + 1; // + '\0' +} diff --git a/src/core/sys/dragonflybsd/netinet/in_.d b/src/core/sys/dragonflybsd/netinet/in_.d new file mode 100644 index 0000000000..36f52f151d --- /dev/null +++ b/src/core/sys/dragonflybsd/netinet/in_.d @@ -0,0 +1,551 @@ +/** + * D header file for DragonFlyBSD's extensions to POSIX's netinet/in.h. + * + * Copyright: Copyright 2017 - + * License: $(WEB www.boost.org/LICENSE_1_0.txt, Boost License 1.0). + * Authors: Jonathan M Davis, Diederik de Groot(port:DragonFlyBSD) + * Copied: From core/sys/freebsd/sys + */ +module core.sys.dragonflybsd.netinet.in_; + +version(DragonFlyBSD): + +import core.sys.dragonflybsd.sys.cdefs; + +public import core.sys.posix.netinet.in_; + +extern(C) nothrow @nogc @system: + +enum IPPROTO_HOPOPTS = 0; + +enum IPPROTO_IPV4 = 4; +enum IPPROTO_IPIP = IPPROTO_IPV4; +enum IPPROTO_ST = 7; +enum IPPROTO_EGP = 8; +enum IPPROTO_PIGP = 9; +enum IPPROTO_RCCMON = 10; +enum IPPROTO_NVPII = 11; + +enum IPPROTO_ARGUS = 13; +enum IPPROTO_EMCON = 14; +enum IPPROTO_XNET = 15; +enum IPPROTO_CHAOS = 16; +enum IPPROTO_MUX = 18; +enum IPPROTO_MEAS = 19; +enum IPPROTO_HMP = 20; +enum IPPROTO_PRM = 21; + +enum IPPROTO_TRUNK1 = 23; +enum IPPROTO_TRUNK2 = 24; +enum IPPROTO_LEAF1 = 25; +enum IPPROTO_LEAF2 = 26; +enum IPPROTO_RDP = 27; +enum IPPROTO_IRTP = 28; +enum IPPROTO_TP = 29; +enum IPPROTO_BLT = 30; +enum IPPROTO_NSP = 31; +enum IPPROTO_INP = 32; +enum IPPROTO_SEP = 33; +enum IPPROTO_3PC = 34; +enum IPPROTO_IDPR = 35; +enum IPPROTO_XTP = 36; +enum IPPROTO_DDP = 37; +enum IPPROTO_CMTP = 38; +enum IPPROTO_TPXX = 39; +enum IPPROTO_IL = 40; +enum IPPROTO_SDRP = 42; +enum IPPROTO_ROUTING = 43; +enum IPPROTO_FRAGMENT = 44; +enum IPPROTO_IDRP = 45; +enum IPPROTO_RSVP = 46; +enum IPPROTO_GRE = 47; +enum IPPROTO_MHRP = 48; +enum IPPROTO_BHA = 49; +enum IPPROTO_ESP = 50; +enum IPPROTO_AH = 51; +enum IPPROTO_INLSP = 52; +enum IPPROTO_SWIPE = 53; +enum IPPROTO_NHRP = 54; +enum IPPROTO_MOBILE = 55; +enum IPPROTO_TLSP = 56; +enum IPPROTO_SKIP = 57; +enum IPPROTO_ICMPV6 = 58; +enum IPPROTO_NONE = 59; +enum IPPROTO_DSTOPTS = 60; +enum IPPROTO_AHIP = 61; +enum IPPROTO_CFTP = 62; +enum IPPROTO_HELLO = 63; +enum IPPROTO_SATEXPAK = 64; +enum IPPROTO_KRYPTOLAN = 65; +enum IPPROTO_RVD = 66; +enum IPPROTO_IPPC = 67; +enum IPPROTO_ADFS = 68; +enum IPPROTO_SATMON = 69; +enum IPPROTO_VISA = 70; +enum IPPROTO_IPCV = 71; +enum IPPROTO_CPNX = 72; +enum IPPROTO_CPHB = 73; +enum IPPROTO_WSN = 74; +enum IPPROTO_PVP = 75; +enum IPPROTO_BRSATMON = 76; + +enum IPPROTO_WBMON = 78; +enum IPPROTO_WBEXPAK = 79; +enum IPPROTO_EON = 80; +enum IPPROTO_VMTP = 81; +enum IPPROTO_SVMTP = 82; +enum IPPROTO_VINES = 83; +enum IPPROTO_TTP = 84; +enum IPPROTO_IGP = 85; +enum IPPROTO_DGP = 86; +enum IPPROTO_TCF = 87; +enum IPPROTO_IGRP = 88; +enum IPPROTO_OSPFIGP = 89; +enum IPPROTO_SRPC = 90; +enum IPPROTO_LARP = 91; +enum IPPROTO_MTP = 92; +enum IPPROTO_AX25 = 93; +enum IPPROTO_IPEIP = 94; +enum IPPROTO_MICP = 95; +enum IPPROTO_SCCSP = 96; +enum IPPROTO_ETHERIP = 97; +enum IPPROTO_ENCAP = 98; +enum IPPROTO_APES = 99; +enum IPPROTO_GMTP = 100; +enum IPPROTO_IPCOMP = 108; +enum IPPROTO_SCTP = 132; +enum IPPROTO_MH = 135; +enum IPPROTO_UDPLITE = 136; +enum IPPROTO_HIP = 139; +enum IPPROTO_SHIM6 = 140; + +enum IPPROTO_PIM = 103; +enum IPPROTO_CARP = 112; +enum IPPROTO_PGM = 113; +enum IPPROTO_MPLS = 137; +enum IPPROTO_PFSYNC = 240; +enum IPPROTO_RESERVED_253 = 253; +enum IPPROTO_RESERVED_254 = 254; + +enum IPPROTO_DONE = 257; + +enum IPPORT_RESERVED = 1024; + +enum IPPORT_EPHEMERALFIRST = 10000; +enum IPPORT_EPHEMERALLAST = 65535; + +enum IPPORT_HIFIRSTAUTO = 49152; +enum IPPORT_HILASTAUTO = 65535; + +enum IPPORT_RESERVEDSTART = 600; + +enum IPPORT_MAX = 65535; + +extern(D) bool IN_CLASSA(in_addr_t i) pure @safe { return (i & 0x80000000) == 0; } +enum IN_CLASSA_NET = 0xff000000; +enum IN_CLASSA_NSHIFT = 24; +enum IN_CLASSA_HOST = 0x00ffffff; +enum IN_CLASSA_MAX = 128; + +extern(D) bool IN_CLASSB(in_addr_t i) pure @safe { return (i & 0xc0000000) == 0x80000000; } +enum IN_CLASSB_NET = 0xffff0000; +enum IN_CLASSB_NSHIFT = 16; +enum IN_CLASSB_HOST = 0x0000ffff; +enum IN_CLASSB_MAX = 65536; + +extern(D) bool IN_CLASSC(in_addr_t i) pure @safe { return (i & 0xe0000000) == 0xc0000000; } +enum IN_CLASSC_NET = 0xffffff00; +enum IN_CLASSC_NSHIFT = 8; +enum IN_CLASSC_HOST = 0x000000ff; + +extern(D) bool IN_CLASSD(in_addr_t i) pure @safe { return (i & 0xf0000000) == 0xe0000000; } +enum IN_CLASSD_NET = 0xf0000000; +enum IN_CLASSD_NSHIFT = 28; +enum IN_CLASSD_HOST = 0x0fffffff; +extern(D) bool IN_MULTICAST(in_addr_t i) { return IN_CLASSD(i); } + +// The fact that these are identical looks suspicious (they're not quite +// identical on Linux). However, this _is_ how they're defined in DragonFlyBSD +// and on OS X. So, while it _might_ be a bug, if it is, it's an upstream +// one, and we're compatible with it. +extern(D) bool IN_EXPERIMENTAL(in_addr_t i) pure @safe { return (i & 0xf0000000) == 0xf0000000; } +extern(D) bool IN_BADCLASS(in_addr_t i) pure @safe { return (i & 0xf0000000) == 0xf0000000; } + +extern(D) bool IN_LINKLOCAL(in_addr_t i) pure @safe { return (i & 0xffff0000) == 0xa9fe0000; } +extern(D) bool IN_LOOPBACK(in_addr_t i) pure @safe { return (i & 0xff000000) == 0x7f000000; } +extern(D) bool IN_ZERONET(in_addr_t i) pure @safe { return (i & 0xff000000) == 0; } + +extern(D) bool IN_PRIVATE(in_addr_t i) pure @safe +{ + return (i & 0xff000000) == 0x0a000000 || + (i & 0xfff00000) == 0xac100000 || + (i & 0xffff0000) == 0xc0a80000; +} + +extern(D) bool IN_LOCAL_GROUP(in_addr_t i) pure @safe { return (i & 0xffffff00) == 0xe0000000; } + +extern(D) bool IN_ANY_LOCAL(in_addr_t i) pure @safe { return IN_LINKLOCAL(i) || IN_LOCAL_GROUP(i); } + +enum INADDR_UNSPEC_GROUP = 0xe0000000; +enum INADDR_ALLHOSTS_GROUP = 0xe0000001; +enum INADDR_ALLRTRS_GROUP = 0xe0000002; +enum INADDR_ALLRPTS_GROUP = 0xe0000016; +enum INADDR_CARP_GROUP = 0xe0000012; +enum INADDR_PFSYNC_GROUP = 0xe00000f0; +enum INADDR_ALLMDNS_GROUP = 0xe00000fb; +enum INADDR_MAX_LOCAL_GROUP = 0xe00000ff; + +enum IN_LOOPBACKNET = 127; + +enum IN_RFC3021_MASK = 0xfffffffe; + +enum IP_OPTIONS = 1; +enum IP_HDRINCL = 2; +enum IP_TOS = 3; +enum IP_TTL = 4; +enum IP_RECVOPTS = 5; +enum IP_RECVRETOPTS = 6; +enum IP_RECVDSTADDR = 7; +enum IP_SENDSRCADDR = IP_RECVDSTADDR; +enum IP_RETOPTS = 8; +enum IP_MULTICAST_IF = 9; + +enum IP_MULTICAST_TTL = 10; +enum IP_MULTICAST_LOOP = 11; +enum IP_ADD_MEMBERSHIP = 12; +enum IP_DROP_MEMBERSHIP = 13; +enum IP_MULTICAST_VIF = 14; +enum IP_RSVP_ON = 15; +enum IP_RSVP_OFF = 16; +enum IP_RSVP_VIF_ON = 17; +enum IP_RSVP_VIF_OFF = 18; +enum IP_PORTRANGE = 19; +enum IP_RECVIF = 20; + +enum IP_IPSEC_POLICY = 21; + +enum IP_ONESBCAST = 23; +enum IP_BINDANY = 24; +enum IP_BINDMULTI = 25; +enum IP_RSS_LISTEN_BUCKET = 26; +enum IP_ORIGDSTADDR = 27; +enum IP_RECVORIGDSTADDR = IP_ORIGDSTADDR; + +enum IP_FW3 = 48; +enum IP_DUMMYNET3 = 49; + +enum IP_ADD_SOURCE_MEMBERSHIP = 70; +enum IP_DROP_SOURCE_MEMBERSHIP = 71; +enum IP_BLOCK_SOURCE = 72; +enum IP_UNBLOCK_SOURCE = 73; + +enum MCAST_JOIN_GROUP = 80; +enum MCAST_LEAVE_GROUP = 81; +enum MCAST_JOIN_SOURCE_GROUP = 82; +enum MCAST_LEAVE_SOURCE_GROUP = 83; +enum MCAST_BLOCK_SOURCE = 84; +enum MCAST_UNBLOCK_SOURCE = 85; + +enum IP_FLOWID = 90; +enum IP_FLOWTYPE = 91; +enum IP_RSSBUCKETID = 92; +enum IP_RECVFLOWID = 93; +enum IP_RECVRSSBUCKETID = 94; + +enum IP_DEFAULT_MULTICAST_TTL = 1; +enum IP_DEFAULT_MULTICAST_LOOP = 1; + +enum IP_MIN_MEMBERSHIPS = 31; +enum IP_MAX_MEMBERSHIPS = 4095; + +enum IP_MAX_GROUP_SRC_FILTER = 512; +enum IP_MAX_SOCK_SRC_FILTER = 128; + +struct ip_mreq +{ + in_addr imr_multiaddr; + in_addr imr_interface; +}; + +struct ip_mreqn +{ + in_addr imr_multiaddr; + in_addr imr_address; + int imr_ifindex; +}; + +struct ip_mreq_source +{ + in_addr imr_multiaddr; + in_addr imr_sourceaddr; + in_addr imr_interface; +}; + +struct group_req +{ + uint gr_interface; + sockaddr_storage gr_group; +}; + +struct group_source_req +{ + uint gsr_interface; + sockaddr_storage gsr_group; + sockaddr_storage gsr_source; +}; + +int setipv4sourcefilter(int, in_addr, in_addr, uint, uint, in_addr*); +int getipv4sourcefilter(int, in_addr, in_addr, uint*, uint*, in_addr*); +int setsourcefilter(int, uint, sockaddr*, socklen_t, uint, uint, sockaddr_storage*); +int getsourcefilter(int, uint, sockaddr*, socklen_t, uint*, uint*, sockaddr_storage*); + +enum MCAST_UNDEFINED = 0; +enum MCAST_INCLUDE = 1; +enum MCAST_EXCLUDE = 2; + +enum IP_PORTRANGE_DEFAULT = 0; +enum IP_PORTRANGE_HIGH = 1; +enum IP_PORTRANGE_LOW = 2; + +enum IPCTL_FORWARDING = 1; +enum IPCTL_SENDREDIRECTS = 2; +enum IPCTL_DEFTTL = 3; +enum IPCTL_DEFMTU = 4; +enum IPCTL_SOURCEROUTE = 8; +enum IPCTL_DIRECTEDBROADCAST = 9; +enum IPCTL_INTRQMAXLEN = 10; +enum IPCTL_INTRQDROPS = 11; +enum IPCTL_STATS = 12; +enum IPCTL_ACCEPTSOURCEROUTE = 13; +enum IPCTL_FASTFORWARDING = 14; +enum IPCTL_GIF_TTL = 16; +enum IPCTL_INTRDQMAXLEN = 17; +enum IPCTL_INTRDQDROPS = 18; + +// ============================================================================= +// What follows is from netinet6/in6.h, but since netinet6/in6.h specifically +// says that it should only be #included by #including netinet/in.h, it makes +// more sense to put them in here so that the way they're imported corresponds +// with the correct way of #including them in C/C++. +// ============================================================================= + +// The #if was around the #include of in6.h at the end of in.h. +enum IPV6PORT_RESERVED = 1024; +enum IPV6PORT_ANONMIN = 49152; +enum IPV6PORT_ANONMAX = 65535; +enum IPV6PORT_RESERVEDMIN = 600; +enum IPV6PORT_RESERVEDMAX = IPV6PORT_RESERVED - 1; + +enum IN6ADDR_ANY_INIT = in6_addr.init; +enum IN6ADDR_LOOPBACK_INIT = in6_addr([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01]); +enum IN6ADDR_NODELOCAL_ALLNODES_INIT = in6_addr([0xff, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01]); +enum IN6ADDR_INTFACELOCAL_ALLNODES_INIT = in6_addr([0xff, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01]); +enum IN6ADDR_LINKLOCAL_ALLNODES_INIT = in6_addr([0xff, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01]); +enum IN6ADDR_LINKLOCAL_ALLROUTERS_INIT = in6_addr([0xff, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02]); +enum IN6ADDR_LINKLOCAL_ALLV2ROUTERS_INIT = in6_addr([0xff, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16]); + +__gshared const in6_addr in6addr_nodelocal_allnodes; +__gshared const in6_addr in6addr_linklocal_allnodes; +__gshared const in6_addr in6addr_linklocal_allrouters; +__gshared const in6_addr in6addr_linklocal_allv2routers; + +extern(D) bool IN6_ARE_ADDR_EQUAL(in6_addr* a, in6_addr* b) pure @safe { return *a == *b; } + +enum __IPV6_ADDR_SCOPE_NODELOCAL = 0x01; +enum __IPV6_ADDR_SCOPE_INTFACELOCAL = 0x01; +enum __IPV6_ADDR_SCOPE_LINKLOCAL = 0x02; +enum __IPV6_ADDR_SCOPE_SITELOCAL = 0x05; +enum __IPV6_ADDR_SCOPE_GLOBAL = 0x0e; + +// TODO - requires declarations from elsewhere that we don't currently have bindings for. +/+ + struct route_in6 + { + rtentry* ro_rt; + llentry* ro_lle; + char* ro_prepend; + ushort ro_plen; + ushort ro_flags; + ushort ro_mtu; + ushort spare; + sockaddr_in6 ro_dst; + }; ++/ + +enum IPV6_SOCKOPT_RESERVED1 = 3; +enum IPV6_PORTRANGE = 14; +enum ICMP6_FILTER = 18; + +enum IPV6_CHECKSUM = 26; + +enum IPV6_IPSEC_POLICY = 28; + +enum IPV6_FW_ADD = 30; +enum IPV6_FW_DEL = 31; +enum IPV6_FW_FLUSH = 32; +enum IPV6_FW_ZERO = 33; +enum IPV6_FW_GET = 34; + +enum IPV6_RTHDRDSTOPTS = 35; + +enum IPV6_RECVPKTINFO = 36; +enum IPV6_RECVHOPLIMIT = 37; +enum IPV6_RECVRTHDR = 38; +enum IPV6_RECVHOPOPTS = 39; +enum IPV6_RECVDSTOPTS = 40; + +enum IPV6_USE_MIN_MTU = 42; +enum IPV6_RECVPATHMTU = 43; + +enum IPV6_PATHMTU = 44; + +enum IPV6_PKTINFO = 46; +enum IPV6_HOPLIMIT = 47; +enum IPV6_NEXTHOP = 48; +enum IPV6_HOPOPTS = 49; +enum IPV6_DSTOPTS = 50; +enum IPV6_RTHDR = 51; + +enum IPV6_RECVTCLASS = 57; + +enum IPV6_AUTOFLOWLABEL = 59; + +enum IPV6_TCLASS = 61; +enum IPV6_DONTFRAG = 62; + +enum IPV6_PREFER_TEMPADDR = 63; + +enum IPV6_BINDANY = 64; + +enum IPV6_BINDMULTI = 65; +enum IPV6_RSS_LISTEN_BUCKET = 66; +enum IPV6_FLOWID = 67; +enum IPV6_FLOWTYPE = 68; +enum IPV6_RSSBUCKETID = 69; +enum IPV6_RECVFLOWID = 70; +enum IPV6_RECVRSSBUCKETID = 71; + +enum IPV6_ORIGDSTADDR = 72; +enum IPV6_RECVORIGDSTADDR = IPV6_ORIGDSTADDR; + +enum IPV6_RTHDR_LOOSE = 0; +enum IPV6_RTHDR_STRICT = 1; +enum IPV6_RTHDR_TYPE_0 = 0; + +enum IPV6_DEFAULT_MULTICAST_HOPS = 1; +enum IPV6_DEFAULT_MULTICAST_LOOP = 1; + +enum IPV6_MIN_MEMBERSHIPS = 31; +enum IPV6_MAX_MEMBERSHIPS = 4095; + +enum IPV6_MAX_GROUP_SRC_FILTER = 512; +enum IPV6_MAX_SOCK_SRC_FILTER = 128; + +struct in6_pktinfo +{ + in6_addr ipi6_addr; + uint ipi6_ifindex; +}; + +struct ip6_mtuinfo +{ + sockaddr_in6 ip6m_addr; + uint ip6m_mtu; +}; + +enum IPV6_PORTRANGE_DEFAULT = 0; +enum IPV6_PORTRANGE_HIGH = 1; +enum IPV6_PORTRANGE_LOW = 2; + +enum IPV6PROTO_MAXID = IPPROTO_PIM + 1; + +enum IPV6CTL_FORWARDING = 1; +enum IPV6CTL_SENDREDIRECTS = 2; +enum IPV6CTL_DEFHLIM = 3; +enum IPV6CTL_DEFMTU = 4; +enum IPV6CTL_FORWSRCRT = 5; +enum IPV6CTL_STATS = 6; +enum IPV6CTL_MRTSTATS = 7; +enum IPV6CTL_MRTPROTO = 8; +enum IPV6CTL_MAXFRAGPACKETS = 9; +enum IPV6CTL_SOURCECHECK = 10; +enum IPV6CTL_SOURCECHECK_LOGINT = 11; +enum IPV6CTL_ACCEPT_RTADV = 12; + +enum IPV6CTL_LOG_INTERVAL = 14; +enum IPV6CTL_HDRNESTLIMIT = 15; +enum IPV6CTL_DAD_COUNT = 16; +enum IPV6CTL_AUTO_FLOWLABEL = 17; +enum IPV6CTL_DEFMCASTHLIM = 18; +enum IPV6CTL_GIF_HLIM = 19; +enum IPV6CTL_KAME_VERSION = 20; +enum IPV6CTL_USE_DEPRECATED = 21; +enum IPV6CTL_RR_PRUNE = 22; +enum IPV6CTL_V6ONLY = 24; + +enum IPV6CTL_USETEMPADDR = 32; +enum IPV6CTL_TEMPPLTIME = 33; +enum IPV6CTL_TEMPVLTIME = 34; +enum IPV6CTL_AUTO_LINKLOCAL = 35; +enum IPV6CTL_RIP6STATS = 36; +enum IPV6CTL_PREFER_TEMPADDR = 37; +enum IPV6CTL_ADDRCTLPOLICY = 38; +enum IPV6CTL_USE_DEFAULTZONE = 39; + +enum IPV6CTL_MAXFRAGS = 41; +enum IPV6CTL_MCAST_PMTU = 44; + +enum IPV6CTL_STEALTH = 45; + +enum ICMPV6CTL_ND6_ONLINKNSRFC4861 = 47; +enum IPV6CTL_NO_RADR = 48; +enum IPV6CTL_NORBIT_RAIF = 49; + +enum IPV6CTL_RFC6204W3 = 50; + +enum IPV6CTL_INTRQMAXLEN = 51; +enum IPV6CTL_INTRDQMAXLEN = 52; + +enum IPV6CTL_MAXID = 53; + +// TODO - require declarations from elsewhere that we don't currently have bindings for. +/+ +enum M_FASTFWD_OURS = M_PROTO1; +enum M_IP6_NEXTHOP = M_PROTO2; +enum M_IP_NEXTHOP = M_PROTO2; +enum M_SKIP_FIREWALL = M_PROTO3; +enum M_AUTHIPHDR = M_PROTO4; +enum M_DECRYPTED = M_PROTO5; +enum M_LOOP = M_PROTO6; +enum M_AUTHIPDGM = M_PROTO7; +enum M_RTALERT_MLD = M_PROTO8; ++/ + +size_t inet6_rthdr_space(int, int) @trusted; +cmsghdr* inet6_rthdr_init(void*, int); +int inet6_rthdr_add(cmsghdr*, const in6_addr*, uint); +int inet6_rthdr_lasthop(cmsghdr*, uint); +int inet6_rthdr_segments(const cmsghdr*); +in6_addr* inet6_rthdr_getaddr(cmsghdr*, int); +int inet6_rthdr_getflags(const cmsghdr*, int); + +int inet6_opt_init(void*, socklen_t); +int inet6_opt_append(void*, socklen_t, int, ubyte, socklen_t, ubyte, void**); +int inet6_opt_finish(void*, socklen_t, int); +int inet6_opt_set_val(void*, int, void*, socklen_t); + +int inet6_opt_next(void*, socklen_t, int, ubyte*, socklen_t*, void**); +int inet6_opt_find(void*, socklen_t, int, ubyte, socklen_t*, void**); +int inet6_opt_get_val(void*, int, void*, socklen_t); +socklen_t inet6_rth_space(int, int) @trusted; +void* inet6_rth_init(void*, socklen_t, int, int); +int inet6_rth_add(void*, const in6_addr*); +int inet6_rth_reverse(const void*, void*); +int inet6_rth_segments(const void*); +in6_addr* inet6_rth_getaddr(const void*, int); diff --git a/src/core/sys/dragonflybsd/pthread_np.d b/src/core/sys/dragonflybsd/pthread_np.d new file mode 100644 index 0000000000..15fee1c715 --- /dev/null +++ b/src/core/sys/dragonflybsd/pthread_np.d @@ -0,0 +1,45 @@ +/** + * D header file for DragonFlyBSD + * + * Authors: Martin Nowak,Diederik de Groot(port:DragonFlyBSD) + * Copied: From core/sys/freebsd/sys + */ +module core.sys.dragonflybsd.pthread; + +version (DragonFlyBSD): + +extern (C) nothrow @nogc @system: + +public import core.sys.posix.sys.types; +// TODO: add full core.sys.dragonflybsd.sys.cpuset; +public import core.sys.dragonflybsd.sys._cpuset; +public import core.sys.posix.time; + +alias pthread_switch_routine_t = void function(pthread_t, pthread_t); + +int pthread_attr_get_np(pthread_t, pthread_attr_t *); +int pthread_attr_getaffinity_np(const(pthread_attr_t)*, size_t, cpuset_t *); +int pthread_attr_setaffinity_np(pthread_attr_t *, size_t, const(cpuset_t)*); +int pthread_attr_setcreatesuspend_np(pthread_attr_t *); +int pthread_getaffinity_np(pthread_t, size_t, cpuset_t *); +int pthread_main_np(); +int pthread_multi_np(); +int pthread_mutexattr_getkind_np(pthread_mutexattr_t); +int pthread_mutexattr_setkind_np(pthread_mutexattr_t *, int); +void pthread_resume_all_np(); +int pthread_resume_np(pthread_t); +void pthread_set_name_np(pthread_t, const(char)*); +int pthread_setaffinity_np(pthread_t, size_t, const(cpuset_t)*); +int pthread_single_np(); +void pthread_suspend_all_np(); +int pthread_suspend_np(pthread_t); +int pthread_switch_add_np(pthread_switch_routine_t); +int pthread_switch_delete_np(pthread_switch_routine_t); +int pthread_timedjoin_np(pthread_t, void **, const(timespec)*); + +//int pthread_getthreadid_np(); +//int pthread_mutex_getspinloops_np(pthread_mutex_t *mutex, int *count); +//int pthread_mutex_setspinloops_np(pthread_mutex_t *mutex, int count); +//int pthread_mutex_getyieldloops_np(pthread_mutex_t *mutex, int *count); +//int pthread_mutex_setyieldloops_np(pthread_mutex_t *mutex, int count); +//int pthread_mutex_isowned_np(pthread_mutex_t *mutex); diff --git a/src/core/sys/dragonflybsd/sys/_bitset.d b/src/core/sys/dragonflybsd/sys/_bitset.d new file mode 100644 index 0000000000..24f9d9c1fd --- /dev/null +++ b/src/core/sys/dragonflybsd/sys/_bitset.d @@ -0,0 +1,46 @@ +/** + * D header file for DragonFlyBSD. + * + * Authors: Martin Nowak, Diederik de Groot(port:DragonFlyBSD) + * Copied: From core/sys/freebsd/sys + */ +module core.sys.dragonflybsd.sys._bitset; + +version (DragonFlyBSD): +extern (C) pure nothrow @nogc @system: + +import core.stdc.config : c_long; + +enum NBBY = 8; // number of bits per byte + +enum _BITSET_BITS = c_long.sizeof * NBBY; + +enum __bitset_words(size_t s) = (s + _BITSET_BITS - 1) / _BITSET_BITS; + +c_long __bitset_mask(size_t s)(size_t n) +{ + static if (__bitset_words!s == 1) + return (cast(c_long)1) << n; + else + return (cast(c_long)1) << n % _BITSET_BITS; +} + +size_t __bitset_word(size_t s)(size_t n) +{ + static if (__bitset_words!s == 1) + return 0; + else + return n / _BITSET_BITS; +} + +struct BITSET_DEFINE(size_t s) +{ + c_long[__bitset_words!s] __bits; +} + +// no idea how to translate those +//#define BITSET_T_INITIALIZER(x) \ +// { .__bits = { x } } +// +//#define BITSET_FSET(n) \ +// [ 0 ... ((n) - 1) ] = (-1L) diff --git a/src/core/sys/dragonflybsd/sys/_cpuset.d b/src/core/sys/dragonflybsd/sys/_cpuset.d new file mode 100644 index 0000000000..d975d10641 --- /dev/null +++ b/src/core/sys/dragonflybsd/sys/_cpuset.d @@ -0,0 +1,29 @@ +/** + * D header file for DragonFlyBSD. + * + * Authors: Martin Nowak, Diederik de Groot(port:DragonFlyBSD) + * Copied: From core/sys/freebsd/sys + */ +module core.sys.dragonflybsd.sys._cpuset; + +version (DragonFlyBSD): + +public import core.sys.dragonflybsd.sys._bitset; + +static if (is(typeof(_KERNEL))) + alias CPU_SETSIZE = MAXCPU; + +enum CPU_MAXSIZE = 256; + +static if (!is(typeof(CPU_SETSIZE))) + alias CPU_SETSIZE = CPU_MAXSIZE; + +enum _NCPUBITS = _BITSET_BITS; +enum _NCPUWORDS = __bitset_words!CPU_SETSIZE; + +alias _cpuset = BITSET_DEFINE!(CPU_SETSIZE); +alias cpuset_t = _cpuset; + +// no idea how to translate those +//#define CPUSET_FSET BITSET_FSET(_NCPUWORDS) +//#define CPUSET_T_INITIALIZER BITSET_T_INITIALIZER diff --git a/src/core/sys/dragonflybsd/sys/cdefs.d b/src/core/sys/dragonflybsd/sys/cdefs.d new file mode 100644 index 0000000000..ede6b6425d --- /dev/null +++ b/src/core/sys/dragonflybsd/sys/cdefs.d @@ -0,0 +1,16 @@ +/** + * D header file for DragonFlyBSD + * + * Authors: Martin Nowak,Diederik de Groot(port:DragonFlyBSD) + * Copied: From core/sys/freebsd/sys + */ +module core.sys.dragonflybsd.sys.cdefs; + +version (DragonFlyBSD): + +public import core.sys.posix.config; + +enum __POSIX_VISIBLE = 200112; +enum __XSI_VISIBLE = 700; +enum __BSD_VISIBLE = true; +enum __ISO_C_VISIBLE = 1999; diff --git a/src/core/sys/dragonflybsd/sys/elf.d b/src/core/sys/dragonflybsd/sys/elf.d new file mode 100644 index 0000000000..ef032014da --- /dev/null +++ b/src/core/sys/dragonflybsd/sys/elf.d @@ -0,0 +1,12 @@ +/** + * D header file for DragonFlyBSD. + * + * Authors: Diederik de Groot(port:DragonFlyBSD) + * Copied: From core/sys/freebsd/sys + */ +module core.sys.dragonflybsd.sys.elf; + +version (DragonFlyBSD): + +public import core.sys.dragonflybsd.sys.elf32; +public import core.sys.dragonflybsd.sys.elf64; diff --git a/src/core/sys/dragonflybsd/sys/elf32.d b/src/core/sys/dragonflybsd/sys/elf32.d new file mode 100644 index 0000000000..92d4a46217 --- /dev/null +++ b/src/core/sys/dragonflybsd/sys/elf32.d @@ -0,0 +1,187 @@ +/** + * D header file for DragonFlyBSD. + * + * Authors: Diederik de Groot(port:DragonFlyBSD) + * Copied: From core/sys/freebsd/sys + */ +module core.sys.dragonflybsd.sys.elf32; + +version (DragonFlyBSD): + +extern (C): + +import core.stdc.stdint; +public import core.sys.dragonflybsd.sys.elf_common; + +alias uint16_t Elf32_Half; +alias uint32_t Elf32_Word; +alias int32_t Elf32_Sword; +alias uint64_t Elf32_Lword; +alias uint32_t Elf32_Addr; +alias uint32_t Elf32_Off; +alias Elf32_Word Elf32_Hashelt; +alias Elf32_Word Elf32_Size; +alias Elf32_Sword Elf32_Ssize; + +struct Elf32_Ehdr +{ + char[EI_NIDENT] e_ident; + 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 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 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 Elf32_Dyn +{ + Elf32_Sword d_tag; + union _d_un + { + Elf32_Word d_val; + Elf32_Addr d_ptr; + } _d_un d_un; +} + +struct Elf32_Rel +{ + Elf32_Addr r_offset; + Elf32_Word r_info; +} + +struct Elf32_Rela +{ + Elf32_Addr r_offset; + Elf32_Word r_info; + Elf32_Sword r_addend; +} + +extern (D) pure @safe +{ + 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); } +} + +alias Elf_Note Elf32_Nhdr; + +struct Elf32_Move +{ + Elf32_Lword m_value; + Elf32_Word m_info; + Elf32_Word m_poffset; + Elf32_Half m_repeat; + Elf32_Half m_stride; +} + +extern (D) pure +{ + auto ELF32_M_SYM(I)(I info) @safe { 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(ubye)size; } +} + +struct Elf32_Cap +{ + Elf32_Word c_tag; + union _c_un + { + Elf32_Word c_val; + Elf32_Addr c_ptr; + } _c_un c_un; +} + +struct Elf32_Sym +{ + Elf32_Word st_name; + Elf32_Addr st_value; + Elf32_Word st_size; + ubyte st_info; + ubyte st_other; + Elf32_Half st_shndx; +} + +extern (D) pure +{ + auto ELF32_ST_BIND(T)(T val) { return cast(ubyte)val >> 4; } + auto ELF32_ST_TYPE(T)(T val) @safe { return val & 0xf; } + auto ELF32_ST_INFO(B, T)(B bind, T type) @safe { return (bind << 4) + (type & 0xf); } + auto ELF32_ST_VISIBILITY(O)(O o) @safe { return o & 0x03; } +} + +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 Elf32_Verdaux +{ + Elf32_Word vda_name; + Elf32_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 Elf32_Vernaux +{ + Elf32_Word vna_hash; + Elf32_Half vna_flags; + Elf32_Half vna_other; + Elf32_Word vna_name; + Elf32_Word vna_next; +} + +alias Elf32_Half Elf32_Versym; + +struct Elf32_Syminfo +{ + Elf32_Half si_boundto; + Elf32_Half si_flags; +} diff --git a/src/core/sys/dragonflybsd/sys/elf64.d b/src/core/sys/dragonflybsd/sys/elf64.d new file mode 100644 index 0000000000..38db4cd8e2 --- /dev/null +++ b/src/core/sys/dragonflybsd/sys/elf64.d @@ -0,0 +1,193 @@ +/** + * D header file for DragonFlyBSD. + * + * Authors: Diederik de Groot(port:DragonFlyBSD) + * Copied: From core/sys/freebsd/sys + */ +module core.sys.dragonflybsd.sys.elf64; + +version (DragonFlyBSD): + +extern (C): + +import core.stdc.stdint; +public import core.sys.dragonflybsd.sys.elf_common; + +alias uint16_t Elf64_Half; +alias uint32_t Elf64_Word; +alias int32_t Elf64_Sword; +alias uint64_t Elf64_Lword; +alias uint64_t Elf64_Xword; +alias int64_t Elf64_Sxword; +alias uint64_t Elf64_Addr; +alias uint64_t Elf64_Off; +alias Elf64_Word Elf64_Hashelt; +alias Elf64_Xword Elf64_Size; +alias Elf64_Sxword Elf64_Ssize; + +struct Elf64_Ehdr +{ + char[EI_NIDENT] e_ident; + 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; +} + +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; +} + +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; +} + +struct Elf64_Dyn +{ + Elf64_Sxword d_tag; + union _d_un + { + Elf64_Xword d_val; + Elf64_Addr d_ptr; + } _d_un d_un; +} + +struct Elf64_Rel +{ + Elf64_Addr r_offset; + Elf64_Xword r_info; +} + +struct Elf64_Rela +{ + Elf64_Addr r_offset; + Elf64_Xword r_info; + Elf64_Sxword r_addend; +} + +extern (D) pure +{ + auto ELF64_R_SYM(I)(I i) @safe { return i >> 32; } + auto ELF64_R_TYPE(I)(I i) @safe { return i & 0xffffffff; } + auto ELF64_R_INFO(S, T)(S sym, T type) @safe { return (sym << 32) + (type & 0xffffffff); } + + auto ELF64_R_TYPE_DATA(I)(I i) { return (cast(Elf64_Xword) i << 32) >> 40; } + auto ELF64_R_TYPE_ID(I)(I i) { return (cast(Elf64_Xword) i << 56 ) >> 56; } + auto ELF64_R_TYPE_INFO(D, T)(D d, T t) { return cast(Elf64_Xword) d << 8 + cast(Elf64_Xword) t; } +} + +alias Elf_Note Elf64_Nhdr; + +struct Elf64_Move +{ + Elf64_Lword m_value; + Elf64_Xword m_info; + Elf64_Xword m_poffset; + Elf64_Half m_repeat; + Elf64_Half m_stride; +} + +extern (D) pure +{ + auto ELF64_M_SYM(I)(I info) @safe { return info >> 8; } + auto ELF64_M_SIZE(I)(I info) { return cast(ubyte)info; } + auto ELF64_M_INFO(S, SZ)(S sym, SZ size) @safe { return (sym << 8) + cast(ubye)size; } +} + +struct Elf64_Cap +{ + Elf64_Xword c_tag; + union _c_un + { + Elf64_Xword c_val; + Elf64_Addr c_ptr; + } _c_un c_un; +} + +struct Elf64_Sym +{ + Elf64_Word st_name; + ubyte st_info; + ubyte st_other; + Elf64_Half st_shndx; + Elf64_Addr st_value; + Elf64_Xword st_size; +} + +extern (D) pure +{ + auto ELF64_ST_BIND(T)(T val) { return cast(ubyte)val >> 4; } + auto ELF64_ST_TYPE(T)(T val) @safe { return val & 0xf; } + auto ELF64_ST_INFO(B, T)(B bind, T type) @safe { return (bind << 4) + (type & 0xf); } + auto ELF64_ST_VISIBILITY(O)(O o) @safe { return o & 0x03; } +} + +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; +} + +struct Elf64_Verdaux +{ + Elf64_Word vda_name; + Elf64_Word vda_next; +} + +struct Elf64_Verneed +{ + Elf64_Half vn_version; + Elf64_Half vn_cnt; + Elf64_Word vn_file; + Elf64_Word vn_aux; + Elf64_Word vn_next; +} + +struct Elf64_Vernaux +{ + Elf64_Word vna_hash; + Elf64_Half vna_flags; + Elf64_Half vna_other; + Elf64_Word vna_name; + Elf64_Word vna_next; +} + +alias Elf64_Half Elf64_Versym; + +struct Elf64_Syminfo +{ + Elf64_Half si_boundto; + Elf64_Half si_flags; +} diff --git a/src/core/sys/dragonflybsd/sys/elf_common.d b/src/core/sys/dragonflybsd/sys/elf_common.d new file mode 100644 index 0000000000..d4ac93d186 --- /dev/null +++ b/src/core/sys/dragonflybsd/sys/elf_common.d @@ -0,0 +1,675 @@ +/** + * D header file for DragonFlyBSD. + * + * Authors: Diederik de Groot(port:DragonFlyBSD) + * Copied: From core/sys/freebsd/sys + */ +module core.sys.dragonflybsd.sys.elf_common; + +version (DragonFlyBSD): + +extern (C): + +import core.stdc.stdint; + +struct Elf_Note +{ + uint32_t n_namesz; + uint32_t n_descsz; + uint32_t n_type; +} + +struct Elf_GNU_Hash_Header +{ + uint32_t gh_nbuckets; + uint32_t gh_symndx; + uint32_t gh_maskwords; + uint32_t gh_shift2; +} + +enum EI_MAG0 = 0; +enum EI_MAG1 = 1; +enum EI_MAG2 = 2; +enum EI_MAG3 = 3; +enum EI_CLASS = 4; +enum EI_DATA = 5; +enum EI_VERSION = 6; +enum EI_OSABI = 7; +enum EI_ABIVERSION = 8; +enum OLD_EI_BRAND = 8; +enum EI_PAD = 9; +enum EI_NIDENT = 16; + +enum ELFMAG0 = 0x7f; +enum ELFMAG1 = 'E'; +enum ELFMAG2 = 'L'; +enum ELFMAG3 = 'F'; +enum ELFMAG = "\177ELF"; +enum SELFMAG = 4; + +enum EV_NONE = 0; +enum EV_CURRENT = 1; + +enum ELFCLASSNONE = 0; +enum ELFCLASS32 = 1; +enum ELFCLASS64 = 2; + +enum ELFDATANONE = 0; +enum ELFDATA2LSB = 1; +enum ELFDATA2MSB = 2; + +enum ELFOSABI_NONE = 0; +enum ELFOSABI_SYSV = 0; +enum ELFOSABI_HPUX = 1; +enum ELFOSABI_NETBSD = 2; +enum ELFOSABI_LINUX = 3; +enum ELFOSABI_HURD = 4; +enum ELFOSABI_86OPEN = 5; +enum ELFOSABI_SOLARIS = 6; +enum ELFOSABI_AIX = 7; +enum ELFOSABI_MONTEREY = 7; +enum ELFOSABI_IRIX = 8; +enum ELFOSABI_FREEBSD = 9; +enum ELFOSABI_TRU64 = 10; +enum ELFOSABI_MODESTO = 11; +enum ELFOSABI_OPENBSD = 12; +enum ELFOSABI_OPENVMS = 13; +enum ELFOSABI_NSK = 14; +enum ELFOSABI_AROS = 15; +enum ELFOSABI_ARM = 97; +enum ELFOSABI_STANDALONE = 255; + +// just a pointer +enum ELFOSABI_DRAGONFLYBSD = ELFOSABI_NONE; + +extern (D) pure @safe +{ + auto IS_ELF(T)(T ehdr) { return ehdr.e_ident[EI_MAG0] == ELFMAG0 && + ehdr.e_ident[EI_MAG1] == ELFMAG1 && + ehdr.e_ident[EI_MAG2] == ELFMAG2 && + ehdr.e_ident[EI_MAG3] == ELFMAG3; } +} + +enum ET_NONE = 0; +enum ET_REL = 1; +enum ET_EXEC = 2; +enum ET_DYN = 3; +enum ET_CORE = 4; +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_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_AMD64 = 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_VIDEOCORE = 95; +enum EM_TMM_GPP = 96; +enum EM_NS32K = 97; +enum EM_TPC = 98; +enum EM_SNP1K = 99; +enum EM_ST200 = 100; +enum EM_IP2K = 101; +enum EM_MAX = 102; +enum EM_CR = 103; +enum EM_F2MC16 = 104; +enum EM_MSP430 = 105; +enum EM_BLACKFIN = 106; +enum EM_SE_C33 = 107; +enum EM_SEP = 108; +enum EM_ARCA = 109; +enum EM_UNICORE = 110; +enum EM_DXP = 112; +enum EM_ALTERA_NIOS2 =113; +enum EM_CRX = 114; +enum EM_XGATE = 115; +enum EM_C166 = 116; +enum EM_M16C = 117; +enum EM_DSPIC30F = 118; +enum EM_CE = 119; +enum EM_M32C = 120; +enum EM_res121 = 121; +enum EM_res122 = 122; +enum EM_res123 = 123; +enum EM_res124 = 124; +enum EM_res125 = 125; +enum EM_res126 = 126; +enum EM_res127 = 127; +enum EM_res128 = 128; +enum EM_res129 = 129; +enum EM_res130 = 130; +enum EM_TSK3000 = 131; +enum EM_RS08 = 132; +enum EM_res133 = 133; +enum EM_ECOG2 = 134; +enum EM_SCORE = 135; +enum EM_SCORE7 = 135; +enum EM_DSP24 = 136; +enum EM_VIDEOCORE3 = 137; +enum EM_LATTICEMICO32 = 138; +enum EM_SE_C17 = 139; +enum EM_TI_C6000 = 140; +enum EM_TI_C2000 = 141; +enum EM_TI_C5500 = 142; +enum EM_res143 = 143; +enum EM_res144 = 144; +enum EM_res145 = 145; +enum EM_res146 = 146; +enum EM_res147 = 147; +enum EM_res148 = 148; +enum EM_res149 = 149; +enum EM_res150 = 150; +enum EM_res151 = 151; +enum EM_res152 = 152; +enum EM_res153 = 153; +enum EM_res154 = 154; +enum EM_res155 = 155; +enum EM_res156 = 156; +enum EM_res157 = 157; +enum EM_res158 = 158; +enum EM_res159 = 159; +enum EM_MMDSP_PLUS = 160; +enum EM_CYPRESS_M8C = 161; +enum EM_R32C = 162; +enum EM_TRIMEDIA = 163; +enum EM_QDSP6 = 164; +enum EM_8051 = 165; +enum EM_STXP7X = 166; +enum EM_NDS32 = 167; +enum EM_ECOG1 = 168; +enum EM_ECOG1X = 168; +enum EM_MAXQ30 = 169; +enum EM_XIMO16 = 170; +enum EM_MANIK = 171; +enum EM_CRAYNV2 = 172; +enum EM_RX = 173; +enum EM_METAG = 174; +enum EM_MCST_ELBRUS = 175; +enum EM_ECOG16 = 176; +enum EM_CR16 = 177; +enum EM_ETPU = 178; +enum EM_SLE9X = 179; +enum EM_L1OM = 180; +enum EM_K1OM = 181; +enum EM_INTEL182 = 182; +enum EM_res183 = 183; +enum EM_res184 = 184; +enum EM_AVR32 = 185; +enum EM_STM8 = 186; +enum EM_TILE64 = 187; +enum EM_TILEPRO = 188; +enum EM_MICROBLAZE = 189; +enum EM_CUDA = 190; +enum EM_TILEGX = 191; + +enum EM_486 = 6; +enum EM_MIPS_RS4_BE = 10; +enum EM_ALPHA_STD = 41; +enum EM_ALPHA = 0x9026; + +enum SHN_UNDEF = 0; +enum SHN_LORESERVE = 0xff00; +enum SHN_LOPROC = 0xff00; +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 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_LOOS = 0x60000000; +enum PT_HIOS = 0x6fffffff; +enum PT_LOPROC = 0x70000000; +enum PT_HIPROC = 0x7fffffff; + +enum PT_GNU_EH_FRAME = PT_LOOS + 0x474e550; /* Frame unwind information */ +enum PT_SUNW_EH_FRAME = PT_GNU_EH_FRAME; /* Solaris uses the same value */ +enum PT_GNU_STACK = PT_LOOS + 0x474e551; /* Stack flags */ +enum PT_GNU_RELRO = PT_LOOS + 0x474e552; /* Read-only after relocation */ + +enum PF_X = 0x1; +enum PF_W = 0x2; +enum PF_R = 0x4; +enum PF_MASKOS = 0x0ff00000; +enum PF_MASKPROC = 0xf0000000; + +enum PN_XNUM = 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_LOOS = 0x60000000; +enum SHT_LOSUNW = 0x6ffffff4; + +enum SHT_GNU_INCREMENTAL_INPUTS = 0x6fff4700; +enum SHT_GNU_ATTRIBUTES = 0x6ffffff5; +enum SHT_GNU_HASH = 0x6ffffff6; +enum SHT_GNU_LIBLIST = 0x6ffffff7; + +//enum SHT_SUNW_dof = 0x6ffffff4; +//enum SHT_SUNW_cap = 0x6ffffff5; +//enum SHT_SUNW_SIGNATURE = 0x6ffffff6; +enum SHT_SUNW_verdef = 0x6ffffffd; +enum SHT_SUNW_verneed = 0x6ffffffe; +enum SHT_SUNW_versym = 0x6fffffff; + +enum SHT_GNU_verdef = SHT_SUNW_verdef; +enum SHT_GNU_verneed = SHT_SUNW_verneed; +enum SHT_GNU_versym = SHT_SUNW_versym; + +enum SHT_LOPROC = 0x70000000; +enum SHT_HIPROC = 0x7fffffff; +enum SHT_LOUSER = 0x80000000; +enum SHT_HIUSER = 0x8fffffff; + +/* +enum SHT_GNU_HASH = 0x6ffffff6; +enum SHT_SUNW_ANNOTATE = 0x6ffffff7; +enum SHT_SUNW_DEBUGSTR = 0x6ffffff8; +enum SHT_SUNW_DEBUG = 0x6ffffff9; +enum SHT_SUNW_move = 0x6ffffffa; +enum SHT_SUNW_COMDAT = 0x6ffffffb; +enum SHT_SUNW_syminfo = 0x6ffffffc; +enum SHT_HISUNW = 0x6fffffff; +enum SHT_HIOS = 0x6fffffff; +enum SHT_AMD64_UNWIND = 0x70000001; +enum SHT_ARM_EXIDX = 0x70000001; +enum SHT_ARM_PREEMPTMAP = 0x70000002; +enum SHT_ARM_ATTRIBUTES = 0x70000003; +enum SHT_ARM_DEBUGOVERLAY = 0x70000004; +enum SHT_ARM_OVERLAYSECTION = 0x70000005; +enum SHT_MIPS_REGINFO = 0x70000006; +enum SHT_MIPS_OPTIONS = 0x7000000d; +enum SHT_MIPS_DWARF = 0x7000001e; +*/ + +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_MASKOS = 0x0ff00000; +enum SHF_MASKPROC = 0xf0000000; + +enum NT_PRSTATUS = 1; +enum NT_FPREGSET = 2; +enum NT_PRPSINFO = 3; +enum NT_TASKSTRUCT = 4; +enum NT_AUXV = 6; + +/* +enum NT_THRMISC = 7; +enum NT_PROCSTAT_PROC = 8; +enum NT_PROCSTAT_FILES = 9; +enum NT_PROCSTAT_VMMAP = 10; +enum NT_PROCSTAT_GROUPS = 11; +enum NT_PROCSTAT_UMASK = 12; +enum NT_PROCSTAT_RLIMIT = 13; +enum NT_PROCSTAT_OSREL = 14; +enum NT_PROCSTAT_PSSTRINGS = 15; +enum NT_PROCSTAT_AUXV = 16; +*/ + +enum STN_UNDEF = 0; + +enum STB_LOCAL = 0; +enum STB_GLOBAL = 1; +enum STB_WEAK = 2; +enum STB_NUM = 3; +enum STB_LOOS = 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 STV_DEFAULT = 0; +enum STV_INTERNAL = 1; +enum STV_HIDDEN = 2; +enum STV_PROTECTED = 3; +/* +enum STV_EXPORTED = 4; +enum STV_SINGLETON = 5; +enum STV_ELIMINATE = 6; +*/ + +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_MAXPOSTAGS = 34; +enum DT_LOOS = 0x6000000d; +enum DT_HIOS = 0x6ffff000; +/* +enum DT_SUNW_AUXILIARY = 0x6000000d; +enum DT_SUNW_RTLDINF = 0x6000000e; +enum DT_SUNW_FILTER = 0x6000000f; +enum DT_SUNW_CAP = 0x60000010; +*/ + +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; +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; +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; +enum DT_VERSYM = 0x6ffffff0; +enum DT_LOPROC = 0x70000000; +//enum DT_DEPRECATED_SPARC_REGISTER = 0x7000001; +enum DT_AUXILIARY = 0x7ffffffd; +enum DT_USED = 0x7ffffffe; +enum DT_FILTER = 0x7fffffff; +enum DT_HIPROC = 0x7fffffff; + +enum DTF_1_PARINIT = 0x00000001; +enum DTF_1_CONFEXP = 0x00000002; + +enum DF_P1_LAZYLOAD = 0x00000001; +enum DF_P1_GROUPPERM= 0x00000002; + +enum DF_1_NOW = 0x00000001; +enum DF_1_BIND_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_CONLFAT = 0x00002000; + +enum DF_ORIGIN = 0x00000001; +enum DF_SYMBOLIC = 0x00000002; +enum DF_TEXTREL = 0x00000004; +enum DF_BIND_NOW = 0x00000008; +enum DF_STATIC_TLS = 0x00000010; + +enum VER_DEF_NONE = 0; +enum VER_DEF_CURRENT = 1; +alias VER_NDX VER_DEF_IDX; + +enum VER_FLG_BASE = 0x1; +enum VER_FLG_WEAK = 0x2; +enum VER_FLG_INFO = 0x4; + +enum VER_NDX_LOCAL = 0; +enum VER_NDX_GLOBAL = 1; +enum VER_NDX_GIVEN = 2; +enum VER_NDX_HIDDEN = 32768; +extern (D) pure @safe +{ + auto VER_NDX(V)(V v) { return v & ~(1u << 15); } +} + +enum VER_NEED_NONE = 0; +enum VER_NEED_CURRENT = 1; +enum VER_NEED_WEAK = 32768; +enum VER_NEED_HIDDEN = VER_NDX_HIDDEN; +alias VER_NDX VER_NEED_IDX; + +/* +enum CA_SUNW_NULL = 0; +enum CA_SUNW_HW_1 = 1; +enum CA_SUNW_SF_1 = 2; +*/ + +enum VERSYM_HIDDEN = 0x8000; +enum VERSYM_VERSION = 0x7fff; +enum ELF_VER_CHR = '@'; + +enum SYMINFO_BT_SELF = 0xffff; +enum SYMINFO_BT_PARENT = 0xfffe; +//enum SYMINFO_BT_NONE = 0xfffd; +//enum SYMINFO_BT_EXTERN = 0xfffc; +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_FLG_DIRECTBIND = 0x0010; +//enum SYMINFO_FLG_NOEXTDIRECT = 0x0020; +//enum SYMINFO_FLG_FILTER = 0x0002; +//enum SYMINFO_FLG_AUXILIARY = 0x0040; + +enum SYMINFO_NONE = 0; +enum SYMINFO_CURRENT = 1; +enum SYMINFO_NUM = 2; + +enum GRP_COMDAT = 0x1; + +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_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_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_IRELATIVE = 42; + +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_JMP_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_IRELATIVE = 37; diff --git a/src/core/sys/dragonflybsd/sys/event.d b/src/core/sys/dragonflybsd/sys/event.d new file mode 100644 index 0000000000..867b55b698 --- /dev/null +++ b/src/core/sys/dragonflybsd/sys/event.d @@ -0,0 +1,124 @@ +/** + * D header file for DragonFlyBSD. + * + * Copyright: Copyright Martin Nowak 2012. + * License: $(WEB www.boost.org/LICENSE_1_0.txt, Boost License 1.0). + * Authors: Martin Nowak,Diederik de Groot(port:DragonFlyBSD) + * Copied: From core/sys/freebsd/sys + */ +module core.sys.dragonflybsd.sys.event; + +version (DragonFlyBSD): + +extern (C) nothrow @nogc @system: + +import core.stdc.stdint; // intptr_t, uintptr_t +import core.sys.posix.time; // timespec + +enum +{ + EVFILT_READ = -1, + EVFILT_WRITE = -2, + EVFILT_AIO = -3, /* attached to aio requests */ + EVFILT_VNODE = -4, /* attached to vnodes */ + EVFILT_PROC = -5, /* attached to struct proc */ + EVFILT_SIGNAL = -6, /* attached to struct proc */ + EVFILT_TIMER = -7, /* timers */ + EVFILT_EXCEPT = -8, /* exceptional conditions */ + EVFILT_USER = -9, /* user events */ + EVFILT_FS = -10, /* filesystem events */ + EVFILT_MARKER = 0xF, /* placemarker for tailq */ + EVFILT_SYSCOUNT = 10, +} + +extern(D) void EV_SET(kevent_t* kevp, typeof(kevent_t.tupleof) args) +{ + *kevp = kevent_t(args); +} + +struct kevent_t +{ + uintptr_t ident; /* identifier for this event */ + short filter; /* filter for event */ + ushort flags; + uint fflags; + intptr_t data; + void *udata; /* opaque user data identifier */ +} + +enum +{ + /* actions */ + EV_ADD = 0x0001, /* add event to kq (implies enable) */ + EV_DELETE = 0x0002, /* delete event from kq */ + EV_ENABLE = 0x0004, /* enable event */ + EV_DISABLE = 0x0008, /* disable event (not reported) */ + + /* flags */ + EV_ONESHOT = 0x0010, /* only report one occurrence */ + EV_CLEAR = 0x0020, /* clear event state after reporting */ + EV_RECEIPT = 0x0040, /* force EV_ERROR on success, data=0 */ + EV_DISPATCH = 0x0080, /* disable event after reporting */ + + EV_SYSFLAGS = 0xF000, /* reserved by system */ + EV_FLAG1 = 0x2000, /* filter-specific flag */ + + /* returned values */ + EV_EOF = 0x8000, /* EOF detected */ + EV_ERROR = 0x4000, /* error, data contains errno */ + EV_NODATA = 0x1000, /* EOF and no more data */ +} + +enum +{ + /* + * data/hint flags/masks for EVFILT_USER, shared with userspace + * + * On input, the top two bits of fflags specifies how the lower twenty four + * bits should be applied to the stored value of fflags. + * + * On output, the top two bits will always be set to NOTE_FFNOP and the + * remaining twenty four bits will contain the stored fflags value. + */ + NOTE_FFNOP = 0x00000000, /* ignore input fflags */ + NOTE_FFAND = 0x40000000, /* AND fflags */ + NOTE_FFOR = 0x80000000, /* OR fflags */ + NOTE_FFCOPY = 0xc0000000, /* copy fflags */ + NOTE_FFCTRLMASK = 0xc0000000, /* masks for operations */ + NOTE_FFLAGSMASK = 0x00ffffff, + + NOTE_TRIGGER = 0x01000000, /* Cause the event to be + triggered for output. */ + + /* + * data/hint flags for EVFILT_{READ|WRITE}, shared with userspace + */ + NOTE_LOWAT = 0x0001, /* low water mark */ + NOTE_OOB = 0x0002, /* OOB data on a socket */ + + /* + * data/hint flags for EVFILT_VNODE, shared with userspace + */ + NOTE_DELETE = 0x0001, /* vnode was removed */ + NOTE_WRITE = 0x0002, /* data contents changed */ + NOTE_EXTEND = 0x0004, /* size increased */ + NOTE_ATTRIB = 0x0008, /* attributes changed */ + NOTE_LINK = 0x0010, /* link count changed */ + NOTE_RENAME = 0x0020, /* vnode was renamed */ + NOTE_REVOKE = 0x0040, /* vnode access was revoked */ + + NOTE_EXIT = 0x80000000, /* process exited */ + NOTE_FORK = 0x40000000, /* process forked */ + NOTE_EXEC = 0x20000000, /* process exec'd */ + NOTE_PCTRLMASK = 0xf0000000, /* mask for hint bits */ + NOTE_PDATAMASK = 0x000fffff, /* mask for pid */ + + /* additional flags for EVFILT_PROC */ + NOTE_TRACK = 0x00000001, /* follow across forks */ + NOTE_TRACKERR = 0x00000002, /* could not track child */ + NOTE_CHILD = 0x00000004, /* am a child process */ +} + +int kqueue(); +int kevent(int kq, const kevent_t *changelist, int nchanges, + int nevents, const timespec *timeout); diff --git a/src/core/sys/dragonflybsd/sys/link_elf.d b/src/core/sys/dragonflybsd/sys/link_elf.d new file mode 100644 index 0000000000..b1a41a8050 --- /dev/null +++ b/src/core/sys/dragonflybsd/sys/link_elf.d @@ -0,0 +1,82 @@ +/** + * D header file for DragonFlyBSD. + * + * $(LINK2 http://svnweb.freebsd.org/base/head/sys/sys/link_elf.h?view=markup, sys/link_elf.h) + * Authors: Diederik de Groot(port:DragonFlyBSD) + * Copied: From core/sys/freebsd/sys + */ +module core.sys.dragonflybsd.sys.link_elf; + +version (DragonFlyBSD): + +extern (C) nothrow @system: + +import core.stdc.stdint : uint64_t; +import core.sys.dragonflybsd.sys.elf; + +version(D_LP64) + enum __ELF_NATIVE_CLASS = 64; +else + enum __ELF_NATIVE_CLASS = 32; + +template ElfW(string type) +{ + mixin("alias Elf"~__ELF_NATIVE_CLASS.stringof~"_"~type~" ElfW;"); +} + +enum LA_SER_ORIG = 0x01; +enum LA_SER_LIBPATH = 0x02; +enum LA_SER_RUNPATH = 0x04; +enum LA_SER_CONFIG = 0x08; +enum LA_SER_DEFAULT = 0x40; +enum LA_SER_SECURE = 0x80; + +struct link_map +{ + char* l_addr; + + version (MIPS32) + char* l_offs; + version (MIPS64) + char* l_offs; + + char* l_name; + void* l_ld; + link_map* l_next, l_prev; +} +alias link_map Link_map; + +enum +{ + RT_CONSISTENT, + RT_ADD, + RT_DELETE, +} + +struct r_debug +{ + int r_version; + link_map* r_map; + void function(r_debug*, link_map*) r_brk; +}; + +struct dl_phdr_info +{ + ElfW!"Addr" dlpi_addr; + char* dlpi_name; + ElfW!"Phdr"* dlpi_phdr; + ElfW!"Half" dlpi_phnum; + uint64_t dlpi_adds; + uint64_t dlpi_subs; + size_t dlpi_tls_modid; + void* dlpi_tls_data; +}; + + +private alias int function(dl_phdr_info*, size_t, void *) dl_iterate_phdr_cb; +private alias int function(dl_phdr_info*, size_t, void *) @nogc dl_iterate_phdr_cb_ngc; + +int dl_iterate_phdr(dl_iterate_phdr_cb __callback, void*__data); +int dl_iterate_phdr(dl_iterate_phdr_cb_ngc __callback, void*__data) @nogc; +int _rtld_addr_phdr(const void*, dl_phdr_info*) @nogc; +int _rtld_get_stack_prot() @nogc; diff --git a/src/core/sys/dragonflybsd/sys/mman.d b/src/core/sys/dragonflybsd/sys/mman.d new file mode 100644 index 0000000000..3733d9f31d --- /dev/null +++ b/src/core/sys/dragonflybsd/sys/mman.d @@ -0,0 +1,127 @@ +/** + * D header file for DragonFlyBSD + * + * Authors: Martin Nowak,Diederik de Groot(port:DragonFlyBSD) + * Copied: From core/sys/freebsd/sys + */ +module core.sys.dragonflybsd.sys.mman; + +version (DragonFlyBSD): +extern (C) nothrow @nogc @system: + +public import core.sys.posix.sys.mman; +import core.sys.dragonflybsd.sys.cdefs; +import core.sys.posix.sys.types; + +enum INHERIT_SHARE = 0; +enum INHERIT_COPY = 1; +enum INHERIT_NONE = 2; + +// already in core.sys.posix.sys.mman +// enum PROT_NONE = 0x00; +// enum PROT_READ = 0x01; +// enum PROT_WRITE = 0x02; +// enum PROT_EXEC = 0x04; +// enum MAP_SHARED = 0x0001; +// enum MAP_PRIVATE = 0x0002; +alias MAP_COPY = MAP_PRIVATE; + +enum MAP_FIXED = 0x00010; +enum MAP_RENAME = 0x00020; +enum MAP_NORESERVE = 0x00040; +enum MAP_INHERIT = 0x00080; +enum MAP_NOEXTEND = 0x00100; +enum MAP_HASSEMAPHORE = 0x00200; +enum MAP_STACK = 0x00400; +enum MAP_NOSYNC = 0x00800; + +enum MAP_FILE = 0x00000; +//enum MAP_ANON = 0x01000; // already in core.sys.posix.sys.mman +alias MAP_ANONYMOUS = MAP_ANON; +enum MAP_VPAGETABLE = 0x02000; + +enum MAP_TRYFIXED = 0x10000; +enum MAP_NOCORE = 0x20000; +enum MAP_SIZEALIGN = 0x40000; + +//enum MAP_EXCL = 0x00004000; +//enum MAP_NOCORE = 0x00020000; +//enum MAP_PREFAULT_READ = 0x00040000; +//version (LP64) +// enum MAP_32BIT = 0x00080000; + +//extern(D) int MAP_ALIGNED(int n) { return n << MAP_ALIGNMENT_SHIFT; } +//enum MAP_ALIGNMENT_SHIFT = 24; +//enum MAP_ALIGNMENT_MASK = MAP_ALIGNED(0xff); +//enum MAP_ALIGNED_SUPER = MAP_ALIGNED(1); + +// enum MCL_CURRENT = 0x0001; // already in core.sys.posix.sys.mman +// enum MCL_FUTURE = 0x0002; // already in core.sys.posix.sys.mman + +// already in core.sys.posix.sys.mman +enum MAP_FAILED = cast(void*)-1; +// enum MS_SYNC = 0x0000; // already in core.sys.posix.sys.mman +// enum MS_ASYNC = 0x0001; // already in core.sys.posix.sys.mman +// enum MS_INVALIDATE = 0x0002; // already in core.sys.posix.sys.mman + +enum _MADV_NORMAL = 0; +enum _MADV_RANDOM = 1; +enum _MADV_SEQUENTIAL = 2; +enum _MADV_WILLNEED = 3; +enum _MADV_DONTNEED = 4; + +alias MADV_NORMAL = _MADV_NORMAL; +alias MADV_RANDOM = _MADV_RANDOM; +alias MADV_SEQUENTIAL = _MADV_SEQUENTIAL; +alias MADV_WILLNEED = _MADV_WILLNEED; +alias MADV_DONTNEED = _MADV_DONTNEED; +enum MADV_FREE = 5; +enum MADV_NOSYNC = 6; +enum MADV_AUTOSYNC = 7; +enum MADV_NOCORE = 8; +enum MADV_CORE = 9; +enum MADV_INVAL = 10; +enum MADV_SETMAP = 11; + +alias MADV_CONTROL_START = MADV_INVAL; +alias MADV_CONTROL_END = MADV_SETMAP; + +enum MINCORE_INCORE = 0x1; +enum MINCORE_REFERENCED = 0x2; +enum MINCORE_MODIFIED = 0x4; +enum MINCORE_REFERENCED_OTHER = 0x8; +enum MINCORE_MODIFIED_OTHER = 0x10; +enum MINCORE_SUPER = 0x20; + +enum SHM_ANON = cast(const(char) *)1; + +// already in core.sys.posix.sys.mman +// alias POSIX_MADV_NORMAL = _MADV_NORMAL; +// alias POSIX_MADV_RANDOM = _MADV_RANDOM; +// alias POSIX_MADV_SEQUENTIAL= _MADV_SEQUENTIAL; +// alias POSIX_MADV_WILLNEED = _MADV_WILLNEED; +// alias POSIX_MADV_DONTNEED = _MADV_DONTNEED; + +int getpagesizes(size_t *, int); +int madvise(void *, size_t, int); +int mincore(const(void) *, size_t, char *); +int minherit(void *, size_t, int); + +// already in core.sys.posix.sys.mman +// int mlock(const void *, size_t); +// void * mmap(void *, size_t, int, int, int, off_t); +// int mprotect(const void *, size_t, int); +// int msync(void *, size_t, int); +// int munlock(const void *, size_t); +// int munmap(void *, size_t); +// int posix_madvise(void *, size_t, int); + +// int mlockall(int); +// int munlockall(); +// int shm_open(const(char) *, int, mode_t); +// int shm_unlink(const(char) *); + +// int madvise(void *, size_t, int); +// int mcontrol(void *, size_t, int, off_t); +// int mincore(const void *, size_t, char *); +// int minherit(void *, size_t, int); diff --git a/src/core/sys/dragonflybsd/time.d b/src/core/sys/dragonflybsd/time.d new file mode 100644 index 0000000000..7e5279c61c --- /dev/null +++ b/src/core/sys/dragonflybsd/time.d @@ -0,0 +1,30 @@ +/** + * D header file for DragonFlyBSD's extensions to POSIX's time.h. + * + * Copyright: Copyright 2014 + * License: $(WEB www.boost.org/LICENSE_1_0.txt, Boost License 1.0). + * Authors: Jonathan M Davis,Diederik de Groot(port:DragonFlyBSD) + * Copied: From core/sys/freebsd/sys + */ +module core.sys.dragonflybsd.time; + +version(DragonFlyBSD): + +public import core.sys.posix.time; + +import core.sys.dragonflybsd.sys.cdefs; + +enum CLOCK_REALTIME = 0; +enum CLOCK_VIRTUAL = 1; +enum CLOCK_PROF = 2; +enum CLOCK_MONOTONIC = 4; +enum CLOCK_UPTIME = 5; +enum CLOCK_UPTIME_PRECISE = 7; +enum CLOCK_UPTIME_FAST = 8; +enum CLOCK_REALTIME_PRECISE = 9; +enum CLOCK_REALTIME_FAST = 10; +enum CLOCK_MONOTONIC_PRECISE = 11; +enum CLOCK_MONOTONIC_FAST = 12; +enum CLOCK_SECOND = 13; +enum CLOCK_THREAD_CPUTIME_ID = 14; +enum CLOCK_PROCESS_CPUTIME_ID= 15; diff --git a/win32.mak b/win32.mak index 57af4e42c7..3492355a9d 100644 --- a/win32.mak +++ b/win32.mak @@ -207,6 +207,7 @@ copydir: $(IMPDIR) mkdir $(IMPDIR)\core\internal mkdir $(IMPDIR)\core\sys\darwin\mach mkdir $(IMPDIR)\core\sys\freebsd\sys + mkdir $(IMPDIR)\core\sys\dragonflybsd\sys mkdir $(IMPDIR)\core\sys\linux\sys mkdir $(IMPDIR)\core\sys\osx\mach mkdir $(IMPDIR)\core\sys\posix\arpa @@ -445,6 +446,51 @@ $(IMPDIR)\core\sys\freebsd\sys\link_elf.d : src\core\sys\freebsd\sys\link_elf.d $(IMPDIR)\core\sys\freebsd\sys\mman.d : src\core\sys\freebsd\sys\mman.d copy $** $@ +$(IMPDIR)\core\sys\dragonflybsd\dlfcn.d : src\core\sys\dragonflybsd\dlfcn.d + copy $** $@ + +$(IMPDIR)\core\sys\dragonflybsd\execinfo.d : src\core\sys\dragonflybsd\execinfo.d + copy $** $@ + +$(IMPDIR)\core\sys\dragonflybsd\pthread_np.d : src\core\sys\dragonflybsd\pthread_np.d + copy $** $@ + +$(IMPDIR)\core\sys\dragonflybsd\time.d : src\core\sys\dragonflybsd\time.d + copy $** $@ + +$(IMPDIR)\core\sys\dragonflybsd\netinet\in_.d : src\core\sys\dragonflybsd\netinet\in_.d + copy $** $@ + +$(IMPDIR)\core\sys\dragonflybsd\sys\cdefs.d : src\core\sys\dragonflybsd\sys\cdefs.d + copy $** $@ + +$(IMPDIR)\core\sys\dragonflybsd\sys\_bitset.d : src\core\sys\dragonflybsd\sys\_bitset.d + copy $** $@ + +$(IMPDIR)\core\sys\dragonflybsd\sys\_cpuset.d : src\core\sys\dragonflybsd\sys\_cpuset.d + copy $** $@ + +$(IMPDIR)\core\sys\dragonflybsd\sys\elf.d : src\core\sys\dragonflybsd\sys\elf.d + copy $** $@ + +$(IMPDIR)\core\sys\dragonflybsd\sys\elf_common.d : src\core\sys\dragonflybsd\sys\elf_common.d + copy $** $@ + +$(IMPDIR)\core\sys\dragonflybsd\sys\elf32.d : src\core\sys\dragonflybsd\sys\elf32.d + copy $** $@ + +$(IMPDIR)\core\sys\dragonflybsd\sys\elf64.d : src\core\sys\dragonflybsd\sys\elf64.d + copy $** $@ + +$(IMPDIR)\core\sys\dragonflybsd\sys\event.d : src\core\sys\dragonflybsd\sys\event.d + copy $** $@ + +$(IMPDIR)\core\sys\dragonflybsd\sys\link_elf.d : src\core\sys\dragonflybsd\sys\link_elf.d + copy $** $@ + +$(IMPDIR)\core\sys\dragonflybsd\sys\mman.d : src\core\sys\dragonflybsd\sys\mman.d + copy $** $@ + $(IMPDIR)\core\sys\linux\config.d : src\core\sys\linux\config.d copy $** $@ diff --git a/win64.mak b/win64.mak index de05c4b5ad..53d896b8df 100644 --- a/win64.mak +++ b/win64.mak @@ -218,6 +218,7 @@ copydir: $(IMPDIR) mkdir $(IMPDIR)\core\internal mkdir $(IMPDIR)\core\sys\darwin\mach mkdir $(IMPDIR)\core\sys\freebsd\sys + mkdir $(IMPDIR)\core\sys\dragonflybsd\sys mkdir $(IMPDIR)\core\sys\linux\sys mkdir $(IMPDIR)\core\sys\osx\mach mkdir $(IMPDIR)\core\sys\posix\arpa @@ -456,6 +457,51 @@ $(IMPDIR)\core\sys\freebsd\sys\link_elf.d : src\core\sys\freebsd\sys\link_elf.d $(IMPDIR)\core\sys\freebsd\sys\mman.d : src\core\sys\freebsd\sys\mman.d copy $** $@ +$(IMPDIR)\core\sys\dragonflybsd\dlfcn.d : src\core\sys\dragonflybsd\dlfcn.d + copy $** $@ + +$(IMPDIR)\core\sys\dragonflybsd\execinfo.d : src\core\sys\dragonflybsd\execinfo.d + copy $** $@ + +$(IMPDIR)\core\sys\dragonflybsd\pthread_np.d : src\core\sys\dragonflybsd\pthread_np.d + copy $** $@ + +$(IMPDIR)\core\sys\dragonflybsd\time.d : src\core\sys\dragonflybsd\time.d + copy $** $@ + +$(IMPDIR)\core\sys\dragonflybsd\netinet\in_.d : src\core\sys\dragonflybsd\netinet\in_.d + copy $** $@ + +$(IMPDIR)\core\sys\dragonflybsd\sys\cdefs.d : src\core\sys\dragonflybsd\sys\cdefs.d + copy $** $@ + +$(IMPDIR)\core\sys\dragonflybsd\sys\_bitset.d : src\core\sys\dragonflybsd\sys\_bitset.d + copy $** $@ + +$(IMPDIR)\core\sys\dragonflybsd\sys\_cpuset.d : src\core\sys\dragonflybsd\sys\_cpuset.d + copy $** $@ + +$(IMPDIR)\core\sys\dragonflybsd\sys\elf.d : src\core\sys\dragonflybsd\sys\elf.d + copy $** $@ + +$(IMPDIR)\core\sys\dragonflybsd\sys\elf_common.d : src\core\sys\dragonflybsd\sys\elf_common.d + copy $** $@ + +$(IMPDIR)\core\sys\dragonflybsd\sys\elf32.d : src\core\sys\dragonflybsd\sys\elf32.d + copy $** $@ + +$(IMPDIR)\core\sys\dragonflybsd\sys\elf64.d : src\core\sys\dragonflybsd\sys\elf64.d + copy $** $@ + +$(IMPDIR)\core\sys\dragonflybsd\sys\event.d : src\core\sys\dragonflybsd\sys\event.d + copy $** $@ + +$(IMPDIR)\core\sys\dragonflybsd\sys\link_elf.d : src\core\sys\dragonflybsd\sys\link_elf.d + copy $** $@ + +$(IMPDIR)\core\sys\dragonflybsd\sys\mman.d : src\core\sys\dragonflybsd\sys\mman.d + copy $** $@ + $(IMPDIR)\core\sys\linux\config.d : src\core\sys\linux\config.d copy $** $@