superinstance-flux-runtime 1.0.0

data/lib/superinstance/flux-runtime/flux_vm.rb

@@ -0,0 +1,1020 @@
+# frozen_string_literal: true
+
+require_relative 'exceptions'
+require_relative 'opcode'
+
+module Flux
+  # Main FLUX ISA v3.0 Virtual Machine
+  #
+  # Register Model:
+  # - 16 GP registers (R0-R15, int32)
+  # - 16 FP registers (F0-F15, float64)
+  # - 16 VR registers (V0-V15, 256 bytes each)
+  # - PC, SP, FP_REG, FLAGS, STATE
+  #
+  # Memory: flat binary string, 64KB default
+  class FluxVM
+    include OpcodeRegistry
+
+    # Register aliases per ISA
+    RV = 8   # Return value
+    A0 = 9   # First argument
+    A1 = 10  # Second argument
+    SP_REG = 11  # Stack pointer
+    FP_REG = 12  # Frame pointer
+    FLAGS = 13   # Flags register
+    TP = 14  # Temporary
+    LR = 15  # Link register
+
+    # VM states
+    RUNNING = :running
+    HALTED = :halted
+    PANICKED = :panicked
+    YIELDED = :yielded
+
+    # Flag bits
+    FLAG_Z = 1 << 0
+    FLAG_S = 1 << 1
+    FLAG_C = 1 << 2
+    FLAG_V = 1 << 3
+
+    attr_accessor :gp, :fp, :vr
+    attr_accessor :pc, :sp, :fp_reg, :flags, :state
+    attr_reader :memory_size, :memory
+
+    # Opcode registry for runtime-registered opcodes
+    @@opcode_registry = {}
+    @@runtime_opcodes = {}
+
+    class << self
+      attr_accessor :opcode_registry, :runtime_opcodes
+
+      def register_opcode(opcode_class)
+        @@runtime_opcodes[opcode_class.opcode_id] = opcode_class
+      end
+    end
+
+    def initialize(memory_size: 65536)
+      @memory_size = memory_size
+      @memory = [0] * memory_size  # Simpler Array of integers
+
+      # General purpose registers (int32)
+      @gp = [0] * 16
+
+      # Floating point registers (float64)
+      @fp = [0.0] * 16
+
+      # Vector registers (256 bytes each as binary string)
+      @vr = Array.new(16) { "\x00" * 256 }
+
+      # System registers
+      @pc = 0
+      @sp = memory_size  # Stack grows down
+      @fp_reg = 0
+      @flags = 0
+      @state = RUNNING
+
+      # Stats
+      @cycles = 0
+      @instruction_count = 0
+    end
+
+    # Load bytecode into memory starting at address 0
+    def load(bytecode_string)
+      bytecode = bytecode_string.dup.force_encoding('BINARY')
+      raise FluxRuntimeError, 'Bytecode too large' if bytecode.bytesize > @memory_size
+
+      bytecode.bytes.each_with_index do |byte, i|
+        @memory[i] = byte
+      end
+
+      @pc = 0
+      @sp = @memory_size
+      self
+    end
+
+    # Run the VM until halt/panic/yield or max_cycles reached
+    def run(max_cycles: nil)
+      @state = RUNNING
+
+      loop do
+        break if @state != RUNNING
+        break if max_cycles && @cycles >= max_cycles
+
+        step
+      end
+
+      self
+    end
+
+    # Execute one instruction
+    def step
+      raise FluxRuntimeError, 'VM not running' unless @state == RUNNING
+
+      opcode = fetch8
+      execute_opcode(opcode)
+
+      @instruction_count += 1
+      @cycles += 1
+
+      self
+    end
+
+    # Reset VM state
+    def reset
+      @memory = [0] * @memory_size
+      @gp = [0] * 16
+      @fp = [0.0] * 16
+      @vr = Array.new(16) { "\x00" * 256 }
+      @pc = 0
+      @sp = @memory_size
+      @fp_reg = 0
+      @flags = 0
+      @state = RUNNING
+      @cycles = 0
+      @instruction_count = 0
+      self
+    end
+
+    # Get register values as hash
+    def regs
+      {
+        pc: @pc,
+        sp: @sp,
+        fp: @fp_reg,
+        flags: @flags,
+        state: @state,
+        gp: @gp.dup,
+        fp_regs: @fp.dup,
+        vr: @vr.dup
+      }
+    end
+
+    # Current VM state
+    def state
+      @state
+    end
+
+    # Execution statistics
+    def stats
+      {
+        cycles: @cycles,
+        instruction_count: @instruction_count,
+        memory_used: @pc
+      }
+    end
+
+    # Memory read helpers
+    def read_memory(addr, bytes)
+      return nil if addr < 0 || addr + bytes > @memory_size
+
+      (0...bytes).map { |i| @memory[addr + i] }
+    end
+
+    def read_memory_u8(addr)
+      return nil if addr < 0 || addr >= @memory_size
+
+      @memory[addr] & 0xFF
+    end
+
+    def read_memory_i32(addr)
+      return nil if addr < 0 || addr + 4 > @memory_size
+
+      val = (@memory[addr] & 0xFF) |
+            ((@memory[addr + 1] & 0xFF) << 8) |
+            ((@memory[addr + 2] & 0xFF) << 16) |
+            ((@memory[addr + 3] & 0xFF) << 24)
+
+      # Sign extend
+      (val << 24) >> 24
+    end
+
+    def read_memory_u32(addr)
+      return nil if addr < 0 || addr + 4 > @memory_size
+
+      (@memory[addr] & 0xFF) |
+        ((@memory[addr + 1] & 0xFF) << 8) |
+        ((@memory[addr + 2] & 0xFF) << 16) |
+        ((@memory[addr + 3] & 0xFF) << 24)
+    end
+
+    def read_memory_i16(addr)
+      return nil if addr < 0 || addr + 2 > @memory_size
+
+      val = (@memory[addr] & 0xFF) | ((@memory[addr + 1] & 0xFF) << 8)
+      (val << 16) >> 16  # Sign extend
+    end
+
+    def read_memory_u16(addr)
+      return nil if addr < 0 || addr + 2 > @memory_size
+
+      (@memory[addr] & 0xFF) | ((@memory[addr + 1] & 0xFF) << 8)
+    end
+
+    # Memory write helpers
+    def write_memory(addr, bytes, value)
+      return if addr < 0 || addr + bytes > @memory_size
+
+      case bytes
+      when 1
+        @memory[addr] = value & 0xFF
+      when 2
+        @memory[addr] = value & 0xFF
+        @memory[addr + 1] = (value >> 8) & 0xFF
+      when 4
+        @memory[addr] = value & 0xFF
+        @memory[addr + 1] = (value >> 8) & 0xFF
+        @memory[addr + 2] = (value >> 16) & 0xFF
+        @memory[addr + 3] = (value >> 24) & 0xFF
+      when 8
+        (0..7).each { |i| @memory[addr + i] = (value >> (i * 8)) & 0xFF }
+      end
+    end
+
+    # Flag setting helpers
+    def set_z(result)
+      @flags = (@flags & ~FLAG_Z) | (result.zero? ? FLAG_Z : 0)
+    end
+
+    def set_s(result)
+      @flags = (@flags & ~FLAG_S) | ((result < 0) ? FLAG_S : 0)
+    end
+
+    def set_c(result)
+      @flags = (@flags & ~FLAG_C) | (result < 0 ? FLAG_C : 0)
+    end
+
+    def set_v(result)
+      @flags = (@flags & ~FLAG_V) | (result < 0 ? FLAG_V : 0)
+    end
+
+    def set_zn(result)
+      set_z(result)
+      set_s(result)
+    end
+
+    def set_znv(result)
+      set_z(result)
+      set_s(result)
+      set_v(result)
+      set_c(result)
+    end
+
+    # Stack helpers
+    def push(value)
+      @sp -= 4
+      raise FluxRuntimeError, 'Stack overflow' if @sp < 0
+      write_memory(@sp, 4, value)
+    end
+
+    def pop
+      raise FluxRuntimeError, 'Stack underflow' if @sp >= @memory_size
+      val = read_memory_i32(@sp)
+      @sp += 4
+      val
+    end
+
+    private
+
+    def fetch8
+      val = read_memory_u8(@pc)
+      @pc += 1
+      val
+    end
+
+    def fetch16
+      lo = fetch8
+      hi = fetch8
+      (lo | (hi << 8)).tap { |v| (v << 16) >> 16 }  # Sign-extend
+    end
+
+    def fetchu16
+      lo = fetch8
+      hi = fetch8
+      lo | (hi << 8)
+    end
+
+    def fetchu32
+      lo = fetch16
+      hi = fetch16
+      lo | (hi << 16)
+    end
+
+    def fetch32
+      val = fetchu32
+      (val << 24) >> 24
+    end
+
+    def execute_opcode(opcode)
+      # Check runtime opcodes first
+      if @@runtime_opcodes[opcode]
+        @@runtime_opcodes[opcode].execute(self)
+        return
+      end
+
+      case opcode
+      # Format A: opcode only (1 byte)
+      when 0x00 then opHalt
+      when 0x01 then opNop
+      when 0x02 then opRet
+      when 0x08 then opYield
+      when 0x09 then opPanic
+      when 0x0A then opUnreachable
+
+      # Format B: opcode + Rd + Rs (3 bytes)
+      when 0x10 then rd = fetch8; rs = fetch8; opPush(rd, rs)
+      when 0x11 then rd = fetch8; rs = fetch8; opPop(rd, rs)
+      when 0x12 then rd = fetch8; rs = fetch8; opDup(rd, rs)
+      when 0x13 then ra = fetch8; rb = fetch8; opSwap(ra, rb)
+      when 0x20 then rd = fetch8; rs = fetch8; opIMov(rd, rs)
+      when 0x40 then rd = fetch8; rs = fetch8; opFMov(rd, rs)
+
+      # Format C: opcode + Rd + Ra + Rb (4 bytes)
+      when 0x21 then rd = fetch8; ra = fetch8; rb = fetch8; opIAdd(rd, ra, rb)
+      when 0x22 then rd = fetch8; ra = fetch8; rb = fetch8; opISub(rd, ra, rb)
+      when 0x23 then rd = fetch8; ra = fetch8; rb = fetch8; opIMul(rd, ra, rb)
+      when 0x24 then rd = fetch8; ra = fetch8; rb = fetch8; opIDiv(rd, ra, rb)
+      when 0x25 then rd = fetch8; ra = fetch8; rb = fetch8; opIMod(rd, ra, rb)
+      when 0x26 then rd = fetch8; ra = fetch8; rb = fetch8; opINeg(rd, ra, rb)
+      when 0x27 then rd = fetch8; ra = fetch8; rb = fetch8; opIAbs(rd, ra, rb)
+      when 0x28 then rd = fetch8; opIInc(rd)
+      when 0x29 then rd = fetch8; opIDec(rd)
+      when 0x2A then rd = fetch8; ra = fetch8; rb = fetch8; opIMin(rd, ra, rb)
+      when 0x2B then rd = fetch8; ra = fetch8; rb = fetch8; opIMax(rd, ra, rb)
+      when 0x2C then rd = fetch8; ra = fetch8; rb = fetch8; opIAnd(rd, ra, rb)
+      when 0x2D then rd = fetch8; ra = fetch8; rb = fetch8; opIOr(rd, ra, rb)
+      when 0x2E then rd = fetch8; ra = fetch8; rb = fetch8; opIXor(rd, ra, rb)
+      when 0x2F then rd = fetch8; ra = fetch8; rb = fetch8; opIShl(rd, ra, rb)
+      when 0x30 then rd = fetch8; ra = fetch8; rb = fetch8; opIShr(rd, ra, rb)
+      when 0x31 then rd = fetch8; ra = fetch8; rb = fetch8; opINot(rd, ra, rb)
+      when 0x32 then rd = fetch8; ra = fetch8; rb = fetch8; opICmpEq(rd, ra, rb)
+      when 0x33 then rd = fetch8; ra = fetch8; rb = fetch8; opICmpNe(rd, ra, rb)
+      when 0x34 then rd = fetch8; ra = fetch8; rb = fetch8; opICmpLt(rd, ra, rb)
+      when 0x35 then rd = fetch8; ra = fetch8; rb = fetch8; opICmpLe(rd, ra, rb)
+      when 0x36 then rd = fetch8; ra = fetch8; rb = fetch8; opICmpGt(rd, ra, rb)
+      when 0x37 then rd = fetch8; ra = fetch8; rb = fetch8; opICmpGe(rd, ra, rb)
+
+      # Float Arithmetic
+      when 0x41 then rd = fetch8; ra = fetch8; rb = fetch8; opFAdd(rd, ra, rb)
+      when 0x42 then rd = fetch8; ra = fetch8; rb = fetch8; opFSub(rd, ra, rb)
+      when 0x43 then rd = fetch8; ra = fetch8; rb = fetch8; opFMul(rd, ra, rb)
+      when 0x44 then rd = fetch8; ra = fetch8; rb = fetch8; opFDiv(rd, ra, rb)
+      when 0x45 then rd = fetch8; ra = fetch8; rb = fetch8; opFMod(rd, ra, rb)
+      when 0x46 then rd = fetch8; ra = fetch8; rb = fetch8; opFNeg(rd, ra, rb)
+      when 0x47 then rd = fetch8; ra = fetch8; rb = fetch8; opFAbs(rd, ra, rb)
+      when 0x48 then rd = fetch8; ra = fetch8; rb = fetch8; opFSqrt(rd, ra, rb)
+      when 0x49 then rd = fetch8; ra = fetch8; rb = fetch8; opFFloor(rd, ra, rb)
+      when 0x4A then rd = fetch8; ra = fetch8; rb = fetch8; opFCeil(rd, ra, rb)
+      when 0x4B then rd = fetch8; ra = fetch8; rb = fetch8; opFRound(rd, ra, rb)
+      when 0x4C then rd = fetch8; ra = fetch8; rb = fetch8; opFMin(rd, ra, rb)
+      when 0x4D then rd = fetch8; ra = fetch8; rb = fetch8; opFMax(rd, ra, rb)
+      when 0x4E then rd = fetch8; ra = fetch8; rb = fetch8; opFSin(rd, ra, rb)
+      when 0x4F then rd = fetch8; ra = fetch8; rb = fetch8; opFCos(rd, ra, rb)
+      when 0x50 then rd = fetch8; ra = fetch8; rb = fetch8; opFExp(rd, ra, rb)
+      when 0x51 then rd = fetch8; ra = fetch8; rb = fetch8; opFLog(rd, ra, rb)
+      when 0x52 then rd = fetch8; ra = fetch8; rb = fetch8; opFClamp(rd, ra, rb)
+      when 0x53 then rd = fetch8; ra = fetch8; rb = fetch8; opFLerp(rd, ra, rb)
+      when 0x54 then rd = fetch8; ra = fetch8; rb = fetch8; opFCmpEq(rd, ra, rb)
+      when 0x55 then rd = fetch8; ra = fetch8; rb = fetch8; opFCmpNe(rd, ra, rb)
+      when 0x56 then rd = fetch8; ra = fetch8; rb = fetch8; opFCmpLt(rd, ra, rb)
+      when 0x57 then rd = fetch8; ra = fetch8; rb = fetch8; opFCmpLe(rd, ra, rb)
+      when 0x58 then rd = fetch8; ra = fetch8; rb = fetch8; opFCmpGt(rd, ra, rb)
+      when 0x59 then rd = fetch8; ra = fetch8; rb = fetch8; opFCmpGe(rd, ra, rb)
+
+      # Conversions
+      when 0x60 then rd = fetch8; ra = fetch8; rb = fetch8; opIToF(rd, ra, rb)
+      when 0x61 then rd = fetch8; ra = fetch8; rb = fetch8; opFToI(rd, ra, rb)
+      when 0x62 then rd = fetch8; ra = fetch8; rb = fetch8; opBToI(rd, ra, rb)
+      when 0x63 then rd = fetch8; ra = fetch8; rb = fetch8; opIToB(rd, ra, rb)
+
+      # Type/Meta
+      when 0x90 then rd = fetch8; ra = fetch8; rb = fetch8; opCast(rd, ra, rb)
+      when 0x91 then rd = fetch8; ra = fetch8; rb = fetch8; opSizeOf(rd, ra, rb)
+      when 0x92 then rd = fetch8; ra = fetch8; rb = fetch8; opTypeOf(rd, ra, rb)
+
+      # Bitwise
+      when 0xA0 then rd = fetch8; ra = fetch8; rb = fetch8; opBAnd(rd, ra, rb)
+      when 0xA1 then rd = fetch8; ra = fetch8; rb = fetch8; opBOr(rd, ra, rb)
+      when 0xA2 then rd = fetch8; ra = fetch8; rb = fetch8; opBXor(rd, ra, rb)
+      when 0xA3 then rd = fetch8; ra = fetch8; rb = fetch8; opBShl(rd, ra, rb)
+      when 0xA4 then rd = fetch8; ra = fetch8; rb = fetch8; opBShr(rd, ra, rb)
+      when 0xA5 then rd = fetch8; ra = fetch8; rb = fetch8; opBNot(rd, ra, rb)
+
+      # Vector
+      when 0xB0 then rd = fetch8; rb = fetch8; off = fetchu16; opVLoad(rd, rb, off)
+      when 0xB1 then rs = fetch8; rb = fetch8; off = fetchu16; opVStore(rs, rb, off)
+      when 0xB2 then rd = fetch8; ra = fetch8; rb = fetch8; opVAdd(rd, ra, rb)
+      when 0xB3 then rd = fetch8; ra = fetch8; rb = fetch8; opVMul(rd, ra, rb)
+      when 0xB4 then rd = fetch8; ra = fetch8; rb = fetch8; opVDot(rd, ra, rb)
+
+      # Memory (Format E)
+      when 0x70 then rd = fetch8; rb = fetch8; off = fetchu16; opLoad8(rd, rb)
+      when 0x71 then rd = fetch8; rb = fetch8; off = fetchu16; opLoad16(rd, rb)
+      when 0x72 then rd = fetch8; rb = fetch8; off = fetchu16; opLoad32(rd, rb)
+      when 0x73 then rd = fetch8; rb = fetch8; off = fetchu16; opLoad64(rd, rb)
+      when 0x74 then rs = fetch8; rb = fetch8; off = fetchu16; opStore8(rs, rb)
+      when 0x75 then rs = fetch8; rb = fetch8; off = fetchu16; opStore16(rs, rb)
+      when 0x76 then rs = fetch8; rb = fetch8; off = fetchu16; opStore32(rs, rb)
+      when 0x77 then rs = fetch8; rb = fetch8; off = fetchu16; opStore64(rs, rb)
+      when 0x78 then rd = fetch8; rb = fetch8; off = fetchu16; opLoadAddr(rd, rb)
+      when 0x79 then rd = fetch8; opStackAlloc(rd)
+
+      else
+        raise UnknownOpcodeError.new(opcode, @pc - 1)
+      end
+    end
+
+    public
+
+    # Format A opcodes (1 byte)
+    def opHalt
+      @state = HALTED
+    end
+
+    def opNop
+      # No operation
+    end
+
+    def opRet
+      @pc = @gp[LR]
+    end
+
+    def opYield
+      @state = YIELDED
+    end
+
+    def opPanic
+      @state = PANICKED
+      raise PanicError.new(pc: @pc - 1)
+    end
+
+    def opUnreachable
+      raise FluxRuntimeError.new('Unreachable instruction executed', opcode: :Unreachable, pc: @pc - 1)
+    end
+
+    # Format G opcodes (variable)
+    def opJump
+      length = fetch8
+      offset = fetch16
+      @pc = @pc &+ offset
+    end
+
+    def opJumpIf
+      length = fetch8
+      rd = fetch8
+      offset = fetch16
+      @pc = @pc &+ offset if @gp[rd] != 0
+    end
+
+    def opJumpIfNot
+      length = fetch8
+      rd = fetch8
+      offset = fetch16
+      @pc = @pc &+ offset if @gp[rd] == 0
+    end
+
+    def opCall
+      length = fetch8
+      func_idx = fetchu16
+      push(@pc)
+      @gp[LR] = @pc
+      @pc = func_idx
+    end
+
+    def opCallIndirect
+      length = fetch8
+      reg = fetch8
+      push(@pc)
+      @gp[LR] = @pc
+      @pc = @gp[reg]
+    end
+
+    # Format B opcodes (3 bytes: opcode + Rd + Rs)
+    def opPush(rd, rs)
+      push(@gp[rs])
+    end
+
+    def opPop(rd, rs)
+      @gp[rd] = pop
+    end
+
+    def opDup(rd, rs)
+      @gp[rd] = @gp[rs]
+    end
+
+    def opSwap(ra, rb)
+      @gp[ra], @gp[rb] = @gp[rb], @gp[ra]
+    end
+
+    def opIMov(rd, rs)
+      @gp[rd] = @gp[rs]
+    end
+
+    def opFMov(rd, rs)
+      @fp[rd] = @fp[rs]
+    end
+
+    # Format D opcodes (4 bytes: opcode + Rd + imm16)
+    def opIInc(rd)
+      imm = fetch16
+      result = @gp[rd] + imm
+      set_znv(result)
+      @gp[rd] = result
+    end
+
+    def opIDec(rd)
+      imm = fetch16
+      result = @gp[rd] - imm
+      set_znv(result)
+      @gp[rd] = result
+    end
+
+    def opStackAlloc(rd)
+      size = fetch16
+      @sp -= size
+      raise FluxRuntimeError, 'Stack overflow' if @sp < 0
+      @gp[rd] = @sp
+    end
+
+    # Format E opcodes (5 bytes: opcode + Rd + Rbase + off16)
+    def opLoad8(rd, rb)
+      off = fetchu16
+      addr = @gp[rb] + off
+      @gp[rd] = read_memory_u8(addr) || 0
+    end
+
+    def opLoad16(rd, rb)
+      off = fetchu16
+      addr = @gp[rb] + off
+      @gp[rd] = read_memory_u16(addr) || 0
+    end
+
+    def opLoad32(rd, rb)
+      off = fetchu16
+      addr = @gp[rb] + off
+      @gp[rd] = read_memory_i32(addr) || 0
+    end
+
+    def opLoad64(rd, rb)
+      off = fetchu16
+      addr = @gp[rb] + off
+      @gp[rd] = read_memory_u32(addr) || 0
+    end
+
+    def opStore8(rs, rb)
+      off = fetchu16
+      addr = @gp[rb] + off
+      write_memory(addr, 1, @gp[rs])
+    end
+
+    def opStore16(rs, rb)
+      off = fetchu16
+      addr = @gp[rb] + off
+      write_memory(addr, 2, @gp[rs])
+    end
+
+    def opStore32(rs, rb)
+      off = fetchu16
+      addr = @gp[rb] + off
+      write_memory(addr, 4, @gp[rs])
+    end
+
+    def opStore64(rs, rb)
+      off = fetchu16
+      addr = @gp[rb] + off
+      write_memory(addr, 8, @gp[rs])
+    end
+
+    def opLoadAddr(rd, rb)
+      off = fetchu16
+      @gp[rd] = @gp[rb] + off
+    end
+
+    # Integer Arithmetic (Format C)
+    def opIAdd(rd, ra, rb)
+      result = @gp[ra] + @gp[rb]
+      set_znv(result)
+      @gp[rd] = result
+    end
+
+    def opISub(rd, ra, rb)
+      result = @gp[ra] - @gp[rb]
+      set_znv(result)
+      @gp[rd] = result
+    end
+
+    def opIMul(rd, ra, rb)
+      result = @gp[ra] * @gp[rb]
+      set_znv(result)
+      @gp[rd] = result
+    end
+
+    def opIDiv(rd, ra, rb)
+      raise DivideByZeroError.new(@pc - 1) if @gp[rb] == 0
+      result = @gp[ra] / @gp[rb]
+      set_znv(result)
+      @gp[rd] = result
+    end
+
+    def opIMod(rd, ra, rb)
+      raise DivideByZeroError.new(@pc - 1) if @gp[rb] == 0
+      result = @gp[ra] % @gp[rb]
+      set_znv(result)
+      @gp[rd] = result
+    end
+
+    def opINeg(rd, ra, rb)
+      result = -@gp[ra]
+      set_zn(result)
+      @gp[rd] = result
+    end
+
+    def opIAbs(rd, ra, rb)
+      result = @gp[ra].abs
+      set_zn(result)
+      @gp[rd] = result
+    end
+
+    def opIMin(rd, ra, rb)
+      result = [@gp[ra], @gp[rb]].min
+      set_zn(result)
+      @gp[rd] = result
+    end
+
+    def opIMax(rd, ra, rb)
+      result = [@gp[ra], @gp[rb]].max
+      set_zn(result)
+      @gp[rd] = result
+    end
+
+    def opIAnd(rd, ra, rb)
+      result = @gp[ra] & @gp[rb]
+      set_zn(result)
+      @gp[rd] = result
+    end
+
+    def opIOr(rd, ra, rb)
+      result = @gp[ra] | @gp[rb]
+      set_zn(result)
+      @gp[rd] = result
+    end
+
+    def opIXor(rd, ra, rb)
+      result = @gp[ra] ^ @gp[rb]
+      set_zn(result)
+      @gp[rd] = result
+    end
+
+    def opIShl(rd, ra, rb)
+      result = @gp[ra] << (@gp[rb] & 31)
+      set_z(result)
+      set_c((@gp[ra] << (@gp[rb] & 31)) != result ? 1 : 0)
+      @gp[rd] = result
+    end
+
+    def opIShr(rd, ra, rb)
+      result = @gp[ra] >> (@gp[rb] & 31)
+      set_z(result)
+      @gp[rd] = result
+    end
+
+    def opINot(rd, ra, rb)
+      result = ~@gp[ra]
+      set_zn(result)
+      @gp[rd] = result
+    end
+
+    # Integer Comparisons
+    def opICmpEq(rd, ra, rb)
+      @gp[rd] = (@gp[ra] == @gp[rb]) ? 1 : 0
+      set_z(@gp[rd])
+    end
+
+    def opICmpNe(rd, ra, rb)
+      @gp[rd] = (@gp[ra] != @gp[rb]) ? 1 : 0
+      set_z(1 - @gp[rd])
+    end
+
+    def opICmpLt(rd, ra, rb)
+      @gp[rd] = (@gp[ra] < @gp[rb]) ? 1 : 0
+      set_z(@gp[rd])
+    end
+
+    def opICmpLe(rd, ra, rb)
+      @gp[rd] = (@gp[ra] <= @gp[rb]) ? 1 : 0
+      set_z(@gp[rd])
+    end
+
+    def opICmpGt(rd, ra, rb)
+      @gp[rd] = (@gp[ra] > @gp[rb]) ? 1 : 0
+      set_z(@gp[rd])
+    end
+
+    def opICmpGe(rd, ra, rb)
+      @gp[rd] = (@gp[ra] >= @gp[rb]) ? 1 : 0
+      set_z(@gp[rd])
+    end
+
+    # Float Arithmetic
+    def opFAdd(rd, ra, rb)
+      result = @fp[ra] + @fp[rb]
+      @fp[rd] = result
+    end
+
+    def opFSub(rd, ra, rb)
+      result = @fp[ra] - @fp[rb]
+      @fp[rd] = result
+    end
+
+    def opFMul(rd, ra, rb)
+      result = @fp[ra] * @fp[rb]
+      @fp[rd] = result
+    end
+
+    def opFDiv(rd, ra, rb)
+      result = @fp[ra] / @fp[rb]
+      @fp[rd] = result
+    end
+
+    def opFMod(rd, ra, rb)
+      result = @fp[ra] % @fp[rb]
+      @fp[rd] = result
+    end
+
+    def opFNeg(rd, ra, rb)
+      @fp[rd] = -@fp[ra]
+    end
+
+    def opFAbs(rd, ra, rb)
+      @fp[rd] = @fp[ra].abs
+    end
+
+    def opFSqrt(rd, ra, rb)
+      @fp[rd] = Math.sqrt(@fp[ra])
+    end
+
+    def opFFloor(rd, ra, rb)
+      @fp[rd] = @fp[ra].floor
+    end
+
+    def opFCeil(rd, ra, rb)
+      @fp[rd] = @fp[ra].ceil
+    end
+
+    def opFRound(rd, ra, rb)
+      @fp[rd] = @fp[ra].round
+    end
+
+    def opFMin(rd, ra, rb)
+      @fp[rd] = [@fp[ra], @fp[rb]].min
+    end
+
+    def opFMax(rd, ra, rb)
+      @fp[rd] = [@fp[ra], @fp[rb]].max
+    end
+
+    def opFSin(rd, ra, rb)
+      @fp[rd] = Math.sin(@fp[ra])
+    end
+
+    def opFCos(rd, ra, rb)
+      @fp[rd] = Math.cos(@fp[ra])
+    end
+
+    def opFExp(rd, ra, rb)
+      @fp[rd] = Math.exp(@fp[ra])
+    end
+
+    def opFLog(rd, ra, rb)
+      @fp[rd] = Math.log(@fp[ra])
+    end
+
+    def opFClamp(rd, ra, rb)
+      # FP[Rd] = clamp(FP[Ra], FP[Rb], Rc) - simplified, just min of ra,rb
+      @fp[rd] = [@fp[ra], @fp[rb]].min
+    end
+
+    def opFLerp(rd, ra, rb)
+      # FP[Rd] = FP[Ra] * t + FP[Rb] * (1-t), with t in Rc
+      # Simplified: use FP[Ra] as t, FP[Rb] as base
+      t = @fp[ra]
+      base = @fp[rb]
+      @fp[rd] = base * (1 - t) + base * t
+    end
+
+    # Float Comparisons
+    def opFCmpEq(rd, ra, rb)
+      @gp[rd] = (@fp[ra] == @fp[rb]) ? 1 : 0
+      set_z(@gp[rd])
+    end
+
+    def opFCmpNe(rd, ra, rb)
+      @gp[rd] = (@fp[ra] != @fp[rb]) ? 1 : 0
+      set_z(1 - @gp[rd])
+    end
+
+    def opFCmpLt(rd, ra, rb)
+      @gp[rd] = (@fp[ra] < @fp[rb]) ? 1 : 0
+      set_z(@gp[rd])
+    end
+
+    def opFCmpLe(rd, ra, rb)
+      @gp[rd] = (@fp[ra] <= @fp[rb]) ? 1 : 0
+      set_z(@gp[rd])
+    end
+
+    def opFCmpGt(rd, ra, rb)
+      @gp[rd] = (@fp[ra] > @fp[rb]) ? 1 : 0
+      set_z(@gp[rd])
+    end
+
+    def opFCmpGe(rd, ra, rb)
+      @gp[rd] = (@fp[ra] >= @fp[rb]) ? 1 : 0
+      set_z(@gp[rd])
+    end
+
+    # Conversions
+    def opIToF(rd, ra, rb)
+      @fp[rd] = @gp[ra].to_f
+    end
+
+    def opFToI(rd, ra, rb)
+      @gp[rd] = @fp[ra].to_i
+    end
+
+    def opBToI(rd, ra, rb)
+      @gp[rd] = (@gp[ra] != 0) ? 1 : 0
+    end
+
+    def opIToB(rd, ra, rb)
+      @gp[rd] = (@gp[ra] != 0) ? 1 : 0
+    end
+
+    # Type/Meta
+    def opCast(rd, ra, rb)
+      # Type-cast: simplified implementation
+      @gp[rd] = @gp[ra]
+    end
+
+    def opSizeOf(rd, ra, rb)
+      # Size of type in GP[Ra], result in GP[Rd]
+      @gp[rd] = 4  # Default size
+    end
+
+    def opTypeOf(rd, ra, rb)
+      # Runtime type tag
+      @gp[rd] = 0  # Integer type
+    end
+
+    # Bitwise
+    def opBAnd(rd, ra, rb)
+      result = @gp[ra] & @gp[rb]
+      set_zn(result)
+      @gp[rd] = result
+    end
+
+    def opBOr(rd, ra, rb)
+      result = @gp[ra] | @gp[rb]
+      set_zn(result)
+      @gp[rd] = result
+    end
+
+    def opBXor(rd, ra, rb)
+      result = @gp[ra] ^ @gp[rb]
+      set_zn(result)
+      @gp[rd] = result
+    end
+
+    def opBShl(rd, ra, rb)
+      result = @gp[ra] << (@gp[rb] & 31)
+      set_zn(result)
+      @gp[rd] = result
+    end
+
+    def opBShr(rd, ra, rb)
+      result = @gp[ra] >> (@gp[rb] & 31)
+      set_zn(result)
+      @gp[rd] = result
+    end
+
+    def opBNot(rd, ra, rb)
+      result = ~@gp[ra]
+      set_zn(result)
+      @gp[rd] = result
+    end
+
+    # Vector Operations
+    def opVLoad(rd, rb, off)
+      addr = @gp[rb] + off
+      (0...256).each do |i|
+        @vr[rd][i] = read_memory_u8(addr + i) || 0
+      end
+    end
+
+    def opVStore(rs, rb, off)
+      addr = @gp[rb] + off
+      @vr[rs].bytes.each_with_index do |byte, i|
+        write_memory(addr + i, 1, byte)
+      end
+    end
+
+    def opVAdd(rd, ra, rb)
+      # Component-wise addition
+      (0...256).each do |i|
+        a = @vr[ra][i].ord
+        b = @vr[rb][i].ord
+        result = (a + b) & 0xFF
+        @vr[rd][i] = result.chr
+      end
+    end
+
+    def opVMul(rd, ra, rb)
+      # Component-wise multiplication
+      (0...256).each do |i|
+        a = @vr[ra][i].ord
+        b = @vr[rb][i].ord
+        result = (a * b) & 0xFF
+        @vr[rd][i] = result.chr
+      end
+    end
+
+    def opVDot(rd, ra, rb)
+      # Dot product -> scalar in F0
+      sum = 0.0
+      (0...256).each do |i|
+        a = @vr[ra][i].ord
+        b = @vr[rb][i].ord
+        sum += a * b
+      end
+      @fp[rd] = sum
+    end
+
+    # A2A Opcodes (stub implementations)
+    def opASend
+      length = fetch8
+      agent_id = fetch8
+      reg = fetch8
+      $stderr.puts "A2A: ASend agent_id=#{agent_id} reg=#{reg}"
+    end
+
+    def opARecv
+      length = fetch8
+      agent_id = fetch8
+      reg = fetch8
+      $stderr.puts "A2A: ARecv agent_id=#{agent_id} reg=#{reg}"
+    end
+
+    def opAAsk
+      length = fetch8
+      agent_id = fetch8
+      reg = fetch8
+      $stderr.puts "A2A: AAsk agent_id=#{agent_id} reg=#{reg}"
+    end
+
+    def opATell
+      length = fetch8
+      agent_id = fetch8
+      reg = fetch8
+      $stderr.puts "A2A: ATell agent_id=#{agent_id} reg=#{reg}"
+    end
+
+    def opADelegate
+      length = fetch8
+      agent_id = fetch8
+      bc_start = fetchu16
+      $stderr.puts "A2A: ADelegate agent_id=#{agent_id} bc_start=#{bc_start}"
+    end
+
+    def opABroadcast
+      length = fetch8
+      reg = fetch8
+      $stderr.puts "A2A: ABroadcast reg=#{reg}"
+    end
+
+    def opASubscribe
+      length = fetch8
+      channel_id = fetch8
+      $stderr.puts "A2A: ASubscribe channel_id=#{channel_id}"
+    end
+
+    def opAWait
+      length = fetch8
+      cond_reg = fetch8
+      $stderr.puts "A2A: AWait cond_reg=#{cond_reg}"
+    end
+
+    def opATrust
+      length = fetch8
+      agent_id = fetch8
+      level = fetch8
+      $stderr.puts "A2A: ATrust agent_id=#{agent_id} level=#{level}"
+    end
+
+    def opAVerify
+      length = fetch8
+      agent_id = fetch8
+      result_reg = fetch8
+      $stderr.puts "A2A: AVerify agent_id=#{agent_id} result_reg=#{result_reg}"
+    end
+  end
+end