nedoPC.org

Electronics hobbyists community established in 2002
Atom Feed | View unanswered posts | View active topics It is currently 28 Mar 2024 08:06



Reply to topic  [ 165 posts ]  Go to page 1, 2, 3, 4, 5 ... 11  Next
Дизассемблер Yozh 
Author Message
Admin
User avatar

Joined: 08 Jan 2003 23:22
Posts: 22409
Location: Silicon Valley
Reply with quote
Я планирую сделать простой и компактный дизассемблер для встраивания в расширенный монитор РК-совместимых компьютеров и т.к. у меня он будет повешан на букву Y, я решил назвать его Yozh :mrgreen:

Как и другие директивы монитора он будет принимать 2 шестнадцатиричных числа через запятую - адрес начала и адрес конца, т.е. введя скажем YF836,F849 мы должны получить:
Code:
F836 3E8A   MVI  A,#8A
F838 320380 STA  #8003
F83B 31CF76 LXI  SP,#76CF
F83E CDCEFA CALL #FACE
F841 210076 LXI  H,#7600
F844 115F76 LXI  D,#765F
F847 0E00   MVI  C,#00
F849 CDEDF9 CALL #F9ED
И как в других директивах F4 должно прекращать вывод, а РУС/ЛАТ - временно останавливать.

P.S.Ещё один способ объяснить почему именно Yozh - потому что код может "съёжиться" до 752 байт (или 731 если использовать только инструкции 8080 - за основу был взят дизассемблер v1.8.1 от vital72, но он уже дальше ушёл и выкатил версию размером 626 байт), а может "разъёжится" до 2КБ собравшись с дополнительным функционалом - объяснялки, секция данных и т.д.

_________________
:dj: https://mastodon.social/@Shaos


07 Feb 2024 00:56
Profile WWW
Doomed

Joined: 10 Aug 2022 07:27
Posts: 351
Reply with quote
Мнемоника под какой ассемблер?)


07 Feb 2024 01:03
Profile
Admin
User avatar

Joined: 08 Jan 2003 23:22
Posts: 22409
Location: Silicon Valley
Reply with quote
Mondx wrote:
Мнемоника под какой ассемблер?)

интел вестимо :lol:

предлагаешь как вариант сделать зайлог? :no:

можно ещё третий вариант поддержать - Human Readable :twisted:
Code:
F836 3E8A   A = #8A
F838 320380 [#8003] = A
F83B 31CF76 SP = #76CF
F83E CDCEFA CALL #FACE
F841 210076 HL = #7600
F844 115F76 DE = #765F
F847 0E00   C = #00
F849 CDEDF9 CALL #F9ED
либо печатать это как комментарий после ;

_________________
:dj: https://mastodon.social/@Shaos


07 Feb 2024 01:04
Profile WWW
Senior
User avatar

Joined: 17 Jun 2014 04:29
Posts: 126
Location: 93.80.157.217
Reply with quote
на кой ляд дизассемблер в Мониторе?
прикладные программы должны грузиться с внешних носителей

_________________
https://radio-86rk.ru
кто я такой, чтобы спорить с самим собой


07 Feb 2024 01:11
Profile WWW
Admin
User avatar

Joined: 08 Jan 2003 23:22
Posts: 22409
Location: Silicon Valley
Reply with quote
vital72 wrote:
на кой ляд дизассемблер в Мониторе?

ну точно также можно сказать на кой ляд модификация ячеек памяти в Мониторе? код должен модифицироваться на ПЦ и далее "грузиться с внешних носителей" :lol:

vital72 wrote:
прикладные программы должны грузиться с внешних носителей

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

P.S. Кстати люди не только дизасм засовывают в монитор, но и асм, и бейсик :lol:

Attachment:
scm-screen-shot.jpg
scm-screen-shot.jpg [ 107.28 KiB | Viewed 913 times ]
Источник: https://smallcomputercentral.com/small-computer-monitor/small-computer-monitor-v1-0/scm-v1-0-description/

_________________
:dj: https://mastodon.social/@Shaos


07 Feb 2024 01:15
Profile WWW
Doomed

Joined: 10 Aug 2022 07:27
Posts: 351
Reply with quote
У м80 нет таких решеток.)
Code:
 MonDX v.06.08.2022 (c600-e200)
        Memory:                         I/O:
Dump            [ran] [lin]     I/O dump        [ran] [lin]
Exchange        [adr]           Output          [adr]
Fill            [ran] [dat]     eXchange CMOS   [adr]
Move            [ran] [dst]             Debug:
Verify          [ran] [adr]     Assemble        [adr]
Load XM         [adr]           Unassemble      [ran] [lin]
Save XM         [ran]           Register        [nam]
        Flash:                  Call            [adr]
Page (32K)      [00BN Fppp]     Go              [adr] [BP1] [BP2]
Write           [ran] [adr]     Break           [BP3] [BP4] [BP5]
Zeroing         [adr]           Kill
        Other:                          Trace           [cnt]
Hex calc        [adr] [adr]     Next (trace)    [cnt]
QP/M (e200 ea00 f800)           Jump (skip)     [cnt]
reboot Yes/no
>uc600 c61f
c600: c3 7e c8          jp      0c87eh

c603: c3 36 cb          jp      0cb36h

c606: c3 33 cb          jp      0cb33h

c609: 3e f1             ld      a,0f1h
c60b: db 00             in      a,(00h)
c60d: e6 02             and     02h
c60f: c8                ret     z

c610: 3e f0             ld      a,0f0h
c612: db 00             in      a,(00h)
c614: c9                ret

c615: 3e f1             ld      a,0f1h
c617: db 00             in      a,(00h)
c619: e6 01             and     01h
c61b: c8                ret     z

c61c: 06 f0             ld      b,0f0h
c61e: ed 49             out     (c),c
>>a

0000: 7c                ld      a,h
0001: b5                or      l
0002: 20 fc             jr      nz,0000h
                                             


07 Feb 2024 01:31
Profile
Admin
User avatar

Joined: 08 Jan 2003 23:22
Posts: 22409
Location: Silicon Valley
Reply with quote
m80 ваще ужос :twisted:

тут дизассемблирование не для того, чтобы потом скопировать и оттранслировать, а чтобы быстро взглянуть на код и понять что там происходит - нолики вначале и хы в конце не очень помогают быстрой читабельности шестнадцатиричных чисел, а решётка - самое то (к тому же в моём ассемблере RASM она поддержана, как и во многих других)...

_________________
:dj: https://mastodon.social/@Shaos


07 Feb 2024 01:41
Profile WWW
Doomed

Joined: 10 Aug 2022 07:27
Posts: 351
Reply with quote
Shaos wrote:
тут дизассемблирование не для того, чтобы потом скопировать и оттранслировать, а чтобы быстро взглянуть на код и понять что там происходит...

Да это понятно. К тому же замена в редакторе не составляет труда. Насчёт 0xxf - это же Микрософт, в том же masm-е86 и т.д.


07 Feb 2024 02:32
Profile
Admin
User avatar

Joined: 08 Jan 2003 23:22
Posts: 22409
Location: Silicon Valley
Reply with quote
Не - я к решётке привык :mrgreen:

_________________
:dj: https://mastodon.social/@Shaos


07 Feb 2024 02:38
Profile WWW
Fanat

Joined: 21 Feb 2017 06:54
Posts: 75
Location: Казань
Reply with quote
Quote:
Я планирую разработать простой и компактный дизассемблер для встраивания в расширенный монитор РК-совместимых компьютеров и т.к. у меня он будет повешан на букву Y, я решил назвать его Yozh :mrgreen:


Дизассемблер нужен, хорошая идея. Можно было назначить его на букву "А" - как в Специалисте. Помню в далеких 80-х я сам сделал для РК 2 программы в машинных кодах - дизассемблер и программатор для ПЗУ с УФ стиранием и решал, что же встроить по адресу F000 - в результате поставил программатор и до сих пор им можно программировать. А дизассемблер использовался на работе много, вроде мне за него даже премию выписали за разработку. Занимал он ровно 1 Кб (у нас были такие м.сх РФ1 ) и по моему его можно было использовать в любых адресах, сейчас уже не помню и от программы только кусочки сохранились на листочках.

Ещё в нем желательно в поле комментариев выводить 3 байта символов (те что по директиве "L") может даже с маской 7F прим так:

F841 32 41 F7 STA #F741 ; "2,A, ."

и ещё третий параметр можно (не обязательный) - начало области данных ( с указанного адреса до первого 00 байта)


07 Feb 2024 03:17
Profile
Maniac
User avatar

Joined: 14 Oct 2019 18:10
Posts: 273
Location: Tashkent
Reply with quote
Оглядываясь на MOS 6502 (что у «Терминатора» и «Бендера» в головах) с его мнемоникой, тоже пытался делать некоторые наброски в этом стиле…
Чтобы команда мнемонически умещалась в два символа…
То есть, MOS-мнемонику «TAX» сокращаем до «AX»…
Code:
     .0 .1 .2 .3 .4 .5 .6 .7 .8 .9 .A .B .C .D .E .F
0000 31 FF 75 21 10 00 CD 18 F8 CD 03 F8 C3 6C F8 00
     S= FF 75 X= 10 00 () 18 F8 () 03 F8 :: 6C F8 00
Где регистровые пары указываются отдельной буквой:
Code:
A A
B B
C C
D D
E E
H H
L L
M (HL) / M
N (DE)
P (BC)
X HL
Y DE
Z BC
Соответственно, дизассемблером выглядит как-то так:
Code:
0000 31 FF 75 || S=75FF
0003 21 10 00 || X=0010
0006 CD 18 F8 || (F818)
0009 CD 03 F8 || (F803)
000C C3 6C F8 || :F86C:


07 Feb 2024 03:34
Profile WWW
Admin
User avatar

Joined: 08 Jan 2003 23:22
Posts: 22409
Location: Silicon Valley
Reply with quote
Спасибо за предложения - пока вот так вот видится:
Code:
0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF

SUPER-86RK/128K
-->YF836,F849,7600
    F836: 3E8A      MVI  A,#8A      ; A = 138
    F838: 320380    STA  #8003      ; [#8003] = A
    F83B: 31CF76    LXI  SP,#76CF   ; SP = DATA+207
    F83E: CDCEFA    CALL #FACE
    F841: 210076    LXI  H,#7600    ; HL = DATA
    F844: 115F76    LXI  D,#765F    ; DE = DATA+95
    F847: 0E00      MVI  C,#00      ; C = 0
    F849: CDEDF9    CALL #F9ED

По поводу вывода символьного представления каждого байта - ну не знаю, по моему это уже лишнее будет, но можно для отдельных байт после MVI и CPI в комментариях, если оно лежит в области меньше #80, показывать символьное написание, а для битовых операций ANI, ORI, XRI наоборот писать двоичное представление аргумента :)

И раз уж если у нас появляется конвертирование в десятичное и двоичное представление, то в монитор можно ещё и конвертилку чисел воткнуть (она может идти как часть "Йожа") скажем на букву B, чтобы переводить из любой системы счисления в любую:
Code:
-->B2,10,1000
    8
-->B10,16,65535
    FFFF
(ну может не из любой в любую, но как минимум поддержать двоичную, восьмиричную, десятичную и шестнадцатиричную системы)

_________________
:dj: https://mastodon.social/@Shaos


07 Feb 2024 08:12
Profile WWW
Senior
User avatar

Joined: 17 Jun 2014 04:29
Posts: 126
Location: 93.80.157.217
Reply with quote
покодил пару часов и получилось нописать дизассм в 1231 байт. мне интересно глянуть на код дизассма в 1 килобайт.
Шаос, а твой дизассм скока весит?
ПЫСЫ: я добавил инструкции 8085 проца


Attachments:
rk86.ru_.png
rk86.ru_.png [ 38.27 KiB | Viewed 746 times ]

_________________
https://radio-86rk.ru
кто я такой, чтобы спорить с самим собой
07 Feb 2024 11:06
Profile WWW
Admin
User avatar

Joined: 08 Jan 2003 23:22
Posts: 22409
Location: Silicon Valley
Reply with quote
И я хотел добавить инструкции 8085 проца :)

Мой дизасм нисколько не весит ибо (пока) не существует ;)

Но если ты свой зарелизишь под открытой лицензией, то я с радостью возьму его в качестве основы :egeek:

_________________
:dj: https://mastodon.social/@Shaos


07 Feb 2024 12:51
Profile WWW
Senior
User avatar

Joined: 17 Jun 2014 04:29
Posts: 126
Location: 93.80.157.217
Reply with quote
ну пусть будет так:

 Disassembler 8085
Code:
;  #############################################################################
;  ##  Disassembler 8085                                                      ##
;  #############################################################################
;
;  Author:  Vitaliy Poedinok aka Vital72
;  License: MIT
;  www:     http://www.86rk.ru/
;  e-mail:  vital72@86rk.ru
;  Version: 1.0
;  Date:    07.02.24

OUT_HEX         EQU   0F815h
OUT_CHAR      EQU   0F809h
OUT_STR         EQU   0F818h
OUT_ADDR      EQU   0FB78h
CMP_DE_HL      EQU   0F990h
MONITOR_PROMPT      EQU   0F86Ch
DISASSM_BUFFER      EQU   7633h

MNEMO_MOV      EQU   0
MNEMO_MVI      EQU   1
MNEMO_STAX      EQU   2
MNEMO_LDAX      EQU   3
MNEMO_STA      EQU   4
MNEMO_LDA      EQU   5
MNEMO_LXI      EQU   6
MNEMO_SHLD      EQU   7
MNEMO_LHLD      EQU   8
MNEMO_PUSH      EQU   9
MNEMO_POP      EQU   10
MNEMO_SPHL      EQU   11
MNEMO_XCHG      EQU   12
MNEMO_XTHL      EQU   13
MNEMO_IN      EQU   14
MNEMO_OUT      EQU   15
MNEMO_CMC      EQU   16
MNEMO_STC      EQU   17
MNEMO_CMA      EQU   18
MNEMO_DAA      EQU   19
MNEMO_INR      EQU   20
MNEMO_DCR      EQU   21
MNEMO_INX      EQU   22
MNEMO_DCX      EQU   23
MNEMO_ADD      EQU   24
MNEMO_ADC      EQU   25
MNEMO_SUB      EQU   26
MNEMO_SBB      EQU   27
MNEMO_ANA      EQU   28
MNEMO_ORA      EQU   29
MNEMO_XRA      EQU   30
MNEMO_CMP      EQU   31
MNEMO_ADI      EQU   32
MNEMO_ACI      EQU   33
MNEMO_SUI      EQU   34
MNEMO_SBI      EQU   35
MNEMO_ANI      EQU   36
MNEMO_ORI      EQU   37
MNEMO_XRI      EQU   38
MNEMO_CPI      EQU   39
MNEMO_DAD      EQU   40
MNEMO_RLC      EQU   41
MNEMO_RAL      EQU   42
MNEMO_RRC      EQU   43
MNEMO_RAR      EQU   44
MNEMO_PCHL      EQU   45
MNEMO_JMP      EQU   46
MNEMO_CALL      EQU   47
MNEMO_RST      EQU   48
MNEMO_RET      EQU   49
MNEMO_JNZ      EQU   50
MNEMO_JZ      EQU   51
MNEMO_JNC      EQU   52
MNEMO_JC      EQU   53
MNEMO_JPO      EQU   54
MNEMO_JPE      EQU   55
MNEMO_JP      EQU   56
MNEMO_JM      EQU   57
MNEMO_CNZ      EQU   58
MNEMO_CZ      EQU   59
MNEMO_CNC      EQU   60
MNEMO_CC      EQU   61
MNEMO_CPO      EQU   62
MNEMO_CPE      EQU   63
MNEMO_CP      EQU   64
MNEMO_CM      EQU   65
MNEMO_RNZ      EQU   66
MNEMO_RZ      EQU   67
MNEMO_RNC      EQU   68
MNEMO_RC      EQU   69
MNEMO_RPO      EQU   70
MNEMO_RPE      EQU   71
MNEMO_RP      EQU   72
MNEMO_RM      EQU   73
MNEMO_EI      EQU   74
MNEMO_DI      EQU   75
MNEMO_HLT      EQU   76
MNEMO_NOP      EQU   77
MNEMO_DSUB      EQU   78
MNEMO_ARHL      EQU   79
MNEMO_RLDE      EQU   80
MNEMO_RIM      EQU   81
MNEMO_SIM      EQU   82
MNEMO_LDHI      EQU   83
MNEMO_LDSI      EQU   84
MNEMO_RSTV      EQU   85
MNEMO_SHLX      EQU   86
MNEMO_LHLX      EQU   87
MNEMO_JNK      EQU   88
MNEMO_JK      EQU   89

MNEMO_OP_NONE      EQU   0
MNEMO_OP_R8      EQU   1
MNEMO_OP_R16      EQU   2
MNEMO_OP_IM8      EQU   3
MNEMO_OP_IM16      EQU   4
MNEMO_OP_R8_IM8      EQU   5
MNEMO_OP_R16_IM16   EQU   6
MNEMO_OP_N      EQU   7
MNEMO_OP_B_R8      EQU   8
MNEMO_OP_C_R8      EQU   9
MNEMO_OP_D_R8      EQU   10
MNEMO_OP_E_R8      EQU   11
MNEMO_OP_H_R8      EQU   12
MNEMO_OP_L_R8      EQU   13
MNEMO_OP_M_R8      EQU   14
MNEMO_OP_A_R8      EQU   15

MNEMO_REG8_B      EQU   0
MNEMO_REG8_C      EQU   1
MNEMO_REG8_D      EQU   2
MNEMO_REG8_E      EQU   3
MNEMO_REG8_H      EQU   4
MNEMO_REG8_L      EQU   5
MNEMO_REG8_M      EQU   6
MNEMO_REG8_A      EQU   7

MNEMO_REG16_B      EQU   0
MNEMO_REG16_D      EQU   1
MNEMO_REG16_H      EQU   2
MNEMO_REG16_SP      EQU   3
MNEMO_REG16_PSW      EQU   4


.macro   instr
   db   @1
   db   (@2 << 4) | @3
.endm

;  =============================================================================

disassm:
   push   d
   push   h      ;  addr of first byte
   lxi   d, disassm_out
   push   d
   mov   e, m
   mvi   d, 0
   inx   h
   push   h
   lxi   h, disassm_table_8085
   dad   d
   dad   d
   mov   b, m      ;  mnemo
   inx   h
   mov   c, m      ;  operands
   mov   a, c
   ani   0F0h
   rrc
   rrc
   rrc
   mov   e, a
   lxi   h, disassm_op
   dad   d
   mov   e, m
   inx   h
   mov   d, m
   xchg
   xthl
   mov   a, c
   ani   07h
   lxi   d, DISASSM_BUFFER
   ret

disassm_op:
   dw   disassm_op_none, disassm_op_r8, disassm_op_r16, disassm_op_im8
   dw   disassm_op_im16, disassm_op_r8_im8, disassm_op_r16_im16, disassm_op_n
   dw   disassm_op_b_r8, disassm_op_c_r8, disassm_op_d_r8, disassm_op_e_r8
   dw   disassm_op_h_r8, disassm_op_l_r8, disassm_op_m_r8, disassm_op_a_r8

disassm_out:
   pop   d      ;  addr of first byte
   push   h      ;  addr of next byte after last
   push   b
   xchg
   mvi   b, 4
   call   OUT_ADDR
   mov   a, m
   inx   h
   dcr   b
   call   OUT_HEX
   call   CMP_DE_HL
   jnz   $-9
   mvi   c, ' '
   call   OUT_CHAR
   call   OUT_CHAR
   dcr   b
   jnz   $-7
   pop   b
   lxi   h, disassm_mnemo_8085
   mov   e, b
   mvi   d, 0
   dad   d
   dad   d
   dad   d
   dad   d
   mvi   b, 4
   mov   c, m
   call   OUT_CHAR
   inx   h
   dcr   b
   jnz   $-6
   mvi   c, ' '
   call   OUT_CHAR
   call   OUT_CHAR
   lxi   h, DISASSM_BUFFER
   call   OUT_STR
   pop   h
   pop   d
   call   CMP_DE_HL
   jnc   MONITOR_PROMPT
   jmp   disassm

disassm_hex2str:
   push   psw
   rrc
   rrc
   rrc
   rrc
   call   $+4
   pop   psw
   ani   0Fh
   cpi   10
   sbi   '0' - 1
   daa
   stax   d
   inx   d
   ret

disassm_get_reg8:
   push   h
   adi   low (disassm_reg8_8085)
   mov   l, a
   mvi   a, 0
   aci   high (disassm_reg8_8085)
   mov   h, a
   mov   a, m
   pop   h
   ret


disassm_op_r8:
   call   disassm_get_reg8
   jmp   disassm_lbl1

disassm_op_r16:
   push   h
   push   d
   lxi   h, disassm_reg16_8085
   mov   e, a
   mvi   d, 0
   dad   d
   dad   d
   dad   d
   dad   d
   pop   d
   mov   a, m
   inx   h
   stax   d
   inx   d
   ana   a
   jnz   $-5
   pop   h
   ret

disassm_op_im8:
   mov   a, m
   inx   h
   call   disassm_hex2str
   jmp   disassm_op_none

disassm_op_im16:
   inx   h
   mov   a, m
   call   disassm_hex2str
   dcx   h
   mov   a, m
   inx   h
   inx   h
   call   disassm_hex2str
   jmp   disassm_op_none

disassm_op_r8_im8:
   call   disassm_get_reg8
   stax   d
   inx   d
   mvi   a, ','
   stax   d
   inx   d
   mvi   a, ' '
   stax   d
   inx   d
   jmp   disassm_op_im8

disassm_op_r16_im16:
   call   disassm_op_r16
   dcx   d
   mvi   a, ','
   stax   d
   inx   d
   mvi   a, ' '
   stax   d
   inx   d
   jmp   disassm_op_im16

disassm_op_n:
   adi   '0'
   jmp   disassm_lbl1

disassm_op_b_r8:
   mvi   a, 'B'
   jmp   disassm_op_a_r8 + 2

disassm_op_c_r8:
   mvi   a, 'C'
   jmp   disassm_op_a_r8 + 2

disassm_op_d_r8:
   mvi   a, 'D'
   jmp   disassm_op_a_r8 + 2

disassm_op_e_r8:
   mvi   a, 'E'
   jmp   disassm_op_a_r8 + 2

disassm_op_h_r8:
   mvi   a, 'H'
   jmp   disassm_op_a_r8 + 2

disassm_op_l_r8:
   mvi   a, 'L'
   jmp   disassm_op_a_r8 + 2

disassm_op_m_r8:
   mvi   a, 'M'
   jmp   disassm_op_a_r8 + 2

disassm_op_a_r8:
   mvi   a, 'A'
   stax   d
   inx   d
   mvi   a, ','
   stax   d
   inx   d
   mvi   a, ' '
   stax   d
   inx   d
   mov   a, c
   ani   07h
   call   disassm_get_reg8
disassm_lbl1:
   stax   d
   inx   d
disassm_op_none:
   xra   a
   stax   d
   ret

;  =============================================================================

disassm_table_8085:
   instr   MNEMO_NOP, MNEMO_OP_NONE, 0
   instr   MNEMO_LXI, MNEMO_OP_R16_IM16, MNEMO_REG16_B
   instr   MNEMO_STAX, MNEMO_OP_R16, MNEMO_REG16_B
   instr   MNEMO_INX, MNEMO_OP_R16, MNEMO_REG16_B
   instr   MNEMO_INR, MNEMO_OP_R8, MNEMO_REG8_B
   instr   MNEMO_DCR, MNEMO_OP_R8, MNEMO_REG8_B
   instr   MNEMO_MVI, MNEMO_OP_R8_IM8, MNEMO_REG8_B
   instr   MNEMO_RLC, MNEMO_OP_NONE, 0
   instr   MNEMO_DSUB, MNEMO_OP_NONE, 0
   instr   MNEMO_DAD, MNEMO_OP_R16, MNEMO_REG16_B
   instr   MNEMO_LDAX, MNEMO_OP_R16, MNEMO_REG16_B
   instr   MNEMO_DCX, MNEMO_OP_R16, MNEMO_REG16_B
   instr   MNEMO_INR, MNEMO_OP_R8, MNEMO_REG8_C
   instr   MNEMO_DCR, MNEMO_OP_R8, MNEMO_REG8_C
   instr   MNEMO_MVI, MNEMO_OP_R8_IM8, MNEMO_REG8_C
   instr   MNEMO_RRC, MNEMO_OP_NONE, 0
   instr   MNEMO_ARHL, MNEMO_OP_NONE, 0
   instr   MNEMO_LXI, MNEMO_OP_R16_IM16, MNEMO_REG16_D
   instr   MNEMO_STAX, MNEMO_OP_R16, MNEMO_REG16_D
   instr   MNEMO_INX, MNEMO_OP_R16, MNEMO_REG16_D
   instr   MNEMO_INR, MNEMO_OP_R8, MNEMO_REG8_D
   instr   MNEMO_DCR, MNEMO_OP_R8, MNEMO_REG8_D
   instr   MNEMO_MVI, MNEMO_OP_R8_IM8, MNEMO_REG8_D
   instr   MNEMO_RAL, MNEMO_OP_NONE, 0
   instr   MNEMO_RLDE, MNEMO_OP_NONE, 0
   instr   MNEMO_DAD, MNEMO_OP_R16, MNEMO_REG16_D
   instr   MNEMO_LDAX, MNEMO_OP_R16, MNEMO_REG16_D
   instr   MNEMO_DCX, MNEMO_OP_R16, MNEMO_REG16_D
   instr   MNEMO_INR, MNEMO_OP_R8, MNEMO_REG8_E
   instr   MNEMO_DCR, MNEMO_OP_R8, MNEMO_REG8_E
   instr   MNEMO_MVI, MNEMO_OP_R8_IM8, MNEMO_REG8_E
   instr   MNEMO_RAR, MNEMO_OP_NONE, 0
   instr   MNEMO_RIM, MNEMO_OP_NONE, 0
   instr   MNEMO_LXI, MNEMO_OP_R16_IM16, MNEMO_REG16_H
   instr   MNEMO_SHLD, MNEMO_OP_IM16, 0
   instr   MNEMO_INX, MNEMO_OP_R16, MNEMO_REG16_H
   instr   MNEMO_INR, MNEMO_OP_R8, MNEMO_REG8_H
   instr   MNEMO_DCR, MNEMO_OP_R8, MNEMO_REG8_H
   instr   MNEMO_MVI, MNEMO_OP_R8_IM8, MNEMO_REG8_H
   instr   MNEMO_DAA, MNEMO_OP_NONE, 0
   instr   MNEMO_LDHI, MNEMO_OP_IM8, 0
   instr   MNEMO_DAD, MNEMO_OP_R16, MNEMO_REG16_H
   instr   MNEMO_LHLD, MNEMO_OP_IM16, 0
   instr   MNEMO_DCX, MNEMO_OP_R16, MNEMO_REG16_H
   instr   MNEMO_INR, MNEMO_OP_R8, MNEMO_REG8_L
   instr   MNEMO_DCR, MNEMO_OP_R8, MNEMO_REG8_L
   instr   MNEMO_MVI, MNEMO_OP_R8_IM8, MNEMO_REG8_L
   instr   MNEMO_CMA, MNEMO_OP_NONE, 0
   instr   MNEMO_SIM, MNEMO_OP_NONE, 0
   instr   MNEMO_LXI, MNEMO_OP_R16_IM16, MNEMO_REG16_SP
   instr   MNEMO_STA, MNEMO_OP_IM16, 0
   instr   MNEMO_INX, MNEMO_OP_R16, MNEMO_REG16_SP
   instr   MNEMO_INR, MNEMO_OP_R8, MNEMO_REG8_M
   instr   MNEMO_DCR, MNEMO_OP_R8, MNEMO_REG8_M
   instr   MNEMO_MVI, MNEMO_OP_R8_IM8, MNEMO_REG8_M
   instr   MNEMO_STC, MNEMO_OP_NONE, 0
   instr   MNEMO_LDSI, MNEMO_OP_IM8, 0
   instr   MNEMO_DAD, MNEMO_OP_R16, MNEMO_REG16_SP
   instr   MNEMO_LDA, MNEMO_OP_IM16, 0
   instr   MNEMO_DCX, MNEMO_OP_R16, MNEMO_REG16_SP
   instr   MNEMO_INR, MNEMO_OP_R8, MNEMO_REG8_A
   instr   MNEMO_DCR, MNEMO_OP_R8, MNEMO_REG8_A
   instr   MNEMO_MVI, MNEMO_OP_R8_IM8, MNEMO_REG8_A
   instr   MNEMO_CMC, MNEMO_OP_NONE, 0
   instr   MNEMO_MOV, MNEMO_OP_B_R8, MNEMO_REG8_B
   instr   MNEMO_MOV, MNEMO_OP_B_R8, MNEMO_REG8_C
   instr   MNEMO_MOV, MNEMO_OP_B_R8, MNEMO_REG8_D
   instr   MNEMO_MOV, MNEMO_OP_B_R8, MNEMO_REG8_E
   instr   MNEMO_MOV, MNEMO_OP_B_R8, MNEMO_REG8_H
   instr   MNEMO_MOV, MNEMO_OP_B_R8, MNEMO_REG8_L
   instr   MNEMO_MOV, MNEMO_OP_B_R8, MNEMO_REG8_M
   instr   MNEMO_MOV, MNEMO_OP_B_R8, MNEMO_REG8_A
   instr   MNEMO_MOV, MNEMO_OP_C_R8, MNEMO_REG8_B
   instr   MNEMO_MOV, MNEMO_OP_C_R8, MNEMO_REG8_C
   instr   MNEMO_MOV, MNEMO_OP_C_R8, MNEMO_REG8_D
   instr   MNEMO_MOV, MNEMO_OP_C_R8, MNEMO_REG8_E
   instr   MNEMO_MOV, MNEMO_OP_C_R8, MNEMO_REG8_H
   instr   MNEMO_MOV, MNEMO_OP_C_R8, MNEMO_REG8_L
   instr   MNEMO_MOV, MNEMO_OP_C_R8, MNEMO_REG8_M
   instr   MNEMO_MOV, MNEMO_OP_C_R8, MNEMO_REG8_A
   instr   MNEMO_MOV, MNEMO_OP_D_R8, MNEMO_REG8_B
   instr   MNEMO_MOV, MNEMO_OP_D_R8, MNEMO_REG8_C
   instr   MNEMO_MOV, MNEMO_OP_D_R8, MNEMO_REG8_D
   instr   MNEMO_MOV, MNEMO_OP_D_R8, MNEMO_REG8_E
   instr   MNEMO_MOV, MNEMO_OP_D_R8, MNEMO_REG8_H
   instr   MNEMO_MOV, MNEMO_OP_D_R8, MNEMO_REG8_L
   instr   MNEMO_MOV, MNEMO_OP_D_R8, MNEMO_REG8_M
   instr   MNEMO_MOV, MNEMO_OP_D_R8, MNEMO_REG8_A
   instr   MNEMO_MOV, MNEMO_OP_E_R8, MNEMO_REG8_B
   instr   MNEMO_MOV, MNEMO_OP_E_R8, MNEMO_REG8_C
   instr   MNEMO_MOV, MNEMO_OP_E_R8, MNEMO_REG8_D
   instr   MNEMO_MOV, MNEMO_OP_E_R8, MNEMO_REG8_E
   instr   MNEMO_MOV, MNEMO_OP_E_R8, MNEMO_REG8_H
   instr   MNEMO_MOV, MNEMO_OP_E_R8, MNEMO_REG8_L
   instr   MNEMO_MOV, MNEMO_OP_E_R8, MNEMO_REG8_M
   instr   MNEMO_MOV, MNEMO_OP_E_R8, MNEMO_REG8_A
   instr   MNEMO_MOV, MNEMO_OP_H_R8, MNEMO_REG8_B
   instr   MNEMO_MOV, MNEMO_OP_H_R8, MNEMO_REG8_C
   instr   MNEMO_MOV, MNEMO_OP_H_R8, MNEMO_REG8_D
   instr   MNEMO_MOV, MNEMO_OP_H_R8, MNEMO_REG8_E
   instr   MNEMO_MOV, MNEMO_OP_H_R8, MNEMO_REG8_H
   instr   MNEMO_MOV, MNEMO_OP_H_R8, MNEMO_REG8_L
   instr   MNEMO_MOV, MNEMO_OP_H_R8, MNEMO_REG8_M
   instr   MNEMO_MOV, MNEMO_OP_H_R8, MNEMO_REG8_A
   instr   MNEMO_MOV, MNEMO_OP_L_R8, MNEMO_REG8_B
   instr   MNEMO_MOV, MNEMO_OP_L_R8, MNEMO_REG8_C
   instr   MNEMO_MOV, MNEMO_OP_L_R8, MNEMO_REG8_D
   instr   MNEMO_MOV, MNEMO_OP_L_R8, MNEMO_REG8_E
   instr   MNEMO_MOV, MNEMO_OP_L_R8, MNEMO_REG8_H
   instr   MNEMO_MOV, MNEMO_OP_L_R8, MNEMO_REG8_L
   instr   MNEMO_MOV, MNEMO_OP_L_R8, MNEMO_REG8_M
   instr   MNEMO_MOV, MNEMO_OP_L_R8, MNEMO_REG8_A
   instr   MNEMO_MOV, MNEMO_OP_M_R8, MNEMO_REG8_B
   instr   MNEMO_MOV, MNEMO_OP_M_R8, MNEMO_REG8_C
   instr   MNEMO_MOV, MNEMO_OP_M_R8, MNEMO_REG8_D
   instr   MNEMO_MOV, MNEMO_OP_M_R8, MNEMO_REG8_E
   instr   MNEMO_MOV, MNEMO_OP_M_R8, MNEMO_REG8_H
   instr   MNEMO_MOV, MNEMO_OP_M_R8, MNEMO_REG8_L
   instr   MNEMO_HLT, MNEMO_OP_NONE, 0
   instr   MNEMO_MOV, MNEMO_OP_M_R8, MNEMO_REG8_A
   instr   MNEMO_MOV, MNEMO_OP_A_R8, MNEMO_REG8_B
   instr   MNEMO_MOV, MNEMO_OP_A_R8, MNEMO_REG8_C
   instr   MNEMO_MOV, MNEMO_OP_A_R8, MNEMO_REG8_D
   instr   MNEMO_MOV, MNEMO_OP_A_R8, MNEMO_REG8_E
   instr   MNEMO_MOV, MNEMO_OP_A_R8, MNEMO_REG8_H
   instr   MNEMO_MOV, MNEMO_OP_A_R8, MNEMO_REG8_L
   instr   MNEMO_MOV, MNEMO_OP_A_R8, MNEMO_REG8_M
   instr   MNEMO_MOV, MNEMO_OP_A_R8, MNEMO_REG8_A
   instr   MNEMO_ADD, MNEMO_OP_R8, MNEMO_REG8_B
   instr   MNEMO_ADD, MNEMO_OP_R8, MNEMO_REG8_C
   instr   MNEMO_ADD, MNEMO_OP_R8, MNEMO_REG8_D
   instr   MNEMO_ADD, MNEMO_OP_R8, MNEMO_REG8_E
   instr   MNEMO_ADD, MNEMO_OP_R8, MNEMO_REG8_H
   instr   MNEMO_ADD, MNEMO_OP_R8, MNEMO_REG8_L
   instr   MNEMO_ADD, MNEMO_OP_R8, MNEMO_REG8_M
   instr   MNEMO_ADD, MNEMO_OP_R8, MNEMO_REG8_A
   instr   MNEMO_ADC, MNEMO_OP_R8, MNEMO_REG8_B
   instr   MNEMO_ADC, MNEMO_OP_R8, MNEMO_REG8_C
   instr   MNEMO_ADC, MNEMO_OP_R8, MNEMO_REG8_D
   instr   MNEMO_ADC, MNEMO_OP_R8, MNEMO_REG8_E
   instr   MNEMO_ADC, MNEMO_OP_R8, MNEMO_REG8_H
   instr   MNEMO_ADC, MNEMO_OP_R8, MNEMO_REG8_L
   instr   MNEMO_ADC, MNEMO_OP_R8, MNEMO_REG8_M
   instr   MNEMO_ADC, MNEMO_OP_R8, MNEMO_REG8_A
   instr   MNEMO_SUB, MNEMO_OP_R8, MNEMO_REG8_B
   instr   MNEMO_SUB, MNEMO_OP_R8, MNEMO_REG8_C
   instr   MNEMO_SUB, MNEMO_OP_R8, MNEMO_REG8_D
   instr   MNEMO_SUB, MNEMO_OP_R8, MNEMO_REG8_E
   instr   MNEMO_SUB, MNEMO_OP_R8, MNEMO_REG8_H
   instr   MNEMO_SUB, MNEMO_OP_R8, MNEMO_REG8_L
   instr   MNEMO_SUB, MNEMO_OP_R8, MNEMO_REG8_M
   instr   MNEMO_SUB, MNEMO_OP_R8, MNEMO_REG8_A
   instr   MNEMO_SBB, MNEMO_OP_R8, MNEMO_REG8_B
   instr   MNEMO_SBB, MNEMO_OP_R8, MNEMO_REG8_C
   instr   MNEMO_SBB, MNEMO_OP_R8, MNEMO_REG8_D
   instr   MNEMO_SBB, MNEMO_OP_R8, MNEMO_REG8_E
   instr   MNEMO_SBB, MNEMO_OP_R8, MNEMO_REG8_H
   instr   MNEMO_SBB, MNEMO_OP_R8, MNEMO_REG8_L
   instr   MNEMO_SBB, MNEMO_OP_R8, MNEMO_REG8_M
   instr   MNEMO_SBB, MNEMO_OP_R8, MNEMO_REG8_A
   instr   MNEMO_ANA, MNEMO_OP_R8, MNEMO_REG8_B
   instr   MNEMO_ANA, MNEMO_OP_R8, MNEMO_REG8_C
   instr   MNEMO_ANA, MNEMO_OP_R8, MNEMO_REG8_D
   instr   MNEMO_ANA, MNEMO_OP_R8, MNEMO_REG8_E
   instr   MNEMO_ANA, MNEMO_OP_R8, MNEMO_REG8_H
   instr   MNEMO_ANA, MNEMO_OP_R8, MNEMO_REG8_L
   instr   MNEMO_ANA, MNEMO_OP_R8, MNEMO_REG8_M
   instr   MNEMO_ANA, MNEMO_OP_R8, MNEMO_REG8_A
   instr   MNEMO_XRA, MNEMO_OP_R8, MNEMO_REG8_B
   instr   MNEMO_XRA, MNEMO_OP_R8, MNEMO_REG8_C
   instr   MNEMO_XRA, MNEMO_OP_R8, MNEMO_REG8_D
   instr   MNEMO_XRA, MNEMO_OP_R8, MNEMO_REG8_E
   instr   MNEMO_XRA, MNEMO_OP_R8, MNEMO_REG8_H
   instr   MNEMO_XRA, MNEMO_OP_R8, MNEMO_REG8_L
   instr   MNEMO_XRA, MNEMO_OP_R8, MNEMO_REG8_M
   instr   MNEMO_XRA, MNEMO_OP_R8, MNEMO_REG8_A
   instr   MNEMO_ORA, MNEMO_OP_R8, MNEMO_REG8_B
   instr   MNEMO_ORA, MNEMO_OP_R8, MNEMO_REG8_C
   instr   MNEMO_ORA, MNEMO_OP_R8, MNEMO_REG8_D
   instr   MNEMO_ORA, MNEMO_OP_R8, MNEMO_REG8_E
   instr   MNEMO_ORA, MNEMO_OP_R8, MNEMO_REG8_H
   instr   MNEMO_ORA, MNEMO_OP_R8, MNEMO_REG8_L
   instr   MNEMO_ORA, MNEMO_OP_R8, MNEMO_REG8_M
   instr   MNEMO_ORA, MNEMO_OP_R8, MNEMO_REG8_A
   instr   MNEMO_CMP, MNEMO_OP_R8, MNEMO_REG8_B
   instr   MNEMO_CMP, MNEMO_OP_R8, MNEMO_REG8_C
   instr   MNEMO_CMP, MNEMO_OP_R8, MNEMO_REG8_D
   instr   MNEMO_CMP, MNEMO_OP_R8, MNEMO_REG8_E
   instr   MNEMO_CMP, MNEMO_OP_R8, MNEMO_REG8_H
   instr   MNEMO_CMP, MNEMO_OP_R8, MNEMO_REG8_L
   instr   MNEMO_CMP, MNEMO_OP_R8, MNEMO_REG8_M
   instr   MNEMO_CMP, MNEMO_OP_R8, MNEMO_REG8_A
   instr   MNEMO_RNZ, MNEMO_OP_NONE, 0
   instr   MNEMO_POP, MNEMO_OP_R16, MNEMO_REG16_B
   instr   MNEMO_JNZ, MNEMO_OP_IM16, 0
   instr   MNEMO_JMP, MNEMO_OP_IM16, 0
   instr   MNEMO_CNZ, MNEMO_OP_IM16, 0
   instr   MNEMO_PUSH, MNEMO_OP_R16, MNEMO_REG16_B
   instr   MNEMO_ADI, MNEMO_OP_IM8, 0
   instr   MNEMO_RST, MNEMO_OP_N, 0
   instr   MNEMO_RZ, MNEMO_OP_NONE, 0
   instr   MNEMO_RET, MNEMO_OP_NONE, 0
   instr   MNEMO_JZ, MNEMO_OP_IM16, 0
   instr   MNEMO_RSTV, MNEMO_OP_NONE, 0
   instr   MNEMO_CZ, MNEMO_OP_IM16, 0
   instr   MNEMO_CALL, MNEMO_OP_IM16, 0
   instr   MNEMO_ACI, MNEMO_OP_IM8, 0
   instr   MNEMO_RST, MNEMO_OP_N, 1
   instr   MNEMO_RNC, MNEMO_OP_NONE, 0
   instr   MNEMO_POP, MNEMO_OP_R16, MNEMO_REG16_D
   instr   MNEMO_JNC, MNEMO_OP_IM16, 0
   instr   MNEMO_OUT, MNEMO_OP_IM8, 0
   instr   MNEMO_CNC, MNEMO_OP_IM16, 0
   instr   MNEMO_PUSH, MNEMO_OP_R16, MNEMO_REG16_D
   instr   MNEMO_SUI, MNEMO_OP_IM8, 0
   instr   MNEMO_RST, MNEMO_OP_N, 2
   instr   MNEMO_RC, MNEMO_OP_NONE, 0
   instr   MNEMO_SHLX, MNEMO_OP_NONE, 0
   instr   MNEMO_JC, MNEMO_OP_IM16, 0
   instr   MNEMO_IN, MNEMO_OP_IM8, 0
   instr   MNEMO_CC, MNEMO_OP_IM16, 0
   instr   MNEMO_JNK, MNEMO_OP_IM16, 0
   instr   MNEMO_SBI, MNEMO_OP_IM8, 0
   instr   MNEMO_RST, MNEMO_OP_N, 3
   instr   MNEMO_RPO, MNEMO_OP_NONE, 0
   instr   MNEMO_POP, MNEMO_OP_R16, MNEMO_REG16_H
   instr   MNEMO_JPO, MNEMO_OP_IM16, 0
   instr   MNEMO_XTHL, MNEMO_OP_NONE, 0
   instr   MNEMO_CPO, MNEMO_OP_IM16, 0
   instr   MNEMO_PUSH, MNEMO_OP_R16, MNEMO_REG16_H
   instr   MNEMO_ANI, MNEMO_OP_IM8, 0
   instr   MNEMO_RST, MNEMO_OP_N, 4
   instr   MNEMO_RPE, MNEMO_OP_NONE, 0
   instr   MNEMO_PCHL, MNEMO_OP_NONE, 0
   instr   MNEMO_JPE, MNEMO_OP_IM16, 0
   instr   MNEMO_XCHG, MNEMO_OP_NONE, 0
   instr   MNEMO_CPE, MNEMO_OP_IM16, 0
   instr   MNEMO_LHLX, MNEMO_OP_NONE, 0
   instr   MNEMO_XRI, MNEMO_OP_IM8, 0
   instr   MNEMO_RST, MNEMO_OP_N, 5
   instr   MNEMO_RP, MNEMO_OP_NONE, 0
   instr   MNEMO_POP, MNEMO_OP_R16, MNEMO_REG16_PSW
   instr   MNEMO_JP, MNEMO_OP_IM16, 0
   instr   MNEMO_DI, MNEMO_OP_NONE, 0
   instr   MNEMO_CP, MNEMO_OP_IM16, 0
   instr   MNEMO_PUSH, MNEMO_OP_R16, MNEMO_REG16_PSW
   instr   MNEMO_ORI, MNEMO_OP_IM8, 0
   instr   MNEMO_RST, MNEMO_OP_N, 6
   instr   MNEMO_RM, MNEMO_OP_NONE, 0
   instr   MNEMO_SPHL, MNEMO_OP_NONE, 0
   instr   MNEMO_JM, MNEMO_OP_IM16, 0
   instr   MNEMO_EI, MNEMO_OP_NONE, 0
   instr   MNEMO_CM, MNEMO_OP_IM16, 0
   instr   MNEMO_JK, MNEMO_OP_IM16, 0
   instr   MNEMO_CPI, MNEMO_OP_IM8, 0
   instr   MNEMO_RST, MNEMO_OP_N, 7

disassm_mnemo_8085:
   db   "MOV ", "MVI ", "STAX", "LDAX", "STA ", "LDA "
   db   "LXI ", "SHLD", "LHLD", "PUSH", "POP ", "SPHL", "XCHG", "XTHL"
   db   "IN  ", "OUT "
   db   "CMC ", "STC ", "CMA ", "DAA ", "INR ", "DCR ", "INX ", "DCX "
   db   "ADD ", "ADC ", "SUB ", "SBB ", "ANA ", "ORA ", "XRA ", "CMP "
   db   "ADI ", "ACI ", "SUI ", "SBI ", "ANI ", "ORI ", "XRI ", "CPI "
   db   "DAD "
   db   "RLC ", "RAL ", "RRC ", "RAR "
   db   "PCHL", "JMP ", "CALL", "RST ", "RET "
   db   "JNZ ", "JZ  ", "JNC ", "JC  ", "JPO ", "JPE ", "JP  ", "JM  "
   db   "CNZ ", "CZ  ", "CNC ", "CC  ", "CPO ", "CPE ", "CP  ", "CM  "
   db   "RNZ ", "RZ  ", "RNC ", "RC  ", "RPO ", "RPE ", "RP  ", "RM  "
   db   "EI  ", "DI  ", "HLT ", "NOP "
   db   "DSUB", "ARHL", "RLDE", "RIM ", "SIM ", "LDHI", "LDSI"
   db   "RSTV", "SHLX", "LHLX", "JNK ", "JK  "

disassm_reg8_8085:
   db   "BCDEHLMA"

disassm_reg16_8085:
   db   "B", 0, 0, 0, "D", 0, 0, 0, "H", 0, 0, 0, "SP", 0, 0, "PSW", 0

;  =============================================================================

говнокодил не долго, на все инструкции не тестировал.
использует внутренние вызовы Монитора, но это не должно быть проблемой, т.к. для Монитора и писалось.
использует внутренний буфер Монитора для ввода стоки.
сейчас нет обработки Ctrl+C, но проблем добавить быть не должно, код как раз писался как шаблон.
логика полностью скопирована из моего же дизассма на JS.
если что-то не компилируется: я использую немного модифицированный компилятор с сайта https://www.asm80.com/, пока свой компилер не написал, приходится использовать чужое.

_________________
https://radio-86rk.ru
кто я такой, чтобы спорить с самим собой


07 Feb 2024 13:10
Profile WWW
Display posts from previous:  Sort by  
Reply to topic   [ 165 posts ]  Go to page 1, 2, 3, 4, 5 ... 11  Next

Who is online

Users browsing this forum: No registered users and 7 guests


You cannot post new topics in this forum
You cannot reply to topics in this forum
You cannot edit your posts in this forum
You cannot delete your posts in this forum
You cannot post attachments in this forum

Search for:
Jump to:  
Powered by phpBB® Forum Software © phpBB Group
Designed by ST Software.