vpi: Added $ivl_darray_method$from_vec.

Converts a vector to dynamic array of vectors.

vpi/v2009.sft

@@ -13,3 +13,4 @@ $increment		vpiSysFuncInt
 $size			vpiSysFuncInt
 
 $ivl_array_method$to_vec	vpiSysFuncVoid
+$ivl_array_method$from_vec	vpiSysFuncVoid

vpi/v2009_array.c

@@ -323,6 +323,138 @@ static PLI_INT32 to_vec_calltf(ICARUS_VPI_CONST PLI_BYTE8*name)
       return 0;
 }
 
+static PLI_INT32 from_vec_compiletf(ICARUS_VPI_CONST PLI_BYTE8*user_data)
+{
+      (void) user_data; /* Parameter is not used. */
+
+      vpiHandle systf_handle, arg_iterator, arg_handle;
+      PLI_INT32 arg_type[2];
+
+      /* obtain a handle to the system task instance */
+      systf_handle = vpi_handle(vpiSysTfCall, NULL);
+      if (systf_handle == NULL) {
+          vpi_printf("ERROR: $ivl_darray_method$from_vec failed to obtain systf handle\n");
+          vpi_control(vpiFinish,0); /* abort simulation */
+          return 0;
+      }
+
+      /* obtain handles to system task arguments */
+      arg_iterator = vpi_iterate(vpiArgument, systf_handle);
+      if (arg_iterator == NULL) {
+          vpi_printf("ERROR: $ivl_darray_method$from_vec requires 2 arguments\n");
+          vpi_control(vpiFinish, 0);
+          return 0;
+      }
+
+      /* check the type of object in system task arguments */
+      arg_handle = vpi_scan(arg_iterator);
+      for(int i = 0; i < 2; ++i) {
+          arg_type[i] = vpi_get(vpiType, arg_handle);
+          arg_handle = vpi_scan(arg_iterator);
+      }
+
+      if (arg_handle != NULL) {       /* are there more arguments? */
+          vpi_printf("ERROR: $ivl_darray_method$from_vec can only have 2 arguments\n");
+          vpi_free_object(arg_iterator);
+          vpi_control(vpiFinish, 0);
+          return 0;
+      }
+
+      if ((arg_type[1] != vpiNet && arg_type[1] != vpiReg && arg_type[1] != vpiBitVar) ||
+              (arg_type[0] != vpiRegArray)) {
+          vpi_printf("ERROR: $ivl_darray_method$from_vec value arguments must be "\
+                      "a net or reg and a dynamic array\n");
+          vpi_free_object(arg_iterator);
+          vpi_control(vpiFinish, 0);
+          return 0;
+      }
+
+      return 0;
+}
+
+static PLI_INT32 from_vec_calltf(ICARUS_VPI_CONST PLI_BYTE8*name)
+{
+      (void)name; /* Parameter is not used. */
+      const int PLI_INT32_bits = sizeof(PLI_INT32) * 8;
+
+      vpiHandle callh = vpi_handle(vpiSysTfCall, 0);
+      vpiHandle argv, darr, darr_word, vec;
+      s_vpi_value darr_val, vec_val;
+      s_vpi_vecval*vector;
+
+      /* Fetch arguments */
+      argv = vpi_iterate(vpiArgument, callh);
+      assert(argv);
+      darr = vpi_scan(argv);
+      assert(darr);
+      vec = vpi_scan(argv);
+      assert(vec);
+      vpi_free_object(argv);
+
+      int darr_length = vpi_get(vpiSize, darr);
+      darr_word = vpi_handle_by_index(darr, 0);
+      int darr_word_bit_size = vpi_get(vpiSize, darr_word);
+      int darr_bit_size = darr_length * darr_word_bit_size;
+
+      int vec_size = vpi_get(vpiSize, vec);
+      if(vec_size <= 0) {
+	    vpi_printf("ERROR: Cannot cast empty vector");
+            vpi_control(vpiFinish, 0);
+            return 0;
+      }
+
+      if(vec_size != darr_bit_size) {
+	    vpi_printf("ERROR: Dynamic array and vector size do not match");
+            vpi_control(vpiFinish, 0);
+            return 0;
+      }
+
+      /* Conversion part */
+      int darr_number = ceil((double)darr_word_bit_size / PLI_INT32_bits);
+      vector = calloc(darr_number, sizeof(s_vpi_vecval));
+
+      vec_val.format = vpiVectorVal;
+      vpi_get_value(vec, &vec_val);
+      s_vpi_vecval*darr_val_ptr;
+      int offset = 0;       // offset in bits
+
+      /* We have to reverse the order of the dynamic array, no memcpy here */
+      for(int i = darr_length - 1; i >= 0; --i) {
+            int bits_to_copy = darr_word_bit_size;
+            darr_word = vpi_handle_by_index(darr, i);
+            assert(darr_val.value.vector);
+            darr_val_ptr = vector;
+
+            while(bits_to_copy > 0) {
+                int copied_bits = bits_to_copy > PLI_INT32_bits ? PLI_INT32_bits : bits_to_copy;
+                PLI_INT32 aval = vec_val.value.vector[offset / PLI_INT32_bits].aval;
+                PLI_INT32 bval = vec_val.value.vector[offset / PLI_INT32_bits].bval;
+
+                if(offset % PLI_INT32_bits != 0) {
+                    unsigned int remainder = offset % 32;
+                    aval >>= remainder;
+                    aval |= vec_val.value.vector[offset / PLI_INT32_bits + 1].aval << (PLI_INT32_bits - remainder);
+                    bval >>= remainder;
+                    bval |= vec_val.value.vector[offset / PLI_INT32_bits + 1].bval << (PLI_INT32_bits - remainder);
+                }
+
+                offset += copied_bits;
+                darr_val_ptr->aval = aval;
+                darr_val_ptr->bval = bval;
+                darr_val_ptr++;
+                bits_to_copy -= copied_bits;
+            }
+
+            darr_val.format = vpiVectorVal;
+            darr_val.value.vector = vector;
+            vpi_put_value(darr_word, &darr_val, 0, vpiNoDelay);
+      }
+
+      free(vector);
+
+      return 0;
+}
+
 void v2009_array_register(void)
 {
       s_vpi_systf_data tf_data;
@@ -338,6 +470,16 @@ void v2009_array_register(void)
       res = vpi_register_systf(&tf_data);
       vpip_make_systf_system_defined(res);
 
+      tf_data.type      = vpiSysTask;
+      tf_data.sysfunctype = 0;
+      tf_data.tfname    = "$ivl_darray_method$from_vec";
+      tf_data.calltf    = from_vec_calltf;
+      tf_data.compiletf = from_vec_compiletf;
+      tf_data.sizetf    = 0;
+      tf_data.user_data = "$ivl_darray_method$from_vec";
+      res = vpi_register_systf(&tf_data);
+      vpip_make_systf_system_defined(res);
+
       tf_data.type        = vpiSysFunc;
       tf_data.sysfunctype = vpiIntFunc;
       tf_data.calltf      = 0;