Implement IR optimization: constant folding

CMakeLists.txt

@@ -64,6 +64,7 @@ if(BUILD_TESTING)
         ${CMAKE_CURRENT_SOURCE_DIR}/tests/lexer_exact_test.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/tests/parser_exact_test.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/tests/parser_syntax_error_files_test.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/tests/ir_constant_folding_test.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/tests/symbol_table_test.cpp
     )
     target_link_libraries(minijava_tests PRIVATE GTest::gtest_main minijava_core)

src/bytecode/BytecodeInstruction.cpp

@@ -15,7 +15,7 @@ void StackParameterInstruction::serialize(Serializer &serializer) const {
 };
 void IntegerParameterInstruction::serialize(Serializer &serializer) const {
     serializer.writeOpcode(opcode);
-    serializer.writeInteger(param);
+    serializer.writeSignedInteger(param);
 };
 void StringParameterInstruction::serialize(Serializer &serializer) const {
     serializer.writeOpcode(opcode);

src/bytecode/BytecodeInstruction.hpp

@@ -15,9 +15,8 @@ class BytecodeInstruction {
 
   public:
     BytecodeInstruction(Opcode opcode_)
-        : opcode(opcode_),
-          mnemonic(mnemonics.at(
-              static_cast<size_t>(static_cast<std::uint8_t>(opcode_)))) {};
+        : opcode(opcode_), mnemonic(mnemonics.at(static_cast<size_t>(
+                               static_cast<std::uint8_t>(opcode_)))) {};
     virtual ~BytecodeInstruction() = default;
     virtual void print(std::ostream &os) const = 0;
 
@@ -39,13 +38,14 @@ class StackParameterInstruction : public BytecodeInstruction {
 class IntegerParameterInstruction : public BytecodeInstruction {
     // An instruction which takes one integer parameter
     // and pushes one result back to the stack
-    size_t param;
+    std::int64_t param;
 
   public:
-    IntegerParameterInstruction(Opcode opcode_, size_t param_)
+    IntegerParameterInstruction(Opcode opcode_, std::int64_t param_)
         : BytecodeInstruction(opcode_), param(param_) {};
     void print(std::ostream &os) const override;
     void serialize(Serializer &serializer) const override;
+    [[nodiscard]] std::int64_t getParam() const { return param; }
 };
 
 class StringParameterInstruction : public BytecodeInstruction {

src/bytecode/BytecodeMethod.hpp

@@ -34,6 +34,7 @@ class BytecodeMethod {
 
     void print(std::ostream &os) const;
 
+    [[nodiscard]] const auto &getBlocks() const { return blocks; }
     [[nodiscard]] const auto &getVariables() const { return variables; }
     [[nodiscard]] const auto &getFieldVariables() const {
         return fieldVariables;

src/bytecode/BytecodeMethodBlock.cpp

@@ -19,8 +19,7 @@ void BytecodeMethodBlock::addBytecodeInstruction(BytecodeInstruction *instr) {
 BytecodeMethodBlock &BytecodeMethodBlock::push(const Operand &operand) {
     if (const auto *ptr = std::get_if<int>(&operand)) {
         addBytecodeInstruction(
-            new IntegerParameterInstruction(Opcode::CONST,
-                                            static_cast<size_t>(*ptr)));
+            new IntegerParameterInstruction(Opcode::CONST, *ptr));
     } else if (const auto *ptr = std::get_if<std::string>(&operand)) {
         addBytecodeInstruction(
             new StringParameterInstruction(Opcode::LOAD, *ptr));

src/bytecode/BytecodeMethodBlock.hpp

@@ -18,6 +18,7 @@ class BytecodeMethodBlock {
 
     BytecodeMethodBlock(const std::string &name_) : name(name_) {};
     [[nodiscard]] const std::string &getName() const { return name; }
+    [[nodiscard]] const auto &getInstructions() const { return instructions; }
     void print(std::ostream &os) const;
     void addBytecodeInstruction(BytecodeInstruction *instr);
 

src/bytecode/BytecodeProgram.cpp

@@ -27,6 +27,19 @@ BytecodeMethod &BytecodeProgram::getBytecodeMethod(const std::string &name) {
     return *it;
 }
 
+std::vector<const BytecodeInstruction *>
+BytecodeProgram::getInstructions() const {
+    std::vector<const BytecodeInstruction *> instructions;
+    for (const auto &method : methods) {
+        for (const auto &block : method.getBlocks()) {
+            for (const auto &instruction : block.getInstructions()) {
+                instructions.push_back(instruction.get());
+            }
+        }
+    }
+    return instructions;
+}
+
 void BytecodeProgram::print(std::ostream &os) const {
     for (const auto &method : methods) {
         method.print(os);

src/bytecode/BytecodeProgram.hpp

@@ -16,6 +16,8 @@ class BytecodeProgram {
                       std::vector<std::string> fieldVariables);
 
     [[nodiscard]] BytecodeMethod &getBytecodeMethod(const std::string &name);
+    [[nodiscard]] std::vector<const BytecodeInstruction *>
+    getInstructions() const;
 
     void print(std::ostream &os) const;
 

src/ir/BBlock.hpp

@@ -37,6 +37,8 @@ class BBlock {
     BBlock *getFalseBlock() { return falseExit; }
 
     void addInstruction(Tac *ptr);
+    [[nodiscard]] const auto &getInstructions() const { return instructions; }
+    [[nodiscard]] auto &getInstructions() { return instructions; }
 
     void printBlockGraphviz(std::ostream &os);
 

src/ir/CFG.hpp

@@ -39,6 +39,7 @@ class CFG {
     [[nodiscard]] BBlock *addMethodBlock();
     [[nodiscard]] BBlock *addMethodRootBlock(const std::string &className,
                                              const std::string &methodName);
+    [[nodiscard]] const auto &getMethodRoots() const { return methodRoots; }
 
     void setTypeInfo(const TypeInfo *info) { type_info_ = info; }
     [[nodiscard]] const std::string *typeOf(const Node &node) const;

src/ir/Tac.hpp

@@ -29,6 +29,21 @@ class Tac {
     virtual void generateBytecode([[maybe_unused]] BytecodeMethodBlock &block) {
     };
 
+    [[nodiscard]] const std::string &getResult() const { return result; }
+    [[nodiscard]] const Operand &getLhsOperand() const { return lhsOp; }
+    [[nodiscard]] const Operand &getRhsOperand() const { return rhsOp; }
+    [[nodiscard]] const std::string &getOperator() const { return op; }
+
+    void setResult(const std::string &value) { result = value; }
+    void setLhsOperand(const Operand &value) {
+        lhsOp = value;
+        lhs = to_string(lhsOp);
+    }
+    void setRhsOperand(const Operand &value) {
+        rhsOp = value;
+        rhs = to_string(rhsOp);
+    }
+
     Tac(const std::string &result_) : result{result_} {}
     Tac(const std::string &result_, const Operand &lhs_, const std::string &op_,
         const Operand &rhs_)