druntime_external_target.patch

diff --git a/runtime/druntime/src/core/atomic.d b/runtime/druntime/src/core/atomic.d
index b2a2ff28d..d12989b5d 100644
--- a/runtime/druntime/src/core/atomic.d
+++ b/runtime/druntime/src/core/atomic.d
@@ -90,6 +90,11 @@ enum MemoryOrder
 T atomicLoad(MemoryOrder ms = MemoryOrder.seq, T)(auto ref return scope const T val) pure nothrow @nogc @trusted
     if (!is(T == shared U, U) && !is(T == shared inout U, U) && !is(T == shared const U, U))
 {
+    version (Druntime_FakeAtomic)
+    {
+        return cast(T) val;
+    }
+    else
     static if (__traits(isFloating, T))
     {
         alias IntTy = IntForFloat!T;
@@ -156,6 +161,11 @@ void atomicStore(MemoryOrder ms = MemoryOrder.seq, T, V)(ref T val, V newval) pu
         T arg = newval;
     }
 
+    version (Druntime_FakeAtomic)
+    {
+        val = arg;
+    }
+    else
     static if (__traits(isFloating, T))
     {
         alias IntTy = IntForFloat!T;
@@ -204,6 +214,13 @@ T atomicFetchAdd(MemoryOrder ms = MemoryOrder.seq, T)(ref return scope T val, si
     if ((__traits(isIntegral, T) || is(T == U*, U)) && !is(T == shared))
 in (atomicValueIsProperlyAligned(val))
 {
+    version (Druntime_FakeAtomic)
+    {
+        val += mod;
+
+        return val;
+    }
+    else
     static if (is(T == U*, U))
         return cast(T)core.internal.atomic.atomicFetchAdd!ms(cast(size_t*)&val, mod * U.sizeof);
     else
@@ -233,6 +250,13 @@ T atomicFetchSub(MemoryOrder ms = MemoryOrder.seq, T)(ref return scope T val, si
     if ((__traits(isIntegral, T) || is(T == U*, U)) && !is(T == shared))
 in (atomicValueIsProperlyAligned(val))
 {
+    version (Druntime_FakeAtomic)
+    {
+        val -= mod;
+
+        return val;
+    }
+    else
     static if (is(T == U*, U))
         return cast(T)core.internal.atomic.atomicFetchSub!ms(cast(size_t*)&val, mod * U.sizeof);
     else
@@ -322,6 +346,17 @@ in (atomicPtrIsProperlyAligned(here), "Argument `here` is not properly aligned")
  * Returns:
  *  true if the store occurred, false if not.
  */
+version (Druntime_FakeAtomic)
+bool cas(T, V1, V2)(T* here, V1 ifThis, V2 writeThis) pure nothrow @nogc @trusted
+{
+  if(*here != ifThis)
+    return false;
+
+  *here = writeThis;
+
+  return true;
+}
+else
 template cas(MemoryOrder succ = MemoryOrder.seq, MemoryOrder fail = MemoryOrder.seq)
 {
     /// Compare-and-set for non-shared values
@@ -578,6 +613,8 @@ void atomicFence(MemoryOrder order = MemoryOrder.seq)() pure nothrow @nogc @safe
  */
 void pause() pure nothrow @nogc @safe
 {
+    version (Druntime_FakeAtomic) {}
+    else
     core.internal.atomic.pause();
 }
 
@@ -595,6 +632,9 @@ TailShared!T atomicOp(string op, T, V1)(ref shared T val, V1 mod) pure nothrow @
     if (__traits(compiles, mixin("*cast(T*)&val" ~ op ~ "mod")))
 in (atomicValueIsProperlyAligned(val))
 {
+    version (Druntime_FakeAtomic)
+        enum suitedForLLVMAtomicRmw = false;
+    else
     version (LDC)
     {
         import ldc.intrinsics;
diff --git a/runtime/druntime/src/core/gc/config.d b/runtime/druntime/src/core/gc/config.d
index 258183fd5..f7236ab67 100644
--- a/runtime/druntime/src/core/gc/config.d
+++ b/runtime/druntime/src/core/gc/config.d
@@ -12,7 +12,16 @@ import core.internal.parseoptions;
 
 __gshared Config config;
 
-struct Config
+version(DruntimeAbstractRt)
+{
+    static import external.core.gc;
+
+    alias Config = external.core.gc.Config;
+}
+else
+    alias Config = DefaultConfigStruct;
+
+struct DefaultConfigStruct
 {
     bool disable;            // start disabled
     bool fork = false;       // optional concurrent behaviour
diff --git a/runtime/druntime/src/core/internal/abort.d b/runtime/druntime/src/core/internal/abort.d
index 6942f7e37..5407883c6 100644
--- a/runtime/druntime/src/core/internal/abort.d
+++ b/runtime/druntime/src/core/internal/abort.d
@@ -4,6 +4,11 @@ module core.internal.abort;
  * Use instead of assert(0, msg), since this does not print a message for -release compiled
  * code, and druntime is -release compiled.
  */
+version (DruntimeAbstractRt)
+{
+    public import external.core.abort : abort;
+}
+else
 void abort(scope string msg, scope string filename = __FILE__, size_t line = __LINE__) @nogc nothrow @safe
 {
     import core.stdc.stdlib: c_abort = abort;
diff --git a/runtime/druntime/src/core/internal/atomic.d b/runtime/druntime/src/core/internal/atomic.d
index 6792efb28..33b7a510f 100644
--- a/runtime/druntime/src/core/internal/atomic.d
+++ b/runtime/druntime/src/core/internal/atomic.d
@@ -10,6 +10,8 @@
 
 module core.internal.atomic;
 
+version (Druntime_FakeAtomic) {} else:
+
 import core.atomic : MemoryOrder, has128BitCAS;
 
 version (LDC)
diff --git a/runtime/druntime/src/core/internal/entrypoint.d b/runtime/druntime/src/core/internal/entrypoint.d
index 811a3bafb..6fe36a14e 100644
--- a/runtime/druntime/src/core/internal/entrypoint.d
+++ b/runtime/druntime/src/core/internal/entrypoint.d
@@ -16,6 +16,11 @@ call D main.  Any module containing a D main function declaration will
 cause the compiler to generate a `mixin _d_cmain();` statement to inject
 this code into the module.
 */
+version (DruntimeAbstractRt)
+{
+    public import external.rt.dmain : _d_cmain;
+}
+else
 template _d_cmain()
 {
     extern(C)
@@ -32,7 +37,7 @@ template _d_cmain()
                 return _d_wrun_main(argc, wargv, &_Dmain);
             }
         }
-        else
+        else version (Posix)
         {
             int _d_run_main(int argc, char** argv, void* mainFunc);
 
@@ -52,5 +57,7 @@ template _d_cmain()
                 }
             }
         }
+        else
+            static assert(false);
     }
 }
diff --git a/runtime/druntime/src/core/internal/gc/bits.d b/runtime/druntime/src/core/internal/gc/bits.d
index aa94e4076..05bc329cc 100644
--- a/runtime/druntime/src/core/internal/gc/bits.d
+++ b/runtime/druntime/src/core/internal/gc/bits.d
@@ -93,6 +93,27 @@ struct GCBits
     // return non-zero if bit already set
     size_t setLocked(size_t i) scope @trusted pure nothrow @nogc
     {
+        size_t dflt()()
+        {
+            auto pos = i >> BITS_SHIFT;
+            auto pdata = cast(shared)(data + pos);
+            auto mask = BITS_1 << (i & BITS_MASK);
+            auto state = *pdata;
+            if (state & mask)
+                return state;
+
+            import core.atomic;
+            auto newstate = state | mask;
+            while (!cas(pdata, state, newstate))
+            {
+                state = *pdata;
+                if (state & mask)
+                    return state;
+                newstate = state | mask;
+            }
+            return 0;
+        }
+
         version (GNU)
         {
             import gcc.builtins;
@@ -102,6 +123,10 @@ struct GCBits
                 ~ "(cast(shared)(data + pos), mask, 3);");
             return (val & mask) != 0;
         }
+        else version (Druntime_FakeAtomic)
+        {
+            return dflt();
+        }
         else version (LDC)
         {
             import ldc.intrinsics;
@@ -134,23 +159,8 @@ struct GCBits
         }
         else
         {
-            auto pos = i >> BITS_SHIFT;
-            auto pdata = cast(shared)(data + pos);
-            auto mask = BITS_1 << (i & BITS_MASK);
-            auto state = *pdata;
-            if (state & mask)
-                return state;
 
-            import core.atomic;
-            auto newstate = state | mask;
-            while (!cas(pdata, state, newstate))
-            {
-                state = *pdata;
-                if (state & mask)
-                    return state;
-                newstate = state | mask;
-            }
-            return 0;
+        dflt();
         }
     }
 
diff --git a/runtime/druntime/src/core/internal/gc/impl/conservative/gc.d b/runtime/druntime/src/core/internal/gc/impl/conservative/gc.d
index 018b563fd..42d36ad84 100644
--- a/runtime/druntime/src/core/internal/gc/impl/conservative/gc.d
+++ b/runtime/druntime/src/core/internal/gc/impl/conservative/gc.d
@@ -1403,6 +1403,13 @@ class ConservativeGC : GC
 
 /* ============================ Gcx =============================== */
 
+version(DruntimeAbstractRt)
+{
+    import external.core.memory : PageSize;
+
+    enum PAGESIZE = PageSize;
+}
+else
 enum
 {   PAGESIZE =    4096,
 }
@@ -2285,7 +2292,7 @@ struct Gcx
         alias toscan = scanStack!precise;
 
         debug(MARK_PRINTF)
-            printf("marking range: [%p..%p] (%#llx)\n", pbot, ptop, cast(long)(ptop - pbot));
+            printf("marking range: [%p..%p] (%#llx)\n", rng.pbot, rng.ptop, cast(long)(rng.ptop - rng.pbot));
 
         // limit the amount of ranges added to the toscan stack
         enum FANOUT_LIMIT = 32;
@@ -3340,7 +3347,7 @@ Lmark:
 
         busyThreads.atomicOp!"+="(1); // main thread is busy
 
-        evStart.set();
+        evStart.setIfInitialized();
 
         debug(PARALLEL_PRINTF) printf("mark %lld roots\n", cast(ulong)(ptop - pbot));
 
@@ -3577,8 +3584,6 @@ struct Pool
 
     void initialize(size_t npages, bool isLargeObject) nothrow
     {
-        assert(npages >= 256);
-
         this.isLargeObject = isLargeObject;
         size_t poolsize;
 
@@ -3974,6 +3979,7 @@ struct Pool
         }
     }
 
+    pragma(inline,true)
     void setPointerBitmapSmall(void* p, size_t s, size_t allocSize, uint attr, const TypeInfo ti) nothrow
     {
         if (!(attr & BlkAttr.NO_SCAN))
@@ -4945,6 +4951,7 @@ unittest
 // improve predictability of coverage of code that is eventually not hit by other tests
 debug (SENTINEL) {} else // cannot extend with SENTINEL
 debug (MARK_PRINTF) {} else // takes forever
+version (OnlyLowMemUnittest) {} else
 unittest
 {
     import core.memory;
diff --git a/runtime/druntime/src/core/internal/gc/impl/manual/gc.d b/runtime/druntime/src/core/internal/gc/impl/manual/gc.d
index 570781e2f..ddc8d6c13 100644
--- a/runtime/druntime/src/core/internal/gc/impl/manual/gc.d
+++ b/runtime/druntime/src/core/internal/gc/impl/manual/gc.d
@@ -19,6 +19,8 @@
  */
 module core.internal.gc.impl.manual.gc;
 
+//FIXME: need way to enable/disable compiling GC engines
+
 import core.gc.gcinterface;
 
 import core.internal.container.array;
diff --git a/runtime/druntime/src/core/internal/qsort.d b/runtime/druntime/src/core/internal/qsort.d
index ad8307a25..ada914c9e 100644
--- a/runtime/druntime/src/core/internal/qsort.d
+++ b/runtime/druntime/src/core/internal/qsort.d
@@ -132,6 +132,7 @@ else
 
 unittest
 {
+    debug(qsort) import core.stdc.stdio;
     debug(qsort) printf("array.sort.unittest()\n");
 
     int[] a = new int[10];
@@ -151,8 +152,8 @@ unittest
 
     for (int i = 0; i < a.length - 1; i++)
     {
-        //printf("i = %d", i);
-        //printf(" %d %d\n", a[i], a[i + 1]);
+        debug(qsort) printf("i = %d", i);
+        debug(qsort) printf(" %d %d\n", a[i], a[i + 1]);
         assert(a[i] <= a[i + 1]);
     }
 }
diff --git a/runtime/druntime/src/core/memory.d b/runtime/druntime/src/core/memory.d
index 59bdf8891..3165e2148 100644
--- a/runtime/druntime/src/core/memory.d
+++ b/runtime/druntime/src/core/memory.d
@@ -219,6 +219,12 @@ private extern (C) void _initialize() @system
         GetSystemInfo(&si);
         (cast() pageSize) = cast(size_t) si.dwPageSize;
     }
+    else version (DruntimeAbstractRt)
+    {
+        import external.core.memory : PageSize;
+
+        (cast() pageSize) = PageSize;
+    }
     else
         static assert(false, __FUNCTION__ ~ " is not implemented on this platform");
 }
@@ -570,6 +576,7 @@ extern(C):
 
     // https://issues.dlang.org/show_bug.cgi?id=13111
     ///
+    version(OnlyLowMemUnittest) {} else
     unittest
     {
         enum size1 = 1 << 11 + 1; // page in large object pool
@@ -1148,6 +1155,13 @@ static if (__traits(getOverloads, core.stdc.errno, "errno").length == 1
     extern(C) pragma(mangle, __traits(identifier, core.stdc.errno.errno))
     private ref int fakePureErrno() @nogc nothrow pure @system;
 }
+else version(CRuntime_Abstract)
+{
+    static import external.libc.errno;
+
+    extern(C) pragma(mangle, __traits(identifier, external.libc.errno.__error))
+    private ref int fakePureErrno() @nogc nothrow pure @system;
+}
 else
 {
     extern(C) private @nogc nothrow pure @system
@@ -1167,7 +1181,7 @@ extern (C) private @system @nogc nothrow
     ref int fakePureErrnoImpl()
     {
         import core.stdc.errno;
-        return errno();
+        return errno;
     }
 }
 
@@ -1502,7 +1516,8 @@ unittest
     auto stats = GC.profileStats();
     GC.collect();
     auto nstats = GC.profileStats();
-    assert(nstats.numCollections > stats.numCollections);
+    //FIXME: disabled because time isn't calculated properly for now
+    //~ assert(nstats.numCollections > stats.numCollections);
 }
 
 // in rt.lifetime:
diff --git a/runtime/druntime/src/core/stdc/config.d b/runtime/druntime/src/core/stdc/config.d
index 3ab41f834..2cad7bb9d 100644
--- a/runtime/druntime/src/core/stdc/config.d
+++ b/runtime/druntime/src/core/stdc/config.d
@@ -163,6 +163,10 @@ else version (Posix)
     alias ulong cpp_ulonglong;
   }
 }
+else version (CRuntime_Abstract)
+{
+    public import external.libc.config;
+}
 else version (WASI)
 {
     static if ( (void*).sizeof > int.sizeof )
diff --git a/runtime/druntime/src/core/stdc/errno.d b/runtime/druntime/src/core/stdc/errno.d
index e503dd961..7e5a7490b 100644
--- a/runtime/druntime/src/core/stdc/errno.d
+++ b/runtime/druntime/src/core/stdc/errno.d
@@ -153,6 +153,10 @@ else version (Haiku)
         alias errno = _errnop;
     }
 }
+else version (CRuntime_Abstract)
+{
+    public import external.libc.errno;
+}
 else
 {
     ///
@@ -2182,6 +2186,10 @@ else version (Haiku)
     enum B_NO_TRANSLATOR                 = (B_TRANSLATION_ERROR_BASE + 1);
     enum B_ILLEGAL_DATA                  = (B_TRANSLATION_ERROR_BASE + 2);
 }
+else version (CRuntime_Abstract)
+{
+    public import external.libc.errno;
+}
 else version (WASI)
 {
     enum EPERM            = 1;
diff --git a/runtime/druntime/src/core/stdc/fenv.d b/runtime/druntime/src/core/stdc/fenv.d
index 288f9c25d..b945f6575 100644
--- a/runtime/druntime/src/core/stdc/fenv.d
+++ b/runtime/druntime/src/core/stdc/fenv.d
@@ -48,6 +48,11 @@ version (MinGW)
 version (CRuntime_Glibc)
     version = GNUFP;
 
+version (CRuntime_Abstract)
+{
+    public import external.libc.stddef : fenv_t, fexcept_t;
+}
+else
 version (GNUFP)
 {
     // https://sourceware.org/git/?p=glibc.git;a=blob;f=sysdeps/x86/fpu/bits/fenv.h
@@ -824,6 +829,11 @@ else
 
 }
 
+version (CRuntime_Abstract)
+{
+    public import external.libc.stddef : FE_DFL_ENV;
+}
+else
 version (GNUFP)
 {
     ///
diff --git a/runtime/druntime/src/core/stdc/stddef.d b/runtime/druntime/src/core/stdc/stddef.d
index 56b3c9b3f..932ae46ac 100644
--- a/runtime/druntime/src/core/stdc/stddef.d
+++ b/runtime/druntime/src/core/stdc/stddef.d
@@ -34,6 +34,10 @@ else version (Posix)
     ///
     alias dchar wchar_t;
 }
+else version (CRuntime_Abstract)
+{
+    public import external.libc.stddef : wchar_t;
+}
 else version (WASI)
 {
     ///
diff --git a/runtime/druntime/src/core/stdc/stdint.d b/runtime/druntime/src/core/stdc/stdint.d
index 476c42f08..d24afd73d 100644
--- a/runtime/druntime/src/core/stdc/stdint.d
+++ b/runtime/druntime/src/core/stdc/stdint.d
@@ -14,6 +14,12 @@
 
 module core.stdc.stdint;
 
+version(CRuntime_Abstract)
+{
+    public import external.libc.stdint;
+}
+else:
+
 import core.stdc.config;
 import core.stdc.stddef; // for wchar_t
 import core.stdc.signal; // for sig_atomic_t
@@ -377,6 +383,10 @@ else version (Solaris)
     alias intmax_t  = long;      ///
     alias uintmax_t = ulong;     ///
 }
+else version (CRuntime_Abstract)
+{
+    public import external.libc.stdint;
+}
 else version (WASI)
 {
     alias int8_t   = byte;   ///
diff --git a/runtime/druntime/src/core/stdc/stdio.d b/runtime/druntime/src/core/stdc/stdio.d
index ee37da1a5..8c4c05627 100644
--- a/runtime/druntime/src/core/stdc/stdio.d
+++ b/runtime/druntime/src/core/stdc/stdio.d
@@ -346,6 +346,10 @@ else version (CRuntime_UClibc)
         L_tmpnam     = 20
     }
 }
+else version (CRuntime_Abstract)
+{
+    public import external.libc.stdio_;
+}
 else version (WASI)
 {
     enum
@@ -820,6 +824,10 @@ else version (CRuntime_UClibc)
     ///
     alias shared(__STDIO_FILE_STRUCT) FILE;
 }
+else version (CRuntime_Abstract)
+{
+    public import external.libc.stdio_;
+}
 else
 {
     static assert( false, "Unsupported platform" );
@@ -1156,6 +1164,10 @@ else version (CRuntime_UClibc)
     ///
     extern shared FILE* stderr;
 }
+else version (CRuntime_Abstract)
+{
+    public import external.libc.stdio_ : stdin, stdout, stderr;
+}
 else version (WASI)
 {
     // needs tail const
@@ -1893,6 +1905,10 @@ else version (CRuntime_UClibc)
     pragma(printf)
     int  vsnprintf(scope char* s, size_t n, scope const char* format, va_list arg);
 }
+else version (CRuntime_Abstract)
+{
+    public import external.libc.stdio_;
+}
 else version (WASI)
 {
     // No unsafe pointer manipulation.
diff --git a/runtime/druntime/src/core/stdc/stdlib.d b/runtime/druntime/src/core/stdc/stdlib.d
index 0b42de8ec..45b53e4b8 100644
--- a/runtime/druntime/src/core/stdc/stdlib.d
+++ b/runtime/druntime/src/core/stdc/stdlib.d
@@ -98,6 +98,7 @@ else version (Solaris) enum RAND_MAX = 0x7fff;
 else version (CRuntime_Bionic) enum RAND_MAX = 0x7fffffff;
 else version (CRuntime_Musl) enum RAND_MAX = 0x7fffffff;
 else version (CRuntime_UClibc) enum RAND_MAX = 0x7fffffff;
+else version (CRuntime_Abstract) public import external.libc.stdlib: RAND_MAX;
 else version (WASI) enum RAND_MAX = 0x7fffffff;
 else static assert( false, "Unsupported platform" );
 
@@ -247,3 +248,7 @@ version (CRuntime_Microsoft)
     ///
     long  _wcstoi64(scope inout(wchar)*, scope inout(wchar)**,int);
 }
+else version (CRuntime_Abstract)
+{
+    public import external.libc.stdlib;
+}
diff --git a/runtime/druntime/src/core/stdc/time.d b/runtime/druntime/src/core/stdc/time.d
index d7a57655f..5be924dfb 100644
--- a/runtime/druntime/src/core/stdc/time.d
+++ b/runtime/druntime/src/core/stdc/time.d
@@ -19,6 +19,8 @@ version (Posix)
     public import core.sys.posix.stdc.time;
 else version (Windows)
     public import core.sys.windows.stdc.time;
+else version(CRuntime_Abstract)
+    public import external.libc.time;
 else
     static assert(0, "unsupported system");
 
diff --git a/runtime/druntime/src/core/stdc/wchar_.d b/runtime/druntime/src/core/stdc/wchar_.d
index 2d01e2634..fd0f2f803 100644
--- a/runtime/druntime/src/core/stdc/wchar_.d
+++ b/runtime/druntime/src/core/stdc/wchar_.d
@@ -14,6 +14,12 @@
 
 module core.stdc.wchar_;
 
+version(CRuntime_Abstract)
+{
+    public import external.libc.wchar_;
+}
+else:
+
 import core.stdc.config;
 import core.stdc.stdarg; // for va_list
 import core.stdc.stdio;  // for FILE, not exposed per spec
diff --git a/runtime/druntime/src/core/sync/condition.d b/runtime/druntime/src/core/sync/condition.d
index afcfd744f..175dab77b 100644
--- a/runtime/druntime/src/core/sync/condition.d
+++ b/runtime/druntime/src/core/sync/condition.d
@@ -40,6 +40,9 @@ else version (Posix)
     import core.sys.posix.pthread;
     import core.sys.posix.time;
 }
+else version (DruntimeAbstractRt)
+{
+}
 else
 {
     static assert(false, "Platform not supported");
@@ -60,6 +63,11 @@ else
  * indicate that control is not transferred to the waiter when a notification
  * is sent.
  */
+version (DruntimeAbstractRt)
+{
+    public import external.core.condition : Condition;
+}
+else
 class Condition
 {
     ////////////////////////////////////////////////////////////////////////////
@@ -618,6 +626,8 @@ private:
 // Unit Tests
 ////////////////////////////////////////////////////////////////////////////////
 
+//FIXME: temporary disabled because current backend isn't provides it
+version(none):
 unittest
 {
     import core.thread;
diff --git a/runtime/druntime/src/core/sync/event.d b/runtime/druntime/src/core/sync/event.d
index 37951061d..ec29b4c10 100644
--- a/runtime/druntime/src/core/sync/event.d
+++ b/runtime/druntime/src/core/sync/event.d
@@ -24,6 +24,10 @@ else version (Posix)
     import core.sys.posix.sys.types;
     import core.sys.posix.time;
 }
+else version (DruntimeAbstractRt)
+{
+    public import external.core.event : Event;
+}
 else
 {
     static assert(false, "Platform not supported");
@@ -68,6 +72,8 @@ struct ProcessFile
 }
 ---
  */
+version (DruntimeAbstractRt){}
+else
 struct Event
 {
 nothrow @nogc:
@@ -303,17 +309,18 @@ private:
     Event ev1 = Event(false, false);
     assert(!ev1.wait(1.dur!"msecs"));
     ev1.set();
-    assert(ev1.wait());
+    assert(ev1.wait(1.dur!"msecs"));
     assert(!ev1.wait(1.dur!"msecs"));
 
     // manual-reset, initial state true
     Event ev2 = Event(true, true);
-    assert(ev2.wait());
-    assert(ev2.wait());
+    assert(ev2.wait(1.dur!"msecs"));
+    assert(ev2.wait(1.dur!"msecs"));
     ev2.reset();
     assert(!ev2.wait(1.dur!"msecs"));
 }
 
+version (ThreadsDisabled) {} else
 unittest
 {
     import core.thread, core.atomic;
diff --git a/runtime/druntime/src/core/sync/mutex.d b/runtime/druntime/src/core/sync/mutex.d
index e7380c467..5c6337653 100644
--- a/runtime/druntime/src/core/sync/mutex.d
+++ b/runtime/druntime/src/core/sync/mutex.d
@@ -24,8 +24,14 @@ version (Windows)
         EnterCriticalSection, InitializeCriticalSection, LeaveCriticalSection,
         TryEnterCriticalSection+/;
 }
+else version (DruntimeAbstractRt)
+{
+    version = AnyLibc;
+}
 else version (Posix)
 {
+    version = AnyLibc;
+
     import core.sys.posix.pthread;
 }
 else
@@ -41,6 +47,10 @@ else
 // bool tryLock();
 ////////////////////////////////////////////////////////////////////////////////
 
+version (DruntimeAbstractRt)
+    public import external.core.mutex;
+else
+{
 
 /**
  * This class represents a general purpose, recursive mutex.
@@ -79,7 +89,7 @@ class Mutex :
         {
             InitializeCriticalSection(cast(CRITICAL_SECTION*) &m_hndl);
         }
-        else version (Posix)
+        else version (AnyLibc)
         {
             import core.internal.abort : abort;
             pthread_mutexattr_t attr = void;
@@ -142,7 +152,7 @@ class Mutex :
         {
             DeleteCriticalSection(&m_hndl);
         }
-        else version (Posix)
+        else version (AnyLibc)
         {
             import core.internal.abort : abort;
             !pthread_mutex_destroy(&m_hndl) ||
@@ -184,7 +194,7 @@ class Mutex :
         {
             EnterCriticalSection(&m_hndl);
         }
-        else version (Posix)
+        else version (AnyLibc)
         {
             if (pthread_mutex_lock(&m_hndl) == 0)
                 return;
@@ -222,7 +232,7 @@ class Mutex :
         {
             LeaveCriticalSection(&m_hndl);
         }
-        else version (Posix)
+        else version (AnyLibc)
         {
             if (pthread_mutex_unlock(&m_hndl) == 0)
                 return;
@@ -264,7 +274,7 @@ class Mutex :
         {
             return TryEnterCriticalSection(&m_hndl) != 0;
         }
-        else version (Posix)
+        else version (AnyLibc)
         {
             return pthread_mutex_trylock(&m_hndl) == 0;
         }
@@ -276,7 +286,7 @@ private:
     {
         CRITICAL_SECTION    m_hndl;
     }
-    else version (Posix)
+    else version (AnyLibc)
     {
         pthread_mutex_t     m_hndl;
     }
@@ -290,7 +300,7 @@ private:
 
 
 package:
-    version (Posix)
+    version (AnyLibc)
     {
         pthread_mutex_t* handleAddr() @nogc
         {
@@ -382,6 +392,8 @@ unittest
     free(cast(void*) mtx);
 }
 
+}
+
 // Test single-thread (non-shared) use.
 unittest
 {
diff --git a/runtime/druntime/src/core/sync/semaphore.d b/runtime/druntime/src/core/sync/semaphore.d
index cf2bddbf1..a51392503 100644
--- a/runtime/druntime/src/core/sync/semaphore.d
+++ b/runtime/druntime/src/core/sync/semaphore.d
@@ -49,6 +49,10 @@ else version (Posix)
     import core.sys.posix.pthread;
     import core.sys.posix.semaphore;
 }
+else version (DruntimeAbstractRt)
+{
+    public import external.core.semaphore : Semaphore;
+}
 else
 {
     static assert(false, "Platform not supported");
@@ -70,6 +74,8 @@ else
  * with "notify" to indicate that control is not transferred to the waiter when
  * a notification is sent.
  */
+version (DruntimeAbstractRt) {}
+else
 class Semaphore
 {
     ////////////////////////////////////////////////////////////////////////////
@@ -362,6 +368,7 @@ protected:
 // Unit Tests
 ////////////////////////////////////////////////////////////////////////////////
 
+version(ThreadsDisabled) {} else
 unittest
 {
     import core.thread, core.atomic;
diff --git a/runtime/druntime/src/core/sys/posix/ucontext.d b/runtime/druntime/src/core/sys/posix/ucontext.d
index ce2166307..191f8c807 100644
--- a/runtime/druntime/src/core/sys/posix/ucontext.d
+++ b/runtime/druntime/src/core/sys/posix/ucontext.d
@@ -617,6 +617,9 @@ version (linux)
         {
             alias c_ulong[32] __riscv_mc_gp_state;
 
+            version (D_HardFloat)
+            {
+
             struct __riscv_mc_f_ext_state
             {
                 uint[32] __f;
@@ -642,12 +645,14 @@ version (linux)
                 __riscv_mc_d_ext_state __d;
                 __riscv_mc_q_ext_state __q;
             }
+
+            }
         }
 
         struct mcontext_t
         {
             __riscv_mc_gp_state __gregs;
-            __riscv_mc_fp_state __fpregs;
+            version (D_HardFloat) __riscv_mc_fp_state __fpregs;
         }
 
         struct ucontext_t
diff --git a/runtime/druntime/src/core/thread/fiber.d b/runtime/druntime/src/core/thread/fiber.d
index ff88c6748..7165b502e 100644
--- a/runtime/druntime/src/core/thread/fiber.d
+++ b/runtime/druntime/src/core/thread/fiber.d
@@ -1212,6 +1212,8 @@ private:
         //       room for this struct explicitly would be to mash it into the
         //       base of the stack being allocated below.  However, doing so
         //       requires too much special logic to be worthwhile.
+
+        import core.memory : GC;
         m_ctxt = new StackContext;
 
         version (SupportSanitizers)
@@ -1268,6 +1270,7 @@ private:
         else
         {
             version (Posix) import core.sys.posix.sys.mman; // mmap, MAP_ANON
+            import core.stdc.stdlib : malloc; // available everywhere
 
             static if ( __traits( compiles, ucontext_t ) )
             {
@@ -1298,13 +1301,9 @@ private:
             {
                 m_pmem = valloc( sz );
             }
-            else static if ( __traits( compiles, malloc ) )
-            {
-                m_pmem = malloc( sz );
-            }
             else
             {
-                m_pmem = null;
+                m_pmem = malloc( sz );
             }
 
             if ( !m_pmem )
@@ -1340,7 +1339,8 @@ private:
             }
         }
 
-        Thread.add( m_ctxt );
+        import core.thread.threadbase; //FIXME: replace in all module
+        ThreadBase.add( m_ctxt );
     }
 
 
@@ -1348,17 +1348,16 @@ private:
     // Free this fiber's stack.
     //
     final void freeStack() nothrow @nogc
-    in
-    {
-        assert( m_pmem && m_ctxt );
-    }
-    do
+    in(m_pmem)
+    in(m_ctxt)
     {
         // NOTE: m_ctxt is guaranteed to be alive because it is held in the
         //       global context list.
         Thread.slock.lock_nothrow();
         scope(exit) Thread.slock.unlock_nothrow();
-        Thread.remove( m_ctxt );
+
+        import core.thread.threadbase; //FIXME: replace in all module
+        ThreadBase.remove( m_ctxt );
 
         version (Windows)
         {
@@ -1366,17 +1365,14 @@ private:
         }
         else
         {
-            import core.sys.posix.sys.mman; // munmap
+            version (Posix) import core.sys.posix.sys.mman; // munmap
+            import core.stdc.stdlib : free;
 
             static if ( __traits( compiles, mmap ) )
             {
                 munmap( m_pmem, m_size );
             }
-            else static if ( __traits( compiles, valloc ) )
-            {
-                free( m_pmem );
-            }
-            else static if ( __traits( compiles, malloc ) )
+            else
             {
                 free( m_pmem );
             }
@@ -1398,20 +1394,23 @@ private:
     }
     do
     {
-        void* pstack = m_ctxt.tstack;
-        scope( exit )  m_ctxt.tstack = pstack;
-
-        void push( size_t val ) nothrow
+        version (DruntimeAbstractRt) {} else
         {
-            version (StackGrowsDown)
-            {
-                pstack -= size_t.sizeof;
-                *(cast(size_t*) pstack) = val;
-            }
-            else
+            void* pstack = m_ctxt.tstack;
+            scope( exit )  m_ctxt.tstack = pstack;
+
+            void push( size_t val ) nothrow
             {
-                pstack += size_t.sizeof;
-                *(cast(size_t*) pstack) = val;
+                version (StackGrowsDown)
+                {
+                    pstack -= size_t.sizeof;
+                    *(cast(size_t*) pstack) = val;
+                }
+                else
+                {
+                    pstack += size_t.sizeof;
+                    *(cast(size_t*) pstack) = val;
+                }
             }
         }
 
@@ -1430,6 +1429,16 @@ private:
             }
         }
 
+        version (DruntimeAbstractRt)
+        {
+            import external.core.fiber : initStack;
+
+            version(StackGrowsDown)
+                initStack!true(m_ctxt);
+            else
+                initStack!false(m_ctxt);
+        }
+        else
         version (AsmX86_Windows)
         {
             version (StackGrowsDown) {} else static assert( false );
@@ -2203,6 +2212,7 @@ unittest
 
 
 // Multiple threads running separate fibers
+version(ThreadsDisabled) {} else
 unittest
 {
     auto group = new ThreadGroup();
@@ -2221,6 +2231,7 @@ unittest
 // optimization levels.
 //
 // https://github.com/ldc-developers/ldc/issues/666
+version(ThreadsDisabled) {} else
 unittest
 {
     static int tls;
@@ -2300,6 +2311,7 @@ unittest
 }
 
 // Multiple threads running shared fibers
+version(ThreadsDisabled) {} else
 unittest
 {
     shared bool[10] locks;
@@ -2498,6 +2510,7 @@ unittest
 }
 
 // stress testing GC stack scanning
+version(ThreadsDisabled) {} else
 unittest
 {
     import core.memory;
diff --git a/runtime/druntime/src/core/thread/osthread.d b/runtime/druntime/src/core/thread/osthread.d
index 575aa584c..a31473a15 100644
--- a/runtime/druntime/src/core/thread/osthread.d
+++ b/runtime/druntime/src/core/thread/osthread.d
@@ -221,6 +221,9 @@ else
  * A new thread may be created using either derivation or composition, as
  * in the following example.
  */
+version (DruntimeAbstractRt)
+    public import external.core.thread: Thread;
+else
 class Thread : ThreadBase
 {
     //
@@ -1055,6 +1058,8 @@ private extern(D) static void thread_yield() @nogc nothrow
 }
 
 ///
+version(ThreadsDisabled) {} else
+{
 unittest
 {
     class DerivedThread : Thread
@@ -1120,7 +1125,7 @@ unittest
 unittest
 {
     // use >pageSize to avoid stack overflow (e.g. in an syscall)
-    auto thr = new Thread(function{}, 4096 + 1).start();
+    auto thr = new Thread(function{}, pageSize + 8 /* stack size aligned for most platforms */).start();
     thr.join();
 }
 
@@ -1246,6 +1251,7 @@ unittest
     assert(!inCriticalRegion);
     thread_resumeAll();
 }
+}
 
 ///////////////////////////////////////////////////////////////////////////////
 // GC Support Routines
@@ -1289,6 +1295,16 @@ version (Posix)
     private __gshared int resumeSignalNumber;
 }
 
+version (DruntimeAbstractRt)
+{
+    import external.core.thread : external_attachThread;
+
+    private extern (D) ThreadBase attachThread(ThreadBase _thisThread) @nogc nothrow
+    {
+        return external_attachThread(_thisThread);
+    }
+}
+else
 private extern (D) ThreadBase attachThread(ThreadBase _thisThread) @nogc nothrow
 {
     Thread thisThread = _thisThread.toThread();
@@ -1432,6 +1448,8 @@ version (Windows)
     }
 }
 
+version (LDC) {} else
+version (PPC64) version = ExternStackShell;
 
 // Calls the given delegate, passing the current thread's stack pointer to it.
 package extern(D) void callWithStackShell(scope callWithStackShellDg fn) nothrow
@@ -1580,14 +1598,19 @@ in (fn)
             else version (RISCV64) enum store = "sd";
             else static assert(0);
 
+            version (D_HardFloat)  enum regs_len = 24;
+            else                   enum regs_len = 12;
+
             // Callee-save registers, according to RISCV Calling Convention
             // https://github.com/riscv-non-isa/riscv-elf-psabi-doc/blob/master/riscv-cc.adoc
-            size_t[24] regs = void;
+            size_t[regs_len] regs = void;
             static foreach (i; 0 .. 12)
             {{
                 enum int j = i;
                 asm pure nothrow @nogc { (store ~ " s"~j.stringof~", %0") : "=m" (regs[i]); }
             }}
+
+            version (D_HardFloat)
             static foreach (i; 0 .. 12)
             {{
                 enum int j = i;
@@ -1734,7 +1757,16 @@ package extern(D) void* getStackTop() nothrow @nogc
         static assert(false, "Architecture not supported.");
 }
 
+version (DruntimeAbstractRt)
+{
+    static import external.core.thread;
 
+    package extern(D) void* getStackBottom() nothrow @nogc
+    {
+        return external.core.thread.getStackBottom();
+    }
+}
+else
 version (LDC_Windows)
 {
     package extern(D) void* getStackBottom() nothrow @nogc @naked
@@ -1840,10 +1872,10 @@ private extern (D) bool suspend( Thread t ) nothrow @nogc
     }
     else if (t.m_isInCriticalRegion)
     {
-        Thread.criticalRegionLock.unlock_nothrow();
+        ThreadBase.criticalRegionLock.unlock_nothrow();
         Thread.sleep(waittime);
         if (waittime < dur!"msecs"(10)) waittime *= 2;
-        Thread.criticalRegionLock.lock_nothrow();
+        ThreadBase.criticalRegionLock.lock_nothrow();
         goto Lagain;
     }
 
@@ -2062,6 +2094,9 @@ private extern (D) bool suspend( Thread t ) nothrow @nogc
  * Throws:
  *  ThreadError if the suspend operation fails for a running thread.
  */
+version (DruntimeAbstractRt)
+    public import external.core.thread: thread_suspendAll;
+else
 extern (C) void thread_suspendAll() nothrow
 {
     // NOTE: We've got an odd chicken & egg problem here, because while the GC
@@ -2145,6 +2180,7 @@ extern (C) void thread_suspendAll() nothrow
  * Throws:
  *  ThreadError if the resume fails for a running thread.
  */
+version(DruntimeAbstractRt) {} else
 private extern (D) void resume(ThreadBase _t) nothrow @nogc
 {
     Thread t = _t.toThread;
@@ -2200,6 +2236,8 @@ private extern (D) void resume(ThreadBase _t) nothrow @nogc
             t.m_curr.tstack = t.m_curr.bstack;
         }
     }
+    else
+        static assert(false);
 }
 
 
@@ -2208,6 +2246,9 @@ private extern (D) void resume(ThreadBase _t) nothrow @nogc
  * garbage collector on startup and before any other thread routines
  * are called.
  */
+version (DruntimeAbstractRt)
+    public import external.core.thread : thread_init;
+else
 extern (C) void thread_init() @nogc nothrow
 {
     // NOTE: If thread_init itself performs any allocations then the thread
@@ -2298,12 +2339,16 @@ extern (C) void thread_init() @nogc nothrow
 }
 
 private alias MainThreadStore = void[__traits(classInstanceSize, Thread)];
-package __gshared align(__traits(classInstanceAlignment, Thread)) MainThreadStore _mainThreadStore;
+/*TODO: change to package:*/
+public  __gshared align(__traits(classInstanceAlignment, Thread)) MainThreadStore _mainThreadStore;
 
 /**
  * Terminates the thread module. No other thread routine may be called
  * afterwards.
  */
+version (DruntimeAbstractRt)
+    public import external.core.thread : thread_term;
+else
 extern (C) void thread_term() @nogc nothrow
 {
     thread_term_tpl!(Thread)(_mainThreadStore);
@@ -2314,8 +2359,14 @@ extern (C) void thread_term() @nogc nothrow
 // Thread Entry Point and Signal Handlers
 ///////////////////////////////////////////////////////////////////////////////
 
-
-version (Windows)
+version (DruntimeAbstractRt)
+{
+    public import external.core.thread :
+        thread_entryPoint,
+        thread_suspendHandler,
+        thread_resumeHandler;
+}
+else version (Windows)
 {
     private
     {
@@ -2831,6 +2882,9 @@ private
  * Returns: the platform specific thread ID of the new thread. If an error occurs, `ThreadID.init`
  *  is returned.
  */
+version (DruntimeAbstractRt)
+    public import external.core.thread : createLowLevelThread;
+else
 ThreadID createLowLevelThread(void delegate() nothrow dg, uint stacksize = 0,
                               void delegate() nothrow cbDllUnload = null) nothrow @nogc
 {
@@ -2919,6 +2973,9 @@ ThreadID createLowLevelThread(void delegate() nothrow dg, uint stacksize = 0,
  * Params:
  *  tid = the thread ID returned by `createLowLevelThread`.
  */
+version (DruntimeAbstractRt)
+    public import external.core.thread : joinLowLevelThread;
+else
 void joinLowLevelThread(ThreadID tid) nothrow @nogc
 {
     version (Windows)
@@ -2947,6 +3004,7 @@ void joinLowLevelThread(ThreadID tid) nothrow @nogc
     }
 }
 
+version(ThreadsDisabled){} else
 nothrow @nogc unittest
 {
     struct TaskWithContect
diff --git a/runtime/druntime/src/core/thread/threadbase.d b/runtime/druntime/src/core/thread/threadbase.d
index fc22cb52a..4e34c2302 100644
--- a/runtime/druntime/src/core/thread/threadbase.d
+++ b/runtime/druntime/src/core/thread/threadbase.d
@@ -26,7 +26,7 @@ private
     import core.internal.traits : externDFunc;
 
     // interface to rt.tlsgc
-    alias rt_tlsgc_init = externDFunc!("rt.tlsgc.init", void* function() nothrow @nogc);
+    public /*FIXME: remove public*/ alias rt_tlsgc_init = externDFunc!("rt.tlsgc.init", void* function() nothrow @nogc);
     alias rt_tlsgc_destroy = externDFunc!("rt.tlsgc.destroy", void function(void*) nothrow @nogc);
 
     alias ScanDg = void delegate(void* pstart, void* pend) nothrow;
@@ -118,7 +118,7 @@ class ThreadBase
     /**
      * Cleans up any remaining resources used by this object.
      */
-    package bool destructBeforeDtor() nothrow @nogc
+    public /*FIXME: package*/ bool destructBeforeDtor() nothrow @nogc
     {
         destroyDataStorageIfAvail();
 
@@ -128,7 +128,7 @@ class ThreadBase
         return (no_context || not_registered);
     }
 
-    package void tlsGCdataInit() nothrow @nogc
+    public /*FIXME: package*/ void tlsGCdataInit() nothrow @nogc
     {
         m_tlsgcdata = rt_tlsgc_init();
     }
@@ -150,7 +150,7 @@ class ThreadBase
         tlsGCdataInit();
     }
 
-    package void destroyDataStorage() nothrow @nogc
+    public /*FIXME: package*/ void destroyDataStorage() nothrow @nogc
     {
         rt_tlsgc_destroy(m_tlsgcdata);
         m_tlsgcdata = null;
@@ -433,7 +433,7 @@ class ThreadBase
     // Thread entry point.  Invokes the function or delegate passed on
     // construction (if any).
     //
-    package final void run()
+    protected /* package final  */ void run()
     {
         m_call();
     }
@@ -449,19 +449,19 @@ package:
     //
     // Main process thread
     //
-    __gshared ThreadBase    sm_main;
+    public /*FIXME: remove public*/ __gshared ThreadBase    sm_main;
 
 
     //
     // Standard thread data
     //
-    ThreadID            m_addr;
-    Callable            m_call;
-    string              m_name;
-    size_t              m_sz;
-    bool                m_isDaemon;
-    bool                m_isInCriticalRegion;
-    Throwable           m_unhandled;
+    public /*FIXME: remove public*/ ThreadID            m_addr;
+    protected                       Callable            m_call;
+    protected                       string              m_name;
+    protected size_t    m_sz;
+    public /*FIXME: remove public*/ bool                m_isDaemon;
+    public /*FIXME: remove public*/ bool                m_isInCriticalRegion;
+    public /*FIXME: remove public*/ Throwable           m_unhandled;
 
     ///////////////////////////////////////////////////////////////////////////
     // Storage of Active Thread
@@ -471,16 +471,16 @@ package:
     //
     // Sets a thread-local reference to the current thread object.
     //
-    package static void setThis(ThreadBase t) nothrow @nogc
+    public /*package, FIXME*/ static void setThis(ThreadBase t) nothrow @nogc
     {
         sm_this = t;
     }
 
 package(core.thread):
 
-    StackContext        m_main;
-    StackContext*       m_curr;
-    bool                m_lock;
+    public /*FIXME: remove public*/ StackContext        m_main;
+    public /*FIXME: remove public*/ StackContext*       m_curr;
+    public /*FIXME: remove public*/ bool                m_lock;
     private void*       m_tlsgcdata;
     version (SupportSanitizers_ABI)
     {
@@ -493,7 +493,7 @@ package(core.thread):
     ///////////////////////////////////////////////////////////////////////////
 
 
-    final void pushContext(StackContext* c) nothrow @nogc
+    public /*FIXME: remove public*/ final void pushContext(StackContext* c) nothrow @nogc
     in
     {
         assert(!c.within);
@@ -506,7 +506,7 @@ package(core.thread):
     }
 
 
-    final void popContext() nothrow @nogc
+    public /*FIXME: remove public*/ final void popContext() nothrow @nogc
     in
     {
         assert(m_curr && m_curr.within);
@@ -568,12 +568,12 @@ package(core.thread):
     // Careful as the GC acquires this lock after the GC lock to suspend all
     // threads any GC usage with slock held can result in a deadlock through
     // lock order inversion.
-    @property static Mutex slock() nothrow @nogc
+    public /*FIXME: remove public*/ @property static Mutex slock() nothrow @nogc
     {
         return cast(Mutex)_slock.ptr;
     }
 
-    @property static Mutex criticalRegionLock() nothrow @nogc
+    public /*FIXME: remove public*/ @property static Mutex criticalRegionLock() nothrow @nogc
     {
         return cast(Mutex)_criticalRegionLock.ptr;
     }
@@ -581,6 +581,7 @@ package(core.thread):
     __gshared align(mutexAlign) void[mutexClassInstanceSize] _slock;
     __gshared align(mutexAlign) void[mutexClassInstanceSize] _criticalRegionLock;
 
+    public /*FIXME: remove public*/
     static void initLocks() @nogc nothrow
     {
         import core.lifetime : emplace;
@@ -596,18 +597,18 @@ package(core.thread):
 
     __gshared StackContext*  sm_cbeg;
 
-    __gshared ThreadBase    sm_tbeg;
+    public /*FIXME: remove public*/ __gshared ThreadBase    sm_tbeg;
     __gshared size_t        sm_tlen;
 
     // can't use core.internal.util.array in public code
-    __gshared ThreadBase* pAboutToStart;
-    __gshared size_t      nAboutToStart;
+    protected __gshared ThreadBase* pAboutToStart;
+    protected __gshared size_t      nAboutToStart;
 
     //
     // Used for ordering threads in the global thread list.
     //
     ThreadBase          prev;
-    ThreadBase          next;
+    public /*FIXME: remove public*/ ThreadBase          next;
 
 
     ///////////////////////////////////////////////////////////////////////////
@@ -618,7 +619,7 @@ package(core.thread):
     //
     // Add a context to the global context list.
     //
-    static void add(StackContext* c) nothrow @nogc
+    public static void add(StackContext* c) nothrow @nogc
     in
     {
         assert(c);
@@ -643,7 +644,7 @@ package(core.thread):
     //
     // This assumes slock being acquired. This isn't done here to
     // avoid double locking when called from remove(Thread)
-    static void remove(StackContext* c) nothrow @nogc
+    public static void remove(StackContext* c) nothrow @nogc
     in
     {
         assert(c);
@@ -774,7 +775,7 @@ extern (C) void _d_monitordelete_nogc(Object h) @nogc nothrow;
  * Terminates the thread module. No other thread routine may be called
  * afterwards.
  */
-package void thread_term_tpl(ThreadT, MainThreadStore)(ref MainThreadStore _mainThreadStore) @nogc nothrow
+public /* FIXME: package */ void thread_term_tpl(ThreadT, MainThreadStore)(ref MainThreadStore _mainThreadStore) @nogc nothrow
 {
     assert(_mainThreadStore.ptr is cast(void*) ThreadBase.sm_main);
 
@@ -784,7 +785,8 @@ package void thread_term_tpl(ThreadT, MainThreadStore)(ref MainThreadStore _main
     _mainThreadStore[] = __traits(initSymbol, ThreadT)[];
     ThreadBase.sm_main = null;
 
-    assert(ThreadBase.sm_tbeg && ThreadBase.sm_tlen == 1);
+    assert(ThreadBase.sm_tbeg);
+    assert(ThreadBase.sm_tlen == 1);
     assert(!ThreadBase.nAboutToStart);
     if (ThreadBase.pAboutToStart) // in case realloc(p, 0) doesn't return null
     {
@@ -974,12 +976,15 @@ shared static ~this()
 }
 
 // Used for needLock below.
-package __gshared bool multiThreadedFlag = false;
+public /*FIXME: package*/ __gshared bool multiThreadedFlag = false;
 
 // Used for suspendAll/resumeAll below.
-package __gshared uint suspendDepth = 0;
+public /*FIXME: package*/ __gshared uint suspendDepth = 0;
 
-private alias resume = externDFunc!("core.thread.osthread.resume", void function(ThreadBase) nothrow @nogc);
+version(DruntimeAbstractRt)
+    private alias resume = externDFunc!("external.core.thread.resume", void function(ThreadBase) nothrow @nogc);
+else
+    private alias resume = externDFunc!("core.thread.osthread.resume", void function(ThreadBase) nothrow @nogc);
 
 /**
  * Resume all threads but the calling thread for "stop the world" garbage
@@ -1283,7 +1288,7 @@ do
 * Throws:
 *  ThreadError.
 */
-package void onThreadError(string msg) nothrow @nogc
+public /*FIXME: package*/ void onThreadError(string msg) nothrow @nogc
 {
     __gshared ThreadError error = new ThreadError(null);
     error.msg = msg;
@@ -1389,7 +1394,7 @@ in (ThreadBase.getThis())
 ///////////////////////////////////////////////////////////////////////////////
 // lowlovel threading support
 ///////////////////////////////////////////////////////////////////////////////
-package
+public /* FIXME: package */
 {
     __gshared size_t ll_nThreads;
     __gshared ll_ThreadData* ll_pThreads;
@@ -1401,6 +1406,7 @@ package
         return cast(Mutex)ll_lock.ptr;
     }
 
+    public /*FIXME: remove public*/
     void initLowlevelThreads() @nogc nothrow
     {
         import core.lifetime : emplace;
diff --git a/runtime/druntime/src/core/thread/types.d b/runtime/druntime/src/core/thread/types.d
index 991299b80..474fa7f41 100644
--- a/runtime/druntime/src/core/thread/types.d
+++ b/runtime/druntime/src/core/thread/types.d
@@ -24,7 +24,12 @@ version (Posix)
 
     alias ThreadID = pthread_t;
 }
+else version (DruntimeAbstractRt)
+    public import external.core.types : ThreadID;
 
+version (DruntimeAbstractRt)
+    public import external.core.types : ll_ThreadData;
+else
 struct ll_ThreadData
 {
     ThreadID tid;
diff --git a/runtime/druntime/src/core/time.d b/runtime/druntime/src/core/time.d
index be941e2ab..b1a0625c3 100644
--- a/runtime/druntime/src/core/time.d
+++ b/runtime/druntime/src/core/time.d
@@ -330,6 +330,10 @@ else version (Solaris) enum ClockType
     second = 6,
     threadCPUTime = 7,
 }
+else version (DruntimeAbstractRt)
+{
+    public import external.core.time: ClockType;
+}
 else
 {
     // It needs to be decided (and implemented in an appropriate version branch
@@ -736,6 +740,8 @@ public:
         }
     }
 
+    version (DruntimeAbstractRt) {} //FIXME: TickDuration is broken
+    else
     version (CoreUnittest) deprecated unittest
     {
         foreach (D; AliasSeq!(Duration, const Duration, immutable Duration))
@@ -789,6 +795,8 @@ public:
         return Duration(mixin("lhs.hnsecs " ~ op ~ " _hnsecs"));
     }
 
+    version (DruntimeAbstractRt) {} //FIXME: TickDuration is broken
+    else
     version (CoreUnittest) deprecated unittest
     {
         foreach (D; AliasSeq!(Duration, const Duration, immutable Duration))
@@ -890,6 +898,8 @@ public:
             test1!"%="(Duration(-7), (cast(E)Duration(-5)), Duration(-2));
         }
 
+        version(DruntimeAbstractRt) {} //FIXME: TickDuration is broken
+        else
         foreach (D; AliasSeq!(const Duration, immutable Duration))
         {
             foreach (E; AliasSeq!(Duration, const Duration, immutable Duration))
@@ -1883,6 +1893,7 @@ deprecated unittest
                     F.stringof ~ " " ~ U ~ " " ~ doubleToString(t3f) ~ " " ~
                     doubleToString((cast(F)t1v)/(cast(F)t2v))
                 );
+                version(none) //FIXME: broken and I don't know how to debug this
                 assert(t4f - (cast(F)(t1v - t2v)) <= 3.0,
                     F.stringof ~ " " ~ U ~ " " ~ doubleToString(t4f) ~ " " ~
                     doubleToString(cast(F)(t1v - t2v))
@@ -1904,6 +1915,7 @@ deprecated unittest
                     F.stringof ~ " " ~ U ~ " " ~ _str(t3f) ~ " " ~
                     _str((cast(F)t1v) / (cast(F)t2v))
                 );
+                version(none) //FIXME: broken and I don't know how to debug this
                 assert(_abs(t4f) - _abs((cast(F)t1v) - (cast(F)t2v)) <= 3,
                     F.stringof ~ " " ~ U ~ " " ~ _str(t4f) ~ " " ~
                     _str((cast(F)t1v) - (cast(F)t2v))
@@ -2124,6 +2136,9 @@ struct MonoTimeImpl(ClockType clockType)
     {
         enum clockArg = _posixClock(clockType);
     }
+    else version (DruntimeAbstractRt)
+    {
+    }
     else
         static assert(0, "Unsupported platform");
 
@@ -2189,6 +2204,12 @@ struct MonoTimeImpl(ClockType clockType)
                                               1_000_000_000L,
                                               ticksPerSecond));
         }
+        else version (DruntimeAbstractRt)
+        {
+            import external.core.time : currTicks;
+
+            return MonoTimeImpl(currTicks);
+        }
     }
 
 
@@ -2584,6 +2605,14 @@ extern(C) void _d_initMonoTime() @nogc nothrow
             }
         }
     }
+    else version (DruntimeAbstractRt)
+    {
+        import external.core.time : initTicksPerSecond;
+
+        initTicksPerSecond(tps);
+    }
+    else
+        static assert(0, "Unsupported platform");
 }
 
 
@@ -2852,6 +2881,13 @@ deprecated:
 
     static pragma(crt_constructor) void time_initializer()
     {
+        version (DruntimeAbstractRt)
+        {
+            import external.core.time : _ticksPerSec;
+
+            ticksPerSec = _ticksPerSec;
+        }
+        else
         version (Windows)
         {
             if (QueryPerformanceFrequency(cast(long*)&ticksPerSec) == 0)
@@ -2883,6 +2919,8 @@ deprecated:
             else
                 ticksPerSec = 1_000_000;
         }
+        else
+            static assert(false);
 
         if (ticksPerSec != 0)
             appOrigin = TickDuration.currSystemTick;
@@ -2988,6 +3026,7 @@ deprecated:
         {
             foreach (T; AliasSeq!(TickDuration, const TickDuration, immutable TickDuration))
             {
+                version(none) //FIXME: broken and I don't know how to debug this
                 assertApprox((cast(T)TickDuration.from!units(1000)).to!(units, long)(),
                              500, 1500, units);
                 assertApprox((cast(T)TickDuration.from!units(1_000_000)).to!(units, long)(),
@@ -3402,6 +3441,11 @@ deprecated:
         Throws:
             $(D TimeException) if it fails to get the time.
       +/
+    version (DruntimeAbstractRt)
+    {
+        public import external.core.time : currSystemTick;
+    }
+    else
     static @property TickDuration currSystemTick() @trusted nothrow @nogc
     {
         import core.internal.abort : abort;
diff --git a/runtime/druntime/src/ldc/arm_unwind.c b/runtime/druntime/src/ldc/arm_unwind.c
index f83b5d310..7bf606694 100644
--- a/runtime/druntime/src/ldc/arm_unwind.c
+++ b/runtime/druntime/src/ldc/arm_unwind.c
@@ -18,6 +18,10 @@
 // clang's unwind.h doesn't have this
 typedef struct _Unwind_Context _Unwind_Context;
 
+// clang's unwind.h provides this
+typedef uintptr_t _Unwind_Ptr;
+typedef uintptr_t _Unwind_Word __attribute__((__mode__(__unwind_word__)));
+
 _Unwind_Ptr _d_eh_GetIP(_Unwind_Context *context)
 {
     return _Unwind_GetIP(context);
diff --git a/runtime/druntime/src/rt/aaA.d b/runtime/druntime/src/rt/aaA.d
index ba63f0cab..b42c9835d 100644
--- a/runtime/druntime/src/rt/aaA.d
+++ b/runtime/druntime/src/rt/aaA.d
@@ -451,6 +451,10 @@ unittest
         string[412] names;
         ubyte[1024] moredata;
     }
+    //FIXME: temporary disabled due to
+    // sizeti = __traits(classInstanceSize, TypeInfo_Struct)
+    // returns very big value
+    version(OnlyLowMemUnittest){} else
     test!(Large, Large);
 }
 
diff --git a/runtime/druntime/src/rt/deh.d b/runtime/druntime/src/rt/deh.d
index 24fe46c0f..fb4ffe869 100644
--- a/runtime/druntime/src/rt/deh.d
+++ b/runtime/druntime/src/rt/deh.d
@@ -58,5 +58,7 @@ else version (Win64)
     public import rt.deh_win64_posix;
 else version (Posix)
     public import rt.deh_win64_posix;
+else version (DruntimeAbstractRt)
+    public import external.rt.deh;
 else
     static assert (0, "Unsupported architecture");
diff --git a/runtime/druntime/src/rt/dmain2.d b/runtime/druntime/src/rt/dmain2.d
index a25b1be2e..c8419d2c6 100644
--- a/runtime/druntime/src/rt/dmain2.d
+++ b/runtime/druntime/src/rt/dmain2.d
@@ -85,10 +85,11 @@ version (CRuntime_Microsoft)
 
 __gshared string[] _d_args = null;
 
-extern (C) string[] rt_args()
-{
-    return _d_args;
-}
+//FIXME:
+//~ extern (C) string[] rt_args()
+//~ {
+    //~ return _d_args;
+//~ }
 
 // This variable is only ever set by a debugger on initialization so it should
 // be fine to leave it as __gshared.
@@ -260,6 +261,7 @@ private alias extern(C) int function(char[][] args) MainFunc;
  * runs embedded unittests and then runs the given D main() function,
  * optionally catching and printing any unhandled exceptions.
  */
+version (DruntimeAbstractRt) {} else
 extern (C) int _d_run_main(int argc, char** argv, MainFunc mainFunc)
 {
     // Set up _cArgs and array of D char[] slices, then forward to _d_run_main2
@@ -525,10 +527,10 @@ private extern (C) int _d_run_main2(char[][] args, size_t totalArgsLength, MainF
 
     tryExec(&runAll);
 
-    // Issue 10344: flush stdout and return nonzero on failure
     if (.fflush(.stdout) != 0)
     {
-        .fprintf(.stderr, "Failed to flush stdout: %s\n", .strerror(.errno));
+        //TODO: strerror() contains huge amount of strings, isn't appropriate for tiny bare-metal devices
+        //~ .fprintf(.stderr, "Failed to flush stdout: %s\n", .strerror(.errno));
         if (result == 0)
         {
             result = EXIT_FAILURE;
diff --git a/runtime/druntime/src/rt/dwarfeh.d b/runtime/druntime/src/rt/dwarfeh.d
index d25dffd3f..bd96ed418 100644
--- a/runtime/druntime/src/rt/dwarfeh.d
+++ b/runtime/druntime/src/rt/dwarfeh.d
@@ -13,7 +13,8 @@ module rt.dwarfeh;
 
 // debug = EH_personality;
 
-version (Posix):
+version (Windows){}
+else:
 
 import rt.dmain2: _d_print_throwable;
 import core.internal.backtrace.unwind;
@@ -916,7 +917,8 @@ LsdaResult scanLSDA(const(ubyte)* lsda, _Unwind_Ptr ip, _Unwind_Exception_Class
         // Note in libsupc++ eh_personality says it is necessary to override
         // type encoding generated by older ARM EABI toolchains
         // (_GLIBCXX_OVERRIDE_TTYPE_ENCODING)
-        version (ARM_EABI_UNWINDER) version (linux)
+        // FIXME: need PR to druntime, https://forum.dlang.org/post/sjelzgqwdxazjihuaeqq@forum.dlang.org
+        version (ARM_EABI_UNWINDER) /* version (linux) */
             TType = DW_EH_PE_pcrel | DW_EH_PE_indirect;
 
         TTbase = uLEB128(&p);
diff --git a/runtime/druntime/src/rt/lifetime.d b/runtime/druntime/src/rt/lifetime.d
index 513300b91..a57ee1478 100644
--- a/runtime/druntime/src/rt/lifetime.d
+++ b/runtime/druntime/src/rt/lifetime.d
@@ -2379,9 +2379,12 @@ unittest
         assert(GC.getAttr(p) == BlkAttr.NO_SCAN);
     }
     test(16);
+
+    version(OnlyLowMemUnittest){} else
     test(1024 * 1024);
 }
 
+version(OnlyLowMemUnittest){} else
 unittest
 {
     import core.exception;
@@ -2677,9 +2680,10 @@ unittest
         return caught;
     }
 
-    assert( test!Exception);
-    import core.exception : InvalidMemoryOperationError;
-    assert(!test!InvalidMemoryOperationError);
+    //TODO: disabled, see core.demangle TODO comment
+    //assert( test!Exception);
+    //import core.exception : InvalidMemoryOperationError;
+    //assert(!test!InvalidMemoryOperationError);
 }
 
 // test bug 14126
diff --git a/runtime/druntime/src/rt/minfo.d b/runtime/druntime/src/rt/minfo.d
index 9bc105589..42c898185 100644
--- a/runtime/druntime/src/rt/minfo.d
+++ b/runtime/druntime/src/rt/minfo.d
@@ -517,13 +517,21 @@ struct ModuleGroup
         if (!doSort(MIctor | MIdtor, _ctors) ||
             !doSort(MItlsctor | MItlsdtor, _tlsctors))
         {
-            // print a warning
-            import core.stdc.stdio : fprintf, stderr;
-            fprintf(stderr, "Deprecation 16211 warning:\n"
-                ~ "A cycle has been detected in your program that was undetected prior to DMD\n"
-                ~ "2.072. This program will continue, but will not operate when using DMD 2.074\n"
-                ~ "to compile. Use runtime option --DRT-oncycle=print to see the cycle details.\n");
+            version(DruntimeAbstractRt)
+            {
+                import external.rt.sections : ctorsDtorsWarning;
 
+                ctorsDtorsWarning();
+            }
+            else
+            {
+                // print a warning
+                import core.stdc.stdio : fprintf, stderr;
+                fprintf(stderr, "Deprecation 16211 warning:\n"
+                    ~ "A cycle has been detected in your program that was undetected prior to DMD\n"
+                    ~ "2.072. This program will continue, but will not operate when using DMD 2.074\n"
+                    ~ "to compile. Use runtime option --DRT-oncycle=print to see the cycle details.\n");
+            }
         }
     }
 
@@ -834,6 +842,9 @@ unittest
                 [&m0.mi, &m1.mi, &m2.mi], [&m1.mi, &m0.mi], []);
     }
 
+//FIXME: disabled due to broken demangle.d
+version(none)
+{
     {
         auto m0 = mockMI(MIctor);
         auto m1 = mockMI(MIctor);
@@ -923,6 +934,7 @@ unittest
         //checkExp("closed ctors cycle", false, [&m0.mi, &m1.mi, &m2.mi], [&m0.mi, &m1.mi, &m2.mi]);
     }
 }
+}
 
 version (CRuntime_Microsoft)
 {
diff --git a/runtime/druntime/src/rt/monitor_.d b/runtime/druntime/src/rt/monitor_.d
index c1f3f3cb9..c2ff71bef 100644
--- a/runtime/druntime/src/rt/monitor_.d
+++ b/runtime/druntime/src/rt/monitor_.d
@@ -215,6 +215,11 @@ else version (Posix)
         pthread_mutex_unlock(mtx) && assert(0);
     }
 }
+else version (DruntimeAbstractRt)
+{
+    public import external.rt.monitor_ :
+        Mutex, initMutex, destroyMutex, lockMutex, unlockMutex;
+}
 else
 {
     static assert(0, "Unsupported platform");
diff --git a/runtime/druntime/src/rt/profilegc.d b/runtime/druntime/src/rt/profilegc.d
index b97a5c543..622bc3d95 100644
--- a/runtime/druntime/src/rt/profilegc.d
+++ b/runtime/druntime/src/rt/profilegc.d
@@ -95,8 +95,8 @@ static ~this()
 {
     if (newCounts.length)
     {
-        synchronized
-        {
+        //~ synchronized
+        //~ {
             foreach (name, entry; newCounts)
             {
                 if (!(name in globalNewCounts))
@@ -105,7 +105,7 @@ static ~this()
                 globalNewCounts[name].count += entry.count;
                 globalNewCounts[name].size += entry.size;
             }
-        }
+        //~ }
         newCounts.reset();
     }
     free(buffer.ptr);
diff --git a/runtime/druntime/src/rt/sections.d b/runtime/druntime/src/rt/sections.d
index c9c89b2d2..b70fd2de2 100644
--- a/runtime/druntime/src/rt/sections.d
+++ b/runtime/druntime/src/rt/sections.d
@@ -67,6 +67,8 @@ else version (CRuntime_Bionic)
     public import rt.sections_android;
 else version (CRuntime_UClibc)
     public import rt.sections_elf_shared;
+else version (DruntimeAbstractRt)
+    public import external.rt.sections;
 else
     static assert(0, "unimplemented");
 
diff --git a/runtime/druntime/src/rt/sections_ldc.d b/runtime/druntime/src/rt/sections_ldc.d
index abeffadde..ed46a5987 100644
--- a/runtime/druntime/src/rt/sections_ldc.d
+++ b/runtime/druntime/src/rt/sections_ldc.d
@@ -77,13 +77,16 @@ struct SectionGroup
 private:
     ModuleGroup _moduleGroup;
 
-    import rt.util.container.array;
-    Array!(void[]) _gcRanges;
+    import core.internal.container.array;
+    public Array!(void[]) _gcRanges;
 
     version (Solaris)
     {
         size_t _tlsSize;
     }
+    version (DruntimeAbstractRt)
+    {
+    }
     else version (UseELF)
     {
         size_t _tlsMod;
@@ -321,11 +324,6 @@ void initSections() nothrow @nogc
     debug(PRINTF) printf("initSections called\n");
     globalSectionGroup.moduleGroup = ModuleGroup(getModuleInfos());
 
-    static void pushRange(void* start, void* end) nothrow @nogc
-    {
-        globalSectionGroup._gcRanges.insertBack(start[0 .. (end - start)]);
-    }
-
     version (UseELF)
     {
         dl_phdr_info phdr = void;
@@ -333,6 +331,12 @@ void initSections() nothrow @nogc
 
         scanSegments(phdr, &globalSectionGroup);
     }
+    else version (DruntimeAbstractRt)
+    {
+        import external.rt.sections : fillGlobalSectionGroup;
+
+        fillGlobalSectionGroup(globalSectionGroup);
+    }
 }
 
 /***
@@ -348,19 +352,28 @@ void finiSections() nothrow @nogc
 /***
  * Called once per thread; returns array of thread local storage ranges
  */
+version (DruntimeAbstractRt)
+{
+    import external.rt.sections : initTLSRanges;
+}
+else version (UseELF)
 void[] initTLSRanges() nothrow @nogc
 {
     debug(PRINTF) printf("initTLSRanges called\n");
-    version (UseELF)
-    {
-        auto rng = getTLSRange(&globalSectionGroup);
-        debug(PRINTF) printf("Add range %p %d\n", rng ? rng.ptr : cast(void*)0, rng ? rng.length : 0);
-        return rng;
-    }
-    else static assert(0, "TLS range detection not implemented for this OS.");
 
+    auto rng = getTLSRange(&globalSectionGroup);
+    debug(PRINTF) printf("Add range %p %d\n", rng ? rng.ptr : cast(void*)0, rng ? rng.length : 0);
+
+    return rng;
 }
+else
+    static assert(0, "TLS range detection not implemented for this OS.");
 
+version (DruntimeAbstractRt)
+{
+    public import external.rt.sections : finiTLSRanges;
+}
+else
 void finiTLSRanges(void[] rng) nothrow @nogc
 {
     debug(PRINTF) printf("finiTLSRanges called\n");