Fixup always body type

leonardt · Jun 5, 2020 · 0b5147f · 0b5147f
1 parent bddf270
commit 0b5147f
Show file tree

Hide file tree

Showing 9 changed files with 74 additions and 36 deletions.
diff --git a/include/verilogAST.hpp b/include/verilogAST.hpp
@@ -748,17 +748,13 @@ class Always : public StructuralStatement {
       std::variant<std::unique_ptr<Identifier>, std::unique_ptr<PosEdge>,
                    std::unique_ptr<NegEdge>, std::unique_ptr<Star>>>
       sensitivity_list;
-  std::vector<std::variant<std::unique_ptr<BehavioralStatement>,
-                           std::unique_ptr<Declaration>>>
-      body;
+  std::vector<std::unique_ptr<BehavioralStatement>> body;
 
   Always(std::vector<
              std::variant<std::unique_ptr<Identifier>, std::unique_ptr<PosEdge>,
                           std::unique_ptr<NegEdge>, std::unique_ptr<Star>>>
              sensitivity_list,
-         std::vector<std::variant<std::unique_ptr<BehavioralStatement>,
-                                  std::unique_ptr<Declaration>>>
-             body)
+         std::vector<std::unique_ptr<BehavioralStatement>> body)
       : body(std::move(body)) {
     if (sensitivity_list.empty()) {
       throw std::runtime_error(

diff --git a/include/verilogAST/assign_inliner.hpp b/include/verilogAST/assign_inliner.hpp
@@ -30,6 +30,8 @@ class AssignMapBuilder : public Transformer {
   virtual std::unique_ptr<Port> visit(std::unique_ptr<Port> node);
   virtual std::unique_ptr<ContinuousAssign> visit(
       std::unique_ptr<ContinuousAssign> node);
+  virtual std::unique_ptr<BlockingAssign> visit(
+      std::unique_ptr<BlockingAssign> node);
 };
 
 class WireReadCounter : public Transformer {
@@ -47,6 +49,8 @@ class WireReadCounter : public Transformer {
   // Skip target of assign (not read)
   virtual std::unique_ptr<ContinuousAssign> visit(
       std::unique_ptr<ContinuousAssign> node);
+  virtual std::unique_ptr<BlockingAssign> visit(
+      std::unique_ptr<BlockingAssign> node);
   // Skip declarations (not read)
   virtual std::unique_ptr<Declaration> visit(std::unique_ptr<Declaration> node);
 };
@@ -96,6 +100,8 @@ class AssignInliner : public Transformer {
   virtual std::unique_ptr<Expression> visit(std::unique_ptr<Expression> node);
   virtual std::unique_ptr<ContinuousAssign> visit(
       std::unique_ptr<ContinuousAssign> node);
+  virtual std::unique_ptr<BlockingAssign> visit(
+      std::unique_ptr<BlockingAssign> node);
   virtual std::unique_ptr<Wire> visit(std::unique_ptr<Wire> node);
   virtual std::unique_ptr<Module> visit(std::unique_ptr<Module> node);
 };

diff --git a/src/assign_inliner.cpp b/src/assign_inliner.cpp
@@ -35,6 +35,12 @@ std::unique_ptr<ContinuousAssign> WireReadCounter::visit(
   return node;
 }
 
+std::unique_ptr<BlockingAssign> WireReadCounter::visit(
+    std::unique_ptr<BlockingAssign> node) {
+  node->value = this->visit(std::move(node->value));
+  return node;
+}
+
 std::unique_ptr<Port> AssignMapBuilder::visit(std::unique_ptr<Port> node) {
   std::string port_str = std::visit(
       [](auto&& value) -> std::string {
@@ -58,6 +64,17 @@ std::unique_ptr<Port> AssignMapBuilder::visit(std::unique_ptr<Port> node) {
   return node;
 }
 
+std::unique_ptr<BlockingAssign> AssignMapBuilder::visit(
+    std::unique_ptr<BlockingAssign> node) {
+  node = Transformer::visit(std::move(node));
+  std::string key =
+      std::visit([](auto&& value) -> std::string { return value->toString(); },
+                 node->target);
+  this->assign_map[key] = node->value->clone();
+  this->assign_count[key]++;
+  return node;
+}
+
 std::unique_ptr<ContinuousAssign> AssignMapBuilder::visit(
     std::unique_ptr<ContinuousAssign> node) {
   node = Transformer::visit(std::move(node));
@@ -136,6 +153,30 @@ std::unique_ptr<ContinuousAssign> AssignInliner::visit(
   return node;
 }
 
+std::unique_ptr<BlockingAssign> AssignInliner::visit(
+    std::unique_ptr<BlockingAssign> node) {
+  node->value = this->visit(std::move(node->value));
+  std::string key =
+      std::visit([](auto&& value) -> std::string { return value->toString(); },
+                 node->target);
+  bool remove = false;
+  std::visit(
+      [&](auto&& value) {
+        if (auto ptr = dynamic_cast<Identifier*>(value.get())) {
+          if (this->can_inline(key) && this->non_input_ports.count(key) == 0) {
+            remove = true;
+          } else if (this->inlined_outputs.count(ptr->toString())) {
+            remove = true;
+          };
+        }
+      },
+      node->target);
+  if (remove) {
+    return std::unique_ptr<BlockingAssign>{};
+  }
+  return node;
+}
+
 std::vector<std::variant<std::unique_ptr<StructuralStatement>,
                          std::unique_ptr<Declaration>>>
 AssignInliner::do_inline(

diff --git a/src/transformer.cpp b/src/transformer.cpp
@@ -342,9 +342,7 @@ std::unique_ptr<Always> Transformer::visit(std::unique_ptr<Always> node) {
     new_sensitivity_list.push_back(this->visit(std::move(item)));
   }
   node->sensitivity_list = std::move(new_sensitivity_list);
-  std::vector<std::variant<std::unique_ptr<BehavioralStatement>,
-                           std::unique_ptr<Declaration>>>
-      new_body;
+  std::vector<std::unique_ptr<BehavioralStatement>> new_body;
   for (auto&& item : node->body) {
     new_body.push_back(this->visit(std::move(item)));
   }

diff --git a/src/verilogAST.cpp b/src/verilogAST.cpp
@@ -414,9 +414,7 @@ std::string Always::toString() {
 
   // emit body
   for (auto &statement : body) {
-    always_str += variant_to_string<std::unique_ptr<BehavioralStatement>,
-                                    std::unique_ptr<Declaration>>(statement) +
-                  "\n";
+    always_str += statement->toString() + "\n";
   }
 
   always_str += "end\n";

diff --git a/tests/assign_inliner.cpp b/tests/assign_inliner.cpp
@@ -51,6 +51,10 @@ TEST(InlineAssignTests, TestBasic) {
       std::make_unique<vAST::Identifier>("o_vec"),
       std::make_unique<vAST::Identifier>("x_vec")));
 
+  std::vector<std::variant<std::unique_ptr<vAST::BehavioralStatement>,
+                           std::unique_ptr<vAST::Declaration>>>
+      always_body;
+
   std::unique_ptr<vAST::AbstractModule> module = std::make_unique<vAST::Module>(
       "test_module", std::move(ports), std::move(body));
 
@@ -540,14 +544,14 @@ TEST(InlineAssignTests, TestMultipleAssign) {
 TEST(InlineAssignTests, TestInstConn) {
   // Should not inline a wire that is assigned multiple times
   std::vector<std::unique_ptr<vAST::AbstractPort>> ports;
-  ports.push_back(std::make_unique<vAST::Port>(vAST::make_id("i"),
-                                               vAST::INPUT, vAST::WIRE));
-  ports.push_back(std::make_unique<vAST::Port>(vAST::make_id("a"),
-                                               vAST::INPUT, vAST::WIRE));
-  ports.push_back(std::make_unique<vAST::Port>(vAST::make_id("o"),
-                                               vAST::OUTPUT, vAST::WIRE));
-  ports.push_back(std::make_unique<vAST::Port>(vAST::make_id("b"),
-                                               vAST::OUTPUT, vAST::WIRE));
+  ports.push_back(std::make_unique<vAST::Port>(vAST::make_id("i"), vAST::INPUT,
+                                               vAST::WIRE));
+  ports.push_back(std::make_unique<vAST::Port>(vAST::make_id("a"), vAST::INPUT,
+                                               vAST::WIRE));
+  ports.push_back(std::make_unique<vAST::Port>(vAST::make_id("o"), vAST::OUTPUT,
+                                               vAST::WIRE));
+  ports.push_back(std::make_unique<vAST::Port>(vAST::make_id("b"), vAST::OUTPUT,
+                                               vAST::WIRE));
 
   std::vector<std::variant<std::unique_ptr<vAST::StructuralStatement>,
                            std::unique_ptr<vAST::Declaration>>>
@@ -568,7 +572,8 @@ TEST(InlineAssignTests, TestInstConn) {
       std::make_unique<vAST::Identifier>("a")));
 
   vAST::Parameters parameters;
-  std::unique_ptr<vAST::Connections> connections = std::make_unique<vAST::Connections>();
+  std::unique_ptr<vAST::Connections> connections =
+      std::make_unique<vAST::Connections>();
   connections->insert("c", vAST::make_id("a"));
   connections->insert("i", vAST::make_id("x"));
   connections->insert("o", vAST::make_id("y"));
@@ -626,12 +631,12 @@ TEST(InlineAssignTests, TestInstConn) {
 TEST(InlineAssignTests, TestNoInlineIndex) {
   std::vector<std::unique_ptr<vAST::AbstractPort>> ports;
   ports.push_back(std::make_unique<vAST::Port>(
-      std::make_unique<vAST::Vector>(vAST::make_id("i1"),
-                                     vAST::make_num("1"), vAST::make_num("0")),
+      std::make_unique<vAST::Vector>(vAST::make_id("i1"), vAST::make_num("1"),
+                                     vAST::make_num("0")),
       vAST::INPUT, vAST::WIRE));
   ports.push_back(std::make_unique<vAST::Port>(
-      std::make_unique<vAST::Vector>(vAST::make_id("i2"),
-                                     vAST::make_num("1"), vAST::make_num("0")),
+      std::make_unique<vAST::Vector>(vAST::make_id("i2"), vAST::make_num("1"),
+                                     vAST::make_num("0")),
       vAST::INPUT, vAST::WIRE));
   ports.push_back(std::make_unique<vAST::Port>(vAST::make_id("o"), vAST::OUTPUT,
                                                vAST::WIRE));

diff --git a/tests/basic.cpp b/tests/basic.cpp
@@ -487,9 +487,7 @@ TEST(BasicTests, TestAlwaysEmpty) {
       std::unique_ptr<vAST::Identifier>, std::unique_ptr<vAST::PosEdge>,
       std::unique_ptr<vAST::NegEdge>, std::unique_ptr<vAST::Star>>>
       sensitivity_list;
-  std::vector<std::variant<std::unique_ptr<vAST::BehavioralStatement>,
-                           std::unique_ptr<vAST::Declaration>>>
-      body;
+  std::vector<std::unique_ptr<vAST::BehavioralStatement>> body;
 
   ASSERT_THROW(
       vAST::Always always_empty(std::move(sensitivity_list), std::move(body)),

diff --git a/tests/common.cpp b/tests/common.cpp
@@ -49,12 +49,9 @@ make_simple_body() {
   return body;
 }
 
-std::vector<std::variant<std::unique_ptr<vAST::BehavioralStatement>,
-                         std::unique_ptr<vAST::Declaration>>>
+std::vector<std::unique_ptr<vAST::BehavioralStatement>>
 make_simple_always_body() {
-  std::vector<std::variant<std::unique_ptr<vAST::BehavioralStatement>,
-                           std::unique_ptr<vAST::Declaration>>>
-      body;
+  std::vector<std::unique_ptr<vAST::BehavioralStatement>> body;
   body.push_back(std::make_unique<vAST::BlockingAssign>(
       std::make_unique<vAST::Identifier>("a"),
       std::make_unique<vAST::Identifier>("b")));

diff --git a/tests/transformer.cpp b/tests/transformer.cpp
@@ -122,9 +122,8 @@ TEST(TransformerTests, TestAlways) {
       std::make_unique<vAST::NegEdge>(std::make_unique<vAST::Identifier>("c")));
   sensitivity_list.push_back(std::make_unique<vAST::Star>());
 
-  std::vector<std::variant<std::unique_ptr<vAST::BehavioralStatement>,
-                           std::unique_ptr<vAST::Declaration>>>
-      always_body = make_simple_always_body();
+  std::vector<std::unique_ptr<vAST::BehavioralStatement>> always_body =
+      make_simple_always_body();
   always_body.push_back(
       std::make_unique<vAST::SingleLineComment>("Test comment"));
   always_body.push_back(