begin JIT

Author: prevter

include/rift/jit.hpp

@@ -0,0 +1,127 @@
+#pragma once
+#ifndef RIFT_JIT_HPP
+#define RIFT_JIT_HPP
+
+#include <cstdint>
+#include <memory>
+#include <span>
+#include <string>
+#include <string_view>
+#include <vector>
+
+#include <Geode/Result.hpp>
+
+#include "value.hpp"
+#include "nodes/node.hpp"
+
+namespace rift::jit {
+    /// @brief Represents the different opcodes used in the custom bytecode format.
+    enum class Opcode : uint8_t {
+        NOP, // No operation
+        RET, // Return the value immediately
+
+        LD_NULL,  // Load a null constant
+        LD_TRUE,  // Load a true constant
+        LD_FALSE, // Load a false constant
+
+        LD_INT64, // Load a 64-bit integer constant
+        LD_INT32, // Load a 32-bit integer constant
+        LD_INT16, // Load a 16-bit integer constant
+        LD_INT8,  // Load an 8-bit integer constant
+
+        LD_FLT,     // Load a float constant as 64-bit double
+        LD_FLT_T64, // Load a float constant as 64-bit integer
+        LD_FLT_T32, // Load a float constant as 32-bit integer
+        LD_FLT_T16, // Load a float constant as 16-bit integer
+        LD_FLT_T8,  // Load a float constant as 8-bit integer
+
+        LD_STR, // Load a string constant
+        LD_ID,  // Load an identifier constant
+
+        ADD, // Add two values
+        SUB, // Subtract two values
+        MUL, // Multiply two values
+        DIV, // Divide two values
+        MOD, // Modulus operation
+        POW, // Power operation
+
+        NOT,       // Logical NOT operation
+        AND,       // Logical AND operation
+        OR,        // Logical OR operation
+        BOOL_CAST, // Cast to boolean
+
+        GT, // Greater than operation
+        GE, // Greater than or equal to operation
+        LT, // Less than operation
+        LE, // Less than or equal to operation
+        EQ, // Equal to operation
+        NE, // Not equal to operation
+
+        JMP,   // Skip N bytes (8-bit)
+        JMP16, // Skip N bytes (16-bit)
+        JMP32, // Skip N bytes (32-bit)
+
+        JNZ,   // Jump if the top of the stack is true (8-bit)
+        JNZ16, // Jump if the top of the stack is true (16-bit)
+        JNZ32, // Jump if the top of the stack is true (32-bit)
+
+        JZ,   // Jump if the top of the stack is false (8-bit)
+        JZ16, // Jump if the top of the stack is false (16-bit)
+        JZ32, // Jump if the top of the stack is false (32-bit)
+
+        JGT,   // Jump if greater than (8-bit)
+        JGT16, // Jump if greater than (16-bit)
+        JGT32, // Jump if greater than (32-bit)
+
+        JGE,   // Jump if greater than or equal to (8-bit)
+        JGE16, // Jump if greater than or equal to (16-bit)
+        JGE32, // Jump if greater than or equal to (32-bit)
+
+        JLT,   // Jump if less than (8-bit)
+        JLT16, // Jump if less than (16-bit)
+        JLT32, // Jump if less than (32-bit)
+
+        JLE,   // Jump if less than or equal to (8-bit)
+        JLE16, // Jump if less than or equal to (16-bit)
+        JLE32, // Jump if less than or equal to (32-bit)
+
+        JEQ,   // Jump if equal (8-bit)
+        JEQ16, // Jump if equal (16-bit)
+        JEQ32, // Jump if equal (32-bit)
+
+        JNE,   // Jump if not equal (8-bit)
+        JNE16, // Jump if not equal (16-bit)
+        JNE32, // Jump if not equal (32-bit)
+
+        CALL,    // Call a function with N arguments
+        CALL_ID, // Call a function with an identifier
+
+        PUSH,     // Append the value to the output
+        PUSH_STR, // Append the string to the output
+    };
+
+    /// @brief Convert an Opcode to a string representation.
+    /// @param op The opcode to convert.
+    /// @return The string representation of the opcode.
+    std::string_view opcodeToString(Opcode op) noexcept;
+
+    /// @brief Compile a node into bytecode.
+    /// @param node The node to compile.
+    /// @param rootCall Used for recursive calls to determine if the node is the root call.
+    /// @return The compiled bytecode as a vector of bytes.
+    geode::Result<std::vector<uint8_t>> compile(
+        std::unique_ptr<Node> const& node,
+        bool rootCall = true
+    ) noexcept;
+
+    /// @brief Run the compiled bytecode with the given variables.
+    /// @param bytecode The compiled bytecode to run.
+    /// @param vars The variables to use during execution.
+    /// @return The result of the execution as a string.
+    geode::Result<std::string> run(
+        std::span<uint8_t> bytecode,
+        Object const& vars = {}
+    ) noexcept;
+}
+
+#endif // RIFT_JIT_HPP