Spill excess arguments to temporary storage. Fixes #1036

Author: nickg

NEWS.md

@@ -17,6 +17,8 @@
 - Fixed a crash when `'last_value` is used with record types (#1043).
 - Selected names can now be to register value change callbacks with
   `vhpi_register_cb` (#1045).
+- Removed the limit on the maximum number of parameters that can be
+  passed to a VHDL subprogram (#1036).
 - Several other minor bugs were resolved (#1038).
 
 ## Version 1.14.1 - 2024-10-26

src/jit/jit-irgen.c

@@ -857,17 +857,6 @@ static jit_value_t irgen_get_arg(jit_irgen_t *g, int op, int arg)
    return irgen_get_value(g, vcode_get_arg(op, arg));
 }
 
-static jit_reg_t irgen_as_reg(jit_irgen_t *g, jit_value_t value)
-{
-   if (value.kind == JIT_VALUE_REG)
-      return value.reg;
-   else {
-      jit_reg_t r = irgen_alloc_reg(g);
-      j_mov(g, r, value);
-      return r;
-   }
-}
-
 static jit_value_t irgen_lea(jit_irgen_t *g, jit_value_t addr)
 {
    switch (addr.kind) {
@@ -887,6 +876,24 @@ static jit_value_t irgen_lea(jit_irgen_t *g, jit_value_t addr)
    }
 }
 
+static jit_reg_t irgen_as_reg(jit_irgen_t *g, jit_value_t value)
+{
+   switch (value.kind) {
+   case JIT_VALUE_REG:
+      return value.reg;
+   case JIT_ADDR_REG:
+   case JIT_ADDR_CPOOL:
+   case JIT_ADDR_ABS:
+      return jit_value_as_reg(irgen_lea(g, value));
+   default:
+      {
+         jit_reg_t r = irgen_alloc_reg(g);
+         j_mov(g, r, value);
+         return r;
+      }
+   }
+}
+
 static jit_value_t irgen_is_scalar(jit_irgen_t *g, int op, int arg)
 {
    const vtype_kind_t kind = vcode_reg_kind(vcode_get_arg(op, arg));
@@ -1189,12 +1196,33 @@ static void irgen_send_args(jit_irgen_t *g, int op, int first)
 {
    const int nargs = vcode_count_args(op);
 
+   jit_value_t spill = { .kind = JIT_VALUE_INVALID };
+   int32_t spilloff = 0;
+
    for (int i = 0, pslot = first; i < nargs; i++) {
       vcode_reg_t vreg = vcode_get_arg(op, i);
       int slots = irgen_slots_for_type(vcode_reg_type(vreg));
-      if (unlikely(pslot + slots >= JIT_MAX_ARGS))
-         fatal("call to %s requires more than the maximum supported "
-               "%d arguments", istr(vcode_get_func(op)), JIT_MAX_ARGS);
+
+      if (pslot + slots >= JIT_MAX_ARGS - 1) {
+         // Large number of arguments spill to the heap
+         if (spill.kind == JIT_VALUE_INVALID) {
+            size_t size = slots * sizeof(jit_scalar_t);
+            for (int j = i + 1; j < nargs; j++) {
+               vcode_type_t vtype = vcode_reg_type(vcode_get_arg(op, j));
+               size += irgen_slots_for_type(vtype) * sizeof(jit_scalar_t);
+            }
+
+            spill = macro_lalloc(g, jit_value_from_int64(size));
+            j_send(g, JIT_MAX_ARGS - 1, spill);
+            pslot = JIT_MAX_ARGS;
+         }
+
+         jit_reg_t base = irgen_as_reg(g, irgen_get_value(g, vreg));
+         for (int j = 0; j < slots; j++, spilloff += sizeof(jit_scalar_t)) {
+            jit_value_t ptr = jit_addr_from_value(spill, spilloff);
+            j_store(g, JIT_SZ_64, jit_value_from_reg(base + j), ptr);
+         }
+      }
       else if (slots > 1) {
          jit_reg_t base = jit_value_as_reg(irgen_get_value(g, vreg));
          for (int j = 0; j < slots; j++)
@@ -3480,6 +3508,11 @@ static void irgen_op_bind_foreign(jit_irgen_t *g, int op)
    const int nparams = vcode_count_params();
    for (int i = 0; i < nparams; i++) {
       const int slots = irgen_slots_for_type(vcode_param_type(i));
+      if (unlikely(pslot + slots >= JIT_MAX_ARGS))
+         fatal("foreign subprogram %s requires more than the maximum supported "
+               "%d arguments", istr(vcode_unit_name(g->func->unit)),
+               JIT_MAX_ARGS);
+
       jit_value_t p = irgen_get_value(g, vcode_param_reg(i));
       j_send(g, pslot++, p);
       for (int j = 1; j < slots; j++)
@@ -4007,19 +4040,36 @@ static void irgen_params(jit_irgen_t *g, int first)
    types[first] = FFI_POINTER;
    types[0] = FFI_VOID;
 
+   jit_value_t spill = { .kind = JIT_VALUE_INVALID };
+   int32_t spilloff = 0;
+
    const int nparams = vcode_count_params();
    for (int i = 0, pslot = first; i < nparams; i++) {
       vcode_reg_t preg = vcode_param_reg(i);
       vcode_type_t vtype = vcode_param_type(i);
       int slots = irgen_slots_for_type(vtype);
 
-      if (unlikely(pslot + slots >= JIT_MAX_ARGS))
-         fatal("%s requires more than the maximum supported %d arguments",
-               istr(g->func->name), JIT_MAX_ARGS);
+      if (pslot + slots >= JIT_MAX_ARGS - 1) {
+         // Large number of arguments spill to the heap
+         if (spill.kind == JIT_VALUE_INVALID) {
+            spill = j_recv(g, JIT_MAX_ARGS - 1);
+            pslot = JIT_MAX_ARGS;
+         }
 
-      g->map[preg] = j_recv(g, pslot++);
-      for (int i = 1; i < slots; i++)
-         j_recv(g, pslot++);   // Must be contiguous registers
+         jit_value_t ptr = jit_addr_from_value(spill, spilloff);
+         g->map[preg] = j_load(g, JIT_SZ_64, ptr);
+         spilloff += sizeof(jit_scalar_t);
+
+         for (int i = 1; i < slots; i++, spilloff += sizeof(jit_scalar_t)) {
+            jit_value_t ptr = jit_addr_from_value(spill, spilloff);
+            j_load(g, JIT_SZ_64, ptr);   // Must be contiguous registers
+         }
+      }
+      else {
+         g->map[preg] = j_recv(g, pslot++);
+         for (int i = 1; i < slots; i++)
+            j_recv(g, pslot++);   // Must be contiguous registers
+      }
 
       if (i + first + 1 < ARRAY_LEN(types))
          types[i + first + 1] = irgen_ffi_type(vtype);
@@ -4180,10 +4230,7 @@ void jit_irgen(jit_func_t *f)
       irgen_bind_label(g, cont);
    }
 
-   const int first_param = irgen_is_procedure(g) || has_jump_table ? 1 : 0;
-   if (has_params)
-      irgen_params(g, first_param);
-   else if (kind == VCODE_UNIT_PROCESS) {
+   if (kind == VCODE_UNIT_PROCESS) {
       const ffi_type_t types[] = { FFI_POINTER, FFI_POINTER, FFI_POINTER };
       g->func->spec = ffi_spec_new(types, ARRAY_LEN(types));
    }
@@ -4208,6 +4255,10 @@ void jit_irgen(jit_func_t *f)
    if (has_jump_table)
       irgen_jump_table(g);
 
+   const int first_param = irgen_is_procedure(g) || has_jump_table ? 1 : 0;
+   if (has_params)
+      irgen_params(g, first_param);
+
    irgen_locals(g);
 
    if (g->stateless) {

src/jit/jit-priv.h

@@ -356,7 +356,7 @@ typedef struct {
 
 typedef struct _pack_writer pack_writer_t;
 
-#define JIT_MAX_ARGS 100
+#define JIT_MAX_ARGS 64
 
 typedef struct _jit_interp jit_interp_t;
 

src/jit/jit.h

@@ -31,6 +31,8 @@ typedef union {
    double   real;
 } jit_scalar_t;
 
+STATIC_ASSERT(sizeof(jit_scalar_t) == 8);
+
 typedef struct {
    void *(*init)(jit_t *);
    void (*cgen)(jit_t *, jit_handle_t, void *);

test/regress/issue1036.vhd

@@ -0,0 +1,57 @@
+entity issue1036 is
+end entity;
+
+architecture test of issue1036 is
+
+    type int2d is array (natural range <>, natural range <>) of integer;
+
+    procedure many_args
+        ( a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11 : inout bit_vector;
+          a12, a13, a14, a15, a16, a17, a18, a19 : inout integer;
+          a20, a21, a22, a23, a24, a25, a26 : inout int2d;
+          a27 : inout integer;
+          signal a28 : inout bit_vector ) is
+    begin
+        assert a5 = X"05";
+        assert a11 = X"1010";
+        assert a25 = (0 => (0 => 42));
+        assert a26(0, 0) = 99;
+        assert a27 = 251;
+        assert a28 = X"f0";
+
+        a25(0, 0) := 77;
+        a26(0, 0) := 55;
+        a27 := 999;
+        a28 <= not a28;
+        wait for 0 ns;
+    end procedure;
+
+    signal s : bit_vector(7 downto 0) := X"f0";
+begin
+
+    process is
+        variable v0, v1, v2, v3, v4, v5 : bit_vector(7 downto 0);
+        variable v6, v7, v8, v9, v10, v11 : bit_vector(15 downto 0);
+        variable v12, v13, v14, v15, v16, v17, v18, v19 : integer;
+        variable v20, v21, v22, v23, v24, v25, v26 : int2d(0 to 0, 0 to 0);
+        variable v27 : integer;
+    begin
+        v5 := X"05";
+        v11 := X"1010";
+        v25 := (0 => (0 => 42));
+        v26(0, 0) := 99;
+        v27 := 251;
+
+        many_args(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11,
+                  v12, v13, v14, v15, v16, v17, v18, v19,
+                  v20, v21, v22, v23, v24, v25, v26, v27, s);
+
+        assert v25 = (0 => (0 => 77));
+        assert v26(0, 0) = 55;
+        assert v27 = 999;
+        assert s = X"0f";
+
+        wait;
+    end process;
+
+end architecture;

test/regress/testlist.txt

@@ -1066,3 +1066,4 @@ psl13           fail,gold,psl
 issue1045       normal,vhpi
 issue1044       mixed
 issue1030       wave,2008,dump-arrays
+issue1036       normal