Add D front-end, libphobos library, and D2 testsuite.

ChangeLog:

	* Makefile.def (target_modules): Add libphobos.
	(flags_to_pass): Add GDC, GDCFLAGS, GDC_FOR_TARGET and
	GDCFLAGS_FOR_TARGET.
	(dependencies): Make libphobos depend on libatomic, libbacktrace
	configure, and zlib configure.
	(language): Add language d.
	* Makefile.in: Rebuild.
	* Makefile.tpl (BUILD_EXPORTS): Add GDC and GDCFLAGS.
	(HOST_EXPORTS): Add GDC.
	(POSTSTAGE1_HOST_EXPORTS): Add GDC and GDC_FOR_BUILD.
	(BASE_TARGET_EXPORTS): Add GDC.
	(GDC_FOR_BUILD, GDC, GDCFLAGS): New variables.
	(GDC_FOR_TARGET, GDC_FLAGS_FOR_TARGET): New variables.
	(EXTRA_HOST_FLAGS): Add GDC.
	(STAGE1_FLAGS_TO_PASS): Add GDC.
	(EXTRA_TARGET_FLAGS): Add GDC and GDCFLAGS.
	* config-ml.in: Treat GDC and GDCFLAGS like other compiler/flag
	environment variables.
	* configure: Rebuild.
	* configure.ac: Add target-libphobos to target_libraries.  Set and
	substitute GDC_FOR_BUILD and GDC_FOR_TARGET.

config/ChangeLog:

	* multi.m4: Set GDC.

gcc/ChangeLog:

	* Makefile.in (tm_d_file_list, tm_d_include_list): New variables.
	(TM_D_H, D_TARGET_DEF, D_TARGET_H, D_TARGET_OBJS): New variables.
	(tm_d.h, cs-tm_d.h, default-d.o): New rules.
	(d/d-target-hooks-def.h, s-d-target-hooks-def-h): New rules.
	(s-tm-texi): Also check timestamp on d-target.def.
	(generated_files): Add TM_D_H and d-target-hooks-def.h.
	(build/genhooks.o): Also depend on D_TARGET_DEF.
	* config.gcc (tm_d_file, d_target_objs, target_has_targetdm): New
	variables.
	* config/aarch64/aarch64-d.c: New file.
	* config/aarch64/aarch64-linux.h (GNU_USER_TARGET_D_CRITSEC_SIZE):
	Define.
	* config/aarch64/aarch64-protos.h (aarch64_d_target_versions): New
	prototype.
	* config/aarch64/aarch64.h (TARGET_D_CPU_VERSIONS): Define.
	* config/aarch64/t-aarch64 (aarch64-d.o): New rule.
	* config/arm/arm-d.c: New file.
	* config/arm/arm-protos.h (arm_d_target_versions): New prototype.
	* config/arm/arm.h (TARGET_D_CPU_VERSIONS): Define.
	* config/arm/linux-eabi.h (EXTRA_TARGET_D_OS_VERSIONS): Define.
	* config/arm/t-arm (arm-d.o): New rule.
	* config/default-d.c: New file.
	* config/glibc-d.c: New file.
	* config/gnu.h (GNU_USER_TARGET_D_OS_VERSIONS): Define.
	* config/i386/i386-d.c: New file.
	* config/i386/i386-protos.h (ix86_d_target_versions): New prototype.
	* config/i386/i386.h (TARGET_D_CPU_VERSIONS): Define.
	* config/i386/linux-common.h (EXTRA_TARGET_D_OS_VERSIONS): Define.
	(GNU_USER_TARGET_D_CRITSEC_SIZE): Define.
	* config/i386/t-i386 (i386-d.o): New rule.
	* config/kfreebsd-gnu.h (GNU_USER_TARGET_D_OS_VERSIONS): Define.
	* config/kopensolaris-gnu.h (GNU_USER_TARGET_D_OS_VERSIONS): Define.
	* config/linux-android.h (ANDROID_TARGET_D_OS_VERSIONS): Define.
	* config/linux.h (GNU_USER_TARGET_D_OS_VERSIONS): Define.
	* config/mips/linux-common.h (EXTRA_TARGET_D_OS_VERSIONS): Define.
	* config/mips/mips-d.c: New file.
	* config/mips/mips-protos.h (mips_d_target_versions): New prototype.
	* config/mips/mips.h (TARGET_D_CPU_VERSIONS): Define.
	* config/mips/t-mips (mips-d.o): New rule.
	* config/powerpcspe/linux.h (GNU_USER_TARGET_D_OS_VERSIONS): Define.
	* config/powerpcspe/linux64.h (GNU_USER_TARGET_D_OS_VERSIONS): Define.
	* config/powerpcspe/powerpcspe-d.c: New file.
	* config/powerpcspe/powerpcspe-protos.h (rs6000_d_target_versions):
	New prototype.
	* config/powerpcspe/powerpcspe.c (rs6000_output_function_epilogue):
	Support GNU D by using 0 as the language type.
	* config/powerpcspe/powerpcspe.h (TARGET_D_CPU_VERSIONS): Define.
	* config/powerpcspe/t-powerpcspe (powerpcspe-d.o): New rule.
	* config/riscv/riscv-d.c: New file.
	* config/riscv/riscv-protos.h (riscv_d_target_versions): New
	prototype.
	* config/riscv/riscv.h (TARGET_D_CPU_VERSIONS): Define.
	* config/riscv/t-riscv (riscv-d.o): New rule.
	* config/rs6000/linux.h (GNU_USER_TARGET_D_OS_VERSIONS): Define.
	* config/rs6000/linux64.h (GNU_USER_TARGET_D_OS_VERSIONS): Define.
	* config/rs6000/rs6000-d.c: New file.
	* config/rs6000/rs6000-protos.h (rs6000_d_target_versions): New
	prototype.
	* config/rs6000/rs6000.c (rs6000_output_function_epilogue):
	Support GNU D by using 0 as the language type.
	* config/rs6000/rs6000.h (TARGET_D_CPU_VERSIONS): Define.
	* config/rs6000/t-rs6000 (rs6000-d.o): New rule.
	* config/s390/s390-d.c: New file.
	* config/s390/s390-protos.h (s390_d_target_versions): New prototype.
	* config/s390/s390.h (TARGET_D_CPU_VERSIONS): Define.
	* config/s390/t-s390 (s390-d.o): New rule.
	* config/sparc/sparc-d.c: New file.
	* config/sparc/sparc-protos.h (sparc_d_target_versions): New
	prototype.
	* config/sparc/sparc.h (TARGET_D_CPU_VERSIONS): Define.
	* config/sparc/t-sparc (sparc-d.o): New rule.
	* config/t-glibc (glibc-d.o): New rule.
	* configure: Regenerated.
	* configure.ac (tm_d_file): New variable.
	(tm_d_file_list, tm_d_include_list, d_target_objs): Add substitutes.
	* doc/contrib.texi (Contributors): Add self for the D frontend.
	* doc/frontends.texi (G++ and GCC): Mention D as a supported language.
	* doc/install.texi (Configuration): Mention libphobos as an option for
	--enable-shared.  Mention d as an option for --enable-languages.
	(Testing): Mention check-d as a target.
	* doc/invoke.texi (Overall Options): Mention .d, .dd, and .di as file
	name suffixes.  Mention d as a -x option.
	* doc/sourcebuild.texi (Top Level): Mention libphobos.
	* doc/standards.texi (Standards): Add section on D language.
	* doc/tm.texi: Regenerated.
	* doc/tm.texi.in: Add @node for D language and ABI, and @hook for
	TARGET_CPU_VERSIONS, TARGET_D_OS_VERSIONS, and TARGET_D_CRITSEC_SIZE.
	* dwarf2out.c (is_dlang): New function.
	(gen_compile_unit_die): Use DW_LANG_D for D.
	(declare_in_namespace): Return module die for D, instead of adding
	extra declarations into the namespace.
	(gen_namespace_die): Generate DW_TAG_module for D.
	(gen_decl_die): Handle CONST_DECLSs for D.
	(dwarf2out_decl): Likewise.
	(prune_unused_types_walk_local_classes): Handle DW_tag_interface_type.
	(prune_unused_types_walk): Handle DW_tag_interface_type same as other
	kinds of aggregates.
	* gcc.c (default_compilers): Add entries for .d, .dd and .di.
	* genhooks.c: Include d/d-target.def.

gcc/po/ChangeLog:

	* EXCLUDES: Add sources from d/dmd.

gcc/testsuite/ChangeLog:

	* gcc.misc-tests/help.exp: Add D to option descriptions check.
	* gdc.dg/asan/asan.exp: New file.
	* gdc.dg/asan/gdc272.d: New test.
	* gdc.dg/compilable.d: New test.
	* gdc.dg/dg.exp: New file.
	* gdc.dg/gdc254.d: New test.
	* gdc.dg/gdc260.d: New test.
	* gdc.dg/gdc270a.d: New test.
	* gdc.dg/gdc270b.d: New test.
	* gdc.dg/gdc282.d: New test.
	* gdc.dg/gdc283.d: New test.
	* gdc.dg/imports/gdc170.d: New test.
	* gdc.dg/imports/gdc231.d: New test.
	* gdc.dg/imports/gdc239.d: New test.
	* gdc.dg/imports/gdc241a.d: New test.
	* gdc.dg/imports/gdc241b.d: New test.
	* gdc.dg/imports/gdc251a.d: New test.
	* gdc.dg/imports/gdc251b.d: New test.
	* gdc.dg/imports/gdc253.d: New test.
	* gdc.dg/imports/gdc254a.d: New test.
	* gdc.dg/imports/gdc256.d: New test.
	* gdc.dg/imports/gdc27.d: New test.
	* gdc.dg/imports/gdcpkg256/package.d: New test.
	* gdc.dg/imports/runnable.d: New test.
	* gdc.dg/link.d: New test.
	* gdc.dg/lto/lto.exp: New file.
	* gdc.dg/lto/ltotests_0.d: New test.
	* gdc.dg/lto/ltotests_1.d: New test.
	* gdc.dg/runnable.d: New test.
	* gdc.dg/simd.d: New test.
	* gdc.test/gdc-test.exp: New file.
	* lib/gdc-dg.exp: New file.
	* lib/gdc.exp: New file.

libphobos/ChangeLog:

	* Makefile.am: New file.
	* Makefile.in: New file.
	* acinclude.m4: New file.
	* aclocal.m4: New file.
	* config.h.in: New file.
	* configure: New file.
	* configure.ac: New file.
	* d_rules.am: New file.
	* libdruntime/Makefile.am: New file.
	* libdruntime/Makefile.in: New file.
	* libdruntime/__entrypoint.di: New file.
	* libdruntime/__main.di: New file.
	* libdruntime/gcc/attribute.d: New file.
	* libdruntime/gcc/backtrace.d: New file.
	* libdruntime/gcc/builtins.d: New file.
	* libdruntime/gcc/config.d.in: New file.
	* libdruntime/gcc/deh.d: New file.
	* libdruntime/gcc/libbacktrace.d.in: New file.
	* libdruntime/gcc/unwind/arm.d: New file.
	* libdruntime/gcc/unwind/arm_common.d: New file.
	* libdruntime/gcc/unwind/c6x.d: New file.
	* libdruntime/gcc/unwind/generic.d: New file.
	* libdruntime/gcc/unwind/package.d: New file.
	* libdruntime/gcc/unwind/pe.d: New file.
	* m4/autoconf.m4: New file.
	* m4/druntime.m4: New file.
	* m4/druntime/cpu.m4: New file.
	* m4/druntime/libraries.m4: New file.
	* m4/druntime/os.m4: New file.
	* m4/gcc_support.m4: New file.
	* m4/gdc.m4: New file.
	* m4/libtool.m4: New file.
	* src/Makefile.am: New file.
	* src/Makefile.in: New file.
	* src/libgphobos.spec.in: New file.
	* testsuite/Makefile.am: New file.
	* testsuite/Makefile.in: New file.
	* testsuite/config/default.exp: New file.
	* testsuite/lib/libphobos-dg.exp: New file.
	* testsuite/lib/libphobos.exp: New file.
	* testsuite/testsuite_flags.in: New file.

From-SVN: r265573

1 files changed, 418 insertions, 0 deletions

diff --git a/libphobos/src/std/outbuffer.d b/libphobos/src/std/outbuffer.d
new file mode 100644
index 0000000..1d59498
--- /dev/null
+++ b/libphobos/src/std/outbuffer.d
@@ -0,0 +1,418 @@
+// Written in the D programming language.
+
+/**
+Serialize data to $(D ubyte) arrays.
+
+ * Copyright: Copyright Digital Mars 2000 - 2015.
+ * License:   $(HTTP www.boost.org/LICENSE_1_0.txt, Boost License 1.0).
+ * Authors:   $(HTTP digitalmars.com, Walter Bright)
+ * Source:    $(PHOBOSSRC std/_outbuffer.d)
+ *
+ * $(SCRIPT inhibitQuickIndex = 1;)
+ */
+module std.outbuffer;
+
+import core.stdc.stdarg; // : va_list;
+
+/*********************************************
+ * OutBuffer provides a way to build up an array of bytes out
+ * of raw data. It is useful for things like preparing an
+ * array of bytes to write out to a file.
+ * OutBuffer's byte order is the format native to the computer.
+ * To control the byte order (endianness), use a class derived
+ * from OutBuffer.
+ * OutBuffer's internal buffer is allocated with the GC. Pointers
+ * stored into the buffer are scanned by the GC, but you have to
+ * ensure proper alignment, e.g. by using alignSize((void*).sizeof).
+ */
+
+class OutBuffer
+{
+    ubyte[] data;
+    size_t offset;
+
+    invariant()
+    {
+        assert(offset <= data.length);
+    }
+
+  pure nothrow @safe
+  {
+    /*********************************
+     * Convert to array of bytes.
+     */
+    ubyte[] toBytes() { return data[0 .. offset]; }
+
+    /***********************************
+     * Preallocate nbytes more to the size of the internal buffer.
+     *
+     * This is a
+     * speed optimization, a good guess at the maximum size of the resulting
+     * buffer will improve performance by eliminating reallocations and copying.
+     */
+    void reserve(size_t nbytes) @trusted
+        in
+        {
+            assert(offset + nbytes >= offset);
+        }
+        out
+        {
+            assert(offset + nbytes <= data.length);
+        }
+        body
+        {
+            if (data.length < offset + nbytes)
+            {
+                void[] vdata = data;
+                vdata.length = (offset + nbytes + 7) * 2; // allocates as void[] to not set BlkAttr.NO_SCAN
+                data = cast(ubyte[]) vdata;
+            }
+        }
+
+    /**********************************
+     * put enables OutBuffer to be used as an OutputRange.
+     */
+    alias put = write;
+
+    /*************************************
+     * Append data to the internal buffer.
+     */
+
+    void write(const(ubyte)[] bytes)
+        {
+            reserve(bytes.length);
+            data[offset .. offset + bytes.length] = bytes[];
+            offset += bytes.length;
+        }
+
+    void write(in wchar[] chars) @trusted
+        {
+        write(cast(ubyte[]) chars);
+        }
+
+    void write(const(dchar)[] chars) @trusted
+        {
+        write(cast(ubyte[]) chars);
+        }
+
+    void write(ubyte b)         /// ditto
+        {
+            reserve(ubyte.sizeof);
+            this.data[offset] = b;
+            offset += ubyte.sizeof;
+        }
+
+    void write(byte b) { write(cast(ubyte) b); }         /// ditto
+    void write(char c) { write(cast(ubyte) c); }         /// ditto
+    void write(dchar c) { write(cast(uint) c); }         /// ditto
+
+    void write(ushort w) @trusted                /// ditto
+    {
+        reserve(ushort.sizeof);
+        *cast(ushort *)&data[offset] = w;
+        offset += ushort.sizeof;
+    }
+
+    void write(short s) { write(cast(ushort) s); }               /// ditto
+
+    void write(wchar c) @trusted        /// ditto
+    {
+        reserve(wchar.sizeof);
+        *cast(wchar *)&data[offset] = c;
+        offset += wchar.sizeof;
+    }
+
+    void write(uint w) @trusted         /// ditto
+    {
+        reserve(uint.sizeof);
+        *cast(uint *)&data[offset] = w;
+        offset += uint.sizeof;
+    }
+
+    void write(int i) { write(cast(uint) i); }           /// ditto
+
+    void write(ulong l) @trusted         /// ditto
+    {
+        reserve(ulong.sizeof);
+        *cast(ulong *)&data[offset] = l;
+        offset += ulong.sizeof;
+    }
+
+    void write(long l) { write(cast(ulong) l); }         /// ditto
+
+    void write(float f) @trusted         /// ditto
+    {
+        reserve(float.sizeof);
+        *cast(float *)&data[offset] = f;
+        offset += float.sizeof;
+    }
+
+    void write(double f) @trusted               /// ditto
+    {
+        reserve(double.sizeof);
+        *cast(double *)&data[offset] = f;
+        offset += double.sizeof;
+    }
+
+    void write(real f) @trusted         /// ditto
+    {
+        reserve(real.sizeof);
+        *cast(real *)&data[offset] = f;
+        offset += real.sizeof;
+    }
+
+    void write(in char[] s) @trusted             /// ditto
+    {
+        write(cast(ubyte[]) s);
+    }
+
+    void write(OutBuffer buf)           /// ditto
+    {
+        write(buf.toBytes());
+    }
+
+    /****************************************
+     * Append nbytes of 0 to the internal buffer.
+     */
+
+    void fill0(size_t nbytes)
+    {
+        reserve(nbytes);
+        data[offset .. offset + nbytes] = 0;
+        offset += nbytes;
+    }
+
+    /**********************************
+     * 0-fill to align on power of 2 boundary.
+     */
+
+    void alignSize(size_t alignsize)
+    in
+    {
+        assert(alignsize && (alignsize & (alignsize - 1)) == 0);
+    }
+    out
+    {
+        assert((offset & (alignsize - 1)) == 0);
+    }
+    body
+    {
+        auto nbytes = offset & (alignsize - 1);
+        if (nbytes)
+            fill0(alignsize - nbytes);
+    }
+
+    /// Clear the data in the buffer
+    void clear()
+    {
+        offset = 0;
+    }
+
+    /****************************************
+     * Optimize common special case alignSize(2)
+     */
+
+    void align2()
+    {
+        if (offset & 1)
+            write(cast(byte) 0);
+    }
+
+    /****************************************
+     * Optimize common special case alignSize(4)
+     */
+
+    void align4()
+    {
+        if (offset & 3)
+        {   auto nbytes = (4 - offset) & 3;
+            fill0(nbytes);
+        }
+    }
+
+    /**************************************
+     * Convert internal buffer to array of chars.
+     */
+
+    override string toString() const
+    {
+        //printf("OutBuffer.toString()\n");
+        return cast(string) data[0 .. offset].idup;
+    }
+  }
+
+    /*****************************************
+     * Append output of C's vprintf() to internal buffer.
+     */
+
+    void vprintf(string format, va_list args) @trusted nothrow
+    {
+        import core.stdc.stdio : vsnprintf;
+        import core.stdc.stdlib : alloca;
+        import std.string : toStringz;
+
+        version (unittest)
+            char[3] buffer = void;      // trigger reallocation
+        else
+            char[128] buffer = void;
+        int count;
+
+        // Can't use `tempCString()` here as it will result in compilation error:
+        // "cannot mix core.std.stdlib.alloca() and exception handling".
+        auto f = toStringz(format);
+        auto p = buffer.ptr;
+        auto psize = buffer.length;
+        for (;;)
+        {
+            va_list args2;
+            va_copy(args2, args);
+            count = vsnprintf(p, psize, f, args2);
+            va_end(args2);
+            if (count == -1)
+            {
+                if (psize > psize.max / 2) assert(0); // overflow check
+                psize *= 2;
+            }
+            else if (count >= psize)
+            {
+                if (count == count.max) assert(0); // overflow check
+                psize = count + 1;
+            }
+            else
+                break;
+
+            p = cast(char *) alloca(psize); // buffer too small, try again with larger size
+        }
+        write(cast(ubyte[]) p[0 .. count]);
+    }
+
+    /*****************************************
+     * Append output of C's printf() to internal buffer.
+     */
+
+    void printf(string format, ...) @trusted
+    {
+        va_list ap;
+        va_start(ap, format);
+        vprintf(format, ap);
+        va_end(ap);
+    }
+
+    /**
+     * Formats and writes its arguments in text format to the OutBuffer.
+     *
+     * Params:
+     *  fmt = format string as described in $(REF formattedWrite, std,format)
+     *  args = arguments to be formatted
+     *
+     * See_Also:
+     *  $(REF _writef, std,stdio);
+     *  $(REF formattedWrite, std,format);
+     */
+    void writef(Char, A...)(in Char[] fmt, A args)
+    {
+        import std.format : formattedWrite;
+        formattedWrite(this, fmt, args);
+    }
+
+    ///
+    @safe unittest
+    {
+        OutBuffer b = new OutBuffer();
+        b.writef("a%sb", 16);
+        assert(b.toString() == "a16b");
+    }
+
+    /**
+     * Formats and writes its arguments in text format to the OutBuffer,
+     * followed by a newline.
+     *
+     * Params:
+     *  fmt = format string as described in $(REF formattedWrite, std,format)
+     *  args = arguments to be formatted
+     *
+     * See_Also:
+     *  $(REF _writefln, std,stdio);
+     *  $(REF formattedWrite, std,format);
+     */
+    void writefln(Char, A...)(in Char[] fmt, A args)
+    {
+        import std.format : formattedWrite;
+        formattedWrite(this, fmt, args);
+        put('\n');
+    }
+
+    ///
+    @safe unittest
+    {
+        OutBuffer b = new OutBuffer();
+        b.writefln("a%sb", 16);
+        assert(b.toString() == "a16b\n");
+    }
+
+    /*****************************************
+     * At offset index into buffer, create nbytes of space by shifting upwards
+     * all data past index.
+     */
+
+    void spread(size_t index, size_t nbytes) pure nothrow @safe
+        in
+        {
+            assert(index <= offset);
+        }
+        body
+        {
+            reserve(nbytes);
+
+            // This is an overlapping copy - should use memmove()
+            for (size_t i = offset; i > index; )
+            {
+                --i;
+                data[i + nbytes] = data[i];
+            }
+            offset += nbytes;
+        }
+}
+
+///
+@safe unittest
+{
+    import std.string : cmp;
+
+    OutBuffer buf = new OutBuffer();
+
+    assert(buf.offset == 0);
+    buf.write("hello");
+    buf.write(cast(byte) 0x20);
+    buf.write("world");
+    buf.printf(" %d", 62665);
+    assert(cmp(buf.toString(), "hello world 62665") == 0);
+
+    buf.clear();
+    assert(cmp(buf.toString(), "") == 0);
+    buf.write("New data");
+    assert(cmp(buf.toString(),"New data") == 0);
+}
+
+@safe unittest
+{
+    import std.range;
+    static assert(isOutputRange!(OutBuffer, char));
+
+    import std.algorithm;
+  {
+    OutBuffer buf = new OutBuffer();
+    "hello".copy(buf);
+    assert(buf.toBytes() == "hello");
+  }
+  {
+    OutBuffer buf = new OutBuffer();
+    "hello"w.copy(buf);
+    assert(buf.toBytes() == "h\x00e\x00l\x00l\x00o\x00");
+  }
+  {
+    OutBuffer buf = new OutBuffer();
+    "hello"d.copy(buf);
+    assert(buf.toBytes() == "h\x00\x00\x00e\x00\x00\x00l\x00\x00\x00l\x00\x00\x00o\x00\x00\x00");
+  }
+}