ruberon/tools/RVMxI.txt


    Экспериментальная 32/64-битная виртуальная машина RVMxI
---------------------------------------------------------------------------------------------------

Использование

  Скомпилировать исполнитель/дизассемблер в .\tools\RVMxI.ob07
  для Windows32/64 Console или Linux32/64:

    Compiler.exe .\tools\RVMxI.ob07 win32con -nochk a -out RVMxI.exe
    Compiler.exe .\tools\RVMxI.ob07 win64con -nochk a -out RVMxI.exe
    Compiler ./tools/RVMxI.ob07 linux32exe -nochk a -out RVMxI
    Compiler ./tools/RVMxI.ob07 linux64exe -nochk a -out RVMxI

  Будет создан файл "RVMxI.exe" и/или "RVMxI".

  Компилировать программу в байт-код RVMxI:

    Compiler.exe program.ob07 rvm32i [-ram size] [-def host_linux]
    Compiler.exe program.ob07 rvm64i [-ram size] [-def host_linux]
      -ram size  --  установить размер оперативной памяти для программы в килобайтах 32768..262144
                    (32..256 Мбайт), по умолчанию 32768 (32 Мбайт)
      -def host_linux -- если байт-код будет исполняться на Linux (по умолчанию -- Windows)

    Будет создан файл "program.bin".

  Выпонить программу:

    RVMxI.exe program.bin -run <параметры>

  Дизассемблировать программу:

    RVMxI.exe program.bin -dis program.txt

    Будет создан файл "program.txt".
---------------------------------------------------------------------------------------------------

Архитектура

    Регистры

      Не меньше пяти 32/64-битных регистров:

        R0, R1, R2   регистры общего назначения
        BP(R3)       указатель кадра стэка
        SP(R4)       указатель стэка (растет вниз)

        R5, R6...    регистры общего назначения (опционально)

      Регистра связи нет (адрес возврата передается через стэк),
      регистр-счетчик команд (PC) -- скрытый, регистр флагов -- скрытый.

      Нет вещественных регистров, операции с плавающей точкой (single (32-бит) или double (64-бит))
      эмулируются.

    Формат кадра стэка

      Стэк:

        меньше <- |лок. переменные|старый BP|адрес возврата|парам1|парам2|...|парамN| -> больше

          (* 32 бита *)
          адрес(парам1) = BP + 8
          адрес(парам2) = BP + 12
          ...

          (* 64 бита *)
          адрес(парам1) = BP + 16
          адрес(парам2) = BP + 24
          ...

      Параметры передаются через стэк справа налево (как cdecl), результат передается через R0,
      вызывающая процедура очищает стэк (как cdecl).

---------------------------------------------------------------------------------------------------

Формат "исполняемого" файла

  RECORD

      Text:           ARRAY i OF RECORD opcode, param1, param2: INTEGER END; (* байт-код *)
      Types:          ARRAY t OF INTEGER; (* таблица типов-записей *)
      Strings:        ARRAY s OF BYTE;    (* строковые литералы *)
      offTypes:       INTEGER;            (* смещение таблицы типов-записей от начала файла (в байтах) *)
      offStrings:     INTEGER;            (* смещение строковых литералов от начала файла (в байтах) *)
      GlobalSize:     INTEGER;            (* размер глобальных переменных (в словах; слово = 4 байта) *)
      HeapStackSize:  INTEGER;            (* размер области кучи/стэка (в словах; слово = 4 байта) *)
      Reserved:       ARRAY 8 OF INTEGER  (* зарезервировано *)

  END

  Где:

      INTEGER = INT32/INT64
      i = offTypes DIV (3 * sizeof(INTEGER));
      t = (offStrings - offTypes) DIV sizeof(INTEGER)
      s = FILE_SIZE - offStrings - 12 * sizeof(INTEGER)
---------------------------------------------------------------------------------------------------

Система команд

    мнемоника              опкод   парам1   парам2        действие

    STOP                     0       0        0           остановить программу
    RET                      1       0        0           возврат из процедуры (pop PC)
    ENTER imm                2      imm       0           push BP; BP := SP; WHILE imm > 0 DO push 0; DEC(imm) END
    NEG Rn                   3       n        0           Rn := -Rn
    NOT Rn                   4       n        0           Rn := ORD(-BITS(Rn))
    NOP                      5       0        0           нет операции
    XCHG Rn, Rm              6       n        m           temp := Rn; Rn := Rm; Rm := temp
    LDB Rn, [Rm + imm]       7   m*256 + n   imm          Rn := UInt8Ptr(Rm + imm)^
    LDH Rn, [Rm + imm]       8   m*256 + n   imm          Rn := UInt16Ptr(Rm + imm)^
    LDW Rn, [Rm + imm]       9   m*256 + n   imm          Rn := UInt32Ptr(Rm + imm)^
*   PUSH Rn                 10       n        0           DEC(SP, 4); UInt32Ptr(SP)^ := Rn
*   PUSH imm                11      imm       0           DEC(SP, 4); UInt32Ptr(SP)^ := imm
*   POP Rn                  12       n        0           Rn := UInt32Ptr(SP)^; INC(SP, 4)
**  PUSH Rn                 10       n        0           DEC(SP, 8); UInt64Ptr(SP)^ := Rn
**  PUSH imm                11      imm       0           DEC(SP, 8); UInt64Ptr(SP)^ := imm
**  POP Rn                  12       n        0           Rn := UInt64Ptr(SP)^; INC(SP, 8)
    L#hex:                  13      hex       0           метка:
    LEA Rn, TYPES + imm     14    n + 000H   imm          Rn := imm + address(TYPES)
    LEA Rn, STRINGS + imm   14    n + 100H   imm          Rn := imm + address(STRINGS)
    LEA Rn, GLOBAL + imm    14    n + 200H   imm          Rn := imm + address(GLOBAL)
    LEA Rn, HEAP + imm      14    n + 300H   imm          Rn := imm + address(HEAP)
    LEA Rn, STACK + imm     14    n + 400H   imm          Rn := imm + address(STACK)
    LLA Rn, L#hex           15       n       hex          Rn := address(L#hex)
**  LDD Rn, [Rm + imm]      16   m*256 + n   imm          Rn := UInt64Ptr(Rm + imm)^

    JMP L#hex               19      hex       0           goto L#hex
    CALL L#hex              20      hex       0           push PC; goto L#hex
    CALL Rn                 21       n        0           push PC; goto Rn
    MOV Rn, Rm              22       n        m           Rn := Rm
    MOV Rn, imm             23       n       imm          Rn := imm
    MUL Rn, Rm              24       n        m           Rn := Rn * Rm
    MUL Rn, imm             25       n       imm          Rn := Rm * imm
    ADD Rn, Rm              26       n        m           Rn := Rn + Rm
    ADD Rn, imm             27       n       imm          Rn := Rn + imm
    SUB Rn, Rm              28       n        m           Rn := Rn - Rm
    SUB Rn, imm             29       n       imm          Rn := Rn - imm
    DIV Rn, Rm              30       n        m           Rn := Rn DIV Rm
    DIV Rn, imm             31       n       imm          Rn := Rn DIV imm
    MOD Rn, Rm              32       n        m           Rn := Rn MOD Rm
    MOD Rn, imm             33       n       imm          Rn := Rn MOD imm
    STB [Rn + imm], Rm      34   n*256 + m   imm          UInt8Ptr(Rn + imm)^ := Rm MOD 256
    STB [Rn], imm           35       n       imm          UInt8Ptr(Rn)^ := imm MOD 256
    STH [Rn + imm], Rm      36   n*256 + m   imm          UInt16Ptr(Rn + imm)^ := Rm MOD 65536
    STH [Rn], imm           37       n       imm          UInt16Ptr(Rn)^ := imm MOD 65536
*   STW [Rn + imm], Rm      38   n*256 + m   imm          UInt32Ptr(Rn + imm)^ := Rm
*   STW [Rn], imm           39       n       imm          UInt32Ptr(Rn)^ := imm
**  STW [Rn + imm], Rm      38   n*256 + m   imm          UInt32Ptr(Rn + imm)^ := Rm MOD 100000000H
**  STW [Rn], imm           39       n       imm          UInt32Ptr(Rn)^ := imm MOD 100000000H
**  STD [Rn + imm], Rm      40   n*256 + m   imm          UInt64Ptr(Rn + imm)^ := Rm
**  STD [Rn], imm           41       n       imm          UInt64Ptr(Rn)^ := imm

    AND Rn, Rm              46       n        m           Rn := ORD(BITS(Rn) * BITS(Rm))
    AND Rn, imm             47       n       imm          Rn := ORD(BITS(Rn) * BITS(imm))
    OR Rn, Rm               48       n        m           Rn := ORD(BITS(Rn) + BITS(Rm))
    OR Rn, imm              49       n       imm          Rn := ORD(BITS(Rn) + BITS(imm))
    XOR Rn, Rm              50       n        m           Rn := ORD(BITS(Rn) / BITS(Rm))
    XOR Rn, imm             51       n       imm          Rn := ORD(BITS(Rn) / BITS(imm))
    ASR Rn, Rm              52       n        m           Rn := ASR(Rn, Rm)
    ASR Rn, imm             53       n       imm          Rn := ASR(Rn, imm)
    LSR Rn, Rm              54       n        m           Rn := LSR(Rn, Rm)
    LSR Rn, imm             55       n       imm          Rn := LSR(Rn, imm)
    LSL Rn, Rm              56       n        m           Rn := LSL(Rn, Rm)
    LSL Rn, imm             57       n       imm          Rn := LSL(Rn, imm)
    ROR Rn, Rm              58       n        m           Rn := ROR(Rn, Rm)
    ROR Rn, imm             59       n       imm          Rn := ROR(Rn, imm)

    CMP Rn, Rm              64       n        m           сравнить Rn и Rm
    CMP Rn, imm             65       n       imm          сравнить Rn и imm
    BIT Rn, Rm              66       n        m           Rn := ORD({Rm})
    SYSCALL Rn              67       n        0           системный вызов; Rn содержит адрес параметров
    JBT L#hex               68      hex       0           перейти на метку L#hex, если "ниже"
    ADD Rn, Rm, imm         69   m*256 + n   imm          Rn := Rm + imm
    JEQ L#hex               70      hex       0           перейти на метку L#hex, если "равно"
    JNE L#hex               71      hex       0           перейти на метку L#hex, если "не равно"
    JLT L#hex               72      hex       0           перейти на метку L#hex, если "меньше"
    JGE L#hex               73      hex       0           перейти на метку L#hex, если "не меньше"
    JGT L#hex               74      hex       0           перейти на метку L#hex, если "больше"
    JLE L#hex               75      hex       0           перейти на метку L#hex, если "не больше"
    SEQ Rn                  76       n        0           если "равно": Rn := 1, иначе Rn := 0
    SNE Rn                  77       n        0           если "не равно": Rn := 1, иначе Rn := 0
    SLT Rn                  78       n        0           если "меньше": Rn := 1, иначе Rn := 0
    SGE Rn                  79       n        0           если "не меньше": Rn := 1, иначе Rn := 0
    SGT Rn                  80       n        0           если "больше": Rn := 1, иначе Rn := 0
    SLE Rn                  81       n        0           если "не больше": Rn := 1, иначе Rn := 0

Команда CMP сохраняет результат сравнения в скрытом регистре, этот результат используется
в командах перехода по условию (JEQ, JNE, JLT, JGE, JGT, JLE, JBT) а также в командах
установки регистра по условию (SEQ, SNE, SLT, SGE, SGT, SLE).

*  Команда для 32-битной виртуальной машины
** Команда для 64-битной виртуальной машины

---------------------------------------------------------------------------------------------------

Общая структура программы

  CODE:   (* машинный код *)
  LEA     SP, STACK + 0x00000000 (* точка входа; инициализация регистра SP *)
  ...
  STOP    (* конец программы *)

  TYPES:  (* таблица типов-записей *)
  WORD 0x00000000, 0x00000000, 0x00000000, 0x00000000
  WORD 0x00000002, 0x00000002, 0x00000002, 0x00000002
  WORD 0x00000000, 0x00000006, 0x00000000, 0x00000000
  WORD 0x00000002, 0x00000000, 0x0000000D, 0x0000000E
  WORD 0x0000000C, 0x0000000E, 0x0000000C, 0x00000000
  WORD 0x00000000, 0x0000000C, 0x0000000C, 0x00000016
  WORD 0x00000000, 0x0000000C, 0x0000000C, 0x0000000C
  WORD 0x00000000, 0x00000000, 0x0000000C, 0x0000000C
  WORD 0x0000000C, 0x0000000C, 0x0000000C, 0x0000000C
  WORD 0x0000000C, 0x0000000C, 0x00000000, 0x00000000
  WORD 0x0000000C, 0x0000000C, 0x0000000C, 0x00000000
  WORD 0x00000000, 0x0000000C, 0x0000002D, 0x0000002D
  WORD 0x0000002D, 0x00000030, 0x00000030, 0x00000030
  WORD 0x00000030, 0x0000002D, 0x00000000, 0x00000000
  WORD 0x0000000A, 0x00000000, 0x00000002, 0x00000000
  WORD 0x00000000, 0x00000000, 0x00000000, 0x00000000
  WORD 0x00000000, 0x00000000, 0x00000000, 0x00000000
  WORD 0x00000000, 0x0000000C, 0x0000000C, 0x00000000
  WORD 0x00000000, 0x0000000C, 0x00000049, 0x00000049
  WORD 0x00000049, 0x0000004C, 0x0000004C, 0x0000004C
  WORD 0x00000049, 0x0000000C, 0x00000000, 0x0000000C
  WORD 0x00000053, 0x00000053, 0x00000053, 0x00000053
  WORD 0x0000000C, 0x00000000, 0x00000000, 0x00000000
  WORD 0x00000006, 0x0000000C

  STRINGS:  (* строковые литералы *)
  BYTE 0x46, 0x50, 0x55, 0x00, 0x54, 0x72, 0x61, 0x70
  BYTE 0x00, 0x0D, 0x0A, 0x00, 0x61, 0x73, 0x73, 0x65
  BYTE 0x72, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x66, 0x61
  BYTE 0x69, 0x6C, 0x75, 0x72, 0x65, 0x00, 0x4E, 0x49
  BYTE 0x4C, 0x20, 0x64, 0x65, 0x72, 0x65, 0x66, 0x65
  BYTE 0x72, 0x65, 0x6E, 0x63, 0x65, 0x00, 0x62, 0x61
  BYTE 0x64, 0x20, 0x64, 0x69, 0x76, 0x69, 0x73, 0x6F
  BYTE 0x72, 0x00, 0x4E, 0x49, 0x4C, 0x20, 0x70, 0x72
  BYTE 0x6F, 0x63, 0x65, 0x64, 0x75, 0x72, 0x65, 0x20
  BYTE 0x63, 0x61, 0x6C, 0x6C, 0x00, 0x74, 0x79, 0x70
  BYTE 0x65, 0x20, 0x67, 0x75, 0x61, 0x72, 0x64, 0x20
  BYTE 0x65, 0x72, 0x72, 0x6F, 0x72, 0x00, 0x69, 0x6E
  BYTE 0x64, 0x65, 0x78, 0x20, 0x6F, 0x75, 0x74, 0x20
  BYTE 0x6F, 0x66, 0x20, 0x72, 0x61, 0x6E, 0x67, 0x65
  BYTE 0x00, 0x69, 0x6E, 0x76, 0x61, 0x6C, 0x69, 0x64
  BYTE 0x20, 0x43, 0x41, 0x53, 0x45, 0x00, 0x61, 0x72
  BYTE 0x72, 0x61, 0x79, 0x20, 0x61, 0x73, 0x73, 0x69
  BYTE 0x67, 0x6E, 0x6D, 0x65, 0x6E, 0x74, 0x20, 0x65
  BYTE 0x72, 0x72, 0x6F, 0x72, 0x00, 0x43, 0x48, 0x52
  BYTE 0x20, 0x6F, 0x75, 0x74, 0x20, 0x6F, 0x66, 0x20
  BYTE 0x72, 0x61, 0x6E, 0x67, 0x65, 0x00, 0x57, 0x43
  BYTE 0x48, 0x52, 0x20, 0x6F, 0x75, 0x74, 0x20, 0x6F
  BYTE 0x66, 0x20, 0x72, 0x61, 0x6E, 0x67, 0x65, 0x00
  BYTE 0x42, 0x59, 0x54, 0x45, 0x20, 0x6F, 0x75, 0x74
  BYTE 0x20, 0x6F, 0x66, 0x20, 0x72, 0x61, 0x6E, 0x67
  BYTE 0x65, 0x00, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20
  BYTE 0x28, 0x00, 0x29, 0x3A, 0x20, 0x00, 0x6D, 0x6F
  BYTE 0x64, 0x75, 0x6C, 0x65, 0x3A, 0x20, 0x00, 0x6C
  BYTE 0x69, 0x6E, 0x65, 0x3A, 0x20, 0x00, 0x52, 0x54
  BYTE 0x4C, 0x00, 0x54, 0x65, 0x73, 0x74, 0x00, 0x00

  GLOBAL:
  WORDS 0x00000004 (* размер глобальных переменных в словах (слово = 4 или 8 байт) *)

  HEAP:
  WORDS 0x007FFFBF (* размер области кучи/стэка в словах (слово = 4 или 8 байт) *)
  STACK:
  WORDS 8 (* зарезервировано *)
---------------------------------------------------------------------------------------------------