d: Merge update dmd 799066f49

Removes the implementation of __traits(argTypes), which only supported
x86_64 targets.  The only use of this trait is an unused va_arg()
function, this has been removed as well.

Reviewed-on: https://github.com/dlang/dmd/pull/11022

gcc/d/ChangeLog:

2020-04-13  Iain Buclaw  <ibuclaw@gdcproject.org>

	* Make-lang.in (D_FRONTEND_OBJS): Remove d/argtypes.o.
	* d-target.cc (Target::toArgTypes): New function.

libphobos/ChangeLog:

2020-04-13  Iain Buclaw  <ibuclaw@gdcproject.org>

	* libdruntime/core/stdc/stdarg.d: Remove run-time va_list template.

8 files changed, 24 insertions, 491 deletions

diff --git a/gcc/d/ChangeLog b/gcc/d/ChangeLog
index 5f7e967..6544b3d 100644
--- a/gcc/d/ChangeLog
+++ b/gcc/d/ChangeLog
@@ -1,3 +1,8 @@
+2020-04-13  Iain Buclaw  <ibuclaw@gdcproject.org>
+
+	* Make-lang.in (D_FRONTEND_OBJS): Remove d/argtypes.o.
+	* d-target.cc (Target::toArgTypes): New function.
+
 2020-04-10  Iain Buclaw  <ibuclaw@gdcproject.org>
 
 	* d-spec.cc (LIBDRUNTIME): Remove.
diff --git a/gcc/d/Make-lang.in b/gcc/d/Make-lang.in
index 71dccad..ac04d07 100644
--- a/gcc/d/Make-lang.in
+++ b/gcc/d/Make-lang.in
@@ -59,7 +59,6 @@ D_FRONTEND_OBJS = \
 	d/access.o \
 	d/aliasthis.o \
 	d/apply.o \
-	d/argtypes.o \
 	d/arrayop.o \
 	d/attrib.o \
 	d/blockexit.o \
diff --git a/gcc/d/d-target.cc b/gcc/d/d-target.cc
index 7e11bd6..b2df266 100644
--- a/gcc/d/d-target.cc
+++ b/gcc/d/d-target.cc
@@ -410,3 +410,15 @@ Target::systemLinkage (void)
 {
   return LINKc;
 }
+
+/* Generate a TypeTuple of the equivalent types used to determine if a
+   function argument of the given type can be passed in registers.
+   The results of this are highly platform dependent, and intended
+   primarly for use in implementing va_arg() with RTTI.  */
+
+TypeTuple *
+Target::toArgTypes (Type *)
+{
+  /* Not implemented, however this is not currently used anywhere.  */
+  return NULL;
+}
diff --git a/gcc/d/dmd/MERGE b/gcc/d/dmd/MERGE
index 7f01407..dc9fb1b 100644
--- a/gcc/d/dmd/MERGE
+++ b/gcc/d/dmd/MERGE
@@ -1,4 +1,4 @@
-3e10e2dd29e583f1d94d84de5e4bd858e0303669
+799066f498aebcfa420df284cac1f204b1f953a8
 
 The first line of this file holds the git revision number of the last
 merge done from the dlang/dmd repository.
diff --git a/gcc/d/dmd/argtypes.c b/gcc/d/dmd/argtypes.c
deleted file mode 100644
index bed1d40..0000000
--- a/gcc/d/dmd/argtypes.c
+++ /dev/null
@@ -1,484 +0,0 @@
-
-/* Compiler implementation of the D programming language
- * Copyright (C) 2010-2019 by The D Language Foundation, All Rights Reserved
- * written by Walter Bright
- * http://www.digitalmars.com
- * Distributed under the Boost Software License, Version 1.0.
- * http://www.boost.org/LICENSE_1_0.txt
- * https://github.com/D-Programming-Language/dmd/blob/master/src/argtypes.c
- */
-
-#include "root/dsystem.h"
-#include "root/checkedint.h"
-
-#include "mars.h"
-#include "dsymbol.h"
-#include "mtype.h"
-#include "scope.h"
-#include "init.h"
-#include "expression.h"
-#include "attrib.h"
-#include "declaration.h"
-#include "template.h"
-#include "id.h"
-#include "enum.h"
-#include "import.h"
-#include "aggregate.h"
-#include "hdrgen.h"
-
-/****************************************************
- * This breaks a type down into 'simpler' types that can be passed to a function
- * in registers, and returned in registers.
- * It's highly platform dependent.
- * Params:
- *      t = type to break down
- * Returns:
- *      tuple of types, each element can be passed in a register.
- *      A tuple of zero length means the type cannot be passed/returned in registers.
- */
-
-TypeTuple *toArgTypes(Type *t)
-{
-    class ToArgTypes : public Visitor
-    {
-    public:
-        TypeTuple *result;
-
-        ToArgTypes()
-        {
-            result = NULL;
-        }
-
-        void visit(Type *)
-        {
-            // not valid for a parameter
-        }
-
-        void visit(TypeError *)
-        {
-            result = new TypeTuple(Type::terror);
-        }
-
-        void visit(TypeBasic *t)
-        {
-            Type *t1 = NULL;
-            Type *t2 = NULL;
-            switch (t->ty)
-            {
-                case Tvoid:
-                     return;
-
-                case Tbool:
-                case Tint8:
-                case Tuns8:
-                case Tint16:
-                case Tuns16:
-                case Tint32:
-                case Tuns32:
-                case Tfloat32:
-                case Tint64:
-                case Tuns64:
-                case Tint128:
-                case Tuns128:
-                case Tfloat64:
-                case Tfloat80:
-                    t1 = t;
-                    break;
-
-                case Timaginary32:
-                    t1 = Type::tfloat32;
-                    break;
-
-                case Timaginary64:
-                    t1 = Type::tfloat64;
-                    break;
-
-                case Timaginary80:
-                    t1 = Type::tfloat80;
-                    break;
-
-                case Tcomplex32:
-                    if (global.params.is64bit)
-                        t1 = Type::tfloat64;
-                    else
-                    {
-                        t1 = Type::tfloat64;
-                        t2 = Type::tfloat64;
-                    }
-                    break;
-
-                case Tcomplex64:
-                    t1 = Type::tfloat64;
-                    t2 = Type::tfloat64;
-                    break;
-
-                case Tcomplex80:
-                    t1 = Type::tfloat80;
-                    t2 = Type::tfloat80;
-                    break;
-
-                case Tchar:
-                    t1 = Type::tuns8;
-                    break;
-
-                case Twchar:
-                    t1 = Type::tuns16;
-                    break;
-
-                case Tdchar:
-                    t1 = Type::tuns32;
-                    break;
-
-                default:
-                    assert(0);
-            }
-
-            if (t1)
-            {
-                if (t2)
-                    result = new TypeTuple(t1, t2);
-                else
-                    result = new TypeTuple(t1);
-            }
-            else
-                result = new TypeTuple();
-        }
-
-        void visit(TypeVector *t)
-        {
-            result = new TypeTuple(t);
-        }
-
-        void visit(TypeSArray *t)
-        {
-            if (t->dim)
-            {
-                /* Should really be done as if it were a struct with dim members
-                 * of the array's elements.
-                 * I.e. int[2] should be done like struct S { int a; int b; }
-                 */
-                dinteger_t sz = t->dim->toInteger();
-                // T[1] should be passed like T
-                if (sz == 1)
-                {
-                    t->next->accept(this);
-                    return;
-                }
-            }
-            result = new TypeTuple();     // pass on the stack for efficiency
-        }
-
-        void visit(TypeAArray *)
-        {
-            result = new TypeTuple(Type::tvoidptr);
-        }
-
-        void visit(TypePointer *)
-        {
-            result = new TypeTuple(Type::tvoidptr);
-        }
-
-        /*************************************
-         * Convert a floating point type into the equivalent integral type.
-         */
-
-        static Type *mergeFloatToInt(Type *t)
-        {
-            switch (t->ty)
-            {
-                case Tfloat32:
-                case Timaginary32:
-                    t = Type::tint32;
-                    break;
-                case Tfloat64:
-                case Timaginary64:
-                case Tcomplex32:
-                    t = Type::tint64;
-                    break;
-                default:
-                    assert(0);
-            }
-            return t;
-        }
-
-        /*************************************
-         * This merges two types into an 8byte type.
-         * Params:
-         *      t1 = first type (can be null)
-         *      t2 = second type (can be null)
-         *      offset2 = offset of t2 from start of t1
-         * Returns:
-         *      type that encompasses both t1 and t2, null if cannot be done
-         */
-
-        static Type *argtypemerge(Type *t1, Type *t2, unsigned offset2)
-        {
-            //printf("argtypemerge(%s, %s, %d)\n", t1 ? t1->toChars() : "", t2 ? t2->toChars() : "", offset2);
-            if (!t1)
-            {   assert(!t2 || offset2 == 0);
-                return t2;
-            }
-            if (!t2)
-                return t1;
-
-            const d_uns64 sz1 = t1->size(Loc());
-            const d_uns64 sz2 = t2->size(Loc());
-            assert(sz1 != SIZE_INVALID && sz2 != SIZE_INVALID);
-
-            if (t1->ty != t2->ty &&
-                (t1->ty == Tfloat80 || t2->ty == Tfloat80))
-                return NULL;
-
-            // [float,float] => [cfloat]
-            if (t1->ty == Tfloat32 && t2->ty == Tfloat32 && offset2 == 4)
-                return Type::tfloat64;
-
-            // Merging floating and non-floating types produces the non-floating type
-            if (t1->isfloating())
-            {
-                if (!t2->isfloating())
-                    t1 = mergeFloatToInt(t1);
-            }
-            else if (t2->isfloating())
-                t2 = mergeFloatToInt(t2);
-
-            Type *t;
-
-            // Pick type with larger size
-            if (sz1 < sz2)
-                t = t2;
-            else
-                t = t1;
-
-            // If t2 does not lie within t1, need to increase the size of t to enclose both
-            assert(sz2 < UINT64_MAX - UINT32_MAX);
-            if (offset2 && sz1 < offset2 + sz2)
-            {
-                switch (offset2 + sz2)
-                {
-                    case 2:
-                        t = Type::tint16;
-                        break;
-                    case 3:
-                    case 4:
-                        t = Type::tint32;
-                        break;
-                    default:
-                        t = Type::tint64;
-                        break;
-                }
-            }
-            return t;
-        }
-
-        void visit(TypeDArray *)
-        {
-            /* Should be done as if it were:
-             * struct S { size_t length; void* ptr; }
-             */
-            if (global.params.is64bit && !global.params.isLP64)
-            {
-                // For AMD64 ILP32 ABI, D arrays fit into a single integer register.
-                unsigned offset = (unsigned)Type::tsize_t->size(Loc());
-                Type *t = argtypemerge(Type::tsize_t, Type::tvoidptr, offset);
-                if (t)
-                {
-                    result = new TypeTuple(t);
-                    return;
-                }
-            }
-            result = new TypeTuple(Type::tsize_t, Type::tvoidptr);
-        }
-
-        void visit(TypeDelegate *)
-        {
-            /* Should be done as if it were:
-             * struct S { size_t length; void* ptr; }
-             */
-            if (global.params.is64bit && !global.params.isLP64)
-            {
-                // For AMD64 ILP32 ABI, delegates fit into a single integer register.
-                unsigned offset = (unsigned)Type::tsize_t->size(Loc());
-                Type *t = argtypemerge(Type::tsize_t, Type::tvoidptr, offset);
-                if (t)
-                {
-                    result = new TypeTuple(t);
-                    return;
-                }
-            }
-            result = new TypeTuple(Type::tvoidptr, Type::tvoidptr);
-        }
-
-        void visit(TypeStruct *t)
-        {
-            //printf("TypeStruct::toArgTypes() %s\n", t->toChars());
-            if (!t->sym->isPOD() || t->sym->fields.dim == 0)
-            {
-            Lmemory:
-                //printf("\ttoArgTypes() %s => [ ]\n", t->toChars());
-                result = new TypeTuple();         // pass on the stack
-                return;
-            }
-            Type *t1 = NULL;
-            Type *t2 = NULL;
-            const d_uns64 sz = t->size(Loc());
-            assert(sz < 0xFFFFFFFF);
-            switch ((unsigned)sz)
-            {
-                case 1:
-                    t1 = Type::tint8;
-                    break;
-                case 2:
-                    t1 = Type::tint16;
-                    break;
-                case 3:
-                    if (!global.params.is64bit)
-                        goto Lmemory;
-                    /* fall through */
-                case 4:
-                    t1 = Type::tint32;
-                    break;
-                case 5:
-                case 6:
-                case 7:
-                    if (!global.params.is64bit)
-                        goto Lmemory;
-                    /* fall through */
-                case 8:
-                    t1 = Type::tint64;
-                    break;
-                case 16:
-                    t1 = NULL;                   // could be a TypeVector
-                    break;
-                case 9:
-                case 10:
-                case 11:
-                case 12:
-                case 13:
-                case 14:
-                case 15:
-                    if (!global.params.is64bit)
-                        goto Lmemory;
-                    t1 = NULL;
-                    break;
-                default:
-                    goto Lmemory;
-            }
-            if (global.params.is64bit && t->sym->fields.dim)
-            {
-                t1 = NULL;
-                for (size_t i = 0; i < t->sym->fields.dim; i++)
-                {
-                    VarDeclaration *f = t->sym->fields[i];
-                    //printf("  [%d] %s f->type = %s\n", (int)i, f->toChars(), f->type->toChars());
-
-                    TypeTuple *tup = toArgTypes(f->type);
-                    if (!tup)
-                        goto Lmemory;
-                    size_t dim = tup->arguments->dim;
-                    Type *ft1 = NULL;
-                    Type *ft2 = NULL;
-                    switch (dim)
-                    {
-                        case 2:
-                            ft1 = (*tup->arguments)[0]->type;
-                            ft2 = (*tup->arguments)[1]->type;
-                            break;
-                        case 1:
-                            if (f->offset < 8)
-                                ft1 = (*tup->arguments)[0]->type;
-                            else
-                                ft2 = (*tup->arguments)[0]->type;
-                            break;
-                        default:
-                            goto Lmemory;
-                    }
-
-                    if (f->offset & 7)
-                    {
-                        // Misaligned fields goto Lmemory
-                        unsigned alignsz = f->type->alignsize();
-                        if (f->offset & (alignsz - 1))
-                            goto Lmemory;
-
-                        // Fields that overlap the 8byte boundary goto Lmemory
-                        const d_uns64 fieldsz = f->type->size(Loc());
-                        assert(fieldsz != SIZE_INVALID && fieldsz < UINT64_MAX - UINT32_MAX);
-                        if (f->offset < 8 && (f->offset + fieldsz) > 8)
-                            goto Lmemory;
-                    }
-
-                    // First field in 8byte must be at start of 8byte
-                    assert(t1 || f->offset == 0);
-                    //printf("ft1 = %s\n", ft1 ? ft1->toChars() : "null");
-                    //printf("ft2 = %s\n", ft2 ? ft2->toChars() : "null");
-                    if (ft1)
-                    {
-                        t1 = argtypemerge(t1, ft1, f->offset);
-                        if (!t1)
-                            goto Lmemory;
-                    }
-
-                    if (ft2)
-                    {
-                        unsigned off2 = f->offset;
-                        if (ft1)
-                            off2 = 8;
-                        if (!t2 && off2 != 8)
-                            goto Lmemory;
-                        assert(t2 || off2 == 8);
-                        t2 = argtypemerge(t2, ft2, off2 - 8);
-                        if (!t2)
-                            goto Lmemory;
-                    }
-                }
-
-                if (t2)
-                {
-                    if (t1->isfloating() && t2->isfloating())
-                    {
-                        if ((t1->ty == Tfloat32 || t1->ty == Tfloat64) &&
-                            (t2->ty == Tfloat32 || t2->ty == Tfloat64))
-                            ;
-                        else
-                            goto Lmemory;
-                    }
-                    else if (t1->isfloating())
-                        goto Lmemory;
-                    else if (t2->isfloating())
-                        goto Lmemory;
-                    else
-                    {
-                    }
-                }
-            }
-
-            //printf("\ttoArgTypes() %s => [%s,%s]\n", t->toChars(), t1 ? t1->toChars() : "", t2 ? t2->toChars() : "");
-
-            if (t1)
-            {
-                //if (t1) printf("test1: %s => %s\n", toChars(), t1->toChars());
-                if (t2)
-                    result = new TypeTuple(t1, t2);
-                else
-                    result = new TypeTuple(t1);
-            }
-            else
-                goto Lmemory;
-        }
-
-        void visit(TypeEnum *t)
-        {
-            t->toBasetype()->accept(this);
-        }
-
-        void visit(TypeClass *)
-        {
-            result = new TypeTuple(Type::tvoidptr);
-        }
-    };
-
-    ToArgTypes v;
-    t->accept(&v);
-    return v.result;
-}
diff --git a/gcc/d/dmd/dstruct.c b/gcc/d/dmd/dstruct.c
index 22da0a3..10771c95 100644
--- a/gcc/d/dmd/dstruct.c
+++ b/gcc/d/dmd/dstruct.c
@@ -22,9 +22,9 @@
 #include "statement.h"
 #include "template.h"
 #include "tokens.h"
+#include "target.h"
 
 Type *getTypeInfoType(Loc loc, Type *t, Scope *sc);
-TypeTuple *toArgTypes(Type *t);
 void unSpeculative(Scope *sc, RootObject *o);
 bool MODimplicitConv(MOD modfrom, MOD modto);
 Expression *resolve(Loc loc, Scope *sc, Dsymbol *s, bool hasOverloads);
@@ -1303,8 +1303,8 @@ void StructDeclaration::finalizeSize()
         }
     }
 
-    TypeTuple *tt = toArgTypes(type);
-    size_t dim = tt->arguments->dim;
+    TypeTuple *tt = Target::toArgTypes(type);
+    size_t dim = tt ? tt->arguments->dim : 0;
     if (dim >= 1)
     {
         assert(dim <= 2);
diff --git a/gcc/d/dmd/expressionsem.c b/gcc/d/dmd/expressionsem.c
index fed36cf..629768a 100644
--- a/gcc/d/dmd/expressionsem.c
+++ b/gcc/d/dmd/expressionsem.c
@@ -37,7 +37,6 @@
 bool typeMerge(Scope *sc, TOK op, Type **pt, Expression **pe1, Expression **pe2);
 bool isArrayOpValid(Expression *e);
 Expression *expandVar(int result, VarDeclaration *v);
-TypeTuple *toArgTypes(Type *t);
 bool checkAssignEscape(Scope *sc, Expression *e, bool gag);
 bool checkParamArgumentEscape(Scope *sc, FuncDeclaration *fdc, Identifier *par, Expression *arg, bool gag);
 bool checkAccess(AggregateDeclaration *ad, Loc loc, Scope *sc, Dsymbol *smember);
@@ -2074,7 +2073,7 @@ public:
                      * The results of this are highly platform dependent, and intended
                      * primarly for use in implementing va_arg().
                      */
-                    tded = toArgTypes(e->targ);
+                    tded = Target::toArgTypes(e->targ);
                     if (!tded)
                         goto Lno;           // not valid for a parameter
                     break;
diff --git a/gcc/d/dmd/target.h b/gcc/d/dmd/target.h
index 1729bc3..51e85ff 100644
--- a/gcc/d/dmd/target.h
+++ b/gcc/d/dmd/target.h
@@ -21,6 +21,7 @@ class Dsymbol;
 class Expression;
 class Parameter;
 class Type;
+class TypeTuple;
 struct OutBuffer;
 
 struct Target
@@ -73,4 +74,5 @@ struct Target
     static Type *cppParameterType(Parameter *p);
     static bool cppFundamentalType(const Type *t, bool& isFundamental);
     static LINK systemLinkage();
+    static TypeTuple *toArgTypes(Type *t);
 };