Merge remote-tracking branch 'upstream/master' into stable

Author: MartinNowak

README.md

@@ -4,8 +4,8 @@ DRuntime: Runtime Library for the D Programming Language
 [![GitHub tag](https://img.shields.io/github/tag/dlang/druntime.svg?maxAge=86400)](https://github.com/dlang/druntime/releases)
 [![Bugzilla Issues](https://img.shields.io/badge/issues-Bugzilla-green.svg)](https://issues.dlang.org/buglist.cgi?component=druntime&list_id=220148&product=D&resolution=---)
 [![CircleCI](https://circleci.com/gh/dlang/druntime/tree/master.svg?style=svg)](https://circleci.com/gh/dlang/druntime/tree/master)
+[![Buildkite](https://badge.buildkite.com/48ab4b9005c947aa3dbf0eeb4125391989c00c9545342b7b24.svg?branch=master)](https://buildkite.com/dlang/druntime)
 [![Code coverage](https://img.shields.io/codecov/c/github/dlang/druntime.svg?maxAge=86400)](https://codecov.io/gh/dlang/druntime)
-[![Issue Stats](https://img.shields.io/issuestats/p/github/dlang/druntime.svg?maxAge=2592000)](http://www.issuestats.com/github/dlang/druntime)
 [![license](https://img.shields.io/github/license/dlang/druntime.svg)](https://github.com/dlang/druntime/blob/master/LICENSE.txt)
 
 This is DRuntime. It is the low-level runtime library

changelog/core-memory-gc-profile-stats.dd

@@ -0,0 +1,4 @@
+Added `GC.profileStats()` to `core.memory`
+
+Allows access to current GC profiling information.
+See $(REF GC.ProfileStats, core,memory) for a list of profile stats.

changelog/cpp_new.dd

@@ -0,0 +1,4 @@
+Added `core.stdcpp.new_`
+
+Added `core.stdcpp.new_`, which exposes interfaces for C++ global new/delete operators.
+This allows D programs to conveniently allocate from the C++ heap, which is useful when sharing memory between languages.

changelog/cpu_count.dd

@@ -0,0 +1,3 @@
+Added `core.sys.linux.sched.CPU_COUNT`.
+
+Added `core.sys.linux.sched.CPU_COUNT`, which returns the number of CPUs in set.

changelog/cpu_isset.dd

@@ -0,0 +1,3 @@
+Added `core.sys.linux.sched.CPU_ISSET`.
+
+Added `core.sys.linux.sched.CPU_ISSET`, which tests to see if cpu is a member of set.

changelog/emplace.dd

@@ -0,0 +1,4 @@
+Moved `std.conv.emplace`, `std.algorithm.mutation.move`, `std.algorithm.mutation.moveEmplace`, and `std.functional.forward` to core/lifetime.d
+
+`emplace` is the counterpart to `destroy`, so it has been moved to also live in druntime (core/lifetime.d) where it is accessible by projects that use a shallow runtime library stack.
+`move`, `moveEmplace`, and `forward` are related low-level construction machinery which also belong in `core.lifetime`.

changelog/gc_cleanup.dd

@@ -0,0 +1,26 @@
+GC cleanup can now be configured as a DRT GC option
+
+The default cleanup method for the GC is to unconditionally run a
+collection before runtime termination to finalize objects
+that are still alive and hold resources that affect system state outside
+the current process. This combines the worst of possible alternatives:
+it can cause a considerable delay and does not guarantee finalization
+of all objects as roots might still exist.
+
+The cleanup behaviour can now be configured by a DRT option to the
+$(LINK2 $(ROOT_DIR)spec/garbage.html, GC configuration),
+e.g. by passing `--DRT-gcopt=cleanup:none` on the command
+line. Three options are provided:
+
+$(UL
+  $(LI collect: run a collection (the default for backward compatibility))
+  $(LI none: do nothing)
+  $(LI finalize: all live objects are finalized unconditionally)
+)
+
+As usual, you can also embed the configuration into the application by
+redefining `rt_options`, e.g.
+
+-------
+extern(C) __gshared string[] rt_options = [ "gcopt=cleanup:none" ];
+-------

changelog/gc_precise.dd

@@ -0,0 +1,8 @@
+A garbage collector with precise heap scanning can now be selected
+
+Precise heap scanning can now be enabled by a DRT option to the
+$(LINK2 $(ROOT_DIR)spec/garbage.html, GC configuration),
+e.g. by passing `--DRT-gcopt=gc:precise` on the command
+line or by redefining `rt_options`. See the
+$(LINK2 $(ROOT_DIR)spec/garbage.html#precise_gc, documentation)
+for details.

changelog/gc_realloc.dd

@@ -0,0 +1,18 @@
+GC.realloc is now more consistent and robust
+
+The specification of $(REF GC.realloc, core, memory) has changed slightly:
+
+$(UL
+ $(LI `GC.realloc` now returns `null` for failure. (It used to return the original pointer but
+   that is is not a good indication of failure as it might also be returned on success. It can
+   lead to overwriting memory if an enlargement was requested.))
+ $(LI as with `GC.free`, the caller has to ensure that there are no other live pointers to the
+   memory passed to `GC.realloc` (This used to be required only when passing a new size `0`).)
+ $(LI as a consequence the GC is allowed to free the memory immediately (the previous
+   implementation did this for objects larger than 4kB when shrinking).)
+ $(LI block attribute bits on the existing block are only set if it is reused (the previous
+   implementation didn't set bits if it reused a small block).)
+)
+
+The implementation now properly verifies that pointers are actually base pointers to allocated
+GC memory (passing other pointers could have crashed immediately or corrupt the GC).

changelog/gc_registry.dd

@@ -0,0 +1,7 @@
+User supplied garbage collectors can now be linked with the runtime
+
+A GC registry has been implemented that allows to add
+garbage collector implementations by just linking them into
+the binary.  See the
+$(LINK2 $(ROOT_DIR)spec/garbage.html#gc_registry, documentation)
+for details.