Akron VM y Bytecode

Máquina virtual de propósito general basada en registros: opcodes, codificación de valores y formato binario.

Akron es la VM de bytecode de propósito general de Achronyme — un intérprete basado en registros que ejecuta archivos .achb producidos por el compilador de bytecode. Corre el lenguaje Achronyme en tiempo de ejecución (ach run) y evalúa bloques prove {} en modo VM.

Akron está emparejado con Artik, la VM dedicada a cómputo de testigos. La división es intencional: Akron maneja scripting y estado de heap mutable con GC, mientras que Artik maneja la matemática de testigos sin efectos secundarios, sin heap ni GC.

Arquitectura

Fuente (.ach)
    |
    v
Compilador de Bytecode -> Prototipos de funcion + bytecode
    |
    v
Serializador -> archivo binario .achb
    |
    v
Cargador -> heap + pila + frames de Akron
    |
    v
Interprete -> Ejecucion basada en registros

Estructura de la VM

Akron {
    heap: Heap,              // arenas tipadas + GC
    stack: [Value; 65536],   // pila de registros fija
    frames: Vec<CallFrame>,  // pila de llamadas
    globals: Vec<GlobalEntry>,  // variables globales
    natives: Vec<NativeObj>,    // funciones integradas
    open_upvalues: lista enlazada, // variables de pila capturadas
    stress_mode: bool,          // forzar GC en cada ciclo
}

Frames de Llamada

Cada llamada a función apila un CallFrame:

CallFrame {
    closure: u32,   // handle a Closure en el heap
    ip: usize,      // puntero de instruccion
    base: usize,    // offset base en la pila
    dest_reg: usize, // donde almacenar el valor de retorno
}

El registro R[i] en el frame actual mapea a stack[frame.base + i].

Representación de Valores

Los valores son enteros de 64 bits etiquetados — sin boxing para tipos comunes:

Bits 63..60 = etiqueta de 4 bits
Bits 59..0  = payload de 60 bits

Etiquetas

Los enteros (etiqueta 0) son el tipo mas comun — usar la etiqueta 0 significa que no se necesita enmascaramiento para el caso comun.

Rango de enteros: -2^59 a 2^59 - 1 (576,460,752,303,423,487). El desbordamiento genera IntegerOverflow.

Codificación de Instrucciones

Cada instrucción es un u32 en uno de dos formatos:

Formato ABC

[opcode:8][A:8][B:8][C:8]

Usado para instrucciones de 3 operandos como Add R[A] = R[B] + R[C].

Formato ABx

[opcode:8][A:8][Bx:16]

Usado para instrucciones con un operando de 16 bits, como LoadConst R[A] = K[Bx] o Jump IP = Bx.

Opcodes

Constantes y Movimientos

Aritmética

Comparación y Lógica

Closures y Upvalues

Funciones

Flujo de Control

Globales

Estructuras de Datos

ZK y Despacho

Especiales

Objetos de Función

Cada función compilada produce un struct Function en el heap:

Function {
    name: String,        // para depuracion
    arity: u8,           // conteo de parametros
    max_slots: u16,      // uso pico de registros
    chunk: Vec<u32>,     // instrucciones de bytecode
    constants: Vec<Value>, // pool de constantes
    upvalue_info: Vec<u8>, // pares [is_local, index]
    line_info: Vec<u32>, // numero de linea por instruccion
}

El vector line_info es paralelo a chunk — cada instrucción tiene un número de línea fuente para reporte de errores.

Formato Binario (.achb)

El formato de archivo .achb (versión 9):

Magic:    b"ACH\x09"          (4 bytes)
Metadata: max_slots (u16 LE)

Global Strings:
    count (u32 LE)
    por cada uno: length (u32 LE) + bytes UTF-8

Global Constants:
    count (u32 LE)
    por cada uno: tag (u8) + payload
        INT (0):    i64 LE
        STRING (1): handle u32 LE
        FIELD (8):  4 x u64 LE (limbs Montgomery)
        BYTES (14): u32 LE length + bytes (blobs ProveIR)
        NIL (255):  (sin payload)

Prototypes:
    count (u32 LE)
    por cada uno:
        name_len (u32 LE) + bytes del nombre
        arity (u8)
        max_slots (u16 LE)
        const_count (u32 LE) + constantes
        upvalue_count (u32 LE) + info de upvalue
        bytecode_len (u32 LE) + instrucciones (u32 LE cada una)

Main Bytecode:
    instruction_count (u32 LE)
    instrucciones (u32 LE cada una)

El formato es compatible con el módulo loader de Akron, que deserializa en objetos del heap.

Disposición de Variables Globales

Indice: 0..22       23..
        Nativos     Globales de usuario

Los primeros 23 slots (0-22) están reservados para funciones nativas. Las globales definidas por el usuario comienzan en el índice 23 (USER_GLOBAL_START).

Relación con Artik

Akron y Artik son VMs hermanas con roles disjuntos:

Ver VM de Testigos Artik para los detalles del camino de testigos.

Archivos Fuente