Unresolved differences between gdc/dmd front ends

src/ddmd/clone.d

@@ -636,7 +636,10 @@ extern (C++) FuncDeclaration buildXopCmp(StructDeclaration sd, Scope* sc)
     fop.generated = true;
     Expression e1 = new IdentifierExp(loc, Id.p);
     Expression e2 = new IdentifierExp(loc, Id.q);
-    Expression e = new CallExp(loc, new DotIdExp(loc, e2, Id.cmp), e1);
+    static if (IN_GCC)
+        Expression e = new CallExp(loc, new DotIdExp(loc, e1, Id.cmp), e2);
+    else
+        Expression e = new CallExp(loc, new DotIdExp(loc, e2, Id.cmp), e1);
     fop.fbody = new ReturnStatement(loc, e);
     uint errors = global.startGagging(); // Do not report errors
     Scope* sc2 = sc.push();

src/ddmd/cppmangle.d

@@ -503,6 +503,19 @@ extern (C++) final class CppMangleVisitor : Visitor
                 td = new TypeDelegate(td);
                 t = t.merge();
             }
+            static if (IN_GCC)
+            {
+                // Could be a va_list, which we mangle as a pointer.
+                if (t.ty == Tsarray && Type.tvalist.ty == Tsarray)
+                {
+                    Type tb = t.toBasetype().mutableOf();
+                    if (tb == Type.tvalist)
+                    {
+                        tb = t.nextOf().pointerTo();
+                        t = tb.castMod(t.mod);
+                    }
+                }
+            }
             if (t.ty == Tsarray)
             {
                 // Mangle static arrays as pointers

src/ddmd/dcast.d

@@ -1475,8 +1475,8 @@ extern (C++) Expression castTo(Expression e, Scope* sc, Type t)
              */
 
             // Fat Value types
-            const(bool) tob_isFV = (tob.ty == Tstruct || tob.ty == Tsarray);
-            const(bool) t1b_isFV = (t1b.ty == Tstruct || t1b.ty == Tsarray);
+            const(bool) tob_isFV = (tob.ty == Tstruct || tob.ty == Tsarray || tob.ty == Tvector);
+            const(bool) t1b_isFV = (t1b.ty == Tstruct || t1b.ty == Tsarray || t1b.ty == Tvector);
 
             // Fat Reference types
             const(bool) tob_isFR = (tob.ty == Tarray || tob.ty == Tdelegate);
@@ -1487,8 +1487,8 @@ extern (C++) Expression castTo(Expression e, Scope* sc, Type t)
             const(bool) t1b_isR = (t1b_isFR || t1b.ty == Tpointer || t1b.ty == Taarray || t1b.ty == Tclass);
 
             // Arithmetic types (== valueable basic types)
-            const(bool) tob_isA = (tob.isintegral() || tob.isfloating());
-            const(bool) t1b_isA = (t1b.isintegral() || t1b.isfloating());
+            const(bool) tob_isA = ((tob.isintegral() || tob.isfloating()) && tob.ty != Tvector);
+            const(bool) t1b_isA = ((t1b.isintegral() || t1b.isfloating()) && t1b.ty != Tvector);
 
             if (AggregateDeclaration t1ad = isAggregate(t1b))
             {

src/ddmd/dinterpret.d

@@ -666,6 +666,18 @@ public:
         // we can't compile asm statements
     }
 
+    static if (IN_GCC)
+    {
+        override void visit(ExtAsmStatement s)
+        {
+            debug (LOGCOMPILE)
+            {
+                printf("%s ExtAsmStatement::ctfeCompile\n", s.loc.toChars());
+            }
+            // we can't compile extended asm statements
+        }
+    }
+
     void ctfeCompile(Statement s)
     {
         s.accept(this);
@@ -1998,6 +2010,25 @@ public:
         result = CTFEExp.cantexp;
     }
 
+    static if (IN_GCC)
+    {
+        override void visit(ExtAsmStatement s)
+        {
+            debug (LOG)
+            {
+                printf("%s ExtAsmStatement::interpret()\n", s.loc.toChars());
+            }
+            if (istate.start)
+            {
+                if (istate.start != s)
+                    return;
+                istate.start = null;
+            }
+            s.error("extended asm statements cannot be interpreted at compile time");
+            result = CTFEExp.cantexp;
+        }
+    }
+
     override void visit(ImportStatement s)
     {
         debug (LOG)

src/ddmd/dsymbol.h

@@ -75,11 +75,11 @@ class Expression;
 class DeleteDeclaration;
 class OverloadSet;
 struct AA;
-#ifdef IN_GCC
+#ifdef IN_GCC	// %%
 typedef union tree_node Symbol;
-#else
+#else	// %%
 struct Symbol;
-#endif
+#endif	// %%
 
 struct Ungag
 {

src/ddmd/expression.h

@@ -49,11 +49,11 @@ class StringExp;
 class ArrayExp;
 class SliceExp;
 struct UnionExp;
-#ifdef IN_GCC
+#ifdef IN_GCC	// %%
 typedef union tree_node Symbol;
-#else
+#else	// %%
 struct Symbol;          // back end symbol
-#endif
+#endif	// %%
 
 Expression *resolveProperties(Scope *sc, Expression *e);
 Expression *resolvePropertiesOnly(Scope *sc, Expression *e1);

src/ddmd/func.d

@@ -35,7 +35,6 @@ import ddmd.hdrgen;
 import ddmd.id;
 import ddmd.identifier;
 import ddmd.init;
-import ddmd.mars;
 import ddmd.mtype;
 import ddmd.nogc;
 import ddmd.objc;
@@ -50,6 +49,8 @@ import ddmd.target;
 import ddmd.tokens;
 import ddmd.visitor;
 
+extern (C++) void genCmain(Scope* sc);
+
 /// Inline Status
 enum ILS : int
 {

src/ddmd/globals.d

@@ -23,7 +23,7 @@ template xversion(string s)
     enum xversion = mixin(`{ version (` ~ s ~ `) return true; else return false; }`)();
 }
 
-enum IN_GCC     = xversion!`IN_GCC`;
+enum IN_GCC     = xversion!`IN_GCC`;  // %%
 
 enum TARGET_LINUX   = xversion!`linux`;
 enum TARGET_OSX     = xversion!`OSX`;

src/ddmd/gluelayer.d

@@ -53,6 +53,24 @@ version (NoBackend)
         void objc_initSymbols() {}
     }
 }
+else version (IN_GCC)
+{
+    union tree_node;
+
+    alias Symbol = tree_node;
+    alias code = tree_node;
+    alias type = tree_node;
+
+    // d-frontend.cc
+    extern (C++)
+    {
+        RET retStyle(TypeFunction tf);
+        Statement asmSemantic(AsmStatement s, Scope* sc);
+    }
+
+    // stubs
+    void objc_initSymbols() { }
+}
 else
 {
     import ddmd.lib : Library;

src/ddmd/hdrgen.d

@@ -685,6 +685,67 @@ public:
         buf.writenl();
     }
 
+    static if (IN_GCC)
+    {
+        override void visit(ExtAsmStatement s)
+        {
+            buf.writestring ("gcc asm { ");
+
+            if (s.insn)
+                buf.writestring (s.insn.toChars());
+
+            buf.writestring (" : ");
+
+            if (s.args)
+            {
+                for (size_t i = 0; i < s.args.dim; i++)
+                {
+                    Identifier name = (*s.names)[i];
+                    Expression constr = (*s.constraints)[i];
+                    Expression arg = (*s.args)[i];
+
+                    if (name)
+                    {
+                        buf.writestring ("[");
+                        buf.writestring (name.toChars());
+                        buf.writestring ("] ");
+                    }
+
+                    if (constr)
+                    {
+                        buf.writestring (constr.toChars());
+                        buf.writestring (" ");
+                    }
+
+                    if (arg)
+                        buf.writestring (arg.toChars());
+
+                    if (i < s.outputargs - 1)
+                        buf.writestring (", ");
+                    else if (i == s.outputargs - 1)
+                        buf.writestring (" : ");
+                    else if (i < s.args.dim - 1)
+                        buf.writestring (", ");
+                }
+            }
+
+            if (s.clobbers)
+            {
+                buf.writestring (" : ");
+                for (size_t i = 0; i < s.clobbers.dim; i++)
+                {
+                    Expression clobber = (*s.clobbers)[i];
+                    buf.writestring (clobber.toChars());
+                    if (i < s.clobbers.dim - 1)
+                        buf.writestring (", ");
+                }
+            }
+
+            buf.writestring ("; }");
+            buf.writenl();
+        }
+    }
+
     override void visit(ImportStatement s)
     {
         foreach (imp; *s.imports)

src/ddmd/id.d

@@ -34,7 +34,7 @@ struct Id
      * An identifier that corresponds to each static field in this struct will
      * be placed in the identifier pool.
      */
-    void initialize()
+    extern (C++) void initialize()
     {
         mixin(msgtable.generate(&initializer));
     }

src/ddmd/mtype.d

@@ -2863,11 +2863,11 @@ extern (C++) abstract class Type : RootObject
         assert(0 < length && length < namelen); // don't overflow the buffer
 
         int off = 0;
-        static if (!IN_GCC)
+        static if (!IN_GCC) // %%
         {
             if (global.params.isOSX || global.params.isWindows && !global.params.is64bit)
                 ++off; // C mangling will add '_' back in
-        }
+        }   // %%
         auto id = Identifier.idPool(name + off, length - off);
 
         if (name != namebuf.ptr)
@@ -4531,8 +4531,22 @@ extern (C++) final class TypeVector : Type
         //printf("TypeVector::implicitConvTo(%s) from %s\n", to.toChars(), toChars());
         if (this == to)
             return MATCHexact;
-        if (ty == to.ty)
-            return MATCHconvert;
+        if (to.ty == Tvector)
+        {
+            TypeVector tv = cast(TypeVector)to;
+            assert(basetype.ty == Tsarray && tv.basetype.ty == Tsarray);
+
+            // Can't convert to a vector which has different size.
+            if (basetype.size() != tv.basetype.size())
+                return MATCHnomatch;
+
+            // Allow conversion to void[]
+            if (tv.basetype.nextOf().ty == Tvoid)
+                return MATCHconvert;
+
+            // Otherwise implicitly convertible only if basetypes are.
+            return basetype.implicitConvTo(tv.basetype);
+        }
         return MATCHnomatch;
     }
 

src/ddmd/mtype.h

@@ -40,11 +40,11 @@ class TypeBasic;
 class Parameter;
 
 // Back end
-#ifdef IN_GCC
+#ifdef IN_GCC   // %%
 typedef union tree_node type;
-#else
+#else   // %%
 typedef struct TYPE type;
-#endif
+#endif  // %%
 
 void semanticTypeInfo(Scope *sc, Type *t);
 MATCH deduceType(RootObject *o, Scope *sc, Type *tparam, TemplateParameters *parameters, Objects *dedtypes, unsigned *wm = NULL, size_t inferStart = 0);