Refactoring: Introduce TargetABI::reverseExplicitParams()

gen/abi-aarch64.cpp

@@ -57,12 +57,6 @@ struct AArch64TargetABI : TargetABI {
       if (!arg->byref)
         rewriteArgument(fty, *arg);
     }
-
-    // extern(D): reverse parameter order for non variadics, for DMD-compliance
-    if (fty.type->linkage == LINKd && fty.type->varargs != 1 &&
-        fty.args.size() > 1) {
-      fty.reverseParams = true;
-    }
   }
 
   void rewriteArgument(IrFuncTy &fty, IrFuncTyArg &arg) override {

gen/abi-arm.cpp

@@ -84,12 +84,6 @@ struct ArmTargetABI : TargetABI {
       if (!arg->byref)
         rewriteArgument(fty, *arg);
     }
-
-    // extern(D): reverse parameter order for non variadics, for DMD-compliance
-    if (fty.type->linkage == LINKd && fty.type->varargs != 1 &&
-        fty.args.size() > 1) {
-      fty.reverseParams = true;
-    }
   }
 
   void rewriteArgument(IrFuncTy &fty, IrFuncTyArg &arg) override {

gen/abi-mips64.cpp

@@ -57,12 +57,6 @@ struct MIPS64TargetABI : TargetABI {
         rewriteArgument(fty, *arg);
       }
     }
-
-    // extern(D): reverse parameter order for non variadics, for DMD-compliance
-    if (fty.type->linkage == LINKd && fty.type->varargs != 1 &&
-        fty.args.size() > 1) {
-      fty.reverseParams = true;
-    }
   }
 
   void rewriteArgument(IrFuncTy &fty, IrFuncTyArg &arg) override {

gen/abi-nvptx.cpp

@@ -28,6 +28,7 @@ struct NVPTXTargetABI : TargetABI {
     t = t->toBasetype();
     return ((t->ty == Tsarray || t->ty == Tstruct) && t->size() > 64);
   }
+  bool reverseExplicitParams(TypeFunction *) override { return false; }
   void rewriteFunctionType(IrFuncTy &fty) override {
     for (auto arg : fty.args) {
       if (!arg->byref)

gen/abi-ppc.cpp

@@ -70,12 +70,6 @@ struct PPCTargetABI : TargetABI {
         rewriteArgument(fty, *arg);
       }
     }
-
-    // extern(D): reverse parameter order for non variadics, for DMD-compliance
-    if (fty.type->linkage == LINKd && fty.type->varargs != 1 &&
-        fty.args.size() > 1) {
-      fty.reverseParams = true;
-    }
   }
 
   void rewriteArgument(IrFuncTy &fty, IrFuncTyArg &arg) override {

gen/abi-ppc64le.cpp

@@ -59,12 +59,6 @@ struct PPC64LETargetABI : TargetABI {
         rewriteArgument(fty, *arg);
       }
     }
-
-    // extern(D): reverse parameter order for non variadics, for DMD-compliance
-    if (fty.type->linkage == LINKd && fty.type->varargs != 1 &&
-        fty.args.size() > 1) {
-      fty.reverseParams = true;
-    }
   }
 
   void rewriteArgument(IrFuncTy &fty, IrFuncTyArg &arg) override {

gen/abi-spirv.cpp

@@ -28,6 +28,7 @@ struct SPIRVTargetABI : TargetABI {
     t = t->toBasetype();
     return ((t->ty == Tsarray || t->ty == Tstruct) && t->size() > 64);
   }
+  bool reverseExplicitParams(TypeFunction *) override { return false; }
   void rewriteFunctionType(IrFuncTy &fty) override {
     for (auto arg : fty.args) {
       if (!arg->byref)

gen/abi-win64.cpp

@@ -120,12 +120,6 @@ public:
         rewriteArgument(fty, *arg);
       }
     }
-
-    // extern(D): reverse parameter order for non variadics, for DMD-compliance
-    if (fty.type->linkage == LINKd && fty.type->varargs != 1 &&
-        fty.args.size() > 1) {
-      fty.reverseParams = true;
-    }
   }
 
   void rewriteVarargs(IrFuncTy &fty,

gen/abi-x86-64.cpp

@@ -319,12 +319,6 @@ void X86_64TargetABI::rewriteFunctionType(IrFuncTy &fty) {
   Logger::println("x86-64 ABI: Transforming argument types");
   LOG_SCOPE;
 
-  // extern(D): reverse parameter order for non variadics, for DMD-compliance
-  if (fty.type->linkage == LINKd && fty.type->varargs != 1 &&
-      fty.args.size() > 1) {
-    fty.reverseParams = true;
-  }
-
   int begin = 0, end = fty.args.size(), step = 1;
   if (fty.reverseParams) {
     begin = end - 1;

gen/abi-x86.cpp

@@ -181,11 +181,6 @@ struct X86TargetABI : TargetABI {
       }
 
       // all other arguments are passed on the stack, don't rewrite
-
-      // reverse parameter order
-      if (fty.args.size() > 1) {
-        fty.reverseParams = true;
-      }
     }
 
     workaroundIssue1356(fty.args);

gen/abi.cpp

@@ -238,6 +238,14 @@ bool TargetABI::canRewriteAsInt(Type *t, bool include64bit) {
 
 //////////////////////////////////////////////////////////////////////////////
 
+bool TargetABI::reverseExplicitParams(TypeFunction *tf) {
+  // Required by druntime for extern(D), except for `, ...`-style variadics.
+  return tf->linkage == LINKd && tf->varargs != 1 &&
+         Parameter::dim(tf->parameters) > 1;
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
 void TargetABI::rewriteVarargs(IrFuncTy &fty,
                                std::vector<IrFuncTyArg *> &args) {
   for (auto arg : args) {
@@ -355,6 +363,8 @@ struct IntrinsicABI : TargetABI {
 
   bool passByVal(Type *t) override { return false; }
 
+  bool reverseExplicitParams(TypeFunction *) override { return false; }
+
   void rewriteArgument(IrFuncTy &fty, IrFuncTyArg &arg) override {
     Type *ty = arg.type->toBasetype();
     if (ty->ty != Tstruct) {

gen/abi.h

@@ -143,6 +143,11 @@ struct TargetABI {
   /// argument.
   virtual bool passThisBeforeSret(TypeFunction *tf) { return false; }
 
+  /// Returns true if the explicit parameters order is to be reversed.
+  /// Defaults to true for non-variadic extern(D) functions as required by
+  /// druntime.
+  virtual bool reverseExplicitParams(TypeFunction *tf);
+
   /// Called to give ABI the chance to rewrite the types
   virtual void rewriteFunctionType(IrFuncTy &fty) = 0;
   virtual void rewriteVarargs(IrFuncTy &fty, std::vector<IrFuncTyArg *> &args);

gen/functions.cpp

@@ -187,6 +187,8 @@ llvm::FunctionType *DtoFunctionType(Type *type, IrFuncTy &irFty, Type *thistype,
     ++nextLLArgIdx;
   }
 
+  newIrFty.reverseParams = abi->reverseExplicitParams(f);
+
   // let the ABI rewrite the types as necessary
   abi->rewriteFunctionType(newIrFty);