diff --git a/frontends/ast/simplify.cc b/frontends/ast/simplify.cc
index f77b59d83..7edff38d9 100644
--- a/frontends/ast/simplify.cc
+++ b/frontends/ast/simplify.cc
@@ -2077,6 +2077,14 @@ bool AstNode::simplify(bool const_fold, bool at_zero, bool in_lvalue, int stage,
auto range = make_struct_member_range(this, item_node);
newNode = new AstNode(AST_IDENTIFIER, range);
newNode->str = sname;
+ // save type and original number of dimensions for $size() etc.
+ newNode->attributes[ID::wiretype] = item_node->clone();
+ if (!item_node->multirange_dimensions.empty() && children.size() > 0) {
+ if (children[0]->type == AST_RANGE)
+ newNode->integer = 1;
+ else if (children[0]->type == AST_MULTIRANGE)
+ newNode->integer = children[0]->children.size();
+ }
newNode->basic_prep = true;
if (item_node->is_signed)
newNode = new AstNode(AST_TO_SIGNED, newNode);
@@ -3393,24 +3401,42 @@ skip_dynamic_range_lvalue_expansion:;
id_ast = current_scope.at(buf->str);
if (!id_ast)
log_file_error(filename, location.first_line, "Failed to resolve identifier %s for width detection!\n", buf->str.c_str());
- // a slice of our identifier means we advance to the next dimension, e.g. $size(a[3])
- if (buf->children.size() > 0) {
- // something is hanging below this identifier
- if (buf->children[0]->type == AST_RANGE && buf->integer == 0)
- // if integer == 0, this node was originally created as AST_RANGE so it's dimension is 1
- dim++;
- // more than one range, e.g. $size(a[3][2])
- else // created an AST_MULTIRANGE, converted to AST_RANGE, but original dimension saved in 'integer' field
- dim += buf->integer; // increment by multirange size
+
+ // Check for item in packed struct / union
+ AST::AstNode *item_node;
+ if (id_ast->type == AST_WIRE &&
+ buf->attributes.count(ID::wiretype) && (item_node = buf->attributes[ID::wiretype]) &&
+ (item_node->type == AST_STRUCT_ITEM || item_node->type == AST_STRUCT || item_node->type == AST_UNION))
+ {
+ // The dimension of the original array expression is saved in the 'integer' field
+ dim += buf->integer;
+ if (item_node->multirange_dimensions.empty()) {
+ if (dim != 1)
+ log_file_error(filename, location.first_line, "Dimension %d out of range in `%s', as it only has one dimension!\n", dim, item_node->str.c_str());
+ left = high = item_node->range_left;
+ right = low = item_node->range_right;
+ } else {
+ int dims = GetSize(item_node->multirange_dimensions)/2;
+ if (dim < 1 || dim > dims)
+ log_file_error(filename, location.first_line, "Dimension %d out of range in `%s', as it only has dimensions 1..%d!\n", dim, item_node->str.c_str(), dims);
+ right = low = get_struct_range_offset(item_node, dim - 1);
+ left = high = low + get_struct_range_width(item_node, dim - 1) - 1;
+ if (item_node->multirange_swapped[dim - 1]) {
+ std::swap(left, right);
+ }
+ for (int i = dim; i < dims; i++) {
+ mem_depth *= get_struct_range_width(item_node, i);
+ }
+ }
}
- // We have 4 cases:
+ // Otherwise, we have 4 cases:
// wire x; ==> AST_WIRE, no AST_RANGE children
// wire [1:0]x; ==> AST_WIRE, AST_RANGE children
// wire [1:0]x[1:0]; ==> AST_MEMORY, two AST_RANGE children (1st for packed, 2nd for unpacked)
// wire [1:0]x[1:0][1:0]; ==> AST_MEMORY, one AST_RANGE child (0) for packed, then AST_MULTIRANGE child (1) for unpacked
// (updated: actually by the time we are here, AST_MULTIRANGE is converted into one big AST_RANGE)
// case 0 handled by default
- if ((id_ast->type == AST_WIRE || id_ast->type == AST_MEMORY) && id_ast->children.size() > 0) {
+ else if ((id_ast->type == AST_WIRE || id_ast->type == AST_MEMORY) && id_ast->children.size() > 0) {
// handle packed array left/right for case 1, and cases 2/3 when requesting the last dimension (packed side)
AstNode *wire_range = id_ast->children[0];
left = wire_range->children[0]->integer;
@@ -3419,6 +3445,17 @@ skip_dynamic_range_lvalue_expansion:;
low = min(left, right);
}
if (id_ast->type == AST_MEMORY) {
+ // a slice of our identifier means we advance to the next dimension, e.g. $size(a[3])
+ if (buf->children.size() > 0) {
+ // something is hanging below this identifier
+ if (buf->children[0]->type == AST_RANGE && buf->integer == 0)
+ // if integer == 0, this node was originally created as AST_RANGE so it's dimension is 1
+ dim++;
+ // more than one range, e.g. $size(a[3][2])
+ else // created an AST_MULTIRANGE, converted to AST_RANGE, but original dimension saved in 'integer' field
+ dim += buf->integer; // increment by multirange size
+ }
+
// We got here only if the argument is a memory
// Otherwise $size() and $bits() return the expression width
AstNode *mem_range = id_ast->children[1];
@@ -3478,7 +3515,7 @@ skip_dynamic_range_lvalue_expansion:;
result = right;
else if (str == "\\$size")
result = width;
- else {
+ else { // str == "\\$bits"
result = width * mem_depth;
}
newNode = mkconst_int(result, true);
diff --git a/tests/svtypes/struct_sizebits.sv b/tests/svtypes/struct_sizebits.sv
new file mode 100644
index 000000000..092d9ecef
--- /dev/null
+++ b/tests/svtypes/struct_sizebits.sv
@@ -0,0 +1,112 @@
+// These tests are adapted from tests/sat/sizebits.sv
+
+module top;
+
+typedef struct packed {
+ logic [2:7][3:0] y;
+} sy_t;
+
+struct packed {
+ logic t;
+ logic [5:2] x;
+ sy_t sy;
+ union packed {
+ logic [7:2][2:9][1:4] z;
+ logic [1:6*8*4] z2;
+ } sz;
+} s;
+
+//wire [$size(s.x)-1:0]x_size;
+//wire [$size({s.x, s.x})-1:0]xx_size;
+//wire [$size(s.sy.y)-1:0]y_size;
+//wire [$size(s.sz.z)-1:0]z_size;
+
+//wire [$bits(s.x)-1:0]x_bits;
+//wire [$bits({s.x, s.x})-1:0]xx_bits;
+
+always_comb begin
+ assert ($size(s) == $size(s.t) + $size(s.x) + $size(s.sy) + $size(s.sz));
+ assert ($size(s) == 1 + 4 + 6*4 + 6*8*4);
+
+ assert ($size(s.t) == 1);
+ assert ($size(s.x) == 4);
+`ifndef VERIFIC
+ assert ($size({3{s.x}}) == 3*4);
+`endif
+ assert ($size(s.sy.y) == 6);
+ assert ($size(s.sy.y, 1) == 6);
+ assert ($size(s.sy.y, (1+1)) == 4);
+ assert ($size(s.sy.y[2], 1) == 4);
+ // This is unsupported at the moment
+ // assert ($size(s.sy.y[2][1], 1) == 1);
+
+ assert ($size(s.sz.z) == 6);
+ assert ($size(s.sz.z, 1) == 6);
+ assert ($size(s.sz.z, 2) == 8);
+ assert ($size(s.sz.z, 3) == 4);
+ assert ($size(s.sz.z[3], 1) == 8);
+ assert ($size(s.sz.z[3][3], 1) == 4);
+ // This is unsupported at the moment
+ // assert ($size(s.sz.z[3][3][3], 1) == 1);
+ // This should trigger an error if enabled (it does).
+ // assert ($size(s.sz.z, 4) == 4);
+
+ assert ($bits(s.t) == 1);
+ assert ($bits(s.x) == 4);
+ assert ($bits(s.sy.y) == 4*6);
+ assert ($bits(s.sz.z) == 4*6*8);
+
+ assert ($high(s.x) == 5);
+ assert ($high(s.sy.y) == 7);
+ assert ($high(s.sy.y, 1) == 7);
+ assert ($high(s.sy.y, (1+1)) == 3);
+
+ assert ($high(s.sz.z) == 7);
+ assert ($high(s.sz.z, 1) == 7);
+ assert ($high(s.sz.z, 2) == 9);
+ assert ($high(s.sz.z, 3) == 4);
+ assert ($high(s.sz.z[3]) == 9);
+ assert ($high(s.sz.z[3][3]) == 4);
+ assert ($high(s.sz.z[3], 2) == 4);
+
+ assert ($low(s.x) == 2);
+ assert ($low(s.sy.y) == 2);
+ assert ($low(s.sy.y, 1) == 2);
+ assert ($low(s.sy.y, (1+1)) == 0);
+
+ assert ($low(s.sz.z) == 2);
+ assert ($low(s.sz.z, 1) == 2);
+ assert ($low(s.sz.z, 2) == 2);
+ assert ($low(s.sz.z, 3) == 1);
+ assert ($low(s.sz.z[3]) == 2);
+ assert ($low(s.sz.z[3][3]) == 1);
+ assert ($low(s.sz.z[3], 2) == 1);
+
+ assert ($left(s.x) == 5);
+ assert ($left(s.sy.y) == 2);
+ assert ($left(s.sy.y, 1) == 2);
+ assert ($left(s.sy.y, (1+1)) == 3);
+
+ assert ($left(s.sz.z) == 7);
+ assert ($left(s.sz.z, 1) == 7);
+ assert ($left(s.sz.z, 2) == 2);
+ assert ($left(s.sz.z, 3) == 1);
+ assert ($left(s.sz.z[3]) == 2);
+ assert ($left(s.sz.z[3][3]) == 1);
+ assert ($left(s.sz.z[3], 2) == 1);
+
+ assert ($right(s.x) == 2);
+ assert ($right(s.sy.y) == 7);
+ assert ($right(s.sy.y, 1) == 7);
+ assert ($right(s.sy.y, (1+1)) == 0);
+
+ assert ($right(s.sz.z) == 2);
+ assert ($right(s.sz.z, 1) == 2);
+ assert ($right(s.sz.z, 2) == 9);
+ assert ($right(s.sz.z, 3) == 4);
+ assert ($right(s.sz.z[3]) == 9);
+ assert ($right(s.sz.z[3][3]) == 4);
+ assert ($right(s.sz.z[3], 2) == 4);
+end
+
+endmodule