args: don't use alloca for const size cases.

* args.h (args_decl_list): This macro now handles only
constant values of N. It declares an anonyous container
struct type which juxtaposes the struc args header
with exactly N values. This is simply defined as a local
variable without alloca.
(args_decl_constsize): Like args_decl, but requiring a
constant N; implemented via args_decl_list.
(args_decl_list_dyn): New name for the old args_decl_list
which calls alloca. No places in the code depend on this
at all, except the definition of args_decl.
(args_decl): Retargeted to args_decl_list_dyn.
There is some inconsistency in the macro naming in that
args_decl_constsize depends on args_decl_list, and
args_decl depends on arg_decl_list_dyn.  This was done
to minimize diffs. Most direct uses of args_decl_list
have a constant size, but a large number of args_decl
uses do not have a constant size.

* eval.c (op_catch): Use args_decl_constsize.

* ffi.c (ffi_struct_in, ffi_struct_get, union_out):
Likewise.

* ftw.c (ftw_callback): Likewise.

* lib.c (funcall, funcall1, funcall2, funcall3,
funcall4, uniq, relate): Likewise.

* socket.c (sockaddr_in_unpack, sockaddr_in6_unpack,
sockaddr_un_unpack):
Likewise.

* stream.c (formatv): Likewise.

* struct.c (struct_from_plist, struct_from_args,
make_struct_lit): Likewise.

* sysif.c (termios_unpack): Likewise.

* time.c (broken_time_struct): Likewise.

11 files changed, 43 insertions, 38 deletions

diff --git a/args.h b/args.h
index 6f4baa43..df8cb3db 100644
--- a/args.h
+++ b/args.h
@@ -64,14 +64,19 @@ INLINE void args_set_fill(struct args *args, cnum fill)
 }
 
 #define args_decl_list(NAME, N, L)                                      \
+  struct { struct args args; val arg[N]; } _ac;                         \
+  struct args *NAME = args_init_list(&_ac.args, N, L)
+
+#define args_decl_constsize(NAME, N) args_decl_list(NAME, N, nil)
+
+#define args_decl_list_dyn(NAME, N, L)                                  \
   mem_t *NAME ## _mem =                                                 \
     coerce(mem_t *,                                                     \
            alloca(offsetof(struct args, arg) + (N)*sizeof (val)));      \
   struct args *NAME = args_init_list(coerce(struct args *,              \
                                             NAME ## _mem), N, L)
 
-#define args_decl(NAME, N) args_decl_list(NAME, N, nil)
-
+#define args_decl(NAME, N) args_decl_list_dyn(NAME, N, nil)
 
 INLINE val args_add(struct args *args, val arg)
 {
diff --git a/eval.c b/eval.c
index 8d7ea7e4..011339ef 100644
--- a/eval.c
+++ b/eval.c
@@ -2791,7 +2791,7 @@ static val op_catch(val form, val env)
   result = eval(try_form, env, try_form);
 
   uw_catch(exsym, exvals) {
-    args_decl(args, ARGS_MIN);
+    args_decl_constsize(args, ARGS_MIN);
     val iter;
 
     args_add(args, exsym);
diff --git a/ffi.c b/ffi.c
index 4c6025d6..ece30eab 100644
--- a/ffi.c
+++ b/ffi.c
@@ -2722,7 +2722,7 @@ static val ffi_struct_in(struct txr_ffi_type *tft, int copy, mem_t *src,
     return strct;
 
   if (strct == nil) {
-    args_decl(args, ARGS_ABS_MIN);
+    args_decl_constsize(args, ARGS_ABS_MIN);
     strct = make_struct(tft->lt, nil, args);
   }
 
@@ -2789,7 +2789,7 @@ static val ffi_struct_get(struct txr_ffi_type *tft, mem_t *src, val self)
 {
   cnum i, nmemb = tft->nelem;
   struct smemb *memb = tft->memb;
-  args_decl(args, ARGS_ABS_MIN);
+  args_decl_constsize(args, ARGS_ABS_MIN);
   val strct = make_struct(tft->lt, nil, args);
   int flexp = tft->flexible;
 
@@ -7191,7 +7191,7 @@ val make_zstruct(val type, struct args *args)
   val self = lit("make-zstruct");
   struct txr_ffi_type *tft = ffi_type_struct_checked(self, type);
   val pairs = args_get_list(args);
-  args_decl(ms_args, ARGS_ABS_MIN);
+  args_decl_constsize(ms_args, ARGS_ABS_MIN);
   val strct = make_struct(tft->lt, nil, ms_args);
   mem_t *zbuf;
   char *inited = coerce(char *, zalloca(tft->nelem));
diff --git a/ftw.c b/ftw.c
index becc8c54..6984b7ff 100644
--- a/ftw.c
+++ b/ftw.c
@@ -71,7 +71,7 @@ static int ftw_callback(const char *c_path, const struct stat *c_sb,
     val base = num(fb->base);
     val result;
 
-    args_decl(args, max(ARGS_MIN, 5));
+    args_decl_constsize(args, max(ARGS_MIN, 5));
     args_add5(args, path, type, sb, level, base);
     result = generic_funcall(s_callback, args);
     c_result = if3(integerp(result), c_num(result, self), 0);
diff --git a/lib.c b/lib.c
index f6cae965..4b992374 100644
--- a/lib.c
+++ b/lib.c
@@ -8422,7 +8422,7 @@ static NORETURN void wrongargs(val fun)
 val funcall(val fun)
 {
   if (type(fun) != FUN || dbg_backtrace) generic: {
-    args_decl(args, ARGS_MIN);
+    args_decl_constsize(args, ARGS_MIN);
     return generic_funcall(fun, args);
   }
 
@@ -8443,14 +8443,14 @@ val funcall(val fun)
       return vm_funcall4(fun, colon_k, colon_k, colon_k, colon_k);
     default:
       {
-        args_decl(args, ARGS_MIN);
+        args_decl_constsize(args, ARGS_MIN);
         return vm_execute_closure(fun, args);
       }
     }
   }
 
   if (fun->f.variadic) {
-    args_decl(args, ARGS_MIN);
+    args_decl_constsize(args, ARGS_MIN);
 
     switch (fun->f.functype) {
     case FINTERP:
@@ -8500,7 +8500,7 @@ val funcall(val fun)
 val funcall1(val fun, val arg)
 {
   if (type(fun) != FUN || dbg_backtrace) generic: {
-    args_decl(args, ARGS_MIN);
+    args_decl_constsize(args, ARGS_MIN);
     args_add(args, z(arg));
     return generic_funcall(fun, args);
   }
@@ -8520,7 +8520,7 @@ val funcall1(val fun, val arg)
       return vm_funcall4(fun, z(arg), colon_k, colon_k, colon_k);
     default:
       {
-        args_decl(args, ARGS_MIN);
+        args_decl_constsize(args, ARGS_MIN);
         args_add(args, arg);
         return vm_execute_closure(fun, args);
       }
@@ -8528,7 +8528,7 @@ val funcall1(val fun, val arg)
   }
 
   if (fun->f.variadic) {
-    args_decl(args, ARGS_MIN);
+    args_decl_constsize(args, ARGS_MIN);
 
     switch (fun->f.functype) {
     case FINTERP:
@@ -8581,7 +8581,7 @@ val funcall1(val fun, val arg)
 val funcall2(val fun, val arg1, val arg2)
 {
   if (type(fun) != FUN || dbg_backtrace) generic: {
-    args_decl(args, ARGS_MIN);
+    args_decl_constsize(args, ARGS_MIN);
     args_add2(args, z(arg1), z(arg2));
     return generic_funcall(fun, args);
   }
@@ -8599,7 +8599,7 @@ val funcall2(val fun, val arg1, val arg2)
       return vm_funcall4(fun, z(arg1), z(arg2), colon_k, colon_k);
     default:
       {
-        args_decl(args, ARGS_MIN);
+        args_decl_constsize(args, ARGS_MIN);
         args_add2(args, arg1, arg2);
         return vm_execute_closure(fun, args);
       }
@@ -8607,7 +8607,7 @@ val funcall2(val fun, val arg1, val arg2)
   }
 
   if (fun->f.variadic) {
-    args_decl(args, ARGS_MIN);
+    args_decl_constsize(args, ARGS_MIN);
 
     switch (fun->f.functype) {
     case FINTERP:
@@ -8664,7 +8664,7 @@ val funcall2(val fun, val arg1, val arg2)
 val funcall3(val fun, val arg1, val arg2, val arg3)
 {
   if (type(fun) != FUN || dbg_backtrace) generic: {
-    args_decl(args, ARGS_MIN);
+    args_decl_constsize(args, ARGS_MIN);
     args_add3(args, z(arg1), z(arg2), z(arg3));
     return generic_funcall(fun, args);
   }
@@ -8680,14 +8680,14 @@ val funcall3(val fun, val arg1, val arg2, val arg3)
       return vm_funcall4(fun, z(arg1), z(arg2), z(arg3), colon_k);
     default:
       {
-        args_decl(args, ARGS_MIN);
+        args_decl_constsize(args, ARGS_MIN);
         args_add3(args, arg1, arg2, arg3);
         return vm_execute_closure(fun, args);
       }
     }
   }
   if (fun->f.variadic) {
-    args_decl(args, ARGS_MIN);
+    args_decl_constsize(args, ARGS_MIN);
 
     switch (fun->f.functype) {
     case FINTERP:
@@ -8746,7 +8746,7 @@ val funcall3(val fun, val arg1, val arg2, val arg3)
 val funcall4(val fun, val arg1, val arg2, val arg3, val arg4)
 {
   if (type(fun) != FUN || dbg_backtrace) generic: {
-    args_decl(args, ARGS_MIN);
+    args_decl_constsize(args, ARGS_MIN);
     args_add4(args, z(arg1), z(arg2), z(arg3), z(arg4));
     return generic_funcall(fun, args);
   }
@@ -8765,7 +8765,7 @@ val funcall4(val fun, val arg1, val arg2, val arg3, val arg4)
   }
 
   if (fun->f.variadic) {
-    args_decl(args, ARGS_MIN);
+    args_decl_constsize(args, ARGS_MIN);
 
     switch (fun->f.functype) {
     case FINTERP:
@@ -11056,7 +11056,7 @@ val unique(val seq, val keyfun, struct args *hashv_args)
 
 val uniq(val seq)
 {
-  args_decl(hashv_args, ARGS_MIN);
+  args_decl_constsize(hashv_args, ARGS_MIN);
   args_add(hashv_args, equal_based_k);
   return unique(seq, identity_f, hashv_args);
 }
@@ -13354,7 +13354,7 @@ val relate(val domain_seq, val range_seq, val dfl_val)
   val lds = length(domain_seq);
   val use_hash = and2(gt(lds, num_fast(10)),
                       le(lds, length(range_seq)));
-  args_decl(args, ARGS_MIN);
+  args_decl_constsize(args, ARGS_MIN);
   val hash = if2(use_hash, hash_zip(domain_seq, range_seq, args));
 
   return if3(missingp(dfl_val),
diff --git a/socket.c b/socket.c
index dfa6cff0..e82fb96f 100644
--- a/socket.c
+++ b/socket.c
@@ -134,7 +134,7 @@ static void ipv6_scope_id_from_num(struct sockaddr_in6 *dst, val scope)
 
 static val sockaddr_in_unpack(struct sockaddr_in *src)
 {
-  args_decl(args, ARGS_MIN);
+  args_decl_constsize(args, ARGS_MIN);
   val out = make_struct(sockaddr_in_s, nil, args);
   slotset(out, addr_s, ipv4_addr_to_num(&src->sin_addr));
   slotset(out, port_s, num_fast(ntohs(src->sin_port)));
@@ -143,7 +143,7 @@ static val sockaddr_in_unpack(struct sockaddr_in *src)
 
 static val sockaddr_in6_unpack(struct sockaddr_in6 *src)
 {
-  args_decl(args, ARGS_MIN);
+  args_decl_constsize(args, ARGS_MIN);
   val out = make_struct(sockaddr_in6_s, nil, args);
   slotset(out, addr_s, ipv6_addr_to_num(&src->sin6_addr));
   slotset(out, port_s, num_fast(ntohs(src->sin6_port)));
@@ -152,7 +152,7 @@ static val sockaddr_in6_unpack(struct sockaddr_in6 *src)
 
 static val sockaddr_un_unpack(struct sockaddr_un *src)
 {
-  args_decl(args, ARGS_MIN);
+  args_decl_constsize(args, ARGS_MIN);
   val out = make_struct(sockaddr_un_s, nil, args);
   slotset(out, path_s, string_utf8(src->sun_path));
   return out;
diff --git a/stream.c b/stream.c
index 3f835367..e51cf4ff 100644
--- a/stream.c
+++ b/stream.c
@@ -3820,7 +3820,7 @@ val formatv(val stream_in, val fmtstr, struct args *al)
 val vformat(val stream, val fmtstr, va_list vl)
 {
   val arg;
-  args_decl(args, ARGS_MAX);
+  args_decl_constsize(args, ARGS_MAX);
 
   while ((arg = va_arg(vl, val)) != nao)
     args_add_checked(lit("format"), args, arg);
diff --git a/struct.c b/struct.c
index e601cbcd..08245107 100644
--- a/struct.c
+++ b/struct.c
@@ -847,13 +847,13 @@ val make_struct(val type, val plist, struct args *boa)
 
 val struct_from_plist(val type, struct args *plist)
 {
-  args_decl(boa, ARGS_ABS_MIN);
+  args_decl_constsize(boa, ARGS_ABS_MIN);
   return make_struct_impl(lit("struct-from-plist"), type, plist, boa);
 }
 
 val struct_from_args(val type, struct args *boa)
 {
-  args_decl(pargs, ARGS_ABS_MIN);
+  args_decl_constsize(pargs, ARGS_ABS_MIN);
   return make_struct_impl(lit("struct-from-args"), type, pargs, boa);
 }
 
@@ -934,7 +934,7 @@ val make_lazy_struct(val type, val argfun)
 
 val make_struct_lit(val type, val plist)
 {
-  args_decl(args, ARGS_ABS_MIN);
+  args_decl_constsize(args, ARGS_ABS_MIN);
   val strct;
 
   if (opt_compat && opt_compat <= 154) {
diff --git a/sysif.c b/sysif.c
index a4002184..339d9962 100644
--- a/sysif.c
+++ b/sysif.c
@@ -1263,7 +1263,7 @@ static val stat_to_list(struct stat st)
 
 val stat_to_struct(struct stat st, val path, val stat_opt)
 {
-  args_decl(args, ARGS_MIN);
+  args_decl_constsize(args, ARGS_MIN);
   val strct = default_arg(stat_opt, make_struct(stat_s, nil, args));
   slotset(strct, dev_s, num(st.st_dev));
   slotset(strct, ino_s, num(st.st_ino));
@@ -1905,7 +1905,7 @@ static void fill_passwd(val to, struct passwd *from)
 
 static val make_pwstruct(struct passwd *p)
 {
-  args_decl(args, ARGS_MIN);
+  args_decl_constsize(args, ARGS_MIN);
   val out = make_struct(passwd_s, nil, args);
   fill_passwd(out, p);
   return out;
@@ -2003,7 +2003,7 @@ static void fill_group(val to, struct group *from)
 
 static val make_grstruct(struct group *g)
 {
-  args_decl(args, ARGS_MIN);
+  args_decl_constsize(args, ARGS_MIN);
   val out = make_struct(group_s, nil, args);
   fill_group(out, g);
   return out;
@@ -2221,7 +2221,7 @@ static val fnmatch_wrap(val pattern, val string, val flags)
 #if HAVE_UNAME
 static val uname_wrap(void)
 {
-  args_decl(args, ARGS_MIN);
+  args_decl_constsize(args, ARGS_MIN);
   struct utsname un;
   int res;
   if ((res = uname(&un)) >= 0) {
@@ -2459,7 +2459,7 @@ static val readdir_wrap(val dirobj, val dirent_in)
       dent = readdir(d->dir);
       continue;
     } else {
-      args_decl(args, ARGS_MIN);
+      args_decl_constsize(args, ARGS_MIN);
       val dirent = default_arg(dirent_in, make_struct(dirent_st, nil, args));
       slotset(dirent, name_s,
               if3(d->path,
@@ -2519,7 +2519,7 @@ val getrlimit_wrap(val resource, val rlim_opt)
                self, resource, num(errno), errno_to_str(errno), nao);
 
   if (missingp(rlim)) {
-    args_decl(args, ARGS_MIN);
+    args_decl_constsize(args, ARGS_MIN);
     rlim = make_struct(rlim_st, nil, args);
   }
 
diff --git a/termios.c b/termios.c
index c717fa76..6f9030e4 100644
--- a/termios.c
+++ b/termios.c
@@ -191,7 +191,7 @@ static speed_t termios_baud_to_speed(cnum baud)
 
 static val termios_unpack(struct termios *in)
 {
-  args_decl(args, ARGS_MIN);
+  args_decl_constsize(args, ARGS_MIN);
   val out = make_struct(termios_s, nil, args);
   int i, cc_sz = convert(int, sizeof in->c_cc / sizeof in->c_cc[0]);
   val cc = vector(num_fast(cc_sz), nil);
diff --git a/time.c b/time.c
index fecb9f40..d1e64526 100644
--- a/time.c
+++ b/time.c
@@ -177,7 +177,7 @@ static void tm_to_time_struct(val time_struct, struct tm *ptm)
 
 static val broken_time_struct(struct tm *tms)
 {
-  args_decl(args, ARGS_MIN);
+  args_decl_constsize(args, ARGS_MIN);
   val ts = make_struct(time_s, nil, args);
 
   tm_to_time_struct(ts, tms);