libphobos: Merge upstream druntime 94686651

Adds extern(C) bindings for version OpenBSD.

Reviewed-on: https://github.com/dlang/druntime/pull/2748

libphobos/ChangeLog:

	* libdruntime/Makefile.am (DRUNTIME_DSOURCES_OPENBSD): Add
	core/sys/openbsd/sys/cdefs.d, core/sys/openbsd/sys/elf.d,
	core/sys/openbsd/sys/elf32.d, core/sys/openbsd/sys/elf64.d,
	core/sys/openbsd/sys/elf_common.d, core/sys/openbsd/sys/link_elf.d,
	core/sys/openbsd/sys/mman.d, core/sys/openbsd/time.d.
	* libdruntime/Makefile.in: Regenerate.

From-SVN: r274772

libphobos/ChangeLog

+2019-08-20  Iain Buclaw  <ibuclaw@gdcproject.org>
+
+	* libdruntime/Makefile.am (DRUNTIME_DSOURCES_OPENBSD): Add
+	core/sys/openbsd/sys/cdefs.d, core/sys/openbsd/sys/elf.d,
+	core/sys/openbsd/sys/elf32.d, core/sys/openbsd/sys/elf64.d,
+	core/sys/openbsd/sys/elf_common.d, core/sys/openbsd/sys/link_elf.d,
+	core/sys/openbsd/sys/mman.d, core/sys/openbsd/time.d.
+	* libdruntime/Makefile.in: Regenerate.
+
 2019-05-07  Rainer Orth  <ro@CeBiTec.Uni-Bielefeld.DE>
 
 	* m4/druntime/os.m4 (DRUNTIME_OS_LINK_SPEC): Only use -z

libphobos/libdruntime/MERGE

-cb1583b4b7313bb6d79a5102b6c91e71f5181b19
+94686651757294d608cfd5f053fda09dcf86695e
 
 The first line of this file holds the git revision number of the last
 merge done from the dlang/druntime repository.

libphobos/libdruntime/Makefile.am

@@ -162,21 +162,21 @@ DRUNTIME_DSOURCES = core/atomic.d core/attribute.d core/bitop.d \
 	core/sync/rwmutex.d core/sync/semaphore.d core/thread.d core/time.d \
 	core/vararg.d gcc/attribute.d gcc/backtrace.d gcc/builtins.d gcc/deh.d \
 	gcc/emutls.d gcc/gthread.d gcc/sections/android.d \
-	gcc/sections/elf_shared.d gcc/sections/osx.d \
-	gcc/sections/package.d gcc/sections/win32.d gcc/sections/win64.d \
-	gcc/unwind/arm.d gcc/unwind/arm_common.d gcc/unwind/c6x.d \
-	gcc/unwind/generic.d gcc/unwind/package.d gcc/unwind/pe.d object.d \
-	rt/aApply.d rt/aApplyR.d rt/aaA.d rt/adi.d rt/arrayassign.d \
-	rt/arraycast.d rt/arraycat.d rt/cast_.d rt/config.d rt/critical_.d \
-	rt/deh.d rt/dmain2.d rt/invariant.d rt/lifetime.d rt/memory.d \
-	rt/minfo.d rt/monitor_.d rt/obj.d rt/qsort.d rt/sections.d \
-	rt/switch_.d rt/tlsgc.d rt/typeinfo/ti_Acdouble.d \
-	rt/typeinfo/ti_Acfloat.d rt/typeinfo/ti_Acreal.d \
-	rt/typeinfo/ti_Adouble.d rt/typeinfo/ti_Afloat.d rt/typeinfo/ti_Ag.d \
-	rt/typeinfo/ti_Aint.d rt/typeinfo/ti_Along.d rt/typeinfo/ti_Areal.d \
-	rt/typeinfo/ti_Ashort.d rt/typeinfo/ti_C.d rt/typeinfo/ti_byte.d \
-	rt/typeinfo/ti_cdouble.d rt/typeinfo/ti_cent.d rt/typeinfo/ti_cfloat.d \
-	rt/typeinfo/ti_char.d rt/typeinfo/ti_creal.d rt/typeinfo/ti_dchar.d \
+	gcc/sections/elf_shared.d gcc/sections/osx.d gcc/sections/package.d \
+	gcc/sections/win32.d gcc/sections/win64.d gcc/unwind/arm.d \
+	gcc/unwind/arm_common.d gcc/unwind/c6x.d gcc/unwind/generic.d \
+	gcc/unwind/package.d gcc/unwind/pe.d object.d rt/aApply.d rt/aApplyR.d \
+	rt/aaA.d rt/adi.d rt/arrayassign.d rt/arraycast.d rt/arraycat.d \
+	rt/cast_.d rt/config.d rt/critical_.d rt/deh.d rt/dmain2.d \
+	rt/invariant.d rt/lifetime.d rt/memory.d rt/minfo.d rt/monitor_.d \
+	rt/obj.d rt/qsort.d rt/sections.d rt/switch_.d rt/tlsgc.d \
+	rt/typeinfo/ti_Acdouble.d rt/typeinfo/ti_Acfloat.d \
+	rt/typeinfo/ti_Acreal.d rt/typeinfo/ti_Adouble.d \
+	rt/typeinfo/ti_Afloat.d rt/typeinfo/ti_Ag.d rt/typeinfo/ti_Aint.d \
+	rt/typeinfo/ti_Along.d rt/typeinfo/ti_Areal.d rt/typeinfo/ti_Ashort.d \
+	rt/typeinfo/ti_C.d rt/typeinfo/ti_byte.d rt/typeinfo/ti_cdouble.d \
+	rt/typeinfo/ti_cent.d rt/typeinfo/ti_cfloat.d rt/typeinfo/ti_char.d \
+	rt/typeinfo/ti_creal.d rt/typeinfo/ti_dchar.d \
 	rt/typeinfo/ti_delegate.d rt/typeinfo/ti_double.d \
 	rt/typeinfo/ti_float.d rt/typeinfo/ti_idouble.d \
 	rt/typeinfo/ti_ifloat.d rt/typeinfo/ti_int.d rt/typeinfo/ti_ireal.d \
@@ -251,7 +251,11 @@ DRUNTIME_DSOURCES_NETBSD = core/sys/netbsd/dlfcn.d \
 	core/sys/netbsd/sys/link_elf.d core/sys/netbsd/sys/mman.d \
 	core/sys/netbsd/time.d
 
-DRUNTIME_DSOURCES_OPENBSD = core/sys/openbsd/dlfcn.d
+DRUNTIME_DSOURCES_OPENBSD = core/sys/openbsd/dlfcn.d \
+	core/sys/openbsd/sys/cdefs.d core/sys/openbsd/sys/elf.d \
+	core/sys/openbsd/sys/elf32.d core/sys/openbsd/sys/elf64.d \
+	core/sys/openbsd/sys/elf_common.d core/sys/openbsd/sys/link_elf.d \
+	core/sys/openbsd/sys/mman.d core/sys/openbsd/time.d
 
 DRUNTIME_DSOURCES_POSIX = core/sys/posix/aio.d \
 	core/sys/posix/arpa/inet.d core/sys/posix/config.d \

libphobos/libdruntime/Makefile.in

@@ -316,7 +316,12 @@ am__objects_17 = core/sys/netbsd/dlfcn.lo core/sys/netbsd/execinfo.lo \
 	core/sys/netbsd/sys/event.lo core/sys/netbsd/sys/link_elf.lo \
 	core/sys/netbsd/sys/mman.lo core/sys/netbsd/time.lo
 @DRUNTIME_OS_NETBSD_TRUE@am__objects_18 = $(am__objects_17)
-am__objects_19 = core/sys/openbsd/dlfcn.lo
+am__objects_19 = core/sys/openbsd/dlfcn.lo \
+	core/sys/openbsd/sys/cdefs.lo core/sys/openbsd/sys/elf.lo \
+	core/sys/openbsd/sys/elf32.lo core/sys/openbsd/sys/elf64.lo \
+	core/sys/openbsd/sys/elf_common.lo \
+	core/sys/openbsd/sys/link_elf.lo core/sys/openbsd/sys/mman.lo \
+	core/sys/openbsd/time.lo
 @DRUNTIME_OS_OPENBSD_TRUE@am__objects_20 = $(am__objects_19)
 am__objects_21 = core/sys/linux/config.lo core/sys/linux/dlfcn.lo \
 	core/sys/linux/elf.lo core/sys/linux/epoll.lo \
@@ -758,21 +763,21 @@ DRUNTIME_DSOURCES = core/atomic.d core/attribute.d core/bitop.d \
 	core/sync/rwmutex.d core/sync/semaphore.d core/thread.d core/time.d \
 	core/vararg.d gcc/attribute.d gcc/backtrace.d gcc/builtins.d gcc/deh.d \
 	gcc/emutls.d gcc/gthread.d gcc/sections/android.d \
-	gcc/sections/elf_shared.d gcc/sections/osx.d \
-	gcc/sections/package.d gcc/sections/win32.d gcc/sections/win64.d \
-	gcc/unwind/arm.d gcc/unwind/arm_common.d gcc/unwind/c6x.d \
-	gcc/unwind/generic.d gcc/unwind/package.d gcc/unwind/pe.d object.d \
-	rt/aApply.d rt/aApplyR.d rt/aaA.d rt/adi.d rt/arrayassign.d \
-	rt/arraycast.d rt/arraycat.d rt/cast_.d rt/config.d rt/critical_.d \
-	rt/deh.d rt/dmain2.d rt/invariant.d rt/lifetime.d rt/memory.d \
-	rt/minfo.d rt/monitor_.d rt/obj.d rt/qsort.d rt/sections.d \
-	rt/switch_.d rt/tlsgc.d rt/typeinfo/ti_Acdouble.d \
-	rt/typeinfo/ti_Acfloat.d rt/typeinfo/ti_Acreal.d \
-	rt/typeinfo/ti_Adouble.d rt/typeinfo/ti_Afloat.d rt/typeinfo/ti_Ag.d \
-	rt/typeinfo/ti_Aint.d rt/typeinfo/ti_Along.d rt/typeinfo/ti_Areal.d \
-	rt/typeinfo/ti_Ashort.d rt/typeinfo/ti_C.d rt/typeinfo/ti_byte.d \
-	rt/typeinfo/ti_cdouble.d rt/typeinfo/ti_cent.d rt/typeinfo/ti_cfloat.d \
-	rt/typeinfo/ti_char.d rt/typeinfo/ti_creal.d rt/typeinfo/ti_dchar.d \
+	gcc/sections/elf_shared.d gcc/sections/osx.d gcc/sections/package.d \
+	gcc/sections/win32.d gcc/sections/win64.d gcc/unwind/arm.d \
+	gcc/unwind/arm_common.d gcc/unwind/c6x.d gcc/unwind/generic.d \
+	gcc/unwind/package.d gcc/unwind/pe.d object.d rt/aApply.d rt/aApplyR.d \
+	rt/aaA.d rt/adi.d rt/arrayassign.d rt/arraycast.d rt/arraycat.d \
+	rt/cast_.d rt/config.d rt/critical_.d rt/deh.d rt/dmain2.d \
+	rt/invariant.d rt/lifetime.d rt/memory.d rt/minfo.d rt/monitor_.d \
+	rt/obj.d rt/qsort.d rt/sections.d rt/switch_.d rt/tlsgc.d \
+	rt/typeinfo/ti_Acdouble.d rt/typeinfo/ti_Acfloat.d \
+	rt/typeinfo/ti_Acreal.d rt/typeinfo/ti_Adouble.d \
+	rt/typeinfo/ti_Afloat.d rt/typeinfo/ti_Ag.d rt/typeinfo/ti_Aint.d \
+	rt/typeinfo/ti_Along.d rt/typeinfo/ti_Areal.d rt/typeinfo/ti_Ashort.d \
+	rt/typeinfo/ti_C.d rt/typeinfo/ti_byte.d rt/typeinfo/ti_cdouble.d \
+	rt/typeinfo/ti_cent.d rt/typeinfo/ti_cfloat.d rt/typeinfo/ti_char.d \
+	rt/typeinfo/ti_creal.d rt/typeinfo/ti_dchar.d \
 	rt/typeinfo/ti_delegate.d rt/typeinfo/ti_double.d \
 	rt/typeinfo/ti_float.d rt/typeinfo/ti_idouble.d \
 	rt/typeinfo/ti_ifloat.d rt/typeinfo/ti_int.d rt/typeinfo/ti_ireal.d \
@@ -846,7 +851,12 @@ DRUNTIME_DSOURCES_NETBSD = core/sys/netbsd/dlfcn.d \
 	core/sys/netbsd/sys/link_elf.d core/sys/netbsd/sys/mman.d \
 	core/sys/netbsd/time.d
 
-DRUNTIME_DSOURCES_OPENBSD = core/sys/openbsd/dlfcn.d
+DRUNTIME_DSOURCES_OPENBSD = core/sys/openbsd/dlfcn.d \
+	core/sys/openbsd/sys/cdefs.d core/sys/openbsd/sys/elf.d \
+	core/sys/openbsd/sys/elf32.d core/sys/openbsd/sys/elf64.d \
+	core/sys/openbsd/sys/elf_common.d core/sys/openbsd/sys/link_elf.d \
+	core/sys/openbsd/sys/mman.d core/sys/openbsd/time.d
+
 DRUNTIME_DSOURCES_POSIX = core/sys/posix/aio.d \
 	core/sys/posix/arpa/inet.d core/sys/posix/config.d \
 	core/sys/posix/dirent.d core/sys/posix/dlfcn.d core/sys/posix/fcntl.d \
@@ -1414,6 +1424,19 @@ core/sys/openbsd/$(am__dirstamp):
 	@$(MKDIR_P) core/sys/openbsd
 	@: > core/sys/openbsd/$(am__dirstamp)
 core/sys/openbsd/dlfcn.lo: core/sys/openbsd/$(am__dirstamp)
+core/sys/openbsd/sys/$(am__dirstamp):
+	@$(MKDIR_P) core/sys/openbsd/sys
+	@: > core/sys/openbsd/sys/$(am__dirstamp)
+core/sys/openbsd/sys/cdefs.lo: core/sys/openbsd/sys/$(am__dirstamp)
+core/sys/openbsd/sys/elf.lo: core/sys/openbsd/sys/$(am__dirstamp)
+core/sys/openbsd/sys/elf32.lo: core/sys/openbsd/sys/$(am__dirstamp)
+core/sys/openbsd/sys/elf64.lo: core/sys/openbsd/sys/$(am__dirstamp)
+core/sys/openbsd/sys/elf_common.lo:  \
+	core/sys/openbsd/sys/$(am__dirstamp)
+core/sys/openbsd/sys/link_elf.lo:  \
+	core/sys/openbsd/sys/$(am__dirstamp)
+core/sys/openbsd/sys/mman.lo: core/sys/openbsd/sys/$(am__dirstamp)
+core/sys/openbsd/time.lo: core/sys/openbsd/$(am__dirstamp)
 core/sys/linux/$(am__dirstamp):
 	@$(MKDIR_P) core/sys/linux
 	@: > core/sys/linux/$(am__dirstamp)
@@ -1753,6 +1776,8 @@ mostlyclean-compile:
 	-rm -f core/sys/netbsd/sys/*.lo
 	-rm -f core/sys/openbsd/*.$(OBJEXT)
 	-rm -f core/sys/openbsd/*.lo
+	-rm -f core/sys/openbsd/sys/*.$(OBJEXT)
+	-rm -f core/sys/openbsd/sys/*.lo
 	-rm -f core/sys/posix/*.$(OBJEXT)
 	-rm -f core/sys/posix/*.lo
 	-rm -f core/sys/posix/arpa/*.$(OBJEXT)
@@ -1871,6 +1896,7 @@ clean-libtool:
 	-rm -rf core/sys/netbsd/.libs core/sys/netbsd/_libs
 	-rm -rf core/sys/netbsd/sys/.libs core/sys/netbsd/sys/_libs
 	-rm -rf core/sys/openbsd/.libs core/sys/openbsd/_libs
+	-rm -rf core/sys/openbsd/sys/.libs core/sys/openbsd/sys/_libs
 	-rm -rf core/sys/posix/.libs core/sys/posix/_libs
 	-rm -rf core/sys/posix/arpa/.libs core/sys/posix/arpa/_libs
 	-rm -rf core/sys/posix/net/.libs core/sys/posix/net/_libs
@@ -2025,6 +2051,7 @@ distclean-generic:
 	-rm -f core/sys/netbsd/$(am__dirstamp)
 	-rm -f core/sys/netbsd/sys/$(am__dirstamp)
 	-rm -f core/sys/openbsd/$(am__dirstamp)
+	-rm -f core/sys/openbsd/sys/$(am__dirstamp)
 	-rm -f core/sys/posix/$(am__dirstamp)
 	-rm -f core/sys/posix/arpa/$(am__dirstamp)
 	-rm -f core/sys/posix/net/$(am__dirstamp)

libphobos/libdruntime/core/stdc/assert_.d

@@ -60,6 +60,15 @@ else version (NetBSD)
      */
     void __assert(const(char)* file, int line, const(char)* exp);
 }
+else version (OpenBSD)
+{
+    /***
+     * Assert failure function in the NetBSD C library.
+     */
+    void __assert(const(char)* file, int line, const(char)* exp);
+    ///
+    void __assert2(const(char)* file, int line, const(char)* func, const(char)* exp);
+}
 else version (DragonFlyBSD)
 {
     /***

libphobos/libdruntime/core/stdc/stdio.d

@@ -425,12 +425,23 @@ else version (CRuntime_Glibc)
         void*   _markers;
         _IO_FILE* _chain;
         int     _fileno;
-        int     _blksize;
-        int     _old_offset;
+        int     _flags2;
+        ptrdiff_t _old_offset;
         ushort  _cur_column;
         byte    _vtable_offset;
         char[1] _shortbuf = 0;
         void*   _lock;
+
+        ptrdiff_t _offset;
+
+        /*_IO_codecvt*/ void* _codecvt;
+        /*_IO_wide_data*/ void* _wide_data;
+        _IO_FILE *_freeres_list;
+        void *_freeres_buf;
+        size_t __pad5;
+        int _mode;
+
+        char[15 * int.sizeof - 4 * (void*).sizeof - size_t.sizeof] _unused2;
     }
 
     ///
@@ -621,6 +632,8 @@ else version (OpenBSD)
     }
 
     ///
+    alias __sFILE _iobuf;
+    ///
     alias shared(__sFILE) FILE;
 }
 else version (DragonFlyBSD)
@@ -994,14 +1007,16 @@ else version (OpenBSD)
         _IONBF = 2,
     }
 
-    private extern shared FILE[] __sF;
-
+    private extern __gshared FILE[3] __sF;
+    @property auto __stdin()() { return &__sF[0]; }
+    @property auto __stdout()() { return &__sF[1]; }
+    @property auto __stderr()() { return &__sF[2]; }
     ///
-    shared stdin  = &__sF[0];
+    alias __stdin stdin;
     ///
-    shared stdout = &__sF[1];
+    alias __stdout stdout;
     ///
-    shared stderr = &__sF[2];
+    alias __stderr stderr;
 }
 else version (DragonFlyBSD)
 {
@@ -1476,17 +1491,17 @@ else version (OpenBSD)
     @trusted private
     {
         ///
-        pure void clearerr(FILE*);
-        alias __clearerr = clearerr;
+        pragma(mangle, "clearerr")
+        pure void __clearerr(FILE*);
         ///
-        pure int  feof(FILE*);
-        alias __feof = feof;
+        pragma(mangle, "feof")
+        pure int __feof(FILE*);
         ///
-        pure int  ferror(FILE*);
-        alias __ferror = ferror;
+        pragma(mangle, "ferror")
+        pure int __ferror(FILE*);
         ///
-        int  fileno(FILE*);
-        alias __fileno = fileno;
+        pragma(mangle, "fileno")
+        int __fileno(FILE*);
     }
 
     enum __SLBF = 0x0001;
@@ -1506,9 +1521,9 @@ else version (OpenBSD)
     enum __SALC = 0x4000;
     enum __SIGN = 0x8000;
 
-    extern int __isthreaded;
+    extern immutable __gshared int __isthreaded;
 
-    extern (D)
+    extern (D) @trusted
     {
         void __sclearerr()(FILE* p)
         {
@@ -1530,17 +1545,17 @@ else version (OpenBSD)
             return p._file;
         }
 
-        int clearerr()(FILE* file)
+        pure void clearerr()(FILE* file)
         {
-            return !__isthreaded ? __sclearerr(file) : __clearerr(file);
+            !__isthreaded ? __sclearerr(file) : __clearerr(file);
         }
 
-        int feof()(FILE* file)
+        pure int feof()(FILE* file)
         {
             return !__isthreaded ? __sfeof(file) : __feof(file);
         }
 
-        int ferror()(FILE* file)
+        pure int ferror()(FILE* file)
         {
             return !__isthreaded ? __sferror(file) : __ferror(file);
         }

libphobos/libdruntime/core/sys/openbsd/sys/cdefs.d

+/**
+ * D header file for OpenBSD
+ *
+ * Authors: Iain Buclaw
+ */
+module core.sys.openbsd.sys.cdefs;
+
+version (OpenBSD):
+
+public import core.sys.posix.config;
+
+enum __XPG_VISIBLE = 700;
+enum __POSIX_VISIBLE = 200809;
+enum __ISO_C_VISIBLE = 1999;
+enum __BSD_VISIBLE = true;

libphobos/libdruntime/core/sys/openbsd/sys/elf.d

+/**
+ * D header file for OpenBSD.
+ *
+ * Authors:  Iain Buclaw
+ * Based-on: core/sys/freebsd/sys
+ */
+module core.sys.openbsd.sys.elf;
+
+version (OpenBSD):
+
+public import core.sys.openbsd.sys.elf32;
+public import core.sys.openbsd.sys.elf64;

libphobos/libdruntime/core/sys/openbsd/sys/elf32.d

+/**
+ * D header file for OpenBSD.
+ *
+ * Authors:  Iain Buclaw
+ * Based-on: core/sys/freebsd/sys
+ */
+module core.sys.openbsd.sys.elf32;
+
+version (OpenBSD):
+
+extern (C):
+
+import core.stdc.stdint;
+public import core.sys.openbsd.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 = 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 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;
+}

libphobos/libdruntime/core/sys/openbsd/sys/elf64.d

+/**
+ * D header file for OpenBSD.
+ *
+ * Authors:  Iain Buclaw
+ * Based-on: core/sys/freebsd/sys
+ */
+module core.sys.openbsd.sys.elf64;
+
+version (OpenBSD):
+
+extern (C):
+
+import core.stdc.stdint;
+public import core.sys.openbsd.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 = 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;
+}
+
+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;
+}

libphobos/libdruntime/core/sys/openbsd/sys/link_elf.d

+/**
+ * D header file for OpenBSD.
+ *
+ * Authors:  Iain Buclaw
+ * Based-on: core/sys/freebsd/sys
+ */
+module core.sys.openbsd.sys.link_elf;
+
+version (OpenBSD):
+
+extern (C) nothrow @system:
+
+import core.sys.posix.config;
+import core.sys.posix.sys.types;
+import core.sys.openbsd.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;");
+}
+
+struct link_map
+{
+    caddr_t     l_addr;
+    char*       l_name;
+    void*       l_ld;
+    link_map*   l_next;
+    link_map*   l_prev;
+}
+
+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;
+    typeof(RT_CONSISTENT) r_state;
+    c_ulong               r_ldbase;
+}
+
+struct dl_phdr_info
+{
+    ElfW!"Addr"     dlpi_addr;
+    char*           dlpi_name;
+    ElfW!"Phdr"*    dlpi_phdr;
+    ElfW!"Half"     dlpi_phnum;
+};
+
+
+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;

libphobos/libdruntime/core/sys/openbsd/sys/mman.d

+/**
+ * D header file for OpenBSD
+ *
+ * Authors:  Iain Buclaw
+ * Based-on: core/sys/freebsd/sys
+ */
+module core.sys.openbsd.sys.mman;
+
+version (OpenBSD):
+extern (C):
+nothrow:
+
+public import core.sys.posix.sys.mman;
+import core.sys.openbsd.sys.cdefs;
+import core.sys.posix.sys.types;
+
+// already in core.sys.posix.sys.mman
+// enum MAP_SHARED = 0x0001;
+// enum MAP_PRIVATE = 0x0002;
+// enum MAP_FIXED = 0x0010;
+// enum MAP_ANON = 0x1000;
+
+alias MAP_ANONYMOUS = MAP_ANON;
+enum MAP_STACK = 0x4000;
+
+enum MAP_FLAGMASK = 0x7ff7;
+
+alias MAP_COPY = MAP_PRIVATE;
+enum MAP_FILE = 0;
+enum MAP_HASSEMAPHORE = 0;
+enum MAP_INHERIT = 0;
+enum MAP_NOEXTEND = 0;
+enum MAP_NORESERVE = 0;
+enum MAP_RENAME = 0;
+enum MAP_TRYFIXED = 0;
+
+static if (__BSD_VISIBLE)
+{
+    alias MADV_NORMAL = POSIX_MADV_NORMAL;
+    alias MADV_RANDOM = POSIX_MADV_RANDOM;
+    alias MADV_SEQUENTIAL = POSIX_MADV_SEQUENTIAL;
+    alias MADV_WILLNEED = POSIX_MADV_WILLNEED;
+    alias MADV_DONTNEED = POSIX_MADV_DONTNEED;
+    enum MADV_SPACEAVAIL = 5;
+    enum MADV_FREE = 6;
+
+    int madvise(void *, size_t, int);
+    int mincore(const(void) *, size_t, char *);
+    int minherit(void *, size_t, int);
+    void* mquery(void *, size_t, int, int, int, off_t);
+}

libphobos/libdruntime/core/sys/openbsd/time.d

+//Written in the D programming language
+
+/++
+    D header file for OpenBSD's extensions to POSIX's time.h.
+
+    Copyright: Copyright 2019
+    License:   $(HTTP www.boost.org/LICENSE_1_0.txt, Boost License 1.0).
+    Authors:   Iain Buclaw
+ +/
+module core.sys.openbsd.time;
+
+public import core.sys.posix.time;
+
+version (OpenBSD):
+
+enum CLOCK_REALTIME           = 0;
+enum CLOCK_PROCESS_CPUTIME_ID = 2;
+enum CLOCK_MONOTONIC          = 3;
+enum CLOCK_THREAD_CPUTIME_ID  = 4;
+enum CLOCK_UPTIME             = 5;
+enum CLOCK_BOOTTIME           = 6;

libphobos/libdruntime/core/sys/posix/aio.d

@@ -203,6 +203,10 @@ else version (NetBSD)
 
     version = BSD_Posix;
 }
+else version (OpenBSD)
+{
+    // OpenBSD does not define aiocb.
+}
 else version (DragonFlyBSD)
 {
     struct aiocb
@@ -442,7 +446,7 @@ version (CRuntime_Glibc)
         int lio_listio(int mode, const(aiocb*)* aiocb_list, int nitems, sigevent* sevp);
     }
 }
-version (CRuntime_UClibc)
+else version (CRuntime_UClibc)
 {
     static if (__USE_LARGEFILE64)
     {
@@ -476,6 +480,10 @@ version (CRuntime_UClibc)
         int lio_listio(int mode, const(aiocb*)* aiocb_list, int nitems, sigevent* sevp);
     }
 }
+else version (OpenBSD)
+{
+    // OpenBSD does not implement aio.h
+}
 else
 {
     int aio_read(aiocb* aiocbp);

libphobos/libdruntime/core/sys/posix/arpa/inet.d

@@ -158,6 +158,47 @@ else version (NetBSD)
     const(char)*    inet_ntop(int, in void*, char*, socklen_t);
     int             inet_pton(int, in char*, void*);
 }
+else version (OpenBSD)
+{
+    alias uint16_t in_port_t;
+    alias uint32_t in_addr_t;
+
+    struct in_addr
+    {
+        in_addr_t s_addr;
+    }
+
+    enum INET_ADDRSTRLEN = 16;
+
+    @safe pure extern (D)
+    {
+        private
+        {
+            uint32_t __swap32( uint32_t x )
+            {
+                uint32_t byte32_swap = (x & 0xff) << 24 | (x &0xff00) << 8 |
+                                     (x & 0xff0000) >> 8 | (x & 0xff000000) >> 24;
+                return byte32_swap;
+            }
+
+            uint16_t __swap16( uint16_t x )
+            {
+                uint16_t byte16_swap = (x & 0xff) << 8 | (x & 0xff00) >> 8;
+                return byte16_swap;
+            }
+        }
+
+        uint32_t htonl(uint32_t x) { return __swap32(x); }
+        uint16_t htons(uint16_t x) { return __swap16(x); }
+        uint32_t ntohl(uint32_t x) { return __swap32(x); }
+        uint16_t ntohs(uint16_t x) { return __swap16(x); }
+    }
+
+    in_addr_t       inet_addr(in char*);
+    char*           inet_ntoa(in_addr);
+    const(char)*    inet_ntop(int, in void*, char*, socklen_t);
+    int             inet_pton(int, in char*, void*);
+}
 else version (DragonFlyBSD)
 {
     alias uint16_t in_port_t;
@@ -324,6 +365,10 @@ else version (NetBSD)
 {
     enum INET6_ADDRSTRLEN = 46;
 }
+else version (OpenBSD)
+{
+    enum INET6_ADDRSTRLEN = 46;
+}
 else version (DragonFlyBSD)
 {
     enum INET6_ADDRSTRLEN = 46;

libphobos/libdruntime/core/sys/posix/config.d

@@ -111,6 +111,59 @@ else version (CRuntime_Bionic)
 {
     enum __USE_GNU           = false;
 }
+else version (OpenBSD)
+{
+    version (Alpha)
+    {
+        enum _ALIGNBYTES = 7;
+        enum _STACKALIGNBYTES = 7;
+        enum _MAX_PAGE_SHIFT = 13;
+    }
+    else version (X86_64)
+    {
+        enum _ALIGNBYTES = c_long.sizeof - 1;
+        enum _STACKALIGNBYTES = 15;
+        enum _MAX_PAGE_SHIFT = 12;
+    }
+    else version (AArch64)
+    {
+        enum _ALIGNBYTES = c_long.sizeof - 1;
+        enum _STACKALIGNBYTES = 15;
+        enum _MAX_PAGE_SHIFT = 12;
+    }
+    else version (ARM)
+    {
+        enum _ALIGNBYTES = 7;
+        enum _STACKALIGNBYTES = 7;
+        enum _MAX_PAGE_SHIFT = 12;
+    }
+    else version (HPPA)
+    {
+        enum _ALIGNBYTES = 7;
+        enum _STACKALIGNBYTES = 7;
+        enum _MAX_PAGE_SHIFT = 12;
+    }
+    else version (X86)
+    {
+        enum _ALIGNBYTES = 3;
+        enum _STACKALIGNBYTES = 15;
+        enum _MAX_PAGE_SHIFT = 12;
+    }
+    else version (PPC)
+    {
+        enum _ALIGNBYTES = 7;
+        enum _STACKALIGNBYTES = 15;
+        enum _MAX_PAGE_SHIFT = 12;
+    }
+    else version (SPARC64)
+    {
+        enum _ALIGNBYTES = 15;
+        enum _STACKALIGNBYTES = 15;
+        enum _MAX_PAGE_SHIFT = 13;
+    }
+    else
+        static assert(false, "Architecture not supported.");
+}
 else version (Solaris)
 {
     enum _FILE_OFFSET_BITS = 64;

libphobos/libdruntime/core/sys/posix/net/if_.d

@@ -106,6 +106,21 @@ else version (NetBSD)
     if_nameindex_t* if_nameindex();
     void            if_freenameindex(if_nameindex_t*);
 }
+else version (OpenBSD)
+{
+    struct if_nameindex_t
+    {
+        uint    if_index;
+        char*   if_name;
+    }
+
+    enum IF_NAMESIZE = 16;
+
+    uint            if_nametoindex(in char*);
+    char*           if_indextoname(uint, char*);
+    if_nameindex_t* if_nameindex();
+    void            if_freenameindex(if_nameindex_t*);
+}
 else version (DragonFlyBSD)
 {
     struct if_nameindex_t

libphobos/libdruntime/core/sys/posix/netinet/in_.d

@@ -246,6 +246,40 @@ else version (NetBSD)
 
     //enum INET_ADDRSTRLEN       = 16;
 }
+else version (OpenBSD)
+{
+    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
+    {
+        IPPROTO_IP   = 0,
+        IPPROTO_ICMP = 1,
+        IPPROTO_IGMP = 2,
+        IPPROTO_GGP  = 3,
+        IPPROTO_TCP  = 6,
+        IPPROTO_PUP  = 12,
+        IPPROTO_UDP  = 17,
+        IPPROTO_IDP  = 22,
+        IPPROTO_MAX  = 256
+    }
+
+    enum : uint
+    {
+        INADDR_ANY       = 0x00000000,
+        INADDR_BROADCAST = 0xffffffff,
+        INADDR_LOOPBACK  = 0x7f000001,
+        INADDR_NONE      = 0xffffffff
+    }
+
+    enum INET_ADDRSTRLEN       = 16;
+}
 else version (DragonFlyBSD)
 {
     //alias uint16_t in_port_t;
@@ -991,6 +1025,145 @@ else version (NetBSD)
                __IPV6_ADDR_MC_SCOPE(a) == __IPV6_ADDR_SCOPE_GLOBAL;
     }
 }
+else version (OpenBSD)
+{
+    struct in6_addr
+    {
+        union
+        {
+            uint8_t[16] s6_addr;
+            uint16_t[8] s6_addr16;
+            uint32_t[4] s6_addr32;
+        }
+    }
+
+    struct sockaddr_in6
+    {
+        uint8_t     sin6_len;
+        sa_family_t sin6_family;
+        in_port_t   sin6_port;
+        uint32_t    sin6_flowinfo;
+        in6_addr    sin6_addr;
+        uint32_t    sin6_scope_id;
+    }
+
+    extern __gshared immutable in6_addr in6addr_any;
+    extern __gshared immutable in6_addr in6addr_loopback;
+
+    struct ipv6_mreq
+    {
+        in6_addr    ipv6mr_multiaddr;
+        uint        ipv6mr_interface;
+    }
+
+    enum : uint
+    {
+        IPPROTO_IPV6        = 41,
+
+        INET6_ADDRSTRLEN    = 46,
+
+        IPV6_JOIN_GROUP     = 12,
+        IPV6_LEAVE_GROUP    = 13,
+        IPV6_MULTICAST_HOPS = 10,
+        IPV6_MULTICAST_IF   = 9,
+        IPV6_MULTICAST_LOOP = 11,
+        IPV6_UNICAST_HOPS   = 4,
+        IPV6_V6ONLY         = 27,
+    }
+
+    private enum
+    {
+        __IPV6_ADDR_SCOPE_NODELOCAL     = 0x01,
+        __IPV6_ADDR_SCOPE_INTFACELOCAL  = 0x01,
+        __IPV6_ADDR_SCOPE_LINKLOCAL     = 0x02,
+        __IPV6_ADDR_SCOPE_SITELOCAL     = 0x05,
+        __IPV6_ADDR_SCOPE_ORGLOCAL      = 0x08,
+        __IPV6_ADDR_SCOPE_GLOBAL        = 0x0e,
+    }
+
+    // macros
+    extern (D) int IN6_IS_ADDR_UNSPECIFIED( in in6_addr* a ) pure
+    {
+        return (*cast(const uint32_t*) cast(const void*) (&a.s6_addr[0]) == 0) &&
+               (*cast(const uint32_t*) cast(const void*) (&a.s6_addr[4]) == 0) &&
+               (*cast(const uint32_t*) cast(const void*) (&a.s6_addr[8]) == 0) &&
+               (*cast(const uint32_t*) cast(const void*) (&a.s6_addr[12]) == 0);
+    }
+
+    extern (D) int IN6_IS_ADDR_LOOPBACK( in in6_addr* a ) pure
+    {
+        return (*cast(const uint32_t*) cast(const void*) (&a.s6_addr[0]) == 0) &&
+               (*cast(const uint32_t*) cast(const void*) (&a.s6_addr[4]) == 0) &&
+               (*cast(const uint32_t*) cast(const void*) (&a.s6_addr[8]) == 0) &&
+               (*cast(const uint32_t*) cast(const void*) (&a.s6_addr[12]) == ntohl(1));
+    }
+
+    extern (D) int IN6_IS_ADDR_V4COMPAT( in in6_addr* a ) pure
+    {
+        return (*cast(const uint32_t*) cast(const void*) (&a.s6_addr[0]) == 0) &&
+               (*cast(const uint32_t*) cast(const void*) (&a.s6_addr[4]) == 0) &&
+               (*cast(const uint32_t*) cast(const void*) (&a.s6_addr[8]) == 0) &&
+               (*cast(const uint32_t*) cast(const void*) (&a.s6_addr[12]) != 0) &&
+               (*cast(const uint32_t*) cast(const void*) (&a.s6_addr[12]) != ntohl(1));
+    }
+
+    extern (D) int IN6_IS_ADDR_V4MAPPED( in in6_addr* a ) pure
+    {
+        return (*cast(const uint32_t*) cast(const void*) (&a.s6_addr[0]) == 0) &&
+               (*cast(const uint32_t*) cast(const void*) (&a.s6_addr[4]) == 0) &&
+               (*cast(const uint32_t*) cast(const void*) (&a.s6_addr[8]) == ntohl(0x0000ffff));
+    }
+
+    extern (D) int IN6_IS_ADDR_LINKLOCAL( in in6_addr* a ) pure
+    {
+        return a.s6_addr[0] == 0xfe && (a.s6_addr[1] & 0xc0) == 0x80;
+    }
+
+    extern (D) int IN6_IS_ADDR_SITELOCAL( in in6_addr* a ) pure
+    {
+        return a.s6_addr[0] == 0xfe && (a.s6_addr[1] & 0xc0) == 0xc0;
+    }
+
+    extern (D) int IN6_IS_ADDR_MULTICAST( in in6_addr* a ) pure
+    {
+        return a.s6_addr[0] == 0xff;
+    }
+
+    extern (D) uint8_t __IPV6_ADDR_MC_SCOPE( in in6_addr* a ) pure
+    {
+        return a.s6_addr[1] & 0x0f;
+    }
+
+    extern (D) int IN6_IS_ADDR_MC_NODELOCAL( in in6_addr* a ) pure
+    {
+        return IN6_IS_ADDR_MULTICAST(a) &&
+               __IPV6_ADDR_MC_SCOPE(a) == __IPV6_ADDR_SCOPE_NODELOCAL;
+    }
+
+    extern (D) int IN6_IS_ADDR_MC_LINKLOCAL( in in6_addr* a ) pure
+    {
+        return IN6_IS_ADDR_MULTICAST(a) &&
+               __IPV6_ADDR_MC_SCOPE(a) == __IPV6_ADDR_SCOPE_LINKLOCAL;
+    }
+
+    extern (D) int IN6_IS_ADDR_MC_SITELOCAL( in in6_addr* a ) pure
+    {
+        return IN6_IS_ADDR_MULTICAST(a) &&
+               __IPV6_ADDR_MC_SCOPE(a) == __IPV6_ADDR_SCOPE_SITELOCAL;
+    }
+
+    extern (D) int IN6_IS_ADDR_MC_ORGLOCAL( in in6_addr* a ) pure
+    {
+        return IN6_IS_ADDR_MULTICAST(a) &&
+               __IPV6_ADDR_MC_SCOPE(a) == __IPV6_ADDR_SCOPE_ORGLOCAL;
+    }
+
+    extern (D) int IN6_IS_ADDR_MC_GLOBAL( in in6_addr* a ) pure
+    {
+        return IN6_IS_ADDR_MULTICAST(a) &&
+               __IPV6_ADDR_MC_SCOPE(a) == __IPV6_ADDR_SCOPE_GLOBAL;
+    }
+}
 else version (DragonFlyBSD)
 {
     struct in6_addr
@@ -1576,6 +1749,10 @@ else version (NetBSD)
 {
     enum uint IPPROTO_RAW = 255;
 }
+else version (OpenBSD)
+{
+    enum uint IPPROTO_RAW = 255;
+}
 else version (DragonFlyBSD)
 {
     enum uint IPPROTO_RAW = 255;

libphobos/libdruntime/core/sys/posix/netinet/tcp.d

@@ -51,6 +51,10 @@ else version (NetBSD)
 {
     enum TCP_NODELAY = 1;
 }
+else version (OpenBSD)
+{
+    enum TCP_NODELAY = 1;
+}
 else version (DragonFlyBSD)
 {
     enum TCP_NODELAY = 1;

libphobos/libdruntime/core/sys/posix/signal.d

@@ -3393,6 +3393,8 @@ else version (NetBSD)
 }
 else version (OpenBSD)
 {
+    // OpenBSD does not implement sigevent.
+    alias sigevent = void;
 }
 else version (DragonFlyBSD)
 {

libphobos/libdruntime/core/sys/posix/sys/ioctl.d

@@ -379,6 +379,18 @@ else version (NetBSD)
 
     int ioctl(int, c_ulong, ...);
 }
+else version (OpenBSD)
+{
+    struct winsize
+    {
+        ushort ws_row;
+        ushort ws_col;
+        ushort ws_xpixel;
+        ushort ws_ypixel;
+    }
+
+    int ioctl(int, c_ulong, ...);
+}
 else version (DragonFlyBSD)
 {
     struct fiodgname_arg

libphobos/libdruntime/core/sys/posix/sys/ipc.d

@@ -149,6 +149,31 @@ else version (NetBSD)
 
     key_t ftok(in char*, int);
 }
+else version (OpenBSD)
+{
+    struct ipc_perm
+    {
+        uid_t   cuid;
+        gid_t   cgid;
+        uid_t   uid;
+        gid_t   gid;
+        mode_t  mode;
+        ushort  seq;
+        key_t   key;
+    }
+
+    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(in char*, int);
+}
 else version (DragonFlyBSD)
 {
     struct ipc_perm

libphobos/libdruntime/core/sys/posix/sys/mman.d

@@ -111,6 +111,15 @@ else version (NetBSD)
     enum POSIX_MADV_DONTNEED    = 4;
     int posix_madvise(void *addr, size_t len, int advice);
 }
+else version (OpenBSD)
+{
+    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 version (DragonFlyBSD)
 {
     enum POSIX_MADV_NORMAL      = 0;
@@ -184,6 +193,13 @@ else version (NetBSD)
     enum PROT_WRITE     = 0x02;
     enum PROT_EXEC      = 0x04;
 }
+else version (OpenBSD)
+{
+    enum PROT_NONE      = 0x00;
+    enum PROT_READ      = 0x01;
+    enum PROT_WRITE     = 0x02;
+    enum PROT_EXEC      = 0x04;
+}
 else version (DragonFlyBSD)
 {
     enum PROT_NONE      = 0x00;
@@ -256,6 +272,11 @@ else version (NetBSD)
     void* mmap(void*, size_t, int, int, int, off_t);
     int   munmap(void*, size_t);
 }
+else version (OpenBSD)
+{
+    void* mmap(void*, size_t, int, int, int, off_t);
+    int   munmap(void*, size_t);
+}
 else version (DragonFlyBSD)
 {
     void* mmap(void*, size_t, int, int, int, off_t);
@@ -423,6 +444,21 @@ else version (NetBSD)
     int __msync13(void*, size_t, int);
     alias msync = __msync13;
 }
+else version (OpenBSD)
+{
+    enum MAP_SHARED     = 0x0001;
+    enum MAP_PRIVATE    = 0x0002;
+    enum MAP_FIXED      = 0x0010;
+    enum MAP_ANON       = 0x1000;
+
+    enum MAP_FAILED     = cast(void*)-1;
+
+    enum MS_SYNC        = 0x0002;
+    enum MS_ASYNC       = 0x0001;
+    enum MS_INVALIDATE  = 0x0004;
+
+    int msync(void*, size_t, int);
+}
 else version (DragonFlyBSD)
 {
     enum MAP_SHARED     = 0x0001;
@@ -585,6 +621,14 @@ else version (NetBSD)
     int mlockall(int);
     int munlockall();
 }
+else version (OpenBSD)
+{
+    enum MCL_CURRENT    = 0x0001;
+    enum MCL_FUTURE     = 0x0002;
+
+    int mlockall(int);
+    int munlockall();
+}
 else version (DragonFlyBSD)
 {
     enum MCL_CURRENT    = 0x0001;
@@ -657,6 +701,11 @@ else version (NetBSD)
     int mlock(in void*, size_t);
     int munlock(in void*, size_t);
 }
+else version (OpenBSD)
+{
+    int mlock(in void*, size_t);
+    int munlock(in void*, size_t);
+}
 else version (DragonFlyBSD)
 {
     int mlock(in void*, size_t);
@@ -708,6 +757,10 @@ else version (NetBSD)
 {
     int mprotect(void*, size_t, int);
 }
+else version (OpenBSD)
+{
+    int mprotect(void*, size_t, int);
+}
 else version (DragonFlyBSD)
 {
     int mprotect(void*, size_t, int);
@@ -761,6 +814,11 @@ else version (NetBSD)
     int shm_open(in char*, int, mode_t);
     int shm_unlink(in char*);
 }
+else version (OpenBSD)
+{
+    int shm_open(in char*, int, mode_t);
+    int shm_unlink(in char*);
+}
 else version (DragonFlyBSD)
 {
     int shm_open(in char*, int, mode_t);

libphobos/libdruntime/core/sys/posix/sys/resource.d

@@ -301,6 +301,65 @@ else version (NetBSD)
         RLIMIT_AS     = 10,
     }
 }
+else version (OpenBSD)
+{
+    enum
+    {
+        PRIO_PROCESS = 0,
+        PRIO_PGRP    = 1,
+        PRIO_USER    = 2,
+    }
+
+    alias ulong rlim_t;
+
+    enum
+    {
+        RLIM_INFINITY  = (cast(rlim_t)((cast(ulong) 1 << 63) - 1)),
+        RLIM_SAVED_MAX = RLIM_INFINITY,
+        RLIM_SAVED_CUR = RLIM_INFINITY,
+    }
+
+    enum
+    {
+        RUSAGE_SELF     =  0,
+        RUSAGE_CHILDREN = -1,
+        RUSAGE_THREAD   =  1,
+    }
+
+    struct rusage
+    {
+        timeval ru_utime;
+        timeval ru_stime;
+        c_long ru_maxrss;
+        alias ru_ixrss ru_first;
+        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;
+        alias ru_nivcsw ru_last;
+    }
+
+    enum
+    {
+        RLIMIT_CORE   =  4,
+        RLIMIT_CPU    =  0,
+        RLIMIT_DATA   =  2,
+        RLIMIT_FSIZE  =  1,
+        RLIMIT_NOFILE =  8,
+        RLIMIT_STACK  =  3,
+        // OpenBSD does not define the following:
+        //RLIMIT_AS,
+    }
+}
 else version (DragonFlyBSD)
 {
     enum
@@ -652,6 +711,12 @@ else version (NetBSD)
     int getrusage(int, rusage*);
     int setrlimit(int, in rlimit*);
 }
+else version (OpenBSD)
+{
+    int getrlimit(int, rlimit*);
+    int getrusage(int, rusage*);
+    int setrlimit(int, in rlimit*);
+}
 else version (DragonFlyBSD)
 {
     int getrlimit(int, rlimit*);

libphobos/libdruntime/core/sys/posix/sys/select.d

@@ -270,6 +270,53 @@ else version (NetBSD)
     int pselect(int, fd_set*, fd_set*, fd_set*, in timespec*, in sigset_t*);
     int select(int, fd_set*, fd_set*, fd_set*, timeval*);
 }
+else version (OpenBSD)
+{
+    private
+    {
+        alias uint __fd_mask;
+        enum _NFDBITS = __fd_mask.sizeof * 8;
+    }
+
+    enum uint FD_SETSIZE = 1024;
+
+    struct fd_set
+    {
+        __fd_mask[(FD_SETSIZE + (_NFDBITS - 1)) / _NFDBITS] __fds_bits;
+    }
+
+    extern (D) __fd_mask __fdset_mask(uint n) pure
+    {
+        return cast(__fd_mask) 1 << (n % _NFDBITS);
+    }
+
+    extern (D) void FD_CLR(int n, fd_set* p) pure
+    {
+        p.__fds_bits[n / _NFDBITS] &= ~__fdset_mask(n);
+    }
+
+    extern (D) bool FD_ISSET(int n, const(fd_set)* p) pure
+    {
+        return (p.__fds_bits[n / _NFDBITS] & __fdset_mask(n)) != 0;
+    }
+
+    extern (D) void FD_SET(int n, fd_set* p) pure
+    {
+        p.__fds_bits[n / _NFDBITS] |= __fdset_mask(n);
+    }
+
+    extern (D) void FD_ZERO(fd_set* p) pure
+    {
+        fd_set *_p = p;
+        size_t _n = (FD_SETSIZE + (_NFDBITS - 1)) / _NFDBITS;
+
+        while (_n > 0)
+            _p.__fds_bits[--_n] = 0;
+    }
+
+    int pselect(int, fd_set*, fd_set*, fd_set*, in timespec*, in sigset_t*);
+    int select(int, fd_set*, fd_set*, fd_set*, timeval*);
+}
 else version (DragonFlyBSD)
 {
     private

libphobos/libdruntime/core/sys/posix/sys/shm.d

@@ -156,6 +156,35 @@ else version (NetBSD)
     int   shmdt(in void*);
     int   shmget(key_t, size_t, int);
 }
+else version (OpenBSD)
+{
+    enum SHM_RDONLY     = 0x01000; // 010000
+    enum SHM_RND        = 0x02000; // 020000
+    enum SHMLBA         = 1 << _MAX_PAGE_SHIFT;
+
+    alias short shmatt_t;
+
+    struct shmid_ds
+    {
+        ipc_perm   shm_perm;
+        int        shm_segsz;
+        pid_t      shm_lpid;
+        pid_t      shm_cpid;
+        shmatt_t   shm_nattch;
+        time_t     shm_atime;
+        c_long   __shm_atimensec;
+        time_t     shm_dtime;
+        c_long   __shm_dtimensec;
+        time_t     shm_ctime;
+        c_long   __shm_ctimensec;
+        void*      shm_internal;
+    }
+
+    void* shmat(int, in void*, int);
+    int   shmctl(int, int, shmid_ds*);
+    int   shmdt(in void*);
+    int   shmget(key_t, size_t, int);
+}
 else version (DragonFlyBSD)
 {
     enum SHM_RDONLY     = 0x01000; // 010000

libphobos/libdruntime/core/sys/posix/sys/socket.d

@@ -1119,6 +1119,179 @@ else version (NetBSD)
     int     sockatmark(int) @safe;
     int     socketpair(int, int, int, ref int[2]) @safe;
 }
+else version (OpenBSD)
+{
+    alias uint   socklen_t;
+    alias ubyte  sa_family_t;
+
+    struct sockaddr
+    {
+        ubyte       sa_len;
+        sa_family_t sa_family;
+        byte[14]    sa_data;
+    }
+
+    struct sockaddr_storage
+    {
+         ubyte       ss_len;
+         sa_family_t ss_family;
+         byte[6]     __ss_pad1;
+         long        __ss_align;
+         byte[240]   __ss_pad2;
+    }
+
+    struct msghdr
+    {
+        void*     msg_name;
+        socklen_t msg_namelen;
+        iovec*    msg_iov;
+        uint      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
+    }
+
+    private // <sys/_types.h>
+    {
+        extern (D) size_t _ALIGN(size_t p) { return (p + _ALIGNBYTES) & ~_ALIGNBYTES; }
+    }
+
+    extern (D) ubyte* CMSG_DATA(cmsghdr* cmsg)
+    {
+        return cast(ubyte*) cmsg + _ALIGN(cmsghdr.sizeof);
+    }
+
+    extern (D) cmsghdr* CMSG_NXTHDR(msghdr* mhdr, cmsghdr* cmsg)
+    {
+        if (cast(ubyte*) cmsg + _ALIGN(cmsg.cmsg_len) + _ALIGN(cmsghdr.sizeof) >
+                cast(ubyte*) mhdr.msg_control + mhdr.msg_controllen)
+            return null;
+        else
+            return cast(cmsghdr*) (cast(ubyte*) cmsg + _ALIGN(cmsg.cmsg_len));
+    }
+
+    extern (D) cmsghdr* CMSG_FIRSTHDR(msghdr* mhdr)
+    {
+        return mhdr.msg_controllen >= cmsghdr.sizeof ? cast(cmsghdr*) mhdr.msg_control : null;
+    }
+
+    struct linger
+    {
+        int l_onoff;
+        int l_linger;
+    }
+
+    enum
+    {
+        SOCK_DGRAM      = 2,
+        SOCK_RDM        = 4,
+        SOCK_SEQPACKET  = 5,
+        SOCK_STREAM     = 1
+    }
+
+    enum : uint
+    {
+        SOL_SOCKET      = 0xffff
+    }
+
+    enum : uint
+    {
+         SO_DEBUG        = 0x0001,
+         SO_ACCEPTCONN   = 0x0002,
+         SO_REUSEADDR    = 0x0004,
+         SO_KEEPALIVE    = 0x0008,
+         SO_DONTROUTE    = 0x0010,
+         SO_BROADCAST    = 0x0020,
+         SO_USELOOPBACK  = 0x0040,
+         SO_LINGER       = 0x0080,
+         SO_OOBINLINE    = 0x0100,
+         SO_REUSEPORT    = 0x0200,
+         SO_TIMESTAMP    = 0x0800,
+         SO_BINDANY      = 0x1000,
+         SO_ZEROSIZE     = 0x2000,
+
+         SO_SNDBUF       = 0x1001,
+         SO_RCVBUF       = 0x1002,
+         SO_SNDLOWAT     = 0x1003,
+         SO_RCVLOWAT     = 0x1004,
+         SO_SNDTIMEO     = 0x1005,
+         SO_RCVTIMEO     = 0x1006,
+         SO_ERROR        = 0x1007,
+         SO_TYPE         = 0x1008,
+         SO_NETPROC      = 0x1020,
+         SO_RTABLE       = 0x1021,
+         SO_PEERCRED     = 0x1022,
+         SO_SPLICE       = 0x1023,
+    }
+
+    enum
+    {
+        SOMAXCONN       = 128
+    }
+
+    enum : uint
+    {
+         MSG_OOB          = 0x001,
+         MSG_PEEK         = 0x002,
+         MSG_DONTROUTE    = 0x004,
+         MSG_EOR          = 0x008,
+         MSG_TRUNC        = 0x010,
+         MSG_CTRUNC       = 0x020,
+         MSG_WAITALL      = 0x040,
+         MSG_DONTWAIT     = 0x080,
+         MSG_BCAST        = 0x100,
+         MSG_MCAST        = 0x200,
+         MSG_NOSIGNAL     = 0x400,
+         MSG_CMSG_CLOEXEC = 0x800,
+    }
+
+    enum
+    {
+        AF_APPLETALK    = 16,
+        AF_INET         = 2,
+        AF_IPX          = 23,
+        AF_UNIX         = 1,
+        AF_UNSPEC       = 0
+    }
+
+    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 version (DragonFlyBSD)
 {
     alias uint   socklen_t;
@@ -2092,6 +2265,13 @@ else version (NetBSD)
         AF_INET6    = 24
     }
 }
+else version (OpenBSD)
+{
+    enum
+    {
+        AF_INET6    = 24
+    }
+}
 else version (DragonFlyBSD)
 {
     enum
@@ -2164,6 +2344,13 @@ else version (NetBSD)
         SOCK_RAW    = 3
     }
 }
+else version (OpenBSD)
+{
+    enum
+    {
+        SOCK_RAW    = 3
+    }
+}
 else version (DragonFlyBSD)
 {
     enum

libphobos/libdruntime/core/sys/posix/sys/stat.d

@@ -1200,6 +1200,83 @@ else version (NetBSD)
     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 ); }
 }
+else version (OpenBSD)
+{
+    import core.sys.openbsd.sys.cdefs;
+
+    struct stat_t
+    {
+        mode_t    st_mode;
+        dev_t     st_dev;
+        ino_t     st_ino;
+        nlink_t   st_nlink;
+        uid_t     st_uid;
+        gid_t     st_gid;
+        dev_t     st_rdev;
+      static if (__POSIX_VISIBLE >= 200809 || __BSD_VISIBLE)
+      {
+        timespec  st_atim;
+        timespec  st_mtim;
+        timespec  st_ctim;
+        extern(D)
+        {
+            @property ref time_t st_atime() { return st_atim.tv_sec; }
+            @property ref time_t st_mtime() { return st_mtim.tv_sec; }
+            @property ref time_t st_ctime() { return st_ctim.tv_sec; }
+        }
+      }
+      else
+      {
+        time_t    st_atime;
+        long      st_atimensec;
+        time_t    st_mtime;
+        long      st_mtimensec;
+        time_t    st_ctime;
+        long      st_ctimensec;
+      }
+        off_t     st_size;
+        blkcnt_t  st_blocks;
+        blksize_t st_blksize;
+        uint32_t  st_flags;
+        uint32_t  st_gen;
+      static if (__POSIX_VISIBLE >= 200809 || __BSD_VISIBLE)
+      {
+        timespec __st_birthtim;
+      }
+      else
+      {
+        time_t  __st_birthtime;
+        long    __st_birthtimensec;
+      }
+    }
+
+    enum S_IRUSR    = 0x100; // octal 0000400
+    enum S_IWUSR    = 0x080; // octal 0000200
+    enum S_IXUSR    = 0x040; // octal 0000100
+    enum S_IRWXU    = 0x1C0; // octal 0000700
+
+    enum S_IRGRP    = 0x020;  // octal 0000040
+    enum S_IWGRP    = 0x010;  // octal 0000020
+    enum S_IXGRP    = 0x008;  // octal 0000010
+    enum S_IRWXG    = 0x038;  // octal 0000070
+
+    enum S_IROTH    = 0x4; // 0000004
+    enum S_IWOTH    = 0x2; // 0000002
+    enum S_IXOTH    = 0x1; // 0000001
+    enum S_IRWXO    = 0x7; // 0000007
+
+    enum S_ISUID    = 0x800; // octal 0004000
+    enum S_ISGID    = 0x400; // octal 0002000
+    enum S_ISVTX    = 0x200; // octal 0001000
+
+    extern (D) bool S_ISBLK(mode_t mode)  { return (mode & S_IFMT) == S_IFBLK;  }
+    extern (D) bool S_ISCHR(mode_t mode)  { return (mode & S_IFMT) == S_IFCHR;  }
+    extern (D) bool S_ISDIR(mode_t mode)  { return (mode & S_IFMT) == S_IFDIR;  }
+    extern (D) bool S_ISFIFO(mode_t mode) { return (mode & S_IFMT) == S_IFIFO;  }
+    extern (D) bool S_ISREG(mode_t mode)  { return (mode & S_IFMT) == S_IFREG;  }
+    extern (D) bool S_ISLNK(mode_t mode)  { return (mode & S_IFMT) == S_IFLNK;  }
+    extern (D) bool S_ISSOCK(mode_t mode) { return (mode & S_IFMT) == S_IFSOCK; }
+}
 else version (DragonFlyBSD)
 {
     struct stat_t {
@@ -1948,6 +2025,12 @@ else version (NetBSD)
     alias __lstat50 lstat;
     alias __stat50 stat;
 }
+else version (OpenBSD)
+{
+    int   fstat(int, stat_t*);
+    int   lstat(in char*, stat_t*);
+    int   stat(in char*, stat_t*);
+}
 else version (DragonFlyBSD)
 {
     int   fstat(int, stat_t*);
@@ -2066,6 +2149,19 @@ else version (NetBSD)
 
     int mknod(in char*, mode_t, dev_t);
 }
+else version (OpenBSD)
+{
+    enum S_IFMT     = 0xF000; // octal 0170000
+    enum S_IFBLK    = 0x6000; // octal 0060000
+    enum S_IFCHR    = 0x2000; // octal 0020000
+    enum S_IFIFO    = 0x1000; // octal 0010000
+    enum S_IFREG    = 0x8000; // octal 0100000
+    enum S_IFDIR    = 0x4000; // octal 0040000
+    enum S_IFLNK    = 0xA000; // octal 0120000
+    enum S_IFSOCK   = 0xC000; // octal 0140000
+
+    int mknod(in char*, mode_t, dev_t);
+}
 else version (DragonFlyBSD)
 {
     enum S_IFMT     = 0xF000; // octal 0170000

libphobos/libdruntime/core/sys/posix/sys/statvfs.d

@@ -133,6 +133,29 @@ else version (NetBSD)
     int statvfs (const char * file, statvfs_t* buf);
     int fstatvfs (int fildes, statvfs_t *buf) @trusted;
 }
+else version (OpenBSD)
+{
+    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;
+        c_ulong    f_flag;
+        c_ulong    f_namemax;
+    }
+
+    enum uint ST_RDONLY = 1;
+    enum uint ST_NOSUID = 2;
+
+    int statvfs (const char* file, statvfs_t* buf);
+    int fstatvfs (int fildes, statvfs_t* buf) @trusted;
+}
 else version (FreeBSD)
 {
     import core.sys.freebsd.sys.mount;

libphobos/libdruntime/core/sys/posix/sys/time.d

@@ -163,6 +163,32 @@ else version (NetBSD)
     int setitimer(int, in itimerval*, itimerval*);
     int utimes(in char*, ref const(timeval)[2]);
 }
+else version (OpenBSD)
+{
+    struct timeval
+    {
+        time_t      tv_sec;
+        suseconds_t tv_usec;
+    }
+
+    struct itimerval
+    {
+        timeval it_interval;
+        timeval it_value;
+    }
+
+    // non-standard
+    struct timezone_t
+    {
+        int tz_minuteswest;
+        int tz_dsttime;
+    }
+
+    int getitimer(int, itimerval*);
+    int gettimeofday(timeval*, timezone_t*);
+    int setitimer(int, in itimerval*, itimerval*);
+    int utimes(in char*, ref const(timeval)[2]);
+}
 else version (DragonFlyBSD)
 {
     struct timeval

libphobos/libdruntime/core/sys/posix/sys/types.d

@@ -177,6 +177,23 @@ else version (NetBSD)
     alias c_long      time_t;
     alias uint        uid_t;
 }
+else version (OpenBSD)
+{
+    alias char*     caddr_t;
+    alias long      blkcnt_t;
+    alias int       blksize_t;
+    alias int       dev_t;
+    alias uint      gid_t;
+    alias ulong     ino_t;
+    alias uint      mode_t;
+    alias uint      nlink_t;
+    alias long      off_t;
+    alias int       pid_t;
+    //size_t (defined in core.stdc.stddef)
+    alias c_long    ssize_t;
+    alias long      time_t;
+    alias uint      uid_t;
+}
 else version (DragonFlyBSD)
 {
     alias long      blkcnt_t;
@@ -361,6 +378,16 @@ else version (NetBSD)
     alias c_long    suseconds_t;
     alias uint      useconds_t;
 }
+else version (OpenBSD)
+{
+    alias ulong     fsblkcnt_t;
+    alias ulong     fsfilcnt_t;
+    alias long      clock_t;
+    alias uint      id_t;
+    alias c_long    key_t;
+    alias c_long    suseconds_t;
+    alias uint      useconds_t;
+}
 else version (DragonFlyBSD)
 {
     alias ulong     fsblkcnt_t;
@@ -934,6 +961,26 @@ else version (NetBSD)
     alias uint pthread_key_t;
     alias void* pthread_t;
 }
+else version (OpenBSD)
+{
+    alias void* pthread_attr_t;
+    alias void* pthread_cond_t;
+    alias void* pthread_condattr_t;
+    alias int   pthread_key_t;
+    alias void* pthread_mutex_t;
+    alias void* pthread_mutexattr_t;
+
+    private struct pthread_once
+    {
+        int state;
+        pthread_mutex_t mutex;
+    }
+    alias pthread_once pthread_once_t;
+
+    alias void* pthread_rwlock_t;
+    alias void* pthread_rwlockattr_t;
+    alias void* pthread_t;
+}
 else version (DragonFlyBSD)
 {
     alias int lwpid_t;
@@ -1270,6 +1317,11 @@ else version (NetBSD)
     alias void* pthread_barrier_t;
     alias void* pthread_barrierattr_t;
 }
+else version (OpenBSD)
+{
+    alias void* pthread_barrier_t;
+    alias void* pthread_barrierattr_t;
+}
 else version (DragonFlyBSD)
 {
     alias void* pthread_barrier_t;
@@ -1339,6 +1391,10 @@ else version (NetBSD)
 {
     //already defined
 }
+else version (OpenBSD)
+{
+    alias void* pthread_spinlock_t;
+}
 else version (DragonFlyBSD)
 {
     alias void* pthread_spinlock_t;

libphobos/libdruntime/core/sys/posix/sys/uio.d

@@ -90,6 +90,17 @@ else version (NetBSD)
     ssize_t readv(int, in iovec*, int);
     ssize_t writev(int, in iovec*, int);
 }
+else version (OpenBSD)
+{
+    struct iovec
+    {
+        void*  iov_base;
+        size_t iov_len;
+    }
+
+    ssize_t readv(int, in iovec*, int);
+    ssize_t writev(int, in iovec*, int);
+}
 else version (DragonFlyBSD)
 {
     struct iovec

libphobos/libdruntime/core/sys/posix/sys/un.d

@@ -78,6 +78,15 @@ else version (NetBSD)
         byte[104]   sun_path;
     }
 }
+else version (OpenBSD)
+{
+    struct sockaddr_un
+    {
+        ubyte       sun_len;
+        sa_family_t sun_family;
+        byte[104]   sun_path;
+    }
+}
 else version (DragonFlyBSD)
 {
     struct sockaddr_un

libphobos/libdruntime/core/sys/posix/sys/utsname.d

@@ -89,6 +89,21 @@ else version (NetBSD)
 
     int uname(utsname* __name);
 }
+else version (OpenBSD)
+{
+    private enum utsNameLength = 256;
+
+    struct utsname
+    {
+        char[utsNameLength] sysname = 0;
+        char[utsNameLength] nodename = 0;
+        char[utsNameLength] release = 0;
+        char[utsNameLength] version_ = 0;
+        char[utsNameLength] machine = 0;
+    }
+
+    int uname(utsname* __name);
+}
 else version (DragonFlyBSD)
 {
     private enum utsNameLength = 32;

libphobos/libdruntime/core/sys/posix/sys/wait.d

@@ -144,6 +144,29 @@ else version (NetBSD)
     extern (D) int  WSTOPSIG( int status )     { return status >> 8;                     }
     extern (D) int  WTERMSIG( int status )     { return _WSTATUS( status );              }
 }
+else version (OpenBSD)
+{
+    enum WNOHANG        = 1;
+    enum WUNTRACED      = 2;
+
+    private
+    {
+        enum _WSTOPPED   = 0x7F;   // octal 0177
+        enum _WCONTINUED = 0xFFFF; // octal 0177777
+    }
+
+    extern (D) int _WSTATUS(int status)         { return (status & 0x7F);                     }
+    extern (D) int  WEXITSTATUS(int status)   { return (status >> 8) & 0xFF;                  }
+    extern (D) int  WIFCONTINUED(int status)  { return (status & _WCONTINUED) == _WCONTINUED; }
+    extern (D) bool WIFEXITED(int status)     { return _WSTATUS(status) == 0;                 }
+    extern (D) bool WIFSIGNALED(int status)
+    {
+        return _WSTATUS(status) != _WSTOPPED && _WSTATUS(status) != 0;
+    }
+    extern (D) bool WIFSTOPPED(int status)   { return (status & 0xFF) == _WSTOPPED; }
+    extern (D) int  WSTOPSIG(int status)     { return (status >> 8) & 0xFF;         }
+    extern (D) int  WTERMSIG(int status)     { return _WSTATUS(status);             }
+}
 else version (DragonFlyBSD)
 {
     enum WNOHANG        = 1;
@@ -312,6 +335,13 @@ else version (NetBSD)
     //enum WCONTINUED     = 4;
     enum WNOWAIT        = 0x00010000;
 }
+else version (OpenBSD)
+{
+    enum WCONTINUED     = 8;
+    // OpenBSD does not define the following:
+    //enum WSTOPPED
+    //enum WNOWAIT
+}
 else version (DragonFlyBSD)
 {
     enum WSTOPPED       = WUNTRACED;

libphobos/libdruntime/core/sys/posix/syslog.d

@@ -276,6 +276,73 @@ else version (NetBSD)
     void syslog (int __pri, const char *__fmt, ...);
     void closelog();
 }
+else version (OpenBSD)
+{
+    //PRIORITY
+    enum
+    {
+        LOG_EMERG = 0,     /* system is unusable */
+        LOG_ALERT = 1,     /* action must be taken immediately */
+        LOG_CRIT  = 2,     /* critical conditions */
+        LOG_ERR   = 3,     /* error conditions */
+        LOG_WARNING = 4,   /* warning conditions */
+        LOG_NOTICE  = 5,   /* normal but significant condition */
+        LOG_INFO    = 6,   /* informational */
+        LOG_DEBUG   = 7,   /* debug-level messages */
+    }
+
+    //OPTIONS
+    enum
+    {
+        LOG_PID    = 0x01,    /* log the pid with each message */
+        LOG_CONS   = 0x02,    /* log on the console if errors in sending */
+        LOG_ODELAY = 0x04,    /* delay open until first syslog() (default) */
+        LOG_NDELAY = 0x08,    /* don't delay open */
+        LOG_NOWAIT = 0x10,    /* don't wait for console forks: DEPRECATED */
+        LOG_PERROR = 0x20,    /* log to stderr as well */
+    }
+
+    //FACILITY
+    enum
+    {
+        LOG_KERN   = (0<<3),  /* kernel messages */
+        LOG_USER   = (1<<3),  /* random user-level messages */
+        LOG_MAIL   = (2<<3),  /* mail system */
+        LOG_DAEMON = (3<<3),  /* system daemons */
+        LOG_AUTH   = (4<<3),  /* security/authorization messages */
+        LOG_SYSLOG = (5<<3),  /* messages generated internally by syslogd */
+        LOG_LPR    = (6<<3),  /* line printer subsystem */
+        LOG_NEWS   = (7<<3),  /* network news subsystem */
+        LOG_UUCP   = (8<<3),  /* UUCP subsystem */
+        LOG_CRON   = (9<<3),  /* clock daemon */
+        LOG_AUTHPRIV = (10<<3), /* security/authorization messages (private), */
+        LOG_FTP    =  (11<<3), /* ftp daemon */
+        // OpenBSD does not define the following:
+        //LOG_NTP
+        //LOG_SECURITY
+        //LOG_CONSOLE
+
+        /* other codes through 15 reserved for system use */
+        LOG_LOCAL0 = (16<<3), /* reserved for local use */
+        LOG_LOCAL1 = (17<<3), /* reserved for local use */
+        LOG_LOCAL2 = (18<<3), /* reserved for local use */
+        LOG_LOCAL3 = (19<<3), /* reserved for local use */
+        LOG_LOCAL4 = (20<<3), /* reserved for local use */
+        LOG_LOCAL5 = (21<<3), /* reserved for local use */
+        LOG_LOCAL6 = (22<<3), /* reserved for local use */
+        LOG_LOCAL7 = (23<<3), /* reserved for local use */
+
+        LOG_NFACILITIES = 24,  /* current number of facilities */
+    }
+
+    extern(D) int LOG_MASK(int pri) { return 1 << pri; }            /* mask for one priority */
+    extern(D) int LOG_UPTO(int pri) { return (1 << (pri+1)) - 1; }  /* all priorities through pri */
+
+    void openlog(const char *, int, int);
+    int  setlogmask(int);
+    void syslog(int, const char *, ...);
+    void closelog();
+}
 else version (DragonFlyBSD)
 {
     //PRIORITY

libphobos/libdruntime/core/sys/posix/termios.d

@@ -683,6 +683,114 @@ else version (NetBSD)
     int     tcsendbreak(int, int);
     int     tcsetattr(int, int, in termios*);
 }
+else version (OpenBSD)
+{
+    alias uint  tcflag_t;
+    alias ubyte cc_t;
+    alias uint  speed_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;
+        int        c_ispeed;
+        int        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   = 1;
+    enum TCOFLUSH   = 2;
+    enum TCIOFLUSH  = 3;
+
+    enum TCIOFF     = 3;
+    enum TCION      = 4;
+    enum TCOOFF     = 1;
+    enum TCOON      = 2;
+
+    speed_t cfgetispeed(in termios*);
+    speed_t cfgetospeed(in 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, in termios*);
+}
 else version (Solaris)
 {
     alias tcflag_t = uint;
@@ -1141,6 +1249,40 @@ else version (NetBSD)
 
     pid_t   tcgetsid(int);
 }
+else version (OpenBSD)
+{
+    enum IXANY      = 0x00000800;
+
+    enum ONLCR      = 0x00000002;
+    enum OCRNL      = 0x00000010;
+    enum ONOCR      = 0x00000040;
+    enum ONLRET     = 0x00000080;
+    //enum OFILL
+    //enum NLDLY
+    //enum   NL0
+    //enum   NL1
+    //enum CRDLY
+    //enum   CR0
+    //enum   CR1
+    //enum   CR2
+    //enum   CR3
+    //enum TABDLY
+    //enum   TAB0
+    //enum   TAB1
+    //enum   TAB2
+    //enum   TAB3
+    //enum BSDLY
+    //enum   BS0
+    //enum   BS1
+    //enum VTDLY
+    //enum   VT0
+    //enum   VT1
+    //enum FFDLY
+    //enum   FF0
+    //enum   FF1
+
+    pid_t   tcgetsid(int);
+}
 else version (Solaris)
 {
     enum IXANY      = 0x0000800;

libphobos/libdruntime/core/sys/posix/time.d

@@ -65,6 +65,10 @@ else version (NetBSD)
 {
     time_t timegm(tm*); // non-standard
 }
+else version (OpenBSD)
+{
+    time_t timegm(tm*); // non-standard
+}
 else version (DragonFlyBSD)
 {
     time_t timegm(tm*); // non-standard
@@ -145,6 +149,11 @@ else version (NetBSD)
     // time.h
     enum CLOCK_MONOTONIC         = 3;
 }
+else version (OpenBSD)
+{
+    // time.h
+    enum CLOCK_MONOTONIC         = 3;
+}
 else version (DragonFlyBSD)
 {   // time.h
     enum CLOCK_MONOTONIC         = 4;
@@ -335,6 +344,30 @@ else version (NetBSD)
     int timer_getoverrun(timer_t);
     int timer_settime(timer_t, int, in itimerspec*, itimerspec*);
 }
+else version (OpenBSD)
+{
+    struct itimerspec
+    {
+        timespec it_interval;
+        timespec it_value;
+    }
+
+    enum CLOCK_REALTIME      = 0;
+    enum TIMER_ABSTIME       = 0x1;
+
+    alias int clockid_t; // <sys/_types.h>
+    alias int timer_t;
+
+    int clock_getres(clockid_t, timespec*);
+    int clock_gettime(clockid_t, timespec*);
+    int clock_settime(clockid_t, in timespec*);
+    int nanosleep(in timespec*, timespec*);
+    int timer_create(clockid_t, sigevent*, timer_t*);
+    int timer_delete(timer_t);
+    int timer_gettime(timer_t, itimerspec*);
+    int timer_getoverrun(timer_t);
+    int timer_settime(timer_t, int, in itimerspec*, itimerspec*);
+}
 else version (Solaris)
 {
     enum CLOCK_PROCESS_CPUTIME_ID = 5; // <sys/time_impl.h>
@@ -499,6 +532,13 @@ else version (NetBSD)
     tm*   gmtime_r(in time_t*, tm*);
     tm*   localtime_r(in time_t*, tm*);
 }
+else version (OpenBSD)
+{
+    char* asctime_r(in tm*, char*);
+    char* ctime_r(in time_t*, char*);
+    tm*   gmtime_r(in time_t*, tm*);
+    tm*   localtime_r(in time_t*, tm*);
+}
 else version (DragonFlyBSD)
 {
     char* asctime_r(in tm*, char*);
@@ -578,6 +618,11 @@ else version (NetBSD)
     tm*   getdate(in char*);
     char* strptime(in char*, in char*, tm*);
 }
+else version (OpenBSD)
+{
+    //tm*   getdate(in char*);
+    char* strptime(in char*, in char*, tm*);
+}
 else version (DragonFlyBSD)
 {
     //tm*   getdate(in char*);

libphobos/libdruntime/core/sys/posix/ucontext.d

@@ -968,6 +968,189 @@ else version (NetBSD)
 
     }
 }
+else version (OpenBSD)
+{
+    version (Alpha)
+    {
+        struct sigcontext
+        {
+            c_long      sc_cookie;
+            c_long      sc_mask;
+            c_long      sc_pc;
+            c_long      sc_ps;
+            c_ulong[32] sc_regs;
+            c_long      sc_ownedfp;
+            c_ulong[32] sc_fpregs;
+            c_ulong     sc_fpcr;
+            c_ulong     sc_fp_control;
+            c_long[2]   sc_reserved;
+            c_long[8]   sc_xxx;
+        }
+    }
+    else version (X86_64)
+    {
+        struct sigcontext
+        {
+            c_long  sc_rdi;
+            c_long  sc_rsi;
+            c_long  sc_rdx;
+            c_long  sc_rcx;
+            c_long  sc_r8;
+            c_long  sc_r9;
+            c_long  sc_r10;
+            c_long  sc_r11;
+            c_long  sc_r12;
+            c_long  sc_r13;
+            c_long  sc_r14;
+            c_long  sc_r15;
+            c_long  sc_rbp;
+            c_long  sc_rbx;
+            c_long  sc_rax;
+            c_long  sc_gs;
+            c_long  sc_fs;
+            c_long  sc_es;
+            c_long  sc_ds;
+            c_long  sc_trapno;
+            c_long  sc_err;
+            c_long  sc_rip;
+            c_long  sc_cs;
+            c_long  sc_rflags;
+            c_long  sc_rsp;
+            c_long  sc_ss;
+            void*   sc_fpstate;  // struct fxsave64*
+            int   __sc_unused;
+            int     sc_mask;
+            c_long  sc_cookie;
+        }
+    }
+    else version (AArch64)
+    {
+        struct sigcontext
+        {
+            int       __sc_unused;
+            int         sc_mask;
+            c_ulong     sc_sp;
+            c_ulong     sc_lr;
+            c_ulong     sc_elr;
+            c_ulong     sc_spsr;
+            c_ulong[30] sc_x;
+            c_long      sc_cookie;
+        }
+    }
+    else version (ARM)
+    {
+        struct sigcontext
+        {
+            c_long    sc_cookie;
+            int       sc_mask;
+            uint      sc_spsr;
+            uint      sc_r0;
+            uint      sc_r1;
+            uint      sc_r2;
+            uint      sc_r3;
+            uint      sc_r4;
+            uint      sc_r5;
+            uint      sc_r6;
+            uint      sc_r7;
+            uint      sc_r8;
+            uint      sc_r9;
+            uint      sc_r10;
+            uint      sc_r11;
+            uint      sc_r12;
+            uint      sc_usr_sp;
+            uint      sc_usr_lr;
+            uint      sc_svc_lr;
+            uint      sc_pc;
+            uint      sc_fpused;
+            uint      sc_fpscr;
+            ulong[32] sc_fpreg;
+        }
+    }
+    else version (HPPA)
+    {
+        struct sigcontext
+        {
+            c_ulong   __sc_unused;
+            c_long      sc_mask;
+            c_ulong     sc_ps;
+            c_ulong     sc_fp;
+            c_ulong     sc_pcoqh;
+            c_ulong     sc_pcoqt;
+            c_ulong[2]  sc_resv;
+            c_ulong[32] sc_regs;
+            c_ulong[64] sc_fpregs;
+            c_long      sc_cookie;
+        }
+    }
+    else version (X86)
+    {
+        struct sigcontext
+        {
+            int     sc_gs;
+            int     sc_fs;
+            int     sc_es;
+            int     sc_ds;
+            int     sc_edi;
+            int     sc_esi;
+            int     sc_ebp;
+            int     sc_ebx;
+            int     sc_edx;
+            int     sc_ecx;
+            int     sc_eax;
+            int     sc_eip;
+            int     sc_cs;
+            int     sc_eflags;
+            int     sc_esp;
+            int     sc_ss;
+            c_long  sc_cookie;
+            int     sc_mask;
+            int     sc_trapno;
+            int     sc_err;
+            void*   sc_fpstate; // union savefpu*
+        };
+    }
+    else version (PPC)
+    {
+        private struct trapframe
+        {
+            c_long[32] fixreg;
+            c_long lr;
+            c_long cr;
+            c_long xer;
+            c_long ctr;
+            int srr0;
+            int srr1;
+            int dar;
+            int dsisr;
+            c_long exc;
+        }
+
+        struct sigcontext
+        {
+            c_long    sc_cookie;
+            int       sc_mask;
+            trapframe sc_frame;
+        }
+    }
+    else version (SPARC64)
+    {
+        struct sigcontext
+        {
+            c_long sc_cookie;
+            c_long sc_sp;
+            c_long sc_pc;
+            c_long sc_npc;
+            c_long sc_tstate;
+            c_long sc_g1;
+            c_long sc_o0;
+            int    sc_mask;
+        }
+    }
+    else
+        static assert(false, "Architecture not supported.");
+
+    alias ucontext_t = sigcontext;
+}
 else version (DragonFlyBSD)
 {
     // <machine/ucontext.h>

libphobos/libdruntime/core/sys/posix/unistd.d

@@ -131,6 +131,11 @@ else version (NetBSD)
     off_t lseek(int, off_t, int) @trusted;
     int   ftruncate(int, off_t) @trusted;
 }
+else version (OpenBSD)
+{
+    off_t lseek(int, off_t, int) @trusted;
+    int   ftruncate(int, off_t) @trusted;
+}
 else version (DragonFlyBSD)
 {
     off_t lseek(int, off_t, int) @trusted;
@@ -993,6 +998,188 @@ else version (NetBSD)
         _CS_POSIX_V6_WIDTH_RESTRICTED_ENVS =  14,
     }
 }
+else version (OpenBSD)
+{
+    enum F_OK       = 0;
+    enum R_OK       = 0x04;
+    enum W_OK       = 0x02;
+    enum X_OK       = 0x01;
+
+    enum F_ULOCK    = 0;
+    enum F_LOCK     = 1;
+    enum F_TLOCK    = 2;
+    enum F_TEST     = 3;
+
+    enum
+    {
+        _SC_ARG_MAX                      =  1,
+        _SC_CHILD_MAX                    =  2,
+        _O_SC_CLK_TCK                    =  3,
+        _SC_NGROUPS_MAX                  =  4,
+        _SC_OPEN_MAX                     =  5,
+        _SC_JOB_CONTROL                  =  6,
+        _SC_SAVED_IDS                    =  7,
+        _SC_VERSION                      =  8,
+        _SC_BC_BASE_MAX                  =  9,
+        _SC_BC_DIM_MAX                   = 10,
+        _SC_BC_SCALE_MAX                 = 11,
+        _SC_BC_STRING_MAX                = 12,
+        _SC_COLL_WEIGHTS_MAX             = 13,
+        _SC_EXPR_NEST_MAX                = 14,
+        _SC_LINE_MAX                     = 15,
+        _SC_RE_DUP_MAX                   = 16,
+        _SC_2_VERSION                    = 17,
+        _SC_2_C_BIND                     = 18,
+        _SC_2_C_DEV                      = 19,
+        _SC_2_CHAR_TERM                  = 20,
+        _SC_2_FORT_DEV                   = 21,
+        _SC_2_FORT_RUN                   = 22,
+        _SC_2_LOCALEDEF                  = 23,
+        _SC_2_SW_DEV                     = 24,
+        _SC_2_UPE                        = 25,
+        _SC_STREAM_MAX                   = 26,
+        _SC_TZNAME_MAX                   = 27,
+        _SC_PAGESIZE                     = 28,
+        _SC_FSYNC                        = 29,
+        _SC_XOPEN_SHM                    = 30,
+        _SC_SEM_NSEMS_MAX                = 31,
+        _SC_SEM_VALUE_MAX                = 32,
+        _SC_HOST_NAME_MAX                = 33,
+        _SC_MONOTONIC_CLOCK              = 34,
+        _SC_2_PBS                        = 35,
+        _SC_2_PBS_ACCOUNTING             = 36,
+        _SC_2_PBS_CHECKPOINT             = 37,
+        _SC_2_PBS_LOCATE                 = 38,
+        _SC_2_PBS_MESSAGE                = 39,
+        _SC_2_PBS_TRACK                  = 40,
+        _SC_ADVISORY_INFO                = 41,
+        _SC_AIO_LISTIO_MAX               = 42,
+        _SC_AIO_MAX                      = 43,
+        _SC_AIO_PRIO_DELTA_MAX           = 44,
+        _SC_ASYNCHRONOUS_IO              = 45,
+        _SC_ATEXIT_MAX                   = 46,
+        _SC_BARRIERS                     = 47,
+        _SC_CLOCK_SELECTION              = 48,
+        _SC_CPUTIME                      = 49,
+        _SC_DELAYTIMER_MAX               = 50,
+        _SC_IOV_MAX                      = 51,
+        _SC_IPV6                         = 52,
+        _SC_MAPPED_FILES                 = 53,
+        _SC_MEMLOCK                      = 54,
+        _SC_MEMLOCK_RANGE                = 55,
+        _SC_MEMORY_PROTECTION            = 56,
+        _SC_MESSAGE_PASSING              = 57,
+        _SC_MQ_OPEN_MAX                  = 58,
+        _SC_MQ_PRIO_MAX                  = 59,
+        _SC_PRIORITIZED_IO               = 60,
+        _SC_PRIORITY_SCHEDULING          = 61,
+        _SC_RAW_SOCKETS                  = 62,
+        _SC_READER_WRITER_LOCKS          = 63,
+        _SC_REALTIME_SIGNALS             = 64,
+        _SC_REGEXP                       = 65,
+        _SC_RTSIG_MAX                    = 66,
+        _SC_SEMAPHORES                   = 67,
+        _SC_SHARED_MEMORY_OBJECTS        = 68,
+        _SC_SHELL                        = 69,
+        _SC_SIGQUEUE_MAX                 = 70,
+        _SC_SPAWN                        = 71,
+        _SC_SPIN_LOCKS                   = 72,
+        _SC_SPORADIC_SERVER              = 73,
+        _SC_SS_REPL_MAX                  = 74,
+        _SC_SYNCHRONIZED_IO              = 75,
+        _SC_SYMLOOP_MAX                  = 76,
+        _SC_THREAD_ATTR_STACKADDR        = 77,
+        _SC_THREAD_ATTR_STACKSIZE        = 78,
+        _SC_THREAD_CPUTIME               = 79,
+        _SC_THREAD_DESTRUCTOR_ITERATIONS = 80,
+        _SC_THREAD_KEYS_MAX              = 81,
+        _SC_THREAD_PRIO_INHERIT          = 82,
+        _SC_THREAD_PRIO_PROTECT          = 83,
+        _SC_THREAD_PRIORITY_SCHEDULING   = 84,
+        _SC_THREAD_PROCESS_SHARED        = 85,
+        _SC_THREAD_ROBUST_PRIO_INHERIT   = 86,
+        _SC_THREAD_ROBUST_PRIO_PROTECT   = 87,
+        _SC_THREAD_SPORADIC_SERVER       = 88,
+        _SC_THREAD_STACK_MIN             = 89,
+        _SC_THREAD_THREADS_MAX           = 90,
+        _SC_THREADS                      = 91,
+        _SC_TIMEOUTS                     = 92,
+        _SC_TIMER_MAX                    = 93,
+        _SC_TIMERS                       = 94,
+        _SC_TRACE                        = 95,
+        _SC_TRACE_EVENT_FILTER           = 96,
+        _SC_TRACE_EVENT_NAME_MAX         = 97,
+        _SC_TRACE_INHERIT                = 98,
+        _SC_TRACE_LOG                    = 99,
+        _SC_GETGR_R_SIZE_MAX             = 100,
+        _SC_GETPW_R_SIZE_MAX             = 101,
+        _SC_LOGIN_NAME_MAX               = 102,
+        _SC_THREAD_SAFE_FUNCTIONS        = 103,
+        _SC_TRACE_NAME_MAX               = 104,
+        _SC_TRACE_SYS_MAX                = 105,
+        _SC_TRACE_USER_EVENT_MAX         = 106,
+        _SC_TTY_NAME_MAX                 = 107,
+        _SC_TYPED_MEMORY_OBJECTS         = 108,
+        _SC_V6_ILP32_OFF32               = 109,
+        _SC_V6_ILP32_OFFBIG              = 110,
+        _SC_V6_LP64_OFF64                = 111,
+        _SC_V6_LPBIG_OFFBIG              = 112,
+        _SC_V7_ILP32_OFF32               = 113,
+        _SC_V7_ILP32_OFFBIG              = 114,
+        _SC_V7_LP64_OFF64                = 115,
+        _SC_V7_LPBIG_OFFBIG              = 116,
+        _SC_XOPEN_CRYPT                  = 117,
+        _SC_XOPEN_ENH_I18N               = 118,
+        _SC_XOPEN_LEGACY                 = 119,
+        _SC_XOPEN_REALTIME               = 120,
+        _SC_XOPEN_REALTIME_THREADS       = 121,
+        _SC_XOPEN_STREAMS                = 122,
+        _SC_XOPEN_UNIX                   = 123,
+        _SC_XOPEN_UUCP                   = 124,
+        _SC_XOPEN_VERSION                = 125,
+        _SC_PHYS_PAGES                   = 500,
+        _SC_AVPHYS_PAGES                 = 501,
+        _SC_NPROCESSORS_CONF             = 502,
+        _SC_NPROCESSORS_ONLN             = 503,
+    }
+
+    enum _SC_PAGE_SIZE = _SC_PAGESIZE;
+
+    enum
+    {
+        _CS_PATH                           = 1,
+        _CS_POSIX_V6_ILP32_OFF32_CFLAGS    = 2,
+        _CS_POSIX_V6_ILP32_OFF32_LDFLAGS   = 3,
+        _CS_POSIX_V6_ILP32_OFF32_LIBS      = 4,
+        _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS   = 5,
+        _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS  = 6,
+        _CS_POSIX_V6_ILP32_OFFBIG_LIBS     = 7,
+        _CS_POSIX_V6_LP64_OFF64_CFLAGS     = 8,
+        _CS_POSIX_V6_LP64_OFF64_LDFLAGS    = 9,
+        _CS_POSIX_V6_LP64_OFF64_LIBS       = 10,
+        _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS   = 11,
+        _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS  = 12,
+        _CS_POSIX_V6_LPBIG_OFFBIG_LIBS     = 13,
+        _CS_POSIX_V6_WIDTH_RESTRICTED_ENVS = 14,
+        _CS_V6_ENV                         = 15,
+        _CS_POSIX_V7_ILP32_OFF32_CFLAGS    = 16,
+        _CS_POSIX_V7_ILP32_OFF32_LDFLAGS   = 17,
+        _CS_POSIX_V7_ILP32_OFF32_LIBS      = 18,
+        _CS_POSIX_V7_ILP32_OFFBIG_CFLAGS   = 19,
+        _CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS  = 20,
+        _CS_POSIX_V7_ILP32_OFFBIG_LIBS     = 21,
+        _CS_POSIX_V7_LP64_OFF64_CFLAGS     = 22,
+        _CS_POSIX_V7_LP64_OFF64_LDFLAGS    = 23,
+        _CS_POSIX_V7_LP64_OFF64_LIBS       = 24,
+        _CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS   = 25,
+        _CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS  = 26,
+        _CS_POSIX_V7_LPBIG_OFFBIG_LIBS     = 27,
+        _CS_POSIX_V7_THREADS_CFLAGS        = 28,
+        _CS_POSIX_V7_THREADS_LDFLAGS       = 29,
+        _CS_POSIX_V7_WIDTH_RESTRICTED_ENVS = 30,
+        _CS_V7_ENV                         = 31,
+    }
+}
 else version (DragonFlyBSD)
 {
     enum F_OK       = 0;
@@ -2007,6 +2194,10 @@ else version (NetBSD)
 {
     int fsync(int) @trusted;
 }
+else version (OpenBSD)
+{
+    int fsync(int) @trusted;
+}
 else version (DragonFlyBSD)
 {
     int fsync(int) @trusted;
@@ -2208,6 +2399,31 @@ else version (NetBSD)
     int        usleep(useconds_t) @trusted;
     pid_t      vfork();
 }
+else version (OpenBSD)
+{
+    char*      crypt(in char*, in char*);
+    //char*      ctermid(char*);
+    //void       encrypt(ref char[64], int) @trusted;
+    int        fchdir(int) @trusted;
+    c_long     gethostid() @trusted;
+    pid_t      getpgid(pid_t) @trusted;
+    pid_t      getsid(pid_t) @trusted;
+    char*      getwd(char*);
+    int        lchown(in char*, uid_t, gid_t);
+    int        lockf(int, int, off_t) @trusted;
+    int        nice(int) @trusted;
+    ssize_t    pread(int, void*, size_t, off_t);
+    ssize_t    pwrite(int, in void*, size_t, off_t);
+    int        setpgrp(pid_t, pid_t) @trusted;
+    int        setregid(gid_t, gid_t) @trusted;
+    int        setreuid(uid_t, uid_t) @trusted;
+    void       swab(in void*, void*, ssize_t);
+    void       sync() @trusted;
+    int        truncate(in char*, off_t);
+    useconds_t ualarm(useconds_t, useconds_t) @trusted;
+    int        usleep(useconds_t) @trusted;
+    pid_t      vfork();
+}
 else version (DragonFlyBSD)
 {
     char*      crypt(in char*, in char*);

libphobos/libdruntime/core/sys/posix/utime.d

@@ -94,6 +94,16 @@ else version (NetBSD)
 
     int utime(in char*, in utimbuf*);
 }
+else version (OpenBSD)
+{
+    struct utimbuf
+    {
+        time_t  actime;
+        time_t  modtime;
+    }
+
+    int utime(in char*, in utimbuf*);
+}
 else version (DragonFlyBSD)
 {
     struct utimbuf

libphobos/libdruntime/core/thread.d

@@ -1190,8 +1190,8 @@ class Thread
             }
             else
             {
-                // NOTE: pthread_setschedprio is not implemented on Darwin, FreeBSD or DragonFlyBSD, so use
-                //       the more complicated get/set sequence below.
+                // NOTE: pthread_setschedprio is not implemented on Darwin, FreeBSD, OpenBSD,
+                //       or DragonFlyBSD, so use the more complicated get/set sequence below.
                 int         policy;
                 sched_param param;
 
@@ -3205,6 +3205,7 @@ extern (C) @nogc nothrow
     version (CRuntime_Glibc) int pthread_getattr_np(pthread_t thread, pthread_attr_t* attr);
     version (FreeBSD) int pthread_attr_get_np(pthread_t thread, pthread_attr_t* attr);
     version (NetBSD) int pthread_attr_get_np(pthread_t thread, pthread_attr_t* attr);
+    version (OpenBSD) int pthread_stackseg_np(pthread_t thread, stack_t* sinfo);
     version (DragonFlyBSD) int pthread_attr_get_np(pthread_t thread, pthread_attr_t* attr);
     version (Solaris) int thr_stksegment(stack_t* stk);
     version (CRuntime_Bionic) int pthread_getattr_np(pthread_t thid, pthread_attr_t* attr);
@@ -3298,6 +3299,13 @@ private void* getStackBottom() nothrow @nogc
             addr += size;
         return addr;
     }
+    else version (OpenBSD)
+    {
+        stack_t stk;
+
+        pthread_stackseg_np(pthread_self(), &stk);
+        return stk.ss_sp;
+    }
     else version (DragonFlyBSD)
     {
         pthread_attr_t attr;
@@ -4612,6 +4620,7 @@ private:
             version (Posix) import core.sys.posix.sys.mman; // mmap
             version (FreeBSD) import core.sys.freebsd.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 (DragonFlyBSD) import core.sys.dragonflybsd.sys.mman : MAP_ANON;
             version (CRuntime_Glibc) import core.sys.linux.sys.mman : MAP_ANON;
             version (Darwin) import core.sys.darwin.sys.mman : MAP_ANON;

libphobos/libdruntime/core/time.d

@@ -164,7 +164,7 @@ version (CoreDdoc) enum ClockType
     normal = 0,
 
     /++
-        $(BLUE Linux-Only)
+        $(BLUE Linux,OpenBSD-Only)
 
         Uses $(D CLOCK_BOOTTIME).
       +/
@@ -214,7 +214,7 @@ version (CoreDdoc) enum ClockType
     precise = 3,
 
     /++
-        $(BLUE Linux,Solaris-Only)
+        $(BLUE Linux,OpenBSD,Solaris-Only)
 
         Uses $(D CLOCK_PROCESS_CPUTIME_ID).
       +/
@@ -251,14 +251,14 @@ version (CoreDdoc) enum ClockType
     second = 6,
 
     /++
-        $(BLUE Linux,Solaris-Only)
+        $(BLUE Linux,OpenBSD,Solaris-Only)
 
         Uses $(D CLOCK_THREAD_CPUTIME_ID).
       +/
     threadCPUTime = 7,
 
     /++
-        $(BLUE FreeBSD-Only)
+        $(BLUE DragonFlyBSD,FreeBSD,OpenBSD-Only)
 
         Uses $(D CLOCK_UPTIME).
       +/
@@ -320,6 +320,17 @@ else version (NetBSD) enum ClockType
     precise = 3,
     second = 6,
 }
+else version (OpenBSD) enum ClockType
+{
+    normal = 0,
+    bootTime = 1,
+    coarse = 2,
+    precise = 3,
+    processCPUTime = 4,
+    second = 6,
+    threadCPUTime = 7,
+    uptime = 8,
+}
 else version (DragonFlyBSD) enum ClockType
 {
     normal = 0,
@@ -396,6 +407,21 @@ version (Posix)
             case second: assert(0);
             }
         }
+        else version (OpenBSD)
+        {
+            import core.sys.openbsd.time;
+            with(ClockType) final switch (clockType)
+            {
+            case bootTime: return CLOCK_BOOTTIME;
+            case coarse: return CLOCK_MONOTONIC;
+            case normal: return CLOCK_MONOTONIC;
+            case precise: return CLOCK_MONOTONIC;
+            case processCPUTime: return CLOCK_PROCESS_CPUTIME_ID;
+            case threadCPUTime: return CLOCK_THREAD_CPUTIME_ID;
+            case uptime: return CLOCK_UPTIME;
+            case second: assert(0);
+            }
+        }
         else version (DragonFlyBSD)
         {
             import core.sys.dragonflybsd.time;

libphobos/libdruntime/gc/os.d

@@ -43,6 +43,7 @@ else version (Posix)
     version (FreeBSD) import core.sys.freebsd.sys.mman : MAP_ANON;
     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 (Darwin) import core.sys.darwin.sys.mman : MAP_ANON;
     version (CRuntime_UClibc) import core.sys.linux.sys.mman : MAP_ANON;