xref: /src/external/gpl3/gdb/dist/sim/testsuite/h8300/movb.s

# Hitachi H8 testcase 'mov.b'
# mach(): h8300h h8300s h8sx
# as(h8300h):	--defsym sim_cpu=1
# as(h8300s):	--defsym sim_cpu=2
# as(h8sx):	--defsym sim_cpu=3
# ld(h8300h):	-m h8300helf
# ld(h8300s):	-m h8300self
# ld(h8sx):	-m h8300sxelf

	.include "testutils.inc"

	start

	.data
	.align	4
byte_dst_dec:
	.byte	0
byte_src:
	.byte	0x77
byte_dst:
	.byte	0

	.text

	;;
	;; Move byte from immediate source
	;;

.if (sim_cpu == h8sx)
mov_b_imm8_to_reg8:
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	set_ccr_zero

	;; mov.b #xx:8, rd
	mov.b	#0x77:8, r0l	; Immediate 3-bit operand
;;;	.word	0xf877

	;; test ccr		; H=0 N=0 Z=0 V=0 C=0
	test_neg_clear
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	test_h_gr32 0xa5a5a577 er0

	test_gr_a5a5 1		; Make sure other general regs not disturbed
	test_gr_a5a5 2
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7
.endif

.if (sim_cpu == h8sx)
mov_b_imm4_to_abs16:
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	set_ccr_zero

	;; mov.b #xx:4, @aa:16
	mov.b	#0xf:4, @byte_dst:16	; 16-bit address-direct operand
;;;	.word	0x6adf
;;;	.word	@byte_dst

	;; test ccr		; H=0 N=0 Z=0 V=0 C=0
	test_neg_clear
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	test_gr_a5a5 0		; Make sure _ALL_ general regs not disturbed
	test_gr_a5a5 1		; (first, because on h8/300 we must use one
	test_gr_a5a5 2		; to examine the destination memory).
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

	;; Now check the result of the move to memory.
	cmp.b	#0xf, @byte_dst
	beq	.Lnext21
	fail
.Lnext21:
	mov.b	#0, @byte_dst	; zero it again for the next use.

mov_b_imm4_to_abs32:
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	set_ccr_zero

	;; mov.b #xx:4, @aa:32
	mov.b	#0xf:4, @byte_dst:32	; 32-bit address-direct operand
;;;	.word	0x6aff
;;;	.long	@byte_dst

	;; test ccr		; H=0 N=0 Z=0 V=0 C=0
	test_neg_clear
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	test_gr_a5a5 0		; Make sure _ALL_ general regs not disturbed
	test_gr_a5a5 1		; (first, because on h8/300 we must use one
	test_gr_a5a5 2		; to examine the destination memory).
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

	;; Now check the result of the move to memory.
	cmp.b	#0xf, @byte_dst
	beq	.Lnext22
	fail
.Lnext22:
	mov.b	#0, @byte_dst	; zero it again for the next use.

mov_b_imm8_to_indirect:
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	set_ccr_zero

	;; mov.b #xx:8, @erd
	mov.l	#byte_dst, er1
	mov.b	#0xa5:8, @er1	; Register indirect operand
;;;	.word	0x017d
;;;	.word	0x01a5

	;; test ccr		; H=0 N=1 Z=0 V=0 C=0
	test_neg_set
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	test_gr_a5a5 0		; Make sure other general regs not disturbed
	test_h_gr32	byte_dst, er1
	test_gr_a5a5 2
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

	;; Now check the result of the move to memory.
	cmp.b	#0xa5, @byte_dst
	beq	.Lnext1
	fail
.Lnext1:
	mov.b	#0, @byte_dst	; zero it again for the next use.

mov_b_imm8_to_postinc:		; post-increment from imm8 to mem
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	set_ccr_zero

	;; mov.b #xx:8, @erd+
	mov.l	#byte_dst, er1
	mov.b	#0xa5:8, @er1+	; Imm8, register post-incr operands.
;;;	.word	0x017d
;;;	.word	0x81a5

	;; test ccr		; H=0 N=1 Z=0 V=0 C=0
	test_neg_set
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	test_gr_a5a5 0		; Make sure other general regs not disturbed
	test_h_gr32	byte_dst+1, er1
	test_gr_a5a5 2
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

	;; Now check the result of the move to memory.
	cmp.b	#0xa5, @byte_dst
	beq	.Lnext2
	fail
.Lnext2:
	mov.b	#0, @byte_dst	; zero it again for the next use.

mov_b_imm8_to_postdec:		; post-decrement from imm8 to mem
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	set_ccr_zero

	;; mov.b #xx:8, @erd-
	mov.l	#byte_dst, er1
	mov.b	#0xa5:8, @er1-	; Imm8, register post-decr operands.
;;;	.word	0x017d
;;;	.word	0xa1a5

	;; test ccr		; H=0 N=1 Z=0 V=0 C=0
	test_neg_set
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	test_gr_a5a5 0		; Make sure other general regs not disturbed
	test_h_gr32	byte_dst-1, er1
	test_gr_a5a5 2
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

	;; Now check the result of the move to memory.
	cmp.b	#0xa5, @byte_dst
	beq	.Lnext3
	fail
.Lnext3:
	mov.b	#0, @byte_dst	; zero it again for the next use.

mov_b_imm8_to_preinc:		; pre-increment from register to mem
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	set_ccr_zero

	;; mov.b #xx:8, @+erd
	mov.l	#byte_dst-1, er1
	mov.b	#0xa5:8, @+er1	; Imm8, register pre-incr operands
;;;	.word	0x017d
;;;	.word	0x91a5

	;; test ccr		; H=0 N=1 Z=0 V=0 C=0
	test_neg_set
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	test_gr_a5a5 0		; Make sure other general regs not disturbed
	test_h_gr32	byte_dst, er1
	test_gr_a5a5 2
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

	;; Now check the result of the move to memory.
	cmp.b	#0xa5, @byte_dst
	beq	.Lnext4
	fail
.Lnext4:
	mov.b	#0, @byte_dst	; zero it again for the next use.

mov_b_imm8_to_predec:		; pre-decrement from register to mem
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	set_ccr_zero

	;; mov.b #xx:8, @-erd
	mov.l	#byte_dst+1, er1
	mov.b	#0xa5:8, @-er1	; Imm8, register pre-decr operands
;;;	.word	0x017d
;;;	.word	0xb1a5

	;; test ccr		; H=0 N=1 Z=0 V=0 C=0
	test_neg_set
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	test_gr_a5a5 0		; Make sure other general regs not disturbed
	test_h_gr32	byte_dst, er1
	test_gr_a5a5 2
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

	;; Now check the result of the move to memory.
	cmp.b	#0xa5, @byte_dst
	beq	.Lnext5
	fail
.Lnext5:
	mov.b	#0, @byte_dst	; zero it again for the next use.

mov_b_imm8_to_disp2:
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	set_ccr_zero

	;; mov.b #xx:8, @(dd:2, erd)
	mov.l	#byte_dst-3, er1
	mov.b	#0xa5:8, @(3:2, er1)	; Imm8, reg plus 2-bit disp. operand
;;;	.word	0x017d
;;;	.word	0x31a5

	;; test ccr		; H=0 N=1 Z=0 V=0 C=0
	test_neg_set
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	test_gr_a5a5 0		; Make sure other general regs not disturbed
	test_h_gr32	byte_dst-3, er1
	test_gr_a5a5 2
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

	;; Now check the result of the move to memory.
	cmp.b	#0xa5, @byte_dst
	beq	.Lnext6
	fail
.Lnext6:
	mov.b	#0, @byte_dst	; zero it again for the next use.

mov_b_imm8_to_disp16:
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	set_ccr_zero

	;; mov.b #xx:8, @(dd:16, erd)
	mov.l	#byte_dst-4, er1
	mov.b	#0xa5:8, @(4:16, er1)	; Register plus 16-bit disp. operand
;;;	.word	0x017d
;;;	.word	0x6f90
;;;	.word	0x0004

	;; test ccr		; H=0 N=1 Z=0 V=0 C=0
	test_neg_set
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	test_gr_a5a5 0		; Make sure other general regs not disturbed
	test_h_gr32	byte_dst-4, er1
	test_gr_a5a5 2
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

	;; Now check the result of the move to memory.
	cmp.b	#0xa5, @byte_dst
	beq	.Lnext7
	fail
.Lnext7:
	mov.b	#0, @byte_dst	; zero it again for the next use.

mov_b_imm8_to_disp32:
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	set_ccr_zero

	;; mov.b #xx:8, @(dd:32, erd)
	mov.l	#byte_dst-8, er1
	mov.b	#0xa5:8, @(8:32, er1)	; Register plus 32-bit disp. operand
;;;	.word	0x017d
;;;	.word	0xc9a5
;;;	.long	8

	;; test ccr		; H=0 N=1 Z=0 V=0 C=0
	test_neg_set
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	test_gr_a5a5 0		; Make sure other general regs not disturbed
	test_h_gr32	byte_dst-8, er1
	test_gr_a5a5 2
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

	;; Now check the result of the move to memory.
	cmp.b	#0xa5, @byte_dst
	beq	.Lnext8
	fail
.Lnext8:
	mov.b	#0, @byte_dst	; zero it again for the next use.

mov_b_imm8_to_indexb16:
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	mov.l	#0xffffff01, er1
	set_ccr_zero
	;; mov.b #xx:8, @(dd:16, rd.b)
	mov.b	#0xa5:8, @(byte_dst-1:16, r1.b) ; byte indexed operand

	;; test ccr		; H=0 N=1 Z=0 V=0 C=0
	test_neg_set
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	test_gr_a5a5 0		; Make sure other general regs not disturbed
	test_h_gr32	0xffffff01, er1
	test_gr_a5a5 2
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

	;; Now check the result of the move to memory.
	cmp.b	#0xa5, @byte_dst
	bne	fail1
	mov.b	#0, @byte_dst	; zero it again for the next use.

mov_b_imm8_to_indexw16:
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	mov.l	#0xffff0002, er1
	set_ccr_zero
	;; mov.b #xx:8, @(dd:16, rd.w)
	mov.b	#0xa5:8, @(byte_dst-2:16, r1.w) ; byte indexed operand

	;; test ccr		; H=0 N=1 Z=0 V=0 C=0
	test_neg_set
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	test_gr_a5a5 0		; Make sure other general regs not disturbed
	test_h_gr32	0xffff0002, er1
	test_gr_a5a5 2
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

	;; Now check the result of the move to memory.
	cmp.b	#0xa5, @byte_dst
	bne	fail1
	mov.b	#0, @byte_dst	; zero it again for the next use.

mov_b_imm8_to_indexl16:
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	mov.l	#0x00000003, er1
	set_ccr_zero
	;; mov.b #xx:8, @(dd:16, erd.l)
	mov.b	#0xa5:8, @(byte_dst-3:16, er1.l) ; byte indexed operand

	;; test ccr		; H=0 N=1 Z=0 V=0 C=0
	test_neg_set
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	test_gr_a5a5 0		; Make sure other general regs not disturbed
	test_h_gr32	0x00000003, er1
	test_gr_a5a5 2
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

	;; Now check the result of the move to memory.
	cmp.b	#0xa5, @byte_dst
	bne	fail1
	mov.b	#0, @byte_dst	; zero it again for the next use.

mov_b_imm8_to_indexb32:
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	mov.l	#0xffffff04, er1
	set_ccr_zero
	;; mov.b #xx:8, @(dd:32, rd.b)
	mov.b	#0xa5:8, @(byte_dst-4:32, r1.b)	; byte indexed operand

	;; test ccr		; H=0 N=1 Z=0 V=0 C=0
	test_neg_set
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	test_gr_a5a5 0		; Make sure other general regs not disturbed
	test_h_gr32	0xffffff04 er1
	test_gr_a5a5 2
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

	;; Now check the result of the move to memory.
	cmp.b	#0xa5, @byte_dst
	bne	fail1
	mov.b	#0, @byte_dst	; zero it again for the next use.

mov_b_imm8_to_indexw32:
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	mov.l	#0xffff0005, er1
	set_ccr_zero
	;; mov.b #xx:8, @(dd:32, rd.w)
	mov.b	#0xa5:8, @(byte_dst-5:32, r1.w)	; byte indexed operand

	;; test ccr		; H=0 N=1 Z=0 V=0 C=0
	test_neg_set
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	test_gr_a5a5 0		; Make sure other general regs not disturbed
	test_h_gr32	0xffff0005 er1
	test_gr_a5a5 2
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

	;; Now check the result of the move to memory.
	cmp.b	#0xa5, @byte_dst
	bne	fail1
	mov.b	#0, @byte_dst	; zero it again for the next use.

mov_b_imm8_to_indexl32:
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	mov.l	#0x00000006, er1
	set_ccr_zero
	;; mov.b #xx:8, @(dd:32, erd.l)
	mov.b	#0xa5:8, @(byte_dst-6:32, er1.l)	; byte indexed operand

	;; test ccr		; H=0 N=1 Z=0 V=0 C=0
	test_neg_set
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	test_gr_a5a5 0		; Make sure other general regs not disturbed
	test_h_gr32	0x00000006 er1
	test_gr_a5a5 2
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

	;; Now check the result of the move to memory.
	cmp.b	#0xa5, @byte_dst
	bne	fail1
	mov.b	#0, @byte_dst	; zero it again for the next use.

mov_b_imm8_to_abs16:
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	set_ccr_zero

	;; mov.b #xx:8, @aa:16
	mov.b	#0xa5:8, @byte_dst:16	; 16-bit address-direct operand
;;;	.word	0x017d
;;;	.word	0x40a5
;;;	.word	@byte_dst

	;; test ccr		; H=0 N=1 Z=0 V=0 C=0
	test_neg_set
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	test_gr_a5a5 0		; Make sure _ALL_ general regs not disturbed
	test_gr_a5a5 1		; (first, because on h8/300 we must use one
	test_gr_a5a5 2		; to examine the destination memory).
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

	;; Now check the result of the move to memory.
	cmp.b	#0xa5, @byte_dst
	beq	.Lnext9
	fail
.Lnext9:
	mov.b	#0, @byte_dst	; zero it again for the next use.

mov_b_imm8_to_abs32:
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	set_ccr_zero

	;; mov.b #xx:8, @aa:32
	mov.b	#0xa5:8, @byte_dst:32	; 32-bit address-direct operand
;;;	.word	0x017d
;;;	.word	0x48a5
;;;	.long	@byte_dst

	;; test ccr		; H=0 N=1 Z=0 V=0 C=0
	test_neg_set
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	test_gr_a5a5 0		; Make sure _ALL_ general regs not disturbed
	test_gr_a5a5 1		; (first, because on h8/300 we must use one
	test_gr_a5a5 2		; to examine the destination memory).
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

	;; Now check the result of the move to memory.
	cmp.b	#0xa5, @byte_dst
	beq	.Lnext10
	fail
.Lnext10:
	mov.b	#0, @byte_dst	; zero it again for the next use.

.endif

	;;
	;; Move byte from register source
	;;

mov_b_reg8_to_reg8:
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	set_ccr_zero

	;; mov.b ers, erd
	mov.b	#0x12, r1l
	mov.b	r1l, r0l	; Register 8-bit operand
;;;	.word	0x0c98

	;; test ccr		; H=0 N=0 Z=0 V=0 C=0
	test_neg_clear
	test_zero_clear
	test_ovf_clear
	test_carry_clear
	test_h_gr16 0xa512 r0
	test_h_gr16 0xa512 r1	; mov src unchanged
.if (sim_cpu)
	test_h_gr32 0xa5a5a512 er0
	test_h_gr32 0xa5a5a512 er1	; mov src unchanged
.endif
	test_gr_a5a5 2		; Make sure other general regs not disturbed
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7


mov_b_reg8_to_indirect:
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	set_ccr_zero

	;; mov.b ers, @erd
	mov.l	#byte_dst, er1
	mov.b	r0l, @er1	; Register indirect operand
;;;	.word	0x6898

	;; test ccr		; H=0 N=1 Z=0 V=0 C=0
	test_neg_set
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	test_gr_a5a5 0		; Make sure other general regs not disturbed
	test_h_gr32	byte_dst, er1
	test_gr_a5a5 2
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

	;; Now check the result of the move to memory.
	mov.b	@byte_dst, r0l
	cmp.b	r2l, r0l
	beq	.Lnext44
	fail
.Lnext44:
	mov.b	#0, r0l
	mov.b	r0l, @byte_dst	; zero it again for the next use.

.if (sim_cpu == h8sx)
mov_b_reg8_to_postinc:		; post-increment from register to mem
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	set_ccr_zero

	;; mov.b ers, @erd+
	mov.l	#byte_dst, er1
	mov.b	r0l, @er1+	; Register post-incr operand
;;;	.word	0x0173
;;;	.word	0x6c98

	;; test ccr		; H=0 N=1 Z=0 V=0 C=0
	test_neg_set
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	test_gr_a5a5 0		; Make sure other general regs not disturbed
	test_h_gr32	byte_dst+1, er1
	test_gr_a5a5 2
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

	;; Now check the result of the move to memory.
	cmp.b	r2l, @byte_dst
	beq	.Lnext49
	fail
.Lnext49:
	;; special case same register
	mov.l	#byte_dst, er0
	mov.b	r0l, r1l
	inc.b	r1l
	mov.b	r0l, @er0+
	mov.b	@byte_dst, r0l
	cmp.b	r0l, r1l
	beq	.Lnext53
	fail
.Lnext53:
	mov.b	#0, @byte_dst	; zero it again for the next use.

mov_b_reg8_to_postdec:		; post-decrement from register to mem
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	set_ccr_zero

	;; mov.b ers, @erd-
	mov.l	#byte_dst, er1
	mov.b	r0l, @er1-	; Register post-decr operand
;;;	.word	0x0171
;;;	.word	0x6c98

	;; test ccr		; H=0 N=1 Z=0 V=0 C=0
	test_neg_set
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	test_gr_a5a5 0		; Make sure other general regs not disturbed
	test_h_gr32	byte_dst-1, er1
	test_gr_a5a5 2
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

	;; Now check the result of the move to memory.
	cmp.b	r2l, @byte_dst
	beq	.Lnext50
	fail
.Lnext50:
	;; special case same register
	mov.l	#byte_dst, er0
	mov.b	r0l, r1l
	dec.b	r1l
	mov.b	r0l, @er0-
	mov.b	@byte_dst, r0l
	cmp.b	r0l, r1l
	beq	.Lnext54
	fail
.Lnext54:
	mov.b	#0, @byte_dst	; zero it again for the next use.

mov_b_reg8_to_preinc:		; pre-increment from register to mem
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	set_ccr_zero

	;; mov.b ers, @+erd
	mov.l	#byte_dst-1, er1
	mov.b	r0l, @+er1	; Register pre-incr operand
;;;	.word	0x0172
;;;	.word	0x6c98

	;; test ccr		; H=0 N=1 Z=0 V=0 C=0
	test_neg_set
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	test_gr_a5a5 0		; Make sure other general regs not disturbed
	test_h_gr32	byte_dst, er1
	test_gr_a5a5 2
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

	;; Now check the result of the move to memory.
	cmp.b	r2l, @byte_dst
	beq	.Lnext51
	fail
.Lnext51:
	;; special case same register
	mov.l	#byte_dst-1, er0
	mov.b	r0l, r1l
	inc.b	r1l
	mov.b	r0l, @+er0
	mov.b	@byte_dst, r0l
	cmp.b	r0l, r1l
	beq	.Lnext55
	fail
.Lnext55:
	mov.b	#0, @byte_dst	; zero it again for the next use.
.endif

mov_b_reg8_to_predec:		; pre-decrement from register to mem
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	set_ccr_zero

	;; mov.b ers, @-erd
	mov.l	#byte_dst+1, er1
	mov.b	r0l, @-er1	; Register pre-decr operand
;;;	.word	0x6c98

	;; test ccr		; H=0 N=1 Z=0 V=0 C=0
	test_neg_set
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	test_gr_a5a5 0		; Make sure other general regs not disturbed
	test_h_gr32	byte_dst, er1
	test_gr_a5a5 2
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

	;; Now check the result of the move to memory.
	mov.b	@byte_dst, r0l
	cmp.b	r2l, r0l
	beq	.Lnext48
	fail
.Lnext48:
	;; Special case in same register
	;; CCR confirmation omitted
	mov.l	#byte_dst+1, er1
	mov.l	er1, er0
	dec.b	r1l
	mov.b	r0l, @-er0
	mov.b	@byte_dst, r0l
	cmp.b	r1l, r0l
	beq	.Lnext47
	fail
.Lnext47:
	mov.b	#0, r0l
	mov.b	r0l, @byte_dst	; zero it again for the next use.

.if (sim_cpu == h8sx)
mov_b_reg8_to_disp2:
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	set_ccr_zero

	;; mov.b ers, @(dd:2, erd)
	mov.l	#byte_dst-3, er1
	mov.b	r0l, @(3:2, er1)	; Register plus 2-bit disp. operand
;;;	.word	0x0173
;;;	.word	0x6898

	;; test ccr		; H=0 N=1 Z=0 V=0 C=0
	test_neg_set
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	test_gr_a5a5 0		; Make sure other general regs not disturbed
	test_h_gr32	byte_dst-3, er1
	test_gr_a5a5 2
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

	;; Now check the result of the move to memory.
	cmp.b	r2l, @byte_dst
	beq	.Lnext52
	fail
.Lnext52:
	mov.b	#0, @byte_dst	; zero it again for the next use.
.endif

mov_b_reg8_to_disp16:
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	set_ccr_zero

	;; mov.b ers, @(dd:16, erd)
	mov.l	#byte_dst-4, er1
	mov.b	r0l, @(4:16, er1)	; Register plus 16-bit disp. operand
;;;	.word	0x6e98
;;;	.word	0x0004

	;; test ccr		; H=0 N=1 Z=0 V=0 C=0
	test_neg_set
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	test_h_gr32	byte_dst-4, er1
	test_gr_a5a5 0		; Make sure other general regs not disturbed
	test_gr_a5a5 2
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

	;; Now check the result of the move to memory.
	mov.b	@byte_dst, r0l
	cmp.b	r2l, r0l
	beq	.Lnext45
	fail
.Lnext45:
	mov.b	#0, r0l
	mov.b	r0l, @byte_dst	; zero it again for the next use.

mov_b_reg8_to_disp32:
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	set_ccr_zero

	;; mov.b ers, @(dd:32, erd)
	mov.l	#byte_dst-8, er1
	mov.b	r0l, @(8:32, er1)	; Register plus 32-bit disp. operand
;;;	.word	0x7810
;;;	.word	0x6aa8
;;;	.long	8

	;; test ccr		; H=0 N=1 Z=0 V=0 C=0
	test_neg_set
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	test_h_gr32	byte_dst-8, er1
	test_gr_a5a5 0		; Make sure other general regs not disturbed
	test_gr_a5a5 2
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

	;; Now check the result of the move to memory.
	mov.b	@byte_dst, r0l
	cmp.b	r2l, r0l
	beq	.Lnext46
	fail
.Lnext46:
	mov.b	#0, r0l
	mov.b	r0l, @byte_dst	; zero it again for the next use.

.if (sim_cpu == h8sx)
mov_b_reg8_to_indexb16:
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	mov.l	#0xffffff01, er1
	set_ccr_zero
	;; mov.b ers, @(dd:16, rd.b)
	mov.b	r0l, @(byte_dst-1:16, r1.b)	; byte indexed operand

	;; test ccr		; H=0 N=1 Z=0 V=0 C=0
	test_neg_set
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	test_h_gr32	0xffffff01 er1
	test_gr_a5a5 0		; Make sure other general regs not disturbed
	test_gr_a5a5 2
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

	;; Now check the result of the move to memory.
	cmp.b	@byte_dst, r0l
	bne	fail1
	mov.b	#0, @byte_dst	; zero it again for the next use.

mov_b_reg8_to_indexw16:
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	mov.l	#0xffff0002, er1
	set_ccr_zero
	;; mov.b ers, @(dd:16, rd.w)
	mov.b	r0l, @(byte_dst-2:16, r1.w)	; byte indexed operand

	;; test ccr		; H=0 N=1 Z=0 V=0 C=0
	test_neg_set
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	test_h_gr32	0xffff0002 er1
	test_gr_a5a5 0		; Make sure other general regs not disturbed
	test_gr_a5a5 2
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

	;; Now check the result of the move to memory.
	cmp.b	@byte_dst, r0l
	bne	fail1
	mov.b	#0, @byte_dst	; zero it again for the next use.

mov_b_reg8_to_indexl16:
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	mov.l	#0x00000003, er1
	set_ccr_zero
	;; mov.b ers, @(dd:16, erd.l)
	mov.b	r0l, @(byte_dst-3:16, er1.l)	; byte indexed operand

	;; test ccr		; H=0 N=1 Z=0 V=0 C=0
	test_neg_set
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	test_h_gr32	0x00000003 er1
	test_gr_a5a5 0		; Make sure other general regs not disturbed
	test_gr_a5a5 2
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

	;; Now check the result of the move to memory.
	cmp.b	@byte_dst, r0l
	bne	fail1
	mov.b	#0, @byte_dst	; zero it again for the next use.

mov_b_reg8_to_indexb32:
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	mov.l	#0xffffff04 er1
	set_ccr_zero
	;; mov.b ers, @(dd:32, rd.b)
	mov.b	r0l, @(byte_dst-4:32, r1.b)	; byte indexed operand

	;; test ccr		; H=0 N=1 Z=0 V=0 C=0
	test_neg_set
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	test_h_gr32	0xffffff04, er1
	test_gr_a5a5 0		; Make sure other general regs not disturbed
	test_gr_a5a5 2
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

	;; Now check the result of the move to memory.
	cmp.b	@byte_dst, r0l
	bne	fail1
	mov.b	#0, @byte_dst	; zero it again for the next use.

mov_b_reg8_to_indexw32:
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	mov.l	#0xffff0005 er1
	set_ccr_zero
	;; mov.b ers, @(dd:32, rd.w)
	mov.b	r0l, @(byte_dst-5:32, r1.w)	; byte indexed operand

	;; test ccr		; H=0 N=1 Z=0 V=0 C=0
	test_neg_set
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	test_h_gr32	0xffff0005, er1
	test_gr_a5a5 0		; Make sure other general regs not disturbed
	test_gr_a5a5 2
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

	;; Now check the result of the move to memory.
	cmp.b	@byte_dst, r0l
	bne	fail1
	mov.b	#0, @byte_dst	; zero it again for the next use.

mov_b_reg8_to_indexl32:
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	mov.l	#0x00000006 er1
	set_ccr_zero
	;; mov.b ers, @(dd:32, erd.l)
	mov.b	r0l, @(byte_dst-6:32, er1.l)	; byte indexed operand

	;; test ccr		; H=0 N=1 Z=0 V=0 C=0
	test_neg_set
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	test_h_gr32	0x00000006, er1
	test_gr_a5a5 0		; Make sure other general regs not disturbed
	test_gr_a5a5 2
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

	;; Now check the result of the move to memory.
	cmp.b	@byte_dst, r0l
	bne	fail1
	mov.b	#0, @byte_dst	; zero it again for the next use.
.endif

.if (sim_cpu == h8sx)
mov_b_reg8_to_abs8:
	set_grs_a5a5		; Fill all general regs with a fixed pattern

	mov.l	#byte_dst-20, er0
	ldc	er0, sbr
	set_ccr_zero
	;; mov.b ers, @aa:8
	mov.b	r1l, @20:8	; 8-bit address-direct (sbr-relative) operand

	;; test ccr		; H=0 N=1 Z=0 V=0 C=0
	test_neg_set
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	test_h_gr32  byte_dst-20, er0
	test_gr_a5a5 1		; Make sure other general regs not disturbed
	test_gr_a5a5 2
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

	;; Now check the result of the move to memory.
	cmp.b	@byte_dst, r1l
	bne	fail1
	mov.b	#0, @byte_dst	; zero it again for the next use.
.endif

mov_b_reg8_to_abs16:
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	set_ccr_zero

	;; mov.b ers, @aa:16
	mov.b	r0l, @byte_dst:16	; 16-bit address-direct operand
;;;	.word	0x6a88
;;;	.word	@byte_dst

	;; test ccr		; H=0 N=1 Z=0 V=0 C=0
	test_neg_set
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	test_gr_a5a5 0		; Make sure _ALL_ general regs not disturbed
	test_gr_a5a5 1		; (first, because on h8/300 we must use one
	test_gr_a5a5 2		; to examine the destination memory).
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

	;; Now check the result of the move to memory.
	mov.b	@byte_dst, r0l
	cmp.b	r0l, r1l
	beq	.Lnext41
	fail
.Lnext41:
	mov.b	#0, r0l
	mov.b	r0l, @byte_dst	; zero it again for the next use.

mov_b_reg8_to_abs32:
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	set_ccr_zero

	;; mov.b ers, @aa:32
	mov.b	r0l, @byte_dst:32	; 32-bit address-direct operand
;;;	.word	0x6aa8
;;;	.long	@byte_dst

	;; test ccr		; H=0 N=1 Z=0 V=0 C=0
	test_neg_set
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	test_gr_a5a5 0		; Make sure _ALL_ general regs not disturbed
	test_gr_a5a5 1		; (first, because on h8/300 we must use one
	test_gr_a5a5 2		; to examine the destination memory).
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

	;; Now check the result of the move to memory.
	mov.b	@byte_dst, r0l
	cmp.b	r0l, r1l
	beq	.Lnext42
	fail
.Lnext42:
	mov.b	#0, r0l
	mov.b	r0l, @byte_dst	; zero it again for the next use.

	;;
	;; Move byte to register destination.
	;;

mov_b_indirect_to_reg8:
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	set_ccr_zero

	;; mov.b @ers, rd
	mov.l	#byte_src, er1
	mov.b	@er1, r0l	; Register indirect operand
;;;	.word	0x6818

	;; test ccr		; H=0 N=0 Z=0 V=0 C=0
	test_neg_clear
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	test_h_gr32 0xa5a5a577 er0

	test_h_gr32	byte_src, er1
	test_gr_a5a5 2		; Make sure other general regs not disturbed
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

mov_b_postinc_to_reg8:		; post-increment from mem to register
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	set_ccr_zero

	;; mov.b @ers+, rd

	mov.l	#byte_src, er1
	mov.b	@er1+, r0l	; Register post-incr operand
;;;	.word	0x6c18

	;; test ccr		; H=0 N=0 Z=0 V=0 C=0
	test_neg_clear
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	test_h_gr32 0xa5a5a577 er0

	test_h_gr32	byte_src+1, er1
	test_gr_a5a5 2		; Make sure other general regs not disturbed
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

.if (sim_cpu == h8sx)
mov_b_postdec_to_reg8:		; post-decrement from mem to register
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	set_ccr_zero

	;; mov.b @ers-, rd

	mov.l	#byte_src, er1
	mov.b	@er1-, r0l	; Register post-decr operand
;;;	.word	0x0172
;;;	.word	0x6c18

	;; test ccr		; H=0 N=0 Z=0 V=0 C=0
	test_neg_clear
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	test_h_gr32 0xa5a5a577 er0

	test_h_gr32	byte_src-1, er1
	test_gr_a5a5 2		; Make sure other general regs not disturbed
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

mov_b_preinc_to_reg8:		; pre-increment from mem to register
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	set_ccr_zero

	;; mov.b @+ers, rd

	mov.l	#byte_src-1, er1
	mov.b	@+er1, r0l	; Register pre-incr operand
;;;	.word	0x0171
;;;	.word	0x6c18

	;; test ccr		; H=0 N=0 Z=0 V=0 C=0
	test_neg_clear
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	test_h_gr32 0xa5a5a577 er0

	test_h_gr32	byte_src, er1
	test_gr_a5a5 2		; Make sure other general regs not disturbed
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

mov_b_predec_to_reg8:		; pre-decrement from mem to register
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	set_ccr_zero

	;; mov.b @-ers, rd

	mov.l	#byte_src+1, er1
	mov.b	@-er1, r0l	; Register pre-decr operand
;;;	.word	0x0173
;;;	.word	0x6c18

	;; test ccr		; H=0 N=0 Z=0 V=0 C=0
	test_neg_clear
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	test_h_gr32 0xa5a5a577 er0

	test_h_gr32	byte_src, er1
	test_gr_a5a5 2		; Make sure other general regs not disturbed
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7


mov_b_disp2_to_reg8:
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	set_ccr_zero

	;; mov.b @(dd:2, ers), rd
	mov.l	#byte_src-1, er1
	mov.b	@(1:2, er1), r0l	; Register plus 2-bit disp. operand
;;; 	.word	0x0171
;;; 	.word	0x6818

	;; test ccr		; H=0 N=0 Z=0 V=0 C=0
	test_neg_clear
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	test_h_gr32 0xa5a5a577 er0	; mov result:	a5a5 | 7777

	test_h_gr32	byte_src-1, er1
	test_gr_a5a5 2		; Make sure other general regs not disturbed
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7
.endif

mov_b_disp16_to_reg8:
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	set_ccr_zero

	;; mov.b @(dd:16, ers), rd
	mov.l	#byte_src+0x1234, er1
	mov.b	@(-0x1234:16, er1), r0l	; Register plus 16-bit disp. operand
;;;	.word	0x6e18
;;;	.word	-0x1234

	;; test ccr		; H=0 N=0 Z=0 V=0 C=0
	test_neg_clear
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	test_h_gr32 0xa5a5a577 er0	; mov result:	a5a5 | 7777

	test_h_gr32	byte_src+0x1234, er1
	test_gr_a5a5 2		; Make sure other general regs not disturbed
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

mov_b_disp32_to_reg8:
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	set_ccr_zero

	;; mov.b @(dd:32, ers), rd
	mov.l	#byte_src+65536, er1
	mov.b	@(-65536:32, er1), r0l	; Register plus 32-bit disp. operand
;;;	.word	0x7810
;;;	.word	0x6a28
;;;	.long	-65536

	;; test ccr		; H=0 N=0 Z=0 V=0 C=0
	test_neg_clear
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	test_h_gr32 0xa5a5a577 er0	; mov result:	a5a5 | 7777

	test_h_gr32	byte_src+65536, er1
	test_gr_a5a5 2		; Make sure other general regs not disturbed
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

.if (sim_cpu == h8sx)
mov_b_indexb16_to_reg8:
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	mov.l	#0xffffff01, er1
	set_ccr_zero
	;; mov.b @(dd:16, rs.b), rd
	mov.b	@(byte_src-1:16, r1.b), r0l	; indexed byte operand

	;; test ccr		; H=0 N=0 Z=0 V=0 C=0
	test_neg_clear
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	test_h_gr32 0xa5a5a577 er0	; mov result:	a5a5a5 | 77

	test_h_gr32  0xffffff01, er1
	test_gr_a5a5 2		; Make sure other general regs not disturbed
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

mov_b_indexw16_to_reg8:
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	mov.l	#0xffff0002, er1
	set_ccr_zero
	;; mov.b @(dd:16, rs.w), rd
	mov.b	@(byte_src-2:16, r1.w), r0l	; indexed byte operand

	;; test ccr		; H=0 N=0 Z=0 V=0 C=0
	test_neg_clear
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	test_h_gr32 0xa5a5a577 er0	; mov result:	a5a5a5 | 77

	test_h_gr32  0xffff0002, er1
	test_gr_a5a5 2		; Make sure other general regs not disturbed
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

mov_b_indexl16_to_reg8:
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	mov.l	#0x00000003, er1
	set_ccr_zero
	;; mov.b @(dd:16, ers.l), rd
	mov.b	@(byte_src-3:16, er1.l), r0l	; indexed byte operand

	;; test ccr		; H=0 N=0 Z=0 V=0 C=0
	test_neg_clear
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	test_h_gr32 0xa5a5a577 er0	; mov result:	a5a5a5 | 77

	test_h_gr32  0x00000003, er1
	test_gr_a5a5 2		; Make sure other general regs not disturbed
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

mov_b_indexb32_to_reg8:
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	mov.l	#0xffffff04, er1
	set_ccr_zero
	;; mov.b @(dd:32, rs.b), rd
	mov.b	@(byte_src-4:32, r1.b), r0l	; indexed byte operand

	;; test ccr		; H=0 N=0 Z=0 V=0 C=0
	test_neg_clear
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	test_h_gr32 0xa5a5a577 er0	; mov result:	a5a5 | 7777

	test_h_gr32  0xffffff04 er1
	test_gr_a5a5 2		; Make sure other general regs not disturbed
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

mov_b_indexw32_to_reg8:
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	mov.l	#0xffff0005, er1
	set_ccr_zero
	;; mov.b @(dd:32, rs.w), rd
	mov.b	@(byte_src-5:32, r1.w), r0l	; indexed byte operand

	;; test ccr		; H=0 N=0 Z=0 V=0 C=0
	test_neg_clear
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	test_h_gr32 0xa5a5a577 er0	; mov result:	a5a5 | 7777

	test_h_gr32  0xffff0005 er1
	test_gr_a5a5 2		; Make sure other general regs not disturbed
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

mov_b_indexl32_to_reg8:
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	mov.l	#0x00000006, er1
	set_ccr_zero
	;; mov.b @(dd:32, ers.l), rd
	mov.b	@(byte_src-6:32, er1.l), r0l	; indexed byte operand

	;; test ccr		; H=0 N=0 Z=0 V=0 C=0
	test_neg_clear
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	test_h_gr32 0xa5a5a577 er0	; mov result:	a5a5 | 7777

	test_h_gr32  0x00000006 er1
	test_gr_a5a5 2		; Make sure other general regs not disturbed
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

.endif

.if (sim_cpu == h8sx)
mov_b_abs8_to_reg8:
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	mov.l	#byte_src-255, er1
	ldc	er1, sbr
	set_ccr_zero
	;; mov.b @aa:8, rd
	mov.b	@0xff:8, r0l	; 8-bit (sbr relative) address-direct operand

	;; test ccr		; H=0 N=0 Z=0 V=0 C=0
	test_neg_clear
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	test_h_gr32 0xa5a5a577 er0

	test_h_gr32  byte_src-255, er1
	test_gr_a5a5 2		; Make sure other general regs not disturbed
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7
.endif

mov_b_abs16_to_reg8:
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	set_ccr_zero

	;; mov.b @aa:16, rd
	mov.b	@byte_src:16, r0l	; 16-bit address-direct operand
;;;	.word	0x6a08
;;;	.word	@byte_src

	;; test ccr		; H=0 N=0 Z=0 V=0 C=0
	test_neg_clear
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	test_h_gr32 0xa5a5a577 er0

	test_gr_a5a5 1		; Make sure other general regs not disturbed
	test_gr_a5a5 2
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

mov_b_abs32_to_reg8:
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	set_ccr_zero

	;; mov.b @aa:32, rd
	mov.b	@byte_src:32, r0l	; 32-bit address-direct operand
;;;	.word	0x6a28
;;;	.long	@byte_src

	;; test ccr		; H=0 N=0 Z=0 V=0 C=0
	test_neg_clear
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	test_h_gr32 0xa5a5a577 er0

	test_gr_a5a5 1		; Make sure other general regs not disturbed
	test_gr_a5a5 2
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

.if (sim_cpu == h8sx)

	;;
	;; Move byte from memory to memory
	;;

mov_b_indirect_to_indirect:	; reg indirect, memory to memory
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	set_ccr_zero

	;; mov.b @ers, @erd

	mov.l	#byte_src, er1
	mov.l	#byte_dst, er0
	mov.b	@er1, @er0
;;;	.word	0x0178
;;;	.word	0x0100

	;; test ccr		; H=0 N=0 Z=0 V=0 C=0
	test_neg_clear
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	;; Verify the affected registers.

	test_h_gr32  byte_dst er0
	test_h_gr32  byte_src er1
	test_gr_a5a5 2		; Make sure other general regs not disturbed
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

	;; Now check the result of the move to memory.
	cmp.b	@byte_src, @byte_dst
	beq	.Lnext56
	fail
.Lnext56:
	;; Now clear the destination location, and verify that.
	mov.b	#0, @byte_dst
	cmp.b	@byte_src, @byte_dst
	bne	.Lnext57
	fail
.Lnext57:			; OK, pass on.

mov_b_postinc_to_postinc:	; reg post-increment, memory to memory
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	set_ccr_zero

	;; mov.b @ers+, @erd+

	mov.l	#byte_src, er1
	mov.l	#byte_dst, er0
	mov.b	@er1+, @er0+
;;;	.word	0x0178
;;;	.word	0x8180

	;; test ccr		; H=0 N=0 Z=0 V=0 C=0
	test_neg_clear
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	;; Verify the affected registers.

	test_h_gr32  byte_dst+1 er0
	test_h_gr32  byte_src+1 er1
	test_gr_a5a5 2		; Make sure other general regs not disturbed
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

	;; Now check the result of the move to memory.
	cmp.b	@byte_src, @byte_dst
	beq	.Lnext65
	fail
.Lnext65:
	;; Now clear the destination location, and verify that.
	mov.b	#0, @byte_dst
	cmp.b	@byte_src, @byte_dst
	bne	.Lnext66
	fail
.Lnext66:			; OK, pass on.
	;; special case same register
	mov.l	#byte_src, er0
	mov.b	@er0+, @er0+	; copying byte_src to byte_dst
	test_h_gr32  byte_src+2 er0
	cmp.b	@byte_src, @byte_dst
	beq	.Lnext67
	fail
.Lnext67:
	;; Now clear the destination location, and verify that.
	mov.b	#0, @byte_dst
	cmp.b	@byte_src, @byte_dst
	bne	.Lnext68
	fail
.Lnext68:

mov_b_postdec_to_postdec:	; reg post-decrement, memory to memory
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	set_ccr_zero

	;; mov.b @ers-, @erd-

	mov.l	#byte_src, er1
	mov.l	#byte_dst, er0
	mov.b	@er1-, @er0-
;;;	.word	0x0178
;;;	.word	0xa1a0

	;; test ccr		; H=0 N=0 Z=0 V=0 C=0
	test_neg_clear
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	;; Verify the affected registers.

	test_h_gr32  byte_dst-1 er0
	test_h_gr32  byte_src-1 er1
	test_gr_a5a5 2		; Make sure other general regs not disturbed
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

	;; Now check the result of the move to memory.
	cmp.b	@byte_src, @byte_dst
	beq	.Lnext75
	fail
.Lnext75:
	;; Now clear the destination location, and verify that.
	mov.b	#0, @byte_dst
	cmp.b	@byte_src, @byte_dst
	bne	.Lnext76
	fail
.Lnext76:			; OK, pass on.
	;; special case same register
	mov.l	#byte_src, er0
	mov.b	@er0-, @er0-	; copying byte_src to byte_dst_dec
	test_h_gr32  byte_src-2 er0
	cmp.b	@byte_src, @byte_dst_dec
	beq	.Lnext77
	fail
.Lnext77:
	;; Now clear the destination location, and verify that.
	mov.b	#0, @byte_dst_dec
	cmp.b	@byte_src, @byte_dst_dec
	bne	.Lnext78
	fail
.Lnext78:

mov_b_preinc_to_preinc:		; reg pre-increment, memory to memory
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	set_ccr_zero

	;; mov.b @+ers, @+erd

	mov.l	#byte_src-1, er1
	mov.l	#byte_dst-1, er0
	mov.b	@+er1, @+er0
;;;	.word	0x0178
;;;	.word	0x9190

	;; test ccr		; H=0 N=0 Z=0 V=0 C=0
	test_neg_clear
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	;; Verify the affected registers.

	test_h_gr32  byte_dst er0
	test_h_gr32  byte_src er1
	test_gr_a5a5 2		; Make sure other general regs not disturbed
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

	;; Now check the result of the move to memory.
	cmp.b	@byte_src, @byte_dst
	beq	.Lnext85
	fail
.Lnext85:
	;; Now clear the destination location, and verify that.
	mov.b	#0, @byte_dst
	cmp.b	@byte_src, @byte_dst
	bne	.Lnext86
	fail
.Lnext86:				; OK, pass on.
	;; special case same register
	mov.l	#byte_src-1, er0
	mov.b	@+er0, @+er0	; copying byte_src to byte_dst
	test_h_gr32  byte_src+1 er0
	cmp.b	@byte_src, @byte_dst
	beq	.Lnext87
	fail
.Lnext87:
	;; Now clear the destination location, and verify that.
	mov.b	#0, @byte_dst
	cmp.b	@byte_src, @byte_dst
	bne	.Lnext88
	fail
.Lnext88:

mov_b_predec_to_predec:		; reg pre-decrement, memory to memory
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	set_ccr_zero

	;; mov.b @-ers, @-erd

	mov.l	#byte_src+1, er1
	mov.l	#byte_dst+1, er0
	mov.b	@-er1, @-er0
;;;	.word	0x0178
;;;	.word	0xb1b0

	;; test ccr		; H=0 N=0 Z=0 V=0 C=0
	test_neg_clear
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	;; Verify the affected registers.

	test_h_gr32  byte_dst er0
	test_h_gr32  byte_src er1
	test_gr_a5a5 2		; Make sure other general regs not disturbed
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

	;; Now check the result of the move to memory.
	cmp.b	@byte_src, @byte_dst
	beq	.Lnext95
	fail
.Lnext95:
	;; Now clear the destination location, and verify that.
	mov.b	#0, @byte_dst
	cmp.b	@byte_src, @byte_dst
	bne	.Lnext96
	fail
.Lnext96:			; OK, pass on.
	;; special case same register
	mov.l	#byte_src+1, er0
	mov.b	@-er0, @-er0	; copying byte_src to byte_dst_dec
	test_h_gr32  byte_src-1 er0
	cmp.b	@byte_src, @byte_dst_dec
	beq	.Lnext97
	fail
.Lnext97:
	;; Now clear the destination location, and verify that.
	mov.b	#0, @byte_dst_dec
	cmp.b	@byte_src, @byte_dst_dec
	bne	.Lnext98
	fail
.Lnext98:

mov_b_disp2_to_disp2:		; reg 2-bit disp, memory to memory
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	set_ccr_zero

	;; mov.b @(dd:2, ers), @(dd:2, erd)

	mov.l	#byte_src-1, er1
	mov.l	#byte_dst-2, er0
	mov.b	@(1:2, er1), @(2:2, er0)
;;; 	.word	0x0178
;;; 	.word	0x1120

	;; test ccr		; H=0 N=0 Z=0 V=0 C=0
	test_neg_clear
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	;; Verify the affected registers.

	test_h_gr32  byte_dst-2 er0
	test_h_gr32  byte_src-1 er1
	test_gr_a5a5 2		; Make sure other general regs not disturbed
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

	;; Now check the result of the move to memory.
	cmp.b	@byte_src, @byte_dst
	beq	.Lnext105
	fail
.Lnext105:
	;; Now clear the destination location, and verify that.
	mov.b	#0, @byte_dst
	cmp.b	@byte_src, @byte_dst
	bne	.Lnext106
	fail
.Lnext106:			; OK, pass on.

mov_b_disp16_to_disp16:		; reg 16-bit disp, memory to memory
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	set_ccr_zero

	;; mov.b @(dd:16, ers), @(dd:16, erd)

	mov.l	#byte_src-1, er1
	mov.l	#byte_dst-2, er0
	mov.b	@(1:16, er1), @(2:16, er0)
;;; 	.word	0x0178
;;; 	.word	0xc1c0
;;; 	.word	0x0001
;;; 	.word	0x0002

	;; test ccr		; H=0 N=0 Z=0 V=0 C=0
	test_neg_clear
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	;; Verify the affected registers.

	test_h_gr32  byte_dst-2 er0
	test_h_gr32  byte_src-1 er1
	test_gr_a5a5 2		; Make sure other general regs not disturbed
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

	;; Now check the result of the move to memory.
	cmp.b	@byte_src, @byte_dst
	beq	.Lnext115
	fail
.Lnext115:
	;; Now clear the destination location, and verify that.
	mov.b	#0, @byte_dst
	cmp.b	@byte_src, @byte_dst
	bne	.Lnext116
	fail
.Lnext116:			; OK, pass on.

mov_b_disp32_to_disp32:		; reg 32-bit disp, memory to memory
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	set_ccr_zero

	;; mov.b @(dd:32, ers), @(dd:32, erd)

	mov.l	#byte_src-1, er1
	mov.l	#byte_dst-2, er0
	mov.b	@(1:32, er1), @(2:32, er0)
;;; 	.word	0x0178
;;; 	.word	0xc9c8
;;;	.long	1
;;;	.long	2

	;; test ccr		; H=0 N=0 Z=0 V=0 C=0
	test_neg_clear
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	;; Verify the affected registers.

	test_h_gr32  byte_dst-2 er0
	test_h_gr32  byte_src-1 er1
	test_gr_a5a5 2		; Make sure other general regs not disturbed
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

	;; Now check the result of the move to memory.
	cmp.b	@byte_src, @byte_dst
	beq	.Lnext125
	fail
.Lnext125:
	;; Now clear the destination location, and verify that.
	mov.b	#0, @byte_dst
	cmp.b	@byte_src, @byte_dst
	bne	.Lnext126
	fail
.Lnext126:				; OK, pass on.

mov_b_indexb16_to_indexb16:	; reg 16-bit indexed, memory to memory
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	mov.l	#0xffffff01, er1
	mov.l	#0xffffff02, er0
	;; mov.b @(dd:16, rs.b), @(dd:16, rd.b)
	set_ccr_zero
	mov.b	@(byte_src-1:16, r1.b), @(byte_dst-2:16, r0.b)

	;; test ccr		; H=0 N=0 Z=0 V=0 C=0
	test_neg_clear
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	;; Verify the affected registers.

	test_h_gr32  0xffffff02 er0
	test_h_gr32  0xffffff01 er1
	test_gr_a5a5 2		; Make sure other general regs not disturbed
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

	;; Now check the result of the move to memory.
	cmp.b	@byte_src, @byte_dst
	bne	fail1
	;; Now clear the destination location, and verify that.
	mov.b	#0, @byte_dst
	cmp.b	@byte_src, @byte_dst
	beq	fail1

mov_b_indexw16_to_indewb16:	; reg 16-bit indexed, memory to memory
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	mov.l	#0xffff0003, er1
	mov.l	#0xffff0004, er0
	;; mov.b @(dd:16, rs.w), @(dd:16, rd.w)
	set_ccr_zero
	mov.b	@(byte_src-3:16, r1.w), @(byte_dst-4:16, r0.w)

	;; test ccr		; H=0 N=0 Z=0 V=0 C=0
	test_neg_clear
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	;; Verify the affected registers.

	test_h_gr32  0xffff0004 er0
	test_h_gr32  0xffff0003 er1
	test_gr_a5a5 2		; Make sure other general regs not disturbed
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

	;; Now check the result of the move to memory.
	cmp.b	@byte_src, @byte_dst
	bne	fail1
	;; Now clear the destination location, and verify that.
	mov.b	#0, @byte_dst
	cmp.b	@byte_src, @byte_dst
	beq	fail1

mov_b_indexl16_to_indexl16:	; reg 16-bit indexed, memory to memory
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	mov.l	#0x00000005, er1
	mov.l	#0x00000006, er0
	;; mov.b @(dd:16, ers.l), @(dd:16, erd.l)
	set_ccr_zero
	mov.b	@(byte_src-5:16, er1.l), @(byte_dst-6:16, er0.l)

	;; test ccr		; H=0 N=0 Z=0 V=0 C=0
	test_neg_clear
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	;; Verify the affected registers.

	test_h_gr32  0x00000006 er0
	test_h_gr32  0x00000005 er1
	test_gr_a5a5 2		; Make sure other general regs not disturbed
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

	;; Now check the result of the move to memory.
	cmp.b	@byte_src, @byte_dst
	bne	fail1
	;; Now clear the destination location, and verify that.
	mov.b	#0, @byte_dst
	cmp.b	@byte_src, @byte_dst
	beq	fail1

mov_b_indexb32_to_indexb32:	; reg 32-bit indexed, memory to memory
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	mov.l	#0xffffff01, er1
	mov.l	#0xffffff02, er0
	set_ccr_zero
	;; mov.b @(dd:32, rs.b), @(dd:32, rd.b)
	mov.b	@(byte_src-1:32, r1.b), @(byte_dst-2:32, r0.b)

	;; test ccr		; H=0 N=0 Z=0 V=0 C=0
	test_neg_clear
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	;; Verify the affected registers.

	test_h_gr32  0xffffff02 er0
	test_h_gr32  0xffffff01 er1
	test_gr_a5a5 2		; Make sure other general regs not disturbed
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

	;; Now check the result of the move to memory.
	cmp.b	@byte_src, @byte_dst
	bne	fail1
	;; Now clear the destination location, and verify that.
	mov.b	#0, @byte_dst
	cmp.b	@byte_src, @byte_dst
	beq	fail1

mov_b_indexw32_to_indexw32:	; reg 32-bit indexed, memory to memory
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	mov.l	#0xffff0003, er1
	mov.l	#0xffff0004, er0
	set_ccr_zero
	;; mov.b @(dd:32, rs.w), @(dd:32, rd.w)
	mov.b	@(byte_src-3:32, r1.w), @(byte_dst-4:32, r0.w)

	;; test ccr		; H=0 N=0 Z=0 V=0 C=0
	test_neg_clear
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	;; Verify the affected registers.

	test_h_gr32  0xffff0004 er0
	test_h_gr32  0xffff0003 er1
	test_gr_a5a5 2		; Make sure other general regs not disturbed
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

	;; Now check the result of the move to memory.
	cmp.b	@byte_src, @byte_dst
	bne	fail1
	;; Now clear the destination location, and verify that.
	mov.b	#0, @byte_dst
	cmp.b	@byte_src, @byte_dst
	beq	fail1

mov_b_indexl32_to_indexl32:	; reg 32-bit indexed, memory to memory
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	mov.l	#0x00000005, er1
	mov.l	#0x00000006, er0
	set_ccr_zero
	;; mov.b @(dd:32, rs.w), @(dd:32, rd.w)
	mov.b	@(byte_src-5:32, er1.l), @(byte_dst-6:32, er0.l)

	;; test ccr		; H=0 N=0 Z=0 V=0 C=0
	test_neg_clear
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	;; Verify the affected registers.

	test_h_gr32  0x00000006 er0
	test_h_gr32  0x00000005 er1
	test_gr_a5a5 2		; Make sure other general regs not disturbed
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

	;; Now check the result of the move to memory.
	cmp.b	@byte_src, @byte_dst
	bne	fail1
	;; Now clear the destination location, and verify that.
	mov.b	#0, @byte_dst
	cmp.b	@byte_src, @byte_dst
	beq	fail1

mov_b_abs16_to_abs16:		; 16-bit absolute addr, memory to memory
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	set_ccr_zero

	;; mov.b @aa:16, @aa:16

	mov.b	@byte_src:16, @byte_dst:16
;;; 	.word	0x0178
;;; 	.word	0x4040
;;;	.word	@byte_src
;;;	.word	@byte_dst

	;; test ccr		; H=0 N=0 Z=0 V=0 C=0
	test_neg_clear
	test_zero_clear
	test_ovf_clear
	test_carry_clear


	test_gr_a5a5 0		; Make sure *NO* general registers are changed
	test_gr_a5a5 1
	test_gr_a5a5 2
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

	;; Now check the result of the move to memory.
	cmp.b	@byte_src, @byte_dst
	beq	.Lnext135
	fail
.Lnext135:
	;; Now clear the destination location, and verify that.
	mov.b	#0, @byte_dst
	cmp.b	@byte_src, @byte_dst
	bne	.Lnext136
	fail
.Lnext136:				; OK, pass on.

mov_b_abs32_to_abs32:		; 32-bit absolute addr, memory to memory
	set_grs_a5a5		; Fill all general regs with a fixed pattern
	set_ccr_zero

	;; mov.b @aa:32, @aa:32

	mov.b	@byte_src:32, @byte_dst:32
;;; 	.word	0x0178
;;; 	.word	0x4848
;;;	.long	@byte_src
;;;	.long	@byte_dst

	;; test ccr		; H=0 N=0 Z=0 V=0 C=0
	test_neg_clear
	test_zero_clear
	test_ovf_clear
	test_carry_clear

	test_gr_a5a5 0		; Make sure *NO* general registers are changed
	test_gr_a5a5 1
	test_gr_a5a5 2
	test_gr_a5a5 3
	test_gr_a5a5 4
	test_gr_a5a5 5
	test_gr_a5a5 6
	test_gr_a5a5 7

	;; Now check the result of the move to memory.
	cmp.b	@byte_src, @byte_dst
	beq	.Lnext145
	fail
.Lnext145:
	;; Now clear the destination location, and verify that.
	mov.b	#0, @byte_dst
	cmp.b	@byte_src, @byte_dst
	bne	.Lnext146
	fail
.Lnext146:				; OK, pass on.


.endif

	pass

	exit 0

fail1:
	fail