/* * Given a path, look the path name up using the PLI, * and set it to 'value'. */ static int uvm_hdl_set_vlog(char *path, p_vpi_vecval value, PLI_INT32 flag) { static int maxsize = -1; vpiHandle r; s_vpi_value value_s = { vpiIntVal, { 0 } }; s_vpi_time time_s = { vpiSimTime, 0, 0, 0.0 }; //vpi_printf("uvm_hdl_set_vlog(%s,%0x)\n",path,value[0].aval); #ifdef QUESTA int result = 0; result = uvm_hdl_set_vlog_partsel(path,value,flag); if (result < 0) return 0; if (result == 1) return 1; if (!strncmp(path,"$root.",6)) r = vpi_handle_by_name(path+6, 0); else #endif r = vpi_handle_by_name(path, 0); if(r == 0) { vpi_printf((PLI_BYTE8*) "UVM_ERROR: set: unable to locate hdl path (%s)\n",path); vpi_printf((PLI_BYTE8*) " Either the name is incorrect, or you may not have PLI/ACC visibility to that name\n"); return 0; } else { if(maxsize == -1) maxsize = uvm_hdl_max_width(); if (flag == vpiReleaseFlag) { //size = vpi_get(vpiSize, r); //value_p = (p_vpi_vecval)(malloc(((size-1)/32+1)*8*sizeof(s_vpi_vecval))); //value = &value_p; } value_s.format = vpiVectorVal; value_s.value.vector = value; vpi_put_value(r, &value_s, &time_s, flag); //if (value_p != NULL) // free(value_p); if (value == NULL) { value = value_s.value.vector; } } #ifndef VCS //vpi_release_handle(r); #endif return 1; }
int _mon_check_quad() { VlVpiHandle vh2 = vpi_handle_by_name((PLI_BYTE8*)"t.quads", NULL); CHECK_RESULT_NZ(vh2); s_vpi_value v; t_vpi_vecval vv[2]; bzero(&vv,sizeof(vv)); s_vpi_time t; t.type = vpiSimTime; t.high = 0; t.low = 0; VlVpiHandle vhidx2 = vpi_handle_by_index(vh2, 2); CHECK_RESULT_NZ(vhidx2); VlVpiHandle vhidx3 = vpi_handle_by_index(vh2, 3); CHECK_RESULT_NZ(vhidx2); v.format = vpiVectorVal; v.value.vector = vv; v.value.vector[1].aval = 0x12819213UL; v.value.vector[0].aval = 0xabd31a1cUL; vpi_put_value(vhidx2, &v, &t, vpiNoDelay); v.format = vpiVectorVal; v.value.vector = vv; v.value.vector[1].aval = 0x1c77bb9bUL; v.value.vector[0].aval = 0x3784ea09UL; vpi_put_value(vhidx3, &v, &t, vpiNoDelay); vpi_get_value(vhidx2, &v); CHECK_RESULT(v.value.vector[1].aval, 0x12819213UL); CHECK_RESULT(v.value.vector[1].bval, 0); vpi_get_value(vhidx3, &v); CHECK_RESULT(v.value.vector[1].aval, 0x1c77bb9bUL); CHECK_RESULT(v.value.vector[1].bval, 0); return 0; }
static void set_handle_to_value(vpiHandle sig, const char*val) { size_t width = strlen(val); size_t vv_count = (width+31)/32; s_vpi_value value; value.value.vector = calloc(vv_count, sizeof(s_vpi_vecval)); int idx; for (idx = 0 ; idx < width ; idx += 1) { int word = idx / 32; int bit = idx % 32; char src = val[width-idx-1]; PLI_INT32 amask = 0; PLI_INT32 bmask = 0; switch (src) { case '0': continue; case '1': amask = 1; bmask = 0; break; case 'x': amask = 1; bmask = 1; break; case 'z': amask = 0; bmask = 1; break; } s_vpi_vecval*vp = value.value.vector+word; vp->aval |= amask << bit; vp->bval |= bmask << bit; } if (vpi_get(vpiSize, sig) != width) { vpi_printf("ERROR: %s is %d bits, got %zu from server\n", vpi_get_str(vpiName, sig), vpi_get(vpiSize, sig), width); vpi_flush(); } assert(vpi_get(vpiSize, sig) == width); assert(vpi_get(vpiType, sig) == vpiReg); value.format = vpiVectorVal; vpi_put_value(sig, &value, 0, vpiNoDelay); free(value.value.vector); }
static PLI_INT32 sys_fopenrwa_calltf(PLI_BYTE8*name) { vpiHandle callh = vpi_handle(vpiSysTfCall, 0); vpiHandle argv = vpi_iterate(vpiArgument, callh); vpiHandle file = vpi_scan(argv); s_vpi_value val; char *mode; unsigned idx, len; vpi_free_object(argv); /* Get the mode. */ mode = name + strlen(name) - 1; /* Get the filename. */ val.format = vpiStringVal; vpi_get_value(file, &val); /* Verify that we have a string and that it is not NULL. */ if (val.format != vpiStringVal || !*(val.value.str)) { vpi_printf("WARNING: %s:%d: ", vpi_get_str(vpiFile, callh), (int)vpi_get(vpiLineNo, callh)); vpi_printf("%s's file name argument is not a valid string.\n", name); return 0; } /* * Verify that the file name is composed of only printable * characters. */ len = strlen(val.value.str); for (idx = 0; idx < len; idx++) { if (! isprint(val.value.str[idx])) { char msg [64]; snprintf(msg, 64, "WARNING: %s:%d:", vpi_get_str(vpiFile, callh), (int)vpi_get(vpiLineNo, callh)); vpi_printf("%s %s's file name argument contains non-" "printable characters.\n", msg, name); vpi_printf("%*s \"%s\"\n", (int) strlen(msg), " ", val.value.str); return 0; } } /* Open the file and return the result. */ val.format = vpiIntVal; val.value.integer = vpi_fopen(val.value.str, mode); vpi_put_value(callh, &val, 0, vpiNoDelay); return 0; }
void set_arg_int(const s_riscyArg *const arg, const int value, const int offset, const int zero_at) { s_vpi_value value_s; s_vpi_time time_s; value_s.format = vpiIntVal; time_s.type = vpiScaledRealTime; value_s.value.integer = value; if (!offset) { vpi_put_value(arg->handle, &value_s, NULL, vpiNoDelay); } else { time_s.real = offset; vpi_put_value(arg->handle, &value_s, &time_s, vpiInertialDelay); } if (zero_at) { time_s.real = zero_at; value_s.value.integer = 0; vpi_put_value(arg->handle, &value_s, &time_s, vpiInertialDelay); } }
/* * set a handle to a real value * * user must make sure href can have have a value put into it * notice the key to vpi_ processing is to save and pass handles */ static void vpiset_to_real(vpiHandle href, double d1) { struct t_vpi_value valrec; struct t_vpi_error_info einfotab; valrec.format = vpiRealVal; valrec.value.real = d1; vpi_put_value(href, &valrec, NULL, vpiNoDelay); if (vpi_chk_error(&einfotab)) { vpi_printf("** ERR: vpi_put_value of real error:\n"); prtvpiemsg(&einfotab); } }
static PLI_INT32 sys_mti_dist_uniform_calltf(ICARUS_VPI_CONST PLI_BYTE8*name) { vpiHandle callh, argv, seed, start, end; s_vpi_value val; long i_seed, i_start, i_end; (void)name; /* Parameter is not used. */ /* Get the argument handles and convert them. */ callh = vpi_handle(vpiSysTfCall, 0); argv = vpi_iterate(vpiArgument, callh); seed = vpi_scan(argv); start = vpi_scan(argv); end = vpi_scan(argv); val.format = vpiIntVal; vpi_get_value(seed, &val); i_seed = val.value.integer; vpi_get_value(start, &val); i_start = val.value.integer; vpi_get_value(end, &val); i_end = val.value.integer; /* Calculate and return the result. */ val.value.integer = mti_dist_uniform(&i_seed, i_start, i_end); vpi_put_value(callh, &val, 0, vpiNoDelay); /* Return the seed. */ val.value.integer = i_seed; vpi_put_value(seed, &val, 0, vpiNoDelay); vpi_free_object(argv); return 0; }
static PLI_INT32 simbus_poll_calltf(char*my_name) { int poll_state; s_vpi_value value; vpiHandle sys = vpi_handle(vpiSysTfCall, 0); vpiHandle argv = vpi_iterate(vpiArgument, sys); vpiHandle bus_h = vpi_scan(argv); assert(bus_h); value.format = vpiIntVal; vpi_get_value(bus_h, &value); int bus = value.value.integer; assert(bus >= 0 && bus < MAX_INSTANCES); vpiHandle trig = vpi_scan(argv); assert(trig); vpi_free_object(argv); DEBUG(SIMBUS_DEBUG_CALLS, "Call $poll(%d...)\n", bus); poll_state = check_readable(bus); value.format = vpiScalarVal; value.value.scalar = poll_state? vpi1 : vpi0; vpi_put_value(trig, &value, 0, vpiNoDelay); if (poll_state == 0) { struct t_cb_data cb_data; struct t_vpi_time cb_time; cb_time.type = vpiSuppressTime; cb_data.reason = cbReadWriteSynch; cb_data.cb_rtn = poll_for_simbus_bus; cb_data.time = &cb_time; vpi_register_cb(&cb_data); instance_table[bus].trig = trig; } else { instance_table[bus].trig = 0; } DEBUG(SIMBUS_DEBUG_CALLS, "return $poll(%d...)\n", bus); return 0; }
static PLI_INT32 ivl_method_prev_calltf(PLI_BYTE8*data) { vpiHandle sys = vpi_handle(vpiSysTfCall, 0); vpiHandle argv = vpi_iterate(vpiArgument, sys); vpiHandle arg_enum = vpi_scan(argv); vpiHandle arg_item = vpi_scan(argv); vpiHandle arg_extra = vpi_scan(argv); vpiHandle enum_list = 0; vpiHandle memb = 0, prev = 0, last_memb = 0; int use_wid = 0; s_vpi_value memb_value, item_value; assert(arg_extra == 0); item_value.format = vpiIntVal; vpi_get_value(arg_item, &item_value); enum_list = vpi_iterate(vpiMember, arg_enum); assert(enum_list); /* Search for the current value in the member list. */ do { prev = memb; memb = vpi_scan(enum_list); if (memb == 0) break; if (use_wid == 0) use_wid = vpi_get(vpiSize, memb); last_memb = memb; memb_value.format = vpiIntVal; vpi_get_value(memb, &memb_value); } while (! compare_value_eequal(&memb_value, &item_value, use_wid)); while (memb) { last_memb = memb; memb = vpi_scan(enum_list); } if (prev == 0) prev = last_memb; vpi_get_value(prev, &memb_value); vpi_put_value(sys, &memb_value, 0, vpiNoDelay); return 0; }
int VpiSignalObjHdl::set_signal_value(std::string &value) { FENTER s_vpi_value value_s; std::vector<char> writable(value.begin(), value.end()); writable.push_back('\0'); value_s.value.str = &writable[0]; value_s.format = vpiBinStrVal; vpi_put_value(GpiObjHdl::get_handle<vpiHandle>(), &value_s, NULL, vpiNoDelay); check_vpi_error(); FEXIT return 0; }
static int sys_fgetc_calltf(char *name) { unsigned int mcd; int type; s_vpi_value value, rval; vpiHandle sys = vpi_handle(vpiSysTfCall, 0); vpiHandle argv = vpi_iterate(vpiArgument, sys); vpiHandle item = vpi_scan(argv); FILE *fp; if (item == 0) { vpi_printf("%s: mcd parameter missing.\n", name); return 0; } type = vpi_get(vpiType, item); switch (type) { case vpiReg: case vpiRealVal: case vpiIntegerVar: break; default: vpi_printf("ERROR: %s mcd parameter must be of integral", name); vpi_printf(", got vpiType=%d\n", type); vpi_free_object(argv); return 0; } value.format = vpiIntVal; vpi_get_value(item, &value); mcd = value.value.integer; rval.format = vpiIntVal; fp = vpi_get_file(mcd); if (!fp || IS_MCD(mcd)) rval.value.integer = EOF; else rval.value.integer = fgetc(fp); vpi_put_value(sys, &rval, 0, vpiNoDelay); return 0; }
/* * Compare the +arguments passed to the simulator with the argument * passed to the $test$plusargs. If there is a simulator argument that * is like this argument, then return true. Otherwise return false. */ static PLI_INT32 sys_test_plusargs_calltf(ICARUS_VPI_CONST PLI_BYTE8*name) { s_vpi_value val; s_vpi_vlog_info info; int idx; int flag = 0; size_t slen, len; (void)name; /* Parameter is not used. */ vpiHandle callh = vpi_handle(vpiSysTfCall, 0); vpiHandle argv = vpi_iterate(vpiArgument, callh); val.format = vpiStringVal; vpi_get_value(vpi_scan(argv), &val); slen = strlen(val.value.str); vpi_get_vlog_info(&info); /* Look for a +arg that matches the prefix supplied. */ for (idx = 0 ; idx < info.argc ; idx += 1) { /* Skip arguments that are not +args. */ if (info.argv[idx][0] != '+') continue; len = strlen(info.argv[idx]+1); if (len < slen) continue; if (strncmp(val.value.str, info.argv[idx]+1, slen) != 0) continue; flag = 1; break; } val.format = vpiIntVal; val.value.integer = flag; vpi_put_value(callh, &val, 0, vpiNoDelay); vpi_free_object(argv); return 0; }
static PLI_INT32 sys_fputc_calltf(PLI_BYTE8*name) { vpiHandle callh = vpi_handle(vpiSysTfCall, 0); vpiHandle argv = vpi_iterate(vpiArgument, callh); vpiHandle arg; s_vpi_value val; PLI_UINT32 fd_mcd; FILE *fp; unsigned char chr; errno = 0; /* Get the character. */ arg = vpi_scan(argv); val.format = vpiIntVal; vpi_get_value(arg, &val); chr = val.value.integer; /* Get the file/MC descriptor. */ arg = vpi_scan(argv); vpi_free_object(argv); val.format = vpiIntVal; vpi_get_value(arg, &val); fd_mcd = val.value.integer; /* Put the character and return the result. */ fp = vpi_get_file(fd_mcd); val.format = vpiIntVal; if (!fp) { vpi_printf("WARNING: %s:%d: ", vpi_get_str(vpiFile, callh), (int)vpi_get(vpiLineNo, callh)); vpi_printf("invalid file descriptor (0x%x) given to %s.\n", (unsigned int)fd_mcd, name); errno = EBADF; val.value.integer = EOF; } else { val.value.integer = fputc(chr, fp); if (val.value.integer != EOF) val.value.integer = 0; } vpi_put_value(callh, &val, 0, vpiNoDelay); return 0; }
static int terminal_calltf(char* user_data){ QList<quint64> val; // retrieve signal values { vpiHandle funchandle; vpiHandle arghandle; vpiHandle arg; t_vpi_value argval; funchandle = vpi_handle(vpiSysTfCall, NULL); arghandle = vpi_iterate(vpiArgument, funchandle); while(arg = vpi_scan(arghandle)){ argval.format = vpiIntVal; vpi_get_value(arg, &argval); val.append(argval.value.integer); } } // get new values procpoll(val); // assert new signal values { vpiHandle funchandle; vpiHandle arghandle; vpiHandle arg; t_vpi_value argval; funchandle = vpi_handle(vpiSysTfCall, NULL); arghandle = vpi_iterate(vpiArgument, funchandle); for(int i=0; (i<val.length()) && (arg = vpi_scan(arghandle)); ++i){ argval.format = vpiIntVal; argval.value.integer = val[i]; vpi_put_value(arg, &argval, NULL,vpiNoDelay); } } return 0; }
static PLI_INT32 sys_deposit_calltf(ICARUS_VPI_CONST PLI_BYTE8 *name) { vpiHandle callh, argv, target, value; s_vpi_value val; callh = vpi_handle(vpiSysTfCall, 0); argv = vpi_iterate(vpiArgument, callh); target = vpi_scan(argv); assert(target); value = vpi_scan(argv); assert(value); val.format = vpiIntVal; vpi_get_value(value, &val); vpi_put_value(target, &val, 0, vpiNoDelay); vpi_free_object(argv); return 0; }
static PLI_INT32 sys_clog2_calltf(PLI_BYTE8 *name) { vpiHandle callh = vpi_handle(vpiSysTfCall, 0); vpiHandle argv = vpi_iterate(vpiArgument, callh); vpiHandle arg; s_vpi_value val; s_vpi_vecval vec; (void) name; /* Not used! */ /* Get the argument. */ arg = vpi_scan(argv); vpi_free_object(argv); vec = vpip_calc_clog2(arg); val.format = vpiVectorVal; val.value.vector = &vec; vpi_put_value(callh, &val, 0, vpiNoDelay); return 0; }
int VpiSignalObjHdl::set_signal_value(double value) { FENTER s_vpi_value value_s; value_s.value.real = value; value_s.format = vpiRealVal; s_vpi_time vpi_time_s; vpi_time_s.type = vpiSimTime; vpi_time_s.high = 0; vpi_time_s.low = 0; vpi_put_value(GpiObjHdl::get_handle<vpiHandle>(), &value_s, &vpi_time_s, vpiInertialDelay); check_vpi_error(); FEXIT return 0; }
static PLI_INT32 sys_itor_calltf(ICARUS_VPI_CONST PLI_BYTE8*name) { vpiHandle callh = vpi_handle(vpiSysTfCall, 0); vpiHandle arg = (vpiHandle) vpi_get_userdata(callh); s_vpi_value value; (void)name; /* Parameter is not used. */ /* get value */ value.format = vpiIntVal; vpi_get_value(arg, &value); /* convert */ value.value.real = value.value.integer; value.format = vpiRealVal; /* return converted value */ vpi_put_value(callh, &value, 0, vpiNoDelay); return 0; }
// Value related functions int VpiSignalObjHdl::set_signal_value(long value) { FENTER s_vpi_value value_s; value_s.value.integer = value; value_s.format = vpiIntVal; s_vpi_time vpi_time_s; vpi_time_s.type = vpiSimTime; vpi_time_s.high = 0; vpi_time_s.low = 0; // Use Inertial delay to schedule an event, thus behaving like a verilog testbench vpi_put_value(GpiObjHdl::get_handle<vpiHandle>(), &value_s, &vpi_time_s, vpiInertialDelay); check_vpi_error(); FEXIT return 0; }
int _mon_check_getput() { VlVpiHandle vh2 = vpi_handle_by_name((PLI_BYTE8*)"t.onebit", NULL); CHECK_RESULT_NZ(vh2); s_vpi_value v; v.format = vpiIntVal; vpi_get_value(vh2, &v); CHECK_RESULT(v.value.integer, 0); s_vpi_time t; t.type = vpiSimTime; t.high = 0; t.low = 0; v.value.integer = 1; vpi_put_value(vh2, &v, &t, vpiNoDelay); vpi_get_value(vh2, &v); CHECK_RESULT(v.value.integer, 1); return 0; }
static void reset_regs(vpiHandle module) { vpiHandle reg, i; s_vpi_value value; int size, j; char * charData; value.format = vpiBinStrVal; i = vpi_iterate(vpiReg, module); while (reg = vpi_scan(i)) { vpi_get_value(reg, &value); charData = value.value.str; size = vpi_get(vpiSize, reg); for (j = 0; j < size; j++) { if (charData[j] == 'x') { charData[j] = '0'; } } vpi_put_value(reg, &value, NULL, vpiNoDelay); } }
/* * Routine to implement the single argument math functions. */ static PLI_INT32 va_single_argument_calltf(ICARUS_VPI_CONST PLI_BYTE8 *ud) { vpiHandle callh = vpi_handle(vpiSysTfCall, 0); s_vpi_value val; va_single_t* fun_data; (void) ud; /* Not used! */ /* Retrieve the function and argument data. */ fun_data = vpi_get_userdata(callh); /* Calculate the result */ val.format = vpiRealVal; vpi_get_value(fun_data->arg, &val); val.value.real = (fun_data->func)(val.value.real); /* Return the result */ vpi_put_value(callh, &val, 0, vpiNoDelay); return 0; }
/* * Routine to return a character value (implements %c). * * Return: 1 for a match, 0 for no match/variable and -1 for a * suppressed match. No variable is fatal. */ static int scan_format_char(vpiHandle callh, vpiHandle argv, struct byte_source *src, unsigned width, unsigned suppress_flag, PLI_BYTE8 *name) { vpiHandle arg; s_vpi_value val; int ch; /* If we are being asked for no digits then return a match fail. */ if (width == 0) return 0; /* Get the character to return. */ ch = byte_getc(src); /* Nothing was matched. */ if (ch == EOF) return 0; /* If this match is being suppressed then return after consuming * the character and report that no arguments were used. */ if (suppress_flag) return -1; /* We must have a variable to put the character value into. */ arg = vpi_scan(argv); if (! arg) { vpi_printf("ERROR: %s:%d: ", vpi_get_str(vpiFile, callh), (int)vpi_get(vpiLineNo, callh)); vpi_printf("%s() ran out of variables for %%c format code.", name); vpi_control(vpiFinish, 1); return 0; } /* Put the character into the variable. */ val.format = vpiIntVal; val.value.integer = ch; vpi_put_value(arg, &val, 0, vpiNoDelay); /* We always consume one variable if it is available. */ return 1; }
static PLI_INT32 PLIbook_PowCalltf(PLI_BYTE8 *user_data) #endif { s_vpi_value value_s; vpiHandle systf_handle, arg_itr, arg_handle; PLI_INT32 base, expo; double result; (void)user_data; /* Parameter is not used. */ //vpi_printf("\n$my_pow PLI calltf function.\n\n"); systf_handle = vpi_handle(vpiSysTfCall, NULL); arg_itr = vpi_iterate(vpiArgument, systf_handle); if (arg_itr == NULL) { vpi_printf("ERROR: $my_pow failed to obtain systf arg handles\n"); return(0); } /* read base from systf arg 1 (compiletf has already verified) */ arg_handle = vpi_scan(arg_itr); value_s.format = vpiIntVal; vpi_get_value(arg_handle, &value_s); base = value_s.value.integer; /* read exponent from systf arg 2 (compiletf has already verified) */ arg_handle = vpi_scan(arg_itr); vpi_free_object(arg_itr); /* not calling scan until returns null */ vpi_get_value(arg_handle, &value_s); expo = value_s.value.integer; /* calculate result of base to power of exponent */ result = pow( (double)base, (double)expo ); /* write result to simulation as return value $my_pow */ value_s.value.integer = (PLI_INT32)result; vpi_put_value(systf_handle, &value_s, NULL, vpiNoDelay); return(0); }
/* * The pattern here is get the current vector, load the new bits on * top of the old ones and then put the modified vector. We need the * "get" first so that if we run out of bits in the file we keep the * original ones. */ static unsigned fread_word(FILE *fp, vpiHandle word, unsigned words, unsigned bpe, s_vpi_vecval *vector) { unsigned rtn, clr_mask, bnum; int bidx, byte; s_vpi_value val; struct t_vpi_vecval *cur = &vector[words-1]; rtn = 0; /* Get the current bits from the register and copy them to * my local vector. */ val.format = vpiVectorVal; vpi_get_value(word, &val); for (bidx = 0; bidx < words; bidx += 1) { vector[bidx].aval = val.value.vector[bidx].aval; vector[bidx].bval = val.value.vector[bidx].bval; } /* Copy the bytes to the local vector MSByte first. */ for (bidx = bpe-1; bidx >= 0; bidx -= 1) { byte = fgetc(fp); if (byte == EOF) break; /* Clear the current byte and load the new value. */ bnum = bidx % 4; clr_mask = ~(0xff << bnum*8); cur->aval &= clr_mask; cur->bval &= clr_mask; cur->aval |= byte << bnum*8; rtn += 1; if (bnum == 0) cur -= 1; } /* Put the updated bits into the register. */ val.value.vector = vector; vpi_put_value(word, &val, 0, vpiNoDelay); return rtn; }
/* * Routine to return a floating point value (implements %e, %f and %g). * * Return: 1 for a match, 0 for no match/variable and -1 for a * suppressed match. No variable is fatal. */ static int scan_format_float(vpiHandle callh, vpiHandle argv, struct byte_source *src, unsigned width, unsigned suppress_flag, PLI_BYTE8 *name, char code) { vpiHandle arg; int match; s_vpi_value val; double result; /* Get the real value. */ result = get_float(src, width, &match); /* Nothing was matched. */ if (match == 0) return 0; /* If this match is being suppressed then return after consuming * the digits and report that no arguments were used. */ if (suppress_flag) return -1; /* We must have a variable to put the double value into. */ arg = vpi_scan(argv); if (! arg) { vpi_printf("ERROR: %s:%d: ", vpi_get_str(vpiFile, callh), (int)vpi_get(vpiLineNo, callh)); vpi_printf("%s() ran out of variables for %%%c format code.", name, code); vpi_control(vpiFinish, 1); return 0; } /* Put the value into the variable. */ val.format = vpiRealVal; val.value.real = result; vpi_put_value(arg, &val, 0, vpiNoDelay); /* We always consume one variable if it is available. */ return 1; }
static PLI_INT32 ivlh_attribute_event_calltf(ICARUS_VPI_CONST PLI_BYTE8*data) { event_type_t type = (event_type_t) data; vpiHandle sys = vpi_handle(vpiSysTfCall, 0); struct t_vpi_value rval; struct monitor_data*mon; rval.format = vpiScalarVal; mon = (struct monitor_data*) (vpi_get_userdata(sys)); if (mon->last_event.type == 0) { rval.value.scalar = vpi0; } else { struct t_vpi_time tnow; tnow.type = vpiSimTime; vpi_get_time(0, &tnow); rval.value.scalar = vpi1; // Detect if change occured in this moment if (mon->last_event.high != tnow.high) rval.value.scalar = vpi0; if (mon->last_event.low != tnow.low) rval.value.scalar = vpi0; // Determine the edge, if required if (type == RISING_EDGE && mon->last_value.value.scalar != vpi1) rval.value.scalar = vpi0; else if (type == FALLING_EDGE && mon->last_value.value.scalar != vpi0) rval.value.scalar = vpi0; } vpi_put_value(sys, &rval, 0, vpiNoDelay); return 0; }
int readUnsignedHalf_calltf(char *user_data) { int data; vpiHandle systf_handle, arg_iterator, arg_handle, reg_handle; s_vpi_value current_value; s_vpi_value value_s; //unsigned long long instruction; /* obtain a handle to the system task instance. */ systf_handle = vpi_handle(vpiSysTfCall, 0); /* obtain handle to system task argument. */ arg_iterator = vpi_iterate(vpiArgument, systf_handle); reg_handle = vpi_scan(arg_iterator); /* free iterator memory */ vpi_free_object(arg_iterator); /* read current value */ current_value.format = vpiIntVal; /* read value as a integer */ vpi_get_value(reg_handle, ¤t_value); data = (int) VMEM[0]->read_unsigned_half(current_value.value.integer); data = (data & 0x0000FFFF); //vpi_printf("Data read \t%x\n",data); value_s.format = vpiIntVal; value_s.value.integer = data; vpi_put_value(systf_handle, &value_s, 0, vpiNoDelay); return(0); }
static PLI_INT32 EndOfCompile(s_cb_data *data) { vpiHandle hand; s_vpi_time timerec = { vpiSimTime, 0, 0, 0 }; s_vpi_value val; int i; (void)data; /* Parameter is not used. */ hand = vpi_handle_by_name("test.r", 0); assert(hand); // Get current state val.format = vpiIntVal; vpi_get_value(hand, &val); // Add a few transitions for (i = 0; i < 6; i++) { if (i < 3) { // delay 10+i time units timerec.low = 1000 * (i + 1); } else { timerec.type = vpiScaledRealTime; timerec.low = 0; timerec.real = 10000.0 * (i+1); } // Toggle state val.value.integer ^= 1; // Put new state vpi_put_value(hand, &val, &timerec, vpiPureTransportDelay); } return 0; }
int vpi_input_str(PLI_BYTE8 *d) { vpiHandle systfref, argh, argsiter; s_vpi_value v; systfref = vpi_handle(vpiSysTfCall, NULL); argsiter = vpi_iterate(vpiArgument, systfref); argh = vpi_scan(argsiter); if (!argh) { vpi_printf("$VPI: missing parameter\n"); return 0; } v.format = vpiIntVal; vpi_get_value(argh, &v); vpi_printf("VPI: %d\n", v.value.integer); // vpi_put_value(systfref, &v, NULL, vpiNoDelay); vpi_put_value(systfref, &v, NULL, vpiNoDelay); return 0; }