Add support for packed arrays

Author: rsetaluri

CMakeLists.txt

@@ -21,8 +21,14 @@ include_directories(
   ${PROJECT_SOURCE_DIR}/include/
 ) 
 
-set(LIB_SOURCES src/verilogAST.cpp src/transformer.cpp src/assign_inliner.cpp
-    src/concat_coalescer.cpp src/zext_coalescer.cpp)
+set(LIB_SOURCES
+      src/verilogAST.cpp
+      src/transformer.cpp
+      src/assign_inliner.cpp
+      src/concat_coalescer.cpp
+      src/zext_coalescer.cpp
+      src/make_packed.cpp
+)
 
 set(LIBRARY_NAME verilogAST)
 add_library(${LIBRARY_NAME} SHARED ${LIB_SOURCES})
@@ -74,6 +80,10 @@ if (VERILOGAST_BUILD_TESTS)
     add_executable(zext_coalescer tests/zext_coalescer.cpp)
     target_link_libraries(zext_coalescer gtest_main ${LIBRARY_NAME})
     add_test(NAME zext_coalescer_tests COMMAND zext_coalescer)
+
+    add_executable(make_packed tests/make_packed.cpp)
+    target_link_libraries(make_packed gtest_main ${LIBRARY_NAME})
+    add_test(NAME make_packed_tests COMMAND make_packed)
 endif()
 
 install(TARGETS ${LIBRARY_NAME} DESTINATION lib)

include/verilogAST.hpp

@@ -507,6 +507,21 @@ class NDVector : public Vector {
   ~NDVector(){};
 };
 
+class PackedNDVector : public NDVector {
+ public:
+  PackedNDVector(
+      std::unique_ptr<Identifier> id, std::unique_ptr<Expression> msb,
+      std::unique_ptr<Expression> lsb,
+      std::vector<
+          std::pair<std::unique_ptr<Expression>, std::unique_ptr<Expression>>>
+          outer_dims)
+      : NDVector(std::move(id), std::move(msb), std::move(lsb),
+                 std::move(outer_dims)) {}
+
+  std::string toString() override;
+  ~PackedNDVector() = default;
+};
+
 class Port : public AbstractPort {
  public:
   // Required

include/verilogAST/make_packed.hpp

@@ -0,0 +1,20 @@
+#ifndef VERILOGAST_MAKE_PACKED_H
+#define VERILOGAST_MAKE_PACKED_H
+
+#include "verilogAST.hpp"
+#include "verilogAST/transformer.hpp"
+
+namespace verilogAST {
+
+class MakePacked : public Transformer {
+ public:
+  MakePacked() = default;
+
+  using Transformer::visit;
+
+  std::unique_ptr<Vector> visit(std::unique_ptr<Vector> vector) override;
+};
+
+}  // namespace verilogAST
+
+#endif  // VERILOGAST_MAKE_PACKED_H

src/make_packed.cpp

@@ -0,0 +1,21 @@
+#include "verilogAST/make_packed.hpp"
+#include <cassert>
+
+namespace verilogAST {
+
+std::unique_ptr<Vector> MakePacked::visit(std::unique_ptr<Vector> vector) {
+  auto ptr = dynamic_cast<const NDVector*>(vector.get());
+  if (not ptr) return vector;
+  std::vector<
+      std::pair<std::unique_ptr<Expression>, std::unique_ptr<Expression>>>
+      outer_dims;
+  for (const auto& dim : ptr->outer_dims) {
+    outer_dims.push_back(
+        std::make_pair(dim.first->clone(), dim.second->clone()));
+  }
+  return std::make_unique<PackedNDVector>(ptr->id->clone(), ptr->msb->clone(),
+                                          ptr->lsb->clone(),
+                                          std::move(outer_dims));
+}
+
+}  // namespace verilogAST

src/verilogAST.cpp

@@ -161,6 +161,14 @@ std::string NDVector::toString() {
   return s;
 }
 
+std::string PackedNDVector::toString() {
+  std::string s = "";
+  for (auto &dim : outer_dims) {
+    s += "[" + dim.first->toString() + ":" + dim.second->toString() + "]";
+  }
+  return (s + Vector::toString());
+}
+
 std::string BinaryOp::toString() {
   std::string op_str;
   switch (op) {

tests/basic.cpp

@@ -133,6 +133,17 @@ TEST(BasicTests, TestNDVector) {
   EXPECT_EQ(slice.toString(), "[31:0] x [7:0][15:0]");
 }
 
+TEST(BasicTests, TestPackedNDVector) {
+  std::vector<std::pair<std::unique_ptr<vAST::Expression>,
+                        std::unique_ptr<vAST::Expression>>>
+      outer_dims;
+  outer_dims.push_back({vAST::make_num("7"), vAST::make_num("0")});
+  outer_dims.push_back({vAST::make_num("15"), vAST::make_num("0")});
+  vAST::PackedNDVector slice(vAST::make_id("x"), vAST::make_num("31"),
+                             vAST::make_num("0"), std::move(outer_dims));
+  EXPECT_EQ(slice.toString(), "[7:0][15:0][31:0] x");
+}
+
 TEST(BasicTests, TestBinaryOp) {
   std::vector<std::pair<vAST::BinOp::BinOp, std::string>> ops;
   ops.push_back(std::make_pair(vAST::BinOp::LSHIFT, "<<"));

tests/make_packed.cpp

@@ -0,0 +1,70 @@
+#include "verilogAST/make_packed.hpp"
+#include "common.cpp"
+#include "gtest/gtest.h"
+
+namespace vAST = verilogAST;
+
+namespace {
+
+using BodyElement = std::variant<std::unique_ptr<vAST::StructuralStatement>,
+                                 std::unique_ptr<vAST::Declaration>>;
+using Dim = std::pair<std::unique_ptr<vAST::Expression>,
+                      std::unique_ptr<vAST::Expression>>;
+
+
+Dim makeDim(std::unique_ptr<vAST::Expression> hi,
+            std::unique_ptr<vAST::Expression> lo) {
+  return std::make_pair(std::move(hi), std::move(lo));
+}
+
+TEST(MakePackedTests, TestBasic) {
+  std::vector<std::unique_ptr<vAST::AbstractPort>> ports;
+
+  auto make_dims = []() {
+    std::vector<Dim> dims;
+    dims.push_back(makeDim(vAST::make_num("7"), vAST::make_num("0")));
+    dims.push_back(makeDim(vAST::make_num("15"), vAST::make_num("0")));
+    return dims;
+  };
+  ports.push_back(
+      std::make_unique<vAST::Port>(
+          std::make_unique<vAST::NDVector>(
+              vAST::make_id("I"),
+              vAST::make_num("31"),
+              vAST::make_num("0"),
+              make_dims()),
+          vAST::INPUT,
+          vAST::WIRE));
+
+  std::vector<BodyElement> body;
+
+  std::unique_ptr<vAST::AbstractModule> module = std::make_unique<vAST::Module>(
+      "test_module",
+      std::move(ports),
+      std::move(body));
+
+  auto pre =
+      "module test_module (\n"
+      "    input [31:0] I [7:0][15:0]\n"
+      ");\n"
+      "endmodule\n";
+  EXPECT_EQ(module->toString(), pre);
+
+  // Run MakePacked transformer.
+  vAST::MakePacked transformer {};
+  module = transformer.visit(std::move(module));
+
+  auto post =
+      "module test_module (\n"
+      "    input [7:0][15:0][31:0] I\n"
+      ");\n"
+      "endmodule\n";
+  EXPECT_EQ(module->toString(), post);
+}
+
+}  // namespace
+
+int main(int argc, char **argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}