HWW Portfolio

Software and Hardware Developer

ООП на Z80: структуры, vtable и типы без накладных расходов

Заметки о брошенном проекте: Lisp-метаассемблер для Zilog Z80, который знал про типы

Этот проект я забросила. Но по дороге в нём получилось несколько идей, которые мне до сих пор кажутся интересными для всех, кто любит Z80: как дать 8-битной машине структуры, наследование и виртуальные методы, не потеряв при этом ни такта лишнего и не утонув в магических числах. Ниже собрано то, что успело заработать, и честно отмечено то, что не успело.

Z80 OOP

1. С чего всё началось: драйверы для Aleste

Исходная задача была приземлённой. Для платформы Aleste LX и её BIOS я писал спецификацию драйверов (видео, аудио, файловые системы) для Z80 на примерно 4 МГц с банковой памятью. Девиз архитектуры: скорость через предсказуемость.

Главная проблема платформы в том, что видеорежимов много и они противоречивы. Обычный код превращается в лес проверок if/else, и каждая проверка стоит десятков тактов. Решение такое:

На форуме меня спросили, всё ли это про Z80 на 4 МГц. Да. И я называла это «полиморфизмом» с оговоркой: это не ООП ради ООП, а отказ от проверок. Побочный бонус в том, что программа, написанная под один видеорежим, автоматически работает и в любом другом: код думает о логике, а не о железе.

Что говорит спецификация BIOS

Всё это описано в черновике спецификации драйверов Aleste BIOS. Для дальнейшего понадобятся несколько её правил:

Минимальный драйвер состоит только из пяти обязательных методов: всё управление идёт через init() и универсальный command(), куда код команды передаётся в аккумуляторе. Для горячих операций (нарисовать спрайт, вывести символ) такой путь слишком медленный, поэтому драйвер добавляет необязательные методы с быстрым входом прямо внутрь. Простому драйверу (сменить режим, вывести текст) хватает 15 байт таблицы; чем сложнее драйвер, тем больше байт копируется при активации.

2. Ад синхронизации

Первая реализация шла на смеси C и ассемблера. Когда основные модули были написаны, проявилась настоящая цена такого подхода: любое изменение структуры данных приходилось вручную протаскивать по цепочке

.h → .c → .inc → .asm

Смещения полей «плыли», регистры и аргументы методов переставали соответствовать друг другу. Хуже всего были не сами ошибки, а то, что их приходилось ловить на работающем железе.

Первая мысль была простой: генерировать файлы из аннотаций в ассемблерном коде (так появилась спецификация XIFF). Но аннотации по ходу работы сами мутировали в S-выражения, и тогда возник вопрос: зачем аннотации, если можно писать всё на Lisp? Макросы и DSL закрывают ровно ту задачу, ради которой я городил генераторы.

3. Z80-ассемблер как Lisp-макрос

Ассемблер сначала был написан на SOOT (мой диалект Лиспа), потом перенесён на основу из библиотеки Common Lisp и в итоге переписан заново. Предыдущий вариант был хорош, но запутан: несколько уровней макросов порождали россыпь методов, каждый на одну сигнатуру операции.

Ассемблерный код — это обычные S-выражения, поэтому внутри него доступен весь язык:

(defmacro subroutine (name &rest code)
  `(list (lab ',name) ,@code))

(zasm
  $start
    (jp 'label3)
    (db 22)
    (db (list 22 33 44))
    (dw 64)
    (ascii "Hello World\n")
    (align 16)
  $label1
    (jmp 'label1)               ; сам выберет jp или jr
    (ld @c (+ 1 3))             ; расчёт на этапе компиляции
  (subroutine label3
    (ld @a [+ ix 5])            ; DD 7E 05
    (ld [- iy 10] #xAA)))       ; FD 36 F6 AA

Что ассемблер делал сам:

Отдельным приоритетом была диагностика. Макрогенерация без точной локации ошибки превращается в мучение, поэтому сообщение выглядело так:

─── ERROR ──────────────────────────────────
  at common/xiff/soot/asm-test.sot:48
        (jmp 'blo-undefined)
        ^
Error: Can't find label blo-undefined

4. Система типов, которая знает про смещения

Главная идея: ассемблер должен знать о типах столько же, сколько знает компилятор языка высокого уровня. Структура описывается один раз:

(deftype vec3 (structure)
  ((x int16)
   (y int16)
   (z int16))
  (:methods
    (new (int16 int16) none)
    (len () int16)))

После этого окружение знает размеры, иерархию и смещения полей с учётом выравнивания, и всё это можно использовать прямо в коде:

(ld @hl (size-of vec3))
(ld @hl (offset-of vec3 y))
(ld [+ iy (offset-of vec3 y)] 10)   ; → FD 36 02 0A

Вместо магических чисел остаются имена полей, а на выходе чистые константы. Если заменить int16 на int32, все смещения во всех файлах пересчитаются при следующей сборке. Накладных расходов в рантайме нет вообще: тип существует только на этапе компиляции.

Более привычная форма записи использует форму rlet, которая привязывает объект к регистру:

(defmethod clear ((self vec3))
  (rlet ((v :reg ix :source self))
    (zasm
      (.ld (-> v x) 0)
      (.ld (-> v y) 0)
      (.ld (-> v z) 0))))

Результат:

DD 36 00 00 | LD (IX+0), $00
DD 36 02 00 | LD (IX+2), $00
DD 36 04 00 | LD (IX+4), $00

Три практических следствия:

Интроспекция

Само окружение тоже можно исследовать. Оператор -> реализован как специальная форма на стороне C++ и позволяет «гулять» по реестру типов прямо из REPL:

soot> (-> *type-system* pointer-size)
=> 2
soot> (-> *type-system* vec3 x offset)
=> 0
soot> (-> *type-system* int8 size)
=> 1

Под капотом это цепочка виртуальных вызовов make_step_alias по иерархии классов (Aliasable → StructureType → BasicType), а данные зависят от выбранной архитектуры (Z80 или значения по умолчанию). Ради этого пришлось аккуратно разделить «тип поля» и «спецификацию типа», чтобы навигация не путала уровни.

5. Виртуальные методы на Z80

Теперь к самому интересному: как выглядит объектная модель на процессоре, у которого нет ни стека кадров, ни косвенного вызова.

Сразу оговорюсь: в этой схеме два разных механизма полиморфизма, и их легко спутать.

Драйверный работает через слот. Команда CMD_SWITCH_DRIVER копирует vtable выбранной реализации в фиксированное место, а приложение всегда вызывает метки слота (например, __video_draw_pixel). Переключение стоит копирования, а сами вызовы бесплатны.

Объектный работает через тип. В первых двух байтах объекта лежит указатель на vtable его типа, метод берётся по индексу. Переключать ничего не надо, но каждый вызов платит за поиск адреса.

Раскладка у обоих одна: тройки JP по три байта. Поэтому метакоманда vtable могла бы строить и слоты драйверов, и таблицы типов. Для этого проект и затевался: перенести драйверы на новую систему.

Таблица как последовательность переходов

vtable здесь представляет собой массив инструкций JP addr (код C3), по три байта на метод. Индекс метода известен из deftype, поэтому метакоманда vtable сама расставляет переходы:

$vec3::new
      (ret)
$vec3::len
      (ret)
      (align 16)
      (vtable position vec3)

Она смотрит на тип, находит реализованные методы, выстраивает их в правильном порядке и заполняет «дырки» для методов, которые не определены. Добавили метод в deftype, и таблица перестроится сама.

Дескриптор типа и наследование

Макрос .type-descriptor генерирует для каждого типа компактную структуру данных:

(defproc test-type-descriptor ()
  (declare (once) (asm-func none))
  (.type-descriptor object)
  (.type-descriptor structure)
  (.type-descriptor vec3))

И в листинге:

[type::def::vec3]
  DW <type::def::structure>     ; указатель на родителя
[vec3::vtable::new]
  JP vec3::new                  ; переопределённый метод
  JP object::delete             ; унаследованный метод

Наследование получается «бесплатным»: если метод в потомке не переопределён, в его таблицу просто копируется JP на реализацию родителя. Наличие имён и ссылок на родителей в рантайме даёт возможность делать проверку типов прямо на железе.

Соглашение о вызовах

Для методов я принял такие правила:

Процедура объявляет типы аргументов вместе с регистрами, и ассемблер проверяет их при вызове:

(defproc test-copy-string ((dest string :reg de)
                           (src  string :reg hl))
  (declare (once) (asm-func none))
  (.label 'loop)
  (.ld a (@ hl))
  (.ld (@ de) a)
  (.or a)
  (.ret 'z)
  (.inc hl)
  (.inc de)
  (.jr 'loop))

Три способа вызвать

Примитив dcall проверяет типы аргументов и результата и поддерживает три варианта:

(dcall vec3::new int16 int16 _type_)
  1. Прямой вызов, если функция известна статически: обычный CALL, никаких накладных расходов.
  2. Через vtable типа (vec3::vtable::new): явный путь.
  3. Через активную таблицу, которая может лежать где угодно: основа полиморфизма драйверов.

Для вызова метода конкретного объекта нужен IX. Адрес метода берётся из vtable объекта и загружается в IY, дальше вызов идёт через него. Полная форма (с сохранением регистров, сложением со смещением и переходом через RET) выглядит так:

LD IX, $8000       ; объект
PUSH HL / PUSH BC  ; сохраняем регистры
LD L,(IX+0)        ; адрес vtable
LD H,(IX+1)
LD BC, $000F       ; смещение метода
ADD HL, BC
PUSH HL / POP IY   ; метод в IY
POP BC / POP HL
PUSH IY            ; адрес метода в стек
RET                ; «вызов» через RET

Это честно дорого, и я так и подписала: «со всеми накладными расходами». Приём с PUSH + RET как косвенным переходом хорошо известен каждому, кто писал под Z80, а цена показывает, почему в горячем коде вместо этого лучше иметь заранее собранную таблицу и один JP (HL).

6. Что не получилось

Самое важное я оставила на конец. Проект не был закончен, и причины были и технические:

7. Что осталось полезного

Даже брошенный, проект подсказывает несколько идей, которые стоит забрать с собой:

  1. Один источник правды для структур. Описание типа порождает и заголовки, и смещения для ассемблера, и дескрипторы. Это лечит «ад синхронизации» лучше любой дисциплины.
  2. vtable как таблица JP. Три байта на метод, вызов за один прыжок, наследование копированием.
  3. Полиморфизм как отказ от проверок. На 4 МГц выигрыш не в красоте архитектуры, а в тактах: режим выбирается один раз.
  4. Регистры как часть сигнатуры. Когда типы и регистры описаны вместе, большой класс ошибок исчезает ещё на сборке.
  5. Метаассемблер на Lisp-макросах. Макросы дают всё, ради чего другие ассемблеры придумывают отдельные языки директив, и без отдельных языков.

Если вы до сих пор любите Z80, надеюсь, что эти заметки пригодятся: не обязательно в Lisp, подойдёт любой макроассемблер, который умеет считать смещения. Главное, что объектную модель на 8-битной машине действительно можно сделать, и обойдётся она недорого.