[#83887] Remove function/task arguments

Signed-off-by: Artur Bieniek <abieniek@internships.antmicro.com>

Author: ArturBieniek4

CMakeLists.txt

@@ -11,7 +11,7 @@ FetchContent_Declare(
 )
 FetchContent_MakeAvailable(slang)
 
-add_executable(sv-bugpoint source/SvBugpoint.cpp source/Utils.cpp source/PairRemovers.cpp source/BodyRemover.cpp source/LabelRemover.cpp
+add_executable(sv-bugpoint source/SvBugpoint.cpp source/Utils.cpp source/PairRemovers.cpp source/SetRemovers.cpp source/BodyRemover.cpp source/LabelRemover.cpp
   source/BodyPartsRemover.cpp source/DeclRemover.cpp source/InstantationRemover.cpp source/BindRemover.cpp source/ModportRemover.cpp source/ContAssignRemover.cpp source/ParamAssignRemover.cpp source/ModuleRemover.cpp
   source/StatementsRemover.cpp source/MemberRemover.cpp source/ImportsRemover.cpp source/TypeSimplifier.cpp)
 

source/PairRemovers.hpp

@@ -4,7 +4,7 @@
 #include "Utils.hpp"
 
 class PairRemover : public SyntaxRewriter<PairRemover> {
-    // each tranform yields removal of pair of nodes (based on locations in suplied pairs list)
+    // each tranform yields removal of pair of nodes (based on locations in supplied pairs list)
    public:
     std::vector<std::pair<SourceRange, SourceRange>> pairs;
     std::pair<SourceRange, SourceRange> searchedPair;

source/SetRemovers.cpp

@@ -0,0 +1,136 @@
+// SPDX-License-Identifier: Apache-2.0
+#include "SetRemovers.hpp"
+#include <slang/ast/ASTVisitor.h>
+#include <unordered_map>
+
+class FunctionArgMapper : public ASTVisitor<FunctionArgMapper, true, true, true> {
+    // Builds vector that maps the argument in definition to all calls
+   public:
+    std::vector<SetRemover::RemovalSet> removals;
+
+    void handle(const SubroutineSymbol& subroutine) {
+        if (shouldProcess(subroutine)) {
+            for (const FormalArgumentSymbol* arg : subroutine.getArguments()) {
+                registerFormal(arg);
+            }
+        }
+
+        visitDefault(subroutine);
+    }
+
+    void handle(const MethodPrototypeSymbol& prototype) {
+        if (shouldProcess(prototype)) {
+            for (const FormalArgumentSymbol* arg : prototype.getArguments()) {
+                registerFormal(arg);
+            }
+        }
+
+        visitDefault(prototype);
+    }
+
+    void handle(const CallExpression& call) {
+        const SubroutineSymbol* subroutine = getSubroutine(call);
+        if (!subroutine || !shouldProcess(*subroutine)) {
+            visitDefault(call);
+            return;
+        }
+
+        auto formals = subroutine->getArguments();
+        auto actuals = call.arguments();
+        size_t count = std::min(formals.size(), actuals.size());
+        for (size_t idx = 0; idx < count; idx++) {
+            size_t removalIdx = registerFormal(formals[idx]);
+            if (removalIdx == invalidIndex) {
+                continue;
+            }
+
+            if (const SyntaxNode* argNode = getArgumentNode(actuals[idx])) {
+                removals[removalIdx].push_back(argNode);
+            }
+        }
+
+        visitDefault(call);
+    }
+
+   private:
+    static constexpr size_t invalidIndex = std::numeric_limits<size_t>::max();
+    std::unordered_map<const FormalArgumentSymbol*, size_t> indexByFormal;
+
+    size_t registerFormal(const FormalArgumentSymbol* formal) {
+        if (!formal) {
+            return invalidIndex;
+        }
+
+        if (auto it = indexByFormal.find(formal); it != indexByFormal.end()) {
+            return it->second;
+        }
+
+        const SyntaxNode* node = getFormalNode(*formal);
+        if (!node) {
+            indexByFormal.emplace(formal, invalidIndex);
+            return invalidIndex;
+        }
+
+        SetRemover::RemovalSet set;
+        set.push_back(node);
+        removals.push_back(std::move(set));
+        size_t idx = removals.size() - 1;
+        indexByFormal.emplace(formal, idx);
+        return idx;
+    }
+
+    static const SyntaxNode* getFormalNode(const FormalArgumentSymbol& formal) {
+        if (auto syntax = formal.getSyntax()) {
+            if (syntax->parent) {
+                return syntax->parent;
+            }
+            return syntax;
+        }
+        return nullptr;
+    }
+
+    static const SyntaxNode* getArgumentNode(const Expression* expr) {
+        if (!expr || !expr->syntax) {
+            return nullptr;
+        }
+
+        const SyntaxNode* node = expr->syntax;
+        while (node) {
+            if (node->kind == SyntaxKind::OrderedArgument ||
+                node->kind == SyntaxKind::NamedArgument) {
+                return node;
+            }
+            node = node->parent;
+        }
+        return nullptr;
+    }
+
+    static const SubroutineSymbol* getSubroutine(const CallExpression& call) {
+        if (call.isSystemCall()) {
+            return nullptr;
+        }
+        if (std::holds_alternative<const SubroutineSymbol*>(call.subroutine)) {
+            return std::get<const SubroutineSymbol*>(call.subroutine);
+        }
+        return nullptr;
+    }
+
+    static bool shouldProcess(const SubroutineSymbol& subroutine) {
+        return subroutine.subroutineKind == SubroutineKind::Function ||
+               subroutine.subroutineKind == SubroutineKind::Task;
+    }
+
+    static bool shouldProcess(const MethodPrototypeSymbol& prototype) {
+        return prototype.subroutineKind == SubroutineKind::Function ||
+               prototype.subroutineKind == SubroutineKind::Task;
+    }
+};
+
+SetRemover makeFunctionArgRemover(std::shared_ptr<SyntaxTree> tree) {
+    Compilation compilation;
+    compilation.addSyntaxTree(tree);
+    compilation.getAllDiagnostics();
+    FunctionArgMapper mapper;
+    compilation.getRoot().visit(mapper);
+    return SetRemover(std::move(mapper.removals));
+}

source/SetRemovers.hpp

@@ -0,0 +1,82 @@
+// SPDX-License-Identifier: Apache-2.0
+#pragma once
+#include <slang/syntax/SyntaxVisitor.h>
+#include "Utils.hpp"
+
+class SetRemover : public SyntaxRewriter<SetRemover> {
+    // each transform yields removal of a set of nodes (based on locations in supplied sets list)
+   public:
+    using RemovalSet = std::vector<const slang::syntax::SyntaxNode*>;
+
+    std::vector<RemovalSet> removals;
+    std::unordered_set<const slang::syntax::SyntaxNode*> pendingNodes;
+    std::string removedTypeInfo;
+
+    SetRemover(std::vector<RemovalSet>&& removals) : removals(removals) {}
+
+    std::shared_ptr<SyntaxTree> transform(const std::shared_ptr<SyntaxTree>& tree,
+                                          bool& traversalDone,
+                                          AttemptStats& stats) {
+        if (removals.empty()) {
+            traversalDone = true;
+            return tree;
+        }
+        RemovalSet removal = removals.back();
+        removals.pop_back();
+        pendingNodes.clear();
+        removedTypeInfo = "";
+        for (const auto* node : removal) {
+            if (node && node->sourceRange() != SourceRange::NoLocation) {
+                pendingNodes.insert(node);
+            }
+        }
+        if (pendingNodes.empty()) {
+            return transform(tree, traversalDone, stats);
+        }
+
+        auto tree2 = SyntaxRewriter<SetRemover>::transform(tree);
+
+        if (!pendingNodes.empty()) {
+            return transform(tree, traversalDone, stats);
+        }
+
+        stats.typeInfo = removedTypeInfo;
+        traversalDone = removals.empty();
+        return tree2;
+    }
+
+    /// The default handler invoked when no visit() method is overridden for a particular type.
+    /// Will visit all child nodes by default.
+    template <typename T>
+    void visitDefault(T&& node) {
+        for (uint32_t i = 0; i < node.getChildCount(); i++) {
+            auto child = node.childNode(i);
+            if (child) {
+                child->visit(*this, node.isChildOptional(i));
+            }
+        }
+    }
+
+    template <typename T>
+    void logType() {
+        std::cerr << STRINGIZE_NODE_TYPE(T) << "\n";
+        removedTypeInfo += (removedTypeInfo.empty() ? "" : ",") + STRINGIZE_NODE_TYPE(T);
+    }
+
+    template <typename T>
+    void visit(T&& node, bool isNodeRemovable = true) {
+        const auto* ptr = &node;
+        auto it = pendingNodes.find(ptr);
+        if (it != pendingNodes.end() && isNodeRemovable &&
+            node.sourceRange() != SourceRange::NoLocation) {
+            logType<T>();
+            std::cerr << prefixLines(node.toString(), "-") << "\n";
+            remove(node);
+            pendingNodes.erase(it);
+            return;
+        }
+        visitDefault(node);
+    }
+};
+
+SetRemover makeFunctionArgRemover(std::shared_ptr<SyntaxTree> tree);

source/SvBugpoint.cpp

@@ -10,13 +10,15 @@
 #include <iostream>
 #include "OneTimeRewritersFwd.hpp"
 #include "PairRemovers.hpp"
+#include "SetRemovers.hpp"
 #include "Utils.hpp"
 
 using namespace slang::syntax;
 using namespace slang::ast;
 using namespace slang;
 
-bool rewriteLoop(PairRemover rewriter,
+template <typename Rewriter>
+bool rewriteLoop(Rewriter rewriter,
                  std::shared_ptr<SyntaxTree>& tree,
                  std::string stageName,
                  std::string passIdx,
@@ -224,6 +226,8 @@ bool SvBugpoint::pass(const std::string& passIdx) {
         commited |= rewriteLoop<ModportRemover>(tree, "modportRemover", passIdx, this);
         commited |= rewriteLoop(makePortsRemover(tree), tree, "portsRemover", passIdx, this);
         commited |= rewriteLoop(makeStructFieldRemover(tree), tree, "structRemover", passIdx, this);
+        commited |=
+            rewriteLoop(makeFunctionArgRemover(tree), tree, "functionArgRemover", passIdx, this);
         commited |= rewriteLoop<ModuleRemover>(tree, "moduleRemover", passIdx, this);
         commited |= rewriteLoop<TypeSimplifier>(tree, "typeSimplifier", passIdx, this);
         commited |= rewriteLoop<LabelRemover>(tree, "LabelRemover", passIdx, this);

tests/Makefile

@@ -62,6 +62,10 @@ test_labels:
 test_dpi:
 	@./run_test dpi checkverilator_lint.sh ${INPUT_DIR}/dpi.sv
 
+.PHONY: test_argument
+test_argument:
+	@./run_test argument checkverilator_run_finish.sh ${INPUT_DIR}/argument.sv
+
 .PHONY: test_caliptra
 test_caliptra: test_caliptra_exit0 test_caliptra_grep
 

tests/golden/argument/sv-bugpoint-combined.sv

@@ -0,0 +1,11 @@
+module t;
+  int i=0;
+  function void f();
+    if(i==1) $finish;
+    i=i+1;
+  endfunction;
+  initial begin
+    f();
+    f();
+  end;
+endmodule

tests/input_files/argument.sv

@@ -0,0 +1,11 @@
+module t;
+  int i=0;
+  function void f(int arg);
+    if(i==1) $finish;
+    i=i+1;
+  endfunction;
+  initial begin;
+    f(1);
+    f(2);
+  end;
+endmodule