Add support for struct > 4B returned via registers

On ARM with hardfloat calling convention, structure containing 4 fields or less of the same float type are returned via float registers. This means that a structure can be returned in up to 4 double registers in a structure is composed of 4 doubles. This commit adds support for return of structures in several registers.

Thomas Preud'homme committed 12 years ago

Commit dcec8671 parent d9d60a15 files · +77 −49Browse files

Unified · Split

5 files

arm-gen.c +30 −18
c67-gen.c +3 −2
i386-gen.c +5 −4
tccgen.c +29 −17
x86_64-gen.c +10 −8

arm-gen.c+30−18

   }
 }
-/* Return 1 if this function returns via an sret pointer, 0 otherwise */
-ST_FUNC int gfunc_sret(CType *vt, CType *ret, int *ret_align) {
-#ifdef TCC_ARM_EABI
-    int size, align;
-    size = type_size(vt, &align);
-    if (size > 4) {
-        return 1;
-    } else {
-        *ret_align = 4;
-        ret->ref = NULL;
-        ret->t = VT_INT;
-        return 0;
-    }
-#else
-    return 1;
-#endif
-}
 #ifdef TCC_ARM_HARDFLOAT
 /* Return whether a structure is an homogeneous float aggregate or not.
    The answer is true if all the elements of the structure are of the same
 }
 #endif
+/* Return the number of registers needed to return the struct, or 0 if
+   returning via struct pointer. */
+ST_FUNC int gfunc_sret(CType *vt, CType *ret, int *ret_align) {
+#ifdef TCC_ARM_EABI
+    int size, align;
+    size = type_size(vt, &align);
+#ifdef TCC_ARM_HARDFLOAT
+    if (is_float(vt->t) || is_hgen_float_aggr(vt)) {
+        *ret_align = 8;
+        ret->ref = NULL;
+        ret->t = VT_DOUBLE;
+        return (size + 7) >> 3;
+    } else
+#endif
+    if (size > 4) {
+        return 0;
+    } else {
+        *ret_align = 4;
+        ret->ref = NULL;
+        ret->t = VT_INT;
+        return 1;
+    }
+#else
+    return 0;
+#endif
+}
 /* Parameters are classified according to how they are copied to their final
    destination for the function call. Because the copying is performed class
    after class according to the order in the union below, it is important that
   n = nf = 0;
   variadic = (func_type->ref->c == FUNC_ELLIPSIS);
   if((func_vt.t & VT_BTYPE) == VT_STRUCT
+#ifdef TCC_ARM_HARDFLOAT
+     && (variadic || !is_hgen_float_aggr(&func_vt))
+#endif
      && type_size(&func_vt,&align) > 4)
   {
     n++;

c67-gen.c+3−2

     }
 }
-/* Return 1 if this function returns via an sret pointer, 0 otherwise */
+/* Return the number of registers needed to return the struct, or 0 if
+   returning via struct pointer. */
 ST_FUNC int gfunc_sret(CType *vt, CType *ret, int *ret_align) {
     *ret_align = 1; // Never have to re-align return values for x86-64
-    return 1;
+    return 0;
 }
 /* generate function call with address in (vtop->t, vtop->c) and free function

i386-gen.c+5−4

 static uint8_t fastcall_regs[3] = { TREG_EAX, TREG_EDX, TREG_ECX };
 static uint8_t fastcallw_regs[2] = { TREG_ECX, TREG_EDX };
-/* Return 1 if this function returns via an sret pointer, 0 otherwise */
+/* Return the number of registers needed to return the struct, or 0 if
+   returning via struct pointer. */
 ST_FUNC int gfunc_sret(CType *vt, CType *ret, int *ret_align)
 {
 #ifdef TCC_TARGET_PE
     *ret_align = 1; // Never have to re-align return values for x86
     size = type_size(vt, &align);
     if (size > 8) {
-        return 1;
+        return 0;
     } else if (size > 4) {
         ret->ref = NULL;
         ret->t = VT_LLONG;
-        return 0;
+        return 1;
     } else {
         ret->ref = NULL;
         ret->t = VT_INT;
     }
 #else
     *ret_align = 1; // Never have to re-align return values for x86
-    return 1;
+    return 0;
 #endif
 }

tccgen.c+29−17

         } else if (tok == '(') {
             SValue ret;
             Sym *sa;
-            int nb_args, sret;
+            int nb_args, sret, ret_align;
             /* function call  */
             if ((vtop->type.t & VT_BTYPE) != VT_FUNC) {
             ret.r2 = VT_CONST;
             /* compute first implicit argument if a structure is returned */
             if ((s->type.t & VT_BTYPE) == VT_STRUCT) {
-                int ret_align;
                 sret = gfunc_sret(&s->type, &ret.type, &ret_align);
-                if (sret) {
+                if (!sret) {
                     /* get some space for the returned structure */
                     size = type_size(&s->type, &align);
                     loc = (loc - size) & -align;
                     nb_args++;
                 }
             } else {
-                sret = 0;
+                sret = 1;
                 ret.type = s->type;
             }
-            if (!sret) {
+            if (sret) {
                 /* return in register */
                 if (is_float(ret.type.t)) {
                     ret.r = reg_fret(ret.type.t);
                 vtop -= (nb_args + 1);
             }
             /* return value */
-            vsetc(&ret.type, ret.r, &ret.c);
+            for (r = ret.r + sret + !sret; r-- > ret.r;) {
-            vtop->r2 = ret.r2;
+                vsetc(&ret.type, r, &ret.c);
+                vtop->r2 = ret.r2; /* Loop only happens when r2 is VT_CONST */
+            }
             /* handle packed struct return */
-            if (((s->type.t & VT_BTYPE) == VT_STRUCT) && !sret) {
+            if (((s->type.t & VT_BTYPE) == VT_STRUCT) && sret) {
-                int addr;
+                int addr, offset;
                 size = type_size(&s->type, &align);
                 loc = (loc - size) & -align;
                 addr = loc;
-                vset(&ret.type, VT_LOCAL | VT_LVAL, addr);
+                for(offset = 0; offset < size; offset += ret_align) {
-                vswap();
+                    vset(&ret.type, VT_LOCAL | VT_LVAL, addr + offset);
-                vstore();
+                    vswap();
-                vtop--;
+                    vstore();
+                    vtop--;
+                }
                 vset(&s->type, VT_LOCAL | VT_LVAL, addr);
             }
         } else {
             if ((func_vt.t & VT_BTYPE) == VT_STRUCT) {
                 CType type, ret_type;
                 int ret_align;
-                if (gfunc_sret(&func_vt, &ret_type, &ret_align)) {
+                if (!gfunc_sret(&func_vt, &ret_type, &ret_align)) {
                     /* if returning structure, must copy it to implicit
                        first pointer arg location */
                     type = func_vt;
                     vstore();
                 } else {
                     /* returning structure packed into registers */
-                    int size, addr, align;
+                    int r, size, addr, offset, align;
                     size = type_size(&func_vt,&align);
                     if ((vtop->r != (VT_LOCAL | VT_LVAL) || (vtop->c.i & (ret_align-1)))
                         && (align & (ret_align-1))) {
                     }
                     vtop->type = ret_type;
                     if (is_float(ret_type.t))
-                        gv(rc_fret(ret_type.t));
+                        r = rc_fret(ret_type.t);
                     else
-                        gv(RC_IRET);
+                        r = RC_IRET;
+                    /* We assume that when a structure is returned in multiple
+                       registers, their classes are consecutive values of the
+                       suite s(n) = 2^n */
+                    for (offset = 0; offset < size; offset += ret_align, r<<=1) {
+                        gv(r);
+                        vtop->c.i += ret_align;
+                        vtop->r = VT_LOCAL | VT_LVAL;
+                    }
                 }
             } else if (is_float(func_vt.t)) {
                 gv(rc_fret(func_vt.t));

x86_64-gen.c+10−8

     }
 }
-/* Return 1 if this function returns via an sret pointer, 0 otherwise */
+/* Return the number of registers needed to return the struct, or 0 if
+   returning via struct pointer. */
 ST_FUNC int gfunc_sret(CType *vt, CType *ret, int *ret_align)
 {
     int size, align;
     size = type_size(vt, &align);
     ret->ref = NULL;
     if (size > 8) {
-        return 1;
+        return 0;
     } else if (size > 4) {
         ret->t = VT_LLONG;
-        return 0;
+        return 1;
     } else if (size > 2) {
         ret->t = VT_INT;
-        return 0;
+        return 1;
     } else if (size > 1) {
         ret->t = VT_SHORT;
-        return 0;
+        return 1;
     } else {
         ret->t = VT_BYTE;
-        return 0;
+        return 1;
     }
 }
     }
 }
-/* Return 1 if this function returns via an sret pointer, 0 otherwise */
+/* Return the number of registers needed to return the struct, or 0 if
+   returning via struct pointer. */
 int gfunc_sret(CType *vt, CType *ret, int *ret_align) {
     int size, align, reg_count;
     *ret_align = 1; // Never have to re-align return values for x86-64
-    return (classify_x86_64_arg(vt, ret, &size, &align, &reg_count) == x86_64_mode_memory);
+    return (classify_x86_64_arg(vt, ret, &size, &align, &reg_count) != x86_64_mode_memory);
 }
 #define REGN 6

Add support for struct > 4B returned via registers

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code