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, 336 insertions, 0 deletions

diff --git a/libphobos/src/std/digest/hmac.d b/libphobos/src/std/digest/hmac.d
new file mode 100644
index 0000000..bf0cbf3
--- /dev/null
+++ b/libphobos/src/std/digest/hmac.d
@@ -0,0 +1,336 @@
+// Written in the D programming language.
+
+/**
+This package implements the hash-based message authentication code (_HMAC)
+algorithm as defined in $(HTTP tools.ietf.org/html/rfc2104, RFC2104). See also
+the corresponding $(HTTP en.wikipedia.org/wiki/Hash-based_message_authentication_code, Wikipedia article).
+
+$(SCRIPT inhibitQuickIndex = 1;)
+
+Macros:
+
+License: $(HTTP boost.org/LICENSE_1_0.txt, Boost License 1.0).
+
+Source: $(PHOBOSSRC std/digest/_hmac.d)
+ */
+
+module std.digest.hmac;
+
+import std.digest : isDigest, hasBlockSize, isDigestibleRange, DigestType;
+import std.meta : allSatisfy;
+
+@safe:
+
+/**
+ * Template API HMAC implementation.
+ *
+ * This implements an _HMAC over the digest H. If H doesn't provide
+ * information about the block size, it can be supplied explicitly using
+ * the second overload.
+ *
+ * This type conforms to $(REF isDigest, std,digest).
+ */
+
+/// Compute HMAC over an input string
+@safe unittest
+{
+    import std.ascii : LetterCase;
+    import std.digest : toHexString;
+    import std.digest.sha : SHA1;
+    import std.string : representation;
+
+    auto secret = "secret".representation;
+    assert("The quick brown fox jumps over the lazy dog"
+            .representation
+            .hmac!SHA1(secret)
+            .toHexString!(LetterCase.lower) == "198ea1ea04c435c1246b586a06d5cf11c3ffcda6");
+}
+
+template HMAC(H)
+if (isDigest!H && hasBlockSize!H)
+{
+    alias HMAC = HMAC!(H, H.blockSize);
+}
+
+/**
+ * Overload of HMAC to be used if H doesn't provide information about its
+ * block size.
+ */
+
+struct HMAC(H, size_t hashBlockSize)
+if (hashBlockSize % 8 == 0)
+{
+    enum blockSize = hashBlockSize;
+
+    private H digest;
+    private ubyte[blockSize / 8] key;
+
+    /**
+     * Constructs the HMAC digest using the specified secret.
+     */
+
+    this(scope const(ubyte)[] secret)
+    {
+        // if secret is too long, shorten it by computing its hash
+        typeof(digest.finish()) buffer = void;
+        if (secret.length > blockSize / 8)
+        {
+            digest.start();
+            digest.put(secret);
+            buffer = digest.finish();
+            secret = buffer[];
+        }
+
+        // if secret is too short, it will be padded with zeroes
+        // (the key buffer is already zero-initialized)
+        import std.algorithm.mutation : copy;
+        secret.copy(key[]);
+
+        start();
+    }
+
+    ///
+    @safe pure nothrow @nogc unittest
+    {
+        import std.digest.hmac, std.digest.sha;
+        import std.string : representation;
+        auto hmac = HMAC!SHA1("My s3cR3T keY".representation);
+        hmac.put("Hello, world".representation);
+        static immutable expected = [
+            130, 32, 235, 44, 208, 141,
+            150, 232, 211, 214, 162, 195,
+            188, 127, 52, 89, 100, 68, 90, 216];
+        assert(hmac.finish() == expected);
+    }
+
+    /**
+     * Reinitializes the digest, making it ready for reuse.
+     *
+     * Note:
+     * The constructor leaves the digest in an initialized state, so that this
+     * method only needs to be called if an unfinished digest is to be reused.
+     *
+     * Returns:
+     * A reference to the digest for convenient chaining.
+     */
+
+    ref HMAC!(H, blockSize) start() return
+    {
+        ubyte[blockSize / 8] ipad = void;
+        foreach (immutable i; 0 .. blockSize / 8)
+            ipad[i] = key[i] ^ 0x36;
+
+        digest.start();
+        digest.put(ipad[]);
+
+        return this;
+    }
+
+    ///
+    @safe pure nothrow @nogc unittest
+    {
+        import std.digest.hmac, std.digest.sha;
+        import std.string : representation;
+        string data1 = "Hello, world", data2 = "Hola mundo";
+        auto hmac = HMAC!SHA1("My s3cR3T keY".representation);
+        hmac.put(data1.representation);
+        hmac.start();                   // reset digest
+        hmac.put(data2.representation); // start over
+        static immutable expected = [
+            122, 151, 232, 240, 249, 80,
+            19, 178, 186, 77, 110, 23, 208,
+            52, 11, 88, 34, 151, 192, 255];
+        assert(hmac.finish() == expected);
+    }
+
+    /**
+     * Feeds a piece of data into the hash computation. This method allows the
+     * type to be used as an $(REF OutputRange, std,range).
+     *
+     * Returns:
+     * A reference to the digest for convenient chaining.
+     */
+
+    ref HMAC!(H, blockSize) put(in ubyte[] data...) return
+    {
+        digest.put(data);
+        return this;
+    }
+
+    ///
+    @safe pure nothrow @nogc unittest
+    {
+        import std.digest.hmac, std.digest.sha;
+        import std.string : representation;
+        string data1 = "Hello, world", data2 = "Hola mundo";
+        auto hmac = HMAC!SHA1("My s3cR3T keY".representation);
+        hmac.put(data1.representation)
+            .put(data2.representation);
+        static immutable expected = [
+            197, 57, 52, 3, 13, 194, 13,
+            36, 117, 228, 8, 11, 111, 51,
+            165, 3, 123, 31, 251, 113];
+        assert(hmac.finish() == expected);
+    }
+
+    /**
+     * Resets the digest and returns the finished hash.
+     */
+
+    DigestType!H finish()
+    {
+        ubyte[blockSize / 8] opad = void;
+        foreach (immutable i; 0 .. blockSize / 8)
+            opad[i] = key[i] ^ 0x5c;
+
+        auto tmp = digest.finish();
+
+        digest.start();
+        digest.put(opad[]);
+        digest.put(tmp);
+        auto result = digest.finish();
+        start();    // reset the digest
+        return result;
+    }
+
+    ///
+    @safe pure nothrow @nogc unittest
+    {
+        import std.digest.hmac, std.digest.sha;
+        import std.string : representation;
+        string data1 = "Hello, world", data2 = "Hola mundo";
+        auto hmac = HMAC!SHA1("My s3cR3T keY".representation);
+        auto digest = hmac.put(data1.representation)
+                          .put(data2.representation)
+                          .finish();
+        static immutable expected = [
+            197, 57, 52, 3, 13, 194, 13,
+            36, 117, 228, 8, 11, 111, 51,
+            165, 3, 123, 31, 251, 113];
+        assert(digest == expected);
+    }
+}
+
+/// Convenience constructor for $(LREF HMAC).
+template hmac(H)
+if (isDigest!H && hasBlockSize!H)
+{
+    alias hmac = hmac!(H, H.blockSize);
+}
+
+/// ditto
+template hmac(H, size_t blockSize)
+if (isDigest!H)
+{
+    /**
+     * Constructs an HMAC digest with the specified secret.
+     *
+     * Returns:
+     * An instance of HMAC that can be fed data as desired, and finished
+     * to compute the final hash when done.
+     */
+    auto hmac(scope const(ubyte)[] secret)
+    {
+        return HMAC!(H, blockSize)(secret);
+    }
+
+    ///
+    @safe pure nothrow @nogc unittest
+    {
+        import std.digest.hmac, std.digest.sha;
+        import std.string : representation;
+        string data1 = "Hello, world", data2 = "Hola mundo";
+        auto digest = hmac!SHA1("My s3cR3T keY".representation)
+                          .put(data1.representation)
+                          .put(data2.representation)
+                          .finish();
+        static immutable expected = [
+            197, 57, 52, 3, 13, 194, 13, 36,
+            117, 228, 8, 11, 111, 51, 165,
+            3, 123, 31, 251, 113];
+        assert(digest == expected);
+    }
+
+    /**
+     * Computes an _HMAC digest over the given range of data with the
+     * specified secret.
+     *
+     * Returns:
+     * The final _HMAC hash.
+     */
+    DigestType!H hmac(T...)(scope T data, scope const(ubyte)[] secret)
+    if (allSatisfy!(isDigestibleRange, typeof(data)))
+    {
+        import std.range.primitives : put;
+        auto hash = HMAC!(H, blockSize)(secret);
+        foreach (datum; data)
+            put(hash, datum);
+        return hash.finish();
+    }
+
+    ///
+    @safe pure nothrow @nogc unittest
+    {
+        import std.algorithm.iteration : map;
+        import std.digest.hmac, std.digest.sha;
+        import std.string : representation;
+        string data = "Hello, world";
+        auto digest = data.representation
+                      .map!(a => cast(ubyte)(a+1))
+                      .hmac!SHA1("My s3cR3T keY".representation);
+        static assert(is(typeof(digest) == ubyte[20]));
+        static immutable expected = [
+            163, 208, 118, 179, 216, 93,
+            17, 10, 84, 200, 87, 104, 244,
+            111, 136, 214, 167, 210, 58, 10];
+        assert(digest == expected);
+    }
+}
+
+version (unittest)
+{
+    import std.digest : toHexString, LetterCase;
+    alias hex = toHexString!(LetterCase.lower);
+}
+
+@safe pure nothrow @nogc
+unittest
+{
+    import std.digest.md : MD5;
+    import std.range : isOutputRange;
+    static assert(isOutputRange!(HMAC!MD5, ubyte));
+    static assert(isDigest!(HMAC!MD5));
+    static assert(hasBlockSize!(HMAC!MD5) && HMAC!MD5.blockSize == MD5.blockSize);
+}
+
+@safe pure nothrow
+unittest
+{
+    import std.digest.md : MD5;
+    import std.digest.sha : SHA1, SHA256;
+
+    ubyte[] nada;
+    assert(hmac!MD5   (nada, nada).hex == "74e6f7298a9c2d168935f58c001bad88");
+    assert(hmac!SHA1  (nada, nada).hex == "fbdb1d1b18aa6c08324b7d64b71fb76370690e1d");
+    assert(hmac!SHA256(nada, nada).hex == "b613679a0814d9ec772f95d778c35fc5ff1697c493715653c6c712144292c5ad");
+
+    import std.string : representation;
+    auto key      = "key".representation,
+         long_key = ("012345678901234567890123456789012345678901"
+            ~"234567890123456789012345678901234567890123456789").representation,
+         data1    = "The quick brown fox ".representation,
+         data2    = "jumps over the lazy dog".representation,
+         data     = data1 ~ data2;
+
+    assert(data.hmac!MD5   (key).hex == "80070713463e7749b90c2dc24911e275");
+    assert(data.hmac!SHA1  (key).hex == "de7c9b85b8b78aa6bc8a7a36f70a90701c9db4d9");
+    assert(data.hmac!SHA256(key).hex == "f7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8");
+
+    assert(data.hmac!MD5   (long_key).hex == "e1728d68e05beae186ea768561963778");
+    assert(data.hmac!SHA1  (long_key).hex == "560d3cd77316e57ab4bba0c186966200d2b37ba3");
+    assert(data.hmac!SHA256(long_key).hex == "a1b0065a5d1edd93152c677e1bc1b1e3bc70d3a76619842e7f733f02b8135c04");
+
+    assert(hmac!MD5   (key).put(data1).put(data2).finish == data.hmac!MD5   (key));
+    assert(hmac!SHA1  (key).put(data1).put(data2).finish == data.hmac!SHA1  (key));
+    assert(hmac!SHA256(key).put(data1).put(data2).finish == data.hmac!SHA256(key));
+}