perf: Add support for tail call optimization

src/bytecode/compiler/Optimizer.cpp

@@ -0,0 +1,33 @@
+#include "Optimizer.h"
+#include "bytecode/instructions/Jump.h"
+#include "bytecode/instructions/Return.h"
+#include "bytecode/instructions/StoreLocal.h"
+
+bool Bytecode::Optimizer::is_tail_recursive(const Bytecode::Segment &segment, size_t id) {
+ const auto &instructions = segment.instructions;
+ return instructions.back()->type == Instruction::Return &&
+ instructions[instructions.size() - 2]->type == Instruction::Call &&
+ instructions[instructions.size() - 2]->params.ri_params.reg == id;
+}
+
+void Bytecode::Optimizer::optimize_tail_calls(Segment &segment) {
+ auto &instructions = segment.instructions;
+ const size_t number_of_args = instructions[instructions.size() - 2]
+ ->params.ri_params.intermediate.asLambda();
+ const size_t old_number_of_instructions = instructions.size() - 1;
+ instructions.pop_back();// Remove the Return instruction
+ instructions.pop_back();// Remove the Call instruction
+ for (size_t i = number_of_args - 1; i != -1; i--)
+ instructions.push_back(new Bytecode::StoreLocal(i));
+ instructions.push_back(new Bytecode::Jump(0));
+ instructions.push_back(new Bytecode::Return());
+
+ // Update jump locations
+ for (auto &instruction: instructions) {
+ if ((instruction->type == Instruction::Jump ||
+ instruction->type == Instruction::CondJumpIfNot) &&
+ instruction->params.r_param.reg == old_number_of_instructions) {
+ instruction->params.r_param.reg = instructions.size() - 1;
+ }
+ }
+}

src/bytecode/compiler/Optimizer.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#include "Segment.h"
+namespace Bytecode::Optimizer {
+ bool is_tail_recursive(const Segment &segment, size_t id);
+ void optimize_tail_calls(Segment &segment);
+}// namespace Bytecode::Optimizer

src/bytecode/instructions/Instruction.h

@@ -38,6 +38,7 @@ namespace Bytecode {
  GreaterThanRI,
  MultiplyRI,
  AddRR,
+ StoreLocal,
  } type;
  union params {
  struct RI_Params {

src/bytecode/instructions/StoreLocal.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include "Instruction.h"
+#include <string>
+
+namespace Bytecode {
+ class StoreLocal final : public Instruction {
+ public:
+ explicit StoreLocal(const size_t reg) {
+ params.r_param = {reg};
+ type = InstructionType::StoreLocal;
+ }
+ void execute(Bytecode::VM &vm) override {
+ vm.call_stack.setLocal(params.r_param.reg, vm.program_stack.pop());
+ }
+ [[nodiscard]] std::string toString() const override {
+ return "StoreLocal $r" + std::to_string(params.r_param.reg);
+ }
+ };
+}// namespace Bytecode

src/main.cpp

@@ -1,3 +1,4 @@
+#include "bytecode/compiler/Optimizer.h"
 #include "bytecode/instructions/Return.h"
 #include "bytecode/vm/Interpreter.h"
 #include "exceptions/SyntaxError.h"
@@ -34,6 +35,13 @@ void exec_program(const std::string &program, struct options opts) {
 
  }
 
+ for (size_t i = 1; i < compiled_bytecode.segments.size(); i++) {
+ const auto segment = compiled_bytecode.segments[i];
+ if (Bytecode::Optimizer::is_tail_recursive(*segment, i))
+ Bytecode::Optimizer::optimize_tail_calls(*segment);
+ }
+
+
  if (opts.dumpBytecode) {
  for (size_t i = 0; i < compiled_bytecode.segments.size(); i++) {
  std::cout << ':' << i << '\n';