From bab88630c28b43851162772c2ce35666357d8933 Mon Sep 17 00:00:00 2001 From: Dag Lem Date: Sat, 12 Nov 2022 08:48:25 +0100 Subject: Support for arrays with swapped ranges within structs This also corrects the implementation of C type arrays within structs. Fixes #3550 --- frontends/ast/simplify.cc | 40 +++++++++++++++++++++++++++++++--------- 1 file changed, 31 insertions(+), 9 deletions(-) (limited to 'frontends/ast/simplify.cc') diff --git a/frontends/ast/simplify.cc b/frontends/ast/simplify.cc index 49bf9af09..923aaa156 100644 --- a/frontends/ast/simplify.cc +++ b/frontends/ast/simplify.cc @@ -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; -- cgit v1.2.3 From ddb12148e74ba898dcb3bc729db691090e1524a2 Mon Sep 17 00:00:00 2001 From: Dag Lem Date: Wed, 23 Nov 2022 16:31:08 +0100 Subject: Support for swapped ranges in second array dimension --- frontends/ast/simplify.cc | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) (limited to 'frontends/ast/simplify.cc') diff --git a/frontends/ast/simplify.cc b/frontends/ast/simplify.cc index 923aaa156..c8958c646 100644 --- a/frontends/ast/simplify.cc +++ b/frontends/ast/simplify.cc @@ -465,10 +465,17 @@ static AstNode *make_struct_index_range(AstNode *node, AstNode *rnode, int strid } } -static AstNode *slice_range(AstNode *rnode, AstNode *snode) +static AstNode *slice_range(AstNode *rnode, AstNode *snode, AstNode *member_node) { + if (member_node->multirange_swapped[1]) { + // The second dimension has swapped range; swap index into the struct accordingly. + int msb = member_node->multirange_dimensions[1] - 1; + for (auto &expr : snode->children) { + expr = new AstNode(AST_SUB, node_int(msb), expr); + } + } + // 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]; @@ -504,7 +511,7 @@ AstNode *AST::make_struct_member_range(AstNode *node, AstNode *member_node) auto mrnode = node->children[0]; 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]); + auto range = slice_range(element_range, mrnode->children[1], member_node); delete element_range; return range; } -- cgit v1.2.3 From 15c8e74329deed3191a0c8aeadc4b741e761e9c6 Mon Sep 17 00:00:00 2001 From: Dag Lem Date: Wed, 30 Nov 2022 20:04:45 +0100 Subject: Check for all cases of currently unsupported array dimensions in packed structs --- frontends/ast/simplify.cc | 23 +++++++++++++---------- 1 file changed, 13 insertions(+), 10 deletions(-) (limited to 'frontends/ast/simplify.cc') diff --git a/frontends/ast/simplify.cc b/frontends/ast/simplify.cc index c8958c646..a10d19c17 100644 --- a/frontends/ast/simplify.cc +++ b/frontends/ast/simplify.cc @@ -273,9 +273,9 @@ static int range_width(AstNode *node, AstNode *rnode) return rnode->range_left - rnode->range_right + 1; } -[[noreturn]] static void struct_array_packing_error(AstNode *node) +[[noreturn]] static void struct_array_dimension_error(AstNode *node) { - log_file_error(node->filename, node->location.first_line, "Unpacked array in packed struct/union member %s\n", node->str.c_str()); + log_file_error(node->filename, node->location.first_line, "Currently limited to two dimensions in packed struct/union member %s\n", node->str.c_str()); } static void save_struct_array_width(AstNode *node, int width) @@ -324,10 +324,12 @@ static int size_packed_struct(AstNode *snode, int base_offset) // member width e.g. bit [7:0] a width = range_width(node, node->children[0]); if (node->children.size() == 2) { + // Unpacked array. Note that this is a Yosys extension; only packed data types + // and integer data types are allowed in packed structs / unions in SystemVerilog. if (node->children[1]->type == AST_RANGE) { - // unpacked array e.g. bit [63:0] a [0:3] + // Unpacked array, e.g. bit [63:0] a [0:3] auto rnode = node->children[1]; - // C-type array size e.g. bit [63:0] a [4] + // C-style 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); @@ -337,10 +339,11 @@ static int size_packed_struct(AstNode *snode, int base_offset) width *= array_count; } else { - // array element must be single bit for a packed array - struct_array_packing_error(node); + // Currently limited to at most two dimensions. + struct_array_dimension_error(node); } } else { + // Vector. save_struct_array_width(node, width); save_struct_range_swapped(node, node->children[0]->range_swapped); } @@ -349,12 +352,12 @@ static int size_packed_struct(AstNode *snode, int base_offset) delete child; node->children.clear(); } - else if (node->children.size() == 1 && node->children[0]->type == AST_MULTIRANGE) { + else if (node->children.size() > 0 && node->children[0]->type == AST_MULTIRANGE) { // packed 2D array, e.g. bit [3:0][63:0] a auto rnode = node->children[0]; - if (rnode->children.size() != 2) { - // packed arrays can only be 2D - struct_array_packing_error(node); + if (node->children.size() != 1 || rnode->children.size() != 2) { + // Currently limited to at most two dimensions. + struct_array_dimension_error(node); } int array_count = range_width(node, rnode->children[0]); save_struct_array_width(node, array_count); -- cgit v1.2.3 From 64f88eb7f120554ab662baf608b6f48d5eec3e6d Mon Sep 17 00:00:00 2001 From: Dag Lem Date: Wed, 30 Nov 2022 23:32:41 +0100 Subject: Added asserts for current limitation of array dimensions in packed structs --- frontends/ast/simplify.cc | 8 ++++++++ 1 file changed, 8 insertions(+) (limited to 'frontends/ast/simplify.cc') diff --git a/frontends/ast/simplify.cc b/frontends/ast/simplify.cc index a10d19c17..63212a9ed 100644 --- a/frontends/ast/simplify.cc +++ b/frontends/ast/simplify.cc @@ -293,6 +293,8 @@ static void save_struct_range_swapped(AstNode *node, bool range_swapped) static int get_struct_array_width(AstNode *node) { + // This function is only useful for up to two array dimensions. + log_assert(node->multirange_dimensions.size() <= 2); // the stride for the array, 1 if not an array return (node->multirange_dimensions.size() != 2 ? 1 : node->multirange_dimensions[1]); @@ -446,6 +448,8 @@ static AstNode *offset_indexed_range(int offset, int stride, AstNode *left_expr, static AstNode *make_struct_index_range(AstNode *node, AstNode *rnode, int stride, int offset, AstNode *member_node) { + // This function should be rewritten to support more than two array dimensions. + log_assert(member_node->multirange_dimensions.size() <= 2 && member_node->multirange_swapped.size() <= 2); 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; @@ -470,6 +474,8 @@ static AstNode *make_struct_index_range(AstNode *node, AstNode *rnode, int strid static AstNode *slice_range(AstNode *rnode, AstNode *snode, AstNode *member_node) { + // This function should be rewritten to support more than two array dimensions. + log_assert(member_node->multirange_dimensions.size() <= 2 && member_node->multirange_swapped.size() <= 2); if (member_node->multirange_swapped[1]) { // The second dimension has swapped range; swap index into the struct accordingly. int msb = member_node->multirange_dimensions[1] - 1; @@ -503,6 +509,8 @@ AstNode *AST::make_struct_member_range(AstNode *node, AstNode *member_node) // no range operations apply, return the whole width return make_range(range_left, range_right); } + // This function should be rewritten to support more than two array dimensions. + log_assert(member_node->multirange_dimensions.size() <= 2 && member_node->multirange_swapped.size() <= 2); 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] -- cgit v1.2.3