Merge pull request #2444 from TurkeyMan/cpp-allocator

std::allocator

Author: thewilsonator

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/std_allocator.dd

@@ -0,0 +1,4 @@
+Added `core.stdcpp.allocator`
+
+Added `core.stdcpp.allocator`, which exposes the C++ `std::allocator<T>` class.
+This is a required foundation for any of the allocating STL container types.

mak/COPY

@@ -50,8 +50,10 @@ COPY=\
 	$(IMPDIR)\core\stdc\wchar_.d \
 	$(IMPDIR)\core\stdc\wctype.d \
 	\
+	$(IMPDIR)\core\stdcpp\allocator.d \
 	$(IMPDIR)\core\stdcpp\array.d \
 	$(IMPDIR)\core\stdcpp\exception.d \
+	$(IMPDIR)\core\stdcpp\new_.d \
 	$(IMPDIR)\core\stdcpp\string_view.d \
 	$(IMPDIR)\core\stdcpp\typeinfo.d \
 	$(IMPDIR)\core\stdcpp\type_traits.d \

mak/DOCS

@@ -39,9 +39,11 @@ DOCS=\
 	$(DOCDIR)\core_stdc_wchar_.html \
 	$(DOCDIR)\core_stdc_wctype.html \
 	\
+	$(DOCDIR)\core_stdcpp_allocator.html \
 	$(DOCDIR)\core_stdcpp_array.html \
-	$(DOCDIR)\core_stdcpp_string_view.html \
 	$(DOCDIR)\core_stdcpp_exception.html \
+	$(DOCDIR)\core_stdcpp_new_.html \
+	$(DOCDIR)\core_stdcpp_string_view.html \
 	$(DOCDIR)\core_stdcpp_typeinfo.html \
 	$(DOCDIR)\core_stdcpp_type_traits.html \
 	\

mak/SRCS

@@ -50,7 +50,9 @@ SRCS=\
 	src\core\stdc\wchar_.d \
 	src\core\stdc\wctype.d \
 	\
+	src\core\stdcpp\allocator.d \
 	src\core\stdcpp\array.d \
+	src\core\stdcpp\new_.d \
 	src\core\stdcpp\string_view.d \
 	src\core\stdcpp\type_traits.d \
 	src\core\stdcpp\xutility.d \

mak/WINDOWS

@@ -189,12 +189,18 @@ $(IMPDIR)\core\stdc\wchar_.d : src\core\stdc\wchar_.d
 $(IMPDIR)\core\stdc\wctype.d : src\core\stdc\wctype.d
 	copy $** $@
 
-$(IMPDIR)\core\stdcpp\exception.d : src\core\stdcpp\exception.d
+$(IMPDIR)\core\stdcpp\allocator.d : src\core\stdcpp\allocator.d
 	copy $** $@
 
 $(IMPDIR)\core\stdcpp\array.d : src\core\stdcpp\array.d
 	copy $** $@
 
+$(IMPDIR)\core\stdcpp\exception.d : src\core\stdcpp\exception.d
+	copy $** $@
+
+$(IMPDIR)\core\stdcpp\new_.d : src\core\stdcpp\new_.d
+	copy $** $@
+
 $(IMPDIR)\core\stdcpp\string_view.d : src\core\stdcpp\string_view.d
 	copy $** $@
 

src/core/stdcpp/allocator.d

@@ -0,0 +1,126 @@
+/**
+ * D binding to C++ std::allocator.
+ *
+ * Copyright: Copyright (c) 2019 D Language Foundation
+ * License: Distributed under the
+ *      $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost Software License 1.0).
+ *    (See accompanying file LICENSE)
+ * Authors:   Manu Evans
+ * Source:    $(DRUNTIMESRC core/stdcpp/allocator.d)
+ */
+
+module core.stdcpp.allocator;
+
+import core.stdcpp.new_;
+import core.stdcpp.xutility : __cpp_sized_deallocation, __cpp_aligned_new;
+
+// some versions of VS require a `* const` pointer mangling hack
+// we need a way to supply the target VS version to the compile
+version (CppRuntime_Microsoft)
+    version = NeedsMangleHack;
+
+/**
+ * Allocators are classes that define memory models to be used by some parts of
+ * the C++ Standard Library, and most specifically, by STL containers.
+ */
+extern(C++, class)
+extern(C++, "std")
+struct allocator(T)
+{
+    static assert(!is(T == const), "The C++ Standard forbids containers of const elements because allocator!(const T) is ill-formed.");
+    static assert(!is(T == immutable), "immutable is not representable in C++");
+    static assert(!is(T == class), "Instantiation with `class` is not supported; D can't mangle the base (non-pointer) type of a class. Use `extern (C++, class) struct T { ... }` instead.");
+
+    ///
+    alias value_type = T;
+
+    version (CppRuntime_Microsoft)
+    {
+        ///
+        T* allocate(size_t count) @nogc;
+        ///
+        void deallocate(T* ptr, size_t count) @nogc;
+
+        ///
+        enum size_t max_size = size_t.max / T.sizeof;
+
+        version (NeedsMangleHack)
+        {
+            // HACK: workaround to make `deallocate` link as a `T * const`
+            private extern (D) enum string constHack(string name) = (){
+                version (Win64)
+                    enum sub = "AAXPE";
+                else
+                    enum sub = "AEXPA";
+                foreach (i; 0 .. name.length - sub.length)
+                    if (name[i .. i + sub.length] == sub[])
+                        return name[0 .. i + 3] ~ 'Q' ~ name[i + 4 .. $];
+                assert(false, "substitution string not found!");
+            }();
+            pragma(linkerDirective, "/alternatename:" ~ deallocate.mangleof ~ "=" ~ constHack!(deallocate.mangleof));
+        }
+    }
+    else version (CppRuntime_Gcc)
+    {
+        ///
+        T* allocate(size_t count, const(void)* = null) @nogc
+        {
+//            if (count > max_size)
+//                std::__throw_bad_alloc();
+
+            static if (__cpp_aligned_new && T.alignof > __STDCPP_DEFAULT_NEW_ALIGNMENT__)
+                return cast(T*)__cpp_new_aligned(count * T.sizeof, cast(align_val_t)T.alignof);
+            else
+                return cast(T*)__cpp_new(count * T.sizeof);
+        }
+        ///
+        void deallocate(T* ptr, size_t count) @nogc
+        {
+            // NOTE: GCC doesn't seem to use the sized delete when it's available...
+
+            static if (__cpp_aligned_new && T.alignof > __STDCPP_DEFAULT_NEW_ALIGNMENT__)
+                __cpp_delete_aligned(cast(void*)ptr, cast(align_val_t)T.alignof);
+            else
+                __cpp_delete(cast(void*)ptr);
+        }
+
+        ///
+        enum size_t max_size = (ptrdiff_t.max < size_t.max ? cast(size_t)ptrdiff_t.max : size_t.max) / T.sizeof;
+    }
+    else version (CppRuntime_Clang)
+    {
+        ///
+        T* allocate(size_t count, const(void)* = null) @nogc
+        {
+//            if (count > max_size)
+//                __throw_length_error("allocator!T.allocate(size_t n) 'n' exceeds maximum supported size");
+
+            static if (__cpp_aligned_new && T.alignof > __STDCPP_DEFAULT_NEW_ALIGNMENT__)
+                return cast(T*)__cpp_new_aligned(count * T.sizeof, cast(align_val_t)T.alignof);
+            else
+                return cast(T*)__cpp_new(count * T.sizeof);
+        }
+        ///
+        void deallocate(T* ptr, size_t count) @nogc
+        {
+            static if (__cpp_aligned_new && T.alignof > __STDCPP_DEFAULT_NEW_ALIGNMENT__)
+            {
+                static if (__cpp_sized_deallocation)
+                    return __cpp_delete_size_aligned(cast(void*)ptr, count * T.sizeof, cast(align_val_t)T.alignof);
+                else
+                    return __cpp_delete_aligned(cast(void*)ptr, cast(align_val_t)T.alignof);
+            }
+            else static if (__cpp_sized_deallocation)
+                return __cpp_delete_size(cast(void*)ptr, count * T.sizeof);
+            else
+                return __cpp_delete(cast(void*)ptr);
+        }
+
+        ///
+        enum size_t max_size = size_t.max / T.sizeof;
+    }
+    else
+    {
+        static assert(false, "C++ runtime not supported");
+    }
+}

src/core/stdcpp/new_.d

@@ -0,0 +1,98 @@
+/**
+ * D binding to C++ <new>
+ *
+ * Copyright: Copyright (c) 2019 D Language Foundation
+ * License: Distributed under the
+ *      $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost Software License 1.0).
+ *    (See accompanying file LICENSE)
+ * Authors:   Manu Evans
+ * Source:    $(DRUNTIMESRC core/stdcpp/new_.d)
+ */
+
+module core.stdcpp.new_;
+
+import core.stdcpp.xutility : __cpp_sized_deallocation, __cpp_aligned_new;
+
+// TODO: this really should come from __traits(getTargetInfo, "defaultNewAlignment")
+enum size_t __STDCPP_DEFAULT_NEW_ALIGNMENT__ = 16;
+
+
+extern (C++):
+
+///
+extern (C++, "std") enum align_val_t : size_t { defaultAlignment = __STDCPP_DEFAULT_NEW_ALIGNMENT__ };
+
+/// Binding for ::operator new(std::size_t count)
+pragma(mangle, __new_mangle)
+void* __cpp_new(size_t count) @nogc;
+
+/// Binding for ::operator delete(void* ptr)
+pragma(mangle, __delete_mangle)
+void __cpp_delete(void* ptr) @nogc;
+
+static if (__cpp_sized_deallocation)
+{
+    /// Binding for ::operator delete(void* ptr, size_t size)
+    pragma(mangle, __delete_size_mangle)
+    void __cpp_delete_size(void* ptr, size_t size) @nogc;
+}
+static if (__cpp_aligned_new)
+{
+    /// Binding for ::operator new(std::size_t count, std::align_val_t al)
+    pragma(mangle, __new_align_mangle)
+    void* __cpp_new_aligned(size_t count, align_val_t alignment) @nogc;
+
+    /// Binding for ::operator delete(void* ptr, std::align_val_t al)
+    pragma(mangle, __delete_align_mangle)
+    void __cpp_delete_aligned(void* ptr, align_val_t alignment) @nogc;
+
+    /// Binding for ::operator delete(void* ptr, size_t size, std::align_val_t al)
+    pragma(mangle, __delete_size_align_mangle)
+    void __cpp_delete_size_aligned(void* ptr, size_t size, align_val_t alignment) @nogc;
+}
+
+private:
+
+// we have to hard-code the mangling for the global new/delete operators
+version (CppRuntime_Microsoft)
+{
+    version (D_LP64)
+    {
+        enum __new_mangle               = "??2@YAPEAX_K@Z";
+        enum __delete_mangle            = "??3@YAXPEAX@Z";
+        enum __delete_size_mangle       = "??3@YAXPEAX_K@Z";
+        enum __new_align_mangle         = "??2@YAPEAX_KW4align_val_t@std@@@Z";
+        enum __delete_align_mangle      = "??3@YAXPEAXW4align_val_t@std@@@Z";
+        enum __delete_size_align_mangle = "??3@YAXPEAX_KW4align_val_t@std@@@Z";
+    }
+    else
+    {
+        enum __new_mangle               = "??2@YAPAXI@Z";
+        enum __delete_mangle            = "??3@YAXPAX@Z";
+        enum __delete_size_mangle       = "??3@YAXPAXI@Z";
+        enum __new_align_mangle         = "??2@YAPAXIW4align_val_t@std@@@Z";
+        enum __delete_align_mangle      = "??3@YAXPAXW4align_val_t@std@@@Z";
+        enum __delete_size_align_mangle = "??3@YAXPAXIW4align_val_t@std@@@Z";
+    }
+}
+else
+{
+    version (D_LP64)
+    {
+        enum __new_mangle               = "_Znwm";
+        enum __delete_mangle            = "_ZdlPv";
+        enum __delete_size_mangle       = "_ZdlPvm";
+        enum __new_align_mangle         = "_ZnwmSt11align_val_t";
+        enum __delete_align_mangle      = "_ZdlPvSt11align_val_t";
+        enum __delete_size_align_mangle = "_ZdlPvmSt11align_val_t";
+    }
+    else
+    {
+        enum __new_mangle               = "_Znwj";
+        enum __delete_mangle            = "_ZdlPv";
+        enum __delete_size_mangle       = "_ZdlPvj";
+        enum __new_align_mangle         = "_ZnwjSt11align_val_t";
+        enum __delete_align_mangle      = "_ZdlPvSt11align_val_t";
+        enum __delete_size_align_mangle = "_ZdlPvjSt11align_val_t";
+    }
+}

src/core/stdcpp/xutility.d

@@ -11,6 +11,22 @@
 
 module core.stdcpp.xutility;
 
+
+enum CppStdRevision : uint
+{
+    cpp98 = 199711,
+    cpp11 = 201103,
+    cpp14 = 201402,
+    cpp17 = 201703
+}
+
+enum __cplusplus = __traits(getTargetInfo, "cppStd");
+
+// wrangle C++ features
+enum __cpp_sized_deallocation = __cplusplus >= CppStdRevision.cpp14 ? 201309 : 0;
+enum __cpp_aligned_new = __cplusplus >= CppStdRevision.cpp17 ? 201606 : 0;
+
+
 extern(C++, "std"):
 
 version (CppRuntime_Microsoft)

test/common.mak

@@ -17,18 +17,20 @@ ROOT:=$(GENERATED)/$(OS)/$(BUILD)/$(MODEL)
 ifneq (default,$(MODEL))
 	MODEL_FLAG:=-m$(MODEL)
 endif
-CFLAGS:=$(MODEL_FLAG) $(PIC) -Wall
+CFLAGS_BASE:= $(MODEL_FLAG) $(PIC) -Wall
 DFLAGS:=$(MODEL_FLAG) $(PIC) -w -I../../src -I../../import -I$(SRC) -defaultlib= -debuglib= -dip1000
 # LINK_SHARED may be set by importing makefile
 DFLAGS+=$(if $(LINK_SHARED),-L$(DRUNTIMESO),-L$(DRUNTIME))
 ifeq ($(BUILD),debug)
 	DFLAGS += -g -debug
-	CFLAGS += -g
+	CFLAGS := $(CFLAGS_BASE) -g
 else
 	DFLAGS += -O -release
-	CFLAGS += -O3
+	CFLAGS := $(CFLAGS_BASE) -O3
 endif
+CXXFLAGS_BASE := $(CFLAGS_BASE) -std=c++11
 CXXFLAGS:=$(CFLAGS) -std=c++11
 ifeq (osx,$(OS))
 	CXXFLAGS+=-stdlib=libc++
+	CXXFLAGS_BASE+=-stdlib=libc++
 endif