core.stdc.vararg: Move implementation to va_arg version returning a value

kinke · kinke · commit a9f9de47bc2c · 2020-04-26T23:03:51.000+02:00
This should be a prerequisite for fixing * https://issues.dlang.org/show_bug.cgi?id=20772 * https://issues.dlang.org/show_bug.cgi?id=20773
diff --git a/src/core/internal/vararg/sysv_x64.d b/src/core/internal/vararg/sysv_x64.d
@@ -43,17 +43,16 @@ alias __va_list = __va_list_tag;
 alias va_list = __va_list*;
 
 ///
-void va_arg(T)(va_list apx, ref T parmn)
+T va_arg(T)(va_list ap)
 {
-    __va_list* ap = cast(__va_list*) apx;
     static if (is(T U == __argTypes))
     {
         static if (U.length == 0 || T.sizeof > 16 || (U[0].sizeof > 8 && !is(U[0] == __vector)))
         {   // Always passed in memory
             // The arg may have more strict alignment than the stack
             void* p = ap.stack_args.alignUp!(T.alignof);
             ap.stack_args = p + T.sizeof.alignUp;
-            parmn = *cast(T*) p;
+            return *cast(T*) p;
         }
         else static if (U.length == 1)
         {   // Arg is passed in one register
@@ -62,35 +61,41 @@ void va_arg(T)(va_list apx, ref T parmn)
             {   // Passed in XMM register
                 if (ap.offset_fpregs < (6 * 8 + 16 * 8))
                 {
-                    parmn = *cast(T*) (ap.reg_args + ap.offset_fpregs);
+                    auto p = cast(T*) (ap.reg_args + ap.offset_fpregs);
                     ap.offset_fpregs += 16;
+                    return *p;
                 }
                 else
                 {
-                    parmn = *cast(T*) ap.stack_args;
+                    auto p = cast(T*) ap.stack_args;
                     ap.stack_args += T1.sizeof.alignUp;
+                    return *p;
                 }
             }
             else
             {   // Passed in regular register
                 if (ap.offset_regs < 6 * 8 && T.sizeof <= 8)
                 {
-                    parmn = *cast(T*) (ap.reg_args + ap.offset_regs);
+                    auto p = cast(T*) (ap.reg_args + ap.offset_regs);
                     ap.offset_regs += 8;
+                    return *p;
                 }
                 else
                 {
                     void* p = ap.stack_args.alignUp!(T.alignof);
                     ap.stack_args = p + T.sizeof.alignUp;
-                    parmn = *cast(T*) p;
+                    return *cast(T*) p;
                 }
             }
         }
         else static if (U.length == 2)
         {   // Arg is passed in two registers
             alias U[0] T1;
             alias U[1] T2;
-            auto p = (cast(void*) &parmn) + 8;
+
+            T result = void;
+            auto p1 = cast(T1*) &result;
+            auto p2 = cast(T2*) ((cast(void*) &result) + 8);
 
             // Both must be in registers, or both on stack, hence 4 cases
 
@@ -99,15 +104,15 @@ void va_arg(T)(va_list apx, ref T parmn)
             {
                 if (ap.offset_fpregs < (6 * 8 + 16 * 8) - 16)
                 {
-                    *cast(T1*) &parmn = *cast(T1*) (ap.reg_args + ap.offset_fpregs);
-                    *cast(T2*) p = *cast(T2*) (ap.reg_args + ap.offset_fpregs + 16);
+                    *p1 = *cast(T1*) (ap.reg_args + ap.offset_fpregs);
+                    *p2 = *cast(T2*) (ap.reg_args + ap.offset_fpregs + 16);
                     ap.offset_fpregs += 32;
                 }
                 else
                 {
-                    *cast(T1*) &parmn = *cast(T1*) ap.stack_args;
+                    *p1 = *cast(T1*) ap.stack_args;
                     ap.stack_args += T1.sizeof.alignUp;
-                    *cast(T2*) p = *cast(T2*) ap.stack_args;
+                    *p2 = *cast(T2*) ap.stack_args;
                     ap.stack_args += T2.sizeof.alignUp;
                 }
             }
@@ -117,37 +122,37 @@ void va_arg(T)(va_list apx, ref T parmn)
                 if (ap.offset_fpregs < (6 * 8 + 16 * 8) &&
                     ap.offset_regs < 6 * 8 && T2.sizeof <= 8)
                 {
-                    *cast(T1*) &parmn = *cast(T1*) (ap.reg_args + ap.offset_fpregs);
+                    *p1 = *cast(T1*) (ap.reg_args + ap.offset_fpregs);
                     ap.offset_fpregs += 16;
                     a = ap.reg_args + ap.offset_regs;
                     ap.offset_regs += 8;
                 }
                 else
                 {
-                    *cast(T1*) &parmn = *cast(T1*) ap.stack_args;
+                    *p1 = *cast(T1*) ap.stack_args;
                     ap.stack_args += T1.sizeof.alignUp;
                     a = ap.stack_args;
                     ap.stack_args += 8;
                 }
                 // Be careful not to go past the size of the actual argument
                 const sz2 = T.sizeof - 8;
-                p[0..sz2] = a[0..sz2];
+                (cast(void*) p2)[0..sz2] = a[0..sz2];
             }
             else static if (is(T2 == double) || is(T2 == float))
             {
                 if (ap.offset_regs < 6 * 8 && T1.sizeof <= 8 &&
                     ap.offset_fpregs < (6 * 8 + 16 * 8))
                 {
-                    *cast(T1*) &parmn = *cast(T1*) (ap.reg_args + ap.offset_regs);
+                    *p1 = *cast(T1*) (ap.reg_args + ap.offset_regs);
                     ap.offset_regs += 8;
-                    *cast(T2*) p = *cast(T2*) (ap.reg_args + ap.offset_fpregs);
+                    *p2 = *cast(T2*) (ap.reg_args + ap.offset_fpregs);
                     ap.offset_fpregs += 16;
                 }
                 else
                 {
-                    *cast(T1*) &parmn = *cast(T1*) ap.stack_args;
+                    *p1 = *cast(T1*) ap.stack_args;
                     ap.stack_args += 8;
-                    *cast(T2*) p = *cast(T2*) ap.stack_args;
+                    *p2 = *cast(T2*) ap.stack_args;
                     ap.stack_args += T2.sizeof.alignUp;
                 }
             }
@@ -156,22 +161,24 @@ void va_arg(T)(va_list apx, ref T parmn)
                 void* a = void;
                 if (ap.offset_regs < 5 * 8 && T1.sizeof <= 8 && T2.sizeof <= 8)
                 {
-                    *cast(T1*) &parmn = *cast(T1*) (ap.reg_args + ap.offset_regs);
+                    *p1 = *cast(T1*) (ap.reg_args + ap.offset_regs);
                     ap.offset_regs += 8;
                     a = ap.reg_args + ap.offset_regs;
                     ap.offset_regs += 8;
                 }
                 else
                 {
-                    *cast(T1*) &parmn = *cast(T1*) ap.stack_args;
+                    *p1 = *cast(T1*) ap.stack_args;
                     ap.stack_args += 8;
                     a = ap.stack_args;
                     ap.stack_args += 8;
                 }
                 // Be careful not to go past the size of the actual argument
                 const sz2 = T.sizeof - 8;
-                p[0..sz2] = a[0..sz2];
+                (cast(void*) p2)[0..sz2] = a[0..sz2];
             }
+
+            return result;
         }
         else
         {
@@ -185,9 +192,8 @@ void va_arg(T)(va_list apx, ref T parmn)
 }
 
 ///
-void va_arg()(va_list apx, TypeInfo ti, void* parmn)
+void va_arg()(va_list ap, TypeInfo ti, void* parmn)
 {
-    __va_list* ap = cast(__va_list*) apx;
     TypeInfo arg1, arg2;
     if (!ti.argTypes(arg1, arg2))
     {
diff --git a/src/core/stdc/stdarg.d b/src/core/stdc/stdarg.d
@@ -167,26 +167,16 @@ else version (DigitalMars)
 /**
  * Retrieve and return the next value that is of type T.
  */
-T va_arg(T)(ref va_list ap)
-{
-    T a;
-    va_arg(ap, a);
-    return a;
-}
-
-
-/**
- * Retrieve and store in parmn the next value that is of type T.
- */
 version (GNU)
-    void va_arg(T)(ref va_list ap, ref T parmn); // intrinsic
+    T va_arg(T)(ref va_list ap); // intrinsic
 else
-void va_arg(T)(ref va_list ap, ref T parmn)
+T va_arg(T)(ref va_list ap)
 {
     version (X86)
     {
-        parmn = *cast(T*) ap;
+        auto p = cast(T*) ap;
         ap += T.sizeof.alignUp;
+        return *p;
     }
     else version (Win64)
     {
@@ -195,47 +185,48 @@ void va_arg(T)(ref va_list ap, ref T parmn)
         else          enum isLDC = false;
         static if (isLDC && is(T == E[], E))
         {
-            const length = *cast(size_t*) ap;
-            ap += size_t.sizeof;
-            auto ptr = *cast(typeof(parmn.ptr)*) ap;
-            parmn = ptr[0 .. length];
+            auto p = cast(T*) ap;
+            ap += T.sizeof;
+            return *p;
         }
+
         // passed indirectly by value if > 64 bits or of a size that is not a power of 2
-        else static if (T.sizeof > size_t.sizeof || (T.sizeof & (T.sizeof - 1)) != 0)
-            parmn = **cast(T**) ap;
+        static if (T.sizeof > size_t.sizeof || (T.sizeof & (T.sizeof - 1)) != 0)
+            auto p = *cast(T**) ap;
         else
-            parmn = *cast(T*) ap;
+            auto p = cast(T*) ap;
         ap += size_t.sizeof;
+        return *p;
     }
     else version (SysV_x64)
     {
-        core.internal.vararg.sysv_x64.va_arg!T(ap, parmn);
+        return core.internal.vararg.sysv_x64.va_arg!T(ap);
     }
     else version (AAPCS32)
     {
         // AAPCS32 section 6.5 B.5: type with alignment >= 8 is 8-byte aligned
         // instead of normal 4-byte alignment (APCS doesn't do this).
         if (T.alignof >= 8)
             ap.__ap = ap.__ap.alignUp!8;
-        auto p = ap.__ap;
+        auto p = cast(T*) ap.__ap;
         version (BigEndian)
             static if (T.sizeof < size_t.sizeof)
                 p = adjustForBigEndian(p, T.sizeof);
-        parmn = *cast(T*) p;
         ap.__ap += T.sizeof.alignUp;
+        return *p;
     }
     else version (AAPCS64)
     {
         static assert(0, "Unsupported platform");
     }
     else version (ARM_Any)
     {
-        auto p = ap;
+        auto p = cast(T*) ap;
         version (BigEndian)
             static if (T.sizeof < size_t.sizeof)
                 p = adjustForBigEndian(p, T.sizeof);
-        parmn = *cast(T*) p;
         ap += T.sizeof.alignUp;
+        return *p;
     }
     else version (PPC_Any)
     {
@@ -249,27 +240,36 @@ void va_arg(T)(ref va_list ap, ref T parmn)
         // be aligned before accessing a value
         if (T.alignof >= 8)
             ap = ap.alignUp!8;
-        auto p = ap;
+        auto p = cast(T*) ap;
         version (BigEndian)
             static if (T.sizeof < size_t.sizeof)
                 p = adjustForBigEndian(p, T.sizeof);
-        parmn = *cast(T*) p;
         ap += T.sizeof.alignUp;
+        return *p;
     }
     else version (MIPS_Any)
     {
-        auto p = ap;
+        auto p = cast(T*) ap;
         version (BigEndian)
             static if (T.sizeof < size_t.sizeof)
                 p = adjustForBigEndian(p, T.sizeof);
-        parmn = *cast(T*) p;
         ap += T.sizeof.alignUp;
+        return *p;
     }
     else
         static assert(0, "Unsupported platform");
 }
 
 
+/**
+ * Retrieve and store in parmn the next value that is of type T.
+ */
+void va_arg(T)(ref va_list ap, ref T parmn)
+{
+    parmn = va_arg!T(ap);
+}
+
+
 /**
  * End use of ap.
  */

Original file line number	Diff line number	Diff line change
`@@ -43,17 +43,16 @@ alias __va_list = __va_list_tag;`
`43`	`43`	`alias va_list = __va_list*;`
`44`	`44`
`45`	`45`	`///`
`46`		`-void va_arg(T)(va_list apx, ref T parmn)`
	`46`	`+T va_arg(T)(va_list ap)`
`47`	`47`	`{`
`48`		`- __va_list* ap = cast(__va_list*) apx;`
`49`	`48`	`static if (is(T U == __argTypes))`
`50`	`49`	`{`
`51`	`50`	`static if (U.length == 0 \|\| T.sizeof > 16 \|\| (U[0].sizeof > 8 && !is(U[0] == __vector)))`
`52`	`51`	`{ // Always passed in memory`
`53`	`52`	`// The arg may have more strict alignment than the stack`
`54`	`53`	`void* p = ap.stack_args.alignUp!(T.alignof);`
`55`	`54`	`ap.stack_args = p + T.sizeof.alignUp;`
`56`		`- parmn = cast(T) p;`
	`55`	`+ return cast(T) p;`
`57`	`56`	`}`
`58`	`57`	`else static if (U.length == 1)`
`59`	`58`	`{ // Arg is passed in one register`
`@@ -62,35 +61,41 @@ void va_arg(T)(va_list apx, ref T parmn)`
`62`	`61`	`{ // Passed in XMM register`
`63`	`62`	`if (ap.offset_fpregs < (6 * 8 + 16 * 8))`
`64`	`63`	`{`
`65`		`- parmn = cast(T) (ap.reg_args + ap.offset_fpregs);`
	`64`	`+ auto p = cast(T*) (ap.reg_args + ap.offset_fpregs);`
`66`	`65`	`ap.offset_fpregs += 16;`
	`66`	`+ return *p;`
`67`	`67`	`}`
`68`	`68`	`else`
`69`	`69`	`{`
`70`		`- parmn = cast(T) ap.stack_args;`
	`70`	`+ auto p = cast(T*) ap.stack_args;`
`71`	`71`	`ap.stack_args += T1.sizeof.alignUp;`
	`72`	`+ return *p;`
`72`	`73`	`}`
`73`	`74`	`}`
`74`	`75`	`else`
`75`	`76`	`{ // Passed in regular register`
`76`	`77`	`if (ap.offset_regs < 6 * 8 && T.sizeof <= 8)`
`77`	`78`	`{`
`78`		`- parmn = cast(T) (ap.reg_args + ap.offset_regs);`
	`79`	`+ auto p = cast(T*) (ap.reg_args + ap.offset_regs);`
`79`	`80`	`ap.offset_regs += 8;`
	`81`	`+ return *p;`
`80`	`82`	`}`
`81`	`83`	`else`
`82`	`84`	`{`
`83`	`85`	`void* p = ap.stack_args.alignUp!(T.alignof);`
`84`	`86`	`ap.stack_args = p + T.sizeof.alignUp;`
`85`		`- parmn = cast(T) p;`
	`87`	`+ return cast(T) p;`
`86`	`88`	`}`
`87`	`89`	`}`
`88`	`90`	`}`
`89`	`91`	`else static if (U.length == 2)`
`90`	`92`	`{ // Arg is passed in two registers`
`91`	`93`	`alias U[0] T1;`
`92`	`94`	`alias U[1] T2;`
`93`		`- auto p = (cast(void*) &parmn) + 8;`
	`95`	`+`
	`96`	`+ T result = void;`
	`97`	`+ auto p1 = cast(T1*) &result;`
	`98`	`+ auto p2 = cast(T2) ((cast(void) &result) + 8);`
`94`	`99`
`95`	`100`	`// Both must be in registers, or both on stack, hence 4 cases`
`96`	`101`
`@@ -99,15 +104,15 @@ void va_arg(T)(va_list apx, ref T parmn)`
`99`	`104`	`{`
`100`	`105`	`if (ap.offset_fpregs < (6 * 8 + 16 * 8) - 16)`
`101`	`106`	`{`
`102`		`- cast(T1) &parmn = cast(T1) (ap.reg_args + ap.offset_fpregs);`
`103`		`- cast(T2) p = cast(T2) (ap.reg_args + ap.offset_fpregs + 16);`
	`107`	`+ p1 = cast(T1*) (ap.reg_args + ap.offset_fpregs);`
	`108`	`+ p2 = cast(T2*) (ap.reg_args + ap.offset_fpregs + 16);`
`104`	`109`	`ap.offset_fpregs += 32;`
`105`	`110`	`}`
`106`	`111`	`else`
`107`	`112`	`{`
`108`		`- cast(T1) &parmn = cast(T1) ap.stack_args;`
	`113`	`+ p1 = cast(T1*) ap.stack_args;`
`109`	`114`	`ap.stack_args += T1.sizeof.alignUp;`
`110`		`- cast(T2) p = cast(T2) ap.stack_args;`
	`115`	`+ p2 = cast(T2*) ap.stack_args;`
`111`	`116`	`ap.stack_args += T2.sizeof.alignUp;`
`112`	`117`	`}`
`113`	`118`	`}`
`@@ -117,37 +122,37 @@ void va_arg(T)(va_list apx, ref T parmn)`
`117`	`122`	`if (ap.offset_fpregs < (6 * 8 + 16 * 8) &&`
`118`	`123`	`ap.offset_regs < 6 * 8 && T2.sizeof <= 8)`
`119`	`124`	`{`
`120`		`- cast(T1) &parmn = cast(T1) (ap.reg_args + ap.offset_fpregs);`
	`125`	`+ p1 = cast(T1*) (ap.reg_args + ap.offset_fpregs);`
`121`	`126`	`ap.offset_fpregs += 16;`
`122`	`127`	`a = ap.reg_args + ap.offset_regs;`
`123`	`128`	`ap.offset_regs += 8;`
`124`	`129`	`}`
`125`	`130`	`else`
`126`	`131`	`{`
`127`		`- cast(T1) &parmn = cast(T1) ap.stack_args;`
	`132`	`+ p1 = cast(T1*) ap.stack_args;`
`128`	`133`	`ap.stack_args += T1.sizeof.alignUp;`
`129`	`134`	`a = ap.stack_args;`
`130`	`135`	`ap.stack_args += 8;`
`131`	`136`	`}`
`132`	`137`	`// Be careful not to go past the size of the actual argument`
`133`	`138`	`const sz2 = T.sizeof - 8;`
`134`		`- p[0..sz2] = a[0..sz2];`
	`139`	`+ (cast(void*) p2)[0..sz2] = a[0..sz2];`
`135`	`140`	`}`
`136`	`141`	`else static if (is(T2 == double) \|\| is(T2 == float))`
`137`	`142`	`{`
`138`	`143`	`if (ap.offset_regs < 6 * 8 && T1.sizeof <= 8 &&`
`139`	`144`	`ap.offset_fpregs < (6 * 8 + 16 * 8))`
`140`	`145`	`{`
`141`		`- cast(T1) &parmn = cast(T1) (ap.reg_args + ap.offset_regs);`
	`146`	`+ p1 = cast(T1*) (ap.reg_args + ap.offset_regs);`
`142`	`147`	`ap.offset_regs += 8;`
`143`		`- cast(T2) p = cast(T2) (ap.reg_args + ap.offset_fpregs);`
	`148`	`+ p2 = cast(T2*) (ap.reg_args + ap.offset_fpregs);`
`144`	`149`	`ap.offset_fpregs += 16;`
`145`	`150`	`}`
`146`	`151`	`else`
`147`	`152`	`{`
`148`		`- cast(T1) &parmn = cast(T1) ap.stack_args;`
	`153`	`+ p1 = cast(T1*) ap.stack_args;`
`149`	`154`	`ap.stack_args += 8;`
`150`		`- cast(T2) p = cast(T2) ap.stack_args;`
	`155`	`+ p2 = cast(T2*) ap.stack_args;`
`151`	`156`	`ap.stack_args += T2.sizeof.alignUp;`
`152`	`157`	`}`
`153`	`158`	`}`
`@@ -156,22 +161,24 @@ void va_arg(T)(va_list apx, ref T parmn)`
`156`	`161`	`void* a = void;`
`157`	`162`	`if (ap.offset_regs < 5 * 8 && T1.sizeof <= 8 && T2.sizeof <= 8)`
`158`	`163`	`{`
`159`		`- cast(T1) &parmn = cast(T1) (ap.reg_args + ap.offset_regs);`
	`164`	`+ p1 = cast(T1*) (ap.reg_args + ap.offset_regs);`
`160`	`165`	`ap.offset_regs += 8;`
`161`	`166`	`a = ap.reg_args + ap.offset_regs;`
`162`	`167`	`ap.offset_regs += 8;`
`163`	`168`	`}`
`164`	`169`	`else`
`165`	`170`	`{`
`166`		`- cast(T1) &parmn = cast(T1) ap.stack_args;`
	`171`	`+ p1 = cast(T1*) ap.stack_args;`
`167`	`172`	`ap.stack_args += 8;`
`168`	`173`	`a = ap.stack_args;`
`169`	`174`	`ap.stack_args += 8;`
`170`	`175`	`}`
`171`	`176`	`// Be careful not to go past the size of the actual argument`
`172`	`177`	`const sz2 = T.sizeof - 8;`
`173`		`- p[0..sz2] = a[0..sz2];`
	`178`	`+ (cast(void*) p2)[0..sz2] = a[0..sz2];`
`174`	`179`	`}`
	`180`	`+`
	`181`	`+ return result;`
`175`	`182`	`}`
`176`	`183`	`else`
`177`	`184`	`{`
`@@ -185,9 +192,8 @@ void va_arg(T)(va_list apx, ref T parmn)`
`185`	`192`	`}`
`186`	`193`
`187`	`194`	`///`
`188`		`-void va_arg()(va_list apx, TypeInfo ti, void* parmn)`
	`195`	`+void va_arg()(va_list ap, TypeInfo ti, void* parmn)`
`189`	`196`	`{`
`190`		`- __va_list* ap = cast(__va_list*) apx;`
`191`	`197`	`TypeInfo arg1, arg2;`
`192`	`198`	`if (!ti.argTypes(arg1, arg2))`
`193`	`199`	`{`