Restructure the structs/unions involved in SRPC argument passing. This will...

src/shared/srpc/invoke.c

 /*
  * Copyright (c) 2008 The Native Client Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 /*
  * NaCl SRPC library.  A primitive rpc library.
  */
 
@@ skipping 128 matching lines @@
  */
 /*
  * Some steps involve skipping a parameter in a va_arg list.
  */
 #define SKIP(va, impl_type) \
     (void) va_arg(va, impl_type);
 
 /*
  * The first phase is the args[] vector construction.
  */
-#define SCALAR_ARG(arg, field, va, impl_type) \
-    (arg)->u.field = va_arg(va, impl_type)
-#define ARRAY_ARG(arg, field, array_name, va, impl_type) \
-    (arg)->u.field.count = va_arg(va, uint32_t);         \
-    (arg)->u.field.array_name = va_arg(va, impl_type)
-#define BOOL_ARG(arg, field, va, impl_type) \
+#define SCALAR_ARG(arg, field, va, impl_type)     \
+    (arg)->field = va_arg(va, impl_type)
+#define ARRAY_ARG(arg, array_name, va, impl_type) \
+    (arg)->u.count = va_arg(va, uint32_t);        \
+    (arg)->array_name = va_arg(va, impl_type)

[Cliff L. Biffle, 2010/12/08 21:51:51]

If you wanted, you could have array_name be e.g. "lval" and use
(arg)->arrays.array_name.  But, not a big deal.

+#define BOOL_ARG(arg, field, va, impl_type)       \
     (arg)->u.bval = (va_arg(va, impl_type) != 0)
 
 /*
  * The second phase is the rets[] vector construction before invocation.
  */
-#define SCALAR_RETINIT(arg, field, va, impl_type) \
-    (arg)->u.field = (impl_type) 0;               \
+#define SCALAR_RETINIT(arg, field, va, impl_type)     \
+    (arg)->field = (impl_type) 0;                     \
     SKIP(va, impl_type *)
-#define ARRAY_RETINIT(arg, field, array_name, va, impl_type) \
-    (arg)->u.field.count = *va_arg(va, uint32_t*);         \
-    (arg)->u.field.array_name = va_arg(va, impl_type)
-#define BOOL_RETINIT(arg, field, va, impl_type) \
+#define ARRAY_RETINIT(arg, array_name, va, impl_type) \
+    (arg)->u.count = *va_arg(va, uint32_t*);          \
+    (arg)->array_name = va_arg(va, impl_type)
+#define BOOL_RETINIT(arg, field, va, impl_type)       \
     SKIP(va, impl_type *)
 
 /*
  * The third phase is skipping the args[] after invocation.
  */
-#define SCALAR_SKIP(arg, field, va, impl_type) \
+#define SCALAR_SKIP(arg, field, va, impl_type)     \
     SKIP(va, impl_type)
-#define ARRAY_SKIP(arg, field, array_name, va, impl_type) \
-    SKIP(va, uint32_t)                                    \
+#define ARRAY_SKIP(arg, array_name, va, impl_type) \
+    SKIP(va, uint32_t)                             \
     SKIP(va, impl_type)
-#define BOOL_SKIP(arg, field, va, impl_type) \
+#define BOOL_SKIP(arg, field, va, impl_type)       \
     SCALAR_SKIP(arg, field, va, impl_type)
 
 /*
  * The fourth phase is copying the rets[] into the va_args after invocation.
  */
-#define SCALAR_RET(arg, field, va, impl_type) \
-    *va_arg(va, impl_type *) = (arg)->u.field
-#define ARRAY_RET(arg, field, array_name, va, impl_type) \
-    ARRAY_SKIP(arg, field, array_name, va, impl_type)
-#define BOOL_RET(arg, field, va, impl_type) \
-    *va_arg(va, impl_type *) = ((arg)->u.field != 0)
+#define SCALAR_RET(arg, field, va, impl_type)     \
+    *va_arg(va, impl_type *) = (arg)->field
+#define ARRAY_RET(arg, array_name, va, impl_type) \
+    ARRAY_SKIP(arg, array_name, va, impl_type)
+#define BOOL_RET(arg, field, va, impl_type)       \
+    *va_arg(va, impl_type *) = ((arg)->field != 0)
 
 /*
  * All the phases consist of a loop around a switch enumerating types.
  */
 #define ARGRET_SWITCH(phase, va, arg)                           \
     switch (*p) {                                               \
       case NACL_SRPC_ARG_TYPE_BOOL:                             \
-        BOOL_##phase(arg, bval, va, int);                       \
+        BOOL_##phase(arg, u.bval, va, int);                     \
         break;                                                  \
       case NACL_SRPC_ARG_TYPE_CHAR_ARRAY:                       \
-        ARRAY_##phase(arg, caval, carr, va, char*);             \
+        ARRAY_##phase(arg, arrays.carr, va, char*);             \
         break;                                                  \
       case NACL_SRPC_ARG_TYPE_DOUBLE:                           \
-        SCALAR_##phase(arg, dval, va, double);                  \
+        SCALAR_##phase(arg, u.dval, va, double);                \
         break;                                                  \
       case NACL_SRPC_ARG_TYPE_DOUBLE_ARRAY:                     \
-        ARRAY_##phase(arg, daval, darr, va, double*);           \
+        ARRAY_##phase(arg, arrays.darr, va, double*);           \
         break;                                                  \
       case NACL_SRPC_ARG_TYPE_HANDLE:                           \
-        SCALAR_##phase(arg, hval, va, NaClSrpcImcDescType);     \
+        SCALAR_##phase(arg, u.hval, va, NaClSrpcImcDescType);   \
         break;                                                  \
       case NACL_SRPC_ARG_TYPE_INT:                              \
-        SCALAR_##phase(arg, ival, va, int32_t);                 \
+        SCALAR_##phase(arg, u.ival, va, int32_t);               \
         break;                                                  \
       case NACL_SRPC_ARG_TYPE_INT_ARRAY:                        \
-        ARRAY_##phase(arg, iaval, iarr, va, int32_t*);          \
+        ARRAY_##phase(arg, arrays.iarr, va, int32_t*);          \
         break;                                                  \
       case NACL_SRPC_ARG_TYPE_LONG:                             \
-        SCALAR_##phase(arg, lval, va, int64_t);                 \
+        SCALAR_##phase(arg, u.lval, va, int64_t);               \
         break;                                                  \
       case NACL_SRPC_ARG_TYPE_LONG_ARRAY:                       \
-        ARRAY_##phase(arg, laval, larr, va, int64_t*);          \
+        ARRAY_##phase(arg, arrays.larr, va, int64_t*);          \
         break;                                                  \
       case NACL_SRPC_ARG_TYPE_STRING:                           \
-        SCALAR_##phase(arg, sval.str, va, char*);               \
+        SCALAR_##phase(arg, arrays.str, va, char*);             \
         break;                                                  \
       /*                                                        \
        * The two cases below are added to avoid warnings,       \
        * they are only used  in the plugin code                 \
        */                                                       \
       case NACL_SRPC_ARG_TYPE_OBJECT:                           \
       case NACL_SRPC_ARG_TYPE_VARIANT_ARRAY:                    \
       default:                                                  \
         rv = NACL_SRPC_RESULT_APP_ERROR;                        \
         goto abort4;                                            \
@@ skipping 138 matching lines @@
   va_start(in_va, rpc_signature);
   va_start(out_va, rpc_signature);
 
   rv = NaClSrpcInvokeVaList(channel, rpc_num, in_va, out_va);
 
   va_end(out_va);
   va_end(in_va);
 
   return rv;
 }