mirror of https://github.com/YosysHQ/yosys.git
Support for arrays with swapped ranges within structs
This also corrects the implementation of C type arrays within structs. Fixes #3550
This commit is contained in:
parent
a217450524
commit
bab88630c2
|
@ -203,7 +203,7 @@ namespace AST
|
|||
|
||||
// if this is a multirange memory then this vector contains offset and length of each dimension
|
||||
std::vector<int> multirange_dimensions;
|
||||
std::vector<bool> multirange_swapped; // true if range is swapped, not used for structs
|
||||
std::vector<bool> multirange_swapped; // true if range is swapped
|
||||
|
||||
// this is set by simplify and used during RTLIL generation
|
||||
AstNode *id2ast;
|
||||
|
|
|
@ -285,10 +285,16 @@ static void save_struct_array_width(AstNode *node, int width)
|
|||
|
||||
}
|
||||
|
||||
static void save_struct_range_swapped(AstNode *node, bool range_swapped)
|
||||
{
|
||||
node->multirange_swapped.push_back(range_swapped);
|
||||
|
||||
}
|
||||
|
||||
static int get_struct_array_width(AstNode *node)
|
||||
{
|
||||
// the stride for the array, 1 if not an array
|
||||
return (node->multirange_dimensions.empty() ? 1 : node->multirange_dimensions.back());
|
||||
return (node->multirange_dimensions.size() != 2 ? 1 : node->multirange_dimensions[1]);
|
||||
|
||||
}
|
||||
|
||||
|
@ -321,18 +327,22 @@ static int size_packed_struct(AstNode *snode, int base_offset)
|
|||
if (node->children[1]->type == AST_RANGE) {
|
||||
// unpacked array e.g. bit [63:0] a [0:3]
|
||||
auto rnode = node->children[1];
|
||||
int array_count = range_width(node, rnode);
|
||||
if (array_count == 1) {
|
||||
// C-type array size e.g. bit [63:0] a [4]
|
||||
array_count = rnode->range_left;
|
||||
}
|
||||
// C-type array size e.g. bit [63:0] a [4]
|
||||
bool c_type = rnode->children.size() == 1;
|
||||
int array_count = c_type ? rnode->range_left : range_width(node, rnode);
|
||||
save_struct_array_width(node, array_count);
|
||||
save_struct_range_swapped(node, rnode->range_swapped || c_type);
|
||||
save_struct_array_width(node, width);
|
||||
save_struct_range_swapped(node, node->children[0]->range_swapped);
|
||||
width *= array_count;
|
||||
}
|
||||
else {
|
||||
// array element must be single bit for a packed array
|
||||
struct_array_packing_error(node);
|
||||
}
|
||||
} else {
|
||||
save_struct_array_width(node, width);
|
||||
save_struct_range_swapped(node, node->children[0]->range_swapped);
|
||||
}
|
||||
// range nodes are now redundant
|
||||
for (AstNode *child : node->children)
|
||||
|
@ -347,8 +357,11 @@ static int size_packed_struct(AstNode *snode, int base_offset)
|
|||
struct_array_packing_error(node);
|
||||
}
|
||||
int array_count = range_width(node, rnode->children[0]);
|
||||
save_struct_array_width(node, array_count);
|
||||
save_struct_range_swapped(node, rnode->children[0]->range_swapped);
|
||||
width = range_width(node, rnode->children[1]);
|
||||
save_struct_array_width(node, width);
|
||||
save_struct_range_swapped(node, rnode->children[1]->range_swapped);
|
||||
width *= array_count;
|
||||
// range nodes are now redundant
|
||||
for (AstNode *child : node->children)
|
||||
|
@ -428,8 +441,16 @@ static AstNode *offset_indexed_range(int offset, int stride, AstNode *left_expr,
|
|||
return new AstNode(AST_RANGE, left, right);
|
||||
}
|
||||
|
||||
static AstNode *make_struct_index_range(AstNode *node, AstNode *rnode, int stride, int offset)
|
||||
static AstNode *make_struct_index_range(AstNode *node, AstNode *rnode, int stride, int offset, AstNode *member_node)
|
||||
{
|
||||
if (member_node->multirange_swapped[0]) {
|
||||
// The struct item has swapped range; swap index into the struct accordingly.
|
||||
int msb = member_node->multirange_dimensions[0] - 1;
|
||||
for (auto &expr : rnode->children) {
|
||||
expr = new AstNode(AST_SUB, node_int(msb), expr);
|
||||
}
|
||||
}
|
||||
|
||||
// generate a range node to perform either bit or array indexing
|
||||
if (rnode->children.size() == 1) {
|
||||
// index e.g. s.a[i]
|
||||
|
@ -447,6 +468,7 @@ static AstNode *make_struct_index_range(AstNode *node, AstNode *rnode, int strid
|
|||
static AstNode *slice_range(AstNode *rnode, AstNode *snode)
|
||||
{
|
||||
// apply the bit slice indicated by snode to the range rnode
|
||||
// TODO: Check for swapped indexes - see make_struct_index_range
|
||||
log_assert(rnode->type==AST_RANGE);
|
||||
auto left = rnode->children[0];
|
||||
auto right = rnode->children[1];
|
||||
|
@ -474,13 +496,13 @@ AstNode *AST::make_struct_member_range(AstNode *node, AstNode *member_node)
|
|||
int stride = get_struct_array_width(member_node);
|
||||
if (node->children.size() == 1 && node->children[0]->type == AST_RANGE) {
|
||||
// bit or array indexing e.g. s.a[2] or s.a[1:0]
|
||||
return make_struct_index_range(node, node->children[0], stride, range_right);
|
||||
return make_struct_index_range(node, node->children[0], stride, range_right, member_node);
|
||||
}
|
||||
else if (node->children.size() == 1 && node->children[0]->type == AST_MULTIRANGE) {
|
||||
// multirange, i.e. bit slice after array index, e.g. s.a[i][p:q]
|
||||
log_assert(stride > 1);
|
||||
auto mrnode = node->children[0];
|
||||
auto element_range = make_struct_index_range(node, mrnode->children[0], stride, range_right);
|
||||
auto element_range = make_struct_index_range(node, mrnode->children[0], stride, range_right, member_node);
|
||||
// then apply bit slice range
|
||||
auto range = slice_range(element_range, mrnode->children[1]);
|
||||
delete element_range;
|
||||
|
|
|
@ -1,7 +1,6 @@
|
|||
// test for array indexing in structures
|
||||
|
||||
module top;
|
||||
|
||||
struct packed {
|
||||
bit [5:0] [7:0] a; // 6 element packed array of bytes
|
||||
bit [15:0] b; // filler for non-zero offset
|
||||
|
@ -39,4 +38,90 @@ module top;
|
|||
|
||||
always_comb assert(s2==80'hFC00_4200_0012_3400_FFFC);
|
||||
|
||||
// Same as s2, but with little endian addressing
|
||||
struct packed {
|
||||
bit [0:7] [7:0] a; // 8 element packed array of bytes
|
||||
bit [0:15] b; // filler for non-zero offset
|
||||
} s3;
|
||||
|
||||
initial begin
|
||||
s3 = '0;
|
||||
|
||||
s3.a[5:6] = 16'h1234;
|
||||
s3.a[2] = 8'h42;
|
||||
|
||||
s3.a[0] = '1;
|
||||
s3.a[0][1:0] = '0;
|
||||
|
||||
s3.b = '1;
|
||||
s3.b[14:15] = '0;
|
||||
end
|
||||
|
||||
always_comb assert(s3==80'hFC00_4200_0012_3400_FFFC);
|
||||
|
||||
// Note that the tests below for unpacked arrays in structs rely on the
|
||||
// fact that they are actually packed in Yosys.
|
||||
|
||||
// Same as s2, but using unpacked array syntax
|
||||
struct packed {
|
||||
bit [7:0] a [7:0]; // 8 element unpacked array of bytes
|
||||
bit [15:0] b; // filler for non-zero offset
|
||||
} s4;
|
||||
|
||||
initial begin
|
||||
s4 = '0;
|
||||
|
||||
s4.a[2:1] = 16'h1234;
|
||||
s4.a[5] = 8'h42;
|
||||
|
||||
s4.a[7] = '1;
|
||||
s4.a[7][1:0] = '0;
|
||||
|
||||
s4.b = '1;
|
||||
s4.b[1:0] = '0;
|
||||
end
|
||||
|
||||
always_comb assert(s4==80'hFC00_4200_0012_3400_FFFC);
|
||||
|
||||
// Same as s3, but using unpacked array syntax
|
||||
struct packed {
|
||||
bit [7:0] a [0:7]; // 8 element unpacked array of bytes
|
||||
bit [0:15] b; // filler for non-zero offset
|
||||
} s5;
|
||||
|
||||
initial begin
|
||||
s5 = '0;
|
||||
|
||||
s5.a[5:6] = 16'h1234;
|
||||
s5.a[2] = 8'h42;
|
||||
|
||||
s5.a[0] = '1;
|
||||
s5.a[0][1:0] = '0;
|
||||
|
||||
s5.b = '1;
|
||||
s5.b[14:15] = '0;
|
||||
end
|
||||
|
||||
always_comb assert(s5==80'hFC00_4200_0012_3400_FFFC);
|
||||
|
||||
// Same as s5, but using C-type unpacked array syntax
|
||||
struct packed {
|
||||
bit [7:0] a [8]; // 8 element unpacked array of bytes
|
||||
bit [0:15] b; // filler for non-zero offset
|
||||
} s6;
|
||||
|
||||
initial begin
|
||||
s6 = '0;
|
||||
|
||||
s6.a[5:6] = 16'h1234;
|
||||
s6.a[2] = 8'h42;
|
||||
|
||||
s6.a[0] = '1;
|
||||
s6.a[0][1:0] = '0;
|
||||
|
||||
s6.b = '1;
|
||||
s6.b[14:15] = '0;
|
||||
end
|
||||
|
||||
always_comb assert(s6==80'hFC00_4200_0012_3400_FFFC);
|
||||
endmodule
|
||||
|
|
Loading…
Reference in New Issue