Дизассемблер Yozh

Советский компьютер Радио-86РК (1986) и его клоны

Moderator: Shaos

User avatar
Shaos
Admin
Posts: 24083
Joined: 08 Jan 2003 23:22
Location: Silicon Valley

Дизассемблер Yozh

Post by Shaos »

Я планирую сделать простой и компактный дизассемблер для встраивания в расширенный монитор РК-совместимых компьютеров и т.к. у меня он будет повешан на букву Y, я решил назвать его Yozh :mrgreen:

Как и другие директивы монитора он будет принимать 2 шестнадцатиричных числа через запятую - адрес начала и адрес конца, т.е. введя скажем YF836,F849 мы должны получить:

Code: Select all

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КБ собравшись с дополнительным функционалом - объяснялки, секция данных и т.д.
Я тут за главного - если что шлите мыло на me собака shaos точка net
Top
Mondx
Doomed
Posts: 518
Joined: 10 Aug 2022 07:27
Location: Crimea

Re: Дизассемблер Yozh

Post by Mondx »

Мнемоника под какой ассемблер?)
Top
User avatar
Shaos
Admin
Posts: 24083
Joined: 08 Jan 2003 23:22
Location: Silicon Valley

Re: Дизассемблер Yozh

Post by Shaos »

Mondx wrote:Мнемоника под какой ассемблер?)
интел вестимо :lol:

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

можно ещё третий вариант поддержать - Human Readable :twisted:

Code: Select all

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
либо печатать это как комментарий после ;
Я тут за главного - если что шлите мыло на me собака shaos точка net
Top
User avatar
vital72
Senior
Posts: 181
Joined: 17 Jun 2014 04:29
Location: 93.80.157.217

Re: Дизассемблер Yozh

Post by vital72 »

на кой ляд дизассемблер в Мониторе?
прикладные программы должны грузиться с внешних носителей
https://radio-86rk.ru
кто я такой, чтобы спорить с самим собой
Top
User avatar
Shaos
Admin
Posts: 24083
Joined: 08 Jan 2003 23:22
Location: Silicon Valley

Re: Дизассемблер Yozh

Post by Shaos »

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

P.S. Кстати люди не только дизасм засовывают в монитор, но и асм, и бейсик :lol:
scm-screen-shot.jpg
Источник: https://smallcomputercentral.com/small-computer-monitor/small-computer-monitor-v1-0/scm-v1-0-description/
You do not have the required permissions to view the files attached to this post.
Я тут за главного - если что шлите мыло на me собака shaos точка net
Top
Mondx
Doomed
Posts: 518
Joined: 10 Aug 2022 07:27
Location: Crimea

Re: Дизассемблер Yozh

Post by Mondx »

У м80 нет таких решеток.)

Code: Select all

 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
Top
User avatar
Shaos
Admin
Posts: 24083
Joined: 08 Jan 2003 23:22
Location: Silicon Valley

Re: Дизассемблер Yozh

Post by Shaos »

m80 ваще ужос :twisted:

тут дизассемблирование не для того, чтобы потом скопировать и оттранслировать, а чтобы быстро взглянуть на код и понять что там происходит - нолики вначале и хы в конце не очень помогают быстрой читабельности шестнадцатиричных чисел, а решётка - самое то (к тому же в моём ассемблере RASM она поддержана, как и во многих других)...
Я тут за главного - если что шлите мыло на me собака shaos точка net
Top
Mondx
Doomed
Posts: 518
Joined: 10 Aug 2022 07:27
Location: Crimea

Re: Дизассемблер Yozh

Post by Mondx »

Shaos wrote: тут дизассемблирование не для того, чтобы потом скопировать и оттранслировать, а чтобы быстро взглянуть на код и понять что там происходит...
Да это понятно. К тому же замена в редакторе не составляет труда. Насчёт 0xxf - это же Микрософт, в том же masm-е86 и т.д.
Top
User avatar
Shaos
Admin
Posts: 24083
Joined: 08 Jan 2003 23:22
Location: Silicon Valley

Re: Дизассемблер Yozh

Post by Shaos »

Не - я к решётке привык :mrgreen:
Я тут за главного - если что шлите мыло на me собака shaos точка net
Top
Damir
Fanat
Posts: 88
Joined: 21 Feb 2017 06:54
Location: Казань

Re: Дизассемблер Yozh

Post by Damir »

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

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

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

и ещё третий параметр можно (не обязательный) - начало области данных ( с указанного адреса до первого 00 байта)
Top
User avatar
Alikberov
Doomed
Posts: 355
Joined: 14 Oct 2019 18:10
Location: Tashkent

Re: Дизассемблер Yozh

Post by Alikberov »

Оглядываясь на MOS 6502 (что у «Терминатора» и «Бендера» в головах) с его мнемоникой, тоже пытался делать некоторые наброски в этом стиле…
Чтобы команда мнемонически умещалась в два символа…
То есть, MOS-мнемонику «TAX» сокращаем до «AX»…

Code: Select all

     .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: Select all

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: Select all

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:
Top
User avatar
Shaos
Admin
Posts: 24083
Joined: 08 Jan 2003 23:22
Location: Silicon Valley

Re: Дизассемблер Yozh

Post by Shaos »

Спасибо за предложения - пока вот так вот видится:

Code: Select all

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: Select all

-->B2,10,1000
    8
-->B10,16,65535
    FFFF
(ну может не из любой в любую, но как минимум поддержать двоичную, восьмиричную, десятичную и шестнадцатиричную системы)
Я тут за главного - если что шлите мыло на me собака shaos точка net
Top
User avatar
vital72
Senior
Posts: 181
Joined: 17 Jun 2014 04:29
Location: 93.80.157.217

Re: Дизассемблер Yozh

Post by vital72 »

покодил пару часов и получилось нописать дизассм в 1231 байт. мне интересно глянуть на код дизассма в 1 килобайт.
Шаос, а твой дизассм скока весит?
ПЫСЫ: я добавил инструкции 8085 проца
You do not have the required permissions to view the files attached to this post.
https://radio-86rk.ru
кто я такой, чтобы спорить с самим собой
Top
User avatar
Shaos
Admin
Posts: 24083
Joined: 08 Jan 2003 23:22
Location: Silicon Valley

Re: Дизассемблер Yozh

Post by Shaos »

И я хотел добавить инструкции 8085 проца :)

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

Но если ты свой зарелизишь под открытой лицензией, то я с радостью возьму его в качестве основы :egeek:
Я тут за главного - если что шлите мыло на me собака shaos точка net
Top
User avatar
vital72
Senior
Posts: 181
Joined: 17 Jun 2014 04:29
Location: 93.80.157.217

Re: Дизассемблер Yozh

Post by vital72 »

ну пусть будет так:

 Disassembler 8085

Code: Select all

;  #############################################################################
;  ##  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
кто я такой, чтобы спорить с самим собой
Top

Return to “Radio-86RK”