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

1. С чего всё началось: драйверы для Aleste
Исходная задача была приземлённой. Для платформы Aleste LX и её BIOS я писал спецификацию драйверов (видео, аудио, файловые системы) для Z80 на примерно 4 МГц с банковой памятью. Девиз архитектуры: скорость через предсказуемость.
Главная проблема платформы в том, что видеорежимов много и они противоречивы. Обычный код превращается в лес проверок if/else, и каждая проверка стоит десятков тактов. Решение такое:
- у полиморфного драйвера есть фиксированный слот в памяти: vtable (слот выровнен до 64 байт ради круглых адресов, минимум же это 15 байт: пять обязательных методов) из инструкций
JPпо три байта; - приложение всегда вызывает метки этого слота, а при смене режима реализация один раз копируется в слот (
LDIR), после чего вызов остаётся прямым, без проверок; простой драйвер копирует всего 15 байт, сложный больше; - накладные расходы вызова через таблицу: один JP (10 тактов) и RET (ещё 10), то есть около 20 тактов (цифру в спецификации, 17, ещё предстоит уточнить);
- синглтоны (MMU, контроллер прерываний, системный таймер) вызываются напрямую по своим меткам и ничего не копируют;
- банки памяти переключаются лениво, только когда это действительно нужно.
На форуме меня спросили, всё ли это про Z80 на 4 МГц. Да. И я называла это «полиморфизмом» с оговоркой: это не ООП ради ООП, а отказ от проверок. Побочный бонус в том, что программа, написанная под один видеорежим, автоматически работает и в любом другом: код думает о логике, а не о железе.
Что говорит спецификация BIOS
Всё это описано в черновике спецификации драйверов Aleste BIOS. Для дальнейшего понадобятся несколько её правил:
- Пять обязательных методов у любого драйвера:
detect(),init(),deinit(),get_info()иcommand(). Питание, смена режима и прочее уходят вcommand()по коду команды, чтобы vtable не разрасталась. - Три состояния: ABSENT, PRESENT, READY. В каждом разрешён свой набор методов, а устройство-специфичные методы доступны только в READY.
- vtable от 15 байт: пять обязательных методов по три байта и до 16 необязательных. Слот в 64 байта нужен только для выравнивания, чтобы адреса получались круглыми. Неиспользуемые записи ведут на общий обработчик
_undefined_method. - Контекст памяти: у драйвера есть 8-байтная структура
MemoryContextс XOR-хешем конфигурации банков. Перед вызовом хеши сравниваются: совпали, значит переключать ничего не надо (5–8 тактов), не совпали, значит окна перенастраиваются (до ~50 тактов). - Ошибки: успех означает CF=0, неудача означает CF=1 и код ошибки в регистре A.
- Принцип KISS: лучше не объявлять функцию, переменную или константу, чем объявить без немедленной цели.
Минимальный драйвер состоит только из пяти обязательных методов: всё управление идёт через 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
Что ассемблер делал сам:
- выбирал между
jpиjrи считал смещения переходов; - вычислял выражения на этапе компиляции;
- поддерживал индексную адресацию
(ix+d)и(iy+d); - собирал модули из нескольких сегментов, выдавал листинг и Intel HEX вместе с таблицей символов.
Отдельным приоритетом была диагностика. Макрогенерация без точной локации ошибки превращается в мучение, поэтому сообщение выглядело так:
─── 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
Три практических следствия:
- не нужно помнить смещения: пишешь
(-> v y), а цифры подставляет компилятор; - ошибки ловятся на сборке: несуществующее поле роняет сборку сразу, а не работающую программу;
- код не привязан к регистру: заменить
ixнаiyможно в одной строкеrlet.
Интроспекция
Само окружение тоже можно исследовать. Оператор -> реализован как специальная форма на стороне 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 генерирует для каждого типа компактную структуру данных:
- ссылку на дескриптор родителя;
- имя типа строкой (для отладки);
- флаги и идентификатор типа;
- собственную vtable.
(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 на реализацию родителя. Наличие имён и ссылок на родителей в рантайме даёт возможность делать проверку типов прямо на железе.
Соглашение о вызовах
Для методов я принял такие правила:
- аргументы передаются последовательно через
AF/HL,DE,BC; IXуказывает на объект;IYуказывает на vtable (для динамической диспетчеризации);- результат возвращается в
AF/HL.
Процедура объявляет типы аргументов вместе с регистрами, и ассемблер проверяет их при вызове:
(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_)
- Прямой вызов, если функция известна статически: обычный
CALL, никаких накладных расходов. - Через vtable типа (
vec3::vtable::new): явный путь. - Через активную таблицу, которая может лежать где угодно: основа полиморфизма драйверов.
Для вызова метода конкретного объекта нужен 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. Что не получилось
Самое важное я оставила на конец. Проект не был закончен, и причины были и технические:
- Скорость компилятора. Он написан на интерпретаторе, а система вышла сложной и работала медленно. Для проектов среднего размера это терпимо, но масштабируемость вызывала у меня обоснованные сомнения.
- Недоделанные куски. Не дошла до конца валидация аргументов методов (
parse-arg): я хотела, чтобы ассемблер бил по рукам, если методу передан не тот регистр или тип. Не были реализованы инстансы (выделение памяти под объекты) и компилятор статических данных, хотя вся инфраструктура интроспекции для него была готова. - Перенос старых драйверов на новую систему так и не начался всерьёз.
7. Что осталось полезного
Даже брошенный, проект подсказывает несколько идей, которые стоит забрать с собой:
- Один источник правды для структур. Описание типа порождает и заголовки, и смещения для ассемблера, и дескрипторы. Это лечит «ад синхронизации» лучше любой дисциплины.
- vtable как таблица
JP. Три байта на метод, вызов за один прыжок, наследование копированием. - Полиморфизм как отказ от проверок. На 4 МГц выигрыш не в красоте архитектуры, а в тактах: режим выбирается один раз.
- Регистры как часть сигнатуры. Когда типы и регистры описаны вместе, большой класс ошибок исчезает ещё на сборке.
- Метаассемблер на Lisp-макросах. Макросы дают всё, ради чего другие ассемблеры придумывают отдельные языки директив, и без отдельных языков.
Если вы до сих пор любите Z80, надеюсь, что эти заметки пригодятся: не обязательно в Lisp, подойдёт любой макроассемблер, который умеет считать смещения. Главное, что объектную модель на 8-битной машине действительно можно сделать, и обойдётся она недорого.