Форум РадиоКот

Основнaя Хабр-Статья.

Целью было сделать некое программируемое Тьюринг-полное устройство, пригодное к использовании в качестве Центрального Процессорного.
Основной акцент делался на кодировании микропрограмм посредством реального механического дампа из шестнадцатеричных тумблеров.
А чтобы не придумывать очередной бинарный машинный код, за основу были взяты тетрады этих тумблеров.

Тем самым…

Код «A1» на тумблере в дампе так и означает выборку регистра «A1»
Код «B2» означает выборку регистра «B2»
Код «AB» означает группу операндов «A,B» для АЛУ-операций. В данном случае - «A1,B2»
Код «EC» означает «End-by-Carry» - выход из подпрограммы по флагу «CF»

Тем самым, чтобы кодировать какую-нибудь небольшую программу, не нужно иметь у себя под носом даже шпаргалку, так как сами тетрады байтов машинного кода являются аббревиатурами и годятся в качестве мнемоники ассемблера сами-по-себе.

В исполнении Принстонской архитектуры на одну операцию затрачивается по 2 такта. Соответственно, Гарвардский вариант требует по 1 такту.

Разрядность контроллера может варьироваться от 4 бит до 64, в зависимости от поставленной задачи и реализации.
Количество всех Регистров Общего Назначения может также варьироваться от 6 до 30.

Причём, роль РОН могут исполнять любые типовые устройства: Таймеры, ПДП, Датчики, Сервоприводы и т.п…
Также, за РОН можно использовать и универсальную магазинную память в режиме FIFO или LIFO, чтобы обеспечить стековые операции.
Концептуально архитектура не ограничивает конечную реализацию процессора. Так как самое главное в процессоре - дешифратор команд, который не должен менять свою логику и обязан декодировать команды в соответствии с парадигмой описываемой архитектуры.

В классическом варианте выполнение программы выполняется не спешно:

Код: Выделить всё

0000 A9      |REG A9      ; (Такт #1) Выборка регистра блока A с индексом #9
0001    AB   |ARG A,B     ; (Такт #2) Сборка группы операндов регистровых групп A и B
0002       0F|MOV A9,B0   ; (Такт #3) Фиксирование в левом операнде данных правого
         | |         ^^
         \ /         ||
          V          |/
          |          |
          +----------+

Но можно ускорить весь процесс:

Код: Выделить всё

0000 A9 AB 0F|MOV A9,B0   ; (Такт #1) Операция выполняется за 1 такт

Если усложнить декодирование команд добавлением нескольких дешифраторов.

Koyaanisqatsi-quatro.png: Четыре дешифратора команд декодируют 32-битное машинное слово в полную команду за 1 такт; (70.5 КБ) 186 скачиваний

Минимально же весь микроконтроллер без АЛУ и РОН можно представить вот так:

Koyaanisqatsi_minimal.png: Минимальный вариант схемы процессора без АЛУ и РОН; (87.43 КБ) 194 скачивания

Допустим, можно на «Кой-Коде» организовать подобие RISC-ядра для эмуляции выполнения команд процессора i8080.
Сначала назначим все регистры i8080 на Кой-Регистры:

Код: Выделить всё

B - B1
C - C1
D - B2
E - C2
H - B3
L - C3
SP- B4C4
A - A1
PC- B5C5
PSW-A1A0
M  - B3C3

Теперь можно описать большинство инструкций процессора i8080 примерно вот так:

Спойлер

Код: Выделить всё

I8080 CODE|KOYAANISQATSI CODE
----------|--------------------
02|STAX B |A1 10 AF|MOV B1C1,A1 ; 5 тактов
0A|LDAX B |A1 10 AE|MOV A1,B1C1 ; 5 тактов
12|STAX D |A1 20 AF|MOV B2C2,A1 ; 5 тактов
1A|LDAX D |A1 20 AE|MOV A1,B2C2 ; 5 тактов
--+-------+--------+-----------
40|MOV B,B|B1 BB 1F|MOV B1,B1   ; 3 такта
41|MOV B,C|B1 BC 1F|MOV B1,C1   ; 3 такта
42|MOV B,D|B1 BB 2F|MOV B1,B2   ; 3 такта
43|MOV B,E|B1 BC 2F|MOV B1,C2   ; 3 такта
44|MOV B,H|B1 BB 3F|MOV B1,B3   ; 3 такта
45|MOV B,L|B1 BC 3F|MOV B1,C3   ; 3 такта
46|MOV B,M|B1 30 BE|MOV B1,B3C3 ; 5 тактов
47|MOV B,A|B1 BA 1F|MOV B1,A1   ; 3 такта
--+-------+--------+-----------
48|MOV C,B|C1 CB 1F|MOV C1,B1
49|MOV C,C|C1 CC 1F|MOV C1,C1
4A|MOV C,D|C1 CB 2F|MOV C1,B2
4B|MOV C,E|C1 CC 2F|MOV C1,C2
4C|MOV C,H|C1 CB 3F|MOV C1,B3
4D|MOV C,L|C1 CC 3F|MOV C1,C3
4E|MOV C,M|C1 30 CE|MOV C1,B3C3
4F|MOV C,A|C1 CA 1F|MOV C1,A1
--+-------+--------+-----------
50|MOV D,B|B2 BB 1F|MOV B2,B1
51|MOV D,C|B2 BC 1F|MOV B2,C1
52|MOV D,D|B2 BB 2F|MOV B2,B2
53|MOV D,E|B2 BC 2F|MOV B2,C2
54|MOV D,H|B2 BB 3F|MOV B2,B3
55|MOV D,L|B2 BC 3F|MOV B2,C3
56|MOV D,M|B2 30 BE|MOV B2,B3C3
57|MOV D,A|B2 BA 1F|MOV B2,A1
--+-------+--------+-----------
58|MOV E,B|C2 CB 1F|MOV C2,B1
59|MOV E,C|C2 CC 1F|MOV C2,C1
5A|MOV E,D|C2 CB 2F|MOV C2,B2
5B|MOV E,E|C2 CC 2F|MOV C2,C2
5C|MOV E,H|C2 CB 3F|MOV C2,B3
5D|MOV E,L|C2 CC 3F|MOV C2,C3
5E|MOV E,M|C2 30 CE|MOV C2,B3C3
5F|MOV E,A|C2 CA 1F|MOV C2,A1
--+-------+--------+-----------
60|MOV L,B|B3 BB 1F|MOV B3,B1
61|MOV L,C|B3 BC 1F|MOV B3,C1
62|MOV L,D|B3 BB 2F|MOV B3,B2
63|MOV L,E|B3 BC 2F|MOV B3,C2
64|MOV L,H|B3 BB 3F|MOV B3,B3
65|MOV L,L|B3 BC 3F|MOV B3,C3
66|MOV L,M|B3 30 BE|MOV B3,B3C3
67|MOV L,A|B3 BA 1F|MOV B3,A1
--+-------+--------+-----------
68|MOV L,B|C3 CB 1F|MOV C3,B1
69|MOV L,C|C3 CC 1F|MOV C3,C1
6A|MOV L,D|C3 CB 2F|MOV C3,B2
6B|MOV L,E|C3 CC 2F|MOV C3,C2
6C|MOV L,H|C3 CB 3F|MOV C3,B3
6D|MOV L,L|C3 CC 3F|MOV C3,C3
6E|MOV L,M|C3 30 CE|MOV C3,B3C3
6F|MOV L,A|C3 CA 1F|MOV C3,A1
--+-------+--------+-----------
70|MOV M,B|B1 30 BF|MOV B3C3,B1
71|MOV M,C|C1 30 CF|MOV B3C3,C1
72|MOV M,D|B2 30 BF|MOV B3C3,B2
73|MOV M,E|C2 30 CF|MOV B3C3,C2
74|MOV M,H|B3 30 BF|MOV B3C3,B3
75|MOV M,L|C3 30 CF|MOV B3C3,C3
76|HLT    |00      |HLT
77|MOV M,A|A1 30 AF|MOV B3C3,A1
--+-------+--------+-----------
78|MOV A,B|A1 AB 1F|MOV A1,B1
79|MOV A,C|A1 AC 1F|MOV A1,C1
7A|MOV A,D|A1 AB 2F|MOV A1,B2
7B|MOV A,E|A1 AC 2F|MOV A1,C2
7C|MOV A,H|A1 AB 3F|MOV A1,B3
7D|MOV A,L|A1 AC 3F|MOV A1,C3
7E|MOV A,M|A1 A0 CE|MOV A1,B3C3
7F|MOV A,A|A1 AA 1F|MOV A1,A1
--+-------+--------+-----------
88|ADC B  |A1 AB 1A|ADD A1,B1   ; 3 такта
89|ADC C  |A1 AC 1A|ADD A1,C1   ; 3 такта
8A|ADC D  |A1 AB 2A|ADD A1,B2   ; 3 такта
8B|ADC E  |A1 AC 2A|ADD A1,C2   ; 3 такта
8C|ADC H  |A1 AB 3A|ADD A1,B3   ; 3 такта
8D|ADC L  |A1 AC 3A|ADD A1,C3   ; 3 такта
8E|ADC M  |A1AA301A|ADD A1,B3C3 ; 6 тактов
8F|ADC A  |A1 AA 1A|ADD A1,A1   ; 3 такта
--+-------+--------+-----------
98|SBB B  |A1 AB 1B|SUB A1,B1
99|SBB C  |A1 AC 1B|SUB A1,C1
9A|SBB D  |A1 AB 2B|SUB A1,B2
9B|SBB E  |A1 AC 2B|SUB A1,C2
9C|SBB H  |A1 AB 3B|SUB A1,B3
9D|SBB L  |A1 AC 3B|SUB A1,C3
9E|SBB M  |A1AA301B|SUB A1,B3C3
9F|SBB A  |A1 AA 1B|SUB A1,A1
--+-------+--------+-----------
A0|ANA B  |A1 AB 1C|AND A1,B1
A1|ANA C  |A1 AC 1C|AND A1,C1
A2|ANA D  |A1 AB 2C|AND A1,B2
A3|ANA E  |A1 AC 2C|AND A1,C2
A4|ANA H  |A1 AB 3C|AND A1,B3
A5|ANA L  |A1 AC 3C|AND A1,C3
A6|ANA M  |A1AA301C|AND A1,B3C3
A7|ANA A  |A1 AA 1C|AND A1,A1
--+-------+--------+-----------
A8|XRA B  |A1 AB 1E|EOR A1,B1
A9|XRA C  |A1 AC 1E|EOR A1,C1
AA|XRA D  |A1 AB 2E|EOR A1,B2
AB|XRA E  |A1 AC 2E|EOR A1,C2
AC|XRA H  |A1 AB 3E|EOR A1,B3
AD|XRA L  |A1 AC 3E|EOR A1,C3
AE|XRA M  |A1AA301E|EOR A1,B3C3
AF|XRA A  |A1 AA 1E|EOR A1,A1
--+-------+--------+-----------
B0|ORA B  |A1 AB 1D|OR  A1,B1
B1|ORA C  |A1 AC 1D|OR  A1,C1
B2|ORA D  |A1 AB 2D|OR  A1,B2
B3|ORA E  |A1 AC 2D|OR  A1,C2
B4|ORA H  |A1 AB 3D|OR  A1,B3
B5|ORA L  |A1 AC 3D|OR  A1,C3
B6|ORA M  |A1AA301D|OR  A1,B3C3
B7|ORA A  |A1 AA 1D|OR  A1,A1
--+-------+--------+-----------
CE|ACI IB |A1AA501A|ADD A1,B5C5
DE|SBI IB |A1AA501B|SUB A1,B5C5
E6|ANI IB |A1AA501C|AND A1,B5C5
EE|XRI IB |A1AA501E|EOR A1,B5C5
F6|ORI IB |A1AA501D|OR  A1,B5C5

Откуда видно, что большинство команд легко накладываются на эмуляцию. Тем самым, если использовать ПЗУ 4 кб под прошивку микрокода и под каждую команду выделить по 16 байтов Кой-Кода, то в Гарвардском исполнении большинство из этих команд будут выполняться за 3 такта. И если на считывание кода команды в цикле M1 будет затрачено 2 такта, то на большинство этих команд в общей сложности будет затрачиваться по 5 тактов или 8 тактов, что практически сравнимо с производительностью самого i8080…
Если не скупиться и использовать четвёрку дешифратора команд, на Кой-Команды будет уходить по 1 такту или по 3, а в общей сложности на чтение i8080-кода и его исполнение будет тратиться по 3 такта или 5, что уже заметно лучше.

P.S.: Здесь и далее будут использоваться сокращения вида «Кой-Дамп», «Кой-Код» и т.п…

За всё это время удалось выделить силы на разработку более-менее инструментальной среды для Койяанискаци.

Ссылка запуска онлайн эмулятора

На странице эмуляции на данный момент уже имеется ассемблер, дизассемблер, дамп памяти и графический дисплей.
Среда пока очень примитивная, но даёт возможность увидеть задуманное в действии и немного вникнуть в суть.

В поле редактирования листинга можно производить любые изменения, которые будут транслированы и вступят в силу при очередном обновлении страницы.

Графический дисплей исполнен в виде симуляции ЖК-дисплея на сегментах, а в качестве демонстрации выбран эскиз с экрана Советской карманной электронной игры Автослалом: Программно можно лишь включать/отключать нужные сегменты, но нельзя попиксельно строить другое произвольное изображение.

Как и писалось выше, процессор Койянискаци разрабатывался прежде всего как микроконтроллер с интуитивно понятным машинным кодом без оглядки на производительность и прежде всего он предназначен для управления инкубатором или теплицей, когда высокая производительность не является одной из важнейших показателей системы.
А для периодического обновления показаний различных датчиков на цифровом дисплее не нужно иметь сложнейшую графическую систему и можно обойтись профильным ЖК.

Управление ЖК (виртуальным)
Всего до 72 сегментов ЖК управляются напрямую через девять 8-битных периферийных регистров общего назначения D₀…₈.
При этом следует сначала записать в регистр D₉ значение 0xCB (Coloured Buffer) для обеспечения прямого доступа к сегментам.

Вывод на консоль (виртуальную)
При печати приветственного «Hello, World!» используется вывод ASCII-последовательности в регистр D₀.
Однако, перед этим в регистр D₉ записывается значение 0xC0 (Console 0ut) для обеспечения прямого канала на печать текстом.

Управление таймером
Программирование микросхемы таймера i8253 (К580ВИ53) происходит через регистры общего назначения D₀…₃.
Перед этим в регистр D₉ должно быть записано значение 0x53 (индекс целевой микросхемы).
(В эмуляторе пока не реализовано.)

Управление периферией
Программирование микросхемы ППА i8255 (К580ВИ55) производится через регистры общего назначения D₀…₃.
Перед этим в регистр D₉ должно быть записано значение 0x55 (индекс целевой микросхемы).
(В эмуляторе пока не реализовано.)

Управление ПДП
Все регистры микросхемы ПДП i8257 (К580ВТ57) доступны через регистры D₀…₇ и D₈ для статуса ПДП.
Перед программированием ПДП необходимо в регистр D₉ записать значение 0x57 (индекс целевой микросхемы) для доступа к микросхеме.
(В эмуляторе пока не реализовано.)

Чтение клавиатуры
Для чтения регистров микросхемы контроллера клавиатуры i8279 (К580ВВ79) следует использовать регистры общего назначения D₀ и D₁.
Перед доступом к контроллеру в регистр D₉ следует записать значение 0x79 (индекс целевой микросхемы) для обеспечения её выборки.
(В эмуляторе пока не реализовано.)

Буфер магазинной памяти
Доступ к микросхеме M66250P осуществляется через регистры общего назначения D₀ и D₁.
Перед доступом к контроллеру в регистр D₉ следует записать индекс целевой микросхемы для обеспечения её выборки.
(В эмуляторе пока не реализовано.)

Код: Выделить всё

╔════╤════════╤════════════════════════════════════════════════════════════════╗
║ D9 │  ИМС   │ Описание доступа к ресурсам микросхемы через РОН процессора    ║
╠════╪════════╪════════════════════════════════════════════════════════════════╣
║0x53│ i8253  │ D0/D1/D2 - Каналы Счётчиков 0/1/2                              ║
║    │К580ВИ53│ D3 - Регистр Статуса Таймера                                   ║
╟────┼────────┼────────────────────────────────────────────────────────────────╢
║0x55│ i8255  │ D0/D1/D2 - Порты A/B/C ППА                                     ║
║    │К580ВИ55│ D3 - Регистр Статуса ППА                                       ║
╟────┼────────┼────────────────────────────────────────────────────────────────╢
║0x57│ i8257  │ D0/D2/D4/D6 - Каналы 0/1/2/3: ПДП Адрес                        ║
║    │        │ D1/D3/D5/D7 - Каналы 0/1/2/3: ПДП Счёт                         ║
║    │К580ВТ57│ D8 - Регистр Статуса ПДП                                       ║
╟────┼────────┼────────────────────────────────────────────────────────────────╢
║0x79│ i8279  │ D0 - Регистр Данных                                            ║
║    │К580ВВ79│ D1 - Регистр Статуса                                           ║
╚════╧════════╧════════════════════════════════════════════════════════════════╝

Демонстрация
При открытии страницы регистры BC₀ (B₀ и C₀) сброшены, что сигнализирует о холодном старте системы.
Нажатиями на кнопку «Step» можно приступить к пошаговому исполнению программы и проследить за исполнением каждой команды.
Кнопкой «Run» можно запустить цикл автоматического исполнения программного кода, который может быть прерван только инструкцией HLT. Без соблюдения этого условия эмуляция может зациклиться и страничка браузера зависнет.
Исходный листинг составлен так, чтобы по первому нажатию на «Run» произвести предустановку всех нужных регистров и вывести приветственное сообщение. Но последующие нажатия на «Run» будут перезаписывать регистры маскирования ЖК-сегментов для воспроизведения имитации игровой сцены известной игры.

Так уж случилось, что из-за поломки основного ПК всё оказалось на долгой паузе...

Все, кто знаком и работает с архитектурой x86 / IA32, давно в курсе, что она - далека от совершенства…
Но, так как на разработку конкретной архитектуры всегда влиял так или иначе Intel, буду приводить примеры на IA-32 для доходчивости…

LEA EBX,[EBX+EBX*2+3] ; Знакомый всем трюк продвинутого ADD
ADD EBX,[EBX+EBX*2+3] ; Здесь получим исключение, так как регистр базы и регистр индекса - один. Что "из ряда вон!" ("маргинал" какой-то…)

Вот такие случаи в Intel никак не предусмотрели и оставили всё на совести программиста, переложив всю заботу на обработчик исключения.

MOV EAX,FS:[0x00000018] ; Встречается порою вполне знакомое…
MOV EAX,CS: DS: ES: FS:[0x00000018] ; Процессор проигнорирует в этой куче три лишних префикса. Но, запись - "из ряда вон!" ("маргинал" какой-то…)

И такие случаи в Intel демократично проигнорировали и оставили на совести программиста…

Теперь читатели темы достаточно подготовились к нововведению…

МАРГИНАЛЫ
Как уже говорилось многим выше, префиксы кодируются с помощью любого ненулевого BCD.

код «10» означает указатель на ячейку в памяти по адресу «[D1+0]» (левый ниббл адресует регистр базы, правый ниббл определяет относительное смещение)
код «10 23» усложняет указатель добавлением к базовому ещё и индексного регистра, что получается «[D1+D2+3]»
код «10 23 45» добавляет ещё один индексный регистр и теперь получилось «[D1+D2+D4+35]» (относительное смещение ожидаемо множится на 10 и накапливает правые нибблы)
код «10 23 45 16» получился недопустимым, как «[D1+D2+D4+D1+356]»! Так какой же регистр здесь можно считать базовым, если D1 повторяется вновь?

Как уже можно догадаться, это - та самая ситуация "из ряда вон!" с условным кодовым именем "маргинал какой-то"…

Естественно, для решения этой задачи не требуется никакой вычислительной мощности, так как здесь - концептуальная проблема.
На решение этой проблемы у меня ушёл, без малого, год…
Год, в часы досуга, на листке бумаги карандашом расписывались подобные ситуации с поиском решения.

И решение было найдено достаточно изящное и гибкое!

код «10 23 45 16» следует интерпретировать как «[D1+(D2+D4)*2+356]», где повторяемый регистр базы служит признаком удвоения суммы индексов
код «10 23 45 16 47» здесь описывает указатель как «[D1+(D2+D4)*2+D4+3567]», что можно упростить до «[D1+2*D2+3*D4+3567]» следуя нехитрым школьным правилам
код «10 23 45 16 47 48» показывает «[D1+(D2+D4)*2+D4+D4+35678]» повторяя D4 дважды. Интерпретируем как «[D1+((D2+D4)*2+D4)*2+D4+35678]» и получаем «[D1+4*D2+7*D4+35678]»

Совсем нетрудно догадаться, что появились механизмы умножения индексных регистров через последовательно-выборочный двоичный сдвиг. Да, код при этом начинает разбухать прилично, но программист получает возможность описать указатель любой сложности.

Одним словом… Эврика!

Но, оказывается, здесь кроется один крошечный подвох…

код «10 10» как следует интерпретировать, если индексные регистры ещё не указаны, а умножение - «[D1+(0)*2+0]» - действует?
код «10 10 10» с таким механизмом это «[D1+((0)*2)*2+0]» - что это такое вообще???

Ещё месяцы ушли на решение этой концептуальной задачи.

В итоге, получилось следующее:

код «10 10» подавляет (сбрасывает) регистр базы и аккумулируется как «маргинал»: Условно, через шарп - «1#»
код «10 10 10» образует «маргинал 1#», но указатель снова в деле. Получаем маргинальный указатель - «1#[D1+0]»
код «80 80 70 70 10» уже интерпретируется как маргинальный указатель «87#[D1+0]»

Тем самым, никакие исключения, в жанре Intel, в моей архитектуре не понадобились, а в сумме - появились и комплексные векторы на ячейку памяти, и «маргинализаторы операций», выводящие код инструкций «вон из процессора» - в сопроцессор…

Естественно, всё это не ограничилось JavaScript-опытами (ссылка на JavaScript кодировщик инструкции).

Verilog-модель аккумулятор эффективного адреса и детекции маргиналов:

Спойлер

Код: Выделить всё

module	vector_accumulator
(input	wire		clk		// Clock (positive edge)
,input	wire		vector_en	// Enable parse vector (BDC detected)
,input	wire		vector_clr	// Clear vector (after any instruction)
,input	wire	[7:0]	operation	// Operation code (BDC only)
,input	wire	[15:0]	vector_input	// Pointer input (pair B:C from register file)
,output	reg	[15:0]	vector_output	// Full vector output (summ of Base + Index + Offset)
,output	reg		vector_margin	// Marginal flag (incorrect Index of "dry" Vector)
);
	reg	[3:0]	pointer_index;	// Index of "base" in operation code
	reg	[3:0]	offset_digit;	// Digit of BDC-digit for "offset"
	reg		is_base;	// Flag of "base" (Index is equal of Base)
	reg		is_shift;	// Flag of "shifting" (Index is repeated in current summ)
	reg	[3:0]	base_index;	// Index of current "base" (Index of Base)
	reg	[9:0]	pointers_set;	// Collection of used pointers (flags of used Indexes in current summ)
	reg	[9:0]	pointer_mask;	// Mask of current pointer
	reg	[15:0]	vector_base;	// Pointer of "base"
	reg	[15:0]	vector_index;	// Summ of used pointers
	reg	[15:0]	vector_offset;	// Decimal offset
	reg	[15:0]	offset_shift;	// Offset multipled by 10

	always	@*
	begin
		pointer_index = operation[7:4];
		pointer_mask = 10'b1 << pointer_index;
		is_base = &(base_index ^ pointer_index);
		is_shift = |(pointers_set & pointer_mask);
		offset_digit = operation[3:0];
		offset_shift = (((vector_offset << 2) + vector_offset) << 1) + {12'd0, offset_digit};
		vector_output = vector_base + vector_index + vector_offset;
		vector_margin = vector_en && ~|offset_digit && is_base && ~|vector_offset && ~|pointers_set;
	end

	always	@(posedge clk)
	begin
		if(vector_clr)
		begin
			base_index <= 0;
			vector_base <= 0;
			vector_index <= 0;
			vector_offset <= 0;
			pointers_set <= 0;
		end else
		if(vector_margin)
			base_index <= 0;
		else
		if(vector_en)
		begin
			vector_offset <= offset_shift;
			if(~|base_index)
			begin
				base_index <= ~pointer_index;
				vector_base <= vector_input;
			end else
			if(is_base)
			begin
				vector_index <= vector_index << 1;
				pointers_set <= pointer_mask;
			end else
			if(is_shift)
			begin
				vector_index <= (vector_index << 1) + vector_input;
				pointers_set <= pointer_mask;
			end else begin
				vector_index <= vector_index + vector_input;
				pointers_set <= pointers_set | pointer_mask;
			end
		end
	end
endmodule

BDC-Accumulator-part#1.png: Незаконченная схема вычислителя "эффективного адреса"; (183.69 КБ) 40 скачиваний

Те же Intel в своей IA-64 не стали разбираться с корректным выполнением инструкций типа «ADD DX,AX» и вообще обнуляют старшие 32 бита RDX в таких случаях.
И здесь по стопам Intel мне совсем ни к чему. Просто на аппаратном уровне такие ситуации также отлавливаются и устанавливаются ещё один флаг.
К тому же, регистр A0 у меня выполняет функцию PSW: Использовать его в вычислениях бессмысленно.
И регистры группы D0-D9 ссылаются либо к портам УВВ (Devices), либо к регистровым парам (как DX - это DH и DL).
Если «MOV BL,BL» работает как «NOP», то мне такие «пустышки» в большом количестве не нужны - такие ситуации также отлавливаются.
Как результат, шесть инструкций «ADD / SUB / AND / OR / EOR / MOV» дешифратором с учётом всех комбинаций операндов синтезируются в три десятка различных инструкций.
Тем самым, к АЛУ подтягивается уже не три бита кода операции, а все 11, из-за чего программно доступно уже большее число разнообразных инструкций всех видов.

Спойлер

Код: Выделить всё

+--------------> Имеется "маргинальный префикс"
|
| +------------> Имеется "векторный префикс"
| |
| | ++---------> Приёмник - либо A0/PSW, либо порт Dj, либо 16-битная регистровая пара Bn:Cn
| | ||
| | || +-------> Приёмник и источник - один РОН или регистровая пара
| | || |
| | || | ++----> Приёмник - либо A0/PSW, либо порт Dj, либо 16-битная регистровая пара Bi:Ci
| | || | ||
| | || | || +--> Признак FOR/MOV - не АЛУ-операции
| | || | || |
M V AD E AD F
X_1_10_1_XX_1:  MOV     PSW,[V]         ; Чтение PSW из ОЗУ
X_1_10_1_XX_0:  UNARY   [V]             ; Унарные INC/DEC/CLR/SET/NOT над ОЗУ
X_0_10_1_XX_1:  MOV???  PSW,PSW         ; 1 шт. !!!reserved!!!
X_0_10_1_XX_0:  UNARY?? PSW             ; 5 шт. !!!reserved!!!
X_1_10_X_01_1:  SWAP    [V],Dn          ; XCHG ОЗУ и 16-битной пары
X_1_10_X_01_0:  ALU_OP  [V],Dn          ; АЛУ-ADD/SUB/AND/OR/EOR 16-битного ОЗУ и пары
X_0_10_X_01_1:  INF     Dj              ; MOV PSW,Dj - Попытка ввода из порта (результат - в CF)
X_0_10_X_01_0:  UNARY   Dn              ; 16-битные унарные INC/DEC/CLR/SET/NOT
X_1_10_X_XX_1:  SWAP    [V],Rn          ; XCHG ОЗУ и 8-битного РОН
X_1_10_X_XX_0:  ALU_OP  [V],Rn          ; АЛУ-ADD/SUB/AND/OR/EOR ОЗУ и 8-битного РОН
X_0_10_X_XX_1:  MOV     PSW,Rn          ; Чтение PSW из РОН
X_0_10_X_XX_0:  UNARY   Rn              ; Унарные INC/DEC/CLR/SET/NOT над РОН
X_1_01_X_10_X:  ALU/MOV Dn,[V]          ; АЛУ-ADD/SUB/AND/OR/EOR и MOV пары с 16-битным ОЗУ
X_0_01_X_10_1:  OUF     Dj              ; MOV Dj,PSW - Попытка вывода в порт (результат - в CF)
X_0_01_X_10_0:  UNARY   Dn,CF           ; Унарные INC/DEC/CLR/SET/NOT над парой при условии CF
X_1_00_X_10_X:  ALU/MOV Rn,[V]          ; АЛУ-ADD/SUB/AND/OR/EOR и MOV РОН с ОЗУ
X_0_00_X_10_1:  MOV     Rn,PSW          ; Загрузка PSW в РОН
X_0_00_X_10_0:  UNARY   Rn,CF           ; Унарные INC/DEC/CLR/SET/NOT над РОН при условии CF
X_1_01_1_XX_1:  LEA     Dn,[V]          ; Загрузка "эффективного адреса" в регистровую пару
X_1_01_0_01_1:  ORD     Dn,[V],Di       ; Dn = (MAX(Dn, Di) - ОЗУ) >> 1
X_1_01_X_01_0:  ALU_OP  Dn,[V],Di       ; 16-битная ADD/SUB/AND/OR/EOR ОЗУ с Di, результат в Dn
X_0_XX_1_XX_1:  MOV???  R,R             ; 1 шт. Холостая пересылка (NOP???)
X_0_01_1_XX_0:  UNARY?? Dn              ; 5 шт. 16-битные унарные INC/DEC/CLR/SET/NOT (повтор!!!)
X_1_01_0_XX_1:  LEX     Dn,[V],Ri       ; 16-битный XLAT: MOV Dn,[V+2*Ri]
X_1_01_X_XX_0:  ALU_OP  Dn,[V],Ri       ; 8-битная ADD/SUB/AND/OR/EOR ОЗУ с РОН, результат в 16-бит Dn
X_0_01_0_00_1:  MOV     Dj,Ri           ; Аналог OUT Dj,Ri - вывод в порт
X_0_01_X_XX_0:  ALU_OP  Dn,Ri           ; 16-битная ADD/SUB/AND/OR/EOR Dn с 8-битным Dn
X_1_0X_X_01_1:  MOV???  R,[V],Dj        ; 1 шт. !!!СТРАННАЯ ОПЕРАЦИЯ!!!
X_1_0X_X_01_0:  ALU_OP  R,[V],Dj        ; 8-битная ADD/SUB/AND/OR/EOR ОЗУ с портом Dj, результат в РОН
X_0_0X_X_01_X:  ALU/MOV R,Dj            ; АЛУ-ADD/SUB/AND/OR/EOR или MOV (IN R,Dj) РОН с портом Dj
X_1_0X_1_0X_1:  LEX     R,[V]           ; 8-битный XLAT: MOV R,[V+R]
X_1_0X_0_0X_1:  ORD     R,[V],R'        ; R = (MAX(R, R') - ОЗУ) >> 1
X_1_0X_X_01_X:  ALU/MOV R,[V],R'        ; ADD/SUB/AND/OR/EOR или MOV ОЗУ с R', результат в РОН
X_0_0X_X_01_X:  ALU/MOV R,R'            ; ADD/SUB/AND/OR/EOR или MOV ОЗУ с R', результат в РОН

Примеры:__________________________________
AA A0 12 0F     MOV     PSW,[D1+2]      ; На самом деле, полная мнемоника операции - MOV A0,[D1+2],A0
AA A0 12 0E     NOT     [D1+2]          ; На самом деле, полная мнемоника операции - EOR A0,[D1+2],A0
AD A0 12 3F     SWAP    [D1+2],D3       ; На самом деле, полная мнемоника операции - MOV A0,[D1+2],D3
AD A0 1F        INF     D1              ; На самом деле, полная мнемоника операции - MOV A0,D1
AD A0 1E        NOT     D1              ; На самом деле, полная мнемоника операции - EOR A0,D1
AB A0 12 3F     SWAP    [D1+2],B3       ; На самом деле, полная мнемоника операции - MOV A0,[D1+2],B3
AB A0 12 3E     EOR     [D1+2],B3       ; На самом деле, полная мнемоника операции - EOR A0,[D1+2],B3
AB A0 1F        MOV     PSW,B1          ; На самом деле, полная мнемоника операции - MOV A0,B1
AB A0 1E        NOT     B1              ; На самом деле, полная мнемоника операции - EOR A0,B1
DA D1 0F        OUF     D1              ; На самом деле, полная мнемоника операции - MOV D1,A0
DA D1 0E        NOT     D1,CF           ; На самом деле, полная мнемоника операции - EOR D1,A0
DD D1 23 1F     LEA     D1,[D2+3]       ; На самом деле, полная мнемоника операции - MOV D1,[D2+3],D1
DD D1 23 4F     ORD     D1,[D2+3],D4    ; На самом деле, полная мнемоника операции - MOV D1,[D2+3],D4
DC D1 23 4F     LEX     D1,[D2+3],C4    ; На самом деле, полная мнемоника операции - MOV D1,[D2+3],C4

Например, вот фрагмент логов отладчика дешифратора команд:

M# / M - последовательность "маргиналов"
VV / V - наличие корректного вектора
IC - код инструкции
E - флаг использования одного регистра за приёмник и за транслятор
AD - флаги наличия A0/PSW или D со стороны приёмника или транслятора

При прогонке отладочного кода через отладочную модель дешифратора команд выдаётся примерно такой лог:

Спойлер

Код: Выделить всё

VCD info: dumpfile testbench.vcd opened for output.
_IP_:M#[VV]IC  M_V_AD_E_AD_F RC<>TR _ASM ..OPERANDS..	_REAL INSTRUCTION_
0000:      AA  0_0_x0_x_0x_0:A?!=0?  ARG   A,A
0001:      A0  0_0_x0_x_00_0:A?!=AA  REG   A0
0002:86#59 A0  1_1_10_0_00_0:A0!=AA  MOV86 D1+2D2+3D3+4D4+5D5+67D6+789,A0
0016:03#   A0  1_0_10_0_00_0:A0!=AA  REG3  A0		; Marginaled
0019:      0F  0_0_10_1_10_1:A0==A0  ---   ???		; MOV	A0,A0
001A:      0E  0_0_10_1_10_0:A0==A0  ---   ???		; EOR	A0,A0
001B:      0D  0_0_10_1_10_0:A0==A0  ---   ???		; DIS	A0,A0
001C:      0C  0_0_10_1_10_0:A0==A0  ---   ???		; CON	A0,A0
001D:      0B  0_0_10_1_10_0:A0==A0  ---   ???		; SUB	A0,A0
001E:      0A  0_0_10_1_10_0:A0==A0  ---   ???		; ADD	A0,A0
001F:   34 0F  0_1_10_1_10_1:A0==A0  MOV   PSW,D3+4	; MOV	A0,D3+4,A0
0021:   34 0E  0_1_10_1_10_0:A0==A0  NOT   D3+4		; EOR	A0,D3+4,A0
0023:      AD  0_0_10_0_00_0:A0!=AA  ARG   A,D
0024:      5F  0_0_10_0_01_1:A0!=D5  INF   D5		; MOV	A0,D5
0025:      5E  0_0_10_0_01_0:A0!=D5  NOT   D5		; EOR	A0,D5
0026:   34 5F  0_1_10_0_01_1:A0!=D5  SWP   D3+4,D5	; MOV	A0,D3+4,D5
0028:   34 5E  0_1_10_0_01_0:A0!=D5  EOR   D3+4,D5	; EOR	A0,D3+4,D5
002A:      AC  0_0_10_0_01_0:A0!=Da  ARG   A,C
002B:      5F  0_0_10_0_00_1:A0!=C5  MOV   PSW,C5	; MOV	A0,C5
002C:      5E  0_0_10_0_00_0:A0!=C5  NOT   C5		; EOR	A0,C5
002D:   34 5F  0_1_10_0_00_1:A0!=C5  SWP   D3+4,C5	; MOV	A0,D3+4,C5
002F:   34 5E  0_1_10_0_00_0:A0!=C5  EOR   D3+4,C5	; EOR	A0,D3+4,C5
0031:      DA  0_0_10_0_00_0:A0!=CD  ARG   D,A
0032:      D1  0_0_01_0_00_0:Dx!=AD  REG   D1
0033:      0F  0_0_01_0_10_1:D1!=A0  OUF   D1		; MOV	D1,A0
0034:      0E  0_0_01_0_10_0:D1!=A0  NOT   D1,CF 	; EOR	D1,A0
0035:   34 0F  0_1_01_0_10_1:D1!=A0  MOV   D1,D3+4	; MOV	D1,D3+4,A0
0037:   34 0E  0_1_01_0_10_0:D1!=A0  EOR   D1,D3+4	; EOR	D1,D3+4,A0
0039:      CA  0_0_01_0_00_0:D1!=AC  ARG   C,A
003A:      C2  0_0_00_0_00_0:C?!=AC  REG   C2
003B:      0F  0_0_00_0_10_1:C2!=A0  MOV   C2,PSW	; MOV	C2,A0
003C:      0E  0_0_00_0_10_0:C2!=A0  NOT   C2,CF 	; EOR	C2,A0
003D:   34 0F  0_1_00_0_10_1:C2!=A0  MOV   C2,D3+4	; MOV	C2,D3+4,A0
003F:   34 0E  0_1_00_0_10_0:C2!=A0  EOR   C2,D3+4	; EOR	C2,D3+4,A0
0041:      DD  0_0_00_0_00_0:C2!=AD  ARG   D,D
0042:      1F  0_0_01_1_01_1:D1==D1  ???   D1		; MOV	D1,D1
0043:      1E  0_0_01_1_01_0:D1==D1  NEG   D1		; EOR	D1,D1
0044:      1D  0_0_01_1_01_0:D1==D1  STD   D1		; DIS	D1,D1
0045:      1C  0_0_01_1_01_0:D1==D1  CLN   D1		; CON	D1,D1
0046:      1B  0_0_01_1_01_0:D1==D1  SUB   D1		; SUB	D1,D1
0047:      1A  0_0_01_1_01_0:D1==D1  ADD   D1		; ADD	D1,D1
0048:06#34 5F  1_1_01_0_01_1:D1!=D5  ORD6  D1,D3+4,D5	; MOV	D1,D3+4,D5
004C:   34 5E  0_1_01_0_01_0:D1!=D5  EOR   D1,D3+4,D5	; EOR	D1,D3+4,D5
004E:   34 1F  0_1_01_1_01_1:D1==D1  LEA   D1,D3+4	; MOV	D1,D3+4,D1
0050:   34 1E  0_1_01_1_01_0:D1==D1  RRC   D1,D3+4,D1	; EOR	D1,D3+4,D1
0052:   34 1D  0_1_01_1_01_0:D1==D1  SAL   D1,D3+4,D1	; DIS	D1,D3+4,D1
0054:   34 1C  0_1_01_1_01_0:D1==D1  SAR   D1,D3+4,D1	; CON	D1,D3+4,D1
0056:   34 1B  0_1_01_1_01_0:D1==D1  SUB   D1,D3+4,D1	; SUB	D1,D3+4,D1
0058:   34 1A  0_1_01_1_01_0:D1==D1  MUL   D1,D3+4,D1	; ADD	D1,D3+4,D1
005A:      DB  0_0_01_0_01_0:D1!=Dd  ARG   D,B
005B:      5F  0_0_01_0_00_1:D1!=B5  OUT   D1,B5	; MOV	D1,B5
005C:      5E  0_0_01_0_00_0:D1!=B5  EOR   D1,B5	; EOR	D1,B5
005D:   34 5F  0_1_01_0_00_1:D1!=B5  LEX   D1,D3+4,B5	; MOV	D1,D3+4,B5
005F:   34 5E  0_1_01_0_00_0:D1!=B5  EOR   D1,D3+4,B5	; EOR	D1,D3+4,B5
0061:      CD  0_0_01_0_00_0:D1!=BC  ARG   C,D
0062:      5F  0_0_00_0_01_1:C2!=D5  MOV   C2,D5	; MOV	C2,D5
0063:      5E  0_0_00_0_01_0:C2!=D5  EOR   C2,D5	; EOR	C2,D5
0064:   34 5F  0_1_00_0_01_1:C2!=D5  ???   C2,D3+4,D5	; MOV	C2,D3+4,D5
0066:   34 5E  0_1_00_0_01_0:C2!=D5  EOR   C2,D3+4,D5	; EOR	C2,D3+4,D5
0068:      CC  0_0_00_0_01_0:C2!=Dc  ARG   C,C
0069:      2F  0_0_00_1_00_1:C2==C2  MOV   C2,C2	; MOV	C2,C2
006A:      2E  0_0_00_1_00_0:C2==C2  NEG   C2,C2	; EOR	C2,C2
006B:      2D  0_0_00_1_00_0:C2==C2  STD   C2,C2	; DIS	C2,C2
006C:      2C  0_0_00_1_00_0:C2==C2  CLN   C2,C2	; CON	C2,C2
006D:      2B  0_0_00_1_00_0:C2==C2  SUB   C2,C2	; SUB	C2,C2
006E:      2A  0_0_00_1_00_0:C2==C2  ADD   C2,C2	; ADD	C2,C2
006F:   34 2F  0_1_00_1_00_1:C2==C2  LEX   C2,D3+4,C2	; MOV	C2,D3+4,C2
0071:   34 2E  0_1_00_1_00_0:C2==C2  RRC   C2,D3+4,C2	; EOR	C2,D3+4,C2
0073:   34 2D  0_1_00_1_00_0:C2==C2  SAL   C2,D3+4,C2	; DIS	C2,D3+4,C2
0075:   34 2C  0_1_00_1_00_0:C2==C2  SAR   C2,D3+4,C2	; CON	C2,D3+4,C2

ТЕ ЕЩЁ МАРГИНАЛЫ
Как сказано выше, указание неверного указателя на аппаратном уровне обрабатываются в особенном виде, из-за чего программист может использовать эти резервные механизмы по своему усмотрению.
Однако, эти самые маргиналы местами просто слишком маргинальны.
Например, рассмотрим несколько странных инструкций:

код «00» - команда останова «HLT»: Переход на адрес 0000 с сохранением точки останова в D0 (регистровой паре B0:C0)
код «10 00» - команда останова «HLT [D1+0]»: Безусловный переход на адрес [D1] с сохранением точки останова в D0
код «10 10 00» - команда останова «HLT1» или «HLT#1»: Здесь присутствует маргинал - непонятная операция…
код «10 10 10 00» - команда останова «HLT 1#D1+0» или «HLT 1#[D1+0]»: Присутствует маргинальный указатель - ещё страннее…

Нетрудно заметить, что на одной только операции Останова с частной комбинацией префиксов уже довольно неясная ситуация. Даже если браться обрабатывать такие комбинации на самом высоком уровне - эмуляцией в JavaScript, не совсем понятно, что именно с этим безобразием делать…

МАРГИНАЛЬНЫЕ КАНАЛЫ
Так как «маргинальные индексы» временно помечались в ассемблере/дизассемблере с «решёткой-шарпом», то это напомнило некоторую аналогию с каналами в Бейсиках (у ZX-Spectrum также имеются).
Так, есть такой GW-Basic - оператор OPEN - вполне хороший пример.

Тем самым, вполне можно:

код «10 10 00» - команду «HLT#1» можно условно обозначать за «CLOSE#1»…
код «10 10 10 00» - команду «HLT#1 [D1]» можно условно обозначать за «OPEN#1 "/dev/…"»…

Тем самым, у процессора на программном уровне в системе команд появляются две, хоть и побочные, но весьма любопытные операции. Программист получает основные операции работы с файловой системой уже на самом низком уровне.

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

МАРГИНАЛЬНАЯ ЭМУЛЯЦИЯ КАНАЛОВ
Естественно, о поддержке «маргинального окружения» на аппаратном уровне думать не приходится в принципе!
Тем самым, следует продумать механизмы прерываний, чтобы поддерживать все эти «маргинальные каналы» на программном уровне драйверов операционной системы.
Ещё во времена DOS и IBM PC-XT существовали библиотеки эмуляции отсутствующего FPU. Здесь - примерно то же самое…

ПРИМЕР
Если мы настроили «Маргинал #1» указателем на строку, типа "/dev/ega/320x240/" как открытия непосредственной проекции EGA-графики, то код

Код: Выделить всё

10 10 80 90 80 80 90 80 80 80 80 80 80 A7

будет означать «MOV 1#[D8+320D9],A7», что буквально «*(BYTE *)(D8 + 320 * D9) = A7», где D8 - координата X и D9 - координата Y.
Получается одна длинная операция пиксельной записи в графическую плоскость.

P.S: Как можно подметить, термин «маргинал» в рамках текущих разработок используется как устоявшийся.
Вполне возможно, что вместо привычных «эскейпов» его вполне можно использовать…

Форум РадиоКот

Койяанискаци - Процессор Радиолюбителя

Койяанискаци - Процессор Радиолюбителя

Койяанискаци - Процессор Радиолюбителя

Маргинальное кодирование