mirror of
https://github.com/sethm/symon.git
synced 2024-08-18 21:29:21 +00:00
11308 lines
563 KiB
Plaintext
Executable File
11308 lines
563 KiB
Plaintext
Executable File
AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 1
|
||
------------------------------------------------ 65C02_extended_opcodes_test.a65c ------------------------------------------------
|
||
|
||
2748 lines read, no errors in pass 1.
|
||
;
|
||
; 6 5 C 0 2 E X T E N D E D O P C O D E S T E S T
|
||
;
|
||
; Copyright (C) 2013 Klaus Dormann
|
||
;
|
||
; This program is free software: you can redistribute it and/or modify
|
||
; it under the terms of the GNU General Public License as published by
|
||
; the Free Software Foundation, either version 3 of the License, or
|
||
; (at your option) any later version.
|
||
;
|
||
; This program is distributed in the hope that it will be useful,
|
||
; but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
; GNU General Public License for more details.
|
||
;
|
||
; You should have received a copy of the GNU General Public License
|
||
; along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||
|
||
|
||
; This program is designed to test all additional 65C02 opcodes, addressing
|
||
; modes and functionality not available in the NMOS version of the 6502.
|
||
; The 6502_functional_test is a prerequisite to this test.
|
||
; NMI, IRQ, BRK, STP & WAI are covered in the 6502_interrupt_test.
|
||
;
|
||
; version 16-aug-2013
|
||
; edited to provide a pre-configured bin file loadable at $0000 for full 64k
|
||
; contact info at http://2m5.de or email K@2m5.de
|
||
;
|
||
; assembled with AS65 from http://www.kingswood-consulting.co.uk/assemblers/
|
||
; command line switches: -l -m -s2 -w -x -h0
|
||
; | | | | | no page headers in listing
|
||
; | | | | 65C02 extensions
|
||
; | | | wide listing (133 char/col)
|
||
; | | write intel hex file instead of binary
|
||
; | expand macros in listing
|
||
; generate pass2 listing
|
||
;
|
||
; No IO - should be run from a monitor with access to registers.
|
||
; To run load intel hex image with a load command, than alter PC to 400 hex
|
||
; (code_segment) and enter a go command.
|
||
; Loop on program counter determines error or successful completion of test.
|
||
; Check listing for relevant traps (jump/branch *).
|
||
; Please note that in early tests some instructions will have to be used before
|
||
; they are actually tested!
|
||
;
|
||
; RESET, NMI or IRQ should not occur and will be trapped if vectors are enabled.
|
||
; Tests documented behavior of the original 65C02 only!
|
||
; Decimal ops will only be tested with valid BCD operands and the V flag will
|
||
; be ignored as it is absolutely useless in decimal mode.
|
||
;
|
||
; Debugging hints:
|
||
; Most of the code is written sequentially. if you hit a trap, check the
|
||
; immediately preceeding code for the instruction to be tested. Results are
|
||
; tested first, flags are checked second by pushing them onto the stack and
|
||
; pulling them to the accumulator after the result was checked. The "real"
|
||
; flags are no longer valid for the tested instruction at this time!
|
||
; If the tested instruction was indexed, the relevant index (X or Y) must
|
||
; also be checked. Opposed to the flags, X and Y registers are still valid.
|
||
;
|
||
; versions:
|
||
; 19-jul-2013 1st version distributed for testing
|
||
; 23-jul-2013 fixed BRA out of range due to larger trap macros
|
||
; added RAM integrity check
|
||
; 16-aug-2013 added error report to standard output option
|
||
|
||
|
||
; C O N F I G U R A T I O N
|
||
|
||
;ROM_vectors writable (0=no, 1=yes)
|
||
;if ROM vectors can not be used interrupts will not be trapped
|
||
;as a consequence BRK can not be tested but will be emulated to test RTI
|
||
0001 = ROM_vectors = 1
|
||
|
||
;load_data_direct (0=move from code segment, 1=load directly)
|
||
;loading directly is preferred but may not be supported by your platform
|
||
;0 produces only consecutive object code, 1 is not suitable for a binary image
|
||
0001 = load_data_direct = 1
|
||
|
||
;I_flag behavior (0=force enabled, 1=force disabled, 2=prohibit change, 3=allow
|
||
;change) 2 requires extra code and is not recommended.
|
||
0003 = I_flag = 3
|
||
|
||
;configure memory - try to stay away from memory used by the system
|
||
;zero_page memory start address, $4e (78) consecutive Bytes required
|
||
; add 2 if I_flag = 2
|
||
000a = zero_page = $a
|
||
|
||
;data_segment memory start address, $5D (93) consecutive Bytes required
|
||
; + 12 Bytes at data_segment + $f9 (JMP indirect page cross test)
|
||
0200 = data_segment = $200
|
||
if (data_segment & $ff) != 0
|
||
ERROR ERROR ERROR low byte of data_segment MUST be $00 !!
|
||
endif
|
||
|
||
;code_segment memory start address, 10kB of consecutive space required
|
||
; add 1 kB if I_flag = 2
|
||
;parts of the code are self modifying and must reside in RAM
|
||
0400 = code_segment = $400
|
||
|
||
;added WDC only opcodes WAI & STP (0=test as NOPs, >0=no test)
|
||
0001 = wdc_op = 1
|
||
|
||
;added Rockwell & WDC opcodes BBR, BBS, RMB & SMB
|
||
;(0=test as NOPs, 1=full test, >1=no test)
|
||
0001 = rkwl_wdc_op = 1
|
||
|
||
;report errors through I/O channel (0=use standard self trap loops, 1=include
|
||
;report.i65 as I/O channel, add 3 kB)
|
||
0000 = report = 0
|
||
|
||
;RAM integrity test option. Checks for undesired RAM writes.
|
||
;set lowest non RAM or RAM mirror address page (-1=disable, 0=64k, $40=16k)
|
||
;leave disabled if a monitor, OS or background interrupt is allowed to alter RAM
|
||
ffff = ram_top = -1
|
||
|
||
noopt ;do not take shortcuts
|
||
|
||
;macros for error & success traps to allow user modification
|
||
;example:
|
||
;trap macro
|
||
; jsr my_error_handler
|
||
; endm
|
||
;trap_eq macro
|
||
; bne skip\?
|
||
; trap ;failed equal (zero)
|
||
;skip\?
|
||
; endm
|
||
;
|
||
; my_error_handler should pop the calling address from the stack and report it.
|
||
; putting larger portions of code (more than 3 bytes) inside the trap macro
|
||
; may lead to branch range problems for some tests.
|
||
if report = 0
|
||
trap macro
|
||
jmp * ;failed anyway
|
||
endm
|
||
trap_eq macro
|
||
beq * ;failed equal (zero)
|
||
endm
|
||
trap_ne macro
|
||
bne * ;failed not equal (non zero)
|
||
endm
|
||
trap_cs macro
|
||
bcs * ;failed carry set
|
||
endm
|
||
trap_cc macro
|
||
bcc * ;failed carry clear
|
||
endm
|
||
trap_mi macro
|
||
bmi * ;failed minus (bit 7 set)
|
||
endm
|
||
trap_pl macro
|
||
bpl * ;failed plus (bit 7 clear)
|
||
endm
|
||
trap_vs macro
|
||
bvs * ;failed overflow set
|
||
endm
|
||
trap_vc macro
|
||
bvc * ;failed overflow clear
|
||
endm
|
||
; please observe that during the test the stack gets invalidated
|
||
; therefore a RTS inside the success macro is not possible
|
||
success macro
|
||
jmp * ;test passed, no errors
|
||
endm
|
||
endif
|
||
if report = 1
|
||
trap macro
|
||
jsr report_error
|
||
endm
|
||
trap_eq macro
|
||
bne skip\?
|
||
trap ;failed equal (zero)
|
||
skip\?
|
||
endm
|
||
trap_ne macro
|
||
beq skip\?
|
||
trap ;failed not equal (non zero)
|
||
skip\?
|
||
endm
|
||
trap_cs macro
|
||
bcc skip\?
|
||
trap ;failed carry set
|
||
skip\?
|
||
endm
|
||
trap_cc macro
|
||
bcs skip\?
|
||
trap ;failed carry clear
|
||
skip\?
|
||
endm
|
||
trap_mi macro
|
||
bpl skip\?
|
||
trap ;failed minus (bit 7 set)
|
||
skip\?
|
||
endm
|
||
trap_pl macro
|
||
bmi skip\?
|
||
trap ;failed plus (bit 7 clear)
|
||
skip\?
|
||
endm
|
||
trap_vs macro
|
||
bvc skip\?
|
||
trap ;failed overflow set
|
||
skip\?
|
||
endm
|
||
trap_vc macro
|
||
bvs skip\?
|
||
trap ;failed overflow clear
|
||
skip\?
|
||
endm
|
||
; please observe that during the test the stack gets invalidated
|
||
; therefore a RTS inside the success macro is not possible
|
||
success macro
|
||
jsr report_success
|
||
endm
|
||
endif
|
||
|
||
|
||
0001 = carry equ %00000001 ;flag bits in status
|
||
0002 = zero equ %00000010
|
||
0004 = intdis equ %00000100
|
||
0008 = decmode equ %00001000
|
||
0010 = break equ %00010000
|
||
0020 = reserv equ %00100000
|
||
0040 = overfl equ %01000000
|
||
0080 = minus equ %10000000
|
||
|
||
0001 = fc equ carry
|
||
0002 = fz equ zero
|
||
0003 = fzc equ carry+zero
|
||
0040 = fv equ overfl
|
||
0042 = fvz equ overfl+zero
|
||
0080 = fn equ minus
|
||
0081 = fnc equ minus+carry
|
||
0082 = fnz equ minus+zero
|
||
0083 = fnzc equ minus+zero+carry
|
||
00c0 = fnv equ minus+overfl
|
||
|
||
0030 = fao equ break+reserv ;bits always on after PHP, BRK
|
||
0034 = fai equ fao+intdis ;+ forced interrupt disable
|
||
00ff = m8 equ $ff ;8 bit mask
|
||
00fb = m8i equ $ff&~intdis ;8 bit mask - interrupt disable
|
||
|
||
;macros to allow masking of status bits.
|
||
;masking of interrupt enable/disable on load and compare
|
||
;masking of always on bits after PHP or BRK (unused & break) on compare
|
||
if I_flag = 0
|
||
load_flag macro
|
||
lda #\1&m8i ;force enable interrupts (mask I)
|
||
endm
|
||
cmp_flag macro
|
||
cmp #(\1|fao)&m8i ;I_flag is always enabled + always on bits
|
||
endm
|
||
eor_flag macro
|
||
eor #(\1&m8i|fao) ;mask I, invert expected flags + always on bits
|
||
endm
|
||
endif
|
||
if I_flag = 1
|
||
load_flag macro
|
||
lda #\1|intdis ;force disable interrupts
|
||
endm
|
||
cmp_flag macro
|
||
cmp #(\1|fai)&m8 ;I_flag is always disabled + always on bits
|
||
endm
|
||
eor_flag macro
|
||
eor #(\1|fai) ;invert expected flags + always on bits + I
|
||
endm
|
||
endif
|
||
if I_flag = 2
|
||
load_flag macro
|
||
lda #\1
|
||
ora flag_I_on ;restore I-flag
|
||
and flag_I_off
|
||
endm
|
||
cmp_flag macro
|
||
eor flag_I_on ;I_flag is never changed
|
||
cmp #(\1|fao)&m8i ;expected flags + always on bits, mask I
|
||
endm
|
||
eor_flag macro
|
||
eor flag_I_on ;I_flag is never changed
|
||
eor #(\1&m8i|fao) ;mask I, invert expected flags + always on bits
|
||
endm
|
||
endif
|
||
if I_flag = 3
|
||
load_flag macro
|
||
lda #\1 ;allow test to change I-flag (no mask)
|
||
endm
|
||
cmp_flag macro
|
||
cmp #(\1|fao)&m8 ;expected flags + always on bits
|
||
endm
|
||
eor_flag macro
|
||
eor #\1|fao ;invert expected flags + always on bits
|
||
endm
|
||
endif
|
||
|
||
;macros to set (register|memory|zeropage) & status
|
||
set_stat macro ;setting flags in the processor status register
|
||
load_flag \1
|
||
pha ;use stack to load status
|
||
plp
|
||
endm
|
||
|
||
set_a macro ;precharging accu & status
|
||
load_flag \2
|
||
pha ;use stack to load status
|
||
lda #\1 ;precharge accu
|
||
plp
|
||
endm
|
||
|
||
set_x macro ;precharging index & status
|
||
load_flag \2
|
||
pha ;use stack to load status
|
||
ldx #\1 ;precharge index x
|
||
plp
|
||
endm
|
||
|
||
set_y macro ;precharging index & status
|
||
load_flag \2
|
||
pha ;use stack to load status
|
||
ldy #\1 ;precharge index y
|
||
plp
|
||
endm
|
||
|
||
set_ax macro ;precharging indexed accu & immediate status
|
||
load_flag \2
|
||
pha ;use stack to load status
|
||
lda \1,x ;precharge accu
|
||
plp
|
||
endm
|
||
|
||
set_ay macro ;precharging indexed accu & immediate status
|
||
load_flag \2
|
||
pha ;use stack to load status
|
||
lda \1,y ;precharge accu
|
||
plp
|
||
endm
|
||
|
||
set_z macro ;precharging indexed zp & immediate status
|
||
load_flag \2
|
||
pha ;use stack to load status
|
||
lda \1,x ;load to zeropage
|
||
sta zpt
|
||
plp
|
||
endm
|
||
|
||
set_zx macro ;precharging zp,x & immediate status
|
||
load_flag \2
|
||
pha ;use stack to load status
|
||
lda \1,x ;load to indexed zeropage
|
||
sta zpt,x
|
||
plp
|
||
endm
|
||
|
||
set_abs macro ;precharging indexed memory & immediate status
|
||
load_flag \2
|
||
pha ;use stack to load status
|
||
lda \1,x ;load to memory
|
||
sta abst
|
||
plp
|
||
endm
|
||
|
||
set_absx macro ;precharging abs,x & immediate status
|
||
load_flag \2
|
||
pha ;use stack to load status
|
||
lda \1,x ;load to indexed memory
|
||
sta abst,x
|
||
plp
|
||
endm
|
||
|
||
;macros to test (register|memory|zeropage) & status & (mask)
|
||
tst_stat macro ;testing flags in the processor status register
|
||
php ;save status
|
||
pla ;use stack to retrieve status
|
||
pha
|
||
cmp_flag \1
|
||
trap_ne
|
||
plp ;restore status
|
||
endm
|
||
|
||
tst_a macro ;testing result in accu & flags
|
||
php ;save flags
|
||
cmp #\1 ;test result
|
||
trap_ne
|
||
pla ;load status
|
||
pha
|
||
cmp_flag \2
|
||
trap_ne
|
||
plp ;restore status
|
||
endm
|
||
|
||
tst_as macro ;testing result in accu & flags, save accu
|
||
pha
|
||
php ;save flags
|
||
cmp #\1 ;test result
|
||
trap_ne
|
||
pla ;load status
|
||
pha
|
||
cmp_flag \2
|
||
trap_ne
|
||
plp ;restore status
|
||
pla
|
||
endm
|
||
|
||
tst_x macro ;testing result in x index & flags
|
||
php ;save flags
|
||
cpx #\1 ;test result
|
||
trap_ne
|
||
pla ;load status
|
||
pha
|
||
cmp_flag \2
|
||
trap_ne
|
||
plp ;restore status
|
||
endm
|
||
|
||
tst_y macro ;testing result in y index & flags
|
||
php ;save flags
|
||
cpy #\1 ;test result
|
||
trap_ne
|
||
pla ;load status
|
||
pha
|
||
cmp_flag \2
|
||
trap_ne
|
||
plp ;restore status
|
||
endm
|
||
|
||
tst_ax macro ;indexed testing result in accu & flags
|
||
php ;save flags
|
||
cmp \1,x ;test result
|
||
trap_ne
|
||
pla ;load status
|
||
eor_flag \3
|
||
cmp \2,x ;test flags
|
||
trap_ne ;
|
||
endm
|
||
|
||
tst_ay macro ;indexed testing result in accu & flags
|
||
php ;save flags
|
||
cmp \1,y ;test result
|
||
trap_ne ;
|
||
pla ;load status
|
||
eor_flag \3
|
||
cmp \2,y ;test flags
|
||
trap_ne
|
||
endm
|
||
|
||
tst_z macro ;indexed testing result in zp & flags
|
||
php ;save flags
|
||
lda zpt
|
||
cmp \1,x ;test result
|
||
trap_ne
|
||
pla ;load status
|
||
eor_flag \3
|
||
cmp \2,x ;test flags
|
||
trap_ne
|
||
endm
|
||
|
||
tst_zx macro ;testing result in zp,x & flags
|
||
php ;save flags
|
||
lda zpt,x
|
||
cmp \1,x ;test result
|
||
trap_ne
|
||
pla ;load status
|
||
eor_flag \3
|
||
cmp \2,x ;test flags
|
||
trap_ne
|
||
endm
|
||
|
||
tst_abs macro ;indexed testing result in memory & flags
|
||
php ;save flags
|
||
lda abst
|
||
cmp \1,x ;test result
|
||
trap_ne
|
||
pla ;load status
|
||
eor_flag \3
|
||
cmp \2,x ;test flags
|
||
trap_ne
|
||
endm
|
||
|
||
tst_absx macro ;testing result in abs,x & flags
|
||
php ;save flags
|
||
lda abst,x
|
||
cmp \1,x ;test result
|
||
trap_ne
|
||
pla ;load status
|
||
eor_flag \3
|
||
cmp \2,x ;test flags
|
||
trap_ne
|
||
endm
|
||
|
||
; RAM integrity test
|
||
; verifies that none of the previous tests has altered RAM outside of the
|
||
; designated write areas.
|
||
; uses zpt word as indirect pointer, zpt+2 word as checksum
|
||
if ram_top > -1
|
||
check_ram macro
|
||
cld
|
||
lda #0
|
||
sta zpt ;set low byte of indirect pointer
|
||
sta zpt+3 ;checksum high byte
|
||
ldx #11 ;reset modifiable RAM
|
||
ccs1\? sta jxi_tab,x ;JMP indirect page cross area
|
||
dex
|
||
bpl ccs1\?
|
||
sta chkdadi ;self modifying code
|
||
sta chkdsbi
|
||
clc
|
||
ldx #zp_bss-zero_page ;zeropage - write test area
|
||
ccs3\? adc zero_page,x
|
||
bcc ccs2\?
|
||
inc zpt+3 ;carry to high byte
|
||
clc
|
||
ccs2\? inx
|
||
bne ccs3\?
|
||
ldx #hi(data_segment) ;set high byte of indirect pointer
|
||
stx zpt+1
|
||
ldy #lo(data_bss) ;data after write test area
|
||
ccs5\? adc (zpt),y
|
||
bcc ccs4\?
|
||
inc zpt+3 ;carry to high byte
|
||
clc
|
||
ccs4\? iny
|
||
bne ccs5\?
|
||
inx ;advance RAM high address
|
||
stx zpt+1
|
||
cpx #ram_top
|
||
bne ccs5\?
|
||
sta zpt+2 ;checksum low is
|
||
cmp ram_chksm ;checksum low expected
|
||
trap_ne ;checksum mismatch
|
||
lda zpt+3 ;checksum high is
|
||
cmp ram_chksm+1 ;checksum high expected
|
||
trap_ne ;checksum mismatch
|
||
endm
|
||
else
|
||
check_ram macro
|
||
;RAM check disabled - RAM size not set
|
||
endm
|
||
endif
|
||
|
||
next_test macro ;make sure, tests don't jump the fence
|
||
lda test_case ;previous test
|
||
cmp #test_num
|
||
trap_ne ;test is out of sequence
|
||
test_num = test_num + 1
|
||
lda #test_num ;*** next tests' number
|
||
sta test_case
|
||
;check_ram ;uncomment to find altered RAM after each test
|
||
endm
|
||
|
||
if load_data_direct = 1
|
||
data
|
||
else
|
||
bss ;uninitialized segment, copy of data at end of code!
|
||
endif
|
||
; org zero_page
|
||
0000 = org 0 ;edited to provide binaries loading from 0
|
||
0000 : 00000000000000.. ds zero_page
|
||
if I_flag = 2
|
||
;masking for I bit in status
|
||
flag_I_on ds 1 ;or mask to load flags
|
||
flag_I_off ds 1 ;and mask to load flags
|
||
endif
|
||
000a : zpt ;5 bytes store/modify test area
|
||
;add/subtract operand generation and result/flag prediction
|
||
000a : 00 adfc ds 1 ;carry flag before op
|
||
000b : 00 ad1 ds 1 ;operand 1 - accumulator
|
||
000c : 00 ad2 ds 1 ;operand 2 - memory / immediate
|
||
000d : 00 adrl ds 1 ;expected result bits 0-7
|
||
000e : 00 adrh ds 1 ;expected result bit 8 (carry)
|
||
000f : 00 adrf ds 1 ;expected flags NV0000ZC (-V in decimal mode)
|
||
0010 : 00 sb2 ds 1 ;operand 2 complemented for subtract
|
||
0011 : zp_bss
|
||
0011 : c3824100 zp1 db $c3,$82,$41,0 ;test patterns for LDx BIT ROL ROR ASL LSR
|
||
0015 : 7f zp7f db $7f ;test pattern for compare
|
||
;logical zeropage operands
|
||
0016 : 001f7180 zpOR db 0,$1f,$71,$80 ;test pattern for OR
|
||
001a : 0fff7f80 zpAN db $0f,$ff,$7f,$80 ;test pattern for AND
|
||
001e : ff0f8f8f zpEO db $ff,$0f,$8f,$8f ;test pattern for EOR
|
||
;indirect addressing pointers
|
||
0022 : 0a02 ind1 dw abs1 ;indirect pointer to pattern in absolute memory
|
||
0024 : 0b02 dw abs1+1
|
||
0026 : 0c02 dw abs1+2
|
||
0028 : 0d02 dw abs1+3
|
||
002a : 0e02 dw abs7f
|
||
002c : 1201 inw1 dw abs1-$f8 ;indirect pointer for wrap-test pattern
|
||
002e : 0502 indt dw abst ;indirect pointer to store area in absolute memory
|
||
0030 : 0602 dw abst+1
|
||
0032 : 0702 dw abst+2
|
||
0034 : 0802 dw abst+3
|
||
0036 : 0d01 inwt dw abst-$f8 ;indirect pointer for wrap-test store
|
||
0038 : 4102 indAN dw absAN ;indirect pointer to AND pattern in absolute memory
|
||
003a : 4202 dw absAN+1
|
||
003c : 4302 dw absAN+2
|
||
003e : 4402 dw absAN+3
|
||
0040 : 4502 indEO dw absEO ;indirect pointer to EOR pattern in absolute memory
|
||
0042 : 4602 dw absEO+1
|
||
0044 : 4702 dw absEO+2
|
||
0046 : 4802 dw absEO+3
|
||
0048 : 3d02 indOR dw absOR ;indirect pointer to OR pattern in absolute memory
|
||
004a : 3e02 dw absOR+1
|
||
004c : 3f02 dw absOR+2
|
||
004e : 4002 dw absOR+3
|
||
;add/subtract indirect pointers
|
||
0050 : 0502 adi2 dw ada2 ;indirect pointer to operand 2 in absolute memory
|
||
0052 : 0602 sbi2 dw sba2 ;indirect pointer to complemented operand 2 (SBC)
|
||
0054 : 0601 adiy2 dw ada2-$ff ;with offset for indirect indexed
|
||
0056 : 0701 sbiy2 dw sba2-$ff
|
||
0058 : zp_bss_end
|
||
|
||
0200 = org data_segment
|
||
0200 : 0000 pg_x ds 2 ;high JMP indirect address for page cross bug
|
||
0202 : 00 test_case ds 1 ;current test number
|
||
0203 : 0000 ram_chksm ds 2 ;checksum for RAM integrity test
|
||
;add/subtract operand copy - abs tests write area
|
||
0205 : abst ;5 bytes store/modify test area
|
||
0205 : 00 ada2 ds 1 ;operand 2
|
||
0206 : 00 sba2 ds 1 ;operand 2 complemented for subtract
|
||
0207 : 000000 ds 3 ;fill remaining bytes
|
||
020a : data_bss
|
||
020a : c3824100 abs1 db $c3,$82,$41,0 ;test patterns for LDx BIT ROL ROR ASL LSR
|
||
020e : 7f abs7f db $7f ;test pattern for compare
|
||
;loads
|
||
020f : 80800002 fLDx db fn,fn,0,fz ;expected flags for load
|
||
;shifts
|
||
0213 : rASL ;expected result ASL & ROL -carry
|
||
0213 : 86048200 rROL db $86,$04,$82,0 ; "
|
||
0217 : 87058301 rROLc db $87,$05,$83,1 ;expected result ROL +carry
|
||
021b : rLSR ;expected result LSR & ROR -carry
|
||
021b : 61412000 rROR db $61,$41,$20,0 ; "
|
||
021f : e1c1a080 rRORc db $e1,$c1,$a0,$80 ;expected result ROR +carry
|
||
0223 : fASL ;expected flags for shifts
|
||
0223 : 81018002 fROL db fnc,fc,fn,fz ;no carry in
|
||
0227 : 81018000 fROLc db fnc,fc,fn,0 ;carry in
|
||
022b : fLSR
|
||
022b : 01000102 fROR db fc,0,fc,fz ;no carry in
|
||
022f : 81808180 fRORc db fnc,fn,fnc,fn ;carry in
|
||
;increments (decrements)
|
||
0233 : 7f80ff0001 rINC db $7f,$80,$ff,0,1 ;expected result for INC/DEC
|
||
0238 : 0080800200 fINC db 0,fn,fn,fz,0 ;expected flags for INC/DEC
|
||
;logical memory operand
|
||
023d : 001f7180 absOR db 0,$1f,$71,$80 ;test pattern for OR
|
||
0241 : 0fff7f80 absAN db $0f,$ff,$7f,$80 ;test pattern for AND
|
||
0245 : ff0f8f8f absEO db $ff,$0f,$8f,$8f ;test pattern for EOR
|
||
;logical accu operand
|
||
0249 : 00f11f00 absORa db 0,$f1,$1f,0 ;test pattern for OR
|
||
024d : f0ffffff absANa db $f0,$ff,$ff,$ff ;test pattern for AND
|
||
0251 : fff0f00f absEOa db $ff,$f0,$f0,$0f ;test pattern for EOR
|
||
;logical results
|
||
0255 : 00ff7f80 absrlo db 0,$ff,$7f,$80
|
||
0259 : 02800080 absflo db fz,fn,0,fn
|
||
025d : data_bss_end
|
||
;define area for page crossing JMP (abs) & JMP (abs,x) test
|
||
02f9 = jxi_tab equ data_segment + $100 - 7 ;JMP (jxi_tab,x) x=6
|
||
02fd = ji_tab equ data_segment + $100 - 3 ;JMP (ji_tab+2)
|
||
0300 = jxp_tab equ data_segment + $100 ;JMP (jxp_tab-255) x=255
|
||
|
||
|
||
code
|
||
0400 = org code_segment
|
||
0400 : d8 start cld
|
||
0401 : a2ff ldx #$ff
|
||
0403 : 9a txs
|
||
0404 : a900 lda #0 ;*** test 0 = initialize
|
||
0406 : 8d0202 sta test_case
|
||
0000 = test_num = 0
|
||
|
||
;stop interrupts before initializing BSS
|
||
if I_flag = 1
|
||
sei
|
||
endif
|
||
|
||
;initialize I/O for report channel
|
||
if report = 1
|
||
jsr report_init
|
||
endif
|
||
|
||
;initialize BSS segment
|
||
if load_data_direct != 1
|
||
ldx #zp_end-zp_init-1
|
||
ld_zp lda zp_init,x
|
||
sta zp_bss,x
|
||
dex
|
||
bpl ld_zp
|
||
ldx #data_end-data_init-1
|
||
ld_data lda data_init,x
|
||
sta data_bss,x
|
||
dex
|
||
bpl ld_data
|
||
if ROM_vectors = 1
|
||
ldx #5
|
||
ld_vect lda vec_init,x
|
||
sta vec_bss,x
|
||
dex
|
||
bpl ld_vect
|
||
endif
|
||
endif
|
||
|
||
;retain status of interrupt flag
|
||
if I_flag = 2
|
||
php
|
||
pla
|
||
and #4 ;isolate flag
|
||
sta flag_I_on ;or mask
|
||
eor #lo(~4) ;reverse
|
||
sta flag_I_off ;and mask
|
||
endif
|
||
|
||
;generate checksum for RAM integrity test
|
||
if ram_top > -1
|
||
lda #0
|
||
sta zpt ;set low byte of indirect pointer
|
||
sta ram_chksm+1 ;checksum high byte
|
||
ldx #11 ;reset modifiable RAM
|
||
gcs1 sta jxi_tab,x ;JMP indirect page cross area
|
||
dex
|
||
bpl gcs1
|
||
sta chkdadi ;self modifying code
|
||
sta chkdsbi
|
||
clc
|
||
ldx #zp_bss-zero_page ;zeropage - write test area
|
||
gcs3 adc zero_page,x
|
||
bcc gcs2
|
||
inc ram_chksm+1 ;carry to high byte
|
||
clc
|
||
gcs2 inx
|
||
bne gcs3
|
||
ldx #hi(data_segment) ;set high byte of indirect pointer
|
||
stx zpt+1
|
||
ldy #lo(data_bss) ;data after write test area
|
||
gcs5 adc (zpt),y
|
||
bcc gcs4
|
||
inc ram_chksm+1 ;carry to high byte
|
||
clc
|
||
gcs4 iny
|
||
bne gcs5
|
||
inx ;advance RAM high address
|
||
stx zpt+1
|
||
cpx #ram_top
|
||
bne gcs5
|
||
sta ram_chksm ;checksum complete
|
||
endif
|
||
next_test
|
||
0409 : ad0202 > lda test_case ;previous test
|
||
040c : c900 > cmp #test_num
|
||
> trap_ne ;test is out of sequence
|
||
040e : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0001 = >test_num = test_num + 1
|
||
0410 : a901 > lda #test_num ;*** next tests' number
|
||
0412 : 8d0202 > sta test_case
|
||
> ;check_ram ;uncomment to find altered RAM after each test
|
||
|
||
|
||
;testing stack operations PHX PHY PLX PLY
|
||
0415 : a999 lda #$99 ;protect a
|
||
0417 : a2ff ldx #$ff ;initialize stack
|
||
0419 : 9a txs
|
||
041a : a255 ldx #$55
|
||
041c : da phx
|
||
041d : a2aa ldx #$aa
|
||
041f : da phx
|
||
0420 : ecfe01 cpx $1fe ;on stack ?
|
||
trap_ne
|
||
0423 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
0425 : ba tsx
|
||
0426 : e0fd cpx #$fd ;sp decremented?
|
||
trap_ne
|
||
0428 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
042a : 7a ply
|
||
042b : c0aa cpy #$aa ;successful retreived from stack?
|
||
trap_ne
|
||
042d : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
042f : 7a ply
|
||
0430 : c055 cpy #$55
|
||
trap_ne
|
||
0432 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
0434 : ccff01 cpy $1ff ;remains on stack?
|
||
trap_ne
|
||
0437 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
0439 : ba tsx
|
||
043a : e0ff cpx #$ff ;sp incremented?
|
||
trap_ne
|
||
043c : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
|
||
043e : a0a5 ldy #$a5
|
||
0440 : 5a phy
|
||
0441 : a05a ldy #$5a
|
||
0443 : 5a phy
|
||
0444 : ccfe01 cpy $1fe ;on stack ?
|
||
trap_ne
|
||
0447 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
0449 : ba tsx
|
||
044a : e0fd cpx #$fd ;sp decremented?
|
||
trap_ne
|
||
044c : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
044e : fa plx
|
||
044f : e05a cpx #$5a ;successful retreived from stack?
|
||
trap_ne
|
||
0451 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
0453 : fa plx
|
||
0454 : e0a5 cpx #$a5
|
||
trap_ne
|
||
0456 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
0458 : ecff01 cpx $1ff ;remains on stack?
|
||
trap_ne
|
||
045b : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
045d : ba tsx
|
||
045e : e0ff cpx #$ff ;sp incremented?
|
||
trap_ne
|
||
0460 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
0462 : c999 cmp #$99 ;unchanged?
|
||
trap_ne
|
||
0464 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
next_test
|
||
0466 : ad0202 > lda test_case ;previous test
|
||
0469 : c901 > cmp #test_num
|
||
> trap_ne ;test is out of sequence
|
||
046b : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0002 = >test_num = test_num + 1
|
||
046d : a902 > lda #test_num ;*** next tests' number
|
||
046f : 8d0202 > sta test_case
|
||
> ;check_ram ;uncomment to find altered RAM after each test
|
||
|
||
|
||
; test PHX does not alter flags or X but PLX does
|
||
0472 : a0aa ldy #$aa ;protect y
|
||
set_x 1,$ff ;push
|
||
> load_flag $ff
|
||
0474 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
0476 : 48 > pha ;use stack to load status
|
||
0477 : a201 > ldx #1 ;precharge index x
|
||
0479 : 28 > plp
|
||
|
||
047a : da phx
|
||
tst_x 1,$ff
|
||
047b : 08 > php ;save flags
|
||
047c : e001 > cpx #1 ;test result
|
||
> trap_ne
|
||
047e : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0480 : 68 > pla ;load status
|
||
0481 : 48 > pha
|
||
> cmp_flag $ff
|
||
0482 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0484 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0486 : 28 > plp ;restore status
|
||
|
||
set_x 0,0
|
||
> load_flag 0
|
||
0487 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
0489 : 48 > pha ;use stack to load status
|
||
048a : a200 > ldx #0 ;precharge index x
|
||
048c : 28 > plp
|
||
|
||
048d : da phx
|
||
tst_x 0,0
|
||
048e : 08 > php ;save flags
|
||
048f : e000 > cpx #0 ;test result
|
||
> trap_ne
|
||
0491 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0493 : 68 > pla ;load status
|
||
0494 : 48 > pha
|
||
> cmp_flag 0
|
||
0495 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0497 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0499 : 28 > plp ;restore status
|
||
|
||
set_x $ff,$ff
|
||
> load_flag $ff
|
||
049a : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
049c : 48 > pha ;use stack to load status
|
||
049d : a2ff > ldx #$ff ;precharge index x
|
||
049f : 28 > plp
|
||
|
||
04a0 : da phx
|
||
tst_x $ff,$ff
|
||
04a1 : 08 > php ;save flags
|
||
04a2 : e0ff > cpx #$ff ;test result
|
||
> trap_ne
|
||
04a4 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
04a6 : 68 > pla ;load status
|
||
04a7 : 48 > pha
|
||
> cmp_flag $ff
|
||
04a8 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
04aa : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
04ac : 28 > plp ;restore status
|
||
|
||
set_x 1,0
|
||
> load_flag 0
|
||
04ad : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
04af : 48 > pha ;use stack to load status
|
||
04b0 : a201 > ldx #1 ;precharge index x
|
||
04b2 : 28 > plp
|
||
|
||
04b3 : da phx
|
||
tst_x 1,0
|
||
04b4 : 08 > php ;save flags
|
||
04b5 : e001 > cpx #1 ;test result
|
||
> trap_ne
|
||
04b7 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
04b9 : 68 > pla ;load status
|
||
04ba : 48 > pha
|
||
> cmp_flag 0
|
||
04bb : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
04bd : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
04bf : 28 > plp ;restore status
|
||
|
||
set_x 0,$ff
|
||
> load_flag $ff
|
||
04c0 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
04c2 : 48 > pha ;use stack to load status
|
||
04c3 : a200 > ldx #0 ;precharge index x
|
||
04c5 : 28 > plp
|
||
|
||
04c6 : da phx
|
||
tst_x 0,$ff
|
||
04c7 : 08 > php ;save flags
|
||
04c8 : e000 > cpx #0 ;test result
|
||
> trap_ne
|
||
04ca : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
04cc : 68 > pla ;load status
|
||
04cd : 48 > pha
|
||
> cmp_flag $ff
|
||
04ce : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
04d0 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
04d2 : 28 > plp ;restore status
|
||
|
||
set_x $ff,0
|
||
> load_flag 0
|
||
04d3 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
04d5 : 48 > pha ;use stack to load status
|
||
04d6 : a2ff > ldx #$ff ;precharge index x
|
||
04d8 : 28 > plp
|
||
|
||
04d9 : da phx
|
||
tst_x $ff,0
|
||
04da : 08 > php ;save flags
|
||
04db : e0ff > cpx #$ff ;test result
|
||
> trap_ne
|
||
04dd : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
04df : 68 > pla ;load status
|
||
04e0 : 48 > pha
|
||
> cmp_flag 0
|
||
04e1 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
04e3 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
04e5 : 28 > plp ;restore status
|
||
|
||
set_x 0,$ff ;pull
|
||
> load_flag $ff
|
||
04e6 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
04e8 : 48 > pha ;use stack to load status
|
||
04e9 : a200 > ldx #0 ;precharge index x
|
||
04eb : 28 > plp
|
||
|
||
04ec : fa plx
|
||
tst_x $ff,$ff-zero
|
||
04ed : 08 > php ;save flags
|
||
04ee : e0ff > cpx #$ff ;test result
|
||
> trap_ne
|
||
04f0 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
04f2 : 68 > pla ;load status
|
||
04f3 : 48 > pha
|
||
> cmp_flag $ff-zero
|
||
04f4 : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
04f6 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
04f8 : 28 > plp ;restore status
|
||
|
||
set_x $ff,0
|
||
> load_flag 0
|
||
04f9 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
04fb : 48 > pha ;use stack to load status
|
||
04fc : a2ff > ldx #$ff ;precharge index x
|
||
04fe : 28 > plp
|
||
|
||
04ff : fa plx
|
||
tst_x 0,zero
|
||
0500 : 08 > php ;save flags
|
||
0501 : e000 > cpx #0 ;test result
|
||
> trap_ne
|
||
0503 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0505 : 68 > pla ;load status
|
||
0506 : 48 > pha
|
||
> cmp_flag zero
|
||
0507 : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0509 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
050b : 28 > plp ;restore status
|
||
|
||
set_x $fe,$ff
|
||
> load_flag $ff
|
||
050c : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
050e : 48 > pha ;use stack to load status
|
||
050f : a2fe > ldx #$fe ;precharge index x
|
||
0511 : 28 > plp
|
||
|
||
0512 : fa plx
|
||
tst_x 1,$ff-zero-minus
|
||
0513 : 08 > php ;save flags
|
||
0514 : e001 > cpx #1 ;test result
|
||
> trap_ne
|
||
0516 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0518 : 68 > pla ;load status
|
||
0519 : 48 > pha
|
||
> cmp_flag $ff-zero-minus
|
||
051a : c97d > cmp #($ff-zero-minus|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
051c : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
051e : 28 > plp ;restore status
|
||
|
||
set_x 0,0
|
||
> load_flag 0
|
||
051f : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
0521 : 48 > pha ;use stack to load status
|
||
0522 : a200 > ldx #0 ;precharge index x
|
||
0524 : 28 > plp
|
||
|
||
0525 : fa plx
|
||
tst_x $ff,minus
|
||
0526 : 08 > php ;save flags
|
||
0527 : e0ff > cpx #$ff ;test result
|
||
> trap_ne
|
||
0529 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
052b : 68 > pla ;load status
|
||
052c : 48 > pha
|
||
> cmp_flag minus
|
||
052d : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
052f : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0531 : 28 > plp ;restore status
|
||
|
||
set_x $ff,$ff
|
||
> load_flag $ff
|
||
0532 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
0534 : 48 > pha ;use stack to load status
|
||
0535 : a2ff > ldx #$ff ;precharge index x
|
||
0537 : 28 > plp
|
||
|
||
0538 : fa plx
|
||
tst_x 0,$ff-minus
|
||
0539 : 08 > php ;save flags
|
||
053a : e000 > cpx #0 ;test result
|
||
> trap_ne
|
||
053c : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
053e : 68 > pla ;load status
|
||
053f : 48 > pha
|
||
> cmp_flag $ff-minus
|
||
0540 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0542 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0544 : 28 > plp ;restore status
|
||
|
||
set_x $fe,0
|
||
> load_flag 0
|
||
0545 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
0547 : 48 > pha ;use stack to load status
|
||
0548 : a2fe > ldx #$fe ;precharge index x
|
||
054a : 28 > plp
|
||
|
||
054b : fa plx
|
||
tst_x 1,0
|
||
054c : 08 > php ;save flags
|
||
054d : e001 > cpx #1 ;test result
|
||
> trap_ne
|
||
054f : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0551 : 68 > pla ;load status
|
||
0552 : 48 > pha
|
||
> cmp_flag 0
|
||
0553 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0555 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0557 : 28 > plp ;restore status
|
||
|
||
0558 : c0aa cpy #$aa ;Y unchanged
|
||
trap_ne
|
||
055a : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
next_test
|
||
055c : ad0202 > lda test_case ;previous test
|
||
055f : c902 > cmp #test_num
|
||
> trap_ne ;test is out of sequence
|
||
0561 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0003 = >test_num = test_num + 1
|
||
0563 : a903 > lda #test_num ;*** next tests' number
|
||
0565 : 8d0202 > sta test_case
|
||
> ;check_ram ;uncomment to find altered RAM after each test
|
||
|
||
|
||
; test PHY does not alter flags or Y but PLY does
|
||
0568 : a255 ldx #$55 ;x & a protected
|
||
set_y 1,$ff ;push
|
||
> load_flag $ff
|
||
056a : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
056c : 48 > pha ;use stack to load status
|
||
056d : a001 > ldy #1 ;precharge index y
|
||
056f : 28 > plp
|
||
|
||
0570 : 5a phy
|
||
tst_y 1,$ff
|
||
0571 : 08 > php ;save flags
|
||
0572 : c001 > cpy #1 ;test result
|
||
> trap_ne
|
||
0574 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0576 : 68 > pla ;load status
|
||
0577 : 48 > pha
|
||
> cmp_flag $ff
|
||
0578 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
057a : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
057c : 28 > plp ;restore status
|
||
|
||
set_y 0,0
|
||
> load_flag 0
|
||
057d : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
057f : 48 > pha ;use stack to load status
|
||
0580 : a000 > ldy #0 ;precharge index y
|
||
0582 : 28 > plp
|
||
|
||
0583 : 5a phy
|
||
tst_y 0,0
|
||
0584 : 08 > php ;save flags
|
||
0585 : c000 > cpy #0 ;test result
|
||
> trap_ne
|
||
0587 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0589 : 68 > pla ;load status
|
||
058a : 48 > pha
|
||
> cmp_flag 0
|
||
058b : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
058d : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
058f : 28 > plp ;restore status
|
||
|
||
set_y $ff,$ff
|
||
> load_flag $ff
|
||
0590 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
0592 : 48 > pha ;use stack to load status
|
||
0593 : a0ff > ldy #$ff ;precharge index y
|
||
0595 : 28 > plp
|
||
|
||
0596 : 5a phy
|
||
tst_y $ff,$ff
|
||
0597 : 08 > php ;save flags
|
||
0598 : c0ff > cpy #$ff ;test result
|
||
> trap_ne
|
||
059a : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
059c : 68 > pla ;load status
|
||
059d : 48 > pha
|
||
> cmp_flag $ff
|
||
059e : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
05a0 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
05a2 : 28 > plp ;restore status
|
||
|
||
set_y 1,0
|
||
> load_flag 0
|
||
05a3 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
05a5 : 48 > pha ;use stack to load status
|
||
05a6 : a001 > ldy #1 ;precharge index y
|
||
05a8 : 28 > plp
|
||
|
||
05a9 : 5a phy
|
||
tst_y 1,0
|
||
05aa : 08 > php ;save flags
|
||
05ab : c001 > cpy #1 ;test result
|
||
> trap_ne
|
||
05ad : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
05af : 68 > pla ;load status
|
||
05b0 : 48 > pha
|
||
> cmp_flag 0
|
||
05b1 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
05b3 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
05b5 : 28 > plp ;restore status
|
||
|
||
set_y 0,$ff
|
||
> load_flag $ff
|
||
05b6 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
05b8 : 48 > pha ;use stack to load status
|
||
05b9 : a000 > ldy #0 ;precharge index y
|
||
05bb : 28 > plp
|
||
|
||
05bc : 5a phy
|
||
tst_y 0,$ff
|
||
05bd : 08 > php ;save flags
|
||
05be : c000 > cpy #0 ;test result
|
||
> trap_ne
|
||
05c0 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
05c2 : 68 > pla ;load status
|
||
05c3 : 48 > pha
|
||
> cmp_flag $ff
|
||
05c4 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
05c6 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
05c8 : 28 > plp ;restore status
|
||
|
||
set_y $ff,0
|
||
> load_flag 0
|
||
05c9 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
05cb : 48 > pha ;use stack to load status
|
||
05cc : a0ff > ldy #$ff ;precharge index y
|
||
05ce : 28 > plp
|
||
|
||
05cf : 5a phy
|
||
tst_y $ff,0
|
||
05d0 : 08 > php ;save flags
|
||
05d1 : c0ff > cpy #$ff ;test result
|
||
> trap_ne
|
||
05d3 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
05d5 : 68 > pla ;load status
|
||
05d6 : 48 > pha
|
||
> cmp_flag 0
|
||
05d7 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
05d9 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
05db : 28 > plp ;restore status
|
||
|
||
set_y 0,$ff ;pull
|
||
> load_flag $ff
|
||
05dc : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
05de : 48 > pha ;use stack to load status
|
||
05df : a000 > ldy #0 ;precharge index y
|
||
05e1 : 28 > plp
|
||
|
||
05e2 : 7a ply
|
||
tst_y $ff,$ff-zero
|
||
05e3 : 08 > php ;save flags
|
||
05e4 : c0ff > cpy #$ff ;test result
|
||
> trap_ne
|
||
05e6 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
05e8 : 68 > pla ;load status
|
||
05e9 : 48 > pha
|
||
> cmp_flag $ff-zero
|
||
05ea : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
05ec : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
05ee : 28 > plp ;restore status
|
||
|
||
set_y $ff,0
|
||
> load_flag 0
|
||
05ef : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
05f1 : 48 > pha ;use stack to load status
|
||
05f2 : a0ff > ldy #$ff ;precharge index y
|
||
05f4 : 28 > plp
|
||
|
||
05f5 : 7a ply
|
||
tst_y 0,zero
|
||
05f6 : 08 > php ;save flags
|
||
05f7 : c000 > cpy #0 ;test result
|
||
> trap_ne
|
||
05f9 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
05fb : 68 > pla ;load status
|
||
05fc : 48 > pha
|
||
> cmp_flag zero
|
||
05fd : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
05ff : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0601 : 28 > plp ;restore status
|
||
|
||
set_y $fe,$ff
|
||
> load_flag $ff
|
||
0602 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
0604 : 48 > pha ;use stack to load status
|
||
0605 : a0fe > ldy #$fe ;precharge index y
|
||
0607 : 28 > plp
|
||
|
||
0608 : 7a ply
|
||
tst_y 1,$ff-zero-minus
|
||
0609 : 08 > php ;save flags
|
||
060a : c001 > cpy #1 ;test result
|
||
> trap_ne
|
||
060c : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
060e : 68 > pla ;load status
|
||
060f : 48 > pha
|
||
> cmp_flag $ff-zero-minus
|
||
0610 : c97d > cmp #($ff-zero-minus|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0612 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0614 : 28 > plp ;restore status
|
||
|
||
set_y 0,0
|
||
> load_flag 0
|
||
0615 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
0617 : 48 > pha ;use stack to load status
|
||
0618 : a000 > ldy #0 ;precharge index y
|
||
061a : 28 > plp
|
||
|
||
061b : 7a ply
|
||
tst_y $ff,minus
|
||
061c : 08 > php ;save flags
|
||
061d : c0ff > cpy #$ff ;test result
|
||
> trap_ne
|
||
061f : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0621 : 68 > pla ;load status
|
||
0622 : 48 > pha
|
||
> cmp_flag minus
|
||
0623 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0625 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0627 : 28 > plp ;restore status
|
||
|
||
set_y $ff,$ff
|
||
> load_flag $ff
|
||
0628 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
062a : 48 > pha ;use stack to load status
|
||
062b : a0ff > ldy #$ff ;precharge index y
|
||
062d : 28 > plp
|
||
|
||
062e : 7a ply
|
||
tst_y 0,$ff-minus
|
||
062f : 08 > php ;save flags
|
||
0630 : c000 > cpy #0 ;test result
|
||
> trap_ne
|
||
0632 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0634 : 68 > pla ;load status
|
||
0635 : 48 > pha
|
||
> cmp_flag $ff-minus
|
||
0636 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0638 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
063a : 28 > plp ;restore status
|
||
|
||
set_y $fe,0
|
||
> load_flag 0
|
||
063b : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
063d : 48 > pha ;use stack to load status
|
||
063e : a0fe > ldy #$fe ;precharge index y
|
||
0640 : 28 > plp
|
||
|
||
0641 : 7a ply
|
||
tst_y 1,0
|
||
0642 : 08 > php ;save flags
|
||
0643 : c001 > cpy #1 ;test result
|
||
> trap_ne
|
||
0645 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0647 : 68 > pla ;load status
|
||
0648 : 48 > pha
|
||
> cmp_flag 0
|
||
0649 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
064b : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
064d : 28 > plp ;restore status
|
||
|
||
064e : e055 cpx #$55 ;x unchanged?
|
||
trap_ne
|
||
0650 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
next_test
|
||
0652 : ad0202 > lda test_case ;previous test
|
||
0655 : c903 > cmp #test_num
|
||
> trap_ne ;test is out of sequence
|
||
0657 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0004 = >test_num = test_num + 1
|
||
0659 : a904 > lda #test_num ;*** next tests' number
|
||
065b : 8d0202 > sta test_case
|
||
> ;check_ram ;uncomment to find altered RAM after each test
|
||
|
||
|
||
; PC modifying instructions (BRA, BBR, BBS, 1, 2, 3 byte NOPs, JMP(abs,x))
|
||
; testing unconditional branch BRA
|
||
|
||
065e : a281 ldx #$81 ;protect unused registers
|
||
0660 : a07e ldy #$7e
|
||
set_a 0,$ff
|
||
> load_flag $ff
|
||
0662 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
0664 : 48 > pha ;use stack to load status
|
||
0665 : a900 > lda #0 ;precharge accu
|
||
0667 : 28 > plp
|
||
|
||
0668 : 8003 bra br1 ;branch should always be taken
|
||
trap
|
||
066a : 4c6a06 > jmp * ;failed anyway
|
||
|
||
066d : br1
|
||
tst_a 0,$ff
|
||
066d : 08 > php ;save flags
|
||
066e : c900 > cmp #0 ;test result
|
||
> trap_ne
|
||
0670 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0672 : 68 > pla ;load status
|
||
0673 : 48 > pha
|
||
> cmp_flag $ff
|
||
0674 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0676 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0678 : 28 > plp ;restore status
|
||
|
||
set_a $ff,0
|
||
> load_flag 0
|
||
0679 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
067b : 48 > pha ;use stack to load status
|
||
067c : a9ff > lda #$ff ;precharge accu
|
||
067e : 28 > plp
|
||
|
||
067f : 8003 bra br2 ;branch should always be taken
|
||
trap
|
||
0681 : 4c8106 > jmp * ;failed anyway
|
||
|
||
0684 : br2
|
||
tst_a $ff,0
|
||
0684 : 08 > php ;save flags
|
||
0685 : c9ff > cmp #$ff ;test result
|
||
> trap_ne
|
||
0687 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0689 : 68 > pla ;load status
|
||
068a : 48 > pha
|
||
> cmp_flag 0
|
||
068b : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
068d : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
068f : 28 > plp ;restore status
|
||
|
||
0690 : e081 cpx #$81
|
||
trap_ne
|
||
0692 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
0694 : c07e cpy #$7e
|
||
trap_ne
|
||
0696 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
next_test
|
||
0698 : ad0202 > lda test_case ;previous test
|
||
069b : c904 > cmp #test_num
|
||
> trap_ne ;test is out of sequence
|
||
069d : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0005 = >test_num = test_num + 1
|
||
069f : a905 > lda #test_num ;*** next tests' number
|
||
06a1 : 8d0202 > sta test_case
|
||
> ;check_ram ;uncomment to find altered RAM after each test
|
||
|
||
|
||
06a4 : a000 ldy #0 ;branch range test
|
||
06a6 : 8061 bra bra0
|
||
|
||
06a8 : c001 bra1 cpy #1
|
||
trap_ne ;long range backward
|
||
06aa : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
06ac : c8 iny
|
||
06ad : 8053 bra bra2
|
||
|
||
06af : c003 bra3 cpy #3
|
||
trap_ne ;long range backward
|
||
06b1 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
06b3 : c8 iny
|
||
06b4 : 8045 bra bra4
|
||
|
||
06b6 : c005 bra5 cpy #5
|
||
trap_ne ;long range backward
|
||
06b8 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
06ba : c8 iny
|
||
06bb : a000 ldy #0
|
||
06bd : 8004 bra brf0
|
||
|
||
06bf : c8 iny
|
||
06c0 : c8 iny
|
||
06c1 : c8 iny
|
||
06c2 : c8 iny
|
||
06c3 : 8003 brf0 bra brf1
|
||
|
||
06c5 : c8 iny
|
||
06c6 : c8 iny
|
||
06c7 : c8 iny
|
||
06c8 : c8 brf1 iny
|
||
06c9 : 8002 bra brf2
|
||
|
||
06cb : c8 iny
|
||
06cc : c8 iny
|
||
06cd : c8 brf2 iny
|
||
06ce : c8 iny
|
||
06cf : 8001 bra brf3
|
||
|
||
06d1 : c8 iny
|
||
06d2 : c8 brf3 iny
|
||
06d3 : c8 iny
|
||
06d4 : c8 iny
|
||
06d5 : 8000 bra brf4
|
||
|
||
06d7 : c8 brf4 iny
|
||
06d8 : c8 iny
|
||
06d9 : c8 iny
|
||
06da : c8 iny
|
||
06db : c00a cpy #10
|
||
trap_ne ;short range forward
|
||
06dd : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
06df : 8012 bra brb0
|
||
|
||
06e1 : 88 brb4 dey
|
||
06e2 : 88 dey
|
||
06e3 : 88 dey
|
||
06e4 : 88 dey
|
||
06e5 : 800e bra brb5
|
||
|
||
06e7 : 88 brb3 dey
|
||
06e8 : 88 dey
|
||
06e9 : 88 dey
|
||
06ea : 80f5 bra brb4
|
||
|
||
06ec : 88 brb2 dey
|
||
06ed : 88 dey
|
||
06ee : 80f7 bra brb3
|
||
|
||
06f0 : 88 brb1 dey
|
||
06f1 : 80f9 bra brb2
|
||
|
||
06f3 : 80fb brb0 bra brb1
|
||
|
||
06f5 : c000 brb5 cpy #0
|
||
trap_ne ;short range backward
|
||
06f7 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
06f9 : 8015 bra bra6
|
||
|
||
06fb : c004 bra4 cpy #4
|
||
trap_ne ;long range forward
|
||
06fd : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
06ff : c8 iny
|
||
0700 : 80b4 bra bra5
|
||
|
||
0702 : c002 bra2 cpy #2
|
||
trap_ne ;long range forward
|
||
0704 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
0706 : c8 iny
|
||
0707 : 80a6 bra bra3
|
||
|
||
0709 : c000 bra0 cpy #0
|
||
trap_ne ;long range forward
|
||
070b : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
070d : c8 iny
|
||
070e : 8098 bra bra1
|
||
|
||
0710 : bra6
|
||
next_test
|
||
0710 : ad0202 > lda test_case ;previous test
|
||
0713 : c905 > cmp #test_num
|
||
> trap_ne ;test is out of sequence
|
||
0715 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0006 = >test_num = test_num + 1
|
||
0717 : a906 > lda #test_num ;*** next tests' number
|
||
0719 : 8d0202 > sta test_case
|
||
> ;check_ram ;uncomment to find altered RAM after each test
|
||
|
||
|
||
if rkwl_wdc_op = 1
|
||
; testing BBR & BBS
|
||
|
||
bbt macro ;\1 = bitnum
|
||
lda #(1<<\1) ;testing 1 bit on
|
||
sta zpt
|
||
set_a $33,0 ;with flags off
|
||
bbr \1,zpt,fail1\?
|
||
bbs \1,zpt,ok1\?
|
||
trap ;bbs branch not taken
|
||
fail1\?
|
||
trap ;bbr branch taken
|
||
ok1\?
|
||
tst_a $33,0
|
||
set_a $cc,$ff ;with flags on
|
||
bbr \1,zpt,fail2\?
|
||
bbs \1,zpt,ok2\?
|
||
trap ;bbs branch not taken
|
||
fail2\?
|
||
trap ;bbr branch taken
|
||
ok2\?
|
||
tst_a $cc,$ff
|
||
lda zpt
|
||
cmp #(1<<\1)
|
||
trap_ne ;zp altered
|
||
lda #$ff-(1<<\1) ;testing 1 bit off
|
||
sta zpt
|
||
set_a $33,0 ;with flags off
|
||
bbs \1,zpt,fail3\?
|
||
bbr \1,zpt,ok3\?
|
||
trap ;bbr branch not taken
|
||
fail3\?
|
||
trap ;bbs branch taken
|
||
ok3\?
|
||
tst_a $33,0
|
||
set_a $cc,$ff ;with flags on
|
||
bbs \1,zpt,fail4\?
|
||
bbr \1,zpt,ok4\?
|
||
trap ;bbr branch not taken
|
||
fail4\?
|
||
trap ;bbs branch taken
|
||
ok4\?
|
||
tst_a $cc,$ff
|
||
lda zpt
|
||
cmp #$ff-(1<<\1)
|
||
trap_ne ;zp altered
|
||
endm
|
||
|
||
071c : a211 ldx #$11 ;test bbr/bbs integrity
|
||
071e : a022 ldy #$22
|
||
bbt 0
|
||
0720 : a901 > lda #(1<<0) ;testing 1 bit on
|
||
0722 : 850a > sta zpt
|
||
> set_a $33,0 ;with flags off
|
||
> load_flag 0
|
||
0724 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
0726 : 48 > pha ;use stack to load status
|
||
0727 : a933 > lda #$33 ;precharge accu
|
||
0729 : 28 > plp
|
||
>
|
||
072a : 0f0a06 > bbr 0,zpt,fail10196
|
||
072d : 8f0a06 > bbs 0,zpt,ok10196
|
||
> trap ;bbs branch not taken
|
||
0730 : 4c3007 > jmp * ;failed anyway
|
||
>
|
||
0733 : >fail10196
|
||
> trap ;bbr branch taken
|
||
0733 : 4c3307 > jmp * ;failed anyway
|
||
>
|
||
0736 : >ok10196
|
||
> tst_a $33,0
|
||
0736 : 08 > php ;save flags
|
||
0737 : c933 > cmp #$33 ;test result
|
||
> trap_ne
|
||
0739 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
073b : 68 > pla ;load status
|
||
073c : 48 > pha
|
||
> cmp_flag 0
|
||
073d : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
073f : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0741 : 28 > plp ;restore status
|
||
>
|
||
> set_a $cc,$ff ;with flags on
|
||
> load_flag $ff
|
||
0742 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
0744 : 48 > pha ;use stack to load status
|
||
0745 : a9cc > lda #$cc ;precharge accu
|
||
0747 : 28 > plp
|
||
>
|
||
0748 : 0f0a06 > bbr 0,zpt,fail20196
|
||
074b : 8f0a06 > bbs 0,zpt,ok20196
|
||
> trap ;bbs branch not taken
|
||
074e : 4c4e07 > jmp * ;failed anyway
|
||
>
|
||
0751 : >fail20196
|
||
> trap ;bbr branch taken
|
||
0751 : 4c5107 > jmp * ;failed anyway
|
||
>
|
||
0754 : >ok20196
|
||
> tst_a $cc,$ff
|
||
0754 : 08 > php ;save flags
|
||
0755 : c9cc > cmp #$cc ;test result
|
||
> trap_ne
|
||
0757 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0759 : 68 > pla ;load status
|
||
075a : 48 > pha
|
||
> cmp_flag $ff
|
||
075b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
075d : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
075f : 28 > plp ;restore status
|
||
>
|
||
0760 : a50a > lda zpt
|
||
0762 : c901 > cmp #(1<<0)
|
||
> trap_ne ;zp altered
|
||
0764 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0766 : a9fe > lda #$ff-(1<<0) ;testing 1 bit off
|
||
0768 : 850a > sta zpt
|
||
> set_a $33,0 ;with flags off
|
||
> load_flag 0
|
||
076a : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
076c : 48 > pha ;use stack to load status
|
||
076d : a933 > lda #$33 ;precharge accu
|
||
076f : 28 > plp
|
||
>
|
||
0770 : 8f0a06 > bbs 0,zpt,fail30196
|
||
0773 : 0f0a06 > bbr 0,zpt,ok30196
|
||
> trap ;bbr branch not taken
|
||
0776 : 4c7607 > jmp * ;failed anyway
|
||
>
|
||
0779 : >fail30196
|
||
> trap ;bbs branch taken
|
||
0779 : 4c7907 > jmp * ;failed anyway
|
||
>
|
||
077c : >ok30196
|
||
> tst_a $33,0
|
||
077c : 08 > php ;save flags
|
||
077d : c933 > cmp #$33 ;test result
|
||
> trap_ne
|
||
077f : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0781 : 68 > pla ;load status
|
||
0782 : 48 > pha
|
||
> cmp_flag 0
|
||
0783 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0785 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0787 : 28 > plp ;restore status
|
||
>
|
||
> set_a $cc,$ff ;with flags on
|
||
> load_flag $ff
|
||
0788 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
078a : 48 > pha ;use stack to load status
|
||
078b : a9cc > lda #$cc ;precharge accu
|
||
078d : 28 > plp
|
||
>
|
||
078e : 8f0a06 > bbs 0,zpt,fail40196
|
||
0791 : 0f0a06 > bbr 0,zpt,ok40196
|
||
> trap ;bbr branch not taken
|
||
0794 : 4c9407 > jmp * ;failed anyway
|
||
>
|
||
0797 : >fail40196
|
||
> trap ;bbs branch taken
|
||
0797 : 4c9707 > jmp * ;failed anyway
|
||
>
|
||
079a : >ok40196
|
||
> tst_a $cc,$ff
|
||
079a : 08 > php ;save flags
|
||
079b : c9cc > cmp #$cc ;test result
|
||
> trap_ne
|
||
079d : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
079f : 68 > pla ;load status
|
||
07a0 : 48 > pha
|
||
> cmp_flag $ff
|
||
07a1 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
07a3 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
07a5 : 28 > plp ;restore status
|
||
>
|
||
07a6 : a50a > lda zpt
|
||
07a8 : c9fe > cmp #$ff-(1<<0)
|
||
> trap_ne ;zp altered
|
||
07aa : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
bbt 1
|
||
07ac : a902 > lda #(1<<1) ;testing 1 bit on
|
||
07ae : 850a > sta zpt
|
||
> set_a $33,0 ;with flags off
|
||
> load_flag 0
|
||
07b0 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
07b2 : 48 > pha ;use stack to load status
|
||
07b3 : a933 > lda #$33 ;precharge accu
|
||
07b5 : 28 > plp
|
||
>
|
||
07b6 : 1f0a06 > bbr 1,zpt,fail10231
|
||
07b9 : 9f0a06 > bbs 1,zpt,ok10231
|
||
> trap ;bbs branch not taken
|
||
07bc : 4cbc07 > jmp * ;failed anyway
|
||
>
|
||
07bf : >fail10231
|
||
> trap ;bbr branch taken
|
||
07bf : 4cbf07 > jmp * ;failed anyway
|
||
>
|
||
07c2 : >ok10231
|
||
> tst_a $33,0
|
||
07c2 : 08 > php ;save flags
|
||
07c3 : c933 > cmp #$33 ;test result
|
||
> trap_ne
|
||
07c5 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
07c7 : 68 > pla ;load status
|
||
07c8 : 48 > pha
|
||
> cmp_flag 0
|
||
07c9 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
07cb : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
07cd : 28 > plp ;restore status
|
||
>
|
||
> set_a $cc,$ff ;with flags on
|
||
> load_flag $ff
|
||
07ce : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
07d0 : 48 > pha ;use stack to load status
|
||
07d1 : a9cc > lda #$cc ;precharge accu
|
||
07d3 : 28 > plp
|
||
>
|
||
07d4 : 1f0a06 > bbr 1,zpt,fail20231
|
||
07d7 : 9f0a06 > bbs 1,zpt,ok20231
|
||
> trap ;bbs branch not taken
|
||
07da : 4cda07 > jmp * ;failed anyway
|
||
>
|
||
07dd : >fail20231
|
||
> trap ;bbr branch taken
|
||
07dd : 4cdd07 > jmp * ;failed anyway
|
||
>
|
||
07e0 : >ok20231
|
||
> tst_a $cc,$ff
|
||
07e0 : 08 > php ;save flags
|
||
07e1 : c9cc > cmp #$cc ;test result
|
||
> trap_ne
|
||
07e3 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
07e5 : 68 > pla ;load status
|
||
07e6 : 48 > pha
|
||
> cmp_flag $ff
|
||
07e7 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
07e9 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
07eb : 28 > plp ;restore status
|
||
>
|
||
07ec : a50a > lda zpt
|
||
07ee : c902 > cmp #(1<<1)
|
||
> trap_ne ;zp altered
|
||
07f0 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
07f2 : a9fd > lda #$ff-(1<<1) ;testing 1 bit off
|
||
07f4 : 850a > sta zpt
|
||
> set_a $33,0 ;with flags off
|
||
> load_flag 0
|
||
07f6 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
07f8 : 48 > pha ;use stack to load status
|
||
07f9 : a933 > lda #$33 ;precharge accu
|
||
07fb : 28 > plp
|
||
>
|
||
07fc : 9f0a06 > bbs 1,zpt,fail30231
|
||
07ff : 1f0a06 > bbr 1,zpt,ok30231
|
||
> trap ;bbr branch not taken
|
||
0802 : 4c0208 > jmp * ;failed anyway
|
||
>
|
||
0805 : >fail30231
|
||
> trap ;bbs branch taken
|
||
0805 : 4c0508 > jmp * ;failed anyway
|
||
>
|
||
0808 : >ok30231
|
||
> tst_a $33,0
|
||
0808 : 08 > php ;save flags
|
||
0809 : c933 > cmp #$33 ;test result
|
||
> trap_ne
|
||
080b : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
080d : 68 > pla ;load status
|
||
080e : 48 > pha
|
||
> cmp_flag 0
|
||
080f : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0811 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0813 : 28 > plp ;restore status
|
||
>
|
||
> set_a $cc,$ff ;with flags on
|
||
> load_flag $ff
|
||
0814 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
0816 : 48 > pha ;use stack to load status
|
||
0817 : a9cc > lda #$cc ;precharge accu
|
||
0819 : 28 > plp
|
||
>
|
||
081a : 9f0a06 > bbs 1,zpt,fail40231
|
||
081d : 1f0a06 > bbr 1,zpt,ok40231
|
||
> trap ;bbr branch not taken
|
||
0820 : 4c2008 > jmp * ;failed anyway
|
||
>
|
||
0823 : >fail40231
|
||
> trap ;bbs branch taken
|
||
0823 : 4c2308 > jmp * ;failed anyway
|
||
>
|
||
0826 : >ok40231
|
||
> tst_a $cc,$ff
|
||
0826 : 08 > php ;save flags
|
||
0827 : c9cc > cmp #$cc ;test result
|
||
> trap_ne
|
||
0829 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
082b : 68 > pla ;load status
|
||
082c : 48 > pha
|
||
> cmp_flag $ff
|
||
082d : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
082f : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0831 : 28 > plp ;restore status
|
||
>
|
||
0832 : a50a > lda zpt
|
||
0834 : c9fd > cmp #$ff-(1<<1)
|
||
> trap_ne ;zp altered
|
||
0836 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
bbt 2
|
||
0838 : a904 > lda #(1<<2) ;testing 1 bit on
|
||
083a : 850a > sta zpt
|
||
> set_a $33,0 ;with flags off
|
||
> load_flag 0
|
||
083c : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
083e : 48 > pha ;use stack to load status
|
||
083f : a933 > lda #$33 ;precharge accu
|
||
0841 : 28 > plp
|
||
>
|
||
0842 : 2f0a06 > bbr 2,zpt,fail10266
|
||
0845 : af0a06 > bbs 2,zpt,ok10266
|
||
> trap ;bbs branch not taken
|
||
0848 : 4c4808 > jmp * ;failed anyway
|
||
>
|
||
084b : >fail10266
|
||
> trap ;bbr branch taken
|
||
084b : 4c4b08 > jmp * ;failed anyway
|
||
>
|
||
084e : >ok10266
|
||
> tst_a $33,0
|
||
084e : 08 > php ;save flags
|
||
084f : c933 > cmp #$33 ;test result
|
||
> trap_ne
|
||
0851 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0853 : 68 > pla ;load status
|
||
0854 : 48 > pha
|
||
> cmp_flag 0
|
||
0855 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0857 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0859 : 28 > plp ;restore status
|
||
>
|
||
> set_a $cc,$ff ;with flags on
|
||
> load_flag $ff
|
||
085a : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
085c : 48 > pha ;use stack to load status
|
||
085d : a9cc > lda #$cc ;precharge accu
|
||
085f : 28 > plp
|
||
>
|
||
0860 : 2f0a06 > bbr 2,zpt,fail20266
|
||
0863 : af0a06 > bbs 2,zpt,ok20266
|
||
> trap ;bbs branch not taken
|
||
0866 : 4c6608 > jmp * ;failed anyway
|
||
>
|
||
0869 : >fail20266
|
||
> trap ;bbr branch taken
|
||
0869 : 4c6908 > jmp * ;failed anyway
|
||
>
|
||
086c : >ok20266
|
||
> tst_a $cc,$ff
|
||
086c : 08 > php ;save flags
|
||
086d : c9cc > cmp #$cc ;test result
|
||
> trap_ne
|
||
086f : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0871 : 68 > pla ;load status
|
||
0872 : 48 > pha
|
||
> cmp_flag $ff
|
||
0873 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0875 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0877 : 28 > plp ;restore status
|
||
>
|
||
0878 : a50a > lda zpt
|
||
087a : c904 > cmp #(1<<2)
|
||
> trap_ne ;zp altered
|
||
087c : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
087e : a9fb > lda #$ff-(1<<2) ;testing 1 bit off
|
||
0880 : 850a > sta zpt
|
||
> set_a $33,0 ;with flags off
|
||
> load_flag 0
|
||
0882 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
0884 : 48 > pha ;use stack to load status
|
||
0885 : a933 > lda #$33 ;precharge accu
|
||
0887 : 28 > plp
|
||
>
|
||
0888 : af0a06 > bbs 2,zpt,fail30266
|
||
088b : 2f0a06 > bbr 2,zpt,ok30266
|
||
> trap ;bbr branch not taken
|
||
088e : 4c8e08 > jmp * ;failed anyway
|
||
>
|
||
0891 : >fail30266
|
||
> trap ;bbs branch taken
|
||
0891 : 4c9108 > jmp * ;failed anyway
|
||
>
|
||
0894 : >ok30266
|
||
> tst_a $33,0
|
||
0894 : 08 > php ;save flags
|
||
0895 : c933 > cmp #$33 ;test result
|
||
> trap_ne
|
||
0897 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0899 : 68 > pla ;load status
|
||
089a : 48 > pha
|
||
> cmp_flag 0
|
||
089b : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
089d : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
089f : 28 > plp ;restore status
|
||
>
|
||
> set_a $cc,$ff ;with flags on
|
||
> load_flag $ff
|
||
08a0 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
08a2 : 48 > pha ;use stack to load status
|
||
08a3 : a9cc > lda #$cc ;precharge accu
|
||
08a5 : 28 > plp
|
||
>
|
||
08a6 : af0a06 > bbs 2,zpt,fail40266
|
||
08a9 : 2f0a06 > bbr 2,zpt,ok40266
|
||
> trap ;bbr branch not taken
|
||
08ac : 4cac08 > jmp * ;failed anyway
|
||
>
|
||
08af : >fail40266
|
||
> trap ;bbs branch taken
|
||
08af : 4caf08 > jmp * ;failed anyway
|
||
>
|
||
08b2 : >ok40266
|
||
> tst_a $cc,$ff
|
||
08b2 : 08 > php ;save flags
|
||
08b3 : c9cc > cmp #$cc ;test result
|
||
> trap_ne
|
||
08b5 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
08b7 : 68 > pla ;load status
|
||
08b8 : 48 > pha
|
||
> cmp_flag $ff
|
||
08b9 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
08bb : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
08bd : 28 > plp ;restore status
|
||
>
|
||
08be : a50a > lda zpt
|
||
08c0 : c9fb > cmp #$ff-(1<<2)
|
||
> trap_ne ;zp altered
|
||
08c2 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
bbt 3
|
||
08c4 : a908 > lda #(1<<3) ;testing 1 bit on
|
||
08c6 : 850a > sta zpt
|
||
> set_a $33,0 ;with flags off
|
||
> load_flag 0
|
||
08c8 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
08ca : 48 > pha ;use stack to load status
|
||
08cb : a933 > lda #$33 ;precharge accu
|
||
08cd : 28 > plp
|
||
>
|
||
08ce : 3f0a06 > bbr 3,zpt,fail10301
|
||
08d1 : bf0a06 > bbs 3,zpt,ok10301
|
||
> trap ;bbs branch not taken
|
||
08d4 : 4cd408 > jmp * ;failed anyway
|
||
>
|
||
08d7 : >fail10301
|
||
> trap ;bbr branch taken
|
||
08d7 : 4cd708 > jmp * ;failed anyway
|
||
>
|
||
08da : >ok10301
|
||
> tst_a $33,0
|
||
08da : 08 > php ;save flags
|
||
08db : c933 > cmp #$33 ;test result
|
||
> trap_ne
|
||
08dd : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
08df : 68 > pla ;load status
|
||
08e0 : 48 > pha
|
||
> cmp_flag 0
|
||
08e1 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
08e3 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
08e5 : 28 > plp ;restore status
|
||
>
|
||
> set_a $cc,$ff ;with flags on
|
||
> load_flag $ff
|
||
08e6 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
08e8 : 48 > pha ;use stack to load status
|
||
08e9 : a9cc > lda #$cc ;precharge accu
|
||
08eb : 28 > plp
|
||
>
|
||
08ec : 3f0a06 > bbr 3,zpt,fail20301
|
||
08ef : bf0a06 > bbs 3,zpt,ok20301
|
||
> trap ;bbs branch not taken
|
||
08f2 : 4cf208 > jmp * ;failed anyway
|
||
>
|
||
08f5 : >fail20301
|
||
> trap ;bbr branch taken
|
||
08f5 : 4cf508 > jmp * ;failed anyway
|
||
>
|
||
08f8 : >ok20301
|
||
> tst_a $cc,$ff
|
||
08f8 : 08 > php ;save flags
|
||
08f9 : c9cc > cmp #$cc ;test result
|
||
> trap_ne
|
||
08fb : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
08fd : 68 > pla ;load status
|
||
08fe : 48 > pha
|
||
> cmp_flag $ff
|
||
08ff : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0901 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0903 : 28 > plp ;restore status
|
||
>
|
||
0904 : a50a > lda zpt
|
||
0906 : c908 > cmp #(1<<3)
|
||
> trap_ne ;zp altered
|
||
0908 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
090a : a9f7 > lda #$ff-(1<<3) ;testing 1 bit off
|
||
090c : 850a > sta zpt
|
||
> set_a $33,0 ;with flags off
|
||
> load_flag 0
|
||
090e : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
0910 : 48 > pha ;use stack to load status
|
||
0911 : a933 > lda #$33 ;precharge accu
|
||
0913 : 28 > plp
|
||
>
|
||
0914 : bf0a06 > bbs 3,zpt,fail30301
|
||
0917 : 3f0a06 > bbr 3,zpt,ok30301
|
||
> trap ;bbr branch not taken
|
||
091a : 4c1a09 > jmp * ;failed anyway
|
||
>
|
||
091d : >fail30301
|
||
> trap ;bbs branch taken
|
||
091d : 4c1d09 > jmp * ;failed anyway
|
||
>
|
||
0920 : >ok30301
|
||
> tst_a $33,0
|
||
0920 : 08 > php ;save flags
|
||
0921 : c933 > cmp #$33 ;test result
|
||
> trap_ne
|
||
0923 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0925 : 68 > pla ;load status
|
||
0926 : 48 > pha
|
||
> cmp_flag 0
|
||
0927 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0929 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
092b : 28 > plp ;restore status
|
||
>
|
||
> set_a $cc,$ff ;with flags on
|
||
> load_flag $ff
|
||
092c : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
092e : 48 > pha ;use stack to load status
|
||
092f : a9cc > lda #$cc ;precharge accu
|
||
0931 : 28 > plp
|
||
>
|
||
0932 : bf0a06 > bbs 3,zpt,fail40301
|
||
0935 : 3f0a06 > bbr 3,zpt,ok40301
|
||
> trap ;bbr branch not taken
|
||
0938 : 4c3809 > jmp * ;failed anyway
|
||
>
|
||
093b : >fail40301
|
||
> trap ;bbs branch taken
|
||
093b : 4c3b09 > jmp * ;failed anyway
|
||
>
|
||
093e : >ok40301
|
||
> tst_a $cc,$ff
|
||
093e : 08 > php ;save flags
|
||
093f : c9cc > cmp #$cc ;test result
|
||
> trap_ne
|
||
0941 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0943 : 68 > pla ;load status
|
||
0944 : 48 > pha
|
||
> cmp_flag $ff
|
||
0945 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0947 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0949 : 28 > plp ;restore status
|
||
>
|
||
094a : a50a > lda zpt
|
||
094c : c9f7 > cmp #$ff-(1<<3)
|
||
> trap_ne ;zp altered
|
||
094e : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
bbt 4
|
||
0950 : a910 > lda #(1<<4) ;testing 1 bit on
|
||
0952 : 850a > sta zpt
|
||
> set_a $33,0 ;with flags off
|
||
> load_flag 0
|
||
0954 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
0956 : 48 > pha ;use stack to load status
|
||
0957 : a933 > lda #$33 ;precharge accu
|
||
0959 : 28 > plp
|
||
>
|
||
095a : 4f0a06 > bbr 4,zpt,fail10336
|
||
095d : cf0a06 > bbs 4,zpt,ok10336
|
||
> trap ;bbs branch not taken
|
||
0960 : 4c6009 > jmp * ;failed anyway
|
||
>
|
||
0963 : >fail10336
|
||
> trap ;bbr branch taken
|
||
0963 : 4c6309 > jmp * ;failed anyway
|
||
>
|
||
0966 : >ok10336
|
||
> tst_a $33,0
|
||
0966 : 08 > php ;save flags
|
||
0967 : c933 > cmp #$33 ;test result
|
||
> trap_ne
|
||
0969 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
096b : 68 > pla ;load status
|
||
096c : 48 > pha
|
||
> cmp_flag 0
|
||
096d : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
096f : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0971 : 28 > plp ;restore status
|
||
>
|
||
> set_a $cc,$ff ;with flags on
|
||
> load_flag $ff
|
||
0972 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
0974 : 48 > pha ;use stack to load status
|
||
0975 : a9cc > lda #$cc ;precharge accu
|
||
0977 : 28 > plp
|
||
>
|
||
0978 : 4f0a06 > bbr 4,zpt,fail20336
|
||
097b : cf0a06 > bbs 4,zpt,ok20336
|
||
> trap ;bbs branch not taken
|
||
097e : 4c7e09 > jmp * ;failed anyway
|
||
>
|
||
0981 : >fail20336
|
||
> trap ;bbr branch taken
|
||
0981 : 4c8109 > jmp * ;failed anyway
|
||
>
|
||
0984 : >ok20336
|
||
> tst_a $cc,$ff
|
||
0984 : 08 > php ;save flags
|
||
0985 : c9cc > cmp #$cc ;test result
|
||
> trap_ne
|
||
0987 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0989 : 68 > pla ;load status
|
||
098a : 48 > pha
|
||
> cmp_flag $ff
|
||
098b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
098d : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
098f : 28 > plp ;restore status
|
||
>
|
||
0990 : a50a > lda zpt
|
||
0992 : c910 > cmp #(1<<4)
|
||
> trap_ne ;zp altered
|
||
0994 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0996 : a9ef > lda #$ff-(1<<4) ;testing 1 bit off
|
||
0998 : 850a > sta zpt
|
||
> set_a $33,0 ;with flags off
|
||
> load_flag 0
|
||
099a : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
099c : 48 > pha ;use stack to load status
|
||
099d : a933 > lda #$33 ;precharge accu
|
||
099f : 28 > plp
|
||
>
|
||
09a0 : cf0a06 > bbs 4,zpt,fail30336
|
||
09a3 : 4f0a06 > bbr 4,zpt,ok30336
|
||
> trap ;bbr branch not taken
|
||
09a6 : 4ca609 > jmp * ;failed anyway
|
||
>
|
||
09a9 : >fail30336
|
||
> trap ;bbs branch taken
|
||
09a9 : 4ca909 > jmp * ;failed anyway
|
||
>
|
||
09ac : >ok30336
|
||
> tst_a $33,0
|
||
09ac : 08 > php ;save flags
|
||
09ad : c933 > cmp #$33 ;test result
|
||
> trap_ne
|
||
09af : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
09b1 : 68 > pla ;load status
|
||
09b2 : 48 > pha
|
||
> cmp_flag 0
|
||
09b3 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
09b5 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
09b7 : 28 > plp ;restore status
|
||
>
|
||
> set_a $cc,$ff ;with flags on
|
||
> load_flag $ff
|
||
09b8 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
09ba : 48 > pha ;use stack to load status
|
||
09bb : a9cc > lda #$cc ;precharge accu
|
||
09bd : 28 > plp
|
||
>
|
||
09be : cf0a06 > bbs 4,zpt,fail40336
|
||
09c1 : 4f0a06 > bbr 4,zpt,ok40336
|
||
> trap ;bbr branch not taken
|
||
09c4 : 4cc409 > jmp * ;failed anyway
|
||
>
|
||
09c7 : >fail40336
|
||
> trap ;bbs branch taken
|
||
09c7 : 4cc709 > jmp * ;failed anyway
|
||
>
|
||
09ca : >ok40336
|
||
> tst_a $cc,$ff
|
||
09ca : 08 > php ;save flags
|
||
09cb : c9cc > cmp #$cc ;test result
|
||
> trap_ne
|
||
09cd : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
09cf : 68 > pla ;load status
|
||
09d0 : 48 > pha
|
||
> cmp_flag $ff
|
||
09d1 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
09d3 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
09d5 : 28 > plp ;restore status
|
||
>
|
||
09d6 : a50a > lda zpt
|
||
09d8 : c9ef > cmp #$ff-(1<<4)
|
||
> trap_ne ;zp altered
|
||
09da : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
bbt 5
|
||
09dc : a920 > lda #(1<<5) ;testing 1 bit on
|
||
09de : 850a > sta zpt
|
||
> set_a $33,0 ;with flags off
|
||
> load_flag 0
|
||
09e0 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
09e2 : 48 > pha ;use stack to load status
|
||
09e3 : a933 > lda #$33 ;precharge accu
|
||
09e5 : 28 > plp
|
||
>
|
||
09e6 : 5f0a06 > bbr 5,zpt,fail10371
|
||
09e9 : df0a06 > bbs 5,zpt,ok10371
|
||
> trap ;bbs branch not taken
|
||
09ec : 4cec09 > jmp * ;failed anyway
|
||
>
|
||
09ef : >fail10371
|
||
> trap ;bbr branch taken
|
||
09ef : 4cef09 > jmp * ;failed anyway
|
||
>
|
||
09f2 : >ok10371
|
||
> tst_a $33,0
|
||
09f2 : 08 > php ;save flags
|
||
09f3 : c933 > cmp #$33 ;test result
|
||
> trap_ne
|
||
09f5 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
09f7 : 68 > pla ;load status
|
||
09f8 : 48 > pha
|
||
> cmp_flag 0
|
||
09f9 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
09fb : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
09fd : 28 > plp ;restore status
|
||
>
|
||
> set_a $cc,$ff ;with flags on
|
||
> load_flag $ff
|
||
09fe : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
0a00 : 48 > pha ;use stack to load status
|
||
0a01 : a9cc > lda #$cc ;precharge accu
|
||
0a03 : 28 > plp
|
||
>
|
||
0a04 : 5f0a06 > bbr 5,zpt,fail20371
|
||
0a07 : df0a06 > bbs 5,zpt,ok20371
|
||
> trap ;bbs branch not taken
|
||
0a0a : 4c0a0a > jmp * ;failed anyway
|
||
>
|
||
0a0d : >fail20371
|
||
> trap ;bbr branch taken
|
||
0a0d : 4c0d0a > jmp * ;failed anyway
|
||
>
|
||
0a10 : >ok20371
|
||
> tst_a $cc,$ff
|
||
0a10 : 08 > php ;save flags
|
||
0a11 : c9cc > cmp #$cc ;test result
|
||
> trap_ne
|
||
0a13 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0a15 : 68 > pla ;load status
|
||
0a16 : 48 > pha
|
||
> cmp_flag $ff
|
||
0a17 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0a19 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0a1b : 28 > plp ;restore status
|
||
>
|
||
0a1c : a50a > lda zpt
|
||
0a1e : c920 > cmp #(1<<5)
|
||
> trap_ne ;zp altered
|
||
0a20 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0a22 : a9df > lda #$ff-(1<<5) ;testing 1 bit off
|
||
0a24 : 850a > sta zpt
|
||
> set_a $33,0 ;with flags off
|
||
> load_flag 0
|
||
0a26 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
0a28 : 48 > pha ;use stack to load status
|
||
0a29 : a933 > lda #$33 ;precharge accu
|
||
0a2b : 28 > plp
|
||
>
|
||
0a2c : df0a06 > bbs 5,zpt,fail30371
|
||
0a2f : 5f0a06 > bbr 5,zpt,ok30371
|
||
> trap ;bbr branch not taken
|
||
0a32 : 4c320a > jmp * ;failed anyway
|
||
>
|
||
0a35 : >fail30371
|
||
> trap ;bbs branch taken
|
||
0a35 : 4c350a > jmp * ;failed anyway
|
||
>
|
||
0a38 : >ok30371
|
||
> tst_a $33,0
|
||
0a38 : 08 > php ;save flags
|
||
0a39 : c933 > cmp #$33 ;test result
|
||
> trap_ne
|
||
0a3b : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0a3d : 68 > pla ;load status
|
||
0a3e : 48 > pha
|
||
> cmp_flag 0
|
||
0a3f : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0a41 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0a43 : 28 > plp ;restore status
|
||
>
|
||
> set_a $cc,$ff ;with flags on
|
||
> load_flag $ff
|
||
0a44 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
0a46 : 48 > pha ;use stack to load status
|
||
0a47 : a9cc > lda #$cc ;precharge accu
|
||
0a49 : 28 > plp
|
||
>
|
||
0a4a : df0a06 > bbs 5,zpt,fail40371
|
||
0a4d : 5f0a06 > bbr 5,zpt,ok40371
|
||
> trap ;bbr branch not taken
|
||
0a50 : 4c500a > jmp * ;failed anyway
|
||
>
|
||
0a53 : >fail40371
|
||
> trap ;bbs branch taken
|
||
0a53 : 4c530a > jmp * ;failed anyway
|
||
>
|
||
0a56 : >ok40371
|
||
> tst_a $cc,$ff
|
||
0a56 : 08 > php ;save flags
|
||
0a57 : c9cc > cmp #$cc ;test result
|
||
> trap_ne
|
||
0a59 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0a5b : 68 > pla ;load status
|
||
0a5c : 48 > pha
|
||
> cmp_flag $ff
|
||
0a5d : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0a5f : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0a61 : 28 > plp ;restore status
|
||
>
|
||
0a62 : a50a > lda zpt
|
||
0a64 : c9df > cmp #$ff-(1<<5)
|
||
> trap_ne ;zp altered
|
||
0a66 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
bbt 6
|
||
0a68 : a940 > lda #(1<<6) ;testing 1 bit on
|
||
0a6a : 850a > sta zpt
|
||
> set_a $33,0 ;with flags off
|
||
> load_flag 0
|
||
0a6c : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
0a6e : 48 > pha ;use stack to load status
|
||
0a6f : a933 > lda #$33 ;precharge accu
|
||
0a71 : 28 > plp
|
||
>
|
||
0a72 : 6f0a06 > bbr 6,zpt,fail10406
|
||
0a75 : ef0a06 > bbs 6,zpt,ok10406
|
||
> trap ;bbs branch not taken
|
||
0a78 : 4c780a > jmp * ;failed anyway
|
||
>
|
||
0a7b : >fail10406
|
||
> trap ;bbr branch taken
|
||
0a7b : 4c7b0a > jmp * ;failed anyway
|
||
>
|
||
0a7e : >ok10406
|
||
> tst_a $33,0
|
||
0a7e : 08 > php ;save flags
|
||
0a7f : c933 > cmp #$33 ;test result
|
||
> trap_ne
|
||
0a81 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0a83 : 68 > pla ;load status
|
||
0a84 : 48 > pha
|
||
> cmp_flag 0
|
||
0a85 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0a87 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0a89 : 28 > plp ;restore status
|
||
>
|
||
> set_a $cc,$ff ;with flags on
|
||
> load_flag $ff
|
||
0a8a : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
0a8c : 48 > pha ;use stack to load status
|
||
0a8d : a9cc > lda #$cc ;precharge accu
|
||
0a8f : 28 > plp
|
||
>
|
||
0a90 : 6f0a06 > bbr 6,zpt,fail20406
|
||
0a93 : ef0a06 > bbs 6,zpt,ok20406
|
||
> trap ;bbs branch not taken
|
||
0a96 : 4c960a > jmp * ;failed anyway
|
||
>
|
||
0a99 : >fail20406
|
||
> trap ;bbr branch taken
|
||
0a99 : 4c990a > jmp * ;failed anyway
|
||
>
|
||
0a9c : >ok20406
|
||
> tst_a $cc,$ff
|
||
0a9c : 08 > php ;save flags
|
||
0a9d : c9cc > cmp #$cc ;test result
|
||
> trap_ne
|
||
0a9f : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0aa1 : 68 > pla ;load status
|
||
0aa2 : 48 > pha
|
||
> cmp_flag $ff
|
||
0aa3 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0aa5 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0aa7 : 28 > plp ;restore status
|
||
>
|
||
0aa8 : a50a > lda zpt
|
||
0aaa : c940 > cmp #(1<<6)
|
||
> trap_ne ;zp altered
|
||
0aac : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0aae : a9bf > lda #$ff-(1<<6) ;testing 1 bit off
|
||
0ab0 : 850a > sta zpt
|
||
> set_a $33,0 ;with flags off
|
||
> load_flag 0
|
||
0ab2 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
0ab4 : 48 > pha ;use stack to load status
|
||
0ab5 : a933 > lda #$33 ;precharge accu
|
||
0ab7 : 28 > plp
|
||
>
|
||
0ab8 : ef0a06 > bbs 6,zpt,fail30406
|
||
0abb : 6f0a06 > bbr 6,zpt,ok30406
|
||
> trap ;bbr branch not taken
|
||
0abe : 4cbe0a > jmp * ;failed anyway
|
||
>
|
||
0ac1 : >fail30406
|
||
> trap ;bbs branch taken
|
||
0ac1 : 4cc10a > jmp * ;failed anyway
|
||
>
|
||
0ac4 : >ok30406
|
||
> tst_a $33,0
|
||
0ac4 : 08 > php ;save flags
|
||
0ac5 : c933 > cmp #$33 ;test result
|
||
> trap_ne
|
||
0ac7 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0ac9 : 68 > pla ;load status
|
||
0aca : 48 > pha
|
||
> cmp_flag 0
|
||
0acb : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0acd : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0acf : 28 > plp ;restore status
|
||
>
|
||
> set_a $cc,$ff ;with flags on
|
||
> load_flag $ff
|
||
0ad0 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
0ad2 : 48 > pha ;use stack to load status
|
||
0ad3 : a9cc > lda #$cc ;precharge accu
|
||
0ad5 : 28 > plp
|
||
>
|
||
0ad6 : ef0a06 > bbs 6,zpt,fail40406
|
||
0ad9 : 6f0a06 > bbr 6,zpt,ok40406
|
||
> trap ;bbr branch not taken
|
||
0adc : 4cdc0a > jmp * ;failed anyway
|
||
>
|
||
0adf : >fail40406
|
||
> trap ;bbs branch taken
|
||
0adf : 4cdf0a > jmp * ;failed anyway
|
||
>
|
||
0ae2 : >ok40406
|
||
> tst_a $cc,$ff
|
||
0ae2 : 08 > php ;save flags
|
||
0ae3 : c9cc > cmp #$cc ;test result
|
||
> trap_ne
|
||
0ae5 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0ae7 : 68 > pla ;load status
|
||
0ae8 : 48 > pha
|
||
> cmp_flag $ff
|
||
0ae9 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0aeb : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0aed : 28 > plp ;restore status
|
||
>
|
||
0aee : a50a > lda zpt
|
||
0af0 : c9bf > cmp #$ff-(1<<6)
|
||
> trap_ne ;zp altered
|
||
0af2 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
bbt 7
|
||
0af4 : a980 > lda #(1<<7) ;testing 1 bit on
|
||
0af6 : 850a > sta zpt
|
||
> set_a $33,0 ;with flags off
|
||
> load_flag 0
|
||
0af8 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
0afa : 48 > pha ;use stack to load status
|
||
0afb : a933 > lda #$33 ;precharge accu
|
||
0afd : 28 > plp
|
||
>
|
||
0afe : 7f0a06 > bbr 7,zpt,fail10441
|
||
0b01 : ff0a06 > bbs 7,zpt,ok10441
|
||
> trap ;bbs branch not taken
|
||
0b04 : 4c040b > jmp * ;failed anyway
|
||
>
|
||
0b07 : >fail10441
|
||
> trap ;bbr branch taken
|
||
0b07 : 4c070b > jmp * ;failed anyway
|
||
>
|
||
0b0a : >ok10441
|
||
> tst_a $33,0
|
||
0b0a : 08 > php ;save flags
|
||
0b0b : c933 > cmp #$33 ;test result
|
||
> trap_ne
|
||
0b0d : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0b0f : 68 > pla ;load status
|
||
0b10 : 48 > pha
|
||
> cmp_flag 0
|
||
0b11 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0b13 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0b15 : 28 > plp ;restore status
|
||
>
|
||
> set_a $cc,$ff ;with flags on
|
||
> load_flag $ff
|
||
0b16 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
0b18 : 48 > pha ;use stack to load status
|
||
0b19 : a9cc > lda #$cc ;precharge accu
|
||
0b1b : 28 > plp
|
||
>
|
||
0b1c : 7f0a06 > bbr 7,zpt,fail20441
|
||
0b1f : ff0a06 > bbs 7,zpt,ok20441
|
||
> trap ;bbs branch not taken
|
||
0b22 : 4c220b > jmp * ;failed anyway
|
||
>
|
||
0b25 : >fail20441
|
||
> trap ;bbr branch taken
|
||
0b25 : 4c250b > jmp * ;failed anyway
|
||
>
|
||
0b28 : >ok20441
|
||
> tst_a $cc,$ff
|
||
0b28 : 08 > php ;save flags
|
||
0b29 : c9cc > cmp #$cc ;test result
|
||
> trap_ne
|
||
0b2b : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0b2d : 68 > pla ;load status
|
||
0b2e : 48 > pha
|
||
> cmp_flag $ff
|
||
0b2f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0b31 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0b33 : 28 > plp ;restore status
|
||
>
|
||
0b34 : a50a > lda zpt
|
||
0b36 : c980 > cmp #(1<<7)
|
||
> trap_ne ;zp altered
|
||
0b38 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0b3a : a97f > lda #$ff-(1<<7) ;testing 1 bit off
|
||
0b3c : 850a > sta zpt
|
||
> set_a $33,0 ;with flags off
|
||
> load_flag 0
|
||
0b3e : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
0b40 : 48 > pha ;use stack to load status
|
||
0b41 : a933 > lda #$33 ;precharge accu
|
||
0b43 : 28 > plp
|
||
>
|
||
0b44 : ff0a06 > bbs 7,zpt,fail30441
|
||
0b47 : 7f0a06 > bbr 7,zpt,ok30441
|
||
> trap ;bbr branch not taken
|
||
0b4a : 4c4a0b > jmp * ;failed anyway
|
||
>
|
||
0b4d : >fail30441
|
||
> trap ;bbs branch taken
|
||
0b4d : 4c4d0b > jmp * ;failed anyway
|
||
>
|
||
0b50 : >ok30441
|
||
> tst_a $33,0
|
||
0b50 : 08 > php ;save flags
|
||
0b51 : c933 > cmp #$33 ;test result
|
||
> trap_ne
|
||
0b53 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0b55 : 68 > pla ;load status
|
||
0b56 : 48 > pha
|
||
> cmp_flag 0
|
||
0b57 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0b59 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0b5b : 28 > plp ;restore status
|
||
>
|
||
> set_a $cc,$ff ;with flags on
|
||
> load_flag $ff
|
||
0b5c : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
0b5e : 48 > pha ;use stack to load status
|
||
0b5f : a9cc > lda #$cc ;precharge accu
|
||
0b61 : 28 > plp
|
||
>
|
||
0b62 : ff0a06 > bbs 7,zpt,fail40441
|
||
0b65 : 7f0a06 > bbr 7,zpt,ok40441
|
||
> trap ;bbr branch not taken
|
||
0b68 : 4c680b > jmp * ;failed anyway
|
||
>
|
||
0b6b : >fail40441
|
||
> trap ;bbs branch taken
|
||
0b6b : 4c6b0b > jmp * ;failed anyway
|
||
>
|
||
0b6e : >ok40441
|
||
> tst_a $cc,$ff
|
||
0b6e : 08 > php ;save flags
|
||
0b6f : c9cc > cmp #$cc ;test result
|
||
> trap_ne
|
||
0b71 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0b73 : 68 > pla ;load status
|
||
0b74 : 48 > pha
|
||
> cmp_flag $ff
|
||
0b75 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0b77 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0b79 : 28 > plp ;restore status
|
||
>
|
||
0b7a : a50a > lda zpt
|
||
0b7c : c97f > cmp #$ff-(1<<7)
|
||
> trap_ne ;zp altered
|
||
0b7e : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
0b80 : e011 cpx #$11
|
||
trap_ne ;x overwritten
|
||
0b82 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
0b84 : c022 cpy #$22
|
||
trap_ne ;y overwritten
|
||
0b86 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
next_test
|
||
0b88 : ad0202 > lda test_case ;previous test
|
||
0b8b : c906 > cmp #test_num
|
||
> trap_ne ;test is out of sequence
|
||
0b8d : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0007 = >test_num = test_num + 1
|
||
0b8f : a907 > lda #test_num ;*** next tests' number
|
||
0b91 : 8d0202 > sta test_case
|
||
> ;check_ram ;uncomment to find altered RAM after each test
|
||
|
||
|
||
bbrc macro ;\1 = bitnum
|
||
bbr \1,zpt,skip\?
|
||
eor #(1<<\1)
|
||
skip\?
|
||
endm
|
||
bbsc macro ;\1 = bitnum
|
||
bbs \1,zpt,skip\?
|
||
eor #(1<<\1)
|
||
skip\?
|
||
endm
|
||
|
||
0b94 : a900 lda #0 ;combined bit test
|
||
0b96 : 850a sta zpt
|
||
0b98 : a900 bbcl lda #0
|
||
bbrc 0
|
||
0b9a : 0f0a02 > bbr 0,zpt,skip0480
|
||
0b9d : 4901 > eor #(1<<0)
|
||
0b9f : >skip0480
|
||
|
||
bbrc 1
|
||
0b9f : 1f0a02 > bbr 1,zpt,skip0481
|
||
0ba2 : 4902 > eor #(1<<1)
|
||
0ba4 : >skip0481
|
||
|
||
bbrc 2
|
||
0ba4 : 2f0a02 > bbr 2,zpt,skip0482
|
||
0ba7 : 4904 > eor #(1<<2)
|
||
0ba9 : >skip0482
|
||
|
||
bbrc 3
|
||
0ba9 : 3f0a02 > bbr 3,zpt,skip0483
|
||
0bac : 4908 > eor #(1<<3)
|
||
0bae : >skip0483
|
||
|
||
bbrc 4
|
||
0bae : 4f0a02 > bbr 4,zpt,skip0484
|
||
0bb1 : 4910 > eor #(1<<4)
|
||
0bb3 : >skip0484
|
||
|
||
bbrc 5
|
||
0bb3 : 5f0a02 > bbr 5,zpt,skip0485
|
||
0bb6 : 4920 > eor #(1<<5)
|
||
0bb8 : >skip0485
|
||
|
||
bbrc 6
|
||
0bb8 : 6f0a02 > bbr 6,zpt,skip0486
|
||
0bbb : 4940 > eor #(1<<6)
|
||
0bbd : >skip0486
|
||
|
||
bbrc 7
|
||
0bbd : 7f0a02 > bbr 7,zpt,skip0487
|
||
0bc0 : 4980 > eor #(1<<7)
|
||
0bc2 : >skip0487
|
||
|
||
0bc2 : 450a eor zpt
|
||
trap_ne ;failed bbr bitnum in accu
|
||
0bc4 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
0bc6 : a9ff lda #$ff
|
||
bbsc 0
|
||
0bc8 : 8f0a02 > bbs 0,zpt,skip0489
|
||
0bcb : 4901 > eor #(1<<0)
|
||
0bcd : >skip0489
|
||
|
||
bbsc 1
|
||
0bcd : 9f0a02 > bbs 1,zpt,skip0490
|
||
0bd0 : 4902 > eor #(1<<1)
|
||
0bd2 : >skip0490
|
||
|
||
bbsc 2
|
||
0bd2 : af0a02 > bbs 2,zpt,skip0491
|
||
0bd5 : 4904 > eor #(1<<2)
|
||
0bd7 : >skip0491
|
||
|
||
bbsc 3
|
||
0bd7 : bf0a02 > bbs 3,zpt,skip0492
|
||
0bda : 4908 > eor #(1<<3)
|
||
0bdc : >skip0492
|
||
|
||
bbsc 4
|
||
0bdc : cf0a02 > bbs 4,zpt,skip0493
|
||
0bdf : 4910 > eor #(1<<4)
|
||
0be1 : >skip0493
|
||
|
||
bbsc 5
|
||
0be1 : df0a02 > bbs 5,zpt,skip0494
|
||
0be4 : 4920 > eor #(1<<5)
|
||
0be6 : >skip0494
|
||
|
||
bbsc 6
|
||
0be6 : ef0a02 > bbs 6,zpt,skip0495
|
||
0be9 : 4940 > eor #(1<<6)
|
||
0beb : >skip0495
|
||
|
||
bbsc 7
|
||
0beb : ff0a02 > bbs 7,zpt,skip0496
|
||
0bee : 4980 > eor #(1<<7)
|
||
0bf0 : >skip0496
|
||
|
||
0bf0 : 450a eor zpt
|
||
trap_ne ;failed bbs bitnum in accu
|
||
0bf2 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
0bf4 : e60a inc zpt
|
||
0bf6 : d0a0 bne bbcl
|
||
next_test
|
||
0bf8 : ad0202 > lda test_case ;previous test
|
||
0bfb : c907 > cmp #test_num
|
||
> trap_ne ;test is out of sequence
|
||
0bfd : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0008 = >test_num = test_num + 1
|
||
0bff : a908 > lda #test_num ;*** next tests' number
|
||
0c01 : 8d0202 > sta test_case
|
||
> ;check_ram ;uncomment to find altered RAM after each test
|
||
|
||
endif
|
||
|
||
; testing NOP
|
||
|
||
nop_test macro ;\1 = opcode, \2 = # of bytes
|
||
ldy #$42
|
||
ldx #4-\2
|
||
db \1 ;test nop length
|
||
if \2 = 1
|
||
dex
|
||
dex
|
||
endif
|
||
if \2 = 2
|
||
iny
|
||
dex
|
||
endif
|
||
if \2 = 3
|
||
iny
|
||
iny
|
||
endif
|
||
dex
|
||
trap_ne ;wrong number of bytes
|
||
set_a $ff-\1,0
|
||
db \1 ;test nop integrity - flags off
|
||
nop
|
||
nop
|
||
tst_a $ff-\1,0
|
||
set_a $aa-\1,$ff
|
||
db \1 ;test nop integrity - flags on
|
||
nop
|
||
nop
|
||
tst_a $aa-\1,$ff
|
||
cpy #$42
|
||
trap_ne ;y changed
|
||
cpx #0
|
||
trap_ne ;x changed
|
||
endm
|
||
|
||
nop_test $02,2
|
||
0c04 : a042 > ldy #$42
|
||
0c06 : a202 > ldx #4-2
|
||
0c08 : 02 > db $02 ;test nop length
|
||
> if 2 = 1
|
||
> dex
|
||
> dex
|
||
> endif
|
||
> if 2 = 2
|
||
0c09 : c8 > iny
|
||
0c0a : ca > dex
|
||
> endif
|
||
> if 2 = 3
|
||
> iny
|
||
> iny
|
||
> endif
|
||
0c0b : ca > dex
|
||
> trap_ne ;wrong number of bytes
|
||
0c0c : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
> set_a $ff-$02,0
|
||
> load_flag 0
|
||
0c0e : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
0c10 : 48 > pha ;use stack to load status
|
||
0c11 : a9fd > lda #$ff-$02 ;precharge accu
|
||
0c13 : 28 > plp
|
||
>
|
||
0c14 : 02 > db $02 ;test nop integrity - flags off
|
||
0c15 : ea > nop
|
||
0c16 : ea > nop
|
||
> tst_a $ff-$02,0
|
||
0c17 : 08 > php ;save flags
|
||
0c18 : c9fd > cmp #$ff-$02 ;test result
|
||
> trap_ne
|
||
0c1a : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0c1c : 68 > pla ;load status
|
||
0c1d : 48 > pha
|
||
> cmp_flag 0
|
||
0c1e : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0c20 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0c22 : 28 > plp ;restore status
|
||
>
|
||
> set_a $aa-$02,$ff
|
||
> load_flag $ff
|
||
0c23 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
0c25 : 48 > pha ;use stack to load status
|
||
0c26 : a9a8 > lda #$aa-$02 ;precharge accu
|
||
0c28 : 28 > plp
|
||
>
|
||
0c29 : 02 > db $02 ;test nop integrity - flags on
|
||
0c2a : ea > nop
|
||
0c2b : ea > nop
|
||
> tst_a $aa-$02,$ff
|
||
0c2c : 08 > php ;save flags
|
||
0c2d : c9a8 > cmp #$aa-$02 ;test result
|
||
> trap_ne
|
||
0c2f : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0c31 : 68 > pla ;load status
|
||
0c32 : 48 > pha
|
||
> cmp_flag $ff
|
||
0c33 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0c35 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0c37 : 28 > plp ;restore status
|
||
>
|
||
0c38 : c042 > cpy #$42
|
||
> trap_ne ;y changed
|
||
0c3a : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0c3c : e000 > cpx #0
|
||
> trap_ne ;x changed
|
||
0c3e : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
nop_test $22,2
|
||
0c40 : a042 > ldy #$42
|
||
0c42 : a202 > ldx #4-2
|
||
0c44 : 22 > db $22 ;test nop length
|
||
> if 2 = 1
|
||
> dex
|
||
> dex
|
||
> endif
|
||
> if 2 = 2
|
||
0c45 : c8 > iny
|
||
0c46 : ca > dex
|
||
> endif
|
||
> if 2 = 3
|
||
> iny
|
||
> iny
|
||
> endif
|
||
0c47 : ca > dex
|
||
> trap_ne ;wrong number of bytes
|
||
0c48 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
> set_a $ff-$22,0
|
||
> load_flag 0
|
||
0c4a : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
0c4c : 48 > pha ;use stack to load status
|
||
0c4d : a9dd > lda #$ff-$22 ;precharge accu
|
||
0c4f : 28 > plp
|
||
>
|
||
0c50 : 22 > db $22 ;test nop integrity - flags off
|
||
0c51 : ea > nop
|
||
0c52 : ea > nop
|
||
> tst_a $ff-$22,0
|
||
0c53 : 08 > php ;save flags
|
||
0c54 : c9dd > cmp #$ff-$22 ;test result
|
||
> trap_ne
|
||
0c56 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0c58 : 68 > pla ;load status
|
||
0c59 : 48 > pha
|
||
> cmp_flag 0
|
||
0c5a : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0c5c : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0c5e : 28 > plp ;restore status
|
||
>
|
||
> set_a $aa-$22,$ff
|
||
> load_flag $ff
|
||
0c5f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
0c61 : 48 > pha ;use stack to load status
|
||
0c62 : a988 > lda #$aa-$22 ;precharge accu
|
||
0c64 : 28 > plp
|
||
>
|
||
0c65 : 22 > db $22 ;test nop integrity - flags on
|
||
0c66 : ea > nop
|
||
0c67 : ea > nop
|
||
> tst_a $aa-$22,$ff
|
||
0c68 : 08 > php ;save flags
|
||
0c69 : c988 > cmp #$aa-$22 ;test result
|
||
> trap_ne
|
||
0c6b : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0c6d : 68 > pla ;load status
|
||
0c6e : 48 > pha
|
||
> cmp_flag $ff
|
||
0c6f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0c71 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0c73 : 28 > plp ;restore status
|
||
>
|
||
0c74 : c042 > cpy #$42
|
||
> trap_ne ;y changed
|
||
0c76 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0c78 : e000 > cpx #0
|
||
> trap_ne ;x changed
|
||
0c7a : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
nop_test $42,2
|
||
0c7c : a042 > ldy #$42
|
||
0c7e : a202 > ldx #4-2
|
||
0c80 : 42 > db $42 ;test nop length
|
||
> if 2 = 1
|
||
> dex
|
||
> dex
|
||
> endif
|
||
> if 2 = 2
|
||
0c81 : c8 > iny
|
||
0c82 : ca > dex
|
||
> endif
|
||
> if 2 = 3
|
||
> iny
|
||
> iny
|
||
> endif
|
||
0c83 : ca > dex
|
||
> trap_ne ;wrong number of bytes
|
||
0c84 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
> set_a $ff-$42,0
|
||
> load_flag 0
|
||
0c86 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
0c88 : 48 > pha ;use stack to load status
|
||
0c89 : a9bd > lda #$ff-$42 ;precharge accu
|
||
0c8b : 28 > plp
|
||
>
|
||
0c8c : 42 > db $42 ;test nop integrity - flags off
|
||
0c8d : ea > nop
|
||
0c8e : ea > nop
|
||
> tst_a $ff-$42,0
|
||
0c8f : 08 > php ;save flags
|
||
0c90 : c9bd > cmp #$ff-$42 ;test result
|
||
> trap_ne
|
||
0c92 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0c94 : 68 > pla ;load status
|
||
0c95 : 48 > pha
|
||
> cmp_flag 0
|
||
0c96 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0c98 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0c9a : 28 > plp ;restore status
|
||
>
|
||
> set_a $aa-$42,$ff
|
||
> load_flag $ff
|
||
0c9b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
0c9d : 48 > pha ;use stack to load status
|
||
0c9e : a968 > lda #$aa-$42 ;precharge accu
|
||
0ca0 : 28 > plp
|
||
>
|
||
0ca1 : 42 > db $42 ;test nop integrity - flags on
|
||
0ca2 : ea > nop
|
||
0ca3 : ea > nop
|
||
> tst_a $aa-$42,$ff
|
||
0ca4 : 08 > php ;save flags
|
||
0ca5 : c968 > cmp #$aa-$42 ;test result
|
||
> trap_ne
|
||
0ca7 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0ca9 : 68 > pla ;load status
|
||
0caa : 48 > pha
|
||
> cmp_flag $ff
|
||
0cab : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0cad : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0caf : 28 > plp ;restore status
|
||
>
|
||
0cb0 : c042 > cpy #$42
|
||
> trap_ne ;y changed
|
||
0cb2 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0cb4 : e000 > cpx #0
|
||
> trap_ne ;x changed
|
||
0cb6 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
nop_test $62,2
|
||
0cb8 : a042 > ldy #$42
|
||
0cba : a202 > ldx #4-2
|
||
0cbc : 62 > db $62 ;test nop length
|
||
> if 2 = 1
|
||
> dex
|
||
> dex
|
||
> endif
|
||
> if 2 = 2
|
||
0cbd : c8 > iny
|
||
0cbe : ca > dex
|
||
> endif
|
||
> if 2 = 3
|
||
> iny
|
||
> iny
|
||
> endif
|
||
0cbf : ca > dex
|
||
> trap_ne ;wrong number of bytes
|
||
0cc0 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
> set_a $ff-$62,0
|
||
> load_flag 0
|
||
0cc2 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
0cc4 : 48 > pha ;use stack to load status
|
||
0cc5 : a99d > lda #$ff-$62 ;precharge accu
|
||
0cc7 : 28 > plp
|
||
>
|
||
0cc8 : 62 > db $62 ;test nop integrity - flags off
|
||
0cc9 : ea > nop
|
||
0cca : ea > nop
|
||
> tst_a $ff-$62,0
|
||
0ccb : 08 > php ;save flags
|
||
0ccc : c99d > cmp #$ff-$62 ;test result
|
||
> trap_ne
|
||
0cce : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0cd0 : 68 > pla ;load status
|
||
0cd1 : 48 > pha
|
||
> cmp_flag 0
|
||
0cd2 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0cd4 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0cd6 : 28 > plp ;restore status
|
||
>
|
||
> set_a $aa-$62,$ff
|
||
> load_flag $ff
|
||
0cd7 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
0cd9 : 48 > pha ;use stack to load status
|
||
0cda : a948 > lda #$aa-$62 ;precharge accu
|
||
0cdc : 28 > plp
|
||
>
|
||
0cdd : 62 > db $62 ;test nop integrity - flags on
|
||
0cde : ea > nop
|
||
0cdf : ea > nop
|
||
> tst_a $aa-$62,$ff
|
||
0ce0 : 08 > php ;save flags
|
||
0ce1 : c948 > cmp #$aa-$62 ;test result
|
||
> trap_ne
|
||
0ce3 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0ce5 : 68 > pla ;load status
|
||
0ce6 : 48 > pha
|
||
> cmp_flag $ff
|
||
0ce7 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0ce9 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0ceb : 28 > plp ;restore status
|
||
>
|
||
0cec : c042 > cpy #$42
|
||
> trap_ne ;y changed
|
||
0cee : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0cf0 : e000 > cpx #0
|
||
> trap_ne ;x changed
|
||
0cf2 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
nop_test $82,2
|
||
0cf4 : a042 > ldy #$42
|
||
0cf6 : a202 > ldx #4-2
|
||
0cf8 : 82 > db $82 ;test nop length
|
||
> if 2 = 1
|
||
> dex
|
||
> dex
|
||
> endif
|
||
> if 2 = 2
|
||
0cf9 : c8 > iny
|
||
0cfa : ca > dex
|
||
> endif
|
||
> if 2 = 3
|
||
> iny
|
||
> iny
|
||
> endif
|
||
0cfb : ca > dex
|
||
> trap_ne ;wrong number of bytes
|
||
0cfc : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
> set_a $ff-$82,0
|
||
> load_flag 0
|
||
0cfe : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
0d00 : 48 > pha ;use stack to load status
|
||
0d01 : a97d > lda #$ff-$82 ;precharge accu
|
||
0d03 : 28 > plp
|
||
>
|
||
0d04 : 82 > db $82 ;test nop integrity - flags off
|
||
0d05 : ea > nop
|
||
0d06 : ea > nop
|
||
> tst_a $ff-$82,0
|
||
0d07 : 08 > php ;save flags
|
||
0d08 : c97d > cmp #$ff-$82 ;test result
|
||
> trap_ne
|
||
0d0a : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0d0c : 68 > pla ;load status
|
||
0d0d : 48 > pha
|
||
> cmp_flag 0
|
||
0d0e : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0d10 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0d12 : 28 > plp ;restore status
|
||
>
|
||
> set_a $aa-$82,$ff
|
||
> load_flag $ff
|
||
0d13 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
0d15 : 48 > pha ;use stack to load status
|
||
0d16 : a928 > lda #$aa-$82 ;precharge accu
|
||
0d18 : 28 > plp
|
||
>
|
||
0d19 : 82 > db $82 ;test nop integrity - flags on
|
||
0d1a : ea > nop
|
||
0d1b : ea > nop
|
||
> tst_a $aa-$82,$ff
|
||
0d1c : 08 > php ;save flags
|
||
0d1d : c928 > cmp #$aa-$82 ;test result
|
||
> trap_ne
|
||
0d1f : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0d21 : 68 > pla ;load status
|
||
0d22 : 48 > pha
|
||
> cmp_flag $ff
|
||
0d23 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0d25 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0d27 : 28 > plp ;restore status
|
||
>
|
||
0d28 : c042 > cpy #$42
|
||
> trap_ne ;y changed
|
||
0d2a : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0d2c : e000 > cpx #0
|
||
> trap_ne ;x changed
|
||
0d2e : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
nop_test $c2,2
|
||
0d30 : a042 > ldy #$42
|
||
0d32 : a202 > ldx #4-2
|
||
0d34 : c2 > db $c2 ;test nop length
|
||
> if 2 = 1
|
||
> dex
|
||
> dex
|
||
> endif
|
||
> if 2 = 2
|
||
0d35 : c8 > iny
|
||
0d36 : ca > dex
|
||
> endif
|
||
> if 2 = 3
|
||
> iny
|
||
> iny
|
||
> endif
|
||
0d37 : ca > dex
|
||
> trap_ne ;wrong number of bytes
|
||
0d38 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
> set_a $ff-$c2,0
|
||
> load_flag 0
|
||
0d3a : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
0d3c : 48 > pha ;use stack to load status
|
||
0d3d : a93d > lda #$ff-$c2 ;precharge accu
|
||
0d3f : 28 > plp
|
||
>
|
||
0d40 : c2 > db $c2 ;test nop integrity - flags off
|
||
0d41 : ea > nop
|
||
0d42 : ea > nop
|
||
> tst_a $ff-$c2,0
|
||
0d43 : 08 > php ;save flags
|
||
0d44 : c93d > cmp #$ff-$c2 ;test result
|
||
> trap_ne
|
||
0d46 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0d48 : 68 > pla ;load status
|
||
0d49 : 48 > pha
|
||
> cmp_flag 0
|
||
0d4a : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0d4c : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0d4e : 28 > plp ;restore status
|
||
>
|
||
> set_a $aa-$c2,$ff
|
||
> load_flag $ff
|
||
0d4f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
0d51 : 48 > pha ;use stack to load status
|
||
0d52 : a9e8 > lda #$aa-$c2 ;precharge accu
|
||
0d54 : 28 > plp
|
||
>
|
||
0d55 : c2 > db $c2 ;test nop integrity - flags on
|
||
0d56 : ea > nop
|
||
0d57 : ea > nop
|
||
> tst_a $aa-$c2,$ff
|
||
0d58 : 08 > php ;save flags
|
||
0d59 : c9e8 > cmp #$aa-$c2 ;test result
|
||
> trap_ne
|
||
0d5b : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0d5d : 68 > pla ;load status
|
||
0d5e : 48 > pha
|
||
> cmp_flag $ff
|
||
0d5f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0d61 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0d63 : 28 > plp ;restore status
|
||
>
|
||
0d64 : c042 > cpy #$42
|
||
> trap_ne ;y changed
|
||
0d66 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0d68 : e000 > cpx #0
|
||
> trap_ne ;x changed
|
||
0d6a : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
nop_test $e2,2
|
||
0d6c : a042 > ldy #$42
|
||
0d6e : a202 > ldx #4-2
|
||
0d70 : e2 > db $e2 ;test nop length
|
||
> if 2 = 1
|
||
> dex
|
||
> dex
|
||
> endif
|
||
> if 2 = 2
|
||
0d71 : c8 > iny
|
||
0d72 : ca > dex
|
||
> endif
|
||
> if 2 = 3
|
||
> iny
|
||
> iny
|
||
> endif
|
||
0d73 : ca > dex
|
||
> trap_ne ;wrong number of bytes
|
||
0d74 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
> set_a $ff-$e2,0
|
||
> load_flag 0
|
||
0d76 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
0d78 : 48 > pha ;use stack to load status
|
||
0d79 : a91d > lda #$ff-$e2 ;precharge accu
|
||
0d7b : 28 > plp
|
||
>
|
||
0d7c : e2 > db $e2 ;test nop integrity - flags off
|
||
0d7d : ea > nop
|
||
0d7e : ea > nop
|
||
> tst_a $ff-$e2,0
|
||
0d7f : 08 > php ;save flags
|
||
0d80 : c91d > cmp #$ff-$e2 ;test result
|
||
> trap_ne
|
||
0d82 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0d84 : 68 > pla ;load status
|
||
0d85 : 48 > pha
|
||
> cmp_flag 0
|
||
0d86 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0d88 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0d8a : 28 > plp ;restore status
|
||
>
|
||
> set_a $aa-$e2,$ff
|
||
> load_flag $ff
|
||
0d8b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
0d8d : 48 > pha ;use stack to load status
|
||
0d8e : a9c8 > lda #$aa-$e2 ;precharge accu
|
||
0d90 : 28 > plp
|
||
>
|
||
0d91 : e2 > db $e2 ;test nop integrity - flags on
|
||
0d92 : ea > nop
|
||
0d93 : ea > nop
|
||
> tst_a $aa-$e2,$ff
|
||
0d94 : 08 > php ;save flags
|
||
0d95 : c9c8 > cmp #$aa-$e2 ;test result
|
||
> trap_ne
|
||
0d97 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0d99 : 68 > pla ;load status
|
||
0d9a : 48 > pha
|
||
> cmp_flag $ff
|
||
0d9b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0d9d : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0d9f : 28 > plp ;restore status
|
||
>
|
||
0da0 : c042 > cpy #$42
|
||
> trap_ne ;y changed
|
||
0da2 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0da4 : e000 > cpx #0
|
||
> trap_ne ;x changed
|
||
0da6 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
nop_test $44,2
|
||
0da8 : a042 > ldy #$42
|
||
0daa : a202 > ldx #4-2
|
||
0dac : 44 > db $44 ;test nop length
|
||
> if 2 = 1
|
||
> dex
|
||
> dex
|
||
> endif
|
||
> if 2 = 2
|
||
0dad : c8 > iny
|
||
0dae : ca > dex
|
||
> endif
|
||
> if 2 = 3
|
||
> iny
|
||
> iny
|
||
> endif
|
||
0daf : ca > dex
|
||
> trap_ne ;wrong number of bytes
|
||
0db0 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
> set_a $ff-$44,0
|
||
> load_flag 0
|
||
0db2 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
0db4 : 48 > pha ;use stack to load status
|
||
0db5 : a9bb > lda #$ff-$44 ;precharge accu
|
||
0db7 : 28 > plp
|
||
>
|
||
0db8 : 44 > db $44 ;test nop integrity - flags off
|
||
0db9 : ea > nop
|
||
0dba : ea > nop
|
||
> tst_a $ff-$44,0
|
||
0dbb : 08 > php ;save flags
|
||
0dbc : c9bb > cmp #$ff-$44 ;test result
|
||
> trap_ne
|
||
0dbe : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0dc0 : 68 > pla ;load status
|
||
0dc1 : 48 > pha
|
||
> cmp_flag 0
|
||
0dc2 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0dc4 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0dc6 : 28 > plp ;restore status
|
||
>
|
||
> set_a $aa-$44,$ff
|
||
> load_flag $ff
|
||
0dc7 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
0dc9 : 48 > pha ;use stack to load status
|
||
0dca : a966 > lda #$aa-$44 ;precharge accu
|
||
0dcc : 28 > plp
|
||
>
|
||
0dcd : 44 > db $44 ;test nop integrity - flags on
|
||
0dce : ea > nop
|
||
0dcf : ea > nop
|
||
> tst_a $aa-$44,$ff
|
||
0dd0 : 08 > php ;save flags
|
||
0dd1 : c966 > cmp #$aa-$44 ;test result
|
||
> trap_ne
|
||
0dd3 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0dd5 : 68 > pla ;load status
|
||
0dd6 : 48 > pha
|
||
> cmp_flag $ff
|
||
0dd7 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0dd9 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0ddb : 28 > plp ;restore status
|
||
>
|
||
0ddc : c042 > cpy #$42
|
||
> trap_ne ;y changed
|
||
0dde : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0de0 : e000 > cpx #0
|
||
> trap_ne ;x changed
|
||
0de2 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
nop_test $54,2
|
||
0de4 : a042 > ldy #$42
|
||
0de6 : a202 > ldx #4-2
|
||
0de8 : 54 > db $54 ;test nop length
|
||
> if 2 = 1
|
||
> dex
|
||
> dex
|
||
> endif
|
||
> if 2 = 2
|
||
0de9 : c8 > iny
|
||
0dea : ca > dex
|
||
> endif
|
||
> if 2 = 3
|
||
> iny
|
||
> iny
|
||
> endif
|
||
0deb : ca > dex
|
||
> trap_ne ;wrong number of bytes
|
||
0dec : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
> set_a $ff-$54,0
|
||
> load_flag 0
|
||
0dee : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
0df0 : 48 > pha ;use stack to load status
|
||
0df1 : a9ab > lda #$ff-$54 ;precharge accu
|
||
0df3 : 28 > plp
|
||
>
|
||
0df4 : 54 > db $54 ;test nop integrity - flags off
|
||
0df5 : ea > nop
|
||
0df6 : ea > nop
|
||
> tst_a $ff-$54,0
|
||
0df7 : 08 > php ;save flags
|
||
0df8 : c9ab > cmp #$ff-$54 ;test result
|
||
> trap_ne
|
||
0dfa : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0dfc : 68 > pla ;load status
|
||
0dfd : 48 > pha
|
||
> cmp_flag 0
|
||
0dfe : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0e00 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0e02 : 28 > plp ;restore status
|
||
>
|
||
> set_a $aa-$54,$ff
|
||
> load_flag $ff
|
||
0e03 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
0e05 : 48 > pha ;use stack to load status
|
||
0e06 : a956 > lda #$aa-$54 ;precharge accu
|
||
0e08 : 28 > plp
|
||
>
|
||
0e09 : 54 > db $54 ;test nop integrity - flags on
|
||
0e0a : ea > nop
|
||
0e0b : ea > nop
|
||
> tst_a $aa-$54,$ff
|
||
0e0c : 08 > php ;save flags
|
||
0e0d : c956 > cmp #$aa-$54 ;test result
|
||
> trap_ne
|
||
0e0f : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0e11 : 68 > pla ;load status
|
||
0e12 : 48 > pha
|
||
> cmp_flag $ff
|
||
0e13 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0e15 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0e17 : 28 > plp ;restore status
|
||
>
|
||
0e18 : c042 > cpy #$42
|
||
> trap_ne ;y changed
|
||
0e1a : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0e1c : e000 > cpx #0
|
||
> trap_ne ;x changed
|
||
0e1e : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
nop_test $d4,2
|
||
0e20 : a042 > ldy #$42
|
||
0e22 : a202 > ldx #4-2
|
||
0e24 : d4 > db $d4 ;test nop length
|
||
> if 2 = 1
|
||
> dex
|
||
> dex
|
||
> endif
|
||
> if 2 = 2
|
||
0e25 : c8 > iny
|
||
0e26 : ca > dex
|
||
> endif
|
||
> if 2 = 3
|
||
> iny
|
||
> iny
|
||
> endif
|
||
0e27 : ca > dex
|
||
> trap_ne ;wrong number of bytes
|
||
0e28 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
> set_a $ff-$d4,0
|
||
> load_flag 0
|
||
0e2a : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
0e2c : 48 > pha ;use stack to load status
|
||
0e2d : a92b > lda #$ff-$d4 ;precharge accu
|
||
0e2f : 28 > plp
|
||
>
|
||
0e30 : d4 > db $d4 ;test nop integrity - flags off
|
||
0e31 : ea > nop
|
||
0e32 : ea > nop
|
||
> tst_a $ff-$d4,0
|
||
0e33 : 08 > php ;save flags
|
||
0e34 : c92b > cmp #$ff-$d4 ;test result
|
||
> trap_ne
|
||
0e36 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0e38 : 68 > pla ;load status
|
||
0e39 : 48 > pha
|
||
> cmp_flag 0
|
||
0e3a : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0e3c : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0e3e : 28 > plp ;restore status
|
||
>
|
||
> set_a $aa-$d4,$ff
|
||
> load_flag $ff
|
||
0e3f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
0e41 : 48 > pha ;use stack to load status
|
||
0e42 : a9d6 > lda #$aa-$d4 ;precharge accu
|
||
0e44 : 28 > plp
|
||
>
|
||
0e45 : d4 > db $d4 ;test nop integrity - flags on
|
||
0e46 : ea > nop
|
||
0e47 : ea > nop
|
||
> tst_a $aa-$d4,$ff
|
||
0e48 : 08 > php ;save flags
|
||
0e49 : c9d6 > cmp #$aa-$d4 ;test result
|
||
> trap_ne
|
||
0e4b : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0e4d : 68 > pla ;load status
|
||
0e4e : 48 > pha
|
||
> cmp_flag $ff
|
||
0e4f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0e51 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0e53 : 28 > plp ;restore status
|
||
>
|
||
0e54 : c042 > cpy #$42
|
||
> trap_ne ;y changed
|
||
0e56 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0e58 : e000 > cpx #0
|
||
> trap_ne ;x changed
|
||
0e5a : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
nop_test $f4,2
|
||
0e5c : a042 > ldy #$42
|
||
0e5e : a202 > ldx #4-2
|
||
0e60 : f4 > db $f4 ;test nop length
|
||
> if 2 = 1
|
||
> dex
|
||
> dex
|
||
> endif
|
||
> if 2 = 2
|
||
0e61 : c8 > iny
|
||
0e62 : ca > dex
|
||
> endif
|
||
> if 2 = 3
|
||
> iny
|
||
> iny
|
||
> endif
|
||
0e63 : ca > dex
|
||
> trap_ne ;wrong number of bytes
|
||
0e64 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
> set_a $ff-$f4,0
|
||
> load_flag 0
|
||
0e66 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
0e68 : 48 > pha ;use stack to load status
|
||
0e69 : a90b > lda #$ff-$f4 ;precharge accu
|
||
0e6b : 28 > plp
|
||
>
|
||
0e6c : f4 > db $f4 ;test nop integrity - flags off
|
||
0e6d : ea > nop
|
||
0e6e : ea > nop
|
||
> tst_a $ff-$f4,0
|
||
0e6f : 08 > php ;save flags
|
||
0e70 : c90b > cmp #$ff-$f4 ;test result
|
||
> trap_ne
|
||
0e72 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0e74 : 68 > pla ;load status
|
||
0e75 : 48 > pha
|
||
> cmp_flag 0
|
||
0e76 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0e78 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0e7a : 28 > plp ;restore status
|
||
>
|
||
> set_a $aa-$f4,$ff
|
||
> load_flag $ff
|
||
0e7b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
0e7d : 48 > pha ;use stack to load status
|
||
0e7e : a9b6 > lda #$aa-$f4 ;precharge accu
|
||
0e80 : 28 > plp
|
||
>
|
||
0e81 : f4 > db $f4 ;test nop integrity - flags on
|
||
0e82 : ea > nop
|
||
0e83 : ea > nop
|
||
> tst_a $aa-$f4,$ff
|
||
0e84 : 08 > php ;save flags
|
||
0e85 : c9b6 > cmp #$aa-$f4 ;test result
|
||
> trap_ne
|
||
0e87 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0e89 : 68 > pla ;load status
|
||
0e8a : 48 > pha
|
||
> cmp_flag $ff
|
||
0e8b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0e8d : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0e8f : 28 > plp ;restore status
|
||
>
|
||
0e90 : c042 > cpy #$42
|
||
> trap_ne ;y changed
|
||
0e92 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0e94 : e000 > cpx #0
|
||
> trap_ne ;x changed
|
||
0e96 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
nop_test $5c,3
|
||
0e98 : a042 > ldy #$42
|
||
0e9a : a201 > ldx #4-3
|
||
0e9c : 5c > db $5c ;test nop length
|
||
> if 3 = 1
|
||
> dex
|
||
> dex
|
||
> endif
|
||
> if 3 = 2
|
||
> iny
|
||
> dex
|
||
> endif
|
||
> if 3 = 3
|
||
0e9d : c8 > iny
|
||
0e9e : c8 > iny
|
||
> endif
|
||
0e9f : ca > dex
|
||
> trap_ne ;wrong number of bytes
|
||
0ea0 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
> set_a $ff-$5c,0
|
||
> load_flag 0
|
||
0ea2 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
0ea4 : 48 > pha ;use stack to load status
|
||
0ea5 : a9a3 > lda #$ff-$5c ;precharge accu
|
||
0ea7 : 28 > plp
|
||
>
|
||
0ea8 : 5c > db $5c ;test nop integrity - flags off
|
||
0ea9 : ea > nop
|
||
0eaa : ea > nop
|
||
> tst_a $ff-$5c,0
|
||
0eab : 08 > php ;save flags
|
||
0eac : c9a3 > cmp #$ff-$5c ;test result
|
||
> trap_ne
|
||
0eae : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0eb0 : 68 > pla ;load status
|
||
0eb1 : 48 > pha
|
||
> cmp_flag 0
|
||
0eb2 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0eb4 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0eb6 : 28 > plp ;restore status
|
||
>
|
||
> set_a $aa-$5c,$ff
|
||
> load_flag $ff
|
||
0eb7 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
0eb9 : 48 > pha ;use stack to load status
|
||
0eba : a94e > lda #$aa-$5c ;precharge accu
|
||
0ebc : 28 > plp
|
||
>
|
||
0ebd : 5c > db $5c ;test nop integrity - flags on
|
||
0ebe : ea > nop
|
||
0ebf : ea > nop
|
||
> tst_a $aa-$5c,$ff
|
||
0ec0 : 08 > php ;save flags
|
||
0ec1 : c94e > cmp #$aa-$5c ;test result
|
||
> trap_ne
|
||
0ec3 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0ec5 : 68 > pla ;load status
|
||
0ec6 : 48 > pha
|
||
> cmp_flag $ff
|
||
0ec7 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0ec9 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0ecb : 28 > plp ;restore status
|
||
>
|
||
0ecc : c042 > cpy #$42
|
||
> trap_ne ;y changed
|
||
0ece : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0ed0 : e000 > cpx #0
|
||
> trap_ne ;x changed
|
||
0ed2 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
nop_test $dc,3
|
||
0ed4 : a042 > ldy #$42
|
||
0ed6 : a201 > ldx #4-3
|
||
0ed8 : dc > db $dc ;test nop length
|
||
> if 3 = 1
|
||
> dex
|
||
> dex
|
||
> endif
|
||
> if 3 = 2
|
||
> iny
|
||
> dex
|
||
> endif
|
||
> if 3 = 3
|
||
0ed9 : c8 > iny
|
||
0eda : c8 > iny
|
||
> endif
|
||
0edb : ca > dex
|
||
> trap_ne ;wrong number of bytes
|
||
0edc : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
> set_a $ff-$dc,0
|
||
> load_flag 0
|
||
0ede : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
0ee0 : 48 > pha ;use stack to load status
|
||
0ee1 : a923 > lda #$ff-$dc ;precharge accu
|
||
0ee3 : 28 > plp
|
||
>
|
||
0ee4 : dc > db $dc ;test nop integrity - flags off
|
||
0ee5 : ea > nop
|
||
0ee6 : ea > nop
|
||
> tst_a $ff-$dc,0
|
||
0ee7 : 08 > php ;save flags
|
||
0ee8 : c923 > cmp #$ff-$dc ;test result
|
||
> trap_ne
|
||
0eea : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0eec : 68 > pla ;load status
|
||
0eed : 48 > pha
|
||
> cmp_flag 0
|
||
0eee : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0ef0 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0ef2 : 28 > plp ;restore status
|
||
>
|
||
> set_a $aa-$dc,$ff
|
||
> load_flag $ff
|
||
0ef3 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
0ef5 : 48 > pha ;use stack to load status
|
||
0ef6 : a9ce > lda #$aa-$dc ;precharge accu
|
||
0ef8 : 28 > plp
|
||
>
|
||
0ef9 : dc > db $dc ;test nop integrity - flags on
|
||
0efa : ea > nop
|
||
0efb : ea > nop
|
||
> tst_a $aa-$dc,$ff
|
||
0efc : 08 > php ;save flags
|
||
0efd : c9ce > cmp #$aa-$dc ;test result
|
||
> trap_ne
|
||
0eff : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0f01 : 68 > pla ;load status
|
||
0f02 : 48 > pha
|
||
> cmp_flag $ff
|
||
0f03 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0f05 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0f07 : 28 > plp ;restore status
|
||
>
|
||
0f08 : c042 > cpy #$42
|
||
> trap_ne ;y changed
|
||
0f0a : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0f0c : e000 > cpx #0
|
||
> trap_ne ;x changed
|
||
0f0e : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
nop_test $fc,3
|
||
0f10 : a042 > ldy #$42
|
||
0f12 : a201 > ldx #4-3
|
||
0f14 : fc > db $fc ;test nop length
|
||
> if 3 = 1
|
||
> dex
|
||
> dex
|
||
> endif
|
||
> if 3 = 2
|
||
> iny
|
||
> dex
|
||
> endif
|
||
> if 3 = 3
|
||
0f15 : c8 > iny
|
||
0f16 : c8 > iny
|
||
> endif
|
||
0f17 : ca > dex
|
||
> trap_ne ;wrong number of bytes
|
||
0f18 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
> set_a $ff-$fc,0
|
||
> load_flag 0
|
||
0f1a : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
0f1c : 48 > pha ;use stack to load status
|
||
0f1d : a903 > lda #$ff-$fc ;precharge accu
|
||
0f1f : 28 > plp
|
||
>
|
||
0f20 : fc > db $fc ;test nop integrity - flags off
|
||
0f21 : ea > nop
|
||
0f22 : ea > nop
|
||
> tst_a $ff-$fc,0
|
||
0f23 : 08 > php ;save flags
|
||
0f24 : c903 > cmp #$ff-$fc ;test result
|
||
> trap_ne
|
||
0f26 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0f28 : 68 > pla ;load status
|
||
0f29 : 48 > pha
|
||
> cmp_flag 0
|
||
0f2a : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0f2c : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0f2e : 28 > plp ;restore status
|
||
>
|
||
> set_a $aa-$fc,$ff
|
||
> load_flag $ff
|
||
0f2f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
0f31 : 48 > pha ;use stack to load status
|
||
0f32 : a9ae > lda #$aa-$fc ;precharge accu
|
||
0f34 : 28 > plp
|
||
>
|
||
0f35 : fc > db $fc ;test nop integrity - flags on
|
||
0f36 : ea > nop
|
||
0f37 : ea > nop
|
||
> tst_a $aa-$fc,$ff
|
||
0f38 : 08 > php ;save flags
|
||
0f39 : c9ae > cmp #$aa-$fc ;test result
|
||
> trap_ne
|
||
0f3b : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0f3d : 68 > pla ;load status
|
||
0f3e : 48 > pha
|
||
> cmp_flag $ff
|
||
0f3f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0f41 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0f43 : 28 > plp ;restore status
|
||
>
|
||
0f44 : c042 > cpy #$42
|
||
> trap_ne ;y changed
|
||
0f46 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0f48 : e000 > cpx #0
|
||
> trap_ne ;x changed
|
||
0f4a : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
nop_test $03,1
|
||
0f4c : a042 > ldy #$42
|
||
0f4e : a203 > ldx #4-1
|
||
0f50 : 03 > db $03 ;test nop length
|
||
> if 1 = 1
|
||
0f51 : ca > dex
|
||
0f52 : ca > dex
|
||
> endif
|
||
> if 1 = 2
|
||
> iny
|
||
> dex
|
||
> endif
|
||
> if 1 = 3
|
||
> iny
|
||
> iny
|
||
> endif
|
||
0f53 : ca > dex
|
||
> trap_ne ;wrong number of bytes
|
||
0f54 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
> set_a $ff-$03,0
|
||
> load_flag 0
|
||
0f56 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
0f58 : 48 > pha ;use stack to load status
|
||
0f59 : a9fc > lda #$ff-$03 ;precharge accu
|
||
0f5b : 28 > plp
|
||
>
|
||
0f5c : 03 > db $03 ;test nop integrity - flags off
|
||
0f5d : ea > nop
|
||
0f5e : ea > nop
|
||
> tst_a $ff-$03,0
|
||
0f5f : 08 > php ;save flags
|
||
0f60 : c9fc > cmp #$ff-$03 ;test result
|
||
> trap_ne
|
||
0f62 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0f64 : 68 > pla ;load status
|
||
0f65 : 48 > pha
|
||
> cmp_flag 0
|
||
0f66 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0f68 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0f6a : 28 > plp ;restore status
|
||
>
|
||
> set_a $aa-$03,$ff
|
||
> load_flag $ff
|
||
0f6b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
0f6d : 48 > pha ;use stack to load status
|
||
0f6e : a9a7 > lda #$aa-$03 ;precharge accu
|
||
0f70 : 28 > plp
|
||
>
|
||
0f71 : 03 > db $03 ;test nop integrity - flags on
|
||
0f72 : ea > nop
|
||
0f73 : ea > nop
|
||
> tst_a $aa-$03,$ff
|
||
0f74 : 08 > php ;save flags
|
||
0f75 : c9a7 > cmp #$aa-$03 ;test result
|
||
> trap_ne
|
||
0f77 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0f79 : 68 > pla ;load status
|
||
0f7a : 48 > pha
|
||
> cmp_flag $ff
|
||
0f7b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0f7d : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0f7f : 28 > plp ;restore status
|
||
>
|
||
0f80 : c042 > cpy #$42
|
||
> trap_ne ;y changed
|
||
0f82 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0f84 : e000 > cpx #0
|
||
> trap_ne ;x changed
|
||
0f86 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
nop_test $13,1
|
||
0f88 : a042 > ldy #$42
|
||
0f8a : a203 > ldx #4-1
|
||
0f8c : 13 > db $13 ;test nop length
|
||
> if 1 = 1
|
||
0f8d : ca > dex
|
||
0f8e : ca > dex
|
||
> endif
|
||
> if 1 = 2
|
||
> iny
|
||
> dex
|
||
> endif
|
||
> if 1 = 3
|
||
> iny
|
||
> iny
|
||
> endif
|
||
0f8f : ca > dex
|
||
> trap_ne ;wrong number of bytes
|
||
0f90 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
> set_a $ff-$13,0
|
||
> load_flag 0
|
||
0f92 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
0f94 : 48 > pha ;use stack to load status
|
||
0f95 : a9ec > lda #$ff-$13 ;precharge accu
|
||
0f97 : 28 > plp
|
||
>
|
||
0f98 : 13 > db $13 ;test nop integrity - flags off
|
||
0f99 : ea > nop
|
||
0f9a : ea > nop
|
||
> tst_a $ff-$13,0
|
||
0f9b : 08 > php ;save flags
|
||
0f9c : c9ec > cmp #$ff-$13 ;test result
|
||
> trap_ne
|
||
0f9e : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0fa0 : 68 > pla ;load status
|
||
0fa1 : 48 > pha
|
||
> cmp_flag 0
|
||
0fa2 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0fa4 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0fa6 : 28 > plp ;restore status
|
||
>
|
||
> set_a $aa-$13,$ff
|
||
> load_flag $ff
|
||
0fa7 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
0fa9 : 48 > pha ;use stack to load status
|
||
0faa : a997 > lda #$aa-$13 ;precharge accu
|
||
0fac : 28 > plp
|
||
>
|
||
0fad : 13 > db $13 ;test nop integrity - flags on
|
||
0fae : ea > nop
|
||
0faf : ea > nop
|
||
> tst_a $aa-$13,$ff
|
||
0fb0 : 08 > php ;save flags
|
||
0fb1 : c997 > cmp #$aa-$13 ;test result
|
||
> trap_ne
|
||
0fb3 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0fb5 : 68 > pla ;load status
|
||
0fb6 : 48 > pha
|
||
> cmp_flag $ff
|
||
0fb7 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0fb9 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0fbb : 28 > plp ;restore status
|
||
>
|
||
0fbc : c042 > cpy #$42
|
||
> trap_ne ;y changed
|
||
0fbe : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0fc0 : e000 > cpx #0
|
||
> trap_ne ;x changed
|
||
0fc2 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
nop_test $23,1
|
||
0fc4 : a042 > ldy #$42
|
||
0fc6 : a203 > ldx #4-1
|
||
0fc8 : 23 > db $23 ;test nop length
|
||
> if 1 = 1
|
||
0fc9 : ca > dex
|
||
0fca : ca > dex
|
||
> endif
|
||
> if 1 = 2
|
||
> iny
|
||
> dex
|
||
> endif
|
||
> if 1 = 3
|
||
> iny
|
||
> iny
|
||
> endif
|
||
0fcb : ca > dex
|
||
> trap_ne ;wrong number of bytes
|
||
0fcc : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
> set_a $ff-$23,0
|
||
> load_flag 0
|
||
0fce : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
0fd0 : 48 > pha ;use stack to load status
|
||
0fd1 : a9dc > lda #$ff-$23 ;precharge accu
|
||
0fd3 : 28 > plp
|
||
>
|
||
0fd4 : 23 > db $23 ;test nop integrity - flags off
|
||
0fd5 : ea > nop
|
||
0fd6 : ea > nop
|
||
> tst_a $ff-$23,0
|
||
0fd7 : 08 > php ;save flags
|
||
0fd8 : c9dc > cmp #$ff-$23 ;test result
|
||
> trap_ne
|
||
0fda : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0fdc : 68 > pla ;load status
|
||
0fdd : 48 > pha
|
||
> cmp_flag 0
|
||
0fde : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0fe0 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0fe2 : 28 > plp ;restore status
|
||
>
|
||
> set_a $aa-$23,$ff
|
||
> load_flag $ff
|
||
0fe3 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
0fe5 : 48 > pha ;use stack to load status
|
||
0fe6 : a987 > lda #$aa-$23 ;precharge accu
|
||
0fe8 : 28 > plp
|
||
>
|
||
0fe9 : 23 > db $23 ;test nop integrity - flags on
|
||
0fea : ea > nop
|
||
0feb : ea > nop
|
||
> tst_a $aa-$23,$ff
|
||
0fec : 08 > php ;save flags
|
||
0fed : c987 > cmp #$aa-$23 ;test result
|
||
> trap_ne
|
||
0fef : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0ff1 : 68 > pla ;load status
|
||
0ff2 : 48 > pha
|
||
> cmp_flag $ff
|
||
0ff3 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
0ff5 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0ff7 : 28 > plp ;restore status
|
||
>
|
||
0ff8 : c042 > cpy #$42
|
||
> trap_ne ;y changed
|
||
0ffa : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0ffc : e000 > cpx #0
|
||
> trap_ne ;x changed
|
||
0ffe : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
nop_test $33,1
|
||
1000 : a042 > ldy #$42
|
||
1002 : a203 > ldx #4-1
|
||
1004 : 33 > db $33 ;test nop length
|
||
> if 1 = 1
|
||
1005 : ca > dex
|
||
1006 : ca > dex
|
||
> endif
|
||
> if 1 = 2
|
||
> iny
|
||
> dex
|
||
> endif
|
||
> if 1 = 3
|
||
> iny
|
||
> iny
|
||
> endif
|
||
1007 : ca > dex
|
||
> trap_ne ;wrong number of bytes
|
||
1008 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
> set_a $ff-$33,0
|
||
> load_flag 0
|
||
100a : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
100c : 48 > pha ;use stack to load status
|
||
100d : a9cc > lda #$ff-$33 ;precharge accu
|
||
100f : 28 > plp
|
||
>
|
||
1010 : 33 > db $33 ;test nop integrity - flags off
|
||
1011 : ea > nop
|
||
1012 : ea > nop
|
||
> tst_a $ff-$33,0
|
||
1013 : 08 > php ;save flags
|
||
1014 : c9cc > cmp #$ff-$33 ;test result
|
||
> trap_ne
|
||
1016 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1018 : 68 > pla ;load status
|
||
1019 : 48 > pha
|
||
> cmp_flag 0
|
||
101a : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
101c : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
101e : 28 > plp ;restore status
|
||
>
|
||
> set_a $aa-$33,$ff
|
||
> load_flag $ff
|
||
101f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
1021 : 48 > pha ;use stack to load status
|
||
1022 : a977 > lda #$aa-$33 ;precharge accu
|
||
1024 : 28 > plp
|
||
>
|
||
1025 : 33 > db $33 ;test nop integrity - flags on
|
||
1026 : ea > nop
|
||
1027 : ea > nop
|
||
> tst_a $aa-$33,$ff
|
||
1028 : 08 > php ;save flags
|
||
1029 : c977 > cmp #$aa-$33 ;test result
|
||
> trap_ne
|
||
102b : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
102d : 68 > pla ;load status
|
||
102e : 48 > pha
|
||
> cmp_flag $ff
|
||
102f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1031 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1033 : 28 > plp ;restore status
|
||
>
|
||
1034 : c042 > cpy #$42
|
||
> trap_ne ;y changed
|
||
1036 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1038 : e000 > cpx #0
|
||
> trap_ne ;x changed
|
||
103a : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
nop_test $43,1
|
||
103c : a042 > ldy #$42
|
||
103e : a203 > ldx #4-1
|
||
1040 : 43 > db $43 ;test nop length
|
||
> if 1 = 1
|
||
1041 : ca > dex
|
||
1042 : ca > dex
|
||
> endif
|
||
> if 1 = 2
|
||
> iny
|
||
> dex
|
||
> endif
|
||
> if 1 = 3
|
||
> iny
|
||
> iny
|
||
> endif
|
||
1043 : ca > dex
|
||
> trap_ne ;wrong number of bytes
|
||
1044 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
> set_a $ff-$43,0
|
||
> load_flag 0
|
||
1046 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
1048 : 48 > pha ;use stack to load status
|
||
1049 : a9bc > lda #$ff-$43 ;precharge accu
|
||
104b : 28 > plp
|
||
>
|
||
104c : 43 > db $43 ;test nop integrity - flags off
|
||
104d : ea > nop
|
||
104e : ea > nop
|
||
> tst_a $ff-$43,0
|
||
104f : 08 > php ;save flags
|
||
1050 : c9bc > cmp #$ff-$43 ;test result
|
||
> trap_ne
|
||
1052 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1054 : 68 > pla ;load status
|
||
1055 : 48 > pha
|
||
> cmp_flag 0
|
||
1056 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1058 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
105a : 28 > plp ;restore status
|
||
>
|
||
> set_a $aa-$43,$ff
|
||
> load_flag $ff
|
||
105b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
105d : 48 > pha ;use stack to load status
|
||
105e : a967 > lda #$aa-$43 ;precharge accu
|
||
1060 : 28 > plp
|
||
>
|
||
1061 : 43 > db $43 ;test nop integrity - flags on
|
||
1062 : ea > nop
|
||
1063 : ea > nop
|
||
> tst_a $aa-$43,$ff
|
||
1064 : 08 > php ;save flags
|
||
1065 : c967 > cmp #$aa-$43 ;test result
|
||
> trap_ne
|
||
1067 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1069 : 68 > pla ;load status
|
||
106a : 48 > pha
|
||
> cmp_flag $ff
|
||
106b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
106d : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
106f : 28 > plp ;restore status
|
||
>
|
||
1070 : c042 > cpy #$42
|
||
> trap_ne ;y changed
|
||
1072 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1074 : e000 > cpx #0
|
||
> trap_ne ;x changed
|
||
1076 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
nop_test $53,1
|
||
1078 : a042 > ldy #$42
|
||
107a : a203 > ldx #4-1
|
||
107c : 53 > db $53 ;test nop length
|
||
> if 1 = 1
|
||
107d : ca > dex
|
||
107e : ca > dex
|
||
> endif
|
||
> if 1 = 2
|
||
> iny
|
||
> dex
|
||
> endif
|
||
> if 1 = 3
|
||
> iny
|
||
> iny
|
||
> endif
|
||
107f : ca > dex
|
||
> trap_ne ;wrong number of bytes
|
||
1080 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
> set_a $ff-$53,0
|
||
> load_flag 0
|
||
1082 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
1084 : 48 > pha ;use stack to load status
|
||
1085 : a9ac > lda #$ff-$53 ;precharge accu
|
||
1087 : 28 > plp
|
||
>
|
||
1088 : 53 > db $53 ;test nop integrity - flags off
|
||
1089 : ea > nop
|
||
108a : ea > nop
|
||
> tst_a $ff-$53,0
|
||
108b : 08 > php ;save flags
|
||
108c : c9ac > cmp #$ff-$53 ;test result
|
||
> trap_ne
|
||
108e : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1090 : 68 > pla ;load status
|
||
1091 : 48 > pha
|
||
> cmp_flag 0
|
||
1092 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1094 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1096 : 28 > plp ;restore status
|
||
>
|
||
> set_a $aa-$53,$ff
|
||
> load_flag $ff
|
||
1097 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
1099 : 48 > pha ;use stack to load status
|
||
109a : a957 > lda #$aa-$53 ;precharge accu
|
||
109c : 28 > plp
|
||
>
|
||
109d : 53 > db $53 ;test nop integrity - flags on
|
||
109e : ea > nop
|
||
109f : ea > nop
|
||
> tst_a $aa-$53,$ff
|
||
10a0 : 08 > php ;save flags
|
||
10a1 : c957 > cmp #$aa-$53 ;test result
|
||
> trap_ne
|
||
10a3 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
10a5 : 68 > pla ;load status
|
||
10a6 : 48 > pha
|
||
> cmp_flag $ff
|
||
10a7 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
10a9 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
10ab : 28 > plp ;restore status
|
||
>
|
||
10ac : c042 > cpy #$42
|
||
> trap_ne ;y changed
|
||
10ae : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
10b0 : e000 > cpx #0
|
||
> trap_ne ;x changed
|
||
10b2 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
nop_test $63,1
|
||
10b4 : a042 > ldy #$42
|
||
10b6 : a203 > ldx #4-1
|
||
10b8 : 63 > db $63 ;test nop length
|
||
> if 1 = 1
|
||
10b9 : ca > dex
|
||
10ba : ca > dex
|
||
> endif
|
||
> if 1 = 2
|
||
> iny
|
||
> dex
|
||
> endif
|
||
> if 1 = 3
|
||
> iny
|
||
> iny
|
||
> endif
|
||
10bb : ca > dex
|
||
> trap_ne ;wrong number of bytes
|
||
10bc : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
> set_a $ff-$63,0
|
||
> load_flag 0
|
||
10be : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
10c0 : 48 > pha ;use stack to load status
|
||
10c1 : a99c > lda #$ff-$63 ;precharge accu
|
||
10c3 : 28 > plp
|
||
>
|
||
10c4 : 63 > db $63 ;test nop integrity - flags off
|
||
10c5 : ea > nop
|
||
10c6 : ea > nop
|
||
> tst_a $ff-$63,0
|
||
10c7 : 08 > php ;save flags
|
||
10c8 : c99c > cmp #$ff-$63 ;test result
|
||
> trap_ne
|
||
10ca : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
10cc : 68 > pla ;load status
|
||
10cd : 48 > pha
|
||
> cmp_flag 0
|
||
10ce : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
10d0 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
10d2 : 28 > plp ;restore status
|
||
>
|
||
> set_a $aa-$63,$ff
|
||
> load_flag $ff
|
||
10d3 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
10d5 : 48 > pha ;use stack to load status
|
||
10d6 : a947 > lda #$aa-$63 ;precharge accu
|
||
10d8 : 28 > plp
|
||
>
|
||
10d9 : 63 > db $63 ;test nop integrity - flags on
|
||
10da : ea > nop
|
||
10db : ea > nop
|
||
> tst_a $aa-$63,$ff
|
||
10dc : 08 > php ;save flags
|
||
10dd : c947 > cmp #$aa-$63 ;test result
|
||
> trap_ne
|
||
10df : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
10e1 : 68 > pla ;load status
|
||
10e2 : 48 > pha
|
||
> cmp_flag $ff
|
||
10e3 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
10e5 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
10e7 : 28 > plp ;restore status
|
||
>
|
||
10e8 : c042 > cpy #$42
|
||
> trap_ne ;y changed
|
||
10ea : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
10ec : e000 > cpx #0
|
||
> trap_ne ;x changed
|
||
10ee : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
nop_test $73,1
|
||
10f0 : a042 > ldy #$42
|
||
10f2 : a203 > ldx #4-1
|
||
10f4 : 73 > db $73 ;test nop length
|
||
> if 1 = 1
|
||
10f5 : ca > dex
|
||
10f6 : ca > dex
|
||
> endif
|
||
> if 1 = 2
|
||
> iny
|
||
> dex
|
||
> endif
|
||
> if 1 = 3
|
||
> iny
|
||
> iny
|
||
> endif
|
||
10f7 : ca > dex
|
||
> trap_ne ;wrong number of bytes
|
||
10f8 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
> set_a $ff-$73,0
|
||
> load_flag 0
|
||
10fa : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
10fc : 48 > pha ;use stack to load status
|
||
10fd : a98c > lda #$ff-$73 ;precharge accu
|
||
10ff : 28 > plp
|
||
>
|
||
1100 : 73 > db $73 ;test nop integrity - flags off
|
||
1101 : ea > nop
|
||
1102 : ea > nop
|
||
> tst_a $ff-$73,0
|
||
1103 : 08 > php ;save flags
|
||
1104 : c98c > cmp #$ff-$73 ;test result
|
||
> trap_ne
|
||
1106 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1108 : 68 > pla ;load status
|
||
1109 : 48 > pha
|
||
> cmp_flag 0
|
||
110a : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
110c : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
110e : 28 > plp ;restore status
|
||
>
|
||
> set_a $aa-$73,$ff
|
||
> load_flag $ff
|
||
110f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
1111 : 48 > pha ;use stack to load status
|
||
1112 : a937 > lda #$aa-$73 ;precharge accu
|
||
1114 : 28 > plp
|
||
>
|
||
1115 : 73 > db $73 ;test nop integrity - flags on
|
||
1116 : ea > nop
|
||
1117 : ea > nop
|
||
> tst_a $aa-$73,$ff
|
||
1118 : 08 > php ;save flags
|
||
1119 : c937 > cmp #$aa-$73 ;test result
|
||
> trap_ne
|
||
111b : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
111d : 68 > pla ;load status
|
||
111e : 48 > pha
|
||
> cmp_flag $ff
|
||
111f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1121 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1123 : 28 > plp ;restore status
|
||
>
|
||
1124 : c042 > cpy #$42
|
||
> trap_ne ;y changed
|
||
1126 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1128 : e000 > cpx #0
|
||
> trap_ne ;x changed
|
||
112a : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
nop_test $83,1
|
||
112c : a042 > ldy #$42
|
||
112e : a203 > ldx #4-1
|
||
1130 : 83 > db $83 ;test nop length
|
||
> if 1 = 1
|
||
1131 : ca > dex
|
||
1132 : ca > dex
|
||
> endif
|
||
> if 1 = 2
|
||
> iny
|
||
> dex
|
||
> endif
|
||
> if 1 = 3
|
||
> iny
|
||
> iny
|
||
> endif
|
||
1133 : ca > dex
|
||
> trap_ne ;wrong number of bytes
|
||
1134 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
> set_a $ff-$83,0
|
||
> load_flag 0
|
||
1136 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
1138 : 48 > pha ;use stack to load status
|
||
1139 : a97c > lda #$ff-$83 ;precharge accu
|
||
113b : 28 > plp
|
||
>
|
||
113c : 83 > db $83 ;test nop integrity - flags off
|
||
113d : ea > nop
|
||
113e : ea > nop
|
||
> tst_a $ff-$83,0
|
||
113f : 08 > php ;save flags
|
||
1140 : c97c > cmp #$ff-$83 ;test result
|
||
> trap_ne
|
||
1142 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1144 : 68 > pla ;load status
|
||
1145 : 48 > pha
|
||
> cmp_flag 0
|
||
1146 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1148 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
114a : 28 > plp ;restore status
|
||
>
|
||
> set_a $aa-$83,$ff
|
||
> load_flag $ff
|
||
114b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
114d : 48 > pha ;use stack to load status
|
||
114e : a927 > lda #$aa-$83 ;precharge accu
|
||
1150 : 28 > plp
|
||
>
|
||
1151 : 83 > db $83 ;test nop integrity - flags on
|
||
1152 : ea > nop
|
||
1153 : ea > nop
|
||
> tst_a $aa-$83,$ff
|
||
1154 : 08 > php ;save flags
|
||
1155 : c927 > cmp #$aa-$83 ;test result
|
||
> trap_ne
|
||
1157 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1159 : 68 > pla ;load status
|
||
115a : 48 > pha
|
||
> cmp_flag $ff
|
||
115b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
115d : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
115f : 28 > plp ;restore status
|
||
>
|
||
1160 : c042 > cpy #$42
|
||
> trap_ne ;y changed
|
||
1162 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1164 : e000 > cpx #0
|
||
> trap_ne ;x changed
|
||
1166 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
nop_test $93,1
|
||
1168 : a042 > ldy #$42
|
||
116a : a203 > ldx #4-1
|
||
116c : 93 > db $93 ;test nop length
|
||
> if 1 = 1
|
||
116d : ca > dex
|
||
116e : ca > dex
|
||
> endif
|
||
> if 1 = 2
|
||
> iny
|
||
> dex
|
||
> endif
|
||
> if 1 = 3
|
||
> iny
|
||
> iny
|
||
> endif
|
||
116f : ca > dex
|
||
> trap_ne ;wrong number of bytes
|
||
1170 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
> set_a $ff-$93,0
|
||
> load_flag 0
|
||
1172 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
1174 : 48 > pha ;use stack to load status
|
||
1175 : a96c > lda #$ff-$93 ;precharge accu
|
||
1177 : 28 > plp
|
||
>
|
||
1178 : 93 > db $93 ;test nop integrity - flags off
|
||
1179 : ea > nop
|
||
117a : ea > nop
|
||
> tst_a $ff-$93,0
|
||
117b : 08 > php ;save flags
|
||
117c : c96c > cmp #$ff-$93 ;test result
|
||
> trap_ne
|
||
117e : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1180 : 68 > pla ;load status
|
||
1181 : 48 > pha
|
||
> cmp_flag 0
|
||
1182 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1184 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1186 : 28 > plp ;restore status
|
||
>
|
||
> set_a $aa-$93,$ff
|
||
> load_flag $ff
|
||
1187 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
1189 : 48 > pha ;use stack to load status
|
||
118a : a917 > lda #$aa-$93 ;precharge accu
|
||
118c : 28 > plp
|
||
>
|
||
118d : 93 > db $93 ;test nop integrity - flags on
|
||
118e : ea > nop
|
||
118f : ea > nop
|
||
> tst_a $aa-$93,$ff
|
||
1190 : 08 > php ;save flags
|
||
1191 : c917 > cmp #$aa-$93 ;test result
|
||
> trap_ne
|
||
1193 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1195 : 68 > pla ;load status
|
||
1196 : 48 > pha
|
||
> cmp_flag $ff
|
||
1197 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1199 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
119b : 28 > plp ;restore status
|
||
>
|
||
119c : c042 > cpy #$42
|
||
> trap_ne ;y changed
|
||
119e : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
11a0 : e000 > cpx #0
|
||
> trap_ne ;x changed
|
||
11a2 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
nop_test $a3,1
|
||
11a4 : a042 > ldy #$42
|
||
11a6 : a203 > ldx #4-1
|
||
11a8 : a3 > db $a3 ;test nop length
|
||
> if 1 = 1
|
||
11a9 : ca > dex
|
||
11aa : ca > dex
|
||
> endif
|
||
> if 1 = 2
|
||
> iny
|
||
> dex
|
||
> endif
|
||
> if 1 = 3
|
||
> iny
|
||
> iny
|
||
> endif
|
||
11ab : ca > dex
|
||
> trap_ne ;wrong number of bytes
|
||
11ac : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
> set_a $ff-$a3,0
|
||
> load_flag 0
|
||
11ae : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
11b0 : 48 > pha ;use stack to load status
|
||
11b1 : a95c > lda #$ff-$a3 ;precharge accu
|
||
11b3 : 28 > plp
|
||
>
|
||
11b4 : a3 > db $a3 ;test nop integrity - flags off
|
||
11b5 : ea > nop
|
||
11b6 : ea > nop
|
||
> tst_a $ff-$a3,0
|
||
11b7 : 08 > php ;save flags
|
||
11b8 : c95c > cmp #$ff-$a3 ;test result
|
||
> trap_ne
|
||
11ba : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
11bc : 68 > pla ;load status
|
||
11bd : 48 > pha
|
||
> cmp_flag 0
|
||
11be : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
11c0 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
11c2 : 28 > plp ;restore status
|
||
>
|
||
> set_a $aa-$a3,$ff
|
||
> load_flag $ff
|
||
11c3 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
11c5 : 48 > pha ;use stack to load status
|
||
11c6 : a907 > lda #$aa-$a3 ;precharge accu
|
||
11c8 : 28 > plp
|
||
>
|
||
11c9 : a3 > db $a3 ;test nop integrity - flags on
|
||
11ca : ea > nop
|
||
11cb : ea > nop
|
||
> tst_a $aa-$a3,$ff
|
||
11cc : 08 > php ;save flags
|
||
11cd : c907 > cmp #$aa-$a3 ;test result
|
||
> trap_ne
|
||
11cf : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
11d1 : 68 > pla ;load status
|
||
11d2 : 48 > pha
|
||
> cmp_flag $ff
|
||
11d3 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
11d5 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
11d7 : 28 > plp ;restore status
|
||
>
|
||
11d8 : c042 > cpy #$42
|
||
> trap_ne ;y changed
|
||
11da : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
11dc : e000 > cpx #0
|
||
> trap_ne ;x changed
|
||
11de : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
nop_test $b3,1
|
||
11e0 : a042 > ldy #$42
|
||
11e2 : a203 > ldx #4-1
|
||
11e4 : b3 > db $b3 ;test nop length
|
||
> if 1 = 1
|
||
11e5 : ca > dex
|
||
11e6 : ca > dex
|
||
> endif
|
||
> if 1 = 2
|
||
> iny
|
||
> dex
|
||
> endif
|
||
> if 1 = 3
|
||
> iny
|
||
> iny
|
||
> endif
|
||
11e7 : ca > dex
|
||
> trap_ne ;wrong number of bytes
|
||
11e8 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
> set_a $ff-$b3,0
|
||
> load_flag 0
|
||
11ea : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
11ec : 48 > pha ;use stack to load status
|
||
11ed : a94c > lda #$ff-$b3 ;precharge accu
|
||
11ef : 28 > plp
|
||
>
|
||
11f0 : b3 > db $b3 ;test nop integrity - flags off
|
||
11f1 : ea > nop
|
||
11f2 : ea > nop
|
||
> tst_a $ff-$b3,0
|
||
11f3 : 08 > php ;save flags
|
||
11f4 : c94c > cmp #$ff-$b3 ;test result
|
||
> trap_ne
|
||
11f6 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
11f8 : 68 > pla ;load status
|
||
11f9 : 48 > pha
|
||
> cmp_flag 0
|
||
11fa : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
11fc : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
11fe : 28 > plp ;restore status
|
||
>
|
||
> set_a $aa-$b3,$ff
|
||
> load_flag $ff
|
||
11ff : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
1201 : 48 > pha ;use stack to load status
|
||
1202 : a9f7 > lda #$aa-$b3 ;precharge accu
|
||
1204 : 28 > plp
|
||
>
|
||
1205 : b3 > db $b3 ;test nop integrity - flags on
|
||
1206 : ea > nop
|
||
1207 : ea > nop
|
||
> tst_a $aa-$b3,$ff
|
||
1208 : 08 > php ;save flags
|
||
1209 : c9f7 > cmp #$aa-$b3 ;test result
|
||
> trap_ne
|
||
120b : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
120d : 68 > pla ;load status
|
||
120e : 48 > pha
|
||
> cmp_flag $ff
|
||
120f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1211 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1213 : 28 > plp ;restore status
|
||
>
|
||
1214 : c042 > cpy #$42
|
||
> trap_ne ;y changed
|
||
1216 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1218 : e000 > cpx #0
|
||
> trap_ne ;x changed
|
||
121a : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
nop_test $c3,1
|
||
121c : a042 > ldy #$42
|
||
121e : a203 > ldx #4-1
|
||
1220 : c3 > db $c3 ;test nop length
|
||
> if 1 = 1
|
||
1221 : ca > dex
|
||
1222 : ca > dex
|
||
> endif
|
||
> if 1 = 2
|
||
> iny
|
||
> dex
|
||
> endif
|
||
> if 1 = 3
|
||
> iny
|
||
> iny
|
||
> endif
|
||
1223 : ca > dex
|
||
> trap_ne ;wrong number of bytes
|
||
1224 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
> set_a $ff-$c3,0
|
||
> load_flag 0
|
||
1226 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
1228 : 48 > pha ;use stack to load status
|
||
1229 : a93c > lda #$ff-$c3 ;precharge accu
|
||
122b : 28 > plp
|
||
>
|
||
122c : c3 > db $c3 ;test nop integrity - flags off
|
||
122d : ea > nop
|
||
122e : ea > nop
|
||
> tst_a $ff-$c3,0
|
||
122f : 08 > php ;save flags
|
||
1230 : c93c > cmp #$ff-$c3 ;test result
|
||
> trap_ne
|
||
1232 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1234 : 68 > pla ;load status
|
||
1235 : 48 > pha
|
||
> cmp_flag 0
|
||
1236 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1238 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
123a : 28 > plp ;restore status
|
||
>
|
||
> set_a $aa-$c3,$ff
|
||
> load_flag $ff
|
||
123b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
123d : 48 > pha ;use stack to load status
|
||
123e : a9e7 > lda #$aa-$c3 ;precharge accu
|
||
1240 : 28 > plp
|
||
>
|
||
1241 : c3 > db $c3 ;test nop integrity - flags on
|
||
1242 : ea > nop
|
||
1243 : ea > nop
|
||
> tst_a $aa-$c3,$ff
|
||
1244 : 08 > php ;save flags
|
||
1245 : c9e7 > cmp #$aa-$c3 ;test result
|
||
> trap_ne
|
||
1247 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1249 : 68 > pla ;load status
|
||
124a : 48 > pha
|
||
> cmp_flag $ff
|
||
124b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
124d : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
124f : 28 > plp ;restore status
|
||
>
|
||
1250 : c042 > cpy #$42
|
||
> trap_ne ;y changed
|
||
1252 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1254 : e000 > cpx #0
|
||
> trap_ne ;x changed
|
||
1256 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
nop_test $d3,1
|
||
1258 : a042 > ldy #$42
|
||
125a : a203 > ldx #4-1
|
||
125c : d3 > db $d3 ;test nop length
|
||
> if 1 = 1
|
||
125d : ca > dex
|
||
125e : ca > dex
|
||
> endif
|
||
> if 1 = 2
|
||
> iny
|
||
> dex
|
||
> endif
|
||
> if 1 = 3
|
||
> iny
|
||
> iny
|
||
> endif
|
||
125f : ca > dex
|
||
> trap_ne ;wrong number of bytes
|
||
1260 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
> set_a $ff-$d3,0
|
||
> load_flag 0
|
||
1262 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
1264 : 48 > pha ;use stack to load status
|
||
1265 : a92c > lda #$ff-$d3 ;precharge accu
|
||
1267 : 28 > plp
|
||
>
|
||
1268 : d3 > db $d3 ;test nop integrity - flags off
|
||
1269 : ea > nop
|
||
126a : ea > nop
|
||
> tst_a $ff-$d3,0
|
||
126b : 08 > php ;save flags
|
||
126c : c92c > cmp #$ff-$d3 ;test result
|
||
> trap_ne
|
||
126e : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1270 : 68 > pla ;load status
|
||
1271 : 48 > pha
|
||
> cmp_flag 0
|
||
1272 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1274 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1276 : 28 > plp ;restore status
|
||
>
|
||
> set_a $aa-$d3,$ff
|
||
> load_flag $ff
|
||
1277 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
1279 : 48 > pha ;use stack to load status
|
||
127a : a9d7 > lda #$aa-$d3 ;precharge accu
|
||
127c : 28 > plp
|
||
>
|
||
127d : d3 > db $d3 ;test nop integrity - flags on
|
||
127e : ea > nop
|
||
127f : ea > nop
|
||
> tst_a $aa-$d3,$ff
|
||
1280 : 08 > php ;save flags
|
||
1281 : c9d7 > cmp #$aa-$d3 ;test result
|
||
> trap_ne
|
||
1283 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1285 : 68 > pla ;load status
|
||
1286 : 48 > pha
|
||
> cmp_flag $ff
|
||
1287 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1289 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
128b : 28 > plp ;restore status
|
||
>
|
||
128c : c042 > cpy #$42
|
||
> trap_ne ;y changed
|
||
128e : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1290 : e000 > cpx #0
|
||
> trap_ne ;x changed
|
||
1292 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
nop_test $e3,1
|
||
1294 : a042 > ldy #$42
|
||
1296 : a203 > ldx #4-1
|
||
1298 : e3 > db $e3 ;test nop length
|
||
> if 1 = 1
|
||
1299 : ca > dex
|
||
129a : ca > dex
|
||
> endif
|
||
> if 1 = 2
|
||
> iny
|
||
> dex
|
||
> endif
|
||
> if 1 = 3
|
||
> iny
|
||
> iny
|
||
> endif
|
||
129b : ca > dex
|
||
> trap_ne ;wrong number of bytes
|
||
129c : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
> set_a $ff-$e3,0
|
||
> load_flag 0
|
||
129e : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
12a0 : 48 > pha ;use stack to load status
|
||
12a1 : a91c > lda #$ff-$e3 ;precharge accu
|
||
12a3 : 28 > plp
|
||
>
|
||
12a4 : e3 > db $e3 ;test nop integrity - flags off
|
||
12a5 : ea > nop
|
||
12a6 : ea > nop
|
||
> tst_a $ff-$e3,0
|
||
12a7 : 08 > php ;save flags
|
||
12a8 : c91c > cmp #$ff-$e3 ;test result
|
||
> trap_ne
|
||
12aa : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
12ac : 68 > pla ;load status
|
||
12ad : 48 > pha
|
||
> cmp_flag 0
|
||
12ae : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
12b0 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
12b2 : 28 > plp ;restore status
|
||
>
|
||
> set_a $aa-$e3,$ff
|
||
> load_flag $ff
|
||
12b3 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
12b5 : 48 > pha ;use stack to load status
|
||
12b6 : a9c7 > lda #$aa-$e3 ;precharge accu
|
||
12b8 : 28 > plp
|
||
>
|
||
12b9 : e3 > db $e3 ;test nop integrity - flags on
|
||
12ba : ea > nop
|
||
12bb : ea > nop
|
||
> tst_a $aa-$e3,$ff
|
||
12bc : 08 > php ;save flags
|
||
12bd : c9c7 > cmp #$aa-$e3 ;test result
|
||
> trap_ne
|
||
12bf : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
12c1 : 68 > pla ;load status
|
||
12c2 : 48 > pha
|
||
> cmp_flag $ff
|
||
12c3 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
12c5 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
12c7 : 28 > plp ;restore status
|
||
>
|
||
12c8 : c042 > cpy #$42
|
||
> trap_ne ;y changed
|
||
12ca : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
12cc : e000 > cpx #0
|
||
> trap_ne ;x changed
|
||
12ce : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
nop_test $f3,1
|
||
12d0 : a042 > ldy #$42
|
||
12d2 : a203 > ldx #4-1
|
||
12d4 : f3 > db $f3 ;test nop length
|
||
> if 1 = 1
|
||
12d5 : ca > dex
|
||
12d6 : ca > dex
|
||
> endif
|
||
> if 1 = 2
|
||
> iny
|
||
> dex
|
||
> endif
|
||
> if 1 = 3
|
||
> iny
|
||
> iny
|
||
> endif
|
||
12d7 : ca > dex
|
||
> trap_ne ;wrong number of bytes
|
||
12d8 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
> set_a $ff-$f3,0
|
||
> load_flag 0
|
||
12da : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
12dc : 48 > pha ;use stack to load status
|
||
12dd : a90c > lda #$ff-$f3 ;precharge accu
|
||
12df : 28 > plp
|
||
>
|
||
12e0 : f3 > db $f3 ;test nop integrity - flags off
|
||
12e1 : ea > nop
|
||
12e2 : ea > nop
|
||
> tst_a $ff-$f3,0
|
||
12e3 : 08 > php ;save flags
|
||
12e4 : c90c > cmp #$ff-$f3 ;test result
|
||
> trap_ne
|
||
12e6 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
12e8 : 68 > pla ;load status
|
||
12e9 : 48 > pha
|
||
> cmp_flag 0
|
||
12ea : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
12ec : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
12ee : 28 > plp ;restore status
|
||
>
|
||
> set_a $aa-$f3,$ff
|
||
> load_flag $ff
|
||
12ef : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
12f1 : 48 > pha ;use stack to load status
|
||
12f2 : a9b7 > lda #$aa-$f3 ;precharge accu
|
||
12f4 : 28 > plp
|
||
>
|
||
12f5 : f3 > db $f3 ;test nop integrity - flags on
|
||
12f6 : ea > nop
|
||
12f7 : ea > nop
|
||
> tst_a $aa-$f3,$ff
|
||
12f8 : 08 > php ;save flags
|
||
12f9 : c9b7 > cmp #$aa-$f3 ;test result
|
||
> trap_ne
|
||
12fb : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
12fd : 68 > pla ;load status
|
||
12fe : 48 > pha
|
||
> cmp_flag $ff
|
||
12ff : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1301 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1303 : 28 > plp ;restore status
|
||
>
|
||
1304 : c042 > cpy #$42
|
||
> trap_ne ;y changed
|
||
1306 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1308 : e000 > cpx #0
|
||
> trap_ne ;x changed
|
||
130a : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
nop_test $0b,1
|
||
130c : a042 > ldy #$42
|
||
130e : a203 > ldx #4-1
|
||
1310 : 0b > db $0b ;test nop length
|
||
> if 1 = 1
|
||
1311 : ca > dex
|
||
1312 : ca > dex
|
||
> endif
|
||
> if 1 = 2
|
||
> iny
|
||
> dex
|
||
> endif
|
||
> if 1 = 3
|
||
> iny
|
||
> iny
|
||
> endif
|
||
1313 : ca > dex
|
||
> trap_ne ;wrong number of bytes
|
||
1314 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
> set_a $ff-$0b,0
|
||
> load_flag 0
|
||
1316 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
1318 : 48 > pha ;use stack to load status
|
||
1319 : a9f4 > lda #$ff-$0b ;precharge accu
|
||
131b : 28 > plp
|
||
>
|
||
131c : 0b > db $0b ;test nop integrity - flags off
|
||
131d : ea > nop
|
||
131e : ea > nop
|
||
> tst_a $ff-$0b,0
|
||
131f : 08 > php ;save flags
|
||
1320 : c9f4 > cmp #$ff-$0b ;test result
|
||
> trap_ne
|
||
1322 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1324 : 68 > pla ;load status
|
||
1325 : 48 > pha
|
||
> cmp_flag 0
|
||
1326 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1328 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
132a : 28 > plp ;restore status
|
||
>
|
||
> set_a $aa-$0b,$ff
|
||
> load_flag $ff
|
||
132b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
132d : 48 > pha ;use stack to load status
|
||
132e : a99f > lda #$aa-$0b ;precharge accu
|
||
1330 : 28 > plp
|
||
>
|
||
1331 : 0b > db $0b ;test nop integrity - flags on
|
||
1332 : ea > nop
|
||
1333 : ea > nop
|
||
> tst_a $aa-$0b,$ff
|
||
1334 : 08 > php ;save flags
|
||
1335 : c99f > cmp #$aa-$0b ;test result
|
||
> trap_ne
|
||
1337 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1339 : 68 > pla ;load status
|
||
133a : 48 > pha
|
||
> cmp_flag $ff
|
||
133b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
133d : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
133f : 28 > plp ;restore status
|
||
>
|
||
1340 : c042 > cpy #$42
|
||
> trap_ne ;y changed
|
||
1342 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1344 : e000 > cpx #0
|
||
> trap_ne ;x changed
|
||
1346 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
nop_test $1b,1
|
||
1348 : a042 > ldy #$42
|
||
134a : a203 > ldx #4-1
|
||
134c : 1b > db $1b ;test nop length
|
||
> if 1 = 1
|
||
134d : ca > dex
|
||
134e : ca > dex
|
||
> endif
|
||
> if 1 = 2
|
||
> iny
|
||
> dex
|
||
> endif
|
||
> if 1 = 3
|
||
> iny
|
||
> iny
|
||
> endif
|
||
134f : ca > dex
|
||
> trap_ne ;wrong number of bytes
|
||
1350 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
> set_a $ff-$1b,0
|
||
> load_flag 0
|
||
1352 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
1354 : 48 > pha ;use stack to load status
|
||
1355 : a9e4 > lda #$ff-$1b ;precharge accu
|
||
1357 : 28 > plp
|
||
>
|
||
1358 : 1b > db $1b ;test nop integrity - flags off
|
||
1359 : ea > nop
|
||
135a : ea > nop
|
||
> tst_a $ff-$1b,0
|
||
135b : 08 > php ;save flags
|
||
135c : c9e4 > cmp #$ff-$1b ;test result
|
||
> trap_ne
|
||
135e : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1360 : 68 > pla ;load status
|
||
1361 : 48 > pha
|
||
> cmp_flag 0
|
||
1362 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1364 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1366 : 28 > plp ;restore status
|
||
>
|
||
> set_a $aa-$1b,$ff
|
||
> load_flag $ff
|
||
1367 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
1369 : 48 > pha ;use stack to load status
|
||
136a : a98f > lda #$aa-$1b ;precharge accu
|
||
136c : 28 > plp
|
||
>
|
||
136d : 1b > db $1b ;test nop integrity - flags on
|
||
136e : ea > nop
|
||
136f : ea > nop
|
||
> tst_a $aa-$1b,$ff
|
||
1370 : 08 > php ;save flags
|
||
1371 : c98f > cmp #$aa-$1b ;test result
|
||
> trap_ne
|
||
1373 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1375 : 68 > pla ;load status
|
||
1376 : 48 > pha
|
||
> cmp_flag $ff
|
||
1377 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1379 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
137b : 28 > plp ;restore status
|
||
>
|
||
137c : c042 > cpy #$42
|
||
> trap_ne ;y changed
|
||
137e : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1380 : e000 > cpx #0
|
||
> trap_ne ;x changed
|
||
1382 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
nop_test $2b,1
|
||
1384 : a042 > ldy #$42
|
||
1386 : a203 > ldx #4-1
|
||
1388 : 2b > db $2b ;test nop length
|
||
> if 1 = 1
|
||
1389 : ca > dex
|
||
138a : ca > dex
|
||
> endif
|
||
> if 1 = 2
|
||
> iny
|
||
> dex
|
||
> endif
|
||
> if 1 = 3
|
||
> iny
|
||
> iny
|
||
> endif
|
||
138b : ca > dex
|
||
> trap_ne ;wrong number of bytes
|
||
138c : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
> set_a $ff-$2b,0
|
||
> load_flag 0
|
||
138e : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
1390 : 48 > pha ;use stack to load status
|
||
1391 : a9d4 > lda #$ff-$2b ;precharge accu
|
||
1393 : 28 > plp
|
||
>
|
||
1394 : 2b > db $2b ;test nop integrity - flags off
|
||
1395 : ea > nop
|
||
1396 : ea > nop
|
||
> tst_a $ff-$2b,0
|
||
1397 : 08 > php ;save flags
|
||
1398 : c9d4 > cmp #$ff-$2b ;test result
|
||
> trap_ne
|
||
139a : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
139c : 68 > pla ;load status
|
||
139d : 48 > pha
|
||
> cmp_flag 0
|
||
139e : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
13a0 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
13a2 : 28 > plp ;restore status
|
||
>
|
||
> set_a $aa-$2b,$ff
|
||
> load_flag $ff
|
||
13a3 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
13a5 : 48 > pha ;use stack to load status
|
||
13a6 : a97f > lda #$aa-$2b ;precharge accu
|
||
13a8 : 28 > plp
|
||
>
|
||
13a9 : 2b > db $2b ;test nop integrity - flags on
|
||
13aa : ea > nop
|
||
13ab : ea > nop
|
||
> tst_a $aa-$2b,$ff
|
||
13ac : 08 > php ;save flags
|
||
13ad : c97f > cmp #$aa-$2b ;test result
|
||
> trap_ne
|
||
13af : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
13b1 : 68 > pla ;load status
|
||
13b2 : 48 > pha
|
||
> cmp_flag $ff
|
||
13b3 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
13b5 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
13b7 : 28 > plp ;restore status
|
||
>
|
||
13b8 : c042 > cpy #$42
|
||
> trap_ne ;y changed
|
||
13ba : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
13bc : e000 > cpx #0
|
||
> trap_ne ;x changed
|
||
13be : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
nop_test $3b,1
|
||
13c0 : a042 > ldy #$42
|
||
13c2 : a203 > ldx #4-1
|
||
13c4 : 3b > db $3b ;test nop length
|
||
> if 1 = 1
|
||
13c5 : ca > dex
|
||
13c6 : ca > dex
|
||
> endif
|
||
> if 1 = 2
|
||
> iny
|
||
> dex
|
||
> endif
|
||
> if 1 = 3
|
||
> iny
|
||
> iny
|
||
> endif
|
||
13c7 : ca > dex
|
||
> trap_ne ;wrong number of bytes
|
||
13c8 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
> set_a $ff-$3b,0
|
||
> load_flag 0
|
||
13ca : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
13cc : 48 > pha ;use stack to load status
|
||
13cd : a9c4 > lda #$ff-$3b ;precharge accu
|
||
13cf : 28 > plp
|
||
>
|
||
13d0 : 3b > db $3b ;test nop integrity - flags off
|
||
13d1 : ea > nop
|
||
13d2 : ea > nop
|
||
> tst_a $ff-$3b,0
|
||
13d3 : 08 > php ;save flags
|
||
13d4 : c9c4 > cmp #$ff-$3b ;test result
|
||
> trap_ne
|
||
13d6 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
13d8 : 68 > pla ;load status
|
||
13d9 : 48 > pha
|
||
> cmp_flag 0
|
||
13da : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
13dc : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
13de : 28 > plp ;restore status
|
||
>
|
||
> set_a $aa-$3b,$ff
|
||
> load_flag $ff
|
||
13df : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
13e1 : 48 > pha ;use stack to load status
|
||
13e2 : a96f > lda #$aa-$3b ;precharge accu
|
||
13e4 : 28 > plp
|
||
>
|
||
13e5 : 3b > db $3b ;test nop integrity - flags on
|
||
13e6 : ea > nop
|
||
13e7 : ea > nop
|
||
> tst_a $aa-$3b,$ff
|
||
13e8 : 08 > php ;save flags
|
||
13e9 : c96f > cmp #$aa-$3b ;test result
|
||
> trap_ne
|
||
13eb : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
13ed : 68 > pla ;load status
|
||
13ee : 48 > pha
|
||
> cmp_flag $ff
|
||
13ef : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
13f1 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
13f3 : 28 > plp ;restore status
|
||
>
|
||
13f4 : c042 > cpy #$42
|
||
> trap_ne ;y changed
|
||
13f6 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
13f8 : e000 > cpx #0
|
||
> trap_ne ;x changed
|
||
13fa : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
nop_test $4b,1
|
||
13fc : a042 > ldy #$42
|
||
13fe : a203 > ldx #4-1
|
||
1400 : 4b > db $4b ;test nop length
|
||
> if 1 = 1
|
||
1401 : ca > dex
|
||
1402 : ca > dex
|
||
> endif
|
||
> if 1 = 2
|
||
> iny
|
||
> dex
|
||
> endif
|
||
> if 1 = 3
|
||
> iny
|
||
> iny
|
||
> endif
|
||
1403 : ca > dex
|
||
> trap_ne ;wrong number of bytes
|
||
1404 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
> set_a $ff-$4b,0
|
||
> load_flag 0
|
||
1406 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
1408 : 48 > pha ;use stack to load status
|
||
1409 : a9b4 > lda #$ff-$4b ;precharge accu
|
||
140b : 28 > plp
|
||
>
|
||
140c : 4b > db $4b ;test nop integrity - flags off
|
||
140d : ea > nop
|
||
140e : ea > nop
|
||
> tst_a $ff-$4b,0
|
||
140f : 08 > php ;save flags
|
||
1410 : c9b4 > cmp #$ff-$4b ;test result
|
||
> trap_ne
|
||
1412 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1414 : 68 > pla ;load status
|
||
1415 : 48 > pha
|
||
> cmp_flag 0
|
||
1416 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1418 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
141a : 28 > plp ;restore status
|
||
>
|
||
> set_a $aa-$4b,$ff
|
||
> load_flag $ff
|
||
141b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
141d : 48 > pha ;use stack to load status
|
||
141e : a95f > lda #$aa-$4b ;precharge accu
|
||
1420 : 28 > plp
|
||
>
|
||
1421 : 4b > db $4b ;test nop integrity - flags on
|
||
1422 : ea > nop
|
||
1423 : ea > nop
|
||
> tst_a $aa-$4b,$ff
|
||
1424 : 08 > php ;save flags
|
||
1425 : c95f > cmp #$aa-$4b ;test result
|
||
> trap_ne
|
||
1427 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1429 : 68 > pla ;load status
|
||
142a : 48 > pha
|
||
> cmp_flag $ff
|
||
142b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
142d : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
142f : 28 > plp ;restore status
|
||
>
|
||
1430 : c042 > cpy #$42
|
||
> trap_ne ;y changed
|
||
1432 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1434 : e000 > cpx #0
|
||
> trap_ne ;x changed
|
||
1436 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
nop_test $5b,1
|
||
1438 : a042 > ldy #$42
|
||
143a : a203 > ldx #4-1
|
||
143c : 5b > db $5b ;test nop length
|
||
> if 1 = 1
|
||
143d : ca > dex
|
||
143e : ca > dex
|
||
> endif
|
||
> if 1 = 2
|
||
> iny
|
||
> dex
|
||
> endif
|
||
> if 1 = 3
|
||
> iny
|
||
> iny
|
||
> endif
|
||
143f : ca > dex
|
||
> trap_ne ;wrong number of bytes
|
||
1440 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
> set_a $ff-$5b,0
|
||
> load_flag 0
|
||
1442 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
1444 : 48 > pha ;use stack to load status
|
||
1445 : a9a4 > lda #$ff-$5b ;precharge accu
|
||
1447 : 28 > plp
|
||
>
|
||
1448 : 5b > db $5b ;test nop integrity - flags off
|
||
1449 : ea > nop
|
||
144a : ea > nop
|
||
> tst_a $ff-$5b,0
|
||
144b : 08 > php ;save flags
|
||
144c : c9a4 > cmp #$ff-$5b ;test result
|
||
> trap_ne
|
||
144e : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1450 : 68 > pla ;load status
|
||
1451 : 48 > pha
|
||
> cmp_flag 0
|
||
1452 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1454 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1456 : 28 > plp ;restore status
|
||
>
|
||
> set_a $aa-$5b,$ff
|
||
> load_flag $ff
|
||
1457 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
1459 : 48 > pha ;use stack to load status
|
||
145a : a94f > lda #$aa-$5b ;precharge accu
|
||
145c : 28 > plp
|
||
>
|
||
145d : 5b > db $5b ;test nop integrity - flags on
|
||
145e : ea > nop
|
||
145f : ea > nop
|
||
> tst_a $aa-$5b,$ff
|
||
1460 : 08 > php ;save flags
|
||
1461 : c94f > cmp #$aa-$5b ;test result
|
||
> trap_ne
|
||
1463 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1465 : 68 > pla ;load status
|
||
1466 : 48 > pha
|
||
> cmp_flag $ff
|
||
1467 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1469 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
146b : 28 > plp ;restore status
|
||
>
|
||
146c : c042 > cpy #$42
|
||
> trap_ne ;y changed
|
||
146e : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1470 : e000 > cpx #0
|
||
> trap_ne ;x changed
|
||
1472 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
nop_test $6b,1
|
||
1474 : a042 > ldy #$42
|
||
1476 : a203 > ldx #4-1
|
||
1478 : 6b > db $6b ;test nop length
|
||
> if 1 = 1
|
||
1479 : ca > dex
|
||
147a : ca > dex
|
||
> endif
|
||
> if 1 = 2
|
||
> iny
|
||
> dex
|
||
> endif
|
||
> if 1 = 3
|
||
> iny
|
||
> iny
|
||
> endif
|
||
147b : ca > dex
|
||
> trap_ne ;wrong number of bytes
|
||
147c : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
> set_a $ff-$6b,0
|
||
> load_flag 0
|
||
147e : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
1480 : 48 > pha ;use stack to load status
|
||
1481 : a994 > lda #$ff-$6b ;precharge accu
|
||
1483 : 28 > plp
|
||
>
|
||
1484 : 6b > db $6b ;test nop integrity - flags off
|
||
1485 : ea > nop
|
||
1486 : ea > nop
|
||
> tst_a $ff-$6b,0
|
||
1487 : 08 > php ;save flags
|
||
1488 : c994 > cmp #$ff-$6b ;test result
|
||
> trap_ne
|
||
148a : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
148c : 68 > pla ;load status
|
||
148d : 48 > pha
|
||
> cmp_flag 0
|
||
148e : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1490 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1492 : 28 > plp ;restore status
|
||
>
|
||
> set_a $aa-$6b,$ff
|
||
> load_flag $ff
|
||
1493 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
1495 : 48 > pha ;use stack to load status
|
||
1496 : a93f > lda #$aa-$6b ;precharge accu
|
||
1498 : 28 > plp
|
||
>
|
||
1499 : 6b > db $6b ;test nop integrity - flags on
|
||
149a : ea > nop
|
||
149b : ea > nop
|
||
> tst_a $aa-$6b,$ff
|
||
149c : 08 > php ;save flags
|
||
149d : c93f > cmp #$aa-$6b ;test result
|
||
> trap_ne
|
||
149f : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
14a1 : 68 > pla ;load status
|
||
14a2 : 48 > pha
|
||
> cmp_flag $ff
|
||
14a3 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
14a5 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
14a7 : 28 > plp ;restore status
|
||
>
|
||
14a8 : c042 > cpy #$42
|
||
> trap_ne ;y changed
|
||
14aa : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
14ac : e000 > cpx #0
|
||
> trap_ne ;x changed
|
||
14ae : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
nop_test $7b,1
|
||
14b0 : a042 > ldy #$42
|
||
14b2 : a203 > ldx #4-1
|
||
14b4 : 7b > db $7b ;test nop length
|
||
> if 1 = 1
|
||
14b5 : ca > dex
|
||
14b6 : ca > dex
|
||
> endif
|
||
> if 1 = 2
|
||
> iny
|
||
> dex
|
||
> endif
|
||
> if 1 = 3
|
||
> iny
|
||
> iny
|
||
> endif
|
||
14b7 : ca > dex
|
||
> trap_ne ;wrong number of bytes
|
||
14b8 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
> set_a $ff-$7b,0
|
||
> load_flag 0
|
||
14ba : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
14bc : 48 > pha ;use stack to load status
|
||
14bd : a984 > lda #$ff-$7b ;precharge accu
|
||
14bf : 28 > plp
|
||
>
|
||
14c0 : 7b > db $7b ;test nop integrity - flags off
|
||
14c1 : ea > nop
|
||
14c2 : ea > nop
|
||
> tst_a $ff-$7b,0
|
||
14c3 : 08 > php ;save flags
|
||
14c4 : c984 > cmp #$ff-$7b ;test result
|
||
> trap_ne
|
||
14c6 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
14c8 : 68 > pla ;load status
|
||
14c9 : 48 > pha
|
||
> cmp_flag 0
|
||
14ca : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
14cc : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
14ce : 28 > plp ;restore status
|
||
>
|
||
> set_a $aa-$7b,$ff
|
||
> load_flag $ff
|
||
14cf : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
14d1 : 48 > pha ;use stack to load status
|
||
14d2 : a92f > lda #$aa-$7b ;precharge accu
|
||
14d4 : 28 > plp
|
||
>
|
||
14d5 : 7b > db $7b ;test nop integrity - flags on
|
||
14d6 : ea > nop
|
||
14d7 : ea > nop
|
||
> tst_a $aa-$7b,$ff
|
||
14d8 : 08 > php ;save flags
|
||
14d9 : c92f > cmp #$aa-$7b ;test result
|
||
> trap_ne
|
||
14db : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
14dd : 68 > pla ;load status
|
||
14de : 48 > pha
|
||
> cmp_flag $ff
|
||
14df : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
14e1 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
14e3 : 28 > plp ;restore status
|
||
>
|
||
14e4 : c042 > cpy #$42
|
||
> trap_ne ;y changed
|
||
14e6 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
14e8 : e000 > cpx #0
|
||
> trap_ne ;x changed
|
||
14ea : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
nop_test $8b,1
|
||
14ec : a042 > ldy #$42
|
||
14ee : a203 > ldx #4-1
|
||
14f0 : 8b > db $8b ;test nop length
|
||
> if 1 = 1
|
||
14f1 : ca > dex
|
||
14f2 : ca > dex
|
||
> endif
|
||
> if 1 = 2
|
||
> iny
|
||
> dex
|
||
> endif
|
||
> if 1 = 3
|
||
> iny
|
||
> iny
|
||
> endif
|
||
14f3 : ca > dex
|
||
> trap_ne ;wrong number of bytes
|
||
14f4 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
> set_a $ff-$8b,0
|
||
> load_flag 0
|
||
14f6 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
14f8 : 48 > pha ;use stack to load status
|
||
14f9 : a974 > lda #$ff-$8b ;precharge accu
|
||
14fb : 28 > plp
|
||
>
|
||
14fc : 8b > db $8b ;test nop integrity - flags off
|
||
14fd : ea > nop
|
||
14fe : ea > nop
|
||
> tst_a $ff-$8b,0
|
||
14ff : 08 > php ;save flags
|
||
1500 : c974 > cmp #$ff-$8b ;test result
|
||
> trap_ne
|
||
1502 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1504 : 68 > pla ;load status
|
||
1505 : 48 > pha
|
||
> cmp_flag 0
|
||
1506 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1508 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
150a : 28 > plp ;restore status
|
||
>
|
||
> set_a $aa-$8b,$ff
|
||
> load_flag $ff
|
||
150b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
150d : 48 > pha ;use stack to load status
|
||
150e : a91f > lda #$aa-$8b ;precharge accu
|
||
1510 : 28 > plp
|
||
>
|
||
1511 : 8b > db $8b ;test nop integrity - flags on
|
||
1512 : ea > nop
|
||
1513 : ea > nop
|
||
> tst_a $aa-$8b,$ff
|
||
1514 : 08 > php ;save flags
|
||
1515 : c91f > cmp #$aa-$8b ;test result
|
||
> trap_ne
|
||
1517 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1519 : 68 > pla ;load status
|
||
151a : 48 > pha
|
||
> cmp_flag $ff
|
||
151b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
151d : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
151f : 28 > plp ;restore status
|
||
>
|
||
1520 : c042 > cpy #$42
|
||
> trap_ne ;y changed
|
||
1522 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1524 : e000 > cpx #0
|
||
> trap_ne ;x changed
|
||
1526 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
nop_test $9b,1
|
||
1528 : a042 > ldy #$42
|
||
152a : a203 > ldx #4-1
|
||
152c : 9b > db $9b ;test nop length
|
||
> if 1 = 1
|
||
152d : ca > dex
|
||
152e : ca > dex
|
||
> endif
|
||
> if 1 = 2
|
||
> iny
|
||
> dex
|
||
> endif
|
||
> if 1 = 3
|
||
> iny
|
||
> iny
|
||
> endif
|
||
152f : ca > dex
|
||
> trap_ne ;wrong number of bytes
|
||
1530 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
> set_a $ff-$9b,0
|
||
> load_flag 0
|
||
1532 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
1534 : 48 > pha ;use stack to load status
|
||
1535 : a964 > lda #$ff-$9b ;precharge accu
|
||
1537 : 28 > plp
|
||
>
|
||
1538 : 9b > db $9b ;test nop integrity - flags off
|
||
1539 : ea > nop
|
||
153a : ea > nop
|
||
> tst_a $ff-$9b,0
|
||
153b : 08 > php ;save flags
|
||
153c : c964 > cmp #$ff-$9b ;test result
|
||
> trap_ne
|
||
153e : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1540 : 68 > pla ;load status
|
||
1541 : 48 > pha
|
||
> cmp_flag 0
|
||
1542 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1544 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1546 : 28 > plp ;restore status
|
||
>
|
||
> set_a $aa-$9b,$ff
|
||
> load_flag $ff
|
||
1547 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
1549 : 48 > pha ;use stack to load status
|
||
154a : a90f > lda #$aa-$9b ;precharge accu
|
||
154c : 28 > plp
|
||
>
|
||
154d : 9b > db $9b ;test nop integrity - flags on
|
||
154e : ea > nop
|
||
154f : ea > nop
|
||
> tst_a $aa-$9b,$ff
|
||
1550 : 08 > php ;save flags
|
||
1551 : c90f > cmp #$aa-$9b ;test result
|
||
> trap_ne
|
||
1553 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1555 : 68 > pla ;load status
|
||
1556 : 48 > pha
|
||
> cmp_flag $ff
|
||
1557 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1559 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
155b : 28 > plp ;restore status
|
||
>
|
||
155c : c042 > cpy #$42
|
||
> trap_ne ;y changed
|
||
155e : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1560 : e000 > cpx #0
|
||
> trap_ne ;x changed
|
||
1562 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
nop_test $ab,1
|
||
1564 : a042 > ldy #$42
|
||
1566 : a203 > ldx #4-1
|
||
1568 : ab > db $ab ;test nop length
|
||
> if 1 = 1
|
||
1569 : ca > dex
|
||
156a : ca > dex
|
||
> endif
|
||
> if 1 = 2
|
||
> iny
|
||
> dex
|
||
> endif
|
||
> if 1 = 3
|
||
> iny
|
||
> iny
|
||
> endif
|
||
156b : ca > dex
|
||
> trap_ne ;wrong number of bytes
|
||
156c : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
> set_a $ff-$ab,0
|
||
> load_flag 0
|
||
156e : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
1570 : 48 > pha ;use stack to load status
|
||
1571 : a954 > lda #$ff-$ab ;precharge accu
|
||
1573 : 28 > plp
|
||
>
|
||
1574 : ab > db $ab ;test nop integrity - flags off
|
||
1575 : ea > nop
|
||
1576 : ea > nop
|
||
> tst_a $ff-$ab,0
|
||
1577 : 08 > php ;save flags
|
||
1578 : c954 > cmp #$ff-$ab ;test result
|
||
> trap_ne
|
||
157a : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
157c : 68 > pla ;load status
|
||
157d : 48 > pha
|
||
> cmp_flag 0
|
||
157e : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1580 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1582 : 28 > plp ;restore status
|
||
>
|
||
> set_a $aa-$ab,$ff
|
||
> load_flag $ff
|
||
1583 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
1585 : 48 > pha ;use stack to load status
|
||
1586 : a9ff > lda #$aa-$ab ;precharge accu
|
||
1588 : 28 > plp
|
||
>
|
||
1589 : ab > db $ab ;test nop integrity - flags on
|
||
158a : ea > nop
|
||
158b : ea > nop
|
||
> tst_a $aa-$ab,$ff
|
||
158c : 08 > php ;save flags
|
||
158d : c9ff > cmp #$aa-$ab ;test result
|
||
> trap_ne
|
||
158f : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1591 : 68 > pla ;load status
|
||
1592 : 48 > pha
|
||
> cmp_flag $ff
|
||
1593 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1595 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1597 : 28 > plp ;restore status
|
||
>
|
||
1598 : c042 > cpy #$42
|
||
> trap_ne ;y changed
|
||
159a : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
159c : e000 > cpx #0
|
||
> trap_ne ;x changed
|
||
159e : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
nop_test $bb,1
|
||
15a0 : a042 > ldy #$42
|
||
15a2 : a203 > ldx #4-1
|
||
15a4 : bb > db $bb ;test nop length
|
||
> if 1 = 1
|
||
15a5 : ca > dex
|
||
15a6 : ca > dex
|
||
> endif
|
||
> if 1 = 2
|
||
> iny
|
||
> dex
|
||
> endif
|
||
> if 1 = 3
|
||
> iny
|
||
> iny
|
||
> endif
|
||
15a7 : ca > dex
|
||
> trap_ne ;wrong number of bytes
|
||
15a8 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
> set_a $ff-$bb,0
|
||
> load_flag 0
|
||
15aa : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
15ac : 48 > pha ;use stack to load status
|
||
15ad : a944 > lda #$ff-$bb ;precharge accu
|
||
15af : 28 > plp
|
||
>
|
||
15b0 : bb > db $bb ;test nop integrity - flags off
|
||
15b1 : ea > nop
|
||
15b2 : ea > nop
|
||
> tst_a $ff-$bb,0
|
||
15b3 : 08 > php ;save flags
|
||
15b4 : c944 > cmp #$ff-$bb ;test result
|
||
> trap_ne
|
||
15b6 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
15b8 : 68 > pla ;load status
|
||
15b9 : 48 > pha
|
||
> cmp_flag 0
|
||
15ba : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
15bc : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
15be : 28 > plp ;restore status
|
||
>
|
||
> set_a $aa-$bb,$ff
|
||
> load_flag $ff
|
||
15bf : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
15c1 : 48 > pha ;use stack to load status
|
||
15c2 : a9ef > lda #$aa-$bb ;precharge accu
|
||
15c4 : 28 > plp
|
||
>
|
||
15c5 : bb > db $bb ;test nop integrity - flags on
|
||
15c6 : ea > nop
|
||
15c7 : ea > nop
|
||
> tst_a $aa-$bb,$ff
|
||
15c8 : 08 > php ;save flags
|
||
15c9 : c9ef > cmp #$aa-$bb ;test result
|
||
> trap_ne
|
||
15cb : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
15cd : 68 > pla ;load status
|
||
15ce : 48 > pha
|
||
> cmp_flag $ff
|
||
15cf : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
15d1 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
15d3 : 28 > plp ;restore status
|
||
>
|
||
15d4 : c042 > cpy #$42
|
||
> trap_ne ;y changed
|
||
15d6 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
15d8 : e000 > cpx #0
|
||
> trap_ne ;x changed
|
||
15da : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
nop_test $eb,1
|
||
15dc : a042 > ldy #$42
|
||
15de : a203 > ldx #4-1
|
||
15e0 : eb > db $eb ;test nop length
|
||
> if 1 = 1
|
||
15e1 : ca > dex
|
||
15e2 : ca > dex
|
||
> endif
|
||
> if 1 = 2
|
||
> iny
|
||
> dex
|
||
> endif
|
||
> if 1 = 3
|
||
> iny
|
||
> iny
|
||
> endif
|
||
15e3 : ca > dex
|
||
> trap_ne ;wrong number of bytes
|
||
15e4 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
> set_a $ff-$eb,0
|
||
> load_flag 0
|
||
15e6 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
15e8 : 48 > pha ;use stack to load status
|
||
15e9 : a914 > lda #$ff-$eb ;precharge accu
|
||
15eb : 28 > plp
|
||
>
|
||
15ec : eb > db $eb ;test nop integrity - flags off
|
||
15ed : ea > nop
|
||
15ee : ea > nop
|
||
> tst_a $ff-$eb,0
|
||
15ef : 08 > php ;save flags
|
||
15f0 : c914 > cmp #$ff-$eb ;test result
|
||
> trap_ne
|
||
15f2 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
15f4 : 68 > pla ;load status
|
||
15f5 : 48 > pha
|
||
> cmp_flag 0
|
||
15f6 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
15f8 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
15fa : 28 > plp ;restore status
|
||
>
|
||
> set_a $aa-$eb,$ff
|
||
> load_flag $ff
|
||
15fb : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
15fd : 48 > pha ;use stack to load status
|
||
15fe : a9bf > lda #$aa-$eb ;precharge accu
|
||
1600 : 28 > plp
|
||
>
|
||
1601 : eb > db $eb ;test nop integrity - flags on
|
||
1602 : ea > nop
|
||
1603 : ea > nop
|
||
> tst_a $aa-$eb,$ff
|
||
1604 : 08 > php ;save flags
|
||
1605 : c9bf > cmp #$aa-$eb ;test result
|
||
> trap_ne
|
||
1607 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1609 : 68 > pla ;load status
|
||
160a : 48 > pha
|
||
> cmp_flag $ff
|
||
160b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
160d : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
160f : 28 > plp ;restore status
|
||
>
|
||
1610 : c042 > cpy #$42
|
||
> trap_ne ;y changed
|
||
1612 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1614 : e000 > cpx #0
|
||
> trap_ne ;x changed
|
||
1616 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
nop_test $fb,1
|
||
1618 : a042 > ldy #$42
|
||
161a : a203 > ldx #4-1
|
||
161c : fb > db $fb ;test nop length
|
||
> if 1 = 1
|
||
161d : ca > dex
|
||
161e : ca > dex
|
||
> endif
|
||
> if 1 = 2
|
||
> iny
|
||
> dex
|
||
> endif
|
||
> if 1 = 3
|
||
> iny
|
||
> iny
|
||
> endif
|
||
161f : ca > dex
|
||
> trap_ne ;wrong number of bytes
|
||
1620 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
> set_a $ff-$fb,0
|
||
> load_flag 0
|
||
1622 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
1624 : 48 > pha ;use stack to load status
|
||
1625 : a904 > lda #$ff-$fb ;precharge accu
|
||
1627 : 28 > plp
|
||
>
|
||
1628 : fb > db $fb ;test nop integrity - flags off
|
||
1629 : ea > nop
|
||
162a : ea > nop
|
||
> tst_a $ff-$fb,0
|
||
162b : 08 > php ;save flags
|
||
162c : c904 > cmp #$ff-$fb ;test result
|
||
> trap_ne
|
||
162e : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1630 : 68 > pla ;load status
|
||
1631 : 48 > pha
|
||
> cmp_flag 0
|
||
1632 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1634 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1636 : 28 > plp ;restore status
|
||
>
|
||
> set_a $aa-$fb,$ff
|
||
> load_flag $ff
|
||
1637 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
1639 : 48 > pha ;use stack to load status
|
||
163a : a9af > lda #$aa-$fb ;precharge accu
|
||
163c : 28 > plp
|
||
>
|
||
163d : fb > db $fb ;test nop integrity - flags on
|
||
163e : ea > nop
|
||
163f : ea > nop
|
||
> tst_a $aa-$fb,$ff
|
||
1640 : 08 > php ;save flags
|
||
1641 : c9af > cmp #$aa-$fb ;test result
|
||
> trap_ne
|
||
1643 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1645 : 68 > pla ;load status
|
||
1646 : 48 > pha
|
||
> cmp_flag $ff
|
||
1647 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1649 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
164b : 28 > plp ;restore status
|
||
>
|
||
164c : c042 > cpy #$42
|
||
> trap_ne ;y changed
|
||
164e : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1650 : e000 > cpx #0
|
||
> trap_ne ;x changed
|
||
1652 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
if rkwl_wdc_op = 0 ;NOPs not available on Rockwell & WDC 65C02
|
||
nop_test $07,1
|
||
nop_test $17,1
|
||
nop_test $27,1
|
||
nop_test $37,1
|
||
nop_test $47,1
|
||
nop_test $57,1
|
||
nop_test $67,1
|
||
nop_test $77,1
|
||
nop_test $87,1
|
||
nop_test $97,1
|
||
nop_test $a7,1
|
||
nop_test $b7,1
|
||
nop_test $c7,1
|
||
nop_test $d7,1
|
||
nop_test $e7,1
|
||
nop_test $f7,1
|
||
nop_test $0f,1
|
||
nop_test $1f,1
|
||
nop_test $2f,1
|
||
nop_test $3f,1
|
||
nop_test $4f,1
|
||
nop_test $5f,1
|
||
nop_test $6f,1
|
||
nop_test $7f,1
|
||
nop_test $8f,1
|
||
nop_test $9f,1
|
||
nop_test $af,1
|
||
nop_test $bf,1
|
||
nop_test $cf,1
|
||
nop_test $df,1
|
||
nop_test $ef,1
|
||
nop_test $ff,1
|
||
endif
|
||
if wdc_op = 0 ;NOPs not available on WDC 65C02 (WAI, STP)
|
||
nop_test $cb,1
|
||
nop_test $db,1
|
||
endif
|
||
next_test
|
||
1654 : ad0202 > lda test_case ;previous test
|
||
1657 : c908 > cmp #test_num
|
||
> trap_ne ;test is out of sequence
|
||
1659 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0009 = >test_num = test_num + 1
|
||
165b : a909 > lda #test_num ;*** next tests' number
|
||
165d : 8d0202 > sta test_case
|
||
> ;check_ram ;uncomment to find altered RAM after each test
|
||
|
||
|
||
; jump indirect (test page cross bug is fixed)
|
||
1660 : a203 ldx #3 ;prepare table
|
||
1662 : bd4026 ji1 lda ji_adr,x
|
||
1665 : 9dfd02 sta ji_tab,x
|
||
1668 : ca dex
|
||
1669 : 10f7 bpl ji1
|
||
166b : a927 lda #hi(ji_px) ;high address if page cross bug
|
||
166d : 8d0002 sta pg_x
|
||
set_stat 0
|
||
> load_flag 0
|
||
1670 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
1672 : 48 > pha ;use stack to load status
|
||
1673 : 28 > plp
|
||
|
||
1674 : a949 lda #'I'
|
||
1676 : a24e ldx #'N'
|
||
1678 : a044 ldy #'D' ;N=0, V=0, Z=0, C=0
|
||
167a : 6cfd02 jmp (ji_tab)
|
||
167d : ea nop
|
||
trap_ne ;runover protection
|
||
167e : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
|
||
1680 : 88 dey
|
||
1681 : 88 dey
|
||
1682 : 08 ji_ret php ;either SP or Y count will fail, if we do not hit
|
||
1683 : 88 dey
|
||
1684 : 88 dey
|
||
1685 : 88 dey
|
||
1686 : 28 plp
|
||
trap_eq ;returned flags OK?
|
||
1687 : f0fe > beq * ;failed equal (zero)
|
||
|
||
trap_pl
|
||
1689 : 10fe > bpl * ;failed plus (bit 7 clear)
|
||
|
||
trap_cc
|
||
168b : 90fe > bcc * ;failed carry clear
|
||
|
||
trap_vc
|
||
168d : 50fe > bvc * ;failed overflow clear
|
||
|
||
168f : c9e3 cmp #('I'^$aa) ;returned registers OK?
|
||
trap_ne
|
||
1691 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
1693 : e04f cpx #('N'+1)
|
||
trap_ne
|
||
1695 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
1697 : c03e cpy #('D'-6)
|
||
trap_ne
|
||
1699 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
169b : ba tsx ;SP check
|
||
169c : e0ff cpx #$ff
|
||
trap_ne
|
||
169e : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
next_test
|
||
16a0 : ad0202 > lda test_case ;previous test
|
||
16a3 : c909 > cmp #test_num
|
||
> trap_ne ;test is out of sequence
|
||
16a5 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
000a = >test_num = test_num + 1
|
||
16a7 : a90a > lda #test_num ;*** next tests' number
|
||
16a9 : 8d0202 > sta test_case
|
||
> ;check_ram ;uncomment to find altered RAM after each test
|
||
|
||
|
||
; jump indexed indirect
|
||
16ac : a20b ldx #11 ;prepare table
|
||
16ae : bd7926 jxi1 lda jxi_adr,x
|
||
16b1 : 9df902 sta jxi_tab,x
|
||
16b4 : ca dex
|
||
16b5 : 10f7 bpl jxi1
|
||
16b7 : a927 lda #hi(jxi_px) ;high address if page cross bug
|
||
16b9 : 8d0002 sta pg_x
|
||
set_stat 0
|
||
> load_flag 0
|
||
16bc : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
16be : 48 > pha ;use stack to load status
|
||
16bf : 28 > plp
|
||
|
||
16c0 : a958 lda #'X'
|
||
16c2 : a204 ldx #4
|
||
16c4 : a049 ldy #'I' ;N=0, V=0, Z=0, C=0
|
||
16c6 : 7cf902 jmp (jxi_tab,x)
|
||
16c9 : ea nop
|
||
trap_ne ;runover protection
|
||
16ca : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
|
||
16cc : 88 dey
|
||
16cd : 88 dey
|
||
16ce : 08 jxi_ret php ;either SP or Y count will fail, if we do not hit
|
||
16cf : 88 dey
|
||
16d0 : 88 dey
|
||
16d1 : 88 dey
|
||
16d2 : 28 plp
|
||
trap_eq ;returned flags OK?
|
||
16d3 : f0fe > beq * ;failed equal (zero)
|
||
|
||
trap_pl
|
||
16d5 : 10fe > bpl * ;failed plus (bit 7 clear)
|
||
|
||
trap_cc
|
||
16d7 : 90fe > bcc * ;failed carry clear
|
||
|
||
trap_vc
|
||
16d9 : 50fe > bvc * ;failed overflow clear
|
||
|
||
16db : c9f2 cmp #('X'^$aa) ;returned registers OK?
|
||
trap_ne
|
||
16dd : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
16df : e006 cpx #6
|
||
trap_ne
|
||
16e1 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
16e3 : c043 cpy #('I'-6)
|
||
trap_ne
|
||
16e5 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
16e7 : ba tsx ;SP check
|
||
16e8 : e0ff cpx #$ff
|
||
trap_ne
|
||
16ea : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
|
||
16ec : a908 lda #lo(jxp_ok) ;test with index causing a page cross
|
||
16ee : 8d0003 sta jxp_tab
|
||
16f1 : a917 lda #hi(jxp_ok)
|
||
16f3 : 8d0103 sta jxp_tab+1
|
||
16f6 : a905 lda #lo(jxp_px)
|
||
16f8 : 8d0002 sta pg_x
|
||
16fb : a917 lda #hi(jxp_px)
|
||
16fd : 8d0102 sta pg_x+1
|
||
1700 : a2ff ldx #$ff
|
||
1702 : 7c0102 jmp (jxp_tab-$ff,x)
|
||
|
||
1705 : jxp_px
|
||
trap ;page cross by index to wrong page
|
||
1705 : 4c0517 > jmp * ;failed anyway
|
||
|
||
|
||
1708 : jxp_ok
|
||
next_test
|
||
1708 : ad0202 > lda test_case ;previous test
|
||
170b : c90a > cmp #test_num
|
||
> trap_ne ;test is out of sequence
|
||
170d : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
000b = >test_num = test_num + 1
|
||
170f : a90b > lda #test_num ;*** next tests' number
|
||
1711 : 8d0202 > sta test_case
|
||
> ;check_ram ;uncomment to find altered RAM after each test
|
||
|
||
|
||
if ROM_vectors = 1
|
||
; test BRK clears decimal mode
|
||
1714 : f8 sed
|
||
1715 : 00 brk
|
||
1716 : ea nop
|
||
1717 : brk_ret
|
||
next_test
|
||
1717 : ad0202 > lda test_case ;previous test
|
||
171a : c90b > cmp #test_num
|
||
> trap_ne ;test is out of sequence
|
||
171c : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
000c = >test_num = test_num + 1
|
||
171e : a90c > lda #test_num ;*** next tests' number
|
||
1720 : 8d0202 > sta test_case
|
||
> ;check_ram ;uncomment to find altered RAM after each test
|
||
|
||
endif
|
||
|
||
; testing accumulator increment/decrement INC A & DEC A
|
||
1723 : a2ac ldx #$ac ;protect x & y
|
||
1725 : a0dc ldy #$dc
|
||
set_a $fe,$ff
|
||
> load_flag $ff
|
||
1727 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
1729 : 48 > pha ;use stack to load status
|
||
172a : a9fe > lda #$fe ;precharge accu
|
||
172c : 28 > plp
|
||
|
||
172d : 1a inc a ;ff
|
||
tst_as $ff,$ff-zero
|
||
172e : 48 > pha
|
||
172f : 08 > php ;save flags
|
||
1730 : c9ff > cmp #$ff ;test result
|
||
> trap_ne
|
||
1732 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1734 : 68 > pla ;load status
|
||
1735 : 48 > pha
|
||
> cmp_flag $ff-zero
|
||
1736 : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1738 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
173a : 28 > plp ;restore status
|
||
173b : 68 > pla
|
||
|
||
173c : 1a inc a ;00
|
||
tst_as 0,$ff-minus
|
||
173d : 48 > pha
|
||
173e : 08 > php ;save flags
|
||
173f : c900 > cmp #0 ;test result
|
||
> trap_ne
|
||
1741 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1743 : 68 > pla ;load status
|
||
1744 : 48 > pha
|
||
> cmp_flag $ff-minus
|
||
1745 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1747 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1749 : 28 > plp ;restore status
|
||
174a : 68 > pla
|
||
|
||
174b : 1a inc a ;01
|
||
tst_as 1,$ff-minus-zero
|
||
174c : 48 > pha
|
||
174d : 08 > php ;save flags
|
||
174e : c901 > cmp #1 ;test result
|
||
> trap_ne
|
||
1750 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1752 : 68 > pla ;load status
|
||
1753 : 48 > pha
|
||
> cmp_flag $ff-minus-zero
|
||
1754 : c97d > cmp #($ff-minus-zero|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1756 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1758 : 28 > plp ;restore status
|
||
1759 : 68 > pla
|
||
|
||
175a : 3a dec a ;00
|
||
tst_as 0,$ff-minus
|
||
175b : 48 > pha
|
||
175c : 08 > php ;save flags
|
||
175d : c900 > cmp #0 ;test result
|
||
> trap_ne
|
||
175f : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1761 : 68 > pla ;load status
|
||
1762 : 48 > pha
|
||
> cmp_flag $ff-minus
|
||
1763 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1765 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1767 : 28 > plp ;restore status
|
||
1768 : 68 > pla
|
||
|
||
1769 : 3a dec a ;ff
|
||
tst_as $ff,$ff-zero
|
||
176a : 48 > pha
|
||
176b : 08 > php ;save flags
|
||
176c : c9ff > cmp #$ff ;test result
|
||
> trap_ne
|
||
176e : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1770 : 68 > pla ;load status
|
||
1771 : 48 > pha
|
||
> cmp_flag $ff-zero
|
||
1772 : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1774 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1776 : 28 > plp ;restore status
|
||
1777 : 68 > pla
|
||
|
||
1778 : 3a dec a ;fe
|
||
set_a $fe,0
|
||
> load_flag 0
|
||
1779 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
177b : 48 > pha ;use stack to load status
|
||
177c : a9fe > lda #$fe ;precharge accu
|
||
177e : 28 > plp
|
||
|
||
177f : 1a inc a ;ff
|
||
tst_as $ff,minus
|
||
1780 : 48 > pha
|
||
1781 : 08 > php ;save flags
|
||
1782 : c9ff > cmp #$ff ;test result
|
||
> trap_ne
|
||
1784 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1786 : 68 > pla ;load status
|
||
1787 : 48 > pha
|
||
> cmp_flag minus
|
||
1788 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
178a : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
178c : 28 > plp ;restore status
|
||
178d : 68 > pla
|
||
|
||
178e : 1a inc a ;00
|
||
tst_as 0,zero
|
||
178f : 48 > pha
|
||
1790 : 08 > php ;save flags
|
||
1791 : c900 > cmp #0 ;test result
|
||
> trap_ne
|
||
1793 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1795 : 68 > pla ;load status
|
||
1796 : 48 > pha
|
||
> cmp_flag zero
|
||
1797 : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1799 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
179b : 28 > plp ;restore status
|
||
179c : 68 > pla
|
||
|
||
179d : 1a inc a ;01
|
||
tst_as 1,0
|
||
179e : 48 > pha
|
||
179f : 08 > php ;save flags
|
||
17a0 : c901 > cmp #1 ;test result
|
||
> trap_ne
|
||
17a2 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
17a4 : 68 > pla ;load status
|
||
17a5 : 48 > pha
|
||
> cmp_flag 0
|
||
17a6 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
17a8 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
17aa : 28 > plp ;restore status
|
||
17ab : 68 > pla
|
||
|
||
17ac : 3a dec a ;00
|
||
tst_as 0,zero
|
||
17ad : 48 > pha
|
||
17ae : 08 > php ;save flags
|
||
17af : c900 > cmp #0 ;test result
|
||
> trap_ne
|
||
17b1 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
17b3 : 68 > pla ;load status
|
||
17b4 : 48 > pha
|
||
> cmp_flag zero
|
||
17b5 : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
17b7 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
17b9 : 28 > plp ;restore status
|
||
17ba : 68 > pla
|
||
|
||
17bb : 3a dec a ;ff
|
||
tst_as $ff,minus
|
||
17bc : 48 > pha
|
||
17bd : 08 > php ;save flags
|
||
17be : c9ff > cmp #$ff ;test result
|
||
> trap_ne
|
||
17c0 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
17c2 : 68 > pla ;load status
|
||
17c3 : 48 > pha
|
||
> cmp_flag minus
|
||
17c4 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
17c6 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
17c8 : 28 > plp ;restore status
|
||
17c9 : 68 > pla
|
||
|
||
17ca : e0ac cpx #$ac
|
||
trap_ne ;x altered during test
|
||
17cc : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
17ce : c0dc cpy #$dc
|
||
trap_ne ;y altered during test
|
||
17d0 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
17d2 : ba tsx
|
||
17d3 : e0ff cpx #$ff
|
||
trap_ne ;sp push/pop mismatch
|
||
17d5 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
next_test
|
||
17d7 : ad0202 > lda test_case ;previous test
|
||
17da : c90c > cmp #test_num
|
||
> trap_ne ;test is out of sequence
|
||
17dc : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
000d = >test_num = test_num + 1
|
||
17de : a90d > lda #test_num ;*** next tests' number
|
||
17e0 : 8d0202 > sta test_case
|
||
> ;check_ram ;uncomment to find altered RAM after each test
|
||
|
||
|
||
; testing load / store accumulator LDA / STA (zp)
|
||
17e3 : a299 ldx #$99 ;protect x & y
|
||
17e5 : a066 ldy #$66
|
||
set_stat 0
|
||
> load_flag 0
|
||
17e7 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
17e9 : 48 > pha ;use stack to load status
|
||
17ea : 28 > plp
|
||
|
||
17eb : b222 lda (ind1)
|
||
17ed : 08 php ;test stores do not alter flags
|
||
17ee : 49c3 eor #$c3
|
||
17f0 : 28 plp
|
||
17f1 : 922e sta (indt)
|
||
17f3 : 08 php ;flags after load/store sequence
|
||
17f4 : 49c3 eor #$c3
|
||
17f6 : c9c3 cmp #$c3 ;test result
|
||
trap_ne
|
||
17f8 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
17fa : 68 pla ;load status
|
||
eor_flag 0
|
||
17fb : 4930 > eor #0|fao ;invert expected flags + always on bits
|
||
|
||
17fd : cd0f02 cmp fLDx ;test flags
|
||
trap_ne
|
||
1800 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
set_stat 0
|
||
> load_flag 0
|
||
1802 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
1804 : 48 > pha ;use stack to load status
|
||
1805 : 28 > plp
|
||
|
||
1806 : b224 lda (ind1+2)
|
||
1808 : 08 php ;test stores do not alter flags
|
||
1809 : 49c3 eor #$c3
|
||
180b : 28 plp
|
||
180c : 9230 sta (indt+2)
|
||
180e : 08 php ;flags after load/store sequence
|
||
180f : 49c3 eor #$c3
|
||
1811 : c982 cmp #$82 ;test result
|
||
trap_ne
|
||
1813 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
1815 : 68 pla ;load status
|
||
eor_flag 0
|
||
1816 : 4930 > eor #0|fao ;invert expected flags + always on bits
|
||
|
||
1818 : cd1002 cmp fLDx+1 ;test flags
|
||
trap_ne
|
||
181b : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
set_stat 0
|
||
> load_flag 0
|
||
181d : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
181f : 48 > pha ;use stack to load status
|
||
1820 : 28 > plp
|
||
|
||
1821 : b226 lda (ind1+4)
|
||
1823 : 08 php ;test stores do not alter flags
|
||
1824 : 49c3 eor #$c3
|
||
1826 : 28 plp
|
||
1827 : 9232 sta (indt+4)
|
||
1829 : 08 php ;flags after load/store sequence
|
||
182a : 49c3 eor #$c3
|
||
182c : c941 cmp #$41 ;test result
|
||
trap_ne
|
||
182e : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
1830 : 68 pla ;load status
|
||
eor_flag 0
|
||
1831 : 4930 > eor #0|fao ;invert expected flags + always on bits
|
||
|
||
1833 : cd1102 cmp fLDx+2 ;test flags
|
||
trap_ne
|
||
1836 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
set_stat 0
|
||
> load_flag 0
|
||
1838 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
183a : 48 > pha ;use stack to load status
|
||
183b : 28 > plp
|
||
|
||
183c : b228 lda (ind1+6)
|
||
183e : 08 php ;test stores do not alter flags
|
||
183f : 49c3 eor #$c3
|
||
1841 : 28 plp
|
||
1842 : 9234 sta (indt+6)
|
||
1844 : 08 php ;flags after load/store sequence
|
||
1845 : 49c3 eor #$c3
|
||
1847 : c900 cmp #0 ;test result
|
||
trap_ne
|
||
1849 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
184b : 68 pla ;load status
|
||
eor_flag 0
|
||
184c : 4930 > eor #0|fao ;invert expected flags + always on bits
|
||
|
||
184e : cd1202 cmp fLDx+3 ;test flags
|
||
trap_ne
|
||
1851 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
1853 : e099 cpx #$99
|
||
trap_ne ;x altered during test
|
||
1855 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
1857 : c066 cpy #$66
|
||
trap_ne ;y altered during test
|
||
1859 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
|
||
185b : a003 ldy #3 ;testing store result
|
||
185d : a200 ldx #0
|
||
185f : b90502 tstai1 lda abst,y
|
||
1862 : 49c3 eor #$c3
|
||
1864 : d90a02 cmp abs1,y
|
||
trap_ne ;store to indirect data
|
||
1867 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
1869 : 8a txa
|
||
186a : 990502 sta abst,y ;clear
|
||
186d : 88 dey
|
||
186e : 10ef bpl tstai1
|
||
|
||
1870 : a299 ldx #$99 ;protect x & y
|
||
1872 : a066 ldy #$66
|
||
set_stat $ff
|
||
> load_flag $ff
|
||
1874 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
1876 : 48 > pha ;use stack to load status
|
||
1877 : 28 > plp
|
||
|
||
1878 : b222 lda (ind1)
|
||
187a : 08 php ;test stores do not alter flags
|
||
187b : 49c3 eor #$c3
|
||
187d : 28 plp
|
||
187e : 922e sta (indt)
|
||
1880 : 08 php ;flags after load/store sequence
|
||
1881 : 49c3 eor #$c3
|
||
1883 : c9c3 cmp #$c3 ;test result
|
||
trap_ne
|
||
1885 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
1887 : 68 pla ;load status
|
||
eor_flag lo~fnz ;mask bits not altered
|
||
1888 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
|
||
|
||
188a : cd0f02 cmp fLDx ;test flags
|
||
trap_ne
|
||
188d : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
set_stat $ff
|
||
> load_flag $ff
|
||
188f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
1891 : 48 > pha ;use stack to load status
|
||
1892 : 28 > plp
|
||
|
||
1893 : b224 lda (ind1+2)
|
||
1895 : 08 php ;test stores do not alter flags
|
||
1896 : 49c3 eor #$c3
|
||
1898 : 28 plp
|
||
1899 : 9230 sta (indt+2)
|
||
189b : 08 php ;flags after load/store sequence
|
||
189c : 49c3 eor #$c3
|
||
189e : c982 cmp #$82 ;test result
|
||
trap_ne
|
||
18a0 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
18a2 : 68 pla ;load status
|
||
eor_flag lo~fnz ;mask bits not altered
|
||
18a3 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
|
||
|
||
18a5 : cd1002 cmp fLDx+1 ;test flags
|
||
trap_ne
|
||
18a8 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
set_stat $ff
|
||
> load_flag $ff
|
||
18aa : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
18ac : 48 > pha ;use stack to load status
|
||
18ad : 28 > plp
|
||
|
||
18ae : b226 lda (ind1+4)
|
||
18b0 : 08 php ;test stores do not alter flags
|
||
18b1 : 49c3 eor #$c3
|
||
18b3 : 28 plp
|
||
18b4 : 9232 sta (indt+4)
|
||
18b6 : 08 php ;flags after load/store sequence
|
||
18b7 : 49c3 eor #$c3
|
||
18b9 : c941 cmp #$41 ;test result
|
||
trap_ne
|
||
18bb : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
18bd : 68 pla ;load status
|
||
eor_flag lo~fnz ;mask bits not altered
|
||
18be : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
|
||
|
||
18c0 : cd1102 cmp fLDx+2 ;test flags
|
||
trap_ne
|
||
18c3 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
set_stat $ff
|
||
> load_flag $ff
|
||
18c5 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
18c7 : 48 > pha ;use stack to load status
|
||
18c8 : 28 > plp
|
||
|
||
18c9 : b228 lda (ind1+6)
|
||
18cb : 08 php ;test stores do not alter flags
|
||
18cc : 49c3 eor #$c3
|
||
18ce : 28 plp
|
||
18cf : 9234 sta (indt+6)
|
||
18d1 : 08 php ;flags after load/store sequence
|
||
18d2 : 49c3 eor #$c3
|
||
18d4 : c900 cmp #0 ;test result
|
||
trap_ne
|
||
18d6 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
18d8 : 68 pla ;load status
|
||
eor_flag lo~fnz ;mask bits not altered
|
||
18d9 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
|
||
|
||
18db : cd1202 cmp fLDx+3 ;test flags
|
||
trap_ne
|
||
18de : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
18e0 : e099 cpx #$99
|
||
trap_ne ;x altered during test
|
||
18e2 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
18e4 : c066 cpy #$66
|
||
trap_ne ;y altered during test
|
||
18e6 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
|
||
18e8 : a003 ldy #3 ;testing store result
|
||
18ea : a200 ldx #0
|
||
18ec : b90502 tstai2 lda abst,y
|
||
18ef : 49c3 eor #$c3
|
||
18f1 : d90a02 cmp abs1,y
|
||
trap_ne ;store to indirect data
|
||
18f4 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
18f6 : 8a txa
|
||
18f7 : 990502 sta abst,y ;clear
|
||
18fa : 88 dey
|
||
18fb : 10ef bpl tstai2
|
||
18fd : ba tsx
|
||
18fe : e0ff cpx #$ff
|
||
trap_ne ;sp push/pop mismatch
|
||
1900 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
next_test
|
||
1902 : ad0202 > lda test_case ;previous test
|
||
1905 : c90d > cmp #test_num
|
||
> trap_ne ;test is out of sequence
|
||
1907 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
000e = >test_num = test_num + 1
|
||
1909 : a90e > lda #test_num ;*** next tests' number
|
||
190b : 8d0202 > sta test_case
|
||
> ;check_ram ;uncomment to find altered RAM after each test
|
||
|
||
|
||
; testing STZ - zp / abs / zp,x / abs,x
|
||
190e : a07b ldy #123 ;protect y
|
||
1910 : a204 ldx #4 ;precharge test area
|
||
1912 : a907 lda #7
|
||
1914 : 950a tstz1 sta zpt,x
|
||
1916 : 0a asl a
|
||
1917 : ca dex
|
||
1918 : 10fa bpl tstz1
|
||
191a : a204 ldx #4
|
||
set_a $55,$ff
|
||
> load_flag $ff
|
||
191c : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
191e : 48 > pha ;use stack to load status
|
||
191f : a955 > lda #$55 ;precharge accu
|
||
1921 : 28 > plp
|
||
|
||
1922 : 640a stz zpt
|
||
1924 : 640b stz zpt+1
|
||
1926 : 640c stz zpt+2
|
||
1928 : 640d stz zpt+3
|
||
192a : 640e stz zpt+4
|
||
tst_a $55,$ff
|
||
192c : 08 > php ;save flags
|
||
192d : c955 > cmp #$55 ;test result
|
||
> trap_ne
|
||
192f : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1931 : 68 > pla ;load status
|
||
1932 : 48 > pha
|
||
> cmp_flag $ff
|
||
1933 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1935 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1937 : 28 > plp ;restore status
|
||
|
||
1938 : b50a tstz2 lda zpt,x ;verify zeros stored
|
||
trap_ne ;non zero after STZ zp
|
||
193a : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
193c : ca dex
|
||
193d : 10f9 bpl tstz2
|
||
193f : a204 ldx #4 ;precharge test area
|
||
1941 : a907 lda #7
|
||
1943 : 950a tstz3 sta zpt,x
|
||
1945 : 0a asl a
|
||
1946 : ca dex
|
||
1947 : 10fa bpl tstz3
|
||
1949 : a204 ldx #4
|
||
set_a $aa,0
|
||
> load_flag 0
|
||
194b : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
194d : 48 > pha ;use stack to load status
|
||
194e : a9aa > lda #$aa ;precharge accu
|
||
1950 : 28 > plp
|
||
|
||
1951 : 640a stz zpt
|
||
1953 : 640b stz zpt+1
|
||
1955 : 640c stz zpt+2
|
||
1957 : 640d stz zpt+3
|
||
1959 : 640e stz zpt+4
|
||
tst_a $aa,0
|
||
195b : 08 > php ;save flags
|
||
195c : c9aa > cmp #$aa ;test result
|
||
> trap_ne
|
||
195e : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1960 : 68 > pla ;load status
|
||
1961 : 48 > pha
|
||
> cmp_flag 0
|
||
1962 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1964 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1966 : 28 > plp ;restore status
|
||
|
||
1967 : b50a tstz4 lda zpt,x ;verify zeros stored
|
||
trap_ne ;non zero after STZ zp
|
||
1969 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
196b : ca dex
|
||
196c : 10f9 bpl tstz4
|
||
|
||
196e : a204 ldx #4 ;precharge test area
|
||
1970 : a907 lda #7
|
||
1972 : 9d0502 tstz5 sta abst,x
|
||
1975 : 0a asl a
|
||
1976 : ca dex
|
||
1977 : 10f9 bpl tstz5
|
||
1979 : a204 ldx #4
|
||
set_a $55,$ff
|
||
> load_flag $ff
|
||
197b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
197d : 48 > pha ;use stack to load status
|
||
197e : a955 > lda #$55 ;precharge accu
|
||
1980 : 28 > plp
|
||
|
||
1981 : 9c0502 stz abst
|
||
1984 : 9c0602 stz abst+1
|
||
1987 : 9c0702 stz abst+2
|
||
198a : 9c0802 stz abst+3
|
||
198d : 9c0902 stz abst+4
|
||
tst_a $55,$ff
|
||
1990 : 08 > php ;save flags
|
||
1991 : c955 > cmp #$55 ;test result
|
||
> trap_ne
|
||
1993 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1995 : 68 > pla ;load status
|
||
1996 : 48 > pha
|
||
> cmp_flag $ff
|
||
1997 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1999 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
199b : 28 > plp ;restore status
|
||
|
||
199c : bd0502 tstz6 lda abst,x ;verify zeros stored
|
||
trap_ne ;non zero after STZ abs
|
||
199f : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
19a1 : ca dex
|
||
19a2 : 10f8 bpl tstz6
|
||
19a4 : a204 ldx #4 ;precharge test area
|
||
19a6 : a907 lda #7
|
||
19a8 : 9d0502 tstz7 sta abst,x
|
||
19ab : 0a asl a
|
||
19ac : ca dex
|
||
19ad : 10f9 bpl tstz7
|
||
19af : a204 ldx #4
|
||
set_a $aa,0
|
||
> load_flag 0
|
||
19b1 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
19b3 : 48 > pha ;use stack to load status
|
||
19b4 : a9aa > lda #$aa ;precharge accu
|
||
19b6 : 28 > plp
|
||
|
||
19b7 : 9c0502 stz abst
|
||
19ba : 9c0602 stz abst+1
|
||
19bd : 9c0702 stz abst+2
|
||
19c0 : 9c0802 stz abst+3
|
||
19c3 : 9c0902 stz abst+4
|
||
tst_a $aa,0
|
||
19c6 : 08 > php ;save flags
|
||
19c7 : c9aa > cmp #$aa ;test result
|
||
> trap_ne
|
||
19c9 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
19cb : 68 > pla ;load status
|
||
19cc : 48 > pha
|
||
> cmp_flag 0
|
||
19cd : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
19cf : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
19d1 : 28 > plp ;restore status
|
||
|
||
19d2 : bd0502 tstz8 lda abst,x ;verify zeros stored
|
||
trap_ne ;non zero after STZ abs
|
||
19d5 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
19d7 : ca dex
|
||
19d8 : 10f8 bpl tstz8
|
||
|
||
19da : a204 ldx #4 ;precharge test area
|
||
19dc : a907 lda #7
|
||
19de : 950a tstz11 sta zpt,x
|
||
19e0 : 0a asl a
|
||
19e1 : ca dex
|
||
19e2 : 10fa bpl tstz11
|
||
19e4 : a204 ldx #4
|
||
19e6 : tstz15
|
||
set_a $55,$ff
|
||
> load_flag $ff
|
||
19e6 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
19e8 : 48 > pha ;use stack to load status
|
||
19e9 : a955 > lda #$55 ;precharge accu
|
||
19eb : 28 > plp
|
||
|
||
19ec : 740a stz zpt,x
|
||
tst_a $55,$ff
|
||
19ee : 08 > php ;save flags
|
||
19ef : c955 > cmp #$55 ;test result
|
||
> trap_ne
|
||
19f1 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
19f3 : 68 > pla ;load status
|
||
19f4 : 48 > pha
|
||
> cmp_flag $ff
|
||
19f5 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
19f7 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
19f9 : 28 > plp ;restore status
|
||
|
||
19fa : ca dex
|
||
19fb : 10e9 bpl tstz15
|
||
19fd : a204 ldx #4
|
||
19ff : b50a tstz12 lda zpt,x ;verify zeros stored
|
||
trap_ne ;non zero after STZ zp
|
||
1a01 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
1a03 : ca dex
|
||
1a04 : 10f9 bpl tstz12
|
||
1a06 : a204 ldx #4 ;precharge test area
|
||
1a08 : a907 lda #7
|
||
1a0a : 950a tstz13 sta zpt,x
|
||
1a0c : 0a asl a
|
||
1a0d : ca dex
|
||
1a0e : 10fa bpl tstz13
|
||
1a10 : a204 ldx #4
|
||
1a12 : tstz16
|
||
set_a $aa,0
|
||
> load_flag 0
|
||
1a12 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
1a14 : 48 > pha ;use stack to load status
|
||
1a15 : a9aa > lda #$aa ;precharge accu
|
||
1a17 : 28 > plp
|
||
|
||
1a18 : 740a stz zpt,x
|
||
tst_a $aa,0
|
||
1a1a : 08 > php ;save flags
|
||
1a1b : c9aa > cmp #$aa ;test result
|
||
> trap_ne
|
||
1a1d : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1a1f : 68 > pla ;load status
|
||
1a20 : 48 > pha
|
||
> cmp_flag 0
|
||
1a21 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1a23 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1a25 : 28 > plp ;restore status
|
||
|
||
1a26 : ca dex
|
||
1a27 : 10e9 bpl tstz16
|
||
1a29 : a204 ldx #4
|
||
1a2b : b50a tstz14 lda zpt,x ;verify zeros stored
|
||
trap_ne ;non zero after STZ zp
|
||
1a2d : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
1a2f : ca dex
|
||
1a30 : 10f9 bpl tstz14
|
||
|
||
1a32 : a204 ldx #4 ;precharge test area
|
||
1a34 : a907 lda #7
|
||
1a36 : 9d0502 tstz21 sta abst,x
|
||
1a39 : 0a asl a
|
||
1a3a : ca dex
|
||
1a3b : 10f9 bpl tstz21
|
||
1a3d : a204 ldx #4
|
||
1a3f : tstz25
|
||
set_a $55,$ff
|
||
> load_flag $ff
|
||
1a3f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
1a41 : 48 > pha ;use stack to load status
|
||
1a42 : a955 > lda #$55 ;precharge accu
|
||
1a44 : 28 > plp
|
||
|
||
1a45 : 9e0502 stz abst,x
|
||
tst_a $55,$ff
|
||
1a48 : 08 > php ;save flags
|
||
1a49 : c955 > cmp #$55 ;test result
|
||
> trap_ne
|
||
1a4b : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1a4d : 68 > pla ;load status
|
||
1a4e : 48 > pha
|
||
> cmp_flag $ff
|
||
1a4f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1a51 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1a53 : 28 > plp ;restore status
|
||
|
||
1a54 : ca dex
|
||
1a55 : 10e8 bpl tstz25
|
||
1a57 : a204 ldx #4
|
||
1a59 : bd0502 tstz22 lda abst,x ;verify zeros stored
|
||
trap_ne ;non zero after STZ zp
|
||
1a5c : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
1a5e : ca dex
|
||
1a5f : 10f8 bpl tstz22
|
||
1a61 : a204 ldx #4 ;precharge test area
|
||
1a63 : a907 lda #7
|
||
1a65 : 9d0502 tstz23 sta abst,x
|
||
1a68 : 0a asl a
|
||
1a69 : ca dex
|
||
1a6a : 10f9 bpl tstz23
|
||
1a6c : a204 ldx #4
|
||
1a6e : tstz26
|
||
set_a $aa,0
|
||
> load_flag 0
|
||
1a6e : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
1a70 : 48 > pha ;use stack to load status
|
||
1a71 : a9aa > lda #$aa ;precharge accu
|
||
1a73 : 28 > plp
|
||
|
||
1a74 : 9e0502 stz abst,x
|
||
tst_a $aa,0
|
||
1a77 : 08 > php ;save flags
|
||
1a78 : c9aa > cmp #$aa ;test result
|
||
> trap_ne
|
||
1a7a : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1a7c : 68 > pla ;load status
|
||
1a7d : 48 > pha
|
||
> cmp_flag 0
|
||
1a7e : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1a80 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1a82 : 28 > plp ;restore status
|
||
|
||
1a83 : ca dex
|
||
1a84 : 10e8 bpl tstz26
|
||
1a86 : a204 ldx #4
|
||
1a88 : bd0502 tstz24 lda abst,x ;verify zeros stored
|
||
trap_ne ;non zero after STZ zp
|
||
1a8b : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
1a8d : ca dex
|
||
1a8e : 10f8 bpl tstz24
|
||
|
||
1a90 : c07b cpy #123
|
||
trap_ne ;y altered during test
|
||
1a92 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
1a94 : ba tsx
|
||
1a95 : e0ff cpx #$ff
|
||
trap_ne ;sp push/pop mismatch
|
||
1a97 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
next_test
|
||
1a99 : ad0202 > lda test_case ;previous test
|
||
1a9c : c90e > cmp #test_num
|
||
> trap_ne ;test is out of sequence
|
||
1a9e : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
000f = >test_num = test_num + 1
|
||
1aa0 : a90f > lda #test_num ;*** next tests' number
|
||
1aa2 : 8d0202 > sta test_case
|
||
> ;check_ram ;uncomment to find altered RAM after each test
|
||
|
||
|
||
; testing BIT - zp,x / abs,x / #
|
||
1aa5 : a042 ldy #$42
|
||
1aa7 : a203 ldx #3
|
||
set_a $ff,0
|
||
> load_flag 0
|
||
1aa9 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
1aab : 48 > pha ;use stack to load status
|
||
1aac : a9ff > lda #$ff ;precharge accu
|
||
1aae : 28 > plp
|
||
|
||
1aaf : 3411 bit zp1,x ;00 - should set Z / clear NV
|
||
tst_a $ff,fz
|
||
1ab1 : 08 > php ;save flags
|
||
1ab2 : c9ff > cmp #$ff ;test result
|
||
> trap_ne
|
||
1ab4 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1ab6 : 68 > pla ;load status
|
||
1ab7 : 48 > pha
|
||
> cmp_flag fz
|
||
1ab8 : c932 > cmp #(fz |fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1aba : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1abc : 28 > plp ;restore status
|
||
|
||
1abd : ca dex
|
||
set_a 1,0
|
||
> load_flag 0
|
||
1abe : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
1ac0 : 48 > pha ;use stack to load status
|
||
1ac1 : a901 > lda #1 ;precharge accu
|
||
1ac3 : 28 > plp
|
||
|
||
1ac4 : 3411 bit zp1,x ;41 - should set V (M6) / clear NZ
|
||
tst_a 1,fv
|
||
1ac6 : 08 > php ;save flags
|
||
1ac7 : c901 > cmp #1 ;test result
|
||
> trap_ne
|
||
1ac9 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1acb : 68 > pla ;load status
|
||
1acc : 48 > pha
|
||
> cmp_flag fv
|
||
1acd : c970 > cmp #(fv|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1acf : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1ad1 : 28 > plp ;restore status
|
||
|
||
1ad2 : ca dex
|
||
set_a 1,0
|
||
> load_flag 0
|
||
1ad3 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
1ad5 : 48 > pha ;use stack to load status
|
||
1ad6 : a901 > lda #1 ;precharge accu
|
||
1ad8 : 28 > plp
|
||
|
||
1ad9 : 3411 bit zp1,x ;82 - should set N (M7) & Z / clear V
|
||
tst_a 1,fnz
|
||
1adb : 08 > php ;save flags
|
||
1adc : c901 > cmp #1 ;test result
|
||
> trap_ne
|
||
1ade : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1ae0 : 68 > pla ;load status
|
||
1ae1 : 48 > pha
|
||
> cmp_flag fnz
|
||
1ae2 : c9b2 > cmp #(fnz|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1ae4 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1ae6 : 28 > plp ;restore status
|
||
|
||
1ae7 : ca dex
|
||
set_a 1,0
|
||
> load_flag 0
|
||
1ae8 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
1aea : 48 > pha ;use stack to load status
|
||
1aeb : a901 > lda #1 ;precharge accu
|
||
1aed : 28 > plp
|
||
|
||
1aee : 3411 bit zp1,x ;c3 - should set N (M7) & V (M6) / clear Z
|
||
tst_a 1,fnv
|
||
1af0 : 08 > php ;save flags
|
||
1af1 : c901 > cmp #1 ;test result
|
||
> trap_ne
|
||
1af3 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1af5 : 68 > pla ;load status
|
||
1af6 : 48 > pha
|
||
> cmp_flag fnv
|
||
1af7 : c9f0 > cmp #(fnv|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1af9 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1afb : 28 > plp ;restore status
|
||
|
||
|
||
set_a 1,$ff
|
||
> load_flag $ff
|
||
1afc : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
1afe : 48 > pha ;use stack to load status
|
||
1aff : a901 > lda #1 ;precharge accu
|
||
1b01 : 28 > plp
|
||
|
||
1b02 : 3411 bit zp1,x ;c3 - should set N (M7) & V (M6) / clear Z
|
||
tst_a 1,~fz
|
||
1b04 : 08 > php ;save flags
|
||
1b05 : c901 > cmp #1 ;test result
|
||
> trap_ne
|
||
1b07 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1b09 : 68 > pla ;load status
|
||
1b0a : 48 > pha
|
||
> cmp_flag ~fz
|
||
1b0b : c9fd > cmp #(~fz|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1b0d : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1b0f : 28 > plp ;restore status
|
||
|
||
1b10 : e8 inx
|
||
set_a 1,$ff
|
||
> load_flag $ff
|
||
1b11 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
1b13 : 48 > pha ;use stack to load status
|
||
1b14 : a901 > lda #1 ;precharge accu
|
||
1b16 : 28 > plp
|
||
|
||
1b17 : 3411 bit zp1,x ;82 - should set N (M7) & Z / clear V
|
||
tst_a 1,~fv
|
||
1b19 : 08 > php ;save flags
|
||
1b1a : c901 > cmp #1 ;test result
|
||
> trap_ne
|
||
1b1c : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1b1e : 68 > pla ;load status
|
||
1b1f : 48 > pha
|
||
> cmp_flag ~fv
|
||
1b20 : c9bf > cmp #(~fv|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1b22 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1b24 : 28 > plp ;restore status
|
||
|
||
1b25 : e8 inx
|
||
set_a 1,$ff
|
||
> load_flag $ff
|
||
1b26 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
1b28 : 48 > pha ;use stack to load status
|
||
1b29 : a901 > lda #1 ;precharge accu
|
||
1b2b : 28 > plp
|
||
|
||
1b2c : 3411 bit zp1,x ;41 - should set V (M6) / clear NZ
|
||
tst_a 1,~fnz
|
||
1b2e : 08 > php ;save flags
|
||
1b2f : c901 > cmp #1 ;test result
|
||
> trap_ne
|
||
1b31 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1b33 : 68 > pla ;load status
|
||
1b34 : 48 > pha
|
||
> cmp_flag ~fnz
|
||
1b35 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1b37 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1b39 : 28 > plp ;restore status
|
||
|
||
1b3a : e8 inx
|
||
set_a $ff,$ff
|
||
> load_flag $ff
|
||
1b3b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
1b3d : 48 > pha ;use stack to load status
|
||
1b3e : a9ff > lda #$ff ;precharge accu
|
||
1b40 : 28 > plp
|
||
|
||
1b41 : 3411 bit zp1,x ;00 - should set Z / clear NV
|
||
tst_a $ff,~fnv
|
||
1b43 : 08 > php ;save flags
|
||
1b44 : c9ff > cmp #$ff ;test result
|
||
> trap_ne
|
||
1b46 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1b48 : 68 > pla ;load status
|
||
1b49 : 48 > pha
|
||
> cmp_flag ~fnv
|
||
1b4a : c93f > cmp #(~fnv |fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1b4c : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1b4e : 28 > plp ;restore status
|
||
|
||
|
||
set_a $ff,0
|
||
> load_flag 0
|
||
1b4f : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
1b51 : 48 > pha ;use stack to load status
|
||
1b52 : a9ff > lda #$ff ;precharge accu
|
||
1b54 : 28 > plp
|
||
|
||
1b55 : 3c0a02 bit abs1,x ;00 - should set Z / clear NV
|
||
tst_a $ff,fz
|
||
1b58 : 08 > php ;save flags
|
||
1b59 : c9ff > cmp #$ff ;test result
|
||
> trap_ne
|
||
1b5b : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1b5d : 68 > pla ;load status
|
||
1b5e : 48 > pha
|
||
> cmp_flag fz
|
||
1b5f : c932 > cmp #(fz |fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1b61 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1b63 : 28 > plp ;restore status
|
||
|
||
1b64 : ca dex
|
||
set_a 1,0
|
||
> load_flag 0
|
||
1b65 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
1b67 : 48 > pha ;use stack to load status
|
||
1b68 : a901 > lda #1 ;precharge accu
|
||
1b6a : 28 > plp
|
||
|
||
1b6b : 3c0a02 bit abs1,x ;41 - should set V (M6) / clear NZ
|
||
tst_a 1,fv
|
||
1b6e : 08 > php ;save flags
|
||
1b6f : c901 > cmp #1 ;test result
|
||
> trap_ne
|
||
1b71 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1b73 : 68 > pla ;load status
|
||
1b74 : 48 > pha
|
||
> cmp_flag fv
|
||
1b75 : c970 > cmp #(fv|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1b77 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1b79 : 28 > plp ;restore status
|
||
|
||
1b7a : ca dex
|
||
set_a 1,0
|
||
> load_flag 0
|
||
1b7b : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
1b7d : 48 > pha ;use stack to load status
|
||
1b7e : a901 > lda #1 ;precharge accu
|
||
1b80 : 28 > plp
|
||
|
||
1b81 : 3c0a02 bit abs1,x ;82 - should set N (M7) & Z / clear V
|
||
tst_a 1,fnz
|
||
1b84 : 08 > php ;save flags
|
||
1b85 : c901 > cmp #1 ;test result
|
||
> trap_ne
|
||
1b87 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1b89 : 68 > pla ;load status
|
||
1b8a : 48 > pha
|
||
> cmp_flag fnz
|
||
1b8b : c9b2 > cmp #(fnz|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1b8d : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1b8f : 28 > plp ;restore status
|
||
|
||
1b90 : ca dex
|
||
set_a 1,0
|
||
> load_flag 0
|
||
1b91 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
1b93 : 48 > pha ;use stack to load status
|
||
1b94 : a901 > lda #1 ;precharge accu
|
||
1b96 : 28 > plp
|
||
|
||
1b97 : 3c0a02 bit abs1,x ;c3 - should set N (M7) & V (M6) / clear Z
|
||
tst_a 1,fnv
|
||
1b9a : 08 > php ;save flags
|
||
1b9b : c901 > cmp #1 ;test result
|
||
> trap_ne
|
||
1b9d : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1b9f : 68 > pla ;load status
|
||
1ba0 : 48 > pha
|
||
> cmp_flag fnv
|
||
1ba1 : c9f0 > cmp #(fnv|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1ba3 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1ba5 : 28 > plp ;restore status
|
||
|
||
|
||
set_a 1,$ff
|
||
> load_flag $ff
|
||
1ba6 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
1ba8 : 48 > pha ;use stack to load status
|
||
1ba9 : a901 > lda #1 ;precharge accu
|
||
1bab : 28 > plp
|
||
|
||
1bac : 3c0a02 bit abs1,x ;c3 - should set N (M7) & V (M6) / clear Z
|
||
tst_a 1,~fz
|
||
1baf : 08 > php ;save flags
|
||
1bb0 : c901 > cmp #1 ;test result
|
||
> trap_ne
|
||
1bb2 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1bb4 : 68 > pla ;load status
|
||
1bb5 : 48 > pha
|
||
> cmp_flag ~fz
|
||
1bb6 : c9fd > cmp #(~fz|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1bb8 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1bba : 28 > plp ;restore status
|
||
|
||
1bbb : e8 inx
|
||
set_a 1,$ff
|
||
> load_flag $ff
|
||
1bbc : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
1bbe : 48 > pha ;use stack to load status
|
||
1bbf : a901 > lda #1 ;precharge accu
|
||
1bc1 : 28 > plp
|
||
|
||
1bc2 : 3c0a02 bit abs1,x ;82 - should set N (M7) & Z / clear V
|
||
tst_a 1,~fv
|
||
1bc5 : 08 > php ;save flags
|
||
1bc6 : c901 > cmp #1 ;test result
|
||
> trap_ne
|
||
1bc8 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1bca : 68 > pla ;load status
|
||
1bcb : 48 > pha
|
||
> cmp_flag ~fv
|
||
1bcc : c9bf > cmp #(~fv|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1bce : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1bd0 : 28 > plp ;restore status
|
||
|
||
1bd1 : e8 inx
|
||
set_a 1,$ff
|
||
> load_flag $ff
|
||
1bd2 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
1bd4 : 48 > pha ;use stack to load status
|
||
1bd5 : a901 > lda #1 ;precharge accu
|
||
1bd7 : 28 > plp
|
||
|
||
1bd8 : 3c0a02 bit abs1,x ;41 - should set V (M6) / clear NZ
|
||
tst_a 1,~fnz
|
||
1bdb : 08 > php ;save flags
|
||
1bdc : c901 > cmp #1 ;test result
|
||
> trap_ne
|
||
1bde : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1be0 : 68 > pla ;load status
|
||
1be1 : 48 > pha
|
||
> cmp_flag ~fnz
|
||
1be2 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1be4 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1be6 : 28 > plp ;restore status
|
||
|
||
1be7 : e8 inx
|
||
set_a $ff,$ff
|
||
> load_flag $ff
|
||
1be8 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
1bea : 48 > pha ;use stack to load status
|
||
1beb : a9ff > lda #$ff ;precharge accu
|
||
1bed : 28 > plp
|
||
|
||
1bee : 3c0a02 bit abs1,x ;00 - should set Z / clear NV
|
||
tst_a $ff,~fnv
|
||
1bf1 : 08 > php ;save flags
|
||
1bf2 : c9ff > cmp #$ff ;test result
|
||
> trap_ne
|
||
1bf4 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1bf6 : 68 > pla ;load status
|
||
1bf7 : 48 > pha
|
||
> cmp_flag ~fnv
|
||
1bf8 : c93f > cmp #(~fnv |fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1bfa : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1bfc : 28 > plp ;restore status
|
||
|
||
|
||
set_a $ff,0
|
||
> load_flag 0
|
||
1bfd : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
1bff : 48 > pha ;use stack to load status
|
||
1c00 : a9ff > lda #$ff ;precharge accu
|
||
1c02 : 28 > plp
|
||
|
||
1c03 : 8900 bit #$00 ;00 - should set Z
|
||
tst_a $ff,fz
|
||
1c05 : 08 > php ;save flags
|
||
1c06 : c9ff > cmp #$ff ;test result
|
||
> trap_ne
|
||
1c08 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1c0a : 68 > pla ;load status
|
||
1c0b : 48 > pha
|
||
> cmp_flag fz
|
||
1c0c : c932 > cmp #(fz |fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1c0e : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1c10 : 28 > plp ;restore status
|
||
|
||
1c11 : ca dex
|
||
set_a 1,0
|
||
> load_flag 0
|
||
1c12 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
1c14 : 48 > pha ;use stack to load status
|
||
1c15 : a901 > lda #1 ;precharge accu
|
||
1c17 : 28 > plp
|
||
|
||
1c18 : 8941 bit #$41 ;41 - should clear Z
|
||
tst_a 1,0
|
||
1c1a : 08 > php ;save flags
|
||
1c1b : c901 > cmp #1 ;test result
|
||
> trap_ne
|
||
1c1d : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1c1f : 68 > pla ;load status
|
||
1c20 : 48 > pha
|
||
> cmp_flag 0
|
||
1c21 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1c23 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1c25 : 28 > plp ;restore status
|
||
|
||
; *** DEBUG INFO ***
|
||
; if it fails the previous test and your BIT # has set the V flag
|
||
; see http://forum.6502.org/viewtopic.php?f=2&t=2241&p=27243#p27239
|
||
; why it shouldn't alter N or V flags on a BIT #
|
||
1c26 : ca dex
|
||
set_a 1,0
|
||
> load_flag 0
|
||
1c27 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
1c29 : 48 > pha ;use stack to load status
|
||
1c2a : a901 > lda #1 ;precharge accu
|
||
1c2c : 28 > plp
|
||
|
||
1c2d : 8982 bit #$82 ;82 - should set Z
|
||
tst_a 1,fz
|
||
1c2f : 08 > php ;save flags
|
||
1c30 : c901 > cmp #1 ;test result
|
||
> trap_ne
|
||
1c32 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1c34 : 68 > pla ;load status
|
||
1c35 : 48 > pha
|
||
> cmp_flag fz
|
||
1c36 : c932 > cmp #(fz|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1c38 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1c3a : 28 > plp ;restore status
|
||
|
||
1c3b : ca dex
|
||
set_a 1,0
|
||
> load_flag 0
|
||
1c3c : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
1c3e : 48 > pha ;use stack to load status
|
||
1c3f : a901 > lda #1 ;precharge accu
|
||
1c41 : 28 > plp
|
||
|
||
1c42 : 89c3 bit #$c3 ;c3 - should clear Z
|
||
tst_a 1,0
|
||
1c44 : 08 > php ;save flags
|
||
1c45 : c901 > cmp #1 ;test result
|
||
> trap_ne
|
||
1c47 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1c49 : 68 > pla ;load status
|
||
1c4a : 48 > pha
|
||
> cmp_flag 0
|
||
1c4b : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1c4d : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1c4f : 28 > plp ;restore status
|
||
|
||
|
||
set_a 1,$ff
|
||
> load_flag $ff
|
||
1c50 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
1c52 : 48 > pha ;use stack to load status
|
||
1c53 : a901 > lda #1 ;precharge accu
|
||
1c55 : 28 > plp
|
||
|
||
1c56 : 89c3 bit #$c3 ;c3 - clear Z
|
||
tst_a 1,~fz
|
||
1c58 : 08 > php ;save flags
|
||
1c59 : c901 > cmp #1 ;test result
|
||
> trap_ne
|
||
1c5b : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1c5d : 68 > pla ;load status
|
||
1c5e : 48 > pha
|
||
> cmp_flag ~fz
|
||
1c5f : c9fd > cmp #(~fz|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1c61 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1c63 : 28 > plp ;restore status
|
||
|
||
1c64 : e8 inx
|
||
set_a 1,$ff
|
||
> load_flag $ff
|
||
1c65 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
1c67 : 48 > pha ;use stack to load status
|
||
1c68 : a901 > lda #1 ;precharge accu
|
||
1c6a : 28 > plp
|
||
|
||
1c6b : 8982 bit #$82 ;82 - should set Z
|
||
tst_a 1,$ff
|
||
1c6d : 08 > php ;save flags
|
||
1c6e : c901 > cmp #1 ;test result
|
||
> trap_ne
|
||
1c70 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1c72 : 68 > pla ;load status
|
||
1c73 : 48 > pha
|
||
> cmp_flag $ff
|
||
1c74 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1c76 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1c78 : 28 > plp ;restore status
|
||
|
||
1c79 : e8 inx
|
||
set_a 1,$ff
|
||
> load_flag $ff
|
||
1c7a : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
1c7c : 48 > pha ;use stack to load status
|
||
1c7d : a901 > lda #1 ;precharge accu
|
||
1c7f : 28 > plp
|
||
|
||
1c80 : 8941 bit #$41 ;41 - should clear Z
|
||
tst_a 1,~fz
|
||
1c82 : 08 > php ;save flags
|
||
1c83 : c901 > cmp #1 ;test result
|
||
> trap_ne
|
||
1c85 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1c87 : 68 > pla ;load status
|
||
1c88 : 48 > pha
|
||
> cmp_flag ~fz
|
||
1c89 : c9fd > cmp #(~fz|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1c8b : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1c8d : 28 > plp ;restore status
|
||
|
||
1c8e : e8 inx
|
||
set_a $ff,$ff
|
||
> load_flag $ff
|
||
1c8f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
1c91 : 48 > pha ;use stack to load status
|
||
1c92 : a9ff > lda #$ff ;precharge accu
|
||
1c94 : 28 > plp
|
||
|
||
1c95 : 8900 bit #$00 ;00 - should set Z
|
||
tst_a $ff,$ff
|
||
1c97 : 08 > php ;save flags
|
||
1c98 : c9ff > cmp #$ff ;test result
|
||
> trap_ne
|
||
1c9a : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1c9c : 68 > pla ;load status
|
||
1c9d : 48 > pha
|
||
> cmp_flag $ff
|
||
1c9e : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1ca0 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1ca2 : 28 > plp ;restore status
|
||
|
||
|
||
1ca3 : e003 cpx #3
|
||
trap_ne ;x altered during test
|
||
1ca5 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
1ca7 : c042 cpy #$42
|
||
trap_ne ;y altered during test
|
||
1ca9 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
1cab : ba tsx
|
||
1cac : e0ff cpx #$ff
|
||
trap_ne ;sp push/pop mismatch
|
||
1cae : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
next_test
|
||
1cb0 : ad0202 > lda test_case ;previous test
|
||
1cb3 : c90f > cmp #test_num
|
||
> trap_ne ;test is out of sequence
|
||
1cb5 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0010 = >test_num = test_num + 1
|
||
1cb7 : a910 > lda #test_num ;*** next tests' number
|
||
1cb9 : 8d0202 > sta test_case
|
||
> ;check_ram ;uncomment to find altered RAM after each test
|
||
|
||
|
||
; testing TRB, TSB - zp / abs
|
||
|
||
trbt macro ;\1 = memory, \2 = flags
|
||
sty \1
|
||
load_flag \2
|
||
pha
|
||
lda zpt+1
|
||
plp
|
||
trb \1
|
||
php
|
||
cmp zpt+1
|
||
trap_ne ;accu was changed
|
||
pla
|
||
pha
|
||
ora #fz ;mask Z
|
||
cmp_flag \2|fz
|
||
trap_ne ;flags changed except Z
|
||
pla
|
||
and #fz
|
||
cmp zpt+2
|
||
trap_ne ;Z flag invalid
|
||
lda zpt+3
|
||
cmp zpt
|
||
trap_ne ;altered bits in memory wrong
|
||
endm
|
||
|
||
tsbt macro ;\1 = memory, \2 = flags
|
||
sty \1
|
||
load_flag \2
|
||
pha
|
||
lda zpt+1
|
||
plp
|
||
tsb \1
|
||
php
|
||
cmp zpt+1
|
||
trap_ne ;accu was changed
|
||
pla
|
||
pha
|
||
ora #fz ;mask Z
|
||
cmp_flag \2|fz
|
||
trap_ne ;flags changed except Z
|
||
pla
|
||
and #fz
|
||
cmp zpt+2
|
||
trap_ne ;Z flag invalid
|
||
lda zpt+4
|
||
cmp zpt
|
||
trap_ne ;altered bits in memory wrong
|
||
endm
|
||
|
||
1cbc : a2c0 ldx #$c0
|
||
1cbe : a000 ldy #0 ;op1 - memory save
|
||
; zpt ;op1 - memory modifiable
|
||
1cc0 : 640b stz zpt+1 ;op2 - accu
|
||
; zpt+2 ;and flags
|
||
; zpt+3 ;memory after reset
|
||
; zpt+4 ;memory after set
|
||
|
||
1cc2 : 98 tbt1 tya
|
||
1cc3 : 250b and zpt+1 ;set Z by anding the 2 operands
|
||
1cc5 : 08 php
|
||
1cc6 : 68 pla
|
||
1cc7 : 2902 and #fz ;mask Z
|
||
1cc9 : 850c sta zpt+2
|
||
1ccb : 98 tya ;reset op1 bits by op2
|
||
1ccc : 49ff eor #$ff
|
||
1cce : 050b ora zpt+1
|
||
1cd0 : 49ff eor #$ff
|
||
1cd2 : 850d sta zpt+3
|
||
1cd4 : 98 tya ;set op1 bits by op2
|
||
1cd5 : 050b ora zpt+1
|
||
1cd7 : 850e sta zpt+4
|
||
|
||
trbt zpt,$ff
|
||
1cd9 : 840a > sty zpt
|
||
> load_flag $ff
|
||
1cdb : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
1cdd : 48 > pha
|
||
1cde : a50b > lda zpt+1
|
||
1ce0 : 28 > plp
|
||
1ce1 : 140a > trb zpt
|
||
1ce3 : 08 > php
|
||
1ce4 : c50b > cmp zpt+1
|
||
> trap_ne ;accu was changed
|
||
1ce6 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1ce8 : 68 > pla
|
||
1ce9 : 48 > pha
|
||
1cea : 0902 > ora #fz ;mask Z
|
||
> cmp_flag $ff|fz
|
||
1cec : c9ff > cmp #($ff|fz|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne ;flags changed except Z
|
||
1cee : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1cf0 : 68 > pla
|
||
1cf1 : 2902 > and #fz
|
||
1cf3 : c50c > cmp zpt+2
|
||
> trap_ne ;Z flag invalid
|
||
1cf5 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1cf7 : a50d > lda zpt+3
|
||
1cf9 : c50a > cmp zpt
|
||
> trap_ne ;altered bits in memory wrong
|
||
1cfb : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
trbt abst,$ff
|
||
1cfd : 8c0502 > sty abst
|
||
> load_flag $ff
|
||
1d00 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
1d02 : 48 > pha
|
||
1d03 : a50b > lda zpt+1
|
||
1d05 : 28 > plp
|
||
1d06 : 1c0502 > trb abst
|
||
1d09 : 08 > php
|
||
1d0a : c50b > cmp zpt+1
|
||
> trap_ne ;accu was changed
|
||
1d0c : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1d0e : 68 > pla
|
||
1d0f : 48 > pha
|
||
1d10 : 0902 > ora #fz ;mask Z
|
||
> cmp_flag $ff|fz
|
||
1d12 : c9ff > cmp #($ff|fz|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne ;flags changed except Z
|
||
1d14 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1d16 : 68 > pla
|
||
1d17 : 2902 > and #fz
|
||
1d19 : c50c > cmp zpt+2
|
||
> trap_ne ;Z flag invalid
|
||
1d1b : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1d1d : a50d > lda zpt+3
|
||
1d1f : c50a > cmp zpt
|
||
> trap_ne ;altered bits in memory wrong
|
||
1d21 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
trbt zpt,0
|
||
1d23 : 840a > sty zpt
|
||
> load_flag 0
|
||
1d25 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
1d27 : 48 > pha
|
||
1d28 : a50b > lda zpt+1
|
||
1d2a : 28 > plp
|
||
1d2b : 140a > trb zpt
|
||
1d2d : 08 > php
|
||
1d2e : c50b > cmp zpt+1
|
||
> trap_ne ;accu was changed
|
||
1d30 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1d32 : 68 > pla
|
||
1d33 : 48 > pha
|
||
1d34 : 0902 > ora #fz ;mask Z
|
||
> cmp_flag 0|fz
|
||
1d36 : c932 > cmp #(0|fz|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne ;flags changed except Z
|
||
1d38 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1d3a : 68 > pla
|
||
1d3b : 2902 > and #fz
|
||
1d3d : c50c > cmp zpt+2
|
||
> trap_ne ;Z flag invalid
|
||
1d3f : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1d41 : a50d > lda zpt+3
|
||
1d43 : c50a > cmp zpt
|
||
> trap_ne ;altered bits in memory wrong
|
||
1d45 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
trbt abst,0
|
||
1d47 : 8c0502 > sty abst
|
||
> load_flag 0
|
||
1d4a : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
1d4c : 48 > pha
|
||
1d4d : a50b > lda zpt+1
|
||
1d4f : 28 > plp
|
||
1d50 : 1c0502 > trb abst
|
||
1d53 : 08 > php
|
||
1d54 : c50b > cmp zpt+1
|
||
> trap_ne ;accu was changed
|
||
1d56 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1d58 : 68 > pla
|
||
1d59 : 48 > pha
|
||
1d5a : 0902 > ora #fz ;mask Z
|
||
> cmp_flag 0|fz
|
||
1d5c : c932 > cmp #(0|fz|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne ;flags changed except Z
|
||
1d5e : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1d60 : 68 > pla
|
||
1d61 : 2902 > and #fz
|
||
1d63 : c50c > cmp zpt+2
|
||
> trap_ne ;Z flag invalid
|
||
1d65 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1d67 : a50d > lda zpt+3
|
||
1d69 : c50a > cmp zpt
|
||
> trap_ne ;altered bits in memory wrong
|
||
1d6b : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
tsbt zpt,$ff
|
||
1d6d : 840a > sty zpt
|
||
> load_flag $ff
|
||
1d6f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
1d71 : 48 > pha
|
||
1d72 : a50b > lda zpt+1
|
||
1d74 : 28 > plp
|
||
1d75 : 040a > tsb zpt
|
||
1d77 : 08 > php
|
||
1d78 : c50b > cmp zpt+1
|
||
> trap_ne ;accu was changed
|
||
1d7a : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1d7c : 68 > pla
|
||
1d7d : 48 > pha
|
||
1d7e : 0902 > ora #fz ;mask Z
|
||
> cmp_flag $ff|fz
|
||
1d80 : c9ff > cmp #($ff|fz|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne ;flags changed except Z
|
||
1d82 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1d84 : 68 > pla
|
||
1d85 : 2902 > and #fz
|
||
1d87 : c50c > cmp zpt+2
|
||
> trap_ne ;Z flag invalid
|
||
1d89 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1d8b : a50e > lda zpt+4
|
||
1d8d : c50a > cmp zpt
|
||
> trap_ne ;altered bits in memory wrong
|
||
1d8f : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
tsbt abst,$ff
|
||
1d91 : 8c0502 > sty abst
|
||
> load_flag $ff
|
||
1d94 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
1d96 : 48 > pha
|
||
1d97 : a50b > lda zpt+1
|
||
1d99 : 28 > plp
|
||
1d9a : 0c0502 > tsb abst
|
||
1d9d : 08 > php
|
||
1d9e : c50b > cmp zpt+1
|
||
> trap_ne ;accu was changed
|
||
1da0 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1da2 : 68 > pla
|
||
1da3 : 48 > pha
|
||
1da4 : 0902 > ora #fz ;mask Z
|
||
> cmp_flag $ff|fz
|
||
1da6 : c9ff > cmp #($ff|fz|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne ;flags changed except Z
|
||
1da8 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1daa : 68 > pla
|
||
1dab : 2902 > and #fz
|
||
1dad : c50c > cmp zpt+2
|
||
> trap_ne ;Z flag invalid
|
||
1daf : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1db1 : a50e > lda zpt+4
|
||
1db3 : c50a > cmp zpt
|
||
> trap_ne ;altered bits in memory wrong
|
||
1db5 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
tsbt zpt,0
|
||
1db7 : 840a > sty zpt
|
||
> load_flag 0
|
||
1db9 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
1dbb : 48 > pha
|
||
1dbc : a50b > lda zpt+1
|
||
1dbe : 28 > plp
|
||
1dbf : 040a > tsb zpt
|
||
1dc1 : 08 > php
|
||
1dc2 : c50b > cmp zpt+1
|
||
> trap_ne ;accu was changed
|
||
1dc4 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1dc6 : 68 > pla
|
||
1dc7 : 48 > pha
|
||
1dc8 : 0902 > ora #fz ;mask Z
|
||
> cmp_flag 0|fz
|
||
1dca : c932 > cmp #(0|fz|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne ;flags changed except Z
|
||
1dcc : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1dce : 68 > pla
|
||
1dcf : 2902 > and #fz
|
||
1dd1 : c50c > cmp zpt+2
|
||
> trap_ne ;Z flag invalid
|
||
1dd3 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1dd5 : a50e > lda zpt+4
|
||
1dd7 : c50a > cmp zpt
|
||
> trap_ne ;altered bits in memory wrong
|
||
1dd9 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
tsbt abst,0
|
||
1ddb : 8c0502 > sty abst
|
||
> load_flag 0
|
||
1dde : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
1de0 : 48 > pha
|
||
1de1 : a50b > lda zpt+1
|
||
1de3 : 28 > plp
|
||
1de4 : 0c0502 > tsb abst
|
||
1de7 : 08 > php
|
||
1de8 : c50b > cmp zpt+1
|
||
> trap_ne ;accu was changed
|
||
1dea : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1dec : 68 > pla
|
||
1ded : 48 > pha
|
||
1dee : 0902 > ora #fz ;mask Z
|
||
> cmp_flag 0|fz
|
||
1df0 : c932 > cmp #(0|fz|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne ;flags changed except Z
|
||
1df2 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1df4 : 68 > pla
|
||
1df5 : 2902 > and #fz
|
||
1df7 : c50c > cmp zpt+2
|
||
> trap_ne ;Z flag invalid
|
||
1df9 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1dfb : a50e > lda zpt+4
|
||
1dfd : c50a > cmp zpt
|
||
> trap_ne ;altered bits in memory wrong
|
||
1dff : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
|
||
1e01 : c8 iny ;iterate op1
|
||
1e02 : d004 bne tbt3
|
||
1e04 : e60b inc zpt+1 ;iterate op2
|
||
1e06 : f003 beq tbt2
|
||
1e08 : 4cc21c tbt3 jmp tbt1
|
||
1e0b : tbt2
|
||
1e0b : e0c0 cpx #$c0
|
||
trap_ne ;x altered during test
|
||
1e0d : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
1e0f : ba tsx
|
||
1e10 : e0ff cpx #$ff
|
||
trap_ne ;sp push/pop mismatch
|
||
1e12 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
next_test
|
||
1e14 : ad0202 > lda test_case ;previous test
|
||
1e17 : c910 > cmp #test_num
|
||
> trap_ne ;test is out of sequence
|
||
1e19 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0011 = >test_num = test_num + 1
|
||
1e1b : a911 > lda #test_num ;*** next tests' number
|
||
1e1d : 8d0202 > sta test_case
|
||
> ;check_ram ;uncomment to find altered RAM after each test
|
||
|
||
|
||
if rkwl_wdc_op
|
||
; testing RMB, SMB - zp
|
||
rmbt macro ;\1 = bitnum
|
||
lda #$ff
|
||
sta zpt
|
||
set_a $a5,0
|
||
rmb \1,zpt
|
||
tst_a $a5,0
|
||
lda zpt
|
||
cmp #$ff-(1<<\1)
|
||
trap_ne ;wrong bits set or cleared
|
||
lda #1<<\1
|
||
sta zpt
|
||
set_a $5a,$ff
|
||
rmb \1,zpt
|
||
tst_a $5a,$ff
|
||
lda zpt
|
||
trap_ne ;wrong bits set or cleared
|
||
endm
|
||
smbt macro ;\1 = bitnum
|
||
lda #$ff-(1<<\1)
|
||
sta zpt
|
||
set_a $a5,0
|
||
smb \1,zpt
|
||
tst_a $a5,0
|
||
lda zpt
|
||
cmp #$ff
|
||
trap_ne ;wrong bits set or cleared
|
||
lda #0
|
||
sta zpt
|
||
set_a $5a,$ff
|
||
smb \1,zpt
|
||
tst_a $5a,$ff
|
||
lda zpt
|
||
cmp #1<<\1
|
||
trap_ne ;wrong bits set or cleared
|
||
endm
|
||
|
||
1e20 : a2ba ldx #$ba ;protect x & y
|
||
1e22 : a0d0 ldy #$d0
|
||
rmbt 0
|
||
1e24 : a9ff > lda #$ff
|
||
1e26 : 850a > sta zpt
|
||
> set_a $a5,0
|
||
> load_flag 0
|
||
1e28 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
1e2a : 48 > pha ;use stack to load status
|
||
1e2b : a9a5 > lda #$a5 ;precharge accu
|
||
1e2d : 28 > plp
|
||
>
|
||
1e2e : 070a > rmb 0,zpt
|
||
> tst_a $a5,0
|
||
1e30 : 08 > php ;save flags
|
||
1e31 : c9a5 > cmp #$a5 ;test result
|
||
> trap_ne
|
||
1e33 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1e35 : 68 > pla ;load status
|
||
1e36 : 48 > pha
|
||
> cmp_flag 0
|
||
1e37 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1e39 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1e3b : 28 > plp ;restore status
|
||
>
|
||
1e3c : a50a > lda zpt
|
||
1e3e : c9fe > cmp #$ff-(1<<0)
|
||
> trap_ne ;wrong bits set or cleared
|
||
1e40 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1e42 : a901 > lda #1<<0
|
||
1e44 : 850a > sta zpt
|
||
> set_a $5a,$ff
|
||
> load_flag $ff
|
||
1e46 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
1e48 : 48 > pha ;use stack to load status
|
||
1e49 : a95a > lda #$5a ;precharge accu
|
||
1e4b : 28 > plp
|
||
>
|
||
1e4c : 070a > rmb 0,zpt
|
||
> tst_a $5a,$ff
|
||
1e4e : 08 > php ;save flags
|
||
1e4f : c95a > cmp #$5a ;test result
|
||
> trap_ne
|
||
1e51 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1e53 : 68 > pla ;load status
|
||
1e54 : 48 > pha
|
||
> cmp_flag $ff
|
||
1e55 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1e57 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1e59 : 28 > plp ;restore status
|
||
>
|
||
1e5a : a50a > lda zpt
|
||
> trap_ne ;wrong bits set or cleared
|
||
1e5c : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
rmbt 1
|
||
1e5e : a9ff > lda #$ff
|
||
1e60 : 850a > sta zpt
|
||
> set_a $a5,0
|
||
> load_flag 0
|
||
1e62 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
1e64 : 48 > pha ;use stack to load status
|
||
1e65 : a9a5 > lda #$a5 ;precharge accu
|
||
1e67 : 28 > plp
|
||
>
|
||
1e68 : 170a > rmb 1,zpt
|
||
> tst_a $a5,0
|
||
1e6a : 08 > php ;save flags
|
||
1e6b : c9a5 > cmp #$a5 ;test result
|
||
> trap_ne
|
||
1e6d : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1e6f : 68 > pla ;load status
|
||
1e70 : 48 > pha
|
||
> cmp_flag 0
|
||
1e71 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1e73 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1e75 : 28 > plp ;restore status
|
||
>
|
||
1e76 : a50a > lda zpt
|
||
1e78 : c9fd > cmp #$ff-(1<<1)
|
||
> trap_ne ;wrong bits set or cleared
|
||
1e7a : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1e7c : a902 > lda #1<<1
|
||
1e7e : 850a > sta zpt
|
||
> set_a $5a,$ff
|
||
> load_flag $ff
|
||
1e80 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
1e82 : 48 > pha ;use stack to load status
|
||
1e83 : a95a > lda #$5a ;precharge accu
|
||
1e85 : 28 > plp
|
||
>
|
||
1e86 : 170a > rmb 1,zpt
|
||
> tst_a $5a,$ff
|
||
1e88 : 08 > php ;save flags
|
||
1e89 : c95a > cmp #$5a ;test result
|
||
> trap_ne
|
||
1e8b : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1e8d : 68 > pla ;load status
|
||
1e8e : 48 > pha
|
||
> cmp_flag $ff
|
||
1e8f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1e91 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1e93 : 28 > plp ;restore status
|
||
>
|
||
1e94 : a50a > lda zpt
|
||
> trap_ne ;wrong bits set or cleared
|
||
1e96 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
rmbt 2
|
||
1e98 : a9ff > lda #$ff
|
||
1e9a : 850a > sta zpt
|
||
> set_a $a5,0
|
||
> load_flag 0
|
||
1e9c : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
1e9e : 48 > pha ;use stack to load status
|
||
1e9f : a9a5 > lda #$a5 ;precharge accu
|
||
1ea1 : 28 > plp
|
||
>
|
||
1ea2 : 270a > rmb 2,zpt
|
||
> tst_a $a5,0
|
||
1ea4 : 08 > php ;save flags
|
||
1ea5 : c9a5 > cmp #$a5 ;test result
|
||
> trap_ne
|
||
1ea7 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1ea9 : 68 > pla ;load status
|
||
1eaa : 48 > pha
|
||
> cmp_flag 0
|
||
1eab : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1ead : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1eaf : 28 > plp ;restore status
|
||
>
|
||
1eb0 : a50a > lda zpt
|
||
1eb2 : c9fb > cmp #$ff-(1<<2)
|
||
> trap_ne ;wrong bits set or cleared
|
||
1eb4 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1eb6 : a904 > lda #1<<2
|
||
1eb8 : 850a > sta zpt
|
||
> set_a $5a,$ff
|
||
> load_flag $ff
|
||
1eba : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
1ebc : 48 > pha ;use stack to load status
|
||
1ebd : a95a > lda #$5a ;precharge accu
|
||
1ebf : 28 > plp
|
||
>
|
||
1ec0 : 270a > rmb 2,zpt
|
||
> tst_a $5a,$ff
|
||
1ec2 : 08 > php ;save flags
|
||
1ec3 : c95a > cmp #$5a ;test result
|
||
> trap_ne
|
||
1ec5 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1ec7 : 68 > pla ;load status
|
||
1ec8 : 48 > pha
|
||
> cmp_flag $ff
|
||
1ec9 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1ecb : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1ecd : 28 > plp ;restore status
|
||
>
|
||
1ece : a50a > lda zpt
|
||
> trap_ne ;wrong bits set or cleared
|
||
1ed0 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
rmbt 3
|
||
1ed2 : a9ff > lda #$ff
|
||
1ed4 : 850a > sta zpt
|
||
> set_a $a5,0
|
||
> load_flag 0
|
||
1ed6 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
1ed8 : 48 > pha ;use stack to load status
|
||
1ed9 : a9a5 > lda #$a5 ;precharge accu
|
||
1edb : 28 > plp
|
||
>
|
||
1edc : 370a > rmb 3,zpt
|
||
> tst_a $a5,0
|
||
1ede : 08 > php ;save flags
|
||
1edf : c9a5 > cmp #$a5 ;test result
|
||
> trap_ne
|
||
1ee1 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1ee3 : 68 > pla ;load status
|
||
1ee4 : 48 > pha
|
||
> cmp_flag 0
|
||
1ee5 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1ee7 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1ee9 : 28 > plp ;restore status
|
||
>
|
||
1eea : a50a > lda zpt
|
||
1eec : c9f7 > cmp #$ff-(1<<3)
|
||
> trap_ne ;wrong bits set or cleared
|
||
1eee : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1ef0 : a908 > lda #1<<3
|
||
1ef2 : 850a > sta zpt
|
||
> set_a $5a,$ff
|
||
> load_flag $ff
|
||
1ef4 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
1ef6 : 48 > pha ;use stack to load status
|
||
1ef7 : a95a > lda #$5a ;precharge accu
|
||
1ef9 : 28 > plp
|
||
>
|
||
1efa : 370a > rmb 3,zpt
|
||
> tst_a $5a,$ff
|
||
1efc : 08 > php ;save flags
|
||
1efd : c95a > cmp #$5a ;test result
|
||
> trap_ne
|
||
1eff : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1f01 : 68 > pla ;load status
|
||
1f02 : 48 > pha
|
||
> cmp_flag $ff
|
||
1f03 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1f05 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1f07 : 28 > plp ;restore status
|
||
>
|
||
1f08 : a50a > lda zpt
|
||
> trap_ne ;wrong bits set or cleared
|
||
1f0a : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
rmbt 4
|
||
1f0c : a9ff > lda #$ff
|
||
1f0e : 850a > sta zpt
|
||
> set_a $a5,0
|
||
> load_flag 0
|
||
1f10 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
1f12 : 48 > pha ;use stack to load status
|
||
1f13 : a9a5 > lda #$a5 ;precharge accu
|
||
1f15 : 28 > plp
|
||
>
|
||
1f16 : 470a > rmb 4,zpt
|
||
> tst_a $a5,0
|
||
1f18 : 08 > php ;save flags
|
||
1f19 : c9a5 > cmp #$a5 ;test result
|
||
> trap_ne
|
||
1f1b : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1f1d : 68 > pla ;load status
|
||
1f1e : 48 > pha
|
||
> cmp_flag 0
|
||
1f1f : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1f21 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1f23 : 28 > plp ;restore status
|
||
>
|
||
1f24 : a50a > lda zpt
|
||
1f26 : c9ef > cmp #$ff-(1<<4)
|
||
> trap_ne ;wrong bits set or cleared
|
||
1f28 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1f2a : a910 > lda #1<<4
|
||
1f2c : 850a > sta zpt
|
||
> set_a $5a,$ff
|
||
> load_flag $ff
|
||
1f2e : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
1f30 : 48 > pha ;use stack to load status
|
||
1f31 : a95a > lda #$5a ;precharge accu
|
||
1f33 : 28 > plp
|
||
>
|
||
1f34 : 470a > rmb 4,zpt
|
||
> tst_a $5a,$ff
|
||
1f36 : 08 > php ;save flags
|
||
1f37 : c95a > cmp #$5a ;test result
|
||
> trap_ne
|
||
1f39 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1f3b : 68 > pla ;load status
|
||
1f3c : 48 > pha
|
||
> cmp_flag $ff
|
||
1f3d : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1f3f : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1f41 : 28 > plp ;restore status
|
||
>
|
||
1f42 : a50a > lda zpt
|
||
> trap_ne ;wrong bits set or cleared
|
||
1f44 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
rmbt 5
|
||
1f46 : a9ff > lda #$ff
|
||
1f48 : 850a > sta zpt
|
||
> set_a $a5,0
|
||
> load_flag 0
|
||
1f4a : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
1f4c : 48 > pha ;use stack to load status
|
||
1f4d : a9a5 > lda #$a5 ;precharge accu
|
||
1f4f : 28 > plp
|
||
>
|
||
1f50 : 570a > rmb 5,zpt
|
||
> tst_a $a5,0
|
||
1f52 : 08 > php ;save flags
|
||
1f53 : c9a5 > cmp #$a5 ;test result
|
||
> trap_ne
|
||
1f55 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1f57 : 68 > pla ;load status
|
||
1f58 : 48 > pha
|
||
> cmp_flag 0
|
||
1f59 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1f5b : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1f5d : 28 > plp ;restore status
|
||
>
|
||
1f5e : a50a > lda zpt
|
||
1f60 : c9df > cmp #$ff-(1<<5)
|
||
> trap_ne ;wrong bits set or cleared
|
||
1f62 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1f64 : a920 > lda #1<<5
|
||
1f66 : 850a > sta zpt
|
||
> set_a $5a,$ff
|
||
> load_flag $ff
|
||
1f68 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
1f6a : 48 > pha ;use stack to load status
|
||
1f6b : a95a > lda #$5a ;precharge accu
|
||
1f6d : 28 > plp
|
||
>
|
||
1f6e : 570a > rmb 5,zpt
|
||
> tst_a $5a,$ff
|
||
1f70 : 08 > php ;save flags
|
||
1f71 : c95a > cmp #$5a ;test result
|
||
> trap_ne
|
||
1f73 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1f75 : 68 > pla ;load status
|
||
1f76 : 48 > pha
|
||
> cmp_flag $ff
|
||
1f77 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1f79 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1f7b : 28 > plp ;restore status
|
||
>
|
||
1f7c : a50a > lda zpt
|
||
> trap_ne ;wrong bits set or cleared
|
||
1f7e : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
rmbt 6
|
||
1f80 : a9ff > lda #$ff
|
||
1f82 : 850a > sta zpt
|
||
> set_a $a5,0
|
||
> load_flag 0
|
||
1f84 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
1f86 : 48 > pha ;use stack to load status
|
||
1f87 : a9a5 > lda #$a5 ;precharge accu
|
||
1f89 : 28 > plp
|
||
>
|
||
1f8a : 670a > rmb 6,zpt
|
||
> tst_a $a5,0
|
||
1f8c : 08 > php ;save flags
|
||
1f8d : c9a5 > cmp #$a5 ;test result
|
||
> trap_ne
|
||
1f8f : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1f91 : 68 > pla ;load status
|
||
1f92 : 48 > pha
|
||
> cmp_flag 0
|
||
1f93 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1f95 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1f97 : 28 > plp ;restore status
|
||
>
|
||
1f98 : a50a > lda zpt
|
||
1f9a : c9bf > cmp #$ff-(1<<6)
|
||
> trap_ne ;wrong bits set or cleared
|
||
1f9c : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1f9e : a940 > lda #1<<6
|
||
1fa0 : 850a > sta zpt
|
||
> set_a $5a,$ff
|
||
> load_flag $ff
|
||
1fa2 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
1fa4 : 48 > pha ;use stack to load status
|
||
1fa5 : a95a > lda #$5a ;precharge accu
|
||
1fa7 : 28 > plp
|
||
>
|
||
1fa8 : 670a > rmb 6,zpt
|
||
> tst_a $5a,$ff
|
||
1faa : 08 > php ;save flags
|
||
1fab : c95a > cmp #$5a ;test result
|
||
> trap_ne
|
||
1fad : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1faf : 68 > pla ;load status
|
||
1fb0 : 48 > pha
|
||
> cmp_flag $ff
|
||
1fb1 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1fb3 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1fb5 : 28 > plp ;restore status
|
||
>
|
||
1fb6 : a50a > lda zpt
|
||
> trap_ne ;wrong bits set or cleared
|
||
1fb8 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
rmbt 7
|
||
1fba : a9ff > lda #$ff
|
||
1fbc : 850a > sta zpt
|
||
> set_a $a5,0
|
||
> load_flag 0
|
||
1fbe : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
1fc0 : 48 > pha ;use stack to load status
|
||
1fc1 : a9a5 > lda #$a5 ;precharge accu
|
||
1fc3 : 28 > plp
|
||
>
|
||
1fc4 : 770a > rmb 7,zpt
|
||
> tst_a $a5,0
|
||
1fc6 : 08 > php ;save flags
|
||
1fc7 : c9a5 > cmp #$a5 ;test result
|
||
> trap_ne
|
||
1fc9 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1fcb : 68 > pla ;load status
|
||
1fcc : 48 > pha
|
||
> cmp_flag 0
|
||
1fcd : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1fcf : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1fd1 : 28 > plp ;restore status
|
||
>
|
||
1fd2 : a50a > lda zpt
|
||
1fd4 : c97f > cmp #$ff-(1<<7)
|
||
> trap_ne ;wrong bits set or cleared
|
||
1fd6 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1fd8 : a980 > lda #1<<7
|
||
1fda : 850a > sta zpt
|
||
> set_a $5a,$ff
|
||
> load_flag $ff
|
||
1fdc : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
1fde : 48 > pha ;use stack to load status
|
||
1fdf : a95a > lda #$5a ;precharge accu
|
||
1fe1 : 28 > plp
|
||
>
|
||
1fe2 : 770a > rmb 7,zpt
|
||
> tst_a $5a,$ff
|
||
1fe4 : 08 > php ;save flags
|
||
1fe5 : c95a > cmp #$5a ;test result
|
||
> trap_ne
|
||
1fe7 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1fe9 : 68 > pla ;load status
|
||
1fea : 48 > pha
|
||
> cmp_flag $ff
|
||
1feb : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
1fed : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
1fef : 28 > plp ;restore status
|
||
>
|
||
1ff0 : a50a > lda zpt
|
||
> trap_ne ;wrong bits set or cleared
|
||
1ff2 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
smbt 0
|
||
1ff4 : a9fe > lda #$ff-(1<<0)
|
||
1ff6 : 850a > sta zpt
|
||
> set_a $a5,0
|
||
> load_flag 0
|
||
1ff8 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
1ffa : 48 > pha ;use stack to load status
|
||
1ffb : a9a5 > lda #$a5 ;precharge accu
|
||
1ffd : 28 > plp
|
||
>
|
||
1ffe : 870a > smb 0,zpt
|
||
> tst_a $a5,0
|
||
2000 : 08 > php ;save flags
|
||
2001 : c9a5 > cmp #$a5 ;test result
|
||
> trap_ne
|
||
2003 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
2005 : 68 > pla ;load status
|
||
2006 : 48 > pha
|
||
> cmp_flag 0
|
||
2007 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
2009 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
200b : 28 > plp ;restore status
|
||
>
|
||
200c : a50a > lda zpt
|
||
200e : c9ff > cmp #$ff
|
||
> trap_ne ;wrong bits set or cleared
|
||
2010 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
2012 : a900 > lda #0
|
||
2014 : 850a > sta zpt
|
||
> set_a $5a,$ff
|
||
> load_flag $ff
|
||
2016 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
2018 : 48 > pha ;use stack to load status
|
||
2019 : a95a > lda #$5a ;precharge accu
|
||
201b : 28 > plp
|
||
>
|
||
201c : 870a > smb 0,zpt
|
||
> tst_a $5a,$ff
|
||
201e : 08 > php ;save flags
|
||
201f : c95a > cmp #$5a ;test result
|
||
> trap_ne
|
||
2021 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
2023 : 68 > pla ;load status
|
||
2024 : 48 > pha
|
||
> cmp_flag $ff
|
||
2025 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
2027 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
2029 : 28 > plp ;restore status
|
||
>
|
||
202a : a50a > lda zpt
|
||
202c : c901 > cmp #1<<0
|
||
> trap_ne ;wrong bits set or cleared
|
||
202e : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
smbt 1
|
||
2030 : a9fd > lda #$ff-(1<<1)
|
||
2032 : 850a > sta zpt
|
||
> set_a $a5,0
|
||
> load_flag 0
|
||
2034 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
2036 : 48 > pha ;use stack to load status
|
||
2037 : a9a5 > lda #$a5 ;precharge accu
|
||
2039 : 28 > plp
|
||
>
|
||
203a : 970a > smb 1,zpt
|
||
> tst_a $a5,0
|
||
203c : 08 > php ;save flags
|
||
203d : c9a5 > cmp #$a5 ;test result
|
||
> trap_ne
|
||
203f : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
2041 : 68 > pla ;load status
|
||
2042 : 48 > pha
|
||
> cmp_flag 0
|
||
2043 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
2045 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
2047 : 28 > plp ;restore status
|
||
>
|
||
2048 : a50a > lda zpt
|
||
204a : c9ff > cmp #$ff
|
||
> trap_ne ;wrong bits set or cleared
|
||
204c : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
204e : a900 > lda #0
|
||
2050 : 850a > sta zpt
|
||
> set_a $5a,$ff
|
||
> load_flag $ff
|
||
2052 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
2054 : 48 > pha ;use stack to load status
|
||
2055 : a95a > lda #$5a ;precharge accu
|
||
2057 : 28 > plp
|
||
>
|
||
2058 : 970a > smb 1,zpt
|
||
> tst_a $5a,$ff
|
||
205a : 08 > php ;save flags
|
||
205b : c95a > cmp #$5a ;test result
|
||
> trap_ne
|
||
205d : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
205f : 68 > pla ;load status
|
||
2060 : 48 > pha
|
||
> cmp_flag $ff
|
||
2061 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
2063 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
2065 : 28 > plp ;restore status
|
||
>
|
||
2066 : a50a > lda zpt
|
||
2068 : c902 > cmp #1<<1
|
||
> trap_ne ;wrong bits set or cleared
|
||
206a : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
smbt 2
|
||
206c : a9fb > lda #$ff-(1<<2)
|
||
206e : 850a > sta zpt
|
||
> set_a $a5,0
|
||
> load_flag 0
|
||
2070 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
2072 : 48 > pha ;use stack to load status
|
||
2073 : a9a5 > lda #$a5 ;precharge accu
|
||
2075 : 28 > plp
|
||
>
|
||
2076 : a70a > smb 2,zpt
|
||
> tst_a $a5,0
|
||
2078 : 08 > php ;save flags
|
||
2079 : c9a5 > cmp #$a5 ;test result
|
||
> trap_ne
|
||
207b : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
207d : 68 > pla ;load status
|
||
207e : 48 > pha
|
||
> cmp_flag 0
|
||
207f : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
2081 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
2083 : 28 > plp ;restore status
|
||
>
|
||
2084 : a50a > lda zpt
|
||
2086 : c9ff > cmp #$ff
|
||
> trap_ne ;wrong bits set or cleared
|
||
2088 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
208a : a900 > lda #0
|
||
208c : 850a > sta zpt
|
||
> set_a $5a,$ff
|
||
> load_flag $ff
|
||
208e : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
2090 : 48 > pha ;use stack to load status
|
||
2091 : a95a > lda #$5a ;precharge accu
|
||
2093 : 28 > plp
|
||
>
|
||
2094 : a70a > smb 2,zpt
|
||
> tst_a $5a,$ff
|
||
2096 : 08 > php ;save flags
|
||
2097 : c95a > cmp #$5a ;test result
|
||
> trap_ne
|
||
2099 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
209b : 68 > pla ;load status
|
||
209c : 48 > pha
|
||
> cmp_flag $ff
|
||
209d : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
209f : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
20a1 : 28 > plp ;restore status
|
||
>
|
||
20a2 : a50a > lda zpt
|
||
20a4 : c904 > cmp #1<<2
|
||
> trap_ne ;wrong bits set or cleared
|
||
20a6 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
smbt 3
|
||
20a8 : a9f7 > lda #$ff-(1<<3)
|
||
20aa : 850a > sta zpt
|
||
> set_a $a5,0
|
||
> load_flag 0
|
||
20ac : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
20ae : 48 > pha ;use stack to load status
|
||
20af : a9a5 > lda #$a5 ;precharge accu
|
||
20b1 : 28 > plp
|
||
>
|
||
20b2 : b70a > smb 3,zpt
|
||
> tst_a $a5,0
|
||
20b4 : 08 > php ;save flags
|
||
20b5 : c9a5 > cmp #$a5 ;test result
|
||
> trap_ne
|
||
20b7 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
20b9 : 68 > pla ;load status
|
||
20ba : 48 > pha
|
||
> cmp_flag 0
|
||
20bb : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
20bd : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
20bf : 28 > plp ;restore status
|
||
>
|
||
20c0 : a50a > lda zpt
|
||
20c2 : c9ff > cmp #$ff
|
||
> trap_ne ;wrong bits set or cleared
|
||
20c4 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
20c6 : a900 > lda #0
|
||
20c8 : 850a > sta zpt
|
||
> set_a $5a,$ff
|
||
> load_flag $ff
|
||
20ca : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
20cc : 48 > pha ;use stack to load status
|
||
20cd : a95a > lda #$5a ;precharge accu
|
||
20cf : 28 > plp
|
||
>
|
||
20d0 : b70a > smb 3,zpt
|
||
> tst_a $5a,$ff
|
||
20d2 : 08 > php ;save flags
|
||
20d3 : c95a > cmp #$5a ;test result
|
||
> trap_ne
|
||
20d5 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
20d7 : 68 > pla ;load status
|
||
20d8 : 48 > pha
|
||
> cmp_flag $ff
|
||
20d9 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
20db : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
20dd : 28 > plp ;restore status
|
||
>
|
||
20de : a50a > lda zpt
|
||
20e0 : c908 > cmp #1<<3
|
||
> trap_ne ;wrong bits set or cleared
|
||
20e2 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
smbt 4
|
||
20e4 : a9ef > lda #$ff-(1<<4)
|
||
20e6 : 850a > sta zpt
|
||
> set_a $a5,0
|
||
> load_flag 0
|
||
20e8 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
20ea : 48 > pha ;use stack to load status
|
||
20eb : a9a5 > lda #$a5 ;precharge accu
|
||
20ed : 28 > plp
|
||
>
|
||
20ee : c70a > smb 4,zpt
|
||
> tst_a $a5,0
|
||
20f0 : 08 > php ;save flags
|
||
20f1 : c9a5 > cmp #$a5 ;test result
|
||
> trap_ne
|
||
20f3 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
20f5 : 68 > pla ;load status
|
||
20f6 : 48 > pha
|
||
> cmp_flag 0
|
||
20f7 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
20f9 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
20fb : 28 > plp ;restore status
|
||
>
|
||
20fc : a50a > lda zpt
|
||
20fe : c9ff > cmp #$ff
|
||
> trap_ne ;wrong bits set or cleared
|
||
2100 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
2102 : a900 > lda #0
|
||
2104 : 850a > sta zpt
|
||
> set_a $5a,$ff
|
||
> load_flag $ff
|
||
2106 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
2108 : 48 > pha ;use stack to load status
|
||
2109 : a95a > lda #$5a ;precharge accu
|
||
210b : 28 > plp
|
||
>
|
||
210c : c70a > smb 4,zpt
|
||
> tst_a $5a,$ff
|
||
210e : 08 > php ;save flags
|
||
210f : c95a > cmp #$5a ;test result
|
||
> trap_ne
|
||
2111 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
2113 : 68 > pla ;load status
|
||
2114 : 48 > pha
|
||
> cmp_flag $ff
|
||
2115 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
2117 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
2119 : 28 > plp ;restore status
|
||
>
|
||
211a : a50a > lda zpt
|
||
211c : c910 > cmp #1<<4
|
||
> trap_ne ;wrong bits set or cleared
|
||
211e : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
smbt 5
|
||
2120 : a9df > lda #$ff-(1<<5)
|
||
2122 : 850a > sta zpt
|
||
> set_a $a5,0
|
||
> load_flag 0
|
||
2124 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
2126 : 48 > pha ;use stack to load status
|
||
2127 : a9a5 > lda #$a5 ;precharge accu
|
||
2129 : 28 > plp
|
||
>
|
||
212a : d70a > smb 5,zpt
|
||
> tst_a $a5,0
|
||
212c : 08 > php ;save flags
|
||
212d : c9a5 > cmp #$a5 ;test result
|
||
> trap_ne
|
||
212f : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
2131 : 68 > pla ;load status
|
||
2132 : 48 > pha
|
||
> cmp_flag 0
|
||
2133 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
2135 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
2137 : 28 > plp ;restore status
|
||
>
|
||
2138 : a50a > lda zpt
|
||
213a : c9ff > cmp #$ff
|
||
> trap_ne ;wrong bits set or cleared
|
||
213c : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
213e : a900 > lda #0
|
||
2140 : 850a > sta zpt
|
||
> set_a $5a,$ff
|
||
> load_flag $ff
|
||
2142 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
2144 : 48 > pha ;use stack to load status
|
||
2145 : a95a > lda #$5a ;precharge accu
|
||
2147 : 28 > plp
|
||
>
|
||
2148 : d70a > smb 5,zpt
|
||
> tst_a $5a,$ff
|
||
214a : 08 > php ;save flags
|
||
214b : c95a > cmp #$5a ;test result
|
||
> trap_ne
|
||
214d : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
214f : 68 > pla ;load status
|
||
2150 : 48 > pha
|
||
> cmp_flag $ff
|
||
2151 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
2153 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
2155 : 28 > plp ;restore status
|
||
>
|
||
2156 : a50a > lda zpt
|
||
2158 : c920 > cmp #1<<5
|
||
> trap_ne ;wrong bits set or cleared
|
||
215a : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
smbt 6
|
||
215c : a9bf > lda #$ff-(1<<6)
|
||
215e : 850a > sta zpt
|
||
> set_a $a5,0
|
||
> load_flag 0
|
||
2160 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
2162 : 48 > pha ;use stack to load status
|
||
2163 : a9a5 > lda #$a5 ;precharge accu
|
||
2165 : 28 > plp
|
||
>
|
||
2166 : e70a > smb 6,zpt
|
||
> tst_a $a5,0
|
||
2168 : 08 > php ;save flags
|
||
2169 : c9a5 > cmp #$a5 ;test result
|
||
> trap_ne
|
||
216b : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
216d : 68 > pla ;load status
|
||
216e : 48 > pha
|
||
> cmp_flag 0
|
||
216f : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
2171 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
2173 : 28 > plp ;restore status
|
||
>
|
||
2174 : a50a > lda zpt
|
||
2176 : c9ff > cmp #$ff
|
||
> trap_ne ;wrong bits set or cleared
|
||
2178 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
217a : a900 > lda #0
|
||
217c : 850a > sta zpt
|
||
> set_a $5a,$ff
|
||
> load_flag $ff
|
||
217e : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
2180 : 48 > pha ;use stack to load status
|
||
2181 : a95a > lda #$5a ;precharge accu
|
||
2183 : 28 > plp
|
||
>
|
||
2184 : e70a > smb 6,zpt
|
||
> tst_a $5a,$ff
|
||
2186 : 08 > php ;save flags
|
||
2187 : c95a > cmp #$5a ;test result
|
||
> trap_ne
|
||
2189 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
218b : 68 > pla ;load status
|
||
218c : 48 > pha
|
||
> cmp_flag $ff
|
||
218d : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
218f : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
2191 : 28 > plp ;restore status
|
||
>
|
||
2192 : a50a > lda zpt
|
||
2194 : c940 > cmp #1<<6
|
||
> trap_ne ;wrong bits set or cleared
|
||
2196 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
smbt 7
|
||
2198 : a97f > lda #$ff-(1<<7)
|
||
219a : 850a > sta zpt
|
||
> set_a $a5,0
|
||
> load_flag 0
|
||
219c : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
219e : 48 > pha ;use stack to load status
|
||
219f : a9a5 > lda #$a5 ;precharge accu
|
||
21a1 : 28 > plp
|
||
>
|
||
21a2 : f70a > smb 7,zpt
|
||
> tst_a $a5,0
|
||
21a4 : 08 > php ;save flags
|
||
21a5 : c9a5 > cmp #$a5 ;test result
|
||
> trap_ne
|
||
21a7 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
21a9 : 68 > pla ;load status
|
||
21aa : 48 > pha
|
||
> cmp_flag 0
|
||
21ab : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
21ad : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
21af : 28 > plp ;restore status
|
||
>
|
||
21b0 : a50a > lda zpt
|
||
21b2 : c9ff > cmp #$ff
|
||
> trap_ne ;wrong bits set or cleared
|
||
21b4 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
21b6 : a900 > lda #0
|
||
21b8 : 850a > sta zpt
|
||
> set_a $5a,$ff
|
||
> load_flag $ff
|
||
21ba : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
21bc : 48 > pha ;use stack to load status
|
||
21bd : a95a > lda #$5a ;precharge accu
|
||
21bf : 28 > plp
|
||
>
|
||
21c0 : f70a > smb 7,zpt
|
||
> tst_a $5a,$ff
|
||
21c2 : 08 > php ;save flags
|
||
21c3 : c95a > cmp #$5a ;test result
|
||
> trap_ne
|
||
21c5 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
21c7 : 68 > pla ;load status
|
||
21c8 : 48 > pha
|
||
> cmp_flag $ff
|
||
21c9 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
21cb : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
21cd : 28 > plp ;restore status
|
||
>
|
||
21ce : a50a > lda zpt
|
||
21d0 : c980 > cmp #1<<7
|
||
> trap_ne ;wrong bits set or cleared
|
||
21d2 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
21d4 : e0ba cpx #$ba
|
||
trap_ne ;x altered during test
|
||
21d6 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
21d8 : c0d0 cpy #$d0
|
||
trap_ne ;y altered during test
|
||
21da : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
21dc : ba tsx
|
||
21dd : e0ff cpx #$ff
|
||
trap_ne ;sp push/pop mismatch
|
||
21df : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
next_test
|
||
21e1 : ad0202 > lda test_case ;previous test
|
||
21e4 : c911 > cmp #test_num
|
||
> trap_ne ;test is out of sequence
|
||
21e6 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0012 = >test_num = test_num + 1
|
||
21e8 : a912 > lda #test_num ;*** next tests' number
|
||
21ea : 8d0202 > sta test_case
|
||
> ;check_ram ;uncomment to find altered RAM after each test
|
||
|
||
endif
|
||
|
||
; testing CMP - (zp)
|
||
21ed : a2de ldx #$de ;protect x & y
|
||
21ef : a0ad ldy #$ad
|
||
set_a $80,0
|
||
> load_flag 0
|
||
21f1 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
21f3 : 48 > pha ;use stack to load status
|
||
21f4 : a980 > lda #$80 ;precharge accu
|
||
21f6 : 28 > plp
|
||
|
||
21f7 : d22a cmp (ind1+8)
|
||
tst_a $80,fc
|
||
21f9 : 08 > php ;save flags
|
||
21fa : c980 > cmp #$80 ;test result
|
||
> trap_ne
|
||
21fc : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
21fe : 68 > pla ;load status
|
||
21ff : 48 > pha
|
||
> cmp_flag fc
|
||
2200 : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
2202 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
2204 : 28 > plp ;restore status
|
||
|
||
set_a $7f,0
|
||
> load_flag 0
|
||
2205 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
2207 : 48 > pha ;use stack to load status
|
||
2208 : a97f > lda #$7f ;precharge accu
|
||
220a : 28 > plp
|
||
|
||
220b : d22a cmp (ind1+8)
|
||
tst_a $7f,fzc
|
||
220d : 08 > php ;save flags
|
||
220e : c97f > cmp #$7f ;test result
|
||
> trap_ne
|
||
2210 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
2212 : 68 > pla ;load status
|
||
2213 : 48 > pha
|
||
> cmp_flag fzc
|
||
2214 : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
2216 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
2218 : 28 > plp ;restore status
|
||
|
||
set_a $7e,0
|
||
> load_flag 0
|
||
2219 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
221b : 48 > pha ;use stack to load status
|
||
221c : a97e > lda #$7e ;precharge accu
|
||
221e : 28 > plp
|
||
|
||
221f : d22a cmp (ind1+8)
|
||
tst_a $7e,fn
|
||
2221 : 08 > php ;save flags
|
||
2222 : c97e > cmp #$7e ;test result
|
||
> trap_ne
|
||
2224 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
2226 : 68 > pla ;load status
|
||
2227 : 48 > pha
|
||
> cmp_flag fn
|
||
2228 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
222a : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
222c : 28 > plp ;restore status
|
||
|
||
set_a $80,$ff
|
||
> load_flag $ff
|
||
222d : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
222f : 48 > pha ;use stack to load status
|
||
2230 : a980 > lda #$80 ;precharge accu
|
||
2232 : 28 > plp
|
||
|
||
2233 : d22a cmp (ind1+8)
|
||
tst_a $80,~fnz
|
||
2235 : 08 > php ;save flags
|
||
2236 : c980 > cmp #$80 ;test result
|
||
> trap_ne
|
||
2238 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
223a : 68 > pla ;load status
|
||
223b : 48 > pha
|
||
> cmp_flag ~fnz
|
||
223c : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
223e : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
2240 : 28 > plp ;restore status
|
||
|
||
set_a $7f,$ff
|
||
> load_flag $ff
|
||
2241 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
2243 : 48 > pha ;use stack to load status
|
||
2244 : a97f > lda #$7f ;precharge accu
|
||
2246 : 28 > plp
|
||
|
||
2247 : d22a cmp (ind1+8)
|
||
tst_a $7f,~fn
|
||
2249 : 08 > php ;save flags
|
||
224a : c97f > cmp #$7f ;test result
|
||
> trap_ne
|
||
224c : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
224e : 68 > pla ;load status
|
||
224f : 48 > pha
|
||
> cmp_flag ~fn
|
||
2250 : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
2252 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
2254 : 28 > plp ;restore status
|
||
|
||
set_a $7e,$ff
|
||
> load_flag $ff
|
||
2255 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
2257 : 48 > pha ;use stack to load status
|
||
2258 : a97e > lda #$7e ;precharge accu
|
||
225a : 28 > plp
|
||
|
||
225b : d22a cmp (ind1+8)
|
||
tst_a $7e,~fzc
|
||
225d : 08 > php ;save flags
|
||
225e : c97e > cmp #$7e ;test result
|
||
> trap_ne
|
||
2260 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
2262 : 68 > pla ;load status
|
||
2263 : 48 > pha
|
||
> cmp_flag ~fzc
|
||
2264 : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits
|
||
>
|
||
> trap_ne
|
||
2266 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
2268 : 28 > plp ;restore status
|
||
|
||
2269 : e0de cpx #$de
|
||
trap_ne ;x altered during test
|
||
226b : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
226d : c0ad cpy #$ad
|
||
trap_ne ;y altered during test
|
||
226f : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
2271 : ba tsx
|
||
2272 : e0ff cpx #$ff
|
||
trap_ne ;sp push/pop mismatch
|
||
2274 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
next_test
|
||
2276 : ad0202 > lda test_case ;previous test
|
||
2279 : c912 > cmp #test_num
|
||
> trap_ne ;test is out of sequence
|
||
227b : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0013 = >test_num = test_num + 1
|
||
227d : a913 > lda #test_num ;*** next tests' number
|
||
227f : 8d0202 > sta test_case
|
||
> ;check_ram ;uncomment to find altered RAM after each test
|
||
|
||
|
||
; testing logical instructions - AND EOR ORA (zp)
|
||
2282 : a242 ldx #$42 ;protect x & y
|
||
|
||
2284 : a000 ldy #0 ;AND
|
||
2286 : a538 lda indAN ;set indirect address
|
||
2288 : 850a sta zpt
|
||
228a : a539 lda indAN+1
|
||
228c : 850b sta zpt+1
|
||
228e : tand1
|
||
set_ay absANa,0
|
||
> load_flag 0
|
||
228e : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
2290 : 48 > pha ;use stack to load status
|
||
2291 : b94d02 > lda absANa,y ;precharge accu
|
||
2294 : 28 > plp
|
||
|
||
2295 : 320a and (zpt)
|
||
tst_ay absrlo,absflo,0
|
||
2297 : 08 > php ;save flags
|
||
2298 : d95502 > cmp absrlo,y ;test result
|
||
> trap_ne ;
|
||
229b : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
229d : 68 > pla ;load status
|
||
> eor_flag 0
|
||
229e : 4930 > eor #0|fao ;invert expected flags + always on bits
|
||
>
|
||
22a0 : d95902 > cmp absflo,y ;test flags
|
||
> trap_ne
|
||
22a3 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
22a5 : e60a inc zpt
|
||
22a7 : c8 iny
|
||
22a8 : c004 cpy #4
|
||
22aa : d0e2 bne tand1
|
||
22ac : 88 dey
|
||
22ad : c60a dec zpt
|
||
22af : tand2
|
||
set_ay absANa,$ff
|
||
> load_flag $ff
|
||
22af : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
22b1 : 48 > pha ;use stack to load status
|
||
22b2 : b94d02 > lda absANa,y ;precharge accu
|
||
22b5 : 28 > plp
|
||
|
||
22b6 : 320a and (zpt)
|
||
tst_ay absrlo,absflo,$ff-fnz
|
||
22b8 : 08 > php ;save flags
|
||
22b9 : d95502 > cmp absrlo,y ;test result
|
||
> trap_ne ;
|
||
22bc : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
22be : 68 > pla ;load status
|
||
> eor_flag $ff-fnz
|
||
22bf : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
|
||
>
|
||
22c1 : d95902 > cmp absflo,y ;test flags
|
||
> trap_ne
|
||
22c4 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
22c6 : c60a dec zpt
|
||
22c8 : 88 dey
|
||
22c9 : 10e4 bpl tand2
|
||
|
||
22cb : a000 ldy #0 ;EOR
|
||
22cd : a540 lda indEO ;set indirect address
|
||
22cf : 850a sta zpt
|
||
22d1 : a541 lda indEO+1
|
||
22d3 : 850b sta zpt+1
|
||
22d5 : teor1
|
||
set_ay absEOa,0
|
||
> load_flag 0
|
||
22d5 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
22d7 : 48 > pha ;use stack to load status
|
||
22d8 : b95102 > lda absEOa,y ;precharge accu
|
||
22db : 28 > plp
|
||
|
||
22dc : 520a eor (zpt)
|
||
tst_ay absrlo,absflo,0
|
||
22de : 08 > php ;save flags
|
||
22df : d95502 > cmp absrlo,y ;test result
|
||
> trap_ne ;
|
||
22e2 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
22e4 : 68 > pla ;load status
|
||
> eor_flag 0
|
||
22e5 : 4930 > eor #0|fao ;invert expected flags + always on bits
|
||
>
|
||
22e7 : d95902 > cmp absflo,y ;test flags
|
||
> trap_ne
|
||
22ea : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
22ec : e60a inc zpt
|
||
22ee : c8 iny
|
||
22ef : c004 cpy #4
|
||
22f1 : d0e2 bne teor1
|
||
22f3 : 88 dey
|
||
22f4 : c60a dec zpt
|
||
22f6 : teor2
|
||
set_ay absEOa,$ff
|
||
> load_flag $ff
|
||
22f6 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
22f8 : 48 > pha ;use stack to load status
|
||
22f9 : b95102 > lda absEOa,y ;precharge accu
|
||
22fc : 28 > plp
|
||
|
||
22fd : 520a eor (zpt)
|
||
tst_ay absrlo,absflo,$ff-fnz
|
||
22ff : 08 > php ;save flags
|
||
2300 : d95502 > cmp absrlo,y ;test result
|
||
> trap_ne ;
|
||
2303 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
2305 : 68 > pla ;load status
|
||
> eor_flag $ff-fnz
|
||
2306 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
|
||
>
|
||
2308 : d95902 > cmp absflo,y ;test flags
|
||
> trap_ne
|
||
230b : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
230d : c60a dec zpt
|
||
230f : 88 dey
|
||
2310 : 10e4 bpl teor2
|
||
|
||
2312 : a000 ldy #0 ;ORA
|
||
2314 : a548 lda indOR ;set indirect address
|
||
2316 : 850a sta zpt
|
||
2318 : a549 lda indOR+1
|
||
231a : 850b sta zpt+1
|
||
231c : tora1
|
||
set_ay absORa,0
|
||
> load_flag 0
|
||
231c : a900 > lda #0 ;allow test to change I-flag (no mask)
|
||
>
|
||
231e : 48 > pha ;use stack to load status
|
||
231f : b94902 > lda absORa,y ;precharge accu
|
||
2322 : 28 > plp
|
||
|
||
2323 : 120a ora (zpt)
|
||
tst_ay absrlo,absflo,0
|
||
2325 : 08 > php ;save flags
|
||
2326 : d95502 > cmp absrlo,y ;test result
|
||
> trap_ne ;
|
||
2329 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
232b : 68 > pla ;load status
|
||
> eor_flag 0
|
||
232c : 4930 > eor #0|fao ;invert expected flags + always on bits
|
||
>
|
||
232e : d95902 > cmp absflo,y ;test flags
|
||
> trap_ne
|
||
2331 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
2333 : e60a inc zpt
|
||
2335 : c8 iny
|
||
2336 : c004 cpy #4
|
||
2338 : d0e2 bne tora1
|
||
233a : 88 dey
|
||
233b : c60a dec zpt
|
||
233d : tora2
|
||
set_ay absORa,$ff
|
||
> load_flag $ff
|
||
233d : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
233f : 48 > pha ;use stack to load status
|
||
2340 : b94902 > lda absORa,y ;precharge accu
|
||
2343 : 28 > plp
|
||
|
||
2344 : 120a ora (zpt)
|
||
tst_ay absrlo,absflo,$ff-fnz
|
||
2346 : 08 > php ;save flags
|
||
2347 : d95502 > cmp absrlo,y ;test result
|
||
> trap_ne ;
|
||
234a : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
234c : 68 > pla ;load status
|
||
> eor_flag $ff-fnz
|
||
234d : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
|
||
>
|
||
234f : d95902 > cmp absflo,y ;test flags
|
||
> trap_ne
|
||
2352 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
|
||
2354 : c60a dec zpt
|
||
2356 : 88 dey
|
||
2357 : 10e4 bpl tora2
|
||
|
||
2359 : e042 cpx #$42
|
||
trap_ne ;x altered during test
|
||
235b : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
235d : ba tsx
|
||
235e : e0ff cpx #$ff
|
||
trap_ne ;sp push/pop mismatch
|
||
2360 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
next_test
|
||
2362 : ad0202 > lda test_case ;previous test
|
||
2365 : c913 > cmp #test_num
|
||
> trap_ne ;test is out of sequence
|
||
2367 : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0014 = >test_num = test_num + 1
|
||
2369 : a914 > lda #test_num ;*** next tests' number
|
||
236b : 8d0202 > sta test_case
|
||
> ;check_ram ;uncomment to find altered RAM after each test
|
||
|
||
|
||
if I_flag = 3
|
||
236e : 58 cli
|
||
endif
|
||
|
||
; full binary add/subtract test - (zp) only
|
||
; iterates through all combinations of operands and carry input
|
||
; uses increments/decrements to predict result & result flags
|
||
236f : d8 cld
|
||
2370 : a20c ldx #ad2 ;for indexed test
|
||
2372 : a0ff ldy #$ff ;max range
|
||
2374 : a900 lda #0 ;start with adding zeroes & no carry
|
||
2376 : 850a sta adfc ;carry in - for diag
|
||
2378 : 850b sta ad1 ;operand 1 - accumulator
|
||
237a : 850c sta ad2 ;operand 2 - memory or immediate
|
||
237c : 8d0502 sta ada2 ;non zp
|
||
237f : 850d sta adrl ;expected result bits 0-7
|
||
2381 : 850e sta adrh ;expected result bit 8 (carry out)
|
||
2383 : a9ff lda #$ff ;complemented operand 2 for subtract
|
||
2385 : 8510 sta sb2
|
||
2387 : 8d0602 sta sba2 ;non zp
|
||
238a : a902 lda #2 ;expected Z-flag
|
||
238c : 850f sta adrf
|
||
238e : 18 tadd clc ;test with carry clear
|
||
238f : 200326 jsr chkadd
|
||
2392 : e60a inc adfc ;now with carry
|
||
2394 : e60d inc adrl ;result +1
|
||
2396 : 08 php ;save N & Z from low result
|
||
2397 : 08 php
|
||
2398 : 68 pla ;accu holds expected flags
|
||
2399 : 2982 and #$82 ;mask N & Z
|
||
239b : 28 plp
|
||
239c : d002 bne tadd1
|
||
239e : e60e inc adrh ;result bit 8 - carry
|
||
23a0 : 050e tadd1 ora adrh ;merge C to expected flags
|
||
23a2 : 850f sta adrf ;save expected flags except overflow
|
||
23a4 : 38 sec ;test with carry set
|
||
23a5 : 200326 jsr chkadd
|
||
23a8 : c60a dec adfc ;same for operand +1 but no carry
|
||
23aa : e60b inc ad1
|
||
23ac : d0e0 bne tadd ;iterate op1
|
||
23ae : a900 lda #0 ;preset result to op2 when op1 = 0
|
||
23b0 : 850e sta adrh
|
||
23b2 : ee0502 inc ada2
|
||
23b5 : e60c inc ad2
|
||
23b7 : 08 php ;save NZ as operand 2 becomes the new result
|
||
23b8 : 68 pla
|
||
23b9 : 2982 and #$82 ;mask N00000Z0
|
||
23bb : 850f sta adrf ;no need to check carry as we are adding to 0
|
||
23bd : c610 dec sb2 ;complement subtract operand 2
|
||
23bf : ce0602 dec sba2
|
||
23c2 : a50c lda ad2
|
||
23c4 : 850d sta adrl
|
||
23c6 : d0c6 bne tadd ;iterate op2
|
||
|
||
23c8 : e00c cpx #ad2
|
||
trap_ne ;x altered during test
|
||
23ca : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
23cc : c0ff cpy #$ff
|
||
trap_ne ;y altered during test
|
||
23ce : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
23d0 : ba tsx
|
||
23d1 : e0ff cpx #$ff
|
||
trap_ne ;sp push/pop mismatch
|
||
23d3 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
next_test
|
||
23d5 : ad0202 > lda test_case ;previous test
|
||
23d8 : c914 > cmp #test_num
|
||
> trap_ne ;test is out of sequence
|
||
23da : d0fe > bne * ;failed not equal (non zero)
|
||
>
|
||
0015 = >test_num = test_num + 1
|
||
23dc : a915 > lda #test_num ;*** next tests' number
|
||
23de : 8d0202 > sta test_case
|
||
> ;check_ram ;uncomment to find altered RAM after each test
|
||
|
||
|
||
; decimal add/subtract test
|
||
; *** WARNING - tests documented behavior only! ***
|
||
; only valid BCD operands are tested, the V flag is ignored
|
||
; although V is declared as beeing valid on the 65C02 it has absolutely
|
||
; no use in BCD math. No sign = no overflow!
|
||
; iterates through all valid combinations of operands and carry input
|
||
; uses increments/decrements to predict result & carry flag
|
||
23e1 : f8 sed
|
||
23e2 : a20c ldx #ad2 ;for indexed test
|
||
23e4 : a0ff ldy #$ff ;max range
|
||
23e6 : a999 lda #$99 ;start with adding 99 to 99 with carry
|
||
23e8 : 850b sta ad1 ;operand 1 - accumulator
|
||
23ea : 850c sta ad2 ;operand 2 - memory or immediate
|
||
23ec : 8d0502 sta ada2 ;non zp
|
||
23ef : 850d sta adrl ;expected result bits 0-7
|
||
23f1 : a901 lda #1 ;set carry in & out
|
||
23f3 : 850a sta adfc ;carry in - for diag
|
||
23f5 : 850e sta adrh ;expected result bit 8 (carry out)
|
||
23f7 : a981 lda #$81 ;set N & C (99 + 99 + C = 99 + C)
|
||
23f9 : 850f sta adrf
|
||
23fb : a900 lda #0 ;complemented operand 2 for subtract
|
||
23fd : 8510 sta sb2
|
||
23ff : 8d0602 sta sba2 ;non zp
|
||
2402 : 38 tdad sec ;test with carry set
|
||
2403 : 20ae24 jsr chkdad
|
||
2406 : c60a dec adfc ;now with carry clear
|
||
2408 : a50d lda adrl ;decimal adjust result
|
||
240a : d008 bne tdad1 ;skip clear carry & preset result 99 (9A-1)
|
||
240c : c60e dec adrh
|
||
240e : a999 lda #$99
|
||
2410 : 850d sta adrl
|
||
2412 : d012 bne tdad3
|
||
2414 : 290f tdad1 and #$f ;lower nibble mask
|
||
2416 : d00c bne tdad2 ;no decimal adjust needed
|
||
2418 : c60d dec adrl ;decimal adjust (?0-6)
|
||
241a : c60d dec adrl
|
||
241c : c60d dec adrl
|
||
241e : c60d dec adrl
|
||
2420 : c60d dec adrl
|
||
2422 : c60d dec adrl
|
||
2424 : c60d tdad2 dec adrl ;result -1
|
||
2426 : 08 tdad3 php ;save valid flags
|
||
2427 : 68 pla
|
||
2428 : 2982 and #$82 ;N-----Z-
|
||
242a : 050e ora adrh ;N-----ZC
|
||
242c : 850f sta adrf
|
||
242e : 18 clc ;test with carry clear
|
||
242f : 20ae24 jsr chkdad
|
||
2432 : e60a inc adfc ;same for operand -1 but with carry
|
||
2434 : a50b lda ad1 ;decimal adjust operand 1
|
||
2436 : f015 beq tdad5 ;iterate operand 2
|
||
2438 : 290f and #$f ;lower nibble mask
|
||
243a : d00c bne tdad4 ;skip decimal adjust
|
||
243c : c60b dec ad1 ;decimal adjust (?0-6)
|
||
243e : c60b dec ad1
|
||
2440 : c60b dec ad1
|
||
2442 : c60b dec ad1
|
||
2444 : c60b dec ad1
|
||
2446 : c60b dec ad1
|
||
2448 : c60b tdad4 dec ad1 ;operand 1 -1
|
||
244a : 4c0224 jmp tdad ;iterate op1
|
||
|
||
244d : a999 tdad5 lda #$99 ;precharge op1 max
|
||
244f : 850b sta ad1
|
||
2451 : a50c lda ad2 ;decimal adjust operand 2
|
||
2453 : f039 beq tdad7 ;end of iteration
|
||
2455 : 290f and #$f ;lower nibble mask
|
||
2457 : d018 bne tdad6 ;skip decimal adjust
|
||
2459 : c60c dec ad2 ;decimal adjust (?0-6)
|
||
245b : c60c dec ad2
|
||
245d : c60c dec ad2
|
||
245f : c60c dec ad2
|
||
2461 : c60c dec ad2
|
||
2463 : c60c dec ad2
|
||
2465 : e610 inc sb2 ;complemented decimal adjust for subtract (?9+6)
|
||
2467 : e610 inc sb2
|
||
2469 : e610 inc sb2
|
||
246b : e610 inc sb2
|
||
246d : e610 inc sb2
|
||
246f : e610 inc sb2
|
||
2471 : c60c tdad6 dec ad2 ;operand 2 -1
|
||
2473 : e610 inc sb2 ;complemented operand for subtract
|
||
2475 : a510 lda sb2
|
||
2477 : 8d0602 sta sba2 ;copy as non zp operand
|
||
247a : a50c lda ad2
|
||
247c : 8d0502 sta ada2 ;copy as non zp operand
|
||
247f : 850d sta adrl ;new result since op1+carry=00+carry +op2=op2
|
||
2481 : 08 php ;save flags
|
||
2482 : 68 pla
|
||
2483 : 2982 and #$82 ;N-----Z-
|
||
2485 : 0901 ora #1 ;N-----ZC
|
||
2487 : 850f sta adrf
|
||
2489 : e60e inc adrh ;result carry
|
||
248b : 4c0224 jmp tdad ;iterate op2
|
||
|
||
248e : e00c tdad7 cpx #ad2
|
||
trap_ne ;x altered during test
|
||
2490 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
2492 : c0ff cpy #$ff
|
||
trap_ne ;y altered during test
|
||
2494 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
2496 : ba tsx
|
||
2497 : e0ff cpx #$ff
|
||
trap_ne ;sp push/pop mismatch
|
||
2499 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
249b : d8 cld
|
||
|
||
249c : ad0202 lda test_case
|
||
249f : c915 cmp #test_num
|
||
trap_ne ;previous test is out of sequence
|
||
24a1 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
24a3 : a9f0 lda #$f0 ;mark opcode testing complete
|
||
24a5 : 8d0202 sta test_case
|
||
|
||
; final RAM integrity test
|
||
; verifies that none of the previous tests has altered RAM outside of the
|
||
; designated write areas.
|
||
check_ram
|
||
> ;RAM check disabled - RAM size not set
|
||
|
||
; *** DEBUG INFO ***
|
||
; to debug checksum errors uncomment check_ram in the next_test macro to
|
||
; narrow down the responsible opcode.
|
||
; may give false errors when monitor, OS or other background activity is
|
||
; allowed during previous tests.
|
||
|
||
|
||
; S U C C E S S ************************************************
|
||
; -------------
|
||
success ;if you get here everything went well
|
||
24a8 : 4ca824 > jmp * ;test passed, no errors
|
||
|
||
; -------------
|
||
; S U C C E S S ************************************************
|
||
24ab : 4c0004 jmp start ;run again
|
||
|
||
; core subroutine of the decimal add/subtract test
|
||
; *** WARNING - tests documented behavior only! ***
|
||
; only valid BCD operands are tested, V flag is ignored
|
||
; iterates through all valid combinations of operands and carry input
|
||
; uses increments/decrements to predict result & carry flag
|
||
24ae : chkdad
|
||
; decimal ADC / SBC zp
|
||
24ae : 08 php ;save carry for subtract
|
||
24af : a50b lda ad1
|
||
24b1 : 650c adc ad2 ;perform add
|
||
24b3 : 08 php
|
||
24b4 : c50d cmp adrl ;check result
|
||
trap_ne ;bad result
|
||
24b6 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
24b8 : 68 pla ;check flags
|
||
24b9 : 2983 and #$83 ;mask N-----ZC
|
||
24bb : c50f cmp adrf
|
||
trap_ne ;bad flags
|
||
24bd : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
24bf : 28 plp
|
||
24c0 : 08 php ;save carry for next add
|
||
24c1 : a50b lda ad1
|
||
24c3 : e510 sbc sb2 ;perform subtract
|
||
24c5 : 08 php
|
||
24c6 : c50d cmp adrl ;check result
|
||
trap_ne ;bad result
|
||
24c8 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
24ca : 68 pla ;check flags
|
||
24cb : 2983 and #$83 ;mask N-----ZC
|
||
24cd : c50f cmp adrf
|
||
trap_ne ;bad flags
|
||
24cf : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
24d1 : 28 plp
|
||
; decimal ADC / SBC abs
|
||
24d2 : 08 php ;save carry for subtract
|
||
24d3 : a50b lda ad1
|
||
24d5 : 6d0502 adc ada2 ;perform add
|
||
24d8 : 08 php
|
||
24d9 : c50d cmp adrl ;check result
|
||
trap_ne ;bad result
|
||
24db : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
24dd : 68 pla ;check flags
|
||
24de : 2983 and #$83 ;mask N-----ZC
|
||
24e0 : c50f cmp adrf
|
||
trap_ne ;bad flags
|
||
24e2 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
24e4 : 28 plp
|
||
24e5 : 08 php ;save carry for next add
|
||
24e6 : a50b lda ad1
|
||
24e8 : ed0602 sbc sba2 ;perform subtract
|
||
24eb : 08 php
|
||
24ec : c50d cmp adrl ;check result
|
||
trap_ne ;bad result
|
||
24ee : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
24f0 : 68 pla ;check flags
|
||
24f1 : 2983 and #$83 ;mask N-----ZC
|
||
24f3 : c50f cmp adrf
|
||
trap_ne ;bad flags
|
||
24f5 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
24f7 : 28 plp
|
||
; decimal ADC / SBC #
|
||
24f8 : 08 php ;save carry for subtract
|
||
24f9 : a50c lda ad2
|
||
24fb : 8d0125 sta chkdadi ;self modify immediate
|
||
24fe : a50b lda ad1
|
||
2501 = chkdadi = * + 1 ;operand of the immediate ADC
|
||
2500 : 6900 adc #0 ;perform add
|
||
2502 : 08 php
|
||
2503 : c50d cmp adrl ;check result
|
||
trap_ne ;bad result
|
||
2505 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
2507 : 68 pla ;check flags
|
||
2508 : 2983 and #$83 ;mask N-----ZC
|
||
250a : c50f cmp adrf
|
||
trap_ne ;bad flags
|
||
250c : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
250e : 28 plp
|
||
250f : 08 php ;save carry for next add
|
||
2510 : a510 lda sb2
|
||
2512 : 8d1825 sta chkdsbi ;self modify immediate
|
||
2515 : a50b lda ad1
|
||
2518 = chkdsbi = * + 1 ;operand of the immediate SBC
|
||
2517 : e900 sbc #0 ;perform subtract
|
||
2519 : 08 php
|
||
251a : c50d cmp adrl ;check result
|
||
trap_ne ;bad result
|
||
251c : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
251e : 68 pla ;check flags
|
||
251f : 2983 and #$83 ;mask N-----ZC
|
||
2521 : c50f cmp adrf
|
||
trap_ne ;bad flags
|
||
2523 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
2525 : 28 plp
|
||
; decimal ADC / SBC zp,x
|
||
2526 : 08 php ;save carry for subtract
|
||
2527 : a50b lda ad1
|
||
2529 : 7500 adc 0,x ;perform add
|
||
252b : 08 php
|
||
252c : c50d cmp adrl ;check result
|
||
trap_ne ;bad result
|
||
252e : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
2530 : 68 pla ;check flags
|
||
2531 : 2983 and #$83 ;mask N-----ZC
|
||
2533 : c50f cmp adrf
|
||
trap_ne ;bad flags
|
||
2535 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
2537 : 28 plp
|
||
2538 : 08 php ;save carry for next add
|
||
2539 : a50b lda ad1
|
||
253b : f504 sbc sb2-ad2,x ;perform subtract
|
||
253d : 08 php
|
||
253e : c50d cmp adrl ;check result
|
||
trap_ne ;bad result
|
||
2540 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
2542 : 68 pla ;check flags
|
||
2543 : 2983 and #$83 ;mask N-----ZC
|
||
2545 : c50f cmp adrf
|
||
trap_ne ;bad flags
|
||
2547 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
2549 : 28 plp
|
||
; decimal ADC / SBC abs,x
|
||
254a : 08 php ;save carry for subtract
|
||
254b : a50b lda ad1
|
||
254d : 7df901 adc ada2-ad2,x ;perform add
|
||
2550 : 08 php
|
||
2551 : c50d cmp adrl ;check result
|
||
trap_ne ;bad result
|
||
2553 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
2555 : 68 pla ;check flags
|
||
2556 : 2983 and #$83 ;mask N-----ZC
|
||
2558 : c50f cmp adrf
|
||
trap_ne ;bad flags
|
||
255a : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
255c : 28 plp
|
||
255d : 08 php ;save carry for next add
|
||
255e : a50b lda ad1
|
||
2560 : fdfa01 sbc sba2-ad2,x ;perform subtract
|
||
2563 : 08 php
|
||
2564 : c50d cmp adrl ;check result
|
||
trap_ne ;bad result
|
||
2566 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
2568 : 68 pla ;check flags
|
||
2569 : 2983 and #$83 ;mask N-----ZC
|
||
256b : c50f cmp adrf
|
||
trap_ne ;bad flags
|
||
256d : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
256f : 28 plp
|
||
; decimal ADC / SBC abs,y
|
||
2570 : 08 php ;save carry for subtract
|
||
2571 : a50b lda ad1
|
||
2573 : 790601 adc ada2-$ff,y ;perform add
|
||
2576 : 08 php
|
||
2577 : c50d cmp adrl ;check result
|
||
trap_ne ;bad result
|
||
2579 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
257b : 68 pla ;check flags
|
||
257c : 2983 and #$83 ;mask N-----ZC
|
||
257e : c50f cmp adrf
|
||
trap_ne ;bad flags
|
||
2580 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
2582 : 28 plp
|
||
2583 : 08 php ;save carry for next add
|
||
2584 : a50b lda ad1
|
||
2586 : f90701 sbc sba2-$ff,y ;perform subtract
|
||
2589 : 08 php
|
||
258a : c50d cmp adrl ;check result
|
||
trap_ne ;bad result
|
||
258c : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
258e : 68 pla ;check flags
|
||
258f : 2983 and #$83 ;mask N-----ZC
|
||
2591 : c50f cmp adrf
|
||
trap_ne ;bad flags
|
||
2593 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
2595 : 28 plp
|
||
; decimal ADC / SBC (zp,x)
|
||
2596 : 08 php ;save carry for subtract
|
||
2597 : a50b lda ad1
|
||
2599 : 6144 adc (lo adi2-ad2,x) ;perform add
|
||
259b : 08 php
|
||
259c : c50d cmp adrl ;check result
|
||
trap_ne ;bad result
|
||
259e : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
25a0 : 68 pla ;check flags
|
||
25a1 : 2983 and #$83 ;mask N-----ZC
|
||
25a3 : c50f cmp adrf
|
||
trap_ne ;bad flags
|
||
25a5 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
25a7 : 28 plp
|
||
25a8 : 08 php ;save carry for next add
|
||
25a9 : a50b lda ad1
|
||
25ab : e146 sbc (lo sbi2-ad2,x) ;perform subtract
|
||
25ad : 08 php
|
||
25ae : c50d cmp adrl ;check result
|
||
trap_ne ;bad result
|
||
25b0 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
25b2 : 68 pla ;check flags
|
||
25b3 : 2983 and #$83 ;mask N-----ZC
|
||
25b5 : c50f cmp adrf
|
||
trap_ne ;bad flags
|
||
25b7 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
25b9 : 28 plp
|
||
; decimal ADC / SBC (abs),y
|
||
25ba : 08 php ;save carry for subtract
|
||
25bb : a50b lda ad1
|
||
25bd : 7154 adc (adiy2),y ;perform add
|
||
25bf : 08 php
|
||
25c0 : c50d cmp adrl ;check result
|
||
trap_ne ;bad result
|
||
25c2 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
25c4 : 68 pla ;check flags
|
||
25c5 : 2983 and #$83 ;mask N-----ZC
|
||
25c7 : c50f cmp adrf
|
||
trap_ne ;bad flags
|
||
25c9 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
25cb : 28 plp
|
||
25cc : 08 php ;save carry for next add
|
||
25cd : a50b lda ad1
|
||
25cf : f156 sbc (sbiy2),y ;perform subtract
|
||
25d1 : 08 php
|
||
25d2 : c50d cmp adrl ;check result
|
||
trap_ne ;bad result
|
||
25d4 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
25d6 : 68 pla ;check flags
|
||
25d7 : 2983 and #$83 ;mask N-----ZC
|
||
25d9 : c50f cmp adrf
|
||
trap_ne ;bad flags
|
||
25db : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
25dd : 28 plp
|
||
; decimal ADC / SBC (zp)
|
||
25de : 08 php ;save carry for subtract
|
||
25df : a50b lda ad1
|
||
25e1 : 7250 adc (adi2) ;perform add
|
||
25e3 : 08 php
|
||
25e4 : c50d cmp adrl ;check result
|
||
trap_ne ;bad result
|
||
25e6 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
25e8 : 68 pla ;check flags
|
||
25e9 : 2983 and #$83 ;mask N-----ZC
|
||
25eb : c50f cmp adrf
|
||
trap_ne ;bad flags
|
||
25ed : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
25ef : 28 plp
|
||
25f0 : 08 php ;save carry for next add
|
||
25f1 : a50b lda ad1
|
||
25f3 : f252 sbc (sbi2) ;perform subtract
|
||
25f5 : 08 php
|
||
25f6 : c50d cmp adrl ;check result
|
||
trap_ne ;bad result
|
||
25f8 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
25fa : 68 pla ;check flags
|
||
25fb : 2983 and #$83 ;mask N-----ZC
|
||
25fd : c50f cmp adrf
|
||
trap_ne ;bad flags
|
||
25ff : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
2601 : 28 plp
|
||
2602 : 60 rts
|
||
|
||
; core subroutine of the full binary add/subtract test
|
||
; iterates through all combinations of operands and carry input
|
||
; uses increments/decrements to predict result & result flags
|
||
2603 : a50f chkadd lda adrf ;add V-flag if overflow
|
||
2605 : 2983 and #$83 ;keep N-----ZC / clear V
|
||
2607 : 48 pha
|
||
2608 : a50b lda ad1 ;test sign unequal between operands
|
||
260a : 450c eor ad2
|
||
260c : 300a bmi ckad1 ;no overflow possible - operands have different sign
|
||
260e : a50b lda ad1 ;test sign equal between operands and result
|
||
2610 : 450d eor adrl
|
||
2612 : 1004 bpl ckad1 ;no overflow occured - operand and result have same sign
|
||
2614 : 68 pla
|
||
2615 : 0940 ora #$40 ;set V
|
||
2617 : 48 pha
|
||
2618 : 68 ckad1 pla
|
||
2619 : 850f sta adrf ;save expected flags
|
||
; binary ADC / SBC (zp)
|
||
261b : 08 php ;save carry for subtract
|
||
261c : a50b lda ad1
|
||
261e : 7250 adc (adi2) ;perform add
|
||
2620 : 08 php
|
||
2621 : c50d cmp adrl ;check result
|
||
trap_ne ;bad result
|
||
2623 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
2625 : 68 pla ;check flags
|
||
2626 : 29c3 and #$c3 ;mask NV----ZC
|
||
2628 : c50f cmp adrf
|
||
trap_ne ;bad flags
|
||
262a : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
262c : 28 plp
|
||
262d : 08 php ;save carry for next add
|
||
262e : a50b lda ad1
|
||
2630 : f252 sbc (sbi2) ;perform subtract
|
||
2632 : 08 php
|
||
2633 : c50d cmp adrl ;check result
|
||
trap_ne ;bad result
|
||
2635 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
2637 : 68 pla ;check flags
|
||
2638 : 29c3 and #$c3 ;mask NV----ZC
|
||
263a : c50f cmp adrf
|
||
trap_ne ;bad flags
|
||
263c : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
263e : 28 plp
|
||
263f : 60 rts
|
||
|
||
; target for the jump indirect test
|
||
2640 : 4626 ji_adr dw test_ji
|
||
2642 : 8216 dw ji_ret
|
||
|
||
2644 : 88 dey
|
||
2645 : 88 dey
|
||
2646 : test_ji
|
||
2646 : 08 php ;either SP or Y count will fail, if we do not hit
|
||
2647 : 88 dey
|
||
2648 : 88 dey
|
||
2649 : 88 dey
|
||
264a : 28 plp
|
||
trap_cs ;flags loaded?
|
||
264b : b0fe > bcs * ;failed carry set
|
||
|
||
trap_vs
|
||
264d : 70fe > bvs * ;failed overflow set
|
||
|
||
trap_mi
|
||
264f : 30fe > bmi * ;failed minus (bit 7 set)
|
||
|
||
trap_eq
|
||
2651 : f0fe > beq * ;failed equal (zero)
|
||
|
||
2653 : c949 cmp #'I' ;registers loaded?
|
||
trap_ne
|
||
2655 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
2657 : e04e cpx #'N'
|
||
trap_ne
|
||
2659 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
265b : c041 cpy #('D'-3)
|
||
trap_ne
|
||
265d : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
265f : 48 pha ;save a,x
|
||
2660 : 8a txa
|
||
2661 : 48 pha
|
||
2662 : ba tsx
|
||
2663 : e0fd cpx #$fd ;check SP
|
||
trap_ne
|
||
2665 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
2667 : 68 pla ;restore x
|
||
2668 : aa tax
|
||
set_stat $ff
|
||
> load_flag $ff
|
||
2669 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
266b : 48 > pha ;use stack to load status
|
||
266c : 28 > plp
|
||
|
||
266d : 68 pla ;restore a
|
||
266e : e8 inx ;return registers with modifications
|
||
266f : 49aa eor #$aa ;N=1, V=1, Z=0, C=1
|
||
2671 : 6cff02 jmp (ji_tab+2)
|
||
2674 : ea nop
|
||
2675 : ea nop
|
||
trap ;runover protection
|
||
2676 : 4c7626 > jmp * ;failed anyway
|
||
|
||
|
||
; target for the jump indirect test
|
||
2679 : bd26 jxi_adr dw trap_ind
|
||
267b : bd26 dw trap_ind
|
||
267d : 8726 dw test_jxi ;+4
|
||
267f : ce16 dw jxi_ret ;+6
|
||
2681 : bd26 dw trap_ind
|
||
2683 : bd26 dw trap_ind
|
||
|
||
2685 : 88 dey
|
||
2686 : 88 dey
|
||
2687 : test_jxi
|
||
2687 : 08 php ;either SP or Y count will fail, if we do not hit
|
||
2688 : 88 dey
|
||
2689 : 88 dey
|
||
268a : 88 dey
|
||
268b : 28 plp
|
||
trap_cs ;flags loaded?
|
||
268c : b0fe > bcs * ;failed carry set
|
||
|
||
trap_vs
|
||
268e : 70fe > bvs * ;failed overflow set
|
||
|
||
trap_mi
|
||
2690 : 30fe > bmi * ;failed minus (bit 7 set)
|
||
|
||
trap_eq
|
||
2692 : f0fe > beq * ;failed equal (zero)
|
||
|
||
2694 : c958 cmp #'X' ;registers loaded?
|
||
trap_ne
|
||
2696 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
2698 : e004 cpx #4
|
||
trap_ne
|
||
269a : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
269c : c046 cpy #('I'-3)
|
||
trap_ne
|
||
269e : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
26a0 : 48 pha ;save a,x
|
||
26a1 : 8a txa
|
||
26a2 : 48 pha
|
||
26a3 : ba tsx
|
||
26a4 : e0fd cpx #$fd ;check SP
|
||
trap_ne
|
||
26a6 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
26a8 : 68 pla ;restore x
|
||
26a9 : aa tax
|
||
set_stat $ff
|
||
> load_flag $ff
|
||
26aa : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
||
>
|
||
26ac : 48 > pha ;use stack to load status
|
||
26ad : 28 > plp
|
||
|
||
26ae : 68 pla ;restore a
|
||
26af : e8 inx ;return registers with modifications
|
||
26b0 : e8 inx
|
||
26b1 : 49aa eor #$aa ;N=1, V=1, Z=0, C=1
|
||
26b3 : 7cf902 jmp (jxi_tab,x)
|
||
26b6 : ea nop
|
||
26b7 : ea nop
|
||
trap ;runover protection
|
||
26b8 : 4cb826 > jmp * ;failed anyway
|
||
|
||
|
||
; JMP (abs,x) with bad x
|
||
26bb : ea nop
|
||
26bc : ea nop
|
||
26bd : trap_ind
|
||
26bd : ea nop
|
||
26be : ea nop
|
||
trap ;near miss indexed indirect jump
|
||
26bf : 4cbf26 > jmp * ;failed anyway
|
||
|
||
|
||
;trap in case of unexpected IRQ, NMI, BRK, RESET
|
||
26c2 : nmi_trap
|
||
trap ;check stack for conditions at NMI
|
||
26c2 : 4cc226 > jmp * ;failed anyway
|
||
|
||
26c5 : res_trap
|
||
trap ;unexpected RESET
|
||
26c5 : 4cc526 > jmp * ;failed anyway
|
||
|
||
26c8 : irq_trap
|
||
26c8 : 08 php ;save decimal flag
|
||
26c9 : ba tsx ;test break on stack
|
||
26ca : bd0201 lda $102,x
|
||
26cd : 2910 and #break
|
||
trap_eq ;check stack for conditions at IRQ
|
||
26cf : f0fe > beq * ;failed equal (zero)
|
||
|
||
if ROM_vectors = 1
|
||
26d1 : 68 pla ;test decimal mode cleared
|
||
26d2 : 2908 and #decmode
|
||
trap_ne ;decimal mode not cleared after BRK
|
||
26d4 : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
26d6 : 28 plp ;pop saved flags
|
||
26d7 : 68 pla ;return address low
|
||
26d8 : c917 cmp #lo(brk_ret)
|
||
trap_ne ;unexpected BRK
|
||
26da : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
26dc : 68 pla ;return address high
|
||
26dd : c917 cmp #hi(brk_ret)
|
||
trap_ne ;unexpected BRK
|
||
26df : d0fe > bne * ;failed not equal (non zero)
|
||
|
||
26e1 : 4c1717 jmp brk_ret
|
||
else
|
||
trap_ne ;check stack for conditions at BRK
|
||
endif
|
||
|
||
if report = 1
|
||
include "report.i65"
|
||
endif
|
||
|
||
;copy of data to initialize BSS segment
|
||
if load_data_direct != 1
|
||
zp_init
|
||
zp1_ db $c3,$82,$41,0 ;test patterns for LDx BIT ROL ROR ASL LSR
|
||
zp7f_ db $7f ;test pattern for compare
|
||
;logical zeropage operands
|
||
zpOR_ db 0,$1f,$71,$80 ;test pattern for OR
|
||
zpAN_ db $0f,$ff,$7f,$80 ;test pattern for AND
|
||
zpEO_ db $ff,$0f,$8f,$8f ;test pattern for EOR
|
||
;indirect addressing pointers
|
||
ind1_ dw abs1 ;indirect pointer to pattern in absolute memory
|
||
dw abs1+1
|
||
dw abs1+2
|
||
dw abs1+3
|
||
dw abs7f
|
||
inw1_ dw abs1-$f8 ;indirect pointer for wrap-test pattern
|
||
indt_ dw abst ;indirect pointer to store area in absolute memory
|
||
dw abst+1
|
||
dw abst+2
|
||
dw abst+3
|
||
inwt_ dw abst-$f8 ;indirect pointer for wrap-test store
|
||
indAN_ dw absAN ;indirect pointer to AND pattern in absolute memory
|
||
dw absAN+1
|
||
dw absAN+2
|
||
dw absAN+3
|
||
indEO_ dw absEO ;indirect pointer to EOR pattern in absolute memory
|
||
dw absEO+1
|
||
dw absEO+2
|
||
dw absEO+3
|
||
indOR_ dw absOR ;indirect pointer to OR pattern in absolute memory
|
||
dw absOR+1
|
||
dw absOR+2
|
||
dw absOR+3
|
||
;add/subtract indirect pointers
|
||
adi2_ dw ada2 ;indirect pointer to operand 2 in absolute memory
|
||
sbi2_ dw sba2 ;indirect pointer to complemented operand 2 (SBC)
|
||
adiy2_ dw ada2-$ff ;with offset for indirect indexed
|
||
sbiy2_ dw sba2-$ff
|
||
zp_end
|
||
if (zp_end - zp_init) != (zp_bss_end - zp_bss)
|
||
;force assembler error if size is different
|
||
ERROR ERROR ERROR ;mismatch between bss and zeropage data
|
||
endif
|
||
data_init
|
||
abs1_ db $c3,$82,$41,0 ;test patterns for LDx BIT ROL ROR ASL LSR
|
||
abs7f_ db $7f ;test pattern for compare
|
||
;loads
|
||
fLDx_ db fn,fn,0,fz ;expected flags for load
|
||
;shifts
|
||
rASL_ ;expected result ASL & ROL -carry
|
||
rROL_ db $86,$04,$82,0 ; "
|
||
rROLc_ db $87,$05,$83,1 ;expected result ROL +carry
|
||
rLSR_ ;expected result LSR & ROR -carry
|
||
rROR_ db $61,$41,$20,0 ; "
|
||
rRORc_ db $e1,$c1,$a0,$80 ;expected result ROR +carry
|
||
fASL_ ;expected flags for shifts
|
||
fROL_ db fnc,fc,fn,fz ;no carry in
|
||
fROLc_ db fnc,fc,fn,0 ;carry in
|
||
fLSR_
|
||
fROR_ db fc,0,fc,fz ;no carry in
|
||
fRORc_ db fnc,fn,fnc,fn ;carry in
|
||
;increments (decrements)
|
||
rINC_ db $7f,$80,$ff,0,1 ;expected result for INC/DEC
|
||
fINC_ db 0,fn,fn,fz,0 ;expected flags for INC/DEC
|
||
;logical memory operand
|
||
absOR_ db 0,$1f,$71,$80 ;test pattern for OR
|
||
absAN_ db $0f,$ff,$7f,$80 ;test pattern for AND
|
||
absEO_ db $ff,$0f,$8f,$8f ;test pattern for EOR
|
||
;logical accu operand
|
||
absORa_ db 0,$f1,$1f,0 ;test pattern for OR
|
||
absANa_ db $f0,$ff,$ff,$ff ;test pattern for AND
|
||
absEOa_ db $ff,$f0,$f0,$0f ;test pattern for EOR
|
||
;logical results
|
||
absrlo_ db 0,$ff,$7f,$80
|
||
absflo_ db fz,fn,0,fn
|
||
data_end
|
||
if (data_end - data_init) != (data_bss_end - data_bss)
|
||
;force assembler error if size is different
|
||
ERROR ERROR ERROR ;mismatch between bss and data
|
||
endif
|
||
|
||
vec_init
|
||
dw nmi_trap
|
||
dw res_trap
|
||
dw irq_trap
|
||
vec_bss equ $fffa
|
||
endif ;end of RAM init data
|
||
|
||
; code at end of image due to the need to add blank space as required
|
||
if ($ff & (ji_ret - * - 2)) < ($ff & (jxi_ret - * - 2))
|
||
; JMP (abs) when $xxff and $xx00 are from same page
|
||
26e4 : 00000000000000.. ds lo(ji_ret - * - 2)
|
||
2780 : ea nop
|
||
2781 : ea nop
|
||
2782 : ea ji_px nop ;low address byte matched with ji_ret
|
||
2783 : ea nop
|
||
trap ;jmp indirect page cross bug
|
||
2784 : 4c8427 > jmp * ;failed anyway
|
||
|
||
|
||
; JMP (abs,x) when $xxff and $xx00 are from same page
|
||
2787 : 00000000000000.. ds lo(jxi_ret - * - 2)
|
||
27cc : ea nop
|
||
27cd : ea nop
|
||
27ce : ea jxi_px nop ;low address byte matched with jxi_ret
|
||
27cf : ea nop
|
||
trap ;jmp indexed indirect page cross bug
|
||
27d0 : 4cd027 > jmp * ;failed anyway
|
||
|
||
else
|
||
; JMP (abs,x) when $xxff and $xx00 are from same page
|
||
ds lo(jxi_ret - * - 2)
|
||
nop
|
||
nop
|
||
jxi_px nop ;low address byte matched with jxi_ret
|
||
nop
|
||
trap ;jmp indexed indirect page cross bug
|
||
|
||
; JMP (abs) when $xxff and $xx00 are from same page
|
||
ds lo(ji_ret - * - 2)
|
||
nop
|
||
nop
|
||
ji_px nop ;low address byte matched with ji_ret
|
||
nop
|
||
trap ;jmp indirect page cross bug
|
||
endif
|
||
|
||
if (load_data_direct = 1) & (ROM_vectors = 1)
|
||
fffa = org $fffa ;vectors
|
||
fffa : c226 dw nmi_trap
|
||
fffc : c526 dw res_trap
|
||
fffe : c826 dw irq_trap
|
||
endif
|
||
|
||
fffa = end start
|
||
|
||
No errors in pass 2.
|
||
Wrote binary from address $0000 through $ffff.
|
||
Total size 65536 bytes.
|
||
Program start address is at $0400 (1024).
|
||
|