luke
/
iverilog
mirror of https://github.com/steveicarus/iverilog.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

vvp: array_[set/get]_word changed to __vpiArray::[set/get]_word.

This commit is contained in:
Maciej Suminski 2014-11-28 10:57:03 +01:00
parent cc4c5f4998
commit 7c77097f71
6 changed files with 119 additions and 127 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

190
vvp/array.cc
View File

@ -301,7 +301,7 @@ void __vpiArray::put_word_value(struct __vpiArrayWord*word, p_vpi_value vp, int)
{
unsigned index = word->get_index();
vvp_vector4_t val = vec4_from_vpi_value(vp, vals_width);
array_set_word(this, index, 0, val);
set_word(index, 0, val);
}
vpiHandle __vpiArray::get_iter_index(struct __vpiArrayIterator*, int idx)
@ -529,13 +529,13 @@ static void vpi_array_vthr_A_get_value(vpiHandle ref, p_vpi_value vp)
unsigned index = obj->get_address();
if (vpi_array_is_real(parent)) {
double tmp = array_get_word_r(parent, index);
double tmp = parent->get_word_r(index);
vpip_real_get_value(tmp, vp);
} else if (vpi_array_is_string(parent)) {
string tmp = array_get_word_str(parent, index);
string tmp = parent->get_word_str(index);
vpip_string_get_value(tmp, vp);
} else {
vvp_vector4_t tmp = array_get_word(parent, index);
vvp_vector4_t tmp = parent->get_word(index);
unsigned width = parent->get_word_size();
vpip_vec4_get_value(tmp, width, parent->signed_flag, vp);
}
@ -554,11 +554,11 @@ static vpiHandle vpi_array_vthr_A_put_value(vpiHandle ref, p_vpi_value vp, int)
if (vpi_array_is_real(parent)) {
double val = real_from_vpi_value(vp);
array_set_word(parent, index, val);
parent->set_word(index, val);
} else {
unsigned width = parent->get_word_size();
vvp_vector4_t val = vec4_from_vpi_value(vp, width);
array_set_word(parent, index, 0, val);
parent->set_word(index, 0, val);
}
return ref;
@ -656,128 +656,125 @@ static void vpi_array_vthr_APV_get_value(vpiHandle ref, p_vpi_value vp)
unsigned index = obj->word_sel;
if (vpi_array_is_real(parent)) {
double tmp = array_get_word_r(parent, index);
double tmp = parent->get_word_r(index);
vpip_real_get_value(tmp, vp);
} else {
vvp_vector4_t tmp = array_get_word(parent, index);
vvp_vector4_t tmp = parent->get_word(index);
tmp = tmp.subvalue(obj->part_bit, obj->part_wid);
vpip_vec4_get_value(tmp, obj->part_wid, parent->signed_flag, vp);
}
}
void array_set_word(vvp_array_t arr,
unsigned address,
unsigned part_off,
vvp_vector4_t val)
void __vpiArray::set_word(unsigned address, unsigned part_off, vvp_vector4_t val)
{
if (address >= arr->get_size())
if (address >= get_size())
return;
if (arr->vals4) {
assert(arr->nets == 0);
if (part_off != 0 || val.size() != arr->vals_width) {
vvp_vector4_t tmp = arr->vals4->get_word(address);
if (vals4) {
assert(nets == 0);
if (part_off != 0 || val.size() != vals_width) {
vvp_vector4_t tmp = vals4->get_word(address);
if ((part_off + val.size()) > tmp.size()) {
cerr << "part_off=" << part_off
<< " val.size()=" << val.size()
<< " arr->vals[address].size()=" << tmp.size()
<< " arr->vals_width=" << arr->vals_width << endl;
<< " vals[address].size()=" << tmp.size()
<< " vals_width=" << vals_width << endl;
assert(0);
}
tmp.set_vec(part_off, val);
arr->vals4->set_word(address, tmp);
vals4->set_word(address, tmp);
} else {
arr->vals4->set_word(address, val);
vals4->set_word(address, val);
}
array_word_change(arr, address);
array_word_change(this, address);
return;
}
if (arr->vals) {
assert(arr->nets == 0);
if (vals) {
assert(nets == 0);
// FIXME: For now, assume no part select of word?
assert(part_off==0);
assert(val.size() == arr->vals_width);
arr->vals->set_word(address, val);
array_word_change(arr, address);
assert(val.size() == vals_width);
vals->set_word(address, val);
array_word_change(this, address);
return;
}
assert(arr->nets != 0);
assert(nets != 0);
// Select the word of the array that we affect.
vpiHandle word = arr->nets[address];
vpiHandle word = nets[address];
struct __vpiSignal*vsig = dynamic_cast<__vpiSignal*>(word);
assert(vsig);
vsig->node->send_vec4_pv(val, part_off, val.size(), vpip_size(vsig), 0);
array_word_change(arr, address);
array_word_change(this, address);
}
void array_set_word(vvp_array_t arr, unsigned address, double val)
void __vpiArray::set_word(unsigned address, double val)
{
assert(arr->vals != 0);
assert(arr->nets == 0);
assert(vals != 0);
assert(nets == 0);
if (address >= arr->vals->get_size())
if (address >= vals->get_size())
return;
arr->vals->set_word(address, val);
array_word_change(arr, address);
vals->set_word(address, val);
array_word_change(this, address);
}
void array_set_word(vvp_array_t arr, unsigned address, const string&val)
void __vpiArray::set_word(unsigned address, const string&val)
{
assert(arr->vals != 0);
assert(arr->nets == 0);
assert(vals != 0);
assert(nets == 0);
if (address >= arr->vals->get_size())
if (address >= vals->get_size())
return;
arr->vals->set_word(address, val);
array_word_change(arr, address);
vals->set_word(address, val);
array_word_change(this, address);
}
void array_set_word(vvp_array_t arr, unsigned address, const vvp_object_t&val)
void __vpiArray::set_word(unsigned address, const vvp_object_t&val)
{
assert(arr->vals != 0);
assert(arr->nets == 0);
assert(vals != 0);
assert(nets == 0);
if (address >= arr->vals->get_size())
if (address >= vals->get_size())
return;
arr->vals->set_word(address, val);
array_word_change(arr, address);
vals->set_word(address, val);
array_word_change(this, address);
}
vvp_vector4_t array_get_word(vvp_array_t arr, unsigned address)
vvp_vector4_t __vpiArray::get_word(unsigned address)
{
if (arr->vals4) {
assert(arr->nets == 0);
assert(arr->vals == 0);
return arr->vals4->get_word(address);
if (vals4) {
assert(nets == 0);
assert(vals == 0);
return vals4->get_word(address);
}
if (arr->vals) {
assert(arr->nets == 0);
assert(arr->vals4== 0);
if (address >= arr->vals->get_size())
return vvp_vector4_t(arr->vals_width, BIT4_X);
if (vals) {
assert(nets == 0);
assert(vals4== 0);
if (address >= vals->get_size())
return vvp_vector4_t(vals_width, BIT4_X);
vvp_vector4_t val;
arr->vals->get_word(address, val);
vals->get_word(address, val);
return val;
}
assert(arr->vals4 == 0);
assert(arr->vals == 0);
assert(arr->nets != 0);
assert(vals4 == 0);
assert(vals == 0);
assert(nets != 0);
if (address >= arr->get_size()) {
if (address >= get_size()) {
// Reading outside the array. Return X's but get the
// width by looking at a word that we know is present.
assert(arr->get_size() > 0);
vpiHandle word = arr->nets[0];
assert(get_size() > 0);
vpiHandle word = nets[0];
assert(word);
struct __vpiSignal*vsig = dynamic_cast<__vpiSignal*>(word);
assert(vsig);
@ -786,7 +783,7 @@ vvp_vector4_t array_get_word(vvp_array_t arr, unsigned address)
return vvp_vector4_t(sig->value_size(), BIT4_X);
}
vpiHandle word = arr->nets[address];
vpiHandle word = nets[address];
struct __vpiSignal*vsig = dynamic_cast<__vpiSignal*>(word);
assert(vsig);
vvp_signal_value*sig = dynamic_cast<vvp_signal_value*> (vsig->node->fil);
@ -797,23 +794,23 @@ vvp_vector4_t array_get_word(vvp_array_t arr, unsigned address)
return val;
}
double array_get_word_r(vvp_array_t arr, unsigned address)
double __vpiArray::get_word_r(unsigned address)
{
if (arr->vals) {
assert(arr->vals4 == 0);
assert(arr->nets == 0);
if (vals) {
assert(vals4 == 0);
assert(nets == 0);
// In this context, address out of bounds returns 0.0
// instead of an error.
if (address >= arr->vals->get_size())
if (address >= vals->get_size())
return 0.0;
double val;
arr->vals->get_word(address, val);
vals->get_word(address, val);
return val;
}
assert(arr->nets);
vpiHandle word = arr->nets[address];
assert(nets);
vpiHandle word = nets[address];
struct __vpiRealVar*vsig = dynamic_cast<__vpiRealVar*>(word);
assert(vsig);
vvp_signal_value*sig = dynamic_cast<vvp_signal_value*> (vsig->net->fil);
@ -821,47 +818,46 @@ double array_get_word_r(vvp_array_t arr, unsigned address)
double val = sig->real_value();
return val;
}
void array_get_word_obj(vvp_array_t arr, unsigned address, vvp_object_t&val)
void __vpiArray::get_word_obj(unsigned address, vvp_object_t&val)
{
if (arr->vals) {
assert(arr->vals4 == 0);
assert(arr->nets == 0);
if (vals) {
assert(vals4 == 0);
assert(nets == 0);
// In this context, address out of bounds returns 0.0
// instead of an error.
if (address >= arr->vals->get_size()) {
if (address >= vals->get_size()) {
val = vvp_object_t();
return;
}
arr->vals->get_word(address, val);
vals->get_word(address, val);
return;
}
assert(arr->nets);
assert(nets);
// Arrays of string nets not implemented!
assert(0);
return;
}
string array_get_word_str(vvp_array_t arr, unsigned address)
string __vpiArray::get_word_str(unsigned address)
{
if (arr->vals) {
assert(arr->vals4 == 0);
assert(arr->nets == 0);
if (vals) {
assert(vals4 == 0);
assert(nets == 0);
// In this context, address out of bounds returns 0.0
// instead of an error.
if (address >= arr->vals->get_size())
if (address >= vals->get_size())
return "";
string val;
arr->vals->get_word(address, val);
vals->get_word(address, val);
return val;
}
assert(arr->nets);
assert(nets);
// Arrays of string nets not implemented!
assert(0);
return "";
@ -1181,9 +1177,9 @@ void vvp_fun_arrayport_sa::recv_vec4(vvp_net_ptr_t port, const vvp_vector4_t&bit
if (! addr_valid_flag)
addr_ = arr_->get_size();
if (vpi_array_is_real(arr_))
port.ptr()->send_real(array_get_word_r(arr_, addr_), 0);
port.ptr()->send_real(arr_->get_word_r(addr_), 0);
else
port.ptr()->send_vec4(array_get_word(arr_,addr_), 0);
port.ptr()->send_vec4(arr_->get_word(addr_), 0);
break;
@ -1198,9 +1194,9 @@ void vvp_fun_arrayport_sa::check_word_change(unsigned long addr)
if (addr != addr_) return;
if (vpi_array_is_real(arr_)) {
net_->send_real(array_get_word_r(arr_, addr_), 0);
net_->send_real(arr_->get_word_r(addr_), 0);
} else {
net_->send_vec4(array_get_word(arr_, addr_), 0);
net_->send_vec4(arr_->get_word(addr_), 0);
}
}
@ -1287,10 +1283,10 @@ void vvp_fun_arrayport_aa::recv_vec4(vvp_net_ptr_t port, const vvp_vector4_t&bit
addr_valid_flag = vector4_to_value(bit, *addr);
if (! addr_valid_flag) *addr = arr_->get_size();
if (vpi_array_is_real(arr_)) {
port.ptr()->send_real(array_get_word_r(arr_, *addr),
port.ptr()->send_real(arr_->get_word_r(*addr),
context);
} else {
port.ptr()->send_vec4(array_get_word(arr_, *addr),
port.ptr()->send_vec4(arr_->get_word(*addr),
context);
}
break;
@ -1318,9 +1314,9 @@ void vvp_fun_arrayport_aa::check_word_change_(unsigned long addr,
return;
if (vpi_array_is_real(arr_)) {
net_->send_real(array_get_word_r(arr_, addr), context);
net_->send_real(arr_->get_word_r(addr), context);
} else {
net_->send_vec4(array_get_word(arr_, addr), context);
net_->send_vec4(arr_->get_word(addr), context);
}
}

14
vvp/array.h
View File

@ -37,20 +37,6 @@ extern void array_attach_word(vvp_array_t array, unsigned addr, vpiHandle word);
extern void array_alias_word(vvp_array_t array, unsigned long addr,
vpiHandle word, int msb, int lsb);
extern void array_set_word(vvp_array_t arr, unsigned idx,
unsigned off, vvp_vector4_t val);
extern void array_set_word(vvp_array_t arr, unsigned idx,
double val);
extern void array_set_word(vvp_array_t arr, unsigned idx,
const std::string&val);
extern void array_set_word(vvp_array_t arr, unsigned idx,
const vvp_object_t&val);
extern vvp_vector4_t array_get_word(vvp_array_t array, unsigned address);
extern double array_get_word_r(vvp_array_t array, unsigned address);
extern void array_get_word_obj(vvp_array_t array, unsigned address, vvp_object_t&val);
extern std::string array_get_word_str(vvp_array_t array, unsigned address);
/* VPI hooks */
extern value_callback* vpip_array_word_change(p_cb_data data);

4
vvp/event.cc
View File

@ -137,7 +137,7 @@ evctl_array::evctl_array(vvp_array_t memory, unsigned index,
void evctl_array::run_run()
{
array_set_word(mem_, idx_, off_, value_);
mem_->set_word(idx_, off_, value_);
}
void schedule_evctl(vvp_array_t memory, unsigned index,
@ -163,7 +163,7 @@ evctl_array_r::evctl_array_r(vvp_array_t memory, unsigned index,
void evctl_array_r::run_run()
{
array_set_word(mem_, idx_, value_);
mem_->set_word(idx_, value_);
}
void schedule_evctl(vvp_array_t memory, unsigned index,

4
vvp/schedule.cc
View File

@ -306,7 +306,7 @@ struct assign_array_word_s : public event_s {
void assign_array_word_s::run_run(void)
{
count_assign_events += 1;
array_set_word(mem, adr, off, val);
mem->set_word(adr, off, val);
}
static const size_t ARRAY_W_CHUNK_COUNT = 8192 / sizeof(struct assign_array_word_s);
@ -396,7 +396,7 @@ struct assign_array_r_word_s : public event_s {
void assign_array_r_word_s::run_run(void)
{
count_assign_events += 1;
array_set_word(mem, adr, val);
mem->set_word(adr, val);
}
static const size_t ARRAY_R_W_CHUNK_COUNT = 8192 / sizeof(struct assign_array_r_word_s);
static slab_t<sizeof(assign_array_r_word_s),ARRAY_R_W_CHUNK_COUNT> array_r_w_heap;

10
vvp/vpi_priv.h
View File

@ -608,6 +608,16 @@ struct __vpiArray : public __vpiArrayBase, public __vpiHandle {
inline vpiHandle vpi_iterate(int code) { return vpi_array_base_iterate(code); }
vpiHandle vpi_index(int idx);
void set_word(unsigned idx, unsigned off, vvp_vector4_t val);
void set_word(unsigned idx, double val);
void set_word(unsigned idx, const std::string&val);
void set_word(unsigned idx, const vvp_object_t&val);
vvp_vector4_t get_word(unsigned address);
double get_word_r(unsigned address);
void get_word_obj(unsigned address, vvp_object_t&val);
std::string get_word_str(unsigned address);
const char*name; /* Permanently allocated string */
__vpiDecConst first_addr;
__vpiDecConst last_addr;

24
vvp/vthread.cc
View File

@ -3262,7 +3262,7 @@ bool of_LOAD_AR(vthread_t thr, vvp_code_t cp)
if (thr_get_bit(thr, 4) == BIT4_1) {
word = 0.0;
} else {
word = array_get_word_r(cp->array, adr);
word = cp->array->get_word_r(adr);
}
thr->push_real(word);
@ -3294,7 +3294,7 @@ bool of_LOAD_AV(vthread_t thr, vvp_code_t cp)
return true;
}
vvp_vector4_t word = array_get_word(cp->array, adr);
vvp_vector4_t word = cp->array->get_word(adr);
if (word.size() > wid)
word.resize(wid);
@ -3451,7 +3451,7 @@ bool of_LOAD_AVP0(vthread_t thr, vvp_code_t cp)
/* We need a vector this wide to make the math work correctly.
* Copy the base bits into the vector, but keep the width. */
vvp_vector4_t sig_value(wid, BIT4_0);
sig_value.copy_bits(array_get_word(cp->array, adr));
sig_value.copy_bits(cp->array->get_word(adr));
load_vp0_common(thr, cp, sig_value);
return true;
@ -3471,7 +3471,7 @@ bool of_LOAD_AVP0_S(vthread_t thr, vvp_code_t cp)
return true;
}
vvp_vector4_t tmp (array_get_word(cp->array, adr));
vvp_vector4_t tmp (cp->array->get_word(adr));
/* We need a vector this wide to make the math work correctly.
* Copy the base bits into the vector, but keep the width. */
@ -3505,7 +3505,7 @@ bool of_LOAD_AVX_P(vthread_t thr, vvp_code_t cp)
long use_index = thr->words[index].w_int;
vvp_vector4_t word = array_get_word(cp->array, adr);
vvp_vector4_t word = cp->array->get_word(adr);
if ((use_index >= (long)word.size()) || (use_index < 0)) {
thr_put_bit(thr, bit, BIT4_X);
@ -3543,7 +3543,7 @@ bool of_LOAD_OBJA(vthread_t thr, vvp_code_t cp)
if (thr_get_bit(thr, 4) == BIT4_1) {
; // Return nil
} else {
array_get_word_obj(cp->array, adr, word);
cp->array->get_word_obj(adr, word);
}
thr->push_object(word);
@ -3591,7 +3591,7 @@ bool of_LOAD_STRA(vthread_t thr, vvp_code_t cp)
if (thr_get_bit(thr, 4) == BIT4_1) {
word = "";
} else {
word = array_get_word_str(cp->array, adr);
word = cp->array->get_word_str(adr);
}
thr->push_str(word);
@ -5051,7 +5051,7 @@ bool of_SET_AV(vthread_t thr, vvp_code_t cp)
/* Make a vector of the desired width. */
vvp_vector4_t value = vthread_bits_to_vector(thr, bit, wid);
array_set_word(cp->array, adr, off, value);
cp->array->set_word(adr, off, value);
return true;
}
@ -5482,7 +5482,7 @@ bool of_STORE_OBJA(vthread_t thr, vvp_code_t cp)
vvp_object_t val;
thr->pop_object(val);
array_set_word(cp->array, adr, val);
cp->array->set_word(adr, val);
return true;
}
@ -5653,7 +5653,7 @@ bool of_STORE_REALA(vthread_t thr, vvp_code_t cp)
unsigned adr = thr->words[idx].w_int;
double val = thr->pop_real();
array_set_word(cp->array, adr, val);
cp->array->set_word(adr, val);
return true;
}
@ -5678,7 +5678,7 @@ bool of_STORE_STRA(vthread_t thr, vvp_code_t cp)
unsigned adr = thr->words[idx].w_int;
string val = thr->pop_str();
array_set_word(cp->array, adr, val);
cp->array->set_word(adr, val);
return true;
}
@ -5861,7 +5861,7 @@ bool of_TEST_NUL_A(vthread_t thr, vvp_code_t cp)
return true;
}
array_get_word_obj(cp->array, adr, word);
cp->array->get_word_obj(adr, word);
if (word.test_nil())
thr_put_bit(thr, 4, BIT4_1);
else