/* Associate C function with new system tesk */
void registerRegfileTestSystfs()
{
  s_vpi_systf_data task_data_s;

  task_data_s.type = vpiSysTask;
  task_data_s.sysfunctype = vpiSysTask;
  task_data_s.tfname = "$regfile_test";
  task_data_s.calltf = regfileTestCallTf;
  task_data_s.compiletf = regfileTestCompileTf;
  task_data_s.sizetf = NULL;
  task_data_s.user_data = "$regfile_test";

  vpi_register_systf(&task_data_s);

  task_data_s.type = vpiSysTask;
  task_data_s.sysfunctype = vpiSysTask;
  task_data_s.tfname = "$regfile_check";
  task_data_s.calltf = regfileCheckCallTf;
  task_data_s.compiletf = regfileCheckCompileTf;
  task_data_s.sizetf = NULL;
  task_data_s.user_data = "$regfile_check";

  vpi_register_systf(&task_data_s);

  /* Arrange for a cleanup function to be called when the
     simulation is finished. */
  s_cb_data cb_data;

  cb_data.reason = cbEndOfSimulation;
  cb_data.cb_rtn = cleanup;
  cb_data.obj    = 0;
  cb_data.time   = 0;

  vpi_register_cb(&cb_data);
}
Beispiel #2
0
void sys_scanf_register()
{
      s_vpi_systf_data tf_data;
      vpiHandle res;

      /*============================== fscanf */
      tf_data.type        = vpiSysFunc;
      tf_data.sysfunctype = vpiIntFunc;
      tf_data.tfname      = "$fscanf";
      tf_data.calltf      = sys_fscanf_calltf;
      tf_data.compiletf   = sys_fscanf_compiletf;
      tf_data.sizetf      = 0;
      tf_data.user_data   = "$fscanf";
      res = vpi_register_systf(&tf_data);
      vpip_make_systf_system_defined(res);

      /*============================== sscanf */
      tf_data.type        = vpiSysFunc;
      tf_data.sysfunctype = vpiIntFunc;
      tf_data.tfname      = "$sscanf";
      tf_data.calltf      = sys_sscanf_calltf;
      tf_data.compiletf   = sys_sscanf_compiletf;
      tf_data.sizetf      = 0;
      tf_data.user_data   = "$sscanf";
      res = vpi_register_systf(&tf_data);
      vpip_make_systf_system_defined(res);
}
Beispiel #3
0
void sys_plusargs_register(void)
{
      s_vpi_systf_data tf_data;
      vpiHandle res;

      tf_data.type        = vpiSysFunc;
      tf_data.sysfunctype = vpiIntFunc;
      tf_data.tfname      = "$test$plusargs";
      tf_data.calltf      = sys_test_plusargs_calltf;
      tf_data.compiletf   = sys_one_string_arg_compiletf;
      tf_data.sizetf      = 0;
      tf_data.user_data   = "$test$plusargs";
      res = vpi_register_systf(&tf_data);
      vpip_make_systf_system_defined(res);

      tf_data.type        = vpiSysFunc;
      tf_data.sysfunctype = vpiIntFunc;
      tf_data.tfname      = "$value$plusargs";
      tf_data.calltf      = sys_value_plusargs_calltf;
      tf_data.compiletf   = sys_value_plusargs_compiletf;
      tf_data.sizetf      = 0;
      tf_data.user_data   = "$value$plusargs";
      res = vpi_register_systf(&tf_data);
      vpip_make_systf_system_defined(res);

}
Beispiel #4
0
static void register_system_functions(void)
{
    s_vpi_systf_data tfData = { vpiSysTask, vpiSysTask };

    tfData.sizetf       = NULL;
    tfData.compiletf    = system_function_compiletf;
    tfData.calltf       = system_function_overload;

    tfData.user_data    = (char *)&systf_info_level;
    tfData.tfname       = "$info";
    vpi_register_systf( &tfData );

    tfData.user_data    = (char *)&systf_warning_level;
    tfData.tfname       = "$warning";
    vpi_register_systf( &tfData );

    tfData.user_data    = (char *)&systf_error_level;
    tfData.tfname       = "$error";
    vpi_register_systf( &tfData );

    tfData.user_data    = (char *)&systf_fatal_level;
    tfData.tfname       = "$fatal";
    vpi_register_systf( &tfData );

}
Beispiel #5
0
static void simbus_register(void)
{
      vpi_register_systf(&simbus_connect_tf);
      vpi_register_systf(&simbus_ready_tf);
      vpi_register_systf(&simbus_poll_tf);
      vpi_register_systf(&simbus_until_tf);
}
Beispiel #6
0
void sys_readmem_register()
{
      s_vpi_systf_data tf_data;
      vpiHandle res;
      s_cb_data cb_data;

      tf_data.type      = vpiSysTask;
      tf_data.tfname    = "$readmemh";
      tf_data.calltf    = sys_readmem_calltf;
      tf_data.compiletf = sys_mem_compiletf;
      tf_data.sizetf    = 0;
      tf_data.user_data = "$readmemh";
      res = vpi_register_systf(&tf_data);
      vpip_make_systf_system_defined(res);

      tf_data.type      = vpiSysTask;
      tf_data.tfname    = "$readmemb";
      tf_data.calltf    = sys_readmem_calltf;
      tf_data.compiletf = sys_mem_compiletf;
      tf_data.sizetf    = 0;
      tf_data.user_data = "$readmemb";
      res = vpi_register_systf(&tf_data);
      vpip_make_systf_system_defined(res);

      tf_data.type      = vpiSysTask;
      tf_data.tfname    = "$readmempath";
      tf_data.calltf    = sys_readmempath_calltf;
      tf_data.compiletf = sys_one_string_arg_compiletf;
      tf_data.sizetf    = 0;
      tf_data.user_data = "$readmempath";
      res = vpi_register_systf(&tf_data);
      vpip_make_systf_system_defined(res);

      tf_data.type      = vpiSysTask;
      tf_data.tfname    = "$writememh";
      tf_data.calltf    = sys_writemem_calltf;
      tf_data.compiletf = sys_mem_compiletf;
      tf_data.sizetf    = 0;
      tf_data.user_data = "$writememh";
      res = vpi_register_systf(&tf_data);
      vpip_make_systf_system_defined(res);

      tf_data.type      = vpiSysTask;
      tf_data.tfname    = "$writememb";
      tf_data.calltf    = sys_writemem_calltf;
      tf_data.compiletf = sys_mem_compiletf;
      tf_data.sizetf    = 0;
      tf_data.user_data = "$writememb";
      res = vpi_register_systf(&tf_data);
      vpip_make_systf_system_defined(res);

      cb_data.reason = cbEndOfSimulation;
      cb_data.time = 0;
      cb_data.cb_rtn = free_readmempath;
      cb_data.user_data = "system";
      vpi_register_cb(&cb_data);
}
Beispiel #7
0
void sys_time_register()
{
      s_vpi_systf_data tf_data;
      vpiHandle res;

      tf_data.type        = vpiSysFunc;
      tf_data.tfname      = "$time";
      tf_data.sysfunctype = vpiTimeFunc;
      tf_data.calltf      = sys_time_calltf;
      tf_data.compiletf   = sys_no_arg_compiletf;
      tf_data.sizetf      = 0;
      tf_data.user_data   = "$time";
      res = vpi_register_systf(&tf_data);
      vpip_make_systf_system_defined(res);

      tf_data.type        = vpiSysFunc;
      tf_data.tfname      = "$realtime";
      tf_data.sysfunctype = vpiRealFunc;
      tf_data.calltf      = sys_realtime_calltf;
      tf_data.compiletf   = sys_no_arg_compiletf;
      tf_data.sizetf      = 0;
      tf_data.user_data   = "$realtime";
      res = vpi_register_systf(&tf_data);
      vpip_make_systf_system_defined(res);

      tf_data.type        = vpiSysFunc;
      tf_data.tfname      = "$stime";
      tf_data.sysfunctype = vpiIntFunc;
      tf_data.calltf      = sys_time_calltf;
      tf_data.compiletf   = sys_no_arg_compiletf;
      tf_data.sizetf      = 0;
      tf_data.user_data   = "$stime";
      res = vpi_register_systf(&tf_data);
      vpip_make_systf_system_defined(res);

      tf_data.type        = vpiSysFunc;
      tf_data.tfname      = "$simtime";
      tf_data.sysfunctype = vpiTimeFunc;
      tf_data.calltf      = sys_time_calltf;
      tf_data.compiletf   = sys_no_arg_compiletf;
      tf_data.sizetf      = 0;
      tf_data.user_data   = "$simtime";
      res = vpi_register_systf(&tf_data);
      vpip_make_systf_system_defined(res);

      tf_data.type        = vpiSysFunc;
      tf_data.tfname      = "$abstime";
      tf_data.sysfunctype = vpiRealFunc;
      tf_data.calltf      = sys_realtime_calltf;
      tf_data.compiletf   = sys_no_arg_compiletf;
      tf_data.sizetf      = 0;
      tf_data.user_data   = "$abstime";
      res = vpi_register_systf(&tf_data);
      vpip_make_systf_system_defined(res);
}
Beispiel #8
0
/*
 * Routine to register the system function provided in this file.
 */
void table_model_register()
{
      s_vpi_systf_data tf_data;
      s_cb_data cb;
      vpiHandle res;

      tf_data.type = vpiSysFunc;
      tf_data.sysfunctype = vpiSysFuncReal;
      tf_data.tfname = "$table_model";
      tf_data.calltf = sys_table_model_calltf;
      tf_data.compiletf = sys_table_model_compiletf;
      tf_data.sizetf = 0;  /* Not needed for a vpiSysFuncReal. */
      tf_data.user_data = "$table_model";
      res = vpi_register_systf(&tf_data);
      vpip_make_systf_system_defined(res);

	/* Create a callback to clear all the table model memory when the
	 * simulator finishes. */
      cb.time = NULL;
      cb.reason = cbEndOfSimulation;
      cb.cb_rtn = cleanup_table_mod;
      cb.user_data = 0x0;
      cb.obj = 0x0;

      vpi_register_cb(&cb);
}
Beispiel #9
0
/* Associate C function with new system tesk */
void registerHelloSystfs()
{
  /* To associate your C function with a system task,
   * create a data structure of type s_vpi_systf_data
   * and a pointer to that structure.
   */
  s_vpi_systf_data task_data_s;

  /* task - does not return a value; function - can return a value.
   *  vpiSysTask, vpiSysFunc
   */
  task_data_s.type = vpiSysTask;
  /* If type is function, sysfunctype indicates
   * the type of the value that the calltf function returns.
   *  vpiSysTask, vpi[Int,Real,Time,Sized, SizedSigned]Func
   */
  task_data_s.sysfunctype = vpiSysTask;
  /* This quoted literal string defines the name of the system task or function.
   * The first character must be $.
   */
  task_data_s.tfname = "$hello";
  /* This field is a pointer to your application routine
   */
  task_data_s.calltf = hello;
  /* This field is a pointer to a routine that the simulator calls once
   * each time it compiles an instance of the task or function.
   * Enter NULL if you have no such routine.
   */
  task_data_s.compiletf = 0;

  vpi_register_systf(&task_data_s);
}
Beispiel #10
0
static void xxx_register()
{
  s_vpi_systf_data      tfdata;

  vpi_printf("+++ in XXX_REGISTER\n");

  tfdata.type           = vpiSysFunc;

  /*
   * TOM: sysfunctype field seems to be problematic for different simulators!
   *  some simulators simply don't register callback if subtype missing.
   *
   * Icarus - doesn't implement vpiSizedFunc, so use vpiIntFunct.
   * CVER - use vpiIntFunc
   * MTI - use vpiSizedFunc or vpiIntFunc.
   * XL/NC - doesn't matter
   * VCS - doesn't matter
   *
   */

  tfdata.sysfunctype    = vpiIntFunc;
  /* tfdata.sysfunctype    = vpiSizedFunc; */

  tfdata.tfname         = "$example";
  tfdata.calltf         = xxx_calltf;
  tfdata.compiletf      = xxx_compiletf;
  /* tfdata.sizetf         = xxx_sizetf; */
  tfdata.sizetf         = 0;
  tfdata.user_data      = 0;

  vpi_register_systf(&tfdata);
  chkvpierr();
}
Beispiel #11
0
static void vhdl_register(void)
{
      s_vpi_systf_data tf_data;
      s_cb_data cb;
      vpiHandle res;

      tf_data.type         = vpiSysFunc;
      tf_data.sysfunctype  = vpiSizedFunc;
      tf_data.calltf       = ivlh_attribute_event_calltf;
      tf_data.compiletf    = ivlh_attribute_event_compiletf;
      tf_data.sizetf       = ivlh_attribute_event_sizetf;
      tf_data.tfname       = func_names[EVENT];
      tf_data.user_data    = (PLI_BYTE8*) EVENT;
      res = vpi_register_systf(&tf_data);
      vpip_make_systf_system_defined(res);

      tf_data.type         = vpiSysFunc;
      tf_data.sysfunctype  = vpiSizedFunc;
      tf_data.calltf       = ivlh_attribute_event_calltf;
      tf_data.compiletf    = ivlh_attribute_event_compiletf;
      tf_data.sizetf       = ivlh_attribute_event_sizetf;
      tf_data.tfname       = func_names[RISING_EDGE];
      tf_data.user_data    = (PLI_BYTE8*) RISING_EDGE;
      res = vpi_register_systf(&tf_data);
      vpip_make_systf_system_defined(res);

      tf_data.type         = vpiSysFunc;
      tf_data.sysfunctype  = vpiSizedFunc;
      tf_data.calltf       = ivlh_attribute_event_calltf;
      tf_data.compiletf    = ivlh_attribute_event_compiletf;
      tf_data.sizetf       = ivlh_attribute_event_sizetf;
      tf_data.tfname       = func_names[FALLING_EDGE];
      tf_data.user_data    = (PLI_BYTE8*) FALLING_EDGE;
      res = vpi_register_systf(&tf_data);
      vpip_make_systf_system_defined(res);

	/* Create a callback to clear the monitor data memory when the
	 * simulator finishes. */
      cb.time = NULL;
      cb.reason = cbEndOfSimulation;
      cb.cb_rtn = cleanup_mdata;
      cb.user_data = NULL;
      cb.obj = NULL;

      vpi_register_cb(&cb);
}
Beispiel #12
0
static void test_array_register(void)
{
      s_vpi_systf_data tf_data;

      tf_data.type      = vpiSysTask;
      tf_data.tfname    = "$display_array";
      tf_data.calltf    = display_array_calltf;
      tf_data.compiletf = one_arg_array_compiletf;
      tf_data.sizetf    = 0;
      vpi_register_systf(&tf_data);

      tf_data.type      = vpiSysTask;
      tf_data.tfname    = "$increase_array_vals";
      tf_data.calltf    = increase_array_vals_calltf;
      tf_data.compiletf = one_arg_array_compiletf;
      tf_data.sizetf    = 0;
      vpi_register_systf(&tf_data);
}
void sys_vcdoff_register()
{
      s_vpi_systf_data tf_data;

      tf_data.type      = vpiSysTask;
      tf_data.tfname    = "$dumpall";
      tf_data.calltf    = sys_dumpall_calltf;
      tf_data.compiletf = 0;
      tf_data.sizetf    = 0;
      tf_data.user_data = "$dumpall";
      vpi_register_systf(&tf_data);

      tf_data.type      = vpiSysTask;
      tf_data.tfname    = "$dumpoff";
      tf_data.calltf    = sys_dumpoff_calltf;
      tf_data.compiletf = 0;
      tf_data.sizetf    = 0;
      tf_data.user_data = "$dumpoff";
      vpi_register_systf(&tf_data);

      tf_data.type      = vpiSysTask;
      tf_data.tfname    = "$dumpon";
      tf_data.calltf    = sys_dumpon_calltf;
      tf_data.compiletf = 0;
      tf_data.sizetf    = 0;
      tf_data.user_data = "$dumpon";
      vpi_register_systf(&tf_data);

      tf_data.type      = vpiSysTask;
      tf_data.tfname    = "$dumpfile";
      tf_data.calltf    = sys_dumpfile_calltf;
      tf_data.compiletf = 0;
      tf_data.sizetf    = 0;
      tf_data.user_data = "$dumpfile";
      vpi_register_systf(&tf_data);

      tf_data.type      = vpiSysTask;
      tf_data.tfname    = "$dumpvars";
      tf_data.calltf    = sys_dumpvars_calltf;
      tf_data.compiletf = sys_vcd_dumpvars_compiletf;
      tf_data.sizetf    = 0;
      tf_data.user_data = "$dumpvars";
      vpi_register_systf(&tf_data);
}
Beispiel #14
0
void terminal_register(){
	s_vpi_systf_data tf_data;
	tf_data.type		= vpiSysTask;
	tf_data.tfname		= "$terminal";
	tf_data.calltf		= terminal_calltf;
	tf_data.compiletf	= terminal_compiletf;
	tf_data.sizetf		= 0;
	tf_data.user_data	= 0;
	vpi_register_systf(&tf_data);
}
Beispiel #15
0
/*
 * Register all the functions with Verilog.
 */
static void va_math_register(void)
{
    s_cb_data cb_data;
    s_vpi_systf_data tf_data;
    vpiHandle res;
    unsigned idx;

    /* Register the single argument functions. */
    tf_data.type        = vpiSysFunc;
    tf_data.sysfunctype = vpiRealFunc;
    tf_data.calltf      = va_single_argument_calltf;
    tf_data.compiletf   = va_single_argument_compiletf;
    tf_data.sizetf      = 0;

    for (idx=0; va_single_data[idx].name != 0; idx++) {
        tf_data.tfname    = va_single_data[idx].name;
        tf_data.user_data = (PLI_BYTE8 *) &va_single_data[idx];
        res = vpi_register_systf(&tf_data);
        vpip_make_systf_system_defined(res);
    }

    /* Register the double argument functions. */
    tf_data.type        = vpiSysFunc;
    tf_data.sysfunctype = vpiRealFunc;
    tf_data.calltf      = va_double_argument_calltf;
    tf_data.compiletf   = va_double_argument_compiletf;
    tf_data.sizetf      = 0;

    for (idx=0; va_double_data[idx].name != 0; idx++) {
        tf_data.tfname    = va_double_data[idx].name;
        tf_data.user_data = (PLI_BYTE8 *) &va_double_data[idx];
        res = vpi_register_systf(&tf_data);
        vpip_make_systf_system_defined(res);
    }

    /* We need to clean up the userdata. */
    cb_data.reason = cbEndOfSimulation;
    cb_data.time = 0;
    cb_data.cb_rtn = sys_end_of_simulation;
    cb_data.user_data = "system";
    vpi_register_cb(&cb_data);
}
Beispiel #16
0
void register_vpi_input_str() {
	s_vpi_systf_data systf;
	systf.type = vpiSysFunc;				//sysfunc 일시			//잠시 수정	sysFunc => inttask
	systf.sysfunctype = vpiIntFunc;			//func의 return type	//잠시 수정 IntFunc =>
	systf.tfname = "$vpi_input_str";
	systf.compiletf = 0; // func ptr not used should be initialized to NULL
	systf.sizetf = 0; // func ptr not used should be initialized to NULL
	systf.user_data = 0; // func ptr not used should be initialized to NULL
	systf.calltf = vpi_input_str;
	vpi_register_systf(&systf);
}
Beispiel #17
0
static void Register(void)
{
	s_vpi_systf_data tf_data;

	tf_data.type = vpiSysTask;
	tf_data.tfname = "$test";
	tf_data.calltf = 0;
	tf_data.compiletf = CompileTF;
	tf_data.sizetf = 0;
	vpi_register_systf(&tf_data);
}
Beispiel #18
0
void register_vpi_test_read() {
	s_vpi_systf_data systf;
	systf.type = vpiSysFunc;
	systf.sysfunctype = vpiIntFunc;
	systf.tfname = "$vpi_test_read";
	systf.compiletf = 0; // func ptr not used should be initialized to NULL
	systf.sizetf = 0; // func ptr not used should be initialized to NULL
	systf.user_data = 0; // func ptr not used should be initialized to NULL
	systf.calltf = vpi_test_read;
	vpi_register_systf(&systf);
}
Beispiel #19
0
static void my_watchreal_register()
{
      s_vpi_systf_data tf_data;

      tf_data.type      = vpiSysTask;
      tf_data.tfname    = "$my_watchreal";
      tf_data.calltf    = my_watchreal_calltf;
      tf_data.compiletf = 0;
      tf_data.sizetf    = 0;
      vpi_register_systf(&tf_data);
}
Beispiel #20
0
static void my_hello_register(void)
{
      s_vpi_systf_data tf_data;

      tf_data.type      = vpiSysTask;
      tf_data.tfname    = "$hello_poke";
      tf_data.calltf    = my_hello_calltf;
      tf_data.compiletf = 0;
      tf_data.sizetf    = 0;
      vpi_register_systf(&tf_data);
}
Beispiel #21
0
void v2009_enum_register(void)
{
      s_vpi_systf_data tf_data;

      tf_data.type        = vpiSysFunc;
      tf_data.calltf      = ivl_method_next_calltf;
      tf_data.compiletf   = ivl_method_next_prev_compiletf;
      tf_data.sizetf      = 0;
      tf_data.tfname      = "$ivl_method$next";
      tf_data.user_data   = "$ivl_method$next";
      vpi_register_systf(&tf_data);

      tf_data.type        = vpiSysFunc;
      tf_data.calltf      = ivl_method_prev_calltf;
      tf_data.compiletf   = 0;
      tf_data.sizetf      = 0;
      tf_data.tfname      = "$ivl_method$prev";
      tf_data.user_data   = "$ivl_method$prev";
      vpi_register_systf(&tf_data);
}
void sys_random_register()
{
      s_vpi_systf_data tf_data;

      tf_data.type   = vpiSysFunc;
      tf_data.tfname = "$random";
      tf_data.calltf = sys_random_calltf;
      tf_data.compiletf = 0;
      tf_data.sizetf = sys_random_sizetf;
      tf_data.user_data = "$random";
      vpi_register_systf(&tf_data);

      tf_data.type   = vpiSysFunc;
      tf_data.tfname = "$dist_uniform";
      tf_data.calltf = sys_dist_uniform_calltf;
      tf_data.compiletf = 0;
      tf_data.sizetf = sys_dist_uniform_sizetf;
      tf_data.user_data = "$dist_uniform";
      vpi_register_systf(&tf_data);
}
Beispiel #23
0
void sys_convert_register(void)
{
      s_vpi_systf_data tf_data;
      vpiHandle res;

      tf_data.type      = vpiSysFunc;
      tf_data.user_data = "$bitstoreal";
      tf_data.tfname    = tf_data.user_data;
      tf_data.sizetf    = sizetf_64;
      tf_data.compiletf = sys_convert_compiletf;
      tf_data.calltf    = sys_bitstoreal_calltf;
      res = vpi_register_systf(&tf_data);
      vpip_make_systf_system_defined(res);

      tf_data.type      = vpiSysFunc;
      tf_data.user_data = "$itor";
      tf_data.tfname    = tf_data.user_data;
      tf_data.sizetf    = sizetf_64;
      tf_data.compiletf = sys_convert_compiletf;
      tf_data.calltf    = sys_itor_calltf;
      res = vpi_register_systf(&tf_data);
      vpip_make_systf_system_defined(res);

      tf_data.type      = vpiSysFunc;
      tf_data.user_data = "$realtobits";
      tf_data.tfname    = tf_data.user_data;
      tf_data.sizetf    = sizetf_64;
      tf_data.compiletf = sys_convert_compiletf;
      tf_data.calltf    = sys_realtobits_calltf;
      res = vpi_register_systf(&tf_data);
      vpip_make_systf_system_defined(res);

      tf_data.type      = vpiSysFunc;
      tf_data.user_data = "$rtoi";
      tf_data.tfname    = tf_data.user_data;
      tf_data.sizetf    = sizetf_32;
      tf_data.compiletf = sys_convert_compiletf;
      tf_data.calltf    = sys_rtoi_calltf;
      res = vpi_register_systf(&tf_data);
      vpip_make_systf_system_defined(res);
}
Beispiel #24
0
// Associate C Function with a New System Function
void checkRetireInst_register() {
  s_vpi_systf_data task_data_s;

  task_data_s.type      = vpiSysTask;
  //task_data_s.sysfunctype = vpiSysFuncSized;
  task_data_s.tfname    = "$checkRetireInst";
  task_data_s.calltf    = checkRetireInst_calltf;
  task_data_s.compiletf = 0;
  //task_data_s.sizetf    = readInst_sizetf;

  vpi_register_systf(&task_data_s);
}
Beispiel #25
0
static void poke_after_delay_register(void)
{
      s_vpi_systf_data tf_data;

      tf_data.type      = vpiSysTask;
      tf_data.tfname    = "$poke_at_simtime";
      tf_data.calltf    = poke_calltf;
      tf_data.compiletf = poke_compiletf;
      tf_data.sizetf    = 0;
      vpi_register_systf(&tf_data);

}
Beispiel #26
0
void hello_register()
{
    s_vpi_systf_data tf_data;
    tf_data.type=vpi SystTask;
    tf_data.tfname=$hello;
    tf_data.calltf=hello_calltf;
    tf_data.compiletf=hello.compiletf;
    tf_data.sizetf=0;
    tf_data.userdata=0;
    vpi_register_systf(& tf_data);

}
Beispiel #27
0
static void vpi_register(void)
{
    s_vpi_systf_data tf_data;

    tf_data.type = vpiSysTask;
    tf_data.tfname = "$is_cell";
    tf_data.calltf = calltf;
    tf_data.compiletf = 0;
    tf_data.sizetf = 0;

    vpi_register_systf(&tf_data);
}
Beispiel #28
0
// Associate C Function with a New System Function
void readWord_register() {
  s_vpi_systf_data task_data_s;

  task_data_s.type      = vpiSysFunc;
  //task_data_s.sysfunctype = vpiSysFuncSized;
  task_data_s.tfname    = "$readWord";
  task_data_s.calltf    = readWord_calltf;
  task_data_s.compiletf = 0;
  //task_data_s.sizetf    = readInst_sizetf;

  vpi_register_systf(&task_data_s);
}
Beispiel #29
0
void sys_sdf_register()
{
      s_vpi_systf_data tf_data;

      tf_data.type      = vpiSysTask;
      tf_data.tfname    = "$sdf_annotate";
      tf_data.calltf    = sys_sdf_annotate_calltf;
      tf_data.compiletf = sys_sdf_annotate_compiletf;
      tf_data.sizetf    = 0;
      tf_data.user_data = "$sdf_annotate";
      vpi_register_systf(&tf_data);
}
void zeroall_register() {
	s_vpi_systf_data tf_data;

	tf_data.type      = vpiSysTask;
	tf_data.tfname    = "$zeroall";
	tf_data.calltf    = zeroall_call;
	tf_data.compiletf = zeroall_compile;

	vpi_register_systf(&tf_data);

	vpi_printf("VPI module verilog-zeroall registered\n");
}