回档之后的重写。部分问题修复。添加了什么我也忘了

src/IR/IR.hpp

@@ -0,0 +1,62 @@
+#pragma once
+
+#include <Core/fig_string.hpp>
+
+#include <vector>
+#include <cstdint>
+namespace Fig::IR
+{
+    using Reg = uint16_t;
+    using Label = uint32_t;
+
+    constexpr Reg INVALID_REG = 0xFFFF;
+
+    enum class Op : uint8_t
+    {
+        // ---- control ----
+        Nop,
+        Jmp,
+        Br, // conditional branch
+        Ret,
+        Call,
+
+        // ---- arithmetic ----
+        Add,
+        Sub,
+        Mul,
+        Div,
+
+        // ---- compare ----
+        Lt,
+        Le,
+        Gt,
+        Ge,
+        Eq,
+
+        // ---- data ----
+        LoadImm, // immediate -> reg
+        Mov,
+    };
+
+    struct Inst
+    {
+        Op op;
+
+        Reg dst; // 结果寄存器
+        Reg a;   // operand a
+        Reg b;   // operand b
+
+        int64_t imm; // immediate / jump offset
+    };
+
+    struct Function
+    {
+        FString name;
+
+        uint16_t paramCount;
+        uint16_t localCount; // 不含参数
+        uint16_t regCount; // param + locals + temps
+
+        std::vector<Inst> code;
+    };
+};

src/IR/IRInterpreter.hpp

@@ -0,0 +1,74 @@
+#pragma once
+
+#include <IR/IR.hpp>
+
+#include <cassert>
+
+namespace Fig::IR
+{
+    struct VirtualMachine
+    {
+        std::vector<Function *> functions;
+
+        int64_t execute(Function *fn, const int64_t *args) 
+        {
+            assert(fn != nullptr);
+            std::vector<int64_t> regs(fn->regCount);
+            // load params
+
+            size_t ip = 0;
+
+            while (ip < fn->code.size())
+            {
+                const Inst &ins = fn->code[ip++];
+
+                switch (ins.op)
+                {
+                    case Op::Nop: break;
+
+                    case Op::LoadImm: regs[ins.dst] = ins.imm; break;
+
+                    case Op::Mov: regs[ins.dst] = regs[ins.a]; break;
+
+                    case Op::Add: regs[ins.dst] = regs[ins.a] + regs[ins.b]; break;
+
+                    case Op::Sub: regs[ins.dst] = regs[ins.a] - regs[ins.b]; break;
+
+                    case Op::Mul: regs[ins.dst] = regs[ins.a] * regs[ins.b]; break;
+
+                    case Op::Div: regs[ins.dst] = regs[ins.a] / regs[ins.b]; break;
+
+                    case Op::Lt: regs[ins.dst] = regs[ins.a] < regs[ins.b]; break;
+
+                    case Op::Le: regs[ins.dst] = regs[ins.a] <= regs[ins.b]; break;
+
+                    case Op::Gt: regs[ins.dst] = regs[ins.a] > regs[ins.b]; break;
+
+                    case Op::Ge: regs[ins.dst] = regs[ins.a] >= regs[ins.b]; break;
+
+                    case Op::Eq: regs[ins.dst] = regs[ins.a] == regs[ins.b]; break;
+
+                    case Op::Jmp: ip = static_cast<size_t>(static_cast<int64_t>(ip) + ins.imm); break;
+
+                    case Op::Br:
+                        if (regs[ins.a] == 0) { ip = static_cast<size_t>(static_cast<int64_t>(ip) + ins.imm); }
+                        break;
+
+                    case Op::Call: {
+                        // currently supports 1-arg call via reg a
+                        Function *callee = functions.at(static_cast<size_t>(ins.imm));
+                        int64_t arg0 = regs[ins.a];
+                        int64_t ret = execute(callee, &arg0);
+                        regs[ins.dst] = ret;
+                        break;
+                    }
+
+                    case Op::Ret: return regs[ins.a];
+                }
+            }
+
+            // unreachable normally
+            return 0;
+        }
+    };
+}; // namespace Fig::IR

src/IR/ir_test_main.cpp

@@ -0,0 +1,14 @@
+#include <IR/IRInterpreter.hpp>
+#include <IR/IR.hpp>
+
+
+int main()
+{
+    using namespace Fig;
+    IR::VirtualMachine vm;
+
+    using namespace IR;
+    IR::Inst fib_ir[] = {
+        
+    };
+}