nedoPC.org

О - круто, спасибо!

P.S. Спрятал простыню под спойлер

да, зобыл нописать.
вход: HL -- адрес начала блока
DE -- адрес конец блока
вызов по метке disassm
ну это по коду вроде понятно, вобщем, как параметры в Мониторе по регистрам раскладываются, так и тут.

Да, хитро' написано

Можно попробовать 135 байт сэкономить, храня слова по 5 бит на букву - это 4 символа в 20 битах (т.е. не кратно байту) вместо теперешних 32. А можно ещё и статистически подойти к вопросу поглядев на распределение вероятностей:
Как можно видеть реально используются только 22 латинские буквы вместо 26 (плюс пробел) - если тупо математически, то это 22^4=234256, что умещается в 18 битах - уже экономия 157 байт (хотя тот факт, что оно не кратно байту добавит лишнего кода), а если ещё и отсортировать по частоте:
то можно типа какого-то микрохаффмана организовать пользуясь этой информацией:
что даст:
однако из-за того, что нам надо одинаковое смещение между словами, то придётся брать максимум из получившегося, а это 22 бита - округляем до 24, что есть 3 байта на слово или 270 байт на весь словарь, что даёт выгоду только в 90 байт по сравнению с первоначальным вариантом. Можно комбинированный вариант сделать - быстро получаем доступ к коротким словам и чуть более долгий для длинных - скажем 20 бит и меньше храним вместе и 21-22 - храним отдельно. Выходит, что отдельно идут только:
и этот вариант всё равно получается хуже, чем первый, значит нафиг микрохаффмана - проще всего пойти по 5-битному пути на букву (первый вариант). Однако если наплевать на быстродействие и просто расположить все мнемоники битовой цепочкой, то с использованием микрохаффмана они займут всего 179 байт т.е. экономя 181 байт - почти в 2 раза меньше! Однако ещё надо прикинуть сколько будет весить код, раскодирующий эти мнемоники деревом...

P.S. Можно двух и трёх-буквенные мнемоники сделать "быстрыми", а четырёхбуквенные (18 штук) - медленными:
в таком случае таблица быстрых мнемоник будет храниться в 3*5=15 битах на слово и 16-й бит будет означать, что нужно откуда-то вычитать четвёртую букву, т.е. это будет 90*2=180 байт плюс логика "дописывания" четвёртой буквы (надо прикинуть сколько байт она может занять и стоит ли оно вообще того). Четвёртых букв у нас только 9:

и ещё у 8085-х инструкций надо пометочку поставить, что они не родные...

P.P.S. Сложноватая логика потребуется, чтобы четвёртую букву программно дописывать:
я там звёздочки поставил у четырёхбуквенных инструкций от 8085, а вот остальные:

Обработал исходник напильником (выкинув макрос), чтобы собиралось с помощью vinxru-шного pdp11asm (2017) - сейчас убедюсь, что работает и выложу... вроде работает


Вот эту функцию ещё упростил, а то pdp11asm не понимает high/low - было:
стало:

подумалось.
если в таблице disassm_table_8085 вместо индекса мнемоники всунуть саму мнемонику, то можно сократить розмер примерно на 80 байт
update
тьфу ты
не можно сократить. исчо не проснулсо

саму мнемонику всмысле слово? по идее мой бредовый вариант туда можно попробовать воткнуть где в 2 байта уталкивается 3 буквы и битик говорящий, что есть четвёртая буква (которая добивается программно)

P.S. pdp11asm вот так умеет:

тут я слово MOV утолкал в 2 байта и +32768 ещё надо сделать для четырёхбуквенных слов

high/low можно заменить на это:


или аналогичные операторы, которые есть в асме

не - pdp11asm так не умеет
/256 умеет, а >>8 или &255 - нет
надо чтоли будет добавить это в мой форк, который pdp11asm85...

P.S. Добавил 9 февраля 2024 года

добавление одно байта на строчку в таблицу disassm_table_8085 вздует эту таблицу на 256 байт, в то время как все мнемоники занимают 360 байт

ну т.е. есть экономия? 360-256=104

это без учёта кода, который будет всё это обрабатывать.. как бы он не вышел больше

да, тяжеловатый код получается

тогда можно оставить табличку мнемоник отдельно, но сохранять одну букву в 5 бит тогда 4 буквы займут 20 бит - с округлением до 24 бит это будет 3 байта - выгода в 90 байт плюс есть 4 бита на каждое слово куда можно дополнительные флаги положить (типа метка инструкции для 8085 и что-то для Human Readable объяснялок)

P.S. человеческие объяснялки, которые хотелось бы добавить как комментарий:
1) MVI r,n ; r = n ; char
2) MOV r1,r2 ; r1 = r2
3) LXI rr,w ; rr = w
4) STA w ; [w] = A
5) LDA w ; A = [w]
6) STAX rr ; [rr] = A
7) LDAX rr ; A = [rr]
8) SHLD w ; [w] = L ; [w+1] = H
9) LHLD w ; L = [w] ; H = [w+1]
10) SPHL ; SP = HL
11) XCHG ; DE <-> HL
12) XTHL ; HL <-> [SP]
13) PCHL ; PC = HL
14) INR r ; r = r + 1
15) DCR r ; r = r - 1
16) INX rr ; rr = rr + 1
17) DCX rr ; rr = rr - 1
18) CMC ; INVERT FC
19) STC ; SET FC
20) CMA ; A = ~A
21) ADD r ; A = A + r
22) ADI n ; A = A + n ; char
23) ADC r ; A = A + r + FC
24) ACI n ; A = A + n + FC ; char
25) SUB r ; A = A - r
26) SUI n ; A = A - n ; char
27) SBB r ; A = A - r - FC
28) SBI n ; A = A - n - FC ; char
29) ANA r ; A = A AND r
30) ANI n ; A = A AND binary
31) ORA r ; A = A OR r
32) ORI n ; A = A OR binary
33) XRA r ; A = A XOR r
34) XRI n ; A = A XOR binary
35) CPI n ; A == n ; char
36) CMP r ; A == r
37) RLC ; A LEFT CIRC
38) RAL ; A LEFT FC
39) RRC ; A RIGHT CIRC
40) RAR ; A RIGHT FC
41) RST n ; CALL n*8
42) xxxx ; 8085
43) нет объяснялки
чото много получается...

P.P.S. Возможно надо исключить те инструкции, которые единичные (типа CMC или RLC) - по ним тип объяснялки будет "смотри по коду" - тогда укладываемся в 5 бит:

0) нет объяснялки (в этом случае даже ; не печатается)
1) "смотри по коду" (см. список таких инструкций ниже по тексту)
2) xxxx ; 8085 (специфичная для 8085 проца инструкция НЕ объясняется, а просто обозначается как чужеродная)
3) MOV r1,r2 ; r1 = r2
4) LXI rr,w ; rr = w
5) STA w ; [w] = A
6) LDA w ; A = [w]
7) STAX rr ; [rr] = A
8) LDAX rr ; A = [rr]
9) SHLD w ; [w] = L ; [w+1] = H
10) LHLD w ; L = [w] ; H = [w+1]
11) INR r ; r = r + 1
12) DCR r ; r = r - 1
13) INX rr ; rr = rr + 1
14) DCX rr ; rr = rr - 1
15) CMP r ; A == r
16) CPI n ; A == n ; char
17) MVI r,n ; r = n ; char
18) ADD r ; A = A + r
19) ADI n ; A = A + n ; char
20) ADC r ; A = A + r + FC
21) ACI n ; A = A + n + FC ; char
22) SUB r ; A = A - r
23) SUI n ; A = A - n ; char
24) SBB r ; A = A - r - FC
25) SBI n ; A = A - n - FC ; char
26) ANA r ; A = A AND r
27) ANI n ; A = A AND binary
28) ORA r ; A = A OR r
29) ORI n ; A = A OR binary
30) XRA r ; A = A XOR r
31) XRI n ; A = A XOR binary

(как можно видеть в первой половине таблицы есть только варианты со словами, регистрами и регистровыми парами, а во второй - с регистрами, с байтами выводимыми как символы либо выводимыми в бинарном виде)

Варианты для "смотри по коду" только статические:
- SPHL ; SP = HL
- XCHG ; DE <-> HL
- XTHL ; HL <-> [SP]
- PCHL ; PC = HL
- CMC ; INVERT FC
- STC ; SET FC
- CMA ; A = ~A
- RLC ; A LEFT CIRC
- RAL ; A LEFT FC
- RRC ; A RIGHT CIRC
- RAR ; A RIGHT FC
- RST 0 ; CALL #0000
- RST 1 ; CALL #0008
- RST 2 ; CALL #0010
- RST 3 ; CALL #0018
- RST 4 ; CALL #0020
- RST 5 ; CALL #0028
- RST 6 ; CALL #0030
- RST 7 ; CALL #0038

Заменить одну жирную таблицу 512 байт на две 256+89 (т.е. вынести атрибуты команды в отдельную таблицу). Экономия примерно 160 байт.

Усложнится код. Достаточно использовать для конца строки старший бит последнего символа (вместо пробела), уже 89 байт сэкономим.

Условия NZ,Z,NC,... тоже можно как параметр команды сделать, уменьшится количество опкодов на 21. С учётом всех таблиц примерно 180 байт. Кода добавится немного.