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

Add a typedef for `std::vector<netrange_t>` 

`std::vector<netrange_t>` is used for signal array dimensions. As such it is
used in quite a few places.

Add a typedef that can be used as a shorthand to refer to it. This helps to
keep lines where this is used from growing to overly long.

The new type is called `netranges_t`.

Signed-off-by: Lars-Peter Clausen <lars@metafoo.de>
This commit is contained in:
Lars-Peter Clausen 2022-01-06 15:24:20 +01:00
parent d6d95c7c49
commit 763907b0e5
27 changed files with 110 additions and 121 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
PExpr.h
View File

@ -217,7 +217,7 @@ class PEAssignPattern : public PExpr {
NetExpr* elaborate_expr_packed_(Design *des, NetScope *scope, NetExpr* elaborate_expr_packed_(Design *des, NetScope *scope,
ivl_variable_type_t base_type, ivl_variable_type_t base_type,
unsigned int width, unsigned int width,
const std::vector<netrange_t> &dims, const netranges_t &dims,
unsigned int cur_dim, unsigned int cur_dim,
bool need_const) const; bool need_const) const;
NetExpr* elaborate_expr_struct_(Design *des, NetScope *scope, NetExpr* elaborate_expr_struct_(Design *des, NetScope *scope,
@ -228,7 +228,7 @@ class PEAssignPattern : public PExpr {
bool need_const, bool up) const; bool need_const, bool up) const;
NetExpr* elaborate_expr_uarray_(Design *des, NetScope *scope, NetExpr* elaborate_expr_uarray_(Design *des, NetScope *scope,
const netuarray_t *uarray_type, const netuarray_t *uarray_type,
const std::vector<netrange_t> &dims, const netranges_t &dims,
unsigned int cur_dim, unsigned int cur_dim,
bool need_const) const; bool need_const) const;

4
PWire.h
View File

@ -134,10 +134,10 @@ class PWire : public PNamedItem {
PWire& operator= (const PWire&); PWire& operator= (const PWire&);
ivl_type_t elaborate_type(Design*des, NetScope*scope, ivl_type_t elaborate_type(Design*des, NetScope*scope,
const std::vector<netrange_t>&packed_dimensions) const; const netranges_t &packed_dimensions) const;
ivl_type_t elaborate_darray_type(Design*des, NetScope*scope, ivl_type_t elaborate_darray_type(Design*des, NetScope*scope,
const char *darray_type, const char *darray_type,
const std::vector<netrange_t>&packed_dimensions) const netranges_t &packed_dimensions)
const; const;
}; };

2
Statement.h
View File

@ -499,7 +499,7 @@ class PForeach : public Statement {
private: private:
NetProc* elaborate_static_array_(Design*des, NetScope*scope, NetProc* elaborate_static_array_(Design*des, NetScope*scope,
const std::vector<netrange_t>&dims) const; const netranges_t&dims) const;
private: private:
perm_string array_var_; perm_string array_var_;

7
design_dump.cc
View File

@ -418,9 +418,9 @@ ostream&operator<<(ostream&out, const list<netrange_t>&rlist)
return out; return out;
} }
ostream&operator<<(ostream&out, const vector<netrange_t>&rlist) ostream&operator<<(ostream&out, const netranges_t&rlist)
{ {
for (vector<netrange_t>::const_iterator cur = rlist.begin() for (netranges_t::const_iterator cur = rlist.begin()
; cur != rlist.end() ; ++cur) { ; cur != rlist.end() ; ++cur) {
out << *cur; out << *cur;
} }
@ -1936,8 +1936,7 @@ void NetESignal::dump(ostream&o) const
o << "+"; o << "+";
o << name(); o << name();
if (word_) o << "[word=" << *word_ << "]"; if (word_) o << "[word=" << *word_ << "]";
vector<netrange_t>tmp = net_->net_type()->slice_dimensions(); o << net_->net_type()->slice_dimensions();
o << tmp;
} }
void NetETernary::dump(ostream&o) const void NetETernary::dump(ostream&o) const

18
elab_expr.cc
View File

@ -312,7 +312,7 @@ NetExpr* PEAssignPattern::elaborate_expr_array_(Design *des, NetScope *scope,
NetExpr* PEAssignPattern::elaborate_expr_uarray_(Design *des, NetScope *scope, NetExpr* PEAssignPattern::elaborate_expr_uarray_(Design *des, NetScope *scope,
const netuarray_t *uarray_type, const netuarray_t *uarray_type,
const std::vector<netrange_t> &dims, const netranges_t &dims,
unsigned int cur_dim, unsigned int cur_dim,
bool need_const) const bool need_const) const
{ {
@ -381,7 +381,7 @@ NetExpr* PEAssignPattern::elaborate_expr_uarray_(Design *des, NetScope *scope,
NetExpr* PEAssignPattern::elaborate_expr_packed_(Design *des, NetScope *scope, NetExpr* PEAssignPattern::elaborate_expr_packed_(Design *des, NetScope *scope,
ivl_variable_type_t base_type, ivl_variable_type_t base_type,
unsigned int width, unsigned int width,
const std::vector<netrange_t> &dims, const netranges_t &dims,
unsigned int cur_dim, unsigned int cur_dim,
bool need_const) const bool need_const) const
{ {
@ -2522,7 +2522,7 @@ static NetExpr* check_for_struct_members(const LineInfo*li,
// kind of array cannot be a struct. // kind of array cannot be a struct.
if (!member_comp.index.empty()) { if (!member_comp.index.empty()) {
// These are the dimensions defined by the type // These are the dimensions defined by the type
const vector<netrange_t>&mem_packed_dims = mem_vec->packed_dims(); const netranges_t&mem_packed_dims = mem_vec->packed_dims();
if (member_comp.index.size() > mem_packed_dims.size()) { if (member_comp.index.size() > mem_packed_dims.size()) {
cerr << li->get_fileline() << ": error: " cerr << li->get_fileline() << ": error: "
@ -2594,7 +2594,7 @@ static NetExpr* check_for_struct_members(const LineInfo*li,
ivl_assert(*li, !member_comp.index.empty()); ivl_assert(*li, !member_comp.index.empty());
// These are the dimensions defined by the type // These are the dimensions defined by the type
const vector<netrange_t>&mem_packed_dims = array->static_dimensions(); const netranges_t&mem_packed_dims = array->static_dimensions();
if (member_comp.index.size() != mem_packed_dims.size()) { if (member_comp.index.size() != mem_packed_dims.size()) {
cerr << li->get_fileline() << ": error: " cerr << li->get_fileline() << ": error: "
@ -2790,7 +2790,7 @@ NetExpr* PEIdent::elaborate_expr_class_field_(Design*des, NetScope*scope,
NetExpr *canon_index = nullptr; NetExpr *canon_index = nullptr;
ivl_type_t tmp_type = class_type->get_prop_type(pidx); ivl_type_t tmp_type = class_type->get_prop_type(pidx);
if (const netuarray_t *tmp_ua = dynamic_cast<const netuarray_t*>(tmp_type)) { if (const netuarray_t *tmp_ua = dynamic_cast<const netuarray_t*>(tmp_type)) {
const std::vector<netrange_t> &dims = tmp_ua->static_dimensions(); const auto &dims = tmp_ua->static_dimensions();
if (debug_elaborate) { if (debug_elaborate) {
cerr << get_fileline() << ": PEIdent::elaborate_expr_class_member_: " cerr << get_fileline() << ": PEIdent::elaborate_expr_class_member_: "
@ -5997,7 +5997,7 @@ NetExpr* PEIdent::elaborate_expr_net_idx_up_(Design*des, NetScope*scope,
long lsv = base_c->value().as_long(); long lsv = base_c->value().as_long();
long rel_base = 0; long rel_base = 0;
// Get the signal range. // Get the signal range.
const vector<netrange_t>&packed = net->sig()->packed_dims(); const netranges_t&packed = net->sig()->packed_dims();
if (prefix_indices.size()+1 < net->sig()->packed_dims().size()) { if (prefix_indices.size()+1 < net->sig()->packed_dims().size()) {
// Here we are selecting one or more sub-arrays. // Here we are selecting one or more sub-arrays.
// Make this work by finding the indexed sub-arrays and // Make this work by finding the indexed sub-arrays and
@ -6144,7 +6144,7 @@ NetExpr* PEIdent::elaborate_expr_net_idx_do_(Design*des, NetScope*scope,
long lsv = base_c->value().as_long(); long lsv = base_c->value().as_long();
long rel_base = 0; long rel_base = 0;
// Get the signal range. // Get the signal range.
const vector<netrange_t>&packed = net->sig()->packed_dims(); const netranges_t&packed = net->sig()->packed_dims();
if (prefix_indices.size()+1 < net->sig()->packed_dims().size()) { if (prefix_indices.size()+1 < net->sig()->packed_dims().size()) {
// Here we are selecting one or more sub-arrays. // Here we are selecting one or more sub-arrays.
// Make this work by finding the indexed sub-arrays and // Make this work by finding the indexed sub-arrays and
@ -6331,7 +6331,7 @@ NetExpr* PEIdent::elaborate_expr_net_bit_(Design*des, NetScope*scope,
long msv = msc->value().as_long(); long msv = msc->value().as_long();
const vector<netrange_t>& sig_packed = net->sig()->packed_dims(); const netranges_t& sig_packed = net->sig()->packed_dims();
if (prefix_indices.size()+2 <= sig_packed.size()) { if (prefix_indices.size()+2 <= sig_packed.size()) {
// Special case: this is a slice of a multi-dimensional // Special case: this is a slice of a multi-dimensional
// packed array. For example: // packed array. For example:
@ -6438,7 +6438,7 @@ NetExpr* PEIdent::elaborate_expr_net_bit_(Design*des, NetScope*scope,
return res; return res;
} }
const vector<netrange_t>& sig_packed = net->sig()->packed_dims(); const netranges_t& sig_packed = net->sig()->packed_dims();
if (prefix_indices.size()+2 <= sig_packed.size()) { if (prefix_indices.size()+2 <= sig_packed.size()) {
// Special case: this is a slice of a multi-dimensional // Special case: this is a slice of a multi-dimensional
// packed array. For example: // packed array. For example:

10
elab_lval.cc
View File

@ -749,7 +749,7 @@ bool PEIdent::elaborate_lval_net_part_(Design*des,
} }
} }
const vector<netrange_t>&packed = reg->packed_dims(); const netranges_t&packed = reg->packed_dims();
long loff, moff; long loff, moff;
long wid; long wid;
@ -874,7 +874,7 @@ bool PEIdent::elaborate_lval_net_idx_(Design*des,
long lsv = base_c->value().as_long(); long lsv = base_c->value().as_long();
long rel_base = 0; long rel_base = 0;
// Get the signal range. // Get the signal range.
const vector<netrange_t>&packed = reg->packed_dims(); const netranges_t&packed = reg->packed_dims();
if (prefix_indices.size()+1 < reg->packed_dims().size()) { if (prefix_indices.size()+1 < reg->packed_dims().size()) {
// Here we are selecting one or more sub-arrays. // Here we are selecting one or more sub-arrays.
// Make this work by finding the indexed sub-arrays and // Make this work by finding the indexed sub-arrays and
@ -1114,7 +1114,7 @@ NetAssign_* PEIdent::elaborate_lval_net_class_member_(Design*des, NetScope*scope
} }
if (const netuarray_t *tmp_ua = dynamic_cast<const netuarray_t*>(ptype)) { if (const netuarray_t *tmp_ua = dynamic_cast<const netuarray_t*>(ptype)) {
const std::vector<netrange_t> &dims = tmp_ua->static_dimensions(); const auto &dims = tmp_ua->static_dimensions();
if (debug_elaborate) { if (debug_elaborate) {
cerr << get_fileline() << ": PEIdent::elaborate_lval_method_class_member_: " cerr << get_fileline() << ": PEIdent::elaborate_lval_method_class_member_: "
@ -1313,7 +1313,7 @@ bool PEIdent::elaborate_lval_net_packed_member_(Design*des, NetScope*scope,
// kind of array cannot be a struct. // kind of array cannot be a struct.
if (!member_comp.index.empty()) { if (!member_comp.index.empty()) {
// These are the dimensions defined by the type // These are the dimensions defined by the type
const vector<netrange_t>&mem_packed_dims = mem_vec->packed_dims(); const netranges_t&mem_packed_dims = mem_vec->packed_dims();
if (member_comp.index.size() > mem_packed_dims.size()) { if (member_comp.index.size() > mem_packed_dims.size()) {
cerr << get_fileline() << ": error: " cerr << get_fileline() << ": error: "
@ -1382,7 +1382,7 @@ bool PEIdent::elaborate_lval_net_packed_member_(Design*des, NetScope*scope,
ivl_assert(*this, !member_comp.index.empty()); ivl_assert(*this, !member_comp.index.empty());
// These are the dimensions defined by the type // These are the dimensions defined by the type
const vector<netrange_t>&mem_packed_dims = array->static_dimensions(); const netranges_t&mem_packed_dims = array->static_dimensions();
if (member_comp.index.size() != mem_packed_dims.size()) { if (member_comp.index.size() != mem_packed_dims.size()) {
cerr << get_fileline() << ": error: " cerr << get_fileline() << ": error: "

12
elab_sig.cc
View File

@ -936,13 +936,13 @@ void PWhile::elaborate_sig(Design*des, NetScope*scope) const
statement_->elaborate_sig(des, scope); statement_->elaborate_sig(des, scope);
} }
bool test_ranges_eeq(const vector<netrange_t>&lef, const vector<netrange_t>&rig) bool test_ranges_eeq(const netranges_t&lef, const netranges_t&rig)
{ {
if (lef.size() != rig.size()) if (lef.size() != rig.size())
return false; return false;
vector<netrange_t>::const_iterator lcur = lef.begin(); netranges_t::const_iterator lcur = lef.begin();
vector<netrange_t>::const_iterator rcur = rig.begin(); netranges_t::const_iterator rcur = rig.begin();
while (lcur != lef.end()) { while (lcur != lef.end()) {
if (lcur->get_msb() != rcur->get_msb()) if (lcur->get_msb() != rcur->get_msb())
return false; return false;
@ -957,7 +957,7 @@ bool test_ranges_eeq(const vector<netrange_t>&lef, const vector<netrange_t>&rig)
} }
ivl_type_t PWire::elaborate_type(Design*des, NetScope*scope, ivl_type_t PWire::elaborate_type(Design*des, NetScope*scope,
const std::vector<netrange_t>&packed_dimensions) const const netranges_t &packed_dimensions) const
{ {
vector_type_t *vec_type = dynamic_cast<vector_type_t*>(set_data_type_.get()); vector_type_t *vec_type = dynamic_cast<vector_type_t*>(set_data_type_.get());
if (set_data_type_ && !vec_type) { if (set_data_type_ && !vec_type) {
@ -1028,7 +1028,7 @@ NetNet* PWire::elaborate_sig(Design*des, NetScope*scope) const
} }
unsigned wid = 1; unsigned wid = 1;
vector<netrange_t>packed_dimensions; netranges_t packed_dimensions;
des->errors += error_cnt_; des->errors += error_cnt_;
@ -1051,7 +1051,7 @@ NetNet* PWire::elaborate_sig(Design*des, NetScope*scope) const
} }
bool dimensions_ok = true; bool dimensions_ok = true;
vector<netrange_t> plist, nlist; netranges_t plist, nlist;
/* If they exist get the port definition MSB and LSB */ /* If they exist get the port definition MSB and LSB */
if (port_set_ && !port_.empty()) { if (port_set_ && !port_.empty()) {
if (debug_elaborate) { if (debug_elaborate) {

8
elab_type.cc
View File

@ -168,7 +168,7 @@ ivl_type_t enum_type_t::elaborate_type_raw(Design *des, NetScope *scope) const
ivl_type_t vector_type_t::elaborate_type_raw(Design*des, NetScope*scope) const ivl_type_t vector_type_t::elaborate_type_raw(Design*des, NetScope*scope) const
{ {
vector<netrange_t> packed; netranges_t packed;
if (pdims.get()) if (pdims.get())
evaluate_ranges(des, scope, this, packed, *pdims); evaluate_ranges(des, scope, this, packed, *pdims);
@ -198,7 +198,7 @@ ivl_type_t string_type_t::elaborate_type_raw(Design*, NetScope*) const
ivl_type_t parray_type_t::elaborate_type_raw(Design*des, NetScope*scope) const ivl_type_t parray_type_t::elaborate_type_raw(Design*des, NetScope*scope) const
{ {
vector<netrange_t>packed; netranges_t packed;
if (dims.get()) if (dims.get())
evaluate_ranges(des, scope, this, packed, *dims); evaluate_ranges(des, scope, this, packed, *dims);
@ -322,7 +322,7 @@ static ivl_type_t elaborate_queue_type(Design *des, NetScope *scope,
// return the base type. Also check that we actually support the base type. // return the base type. Also check that we actually support the base type.
static ivl_type_t elaborate_static_array_type(Design *des, const LineInfo &li, static ivl_type_t elaborate_static_array_type(Design *des, const LineInfo &li,
ivl_type_t base_type, ivl_type_t base_type,
std::vector<netrange_t> &dims) netranges_t &dims)
{ {
if (dims.empty()) if (dims.empty())
return base_type; return base_type;
@ -354,7 +354,7 @@ ivl_type_t elaborate_array_type(Design *des, NetScope *scope,
const list<pform_range_t> &dims) const list<pform_range_t> &dims)
{ {
const long warn_dimension_size = 1 << 30; const long warn_dimension_size = 1 << 30;
std::vector<netrange_t> dimensions; netranges_t dimensions;
dimensions.reserve(dims.size()); dimensions.reserve(dims.size());
ivl_type_t type = base_type; ivl_type_t type = base_type;

6
elaborate.cc
View File

@ -5414,7 +5414,7 @@ NetProc* PForeach::elaborate(Design*des, NetScope*scope) const
return 0; return 0;
} }
const std::vector<netrange_t>&dims = atype->static_dimensions(); const netranges_t&dims = atype->static_dimensions();
if (dims.size() < index_vars_.size()) { if (dims.size() < index_vars_.size()) {
cerr << get_fileline() << ": error: " cerr << get_fileline() << ": error: "
<< "class " << class_scope->get_name() << "class " << class_scope->get_name()
@ -5447,7 +5447,7 @@ NetProc* PForeach::elaborate(Design*des, NetScope*scope) const
<< " packed dimensions." << endl; << " packed dimensions." << endl;
} }
std::vector<netrange_t>dims = array_sig->unpacked_dims(); netranges_t dims = array_sig->unpacked_dims();
if (array_sig->packed_dimensions() > 0) { if (array_sig->packed_dimensions() > 0) {
dims.insert(dims.end(), array_sig->packed_dims().begin(), array_sig->packed_dims().end()); dims.insert(dims.end(), array_sig->packed_dims().begin(), array_sig->packed_dims().end());
} }
@ -5523,7 +5523,7 @@ NetProc* PForeach::elaborate(Design*des, NetScope*scope) const
* and possibly do some optimizations. * and possibly do some optimizations.
*/ */
NetProc* PForeach::elaborate_static_array_(Design*des, NetScope*scope, NetProc* PForeach::elaborate_static_array_(Design*des, NetScope*scope,
const vector<netrange_t>&dims) const const netranges_t&dims) const
{ {
if (debug_elaborate) { if (debug_elaborate) {
cerr << get_fileline() << ": PForeach::elaborate_static_array_: " cerr << get_fileline() << ": PForeach::elaborate_static_array_: "

4
eval_tree.cc
View File

@ -2197,12 +2197,12 @@ static bool get_array_info(const NetExpr*arg, long dim,
if (dim > (pdims + updims)) return true; if (dim > (pdims + updims)) return true;
/* Get the appropriate unpacked or packed dimension information. */ /* Get the appropriate unpacked or packed dimension information. */
if (dim > updims) { if (dim > updims) {
const vector<netrange_t>&dim_vals = sig->packed_dims(); const netranges_t&dim_vals = sig->packed_dims();
const netrange_t&range = dim_vals[dim-updims-1]; const netrange_t&range = dim_vals[dim-updims-1];
left = range.get_msb(); left = range.get_msb();
right = range.get_lsb(); right = range.get_lsb();
} else { } else {
const vector<netrange_t>&dim_vals = sig->unpacked_dims(); const netranges_t&dim_vals = sig->unpacked_dims();
const netrange_t&range = dim_vals[dim-1]; const netrange_t&range = dim_vals[dim-1];
left = range.get_msb(); left = range.get_msb();
right = range.get_lsb(); right = range.get_lsb();

2
netenum.cc
View File

@ -56,7 +56,7 @@ long netenum_t::packed_width() const
return base_type_->packed_width(); return base_type_->packed_width();
} }
vector<netrange_t> netenum_t::slice_dimensions() const netranges_t netenum_t::slice_dimensions() const
{ {
return base_type_->slice_dimensions(); return base_type_->slice_dimensions();
} }

2
netenum.h
View File

@ -39,7 +39,7 @@ class netenum_t : public LineInfo, public ivl_type_s {
virtual ivl_variable_type_t base_type() const; virtual ivl_variable_type_t base_type() const;
virtual bool packed() const; virtual bool packed() const;
virtual long packed_width() const; virtual long packed_width() const;
std::vector<netrange_t> slice_dimensions() const; netranges_t slice_dimensions() const;
bool get_signed() const; bool get_signed() const;
bool get_isint() const; bool get_isint() const;

8
netlist.cc
View File

@ -557,7 +557,7 @@ void NetNet::calculate_slice_widths_from_packed_dims_(void)
ivl_assert(*this, ! slice_wids_.empty()); ivl_assert(*this, ! slice_wids_.empty());
slice_wids_[0] = netrange_width(slice_dims_); slice_wids_[0] = netrange_width(slice_dims_);
vector<netrange_t>::const_iterator cur = slice_dims_.begin(); netranges_t::const_iterator cur = slice_dims_.begin();
for (size_t idx = 1 ; idx < slice_wids_.size() ; idx += 1, ++cur) { for (size_t idx = 1 ; idx < slice_wids_.size() ; idx += 1, ++cur) {
slice_wids_[idx] = slice_wids_[idx-1] / cur->width(); slice_wids_[idx] = slice_wids_[idx-1] / cur->width();
} }
@ -775,7 +775,7 @@ long NetNet::sb_to_idx(const list<long>&indices, long sb) const
{ {
ivl_assert(*this, indices.size()+1 == packed_dims().size()); ivl_assert(*this, indices.size()+1 == packed_dims().size());
vector<netrange_t>::const_iterator pcur = packed_dims().end(); netranges_t::const_iterator pcur = packed_dims().end();
-- pcur; -- pcur;
long acc_off; long acc_off;
@ -2453,14 +2453,14 @@ NetNet* NetESignal::sig()
*/ */
long NetESignal::lsi() const long NetESignal::lsi() const
{ {
const vector<netrange_t>&packed = net_->packed_dims(); const netranges_t&packed = net_->packed_dims();
ivl_assert(*this, packed.size() == 1); ivl_assert(*this, packed.size() == 1);
return packed.back().get_lsb(); return packed.back().get_lsb();
} }
long NetESignal::msi() const long NetESignal::msi() const
{ {
const vector<netrange_t>&packed = net_->packed_dims(); const netranges_t&packed = net_->packed_dims();
ivl_assert(*this, packed.size() == 1); ivl_assert(*this, packed.size() == 1);
return packed.back().get_msb(); return packed.back().get_msb();
} }

8
netlist.h
View File

@ -723,9 +723,9 @@ class NetNet : public NetObj, public PortType {
first range in the list (front) is the left-most range in first range in the list (front) is the left-most range in
the Verilog declaration. These packed dims are compressed the Verilog declaration. These packed dims are compressed
to represent the dimensions of all the subtypes. */ to represent the dimensions of all the subtypes. */
const std::vector<netrange_t>& packed_dims() const { return slice_dims_; } const netranges_t& packed_dims() const { return slice_dims_; }
const std::vector<netrange_t>& unpacked_dims() const { return unpacked_dims_; } const netranges_t& unpacked_dims() const { return unpacked_dims_; }
/* The vector_width returns the bit width of the packed array, /* The vector_width returns the bit width of the packed array,
vector or scalar that is this NetNet object. */ vector or scalar that is this NetNet object. */
@ -813,7 +813,7 @@ class NetNet : public NetObj, public PortType {
// Whether the net is variable declared with the const keyword. // Whether the net is variable declared with the const keyword.
bool is_const_ = false; bool is_const_ = false;
std::vector<netrange_t> unpacked_dims_; netranges_t unpacked_dims_;
// These are the widths of the various slice depths. There is // These are the widths of the various slice depths. There is
// one entry in this vector for each packed dimension. The // one entry in this vector for each packed dimension. The
@ -821,7 +821,7 @@ class NetNet : public NetObj, public PortType {
// //
// For example: slice_wids_[0] is vector_width(). // For example: slice_wids_[0] is vector_width().
void calculate_slice_widths_from_packed_dims_(void); void calculate_slice_widths_from_packed_dims_(void);
std::vector<netrange_t> slice_dims_; netranges_t slice_dims_;
std::vector<unsigned long> slice_wids_; std::vector<unsigned long> slice_wids_;
unsigned eref_count_; unsigned eref_count_;

32
netmisc.cc
View File

@ -415,7 +415,7 @@ NetExpr *normalize_variable_base(NetExpr *base,
NetExpr *normalize_variable_bit_base(const list<long>&indices, NetExpr*base, NetExpr *normalize_variable_bit_base(const list<long>&indices, NetExpr*base,
const NetNet*reg) const NetNet*reg)
{ {
const vector<netrange_t>&packed_dims = reg->packed_dims(); const netranges_t&packed_dims = reg->packed_dims();
ivl_assert(*base, indices.size()+1 == packed_dims.size()); ivl_assert(*base, indices.size()+1 == packed_dims.size());
// Get the canonical offset of the slice within which we are // Get the canonical offset of the slice within which we are
@ -431,7 +431,7 @@ NetExpr *normalize_variable_part_base(const list<long>&indices, NetExpr*base,
const NetNet*reg, const NetNet*reg,
unsigned long wid, bool is_up) unsigned long wid, bool is_up)
{ {
const vector<netrange_t>&packed_dims = reg->packed_dims(); const netranges_t&packed_dims = reg->packed_dims();
ivl_assert(*base, indices.size()+1 == packed_dims.size()); ivl_assert(*base, indices.size()+1 == packed_dims.size());
// Get the canonical offset of the slice within which we are // Get the canonical offset of the slice within which we are
@ -446,10 +446,10 @@ NetExpr *normalize_variable_part_base(const list<long>&indices, NetExpr*base,
NetExpr *normalize_variable_slice_base(const list<long>&indices, NetExpr*base, NetExpr *normalize_variable_slice_base(const list<long>&indices, NetExpr*base,
const NetNet*reg, unsigned long&lwid) const NetNet*reg, unsigned long&lwid)
{ {
const vector<netrange_t>&packed_dims = reg->packed_dims(); const netranges_t&packed_dims = reg->packed_dims();
ivl_assert(*base, indices.size() < packed_dims.size()); ivl_assert(*base, indices.size() < packed_dims.size());
vector<netrange_t>::const_iterator pcur = packed_dims.end(); netranges_t::const_iterator pcur = packed_dims.end();
for (size_t idx = indices.size() ; idx < packed_dims.size(); idx += 1) { for (size_t idx = indices.size() ; idx < packed_dims.size(); idx += 1) {
-- pcur; -- pcur;
} }
@ -563,8 +563,7 @@ void indices_to_expressions(Design*des, NetScope*scope,
} }
} }
static void make_strides(const vector<netrange_t>&dims, static void make_strides(const netranges_t&dims, vector<long>&stride)
vector<long>&stride)
{ {
stride[dims.size()-1] = 1; stride[dims.size()-1] = 1;
for (size_t idx = stride.size()-1 ; idx > 0 ; --idx) { for (size_t idx = stride.size()-1 ; idx > 0 ; --idx) {
@ -581,7 +580,7 @@ static void make_strides(const vector<netrange_t>&dims,
* word. If any of the indices are out of bounds, return nil instead * word. If any of the indices are out of bounds, return nil instead
* of an expression. * of an expression.
*/ */
static NetExpr* normalize_variable_unpacked(const vector<netrange_t>&dims, list<long>&indices) static NetExpr* normalize_variable_unpacked(const netranges_t&dims, list<long>&indices)
{ {
// Make strides for each index. The stride is the distance (in // Make strides for each index. The stride is the distance (in
// words) to the next element in the canonical array. // words) to the next element in the canonical array.
@ -614,17 +613,17 @@ static NetExpr* normalize_variable_unpacked(const vector<netrange_t>&dims, list<
NetExpr* normalize_variable_unpacked(const NetNet*net, list<long>&indices) NetExpr* normalize_variable_unpacked(const NetNet*net, list<long>&indices)
{ {
const vector<netrange_t>&dims = net->unpacked_dims(); const netranges_t&dims = net->unpacked_dims();
return normalize_variable_unpacked(dims, indices); return normalize_variable_unpacked(dims, indices);
} }
NetExpr* normalize_variable_unpacked(const netsarray_t*stype, list<long>&indices) NetExpr* normalize_variable_unpacked(const netsarray_t*stype, list<long>&indices)
{ {
const vector<netrange_t>&dims = stype->static_dimensions(); const netranges_t&dims = stype->static_dimensions();
return normalize_variable_unpacked(dims, indices); return normalize_variable_unpacked(dims, indices);
} }
NetExpr* normalize_variable_unpacked(const LineInfo&loc, const vector<netrange_t>&dims, list<NetExpr*>&indices) NetExpr* normalize_variable_unpacked(const LineInfo&loc, const netranges_t&dims, list<NetExpr*>&indices)
{ {
// Make strides for each index. The stride is the distance (in // Make strides for each index. The stride is the distance (in
// words) to the next element in the canonical array. // words) to the next element in the canonical array.
@ -711,13 +710,13 @@ NetExpr* normalize_variable_unpacked(const LineInfo&loc, const vector<netrange_t
NetExpr* normalize_variable_unpacked(const NetNet*net, list<NetExpr*>&indices) NetExpr* normalize_variable_unpacked(const NetNet*net, list<NetExpr*>&indices)
{ {
const vector<netrange_t>&dims = net->unpacked_dims(); const netranges_t&dims = net->unpacked_dims();
return normalize_variable_unpacked(*net, dims, indices); return normalize_variable_unpacked(*net, dims, indices);
} }
NetExpr* normalize_variable_unpacked(const LineInfo&loc, const netsarray_t*stype, list<NetExpr*>&indices) NetExpr* normalize_variable_unpacked(const LineInfo&loc, const netsarray_t*stype, list<NetExpr*>&indices)
{ {
const vector<netrange_t>&dims = stype->static_dimensions(); const netranges_t&dims = stype->static_dimensions();
return normalize_variable_unpacked(loc, dims, indices); return normalize_variable_unpacked(loc, dims, indices);
} }
@ -1159,8 +1158,7 @@ bool evaluate_range(Design*des, NetScope*scope, const LineInfo*li,
} }
bool evaluate_ranges(Design*des, NetScope*scope, const LineInfo*li, bool evaluate_ranges(Design*des, NetScope*scope, const LineInfo*li,
vector<netrange_t>&llist, netranges_t&llist, const list<pform_range_t>&rlist)
const list<pform_range_t>&rlist)
{ {
bool dimensions_ok = true; bool dimensions_ok = true;
@ -1587,8 +1585,8 @@ NetExpr*collapse_array_exprs(Design*des, NetScope*scope,
return *exprs.begin(); return *exprs.begin();
} }
const std::vector<netrange_t>&pdims = net->packed_dims(); const netranges_t&pdims = net->packed_dims();
std::vector<netrange_t>::const_iterator pcur = pdims.begin(); netranges_t::const_iterator pcur = pdims.begin();
list<NetExpr*>::iterator ecur = exprs.begin(); list<NetExpr*>::iterator ecur = exprs.begin();
NetExpr* base = 0; NetExpr* base = 0;
@ -1881,7 +1879,7 @@ bool calculate_param_range(const LineInfo&line, ivl_type_t par_type,
} }
ivl_assert(line, vector_type->packed()); ivl_assert(line, vector_type->packed());
const std::vector<netrange_t>& packed_dims = vector_type->packed_dims(); const netranges_t& packed_dims = vector_type->packed_dims();
// This is a netvector_t with 0 dimensions, then the parameter was // This is a netvector_t with 0 dimensions, then the parameter was
// declared with a statement like this: // declared with a statement like this:

2
netmisc.h
View File

@ -418,7 +418,7 @@ extern bool evaluate_range(Design*des, NetScope*scope, const LineInfo*li,
long&index_l, long&index_r); long&index_l, long&index_r);
extern bool evaluate_ranges(Design*des, NetScope*scope, const LineInfo*li, extern bool evaluate_ranges(Design*des, NetScope*scope, const LineInfo*li,
std::vector<netrange_t>&llist, netranges_t&llist,
const std::list<pform_range_t>&rlist); const std::list<pform_range_t>&rlist);
/* /*
* This procedure evaluates an expression and if the evaluation is * This procedure evaluates an expression and if the evaluation is

10
netparray.cc
View File

@ -46,13 +46,13 @@ long netparray_t::packed_width(void) const
element_type()->packed_width()); element_type()->packed_width());
} }
vector<netrange_t> netparray_t::slice_dimensions() const netranges_t netparray_t::slice_dimensions() const
{ {
const vector<netrange_t>&packed_dims = static_dimensions(); const netranges_t&packed_dims = static_dimensions();
vector<netrange_t> elem_dims = element_type()->slice_dimensions(); netranges_t elem_dims = element_type()->slice_dimensions();
vector<netrange_t> res (packed_dims.size() + elem_dims.size()); netranges_t res (packed_dims.size() + elem_dims.size());
for (size_t idx = 0 ; idx < packed_dims.size() ; idx += 1) for (size_t idx = 0 ; idx < packed_dims.size() ; idx += 1)
res[idx] = packed_dims[idx]; res[idx] = packed_dims[idx];
@ -76,7 +76,7 @@ netuarray_t::~netuarray_t()
{ {
} }
vector<netrange_t> netuarray_t::slice_dimensions() const netranges_t netuarray_t::slice_dimensions() const
{ {
return static_dimensions(); return static_dimensions();
} }

26
netparray.h
View File

@ -30,24 +30,22 @@
class netsarray_t : public netarray_t { class netsarray_t : public netarray_t {
public: public:
explicit netsarray_t(const std::vector<netrange_t>&packed, explicit netsarray_t(const netranges_t&packed, ivl_type_t etype);
ivl_type_t etype);
~netsarray_t(); ~netsarray_t();
public: public:
// Virtual methods from the ivl_type_s type... // Virtual methods from the ivl_type_s type...
public: public:
inline const std::vector<netrange_t>& static_dimensions() const inline const netranges_t& static_dimensions() const
{ return dims_; } { return dims_; }
private: private:
std::vector<netrange_t> dims_; netranges_t dims_;
}; };
inline netsarray_t::netsarray_t(const std::vector<netrange_t>&pd, inline netsarray_t::netsarray_t(const netranges_t&pd, ivl_type_t etype)
ivl_type_t etype)
: netarray_t(etype), dims_(pd) : netarray_t(etype), dims_(pd)
{ {
} }
@ -58,23 +56,21 @@ inline netsarray_t::netsarray_t(const std::vector<netrange_t>&pd,
class netparray_t : public netsarray_t { class netparray_t : public netsarray_t {
public: public:
explicit netparray_t(const std::vector<netrange_t>&packed, explicit netparray_t(const netranges_t&packed, ivl_type_t etype);
ivl_type_t etype);
~netparray_t(); ~netparray_t();
public: public:
// Virtual methods from the ivl_type_s type... // Virtual methods from the ivl_type_s type...
bool packed(void) const; bool packed(void) const;
long packed_width(void) const; long packed_width(void) const;
std::vector<netrange_t> slice_dimensions() const; netranges_t slice_dimensions() const;
private: private:
bool test_compatibility(ivl_type_t that) const; bool test_compatibility(ivl_type_t that) const;
bool test_equivalence(ivl_type_t that) const; bool test_equivalence(ivl_type_t that) const;
}; };
inline netparray_t::netparray_t(const std::vector<netrange_t>&pd, inline netparray_t::netparray_t(const netranges_t&pd, ivl_type_t etype)
ivl_type_t etype)
: netsarray_t(pd, etype) : netsarray_t(pd, etype)
{ {
} }
@ -85,20 +81,18 @@ inline netparray_t::netparray_t(const std::vector<netrange_t>&pd,
class netuarray_t : public netsarray_t { class netuarray_t : public netsarray_t {
public: public:
explicit netuarray_t(const std::vector<netrange_t>&packed, explicit netuarray_t(const netranges_t&packed, ivl_type_t etype);
ivl_type_t etype);
~netuarray_t(); ~netuarray_t();
public: public:
// Virtual methods from the ivl_type_s type... // Virtual methods from the ivl_type_s type...
std::vector<netrange_t> slice_dimensions() const; netranges_t slice_dimensions() const;
private: private:
bool test_equivalence(ivl_type_t that) const; bool test_equivalence(ivl_type_t that) const;
}; };
inline netuarray_t::netuarray_t(const std::vector<netrange_t>&pd, inline netuarray_t::netuarray_t(const netranges_t&pd, ivl_type_t etype)
ivl_type_t etype)
: netsarray_t(pd, etype) : netsarray_t(pd, etype)
{ {
} }

4
netstruct.cc
View File

@ -115,9 +115,9 @@ long netstruct_t::packed_width(void) const
return res; return res;
} }
vector<netrange_t> netstruct_t::slice_dimensions() const netranges_t netstruct_t::slice_dimensions() const
{ {
vector<netrange_t> tmp; netranges_t tmp;
tmp .push_back(netrange_t(packed_width()-1, 0)); tmp .push_back(netrange_t(packed_width()-1, 0));
return tmp; return tmp;
} }

2
netstruct.h
View File

@ -70,7 +70,7 @@ class netstruct_t : public LineInfo, public ivl_type_s {
// Return the width (in bits) of the packed record, or -1 if // Return the width (in bits) of the packed record, or -1 if
// the record is not packed. // the record is not packed.
long packed_width() const; long packed_width() const;
std::vector<netrange_t> slice_dimensions() const; netranges_t slice_dimensions() const;
// Return the base type of the packed record, or // Return the base type of the packed record, or
// IVL_VT_NO_TYPE if the record is not packed. // IVL_VT_NO_TYPE if the record is not packed.

18
nettypes.cc
View File

@ -42,9 +42,9 @@ long ivl_type_s::packed_width(void) const
return 1; return 1;
} }
vector<netrange_t> ivl_type_s::slice_dimensions() const netranges_t ivl_type_s::slice_dimensions() const
{ {
return vector<netrange_t>(); return netranges_t();
} }
ivl_variable_type_t ivl_type_s::base_type() const ivl_variable_type_t ivl_type_s::base_type() const
@ -97,11 +97,11 @@ ivl_variable_type_t netarray_t::base_type() const
return element_type_->base_type(); return element_type_->base_type();
} }
unsigned long netrange_width(const vector<netrange_t>&packed, unsigned long netrange_width(const netranges_t &packed,
unsigned int base_width) unsigned int base_width)
{ {
unsigned wid = base_width; unsigned wid = base_width;
for (vector<netrange_t>::const_iterator cur = packed.begin() for (netranges_t::const_iterator cur = packed.begin()
; cur != packed.end() ; ++cur) { ; cur != packed.end() ; ++cur) {
unsigned use_wid = cur->width(); unsigned use_wid = cur->width();
wid *= use_wid; wid *= use_wid;
@ -110,8 +110,7 @@ unsigned long netrange_width(const vector<netrange_t>&packed,
return wid; return wid;
} }
bool netrange_equivalent(const std::vector<netrange_t> &a, bool netrange_equivalent(const netranges_t &a, const netranges_t &b)
const std::vector<netrange_t> &b)
{ {
if (a.size() != b.size()) if (a.size() != b.size())
return false; return false;
@ -130,9 +129,8 @@ bool netrange_equivalent(const std::vector<netrange_t> &a,
* and width of the resulting slice. In this case, the "sb" argument * and width of the resulting slice. In this case, the "sb" argument
* is an extra index of the prefix. * is an extra index of the prefix.
*/ */
bool prefix_to_slice(const std::vector<netrange_t>&dims, bool prefix_to_slice(const netranges_t&dims, const std::list<long>&prefix,
const std::list<long>&prefix, long sb, long sb, long&loff, unsigned long&lwid)
long&loff, unsigned long&lwid)
{ {
assert(prefix.size() < dims.size()); assert(prefix.size() < dims.size());
@ -143,7 +141,7 @@ bool prefix_to_slice(const std::vector<netrange_t>&dims,
// this by multiplying the widths of the dims that are NOT // this by multiplying the widths of the dims that are NOT
// accounted for by the prefix or sb indices. // accounted for by the prefix or sb indices.
size_t acc_wid = 1; size_t acc_wid = 1;
vector<netrange_t>::const_iterator pcur = dims.end(); netranges_t::const_iterator pcur = dims.end();
for (size_t idx = prefix.size()+1 ; idx < dims.size() ; idx += 1) { for (size_t idx = prefix.size()+1 ; idx < dims.size() ; idx += 1) {
-- pcur; -- pcur;
acc_wid *= pcur->width(); acc_wid *= pcur->width();

15
nettypes.h
View File

@ -29,6 +29,8 @@
class netrange_t; class netrange_t;
class LineInfo; class LineInfo;
typedef std::vector<netrange_t> netranges_t;
/* /*
* This is a fully abstract type that is a type that can be attached * This is a fully abstract type that is a type that can be attached
* to a NetNet object. * to a NetNet object.
@ -38,7 +40,7 @@ class ivl_type_s {
virtual ~ivl_type_s() =0; virtual ~ivl_type_s() =0;
virtual bool packed(void) const; virtual bool packed(void) const;
virtual long packed_width(void) const; virtual long packed_width(void) const;
virtual std::vector<netrange_t> slice_dimensions() const; virtual netranges_t slice_dimensions() const;
// Some types have a base variable type. This is the bit type // Some types have a base variable type. This is the bit type
// for packed data types, or IVL_VT_DARRAY or IVL_VT_CLASS for // for packed data types, or IVL_VT_DARRAY or IVL_VT_CLASS for
@ -67,7 +69,7 @@ class ivl_type_s {
* Convenience functions for making ivl_type_t objects from various inputs. * Convenience functions for making ivl_type_t objects from various inputs.
*/ */
extern ivl_type_t make_ivl_type(ivl_variable_type_t vt, extern ivl_type_t make_ivl_type(ivl_variable_type_t vt,
const std::vector<netrange_t>&packed_dimensions, const netranges_t&packed_dimensions,
bool signed_flag =false, bool isint_flag =false); bool signed_flag =false, bool isint_flag =false);
/* /*
@ -147,12 +149,11 @@ class netrange_t {
}; };
extern std::ostream&operator << (std::ostream&out, const std::list<netrange_t>&rlist); extern std::ostream&operator << (std::ostream&out, const std::list<netrange_t>&rlist);
extern std::ostream&operator << (std::ostream&out, const std::vector<netrange_t>&rlist); extern std::ostream&operator << (std::ostream&out, const netranges_t&rlist);
extern unsigned long netrange_width(const std::vector<netrange_t>&dims, extern unsigned long netrange_width(const netranges_t &dims,
unsigned int base_width = 1); unsigned int base_width = 1);
extern bool netrange_equivalent(const std::vector<netrange_t> &a, extern bool netrange_equivalent(const netranges_t &a, const netranges_t &b);
const std::vector<netrange_t> &b);
/* /*
* There are a few cases where we need to know about the single-level * There are a few cases where we need to know about the single-level
@ -168,7 +169,7 @@ extern bool calculate_param_range(const LineInfo&line, ivl_type_t par_type,
* indices, and calculate the offset/width of the resulting slice into * indices, and calculate the offset/width of the resulting slice into
* the packed array. * the packed array.
*/ */
extern bool prefix_to_slice(const std::vector<netrange_t>&dims, extern bool prefix_to_slice(const netranges_t&dims,
const std::list<long>&prefix, long sb, const std::list<long>&prefix, long sb,
long&loff, unsigned long&lwid); long&loff, unsigned long&lwid);

2
netvector.cc
View File

@ -82,7 +82,7 @@ long netvector_t::packed_width() const
return netrange_width(packed_dims_); return netrange_width(packed_dims_);
} }
vector<netrange_t> netvector_t::slice_dimensions() const netranges_t netvector_t::slice_dimensions() const
{ {
return packed_dims_; return packed_dims_;
} }

13
netvector.h
View File

@ -26,8 +26,7 @@
class netvector_t : public ivl_type_s { class netvector_t : public ivl_type_s {
public: public:
explicit netvector_t(const std::vector<netrange_t>&packed, explicit netvector_t(const netranges_t&packed, ivl_variable_type_t type);
ivl_variable_type_t type);
// This is a variant of the vector form. Some code processes // This is a variant of the vector form. Some code processes
// the list of packed ranges as a list, but we will store them // the list of packed ranges as a list, but we will store them
@ -60,11 +59,11 @@ class netvector_t : public ivl_type_s {
bool get_implicit() const { return implicit_; } bool get_implicit() const { return implicit_; }
ivl_variable_type_t base_type() const; ivl_variable_type_t base_type() const;
const std::vector<netrange_t>&packed_dims() const; const netranges_t&packed_dims() const;
bool packed(void) const; bool packed(void) const;
long packed_width() const; long packed_width() const;
std::vector<netrange_t> slice_dimensions() const; netranges_t slice_dimensions() const;
std::ostream& debug_dump(std::ostream&) const; std::ostream& debug_dump(std::ostream&) const;
@ -89,20 +88,20 @@ class netvector_t : public ivl_type_s {
bool test_equivalence(ivl_type_t that) const; bool test_equivalence(ivl_type_t that) const;
private: private:
std::vector<netrange_t> packed_dims_; netranges_t packed_dims_;
ivl_variable_type_t type_; ivl_variable_type_t type_;
bool signed_ : 1; bool signed_ : 1;
bool isint_ : 1; // original type of integer bool isint_ : 1; // original type of integer
bool implicit_ : 1; bool implicit_ : 1;
}; };
inline netvector_t::netvector_t(const std::vector<netrange_t>&pd, inline netvector_t::netvector_t(const netranges_t &pd,
ivl_variable_type_t type) ivl_variable_type_t type)
: packed_dims_(pd), type_(type), signed_(false), isint_(false), implicit_(false) : packed_dims_(pd), type_(type), signed_(false), isint_(false), implicit_(false)
{ {
} }
inline const std::vector<netrange_t>& netvector_t::packed_dims() const inline const netranges_t& netvector_t::packed_dims() const
{ {
return packed_dims_; return packed_dims_;
} }

6
t-dll-api.cc
View File

@ -3257,14 +3257,14 @@ extern "C" unsigned ivl_type_packed_width(ivl_type_t net)
extern "C" unsigned ivl_type_packed_dimensions(ivl_type_t net) extern "C" unsigned ivl_type_packed_dimensions(ivl_type_t net)
{ {
assert(net); assert(net);
vector<netrange_t> slice = net->slice_dimensions(); netranges_t slice = net->slice_dimensions();
return slice.size(); return slice.size();
} }
extern "C" int ivl_type_packed_lsb(ivl_type_t net, unsigned dim) extern "C" int ivl_type_packed_lsb(ivl_type_t net, unsigned dim)
{ {
assert(net); assert(net);
vector<netrange_t> slice = net->slice_dimensions(); netranges_t slice = net->slice_dimensions();
assert(dim < slice.size()); assert(dim < slice.size());
return slice[dim].get_lsb(); return slice[dim].get_lsb();
} }
@ -3272,7 +3272,7 @@ extern "C" int ivl_type_packed_lsb(ivl_type_t net, unsigned dim)
extern "C" int ivl_type_packed_msb(ivl_type_t net, unsigned dim) extern "C" int ivl_type_packed_msb(ivl_type_t net, unsigned dim)
{ {
assert(net); assert(net);
vector<netrange_t> slice = net->slice_dimensions(); netranges_t slice = net->slice_dimensions();
assert(dim < slice.size()); assert(dim < slice.size());
return slice[dim].get_msb(); return slice[dim].get_msb();
} }

4
t-dll.cc
View File

@ -2601,7 +2601,7 @@ void dll_target::signal(const NetNet*net)
ivl_signal_t object. */ ivl_signal_t object. */
{ size_t idx = 0; { size_t idx = 0;
vector<netrange_t>::const_iterator cur; netranges_t::const_iterator cur;
obj->packed_dims.resize(net->packed_dims().size()); obj->packed_dims.resize(net->packed_dims().size());
for (cur = net->packed_dims().begin(), idx = 0 for (cur = net->packed_dims().begin(), idx = 0
; cur != net->packed_dims().end() ; ++cur, idx += 1) { ; cur != net->packed_dims().end() ; ++cur, idx += 1) {
@ -2717,7 +2717,7 @@ void dll_target::signal(const NetNet*net)
next encounter the nexus. */ next encounter the nexus. */
if (obj->array_dimensions_ == 1) { if (obj->array_dimensions_ == 1) {
const vector<netrange_t>& dims = net->unpacked_dims(); const netranges_t& dims = net->unpacked_dims();
if (dims[0].get_msb() < dims[0].get_lsb()) { if (dims[0].get_msb() < dims[0].get_lsb()) {
obj->array_base = dims[0].get_msb(); obj->array_base = dims[0].get_msb();
obj->array_addr_swapped = false; obj->array_addr_swapped = false;

2
t-dll.h
View File

@ -759,7 +759,7 @@ struct ivl_signal_s {
/* These encode the declared packed dimensions for the /* These encode the declared packed dimensions for the
signal, in case they are needed by the run-time */ signal, in case they are needed by the run-time */
std::vector<netrange_t> packed_dims; netranges_t packed_dims;
perm_string name_; perm_string name_;
ivl_scope_t scope_; ivl_scope_t scope_;