Implement the trivial dead code elmination algorithm

CMakeLists.txt

@@ -13,7 +13,9 @@ set(SOURCES
     src/buildCFG.cpp
     src/common.cpp
     src/logger.cpp
+    src/config.cpp
     src/localValueNumbering.cpp
+    src/deadCodeElimination.cpp
 )
 
 add_library(bril_common ${SOURCES})
@@ -27,4 +29,7 @@ add_executable(build_cfg src/buildCFGMain.cpp)
 target_link_libraries(build_cfg PRIVATE bril_common nlohmann_json::nlohmann_json)
 
 add_executable(local_value_numbering src/localValueNumberingMain.cpp)
-target_link_libraries(local_value_numbering PRIVATE bril_common nlohmann_json::nlohmann_json)
+target_link_libraries(local_value_numbering PRIVATE bril_common nlohmann_json::nlohmann_json)
+
+add_executable(dead_code_elimination src/deadCodeEliminationMain.cpp)
+target_link_libraries(dead_code_elimination PRIVATE bril_common nlohmann_json::nlohmann_json)

include/config.h

@@ -3,14 +3,28 @@
 
 #include <string>
 
-class Config {
+class PassConfig {
+public:
+    virtual ~PassConfig() = default;
+};
+
+class LVNConfig : public PassConfig {
 public:
     bool enableCommutative;
     bool enableConstantFolding;
     bool enableAlgebraicIdentity;
 
-    Config(bool enableCommutative, bool enableConstantFolding, bool enableAlgebraicIdentity)
+    LVNConfig(bool enableCommutative, bool enableConstantFolding, bool enableAlgebraicIdentity)
         : enableCommutative(enableCommutative), enableConstantFolding(enableConstantFolding), enableAlgebraicIdentity(enableAlgebraicIdentity) {}
 };
 
+class DCEConfig : public PassConfig {
+public:
+    bool enableAggressiveDCE;
+
+    DCEConfig(bool enableAggressiveDCE) : enableAggressiveDCE(enableAggressiveDCE) {}
+};
+
+PassConfig* createPassConfig(const std::string& passName);
+
 #endif

include/deadCodeElimination.h

@@ -0,0 +1,17 @@
+#ifndef DEAD_CODE_ELIMINATION_H
+#define DEAD_CODE_ELIMINATION_H
+
+#include "config.h"
+#include <nlohmann/json.hpp>
+#include <unordered_set>
+#include <unordered_map>
+#include <vector>
+#include <tuple>
+#include <functional>
+#include <iostream>
+
+using json = nlohmann::json;
+
+void deadCodeElimination(std::vector<std::vector<json>>& blocks, DCEConfig& config);
+
+#endif

include/localValueNumbering.h

@@ -48,11 +48,11 @@ class ValueNumbering {
     int refreshNumber(const std::string& name);
     long long stov(const std::string& value);
     long long evaluate(const std::string& type1, const std::string& value1, const std::string& type2, const std::string& value2, const std::string& op);
-    void update(json& instr, const Config& config);
+    void update(json& instr, const LVNConfig& config);
 };
 
 void checkCommutative(std::tuple<int, std::string, int>& nameTuple);
 IdentityType checkAlgebraicIdentity(std::tuple<int, std::string, int>& nameTuple);
 
-void localValueNumbering(std::vector<std::vector<json>>& blocks, const Config& config);
+void localValueNumbering(std::vector<std::vector<json>>& blocks, const LVNConfig& config);
 #endif

src/config.cpp

@@ -0,0 +1,10 @@
+#include "config.h"
+
+PassConfig* createPassConfig(const std::string& passName) {
+    if (passName == "LVN") {
+        return new LVNConfig(false, false, false);
+    } else if (passName == "DCE") {
+        return new DCEConfig(false);
+    }
+    return nullptr;
+}

src/deadCodeElimination.cpp

@@ -0,0 +1,34 @@
+#include "deadCodeElimination.h"
+#include "logger.h"
+
+void deadCodeElimination(std::vector<std::vector<json>>& blocks, DCEConfig& config) {
+    std::unordered_set<std::string> usedVars;
+    // 1. Traverse the blocks to get all used variables
+    for (auto &block : blocks) {
+        for (auto &instr : block) {
+            for (auto &arg : instr["args"]) {
+                usedVars.insert(arg.get<std::string>());
+            }
+        }
+    }
+    // 2. Traverse the blocks to remove unused variables
+    bool changed = false;
+    for (auto &block : blocks) {
+        std::vector<json> newBlock;
+        for (auto &instr : block) {
+            if (instr.find("dest") == instr.end() || usedVars.find(instr["dest"].get<std::string>()) != usedVars.end()) {
+                LOG_DEBUG(instr.dump());
+                newBlock.push_back(instr);
+            }
+        }
+        if (block.size() != newBlock.size()) {
+            changed = true;
+        }
+        block = newBlock;
+    }
+    if (changed) {
+        deadCodeElimination(blocks, config);
+    }
+    LOG_DEBUG("\n");
+    return;
+}

src/deadCodeEliminationMain.cpp

@@ -0,0 +1,36 @@
+#include "deadCodeElimination.h"
+#include "common.h"
+#include "buildBlocks.h"
+#include "logger.h"
+
+int main(int argc, char* argv[]) {
+    try {
+        Logger::getInstance().setLogLevel(LogLevel::INFO);
+        json program = parseJsonFromStdin();
+        LOG_DEBUG("Starting dead code elimination");
+        for (auto& func : program["functions"]) {
+            std::vector<std::vector<json>> blocks = buildBlocks(func["instrs"]);
+            std::vector<std::string> args(argv + 1, argv + argc);
+            DCEConfig* config = static_cast<DCEConfig*>(createPassConfig("DCE"));
+            for (auto& arg : args) {
+                if (arg == "-g") {
+                    Logger::getInstance().setLogLevel(LogLevel::DEBUG);
+                }
+                if (arg == "-a") {
+                    config->enableAggressiveDCE = true;
+                }
+            }
+            deadCodeElimination(blocks, *config);
+            delete config;
+            LOG_DEBUG("After dead code elimination");
+            //printBlocks(blocks, false);
+            func["instrs"] = flattenBlocks(blocks);
+        }
+        std::cout << program.dump(2) << std::endl;
+        LOG_DEBUG("Local value numbering finished");
+    } catch (const std::exception& e) {
+        LOG_ERROR(std::string("Error: ") + e.what());
+        return 1;
+    }
+    return 0;
+}

src/localValueNumbering.cpp

@@ -61,7 +61,7 @@ IdentityType checkAlgebraicIdentity(std::tuple<int, std::string, int>& nameTuple
     return IDENTITY_NONE;
 }
 
-void ValueNumbering::update(json& instr, const Config& config) {
+void ValueNumbering::update(json& instr, const LVNConfig& config) {
     std::string op = instr["op"];
     std::string dest = instr["dest"];
     if (op == "const") {
@@ -146,7 +146,7 @@ void checkCommutative(std::tuple<int, std::string, int>& nameTuple) {
     return;
 }
 
-void localValueNumbering(std::vector<std::vector<json>>& blocks, const Config& config) {
+void localValueNumbering(std::vector<std::vector<json>>& blocks, const LVNConfig& config) {
     for (auto& block : blocks) {
         ValueNumbering vn;
         for (auto& instr : block) {

src/localValueNumberingMain.cpp

@@ -13,22 +13,23 @@ int main(int argc, char* argv[]) {
             LOG_DEBUG("Before local value numbering");
             //printBlocks(blocks, true);
             std::vector<std::string> args(argv + 1, argv + argc);
-            Config config(false, false, false);
+            LVNConfig* config = static_cast<LVNConfig*>(createPassConfig("LVN"));
             for (auto& arg : args) {
                 if (arg == "-g") {
                     Logger::getInstance().setLogLevel(LogLevel::DEBUG);
                 }
                 if (arg == "-c") {
-                    config.enableCommutative = true;
+                    config->enableCommutative = true;
                 }
                 else if (arg == "-f") {
-                    config.enableConstantFolding = true;
+                    config->enableConstantFolding = true;
                 }
                 else if (arg == "-a") {
-                    config.enableAlgebraicIdentity = true;
+                    config->enableAlgebraicIdentity = true;
                 }
             }
-            localValueNumbering(blocks, config);
+            localValueNumbering(blocks, *config);
+            delete config;
             LOG_DEBUG("After local value numbering");
             //printBlocks(blocks, false);
             func["instrs"] = flattenBlocks(blocks);

test/dce/dce_test.bril

@@ -0,0 +1,12 @@
+@main {
+    num1: int = const 1;
+    num2: int = const 2;
+    should_be_removed1: int = const 3;
+    should_be_removed2: int = const 4;
+    should_not_be_removed: int = const 5;
+
+    num3: int = add num1 num2;
+    num4: int = add num3 num3;
+    num5: int = and num4 should_not_be_removed;
+    print num4;
+}

test/dce/lvn_dce.out

@@ -0,0 +1,9 @@
+@main {
+  num1: int = const 1;
+  num2: int = const 2;
+  should_be_removed2: int = add num1 num2;
+  should_not_be_removed1: int = id should_be_removed2;
+  num4: int = add num3 num3;
+  print num4;
+  print should_not_be_removed1;
+}

test/dce/lvn_dce_test.bril

@@ -0,0 +1,12 @@
+@main {
+    num1: int = const 1;
+    num2: int = const 2;
+    should_be_removed1: int = const 3;
+    should_be_removed2: int = add num1 num2;
+    should_be_removed3: int = add num1 num2;
+    should_not_be_removed1: int = add num1 num2;
+
+    num4: int = add num3 num3;
+    print num4;
+    print should_not_be_removed1;
+}

test/dce/only_dce.out

@@ -0,0 +1,8 @@
+@main {
+  num1: int = const 1;
+  num2: int = const 2;
+  should_not_be_removed1: int = add num1 num2;
+  num4: int = add num3 num3;
+  print num4;
+  print should_not_be_removed1;
+}

test/lvn/cse.bril

@@ -0,0 +1,10 @@
+@main{
+  a: int = const 1;
+  b: int = const 1;
+  two: int = const 2;
+  t1: int = mul a two;
+  t2: int = mul a two;
+  t3: int = mul t2 b;
+  result: int = add t1 t3;
+  print result;
+}

test/lvn/cse_out.bril

@@ -0,0 +1,6 @@
+@main {
+  t1: int = mul a two;
+  t2: int = mul t1 b;
+  result: int = add t1 t2;
+  print result;
+}