Поиграем?

Однакo, придумать адекватное мнемоническое идентифицирование инструкциям не менее сложнее, чем заставить всё это крутиться и работать…
Использовать заимствованные идентификаторы сторонних архитектур и пытаться их эстетически приспособить в таблицу команд не всегда получается. Приходится подбирать из английского словаря близкие по смыслу к логике действия операции обозначения.

Код (DOS):

1. Байт-код|Мнемоника|Аббривиатура
2. --------+---------+------------
3.    B0 $$|BIO  $+$$|Branch If parity if Odd (PF=1)
4.    B1 $$|BIP  $+$$|Branch If Parity is even(PF=0)
5.    .. ..|...  ....|..............................
6.    B6 FF|CIE      |Call from heap of stack (ZF=1)
7.    B7 $$|COF  $+$$|Call Of Fictional code  (ZF=0)
8.    B8 $$|JMP  $+$$|..............................
9.    B9 $$|CALL $+$$|..............................
10.    BA $$|BIA  $+$$|Branch If Among         (SF=1)
11.    BB $$|BIB  $+$$|Branch If Bigger        (SF=0)
12.    BC $$|BIC  $+$$|Branch If Carry         (CF=1)
13.    BD $$|BID  $+$$|Branch If Discarded     (CF=0)
14.    BE $$|BIE  $+$$|Branch If Equality      (ZF=1)
15.    BE FE|DOE      |DO if Equality (Skip if ZF!=1)
16.    BF $$|BIF  $+$$|Branch If Fictional     (ZF=0)
17.    BF FF|RIF      |Return If Fictional     (ZF=0)
18.    .. ..|...  ....|..............................
19. RR EB   |EACH [RR]|Each By Register
20. RR EC   |EACH  RR |Each by Counting Register
21. NN ED   |EACH  NN |Each by Data number
22.    .. ..|...  ....|..............................
23. RR FB   |FAKE [RR]|Fake By Register
24. RR FC   |FAIR  RR |Fetch by Counting Register
25. NN FD   |FAKE  NN |Fake by Data number

Если это кому-то покажется смешным - поддерживаю… Так как подбирал с некоторым трудом.
Мнемоника и байт-код получается соответствующий.

• EB: Each(Buffered) - раньше была традиционная Loop, но не вписывалась в аббревиатуру EB
• FC: Fair(Counter) - думаю ею подменить традиционный Wait
• FD: Fake(Data) - вместо традиционной Skip можно мнемонически объявлять инструкции фейковыми

За прошлые дни сильно провозился с ассемблером и дизассемблером. Так как эмуляция хоть и работает, но байт-код крайне неверно интерпретировался в отладчике.
Как я уже говорил, система команд - Ребусная (Rebused-ISC), что делает её местами очень запутанной не только в ассемблере, но и перевариванием собственным серым веществом…
Почему FB/FC/FD стало Fake/Fair/Fake (раньше было три Фейка)? Просто считать фейковыми и пропускать все 255 инструкций я считаю бесполезной операцией.
Есть некоторые крайне редкостные комбинации операций, которые нужно как-то иначе воспринимать и интерпретировать в совокупности. Например:

• Each+Each - двойной префикс цикла. Нет смысла в цикле начинать другой цикл
• Each+Fair - бессмысленно в цикле задавать интервал ожидающего цикла
• Each+Fake - не ясно, зачем в цикле нужно объявлять группу фейковых инструкций
• Fair+Each - циклом ожидания пытаться начать другой цикл не имеет смысла
• Fair+Fair - двойной префикс ожидающего цикла. Не понятно, что этим можно пытаться добиться
• Fair+Fake - в ожидающем цикле объявлять группу инструкций фейковыми

Либо у меня фантазия очень узкая, либо я - консервативная фантазирующая личность. Потому что:

• MOV R - инструкция с одним операндом. В x86 имеется инструкция Enter. Не стал я привлекать новое слово мнемоники для ввода аргумента вызова
• MOV N - инструкция с числовым операндом. Не скажу, что это нечто типа Leave в x86. Но я обошёлся одной цифрой для доступа к аргументу вызова
• CALL - инструкция без адреса/метки. Псевдоним XCHG IP,[SP] - обмен с верхушкой стека указателем на инструкцию
• CIA/CIB/CIC/CID/CIE/CIF - без метки. Вызов подпрограммы с верхушки стека по условию

Если будут идеи на счёт красивых мнемоник - предлагайте. Пока что насчитывается порядка 40 мнемонических слов. Считаю, чем меньше - тем лучше.
А теперь…

Обработка доступа к портам ввода-вывода системой
Несколько строчек с примером:

Код (DOS):

1. 1100    A4 FD|MOV  AL,0xFD;Указываем читаемый порт
2. 1102    A5 67|MOV  CL,0x67;Выставляем интервал ожидания
3. 1104 55 FC   |FAIR CL     ;Ожидающий цикл со счётчиком CL
4. 1106 44 44   |IN   AL     ;Прервёт задачу с обращением к ядру
5. ; Здесь 44 - MOV AL,AL работающий как префикс для AL
6. ; Так как 44+44 - MOV AL,AL под префиксом AL в ожидании, работает как портовая
7. ; Кстати, эта IN AL прерывает приложение и управление возвращается ядру с кодом:
8. FF00    E8 ??|JMP  .overhead; Запрос к стандартному API
9. FF02    E8 ??|JMP  .acclaim ; Обращение к программным прерываниям INT 0-79
10. FF04    E8 ??|JMP  .buffer  ; Буферная зона - прослойка диспетчера памяти
11. FF06    E8 ??|JMP  .context ; Диспетчер переключения контекста процессов
12. FF08    E8 04|JMP  .device  ; Запрос ко внешнему устройству ввода/вывода
13. FF0E ........|.device:      ; Метка обработчика запросов к устройствам
14. FF0E    BC ??|BIC  ..write  ; Установленный флаг CF - признак записи в порт
15. FF10 44 FA   |POP  AL       ; Доступ к стеку истории регистра AL
16. FF12    42   |MOV  CH,AL    ; Запоминаем ячейку контекста со счётчиком
17. FF13 44 FA   |POP  AL       ; Пропускаем байт
18. FF15 44 FA   |POP  AL       ; Доходим до истории с индексом порта
19. FF17    43   |MOV  DH,AL    ; Запомним адрес ячейки контекста с приёмником
20. FF18    37   |MOV  DL,DH    ; Необходимость особенности архитектуры
21. FF19    B8 FE|WAIT          ; Разовое ожидание
22. FF1B 77 70   |MOV  DL,[DL]  ; Читаем индекс порта с контекста приложения
23. FF1D    62   |MOV  CL,CH    ; Необходимость особенности архитектуры
24. FF1E    B8 FE|WAIT          ; Разовое ожидание
25. FF20 66 60   |MOV  CL,[CL]  ; Читаем индекс выдержки ожидания готовности порта
26. FF22 66 FC   |FAIR CL       ; Ожидание с декрементом
27. FF24 44 77   |IN   DL       ; Чтение данных с физического порта
28. FF26    48   |SBB  AL,AL    ; Если порт готов и данные прочитаны, CF будет в "1"
29. FF27    AC 02|AND  AL,0x02  ; Маскируем бит флажка CF для приложения
30. FF29    A1 A8|MOV  BH,0xA8  ; Ячейка контекста приложения с флажками
31. FF2B    15   |MOV  BL,BH    ; Необходимость особенности архитектуры
32. FF2C    B8 FE|WAIT          ; Разовое ожидание
33. FF2E 55 50   |MOV  BL,[BL]  ; Читаем биты флажков
34. FF30    5D   |OR   AL,BL    ; Выставляем бит CF приложения по готовности
35. FF31    B8 FE|WAIT          ; Необходимость особенности архитектуры
36. FF33 11 40   |MOV  [BH],AL  ; Записываем в контекст приложения признак CF
37. FF35    B8 FE|WAIT          ; Необходимость особенности архитектуры
38. FF37 22 60   |MOV  [CH],CL  ; Значение счётчика передадим в контекст приложения
39. FF39    B8 FE|WAIT          ; Необходимость особенности архитектуры
40. FF3B 33 70   |MOV  [DH],DL  ; Считанный байт запишем в контекст приложения
41. FF3D    B8 FE|WAIT          ; Необходимость особенности архитектуры
42. FF3F    04   |MOV  AL,[0]   ; Читаем индекс контекста прерванной задачи
43. FF40    AC 7F|AND  AL,0x7F  ; Сбрасываем бит системного контекста ядра
44. FF42    44 00|HLT  AL       ; Указываем регистр ключевым
45. FF44    B8 FE|WAIT          ; Необходимость особенности архитектуры
46. FF46    00   |MOV  [0],AL   ; Так как AL был ключевым, HLT переключит контекст
47. ; Здесь работа системного кода прерывается
48. ; Управление получает прерванная прикладная задача
49. 1108    BD F6|BID  0x1100   ; Если флаг переноса сброшен, порт не прочитан

P.S.: На практике указанный код работает на 90%…
Почему не 100%? На примере эмуляции github код работает на 95%, так как там имеется проблема с флажком CF (приложение всегда получает сигнал готовности клавиатуры, например) и когда буфер клавиатуры пуст, приложение всё равно его читает…
А текущая разрабатываемая версия эмулятор и флаг не передаёт как надо, и сам байт с порта попадает куды не надо…
(сложная проблема самого ядра эмулятора, где не могу справиться с синхронизацией переключения исполняемых потоков - от системного к прикладному)

 

Нa этих выходных решил попробовать написать эмулятор с нуля, руководствуясь накопленным опытом.
Основной задачей было поставленно написать некий универсальный движок, с помощью которого можно описать нужный процессор простым шаблоном, который развернётся в работающую модель с комплектом 3 в 1: Эмулятор, Дизассемблер, Ассемблер. При этом, не нужно было бы сурово переделывать сам js-текст.
В итоге, уложился в трое суток бессонных ночей отладки.
Получился компактный - 1500 строк и 60кб.

P.S.: Если браузерная совместимость не подведёт, эмулятор запустится сразу под рандомным мусором в его ОЗУ…
Необходимо нажать кнопку Reset, а затем - Start.
Клавиши тоже должны работать: F1-Шаг отладки, F4-Полный ход, F9-Брейк-пойнт.
Также, F7-Выбор настраиваемого параметра(FPS, IPC, IPS), F6/F8-Декремент/Инкремент параметра.
Пожалуйста, отпишитесь, у кого - какой результат.
Кстати, шаблон можно редактировать прямо в процессе (кнопка Matrix) и изменить всю систему команд на ходу (двойной клик по той же Matrix)…
(по идее, можно описать 6502. Для Z80 пока ещё не хватает поддержки префиксов, что довольно поправимо)

 

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

 

Дa в том то и дело, что готовые проекты - это switch и 256 штук case. Выше говорил, что пытался переделать тот эмулятор и переписывался с автором. Но, отлаживать - чудовищно было!
В принципе, этот мой эмулятор работает же. Осталось клавиатуру подцепить и можно в Бейсике тригонометрией баловаться

 

Paguo_86PK, а как тебе dosemu, dosbox, qemu?

 

Смешная история, так как сидя за Pentium-I 90mHz/48mb-RAM ещё я пытался установить vmWare, но та вылетала с ошибкой отсутствия в процессоре поддержки каких-то критически важных команд для эмуляции. Пользовался, в частности, Bochs. И он мне тогда вполне подходил (ставил под ним Windows'XP 18 часов).
А будучи уже с Pentium-IV (сидел на Pentium-I до 2009 года) я вспомнил и поставил vmWare и ей пользуюсь по сей день.

 

Paguo_86PK, со слабым компом у тебя имеется обходной вариант: можно подключаться к облачным проектам (инет, кстати, у тебя какой?) ==>> среда разработки/прогонки на облаках. покажешь себя там и вольёшься в Сообщество, а дальше ужо проблем с жестянками испытывать не будешь.. сейчас дикий недобор спецов чуть ли не по всем областям..

 

Прo что вы?
Четыре года назад P-IV полетел (южный мост) из-за неполадок БП (на видяхе кондёр разорвало), так как БП не включался и с 15 раза бывало последний год…
Пришлось пойти и купить GA-F2A85X-UP4 и временно попрощаться с этим…

Интернет у меня порядка 256кбод (ночью - до 2048). Хотел как-то BitCoin'ить и зарабатывать. Но, там много всяческих фокусов…

 

с биткоин, пожалуй, проблем токЪ больше будет лучше в проектах на ОК (открытых кодах) поучаствуй.

 

Мегапроцессoр недавно вот увидел - жесть!

Спойлер

В подобном проекте бы поучавствовал, не живя вот в вакууме, где ни монтажных плат, ни рассыпухи, ни паяльника…
Недавно вот случай был. Человек разрабатывает игру и ему потребовалось сгенерировать лабиринт так, чтобы маршрут по нему нёс некую осмысленную информацию. У меня как раз "завалялась" та старенькая идея с пентаминным письмом и я её предложил. Правда, там "баги" концепции, так как требуется координация лингвиста-полиглота… Но сам принцип - практический годный. (декодер читает лабиринты "жуком". с аналогом QR-читалке по изображению - пока не справляюсь)
И вот к чему я. Если где-то кому-то потребуется (вдруг) микромощный процессор с адекватной системой команд - может мои труды и пригодятся…
P.S.: Некоторые саунд бластеры мастерят…

 

Еще как мастерят

http://www.phantom.sannata.ru/forum/index.php?t=14626&a=stdforum_view&o=&st=0

youtube.com/watch?v=GZw1g0FCslA

 

Свoй x80 попытался облачно набросать…
Вроде и работает, исполняя несколько инструкций, но листинг путаный и если не заниматься им годик, очень сложно въехать.

Другое дело - LogiSim: В режиме реального времени всё видно. А так как электронщиком я стал раньше, чем изучил Бейсик РАДИО-86РК, то и схемки разрабатывал ещё в тетрадях в клеточку.
Вот набросок узла чтения x80-инструкций, включая 8 префиксов и 32 постфикса.
К моему удивлению, получилось всё компактно и просто.

Спойлер

До этого испытал себя на RISC.

Спойлер

Система команд крайне проста и элементарна:
Коды 0x01…0x99 (исключая хексы) заносят десятичную величину в выбранный регистр.
Коды 0xA1…0xA9, 0xB1…0xB9, 0xC1…0xC9 выбирают активные регистры A, B, C.
Коды 0xAA, 0xAB, 0xAC, 0xBA, 0xBB, 0xBC, 0xCA, 0xCB, 0xCC выбирают регистры операнды.
Например, «A3 B5 AB 0A» означает «ADD A3,B5», так как 0xA3 выбирает регистр A3, 0xB5 выбирает регистр B5, 0xAB выставляет порядок операндов «A,B», 0x0A означает ADD…
Все инструкции выполняются в 2 такта. А при чтение/записи памяти - 4 такта. Условное выполнение - 3 такта.

Однако CISC мне более привлекательны…

 

Кстaти, если кому-нибудь интересно, ниже архив с RISC-проектом для LogiSim.
Как я писал выше, процессор максимально прост и интуитивен для набивания кода голым дампом.

Код (Text):

1. 00    - HALT
2. 01…99 - 1…99
3. 0A    - ADC
4. 0B    - SBB
5. 0C    - AND (Conjunction)
6. 0D    - OR (Disjunction)
7. 0E    - EOR
8. 0F    - CMP (Flags set)
9. A1…A9 - A1…A9
10. AA…AC - A,A | A,B | A,C
11. AD    - ADDRESS
12. B1…B9 - B1…B9
13. BA…BC - B,A | B,B | B,C
14. BE    - BE (Buffer Extract) / MOV R,[ADDRESS]
15. BF    - BF (Buffer Fill) / MOV [ADDRESS],R
16. C1…C9 - C1…C9
17. CA…CC - C,A | C,B | C,C
18. CF    - CF / CMC / Complement CF
19. D0    - DO / MOV ADDRESS,IP
20. DA    - DA (Do if Amount) / JS
21. DB    - DB (Do if Bigger) / JNS
22. DC    - DC (Do if Carry) / JC
23. DD    - DD (Do if Discarry) / JNC
24. DE    - DE (Do if Equal) / JE
25. DF    - DF (Do if False) / JNE
26. EB    - EB (Execute Buffer / End Block) / JMP ADDRESS

Где шестнадцатеричный код и является мнемоникой.
Так, 0xD0 выглядит как «DO» и открывает блок инструкций. А закрывается он кодом 0xEB команды «EB» - «End Block»…
И код «D0 A1 B2 C3 AB 0A AC 0F DA EB» буквально можно записать
как «DO { ADD A1,B2; CMP A1,C3; } DA EB»
или «do { A1 += B2 } while (A1 < C3)».

У процессора должны были быть команды D1…D9 для определения 9 блок-меток и команды E1…E9 для исполнения этих блок-меток.
Но лень было заниматься их реализацией.

Нужно ещё сказать, что ADDR является 16-битным регистром и доступен свободно на запись командой AD.
Например, «A7 B7 AB AD» означает «ADDR = A7 | (B7 << 8)».
Читать его свободно нельзя и напрямую он доступен лишь при ветвлениях, сбрасывающих регистры до B0 и C0.
Где B0 = HI(ADDR), C0 = LO(ADDR).
Тем самым, при входе в подпрограмму, до первых команд B1…B9 и C1…C9 имеется возможность прочитать точку возврата и поместить её в стек, который нужно реализовывать программно.

Для запуска симуляции активируйте сигнал готовности памяти - Ready, и включите режим автоматического исполнения сигналом Run.
Загрузите в ОЗУ сам код программы и разрешите в меню такты.
Программа напишет «Hello, world!».
Есть вариант и с вводом с клавиатуры, но здесь я его не даю…

P.S.: В общем, процессор получился интуитивно понятным дампом и готовился под ядро x80.
Правда, команда RET описывается в 15 инструкций и требует до 30 тактов. И та - разовая: Её нельзя применять во вложенных подпрограммах.
Требуется заносить в буфер стека, а это ещё десятки команд и тактов под сотню! Что никуда не годится.

 

Вoт и прошло пол года…
На днях решил вернуться к теме и продолжить разработку схемы.
Вот, что получилось:

Выборка кодов из ОЗУ теперь происходит по правилам - с READ-стробированием и с ожиданием готовности шины по READY.
Справа - три регистра выборки команды:
IB (Instruction Buffer) - буфер инструкции. Точнее, её префикс или постфикс. Несмотря на то, что используется всего 10 логических элементов, но все они способны полноценно считывать x80-команды. Мною не мало сил было направлено на максимальное упрощение данного узла.
IC и ID - Instruction Code и Immediate Data соответственно для хранения кода команды и константного операнда.
Светодиод M1 указывает на опустошение этих трёх регистров и ожидание чтения очередной команды.
Весь этот набор IB IC ID концентрируется в одну шину и идёт на ПЗУ в левом нижнем углу на 65535 32-битных слов, хранящее микрокод.
Тем самым, всего возможно до 4096 команд и до 16 микрокоманд в каждой.
Но, так как получается 9 префиксов (7 стандартных, 1 системный и 1 дефолтный) плюс два постфикса ($ и $+1), всего получается 11 префиксов - до 2816 команд и 45056 микрокоманд.

А теперь, о постфиксах.
Если в x86 допустимы замыкания на себя типа «JC $» с бесконечным зацикливанием, то у меня схематически это обрабатывается за постфикс…
Тем самым, «JC $» и «JC $+1» работают как две отличные от «JC» команды, где «JC $» - «CLC», «JNC $» - «STC», «JZ $» - «REPZ» и т.д…
Из анимации видно, что при холостой (пока) обработке микрокода шина адреса уходит в ноль, хотя можно было бы продолжать считывания очередной команды в конвейер. Из-за чего на 8 команд уходит около 86 тактов - примерно 11 тактов на команду. Но я принципиально не буду (пока) здесь разрабатывать конвейер, так как не желаю соревноваться с индустрией RISC и PIC.

Вверху схемы виден модуль контекста CTX, хранящий регистровый файл. Очень долго я им занимался и под LogiSim он слишком объёмен для нормальной работы. Вместо 256 регистров там используется всего пара десятков регистров, так как четырёх портовую схему было сложно набросать и отладить целиком.
Но по обозначению и так всё ясно:
PTR - указатель IP/SP/BP/SI/DI/BX/CX/DX для выдачи адреса на шину.
SRC - второй операнд-источник команды, выдаваемый как BYTE.
DST - основной операнд команды, выдаваемый как DATA или записываемый как R(esult).
А вот через Page считывается Mode. Так как память разбивается на сегменты по 4Кб, сам файл контекста хранит все данные по управлению памятью.
Если Вы подзабыли, x80 - многозадачный процессор, в котором должно быть 128 регистровых файлов для аппаратной поддержки до 128 независимых процессов.
Тем самым, Page-Mode информация служит для изоляции и защиты памяти на встроенном аппаратном уровне. Но об этом не буду здесь разворачиваться. Так как Page-Mode - не просто 16 страниц, а 16 * ИндексПроцесса страниц. То есть, до 2048 страниц по 4кб - 8Мб памяти в усечённой версии.

 

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

 

Добaвил АЛУ (как попало, лишь бы работало), регистр флажков и мультиплексор условий. Теперь и команды условного ветвления работают. Правда, не в автоматическом режиме: Флажки меняю вручную и тестирую.
(Сначала команда 000C BC FC не срабатывает, а работает 000E B8 F6 и прыгает на адрес 0006. А после занесения 1 в флаг CF команда 000C BC FC срабатывает и прыгает на адрес 000A.)

В общем, процессор готов. Остаётся лишь набить микрокод каждой операции, добавить цепи сохранения флажков АЛУ и т.д.
Сегодня набил 41 операцию mov r,r1. Операций mov r,m/m,r нету, так как нет цепей обмена данными с памятью.

В целом же, схема - мусор. Хотел я x80 сделать чистым CISC, а получился RISC читающий CISC-команды.
Единственное ценное и годное во всей схеме - модуль логики с регистрами IB/IC/ID.
Остальное - лишь набросок для отладки работы с блоком CTX - контекстным регистровым файлом. Оказывается, я три дня с ним неверно работал, постоянно тактируя: Тот хаотически заполнял разные ячейки. Теперь я понял, где тактирование нужно прерывать.

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

А как же GameBoy? Мною x80 задумывался не с чистого листа. По сути, x80 - тот же i8080/z80, но система команд причёсана гребешком. Можно сказать, x80 - это 580ИК80, но с контекстом под выполнение 128 независимых процессов и с механизмами памяти/защиты/исключений. Ассемблером x80 почти полностью подобен x86.
То есть, если ИРИША графически совместим с IBM-PC/XT с CGA-графикой, но с процессором 580ИК80, то получался как недо-XT. То своим x80 я пытаюсь сделать промежуточную пародию на процессор, ассемблерно совместимым с x86, логикой команд - с i8080/z80, но с уникальным собственным байт-кодом.
То есть, недо-z80 и недо-x86.

Так что, теоретически, его можно воткнуть и в PC-XT, и в ZX-Spectrum. Нигде никакие готовые программы не запустятся, но по шинам будет z80 и по памяти получится почти i80286.
Я просто работаю над мечтой школьного детства - сделать идеальный КР580ВМ80А.

 

А ну тогда понятно. Если ловишь кайф то почему бы не заняться.

Раз тут затрагиваются темы эмуляторов процессоров то задам такой вопрос.
Насколько сложно сейчас сделать полноценный "открытый" эмулятор операционки windows?
Открытый в том смыcле что это не как vmware а такой который позволял бы ставить брейкпоинты на вызовы тех или иных вызовов winapi, позволял бы просматривать состояние проца.
Я так думаю для этого надо скрестить wine и бош например. wine транслирует winapi в позикс а бош эмулятор x86.
Правильно мыслю?

 

Всегдa задавался вопросом, почему ни в каких процессорах нету команды для дизассемблинга кода и думал, что это сложно. Однако, как показывает сегодняшний опыт, даже как попало можно из тройки мелких ПЗУ сделать пародию на дизассемблер.

Кaк эксперимент, решил набросать «аппаратный x80-дизассемблер»…
По сути, это тот же RISC-процессор, но вместо микрокоманд в нём используется поток ASCII-символов прямо на терминал.

Получилось (внизу) три крошечные ПЗУ внизу:
Первая (512 байтов) хранит саму мнемонику и ссылки на токены.
Вторая (справа, 256 байт) хранит указатели на токены и индексы от шины (выборка строк, столбцов и префикса).
Третья (внизу на 512 байтов) хранит имена регистров, регистровых пар и АЛУ-операции.

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

Даже своим x80-эмулятором на JavaScript я «плясал с бубном», так как тяжело было обрабатывать байт-код x80 на языке высокого уровня. В частности, «jmp замыкания» на себя приходилось перехватывать уже в самой команде. Теперь я вижу, как нужно было организовывать эмулятор…
А если в JavaScript я напортачил, что говорить про Verilog!
Теперь я вижу, как надо делать. По крайней мере, нащупал вариант компактнее и производительнее.

P.S.: Как программист я избалован тем, что программы можно бить неограниченной сложности.
В Verilog похожая ситуация, так как не смотря на ограничения, в нём можно описать модуль космической сложности.
А вот LogiSim связывает меня по рукам из-за многих ограничений и мозги начинают действительно варить на качественно ином уровне, так как изнуряет графическое редактирование и начинаешь реально думать очень чётко…
А смотреть, как всё это мигает, переключается и, главное, работает - реальный кайф!

 

Тепeрь схему можно скачать.
Она поддерживает до 15 команд, так как старался уместить всё на экране без скроллинга.

Демонстрация работы:

Справа - дешифратор команд на логических элементах, которые сигнализируют шифратору приоритетов, какая инструкция сейчас активна.
Внизу - светодиоды с обозначениями мнемоник, указывающие на активность любой из инструкций.
Левее - три ПЗУ с мнемониками инструкций и именами операндов. Всё, что будет передаваться на экран терминала.

Короче говоря, я набросал сложнейшую из всех моих схем, которая является усечённым аппаратным дизассемблером системы команд «x80»…
Тем самым, если раннее я написал JavaScript эмулятор и это не было серьёзным достижением. То этими схемами я прощупываю себе путь к аппаратной реализации процессора мечты своего детства!
Так как я не доволен уровнем владения Verilog, где я действую как программист и во многих местах меня разносит на слишком сложные конструкции.
В LogiSim мозги работает иначе и я более внимательнее и аккуратнее расходую комбинаторику.
И под Verilog я узлы и цепи испытываю визуально в LogiSim, так как мне так удобнее…

И CISC проектировать, когда кругом примеры разных RISC - достаточно сложно.
На схеме иногда горят два светодиода «MOV R,R1» и «HLT», что фильтруется шифратором.
Главное, правильно расставить инструкции про приоритетам…

Как я выше уже сказал, достаточно перепрошить три ПЗУ микрокодом и заменить экран терминала на регистровый файл, чтобы с добавлением АЛУ и логики условий достичь реального вычислительного процесса…
Надеюсь, я хоть немножечко уже понимаю, что делаю…

P.S.: Одной только JavaScript-эмуляцией я не удовлетворён, так как программно можно легко поднять любую лабуду…
Хочется подключить когда-нибудь реальное FPGA-железо прямо к монитору, под управлением именно моего x80, а не NIOS.

 

Доработaл схему и нарастил дешифратор команд до 21.

Дальше - сложнее.
Во-первых, удобнее было бы схему разбить на модули. Но тогда пострадает визуальный охват всей схемы целиком.
Во-вторых, остальные инструкции более сложны для декодирования в рамках данной схемы: Требуется компаратор (перед регистром IA) заменить на ПЗУ.
В-третьих, с комбинаторикой здесь более-менее я разобрался. А вот с последовательной логикой у меня проблемы.

Здесь в строчках 42-98 наблюдается жуткий бардак в узле обмена с памятью. Если в Icarus Verilog я не смог построить нормально этот узел, то позже, скачав LogiSim, надеялся без установки громоздкой OrCAD проработать этот узел в графической схеме…
(Надо сказать, что цель - не разработать в LogiSim сложную схему, а проработать спорные и мутные узлы, чтобы понять, как корректнее описать их в Verilog.)
Но и в схеме наблюдается жуть с RS-триггерами и вентилями (управление чтением/записью ОЗУ слева), так как расключаю их на ощупь, методом тыка.

P.S.: Смотреть на работающую схему - довольно приятно…