11783 lines
587 KiB
Plaintext
11783 lines
587 KiB
Plaintext
AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 1
|
|
------------------------------------------------ 65C02_extended_opcodes_test.a65c ------------------------------------------------
|
|
|
|
2883 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-2017 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, STP & WAI are covered in the 6502_interrupt_test.
|
|
;
|
|
; version 04-dec-2017
|
|
; 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
|
|
; 23-aug-2015 change revoked
|
|
; 24-aug-2015 all self modifying immediate opcodes now execute in data RAM
|
|
; 28-aug-2015 fixed decimal adc/sbc immediate only testing carry
|
|
; 09-feb-2017 fixed RMB/SMB tested when they shouldn't be tested
|
|
; 04-dec-2017 fixed BRK not tested for actually going through the IRQ vector
|
|
; added option to skip the remainder of a failing test
|
|
; in report.i65
|
|
; added skip override to undefined opcode as NOP test
|
|
|
|
|
|
; 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, $63 (99) 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
|
|
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)
|
|
0000 = rkwl_wdc_op = 0
|
|
|
|
;skip testing all undefined opcodes override
|
|
;0=test as NOP, >0=skip
|
|
0000 = skip_nop = 0
|
|
|
|
;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
|
|
;db $db
|
|
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\?
|
|
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(abs1) ;set high byte of indirect pointer
|
|
stx zpt+1
|
|
ldy #lo(abs1) ;data after write & execute 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
|
|
000a = org zero_page
|
|
;break test interrupt save
|
|
000a : 00 irq_a ds 1 ;a register
|
|
000b : 00 irq_x ds 1 ;x register
|
|
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
|
|
000c : zpt ;5 bytes store/modify test area
|
|
;add/subtract operand generation and result/flag prediction
|
|
000c : 00 adfc ds 1 ;carry flag before op
|
|
000d : 00 ad1 ds 1 ;operand 1 - accumulator
|
|
000e : 00 ad2 ds 1 ;operand 2 - memory / immediate
|
|
000f : 00 adrl ds 1 ;expected result bits 0-7
|
|
0010 : 00 adrh ds 1 ;expected result bit 8 (carry)
|
|
0011 : 00 adrf ds 1 ;expected flags NV0000ZC (-V in decimal mode)
|
|
0012 : 00 sb2 ds 1 ;operand 2 complemented for subtract
|
|
0013 : zp_bss
|
|
0013 : c3824100 zp1 db $c3,$82,$41,0 ;test patterns for LDx BIT ROL ROR ASL LSR
|
|
0017 : 7f zp7f db $7f ;test pattern for compare
|
|
;logical zeropage operands
|
|
0018 : 001f7180 zpOR db 0,$1f,$71,$80 ;test pattern for OR
|
|
001c : 0fff7f80 zpAN db $0f,$ff,$7f,$80 ;test pattern for AND
|
|
0020 : ff0f8f8f zpEO db $ff,$0f,$8f,$8f ;test pattern for EOR
|
|
;indirect addressing pointers
|
|
0024 : 1002 ind1 dw abs1 ;indirect pointer to pattern in absolute memory
|
|
0026 : 1102 dw abs1+1
|
|
0028 : 1202 dw abs1+2
|
|
002a : 1302 dw abs1+3
|
|
002c : 1402 dw abs7f
|
|
002e : 1801 inw1 dw abs1-$f8 ;indirect pointer for wrap-test pattern
|
|
0030 : 0502 indt dw abst ;indirect pointer to store area in absolute memory
|
|
0032 : 0602 dw abst+1
|
|
0034 : 0702 dw abst+2
|
|
0036 : 0802 dw abst+3
|
|
0038 : 0d01 inwt dw abst-$f8 ;indirect pointer for wrap-test store
|
|
003a : 4702 indAN dw absAN ;indirect pointer to AND pattern in absolute memory
|
|
003c : 4802 dw absAN+1
|
|
003e : 4902 dw absAN+2
|
|
0040 : 4a02 dw absAN+3
|
|
0042 : 4b02 indEO dw absEO ;indirect pointer to EOR pattern in absolute memory
|
|
0044 : 4c02 dw absEO+1
|
|
0046 : 4d02 dw absEO+2
|
|
0048 : 4e02 dw absEO+3
|
|
004a : 4302 indOR dw absOR ;indirect pointer to OR pattern in absolute memory
|
|
004c : 4402 dw absOR+1
|
|
004e : 4502 dw absOR+2
|
|
0050 : 4602 dw absOR+3
|
|
;add/subtract indirect pointers
|
|
0052 : 0502 adi2 dw ada2 ;indirect pointer to operand 2 in absolute memory
|
|
0054 : 0602 sbi2 dw sba2 ;indirect pointer to complemented operand 2 (SBC)
|
|
0056 : 0601 adiy2 dw ada2-$ff ;with offset for indirect indexed
|
|
0058 : 0701 sbiy2 dw sba2-$ff
|
|
005a : 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
|
|
if load_data_direct = 1
|
|
020a : 6900 ex_adci adc #0 ;execute immediate opcodes
|
|
020c : 60 rts
|
|
020d : e900 ex_sbci sbc #0 ;execute immediate opcodes
|
|
020f : 60 rts
|
|
else
|
|
ex_adci ds 3
|
|
ex_sbci ds 3
|
|
endif
|
|
0210 : c3824100 abs1 db $c3,$82,$41,0 ;test patterns for LDx BIT ROL ROR ASL LSR
|
|
0214 : 7f abs7f db $7f ;test pattern for compare
|
|
;loads
|
|
0215 : 80800002 fLDx db fn,fn,0,fz ;expected flags for load
|
|
;shifts
|
|
0219 : rASL ;expected result ASL & ROL -carry
|
|
0219 : 86048200 rROL db $86,$04,$82,0 ; "
|
|
021d : 87058301 rROLc db $87,$05,$83,1 ;expected result ROL +carry
|
|
0221 : rLSR ;expected result LSR & ROR -carry
|
|
0221 : 61412000 rROR db $61,$41,$20,0 ; "
|
|
0225 : e1c1a080 rRORc db $e1,$c1,$a0,$80 ;expected result ROR +carry
|
|
0229 : fASL ;expected flags for shifts
|
|
0229 : 81018002 fROL db fnc,fc,fn,fz ;no carry in
|
|
022d : 81018000 fROLc db fnc,fc,fn,0 ;carry in
|
|
0231 : fLSR
|
|
0231 : 01000102 fROR db fc,0,fc,fz ;no carry in
|
|
0235 : 81808180 fRORc db fnc,fn,fnc,fn ;carry in
|
|
;increments (decrements)
|
|
0239 : 7f80ff0001 rINC db $7f,$80,$ff,0,1 ;expected result for INC/DEC
|
|
023e : 0080800200 fINC db 0,fn,fn,fz,0 ;expected flags for INC/DEC
|
|
;logical memory operand
|
|
0243 : 001f7180 absOR db 0,$1f,$71,$80 ;test pattern for OR
|
|
0247 : 0fff7f80 absAN db $0f,$ff,$7f,$80 ;test pattern for AND
|
|
024b : ff0f8f8f absEO db $ff,$0f,$8f,$8f ;test pattern for EOR
|
|
;logical accu operand
|
|
024f : 00f11f00 absORa db 0,$f1,$1f,0 ;test pattern for OR
|
|
0253 : f0ffffff absANa db $f0,$ff,$ff,$ff ;test pattern for AND
|
|
0257 : fff0f00f absEOa db $ff,$f0,$f0,$0f ;test pattern for EOR
|
|
;logical results
|
|
025b : 00ff7f80 absrlo db 0,$ff,$7f,$80
|
|
025f : 02800080 absflo db fz,fn,0,fn
|
|
0263 : 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
|
|
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(abs1) ;set high byte of indirect pointer
|
|
stx zpt+1
|
|
ldy #lo(abs1) ;data after write & execute 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
|
|
|
|
ldx #$11 ;test bbr/bbs integrity
|
|
ldy #$22
|
|
bbt 0
|
|
bbt 1
|
|
bbt 2
|
|
bbt 3
|
|
bbt 4
|
|
bbt 5
|
|
bbt 6
|
|
bbt 7
|
|
cpx #$11
|
|
trap_ne ;x overwritten
|
|
cpy #$22
|
|
trap_ne ;y overwritten
|
|
next_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
|
|
|
|
lda #0 ;combined bit test
|
|
sta zpt
|
|
bbcl lda #0
|
|
bbrc 0
|
|
bbrc 1
|
|
bbrc 2
|
|
bbrc 3
|
|
bbrc 4
|
|
bbrc 5
|
|
bbrc 6
|
|
bbrc 7
|
|
eor zpt
|
|
trap_ne ;failed bbr bitnum in accu
|
|
lda #$ff
|
|
bbsc 0
|
|
bbsc 1
|
|
bbsc 2
|
|
bbsc 3
|
|
bbsc 4
|
|
bbsc 5
|
|
bbsc 6
|
|
bbsc 7
|
|
eor zpt
|
|
trap_ne ;failed bbs bitnum in accu
|
|
inc zpt
|
|
bne bbcl
|
|
next_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
|
|
|
|
if skip_nop = 0
|
|
nop_test $02,2
|
|
071c : a042 > ldy #$42
|
|
071e : a202 > ldx #4-2
|
|
0720 : 02 > db $02 ;test nop length
|
|
> if 2 = 1
|
|
> dex
|
|
> dex
|
|
> endif
|
|
> if 2 = 2
|
|
0721 : c8 > iny
|
|
0722 : ca > dex
|
|
> endif
|
|
> if 2 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
0723 : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
0724 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$02,0
|
|
> load_flag 0
|
|
0726 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
0728 : 48 > pha ;use stack to load status
|
|
0729 : a9fd > lda #$ff-$02 ;precharge accu
|
|
072b : 28 > plp
|
|
>
|
|
072c : 02 > db $02 ;test nop integrity - flags off
|
|
072d : ea > nop
|
|
072e : ea > nop
|
|
> tst_a $ff-$02,0
|
|
072f : 08 > php ;save flags
|
|
0730 : c9fd > cmp #$ff-$02 ;test result
|
|
> trap_ne
|
|
0732 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0734 : 68 > pla ;load status
|
|
0735 : 48 > pha
|
|
> cmp_flag 0
|
|
0736 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0738 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
073a : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$02,$ff
|
|
> load_flag $ff
|
|
073b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
073d : 48 > pha ;use stack to load status
|
|
073e : a9a8 > lda #$aa-$02 ;precharge accu
|
|
0740 : 28 > plp
|
|
>
|
|
0741 : 02 > db $02 ;test nop integrity - flags on
|
|
0742 : ea > nop
|
|
0743 : ea > nop
|
|
> tst_a $aa-$02,$ff
|
|
0744 : 08 > php ;save flags
|
|
0745 : c9a8 > cmp #$aa-$02 ;test result
|
|
> trap_ne
|
|
0747 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0749 : 68 > pla ;load status
|
|
074a : 48 > pha
|
|
> cmp_flag $ff
|
|
074b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
074d : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
074f : 28 > plp ;restore status
|
|
>
|
|
0750 : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
0752 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0754 : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
0756 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $22,2
|
|
0758 : a042 > ldy #$42
|
|
075a : a202 > ldx #4-2
|
|
075c : 22 > db $22 ;test nop length
|
|
> if 2 = 1
|
|
> dex
|
|
> dex
|
|
> endif
|
|
> if 2 = 2
|
|
075d : c8 > iny
|
|
075e : ca > dex
|
|
> endif
|
|
> if 2 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
075f : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
0760 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$22,0
|
|
> load_flag 0
|
|
0762 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
0764 : 48 > pha ;use stack to load status
|
|
0765 : a9dd > lda #$ff-$22 ;precharge accu
|
|
0767 : 28 > plp
|
|
>
|
|
0768 : 22 > db $22 ;test nop integrity - flags off
|
|
0769 : ea > nop
|
|
076a : ea > nop
|
|
> tst_a $ff-$22,0
|
|
076b : 08 > php ;save flags
|
|
076c : c9dd > cmp #$ff-$22 ;test result
|
|
> trap_ne
|
|
076e : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0770 : 68 > pla ;load status
|
|
0771 : 48 > pha
|
|
> cmp_flag 0
|
|
0772 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0774 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0776 : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$22,$ff
|
|
> load_flag $ff
|
|
0777 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
0779 : 48 > pha ;use stack to load status
|
|
077a : a988 > lda #$aa-$22 ;precharge accu
|
|
077c : 28 > plp
|
|
>
|
|
077d : 22 > db $22 ;test nop integrity - flags on
|
|
077e : ea > nop
|
|
077f : ea > nop
|
|
> tst_a $aa-$22,$ff
|
|
0780 : 08 > php ;save flags
|
|
0781 : c988 > cmp #$aa-$22 ;test result
|
|
> trap_ne
|
|
0783 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0785 : 68 > pla ;load status
|
|
0786 : 48 > pha
|
|
> cmp_flag $ff
|
|
0787 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0789 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
078b : 28 > plp ;restore status
|
|
>
|
|
078c : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
078e : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0790 : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
0792 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $42,2
|
|
0794 : a042 > ldy #$42
|
|
0796 : a202 > ldx #4-2
|
|
0798 : 42 > db $42 ;test nop length
|
|
> if 2 = 1
|
|
> dex
|
|
> dex
|
|
> endif
|
|
> if 2 = 2
|
|
0799 : c8 > iny
|
|
079a : ca > dex
|
|
> endif
|
|
> if 2 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
079b : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
079c : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$42,0
|
|
> load_flag 0
|
|
079e : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
07a0 : 48 > pha ;use stack to load status
|
|
07a1 : a9bd > lda #$ff-$42 ;precharge accu
|
|
07a3 : 28 > plp
|
|
>
|
|
07a4 : 42 > db $42 ;test nop integrity - flags off
|
|
07a5 : ea > nop
|
|
07a6 : ea > nop
|
|
> tst_a $ff-$42,0
|
|
07a7 : 08 > php ;save flags
|
|
07a8 : c9bd > cmp #$ff-$42 ;test result
|
|
> trap_ne
|
|
07aa : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
07ac : 68 > pla ;load status
|
|
07ad : 48 > pha
|
|
> cmp_flag 0
|
|
07ae : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
07b0 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
07b2 : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$42,$ff
|
|
> load_flag $ff
|
|
07b3 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
07b5 : 48 > pha ;use stack to load status
|
|
07b6 : a968 > lda #$aa-$42 ;precharge accu
|
|
07b8 : 28 > plp
|
|
>
|
|
07b9 : 42 > db $42 ;test nop integrity - flags on
|
|
07ba : ea > nop
|
|
07bb : ea > nop
|
|
> tst_a $aa-$42,$ff
|
|
07bc : 08 > php ;save flags
|
|
07bd : c968 > cmp #$aa-$42 ;test result
|
|
> trap_ne
|
|
07bf : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
07c1 : 68 > pla ;load status
|
|
07c2 : 48 > pha
|
|
> cmp_flag $ff
|
|
07c3 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
07c5 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
07c7 : 28 > plp ;restore status
|
|
>
|
|
07c8 : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
07ca : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
07cc : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
07ce : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $62,2
|
|
07d0 : a042 > ldy #$42
|
|
07d2 : a202 > ldx #4-2
|
|
07d4 : 62 > db $62 ;test nop length
|
|
> if 2 = 1
|
|
> dex
|
|
> dex
|
|
> endif
|
|
> if 2 = 2
|
|
07d5 : c8 > iny
|
|
07d6 : ca > dex
|
|
> endif
|
|
> if 2 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
07d7 : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
07d8 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$62,0
|
|
> load_flag 0
|
|
07da : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
07dc : 48 > pha ;use stack to load status
|
|
07dd : a99d > lda #$ff-$62 ;precharge accu
|
|
07df : 28 > plp
|
|
>
|
|
07e0 : 62 > db $62 ;test nop integrity - flags off
|
|
07e1 : ea > nop
|
|
07e2 : ea > nop
|
|
> tst_a $ff-$62,0
|
|
07e3 : 08 > php ;save flags
|
|
07e4 : c99d > cmp #$ff-$62 ;test result
|
|
> trap_ne
|
|
07e6 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
07e8 : 68 > pla ;load status
|
|
07e9 : 48 > pha
|
|
> cmp_flag 0
|
|
07ea : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
07ec : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
07ee : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$62,$ff
|
|
> load_flag $ff
|
|
07ef : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
07f1 : 48 > pha ;use stack to load status
|
|
07f2 : a948 > lda #$aa-$62 ;precharge accu
|
|
07f4 : 28 > plp
|
|
>
|
|
07f5 : 62 > db $62 ;test nop integrity - flags on
|
|
07f6 : ea > nop
|
|
07f7 : ea > nop
|
|
> tst_a $aa-$62,$ff
|
|
07f8 : 08 > php ;save flags
|
|
07f9 : c948 > cmp #$aa-$62 ;test result
|
|
> trap_ne
|
|
07fb : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
07fd : 68 > pla ;load status
|
|
07fe : 48 > pha
|
|
> cmp_flag $ff
|
|
07ff : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0801 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0803 : 28 > plp ;restore status
|
|
>
|
|
0804 : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
0806 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0808 : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
080a : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $82,2
|
|
080c : a042 > ldy #$42
|
|
080e : a202 > ldx #4-2
|
|
0810 : 82 > db $82 ;test nop length
|
|
> if 2 = 1
|
|
> dex
|
|
> dex
|
|
> endif
|
|
> if 2 = 2
|
|
0811 : c8 > iny
|
|
0812 : ca > dex
|
|
> endif
|
|
> if 2 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
0813 : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
0814 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$82,0
|
|
> load_flag 0
|
|
0816 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
0818 : 48 > pha ;use stack to load status
|
|
0819 : a97d > lda #$ff-$82 ;precharge accu
|
|
081b : 28 > plp
|
|
>
|
|
081c : 82 > db $82 ;test nop integrity - flags off
|
|
081d : ea > nop
|
|
081e : ea > nop
|
|
> tst_a $ff-$82,0
|
|
081f : 08 > php ;save flags
|
|
0820 : c97d > cmp #$ff-$82 ;test result
|
|
> trap_ne
|
|
0822 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0824 : 68 > pla ;load status
|
|
0825 : 48 > pha
|
|
> cmp_flag 0
|
|
0826 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0828 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
082a : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$82,$ff
|
|
> load_flag $ff
|
|
082b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
082d : 48 > pha ;use stack to load status
|
|
082e : a928 > lda #$aa-$82 ;precharge accu
|
|
0830 : 28 > plp
|
|
>
|
|
0831 : 82 > db $82 ;test nop integrity - flags on
|
|
0832 : ea > nop
|
|
0833 : ea > nop
|
|
> tst_a $aa-$82,$ff
|
|
0834 : 08 > php ;save flags
|
|
0835 : c928 > cmp #$aa-$82 ;test result
|
|
> trap_ne
|
|
0837 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0839 : 68 > pla ;load status
|
|
083a : 48 > pha
|
|
> cmp_flag $ff
|
|
083b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
083d : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
083f : 28 > plp ;restore status
|
|
>
|
|
0840 : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
0842 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0844 : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
0846 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $c2,2
|
|
0848 : a042 > ldy #$42
|
|
084a : a202 > ldx #4-2
|
|
084c : c2 > db $c2 ;test nop length
|
|
> if 2 = 1
|
|
> dex
|
|
> dex
|
|
> endif
|
|
> if 2 = 2
|
|
084d : c8 > iny
|
|
084e : ca > dex
|
|
> endif
|
|
> if 2 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
084f : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
0850 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$c2,0
|
|
> load_flag 0
|
|
0852 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
0854 : 48 > pha ;use stack to load status
|
|
0855 : a93d > lda #$ff-$c2 ;precharge accu
|
|
0857 : 28 > plp
|
|
>
|
|
0858 : c2 > db $c2 ;test nop integrity - flags off
|
|
0859 : ea > nop
|
|
085a : ea > nop
|
|
> tst_a $ff-$c2,0
|
|
085b : 08 > php ;save flags
|
|
085c : c93d > cmp #$ff-$c2 ;test result
|
|
> trap_ne
|
|
085e : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0860 : 68 > pla ;load status
|
|
0861 : 48 > pha
|
|
> cmp_flag 0
|
|
0862 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0864 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0866 : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$c2,$ff
|
|
> load_flag $ff
|
|
0867 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
0869 : 48 > pha ;use stack to load status
|
|
086a : a9e8 > lda #$aa-$c2 ;precharge accu
|
|
086c : 28 > plp
|
|
>
|
|
086d : c2 > db $c2 ;test nop integrity - flags on
|
|
086e : ea > nop
|
|
086f : ea > nop
|
|
> tst_a $aa-$c2,$ff
|
|
0870 : 08 > php ;save flags
|
|
0871 : c9e8 > cmp #$aa-$c2 ;test result
|
|
> trap_ne
|
|
0873 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0875 : 68 > pla ;load status
|
|
0876 : 48 > pha
|
|
> cmp_flag $ff
|
|
0877 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0879 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
087b : 28 > plp ;restore status
|
|
>
|
|
087c : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
087e : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0880 : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
0882 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $e2,2
|
|
0884 : a042 > ldy #$42
|
|
0886 : a202 > ldx #4-2
|
|
0888 : e2 > db $e2 ;test nop length
|
|
> if 2 = 1
|
|
> dex
|
|
> dex
|
|
> endif
|
|
> if 2 = 2
|
|
0889 : c8 > iny
|
|
088a : ca > dex
|
|
> endif
|
|
> if 2 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
088b : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
088c : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$e2,0
|
|
> load_flag 0
|
|
088e : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
0890 : 48 > pha ;use stack to load status
|
|
0891 : a91d > lda #$ff-$e2 ;precharge accu
|
|
0893 : 28 > plp
|
|
>
|
|
0894 : e2 > db $e2 ;test nop integrity - flags off
|
|
0895 : ea > nop
|
|
0896 : ea > nop
|
|
> tst_a $ff-$e2,0
|
|
0897 : 08 > php ;save flags
|
|
0898 : c91d > cmp #$ff-$e2 ;test result
|
|
> trap_ne
|
|
089a : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
089c : 68 > pla ;load status
|
|
089d : 48 > pha
|
|
> cmp_flag 0
|
|
089e : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
08a0 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
08a2 : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$e2,$ff
|
|
> load_flag $ff
|
|
08a3 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
08a5 : 48 > pha ;use stack to load status
|
|
08a6 : a9c8 > lda #$aa-$e2 ;precharge accu
|
|
08a8 : 28 > plp
|
|
>
|
|
08a9 : e2 > db $e2 ;test nop integrity - flags on
|
|
08aa : ea > nop
|
|
08ab : ea > nop
|
|
> tst_a $aa-$e2,$ff
|
|
08ac : 08 > php ;save flags
|
|
08ad : c9c8 > cmp #$aa-$e2 ;test result
|
|
> trap_ne
|
|
08af : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
08b1 : 68 > pla ;load status
|
|
08b2 : 48 > pha
|
|
> cmp_flag $ff
|
|
08b3 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
08b5 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
08b7 : 28 > plp ;restore status
|
|
>
|
|
08b8 : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
08ba : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
08bc : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
08be : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $44,2
|
|
08c0 : a042 > ldy #$42
|
|
08c2 : a202 > ldx #4-2
|
|
08c4 : 44 > db $44 ;test nop length
|
|
> if 2 = 1
|
|
> dex
|
|
> dex
|
|
> endif
|
|
> if 2 = 2
|
|
08c5 : c8 > iny
|
|
08c6 : ca > dex
|
|
> endif
|
|
> if 2 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
08c7 : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
08c8 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$44,0
|
|
> load_flag 0
|
|
08ca : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
08cc : 48 > pha ;use stack to load status
|
|
08cd : a9bb > lda #$ff-$44 ;precharge accu
|
|
08cf : 28 > plp
|
|
>
|
|
08d0 : 44 > db $44 ;test nop integrity - flags off
|
|
08d1 : ea > nop
|
|
08d2 : ea > nop
|
|
> tst_a $ff-$44,0
|
|
08d3 : 08 > php ;save flags
|
|
08d4 : c9bb > cmp #$ff-$44 ;test result
|
|
> trap_ne
|
|
08d6 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
08d8 : 68 > pla ;load status
|
|
08d9 : 48 > pha
|
|
> cmp_flag 0
|
|
08da : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
08dc : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
08de : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$44,$ff
|
|
> load_flag $ff
|
|
08df : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
08e1 : 48 > pha ;use stack to load status
|
|
08e2 : a966 > lda #$aa-$44 ;precharge accu
|
|
08e4 : 28 > plp
|
|
>
|
|
08e5 : 44 > db $44 ;test nop integrity - flags on
|
|
08e6 : ea > nop
|
|
08e7 : ea > nop
|
|
> tst_a $aa-$44,$ff
|
|
08e8 : 08 > php ;save flags
|
|
08e9 : c966 > cmp #$aa-$44 ;test result
|
|
> trap_ne
|
|
08eb : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
08ed : 68 > pla ;load status
|
|
08ee : 48 > pha
|
|
> cmp_flag $ff
|
|
08ef : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
08f1 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
08f3 : 28 > plp ;restore status
|
|
>
|
|
08f4 : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
08f6 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
08f8 : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
08fa : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $54,2
|
|
08fc : a042 > ldy #$42
|
|
08fe : a202 > ldx #4-2
|
|
0900 : 54 > db $54 ;test nop length
|
|
> if 2 = 1
|
|
> dex
|
|
> dex
|
|
> endif
|
|
> if 2 = 2
|
|
0901 : c8 > iny
|
|
0902 : ca > dex
|
|
> endif
|
|
> if 2 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
0903 : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
0904 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$54,0
|
|
> load_flag 0
|
|
0906 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
0908 : 48 > pha ;use stack to load status
|
|
0909 : a9ab > lda #$ff-$54 ;precharge accu
|
|
090b : 28 > plp
|
|
>
|
|
090c : 54 > db $54 ;test nop integrity - flags off
|
|
090d : ea > nop
|
|
090e : ea > nop
|
|
> tst_a $ff-$54,0
|
|
090f : 08 > php ;save flags
|
|
0910 : c9ab > cmp #$ff-$54 ;test result
|
|
> trap_ne
|
|
0912 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0914 : 68 > pla ;load status
|
|
0915 : 48 > pha
|
|
> cmp_flag 0
|
|
0916 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0918 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
091a : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$54,$ff
|
|
> load_flag $ff
|
|
091b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
091d : 48 > pha ;use stack to load status
|
|
091e : a956 > lda #$aa-$54 ;precharge accu
|
|
0920 : 28 > plp
|
|
>
|
|
0921 : 54 > db $54 ;test nop integrity - flags on
|
|
0922 : ea > nop
|
|
0923 : ea > nop
|
|
> tst_a $aa-$54,$ff
|
|
0924 : 08 > php ;save flags
|
|
0925 : c956 > cmp #$aa-$54 ;test result
|
|
> trap_ne
|
|
0927 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0929 : 68 > pla ;load status
|
|
092a : 48 > pha
|
|
> cmp_flag $ff
|
|
092b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
092d : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
092f : 28 > plp ;restore status
|
|
>
|
|
0930 : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
0932 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0934 : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
0936 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $d4,2
|
|
0938 : a042 > ldy #$42
|
|
093a : a202 > ldx #4-2
|
|
093c : d4 > db $d4 ;test nop length
|
|
> if 2 = 1
|
|
> dex
|
|
> dex
|
|
> endif
|
|
> if 2 = 2
|
|
093d : c8 > iny
|
|
093e : ca > dex
|
|
> endif
|
|
> if 2 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
093f : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
0940 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$d4,0
|
|
> load_flag 0
|
|
0942 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
0944 : 48 > pha ;use stack to load status
|
|
0945 : a92b > lda #$ff-$d4 ;precharge accu
|
|
0947 : 28 > plp
|
|
>
|
|
0948 : d4 > db $d4 ;test nop integrity - flags off
|
|
0949 : ea > nop
|
|
094a : ea > nop
|
|
> tst_a $ff-$d4,0
|
|
094b : 08 > php ;save flags
|
|
094c : c92b > cmp #$ff-$d4 ;test result
|
|
> trap_ne
|
|
094e : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0950 : 68 > pla ;load status
|
|
0951 : 48 > pha
|
|
> cmp_flag 0
|
|
0952 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0954 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0956 : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$d4,$ff
|
|
> load_flag $ff
|
|
0957 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
0959 : 48 > pha ;use stack to load status
|
|
095a : a9d6 > lda #$aa-$d4 ;precharge accu
|
|
095c : 28 > plp
|
|
>
|
|
095d : d4 > db $d4 ;test nop integrity - flags on
|
|
095e : ea > nop
|
|
095f : ea > nop
|
|
> tst_a $aa-$d4,$ff
|
|
0960 : 08 > php ;save flags
|
|
0961 : c9d6 > cmp #$aa-$d4 ;test result
|
|
> trap_ne
|
|
0963 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0965 : 68 > pla ;load status
|
|
0966 : 48 > pha
|
|
> cmp_flag $ff
|
|
0967 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0969 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
096b : 28 > plp ;restore status
|
|
>
|
|
096c : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
096e : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0970 : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
0972 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $f4,2
|
|
0974 : a042 > ldy #$42
|
|
0976 : a202 > ldx #4-2
|
|
0978 : f4 > db $f4 ;test nop length
|
|
> if 2 = 1
|
|
> dex
|
|
> dex
|
|
> endif
|
|
> if 2 = 2
|
|
0979 : c8 > iny
|
|
097a : ca > dex
|
|
> endif
|
|
> if 2 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
097b : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
097c : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$f4,0
|
|
> load_flag 0
|
|
097e : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
0980 : 48 > pha ;use stack to load status
|
|
0981 : a90b > lda #$ff-$f4 ;precharge accu
|
|
0983 : 28 > plp
|
|
>
|
|
0984 : f4 > db $f4 ;test nop integrity - flags off
|
|
0985 : ea > nop
|
|
0986 : ea > nop
|
|
> tst_a $ff-$f4,0
|
|
0987 : 08 > php ;save flags
|
|
0988 : c90b > cmp #$ff-$f4 ;test result
|
|
> trap_ne
|
|
098a : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
098c : 68 > pla ;load status
|
|
098d : 48 > pha
|
|
> cmp_flag 0
|
|
098e : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0990 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0992 : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$f4,$ff
|
|
> load_flag $ff
|
|
0993 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
0995 : 48 > pha ;use stack to load status
|
|
0996 : a9b6 > lda #$aa-$f4 ;precharge accu
|
|
0998 : 28 > plp
|
|
>
|
|
0999 : f4 > db $f4 ;test nop integrity - flags on
|
|
099a : ea > nop
|
|
099b : ea > nop
|
|
> tst_a $aa-$f4,$ff
|
|
099c : 08 > php ;save flags
|
|
099d : c9b6 > cmp #$aa-$f4 ;test result
|
|
> trap_ne
|
|
099f : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
09a1 : 68 > pla ;load status
|
|
09a2 : 48 > pha
|
|
> cmp_flag $ff
|
|
09a3 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
09a5 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
09a7 : 28 > plp ;restore status
|
|
>
|
|
09a8 : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
09aa : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
09ac : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
09ae : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $5c,3
|
|
09b0 : a042 > ldy #$42
|
|
09b2 : a201 > ldx #4-3
|
|
09b4 : 5c > db $5c ;test nop length
|
|
> if 3 = 1
|
|
> dex
|
|
> dex
|
|
> endif
|
|
> if 3 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 3 = 3
|
|
09b5 : c8 > iny
|
|
09b6 : c8 > iny
|
|
> endif
|
|
09b7 : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
09b8 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$5c,0
|
|
> load_flag 0
|
|
09ba : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
09bc : 48 > pha ;use stack to load status
|
|
09bd : a9a3 > lda #$ff-$5c ;precharge accu
|
|
09bf : 28 > plp
|
|
>
|
|
09c0 : 5c > db $5c ;test nop integrity - flags off
|
|
09c1 : ea > nop
|
|
09c2 : ea > nop
|
|
> tst_a $ff-$5c,0
|
|
09c3 : 08 > php ;save flags
|
|
09c4 : c9a3 > cmp #$ff-$5c ;test result
|
|
> trap_ne
|
|
09c6 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
09c8 : 68 > pla ;load status
|
|
09c9 : 48 > pha
|
|
> cmp_flag 0
|
|
09ca : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
09cc : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
09ce : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$5c,$ff
|
|
> load_flag $ff
|
|
09cf : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
09d1 : 48 > pha ;use stack to load status
|
|
09d2 : a94e > lda #$aa-$5c ;precharge accu
|
|
09d4 : 28 > plp
|
|
>
|
|
09d5 : 5c > db $5c ;test nop integrity - flags on
|
|
09d6 : ea > nop
|
|
09d7 : ea > nop
|
|
> tst_a $aa-$5c,$ff
|
|
09d8 : 08 > php ;save flags
|
|
09d9 : c94e > cmp #$aa-$5c ;test result
|
|
> trap_ne
|
|
09db : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
09dd : 68 > pla ;load status
|
|
09de : 48 > pha
|
|
> cmp_flag $ff
|
|
09df : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
09e1 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
09e3 : 28 > plp ;restore status
|
|
>
|
|
09e4 : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
09e6 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
09e8 : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
09ea : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $dc,3
|
|
09ec : a042 > ldy #$42
|
|
09ee : a201 > ldx #4-3
|
|
09f0 : dc > db $dc ;test nop length
|
|
> if 3 = 1
|
|
> dex
|
|
> dex
|
|
> endif
|
|
> if 3 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 3 = 3
|
|
09f1 : c8 > iny
|
|
09f2 : c8 > iny
|
|
> endif
|
|
09f3 : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
09f4 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$dc,0
|
|
> load_flag 0
|
|
09f6 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
09f8 : 48 > pha ;use stack to load status
|
|
09f9 : a923 > lda #$ff-$dc ;precharge accu
|
|
09fb : 28 > plp
|
|
>
|
|
09fc : dc > db $dc ;test nop integrity - flags off
|
|
09fd : ea > nop
|
|
09fe : ea > nop
|
|
> tst_a $ff-$dc,0
|
|
09ff : 08 > php ;save flags
|
|
0a00 : c923 > cmp #$ff-$dc ;test result
|
|
> trap_ne
|
|
0a02 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0a04 : 68 > pla ;load status
|
|
0a05 : 48 > pha
|
|
> cmp_flag 0
|
|
0a06 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0a08 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0a0a : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$dc,$ff
|
|
> load_flag $ff
|
|
0a0b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
0a0d : 48 > pha ;use stack to load status
|
|
0a0e : a9ce > lda #$aa-$dc ;precharge accu
|
|
0a10 : 28 > plp
|
|
>
|
|
0a11 : dc > db $dc ;test nop integrity - flags on
|
|
0a12 : ea > nop
|
|
0a13 : ea > nop
|
|
> tst_a $aa-$dc,$ff
|
|
0a14 : 08 > php ;save flags
|
|
0a15 : c9ce > cmp #$aa-$dc ;test result
|
|
> trap_ne
|
|
0a17 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0a19 : 68 > pla ;load status
|
|
0a1a : 48 > pha
|
|
> cmp_flag $ff
|
|
0a1b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0a1d : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0a1f : 28 > plp ;restore status
|
|
>
|
|
0a20 : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
0a22 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0a24 : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
0a26 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $fc,3
|
|
0a28 : a042 > ldy #$42
|
|
0a2a : a201 > ldx #4-3
|
|
0a2c : fc > db $fc ;test nop length
|
|
> if 3 = 1
|
|
> dex
|
|
> dex
|
|
> endif
|
|
> if 3 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 3 = 3
|
|
0a2d : c8 > iny
|
|
0a2e : c8 > iny
|
|
> endif
|
|
0a2f : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
0a30 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$fc,0
|
|
> load_flag 0
|
|
0a32 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
0a34 : 48 > pha ;use stack to load status
|
|
0a35 : a903 > lda #$ff-$fc ;precharge accu
|
|
0a37 : 28 > plp
|
|
>
|
|
0a38 : fc > db $fc ;test nop integrity - flags off
|
|
0a39 : ea > nop
|
|
0a3a : ea > nop
|
|
> tst_a $ff-$fc,0
|
|
0a3b : 08 > php ;save flags
|
|
0a3c : c903 > cmp #$ff-$fc ;test result
|
|
> trap_ne
|
|
0a3e : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0a40 : 68 > pla ;load status
|
|
0a41 : 48 > pha
|
|
> cmp_flag 0
|
|
0a42 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0a44 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0a46 : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$fc,$ff
|
|
> load_flag $ff
|
|
0a47 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
0a49 : 48 > pha ;use stack to load status
|
|
0a4a : a9ae > lda #$aa-$fc ;precharge accu
|
|
0a4c : 28 > plp
|
|
>
|
|
0a4d : fc > db $fc ;test nop integrity - flags on
|
|
0a4e : ea > nop
|
|
0a4f : ea > nop
|
|
> tst_a $aa-$fc,$ff
|
|
0a50 : 08 > php ;save flags
|
|
0a51 : c9ae > cmp #$aa-$fc ;test result
|
|
> trap_ne
|
|
0a53 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0a55 : 68 > pla ;load status
|
|
0a56 : 48 > pha
|
|
> cmp_flag $ff
|
|
0a57 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0a59 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0a5b : 28 > plp ;restore status
|
|
>
|
|
0a5c : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
0a5e : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0a60 : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
0a62 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $03,1
|
|
0a64 : a042 > ldy #$42
|
|
0a66 : a203 > ldx #4-1
|
|
0a68 : 03 > db $03 ;test nop length
|
|
> if 1 = 1
|
|
0a69 : ca > dex
|
|
0a6a : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
0a6b : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
0a6c : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$03,0
|
|
> load_flag 0
|
|
0a6e : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
0a70 : 48 > pha ;use stack to load status
|
|
0a71 : a9fc > lda #$ff-$03 ;precharge accu
|
|
0a73 : 28 > plp
|
|
>
|
|
0a74 : 03 > db $03 ;test nop integrity - flags off
|
|
0a75 : ea > nop
|
|
0a76 : ea > nop
|
|
> tst_a $ff-$03,0
|
|
0a77 : 08 > php ;save flags
|
|
0a78 : c9fc > cmp #$ff-$03 ;test result
|
|
> trap_ne
|
|
0a7a : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0a7c : 68 > pla ;load status
|
|
0a7d : 48 > pha
|
|
> cmp_flag 0
|
|
0a7e : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0a80 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0a82 : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$03,$ff
|
|
> load_flag $ff
|
|
0a83 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
0a85 : 48 > pha ;use stack to load status
|
|
0a86 : a9a7 > lda #$aa-$03 ;precharge accu
|
|
0a88 : 28 > plp
|
|
>
|
|
0a89 : 03 > db $03 ;test nop integrity - flags on
|
|
0a8a : ea > nop
|
|
0a8b : ea > nop
|
|
> tst_a $aa-$03,$ff
|
|
0a8c : 08 > php ;save flags
|
|
0a8d : c9a7 > cmp #$aa-$03 ;test result
|
|
> trap_ne
|
|
0a8f : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0a91 : 68 > pla ;load status
|
|
0a92 : 48 > pha
|
|
> cmp_flag $ff
|
|
0a93 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0a95 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0a97 : 28 > plp ;restore status
|
|
>
|
|
0a98 : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
0a9a : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0a9c : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
0a9e : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $13,1
|
|
0aa0 : a042 > ldy #$42
|
|
0aa2 : a203 > ldx #4-1
|
|
0aa4 : 13 > db $13 ;test nop length
|
|
> if 1 = 1
|
|
0aa5 : ca > dex
|
|
0aa6 : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
0aa7 : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
0aa8 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$13,0
|
|
> load_flag 0
|
|
0aaa : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
0aac : 48 > pha ;use stack to load status
|
|
0aad : a9ec > lda #$ff-$13 ;precharge accu
|
|
0aaf : 28 > plp
|
|
>
|
|
0ab0 : 13 > db $13 ;test nop integrity - flags off
|
|
0ab1 : ea > nop
|
|
0ab2 : ea > nop
|
|
> tst_a $ff-$13,0
|
|
0ab3 : 08 > php ;save flags
|
|
0ab4 : c9ec > cmp #$ff-$13 ;test result
|
|
> trap_ne
|
|
0ab6 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0ab8 : 68 > pla ;load status
|
|
0ab9 : 48 > pha
|
|
> cmp_flag 0
|
|
0aba : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0abc : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0abe : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$13,$ff
|
|
> load_flag $ff
|
|
0abf : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
0ac1 : 48 > pha ;use stack to load status
|
|
0ac2 : a997 > lda #$aa-$13 ;precharge accu
|
|
0ac4 : 28 > plp
|
|
>
|
|
0ac5 : 13 > db $13 ;test nop integrity - flags on
|
|
0ac6 : ea > nop
|
|
0ac7 : ea > nop
|
|
> tst_a $aa-$13,$ff
|
|
0ac8 : 08 > php ;save flags
|
|
0ac9 : c997 > cmp #$aa-$13 ;test result
|
|
> trap_ne
|
|
0acb : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0acd : 68 > pla ;load status
|
|
0ace : 48 > pha
|
|
> cmp_flag $ff
|
|
0acf : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0ad1 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0ad3 : 28 > plp ;restore status
|
|
>
|
|
0ad4 : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
0ad6 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0ad8 : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
0ada : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $23,1
|
|
0adc : a042 > ldy #$42
|
|
0ade : a203 > ldx #4-1
|
|
0ae0 : 23 > db $23 ;test nop length
|
|
> if 1 = 1
|
|
0ae1 : ca > dex
|
|
0ae2 : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
0ae3 : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
0ae4 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$23,0
|
|
> load_flag 0
|
|
0ae6 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
0ae8 : 48 > pha ;use stack to load status
|
|
0ae9 : a9dc > lda #$ff-$23 ;precharge accu
|
|
0aeb : 28 > plp
|
|
>
|
|
0aec : 23 > db $23 ;test nop integrity - flags off
|
|
0aed : ea > nop
|
|
0aee : ea > nop
|
|
> tst_a $ff-$23,0
|
|
0aef : 08 > php ;save flags
|
|
0af0 : c9dc > cmp #$ff-$23 ;test result
|
|
> trap_ne
|
|
0af2 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0af4 : 68 > pla ;load status
|
|
0af5 : 48 > pha
|
|
> cmp_flag 0
|
|
0af6 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0af8 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0afa : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$23,$ff
|
|
> load_flag $ff
|
|
0afb : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
0afd : 48 > pha ;use stack to load status
|
|
0afe : a987 > lda #$aa-$23 ;precharge accu
|
|
0b00 : 28 > plp
|
|
>
|
|
0b01 : 23 > db $23 ;test nop integrity - flags on
|
|
0b02 : ea > nop
|
|
0b03 : ea > nop
|
|
> tst_a $aa-$23,$ff
|
|
0b04 : 08 > php ;save flags
|
|
0b05 : c987 > cmp #$aa-$23 ;test result
|
|
> trap_ne
|
|
0b07 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0b09 : 68 > pla ;load status
|
|
0b0a : 48 > pha
|
|
> cmp_flag $ff
|
|
0b0b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0b0d : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0b0f : 28 > plp ;restore status
|
|
>
|
|
0b10 : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
0b12 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0b14 : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
0b16 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $33,1
|
|
0b18 : a042 > ldy #$42
|
|
0b1a : a203 > ldx #4-1
|
|
0b1c : 33 > db $33 ;test nop length
|
|
> if 1 = 1
|
|
0b1d : ca > dex
|
|
0b1e : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
0b1f : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
0b20 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$33,0
|
|
> load_flag 0
|
|
0b22 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
0b24 : 48 > pha ;use stack to load status
|
|
0b25 : a9cc > lda #$ff-$33 ;precharge accu
|
|
0b27 : 28 > plp
|
|
>
|
|
0b28 : 33 > db $33 ;test nop integrity - flags off
|
|
0b29 : ea > nop
|
|
0b2a : ea > nop
|
|
> tst_a $ff-$33,0
|
|
0b2b : 08 > php ;save flags
|
|
0b2c : c9cc > cmp #$ff-$33 ;test result
|
|
> trap_ne
|
|
0b2e : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0b30 : 68 > pla ;load status
|
|
0b31 : 48 > pha
|
|
> cmp_flag 0
|
|
0b32 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0b34 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0b36 : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$33,$ff
|
|
> load_flag $ff
|
|
0b37 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
0b39 : 48 > pha ;use stack to load status
|
|
0b3a : a977 > lda #$aa-$33 ;precharge accu
|
|
0b3c : 28 > plp
|
|
>
|
|
0b3d : 33 > db $33 ;test nop integrity - flags on
|
|
0b3e : ea > nop
|
|
0b3f : ea > nop
|
|
> tst_a $aa-$33,$ff
|
|
0b40 : 08 > php ;save flags
|
|
0b41 : c977 > cmp #$aa-$33 ;test result
|
|
> trap_ne
|
|
0b43 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0b45 : 68 > pla ;load status
|
|
0b46 : 48 > pha
|
|
> cmp_flag $ff
|
|
0b47 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0b49 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0b4b : 28 > plp ;restore status
|
|
>
|
|
0b4c : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
0b4e : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0b50 : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
0b52 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $43,1
|
|
0b54 : a042 > ldy #$42
|
|
0b56 : a203 > ldx #4-1
|
|
0b58 : 43 > db $43 ;test nop length
|
|
> if 1 = 1
|
|
0b59 : ca > dex
|
|
0b5a : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
0b5b : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
0b5c : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$43,0
|
|
> load_flag 0
|
|
0b5e : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
0b60 : 48 > pha ;use stack to load status
|
|
0b61 : a9bc > lda #$ff-$43 ;precharge accu
|
|
0b63 : 28 > plp
|
|
>
|
|
0b64 : 43 > db $43 ;test nop integrity - flags off
|
|
0b65 : ea > nop
|
|
0b66 : ea > nop
|
|
> tst_a $ff-$43,0
|
|
0b67 : 08 > php ;save flags
|
|
0b68 : c9bc > cmp #$ff-$43 ;test result
|
|
> trap_ne
|
|
0b6a : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0b6c : 68 > pla ;load status
|
|
0b6d : 48 > pha
|
|
> cmp_flag 0
|
|
0b6e : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0b70 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0b72 : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$43,$ff
|
|
> load_flag $ff
|
|
0b73 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
0b75 : 48 > pha ;use stack to load status
|
|
0b76 : a967 > lda #$aa-$43 ;precharge accu
|
|
0b78 : 28 > plp
|
|
>
|
|
0b79 : 43 > db $43 ;test nop integrity - flags on
|
|
0b7a : ea > nop
|
|
0b7b : ea > nop
|
|
> tst_a $aa-$43,$ff
|
|
0b7c : 08 > php ;save flags
|
|
0b7d : c967 > cmp #$aa-$43 ;test result
|
|
> trap_ne
|
|
0b7f : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0b81 : 68 > pla ;load status
|
|
0b82 : 48 > pha
|
|
> cmp_flag $ff
|
|
0b83 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0b85 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0b87 : 28 > plp ;restore status
|
|
>
|
|
0b88 : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
0b8a : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0b8c : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
0b8e : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $53,1
|
|
0b90 : a042 > ldy #$42
|
|
0b92 : a203 > ldx #4-1
|
|
0b94 : 53 > db $53 ;test nop length
|
|
> if 1 = 1
|
|
0b95 : ca > dex
|
|
0b96 : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
0b97 : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
0b98 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$53,0
|
|
> load_flag 0
|
|
0b9a : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
0b9c : 48 > pha ;use stack to load status
|
|
0b9d : a9ac > lda #$ff-$53 ;precharge accu
|
|
0b9f : 28 > plp
|
|
>
|
|
0ba0 : 53 > db $53 ;test nop integrity - flags off
|
|
0ba1 : ea > nop
|
|
0ba2 : ea > nop
|
|
> tst_a $ff-$53,0
|
|
0ba3 : 08 > php ;save flags
|
|
0ba4 : c9ac > cmp #$ff-$53 ;test result
|
|
> trap_ne
|
|
0ba6 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0ba8 : 68 > pla ;load status
|
|
0ba9 : 48 > pha
|
|
> cmp_flag 0
|
|
0baa : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0bac : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0bae : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$53,$ff
|
|
> load_flag $ff
|
|
0baf : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
0bb1 : 48 > pha ;use stack to load status
|
|
0bb2 : a957 > lda #$aa-$53 ;precharge accu
|
|
0bb4 : 28 > plp
|
|
>
|
|
0bb5 : 53 > db $53 ;test nop integrity - flags on
|
|
0bb6 : ea > nop
|
|
0bb7 : ea > nop
|
|
> tst_a $aa-$53,$ff
|
|
0bb8 : 08 > php ;save flags
|
|
0bb9 : c957 > cmp #$aa-$53 ;test result
|
|
> trap_ne
|
|
0bbb : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0bbd : 68 > pla ;load status
|
|
0bbe : 48 > pha
|
|
> cmp_flag $ff
|
|
0bbf : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0bc1 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0bc3 : 28 > plp ;restore status
|
|
>
|
|
0bc4 : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
0bc6 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0bc8 : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
0bca : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $63,1
|
|
0bcc : a042 > ldy #$42
|
|
0bce : a203 > ldx #4-1
|
|
0bd0 : 63 > db $63 ;test nop length
|
|
> if 1 = 1
|
|
0bd1 : ca > dex
|
|
0bd2 : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
0bd3 : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
0bd4 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$63,0
|
|
> load_flag 0
|
|
0bd6 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
0bd8 : 48 > pha ;use stack to load status
|
|
0bd9 : a99c > lda #$ff-$63 ;precharge accu
|
|
0bdb : 28 > plp
|
|
>
|
|
0bdc : 63 > db $63 ;test nop integrity - flags off
|
|
0bdd : ea > nop
|
|
0bde : ea > nop
|
|
> tst_a $ff-$63,0
|
|
0bdf : 08 > php ;save flags
|
|
0be0 : c99c > cmp #$ff-$63 ;test result
|
|
> trap_ne
|
|
0be2 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0be4 : 68 > pla ;load status
|
|
0be5 : 48 > pha
|
|
> cmp_flag 0
|
|
0be6 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0be8 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0bea : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$63,$ff
|
|
> load_flag $ff
|
|
0beb : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
0bed : 48 > pha ;use stack to load status
|
|
0bee : a947 > lda #$aa-$63 ;precharge accu
|
|
0bf0 : 28 > plp
|
|
>
|
|
0bf1 : 63 > db $63 ;test nop integrity - flags on
|
|
0bf2 : ea > nop
|
|
0bf3 : ea > nop
|
|
> tst_a $aa-$63,$ff
|
|
0bf4 : 08 > php ;save flags
|
|
0bf5 : c947 > cmp #$aa-$63 ;test result
|
|
> trap_ne
|
|
0bf7 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0bf9 : 68 > pla ;load status
|
|
0bfa : 48 > pha
|
|
> cmp_flag $ff
|
|
0bfb : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0bfd : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0bff : 28 > plp ;restore status
|
|
>
|
|
0c00 : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
0c02 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0c04 : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
0c06 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $73,1
|
|
0c08 : a042 > ldy #$42
|
|
0c0a : a203 > ldx #4-1
|
|
0c0c : 73 > db $73 ;test nop length
|
|
> if 1 = 1
|
|
0c0d : ca > dex
|
|
0c0e : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
0c0f : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
0c10 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$73,0
|
|
> load_flag 0
|
|
0c12 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
0c14 : 48 > pha ;use stack to load status
|
|
0c15 : a98c > lda #$ff-$73 ;precharge accu
|
|
0c17 : 28 > plp
|
|
>
|
|
0c18 : 73 > db $73 ;test nop integrity - flags off
|
|
0c19 : ea > nop
|
|
0c1a : ea > nop
|
|
> tst_a $ff-$73,0
|
|
0c1b : 08 > php ;save flags
|
|
0c1c : c98c > cmp #$ff-$73 ;test result
|
|
> trap_ne
|
|
0c1e : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0c20 : 68 > pla ;load status
|
|
0c21 : 48 > pha
|
|
> cmp_flag 0
|
|
0c22 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0c24 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0c26 : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$73,$ff
|
|
> load_flag $ff
|
|
0c27 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
0c29 : 48 > pha ;use stack to load status
|
|
0c2a : a937 > lda #$aa-$73 ;precharge accu
|
|
0c2c : 28 > plp
|
|
>
|
|
0c2d : 73 > db $73 ;test nop integrity - flags on
|
|
0c2e : ea > nop
|
|
0c2f : ea > nop
|
|
> tst_a $aa-$73,$ff
|
|
0c30 : 08 > php ;save flags
|
|
0c31 : c937 > cmp #$aa-$73 ;test result
|
|
> trap_ne
|
|
0c33 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0c35 : 68 > pla ;load status
|
|
0c36 : 48 > pha
|
|
> cmp_flag $ff
|
|
0c37 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0c39 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0c3b : 28 > plp ;restore status
|
|
>
|
|
0c3c : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
0c3e : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0c40 : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
0c42 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $83,1
|
|
0c44 : a042 > ldy #$42
|
|
0c46 : a203 > ldx #4-1
|
|
0c48 : 83 > db $83 ;test nop length
|
|
> if 1 = 1
|
|
0c49 : ca > dex
|
|
0c4a : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
0c4b : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
0c4c : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$83,0
|
|
> load_flag 0
|
|
0c4e : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
0c50 : 48 > pha ;use stack to load status
|
|
0c51 : a97c > lda #$ff-$83 ;precharge accu
|
|
0c53 : 28 > plp
|
|
>
|
|
0c54 : 83 > db $83 ;test nop integrity - flags off
|
|
0c55 : ea > nop
|
|
0c56 : ea > nop
|
|
> tst_a $ff-$83,0
|
|
0c57 : 08 > php ;save flags
|
|
0c58 : c97c > cmp #$ff-$83 ;test result
|
|
> trap_ne
|
|
0c5a : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0c5c : 68 > pla ;load status
|
|
0c5d : 48 > pha
|
|
> cmp_flag 0
|
|
0c5e : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0c60 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0c62 : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$83,$ff
|
|
> load_flag $ff
|
|
0c63 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
0c65 : 48 > pha ;use stack to load status
|
|
0c66 : a927 > lda #$aa-$83 ;precharge accu
|
|
0c68 : 28 > plp
|
|
>
|
|
0c69 : 83 > db $83 ;test nop integrity - flags on
|
|
0c6a : ea > nop
|
|
0c6b : ea > nop
|
|
> tst_a $aa-$83,$ff
|
|
0c6c : 08 > php ;save flags
|
|
0c6d : c927 > cmp #$aa-$83 ;test result
|
|
> trap_ne
|
|
0c6f : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0c71 : 68 > pla ;load status
|
|
0c72 : 48 > pha
|
|
> cmp_flag $ff
|
|
0c73 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0c75 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0c77 : 28 > plp ;restore status
|
|
>
|
|
0c78 : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
0c7a : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0c7c : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
0c7e : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $93,1
|
|
0c80 : a042 > ldy #$42
|
|
0c82 : a203 > ldx #4-1
|
|
0c84 : 93 > db $93 ;test nop length
|
|
> if 1 = 1
|
|
0c85 : ca > dex
|
|
0c86 : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
0c87 : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
0c88 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$93,0
|
|
> load_flag 0
|
|
0c8a : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
0c8c : 48 > pha ;use stack to load status
|
|
0c8d : a96c > lda #$ff-$93 ;precharge accu
|
|
0c8f : 28 > plp
|
|
>
|
|
0c90 : 93 > db $93 ;test nop integrity - flags off
|
|
0c91 : ea > nop
|
|
0c92 : ea > nop
|
|
> tst_a $ff-$93,0
|
|
0c93 : 08 > php ;save flags
|
|
0c94 : c96c > cmp #$ff-$93 ;test result
|
|
> trap_ne
|
|
0c96 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0c98 : 68 > pla ;load status
|
|
0c99 : 48 > pha
|
|
> cmp_flag 0
|
|
0c9a : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0c9c : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0c9e : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$93,$ff
|
|
> load_flag $ff
|
|
0c9f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
0ca1 : 48 > pha ;use stack to load status
|
|
0ca2 : a917 > lda #$aa-$93 ;precharge accu
|
|
0ca4 : 28 > plp
|
|
>
|
|
0ca5 : 93 > db $93 ;test nop integrity - flags on
|
|
0ca6 : ea > nop
|
|
0ca7 : ea > nop
|
|
> tst_a $aa-$93,$ff
|
|
0ca8 : 08 > php ;save flags
|
|
0ca9 : c917 > cmp #$aa-$93 ;test result
|
|
> trap_ne
|
|
0cab : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0cad : 68 > pla ;load status
|
|
0cae : 48 > pha
|
|
> cmp_flag $ff
|
|
0caf : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0cb1 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0cb3 : 28 > plp ;restore status
|
|
>
|
|
0cb4 : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
0cb6 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0cb8 : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
0cba : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $a3,1
|
|
0cbc : a042 > ldy #$42
|
|
0cbe : a203 > ldx #4-1
|
|
0cc0 : a3 > db $a3 ;test nop length
|
|
> if 1 = 1
|
|
0cc1 : ca > dex
|
|
0cc2 : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
0cc3 : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
0cc4 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$a3,0
|
|
> load_flag 0
|
|
0cc6 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
0cc8 : 48 > pha ;use stack to load status
|
|
0cc9 : a95c > lda #$ff-$a3 ;precharge accu
|
|
0ccb : 28 > plp
|
|
>
|
|
0ccc : a3 > db $a3 ;test nop integrity - flags off
|
|
0ccd : ea > nop
|
|
0cce : ea > nop
|
|
> tst_a $ff-$a3,0
|
|
0ccf : 08 > php ;save flags
|
|
0cd0 : c95c > cmp #$ff-$a3 ;test result
|
|
> trap_ne
|
|
0cd2 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0cd4 : 68 > pla ;load status
|
|
0cd5 : 48 > pha
|
|
> cmp_flag 0
|
|
0cd6 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0cd8 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0cda : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$a3,$ff
|
|
> load_flag $ff
|
|
0cdb : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
0cdd : 48 > pha ;use stack to load status
|
|
0cde : a907 > lda #$aa-$a3 ;precharge accu
|
|
0ce0 : 28 > plp
|
|
>
|
|
0ce1 : a3 > db $a3 ;test nop integrity - flags on
|
|
0ce2 : ea > nop
|
|
0ce3 : ea > nop
|
|
> tst_a $aa-$a3,$ff
|
|
0ce4 : 08 > php ;save flags
|
|
0ce5 : c907 > cmp #$aa-$a3 ;test result
|
|
> trap_ne
|
|
0ce7 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0ce9 : 68 > pla ;load status
|
|
0cea : 48 > pha
|
|
> cmp_flag $ff
|
|
0ceb : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0ced : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0cef : 28 > plp ;restore status
|
|
>
|
|
0cf0 : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
0cf2 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0cf4 : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
0cf6 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $b3,1
|
|
0cf8 : a042 > ldy #$42
|
|
0cfa : a203 > ldx #4-1
|
|
0cfc : b3 > db $b3 ;test nop length
|
|
> if 1 = 1
|
|
0cfd : ca > dex
|
|
0cfe : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
0cff : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
0d00 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$b3,0
|
|
> load_flag 0
|
|
0d02 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
0d04 : 48 > pha ;use stack to load status
|
|
0d05 : a94c > lda #$ff-$b3 ;precharge accu
|
|
0d07 : 28 > plp
|
|
>
|
|
0d08 : b3 > db $b3 ;test nop integrity - flags off
|
|
0d09 : ea > nop
|
|
0d0a : ea > nop
|
|
> tst_a $ff-$b3,0
|
|
0d0b : 08 > php ;save flags
|
|
0d0c : c94c > cmp #$ff-$b3 ;test result
|
|
> trap_ne
|
|
0d0e : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0d10 : 68 > pla ;load status
|
|
0d11 : 48 > pha
|
|
> cmp_flag 0
|
|
0d12 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0d14 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0d16 : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$b3,$ff
|
|
> load_flag $ff
|
|
0d17 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
0d19 : 48 > pha ;use stack to load status
|
|
0d1a : a9f7 > lda #$aa-$b3 ;precharge accu
|
|
0d1c : 28 > plp
|
|
>
|
|
0d1d : b3 > db $b3 ;test nop integrity - flags on
|
|
0d1e : ea > nop
|
|
0d1f : ea > nop
|
|
> tst_a $aa-$b3,$ff
|
|
0d20 : 08 > php ;save flags
|
|
0d21 : c9f7 > cmp #$aa-$b3 ;test result
|
|
> trap_ne
|
|
0d23 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0d25 : 68 > pla ;load status
|
|
0d26 : 48 > pha
|
|
> cmp_flag $ff
|
|
0d27 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0d29 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0d2b : 28 > plp ;restore status
|
|
>
|
|
0d2c : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
0d2e : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0d30 : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
0d32 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $c3,1
|
|
0d34 : a042 > ldy #$42
|
|
0d36 : a203 > ldx #4-1
|
|
0d38 : c3 > db $c3 ;test nop length
|
|
> if 1 = 1
|
|
0d39 : ca > dex
|
|
0d3a : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
0d3b : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
0d3c : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$c3,0
|
|
> load_flag 0
|
|
0d3e : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
0d40 : 48 > pha ;use stack to load status
|
|
0d41 : a93c > lda #$ff-$c3 ;precharge accu
|
|
0d43 : 28 > plp
|
|
>
|
|
0d44 : c3 > db $c3 ;test nop integrity - flags off
|
|
0d45 : ea > nop
|
|
0d46 : ea > nop
|
|
> tst_a $ff-$c3,0
|
|
0d47 : 08 > php ;save flags
|
|
0d48 : c93c > cmp #$ff-$c3 ;test result
|
|
> trap_ne
|
|
0d4a : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0d4c : 68 > pla ;load status
|
|
0d4d : 48 > pha
|
|
> cmp_flag 0
|
|
0d4e : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0d50 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0d52 : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$c3,$ff
|
|
> load_flag $ff
|
|
0d53 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
0d55 : 48 > pha ;use stack to load status
|
|
0d56 : a9e7 > lda #$aa-$c3 ;precharge accu
|
|
0d58 : 28 > plp
|
|
>
|
|
0d59 : c3 > db $c3 ;test nop integrity - flags on
|
|
0d5a : ea > nop
|
|
0d5b : ea > nop
|
|
> tst_a $aa-$c3,$ff
|
|
0d5c : 08 > php ;save flags
|
|
0d5d : c9e7 > cmp #$aa-$c3 ;test result
|
|
> trap_ne
|
|
0d5f : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0d61 : 68 > pla ;load status
|
|
0d62 : 48 > pha
|
|
> cmp_flag $ff
|
|
0d63 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0d65 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0d67 : 28 > plp ;restore status
|
|
>
|
|
0d68 : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
0d6a : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0d6c : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
0d6e : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $d3,1
|
|
0d70 : a042 > ldy #$42
|
|
0d72 : a203 > ldx #4-1
|
|
0d74 : d3 > db $d3 ;test nop length
|
|
> if 1 = 1
|
|
0d75 : ca > dex
|
|
0d76 : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
0d77 : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
0d78 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$d3,0
|
|
> load_flag 0
|
|
0d7a : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
0d7c : 48 > pha ;use stack to load status
|
|
0d7d : a92c > lda #$ff-$d3 ;precharge accu
|
|
0d7f : 28 > plp
|
|
>
|
|
0d80 : d3 > db $d3 ;test nop integrity - flags off
|
|
0d81 : ea > nop
|
|
0d82 : ea > nop
|
|
> tst_a $ff-$d3,0
|
|
0d83 : 08 > php ;save flags
|
|
0d84 : c92c > cmp #$ff-$d3 ;test result
|
|
> trap_ne
|
|
0d86 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0d88 : 68 > pla ;load status
|
|
0d89 : 48 > pha
|
|
> cmp_flag 0
|
|
0d8a : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0d8c : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0d8e : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$d3,$ff
|
|
> load_flag $ff
|
|
0d8f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
0d91 : 48 > pha ;use stack to load status
|
|
0d92 : a9d7 > lda #$aa-$d3 ;precharge accu
|
|
0d94 : 28 > plp
|
|
>
|
|
0d95 : d3 > db $d3 ;test nop integrity - flags on
|
|
0d96 : ea > nop
|
|
0d97 : ea > nop
|
|
> tst_a $aa-$d3,$ff
|
|
0d98 : 08 > php ;save flags
|
|
0d99 : c9d7 > cmp #$aa-$d3 ;test result
|
|
> trap_ne
|
|
0d9b : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0d9d : 68 > pla ;load status
|
|
0d9e : 48 > pha
|
|
> cmp_flag $ff
|
|
0d9f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0da1 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0da3 : 28 > plp ;restore status
|
|
>
|
|
0da4 : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
0da6 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0da8 : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
0daa : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $e3,1
|
|
0dac : a042 > ldy #$42
|
|
0dae : a203 > ldx #4-1
|
|
0db0 : e3 > db $e3 ;test nop length
|
|
> if 1 = 1
|
|
0db1 : ca > dex
|
|
0db2 : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
0db3 : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
0db4 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$e3,0
|
|
> load_flag 0
|
|
0db6 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
0db8 : 48 > pha ;use stack to load status
|
|
0db9 : a91c > lda #$ff-$e3 ;precharge accu
|
|
0dbb : 28 > plp
|
|
>
|
|
0dbc : e3 > db $e3 ;test nop integrity - flags off
|
|
0dbd : ea > nop
|
|
0dbe : ea > nop
|
|
> tst_a $ff-$e3,0
|
|
0dbf : 08 > php ;save flags
|
|
0dc0 : c91c > cmp #$ff-$e3 ;test result
|
|
> trap_ne
|
|
0dc2 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0dc4 : 68 > pla ;load status
|
|
0dc5 : 48 > pha
|
|
> cmp_flag 0
|
|
0dc6 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0dc8 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0dca : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$e3,$ff
|
|
> load_flag $ff
|
|
0dcb : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
0dcd : 48 > pha ;use stack to load status
|
|
0dce : a9c7 > lda #$aa-$e3 ;precharge accu
|
|
0dd0 : 28 > plp
|
|
>
|
|
0dd1 : e3 > db $e3 ;test nop integrity - flags on
|
|
0dd2 : ea > nop
|
|
0dd3 : ea > nop
|
|
> tst_a $aa-$e3,$ff
|
|
0dd4 : 08 > php ;save flags
|
|
0dd5 : c9c7 > cmp #$aa-$e3 ;test result
|
|
> trap_ne
|
|
0dd7 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0dd9 : 68 > pla ;load status
|
|
0dda : 48 > pha
|
|
> cmp_flag $ff
|
|
0ddb : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0ddd : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0ddf : 28 > plp ;restore status
|
|
>
|
|
0de0 : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
0de2 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0de4 : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
0de6 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $f3,1
|
|
0de8 : a042 > ldy #$42
|
|
0dea : a203 > ldx #4-1
|
|
0dec : f3 > db $f3 ;test nop length
|
|
> if 1 = 1
|
|
0ded : ca > dex
|
|
0dee : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
0def : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
0df0 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$f3,0
|
|
> load_flag 0
|
|
0df2 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
0df4 : 48 > pha ;use stack to load status
|
|
0df5 : a90c > lda #$ff-$f3 ;precharge accu
|
|
0df7 : 28 > plp
|
|
>
|
|
0df8 : f3 > db $f3 ;test nop integrity - flags off
|
|
0df9 : ea > nop
|
|
0dfa : ea > nop
|
|
> tst_a $ff-$f3,0
|
|
0dfb : 08 > php ;save flags
|
|
0dfc : c90c > cmp #$ff-$f3 ;test result
|
|
> trap_ne
|
|
0dfe : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0e00 : 68 > pla ;load status
|
|
0e01 : 48 > pha
|
|
> cmp_flag 0
|
|
0e02 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0e04 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0e06 : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$f3,$ff
|
|
> load_flag $ff
|
|
0e07 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
0e09 : 48 > pha ;use stack to load status
|
|
0e0a : a9b7 > lda #$aa-$f3 ;precharge accu
|
|
0e0c : 28 > plp
|
|
>
|
|
0e0d : f3 > db $f3 ;test nop integrity - flags on
|
|
0e0e : ea > nop
|
|
0e0f : ea > nop
|
|
> tst_a $aa-$f3,$ff
|
|
0e10 : 08 > php ;save flags
|
|
0e11 : c9b7 > cmp #$aa-$f3 ;test result
|
|
> trap_ne
|
|
0e13 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0e15 : 68 > pla ;load status
|
|
0e16 : 48 > pha
|
|
> cmp_flag $ff
|
|
0e17 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0e19 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0e1b : 28 > plp ;restore status
|
|
>
|
|
0e1c : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
0e1e : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0e20 : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
0e22 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $0b,1
|
|
0e24 : a042 > ldy #$42
|
|
0e26 : a203 > ldx #4-1
|
|
0e28 : 0b > db $0b ;test nop length
|
|
> if 1 = 1
|
|
0e29 : ca > dex
|
|
0e2a : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
0e2b : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
0e2c : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$0b,0
|
|
> load_flag 0
|
|
0e2e : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
0e30 : 48 > pha ;use stack to load status
|
|
0e31 : a9f4 > lda #$ff-$0b ;precharge accu
|
|
0e33 : 28 > plp
|
|
>
|
|
0e34 : 0b > db $0b ;test nop integrity - flags off
|
|
0e35 : ea > nop
|
|
0e36 : ea > nop
|
|
> tst_a $ff-$0b,0
|
|
0e37 : 08 > php ;save flags
|
|
0e38 : c9f4 > cmp #$ff-$0b ;test result
|
|
> trap_ne
|
|
0e3a : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0e3c : 68 > pla ;load status
|
|
0e3d : 48 > pha
|
|
> cmp_flag 0
|
|
0e3e : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0e40 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0e42 : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$0b,$ff
|
|
> load_flag $ff
|
|
0e43 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
0e45 : 48 > pha ;use stack to load status
|
|
0e46 : a99f > lda #$aa-$0b ;precharge accu
|
|
0e48 : 28 > plp
|
|
>
|
|
0e49 : 0b > db $0b ;test nop integrity - flags on
|
|
0e4a : ea > nop
|
|
0e4b : ea > nop
|
|
> tst_a $aa-$0b,$ff
|
|
0e4c : 08 > php ;save flags
|
|
0e4d : c99f > cmp #$aa-$0b ;test result
|
|
> trap_ne
|
|
0e4f : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0e51 : 68 > pla ;load status
|
|
0e52 : 48 > pha
|
|
> cmp_flag $ff
|
|
0e53 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0e55 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0e57 : 28 > plp ;restore status
|
|
>
|
|
0e58 : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
0e5a : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0e5c : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
0e5e : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $1b,1
|
|
0e60 : a042 > ldy #$42
|
|
0e62 : a203 > ldx #4-1
|
|
0e64 : 1b > db $1b ;test nop length
|
|
> if 1 = 1
|
|
0e65 : ca > dex
|
|
0e66 : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
0e67 : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
0e68 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$1b,0
|
|
> load_flag 0
|
|
0e6a : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
0e6c : 48 > pha ;use stack to load status
|
|
0e6d : a9e4 > lda #$ff-$1b ;precharge accu
|
|
0e6f : 28 > plp
|
|
>
|
|
0e70 : 1b > db $1b ;test nop integrity - flags off
|
|
0e71 : ea > nop
|
|
0e72 : ea > nop
|
|
> tst_a $ff-$1b,0
|
|
0e73 : 08 > php ;save flags
|
|
0e74 : c9e4 > cmp #$ff-$1b ;test result
|
|
> trap_ne
|
|
0e76 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0e78 : 68 > pla ;load status
|
|
0e79 : 48 > pha
|
|
> cmp_flag 0
|
|
0e7a : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0e7c : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0e7e : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$1b,$ff
|
|
> load_flag $ff
|
|
0e7f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
0e81 : 48 > pha ;use stack to load status
|
|
0e82 : a98f > lda #$aa-$1b ;precharge accu
|
|
0e84 : 28 > plp
|
|
>
|
|
0e85 : 1b > db $1b ;test nop integrity - flags on
|
|
0e86 : ea > nop
|
|
0e87 : ea > nop
|
|
> tst_a $aa-$1b,$ff
|
|
0e88 : 08 > php ;save flags
|
|
0e89 : c98f > cmp #$aa-$1b ;test result
|
|
> trap_ne
|
|
0e8b : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0e8d : 68 > pla ;load status
|
|
0e8e : 48 > pha
|
|
> cmp_flag $ff
|
|
0e8f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0e91 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0e93 : 28 > plp ;restore status
|
|
>
|
|
0e94 : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
0e96 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0e98 : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
0e9a : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $2b,1
|
|
0e9c : a042 > ldy #$42
|
|
0e9e : a203 > ldx #4-1
|
|
0ea0 : 2b > db $2b ;test nop length
|
|
> if 1 = 1
|
|
0ea1 : ca > dex
|
|
0ea2 : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
0ea3 : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
0ea4 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$2b,0
|
|
> load_flag 0
|
|
0ea6 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
0ea8 : 48 > pha ;use stack to load status
|
|
0ea9 : a9d4 > lda #$ff-$2b ;precharge accu
|
|
0eab : 28 > plp
|
|
>
|
|
0eac : 2b > db $2b ;test nop integrity - flags off
|
|
0ead : ea > nop
|
|
0eae : ea > nop
|
|
> tst_a $ff-$2b,0
|
|
0eaf : 08 > php ;save flags
|
|
0eb0 : c9d4 > cmp #$ff-$2b ;test result
|
|
> trap_ne
|
|
0eb2 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0eb4 : 68 > pla ;load status
|
|
0eb5 : 48 > pha
|
|
> cmp_flag 0
|
|
0eb6 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0eb8 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0eba : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$2b,$ff
|
|
> load_flag $ff
|
|
0ebb : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
0ebd : 48 > pha ;use stack to load status
|
|
0ebe : a97f > lda #$aa-$2b ;precharge accu
|
|
0ec0 : 28 > plp
|
|
>
|
|
0ec1 : 2b > db $2b ;test nop integrity - flags on
|
|
0ec2 : ea > nop
|
|
0ec3 : ea > nop
|
|
> tst_a $aa-$2b,$ff
|
|
0ec4 : 08 > php ;save flags
|
|
0ec5 : c97f > cmp #$aa-$2b ;test result
|
|
> trap_ne
|
|
0ec7 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0ec9 : 68 > pla ;load status
|
|
0eca : 48 > pha
|
|
> cmp_flag $ff
|
|
0ecb : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0ecd : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0ecf : 28 > plp ;restore status
|
|
>
|
|
0ed0 : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
0ed2 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0ed4 : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
0ed6 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $3b,1
|
|
0ed8 : a042 > ldy #$42
|
|
0eda : a203 > ldx #4-1
|
|
0edc : 3b > db $3b ;test nop length
|
|
> if 1 = 1
|
|
0edd : ca > dex
|
|
0ede : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
0edf : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
0ee0 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$3b,0
|
|
> load_flag 0
|
|
0ee2 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
0ee4 : 48 > pha ;use stack to load status
|
|
0ee5 : a9c4 > lda #$ff-$3b ;precharge accu
|
|
0ee7 : 28 > plp
|
|
>
|
|
0ee8 : 3b > db $3b ;test nop integrity - flags off
|
|
0ee9 : ea > nop
|
|
0eea : ea > nop
|
|
> tst_a $ff-$3b,0
|
|
0eeb : 08 > php ;save flags
|
|
0eec : c9c4 > cmp #$ff-$3b ;test result
|
|
> trap_ne
|
|
0eee : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0ef0 : 68 > pla ;load status
|
|
0ef1 : 48 > pha
|
|
> cmp_flag 0
|
|
0ef2 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0ef4 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0ef6 : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$3b,$ff
|
|
> load_flag $ff
|
|
0ef7 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
0ef9 : 48 > pha ;use stack to load status
|
|
0efa : a96f > lda #$aa-$3b ;precharge accu
|
|
0efc : 28 > plp
|
|
>
|
|
0efd : 3b > db $3b ;test nop integrity - flags on
|
|
0efe : ea > nop
|
|
0eff : ea > nop
|
|
> tst_a $aa-$3b,$ff
|
|
0f00 : 08 > php ;save flags
|
|
0f01 : c96f > cmp #$aa-$3b ;test result
|
|
> trap_ne
|
|
0f03 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0f05 : 68 > pla ;load status
|
|
0f06 : 48 > pha
|
|
> cmp_flag $ff
|
|
0f07 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0f09 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0f0b : 28 > plp ;restore status
|
|
>
|
|
0f0c : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
0f0e : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0f10 : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
0f12 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $4b,1
|
|
0f14 : a042 > ldy #$42
|
|
0f16 : a203 > ldx #4-1
|
|
0f18 : 4b > db $4b ;test nop length
|
|
> if 1 = 1
|
|
0f19 : ca > dex
|
|
0f1a : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
0f1b : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
0f1c : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$4b,0
|
|
> load_flag 0
|
|
0f1e : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
0f20 : 48 > pha ;use stack to load status
|
|
0f21 : a9b4 > lda #$ff-$4b ;precharge accu
|
|
0f23 : 28 > plp
|
|
>
|
|
0f24 : 4b > db $4b ;test nop integrity - flags off
|
|
0f25 : ea > nop
|
|
0f26 : ea > nop
|
|
> tst_a $ff-$4b,0
|
|
0f27 : 08 > php ;save flags
|
|
0f28 : c9b4 > cmp #$ff-$4b ;test result
|
|
> trap_ne
|
|
0f2a : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0f2c : 68 > pla ;load status
|
|
0f2d : 48 > pha
|
|
> cmp_flag 0
|
|
0f2e : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0f30 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0f32 : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$4b,$ff
|
|
> load_flag $ff
|
|
0f33 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
0f35 : 48 > pha ;use stack to load status
|
|
0f36 : a95f > lda #$aa-$4b ;precharge accu
|
|
0f38 : 28 > plp
|
|
>
|
|
0f39 : 4b > db $4b ;test nop integrity - flags on
|
|
0f3a : ea > nop
|
|
0f3b : ea > nop
|
|
> tst_a $aa-$4b,$ff
|
|
0f3c : 08 > php ;save flags
|
|
0f3d : c95f > cmp #$aa-$4b ;test result
|
|
> trap_ne
|
|
0f3f : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0f41 : 68 > pla ;load status
|
|
0f42 : 48 > pha
|
|
> cmp_flag $ff
|
|
0f43 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0f45 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0f47 : 28 > plp ;restore status
|
|
>
|
|
0f48 : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
0f4a : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0f4c : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
0f4e : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $5b,1
|
|
0f50 : a042 > ldy #$42
|
|
0f52 : a203 > ldx #4-1
|
|
0f54 : 5b > db $5b ;test nop length
|
|
> if 1 = 1
|
|
0f55 : ca > dex
|
|
0f56 : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
0f57 : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
0f58 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$5b,0
|
|
> load_flag 0
|
|
0f5a : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
0f5c : 48 > pha ;use stack to load status
|
|
0f5d : a9a4 > lda #$ff-$5b ;precharge accu
|
|
0f5f : 28 > plp
|
|
>
|
|
0f60 : 5b > db $5b ;test nop integrity - flags off
|
|
0f61 : ea > nop
|
|
0f62 : ea > nop
|
|
> tst_a $ff-$5b,0
|
|
0f63 : 08 > php ;save flags
|
|
0f64 : c9a4 > cmp #$ff-$5b ;test result
|
|
> trap_ne
|
|
0f66 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0f68 : 68 > pla ;load status
|
|
0f69 : 48 > pha
|
|
> cmp_flag 0
|
|
0f6a : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0f6c : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0f6e : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$5b,$ff
|
|
> load_flag $ff
|
|
0f6f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
0f71 : 48 > pha ;use stack to load status
|
|
0f72 : a94f > lda #$aa-$5b ;precharge accu
|
|
0f74 : 28 > plp
|
|
>
|
|
0f75 : 5b > db $5b ;test nop integrity - flags on
|
|
0f76 : ea > nop
|
|
0f77 : ea > nop
|
|
> tst_a $aa-$5b,$ff
|
|
0f78 : 08 > php ;save flags
|
|
0f79 : c94f > cmp #$aa-$5b ;test result
|
|
> trap_ne
|
|
0f7b : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0f7d : 68 > pla ;load status
|
|
0f7e : 48 > pha
|
|
> cmp_flag $ff
|
|
0f7f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0f81 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0f83 : 28 > plp ;restore status
|
|
>
|
|
0f84 : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
0f86 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0f88 : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
0f8a : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $6b,1
|
|
0f8c : a042 > ldy #$42
|
|
0f8e : a203 > ldx #4-1
|
|
0f90 : 6b > db $6b ;test nop length
|
|
> if 1 = 1
|
|
0f91 : ca > dex
|
|
0f92 : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
0f93 : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
0f94 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$6b,0
|
|
> load_flag 0
|
|
0f96 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
0f98 : 48 > pha ;use stack to load status
|
|
0f99 : a994 > lda #$ff-$6b ;precharge accu
|
|
0f9b : 28 > plp
|
|
>
|
|
0f9c : 6b > db $6b ;test nop integrity - flags off
|
|
0f9d : ea > nop
|
|
0f9e : ea > nop
|
|
> tst_a $ff-$6b,0
|
|
0f9f : 08 > php ;save flags
|
|
0fa0 : c994 > cmp #$ff-$6b ;test result
|
|
> trap_ne
|
|
0fa2 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0fa4 : 68 > pla ;load status
|
|
0fa5 : 48 > pha
|
|
> cmp_flag 0
|
|
0fa6 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0fa8 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0faa : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$6b,$ff
|
|
> load_flag $ff
|
|
0fab : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
0fad : 48 > pha ;use stack to load status
|
|
0fae : a93f > lda #$aa-$6b ;precharge accu
|
|
0fb0 : 28 > plp
|
|
>
|
|
0fb1 : 6b > db $6b ;test nop integrity - flags on
|
|
0fb2 : ea > nop
|
|
0fb3 : ea > nop
|
|
> tst_a $aa-$6b,$ff
|
|
0fb4 : 08 > php ;save flags
|
|
0fb5 : c93f > cmp #$aa-$6b ;test result
|
|
> trap_ne
|
|
0fb7 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0fb9 : 68 > pla ;load status
|
|
0fba : 48 > pha
|
|
> cmp_flag $ff
|
|
0fbb : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0fbd : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0fbf : 28 > plp ;restore status
|
|
>
|
|
0fc0 : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
0fc2 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0fc4 : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
0fc6 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $7b,1
|
|
0fc8 : a042 > ldy #$42
|
|
0fca : a203 > ldx #4-1
|
|
0fcc : 7b > db $7b ;test nop length
|
|
> if 1 = 1
|
|
0fcd : ca > dex
|
|
0fce : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
0fcf : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
0fd0 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$7b,0
|
|
> load_flag 0
|
|
0fd2 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
0fd4 : 48 > pha ;use stack to load status
|
|
0fd5 : a984 > lda #$ff-$7b ;precharge accu
|
|
0fd7 : 28 > plp
|
|
>
|
|
0fd8 : 7b > db $7b ;test nop integrity - flags off
|
|
0fd9 : ea > nop
|
|
0fda : ea > nop
|
|
> tst_a $ff-$7b,0
|
|
0fdb : 08 > php ;save flags
|
|
0fdc : c984 > cmp #$ff-$7b ;test result
|
|
> trap_ne
|
|
0fde : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0fe0 : 68 > pla ;load status
|
|
0fe1 : 48 > pha
|
|
> cmp_flag 0
|
|
0fe2 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0fe4 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0fe6 : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$7b,$ff
|
|
> load_flag $ff
|
|
0fe7 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
0fe9 : 48 > pha ;use stack to load status
|
|
0fea : a92f > lda #$aa-$7b ;precharge accu
|
|
0fec : 28 > plp
|
|
>
|
|
0fed : 7b > db $7b ;test nop integrity - flags on
|
|
0fee : ea > nop
|
|
0fef : ea > nop
|
|
> tst_a $aa-$7b,$ff
|
|
0ff0 : 08 > php ;save flags
|
|
0ff1 : c92f > cmp #$aa-$7b ;test result
|
|
> trap_ne
|
|
0ff3 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0ff5 : 68 > pla ;load status
|
|
0ff6 : 48 > pha
|
|
> cmp_flag $ff
|
|
0ff7 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
0ff9 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0ffb : 28 > plp ;restore status
|
|
>
|
|
0ffc : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
0ffe : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1000 : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
1002 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $8b,1
|
|
1004 : a042 > ldy #$42
|
|
1006 : a203 > ldx #4-1
|
|
1008 : 8b > db $8b ;test nop length
|
|
> if 1 = 1
|
|
1009 : ca > dex
|
|
100a : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
100b : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
100c : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$8b,0
|
|
> load_flag 0
|
|
100e : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
1010 : 48 > pha ;use stack to load status
|
|
1011 : a974 > lda #$ff-$8b ;precharge accu
|
|
1013 : 28 > plp
|
|
>
|
|
1014 : 8b > db $8b ;test nop integrity - flags off
|
|
1015 : ea > nop
|
|
1016 : ea > nop
|
|
> tst_a $ff-$8b,0
|
|
1017 : 08 > php ;save flags
|
|
1018 : c974 > cmp #$ff-$8b ;test result
|
|
> trap_ne
|
|
101a : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
101c : 68 > pla ;load status
|
|
101d : 48 > pha
|
|
> cmp_flag 0
|
|
101e : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1020 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1022 : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$8b,$ff
|
|
> load_flag $ff
|
|
1023 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
1025 : 48 > pha ;use stack to load status
|
|
1026 : a91f > lda #$aa-$8b ;precharge accu
|
|
1028 : 28 > plp
|
|
>
|
|
1029 : 8b > db $8b ;test nop integrity - flags on
|
|
102a : ea > nop
|
|
102b : ea > nop
|
|
> tst_a $aa-$8b,$ff
|
|
102c : 08 > php ;save flags
|
|
102d : c91f > cmp #$aa-$8b ;test result
|
|
> trap_ne
|
|
102f : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1031 : 68 > pla ;load status
|
|
1032 : 48 > pha
|
|
> cmp_flag $ff
|
|
1033 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1035 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1037 : 28 > plp ;restore status
|
|
>
|
|
1038 : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
103a : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
103c : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
103e : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $9b,1
|
|
1040 : a042 > ldy #$42
|
|
1042 : a203 > ldx #4-1
|
|
1044 : 9b > db $9b ;test nop length
|
|
> if 1 = 1
|
|
1045 : ca > dex
|
|
1046 : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
1047 : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
1048 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$9b,0
|
|
> load_flag 0
|
|
104a : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
104c : 48 > pha ;use stack to load status
|
|
104d : a964 > lda #$ff-$9b ;precharge accu
|
|
104f : 28 > plp
|
|
>
|
|
1050 : 9b > db $9b ;test nop integrity - flags off
|
|
1051 : ea > nop
|
|
1052 : ea > nop
|
|
> tst_a $ff-$9b,0
|
|
1053 : 08 > php ;save flags
|
|
1054 : c964 > cmp #$ff-$9b ;test result
|
|
> trap_ne
|
|
1056 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1058 : 68 > pla ;load status
|
|
1059 : 48 > pha
|
|
> cmp_flag 0
|
|
105a : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
105c : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
105e : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$9b,$ff
|
|
> load_flag $ff
|
|
105f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
1061 : 48 > pha ;use stack to load status
|
|
1062 : a90f > lda #$aa-$9b ;precharge accu
|
|
1064 : 28 > plp
|
|
>
|
|
1065 : 9b > db $9b ;test nop integrity - flags on
|
|
1066 : ea > nop
|
|
1067 : ea > nop
|
|
> tst_a $aa-$9b,$ff
|
|
1068 : 08 > php ;save flags
|
|
1069 : c90f > cmp #$aa-$9b ;test result
|
|
> trap_ne
|
|
106b : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
106d : 68 > pla ;load status
|
|
106e : 48 > pha
|
|
> cmp_flag $ff
|
|
106f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1071 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1073 : 28 > plp ;restore status
|
|
>
|
|
1074 : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
1076 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1078 : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
107a : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $ab,1
|
|
107c : a042 > ldy #$42
|
|
107e : a203 > ldx #4-1
|
|
1080 : ab > db $ab ;test nop length
|
|
> if 1 = 1
|
|
1081 : ca > dex
|
|
1082 : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
1083 : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
1084 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$ab,0
|
|
> load_flag 0
|
|
1086 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
1088 : 48 > pha ;use stack to load status
|
|
1089 : a954 > lda #$ff-$ab ;precharge accu
|
|
108b : 28 > plp
|
|
>
|
|
108c : ab > db $ab ;test nop integrity - flags off
|
|
108d : ea > nop
|
|
108e : ea > nop
|
|
> tst_a $ff-$ab,0
|
|
108f : 08 > php ;save flags
|
|
1090 : c954 > cmp #$ff-$ab ;test result
|
|
> trap_ne
|
|
1092 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1094 : 68 > pla ;load status
|
|
1095 : 48 > pha
|
|
> cmp_flag 0
|
|
1096 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1098 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
109a : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$ab,$ff
|
|
> load_flag $ff
|
|
109b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
109d : 48 > pha ;use stack to load status
|
|
109e : a9ff > lda #$aa-$ab ;precharge accu
|
|
10a0 : 28 > plp
|
|
>
|
|
10a1 : ab > db $ab ;test nop integrity - flags on
|
|
10a2 : ea > nop
|
|
10a3 : ea > nop
|
|
> tst_a $aa-$ab,$ff
|
|
10a4 : 08 > php ;save flags
|
|
10a5 : c9ff > cmp #$aa-$ab ;test result
|
|
> trap_ne
|
|
10a7 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
10a9 : 68 > pla ;load status
|
|
10aa : 48 > pha
|
|
> cmp_flag $ff
|
|
10ab : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
10ad : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
10af : 28 > plp ;restore status
|
|
>
|
|
10b0 : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
10b2 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
10b4 : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
10b6 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $bb,1
|
|
10b8 : a042 > ldy #$42
|
|
10ba : a203 > ldx #4-1
|
|
10bc : bb > db $bb ;test nop length
|
|
> if 1 = 1
|
|
10bd : ca > dex
|
|
10be : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
10bf : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
10c0 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$bb,0
|
|
> load_flag 0
|
|
10c2 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
10c4 : 48 > pha ;use stack to load status
|
|
10c5 : a944 > lda #$ff-$bb ;precharge accu
|
|
10c7 : 28 > plp
|
|
>
|
|
10c8 : bb > db $bb ;test nop integrity - flags off
|
|
10c9 : ea > nop
|
|
10ca : ea > nop
|
|
> tst_a $ff-$bb,0
|
|
10cb : 08 > php ;save flags
|
|
10cc : c944 > cmp #$ff-$bb ;test result
|
|
> trap_ne
|
|
10ce : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
10d0 : 68 > pla ;load status
|
|
10d1 : 48 > pha
|
|
> cmp_flag 0
|
|
10d2 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
10d4 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
10d6 : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$bb,$ff
|
|
> load_flag $ff
|
|
10d7 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
10d9 : 48 > pha ;use stack to load status
|
|
10da : a9ef > lda #$aa-$bb ;precharge accu
|
|
10dc : 28 > plp
|
|
>
|
|
10dd : bb > db $bb ;test nop integrity - flags on
|
|
10de : ea > nop
|
|
10df : ea > nop
|
|
> tst_a $aa-$bb,$ff
|
|
10e0 : 08 > php ;save flags
|
|
10e1 : c9ef > cmp #$aa-$bb ;test result
|
|
> trap_ne
|
|
10e3 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
10e5 : 68 > pla ;load status
|
|
10e6 : 48 > pha
|
|
> cmp_flag $ff
|
|
10e7 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
10e9 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
10eb : 28 > plp ;restore status
|
|
>
|
|
10ec : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
10ee : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
10f0 : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
10f2 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $eb,1
|
|
10f4 : a042 > ldy #$42
|
|
10f6 : a203 > ldx #4-1
|
|
10f8 : eb > db $eb ;test nop length
|
|
> if 1 = 1
|
|
10f9 : ca > dex
|
|
10fa : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
10fb : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
10fc : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$eb,0
|
|
> load_flag 0
|
|
10fe : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
1100 : 48 > pha ;use stack to load status
|
|
1101 : a914 > lda #$ff-$eb ;precharge accu
|
|
1103 : 28 > plp
|
|
>
|
|
1104 : eb > db $eb ;test nop integrity - flags off
|
|
1105 : ea > nop
|
|
1106 : ea > nop
|
|
> tst_a $ff-$eb,0
|
|
1107 : 08 > php ;save flags
|
|
1108 : c914 > cmp #$ff-$eb ;test result
|
|
> trap_ne
|
|
110a : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
110c : 68 > pla ;load status
|
|
110d : 48 > pha
|
|
> cmp_flag 0
|
|
110e : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1110 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1112 : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$eb,$ff
|
|
> load_flag $ff
|
|
1113 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
1115 : 48 > pha ;use stack to load status
|
|
1116 : a9bf > lda #$aa-$eb ;precharge accu
|
|
1118 : 28 > plp
|
|
>
|
|
1119 : eb > db $eb ;test nop integrity - flags on
|
|
111a : ea > nop
|
|
111b : ea > nop
|
|
> tst_a $aa-$eb,$ff
|
|
111c : 08 > php ;save flags
|
|
111d : c9bf > cmp #$aa-$eb ;test result
|
|
> trap_ne
|
|
111f : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1121 : 68 > pla ;load status
|
|
1122 : 48 > pha
|
|
> cmp_flag $ff
|
|
1123 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1125 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1127 : 28 > plp ;restore status
|
|
>
|
|
1128 : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
112a : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
112c : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
112e : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $fb,1
|
|
1130 : a042 > ldy #$42
|
|
1132 : a203 > ldx #4-1
|
|
1134 : fb > db $fb ;test nop length
|
|
> if 1 = 1
|
|
1135 : ca > dex
|
|
1136 : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
1137 : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
1138 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$fb,0
|
|
> load_flag 0
|
|
113a : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
113c : 48 > pha ;use stack to load status
|
|
113d : a904 > lda #$ff-$fb ;precharge accu
|
|
113f : 28 > plp
|
|
>
|
|
1140 : fb > db $fb ;test nop integrity - flags off
|
|
1141 : ea > nop
|
|
1142 : ea > nop
|
|
> tst_a $ff-$fb,0
|
|
1143 : 08 > php ;save flags
|
|
1144 : c904 > cmp #$ff-$fb ;test result
|
|
> trap_ne
|
|
1146 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1148 : 68 > pla ;load status
|
|
1149 : 48 > pha
|
|
> cmp_flag 0
|
|
114a : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
114c : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
114e : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$fb,$ff
|
|
> load_flag $ff
|
|
114f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
1151 : 48 > pha ;use stack to load status
|
|
1152 : a9af > lda #$aa-$fb ;precharge accu
|
|
1154 : 28 > plp
|
|
>
|
|
1155 : fb > db $fb ;test nop integrity - flags on
|
|
1156 : ea > nop
|
|
1157 : ea > nop
|
|
> tst_a $aa-$fb,$ff
|
|
1158 : 08 > php ;save flags
|
|
1159 : c9af > cmp #$aa-$fb ;test result
|
|
> trap_ne
|
|
115b : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
115d : 68 > pla ;load status
|
|
115e : 48 > pha
|
|
> cmp_flag $ff
|
|
115f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1161 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1163 : 28 > plp ;restore status
|
|
>
|
|
1164 : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
1166 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1168 : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
116a : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
if rkwl_wdc_op = 0 ;NOPs not available on Rockwell & WDC 65C02
|
|
nop_test $07,1
|
|
116c : a042 > ldy #$42
|
|
116e : a203 > ldx #4-1
|
|
1170 : 07 > db $07 ;test nop length
|
|
> if 1 = 1
|
|
1171 : ca > dex
|
|
1172 : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
1173 : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
1174 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$07,0
|
|
> load_flag 0
|
|
1176 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
1178 : 48 > pha ;use stack to load status
|
|
1179 : a9f8 > lda #$ff-$07 ;precharge accu
|
|
117b : 28 > plp
|
|
>
|
|
117c : 07 > db $07 ;test nop integrity - flags off
|
|
117d : ea > nop
|
|
117e : ea > nop
|
|
> tst_a $ff-$07,0
|
|
117f : 08 > php ;save flags
|
|
1180 : c9f8 > cmp #$ff-$07 ;test result
|
|
> trap_ne
|
|
1182 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1184 : 68 > pla ;load status
|
|
1185 : 48 > pha
|
|
> cmp_flag 0
|
|
1186 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1188 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
118a : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$07,$ff
|
|
> load_flag $ff
|
|
118b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
118d : 48 > pha ;use stack to load status
|
|
118e : a9a3 > lda #$aa-$07 ;precharge accu
|
|
1190 : 28 > plp
|
|
>
|
|
1191 : 07 > db $07 ;test nop integrity - flags on
|
|
1192 : ea > nop
|
|
1193 : ea > nop
|
|
> tst_a $aa-$07,$ff
|
|
1194 : 08 > php ;save flags
|
|
1195 : c9a3 > cmp #$aa-$07 ;test result
|
|
> trap_ne
|
|
1197 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1199 : 68 > pla ;load status
|
|
119a : 48 > pha
|
|
> cmp_flag $ff
|
|
119b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
119d : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
119f : 28 > plp ;restore status
|
|
>
|
|
11a0 : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
11a2 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
11a4 : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
11a6 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $17,1
|
|
11a8 : a042 > ldy #$42
|
|
11aa : a203 > ldx #4-1
|
|
11ac : 17 > db $17 ;test nop length
|
|
> if 1 = 1
|
|
11ad : ca > dex
|
|
11ae : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
11af : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
11b0 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$17,0
|
|
> load_flag 0
|
|
11b2 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
11b4 : 48 > pha ;use stack to load status
|
|
11b5 : a9e8 > lda #$ff-$17 ;precharge accu
|
|
11b7 : 28 > plp
|
|
>
|
|
11b8 : 17 > db $17 ;test nop integrity - flags off
|
|
11b9 : ea > nop
|
|
11ba : ea > nop
|
|
> tst_a $ff-$17,0
|
|
11bb : 08 > php ;save flags
|
|
11bc : c9e8 > cmp #$ff-$17 ;test result
|
|
> trap_ne
|
|
11be : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
11c0 : 68 > pla ;load status
|
|
11c1 : 48 > pha
|
|
> cmp_flag 0
|
|
11c2 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
11c4 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
11c6 : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$17,$ff
|
|
> load_flag $ff
|
|
11c7 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
11c9 : 48 > pha ;use stack to load status
|
|
11ca : a993 > lda #$aa-$17 ;precharge accu
|
|
11cc : 28 > plp
|
|
>
|
|
11cd : 17 > db $17 ;test nop integrity - flags on
|
|
11ce : ea > nop
|
|
11cf : ea > nop
|
|
> tst_a $aa-$17,$ff
|
|
11d0 : 08 > php ;save flags
|
|
11d1 : c993 > cmp #$aa-$17 ;test result
|
|
> trap_ne
|
|
11d3 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
11d5 : 68 > pla ;load status
|
|
11d6 : 48 > pha
|
|
> cmp_flag $ff
|
|
11d7 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
11d9 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
11db : 28 > plp ;restore status
|
|
>
|
|
11dc : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
11de : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
11e0 : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
11e2 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $27,1
|
|
11e4 : a042 > ldy #$42
|
|
11e6 : a203 > ldx #4-1
|
|
11e8 : 27 > db $27 ;test nop length
|
|
> if 1 = 1
|
|
11e9 : ca > dex
|
|
11ea : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
11eb : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
11ec : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$27,0
|
|
> load_flag 0
|
|
11ee : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
11f0 : 48 > pha ;use stack to load status
|
|
11f1 : a9d8 > lda #$ff-$27 ;precharge accu
|
|
11f3 : 28 > plp
|
|
>
|
|
11f4 : 27 > db $27 ;test nop integrity - flags off
|
|
11f5 : ea > nop
|
|
11f6 : ea > nop
|
|
> tst_a $ff-$27,0
|
|
11f7 : 08 > php ;save flags
|
|
11f8 : c9d8 > cmp #$ff-$27 ;test result
|
|
> trap_ne
|
|
11fa : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
11fc : 68 > pla ;load status
|
|
11fd : 48 > pha
|
|
> cmp_flag 0
|
|
11fe : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1200 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1202 : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$27,$ff
|
|
> load_flag $ff
|
|
1203 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
1205 : 48 > pha ;use stack to load status
|
|
1206 : a983 > lda #$aa-$27 ;precharge accu
|
|
1208 : 28 > plp
|
|
>
|
|
1209 : 27 > db $27 ;test nop integrity - flags on
|
|
120a : ea > nop
|
|
120b : ea > nop
|
|
> tst_a $aa-$27,$ff
|
|
120c : 08 > php ;save flags
|
|
120d : c983 > cmp #$aa-$27 ;test result
|
|
> trap_ne
|
|
120f : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1211 : 68 > pla ;load status
|
|
1212 : 48 > pha
|
|
> cmp_flag $ff
|
|
1213 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1215 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1217 : 28 > plp ;restore status
|
|
>
|
|
1218 : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
121a : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
121c : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
121e : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $37,1
|
|
1220 : a042 > ldy #$42
|
|
1222 : a203 > ldx #4-1
|
|
1224 : 37 > db $37 ;test nop length
|
|
> if 1 = 1
|
|
1225 : ca > dex
|
|
1226 : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
1227 : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
1228 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$37,0
|
|
> load_flag 0
|
|
122a : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
122c : 48 > pha ;use stack to load status
|
|
122d : a9c8 > lda #$ff-$37 ;precharge accu
|
|
122f : 28 > plp
|
|
>
|
|
1230 : 37 > db $37 ;test nop integrity - flags off
|
|
1231 : ea > nop
|
|
1232 : ea > nop
|
|
> tst_a $ff-$37,0
|
|
1233 : 08 > php ;save flags
|
|
1234 : c9c8 > cmp #$ff-$37 ;test result
|
|
> trap_ne
|
|
1236 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1238 : 68 > pla ;load status
|
|
1239 : 48 > pha
|
|
> cmp_flag 0
|
|
123a : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
123c : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
123e : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$37,$ff
|
|
> load_flag $ff
|
|
123f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
1241 : 48 > pha ;use stack to load status
|
|
1242 : a973 > lda #$aa-$37 ;precharge accu
|
|
1244 : 28 > plp
|
|
>
|
|
1245 : 37 > db $37 ;test nop integrity - flags on
|
|
1246 : ea > nop
|
|
1247 : ea > nop
|
|
> tst_a $aa-$37,$ff
|
|
1248 : 08 > php ;save flags
|
|
1249 : c973 > cmp #$aa-$37 ;test result
|
|
> trap_ne
|
|
124b : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
124d : 68 > pla ;load status
|
|
124e : 48 > pha
|
|
> cmp_flag $ff
|
|
124f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1251 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1253 : 28 > plp ;restore status
|
|
>
|
|
1254 : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
1256 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1258 : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
125a : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $47,1
|
|
125c : a042 > ldy #$42
|
|
125e : a203 > ldx #4-1
|
|
1260 : 47 > db $47 ;test nop length
|
|
> if 1 = 1
|
|
1261 : ca > dex
|
|
1262 : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
1263 : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
1264 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$47,0
|
|
> load_flag 0
|
|
1266 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
1268 : 48 > pha ;use stack to load status
|
|
1269 : a9b8 > lda #$ff-$47 ;precharge accu
|
|
126b : 28 > plp
|
|
>
|
|
126c : 47 > db $47 ;test nop integrity - flags off
|
|
126d : ea > nop
|
|
126e : ea > nop
|
|
> tst_a $ff-$47,0
|
|
126f : 08 > php ;save flags
|
|
1270 : c9b8 > cmp #$ff-$47 ;test result
|
|
> trap_ne
|
|
1272 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1274 : 68 > pla ;load status
|
|
1275 : 48 > pha
|
|
> cmp_flag 0
|
|
1276 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1278 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
127a : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$47,$ff
|
|
> load_flag $ff
|
|
127b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
127d : 48 > pha ;use stack to load status
|
|
127e : a963 > lda #$aa-$47 ;precharge accu
|
|
1280 : 28 > plp
|
|
>
|
|
1281 : 47 > db $47 ;test nop integrity - flags on
|
|
1282 : ea > nop
|
|
1283 : ea > nop
|
|
> tst_a $aa-$47,$ff
|
|
1284 : 08 > php ;save flags
|
|
1285 : c963 > cmp #$aa-$47 ;test result
|
|
> trap_ne
|
|
1287 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1289 : 68 > pla ;load status
|
|
128a : 48 > pha
|
|
> cmp_flag $ff
|
|
128b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
128d : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
128f : 28 > plp ;restore status
|
|
>
|
|
1290 : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
1292 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1294 : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
1296 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $57,1
|
|
1298 : a042 > ldy #$42
|
|
129a : a203 > ldx #4-1
|
|
129c : 57 > db $57 ;test nop length
|
|
> if 1 = 1
|
|
129d : ca > dex
|
|
129e : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
129f : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
12a0 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$57,0
|
|
> load_flag 0
|
|
12a2 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
12a4 : 48 > pha ;use stack to load status
|
|
12a5 : a9a8 > lda #$ff-$57 ;precharge accu
|
|
12a7 : 28 > plp
|
|
>
|
|
12a8 : 57 > db $57 ;test nop integrity - flags off
|
|
12a9 : ea > nop
|
|
12aa : ea > nop
|
|
> tst_a $ff-$57,0
|
|
12ab : 08 > php ;save flags
|
|
12ac : c9a8 > cmp #$ff-$57 ;test result
|
|
> trap_ne
|
|
12ae : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
12b0 : 68 > pla ;load status
|
|
12b1 : 48 > pha
|
|
> cmp_flag 0
|
|
12b2 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
12b4 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
12b6 : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$57,$ff
|
|
> load_flag $ff
|
|
12b7 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
12b9 : 48 > pha ;use stack to load status
|
|
12ba : a953 > lda #$aa-$57 ;precharge accu
|
|
12bc : 28 > plp
|
|
>
|
|
12bd : 57 > db $57 ;test nop integrity - flags on
|
|
12be : ea > nop
|
|
12bf : ea > nop
|
|
> tst_a $aa-$57,$ff
|
|
12c0 : 08 > php ;save flags
|
|
12c1 : c953 > cmp #$aa-$57 ;test result
|
|
> trap_ne
|
|
12c3 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
12c5 : 68 > pla ;load status
|
|
12c6 : 48 > pha
|
|
> cmp_flag $ff
|
|
12c7 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
12c9 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
12cb : 28 > plp ;restore status
|
|
>
|
|
12cc : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
12ce : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
12d0 : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
12d2 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $67,1
|
|
12d4 : a042 > ldy #$42
|
|
12d6 : a203 > ldx #4-1
|
|
12d8 : 67 > db $67 ;test nop length
|
|
> if 1 = 1
|
|
12d9 : ca > dex
|
|
12da : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
12db : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
12dc : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$67,0
|
|
> load_flag 0
|
|
12de : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
12e0 : 48 > pha ;use stack to load status
|
|
12e1 : a998 > lda #$ff-$67 ;precharge accu
|
|
12e3 : 28 > plp
|
|
>
|
|
12e4 : 67 > db $67 ;test nop integrity - flags off
|
|
12e5 : ea > nop
|
|
12e6 : ea > nop
|
|
> tst_a $ff-$67,0
|
|
12e7 : 08 > php ;save flags
|
|
12e8 : c998 > cmp #$ff-$67 ;test result
|
|
> trap_ne
|
|
12ea : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
12ec : 68 > pla ;load status
|
|
12ed : 48 > pha
|
|
> cmp_flag 0
|
|
12ee : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
12f0 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
12f2 : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$67,$ff
|
|
> load_flag $ff
|
|
12f3 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
12f5 : 48 > pha ;use stack to load status
|
|
12f6 : a943 > lda #$aa-$67 ;precharge accu
|
|
12f8 : 28 > plp
|
|
>
|
|
12f9 : 67 > db $67 ;test nop integrity - flags on
|
|
12fa : ea > nop
|
|
12fb : ea > nop
|
|
> tst_a $aa-$67,$ff
|
|
12fc : 08 > php ;save flags
|
|
12fd : c943 > cmp #$aa-$67 ;test result
|
|
> trap_ne
|
|
12ff : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1301 : 68 > pla ;load status
|
|
1302 : 48 > pha
|
|
> cmp_flag $ff
|
|
1303 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1305 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1307 : 28 > plp ;restore status
|
|
>
|
|
1308 : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
130a : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
130c : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
130e : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $77,1
|
|
1310 : a042 > ldy #$42
|
|
1312 : a203 > ldx #4-1
|
|
1314 : 77 > db $77 ;test nop length
|
|
> if 1 = 1
|
|
1315 : ca > dex
|
|
1316 : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
1317 : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
1318 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$77,0
|
|
> load_flag 0
|
|
131a : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
131c : 48 > pha ;use stack to load status
|
|
131d : a988 > lda #$ff-$77 ;precharge accu
|
|
131f : 28 > plp
|
|
>
|
|
1320 : 77 > db $77 ;test nop integrity - flags off
|
|
1321 : ea > nop
|
|
1322 : ea > nop
|
|
> tst_a $ff-$77,0
|
|
1323 : 08 > php ;save flags
|
|
1324 : c988 > cmp #$ff-$77 ;test result
|
|
> trap_ne
|
|
1326 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1328 : 68 > pla ;load status
|
|
1329 : 48 > pha
|
|
> cmp_flag 0
|
|
132a : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
132c : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
132e : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$77,$ff
|
|
> load_flag $ff
|
|
132f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
1331 : 48 > pha ;use stack to load status
|
|
1332 : a933 > lda #$aa-$77 ;precharge accu
|
|
1334 : 28 > plp
|
|
>
|
|
1335 : 77 > db $77 ;test nop integrity - flags on
|
|
1336 : ea > nop
|
|
1337 : ea > nop
|
|
> tst_a $aa-$77,$ff
|
|
1338 : 08 > php ;save flags
|
|
1339 : c933 > cmp #$aa-$77 ;test result
|
|
> trap_ne
|
|
133b : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
133d : 68 > pla ;load status
|
|
133e : 48 > pha
|
|
> cmp_flag $ff
|
|
133f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1341 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1343 : 28 > plp ;restore status
|
|
>
|
|
1344 : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
1346 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1348 : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
134a : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $87,1
|
|
134c : a042 > ldy #$42
|
|
134e : a203 > ldx #4-1
|
|
1350 : 87 > db $87 ;test nop length
|
|
> if 1 = 1
|
|
1351 : ca > dex
|
|
1352 : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
1353 : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
1354 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$87,0
|
|
> load_flag 0
|
|
1356 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
1358 : 48 > pha ;use stack to load status
|
|
1359 : a978 > lda #$ff-$87 ;precharge accu
|
|
135b : 28 > plp
|
|
>
|
|
135c : 87 > db $87 ;test nop integrity - flags off
|
|
135d : ea > nop
|
|
135e : ea > nop
|
|
> tst_a $ff-$87,0
|
|
135f : 08 > php ;save flags
|
|
1360 : c978 > cmp #$ff-$87 ;test result
|
|
> trap_ne
|
|
1362 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1364 : 68 > pla ;load status
|
|
1365 : 48 > pha
|
|
> cmp_flag 0
|
|
1366 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1368 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
136a : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$87,$ff
|
|
> load_flag $ff
|
|
136b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
136d : 48 > pha ;use stack to load status
|
|
136e : a923 > lda #$aa-$87 ;precharge accu
|
|
1370 : 28 > plp
|
|
>
|
|
1371 : 87 > db $87 ;test nop integrity - flags on
|
|
1372 : ea > nop
|
|
1373 : ea > nop
|
|
> tst_a $aa-$87,$ff
|
|
1374 : 08 > php ;save flags
|
|
1375 : c923 > cmp #$aa-$87 ;test result
|
|
> trap_ne
|
|
1377 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1379 : 68 > pla ;load status
|
|
137a : 48 > pha
|
|
> cmp_flag $ff
|
|
137b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
137d : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
137f : 28 > plp ;restore status
|
|
>
|
|
1380 : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
1382 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1384 : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
1386 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $97,1
|
|
1388 : a042 > ldy #$42
|
|
138a : a203 > ldx #4-1
|
|
138c : 97 > db $97 ;test nop length
|
|
> if 1 = 1
|
|
138d : ca > dex
|
|
138e : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
138f : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
1390 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$97,0
|
|
> load_flag 0
|
|
1392 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
1394 : 48 > pha ;use stack to load status
|
|
1395 : a968 > lda #$ff-$97 ;precharge accu
|
|
1397 : 28 > plp
|
|
>
|
|
1398 : 97 > db $97 ;test nop integrity - flags off
|
|
1399 : ea > nop
|
|
139a : ea > nop
|
|
> tst_a $ff-$97,0
|
|
139b : 08 > php ;save flags
|
|
139c : c968 > cmp #$ff-$97 ;test result
|
|
> trap_ne
|
|
139e : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
13a0 : 68 > pla ;load status
|
|
13a1 : 48 > pha
|
|
> cmp_flag 0
|
|
13a2 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
13a4 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
13a6 : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$97,$ff
|
|
> load_flag $ff
|
|
13a7 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
13a9 : 48 > pha ;use stack to load status
|
|
13aa : a913 > lda #$aa-$97 ;precharge accu
|
|
13ac : 28 > plp
|
|
>
|
|
13ad : 97 > db $97 ;test nop integrity - flags on
|
|
13ae : ea > nop
|
|
13af : ea > nop
|
|
> tst_a $aa-$97,$ff
|
|
13b0 : 08 > php ;save flags
|
|
13b1 : c913 > cmp #$aa-$97 ;test result
|
|
> trap_ne
|
|
13b3 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
13b5 : 68 > pla ;load status
|
|
13b6 : 48 > pha
|
|
> cmp_flag $ff
|
|
13b7 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
13b9 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
13bb : 28 > plp ;restore status
|
|
>
|
|
13bc : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
13be : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
13c0 : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
13c2 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $a7,1
|
|
13c4 : a042 > ldy #$42
|
|
13c6 : a203 > ldx #4-1
|
|
13c8 : a7 > db $a7 ;test nop length
|
|
> if 1 = 1
|
|
13c9 : ca > dex
|
|
13ca : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
13cb : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
13cc : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$a7,0
|
|
> load_flag 0
|
|
13ce : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
13d0 : 48 > pha ;use stack to load status
|
|
13d1 : a958 > lda #$ff-$a7 ;precharge accu
|
|
13d3 : 28 > plp
|
|
>
|
|
13d4 : a7 > db $a7 ;test nop integrity - flags off
|
|
13d5 : ea > nop
|
|
13d6 : ea > nop
|
|
> tst_a $ff-$a7,0
|
|
13d7 : 08 > php ;save flags
|
|
13d8 : c958 > cmp #$ff-$a7 ;test result
|
|
> trap_ne
|
|
13da : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
13dc : 68 > pla ;load status
|
|
13dd : 48 > pha
|
|
> cmp_flag 0
|
|
13de : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
13e0 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
13e2 : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$a7,$ff
|
|
> load_flag $ff
|
|
13e3 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
13e5 : 48 > pha ;use stack to load status
|
|
13e6 : a903 > lda #$aa-$a7 ;precharge accu
|
|
13e8 : 28 > plp
|
|
>
|
|
13e9 : a7 > db $a7 ;test nop integrity - flags on
|
|
13ea : ea > nop
|
|
13eb : ea > nop
|
|
> tst_a $aa-$a7,$ff
|
|
13ec : 08 > php ;save flags
|
|
13ed : c903 > cmp #$aa-$a7 ;test result
|
|
> trap_ne
|
|
13ef : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
13f1 : 68 > pla ;load status
|
|
13f2 : 48 > pha
|
|
> cmp_flag $ff
|
|
13f3 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
13f5 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
13f7 : 28 > plp ;restore status
|
|
>
|
|
13f8 : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
13fa : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
13fc : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
13fe : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $b7,1
|
|
1400 : a042 > ldy #$42
|
|
1402 : a203 > ldx #4-1
|
|
1404 : b7 > db $b7 ;test nop length
|
|
> if 1 = 1
|
|
1405 : ca > dex
|
|
1406 : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
1407 : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
1408 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$b7,0
|
|
> load_flag 0
|
|
140a : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
140c : 48 > pha ;use stack to load status
|
|
140d : a948 > lda #$ff-$b7 ;precharge accu
|
|
140f : 28 > plp
|
|
>
|
|
1410 : b7 > db $b7 ;test nop integrity - flags off
|
|
1411 : ea > nop
|
|
1412 : ea > nop
|
|
> tst_a $ff-$b7,0
|
|
1413 : 08 > php ;save flags
|
|
1414 : c948 > cmp #$ff-$b7 ;test result
|
|
> trap_ne
|
|
1416 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1418 : 68 > pla ;load status
|
|
1419 : 48 > pha
|
|
> cmp_flag 0
|
|
141a : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
141c : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
141e : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$b7,$ff
|
|
> load_flag $ff
|
|
141f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
1421 : 48 > pha ;use stack to load status
|
|
1422 : a9f3 > lda #$aa-$b7 ;precharge accu
|
|
1424 : 28 > plp
|
|
>
|
|
1425 : b7 > db $b7 ;test nop integrity - flags on
|
|
1426 : ea > nop
|
|
1427 : ea > nop
|
|
> tst_a $aa-$b7,$ff
|
|
1428 : 08 > php ;save flags
|
|
1429 : c9f3 > cmp #$aa-$b7 ;test result
|
|
> trap_ne
|
|
142b : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
142d : 68 > pla ;load status
|
|
142e : 48 > pha
|
|
> cmp_flag $ff
|
|
142f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1431 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1433 : 28 > plp ;restore status
|
|
>
|
|
1434 : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
1436 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1438 : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
143a : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $c7,1
|
|
143c : a042 > ldy #$42
|
|
143e : a203 > ldx #4-1
|
|
1440 : c7 > db $c7 ;test nop length
|
|
> if 1 = 1
|
|
1441 : ca > dex
|
|
1442 : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
1443 : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
1444 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$c7,0
|
|
> load_flag 0
|
|
1446 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
1448 : 48 > pha ;use stack to load status
|
|
1449 : a938 > lda #$ff-$c7 ;precharge accu
|
|
144b : 28 > plp
|
|
>
|
|
144c : c7 > db $c7 ;test nop integrity - flags off
|
|
144d : ea > nop
|
|
144e : ea > nop
|
|
> tst_a $ff-$c7,0
|
|
144f : 08 > php ;save flags
|
|
1450 : c938 > cmp #$ff-$c7 ;test result
|
|
> trap_ne
|
|
1452 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1454 : 68 > pla ;load status
|
|
1455 : 48 > pha
|
|
> cmp_flag 0
|
|
1456 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1458 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
145a : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$c7,$ff
|
|
> load_flag $ff
|
|
145b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
145d : 48 > pha ;use stack to load status
|
|
145e : a9e3 > lda #$aa-$c7 ;precharge accu
|
|
1460 : 28 > plp
|
|
>
|
|
1461 : c7 > db $c7 ;test nop integrity - flags on
|
|
1462 : ea > nop
|
|
1463 : ea > nop
|
|
> tst_a $aa-$c7,$ff
|
|
1464 : 08 > php ;save flags
|
|
1465 : c9e3 > cmp #$aa-$c7 ;test result
|
|
> trap_ne
|
|
1467 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1469 : 68 > pla ;load status
|
|
146a : 48 > pha
|
|
> cmp_flag $ff
|
|
146b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
146d : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
146f : 28 > plp ;restore status
|
|
>
|
|
1470 : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
1472 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1474 : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
1476 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $d7,1
|
|
1478 : a042 > ldy #$42
|
|
147a : a203 > ldx #4-1
|
|
147c : d7 > db $d7 ;test nop length
|
|
> if 1 = 1
|
|
147d : ca > dex
|
|
147e : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
147f : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
1480 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$d7,0
|
|
> load_flag 0
|
|
1482 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
1484 : 48 > pha ;use stack to load status
|
|
1485 : a928 > lda #$ff-$d7 ;precharge accu
|
|
1487 : 28 > plp
|
|
>
|
|
1488 : d7 > db $d7 ;test nop integrity - flags off
|
|
1489 : ea > nop
|
|
148a : ea > nop
|
|
> tst_a $ff-$d7,0
|
|
148b : 08 > php ;save flags
|
|
148c : c928 > cmp #$ff-$d7 ;test result
|
|
> trap_ne
|
|
148e : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1490 : 68 > pla ;load status
|
|
1491 : 48 > pha
|
|
> cmp_flag 0
|
|
1492 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1494 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1496 : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$d7,$ff
|
|
> load_flag $ff
|
|
1497 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
1499 : 48 > pha ;use stack to load status
|
|
149a : a9d3 > lda #$aa-$d7 ;precharge accu
|
|
149c : 28 > plp
|
|
>
|
|
149d : d7 > db $d7 ;test nop integrity - flags on
|
|
149e : ea > nop
|
|
149f : ea > nop
|
|
> tst_a $aa-$d7,$ff
|
|
14a0 : 08 > php ;save flags
|
|
14a1 : c9d3 > cmp #$aa-$d7 ;test result
|
|
> trap_ne
|
|
14a3 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
14a5 : 68 > pla ;load status
|
|
14a6 : 48 > pha
|
|
> cmp_flag $ff
|
|
14a7 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
14a9 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
14ab : 28 > plp ;restore status
|
|
>
|
|
14ac : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
14ae : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
14b0 : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
14b2 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $e7,1
|
|
14b4 : a042 > ldy #$42
|
|
14b6 : a203 > ldx #4-1
|
|
14b8 : e7 > db $e7 ;test nop length
|
|
> if 1 = 1
|
|
14b9 : ca > dex
|
|
14ba : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
14bb : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
14bc : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$e7,0
|
|
> load_flag 0
|
|
14be : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
14c0 : 48 > pha ;use stack to load status
|
|
14c1 : a918 > lda #$ff-$e7 ;precharge accu
|
|
14c3 : 28 > plp
|
|
>
|
|
14c4 : e7 > db $e7 ;test nop integrity - flags off
|
|
14c5 : ea > nop
|
|
14c6 : ea > nop
|
|
> tst_a $ff-$e7,0
|
|
14c7 : 08 > php ;save flags
|
|
14c8 : c918 > cmp #$ff-$e7 ;test result
|
|
> trap_ne
|
|
14ca : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
14cc : 68 > pla ;load status
|
|
14cd : 48 > pha
|
|
> cmp_flag 0
|
|
14ce : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
14d0 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
14d2 : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$e7,$ff
|
|
> load_flag $ff
|
|
14d3 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
14d5 : 48 > pha ;use stack to load status
|
|
14d6 : a9c3 > lda #$aa-$e7 ;precharge accu
|
|
14d8 : 28 > plp
|
|
>
|
|
14d9 : e7 > db $e7 ;test nop integrity - flags on
|
|
14da : ea > nop
|
|
14db : ea > nop
|
|
> tst_a $aa-$e7,$ff
|
|
14dc : 08 > php ;save flags
|
|
14dd : c9c3 > cmp #$aa-$e7 ;test result
|
|
> trap_ne
|
|
14df : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
14e1 : 68 > pla ;load status
|
|
14e2 : 48 > pha
|
|
> cmp_flag $ff
|
|
14e3 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
14e5 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
14e7 : 28 > plp ;restore status
|
|
>
|
|
14e8 : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
14ea : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
14ec : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
14ee : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $f7,1
|
|
14f0 : a042 > ldy #$42
|
|
14f2 : a203 > ldx #4-1
|
|
14f4 : f7 > db $f7 ;test nop length
|
|
> if 1 = 1
|
|
14f5 : ca > dex
|
|
14f6 : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
14f7 : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
14f8 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$f7,0
|
|
> load_flag 0
|
|
14fa : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
14fc : 48 > pha ;use stack to load status
|
|
14fd : a908 > lda #$ff-$f7 ;precharge accu
|
|
14ff : 28 > plp
|
|
>
|
|
1500 : f7 > db $f7 ;test nop integrity - flags off
|
|
1501 : ea > nop
|
|
1502 : ea > nop
|
|
> tst_a $ff-$f7,0
|
|
1503 : 08 > php ;save flags
|
|
1504 : c908 > cmp #$ff-$f7 ;test result
|
|
> trap_ne
|
|
1506 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1508 : 68 > pla ;load status
|
|
1509 : 48 > pha
|
|
> cmp_flag 0
|
|
150a : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
150c : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
150e : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$f7,$ff
|
|
> load_flag $ff
|
|
150f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
1511 : 48 > pha ;use stack to load status
|
|
1512 : a9b3 > lda #$aa-$f7 ;precharge accu
|
|
1514 : 28 > plp
|
|
>
|
|
1515 : f7 > db $f7 ;test nop integrity - flags on
|
|
1516 : ea > nop
|
|
1517 : ea > nop
|
|
> tst_a $aa-$f7,$ff
|
|
1518 : 08 > php ;save flags
|
|
1519 : c9b3 > cmp #$aa-$f7 ;test result
|
|
> trap_ne
|
|
151b : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
151d : 68 > pla ;load status
|
|
151e : 48 > pha
|
|
> cmp_flag $ff
|
|
151f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1521 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1523 : 28 > plp ;restore status
|
|
>
|
|
1524 : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
1526 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1528 : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
152a : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $0f,1
|
|
152c : a042 > ldy #$42
|
|
152e : a203 > ldx #4-1
|
|
1530 : 0f > db $0f ;test nop length
|
|
> if 1 = 1
|
|
1531 : ca > dex
|
|
1532 : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
1533 : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
1534 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$0f,0
|
|
> load_flag 0
|
|
1536 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
1538 : 48 > pha ;use stack to load status
|
|
1539 : a9f0 > lda #$ff-$0f ;precharge accu
|
|
153b : 28 > plp
|
|
>
|
|
153c : 0f > db $0f ;test nop integrity - flags off
|
|
153d : ea > nop
|
|
153e : ea > nop
|
|
> tst_a $ff-$0f,0
|
|
153f : 08 > php ;save flags
|
|
1540 : c9f0 > cmp #$ff-$0f ;test result
|
|
> trap_ne
|
|
1542 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1544 : 68 > pla ;load status
|
|
1545 : 48 > pha
|
|
> cmp_flag 0
|
|
1546 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1548 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
154a : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$0f,$ff
|
|
> load_flag $ff
|
|
154b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
154d : 48 > pha ;use stack to load status
|
|
154e : a99b > lda #$aa-$0f ;precharge accu
|
|
1550 : 28 > plp
|
|
>
|
|
1551 : 0f > db $0f ;test nop integrity - flags on
|
|
1552 : ea > nop
|
|
1553 : ea > nop
|
|
> tst_a $aa-$0f,$ff
|
|
1554 : 08 > php ;save flags
|
|
1555 : c99b > cmp #$aa-$0f ;test result
|
|
> trap_ne
|
|
1557 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1559 : 68 > pla ;load status
|
|
155a : 48 > pha
|
|
> cmp_flag $ff
|
|
155b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
155d : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
155f : 28 > plp ;restore status
|
|
>
|
|
1560 : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
1562 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1564 : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
1566 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $1f,1
|
|
1568 : a042 > ldy #$42
|
|
156a : a203 > ldx #4-1
|
|
156c : 1f > db $1f ;test nop length
|
|
> if 1 = 1
|
|
156d : ca > dex
|
|
156e : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
156f : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
1570 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$1f,0
|
|
> load_flag 0
|
|
1572 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
1574 : 48 > pha ;use stack to load status
|
|
1575 : a9e0 > lda #$ff-$1f ;precharge accu
|
|
1577 : 28 > plp
|
|
>
|
|
1578 : 1f > db $1f ;test nop integrity - flags off
|
|
1579 : ea > nop
|
|
157a : ea > nop
|
|
> tst_a $ff-$1f,0
|
|
157b : 08 > php ;save flags
|
|
157c : c9e0 > cmp #$ff-$1f ;test result
|
|
> trap_ne
|
|
157e : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1580 : 68 > pla ;load status
|
|
1581 : 48 > pha
|
|
> cmp_flag 0
|
|
1582 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1584 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1586 : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$1f,$ff
|
|
> load_flag $ff
|
|
1587 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
1589 : 48 > pha ;use stack to load status
|
|
158a : a98b > lda #$aa-$1f ;precharge accu
|
|
158c : 28 > plp
|
|
>
|
|
158d : 1f > db $1f ;test nop integrity - flags on
|
|
158e : ea > nop
|
|
158f : ea > nop
|
|
> tst_a $aa-$1f,$ff
|
|
1590 : 08 > php ;save flags
|
|
1591 : c98b > cmp #$aa-$1f ;test result
|
|
> trap_ne
|
|
1593 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1595 : 68 > pla ;load status
|
|
1596 : 48 > pha
|
|
> cmp_flag $ff
|
|
1597 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1599 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
159b : 28 > plp ;restore status
|
|
>
|
|
159c : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
159e : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
15a0 : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
15a2 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $2f,1
|
|
15a4 : a042 > ldy #$42
|
|
15a6 : a203 > ldx #4-1
|
|
15a8 : 2f > db $2f ;test nop length
|
|
> if 1 = 1
|
|
15a9 : ca > dex
|
|
15aa : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
15ab : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
15ac : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$2f,0
|
|
> load_flag 0
|
|
15ae : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
15b0 : 48 > pha ;use stack to load status
|
|
15b1 : a9d0 > lda #$ff-$2f ;precharge accu
|
|
15b3 : 28 > plp
|
|
>
|
|
15b4 : 2f > db $2f ;test nop integrity - flags off
|
|
15b5 : ea > nop
|
|
15b6 : ea > nop
|
|
> tst_a $ff-$2f,0
|
|
15b7 : 08 > php ;save flags
|
|
15b8 : c9d0 > cmp #$ff-$2f ;test result
|
|
> trap_ne
|
|
15ba : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
15bc : 68 > pla ;load status
|
|
15bd : 48 > pha
|
|
> cmp_flag 0
|
|
15be : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
15c0 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
15c2 : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$2f,$ff
|
|
> load_flag $ff
|
|
15c3 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
15c5 : 48 > pha ;use stack to load status
|
|
15c6 : a97b > lda #$aa-$2f ;precharge accu
|
|
15c8 : 28 > plp
|
|
>
|
|
15c9 : 2f > db $2f ;test nop integrity - flags on
|
|
15ca : ea > nop
|
|
15cb : ea > nop
|
|
> tst_a $aa-$2f,$ff
|
|
15cc : 08 > php ;save flags
|
|
15cd : c97b > cmp #$aa-$2f ;test result
|
|
> trap_ne
|
|
15cf : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
15d1 : 68 > pla ;load status
|
|
15d2 : 48 > pha
|
|
> cmp_flag $ff
|
|
15d3 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
15d5 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
15d7 : 28 > plp ;restore status
|
|
>
|
|
15d8 : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
15da : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
15dc : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
15de : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $3f,1
|
|
15e0 : a042 > ldy #$42
|
|
15e2 : a203 > ldx #4-1
|
|
15e4 : 3f > db $3f ;test nop length
|
|
> if 1 = 1
|
|
15e5 : ca > dex
|
|
15e6 : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
15e7 : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
15e8 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$3f,0
|
|
> load_flag 0
|
|
15ea : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
15ec : 48 > pha ;use stack to load status
|
|
15ed : a9c0 > lda #$ff-$3f ;precharge accu
|
|
15ef : 28 > plp
|
|
>
|
|
15f0 : 3f > db $3f ;test nop integrity - flags off
|
|
15f1 : ea > nop
|
|
15f2 : ea > nop
|
|
> tst_a $ff-$3f,0
|
|
15f3 : 08 > php ;save flags
|
|
15f4 : c9c0 > cmp #$ff-$3f ;test result
|
|
> trap_ne
|
|
15f6 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
15f8 : 68 > pla ;load status
|
|
15f9 : 48 > pha
|
|
> cmp_flag 0
|
|
15fa : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
15fc : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
15fe : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$3f,$ff
|
|
> load_flag $ff
|
|
15ff : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
1601 : 48 > pha ;use stack to load status
|
|
1602 : a96b > lda #$aa-$3f ;precharge accu
|
|
1604 : 28 > plp
|
|
>
|
|
1605 : 3f > db $3f ;test nop integrity - flags on
|
|
1606 : ea > nop
|
|
1607 : ea > nop
|
|
> tst_a $aa-$3f,$ff
|
|
1608 : 08 > php ;save flags
|
|
1609 : c96b > cmp #$aa-$3f ;test result
|
|
> trap_ne
|
|
160b : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
160d : 68 > pla ;load status
|
|
160e : 48 > pha
|
|
> cmp_flag $ff
|
|
160f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1611 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1613 : 28 > plp ;restore status
|
|
>
|
|
1614 : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
1616 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1618 : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
161a : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $4f,1
|
|
161c : a042 > ldy #$42
|
|
161e : a203 > ldx #4-1
|
|
1620 : 4f > db $4f ;test nop length
|
|
> if 1 = 1
|
|
1621 : ca > dex
|
|
1622 : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
1623 : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
1624 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$4f,0
|
|
> load_flag 0
|
|
1626 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
1628 : 48 > pha ;use stack to load status
|
|
1629 : a9b0 > lda #$ff-$4f ;precharge accu
|
|
162b : 28 > plp
|
|
>
|
|
162c : 4f > db $4f ;test nop integrity - flags off
|
|
162d : ea > nop
|
|
162e : ea > nop
|
|
> tst_a $ff-$4f,0
|
|
162f : 08 > php ;save flags
|
|
1630 : c9b0 > cmp #$ff-$4f ;test result
|
|
> trap_ne
|
|
1632 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1634 : 68 > pla ;load status
|
|
1635 : 48 > pha
|
|
> cmp_flag 0
|
|
1636 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1638 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
163a : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$4f,$ff
|
|
> load_flag $ff
|
|
163b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
163d : 48 > pha ;use stack to load status
|
|
163e : a95b > lda #$aa-$4f ;precharge accu
|
|
1640 : 28 > plp
|
|
>
|
|
1641 : 4f > db $4f ;test nop integrity - flags on
|
|
1642 : ea > nop
|
|
1643 : ea > nop
|
|
> tst_a $aa-$4f,$ff
|
|
1644 : 08 > php ;save flags
|
|
1645 : c95b > cmp #$aa-$4f ;test result
|
|
> trap_ne
|
|
1647 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1649 : 68 > pla ;load status
|
|
164a : 48 > pha
|
|
> cmp_flag $ff
|
|
164b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
164d : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
164f : 28 > plp ;restore status
|
|
>
|
|
1650 : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
1652 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1654 : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
1656 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $5f,1
|
|
1658 : a042 > ldy #$42
|
|
165a : a203 > ldx #4-1
|
|
165c : 5f > db $5f ;test nop length
|
|
> if 1 = 1
|
|
165d : ca > dex
|
|
165e : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
165f : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
1660 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$5f,0
|
|
> load_flag 0
|
|
1662 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
1664 : 48 > pha ;use stack to load status
|
|
1665 : a9a0 > lda #$ff-$5f ;precharge accu
|
|
1667 : 28 > plp
|
|
>
|
|
1668 : 5f > db $5f ;test nop integrity - flags off
|
|
1669 : ea > nop
|
|
166a : ea > nop
|
|
> tst_a $ff-$5f,0
|
|
166b : 08 > php ;save flags
|
|
166c : c9a0 > cmp #$ff-$5f ;test result
|
|
> trap_ne
|
|
166e : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1670 : 68 > pla ;load status
|
|
1671 : 48 > pha
|
|
> cmp_flag 0
|
|
1672 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1674 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1676 : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$5f,$ff
|
|
> load_flag $ff
|
|
1677 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
1679 : 48 > pha ;use stack to load status
|
|
167a : a94b > lda #$aa-$5f ;precharge accu
|
|
167c : 28 > plp
|
|
>
|
|
167d : 5f > db $5f ;test nop integrity - flags on
|
|
167e : ea > nop
|
|
167f : ea > nop
|
|
> tst_a $aa-$5f,$ff
|
|
1680 : 08 > php ;save flags
|
|
1681 : c94b > cmp #$aa-$5f ;test result
|
|
> trap_ne
|
|
1683 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1685 : 68 > pla ;load status
|
|
1686 : 48 > pha
|
|
> cmp_flag $ff
|
|
1687 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1689 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
168b : 28 > plp ;restore status
|
|
>
|
|
168c : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
168e : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1690 : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
1692 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $6f,1
|
|
1694 : a042 > ldy #$42
|
|
1696 : a203 > ldx #4-1
|
|
1698 : 6f > db $6f ;test nop length
|
|
> if 1 = 1
|
|
1699 : ca > dex
|
|
169a : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
169b : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
169c : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$6f,0
|
|
> load_flag 0
|
|
169e : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
16a0 : 48 > pha ;use stack to load status
|
|
16a1 : a990 > lda #$ff-$6f ;precharge accu
|
|
16a3 : 28 > plp
|
|
>
|
|
16a4 : 6f > db $6f ;test nop integrity - flags off
|
|
16a5 : ea > nop
|
|
16a6 : ea > nop
|
|
> tst_a $ff-$6f,0
|
|
16a7 : 08 > php ;save flags
|
|
16a8 : c990 > cmp #$ff-$6f ;test result
|
|
> trap_ne
|
|
16aa : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
16ac : 68 > pla ;load status
|
|
16ad : 48 > pha
|
|
> cmp_flag 0
|
|
16ae : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
16b0 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
16b2 : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$6f,$ff
|
|
> load_flag $ff
|
|
16b3 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
16b5 : 48 > pha ;use stack to load status
|
|
16b6 : a93b > lda #$aa-$6f ;precharge accu
|
|
16b8 : 28 > plp
|
|
>
|
|
16b9 : 6f > db $6f ;test nop integrity - flags on
|
|
16ba : ea > nop
|
|
16bb : ea > nop
|
|
> tst_a $aa-$6f,$ff
|
|
16bc : 08 > php ;save flags
|
|
16bd : c93b > cmp #$aa-$6f ;test result
|
|
> trap_ne
|
|
16bf : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
16c1 : 68 > pla ;load status
|
|
16c2 : 48 > pha
|
|
> cmp_flag $ff
|
|
16c3 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
16c5 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
16c7 : 28 > plp ;restore status
|
|
>
|
|
16c8 : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
16ca : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
16cc : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
16ce : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $7f,1
|
|
16d0 : a042 > ldy #$42
|
|
16d2 : a203 > ldx #4-1
|
|
16d4 : 7f > db $7f ;test nop length
|
|
> if 1 = 1
|
|
16d5 : ca > dex
|
|
16d6 : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
16d7 : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
16d8 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$7f,0
|
|
> load_flag 0
|
|
16da : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
16dc : 48 > pha ;use stack to load status
|
|
16dd : a980 > lda #$ff-$7f ;precharge accu
|
|
16df : 28 > plp
|
|
>
|
|
16e0 : 7f > db $7f ;test nop integrity - flags off
|
|
16e1 : ea > nop
|
|
16e2 : ea > nop
|
|
> tst_a $ff-$7f,0
|
|
16e3 : 08 > php ;save flags
|
|
16e4 : c980 > cmp #$ff-$7f ;test result
|
|
> trap_ne
|
|
16e6 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
16e8 : 68 > pla ;load status
|
|
16e9 : 48 > pha
|
|
> cmp_flag 0
|
|
16ea : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
16ec : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
16ee : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$7f,$ff
|
|
> load_flag $ff
|
|
16ef : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
16f1 : 48 > pha ;use stack to load status
|
|
16f2 : a92b > lda #$aa-$7f ;precharge accu
|
|
16f4 : 28 > plp
|
|
>
|
|
16f5 : 7f > db $7f ;test nop integrity - flags on
|
|
16f6 : ea > nop
|
|
16f7 : ea > nop
|
|
> tst_a $aa-$7f,$ff
|
|
16f8 : 08 > php ;save flags
|
|
16f9 : c92b > cmp #$aa-$7f ;test result
|
|
> trap_ne
|
|
16fb : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
16fd : 68 > pla ;load status
|
|
16fe : 48 > pha
|
|
> cmp_flag $ff
|
|
16ff : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1701 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1703 : 28 > plp ;restore status
|
|
>
|
|
1704 : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
1706 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1708 : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
170a : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $8f,1
|
|
170c : a042 > ldy #$42
|
|
170e : a203 > ldx #4-1
|
|
1710 : 8f > db $8f ;test nop length
|
|
> if 1 = 1
|
|
1711 : ca > dex
|
|
1712 : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
1713 : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
1714 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$8f,0
|
|
> load_flag 0
|
|
1716 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
1718 : 48 > pha ;use stack to load status
|
|
1719 : a970 > lda #$ff-$8f ;precharge accu
|
|
171b : 28 > plp
|
|
>
|
|
171c : 8f > db $8f ;test nop integrity - flags off
|
|
171d : ea > nop
|
|
171e : ea > nop
|
|
> tst_a $ff-$8f,0
|
|
171f : 08 > php ;save flags
|
|
1720 : c970 > cmp #$ff-$8f ;test result
|
|
> trap_ne
|
|
1722 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1724 : 68 > pla ;load status
|
|
1725 : 48 > pha
|
|
> cmp_flag 0
|
|
1726 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1728 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
172a : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$8f,$ff
|
|
> load_flag $ff
|
|
172b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
172d : 48 > pha ;use stack to load status
|
|
172e : a91b > lda #$aa-$8f ;precharge accu
|
|
1730 : 28 > plp
|
|
>
|
|
1731 : 8f > db $8f ;test nop integrity - flags on
|
|
1732 : ea > nop
|
|
1733 : ea > nop
|
|
> tst_a $aa-$8f,$ff
|
|
1734 : 08 > php ;save flags
|
|
1735 : c91b > cmp #$aa-$8f ;test result
|
|
> trap_ne
|
|
1737 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1739 : 68 > pla ;load status
|
|
173a : 48 > pha
|
|
> cmp_flag $ff
|
|
173b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
173d : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
173f : 28 > plp ;restore status
|
|
>
|
|
1740 : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
1742 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1744 : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
1746 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $9f,1
|
|
1748 : a042 > ldy #$42
|
|
174a : a203 > ldx #4-1
|
|
174c : 9f > db $9f ;test nop length
|
|
> if 1 = 1
|
|
174d : ca > dex
|
|
174e : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
174f : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
1750 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$9f,0
|
|
> load_flag 0
|
|
1752 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
1754 : 48 > pha ;use stack to load status
|
|
1755 : a960 > lda #$ff-$9f ;precharge accu
|
|
1757 : 28 > plp
|
|
>
|
|
1758 : 9f > db $9f ;test nop integrity - flags off
|
|
1759 : ea > nop
|
|
175a : ea > nop
|
|
> tst_a $ff-$9f,0
|
|
175b : 08 > php ;save flags
|
|
175c : c960 > cmp #$ff-$9f ;test result
|
|
> trap_ne
|
|
175e : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1760 : 68 > pla ;load status
|
|
1761 : 48 > pha
|
|
> cmp_flag 0
|
|
1762 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1764 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1766 : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$9f,$ff
|
|
> load_flag $ff
|
|
1767 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
1769 : 48 > pha ;use stack to load status
|
|
176a : a90b > lda #$aa-$9f ;precharge accu
|
|
176c : 28 > plp
|
|
>
|
|
176d : 9f > db $9f ;test nop integrity - flags on
|
|
176e : ea > nop
|
|
176f : ea > nop
|
|
> tst_a $aa-$9f,$ff
|
|
1770 : 08 > php ;save flags
|
|
1771 : c90b > cmp #$aa-$9f ;test result
|
|
> trap_ne
|
|
1773 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1775 : 68 > pla ;load status
|
|
1776 : 48 > pha
|
|
> cmp_flag $ff
|
|
1777 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1779 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
177b : 28 > plp ;restore status
|
|
>
|
|
177c : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
177e : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1780 : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
1782 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $af,1
|
|
1784 : a042 > ldy #$42
|
|
1786 : a203 > ldx #4-1
|
|
1788 : af > db $af ;test nop length
|
|
> if 1 = 1
|
|
1789 : ca > dex
|
|
178a : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
178b : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
178c : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$af,0
|
|
> load_flag 0
|
|
178e : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
1790 : 48 > pha ;use stack to load status
|
|
1791 : a950 > lda #$ff-$af ;precharge accu
|
|
1793 : 28 > plp
|
|
>
|
|
1794 : af > db $af ;test nop integrity - flags off
|
|
1795 : ea > nop
|
|
1796 : ea > nop
|
|
> tst_a $ff-$af,0
|
|
1797 : 08 > php ;save flags
|
|
1798 : c950 > cmp #$ff-$af ;test result
|
|
> trap_ne
|
|
179a : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
179c : 68 > pla ;load status
|
|
179d : 48 > pha
|
|
> cmp_flag 0
|
|
179e : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
17a0 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
17a2 : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$af,$ff
|
|
> load_flag $ff
|
|
17a3 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
17a5 : 48 > pha ;use stack to load status
|
|
17a6 : a9fb > lda #$aa-$af ;precharge accu
|
|
17a8 : 28 > plp
|
|
>
|
|
17a9 : af > db $af ;test nop integrity - flags on
|
|
17aa : ea > nop
|
|
17ab : ea > nop
|
|
> tst_a $aa-$af,$ff
|
|
17ac : 08 > php ;save flags
|
|
17ad : c9fb > cmp #$aa-$af ;test result
|
|
> trap_ne
|
|
17af : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
17b1 : 68 > pla ;load status
|
|
17b2 : 48 > pha
|
|
> cmp_flag $ff
|
|
17b3 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
17b5 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
17b7 : 28 > plp ;restore status
|
|
>
|
|
17b8 : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
17ba : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
17bc : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
17be : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $bf,1
|
|
17c0 : a042 > ldy #$42
|
|
17c2 : a203 > ldx #4-1
|
|
17c4 : bf > db $bf ;test nop length
|
|
> if 1 = 1
|
|
17c5 : ca > dex
|
|
17c6 : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
17c7 : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
17c8 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$bf,0
|
|
> load_flag 0
|
|
17ca : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
17cc : 48 > pha ;use stack to load status
|
|
17cd : a940 > lda #$ff-$bf ;precharge accu
|
|
17cf : 28 > plp
|
|
>
|
|
17d0 : bf > db $bf ;test nop integrity - flags off
|
|
17d1 : ea > nop
|
|
17d2 : ea > nop
|
|
> tst_a $ff-$bf,0
|
|
17d3 : 08 > php ;save flags
|
|
17d4 : c940 > cmp #$ff-$bf ;test result
|
|
> trap_ne
|
|
17d6 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
17d8 : 68 > pla ;load status
|
|
17d9 : 48 > pha
|
|
> cmp_flag 0
|
|
17da : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
17dc : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
17de : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$bf,$ff
|
|
> load_flag $ff
|
|
17df : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
17e1 : 48 > pha ;use stack to load status
|
|
17e2 : a9eb > lda #$aa-$bf ;precharge accu
|
|
17e4 : 28 > plp
|
|
>
|
|
17e5 : bf > db $bf ;test nop integrity - flags on
|
|
17e6 : ea > nop
|
|
17e7 : ea > nop
|
|
> tst_a $aa-$bf,$ff
|
|
17e8 : 08 > php ;save flags
|
|
17e9 : c9eb > cmp #$aa-$bf ;test result
|
|
> trap_ne
|
|
17eb : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
17ed : 68 > pla ;load status
|
|
17ee : 48 > pha
|
|
> cmp_flag $ff
|
|
17ef : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
17f1 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
17f3 : 28 > plp ;restore status
|
|
>
|
|
17f4 : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
17f6 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
17f8 : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
17fa : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $cf,1
|
|
17fc : a042 > ldy #$42
|
|
17fe : a203 > ldx #4-1
|
|
1800 : cf > db $cf ;test nop length
|
|
> if 1 = 1
|
|
1801 : ca > dex
|
|
1802 : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
1803 : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
1804 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$cf,0
|
|
> load_flag 0
|
|
1806 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
1808 : 48 > pha ;use stack to load status
|
|
1809 : a930 > lda #$ff-$cf ;precharge accu
|
|
180b : 28 > plp
|
|
>
|
|
180c : cf > db $cf ;test nop integrity - flags off
|
|
180d : ea > nop
|
|
180e : ea > nop
|
|
> tst_a $ff-$cf,0
|
|
180f : 08 > php ;save flags
|
|
1810 : c930 > cmp #$ff-$cf ;test result
|
|
> trap_ne
|
|
1812 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1814 : 68 > pla ;load status
|
|
1815 : 48 > pha
|
|
> cmp_flag 0
|
|
1816 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1818 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
181a : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$cf,$ff
|
|
> load_flag $ff
|
|
181b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
181d : 48 > pha ;use stack to load status
|
|
181e : a9db > lda #$aa-$cf ;precharge accu
|
|
1820 : 28 > plp
|
|
>
|
|
1821 : cf > db $cf ;test nop integrity - flags on
|
|
1822 : ea > nop
|
|
1823 : ea > nop
|
|
> tst_a $aa-$cf,$ff
|
|
1824 : 08 > php ;save flags
|
|
1825 : c9db > cmp #$aa-$cf ;test result
|
|
> trap_ne
|
|
1827 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1829 : 68 > pla ;load status
|
|
182a : 48 > pha
|
|
> cmp_flag $ff
|
|
182b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
182d : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
182f : 28 > plp ;restore status
|
|
>
|
|
1830 : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
1832 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1834 : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
1836 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $df,1
|
|
1838 : a042 > ldy #$42
|
|
183a : a203 > ldx #4-1
|
|
183c : df > db $df ;test nop length
|
|
> if 1 = 1
|
|
183d : ca > dex
|
|
183e : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
183f : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
1840 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$df,0
|
|
> load_flag 0
|
|
1842 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
1844 : 48 > pha ;use stack to load status
|
|
1845 : a920 > lda #$ff-$df ;precharge accu
|
|
1847 : 28 > plp
|
|
>
|
|
1848 : df > db $df ;test nop integrity - flags off
|
|
1849 : ea > nop
|
|
184a : ea > nop
|
|
> tst_a $ff-$df,0
|
|
184b : 08 > php ;save flags
|
|
184c : c920 > cmp #$ff-$df ;test result
|
|
> trap_ne
|
|
184e : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1850 : 68 > pla ;load status
|
|
1851 : 48 > pha
|
|
> cmp_flag 0
|
|
1852 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1854 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1856 : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$df,$ff
|
|
> load_flag $ff
|
|
1857 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
1859 : 48 > pha ;use stack to load status
|
|
185a : a9cb > lda #$aa-$df ;precharge accu
|
|
185c : 28 > plp
|
|
>
|
|
185d : df > db $df ;test nop integrity - flags on
|
|
185e : ea > nop
|
|
185f : ea > nop
|
|
> tst_a $aa-$df,$ff
|
|
1860 : 08 > php ;save flags
|
|
1861 : c9cb > cmp #$aa-$df ;test result
|
|
> trap_ne
|
|
1863 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1865 : 68 > pla ;load status
|
|
1866 : 48 > pha
|
|
> cmp_flag $ff
|
|
1867 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1869 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
186b : 28 > plp ;restore status
|
|
>
|
|
186c : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
186e : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1870 : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
1872 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $ef,1
|
|
1874 : a042 > ldy #$42
|
|
1876 : a203 > ldx #4-1
|
|
1878 : ef > db $ef ;test nop length
|
|
> if 1 = 1
|
|
1879 : ca > dex
|
|
187a : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
187b : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
187c : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$ef,0
|
|
> load_flag 0
|
|
187e : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
1880 : 48 > pha ;use stack to load status
|
|
1881 : a910 > lda #$ff-$ef ;precharge accu
|
|
1883 : 28 > plp
|
|
>
|
|
1884 : ef > db $ef ;test nop integrity - flags off
|
|
1885 : ea > nop
|
|
1886 : ea > nop
|
|
> tst_a $ff-$ef,0
|
|
1887 : 08 > php ;save flags
|
|
1888 : c910 > cmp #$ff-$ef ;test result
|
|
> trap_ne
|
|
188a : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
188c : 68 > pla ;load status
|
|
188d : 48 > pha
|
|
> cmp_flag 0
|
|
188e : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1890 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1892 : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$ef,$ff
|
|
> load_flag $ff
|
|
1893 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
1895 : 48 > pha ;use stack to load status
|
|
1896 : a9bb > lda #$aa-$ef ;precharge accu
|
|
1898 : 28 > plp
|
|
>
|
|
1899 : ef > db $ef ;test nop integrity - flags on
|
|
189a : ea > nop
|
|
189b : ea > nop
|
|
> tst_a $aa-$ef,$ff
|
|
189c : 08 > php ;save flags
|
|
189d : c9bb > cmp #$aa-$ef ;test result
|
|
> trap_ne
|
|
189f : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
18a1 : 68 > pla ;load status
|
|
18a2 : 48 > pha
|
|
> cmp_flag $ff
|
|
18a3 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
18a5 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
18a7 : 28 > plp ;restore status
|
|
>
|
|
18a8 : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
18aa : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
18ac : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
18ae : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
nop_test $ff,1
|
|
18b0 : a042 > ldy #$42
|
|
18b2 : a203 > ldx #4-1
|
|
18b4 : ff > db $ff ;test nop length
|
|
> if 1 = 1
|
|
18b5 : ca > dex
|
|
18b6 : ca > dex
|
|
> endif
|
|
> if 1 = 2
|
|
> iny
|
|
> dex
|
|
> endif
|
|
> if 1 = 3
|
|
> iny
|
|
> iny
|
|
> endif
|
|
18b7 : ca > dex
|
|
> trap_ne ;wrong number of bytes
|
|
18b8 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
> set_a $ff-$ff,0
|
|
> load_flag 0
|
|
18ba : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
18bc : 48 > pha ;use stack to load status
|
|
18bd : a900 > lda #$ff-$ff ;precharge accu
|
|
18bf : 28 > plp
|
|
>
|
|
18c0 : ff > db $ff ;test nop integrity - flags off
|
|
18c1 : ea > nop
|
|
18c2 : ea > nop
|
|
> tst_a $ff-$ff,0
|
|
18c3 : 08 > php ;save flags
|
|
18c4 : c900 > cmp #$ff-$ff ;test result
|
|
> trap_ne
|
|
18c6 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
18c8 : 68 > pla ;load status
|
|
18c9 : 48 > pha
|
|
> cmp_flag 0
|
|
18ca : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
18cc : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
18ce : 28 > plp ;restore status
|
|
>
|
|
> set_a $aa-$ff,$ff
|
|
> load_flag $ff
|
|
18cf : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
18d1 : 48 > pha ;use stack to load status
|
|
18d2 : a9ab > lda #$aa-$ff ;precharge accu
|
|
18d4 : 28 > plp
|
|
>
|
|
18d5 : ff > db $ff ;test nop integrity - flags on
|
|
18d6 : ea > nop
|
|
18d7 : ea > nop
|
|
> tst_a $aa-$ff,$ff
|
|
18d8 : 08 > php ;save flags
|
|
18d9 : c9ab > cmp #$aa-$ff ;test result
|
|
> trap_ne
|
|
18db : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
18dd : 68 > pla ;load status
|
|
18de : 48 > pha
|
|
> cmp_flag $ff
|
|
18df : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
18e1 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
18e3 : 28 > plp ;restore status
|
|
>
|
|
18e4 : c042 > cpy #$42
|
|
> trap_ne ;y changed
|
|
18e6 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
18e8 : e000 > cpx #0
|
|
> trap_ne ;x changed
|
|
18ea : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
endif
|
|
if wdc_op = 0 ;NOPs not available on WDC 65C02 (WAI, STP)
|
|
nop_test $cb,1
|
|
nop_test $db,1
|
|
endif
|
|
next_test
|
|
18ec : ad0202 > lda test_case ;previous test
|
|
18ef : c906 > cmp #test_num
|
|
> trap_ne ;test is out of sequence
|
|
18f1 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0007 = >test_num = test_num + 1
|
|
18f3 : a907 > lda #test_num ;*** next tests' number
|
|
18f5 : 8d0202 > sta test_case
|
|
> ;check_ram ;uncomment to find altered RAM after each test
|
|
|
|
endif
|
|
|
|
; jump indirect (test page cross bug is fixed)
|
|
18f8 : a203 ldx #3 ;prepare table
|
|
18fa : bd5625 ji1 lda ji_adr,x
|
|
18fd : 9dfd02 sta ji_tab,x
|
|
1900 : ca dex
|
|
1901 : 10f7 bpl ji1
|
|
1903 : a927 lda #hi(ji_px) ;high address if page cross bug
|
|
1905 : 8d0002 sta pg_x
|
|
set_stat 0
|
|
> load_flag 0
|
|
1908 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
190a : 48 > pha ;use stack to load status
|
|
190b : 28 > plp
|
|
|
|
190c : a949 lda #'I'
|
|
190e : a24e ldx #'N'
|
|
1910 : a044 ldy #'D' ;N=0, V=0, Z=0, C=0
|
|
1912 : 6cfd02 jmp (ji_tab)
|
|
1915 : ea nop
|
|
trap_ne ;runover protection
|
|
1916 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
|
|
1918 : 88 dey
|
|
1919 : 88 dey
|
|
191a : 08 ji_ret php ;either SP or Y count will fail, if we do not hit
|
|
191b : 88 dey
|
|
191c : 88 dey
|
|
191d : 88 dey
|
|
191e : 28 plp
|
|
trap_eq ;returned flags OK?
|
|
191f : f0fe > beq * ;failed equal (zero)
|
|
|
|
trap_pl
|
|
1921 : 10fe > bpl * ;failed plus (bit 7 clear)
|
|
|
|
trap_cc
|
|
1923 : 90fe > bcc * ;failed carry clear
|
|
|
|
trap_vc
|
|
1925 : 50fe > bvc * ;failed overflow clear
|
|
|
|
1927 : c9e3 cmp #('I'^$aa) ;returned registers OK?
|
|
trap_ne
|
|
1929 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
192b : e04f cpx #('N'+1)
|
|
trap_ne
|
|
192d : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
192f : c03e cpy #('D'-6)
|
|
trap_ne
|
|
1931 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
1933 : ba tsx ;SP check
|
|
1934 : e0ff cpx #$ff
|
|
trap_ne
|
|
1936 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
next_test
|
|
1938 : ad0202 > lda test_case ;previous test
|
|
193b : c907 > cmp #test_num
|
|
> trap_ne ;test is out of sequence
|
|
193d : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0008 = >test_num = test_num + 1
|
|
193f : a908 > lda #test_num ;*** next tests' number
|
|
1941 : 8d0202 > sta test_case
|
|
> ;check_ram ;uncomment to find altered RAM after each test
|
|
|
|
|
|
; jump indexed indirect
|
|
1944 : a20b ldx #11 ;prepare table
|
|
1946 : bd9225 jxi1 lda jxi_adr,x
|
|
1949 : 9df902 sta jxi_tab,x
|
|
194c : ca dex
|
|
194d : 10f7 bpl jxi1
|
|
194f : a927 lda #hi(jxi_px) ;high address if page cross bug
|
|
1951 : 8d0002 sta pg_x
|
|
set_stat 0
|
|
> load_flag 0
|
|
1954 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
1956 : 48 > pha ;use stack to load status
|
|
1957 : 28 > plp
|
|
|
|
1958 : a958 lda #'X'
|
|
195a : a204 ldx #4
|
|
195c : a049 ldy #'I' ;N=0, V=0, Z=0, C=0
|
|
195e : 7cf902 jmp (jxi_tab,x)
|
|
1961 : ea nop
|
|
trap_ne ;runover protection
|
|
1962 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
|
|
1964 : 88 dey
|
|
1965 : 88 dey
|
|
1966 : 08 jxi_ret php ;either SP or Y count will fail, if we do not hit
|
|
1967 : 88 dey
|
|
1968 : 88 dey
|
|
1969 : 88 dey
|
|
196a : 28 plp
|
|
trap_eq ;returned flags OK?
|
|
196b : f0fe > beq * ;failed equal (zero)
|
|
|
|
trap_pl
|
|
196d : 10fe > bpl * ;failed plus (bit 7 clear)
|
|
|
|
trap_cc
|
|
196f : 90fe > bcc * ;failed carry clear
|
|
|
|
trap_vc
|
|
1971 : 50fe > bvc * ;failed overflow clear
|
|
|
|
1973 : c9f2 cmp #('X'^$aa) ;returned registers OK?
|
|
trap_ne
|
|
1975 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
1977 : e006 cpx #6
|
|
trap_ne
|
|
1979 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
197b : c043 cpy #('I'-6)
|
|
trap_ne
|
|
197d : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
197f : ba tsx ;SP check
|
|
1980 : e0ff cpx #$ff
|
|
trap_ne
|
|
1982 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
|
|
1984 : a9a0 lda #lo(jxp_ok) ;test with index causing a page cross
|
|
1986 : 8d0003 sta jxp_tab
|
|
1989 : a919 lda #hi(jxp_ok)
|
|
198b : 8d0103 sta jxp_tab+1
|
|
198e : a99d lda #lo(jxp_px)
|
|
1990 : 8d0002 sta pg_x
|
|
1993 : a919 lda #hi(jxp_px)
|
|
1995 : 8d0102 sta pg_x+1
|
|
1998 : a2ff ldx #$ff
|
|
199a : 7c0102 jmp (jxp_tab-$ff,x)
|
|
|
|
199d : jxp_px
|
|
trap ;page cross by index to wrong page
|
|
199d : 4c9d19 > jmp * ;failed anyway
|
|
|
|
|
|
19a0 : jxp_ok
|
|
next_test
|
|
19a0 : ad0202 > lda test_case ;previous test
|
|
19a3 : c908 > cmp #test_num
|
|
> trap_ne ;test is out of sequence
|
|
19a5 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0009 = >test_num = test_num + 1
|
|
19a7 : a909 > lda #test_num ;*** next tests' number
|
|
19a9 : 8d0202 > sta test_case
|
|
> ;check_ram ;uncomment to find altered RAM after each test
|
|
|
|
|
|
if ROM_vectors = 1
|
|
; test BRK clears decimal mode
|
|
load_flag 0 ;with interrupts enabled if allowed!
|
|
19ac : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
|
|
19ae : 48 pha
|
|
19af : a942 lda #'B'
|
|
19b1 : a252 ldx #'R'
|
|
19b3 : a04b ldy #'K'
|
|
19b5 : 28 plp ;N=0, V=0, Z=0, C=0
|
|
19b6 : 00 brk
|
|
19b7 : 88 dey ;should not be executed
|
|
19b8 : brk_ret0 ;address of break return
|
|
19b8 : 08 php ;either SP or Y count will fail, if we do not hit
|
|
19b9 : 88 dey
|
|
19ba : 88 dey
|
|
19bb : 88 dey
|
|
19bc : c9e8 cmp #'B'^$aa ;returned registers OK?
|
|
;the IRQ vector was never executed if A & X stay unmodified
|
|
trap_ne
|
|
19be : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
19c0 : e053 cpx #'R'+1
|
|
trap_ne
|
|
19c2 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
19c4 : c045 cpy #'K'-6
|
|
trap_ne
|
|
19c6 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
19c8 : 68 pla ;returned flags OK (unchanged)?
|
|
cmp_flag 0
|
|
19c9 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
|
|
trap_ne
|
|
19cb : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
19cd : ba tsx ;sp?
|
|
19ce : e0ff cpx #$ff
|
|
trap_ne
|
|
19d0 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
;pass 2
|
|
load_flag $ff ;with interrupts disabled if allowed!
|
|
19d2 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
|
|
19d4 : 48 pha
|
|
19d5 : a9bd lda #$ff-'B'
|
|
19d7 : a2ad ldx #$ff-'R'
|
|
19d9 : a0b4 ldy #$ff-'K'
|
|
19db : 28 plp ;N=1, V=1, Z=1, C=1
|
|
19dc : 00 brk
|
|
19dd : 88 dey ;should not be executed
|
|
19de : brk_ret1 ;address of break return
|
|
19de : 08 php ;either SP or Y count will fail, if we do not hit
|
|
19df : 88 dey
|
|
19e0 : 88 dey
|
|
19e1 : 88 dey
|
|
19e2 : c917 cmp #($ff-'B')^$aa ;returned registers OK?
|
|
;the IRQ vector was never executed if A & X stay unmodified
|
|
trap_ne
|
|
19e4 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
19e6 : e0ae cpx #$ff-'R'+1
|
|
trap_ne
|
|
19e8 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
19ea : c0ae cpy #$ff-'K'-6
|
|
trap_ne
|
|
19ec : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
19ee : 68 pla ;returned flags OK (unchanged)?
|
|
cmp_flag $ff
|
|
19ef : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
|
|
trap_ne
|
|
19f1 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
19f3 : ba tsx ;sp?
|
|
19f4 : e0ff cpx #$ff
|
|
trap_ne
|
|
19f6 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
next_test
|
|
19f8 : ad0202 > lda test_case ;previous test
|
|
19fb : c909 > cmp #test_num
|
|
> trap_ne ;test is out of sequence
|
|
19fd : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
000a = >test_num = test_num + 1
|
|
19ff : a90a > lda #test_num ;*** next tests' number
|
|
1a01 : 8d0202 > sta test_case
|
|
> ;check_ram ;uncomment to find altered RAM after each test
|
|
|
|
endif
|
|
|
|
; testing accumulator increment/decrement INC A & DEC A
|
|
1a04 : a2ac ldx #$ac ;protect x & y
|
|
1a06 : a0dc ldy #$dc
|
|
set_a $fe,$ff
|
|
> load_flag $ff
|
|
1a08 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
1a0a : 48 > pha ;use stack to load status
|
|
1a0b : a9fe > lda #$fe ;precharge accu
|
|
1a0d : 28 > plp
|
|
|
|
1a0e : 1a inc a ;ff
|
|
tst_as $ff,$ff-zero
|
|
1a0f : 48 > pha
|
|
1a10 : 08 > php ;save flags
|
|
1a11 : c9ff > cmp #$ff ;test result
|
|
> trap_ne
|
|
1a13 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1a15 : 68 > pla ;load status
|
|
1a16 : 48 > pha
|
|
> cmp_flag $ff-zero
|
|
1a17 : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1a19 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1a1b : 28 > plp ;restore status
|
|
1a1c : 68 > pla
|
|
|
|
1a1d : 1a inc a ;00
|
|
tst_as 0,$ff-minus
|
|
1a1e : 48 > pha
|
|
1a1f : 08 > php ;save flags
|
|
1a20 : c900 > cmp #0 ;test result
|
|
> trap_ne
|
|
1a22 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1a24 : 68 > pla ;load status
|
|
1a25 : 48 > pha
|
|
> cmp_flag $ff-minus
|
|
1a26 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1a28 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1a2a : 28 > plp ;restore status
|
|
1a2b : 68 > pla
|
|
|
|
1a2c : 1a inc a ;01
|
|
tst_as 1,$ff-minus-zero
|
|
1a2d : 48 > pha
|
|
1a2e : 08 > php ;save flags
|
|
1a2f : c901 > cmp #1 ;test result
|
|
> trap_ne
|
|
1a31 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1a33 : 68 > pla ;load status
|
|
1a34 : 48 > pha
|
|
> cmp_flag $ff-minus-zero
|
|
1a35 : c97d > cmp #($ff-minus-zero|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1a37 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1a39 : 28 > plp ;restore status
|
|
1a3a : 68 > pla
|
|
|
|
1a3b : 3a dec a ;00
|
|
tst_as 0,$ff-minus
|
|
1a3c : 48 > pha
|
|
1a3d : 08 > php ;save flags
|
|
1a3e : c900 > cmp #0 ;test result
|
|
> trap_ne
|
|
1a40 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1a42 : 68 > pla ;load status
|
|
1a43 : 48 > pha
|
|
> cmp_flag $ff-minus
|
|
1a44 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1a46 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1a48 : 28 > plp ;restore status
|
|
1a49 : 68 > pla
|
|
|
|
1a4a : 3a dec a ;ff
|
|
tst_as $ff,$ff-zero
|
|
1a4b : 48 > pha
|
|
1a4c : 08 > php ;save flags
|
|
1a4d : c9ff > cmp #$ff ;test result
|
|
> trap_ne
|
|
1a4f : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1a51 : 68 > pla ;load status
|
|
1a52 : 48 > pha
|
|
> cmp_flag $ff-zero
|
|
1a53 : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1a55 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1a57 : 28 > plp ;restore status
|
|
1a58 : 68 > pla
|
|
|
|
1a59 : 3a dec a ;fe
|
|
set_a $fe,0
|
|
> load_flag 0
|
|
1a5a : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
1a5c : 48 > pha ;use stack to load status
|
|
1a5d : a9fe > lda #$fe ;precharge accu
|
|
1a5f : 28 > plp
|
|
|
|
1a60 : 1a inc a ;ff
|
|
tst_as $ff,minus
|
|
1a61 : 48 > pha
|
|
1a62 : 08 > php ;save flags
|
|
1a63 : c9ff > cmp #$ff ;test result
|
|
> trap_ne
|
|
1a65 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1a67 : 68 > pla ;load status
|
|
1a68 : 48 > pha
|
|
> cmp_flag minus
|
|
1a69 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1a6b : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1a6d : 28 > plp ;restore status
|
|
1a6e : 68 > pla
|
|
|
|
1a6f : 1a inc a ;00
|
|
tst_as 0,zero
|
|
1a70 : 48 > pha
|
|
1a71 : 08 > php ;save flags
|
|
1a72 : c900 > cmp #0 ;test result
|
|
> trap_ne
|
|
1a74 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1a76 : 68 > pla ;load status
|
|
1a77 : 48 > pha
|
|
> cmp_flag zero
|
|
1a78 : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1a7a : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1a7c : 28 > plp ;restore status
|
|
1a7d : 68 > pla
|
|
|
|
1a7e : 1a inc a ;01
|
|
tst_as 1,0
|
|
1a7f : 48 > pha
|
|
1a80 : 08 > php ;save flags
|
|
1a81 : c901 > cmp #1 ;test result
|
|
> trap_ne
|
|
1a83 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1a85 : 68 > pla ;load status
|
|
1a86 : 48 > pha
|
|
> cmp_flag 0
|
|
1a87 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1a89 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1a8b : 28 > plp ;restore status
|
|
1a8c : 68 > pla
|
|
|
|
1a8d : 3a dec a ;00
|
|
tst_as 0,zero
|
|
1a8e : 48 > pha
|
|
1a8f : 08 > php ;save flags
|
|
1a90 : c900 > cmp #0 ;test result
|
|
> trap_ne
|
|
1a92 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1a94 : 68 > pla ;load status
|
|
1a95 : 48 > pha
|
|
> cmp_flag zero
|
|
1a96 : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1a98 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1a9a : 28 > plp ;restore status
|
|
1a9b : 68 > pla
|
|
|
|
1a9c : 3a dec a ;ff
|
|
tst_as $ff,minus
|
|
1a9d : 48 > pha
|
|
1a9e : 08 > php ;save flags
|
|
1a9f : c9ff > cmp #$ff ;test result
|
|
> trap_ne
|
|
1aa1 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1aa3 : 68 > pla ;load status
|
|
1aa4 : 48 > pha
|
|
> cmp_flag minus
|
|
1aa5 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1aa7 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1aa9 : 28 > plp ;restore status
|
|
1aaa : 68 > pla
|
|
|
|
1aab : e0ac cpx #$ac
|
|
trap_ne ;x altered during test
|
|
1aad : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
1aaf : c0dc cpy #$dc
|
|
trap_ne ;y altered during test
|
|
1ab1 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
1ab3 : ba tsx
|
|
1ab4 : e0ff cpx #$ff
|
|
trap_ne ;sp push/pop mismatch
|
|
1ab6 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
next_test
|
|
1ab8 : ad0202 > lda test_case ;previous test
|
|
1abb : c90a > cmp #test_num
|
|
> trap_ne ;test is out of sequence
|
|
1abd : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
000b = >test_num = test_num + 1
|
|
1abf : a90b > lda #test_num ;*** next tests' number
|
|
1ac1 : 8d0202 > sta test_case
|
|
> ;check_ram ;uncomment to find altered RAM after each test
|
|
|
|
|
|
; testing load / store accumulator LDA / STA (zp)
|
|
1ac4 : a299 ldx #$99 ;protect x & y
|
|
1ac6 : a066 ldy #$66
|
|
set_stat 0
|
|
> load_flag 0
|
|
1ac8 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
1aca : 48 > pha ;use stack to load status
|
|
1acb : 28 > plp
|
|
|
|
1acc : b224 lda (ind1)
|
|
1ace : 08 php ;test stores do not alter flags
|
|
1acf : 49c3 eor #$c3
|
|
1ad1 : 28 plp
|
|
1ad2 : 9230 sta (indt)
|
|
1ad4 : 08 php ;flags after load/store sequence
|
|
1ad5 : 49c3 eor #$c3
|
|
1ad7 : c9c3 cmp #$c3 ;test result
|
|
trap_ne
|
|
1ad9 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
1adb : 68 pla ;load status
|
|
eor_flag 0
|
|
1adc : 4930 > eor #0|fao ;invert expected flags + always on bits
|
|
|
|
1ade : cd1502 cmp fLDx ;test flags
|
|
trap_ne
|
|
1ae1 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
set_stat 0
|
|
> load_flag 0
|
|
1ae3 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
1ae5 : 48 > pha ;use stack to load status
|
|
1ae6 : 28 > plp
|
|
|
|
1ae7 : b226 lda (ind1+2)
|
|
1ae9 : 08 php ;test stores do not alter flags
|
|
1aea : 49c3 eor #$c3
|
|
1aec : 28 plp
|
|
1aed : 9232 sta (indt+2)
|
|
1aef : 08 php ;flags after load/store sequence
|
|
1af0 : 49c3 eor #$c3
|
|
1af2 : c982 cmp #$82 ;test result
|
|
trap_ne
|
|
1af4 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
1af6 : 68 pla ;load status
|
|
eor_flag 0
|
|
1af7 : 4930 > eor #0|fao ;invert expected flags + always on bits
|
|
|
|
1af9 : cd1602 cmp fLDx+1 ;test flags
|
|
trap_ne
|
|
1afc : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
set_stat 0
|
|
> load_flag 0
|
|
1afe : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
1b00 : 48 > pha ;use stack to load status
|
|
1b01 : 28 > plp
|
|
|
|
1b02 : b228 lda (ind1+4)
|
|
1b04 : 08 php ;test stores do not alter flags
|
|
1b05 : 49c3 eor #$c3
|
|
1b07 : 28 plp
|
|
1b08 : 9234 sta (indt+4)
|
|
1b0a : 08 php ;flags after load/store sequence
|
|
1b0b : 49c3 eor #$c3
|
|
1b0d : c941 cmp #$41 ;test result
|
|
trap_ne
|
|
1b0f : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
1b11 : 68 pla ;load status
|
|
eor_flag 0
|
|
1b12 : 4930 > eor #0|fao ;invert expected flags + always on bits
|
|
|
|
1b14 : cd1702 cmp fLDx+2 ;test flags
|
|
trap_ne
|
|
1b17 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
set_stat 0
|
|
> load_flag 0
|
|
1b19 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
1b1b : 48 > pha ;use stack to load status
|
|
1b1c : 28 > plp
|
|
|
|
1b1d : b22a lda (ind1+6)
|
|
1b1f : 08 php ;test stores do not alter flags
|
|
1b20 : 49c3 eor #$c3
|
|
1b22 : 28 plp
|
|
1b23 : 9236 sta (indt+6)
|
|
1b25 : 08 php ;flags after load/store sequence
|
|
1b26 : 49c3 eor #$c3
|
|
1b28 : c900 cmp #0 ;test result
|
|
trap_ne
|
|
1b2a : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
1b2c : 68 pla ;load status
|
|
eor_flag 0
|
|
1b2d : 4930 > eor #0|fao ;invert expected flags + always on bits
|
|
|
|
1b2f : cd1802 cmp fLDx+3 ;test flags
|
|
trap_ne
|
|
1b32 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
1b34 : e099 cpx #$99
|
|
trap_ne ;x altered during test
|
|
1b36 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
1b38 : c066 cpy #$66
|
|
trap_ne ;y altered during test
|
|
1b3a : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
|
|
1b3c : a003 ldy #3 ;testing store result
|
|
1b3e : a200 ldx #0
|
|
1b40 : b90502 tstai1 lda abst,y
|
|
1b43 : 49c3 eor #$c3
|
|
1b45 : d91002 cmp abs1,y
|
|
trap_ne ;store to indirect data
|
|
1b48 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
1b4a : 8a txa
|
|
1b4b : 990502 sta abst,y ;clear
|
|
1b4e : 88 dey
|
|
1b4f : 10ef bpl tstai1
|
|
|
|
1b51 : a299 ldx #$99 ;protect x & y
|
|
1b53 : a066 ldy #$66
|
|
set_stat $ff
|
|
> load_flag $ff
|
|
1b55 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
1b57 : 48 > pha ;use stack to load status
|
|
1b58 : 28 > plp
|
|
|
|
1b59 : b224 lda (ind1)
|
|
1b5b : 08 php ;test stores do not alter flags
|
|
1b5c : 49c3 eor #$c3
|
|
1b5e : 28 plp
|
|
1b5f : 9230 sta (indt)
|
|
1b61 : 08 php ;flags after load/store sequence
|
|
1b62 : 49c3 eor #$c3
|
|
1b64 : c9c3 cmp #$c3 ;test result
|
|
trap_ne
|
|
1b66 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
1b68 : 68 pla ;load status
|
|
eor_flag lo~fnz ;mask bits not altered
|
|
1b69 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
|
|
|
|
1b6b : cd1502 cmp fLDx ;test flags
|
|
trap_ne
|
|
1b6e : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
set_stat $ff
|
|
> load_flag $ff
|
|
1b70 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
1b72 : 48 > pha ;use stack to load status
|
|
1b73 : 28 > plp
|
|
|
|
1b74 : b226 lda (ind1+2)
|
|
1b76 : 08 php ;test stores do not alter flags
|
|
1b77 : 49c3 eor #$c3
|
|
1b79 : 28 plp
|
|
1b7a : 9232 sta (indt+2)
|
|
1b7c : 08 php ;flags after load/store sequence
|
|
1b7d : 49c3 eor #$c3
|
|
1b7f : c982 cmp #$82 ;test result
|
|
trap_ne
|
|
1b81 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
1b83 : 68 pla ;load status
|
|
eor_flag lo~fnz ;mask bits not altered
|
|
1b84 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
|
|
|
|
1b86 : cd1602 cmp fLDx+1 ;test flags
|
|
trap_ne
|
|
1b89 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
set_stat $ff
|
|
> load_flag $ff
|
|
1b8b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
1b8d : 48 > pha ;use stack to load status
|
|
1b8e : 28 > plp
|
|
|
|
1b8f : b228 lda (ind1+4)
|
|
1b91 : 08 php ;test stores do not alter flags
|
|
1b92 : 49c3 eor #$c3
|
|
1b94 : 28 plp
|
|
1b95 : 9234 sta (indt+4)
|
|
1b97 : 08 php ;flags after load/store sequence
|
|
1b98 : 49c3 eor #$c3
|
|
1b9a : c941 cmp #$41 ;test result
|
|
trap_ne
|
|
1b9c : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
1b9e : 68 pla ;load status
|
|
eor_flag lo~fnz ;mask bits not altered
|
|
1b9f : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
|
|
|
|
1ba1 : cd1702 cmp fLDx+2 ;test flags
|
|
trap_ne
|
|
1ba4 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
set_stat $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 : 28 > plp
|
|
|
|
1baa : b22a lda (ind1+6)
|
|
1bac : 08 php ;test stores do not alter flags
|
|
1bad : 49c3 eor #$c3
|
|
1baf : 28 plp
|
|
1bb0 : 9236 sta (indt+6)
|
|
1bb2 : 08 php ;flags after load/store sequence
|
|
1bb3 : 49c3 eor #$c3
|
|
1bb5 : c900 cmp #0 ;test result
|
|
trap_ne
|
|
1bb7 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
1bb9 : 68 pla ;load status
|
|
eor_flag lo~fnz ;mask bits not altered
|
|
1bba : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
|
|
|
|
1bbc : cd1802 cmp fLDx+3 ;test flags
|
|
trap_ne
|
|
1bbf : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
1bc1 : e099 cpx #$99
|
|
trap_ne ;x altered during test
|
|
1bc3 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
1bc5 : c066 cpy #$66
|
|
trap_ne ;y altered during test
|
|
1bc7 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
|
|
1bc9 : a003 ldy #3 ;testing store result
|
|
1bcb : a200 ldx #0
|
|
1bcd : b90502 tstai2 lda abst,y
|
|
1bd0 : 49c3 eor #$c3
|
|
1bd2 : d91002 cmp abs1,y
|
|
trap_ne ;store to indirect data
|
|
1bd5 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
1bd7 : 8a txa
|
|
1bd8 : 990502 sta abst,y ;clear
|
|
1bdb : 88 dey
|
|
1bdc : 10ef bpl tstai2
|
|
1bde : ba tsx
|
|
1bdf : e0ff cpx #$ff
|
|
trap_ne ;sp push/pop mismatch
|
|
1be1 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
next_test
|
|
1be3 : ad0202 > lda test_case ;previous test
|
|
1be6 : c90b > cmp #test_num
|
|
> trap_ne ;test is out of sequence
|
|
1be8 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
000c = >test_num = test_num + 1
|
|
1bea : a90c > lda #test_num ;*** next tests' number
|
|
1bec : 8d0202 > sta test_case
|
|
> ;check_ram ;uncomment to find altered RAM after each test
|
|
|
|
|
|
; testing STZ - zp / abs / zp,x / abs,x
|
|
1bef : a07b ldy #123 ;protect y
|
|
1bf1 : a204 ldx #4 ;precharge test area
|
|
1bf3 : a907 lda #7
|
|
1bf5 : 950c tstz1 sta zpt,x
|
|
1bf7 : 0a asl a
|
|
1bf8 : ca dex
|
|
1bf9 : 10fa bpl tstz1
|
|
1bfb : a204 ldx #4
|
|
set_a $55,$ff
|
|
> load_flag $ff
|
|
1bfd : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
1bff : 48 > pha ;use stack to load status
|
|
1c00 : a955 > lda #$55 ;precharge accu
|
|
1c02 : 28 > plp
|
|
|
|
1c03 : 640c stz zpt
|
|
1c05 : 640d stz zpt+1
|
|
1c07 : 640e stz zpt+2
|
|
1c09 : 640f stz zpt+3
|
|
1c0b : 6410 stz zpt+4
|
|
tst_a $55,$ff
|
|
1c0d : 08 > php ;save flags
|
|
1c0e : c955 > cmp #$55 ;test result
|
|
> trap_ne
|
|
1c10 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1c12 : 68 > pla ;load status
|
|
1c13 : 48 > pha
|
|
> cmp_flag $ff
|
|
1c14 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1c16 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1c18 : 28 > plp ;restore status
|
|
|
|
1c19 : b50c tstz2 lda zpt,x ;verify zeros stored
|
|
trap_ne ;non zero after STZ zp
|
|
1c1b : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
1c1d : ca dex
|
|
1c1e : 10f9 bpl tstz2
|
|
1c20 : a204 ldx #4 ;precharge test area
|
|
1c22 : a907 lda #7
|
|
1c24 : 950c tstz3 sta zpt,x
|
|
1c26 : 0a asl a
|
|
1c27 : ca dex
|
|
1c28 : 10fa bpl tstz3
|
|
1c2a : a204 ldx #4
|
|
set_a $aa,0
|
|
> load_flag 0
|
|
1c2c : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
1c2e : 48 > pha ;use stack to load status
|
|
1c2f : a9aa > lda #$aa ;precharge accu
|
|
1c31 : 28 > plp
|
|
|
|
1c32 : 640c stz zpt
|
|
1c34 : 640d stz zpt+1
|
|
1c36 : 640e stz zpt+2
|
|
1c38 : 640f stz zpt+3
|
|
1c3a : 6410 stz zpt+4
|
|
tst_a $aa,0
|
|
1c3c : 08 > php ;save flags
|
|
1c3d : c9aa > cmp #$aa ;test result
|
|
> trap_ne
|
|
1c3f : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1c41 : 68 > pla ;load status
|
|
1c42 : 48 > pha
|
|
> cmp_flag 0
|
|
1c43 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1c45 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1c47 : 28 > plp ;restore status
|
|
|
|
1c48 : b50c tstz4 lda zpt,x ;verify zeros stored
|
|
trap_ne ;non zero after STZ zp
|
|
1c4a : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
1c4c : ca dex
|
|
1c4d : 10f9 bpl tstz4
|
|
|
|
1c4f : a204 ldx #4 ;precharge test area
|
|
1c51 : a907 lda #7
|
|
1c53 : 9d0502 tstz5 sta abst,x
|
|
1c56 : 0a asl a
|
|
1c57 : ca dex
|
|
1c58 : 10f9 bpl tstz5
|
|
1c5a : a204 ldx #4
|
|
set_a $55,$ff
|
|
> load_flag $ff
|
|
1c5c : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
1c5e : 48 > pha ;use stack to load status
|
|
1c5f : a955 > lda #$55 ;precharge accu
|
|
1c61 : 28 > plp
|
|
|
|
1c62 : 9c0502 stz abst
|
|
1c65 : 9c0602 stz abst+1
|
|
1c68 : 9c0702 stz abst+2
|
|
1c6b : 9c0802 stz abst+3
|
|
1c6e : 9c0902 stz abst+4
|
|
tst_a $55,$ff
|
|
1c71 : 08 > php ;save flags
|
|
1c72 : c955 > cmp #$55 ;test result
|
|
> trap_ne
|
|
1c74 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1c76 : 68 > pla ;load status
|
|
1c77 : 48 > pha
|
|
> cmp_flag $ff
|
|
1c78 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1c7a : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1c7c : 28 > plp ;restore status
|
|
|
|
1c7d : bd0502 tstz6 lda abst,x ;verify zeros stored
|
|
trap_ne ;non zero after STZ abs
|
|
1c80 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
1c82 : ca dex
|
|
1c83 : 10f8 bpl tstz6
|
|
1c85 : a204 ldx #4 ;precharge test area
|
|
1c87 : a907 lda #7
|
|
1c89 : 9d0502 tstz7 sta abst,x
|
|
1c8c : 0a asl a
|
|
1c8d : ca dex
|
|
1c8e : 10f9 bpl tstz7
|
|
1c90 : a204 ldx #4
|
|
set_a $aa,0
|
|
> load_flag 0
|
|
1c92 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
1c94 : 48 > pha ;use stack to load status
|
|
1c95 : a9aa > lda #$aa ;precharge accu
|
|
1c97 : 28 > plp
|
|
|
|
1c98 : 9c0502 stz abst
|
|
1c9b : 9c0602 stz abst+1
|
|
1c9e : 9c0702 stz abst+2
|
|
1ca1 : 9c0802 stz abst+3
|
|
1ca4 : 9c0902 stz abst+4
|
|
tst_a $aa,0
|
|
1ca7 : 08 > php ;save flags
|
|
1ca8 : c9aa > cmp #$aa ;test result
|
|
> trap_ne
|
|
1caa : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1cac : 68 > pla ;load status
|
|
1cad : 48 > pha
|
|
> cmp_flag 0
|
|
1cae : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1cb0 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1cb2 : 28 > plp ;restore status
|
|
|
|
1cb3 : bd0502 tstz8 lda abst,x ;verify zeros stored
|
|
trap_ne ;non zero after STZ abs
|
|
1cb6 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
1cb8 : ca dex
|
|
1cb9 : 10f8 bpl tstz8
|
|
|
|
1cbb : a204 ldx #4 ;precharge test area
|
|
1cbd : a907 lda #7
|
|
1cbf : 950c tstz11 sta zpt,x
|
|
1cc1 : 0a asl a
|
|
1cc2 : ca dex
|
|
1cc3 : 10fa bpl tstz11
|
|
1cc5 : a204 ldx #4
|
|
1cc7 : tstz15
|
|
set_a $55,$ff
|
|
> load_flag $ff
|
|
1cc7 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
1cc9 : 48 > pha ;use stack to load status
|
|
1cca : a955 > lda #$55 ;precharge accu
|
|
1ccc : 28 > plp
|
|
|
|
1ccd : 740c stz zpt,x
|
|
tst_a $55,$ff
|
|
1ccf : 08 > php ;save flags
|
|
1cd0 : c955 > cmp #$55 ;test result
|
|
> trap_ne
|
|
1cd2 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1cd4 : 68 > pla ;load status
|
|
1cd5 : 48 > pha
|
|
> cmp_flag $ff
|
|
1cd6 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1cd8 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1cda : 28 > plp ;restore status
|
|
|
|
1cdb : ca dex
|
|
1cdc : 10e9 bpl tstz15
|
|
1cde : a204 ldx #4
|
|
1ce0 : b50c tstz12 lda zpt,x ;verify zeros stored
|
|
trap_ne ;non zero after STZ zp
|
|
1ce2 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
1ce4 : ca dex
|
|
1ce5 : 10f9 bpl tstz12
|
|
1ce7 : a204 ldx #4 ;precharge test area
|
|
1ce9 : a907 lda #7
|
|
1ceb : 950c tstz13 sta zpt,x
|
|
1ced : 0a asl a
|
|
1cee : ca dex
|
|
1cef : 10fa bpl tstz13
|
|
1cf1 : a204 ldx #4
|
|
1cf3 : tstz16
|
|
set_a $aa,0
|
|
> load_flag 0
|
|
1cf3 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
1cf5 : 48 > pha ;use stack to load status
|
|
1cf6 : a9aa > lda #$aa ;precharge accu
|
|
1cf8 : 28 > plp
|
|
|
|
1cf9 : 740c stz zpt,x
|
|
tst_a $aa,0
|
|
1cfb : 08 > php ;save flags
|
|
1cfc : c9aa > cmp #$aa ;test result
|
|
> trap_ne
|
|
1cfe : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1d00 : 68 > pla ;load status
|
|
1d01 : 48 > pha
|
|
> cmp_flag 0
|
|
1d02 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1d04 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1d06 : 28 > plp ;restore status
|
|
|
|
1d07 : ca dex
|
|
1d08 : 10e9 bpl tstz16
|
|
1d0a : a204 ldx #4
|
|
1d0c : b50c tstz14 lda zpt,x ;verify zeros stored
|
|
trap_ne ;non zero after STZ zp
|
|
1d0e : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
1d10 : ca dex
|
|
1d11 : 10f9 bpl tstz14
|
|
|
|
1d13 : a204 ldx #4 ;precharge test area
|
|
1d15 : a907 lda #7
|
|
1d17 : 9d0502 tstz21 sta abst,x
|
|
1d1a : 0a asl a
|
|
1d1b : ca dex
|
|
1d1c : 10f9 bpl tstz21
|
|
1d1e : a204 ldx #4
|
|
1d20 : tstz25
|
|
set_a $55,$ff
|
|
> load_flag $ff
|
|
1d20 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
1d22 : 48 > pha ;use stack to load status
|
|
1d23 : a955 > lda #$55 ;precharge accu
|
|
1d25 : 28 > plp
|
|
|
|
1d26 : 9e0502 stz abst,x
|
|
tst_a $55,$ff
|
|
1d29 : 08 > php ;save flags
|
|
1d2a : c955 > cmp #$55 ;test result
|
|
> trap_ne
|
|
1d2c : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1d2e : 68 > pla ;load status
|
|
1d2f : 48 > pha
|
|
> cmp_flag $ff
|
|
1d30 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1d32 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1d34 : 28 > plp ;restore status
|
|
|
|
1d35 : ca dex
|
|
1d36 : 10e8 bpl tstz25
|
|
1d38 : a204 ldx #4
|
|
1d3a : bd0502 tstz22 lda abst,x ;verify zeros stored
|
|
trap_ne ;non zero after STZ zp
|
|
1d3d : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
1d3f : ca dex
|
|
1d40 : 10f8 bpl tstz22
|
|
1d42 : a204 ldx #4 ;precharge test area
|
|
1d44 : a907 lda #7
|
|
1d46 : 9d0502 tstz23 sta abst,x
|
|
1d49 : 0a asl a
|
|
1d4a : ca dex
|
|
1d4b : 10f9 bpl tstz23
|
|
1d4d : a204 ldx #4
|
|
1d4f : tstz26
|
|
set_a $aa,0
|
|
> load_flag 0
|
|
1d4f : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
1d51 : 48 > pha ;use stack to load status
|
|
1d52 : a9aa > lda #$aa ;precharge accu
|
|
1d54 : 28 > plp
|
|
|
|
1d55 : 9e0502 stz abst,x
|
|
tst_a $aa,0
|
|
1d58 : 08 > php ;save flags
|
|
1d59 : c9aa > cmp #$aa ;test result
|
|
> trap_ne
|
|
1d5b : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1d5d : 68 > pla ;load status
|
|
1d5e : 48 > pha
|
|
> cmp_flag 0
|
|
1d5f : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1d61 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1d63 : 28 > plp ;restore status
|
|
|
|
1d64 : ca dex
|
|
1d65 : 10e8 bpl tstz26
|
|
1d67 : a204 ldx #4
|
|
1d69 : bd0502 tstz24 lda abst,x ;verify zeros stored
|
|
trap_ne ;non zero after STZ zp
|
|
1d6c : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
1d6e : ca dex
|
|
1d6f : 10f8 bpl tstz24
|
|
|
|
1d71 : c07b cpy #123
|
|
trap_ne ;y altered during test
|
|
1d73 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
1d75 : ba tsx
|
|
1d76 : e0ff cpx #$ff
|
|
trap_ne ;sp push/pop mismatch
|
|
1d78 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
next_test
|
|
1d7a : ad0202 > lda test_case ;previous test
|
|
1d7d : c90c > cmp #test_num
|
|
> trap_ne ;test is out of sequence
|
|
1d7f : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
000d = >test_num = test_num + 1
|
|
1d81 : a90d > lda #test_num ;*** next tests' number
|
|
1d83 : 8d0202 > sta test_case
|
|
> ;check_ram ;uncomment to find altered RAM after each test
|
|
|
|
|
|
; testing BIT - zp,x / abs,x / #
|
|
1d86 : a042 ldy #$42
|
|
1d88 : a203 ldx #3
|
|
set_a $ff,0
|
|
> load_flag 0
|
|
1d8a : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
1d8c : 48 > pha ;use stack to load status
|
|
1d8d : a9ff > lda #$ff ;precharge accu
|
|
1d8f : 28 > plp
|
|
|
|
1d90 : 3413 bit zp1,x ;00 - should set Z / clear NV
|
|
tst_a $ff,fz
|
|
1d92 : 08 > php ;save flags
|
|
1d93 : c9ff > cmp #$ff ;test result
|
|
> trap_ne
|
|
1d95 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1d97 : 68 > pla ;load status
|
|
1d98 : 48 > pha
|
|
> cmp_flag fz
|
|
1d99 : c932 > cmp #(fz |fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1d9b : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1d9d : 28 > plp ;restore status
|
|
|
|
1d9e : ca dex
|
|
set_a 1,0
|
|
> load_flag 0
|
|
1d9f : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
1da1 : 48 > pha ;use stack to load status
|
|
1da2 : a901 > lda #1 ;precharge accu
|
|
1da4 : 28 > plp
|
|
|
|
1da5 : 3413 bit zp1,x ;41 - should set V (M6) / clear NZ
|
|
tst_a 1,fv
|
|
1da7 : 08 > php ;save flags
|
|
1da8 : c901 > cmp #1 ;test result
|
|
> trap_ne
|
|
1daa : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1dac : 68 > pla ;load status
|
|
1dad : 48 > pha
|
|
> cmp_flag fv
|
|
1dae : c970 > cmp #(fv|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1db0 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1db2 : 28 > plp ;restore status
|
|
|
|
1db3 : ca dex
|
|
set_a 1,0
|
|
> load_flag 0
|
|
1db4 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
1db6 : 48 > pha ;use stack to load status
|
|
1db7 : a901 > lda #1 ;precharge accu
|
|
1db9 : 28 > plp
|
|
|
|
1dba : 3413 bit zp1,x ;82 - should set N (M7) & Z / clear V
|
|
tst_a 1,fnz
|
|
1dbc : 08 > php ;save flags
|
|
1dbd : c901 > cmp #1 ;test result
|
|
> trap_ne
|
|
1dbf : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1dc1 : 68 > pla ;load status
|
|
1dc2 : 48 > pha
|
|
> cmp_flag fnz
|
|
1dc3 : c9b2 > cmp #(fnz|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1dc5 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1dc7 : 28 > plp ;restore status
|
|
|
|
1dc8 : ca dex
|
|
set_a 1,0
|
|
> load_flag 0
|
|
1dc9 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
1dcb : 48 > pha ;use stack to load status
|
|
1dcc : a901 > lda #1 ;precharge accu
|
|
1dce : 28 > plp
|
|
|
|
1dcf : 3413 bit zp1,x ;c3 - should set N (M7) & V (M6) / clear Z
|
|
tst_a 1,fnv
|
|
1dd1 : 08 > php ;save flags
|
|
1dd2 : c901 > cmp #1 ;test result
|
|
> trap_ne
|
|
1dd4 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1dd6 : 68 > pla ;load status
|
|
1dd7 : 48 > pha
|
|
> cmp_flag fnv
|
|
1dd8 : c9f0 > cmp #(fnv|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1dda : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1ddc : 28 > plp ;restore status
|
|
|
|
|
|
set_a 1,$ff
|
|
> load_flag $ff
|
|
1ddd : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
1ddf : 48 > pha ;use stack to load status
|
|
1de0 : a901 > lda #1 ;precharge accu
|
|
1de2 : 28 > plp
|
|
|
|
1de3 : 3413 bit zp1,x ;c3 - should set N (M7) & V (M6) / clear Z
|
|
tst_a 1,~fz
|
|
1de5 : 08 > php ;save flags
|
|
1de6 : c901 > cmp #1 ;test result
|
|
> trap_ne
|
|
1de8 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1dea : 68 > pla ;load status
|
|
1deb : 48 > pha
|
|
> cmp_flag ~fz
|
|
1dec : c9fd > cmp #(~fz|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1dee : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1df0 : 28 > plp ;restore status
|
|
|
|
1df1 : e8 inx
|
|
set_a 1,$ff
|
|
> load_flag $ff
|
|
1df2 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
1df4 : 48 > pha ;use stack to load status
|
|
1df5 : a901 > lda #1 ;precharge accu
|
|
1df7 : 28 > plp
|
|
|
|
1df8 : 3413 bit zp1,x ;82 - should set N (M7) & Z / clear V
|
|
tst_a 1,~fv
|
|
1dfa : 08 > php ;save flags
|
|
1dfb : c901 > cmp #1 ;test result
|
|
> trap_ne
|
|
1dfd : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1dff : 68 > pla ;load status
|
|
1e00 : 48 > pha
|
|
> cmp_flag ~fv
|
|
1e01 : c9bf > cmp #(~fv|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1e03 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1e05 : 28 > plp ;restore status
|
|
|
|
1e06 : e8 inx
|
|
set_a 1,$ff
|
|
> load_flag $ff
|
|
1e07 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
1e09 : 48 > pha ;use stack to load status
|
|
1e0a : a901 > lda #1 ;precharge accu
|
|
1e0c : 28 > plp
|
|
|
|
1e0d : 3413 bit zp1,x ;41 - should set V (M6) / clear NZ
|
|
tst_a 1,~fnz
|
|
1e0f : 08 > php ;save flags
|
|
1e10 : c901 > cmp #1 ;test result
|
|
> trap_ne
|
|
1e12 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1e14 : 68 > pla ;load status
|
|
1e15 : 48 > pha
|
|
> cmp_flag ~fnz
|
|
1e16 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1e18 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1e1a : 28 > plp ;restore status
|
|
|
|
1e1b : e8 inx
|
|
set_a $ff,$ff
|
|
> load_flag $ff
|
|
1e1c : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
1e1e : 48 > pha ;use stack to load status
|
|
1e1f : a9ff > lda #$ff ;precharge accu
|
|
1e21 : 28 > plp
|
|
|
|
1e22 : 3413 bit zp1,x ;00 - should set Z / clear NV
|
|
tst_a $ff,~fnv
|
|
1e24 : 08 > php ;save flags
|
|
1e25 : c9ff > cmp #$ff ;test result
|
|
> trap_ne
|
|
1e27 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1e29 : 68 > pla ;load status
|
|
1e2a : 48 > pha
|
|
> cmp_flag ~fnv
|
|
1e2b : c93f > cmp #(~fnv |fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1e2d : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1e2f : 28 > plp ;restore status
|
|
|
|
|
|
set_a $ff,0
|
|
> load_flag 0
|
|
1e30 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
1e32 : 48 > pha ;use stack to load status
|
|
1e33 : a9ff > lda #$ff ;precharge accu
|
|
1e35 : 28 > plp
|
|
|
|
1e36 : 3c1002 bit abs1,x ;00 - should set Z / clear NV
|
|
tst_a $ff,fz
|
|
1e39 : 08 > php ;save flags
|
|
1e3a : c9ff > cmp #$ff ;test result
|
|
> trap_ne
|
|
1e3c : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1e3e : 68 > pla ;load status
|
|
1e3f : 48 > pha
|
|
> cmp_flag fz
|
|
1e40 : c932 > cmp #(fz |fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1e42 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1e44 : 28 > plp ;restore status
|
|
|
|
1e45 : ca dex
|
|
set_a 1,0
|
|
> load_flag 0
|
|
1e46 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
1e48 : 48 > pha ;use stack to load status
|
|
1e49 : a901 > lda #1 ;precharge accu
|
|
1e4b : 28 > plp
|
|
|
|
1e4c : 3c1002 bit abs1,x ;41 - should set V (M6) / clear NZ
|
|
tst_a 1,fv
|
|
1e4f : 08 > php ;save flags
|
|
1e50 : c901 > cmp #1 ;test result
|
|
> trap_ne
|
|
1e52 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1e54 : 68 > pla ;load status
|
|
1e55 : 48 > pha
|
|
> cmp_flag fv
|
|
1e56 : c970 > cmp #(fv|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1e58 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1e5a : 28 > plp ;restore status
|
|
|
|
1e5b : ca dex
|
|
set_a 1,0
|
|
> load_flag 0
|
|
1e5c : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
1e5e : 48 > pha ;use stack to load status
|
|
1e5f : a901 > lda #1 ;precharge accu
|
|
1e61 : 28 > plp
|
|
|
|
1e62 : 3c1002 bit abs1,x ;82 - should set N (M7) & Z / clear V
|
|
tst_a 1,fnz
|
|
1e65 : 08 > php ;save flags
|
|
1e66 : c901 > cmp #1 ;test result
|
|
> trap_ne
|
|
1e68 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1e6a : 68 > pla ;load status
|
|
1e6b : 48 > pha
|
|
> cmp_flag fnz
|
|
1e6c : c9b2 > cmp #(fnz|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1e6e : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1e70 : 28 > plp ;restore status
|
|
|
|
1e71 : ca dex
|
|
set_a 1,0
|
|
> load_flag 0
|
|
1e72 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
1e74 : 48 > pha ;use stack to load status
|
|
1e75 : a901 > lda #1 ;precharge accu
|
|
1e77 : 28 > plp
|
|
|
|
1e78 : 3c1002 bit abs1,x ;c3 - should set N (M7) & V (M6) / clear Z
|
|
tst_a 1,fnv
|
|
1e7b : 08 > php ;save flags
|
|
1e7c : c901 > cmp #1 ;test result
|
|
> trap_ne
|
|
1e7e : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1e80 : 68 > pla ;load status
|
|
1e81 : 48 > pha
|
|
> cmp_flag fnv
|
|
1e82 : c9f0 > cmp #(fnv|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1e84 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1e86 : 28 > plp ;restore status
|
|
|
|
|
|
set_a 1,$ff
|
|
> load_flag $ff
|
|
1e87 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
1e89 : 48 > pha ;use stack to load status
|
|
1e8a : a901 > lda #1 ;precharge accu
|
|
1e8c : 28 > plp
|
|
|
|
1e8d : 3c1002 bit abs1,x ;c3 - should set N (M7) & V (M6) / clear Z
|
|
tst_a 1,~fz
|
|
1e90 : 08 > php ;save flags
|
|
1e91 : c901 > cmp #1 ;test result
|
|
> trap_ne
|
|
1e93 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1e95 : 68 > pla ;load status
|
|
1e96 : 48 > pha
|
|
> cmp_flag ~fz
|
|
1e97 : c9fd > cmp #(~fz|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1e99 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1e9b : 28 > plp ;restore status
|
|
|
|
1e9c : e8 inx
|
|
set_a 1,$ff
|
|
> load_flag $ff
|
|
1e9d : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
1e9f : 48 > pha ;use stack to load status
|
|
1ea0 : a901 > lda #1 ;precharge accu
|
|
1ea2 : 28 > plp
|
|
|
|
1ea3 : 3c1002 bit abs1,x ;82 - should set N (M7) & Z / clear V
|
|
tst_a 1,~fv
|
|
1ea6 : 08 > php ;save flags
|
|
1ea7 : c901 > cmp #1 ;test result
|
|
> trap_ne
|
|
1ea9 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1eab : 68 > pla ;load status
|
|
1eac : 48 > pha
|
|
> cmp_flag ~fv
|
|
1ead : c9bf > cmp #(~fv|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1eaf : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1eb1 : 28 > plp ;restore status
|
|
|
|
1eb2 : e8 inx
|
|
set_a 1,$ff
|
|
> load_flag $ff
|
|
1eb3 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
1eb5 : 48 > pha ;use stack to load status
|
|
1eb6 : a901 > lda #1 ;precharge accu
|
|
1eb8 : 28 > plp
|
|
|
|
1eb9 : 3c1002 bit abs1,x ;41 - should set V (M6) / clear NZ
|
|
tst_a 1,~fnz
|
|
1ebc : 08 > php ;save flags
|
|
1ebd : c901 > cmp #1 ;test result
|
|
> trap_ne
|
|
1ebf : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1ec1 : 68 > pla ;load status
|
|
1ec2 : 48 > pha
|
|
> cmp_flag ~fnz
|
|
1ec3 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1ec5 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1ec7 : 28 > plp ;restore status
|
|
|
|
1ec8 : e8 inx
|
|
set_a $ff,$ff
|
|
> load_flag $ff
|
|
1ec9 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
1ecb : 48 > pha ;use stack to load status
|
|
1ecc : a9ff > lda #$ff ;precharge accu
|
|
1ece : 28 > plp
|
|
|
|
1ecf : 3c1002 bit abs1,x ;00 - should set Z / clear NV
|
|
tst_a $ff,~fnv
|
|
1ed2 : 08 > php ;save flags
|
|
1ed3 : c9ff > cmp #$ff ;test result
|
|
> trap_ne
|
|
1ed5 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1ed7 : 68 > pla ;load status
|
|
1ed8 : 48 > pha
|
|
> cmp_flag ~fnv
|
|
1ed9 : c93f > cmp #(~fnv |fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1edb : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1edd : 28 > plp ;restore status
|
|
|
|
|
|
set_a $ff,0
|
|
> load_flag 0
|
|
1ede : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
1ee0 : 48 > pha ;use stack to load status
|
|
1ee1 : a9ff > lda #$ff ;precharge accu
|
|
1ee3 : 28 > plp
|
|
|
|
1ee4 : 8900 bit #$00 ;00 - should set Z
|
|
tst_a $ff,fz
|
|
1ee6 : 08 > php ;save flags
|
|
1ee7 : c9ff > cmp #$ff ;test result
|
|
> trap_ne
|
|
1ee9 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1eeb : 68 > pla ;load status
|
|
1eec : 48 > pha
|
|
> cmp_flag fz
|
|
1eed : c932 > cmp #(fz |fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1eef : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1ef1 : 28 > plp ;restore status
|
|
|
|
1ef2 : ca dex
|
|
set_a 1,0
|
|
> load_flag 0
|
|
1ef3 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
1ef5 : 48 > pha ;use stack to load status
|
|
1ef6 : a901 > lda #1 ;precharge accu
|
|
1ef8 : 28 > plp
|
|
|
|
1ef9 : 8941 bit #$41 ;41 - should clear Z
|
|
tst_a 1,0
|
|
1efb : 08 > php ;save flags
|
|
1efc : c901 > cmp #1 ;test result
|
|
> trap_ne
|
|
1efe : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1f00 : 68 > pla ;load status
|
|
1f01 : 48 > pha
|
|
> cmp_flag 0
|
|
1f02 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1f04 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1f06 : 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 #
|
|
1f07 : ca dex
|
|
set_a 1,0
|
|
> load_flag 0
|
|
1f08 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
1f0a : 48 > pha ;use stack to load status
|
|
1f0b : a901 > lda #1 ;precharge accu
|
|
1f0d : 28 > plp
|
|
|
|
1f0e : 8982 bit #$82 ;82 - should set Z
|
|
tst_a 1,fz
|
|
1f10 : 08 > php ;save flags
|
|
1f11 : c901 > cmp #1 ;test result
|
|
> trap_ne
|
|
1f13 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1f15 : 68 > pla ;load status
|
|
1f16 : 48 > pha
|
|
> cmp_flag fz
|
|
1f17 : c932 > cmp #(fz|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1f19 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1f1b : 28 > plp ;restore status
|
|
|
|
1f1c : ca dex
|
|
set_a 1,0
|
|
> load_flag 0
|
|
1f1d : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
1f1f : 48 > pha ;use stack to load status
|
|
1f20 : a901 > lda #1 ;precharge accu
|
|
1f22 : 28 > plp
|
|
|
|
1f23 : 89c3 bit #$c3 ;c3 - should clear Z
|
|
tst_a 1,0
|
|
1f25 : 08 > php ;save flags
|
|
1f26 : c901 > cmp #1 ;test result
|
|
> trap_ne
|
|
1f28 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1f2a : 68 > pla ;load status
|
|
1f2b : 48 > pha
|
|
> cmp_flag 0
|
|
1f2c : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1f2e : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1f30 : 28 > plp ;restore status
|
|
|
|
|
|
set_a 1,$ff
|
|
> load_flag $ff
|
|
1f31 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
1f33 : 48 > pha ;use stack to load status
|
|
1f34 : a901 > lda #1 ;precharge accu
|
|
1f36 : 28 > plp
|
|
|
|
1f37 : 89c3 bit #$c3 ;c3 - clear Z
|
|
tst_a 1,~fz
|
|
1f39 : 08 > php ;save flags
|
|
1f3a : c901 > cmp #1 ;test result
|
|
> trap_ne
|
|
1f3c : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1f3e : 68 > pla ;load status
|
|
1f3f : 48 > pha
|
|
> cmp_flag ~fz
|
|
1f40 : c9fd > cmp #(~fz|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1f42 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1f44 : 28 > plp ;restore status
|
|
|
|
1f45 : e8 inx
|
|
set_a 1,$ff
|
|
> load_flag $ff
|
|
1f46 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
1f48 : 48 > pha ;use stack to load status
|
|
1f49 : a901 > lda #1 ;precharge accu
|
|
1f4b : 28 > plp
|
|
|
|
1f4c : 8982 bit #$82 ;82 - should set Z
|
|
tst_a 1,$ff
|
|
1f4e : 08 > php ;save flags
|
|
1f4f : c901 > cmp #1 ;test result
|
|
> trap_ne
|
|
1f51 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1f53 : 68 > pla ;load status
|
|
1f54 : 48 > pha
|
|
> cmp_flag $ff
|
|
1f55 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1f57 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1f59 : 28 > plp ;restore status
|
|
|
|
1f5a : e8 inx
|
|
set_a 1,$ff
|
|
> load_flag $ff
|
|
1f5b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
1f5d : 48 > pha ;use stack to load status
|
|
1f5e : a901 > lda #1 ;precharge accu
|
|
1f60 : 28 > plp
|
|
|
|
1f61 : 8941 bit #$41 ;41 - should clear Z
|
|
tst_a 1,~fz
|
|
1f63 : 08 > php ;save flags
|
|
1f64 : c901 > cmp #1 ;test result
|
|
> trap_ne
|
|
1f66 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1f68 : 68 > pla ;load status
|
|
1f69 : 48 > pha
|
|
> cmp_flag ~fz
|
|
1f6a : c9fd > cmp #(~fz|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1f6c : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1f6e : 28 > plp ;restore status
|
|
|
|
1f6f : e8 inx
|
|
set_a $ff,$ff
|
|
> load_flag $ff
|
|
1f70 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
1f72 : 48 > pha ;use stack to load status
|
|
1f73 : a9ff > lda #$ff ;precharge accu
|
|
1f75 : 28 > plp
|
|
|
|
1f76 : 8900 bit #$00 ;00 - should set Z
|
|
tst_a $ff,$ff
|
|
1f78 : 08 > php ;save flags
|
|
1f79 : c9ff > cmp #$ff ;test result
|
|
> trap_ne
|
|
1f7b : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1f7d : 68 > pla ;load status
|
|
1f7e : 48 > pha
|
|
> cmp_flag $ff
|
|
1f7f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
1f81 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1f83 : 28 > plp ;restore status
|
|
|
|
|
|
1f84 : e003 cpx #3
|
|
trap_ne ;x altered during test
|
|
1f86 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
1f88 : c042 cpy #$42
|
|
trap_ne ;y altered during test
|
|
1f8a : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
1f8c : ba tsx
|
|
1f8d : e0ff cpx #$ff
|
|
trap_ne ;sp push/pop mismatch
|
|
1f8f : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
next_test
|
|
1f91 : ad0202 > lda test_case ;previous test
|
|
1f94 : c90d > cmp #test_num
|
|
> trap_ne ;test is out of sequence
|
|
1f96 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
000e = >test_num = test_num + 1
|
|
1f98 : a90e > lda #test_num ;*** next tests' number
|
|
1f9a : 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
|
|
|
|
1f9d : a2c0 ldx #$c0
|
|
1f9f : a000 ldy #0 ;op1 - memory save
|
|
; zpt ;op1 - memory modifiable
|
|
1fa1 : 640d stz zpt+1 ;op2 - accu
|
|
; zpt+2 ;and flags
|
|
; zpt+3 ;memory after reset
|
|
; zpt+4 ;memory after set
|
|
|
|
1fa3 : 98 tbt1 tya
|
|
1fa4 : 250d and zpt+1 ;set Z by anding the 2 operands
|
|
1fa6 : 08 php
|
|
1fa7 : 68 pla
|
|
1fa8 : 2902 and #fz ;mask Z
|
|
1faa : 850e sta zpt+2
|
|
1fac : 98 tya ;reset op1 bits by op2
|
|
1fad : 49ff eor #$ff
|
|
1faf : 050d ora zpt+1
|
|
1fb1 : 49ff eor #$ff
|
|
1fb3 : 850f sta zpt+3
|
|
1fb5 : 98 tya ;set op1 bits by op2
|
|
1fb6 : 050d ora zpt+1
|
|
1fb8 : 8510 sta zpt+4
|
|
|
|
trbt zpt,$ff
|
|
1fba : 840c > sty zpt
|
|
> load_flag $ff
|
|
1fbc : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
1fbe : 48 > pha
|
|
1fbf : a50d > lda zpt+1
|
|
1fc1 : 28 > plp
|
|
1fc2 : 140c > trb zpt
|
|
1fc4 : 08 > php
|
|
1fc5 : c50d > cmp zpt+1
|
|
> trap_ne ;accu was changed
|
|
1fc7 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1fc9 : 68 > pla
|
|
1fca : 48 > pha
|
|
1fcb : 0902 > ora #fz ;mask Z
|
|
> cmp_flag $ff|fz
|
|
1fcd : c9ff > cmp #($ff|fz|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne ;flags changed except Z
|
|
1fcf : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1fd1 : 68 > pla
|
|
1fd2 : 2902 > and #fz
|
|
1fd4 : c50e > cmp zpt+2
|
|
> trap_ne ;Z flag invalid
|
|
1fd6 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1fd8 : a50f > lda zpt+3
|
|
1fda : c50c > cmp zpt
|
|
> trap_ne ;altered bits in memory wrong
|
|
1fdc : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
trbt abst,$ff
|
|
1fde : 8c0502 > sty abst
|
|
> load_flag $ff
|
|
1fe1 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
1fe3 : 48 > pha
|
|
1fe4 : a50d > lda zpt+1
|
|
1fe6 : 28 > plp
|
|
1fe7 : 1c0502 > trb abst
|
|
1fea : 08 > php
|
|
1feb : c50d > cmp zpt+1
|
|
> trap_ne ;accu was changed
|
|
1fed : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1fef : 68 > pla
|
|
1ff0 : 48 > pha
|
|
1ff1 : 0902 > ora #fz ;mask Z
|
|
> cmp_flag $ff|fz
|
|
1ff3 : c9ff > cmp #($ff|fz|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne ;flags changed except Z
|
|
1ff5 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1ff7 : 68 > pla
|
|
1ff8 : 2902 > and #fz
|
|
1ffa : c50e > cmp zpt+2
|
|
> trap_ne ;Z flag invalid
|
|
1ffc : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
1ffe : a50f > lda zpt+3
|
|
2000 : c50c > cmp zpt
|
|
> trap_ne ;altered bits in memory wrong
|
|
2002 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
trbt zpt,0
|
|
2004 : 840c > sty zpt
|
|
> load_flag 0
|
|
2006 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
2008 : 48 > pha
|
|
2009 : a50d > lda zpt+1
|
|
200b : 28 > plp
|
|
200c : 140c > trb zpt
|
|
200e : 08 > php
|
|
200f : c50d > cmp zpt+1
|
|
> trap_ne ;accu was changed
|
|
2011 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
2013 : 68 > pla
|
|
2014 : 48 > pha
|
|
2015 : 0902 > ora #fz ;mask Z
|
|
> cmp_flag 0|fz
|
|
2017 : c932 > cmp #(0|fz|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne ;flags changed except Z
|
|
2019 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
201b : 68 > pla
|
|
201c : 2902 > and #fz
|
|
201e : c50e > cmp zpt+2
|
|
> trap_ne ;Z flag invalid
|
|
2020 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
2022 : a50f > lda zpt+3
|
|
2024 : c50c > cmp zpt
|
|
> trap_ne ;altered bits in memory wrong
|
|
2026 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
trbt abst,0
|
|
2028 : 8c0502 > sty abst
|
|
> load_flag 0
|
|
202b : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
202d : 48 > pha
|
|
202e : a50d > lda zpt+1
|
|
2030 : 28 > plp
|
|
2031 : 1c0502 > trb abst
|
|
2034 : 08 > php
|
|
2035 : c50d > cmp zpt+1
|
|
> trap_ne ;accu was changed
|
|
2037 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
2039 : 68 > pla
|
|
203a : 48 > pha
|
|
203b : 0902 > ora #fz ;mask Z
|
|
> cmp_flag 0|fz
|
|
203d : c932 > cmp #(0|fz|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne ;flags changed except Z
|
|
203f : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
2041 : 68 > pla
|
|
2042 : 2902 > and #fz
|
|
2044 : c50e > cmp zpt+2
|
|
> trap_ne ;Z flag invalid
|
|
2046 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
2048 : a50f > lda zpt+3
|
|
204a : c50c > cmp zpt
|
|
> trap_ne ;altered bits in memory wrong
|
|
204c : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
tsbt zpt,$ff
|
|
204e : 840c > sty zpt
|
|
> load_flag $ff
|
|
2050 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
2052 : 48 > pha
|
|
2053 : a50d > lda zpt+1
|
|
2055 : 28 > plp
|
|
2056 : 040c > tsb zpt
|
|
2058 : 08 > php
|
|
2059 : c50d > cmp zpt+1
|
|
> trap_ne ;accu was changed
|
|
205b : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
205d : 68 > pla
|
|
205e : 48 > pha
|
|
205f : 0902 > ora #fz ;mask Z
|
|
> cmp_flag $ff|fz
|
|
2061 : c9ff > cmp #($ff|fz|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne ;flags changed except Z
|
|
2063 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
2065 : 68 > pla
|
|
2066 : 2902 > and #fz
|
|
2068 : c50e > cmp zpt+2
|
|
> trap_ne ;Z flag invalid
|
|
206a : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
206c : a510 > lda zpt+4
|
|
206e : c50c > cmp zpt
|
|
> trap_ne ;altered bits in memory wrong
|
|
2070 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
tsbt abst,$ff
|
|
2072 : 8c0502 > sty abst
|
|
> load_flag $ff
|
|
2075 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
2077 : 48 > pha
|
|
2078 : a50d > lda zpt+1
|
|
207a : 28 > plp
|
|
207b : 0c0502 > tsb abst
|
|
207e : 08 > php
|
|
207f : c50d > cmp zpt+1
|
|
> trap_ne ;accu was changed
|
|
2081 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
2083 : 68 > pla
|
|
2084 : 48 > pha
|
|
2085 : 0902 > ora #fz ;mask Z
|
|
> cmp_flag $ff|fz
|
|
2087 : c9ff > cmp #($ff|fz|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne ;flags changed except Z
|
|
2089 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
208b : 68 > pla
|
|
208c : 2902 > and #fz
|
|
208e : c50e > cmp zpt+2
|
|
> trap_ne ;Z flag invalid
|
|
2090 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
2092 : a510 > lda zpt+4
|
|
2094 : c50c > cmp zpt
|
|
> trap_ne ;altered bits in memory wrong
|
|
2096 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
tsbt zpt,0
|
|
2098 : 840c > sty zpt
|
|
> load_flag 0
|
|
209a : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
209c : 48 > pha
|
|
209d : a50d > lda zpt+1
|
|
209f : 28 > plp
|
|
20a0 : 040c > tsb zpt
|
|
20a2 : 08 > php
|
|
20a3 : c50d > cmp zpt+1
|
|
> trap_ne ;accu was changed
|
|
20a5 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
20a7 : 68 > pla
|
|
20a8 : 48 > pha
|
|
20a9 : 0902 > ora #fz ;mask Z
|
|
> cmp_flag 0|fz
|
|
20ab : c932 > cmp #(0|fz|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne ;flags changed except Z
|
|
20ad : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
20af : 68 > pla
|
|
20b0 : 2902 > and #fz
|
|
20b2 : c50e > cmp zpt+2
|
|
> trap_ne ;Z flag invalid
|
|
20b4 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
20b6 : a510 > lda zpt+4
|
|
20b8 : c50c > cmp zpt
|
|
> trap_ne ;altered bits in memory wrong
|
|
20ba : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
tsbt abst,0
|
|
20bc : 8c0502 > sty abst
|
|
> load_flag 0
|
|
20bf : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
20c1 : 48 > pha
|
|
20c2 : a50d > lda zpt+1
|
|
20c4 : 28 > plp
|
|
20c5 : 0c0502 > tsb abst
|
|
20c8 : 08 > php
|
|
20c9 : c50d > cmp zpt+1
|
|
> trap_ne ;accu was changed
|
|
20cb : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
20cd : 68 > pla
|
|
20ce : 48 > pha
|
|
20cf : 0902 > ora #fz ;mask Z
|
|
> cmp_flag 0|fz
|
|
20d1 : c932 > cmp #(0|fz|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne ;flags changed except Z
|
|
20d3 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
20d5 : 68 > pla
|
|
20d6 : 2902 > and #fz
|
|
20d8 : c50e > cmp zpt+2
|
|
> trap_ne ;Z flag invalid
|
|
20da : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
20dc : a510 > lda zpt+4
|
|
20de : c50c > cmp zpt
|
|
> trap_ne ;altered bits in memory wrong
|
|
20e0 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
|
|
20e2 : c8 iny ;iterate op1
|
|
20e3 : d004 bne tbt3
|
|
20e5 : e60d inc zpt+1 ;iterate op2
|
|
20e7 : f003 beq tbt2
|
|
20e9 : 4ca31f tbt3 jmp tbt1
|
|
20ec : tbt2
|
|
20ec : e0c0 cpx #$c0
|
|
trap_ne ;x altered during test
|
|
20ee : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
20f0 : ba tsx
|
|
20f1 : e0ff cpx #$ff
|
|
trap_ne ;sp push/pop mismatch
|
|
20f3 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
next_test
|
|
20f5 : ad0202 > lda test_case ;previous test
|
|
20f8 : c90e > cmp #test_num
|
|
> trap_ne ;test is out of sequence
|
|
20fa : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
000f = >test_num = test_num + 1
|
|
20fc : a90f > lda #test_num ;*** next tests' number
|
|
20fe : 8d0202 > sta test_case
|
|
> ;check_ram ;uncomment to find altered RAM after each test
|
|
|
|
|
|
if rkwl_wdc_op = 1
|
|
; 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
|
|
|
|
ldx #$ba ;protect x & y
|
|
ldy #$d0
|
|
rmbt 0
|
|
rmbt 1
|
|
rmbt 2
|
|
rmbt 3
|
|
rmbt 4
|
|
rmbt 5
|
|
rmbt 6
|
|
rmbt 7
|
|
smbt 0
|
|
smbt 1
|
|
smbt 2
|
|
smbt 3
|
|
smbt 4
|
|
smbt 5
|
|
smbt 6
|
|
smbt 7
|
|
cpx #$ba
|
|
trap_ne ;x altered during test
|
|
cpy #$d0
|
|
trap_ne ;y altered during test
|
|
tsx
|
|
cpx #$ff
|
|
trap_ne ;sp push/pop mismatch
|
|
next_test
|
|
endif
|
|
|
|
; testing CMP - (zp)
|
|
2101 : a2de ldx #$de ;protect x & y
|
|
2103 : a0ad ldy #$ad
|
|
set_a $80,0
|
|
> load_flag 0
|
|
2105 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
2107 : 48 > pha ;use stack to load status
|
|
2108 : a980 > lda #$80 ;precharge accu
|
|
210a : 28 > plp
|
|
|
|
210b : d22c cmp (ind1+8)
|
|
tst_a $80,fc
|
|
210d : 08 > php ;save flags
|
|
210e : c980 > cmp #$80 ;test result
|
|
> trap_ne
|
|
2110 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
2112 : 68 > pla ;load status
|
|
2113 : 48 > pha
|
|
> cmp_flag fc
|
|
2114 : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
2116 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
2118 : 28 > plp ;restore status
|
|
|
|
set_a $7f,0
|
|
> load_flag 0
|
|
2119 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
211b : 48 > pha ;use stack to load status
|
|
211c : a97f > lda #$7f ;precharge accu
|
|
211e : 28 > plp
|
|
|
|
211f : d22c cmp (ind1+8)
|
|
tst_a $7f,fzc
|
|
2121 : 08 > php ;save flags
|
|
2122 : c97f > cmp #$7f ;test result
|
|
> trap_ne
|
|
2124 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
2126 : 68 > pla ;load status
|
|
2127 : 48 > pha
|
|
> cmp_flag fzc
|
|
2128 : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
212a : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
212c : 28 > plp ;restore status
|
|
|
|
set_a $7e,0
|
|
> load_flag 0
|
|
212d : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
212f : 48 > pha ;use stack to load status
|
|
2130 : a97e > lda #$7e ;precharge accu
|
|
2132 : 28 > plp
|
|
|
|
2133 : d22c cmp (ind1+8)
|
|
tst_a $7e,fn
|
|
2135 : 08 > php ;save flags
|
|
2136 : c97e > cmp #$7e ;test result
|
|
> trap_ne
|
|
2138 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
213a : 68 > pla ;load status
|
|
213b : 48 > pha
|
|
> cmp_flag fn
|
|
213c : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
213e : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
2140 : 28 > plp ;restore status
|
|
|
|
set_a $80,$ff
|
|
> load_flag $ff
|
|
2141 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
2143 : 48 > pha ;use stack to load status
|
|
2144 : a980 > lda #$80 ;precharge accu
|
|
2146 : 28 > plp
|
|
|
|
2147 : d22c cmp (ind1+8)
|
|
tst_a $80,~fnz
|
|
2149 : 08 > php ;save flags
|
|
214a : c980 > cmp #$80 ;test result
|
|
> trap_ne
|
|
214c : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
214e : 68 > pla ;load status
|
|
214f : 48 > pha
|
|
> cmp_flag ~fnz
|
|
2150 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
2152 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
2154 : 28 > plp ;restore status
|
|
|
|
set_a $7f,$ff
|
|
> load_flag $ff
|
|
2155 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
2157 : 48 > pha ;use stack to load status
|
|
2158 : a97f > lda #$7f ;precharge accu
|
|
215a : 28 > plp
|
|
|
|
215b : d22c cmp (ind1+8)
|
|
tst_a $7f,~fn
|
|
215d : 08 > php ;save flags
|
|
215e : c97f > cmp #$7f ;test result
|
|
> trap_ne
|
|
2160 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
2162 : 68 > pla ;load status
|
|
2163 : 48 > pha
|
|
> cmp_flag ~fn
|
|
2164 : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
2166 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
2168 : 28 > plp ;restore status
|
|
|
|
set_a $7e,$ff
|
|
> load_flag $ff
|
|
2169 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
216b : 48 > pha ;use stack to load status
|
|
216c : a97e > lda #$7e ;precharge accu
|
|
216e : 28 > plp
|
|
|
|
216f : d22c cmp (ind1+8)
|
|
tst_a $7e,~fzc
|
|
2171 : 08 > php ;save flags
|
|
2172 : c97e > cmp #$7e ;test result
|
|
> trap_ne
|
|
2174 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
2176 : 68 > pla ;load status
|
|
2177 : 48 > pha
|
|
> cmp_flag ~fzc
|
|
2178 : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits
|
|
>
|
|
> trap_ne
|
|
217a : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
217c : 28 > plp ;restore status
|
|
|
|
217d : e0de cpx #$de
|
|
trap_ne ;x altered during test
|
|
217f : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
2181 : c0ad cpy #$ad
|
|
trap_ne ;y altered during test
|
|
2183 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
2185 : ba tsx
|
|
2186 : e0ff cpx #$ff
|
|
trap_ne ;sp push/pop mismatch
|
|
2188 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
next_test
|
|
218a : ad0202 > lda test_case ;previous test
|
|
218d : c90f > cmp #test_num
|
|
> trap_ne ;test is out of sequence
|
|
218f : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0010 = >test_num = test_num + 1
|
|
2191 : a910 > lda #test_num ;*** next tests' number
|
|
2193 : 8d0202 > sta test_case
|
|
> ;check_ram ;uncomment to find altered RAM after each test
|
|
|
|
|
|
; testing logical instructions - AND EOR ORA (zp)
|
|
2196 : a242 ldx #$42 ;protect x & y
|
|
|
|
2198 : a000 ldy #0 ;AND
|
|
219a : a53a lda indAN ;set indirect address
|
|
219c : 850c sta zpt
|
|
219e : a53b lda indAN+1
|
|
21a0 : 850d sta zpt+1
|
|
21a2 : tand1
|
|
set_ay absANa,0
|
|
> load_flag 0
|
|
21a2 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
21a4 : 48 > pha ;use stack to load status
|
|
21a5 : b95302 > lda absANa,y ;precharge accu
|
|
21a8 : 28 > plp
|
|
|
|
21a9 : 320c and (zpt)
|
|
tst_ay absrlo,absflo,0
|
|
21ab : 08 > php ;save flags
|
|
21ac : d95b02 > cmp absrlo,y ;test result
|
|
> trap_ne ;
|
|
21af : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
21b1 : 68 > pla ;load status
|
|
> eor_flag 0
|
|
21b2 : 4930 > eor #0|fao ;invert expected flags + always on bits
|
|
>
|
|
21b4 : d95f02 > cmp absflo,y ;test flags
|
|
> trap_ne
|
|
21b7 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
21b9 : e60c inc zpt
|
|
21bb : c8 iny
|
|
21bc : c004 cpy #4
|
|
21be : d0e2 bne tand1
|
|
21c0 : 88 dey
|
|
21c1 : c60c dec zpt
|
|
21c3 : tand2
|
|
set_ay absANa,$ff
|
|
> load_flag $ff
|
|
21c3 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
21c5 : 48 > pha ;use stack to load status
|
|
21c6 : b95302 > lda absANa,y ;precharge accu
|
|
21c9 : 28 > plp
|
|
|
|
21ca : 320c and (zpt)
|
|
tst_ay absrlo,absflo,$ff-fnz
|
|
21cc : 08 > php ;save flags
|
|
21cd : d95b02 > cmp absrlo,y ;test result
|
|
> trap_ne ;
|
|
21d0 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
21d2 : 68 > pla ;load status
|
|
> eor_flag $ff-fnz
|
|
21d3 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
|
|
>
|
|
21d5 : d95f02 > cmp absflo,y ;test flags
|
|
> trap_ne
|
|
21d8 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
21da : c60c dec zpt
|
|
21dc : 88 dey
|
|
21dd : 10e4 bpl tand2
|
|
|
|
21df : a000 ldy #0 ;EOR
|
|
21e1 : a542 lda indEO ;set indirect address
|
|
21e3 : 850c sta zpt
|
|
21e5 : a543 lda indEO+1
|
|
21e7 : 850d sta zpt+1
|
|
21e9 : teor1
|
|
set_ay absEOa,0
|
|
> load_flag 0
|
|
21e9 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
21eb : 48 > pha ;use stack to load status
|
|
21ec : b95702 > lda absEOa,y ;precharge accu
|
|
21ef : 28 > plp
|
|
|
|
21f0 : 520c eor (zpt)
|
|
tst_ay absrlo,absflo,0
|
|
21f2 : 08 > php ;save flags
|
|
21f3 : d95b02 > cmp absrlo,y ;test result
|
|
> trap_ne ;
|
|
21f6 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
21f8 : 68 > pla ;load status
|
|
> eor_flag 0
|
|
21f9 : 4930 > eor #0|fao ;invert expected flags + always on bits
|
|
>
|
|
21fb : d95f02 > cmp absflo,y ;test flags
|
|
> trap_ne
|
|
21fe : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
2200 : e60c inc zpt
|
|
2202 : c8 iny
|
|
2203 : c004 cpy #4
|
|
2205 : d0e2 bne teor1
|
|
2207 : 88 dey
|
|
2208 : c60c dec zpt
|
|
220a : teor2
|
|
set_ay absEOa,$ff
|
|
> load_flag $ff
|
|
220a : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
220c : 48 > pha ;use stack to load status
|
|
220d : b95702 > lda absEOa,y ;precharge accu
|
|
2210 : 28 > plp
|
|
|
|
2211 : 520c eor (zpt)
|
|
tst_ay absrlo,absflo,$ff-fnz
|
|
2213 : 08 > php ;save flags
|
|
2214 : d95b02 > cmp absrlo,y ;test result
|
|
> trap_ne ;
|
|
2217 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
2219 : 68 > pla ;load status
|
|
> eor_flag $ff-fnz
|
|
221a : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
|
|
>
|
|
221c : d95f02 > cmp absflo,y ;test flags
|
|
> trap_ne
|
|
221f : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
2221 : c60c dec zpt
|
|
2223 : 88 dey
|
|
2224 : 10e4 bpl teor2
|
|
|
|
2226 : a000 ldy #0 ;ORA
|
|
2228 : a54a lda indOR ;set indirect address
|
|
222a : 850c sta zpt
|
|
222c : a54b lda indOR+1
|
|
222e : 850d sta zpt+1
|
|
2230 : tora1
|
|
set_ay absORa,0
|
|
> load_flag 0
|
|
2230 : a900 > lda #0 ;allow test to change I-flag (no mask)
|
|
>
|
|
2232 : 48 > pha ;use stack to load status
|
|
2233 : b94f02 > lda absORa,y ;precharge accu
|
|
2236 : 28 > plp
|
|
|
|
2237 : 120c ora (zpt)
|
|
tst_ay absrlo,absflo,0
|
|
2239 : 08 > php ;save flags
|
|
223a : d95b02 > cmp absrlo,y ;test result
|
|
> trap_ne ;
|
|
223d : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
223f : 68 > pla ;load status
|
|
> eor_flag 0
|
|
2240 : 4930 > eor #0|fao ;invert expected flags + always on bits
|
|
>
|
|
2242 : d95f02 > cmp absflo,y ;test flags
|
|
> trap_ne
|
|
2245 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
2247 : e60c inc zpt
|
|
2249 : c8 iny
|
|
224a : c004 cpy #4
|
|
224c : d0e2 bne tora1
|
|
224e : 88 dey
|
|
224f : c60c dec zpt
|
|
2251 : tora2
|
|
set_ay absORa,$ff
|
|
> load_flag $ff
|
|
2251 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
2253 : 48 > pha ;use stack to load status
|
|
2254 : b94f02 > lda absORa,y ;precharge accu
|
|
2257 : 28 > plp
|
|
|
|
2258 : 120c ora (zpt)
|
|
tst_ay absrlo,absflo,$ff-fnz
|
|
225a : 08 > php ;save flags
|
|
225b : d95b02 > cmp absrlo,y ;test result
|
|
> trap_ne ;
|
|
225e : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
2260 : 68 > pla ;load status
|
|
> eor_flag $ff-fnz
|
|
2261 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
|
|
>
|
|
2263 : d95f02 > cmp absflo,y ;test flags
|
|
> trap_ne
|
|
2266 : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
|
|
2268 : c60c dec zpt
|
|
226a : 88 dey
|
|
226b : 10e4 bpl tora2
|
|
|
|
226d : e042 cpx #$42
|
|
trap_ne ;x 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 : c910 > cmp #test_num
|
|
> trap_ne ;test is out of sequence
|
|
227b : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0011 = >test_num = test_num + 1
|
|
227d : a911 > lda #test_num ;*** next tests' number
|
|
227f : 8d0202 > sta test_case
|
|
> ;check_ram ;uncomment to find altered RAM after each test
|
|
|
|
|
|
if I_flag = 3
|
|
2282 : 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
|
|
2283 : d8 cld
|
|
2284 : a20e ldx #ad2 ;for indexed test
|
|
2286 : a0ff ldy #$ff ;max range
|
|
2288 : a900 lda #0 ;start with adding zeroes & no carry
|
|
228a : 850c sta adfc ;carry in - for diag
|
|
228c : 850d sta ad1 ;operand 1 - accumulator
|
|
228e : 850e sta ad2 ;operand 2 - memory or immediate
|
|
2290 : 8d0502 sta ada2 ;non zp
|
|
2293 : 850f sta adrl ;expected result bits 0-7
|
|
2295 : 8510 sta adrh ;expected result bit 8 (carry out)
|
|
2297 : a9ff lda #$ff ;complemented operand 2 for subtract
|
|
2299 : 8512 sta sb2
|
|
229b : 8d0602 sta sba2 ;non zp
|
|
229e : a902 lda #2 ;expected Z-flag
|
|
22a0 : 8511 sta adrf
|
|
22a2 : 18 tadd clc ;test with carry clear
|
|
22a3 : 201925 jsr chkadd
|
|
22a6 : e60c inc adfc ;now with carry
|
|
22a8 : e60f inc adrl ;result +1
|
|
22aa : 08 php ;save N & Z from low result
|
|
22ab : 08 php
|
|
22ac : 68 pla ;accu holds expected flags
|
|
22ad : 2982 and #$82 ;mask N & Z
|
|
22af : 28 plp
|
|
22b0 : d002 bne tadd1
|
|
22b2 : e610 inc adrh ;result bit 8 - carry
|
|
22b4 : 0510 tadd1 ora adrh ;merge C to expected flags
|
|
22b6 : 8511 sta adrf ;save expected flags except overflow
|
|
22b8 : 38 sec ;test with carry set
|
|
22b9 : 201925 jsr chkadd
|
|
22bc : c60c dec adfc ;same for operand +1 but no carry
|
|
22be : e60d inc ad1
|
|
22c0 : d0e0 bne tadd ;iterate op1
|
|
22c2 : a900 lda #0 ;preset result to op2 when op1 = 0
|
|
22c4 : 8510 sta adrh
|
|
22c6 : ee0502 inc ada2
|
|
22c9 : e60e inc ad2
|
|
22cb : 08 php ;save NZ as operand 2 becomes the new result
|
|
22cc : 68 pla
|
|
22cd : 2982 and #$82 ;mask N00000Z0
|
|
22cf : 8511 sta adrf ;no need to check carry as we are adding to 0
|
|
22d1 : c612 dec sb2 ;complement subtract operand 2
|
|
22d3 : ce0602 dec sba2
|
|
22d6 : a50e lda ad2
|
|
22d8 : 850f sta adrl
|
|
22da : d0c6 bne tadd ;iterate op2
|
|
|
|
22dc : e00e cpx #ad2
|
|
trap_ne ;x altered during test
|
|
22de : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
22e0 : c0ff cpy #$ff
|
|
trap_ne ;y altered during test
|
|
22e2 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
22e4 : ba tsx
|
|
22e5 : e0ff cpx #$ff
|
|
trap_ne ;sp push/pop mismatch
|
|
22e7 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
next_test
|
|
22e9 : ad0202 > lda test_case ;previous test
|
|
22ec : c911 > cmp #test_num
|
|
> trap_ne ;test is out of sequence
|
|
22ee : d0fe > bne * ;failed not equal (non zero)
|
|
>
|
|
0012 = >test_num = test_num + 1
|
|
22f0 : a912 > lda #test_num ;*** next tests' number
|
|
22f2 : 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
|
|
22f5 : f8 sed
|
|
22f6 : a20e ldx #ad2 ;for indexed test
|
|
22f8 : a0ff ldy #$ff ;max range
|
|
22fa : a999 lda #$99 ;start with adding 99 to 99 with carry
|
|
22fc : 850d sta ad1 ;operand 1 - accumulator
|
|
22fe : 850e sta ad2 ;operand 2 - memory or immediate
|
|
2300 : 8d0502 sta ada2 ;non zp
|
|
2303 : 850f sta adrl ;expected result bits 0-7
|
|
2305 : a901 lda #1 ;set carry in & out
|
|
2307 : 850c sta adfc ;carry in - for diag
|
|
2309 : 8510 sta adrh ;expected result bit 8 (carry out)
|
|
230b : a981 lda #$81 ;set N & C (99 + 99 + C = 99 + C)
|
|
230d : 8511 sta adrf
|
|
230f : a900 lda #0 ;complemented operand 2 for subtract
|
|
2311 : 8512 sta sb2
|
|
2313 : 8d0602 sta sba2 ;non zp
|
|
2316 : 38 tdad sec ;test with carry set
|
|
2317 : 20c223 jsr chkdad
|
|
231a : c60c dec adfc ;now with carry clear
|
|
231c : a50f lda adrl ;decimal adjust result
|
|
231e : d008 bne tdad1 ;skip clear carry & preset result 99 (9A-1)
|
|
2320 : c610 dec adrh
|
|
2322 : a999 lda #$99
|
|
2324 : 850f sta adrl
|
|
2326 : d012 bne tdad3
|
|
2328 : 290f tdad1 and #$f ;lower nibble mask
|
|
232a : d00c bne tdad2 ;no decimal adjust needed
|
|
232c : c60f dec adrl ;decimal adjust (?0-6)
|
|
232e : c60f dec adrl
|
|
2330 : c60f dec adrl
|
|
2332 : c60f dec adrl
|
|
2334 : c60f dec adrl
|
|
2336 : c60f dec adrl
|
|
2338 : c60f tdad2 dec adrl ;result -1
|
|
233a : 08 tdad3 php ;save valid flags
|
|
233b : 68 pla
|
|
233c : 2982 and #$82 ;N-----Z-
|
|
233e : 0510 ora adrh ;N-----ZC
|
|
2340 : 8511 sta adrf
|
|
2342 : 18 clc ;test with carry clear
|
|
2343 : 20c223 jsr chkdad
|
|
2346 : e60c inc adfc ;same for operand -1 but with carry
|
|
2348 : a50d lda ad1 ;decimal adjust operand 1
|
|
234a : f015 beq tdad5 ;iterate operand 2
|
|
234c : 290f and #$f ;lower nibble mask
|
|
234e : d00c bne tdad4 ;skip decimal adjust
|
|
2350 : c60d dec ad1 ;decimal adjust (?0-6)
|
|
2352 : c60d dec ad1
|
|
2354 : c60d dec ad1
|
|
2356 : c60d dec ad1
|
|
2358 : c60d dec ad1
|
|
235a : c60d dec ad1
|
|
235c : c60d tdad4 dec ad1 ;operand 1 -1
|
|
235e : 4c1623 jmp tdad ;iterate op1
|
|
|
|
2361 : a999 tdad5 lda #$99 ;precharge op1 max
|
|
2363 : 850d sta ad1
|
|
2365 : a50e lda ad2 ;decimal adjust operand 2
|
|
2367 : f039 beq tdad7 ;end of iteration
|
|
2369 : 290f and #$f ;lower nibble mask
|
|
236b : d018 bne tdad6 ;skip decimal adjust
|
|
236d : c60e dec ad2 ;decimal adjust (?0-6)
|
|
236f : c60e dec ad2
|
|
2371 : c60e dec ad2
|
|
2373 : c60e dec ad2
|
|
2375 : c60e dec ad2
|
|
2377 : c60e dec ad2
|
|
2379 : e612 inc sb2 ;complemented decimal adjust for subtract (?9+6)
|
|
237b : e612 inc sb2
|
|
237d : e612 inc sb2
|
|
237f : e612 inc sb2
|
|
2381 : e612 inc sb2
|
|
2383 : e612 inc sb2
|
|
2385 : c60e tdad6 dec ad2 ;operand 2 -1
|
|
2387 : e612 inc sb2 ;complemented operand for subtract
|
|
2389 : a512 lda sb2
|
|
238b : 8d0602 sta sba2 ;copy as non zp operand
|
|
238e : a50e lda ad2
|
|
2390 : 8d0502 sta ada2 ;copy as non zp operand
|
|
2393 : 850f sta adrl ;new result since op1+carry=00+carry +op2=op2
|
|
2395 : 08 php ;save flags
|
|
2396 : 68 pla
|
|
2397 : 2982 and #$82 ;N-----Z-
|
|
2399 : 0901 ora #1 ;N-----ZC
|
|
239b : 8511 sta adrf
|
|
239d : e610 inc adrh ;result carry
|
|
239f : 4c1623 jmp tdad ;iterate op2
|
|
|
|
23a2 : e00e tdad7 cpx #ad2
|
|
trap_ne ;x altered during test
|
|
23a4 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
23a6 : c0ff cpy #$ff
|
|
trap_ne ;y altered during test
|
|
23a8 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
23aa : ba tsx
|
|
23ab : e0ff cpx #$ff
|
|
trap_ne ;sp push/pop mismatch
|
|
23ad : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
23af : d8 cld
|
|
|
|
23b0 : ad0202 lda test_case
|
|
23b3 : c912 cmp #test_num
|
|
trap_ne ;previous test is out of sequence
|
|
23b5 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
23b7 : a9f0 lda #$f0 ;mark opcode testing complete
|
|
23b9 : 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
|
|
> ;db $db
|
|
23bc : 4cbc23 > jmp * ;test passed, no errors
|
|
|
|
; -------------
|
|
; S U C C E S S ************************************************
|
|
23bf : 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
|
|
23c2 : chkdad
|
|
; decimal ADC / SBC zp
|
|
23c2 : 08 php ;save carry for subtract
|
|
23c3 : a50d lda ad1
|
|
23c5 : 650e adc ad2 ;perform add
|
|
23c7 : 08 php
|
|
23c8 : c50f cmp adrl ;check result
|
|
trap_ne ;bad result
|
|
23ca : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
23cc : 68 pla ;check flags
|
|
23cd : 2983 and #$83 ;mask N-----ZC
|
|
23cf : c511 cmp adrf
|
|
trap_ne ;bad flags
|
|
23d1 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
23d3 : 28 plp
|
|
23d4 : 08 php ;save carry for next add
|
|
23d5 : a50d lda ad1
|
|
23d7 : e512 sbc sb2 ;perform subtract
|
|
23d9 : 08 php
|
|
23da : c50f cmp adrl ;check result
|
|
trap_ne ;bad result
|
|
23dc : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
23de : 68 pla ;check flags
|
|
23df : 2983 and #$83 ;mask N-----ZC
|
|
23e1 : c511 cmp adrf
|
|
trap_ne ;bad flags
|
|
23e3 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
23e5 : 28 plp
|
|
; decimal ADC / SBC abs
|
|
23e6 : 08 php ;save carry for subtract
|
|
23e7 : a50d lda ad1
|
|
23e9 : 6d0502 adc ada2 ;perform add
|
|
23ec : 08 php
|
|
23ed : c50f cmp adrl ;check result
|
|
trap_ne ;bad result
|
|
23ef : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
23f1 : 68 pla ;check flags
|
|
23f2 : 2983 and #$83 ;mask N-----ZC
|
|
23f4 : c511 cmp adrf
|
|
trap_ne ;bad flags
|
|
23f6 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
23f8 : 28 plp
|
|
23f9 : 08 php ;save carry for next add
|
|
23fa : a50d lda ad1
|
|
23fc : ed0602 sbc sba2 ;perform subtract
|
|
23ff : 08 php
|
|
2400 : c50f cmp adrl ;check result
|
|
trap_ne ;bad result
|
|
2402 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
2404 : 68 pla ;check flags
|
|
2405 : 2983 and #$83 ;mask N-----ZC
|
|
2407 : c511 cmp adrf
|
|
trap_ne ;bad flags
|
|
2409 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
240b : 28 plp
|
|
; decimal ADC / SBC #
|
|
240c : 08 php ;save carry for subtract
|
|
240d : a50e lda ad2
|
|
240f : 8d0b02 sta ex_adci+1 ;set ADC # operand
|
|
2412 : a50d lda ad1
|
|
2414 : 200a02 jsr ex_adci ;execute ADC # in RAM
|
|
2417 : 08 php
|
|
2418 : c50f cmp adrl ;check result
|
|
trap_ne ;bad result
|
|
241a : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
241c : 68 pla ;check flags
|
|
241d : 2983 and #$83 ;mask N-----ZC
|
|
241f : c511 cmp adrf
|
|
trap_ne ;bad flags
|
|
2421 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
2423 : 28 plp
|
|
2424 : 08 php ;save carry for next add
|
|
2425 : a512 lda sb2
|
|
2427 : 8d0e02 sta ex_sbci+1 ;set SBC # operand
|
|
242a : a50d lda ad1
|
|
242c : 200d02 jsr ex_sbci ;execute SBC # in RAM
|
|
242f : 08 php
|
|
2430 : c50f cmp adrl ;check result
|
|
trap_ne ;bad result
|
|
2432 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
2434 : 68 pla ;check flags
|
|
2435 : 2983 and #$83 ;mask N-----ZC
|
|
2437 : c511 cmp adrf
|
|
trap_ne ;bad flags
|
|
2439 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
243b : 28 plp
|
|
; decimal ADC / SBC zp,x
|
|
243c : 08 php ;save carry for subtract
|
|
243d : a50d lda ad1
|
|
243f : 7500 adc 0,x ;perform add
|
|
2441 : 08 php
|
|
2442 : c50f cmp adrl ;check result
|
|
trap_ne ;bad result
|
|
2444 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
2446 : 68 pla ;check flags
|
|
2447 : 2983 and #$83 ;mask N-----ZC
|
|
2449 : c511 cmp adrf
|
|
trap_ne ;bad flags
|
|
244b : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
244d : 28 plp
|
|
244e : 08 php ;save carry for next add
|
|
244f : a50d lda ad1
|
|
2451 : f504 sbc sb2-ad2,x ;perform subtract
|
|
2453 : 08 php
|
|
2454 : c50f cmp adrl ;check result
|
|
trap_ne ;bad result
|
|
2456 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
2458 : 68 pla ;check flags
|
|
2459 : 2983 and #$83 ;mask N-----ZC
|
|
245b : c511 cmp adrf
|
|
trap_ne ;bad flags
|
|
245d : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
245f : 28 plp
|
|
; decimal ADC / SBC abs,x
|
|
2460 : 08 php ;save carry for subtract
|
|
2461 : a50d lda ad1
|
|
2463 : 7df701 adc ada2-ad2,x ;perform add
|
|
2466 : 08 php
|
|
2467 : c50f cmp adrl ;check result
|
|
trap_ne ;bad result
|
|
2469 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
246b : 68 pla ;check flags
|
|
246c : 2983 and #$83 ;mask N-----ZC
|
|
246e : c511 cmp adrf
|
|
trap_ne ;bad flags
|
|
2470 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
2472 : 28 plp
|
|
2473 : 08 php ;save carry for next add
|
|
2474 : a50d lda ad1
|
|
2476 : fdf801 sbc sba2-ad2,x ;perform subtract
|
|
2479 : 08 php
|
|
247a : c50f cmp adrl ;check result
|
|
trap_ne ;bad result
|
|
247c : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
247e : 68 pla ;check flags
|
|
247f : 2983 and #$83 ;mask N-----ZC
|
|
2481 : c511 cmp adrf
|
|
trap_ne ;bad flags
|
|
2483 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
2485 : 28 plp
|
|
; decimal ADC / SBC abs,y
|
|
2486 : 08 php ;save carry for subtract
|
|
2487 : a50d lda ad1
|
|
2489 : 790601 adc ada2-$ff,y ;perform add
|
|
248c : 08 php
|
|
248d : c50f cmp adrl ;check result
|
|
trap_ne ;bad result
|
|
248f : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
2491 : 68 pla ;check flags
|
|
2492 : 2983 and #$83 ;mask N-----ZC
|
|
2494 : c511 cmp adrf
|
|
trap_ne ;bad flags
|
|
2496 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
2498 : 28 plp
|
|
2499 : 08 php ;save carry for next add
|
|
249a : a50d lda ad1
|
|
249c : f90701 sbc sba2-$ff,y ;perform subtract
|
|
249f : 08 php
|
|
24a0 : c50f cmp adrl ;check result
|
|
trap_ne ;bad result
|
|
24a2 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
24a4 : 68 pla ;check flags
|
|
24a5 : 2983 and #$83 ;mask N-----ZC
|
|
24a7 : c511 cmp adrf
|
|
trap_ne ;bad flags
|
|
24a9 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
24ab : 28 plp
|
|
; decimal ADC / SBC (zp,x)
|
|
24ac : 08 php ;save carry for subtract
|
|
24ad : a50d lda ad1
|
|
24af : 6144 adc (lo adi2-ad2,x) ;perform add
|
|
24b1 : 08 php
|
|
24b2 : c50f cmp adrl ;check result
|
|
trap_ne ;bad result
|
|
24b4 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
24b6 : 68 pla ;check flags
|
|
24b7 : 2983 and #$83 ;mask N-----ZC
|
|
24b9 : c511 cmp adrf
|
|
trap_ne ;bad flags
|
|
24bb : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
24bd : 28 plp
|
|
24be : 08 php ;save carry for next add
|
|
24bf : a50d lda ad1
|
|
24c1 : e146 sbc (lo sbi2-ad2,x) ;perform subtract
|
|
24c3 : 08 php
|
|
24c4 : c50f cmp adrl ;check result
|
|
trap_ne ;bad result
|
|
24c6 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
24c8 : 68 pla ;check flags
|
|
24c9 : 2983 and #$83 ;mask N-----ZC
|
|
24cb : c511 cmp adrf
|
|
trap_ne ;bad flags
|
|
24cd : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
24cf : 28 plp
|
|
; decimal ADC / SBC (abs),y
|
|
24d0 : 08 php ;save carry for subtract
|
|
24d1 : a50d lda ad1
|
|
24d3 : 7156 adc (adiy2),y ;perform add
|
|
24d5 : 08 php
|
|
24d6 : c50f cmp adrl ;check result
|
|
trap_ne ;bad result
|
|
24d8 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
24da : 68 pla ;check flags
|
|
24db : 2983 and #$83 ;mask N-----ZC
|
|
24dd : c511 cmp adrf
|
|
trap_ne ;bad flags
|
|
24df : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
24e1 : 28 plp
|
|
24e2 : 08 php ;save carry for next add
|
|
24e3 : a50d lda ad1
|
|
24e5 : f158 sbc (sbiy2),y ;perform subtract
|
|
24e7 : 08 php
|
|
24e8 : c50f cmp adrl ;check result
|
|
trap_ne ;bad result
|
|
24ea : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
24ec : 68 pla ;check flags
|
|
24ed : 2983 and #$83 ;mask N-----ZC
|
|
24ef : c511 cmp adrf
|
|
trap_ne ;bad flags
|
|
24f1 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
24f3 : 28 plp
|
|
; decimal ADC / SBC (zp)
|
|
24f4 : 08 php ;save carry for subtract
|
|
24f5 : a50d lda ad1
|
|
24f7 : 7252 adc (adi2) ;perform add
|
|
24f9 : 08 php
|
|
24fa : c50f cmp adrl ;check result
|
|
trap_ne ;bad result
|
|
24fc : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
24fe : 68 pla ;check flags
|
|
24ff : 2983 and #$83 ;mask N-----ZC
|
|
2501 : c511 cmp adrf
|
|
trap_ne ;bad flags
|
|
2503 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
2505 : 28 plp
|
|
2506 : 08 php ;save carry for next add
|
|
2507 : a50d lda ad1
|
|
2509 : f254 sbc (sbi2) ;perform subtract
|
|
250b : 08 php
|
|
250c : c50f cmp adrl ;check result
|
|
trap_ne ;bad result
|
|
250e : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
2510 : 68 pla ;check flags
|
|
2511 : 2983 and #$83 ;mask N-----ZC
|
|
2513 : c511 cmp adrf
|
|
trap_ne ;bad flags
|
|
2515 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
2517 : 28 plp
|
|
2518 : 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
|
|
2519 : a511 chkadd lda adrf ;add V-flag if overflow
|
|
251b : 2983 and #$83 ;keep N-----ZC / clear V
|
|
251d : 48 pha
|
|
251e : a50d lda ad1 ;test sign unequal between operands
|
|
2520 : 450e eor ad2
|
|
2522 : 300a bmi ckad1 ;no overflow possible - operands have different sign
|
|
2524 : a50d lda ad1 ;test sign equal between operands and result
|
|
2526 : 450f eor adrl
|
|
2528 : 1004 bpl ckad1 ;no overflow occured - operand and result have same sign
|
|
252a : 68 pla
|
|
252b : 0940 ora #$40 ;set V
|
|
252d : 48 pha
|
|
252e : 68 ckad1 pla
|
|
252f : 8511 sta adrf ;save expected flags
|
|
; binary ADC / SBC (zp)
|
|
2531 : 08 php ;save carry for subtract
|
|
2532 : a50d lda ad1
|
|
2534 : 7252 adc (adi2) ;perform add
|
|
2536 : 08 php
|
|
2537 : c50f cmp adrl ;check result
|
|
trap_ne ;bad result
|
|
2539 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
253b : 68 pla ;check flags
|
|
253c : 29c3 and #$c3 ;mask NV----ZC
|
|
253e : c511 cmp adrf
|
|
trap_ne ;bad flags
|
|
2540 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
2542 : 28 plp
|
|
2543 : 08 php ;save carry for next add
|
|
2544 : a50d lda ad1
|
|
2546 : f254 sbc (sbi2) ;perform subtract
|
|
2548 : 08 php
|
|
2549 : c50f cmp adrl ;check result
|
|
trap_ne ;bad result
|
|
254b : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
254d : 68 pla ;check flags
|
|
254e : 29c3 and #$c3 ;mask NV----ZC
|
|
2550 : c511 cmp adrf
|
|
trap_ne ;bad flags
|
|
2552 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
2554 : 28 plp
|
|
2555 : 60 rts
|
|
|
|
; target for the jump indirect test
|
|
2556 : 5c25 ji_adr dw test_ji
|
|
2558 : 1a19 dw ji_ret
|
|
|
|
255a : 88 dey
|
|
255b : 88 dey
|
|
255c : test_ji
|
|
255c : 08 php ;either SP or Y count will fail, if we do not hit
|
|
255d : 88 dey
|
|
255e : 88 dey
|
|
255f : 88 dey
|
|
2560 : 28 plp
|
|
trap_cs ;flags loaded?
|
|
2561 : b0fe > bcs * ;failed carry set
|
|
|
|
trap_vs
|
|
2563 : 70fe > bvs * ;failed overflow set
|
|
|
|
trap_mi
|
|
2565 : 30fe > bmi * ;failed minus (bit 7 set)
|
|
|
|
trap_eq
|
|
2567 : f0fe > beq * ;failed equal (zero)
|
|
|
|
2569 : c949 cmp #'I' ;registers loaded?
|
|
trap_ne
|
|
256b : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
256d : e04e cpx #'N'
|
|
trap_ne
|
|
256f : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
2571 : c041 cpy #('D'-3)
|
|
trap_ne
|
|
2573 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
2575 : 48 pha ;save a,x
|
|
2576 : 8a txa
|
|
2577 : 48 pha
|
|
2578 : ba tsx
|
|
2579 : e0fd cpx #$fd ;check SP
|
|
trap_ne
|
|
257b : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
257d : 68 pla ;restore x
|
|
257e : aa tax
|
|
set_stat $ff
|
|
> load_flag $ff
|
|
257f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
2581 : 48 > pha ;use stack to load status
|
|
2582 : 28 > plp
|
|
|
|
2583 : 68 pla ;restore a
|
|
2584 : e8 inx ;return registers with modifications
|
|
2585 : 49aa eor #$aa ;N=1, V=1, Z=0, C=1
|
|
2587 : 6cff02 jmp (ji_tab+2)
|
|
258a : ea nop
|
|
258b : ea nop
|
|
trap ;runover protection
|
|
258c : 4c8c25 > jmp * ;failed anyway
|
|
|
|
258f : 4c0004 jmp start ;catastrophic error - cannot continue
|
|
|
|
; target for the jump indirect test
|
|
2592 : d925 jxi_adr dw trap_ind
|
|
2594 : d925 dw trap_ind
|
|
2596 : a025 dw test_jxi ;+4
|
|
2598 : 6619 dw jxi_ret ;+6
|
|
259a : d925 dw trap_ind
|
|
259c : d925 dw trap_ind
|
|
|
|
259e : 88 dey
|
|
259f : 88 dey
|
|
25a0 : test_jxi
|
|
25a0 : 08 php ;either SP or Y count will fail, if we do not hit
|
|
25a1 : 88 dey
|
|
25a2 : 88 dey
|
|
25a3 : 88 dey
|
|
25a4 : 28 plp
|
|
trap_cs ;flags loaded?
|
|
25a5 : b0fe > bcs * ;failed carry set
|
|
|
|
trap_vs
|
|
25a7 : 70fe > bvs * ;failed overflow set
|
|
|
|
trap_mi
|
|
25a9 : 30fe > bmi * ;failed minus (bit 7 set)
|
|
|
|
trap_eq
|
|
25ab : f0fe > beq * ;failed equal (zero)
|
|
|
|
25ad : c958 cmp #'X' ;registers loaded?
|
|
trap_ne
|
|
25af : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
25b1 : e004 cpx #4
|
|
trap_ne
|
|
25b3 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
25b5 : c046 cpy #('I'-3)
|
|
trap_ne
|
|
25b7 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
25b9 : 48 pha ;save a,x
|
|
25ba : 8a txa
|
|
25bb : 48 pha
|
|
25bc : ba tsx
|
|
25bd : e0fd cpx #$fd ;check SP
|
|
trap_ne
|
|
25bf : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
25c1 : 68 pla ;restore x
|
|
25c2 : aa tax
|
|
set_stat $ff
|
|
> load_flag $ff
|
|
25c3 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
>
|
|
25c5 : 48 > pha ;use stack to load status
|
|
25c6 : 28 > plp
|
|
|
|
25c7 : 68 pla ;restore a
|
|
25c8 : e8 inx ;return registers with modifications
|
|
25c9 : e8 inx
|
|
25ca : 49aa eor #$aa ;N=1, V=1, Z=0, C=1
|
|
25cc : 7cf902 jmp (jxi_tab,x)
|
|
25cf : ea nop
|
|
25d0 : ea nop
|
|
trap ;runover protection
|
|
25d1 : 4cd125 > jmp * ;failed anyway
|
|
|
|
25d4 : 4c0004 jmp start ;catastrophic error - cannot continue
|
|
|
|
; JMP (abs,x) with bad x
|
|
25d7 : ea nop
|
|
25d8 : ea nop
|
|
25d9 : trap_ind
|
|
25d9 : ea nop
|
|
25da : ea nop
|
|
trap ;near miss indexed indirect jump
|
|
25db : 4cdb25 > jmp * ;failed anyway
|
|
|
|
25de : 4c0004 jmp start ;catastrophic error - cannot continue
|
|
|
|
;trap in case of unexpected IRQ, NMI, BRK, RESET
|
|
25e1 : nmi_trap
|
|
trap ;check stack for conditions at NMI
|
|
25e1 : 4ce125 > jmp * ;failed anyway
|
|
|
|
25e4 : 4c0004 jmp start ;catastrophic error - cannot continue
|
|
25e7 : res_trap
|
|
trap ;unexpected RESET
|
|
25e7 : 4ce725 > jmp * ;failed anyway
|
|
|
|
25ea : 4c0004 jmp start ;catastrophic error - cannot continue
|
|
|
|
25ed : 88 dey
|
|
25ee : 88 dey
|
|
25ef : irq_trap ;BRK test or unextpected BRK or IRQ
|
|
25ef : 08 php ;either SP or Y count will fail, if we do not hit
|
|
25f0 : 88 dey
|
|
25f1 : 88 dey
|
|
25f2 : 88 dey
|
|
;next traps could be caused by unexpected BRK or IRQ
|
|
;check stack for BREAK and originating location
|
|
;possible jump/branch into weeds (uninitialized space)
|
|
25f3 : c9bd cmp #$ff-'B' ;BRK pass 2 registers loaded?
|
|
25f5 : f042 beq break2
|
|
25f7 : c942 cmp #'B' ;BRK pass 1 registers loaded?
|
|
trap_ne
|
|
25f9 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
25fb : e052 cpx #'R'
|
|
trap_ne
|
|
25fd : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
25ff : c048 cpy #'K'-3
|
|
trap_ne
|
|
2601 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
2603 : 850a sta irq_a ;save registers during break test
|
|
2605 : 860b stx irq_x
|
|
2607 : ba tsx ;test break on stack
|
|
2608 : bd0201 lda $102,x
|
|
cmp_flag 0 ;break test should have B=1 & unused=1 on stack
|
|
260b : c930 > cmp #(0 |fao)&m8 ;expected flags + always on bits
|
|
|
|
trap_ne ;possible no break flag on stack
|
|
260d : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
260f : 68 pla
|
|
cmp_flag intdis ;should have added interrupt disable
|
|
2610 : c934 > cmp #(intdis |fao)&m8 ;expected flags + always on bits
|
|
|
|
trap_ne
|
|
2612 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
2614 : ba tsx
|
|
2615 : e0fc cpx #$fc ;sp -3? (return addr, flags)
|
|
trap_ne
|
|
2617 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
2619 : adff01 lda $1ff ;propper return on stack
|
|
261c : c919 cmp #hi(brk_ret0)
|
|
trap_ne
|
|
261e : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
2620 : adfe01 lda $1fe
|
|
2623 : c9b8 cmp #lo(brk_ret0)
|
|
trap_ne
|
|
2625 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
load_flag $ff
|
|
2627 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
|
|
|
|
2629 : 48 pha
|
|
262a : a60b ldx irq_x
|
|
262c : e8 inx ;return registers with modifications
|
|
262d : a50a lda irq_a
|
|
262f : 49aa eor #$aa
|
|
2631 : 28 plp ;N=1, V=1, Z=1, C=1 but original flags should be restored
|
|
2632 : 40 rti
|
|
trap ;runover protection
|
|
2633 : 4c3326 > jmp * ;failed anyway
|
|
|
|
2636 : 4c0004 jmp start ;catastrophic error - cannot continue
|
|
|
|
2639 : break2 ;BRK pass 2
|
|
2639 : e0ad cpx #$ff-'R'
|
|
trap_ne
|
|
263b : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
263d : c0b1 cpy #$ff-'K'-3
|
|
trap_ne
|
|
263f : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
2641 : 850a sta irq_a ;save registers during break test
|
|
2643 : 860b stx irq_x
|
|
2645 : ba tsx ;test break on stack
|
|
2646 : bd0201 lda $102,x
|
|
cmp_flag $ff ;break test should have B=1
|
|
2649 : c9ff > cmp #($ff |fao)&m8 ;expected flags + always on bits
|
|
|
|
trap_ne ;possibly no break flag on stack
|
|
264b : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
264d : 68 pla
|
|
cmp_flag $ff-decmode ;actual passed flags should have decmode cleared
|
|
264e : c9f7 > cmp #($ff-decmode |fao)&m8 ;expected flags + always on bits
|
|
|
|
trap_ne
|
|
2650 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
2652 : ba tsx
|
|
2653 : e0fc cpx #$fc ;sp -3? (return addr, flags)
|
|
trap_ne
|
|
2655 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
2657 : adff01 lda $1ff ;propper return on stack
|
|
265a : c919 cmp #hi(brk_ret1)
|
|
trap_ne
|
|
265c : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
265e : adfe01 lda $1fe
|
|
2661 : c9de cmp #lo(brk_ret1)
|
|
trap_ne
|
|
2663 : d0fe > bne * ;failed not equal (non zero)
|
|
|
|
load_flag intdis
|
|
2665 : a904 > lda #intdis ;allow test to change I-flag (no mask)
|
|
|
|
2667 : 48 pha
|
|
2668 : a60b ldx irq_x
|
|
266a : e8 inx ;return registers with modifications
|
|
266b : a50a lda irq_a
|
|
266d : 49aa eor #$aa
|
|
266f : 28 plp ;N=0, V=0, Z=0, C=0 but original flags should be restored
|
|
2670 : 40 rti
|
|
trap ;runover protection
|
|
2671 : 4c7126 > jmp * ;failed anyway
|
|
|
|
2674 : 4c0004 jmp start ;catastrophic error - cannot continue
|
|
|
|
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
|
|
ex_adc_ adc #0 ;execute immediate opcodes
|
|
rts
|
|
ex_sbc_ sbc #0 ;execute immediate opcodes
|
|
rts
|
|
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
|
|
2677 : 00000000000000.. ds lo(ji_ret - * - 2)
|
|
2718 : ea nop
|
|
2719 : ea nop
|
|
271a : ea ji_px nop ;low address byte matched with ji_ret
|
|
271b : ea nop
|
|
trap ;jmp indirect page cross bug
|
|
271c : 4c1c27 > jmp * ;failed anyway
|
|
|
|
|
|
; JMP (abs,x) when $xxff and $xx00 are from same page
|
|
271f : 00000000000000.. ds lo(jxi_ret - * - 2)
|
|
2764 : ea nop
|
|
2765 : ea nop
|
|
2766 : ea jxi_px nop ;low address byte matched with jxi_ret
|
|
2767 : ea nop
|
|
trap ;jmp indexed indirect page cross bug
|
|
2768 : 4c6827 > 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 : e125 dw nmi_trap
|
|
fffc : e725 dw res_trap
|
|
fffe : ef25 dw irq_trap
|
|
endif
|
|
|
|
fffa = end start
|
|
|
|
No errors in pass 2.
|