6502.org • View topic - 65Org16 Assembler (16-bit bytes, 32-bit address space)

View unanswered posts | View active topics

Board index » 6502.org Users Forum » Programming

All times are UTC

65Org16 Assembler (16-bit bytes, 32-bit address space)

Page 2 of 9

[ 132 posts ]

Go to page Previous 1, 2, 3, 4, 5 ... 9 Next

Previous topic | Next topic

Author

Message

BigEd

Post subject:

Posted: Sat Jun 04, 2011 9:56 am

Joined: Thu Dec 11, 2008 1:28 pm
Posts: 10837
Location: England

teamtempest wrote:

nothing to stop me from defining new '-BIT--' types that have the desired properties - 16-bit values having size one as far as the PC goes, for instance - while keeping all the current types. A particular native assembler or macro instruction set would use just the types it was interested in.

This sounds promising. Deal in 16-bit quantities, each at a unique address. This will also set us up well if and when we have a 65Org32.

teamtempest wrote:

What does the proposed CPU expect to see? If it's this, as EE suggests:

Quote:

LDA $89ABCDEF ; 00AD CDEF 89AB

That's certainly what the CPU will see, in terms of a sequence of 16-bit 'bytes'. Up to that point, we're fine. But I think you're still trying to see it as a (longer) sequence of octets, and so you say...

teamtempest wrote:

then this macro (also shown earlier) creates it:

Code:

.cpu T_32_M      ; MSB-first order

.macro LDA, ?addr
.word $00AD      ; opcode
.word ?addr,     ; lo 16 bits
.word ^(?addr)   ; hi 16 bits
.endm

Though a native version would do this faster, and also not have to evaluate '?addr' twice.

Which I still don't like: firstly because it's from the big-endian family, which is a sign that something is wrong, and secondly because it has to take an extra step and therefore evaluate twice.

(Edit: on reflection, perhaps I'm being too much of a purist. If you can see a way to make things work, that would be a good thing!)

If the endpoint of your assembler is a listing like I can get from DB's assembler. which looks much like

Code:

FFFFE000 00A9 0000 
FFFFE002 0085 0000 
FFFFE004 00A9 1000 
FFFFE006 0085 0001 
FFFFE008 00A2 FFFE 
FFFFE00A 00A0 0000 
FFFFE00C 00A9 AA55 
FFFFE00E 0091 0000 
FFFFE010 00C8 
FFFFE011 00D0 FFFB 
FFFFE013 00E6 0001 
FFFFE014 00CA 
FFFFE015 00D0 FFF6 
FFFFE017 004C E017 FFFF 

then we're all happy, and all we need to do is get this into a loader format, or into a ROM.

In fact, it will be good to get that final step also from the assembler, but if you see that intermediate form clearly, especially as the format for listing, I don't think you'll have so much bother about byte order. It's just as natural as 6502, and as Garth has pointed out, just as natural as the nibbles in 6502 listings being MSB-first despite the bytes being LSB-first.

Hope this helps.

Cheers
Ed

Top

teamtempest

Post subject:

Posted: Sat Jun 04, 2011 3:31 pm

Joined: Sun Nov 08, 2009 1:56 am
Posts: 390
Location: Minnesota

BigEd wrote:

teamtempest wrote:

This sounds promising. Deal in 16-bit quantities, each at a unique address. This will also set us up well if and when we have a 65Org32.

teamtempest wrote:

What does the proposed CPU expect to see? If it's this, as EE suggests:

Quote:

LDA $89ABCDEF ; 00AD CDEF 89AB

teamtempest wrote:

then this macro (also shown earlier) creates it:

Code:

.cpu T_32_M      ; MSB-first order

.macro LDA, ?addr
.word $00AD      ; opcode
.word ?addr,     ; lo 16 bits
.word ^(?addr)   ; hi 16 bits
.endm

Though a native version would do this faster, and also not have to evaluate '?addr' twice.

Well, if it makes you feel better maybe you can think of it as the equivalent of

Code:

lda #<(addr)
ldy #>(addr)

which does the same double evaluation of one expression (and for the same reason).

Quote:

If the endpoint of your assembler is a listing like I can get from DB's assembler. which looks much like

Code:

FFFFE000 00A9 0000 
FFFFE002 0085 0000 
FFFFE004 00A9 1000 
FFFFE006 0085 0001 
FFFFE008 00A2 FFFE 
FFFFE00A 00A0 0000 
FFFFE00C 00A9 AA55 
FFFFE00E 0091 0000 
FFFFE010 00C8 
FFFFE011 00D0 FFFB 
FFFFE013 00E6 0001 
FFFFE014 00CA 
FFFFE015 00D0 FFF6 
FFFFE017 004C E017 FFFF 

then we're all happy, and all we need to do is get this into a loader format, or into a ROM.

There is one function called with an index to a [type, value] pair whose job is to split apart 'value' according to 'type' and return an array of what amount to 8-bit byte values in the order desired. It's called by the listing routine, the raw binary output routine, the Intel Hex output routine and the Motorola SRecord output routine. The macro shown will create the above listing, albeit shown as pairs of 8-bit bytes. The first instruction from the above code would look like this in a listing:

Code:

FFFFE000 00 A9
FFFFE001 00 00

And that's the same sequence - '00A90000' - that will show up in an Intel or Motorola data record.

Quote:

In fact, it will be good to get that final step also from the assembler, but if you see that intermediate form clearly, especially as the format for listing, I don't think you'll have so much bother about byte order. It's just as natural as 6502, and as Garth has pointed out, just as natural as the nibbles in 6502 listings being MSB-first despite the bytes being LSB-first.

Indeed.

At this point I think the bare minimum that need be done is define a single new type - call it 'BYT16' - that has size one and takes the low 16 bits of its 32-bit value component when extracting. All instruction could be coded using just this, the same way all 6502 instructions could be coded using only 'BIT08' instructions. The use of other new types, larger and/or range-checked, are very handy but not necessary.

Still doesn't answer what to do about 'STRING', 'HEX', etc. I kind of like the idea of 'STRING16', 'HEX16', although at first I'd probably want to code them as macros to see how they play out in practice before making them native.

'STRING16' (or 'STRYNG' or something else entirely) might, for example, pad all strings to 16-bit bytes like this:

Code:

.macro STRYNG, ?str
]org$ = ?str
]new$ = ""
]ndx = 1
.repeat len(]org$)
]new$ = ]new$ mid$(]org$, ]ndx, 1) "\0"
]ndx = ]ndx + 1
.endr
.if ]new$
.string ]new$
.endif
.endmacro

which is then used like this:

Code:

stryng "Hello, World!"

That's pretty much my first impression of how such a thing would be implemented natively anyway. The point would simply to be see if that's useful, and if not, change it easily.

Top

BigEd

Post subject:

Posted: Sun Jun 05, 2011 11:36 am

Joined: Thu Dec 11, 2008 1:28 pm
Posts: 10837
Location: England

OK, sounds good! I'd recommend STRING16 because the 65Org32 would need a STRING32, and STRYNG doesn't offer a similar extension.

Is there a means to alias or redefine, so that in a 65Org16 context STRING would have the meaning STRING16? That would be even better.

In the case of HEX and similar, a couple of obvious use cases are jump tables and tables of numeric constants. Very typical, from Ross Archer's hex loader:

Code:

.org $FFFF_FFFA
NMIENT  .word     GONMI
RSTENT  .word     GORST
IRQENT  .word     GOIRQ

and then perhaps we might have two-word floating point constants:

Code:

.byte16 $8149,$0FDB ; 1.570796371 (pi/2) as floating #

(From Lee's EhBASIC)

On reflection, and with your example, I'm less worried about double evaluation because unlike C we don't have the problem of expressions with side-effects.

Cheers
Ed

Top

teamtempest

Post subject:

Posted: Sun Jun 05, 2011 7:17 pm

Joined: Sun Nov 08, 2009 1:56 am
Posts: 390
Location: Minnesota

BigEd wrote:

Is there a means to alias or redefine, so that in a 65Org16 context STRING would have the meaning STRING16? That would be even better.

Yes - and no. The 'PSALIAS' pseudo op can assign an alias to any pseudo op, but to avoid ambiguity it doesn't permit an alias to be the same as any existing pseudo op (or alias or macro name or global label). Perhaps it's stricter than it needs to be about that sort of thing, but the original idea was to make it easier to port source that used pseudo ops HXA doesn't know.

Another approach might be to maintain a flag somewhere that indicated whether or not to pad string characters out, and if so by how much (and perhaps with what). A new pseudo op ('MULTIBYTESTR'?) or an extension to the 'ASSUME' mechanism (which replaces a plethora of new pseudo ops with a plethora of new 'assumptions) might work, or it might be assigned as part of the task of initializing a particular CPU.

Top

BigEd

Post subject:

Posted: Sun Jun 05, 2011 7:33 pm

Joined: Thu Dec 11, 2008 1:28 pm
Posts: 10837
Location: England

Great - sounds like several possible solutions! As far as I can imagine, STRING should always place one octet from the source file into each target address, so any way to arrange that would be good. (The other methods of defining lists of constants should place one element into each address.)

ASSUME appeals, but the best choice might depend on the implementation details.

Cheers
Ed

Top

teamtempest

Post subject:

Posted: Sun Jun 12, 2011 4:00 am

Joined: Sun Nov 08, 2009 1:56 am
Posts: 390
Location: Minnesota

Okay, I have been thinking about this for a while now. The best way to approach this seems to be by using cpu initialization. I've experimentally extended the "T_PC_O" mechanism to be essentially a descriptor for most everything HXA needs to know about a CPU except for the instruction set.

So descriptors like these:

Code:

.cpu "T_16_L"

.cpu "T_16_L08"

are interpreted as "16-bit PC range, little-endian, 8-bit bytes". No byte size specified defaults to 8-bit bytes for backward compatability.

A descriptor for a 65Org16 looks like this:

Code:

.cpu "T_32_L16"

meaning 32-bit PC range, little-endian, 16-bit bytes.

The "-BIT--" data storage pseudo ops are dynamically created as part of initialization based on how many bits are in a byte. Eight-bit bytes create "-BIT08", "-BIT16", "-BIT24" and "-BIT32" pseudo ops, but a 16-bit byte creates only "-"BIT16" and "-BIT32" (attempts to use "-BIT08" and "-BIT24" will fail).

The size of a "-BIT--" pseudo op as far as the program counter is concerned is the number of bits it has divided by the number of bits in a byte. So "BIT16" with an eight-bit byte has size two, but with a 16-bit byte has size one.

The aliases "BYTE", "WORD" and "LONG" are dynamically assigned to the "-BIT--" pseudo ops with sizes one, two and four respectively. Since HXA can handle only 32-bit integers, not all of these are always available.

This is as far as I've gotten. Data storage pseudo ops are not yet adapted. Some are easy: "FILL" and "PADTO" simply multiply their size arguments by the size of a "byte" in eight-bit bytes. The simplest thing to do with "STRING" is zero-pad each eight-bit char out to the size of "byte", putting the char at the "left end" for an LSB processor and the "right end" for an MSB processor. I'm not quite sure yet what to do with "HEX" strings and "INCBIN" binary inclusions that are not multiples of the "byte" size (error? Silently pad? Pad with warning?)

I've also implemented 32-bit bytes, but (a) the only data storage pseudo ops are all "BYTE" variations, and (b) since only "bytes" are available, both LSB and MSB processors create the same sequences, ie., the actual physical order of eight-bit bytes is the same for both.

Anyway, I've got five files I'll post separately to show how it all works so far. The 65Org16 instruction set is implemented as macros - in fact I used an existing macro set for the 6502, only changing the cpu descriptor:

1) A macro definition source file
2) A 6502-instruction test source file ("includes" (1))
3) An assembly listing of (2)
4) A 65Org16-instruction test source file ("includes" (1))
5) An assembly listing of (4)

The idea being that (3) and (5) can be easily compared, and if (5) is what is wanted, it can be coded as a native instruction set in an HXA variant.

Top

teamtempest

Post subject:

Posted: Sun Jun 12, 2011 4:04 am

Joined: Sun Nov 08, 2009 1:56 am
Posts: 390
Location: Minnesota

Code:

; Hobby Cross-Assembler Processor Instruction Set
; Macro Implementation
; Processor: 6502

; by Anton Treuenfels

; first created: 06/26/06
; last revision: 06/11/11

;-----------------------------------------------

        .if ver() < $0180
        .fatal  "HXA version 0.180 or higher required"
        .endif

; ----------------------------

; this file implements the same instruction set for the 6502 as
; the HXA65 assembler, including extended instruction variants defined
; by Western Design Center (portable) and HXA65 (not portable)

; "forced address modes" (normally zero page modes to absolute and
; vice versa) are NOT supported, however additional macros having
; the same effect are not difficult to define
; (eg., LDAA could be defined to "Load Absolute Always")

; variable labels are used to:
; - reduce macro substitution
; - increase expression cache efficiency

; ----------------------------

        .if forward( "cpu65Org16" )

        .cpu    T_16_L08    ; 16-bit little-endian, 8-bit bytes
zp_mask .equ    $FFFFFF00   ; 256-byte zero page

        .else

        .cpu    T_32_L16    ; 32-bit little-endian, 16-bit bytes
zp_mask .equ    $FFFF0000   ; 64K "zero page"

        .endif

; ----------------------------

; reserved label names - macro expansion can change their values!!

]adr$   .equ    ""
]ndx$   .equ    ""
]opc    .equ    0

; ----------------------------
; Error Macros
; ----------------------------

        .macro badmode
        .error "Bad address mode"
        .endm

; ----------------------------
; Helper Macros
; ----------------------------

; store single address modes

        ; store immediate

        .macro  imm, ]opc
        .byte ]opc, val(mid$(]adr$, 2))
        .endm

        ; store program counter relative

        .macro pcr, ]opc, ?addr
        .byte ]opc
        .rbyte ?addr
        .endm

        ; store zero page

        .macro zp, ]opc
        .byte ]opc
        .ubyte val(]adr$)
        .endm

        ; store zero page x-indexed indirect

        .macro  zpxi
        .byte ]opc
        .ubyte val(mid$(]adr$,2,indexr(]adr$,",")-2))
        .endm

; distinguish between multiple possible address modes

        ; between absolute,y and zero page indirect y-indexed

        .macro  aby.zpiy, ]opc
        .if ]adr$ ~ /^\(.+\)$/
        .byte ]opc
        .ubyte val(]adr$)
        .else
        .byte ]opc+8
        .uword val(]adr$)
        .endif
        .endm

        ; between absolute and zero page
        ; - absolute if addr not resolvable or not on "zero page"

        .macro  ab.zp, ]opc
        .if forward(]adr$) || (val(]adr$) & zp_mask)
        .byte ]opc+8
        .uword val(]adr$)
        .else
        .byte ]opc
        .ubyte val(]adr$)
        .endif
        .endm

        ; between absolute, immediate, zero page
        ; and zero page x-indexed indirect

        .macro  ab.imm.zp.zpxi
        .if ]adr$ ~ /^#/
        imm ]opc+8
        .elseif ]adr$ ~ /^\(.+\,[ \t]*X[ \t]*\)$/i
        zpxi
        .else
        ab.zp ]opc+4
        .endif
        .endm

        ; between absolute, immediate and zero page

        .macro ab.imm.zp, ]opc
        .if ]adr$ ~ /^#/
        imm ]opc
        .else
        ab.zp ]opc+4
        .endif
        .endm

        ; between absolute, absolute,x, zero page and zero page,x

        .macro  ab.abx.zp.zpx, ]opc, ]adr$, ]ndx$
        if ]ndx$ ~ /^[X@]$/i
        ab.zp ]ndx$ == "@" ? ]opc : ]opc+16
        .else
        badmode
        .endif
        .endm

        ; between absolute, accumulator and zero page

        .macro ab.acc.zp
        .if ]adr$ ~ /^A$/i
        .byte ]opc+4
        .else
        ab.zp ]opc
        .endif
        .endm

; distinguish shared address class possibilities

        ; "arithmetic-logic" class (load/store, too)

        .macro  arith.logic, ]opc, ]adr$, ]ndx$
        .if ]ndx$ ~ /^Y$/i
        aby.zpiy ]opc+16
        .elseif ]ndx$ ~ /^X$/i
        ab.zp ]opc+20
        .elseif ]ndx$ == "@"
        ab.imm.zp.zpxi
        .else
        badmode
        .endif
        .endm

        ; "shift" class

        .macro  shift, ]opc, ]adr$, ]ndx$
        .if ]ndx$ ~ /^X$/i
        ab.zp ]opc+16
        .elseif ]ndx$ == "@"
        ab.acc.zp
        .else
        badmode
        .endif
        .endm

; ----------------------------
; Processor Instruction Macros
; ----------------------------

        .macro  ADC, ?addr, ?ndx=@
        arith.logic $61, "?addr", "?ndx"
        .endm

        .macro  AND, ?addr, ?ndx=@
        arith.logic $21, "?addr", "?ndx"
        .endm

        .macro  ASL, ?addr=A, ?ndx=@
        shift $06, "?addr", "?ndx"
        .endm

        .macro  BCC, ?addr
        pcr $90, ?addr
        .endm

        .macro  BCS, ?addr
        pcr $B0, ?addr
        .endm

        .macro  BEQ, ?addr
        pcr $F0, ?addr
        .endm

        .macro  BGE, ?addr      ; (wdc)
        pcr $B0, ?addr
        .endm

        .macro  BIT, ?addr
]adr$   .equ "?addr"
        ab.zp $24
        .endm

        .macro  BLT, ?addr      ; (wdc)
        pcr $90, ?addr
        .endm

        .macro  BMI, ?addr
        pcr $30, ?addr
        .endm

        .macro  BNE, ?addr
        pcr $D0, ?addr
        .endm

        .macro  BPL, ?addr
        pcr $10, ?addr
        .endm

        .macro  BRK, ?addr=@    ; (hxa)
]adr$   .equ "?addr"
        .if ]adr$ == "@"
        .byte $00
        .elseif ]adr$ ~ /^#/
        imm $00
        .else
        zp $00
        .endif
        .endm

        .macro  BVC, ?addr
        pcr $50, ?addr
        .endm

        .macro  BVS, ?addr
        pcr $70, ?addr
        .endm

        .macro  CLC
        .byte $18
        .endm

        .macro  CLD
        .byte $D8
        .endm

        .macro  CLI
        .byte $58
        .endm

        .macro  CLV
        .byte $B8
        .endm

        .macro  CMP, ?addr, ?ndx=@
        arith.logic $C1, "?addr", "?ndx"
        .endm

        .macro  CPX, ?addr
]adr$   .equ "?addr"
        ab.imm.zp $E0
        .endm

        .macro  CPY, ?addr
]adr$   .equ "?addr"
        ab.imm.zp $C0
        .endm

        .macro  DEC, ?addr, ?ndx=@
        ab.abx.zp.zpx $C6, "?addr", "?ndx"
        .endm

        .macro  DEX
        .byte $CA
        .endm

        .macro  DEY
        .byte $88
        .endm

        .macro  EOR, ?addr, ?ndx=@
        arith.logic $41, "?addr", "?ndx"
        .endm

        .macro  INC, ?addr, ?ndx=@
        ab.abx.zp.zpx $E6, "?addr", "?ndx"
        .endm

        .macro  INX
        .byte $E8
        .endm

        .macro  INY
        .byte $C8
        .endm

        .macro  JMP, ?addr
]adr$   .equ "?addr"
        .byte ]adr$ ~ /^\(.+\)$/ ? $6C : $4C
        .uword val(]adr$)
        .endm

        .macro  JSR, ?addr
        .byte $20
        .uword ?addr
        .endm

        .macro  LDA, ?addr, ?ndx=@
        arith.logic $A1, "?addr", "?ndx"
        .endm

        .macro  LDX, ?addr, ?ndx=@
]adr$   .equ "?addr"
]ndx$   .equ "?ndx"
        .if ]ndx$ ~ /^Y$/i
        ab.zp $B6
        .elseif ]ndx$ == "@"
        ab.imm.zp $A2
        .else
        badmode
        .endif
        .endm

        .macro  LDY, ?addr, ?ndx=@
]adr$   .equ "?addr"
]ndx$   .equ "?ndx"
        .if ]ndx$ ~ /^X$/i
        ab.zp $B4
        .elseif ]ndx$ == "@"
        ab.imm.zp $A0
        .else
        badmode
        .endif
        .endm

        .macro LSR, ?addr=A, ?ndx=@
        shift $46, "?addr", "?ndx"
        .endm

        .macro  NOP
        .byte $EA
        .endm

        .macro  ORA, ?addr, ?ndx=@
        arith.logic $01, "?addr", "?ndx"
        .endm

        .macro  PHA
        .byte $48
        .endm

        .macro  PHP
        .byte $08
        .endm

        .macro  PLA
        .byte $68
        .endm

        .macro  PLP
        .byte $28
        .endm

        .macro  ROL, ?addr=A, ?ndx=@
        shift $26, "?addr", "?ndx"
        .endm

        .macro  ROR, ?addr=A, ?ndx=@
        shift $66, "?addr", "?ndx"
        .endm

        .macro  RTI
        .byte $40
        .endm

        .macro  RTS
        .byte $60
        .endm

        .macro  SBC, ?addr, ?ndx=@
        arith.logic $E1, "?addr", "?ndx"
        .endm

        .macro  SEC
        .byte $38
        .endm

        .macro  SED
        .byte $F8
        .endm

        .macro  SEI
        .byte $78
        .endm

        .macro  STA, ?addr, ?ndx=@
]adr$   .equ "?addr"
        .if ]adr$ !~ /^#/
        arith.logic $81, "?addr", "?ndx"
        .else
        badmode
        .endif
        .endm

        .macro  STX, ?addr, ?ndx=@
]adr$   .equ "?addr"
]ndx$   .equ "?ndx"
        .if ]ndx$ ~ /^Y$/i
        zp $96
        .elseif ]ndx$ == "@"
        ab.zp $86
        .else
        badmode
        .endif
        .endm

        .macro  STY, ?addr, ?ndx=@
]adr$   .equ "?addr"
]ndx$   .equ "?ndx"
        .if ]ndx$ ~ /^X$/i
        zp $94
        .elseif ]ndx$ == "@"
        ab.zp $84
        .else
        badmode
        .endif
        .endm

        .macro  TAX
        .byte $AA
        .endm

        .macro  TAY
        .byte $A8
        .endm

        .macro  TSX
        .byte $BA
        .endm

        .macro  TXA
        .byte $8A
        .endm

        .macro  TXS
        .byte $9A
        .endm

        .macro  TYA
        .byte $98
        .endm

; ----------------------------

Top

teamtempest

Post subject:

Posted: Sun Jun 12, 2011 4:06 am

Joined: Sun Nov 08, 2009 1:56 am
Posts: 390
Location: Minnesota

Code:

; Hobby Cross-Assembler Demo 034
; Macro Instruction Set\6502
; ok: 6502 instruction set

; by Anton Treuenfels

; first created: 06/29/06
; last revised:  06/19/07

; no errors to detect

        .listfile
        .errfile

; -------------------------------

        .listoff    includes
        .liston     stats

        .include "i6502.a"

;        .cpu    "6502"      ; required psop
        .org    $1000       ; required psop

; -------------------------------

; backward reference

bakbyt  .equ    $12
bakwrd  .equ    $1234

; a simple test of all legal instructions using legal address modes
; - no complicated expressions
; - references to "fwdbyt" in contexts where both zero-page and absolute
; modes are possible are resolved as absolute

; some instructions produce the same code but use
; a different mnemonic or syntax:
; - "(wdc)" = WDC-recommended (fairly portable)
; - "(hxa)" = HXA-specific (not portable)

        ADC     $1234       ; ab
        ADC     bakwrd
        ADC     fwdwrd
        ADC     $1234,x     ; abx
        ADC     bakwrd,x
        ADC     fwdwrd,x
        ADC     $1234,y     ; aby
        ADC     bakwrd,y
        ADC     fwdwrd,y
        ADC     #$12        ; imm
        ADC     #bakbyt
        ADC     #fwdbyt
        ADC     $12         ; zp
        ADC     bakbyt
        ADC     fwdbyt
        ADC     ($12),y     ; zpiy
        ADC     (bakbyt),y
        ADC     (fwdbyt),y
        ADC     $12,x       ; zpx
        ADC     bakbyt,x
        ADC     fwdbyt,x
        ADC     ($12,x)     ; zpxi
        ADC     (bakbyt,x)
        ADC     (fwdbyt,x)

        AND     $1234       ; ab
        AND     bakwrd
        AND     fwdwrd
        AND     $1234,x     ; abx
        AND     bakwrd,x
        AND     fwdwrd,x
        AND     $1234,y     ; aby
        AND     bakwrd,y
        AND     fwdwrd,y
        AND     #$12        ; imm
        AND     #bakbyt
        AND     #fwdbyt
        AND     $12         ; zp
        AND     bakbyt
        AND     fwdbyt
        AND     ($12),y     ; zpiy
        AND     (bakbyt),y
        AND     (fwdbyt),y
        AND     $12,x       ; zpx
        AND     bakbyt,x
        AND     fwdbyt,x
        AND     ($12,x)     ; zpxi
        AND     (bakbyt,x)
        AND     (fwdbyt,x)

        ASL     $1234       ; ab
        ASL     bakwrd
        ASL     fwdwrd
        ASL     $1234,x     ; abx
        ASL     bakwrd,x
        ASL     fwdwrd,x
        ASL                 ; acc
        ASL     a           ; acc
        ASL     $12         ; zp
        ASL     bakbyt
        ASL     fwdbyt
        ASL     $12,x       ; zpx
        ASL     bakbyt,x
        ASL     fwdbyt,x

baktarget:

        BCC     baktarget   ; rel
        BCC     fwdtarget

        BCS     baktarget   ; rel
        BCS     fwdtarget

        BEQ     baktarget   ; rel
        BEQ     fwdtarget

        BGE     baktarget   ; rel (wdc)
        BGE     fwdtarget

        BIT     $1234       ; ab
        BIT     bakwrd
        BIT     fwdwrd
        BIT     $12         ; zp
        BIT     bakbyt
        BIT     fwdbyt

        BLT     baktarget   ; rel (wdc)
        BLT     fwdtarget

        BMI     baktarget   ; rel
        BMI     fwdtarget

        BNE     baktarget   ; rel
        BNE     fwdtarget

        BPL     baktarget   ; rel
        BPL     fwdtarget

        BRK     #$12        ; imm (hxa)
        BRK     #bakbyt
        BRK     #fwdbyt
        BRK                 ; imp
        BRK     $12         ; zp (hxa)
        BRK     bakbyt
        BRK     fwdbyt

        BVC     baktarget   ; rel
        BVC     fwdtarget

        BVS     baktarget   ; rel
        BVS     fwdtarget

fwdtarget:

        CLC                 ; imp

        CLD                 ; imp

        CLI                 ; imp

        CLV                 ; imp

        CMP     $1234       ; ab
        CMP     bakwrd
        CMP     fwdwrd
        CMP     $1234,x     ; abx
        CMP     bakwrd,x
        CMP     fwdwrd,x
        CMP     $1234,y     ; aby
        CMP     bakwrd,y
        CMP     fwdwrd,y
        CMP     #$12        ; imm
        CMP     #bakbyt
        CMP     #fwdbyt
        CMP     $12         ; zp
        CMP     bakbyt
        CMP     fwdbyt
        CMP     ($12),y     ; zpiy
        CMP     (bakbyt),y
        CMP     (fwdbyt),y
        CMP     $12,x       ; zpx
        CMP     bakbyt,x
        CMP     fwdbyt,x
        CMP     ($12,x)     ; zpxi
        CMP     (bakbyt,x)
        CMP     (fwdbyt,x)

        CPX     $1234       ; ab
        CPX     bakwrd
        CPX     fwdwrd
        CPX     #$12        ; imm
        CPX     #bakbyt
        CPX     #fwdbyt
        CPX     $12         ; zp
        CPX     bakbyt
        CPX     fwdbyt

        CPY     $1234       ; ab
        CPY     bakwrd
        CPY     fwdwrd
        CPY     #$12        ; imm
        CPY     #bakbyt
        CPY     #fwdbyt
        CPY     $12         ; zp
        CPY     bakbyt
        CPY     fwdbyt

        DEC     $1234       ; ab
        DEC     bakwrd
        DEC     fwdwrd
        DEC     $1234,x     ; abx
        DEC     bakwrd,x
        DEC     fwdwrd,x
        DEC     $12         ; zp
        DEC     bakbyt
        DEC     fwdbyt
        DEC     $12,x       ; zpx
        DEC     bakbyt,x
        DEC     fwdbyt,x
        
        DEX                 ; imp

        DEY                 ; imp

        EOR     $1234       ; ab
        EOR     bakwrd
        EOR     fwdwrd
        EOR     $1234,x     ; abx
        EOR     bakwrd,x
        EOR     fwdwrd,x
        EOR     $1234,y     ; aby
        EOR     bakwrd,y
        EOR     fwdwrd,y
        EOR     #$12        ; imm
        EOR     #bakbyt
        EOR     #fwdbyt
        EOR     $12         ; zp
        EOR     bakbyt
        EOR     fwdbyt
        EOR     ($12),y     ; zpiy
        EOR     (bakbyt),y
        EOR     (fwdbyt),y
        EOR     $12,x       ; zpx
        EOR     bakbyt,x
        EOR     fwdbyt,x
        EOR     ($12,x)     ; zpxi
        EOR     (bakbyt,x)
        EOR     (fwdbyt,x)

        INC     $1234       ; ab
        INC     bakwrd
        INC     fwdwrd
        INC     $1234,x     ; abx
        INC     bakwrd,x
        INC     fwdwrd,x
        INC     $12         ; zp
        INC     bakbyt
        INC     fwdbyt
        INC     $12,x       ; zpx
        INC     bakbyt,x
        INC     fwdbyt,x
        
        INX                 ; imp

        INY                 ; imp

        JMP     $1234       ; ab
        JMP     bakwrd
        JMP     fwdwrd
        JMP     ($1234)     ; abi
        JMP     (bakwrd)
        JMP     (fwdwrd)

        JSR     $1234       ; ab
        JSR     bakwrd
        JSR     fwdwrd

        LDA     $1234       ; ab
        LDA     bakwrd
        LDA     fwdwrd
        LDA     $1234,x     ; abx
        LDA     bakwrd,x
        LDA     fwdwrd,x
        LDA     $1234,y     ; aby
        LDA     bakwrd,y
        LDA     fwdwrd,y
        LDA     #$12        ; imm
        LDA     #bakbyt
        LDA     #fwdbyt
        LDA     $12         ; zp
        LDA     bakbyt
        LDA     fwdbyt
        LDA     ($12),y     ; zpiy
        LDA     (bakbyt),y
        LDA     (fwdbyt),y
        LDA     $12,x       ; zpx
        LDA     bakbyt,x
        LDA     fwdbyt,x
        LDA     ($12,x)     ; zpxi
        LDA     (bakbyt,x)
        LDA     (fwdbyt,x)

        LDX     $1234       ; ab
        LDX     bakwrd
        LDX     fwdwrd
        LDX     $1234,y     ; aby
        LDX     bakwrd,y
        LDX     fwdwrd,y
        LDX     #12         ; imm
        LDX     #bakbyt
        LDX     #fwdbyt
        LDX     $12         ; zp
        LDX     bakbyt
        LDX     fwdbyt
        LDX     $12,y       ; zpy
        LDX     bakbyt,y
        LDX     fwdbyt,y

        LDY     $1234       ; ab
        LDY     bakwrd
        LDY     fwdwrd
        LDY     $1234,x     ; abx
        LDY     bakwrd,x
        LDY     fwdwrd,x
        LDY     #12         ; imm
        LDY     #bakbyt
        LDY     #fwdbyt
        LDY     $12         ; zp
        LDY     bakbyt
        LDY     fwdbyt
        LDY     $12,x       ; zpx
        LDY     bakbyt,x
        LDY     fwdbyt,x

        LSR     $1234       ; ab
        LSR     bakwrd
        LSR     fwdwrd
        LSR     $1234,x     ; abx
        LSR     bakwrd,x
        LSR     fwdwrd,x
        LSR                 ; acc
        LSR     a           ; acc
        LSR     $12         ; zp
        LSR     bakbyt
        LSR     fwdbyt
        LSR     $12,x       ; zpx
        LSR     bakbyt,x
        LSR     fwdbyt,x

        NOP                 ; imp

        ORA     $1234       ; ab
        ORA     bakwrd
        ORA     fwdwrd
        ORA     $1234,x     ; abx
        ORA     bakwrd,x
        ORA     fwdwrd,x
        ORA     $1234,y     ; aby
        ORA     bakwrd,y
        ORA     fwdwrd,y
        ORA     #$12        ; imm
        ORA     #bakbyt
        ORA     #fwdbyt
        ORA     $12         ; zp
        ORA     bakbyt
        ORA     fwdbyt
        ORA     ($12),y     ; zpiy
        ORA     (bakbyt),y
        ORA     (fwdbyt),y
        ORA     $12,x       ; zpx
        ORA     bakbyt,x
        ORA     fwdbyt,x
        ORA     ($12,x)     ; zpxi
        ORA     (bakbyt,x)
        ORA     (fwdbyt,x)

        PHA                 ; imp

        PHP                 ; imp

        PLA                 ; imp

        PLP                 ; imp

        ROL     $1234       ; ab
        ROL     bakwrd
        ROL     fwdwrd
        ROL     $1234,x     ; abx
        ROL     bakwrd,x
        ROL     fwdwrd,x
        ROL                 ; acc
        ROL     a           ; acc
        ROL     $12         ; zp
        ROL     bakbyt
        ROL     fwdbyt
        ROL     $12,x       ; zpx
        ROL     bakbyt,x
        ROL     fwdbyt,x

        ROR     $1234       ; ab
        ROR     bakwrd
        ROR     fwdwrd
        ROR     $1234,x     ; abx
        ROR     bakwrd,x
        ROR     fwdwrd,x
        ROR                 ; acc
        ROR     a           ; acc
        ROR     $12         ; zp
        ROR     bakbyt
        ROR     fwdbyt
        ROR     $12,x       ; zpx
        ROR     bakbyt,x
        ROR     fwdbyt,x

        RTI                 ; imp

        RTS                 ; imp

        SBC     $1234       ; ab
        SBC     bakwrd
        SBC     fwdwrd
        SBC     $1234,x     ; abx
        SBC     bakwrd,x
        SBC     fwdwrd,x
        SBC     $1234,y     ; aby
        SBC     bakwrd,y
        SBC     fwdwrd,y
        SBC     #$12        ; imm
        SBC     #bakbyt
        SBC     #fwdbyt
        SBC     $12         ; zp
        SBC     bakbyt
        SBC     fwdbyt
        SBC     ($12),y     ; zpiy
        SBC     (bakbyt),y
        SBC     (fwdbyt),y
        SBC     $12,x       ; zpx
        SBC     bakbyt,x
        SBC     fwdbyt,x
        SBC     ($12,x)     ; zpxi
        SBC     (bakbyt,x)
        SBC     (fwdbyt,x)

        SEC                 ; imp

        SED                 ; imp

        SEI                 ; imp

        STA     $1234       ; ab
        STA     bakwrd
        STA     fwdwrd
        STA     $1234,x     ; abx
        STA     bakwrd,x
        STA     fwdwrd,x
        STA     $1234,y     ; aby
        STA     bakwrd,y
        STA     fwdwrd,y
        STA     $12         ; zp
        STA     bakbyt
        STA     fwdbyt
        STA     ($12),y     ; zpiy
        STA     (bakbyt),y
        STA     (fwdbyt),y
        STA     $12,x       ; zpx
        STA     bakbyt,x
        STA     fwdbyt,x
        STA     ($12,x)     ; zpxi
        STA     (bakbyt,x)
        STA     (fwdbyt,x)

        STX     $1234       ; ab
        STX     bakwrd
        STX     fwdwrd
        STX     $12         ; zp
        STX     bakbyt
        STX     fwdbyt
        STX     $12,y       ; zpy
        STX     bakbyt,y
        STX     fwdbyt,y

        STY     $1234       ; ab
        STY     bakwrd
        STY     fwdwrd
        STY     $12         ; zp
        STY     bakbyt
        STY     fwdbyt
        STY     $12,x       ; zpx
        STY     bakbyt,x
        STY     fwdbyt,x

        TAX                 ; imp

        TAY                 ; imp

        TSX                 ; imp

        TXA                 ; imp

        TXS                 ; imp

        TYA                 ; imp

; forward reference

fwdbyt  .equ    $12
fwdwrd  .equ    $1234

; -------------------------------

        .end

Top

teamtempest

Post subject:

Posted: Sun Jun 12, 2011 4:08 am

Joined: Sun Nov 08, 2009 1:56 am
Posts: 390
Location: Minnesota

Code:

HXA v0.180 Listing File - T_16_L08 Instruction Set - Sat Jun 11 20:53:27 
                   2011

*** Object Code Listing

                   ; Hobby Cross-Assembler Demo 034
                   ; Macro Instruction Set\6502
                   ; ok: 6502 instruction set

                   ; by Anton Treuenfels

                   ; first created: 06/29/06
                   ; last revised:  06/19/07

                   ; no errors to detect

                           .listfile
                           .errfile

                   ; -------------------------------

                           .listoff    includes
                           .liston     stats

                           .include "i6502.a"

                   ;        .cpu    "6502"      ; required psop
                           .org    $1000       ; required psop

                   ; -------------------------------

                   ; backward reference

                   bakbyt  .equ    $12
                   bakwrd  .equ    $1234

                   ; a simple test of all legal instructions using legal 
                   address modes
                   ; - no complicated expressions
                   ; - references to "fwdbyt" in contexts where both 
                   zero-page and absolute
                   ; modes are possible are resolved as absolute

                   ; some instructions produce the same code but use
                   ; a different mnemonic or syntax:
                   ; - "(wdc)" = WDC-recommended (fairly portable)
                   ; - "(hxa)" = HXA-specific (not portable)

                           ADC     $1234       ; ab
^1000  6D                  .byte ]opc+8
^1001  34 12               .uword val(]adr$)
                           ADC     bakwrd
^1003  6D                  .byte ]opc+8
^1004  34 12               .uword val(]adr$)
                           ADC     fwdwrd
^1006  6D                  .byte ]opc+8
^1007  34 12               .uword val(]adr$)
                           ADC     $1234,x     ; abx
^1009  7D                  .byte ]opc+8
^100A  34 12               .uword val(]adr$)
                           ADC     bakwrd,x
^100C  7D                  .byte ]opc+8
^100D  34 12               .uword val(]adr$)
                           ADC     fwdwrd,x
^100F  7D                  .byte ]opc+8
^1010  34 12               .uword val(]adr$)
                           ADC     $1234,y     ; aby
^1012  79                  .byte ]opc+8
^1013  34 12               .uword val(]adr$)
                           ADC     bakwrd,y
^1015  79                  .byte ]opc+8
^1016  34 12               .uword val(]adr$)
                           ADC     fwdwrd,y
^1018  79                  .byte ]opc+8
^1019  34 12               .uword val(]adr$)
                           ADC     #$12        ; imm
^101B  69                  .byte ]opc, val(mid$(]adr$, 2))
^101C  12
                           ADC     #bakbyt
^101D  69                  .byte ]opc, val(mid$(]adr$, 2))
^101E  12
                           ADC     #fwdbyt
^101F  69                  .byte ]opc, val(mid$(]adr$, 2))
^1020  12
                           ADC     $12         ; zp
^1021  65                  .byte ]opc
^1022  12                  .ubyte val(]adr$)
                           ADC     bakbyt
^1023  65                  .byte ]opc
^1024  12                  .ubyte val(]adr$)
                           ADC     fwdbyt
^1025  6D                  .byte ]opc+8
^1026  12 00               .uword val(]adr$)
                           ADC     ($12),y     ; zpiy
^1028  71                  .byte ]opc
^1029  12                  .ubyte val(]adr$)
                           ADC     (bakbyt),y
^102A  71                  .byte ]opc
^102B  12                  .ubyte val(]adr$)
                           ADC     (fwdbyt),y
^102C  71                  .byte ]opc
^102D  12                  .ubyte val(]adr$)
                           ADC     $12,x       ; zpx
^102E  75                  .byte ]opc
^102F  12                  .ubyte val(]adr$)
                           ADC     bakbyt,x
^1030  75                  .byte ]opc
^1031  12                  .ubyte val(]adr$)
                           ADC     fwdbyt,x
^1032  7D                  .byte ]opc+8
^1033  12 00               .uword val(]adr$)
                           ADC     ($12,x)     ; zpxi
^1035  61                  .byte ]opc
^1036  12                  .ubyte val(mid$(]adr$,2,indexr(]adr$,",")-2))
                           ADC     (bakbyt,x)
^1037  61                  .byte ]opc
^1038  12                  .ubyte val(mid$(]adr$,2,indexr(]adr$,",")-2))
                           ADC     (fwdbyt,x)
^1039  61                  .byte ]opc
^103A  12                  .ubyte val(mid$(]adr$,2,indexr(]adr$,",")-2))

                           AND     $1234       ; ab
^103B  2D                  .byte ]opc+8
^103C  34 12               .uword val(]adr$)
                           AND     bakwrd
^103E  2D                  .byte ]opc+8
^103F  34 12               .uword val(]adr$)
                           AND     fwdwrd
^1041  2D                  .byte ]opc+8
^1042  34 12               .uword val(]adr$)
                           AND     $1234,x     ; abx
^1044  3D                  .byte ]opc+8
^1045  34 12               .uword val(]adr$)
                           AND     bakwrd,x
^1047  3D                  .byte ]opc+8
^1048  34 12               .uword val(]adr$)
                           AND     fwdwrd,x
^104A  3D                  .byte ]opc+8
^104B  34 12               .uword val(]adr$)
                           AND     $1234,y     ; aby
^104D  39                  .byte ]opc+8
^104E  34 12               .uword val(]adr$)
                           AND     bakwrd,y
^1050  39                  .byte ]opc+8
^1051  34 12               .uword val(]adr$)
                           AND     fwdwrd,y
^1053  39                  .byte ]opc+8
^1054  34 12               .uword val(]adr$)
                           AND     #$12        ; imm
^1056  29                  .byte ]opc, val(mid$(]adr$, 2))
^1057  12
                           AND     #bakbyt
^1058  29                  .byte ]opc, val(mid$(]adr$, 2))
^1059  12
                           AND     #fwdbyt
^105A  29                  .byte ]opc, val(mid$(]adr$, 2))
^105B  12
                           AND     $12         ; zp
^105C  25                  .byte ]opc
^105D  12                  .ubyte val(]adr$)
                           AND     bakbyt
^105E  25                  .byte ]opc
^105F  12                  .ubyte val(]adr$)
                           AND     fwdbyt
^1060  2D                  .byte ]opc+8
^1061  12 00               .uword val(]adr$)
                           AND     ($12),y     ; zpiy
^1063  31                  .byte ]opc
^1064  12                  .ubyte val(]adr$)
                           AND     (bakbyt),y
^1065  31                  .byte ]opc
^1066  12                  .ubyte val(]adr$)
                           AND     (fwdbyt),y
^1067  31                  .byte ]opc
^1068  12                  .ubyte val(]adr$)
                           AND     $12,x       ; zpx
^1069  35                  .byte ]opc
^106A  12                  .ubyte val(]adr$)
                           AND     bakbyt,x
^106B  35                  .byte ]opc
^106C  12                  .ubyte val(]adr$)
                           AND     fwdbyt,x
^106D  3D                  .byte ]opc+8
^106E  12 00               .uword val(]adr$)
                           AND     ($12,x)     ; zpxi
^1070  21                  .byte ]opc
^1071  12                  .ubyte val(mid$(]adr$,2,indexr(]adr$,",")-2))
                           AND     (bakbyt,x)
^1072  21                  .byte ]opc
^1073  12                  .ubyte val(mid$(]adr$,2,indexr(]adr$,",")-2))
                           AND     (fwdbyt,x)
^1074  21                  .byte ]opc
^1075  12                  .ubyte val(mid$(]adr$,2,indexr(]adr$,",")-2))

                           ASL     $1234       ; ab
^1076  0E                  .byte ]opc+8
^1077  34 12               .uword val(]adr$)
                           ASL     bakwrd
^1079  0E                  .byte ]opc+8
^107A  34 12               .uword val(]adr$)
                           ASL     fwdwrd
^107C  0E                  .byte ]opc+8
^107D  34 12               .uword val(]adr$)
                           ASL     $1234,x     ; abx
^107F  1E                  .byte ]opc+8
^1080  34 12               .uword val(]adr$)
                           ASL     bakwrd,x
^1082  1E                  .byte ]opc+8
^1083  34 12               .uword val(]adr$)
                           ASL     fwdwrd,x
^1085  1E                  .byte ]opc+8
^1086  34 12               .uword val(]adr$)
                           ASL                 ; acc
^1088  0A                  .byte ]opc+4
                           ASL     a           ; acc
^1089  0A                  .byte ]opc+4
                           ASL     $12         ; zp
^108A  06                  .byte ]opc
^108B  12                  .ubyte val(]adr$)
                           ASL     bakbyt
^108C  06                  .byte ]opc
^108D  12                  .ubyte val(]adr$)
                           ASL     fwdbyt
^108E  0E                  .byte ]opc+8
^108F  12 00               .uword val(]adr$)
                           ASL     $12,x       ; zpx
^1091  16                  .byte ]opc
^1092  12                  .ubyte val(]adr$)
                           ASL     bakbyt,x
^1093  16                  .byte ]opc
^1094  12                  .ubyte val(]adr$)
                           ASL     fwdbyt,x
^1095  1E                  .byte ]opc+8
^1096  12 00               .uword val(]adr$)

                   baktarget:

                           BCC     baktarget   ; rel
^1098  90                  .byte ]opc
^1099  FE                  .rbyte baktarget
                           BCC     fwdtarget
^109A  90                  .byte ]opc
^109B  41                  .rbyte fwdtarget

                           BCS     baktarget   ; rel
^109C  B0                  .byte ]opc
^109D  FA                  .rbyte baktarget
                           BCS     fwdtarget
^109E  B0                  .byte ]opc
^109F  3D                  .rbyte fwdtarget

                           BEQ     baktarget   ; rel
^10A0  F0                  .byte ]opc
^10A1  F6                  .rbyte baktarget
                           BEQ     fwdtarget
^10A2  F0                  .byte ]opc
^10A3  39                  .rbyte fwdtarget

                           BGE     baktarget   ; rel (wdc)
^10A4  B0                  .byte ]opc
^10A5  F2                  .rbyte baktarget
                           BGE     fwdtarget
^10A6  B0                  .byte ]opc
^10A7  35                  .rbyte fwdtarget

                           BIT     $1234       ; ab
^10A8  2C                  .byte ]opc+8
^10A9  34 12               .uword val(]adr$)
                           BIT     bakwrd
^10AB  2C                  .byte ]opc+8
^10AC  34 12               .uword val(]adr$)
                           BIT     fwdwrd
^10AE  2C                  .byte ]opc+8
^10AF  34 12               .uword val(]adr$)
                           BIT     $12         ; zp
^10B1  24                  .byte ]opc
^10B2  12                  .ubyte val(]adr$)
                           BIT     bakbyt
^10B3  24                  .byte ]opc
^10B4  12                  .ubyte val(]adr$)
                           BIT     fwdbyt
^10B5  2C                  .byte ]opc+8
^10B6  12 00               .uword val(]adr$)

                           BLT     baktarget   ; rel (wdc)
^10B8  90                  .byte ]opc
^10B9  DE                  .rbyte baktarget
                           BLT     fwdtarget
^10BA  90                  .byte ]opc
^10BB  21                  .rbyte fwdtarget

                           BMI     baktarget   ; rel
^10BC  30                  .byte ]opc
^10BD  DA                  .rbyte baktarget
                           BMI     fwdtarget
^10BE  30                  .byte ]opc
^10BF  1D                  .rbyte fwdtarget

                           BNE     baktarget   ; rel
^10C0  D0                  .byte ]opc
^10C1  D6                  .rbyte baktarget
                           BNE     fwdtarget
^10C2  D0                  .byte ]opc
^10C3  19                  .rbyte fwdtarget

                           BPL     baktarget   ; rel
^10C4  10                  .byte ]opc
^10C5  D2                  .rbyte baktarget
                           BPL     fwdtarget
^10C6  10                  .byte ]opc
^10C7  15                  .rbyte fwdtarget

                           BRK     #$12        ; imm (hxa)
^10C8  00                  .byte ]opc, val(mid$(]adr$, 2))
^10C9  12
                           BRK     #bakbyt
^10CA  00                  .byte ]opc, val(mid$(]adr$, 2))
^10CB  12
                           BRK     #fwdbyt
^10CC  00                  .byte ]opc, val(mid$(]adr$, 2))
^10CD  12
                           BRK                 ; imp
^10CE  00                  .byte $00
                           BRK     $12         ; zp (hxa)
^10CF  00                  .byte ]opc
^10D0  12                  .ubyte val(]adr$)
                           BRK     bakbyt
^10D1  00                  .byte ]opc
^10D2  12                  .ubyte val(]adr$)
                           BRK     fwdbyt
^10D3  00                  .byte ]opc
^10D4  12                  .ubyte val(]adr$)

                           BVC     baktarget   ; rel
^10D5  50                  .byte ]opc
^10D6  C1                  .rbyte baktarget
                           BVC     fwdtarget
^10D7  50                  .byte ]opc
^10D8  04                  .rbyte fwdtarget

                           BVS     baktarget   ; rel
^10D9  70                  .byte ]opc
^10DA  BD                  .rbyte baktarget
                           BVS     fwdtarget
^10DB  70                  .byte ]opc
^10DC  00                  .rbyte fwdtarget

                   fwdtarget:

                           CLC                 ; imp
^10DD  18                  .byte $18

                           CLD                 ; imp
^10DE  D8                  .byte $D8

                           CLI                 ; imp
^10DF  58                  .byte $58

                           CLV                 ; imp
^10E0  B8                  .byte $B8

                           CMP     $1234       ; ab
^10E1  CD                  .byte ]opc+8
^10E2  34 12               .uword val(]adr$)
                           CMP     bakwrd
^10E4  CD                  .byte ]opc+8
^10E5  34 12               .uword val(]adr$)
                           CMP     fwdwrd
^10E7  CD                  .byte ]opc+8
^10E8  34 12               .uword val(]adr$)
                           CMP     $1234,x     ; abx
^10EA  DD                  .byte ]opc+8
^10EB  34 12               .uword val(]adr$)
                           CMP     bakwrd,x
^10ED  DD                  .byte ]opc+8
^10EE  34 12               .uword val(]adr$)
                           CMP     fwdwrd,x
^10F0  DD                  .byte ]opc+8
^10F1  34 12               .uword val(]adr$)
                           CMP     $1234,y     ; aby
^10F3  D9                  .byte ]opc+8
^10F4  34 12               .uword val(]adr$)
                           CMP     bakwrd,y
^10F6  D9                  .byte ]opc+8
^10F7  34 12               .uword val(]adr$)
                           CMP     fwdwrd,y
^10F9  D9                  .byte ]opc+8
^10FA  34 12               .uword val(]adr$)
                           CMP     #$12        ; imm
^10FC  C9                  .byte ]opc, val(mid$(]adr$, 2))
^10FD  12
                           CMP     #bakbyt
^10FE  C9                  .byte ]opc, val(mid$(]adr$, 2))
^10FF  12
                           CMP     #fwdbyt
^1100  C9                  .byte ]opc, val(mid$(]adr$, 2))
^1101  12
                           CMP     $12         ; zp
^1102  C5                  .byte ]opc
^1103  12                  .ubyte val(]adr$)
                           CMP     bakbyt
^1104  C5                  .byte ]opc
^1105  12                  .ubyte val(]adr$)
                           CMP     fwdbyt
^1106  CD                  .byte ]opc+8
^1107  12 00               .uword val(]adr$)
                           CMP     ($12),y     ; zpiy
^1109  D1                  .byte ]opc
^110A  12                  .ubyte val(]adr$)
                           CMP     (bakbyt),y
^110B  D1                  .byte ]opc
^110C  12                  .ubyte val(]adr$)
                           CMP     (fwdbyt),y
^110D  D1                  .byte ]opc
^110E  12                  .ubyte val(]adr$)
                           CMP     $12,x       ; zpx
^110F  D5                  .byte ]opc
^1110  12                  .ubyte val(]adr$)
                           CMP     bakbyt,x
^1111  D5                  .byte ]opc
^1112  12                  .ubyte val(]adr$)
                           CMP     fwdbyt,x
^1113  DD                  .byte ]opc+8
^1114  12 00               .uword val(]adr$)
                           CMP     ($12,x)     ; zpxi
^1116  C1                  .byte ]opc
^1117  12                  .ubyte val(mid$(]adr$,2,indexr(]adr$,",")-2))
                           CMP     (bakbyt,x)
^1118  C1                  .byte ]opc
^1119  12                  .ubyte val(mid$(]adr$,2,indexr(]adr$,",")-2))
                           CMP     (fwdbyt,x)
^111A  C1                  .byte ]opc
^111B  12                  .ubyte val(mid$(]adr$,2,indexr(]adr$,",")-2))

                           CPX     $1234       ; ab
^111C  EC                  .byte ]opc+8
^111D  34 12               .uword val(]adr$)
                           CPX     bakwrd
^111F  EC                  .byte ]opc+8
^1120  34 12               .uword val(]adr$)
                           CPX     fwdwrd
^1122  EC                  .byte ]opc+8
^1123  34 12               .uword val(]adr$)
                           CPX     #$12        ; imm
^1125  E0                  .byte ]opc, val(mid$(]adr$, 2))
^1126  12
                           CPX     #bakbyt
^1127  E0                  .byte ]opc, val(mid$(]adr$, 2))
^1128  12
                           CPX     #fwdbyt
^1129  E0                  .byte ]opc, val(mid$(]adr$, 2))
^112A  12
                           CPX     $12         ; zp
^112B  E4                  .byte ]opc
^112C  12                  .ubyte val(]adr$)
                           CPX     bakbyt
^112D  E4                  .byte ]opc
^112E  12                  .ubyte val(]adr$)
                           CPX     fwdbyt
^112F  EC                  .byte ]opc+8
^1130  12 00               .uword val(]adr$)

                           CPY     $1234       ; ab
^1132  CC                  .byte ]opc+8
^1133  34 12               .uword val(]adr$)
                           CPY     bakwrd
^1135  CC                  .byte ]opc+8
^1136  34 12               .uword val(]adr$)
                           CPY     fwdwrd
^1138  CC                  .byte ]opc+8
^1139  34 12               .uword val(]adr$)
                           CPY     #$12        ; imm
^113B  C0                  .byte ]opc, val(mid$(]adr$, 2))
^113C  12
                           CPY     #bakbyt
^113D  C0                  .byte ]opc, val(mid$(]adr$, 2))
^113E  12
                           CPY     #fwdbyt
^113F  C0                  .byte ]opc, val(mid$(]adr$, 2))
^1140  12
                           CPY     $12         ; zp
^1141  C4                  .byte ]opc
^1142  12                  .ubyte val(]adr$)
                           CPY     bakbyt
^1143  C4                  .byte ]opc
^1144  12                  .ubyte val(]adr$)
                           CPY     fwdbyt
^1145  CC                  .byte ]opc+8
^1146  12 00               .uword val(]adr$)

                           DEC     $1234       ; ab
^1148  CE                  .byte ]opc+8
^1149  34 12               .uword val(]adr$)
                           DEC     bakwrd
^114B  CE                  .byte ]opc+8
^114C  34 12               .uword val(]adr$)
                           DEC     fwdwrd
^114E  CE                  .byte ]opc+8
^114F  34 12               .uword val(]adr$)
                           DEC     $1234,x     ; abx
^1151  DE                  .byte ]opc+8
^1152  34 12               .uword val(]adr$)
                           DEC     bakwrd,x
^1154  DE                  .byte ]opc+8
^1155  34 12               .uword val(]adr$)
                           DEC     fwdwrd,x
^1157  DE                  .byte ]opc+8
^1158  34 12               .uword val(]adr$)
                           DEC     $12         ; zp
^115A  C6                  .byte ]opc
^115B  12                  .ubyte val(]adr$)
                           DEC     bakbyt
^115C  C6                  .byte ]opc
^115D  12                  .ubyte val(]adr$)
                           DEC     fwdbyt
^115E  CE                  .byte ]opc+8
^115F  12 00               .uword val(]adr$)
                           DEC     $12,x       ; zpx
^1161  D6                  .byte ]opc
^1162  12                  .ubyte val(]adr$)
                           DEC     bakbyt,x
^1163  D6                  .byte ]opc
^1164  12                  .ubyte val(]adr$)
                           DEC     fwdbyt,x
^1165  DE                  .byte ]opc+8
^1166  12 00               .uword val(]adr$)

                           DEX                 ; imp
^1168  CA                  .byte $CA

                           DEY                 ; imp
^1169  88                  .byte $88

                           EOR     $1234       ; ab
^116A  4D                  .byte ]opc+8
^116B  34 12               .uword val(]adr$)
                           EOR     bakwrd
^116D  4D                  .byte ]opc+8
^116E  34 12               .uword val(]adr$)
                           EOR     fwdwrd
^1170  4D                  .byte ]opc+8
^1171  34 12               .uword val(]adr$)
                           EOR     $1234,x     ; abx
^1173  5D                  .byte ]opc+8
^1174  34 12               .uword val(]adr$)
                           EOR     bakwrd,x
^1176  5D                  .byte ]opc+8
^1177  34 12               .uword val(]adr$)
                           EOR     fwdwrd,x
^1179  5D                  .byte ]opc+8
^117A  34 12               .uword val(]adr$)
                           EOR     $1234,y     ; aby
^117C  59                  .byte ]opc+8
^117D  34 12               .uword val(]adr$)
                           EOR     bakwrd,y
^117F  59                  .byte ]opc+8
^1180  34 12               .uword val(]adr$)
                           EOR     fwdwrd,y
^1182  59                  .byte ]opc+8
^1183  34 12               .uword val(]adr$)
                           EOR     #$12        ; imm
^1185  49                  .byte ]opc, val(mid$(]adr$, 2))
^1186  12
                           EOR     #bakbyt
^1187  49                  .byte ]opc, val(mid$(]adr$, 2))
^1188  12
                           EOR     #fwdbyt
^1189  49                  .byte ]opc, val(mid$(]adr$, 2))
^118A  12
                           EOR     $12         ; zp
^118B  45                  .byte ]opc
^118C  12                  .ubyte val(]adr$)
                           EOR     bakbyt
^118D  45                  .byte ]opc
^118E  12                  .ubyte val(]adr$)
                           EOR     fwdbyt
^118F  4D                  .byte ]opc+8
^1190  12 00               .uword val(]adr$)
                           EOR     ($12),y     ; zpiy
^1192  51                  .byte ]opc
^1193  12                  .ubyte val(]adr$)
                           EOR     (bakbyt),y
^1194  51                  .byte ]opc
^1195  12                  .ubyte val(]adr$)
                           EOR     (fwdbyt),y
^1196  51                  .byte ]opc
^1197  12                  .ubyte val(]adr$)
                           EOR     $12,x       ; zpx
^1198  55                  .byte ]opc
^1199  12                  .ubyte val(]adr$)
                           EOR     bakbyt,x
^119A  55                  .byte ]opc
^119B  12                  .ubyte val(]adr$)
                           EOR     fwdbyt,x
^119C  5D                  .byte ]opc+8
^119D  12 00               .uword val(]adr$)
                           EOR     ($12,x)     ; zpxi
^119F  41                  .byte ]opc
^11A0  12                  .ubyte val(mid$(]adr$,2,indexr(]adr$,",")-2))
                           EOR     (bakbyt,x)
^11A1  41                  .byte ]opc
^11A2  12                  .ubyte val(mid$(]adr$,2,indexr(]adr$,",")-2))
                           EOR     (fwdbyt,x)
^11A3  41                  .byte ]opc
^11A4  12                  .ubyte val(mid$(]adr$,2,indexr(]adr$,",")-2))

                           INC     $1234       ; ab
^11A5  EE                  .byte ]opc+8
^11A6  34 12               .uword val(]adr$)
                           INC     bakwrd
^11A8  EE                  .byte ]opc+8
^11A9  34 12               .uword val(]adr$)
                           INC     fwdwrd
^11AB  EE                  .byte ]opc+8
^11AC  34 12               .uword val(]adr$)
                           INC     $1234,x     ; abx
^11AE  FE                  .byte ]opc+8
^11AF  34 12               .uword val(]adr$)
                           INC     bakwrd,x
^11B1  FE                  .byte ]opc+8
^11B2  34 12               .uword val(]adr$)
                           INC     fwdwrd,x
^11B4  FE                  .byte ]opc+8
^11B5  34 12               .uword val(]adr$)
                           INC     $12         ; zp
^11B7  E6                  .byte ]opc
^11B8  12                  .ubyte val(]adr$)
                           INC     bakbyt
^11B9  E6                  .byte ]opc
^11BA  12                  .ubyte val(]adr$)
                           INC     fwdbyt
^11BB  EE                  .byte ]opc+8
^11BC  12 00               .uword val(]adr$)
                           INC     $12,x       ; zpx
^11BE  F6                  .byte ]opc
^11BF  12                  .ubyte val(]adr$)
                           INC     bakbyt,x
^11C0  F6                  .byte ]opc
^11C1  12                  .ubyte val(]adr$)
                           INC     fwdbyt,x
^11C2  FE                  .byte ]opc+8
^11C3  12 00               .uword val(]adr$)

                           INX                 ; imp
^11C5  E8                  .byte $E8

                           INY                 ; imp
^11C6  C8                  .byte $C8

                           JMP     $1234       ; ab
^11C7  4C                  .byte ]adr$ ~ /^\(.+\)$/ ? $6C : $4C
^11C8  34 12               .uword val(]adr$)
                           JMP     bakwrd
^11CA  4C                  .byte ]adr$ ~ /^\(.+\)$/ ? $6C : $4C
^11CB  34 12               .uword val(]adr$)
                           JMP     fwdwrd
^11CD  4C                  .byte ]adr$ ~ /^\(.+\)$/ ? $6C : $4C
^11CE  34 12               .uword val(]adr$)
                           JMP     ($1234)     ; abi
^11D0  6C                  .byte ]adr$ ~ /^\(.+\)$/ ? $6C : $4C
^11D1  34 12               .uword val(]adr$)
                           JMP     (bakwrd)
^11D3  6C                  .byte ]adr$ ~ /^\(.+\)$/ ? $6C : $4C
^11D4  34 12               .uword val(]adr$)
                           JMP     (fwdwrd)
^11D6  6C                  .byte ]adr$ ~ /^\(.+\)$/ ? $6C : $4C
^11D7  34 12               .uword val(]adr$)

                           JSR     $1234       ; ab
^11D9  20                  .byte $20
^11DA  34 12               .uword $1234
                           JSR     bakwrd
^11DC  20                  .byte $20
^11DD  34 12               .uword bakwrd
                           JSR     fwdwrd
^11DF  20                  .byte $20
^11E0  34 12               .uword fwdwrd

                           LDA     $1234       ; ab
^11E2  AD                  .byte ]opc+8
^11E3  34 12               .uword val(]adr$)
                           LDA     bakwrd
^11E5  AD                  .byte ]opc+8
^11E6  34 12               .uword val(]adr$)
                           LDA     fwdwrd
^11E8  AD                  .byte ]opc+8
^11E9  34 12               .uword val(]adr$)
                           LDA     $1234,x     ; abx
^11EB  BD                  .byte ]opc+8
^11EC  34 12               .uword val(]adr$)
                           LDA     bakwrd,x
^11EE  BD                  .byte ]opc+8
^11EF  34 12               .uword val(]adr$)
                           LDA     fwdwrd,x
^11F1  BD                  .byte ]opc+8
^11F2  34 12               .uword val(]adr$)
                           LDA     $1234,y     ; aby
^11F4  B9                  .byte ]opc+8
^11F5  34 12               .uword val(]adr$)
                           LDA     bakwrd,y
^11F7  B9                  .byte ]opc+8
^11F8  34 12               .uword val(]adr$)
                           LDA     fwdwrd,y
^11FA  B9                  .byte ]opc+8
^11FB  34 12               .uword val(]adr$)
                           LDA     #$12        ; imm
^11FD  A9                  .byte ]opc, val(mid$(]adr$, 2))
^11FE  12
                           LDA     #bakbyt
^11FF  A9                  .byte ]opc, val(mid$(]adr$, 2))
^1200  12
                           LDA     #fwdbyt
^1201  A9                  .byte ]opc, val(mid$(]adr$, 2))
^1202  12
                           LDA     $12         ; zp
^1203  A5                  .byte ]opc
^1204  12                  .ubyte val(]adr$)
                           LDA     bakbyt
^1205  A5                  .byte ]opc
^1206  12                  .ubyte val(]adr$)
                           LDA     fwdbyt
^1207  AD                  .byte ]opc+8
^1208  12 00               .uword val(]adr$)
                           LDA     ($12),y     ; zpiy
^120A  B1                  .byte ]opc
^120B  12                  .ubyte val(]adr$)
                           LDA     (bakbyt),y
^120C  B1                  .byte ]opc
^120D  12                  .ubyte val(]adr$)
                           LDA     (fwdbyt),y
^120E  B1                  .byte ]opc
^120F  12                  .ubyte val(]adr$)
                           LDA     $12,x       ; zpx
^1210  B5                  .byte ]opc
^1211  12                  .ubyte val(]adr$)
                           LDA     bakbyt,x
^1212  B5                  .byte ]opc
^1213  12                  .ubyte val(]adr$)
                           LDA     fwdbyt,x
^1214  BD                  .byte ]opc+8
^1215  12 00               .uword val(]adr$)
                           LDA     ($12,x)     ; zpxi
^1217  A1                  .byte ]opc
^1218  12                  .ubyte val(mid$(]adr$,2,indexr(]adr$,",")-2))
                           LDA     (bakbyt,x)
^1219  A1                  .byte ]opc
^121A  12                  .ubyte val(mid$(]adr$,2,indexr(]adr$,",")-2))
                           LDA     (fwdbyt,x)
^121B  A1                  .byte ]opc
^121C  12                  .ubyte val(mid$(]adr$,2,indexr(]adr$,",")-2))

                           LDX     $1234       ; ab
^121D  AE                  .byte ]opc+8
^121E  34 12               .uword val(]adr$)
                           LDX     bakwrd
^1220  AE                  .byte ]opc+8
^1221  34 12               .uword val(]adr$)
                           LDX     fwdwrd
^1223  AE                  .byte ]opc+8
^1224  34 12               .uword val(]adr$)
                           LDX     $1234,y     ; aby
^1226  BE                  .byte ]opc+8
^1227  34 12               .uword val(]adr$)
                           LDX     bakwrd,y
^1229  BE                  .byte ]opc+8
^122A  34 12               .uword val(]adr$)
                           LDX     fwdwrd,y
^122C  BE                  .byte ]opc+8
^122D  34 12               .uword val(]adr$)
                           LDX     #12         ; imm
^122F  A2                  .byte ]opc, val(mid$(]adr$, 2))
^1230  0C
                           LDX     #bakbyt
^1231  A2                  .byte ]opc, val(mid$(]adr$, 2))
^1232  12
                           LDX     #fwdbyt
^1233  A2                  .byte ]opc, val(mid$(]adr$, 2))
^1234  12
                           LDX     $12         ; zp
^1235  A6                  .byte ]opc
^1236  12                  .ubyte val(]adr$)
                           LDX     bakbyt
^1237  A6                  .byte ]opc
^1238  12                  .ubyte val(]adr$)
                           LDX     fwdbyt
^1239  AE                  .byte ]opc+8
^123A  12 00               .uword val(]adr$)
                           LDX     $12,y       ; zpy
^123C  B6                  .byte ]opc
^123D  12                  .ubyte val(]adr$)
                           LDX     bakbyt,y
^123E  B6                  .byte ]opc
^123F  12                  .ubyte val(]adr$)
                           LDX     fwdbyt,y
^1240  BE                  .byte ]opc+8
^1241  12 00               .uword val(]adr$)

                           LDY     $1234       ; ab
^1243  AC                  .byte ]opc+8
^1244  34 12               .uword val(]adr$)
                           LDY     bakwrd
^1246  AC                  .byte ]opc+8
^1247  34 12               .uword val(]adr$)
                           LDY     fwdwrd
^1249  AC                  .byte ]opc+8
^124A  34 12               .uword val(]adr$)
                           LDY     $1234,x     ; abx
^124C  BC                  .byte ]opc+8
^124D  34 12               .uword val(]adr$)
                           LDY     bakwrd,x
^124F  BC                  .byte ]opc+8
^1250  34 12               .uword val(]adr$)
                           LDY     fwdwrd,x
^1252  BC                  .byte ]opc+8
^1253  34 12               .uword val(]adr$)
                           LDY     #12         ; imm
^1255  A0                  .byte ]opc, val(mid$(]adr$, 2))
^1256  0C
                           LDY     #bakbyt
^1257  A0                  .byte ]opc, val(mid$(]adr$, 2))
^1258  12
                           LDY     #fwdbyt
^1259  A0                  .byte ]opc, val(mid$(]adr$, 2))
^125A  12
                           LDY     $12         ; zp
^125B  A4                  .byte ]opc
^125C  12                  .ubyte val(]adr$)
                           LDY     bakbyt
^125D  A4                  .byte ]opc
^125E  12                  .ubyte val(]adr$)
                           LDY     fwdbyt
^125F  AC                  .byte ]opc+8
^1260  12 00               .uword val(]adr$)
                           LDY     $12,x       ; zpx
^1262  B4                  .byte ]opc
^1263  12                  .ubyte val(]adr$)
                           LDY     bakbyt,x
^1264  B4                  .byte ]opc
^1265  12                  .ubyte val(]adr$)
                           LDY     fwdbyt,x
^1266  BC                  .byte ]opc+8
^1267  12 00               .uword val(]adr$)

                           LSR     $1234       ; ab
^1269  4E                  .byte ]opc+8
^126A  34 12               .uword val(]adr$)
                           LSR     bakwrd
^126C  4E                  .byte ]opc+8
^126D  34 12               .uword val(]adr$)
                           LSR     fwdwrd
^126F  4E                  .byte ]opc+8
^1270  34 12               .uword val(]adr$)
                           LSR     $1234,x     ; abx
^1272  5E                  .byte ]opc+8
^1273  34 12               .uword val(]adr$)
                           LSR     bakwrd,x
^1275  5E                  .byte ]opc+8
^1276  34 12               .uword val(]adr$)
                           LSR     fwdwrd,x
^1278  5E                  .byte ]opc+8
^1279  34 12               .uword val(]adr$)
                           LSR                 ; acc
^127B  4A                  .byte ]opc+4
                           LSR     a           ; acc
^127C  4A                  .byte ]opc+4
                           LSR     $12         ; zp
^127D  46                  .byte ]opc
^127E  12                  .ubyte val(]adr$)
                           LSR     bakbyt
^127F  46                  .byte ]opc
^1280  12                  .ubyte val(]adr$)
                           LSR     fwdbyt
^1281  4E                  .byte ]opc+8
^1282  12 00               .uword val(]adr$)
                           LSR     $12,x       ; zpx
^1284  56                  .byte ]opc
^1285  12                  .ubyte val(]adr$)
                           LSR     bakbyt,x
^1286  56                  .byte ]opc
^1287  12                  .ubyte val(]adr$)
                           LSR     fwdbyt,x
^1288  5E                  .byte ]opc+8
^1289  12 00               .uword val(]adr$)

                           NOP                 ; imp
^128B  EA                  .byte $EA

                           ORA     $1234       ; ab
^128C  0D                  .byte ]opc+8
^128D  34 12               .uword val(]adr$)
                           ORA     bakwrd
^128F  0D                  .byte ]opc+8
^1290  34 12               .uword val(]adr$)
                           ORA     fwdwrd
^1292  0D                  .byte ]opc+8
^1293  34 12               .uword val(]adr$)
                           ORA     $1234,x     ; abx
^1295  1D                  .byte ]opc+8
^1296  34 12               .uword val(]adr$)
                           ORA     bakwrd,x
^1298  1D                  .byte ]opc+8
^1299  34 12               .uword val(]adr$)
                           ORA     fwdwrd,x
^129B  1D                  .byte ]opc+8
^129C  34 12               .uword val(]adr$)
                           ORA     $1234,y     ; aby
^129E  19                  .byte ]opc+8
^129F  34 12               .uword val(]adr$)
                           ORA     bakwrd,y
^12A1  19                  .byte ]opc+8
^12A2  34 12               .uword val(]adr$)
                           ORA     fwdwrd,y
^12A4  19                  .byte ]opc+8
^12A5  34 12               .uword val(]adr$)
                           ORA     #$12        ; imm
^12A7  09                  .byte ]opc, val(mid$(]adr$, 2))
^12A8  12
                           ORA     #bakbyt
^12A9  09                  .byte ]opc, val(mid$(]adr$, 2))
^12AA  12
                           ORA     #fwdbyt
^12AB  09                  .byte ]opc, val(mid$(]adr$, 2))
^12AC  12
                           ORA     $12         ; zp
^12AD  05                  .byte ]opc
^12AE  12                  .ubyte val(]adr$)
                           ORA     bakbyt
^12AF  05                  .byte ]opc
^12B0  12                  .ubyte val(]adr$)
                           ORA     fwdbyt
^12B1  0D                  .byte ]opc+8
^12B2  12 00               .uword val(]adr$)
                           ORA     ($12),y     ; zpiy
^12B4  11                  .byte ]opc
^12B5  12                  .ubyte val(]adr$)
                           ORA     (bakbyt),y
^12B6  11                  .byte ]opc
^12B7  12                  .ubyte val(]adr$)
                           ORA     (fwdbyt),y
^12B8  11                  .byte ]opc
^12B9  12                  .ubyte val(]adr$)
                           ORA     $12,x       ; zpx
^12BA  15                  .byte ]opc
^12BB  12                  .ubyte val(]adr$)
                           ORA     bakbyt,x
^12BC  15                  .byte ]opc
^12BD  12                  .ubyte val(]adr$)
                           ORA     fwdbyt,x
^12BE  1D                  .byte ]opc+8
^12BF  12 00               .uword val(]adr$)
                           ORA     ($12,x)     ; zpxi
^12C1  01                  .byte ]opc
^12C2  12                  .ubyte val(mid$(]adr$,2,indexr(]adr$,",")-2))
                           ORA     (bakbyt,x)
^12C3  01                  .byte ]opc
^12C4  12                  .ubyte val(mid$(]adr$,2,indexr(]adr$,",")-2))
                           ORA     (fwdbyt,x)
^12C5  01                  .byte ]opc
^12C6  12                  .ubyte val(mid$(]adr$,2,indexr(]adr$,",")-2))

                           PHA                 ; imp
^12C7  48                  .byte $48

                           PHP                 ; imp
^12C8  08                  .byte $08

                           PLA                 ; imp
^12C9  68                  .byte $68

                           PLP                 ; imp
^12CA  28                  .byte $28

                           ROL     $1234       ; ab
^12CB  2E                  .byte ]opc+8
^12CC  34 12               .uword val(]adr$)
                           ROL     bakwrd
^12CE  2E                  .byte ]opc+8
^12CF  34 12               .uword val(]adr$)
                           ROL     fwdwrd
^12D1  2E                  .byte ]opc+8
^12D2  34 12               .uword val(]adr$)
                           ROL     $1234,x     ; abx
^12D4  3E                  .byte ]opc+8
^12D5  34 12               .uword val(]adr$)
                           ROL     bakwrd,x
^12D7  3E                  .byte ]opc+8
^12D8  34 12               .uword val(]adr$)
                           ROL     fwdwrd,x
^12DA  3E                  .byte ]opc+8
^12DB  34 12               .uword val(]adr$)
                           ROL                 ; acc
^12DD  2A                  .byte ]opc+4
                           ROL     a           ; acc
^12DE  2A                  .byte ]opc+4
                           ROL     $12         ; zp
^12DF  26                  .byte ]opc
^12E0  12                  .ubyte val(]adr$)
                           ROL     bakbyt
^12E1  26                  .byte ]opc
^12E2  12                  .ubyte val(]adr$)
                           ROL     fwdbyt
^12E3  2E                  .byte ]opc+8
^12E4  12 00               .uword val(]adr$)
                           ROL     $12,x       ; zpx
^12E6  36                  .byte ]opc
^12E7  12                  .ubyte val(]adr$)
                           ROL     bakbyt,x
^12E8  36                  .byte ]opc
^12E9  12                  .ubyte val(]adr$)
                           ROL     fwdbyt,x
^12EA  3E                  .byte ]opc+8
^12EB  12 00               .uword val(]adr$)

                           ROR     $1234       ; ab
^12ED  6E                  .byte ]opc+8
^12EE  34 12               .uword val(]adr$)
                           ROR     bakwrd
^12F0  6E                  .byte ]opc+8
^12F1  34 12               .uword val(]adr$)
                           ROR     fwdwrd
^12F3  6E                  .byte ]opc+8
^12F4  34 12               .uword val(]adr$)
                           ROR     $1234,x     ; abx
^12F6  7E                  .byte ]opc+8
^12F7  34 12               .uword val(]adr$)
                           ROR     bakwrd,x
^12F9  7E                  .byte ]opc+8
^12FA  34 12               .uword val(]adr$)
                           ROR     fwdwrd,x
^12FC  7E                  .byte ]opc+8
^12FD  34 12               .uword val(]adr$)
                           ROR                 ; acc
^12FF  6A                  .byte ]opc+4
                           ROR     a           ; acc
^1300  6A                  .byte ]opc+4
                           ROR     $12         ; zp
^1301  66                  .byte ]opc
^1302  12                  .ubyte val(]adr$)
                           ROR     bakbyt
^1303  66                  .byte ]opc
^1304  12                  .ubyte val(]adr$)
                           ROR     fwdbyt
^1305  6E                  .byte ]opc+8
^1306  12 00               .uword val(]adr$)
                           ROR     $12,x       ; zpx
^1308  76                  .byte ]opc
^1309  12                  .ubyte val(]adr$)
                           ROR     bakbyt,x
^130A  76                  .byte ]opc
^130B  12                  .ubyte val(]adr$)
                           ROR     fwdbyt,x
^130C  7E                  .byte ]opc+8
^130D  12 00               .uword val(]adr$)

                           RTI                 ; imp
^130F  40                  .byte $40

                           RTS                 ; imp
^1310  60                  .byte $60

                           SBC     $1234       ; ab
^1311  ED                  .byte ]opc+8
^1312  34 12               .uword val(]adr$)
                           SBC     bakwrd
^1314  ED                  .byte ]opc+8
^1315  34 12               .uword val(]adr$)
                           SBC     fwdwrd
^1317  ED                  .byte ]opc+8
^1318  34 12               .uword val(]adr$)
                           SBC     $1234,x     ; abx
^131A  FD                  .byte ]opc+8
^131B  34 12               .uword val(]adr$)
                           SBC     bakwrd,x
^131D  FD                  .byte ]opc+8
^131E  34 12               .uword val(]adr$)
                           SBC     fwdwrd,x
^1320  FD                  .byte ]opc+8
^1321  34 12               .uword val(]adr$)
                           SBC     $1234,y     ; aby
^1323  F9                  .byte ]opc+8
^1324  34 12               .uword val(]adr$)
                           SBC     bakwrd,y
^1326  F9                  .byte ]opc+8
^1327  34 12               .uword val(]adr$)
                           SBC     fwdwrd,y
^1329  F9                  .byte ]opc+8
^132A  34 12               .uword val(]adr$)
                           SBC     #$12        ; imm
^132C  E9                  .byte ]opc, val(mid$(]adr$, 2))
^132D  12
                           SBC     #bakbyt
^132E  E9                  .byte ]opc, val(mid$(]adr$, 2))
^132F  12
                           SBC     #fwdbyt
^1330  E9                  .byte ]opc, val(mid$(]adr$, 2))
^1331  12
                           SBC     $12         ; zp
^1332  E5                  .byte ]opc
^1333  12                  .ubyte val(]adr$)
                           SBC     bakbyt
^1334  E5                  .byte ]opc
^1335  12                  .ubyte val(]adr$)
                           SBC     fwdbyt
^1336  ED                  .byte ]opc+8
^1337  12 00               .uword val(]adr$)
                           SBC     ($12),y     ; zpiy
^1339  F1                  .byte ]opc
^133A  12                  .ubyte val(]adr$)
                           SBC     (bakbyt),y
^133B  F1                  .byte ]opc
^133C  12                  .ubyte val(]adr$)
                           SBC     (fwdbyt),y
^133D  F1                  .byte ]opc
^133E  12                  .ubyte val(]adr$)
                           SBC     $12,x       ; zpx
^133F  F5                  .byte ]opc
^1340  12                  .ubyte val(]adr$)
                           SBC     bakbyt,x
^1341  F5                  .byte ]opc
^1342  12                  .ubyte val(]adr$)
                           SBC     fwdbyt,x
^1343  FD                  .byte ]opc+8
^1344  12 00               .uword val(]adr$)
                           SBC     ($12,x)     ; zpxi
^1346  E1                  .byte ]opc
^1347  12                  .ubyte val(mid$(]adr$,2,indexr(]adr$,",")-2))
                           SBC     (bakbyt,x)
^1348  E1                  .byte ]opc
^1349  12                  .ubyte val(mid$(]adr$,2,indexr(]adr$,",")-2))
                           SBC     (fwdbyt,x)
^134A  E1                  .byte ]opc
^134B  12                  .ubyte val(mid$(]adr$,2,indexr(]adr$,",")-2))

                           SEC                 ; imp
^134C  38                  .byte $38

                           SED                 ; imp
^134D  F8                  .byte $F8

                           SEI                 ; imp
^134E  78                  .byte $78

                           STA     $1234       ; ab
^134F  8D                  .byte ]opc+8
^1350  34 12               .uword val(]adr$)
                           STA     bakwrd
^1352  8D                  .byte ]opc+8
^1353  34 12               .uword val(]adr$)
                           STA     fwdwrd
^1355  8D                  .byte ]opc+8
^1356  34 12               .uword val(]adr$)
                           STA     $1234,x     ; abx
^1358  9D                  .byte ]opc+8
^1359  34 12               .uword val(]adr$)
                           STA     bakwrd,x
^135B  9D                  .byte ]opc+8
^135C  34 12               .uword val(]adr$)
                           STA     fwdwrd,x
^135E  9D                  .byte ]opc+8
^135F  34 12               .uword val(]adr$)
                           STA     $1234,y     ; aby
^1361  99                  .byte ]opc+8
^1362  34 12               .uword val(]adr$)
                           STA     bakwrd,y
^1364  99                  .byte ]opc+8
^1365  34 12               .uword val(]adr$)
                           STA     fwdwrd,y
^1367  99                  .byte ]opc+8
^1368  34 12               .uword val(]adr$)
                           STA     $12         ; zp
^136A  85                  .byte ]opc
^136B  12                  .ubyte val(]adr$)
                           STA     bakbyt
^136C  85                  .byte ]opc
^136D  12                  .ubyte val(]adr$)
                           STA     fwdbyt
^136E  8D                  .byte ]opc+8
^136F  12 00               .uword val(]adr$)
                           STA     ($12),y     ; zpiy
^1371  91                  .byte ]opc
^1372  12                  .ubyte val(]adr$)
                           STA     (bakbyt),y
^1373  91                  .byte ]opc
^1374  12                  .ubyte val(]adr$)
                           STA     (fwdbyt),y
^1375  91                  .byte ]opc
^1376  12                  .ubyte val(]adr$)
                           STA     $12,x       ; zpx
^1377  95                  .byte ]opc
^1378  12                  .ubyte val(]adr$)
                           STA     bakbyt,x
^1379  95                  .byte ]opc
^137A  12                  .ubyte val(]adr$)
                           STA     fwdbyt,x
^137B  9D                  .byte ]opc+8
^137C  12 00               .uword val(]adr$)
                           STA     ($12,x)     ; zpxi
^137E  81                  .byte ]opc
^137F  12                  .ubyte val(mid$(]adr$,2,indexr(]adr$,",")-2))
                           STA     (bakbyt,x)
^1380  81                  .byte ]opc
^1381  12                  .ubyte val(mid$(]adr$,2,indexr(]adr$,",")-2))
                           STA     (fwdbyt,x)
^1382  81                  .byte ]opc
^1383  12                  .ubyte val(mid$(]adr$,2,indexr(]adr$,",")-2))

                           STX     $1234       ; ab
^1384  8E                  .byte ]opc+8
^1385  34 12               .uword val(]adr$)
                           STX     bakwrd
^1387  8E                  .byte ]opc+8
^1388  34 12               .uword val(]adr$)
                           STX     fwdwrd
^138A  8E                  .byte ]opc+8
^138B  34 12               .uword val(]adr$)
                           STX     $12         ; zp
^138D  86                  .byte ]opc
^138E  12                  .ubyte val(]adr$)
                           STX     bakbyt
^138F  86                  .byte ]opc
^1390  12                  .ubyte val(]adr$)
                           STX     fwdbyt
^1391  8E                  .byte ]opc+8
^1392  12 00               .uword val(]adr$)
                           STX     $12,y       ; zpy
^1394  96                  .byte ]opc
^1395  12                  .ubyte val(]adr$)
                           STX     bakbyt,y
^1396  96                  .byte ]opc
^1397  12                  .ubyte val(]adr$)
                           STX     fwdbyt,y
^1398  96                  .byte ]opc
^1399  12                  .ubyte val(]adr$)

                           STY     $1234       ; ab
^139A  8C                  .byte ]opc+8
^139B  34 12               .uword val(]adr$)
                           STY     bakwrd
^139D  8C                  .byte ]opc+8
^139E  34 12               .uword val(]adr$)
                           STY     fwdwrd
^13A0  8C                  .byte ]opc+8
^13A1  34 12               .uword val(]adr$)
                           STY     $12         ; zp
^13A3  84                  .byte ]opc
^13A4  12                  .ubyte val(]adr$)
                           STY     bakbyt
^13A5  84                  .byte ]opc
^13A6  12                  .ubyte val(]adr$)
                           STY     fwdbyt
^13A7  8C                  .byte ]opc+8
^13A8  12 00               .uword val(]adr$)
                           STY     $12,x       ; zpx
^13AA  94                  .byte ]opc
^13AB  12                  .ubyte val(]adr$)
                           STY     bakbyt,x
^13AC  94                  .byte ]opc
^13AD  12                  .ubyte val(]adr$)
                           STY     fwdbyt,x
^13AE  94                  .byte ]opc
^13AF  12                  .ubyte val(]adr$)

                           TAX                 ; imp
^13B0  AA                  .byte $AA

                           TAY                 ; imp
^13B1  A8                  .byte $A8

                           TSX                 ; imp
^13B2  BA                  .byte $BA

                           TXA                 ; imp
^13B3  8A                  .byte $8A

                           TXS                 ; imp
^13B4  9A                  .byte $9A

                           TYA                 ; imp
^13B5  98                  .byte $98

                   ; forward reference

                   fwdbyt  .equ    $12
                   fwdwrd  .equ    $1234

                   ; -------------------------------

                           .end

*** Symbol Table Listing

Numeric Name     Ref Cnt   Hex Value    Dec Value

 BAKBYT              142   $      12           18
 BAKTARGET            10   $    1098         4248
 BAKWRD              122   $    1234         4660
 FWDBYT               68   $      12           18
 FWDTARGET            10   $    10DD         4317
 FWDWRD               48   $    1234         4660
 ZP_MASK             148   $FFFFFF00   4294967040
 ]OPC                640   $      94          148

Numeric Value    Ref Cnt   Hex Value    Dec Value

 BAKBYT              142   $      12           18
 FWDBYT               68   $      12           18
 BAKTARGET            10   $    1098         4248
 FWDTARGET            10   $    10DD         4317
 BAKWRD              122   $    1234         4660
 FWDWRD               48   $    1234         4660
 ZP_MASK             148   $FFFFFF00   4294967040

String Name      Ref Cnt   Value

 ]ADR$              1060  "fwdbyt"
 ]NDX$               637  "x"

Macro Name       Exp Cnt

 AB.ABX.ZP.ZPX        24
 AB.ACC.ZP            32
 AB.IMM.ZP            36
 AB.IMM.ZP.ZPXI       93
 AB.ZP               222
 ABY.ZPIY             48
 ADC                  24
 AND                  24
 ARITH.LOGIC         189
 ASL                  14
 BADMODE               -
 BCC                   2
 BCS                   2
 BEQ                   2
 BGE                   2
 BIT                   6
 BLT                   2
 BMI                   2
 BNE                   2
 BPL                   2
 BRK                   7
 BVC                   2
 BVS                   2
 CLC                   1
 CLD                   1
 CLI                   1
 CLV                   1
 CMP                  24
 CPX                   9
 CPY                   9
 DEC                  12
 DEX                   1
 DEY                   1
 EOR                  24
 IMM                  36
 INC                  12
 INX                   1
 INY                   1
 JMP                   6
 JSR                   3
 LDA                  24
 LDX                  15
 LDY                  15
 LSR                  14
 NOP                   1
 ORA                  24
 PCR                  20
 PHA                   1
 PHP                   1
 PLA                   1
 PLP                   1
 ROL                  14
 ROR                  14
 RTI                   1
 RTS                   1
 SBC                  24
 SEC                   1
 SED                   1
 SEI                   1
 SHIFT                56
 STA                  21
 STX                   9
 STY                   9
 TAX                   1
 TAY                   1
 TSX                   1
 TXA                   1
 TXS                   1
 TYA                   1
 ZP                    9
 ZPXI                 24

*** Assembly Statistics Listing

Pass One time= 00:00:13

Source lines= 991
 Macro lines= 7404
 Total lines= 8395

Lines/Sec= 645.8

Pass Two time= 00:00:00

Data Values= 769

Values/Sec= 769.0

   Total time= 00:00:13

Object Bytes= 950

Expressions cached= 26
 Cache hits= 1919
Regexes cached= 7
 Cache hits= 772

Top

teamtempest

Post subject:

Posted: Sun Jun 12, 2011 4:11 am

Joined: Sun Nov 08, 2009 1:56 am
Posts: 390
Location: Minnesota

Code:

; Hobby Cross-Assembler Demo 034b
; Macro Instruction Set\6502
; ok: 65Org16 instruction set

; by Anton Treuenfels

; first created: 06/11/11
; last revised:  06/11/11

; no errors to detect

        .listfile
        .errfile

; -------------------------------

        .listoff    includes
        .liston     stats

cpu65Org16    =   1          ; 32-bit little-endian, 16-bit "bytes"

        .include "i6502.a"

;        .cpu    "6502"      ; required psop
        .org    $FFFF0000    ; required psop

; -------------------------------

; backward reference

bakbyt  .equ    $1234       ; zero page value 
bakwrd  .equ    $56789ABC   ; non-zero page value

; a simple test of all legal instructions using legal address modes
; - no complicated expressions
; - references to "fwdbyt" in contexts where both zero-page and absolute
; modes are possible are resolved as absolute

; some instructions produce the same code but use
; a different mnemonic or syntax:
; - "(wdc)" = WDC-recommended (fairly portable)
; - "(hxa)" = HXA-specific (not portable)

        ADC     $12345678   ; ab
        ADC     bakwrd
        ADC     fwdwrd
        ADC     $12345678,x ; abx
        ADC     bakwrd,x
        ADC     fwdwrd,x
        ADC     $12345678,y ; aby
        ADC     bakwrd,y
        ADC     fwdwrd,y
        ADC     #$1234      ; imm
        ADC     #bakbyt
        ADC     #fwdbyt
        ADC     $1234       ; zp
        ADC     bakbyt
        ADC     fwdbyt
        ADC     ($1234),y   ; zpiy
        ADC     (bakbyt),y
        ADC     (fwdbyt),y
        ADC     $1234,x     ; zpx
        ADC     bakbyt,x
        ADC     fwdbyt,x
        ADC     ($1234,x)   ; zpxi
        ADC     (bakbyt,x)
        ADC     (fwdbyt,x)

        AND     $12345678   ; ab
        AND     bakwrd
        AND     fwdwrd
        AND     $12345678,x ; abx
        AND     bakwrd,x
        AND     fwdwrd,x
        AND     $12345678,y ; aby
        AND     bakwrd,y
        AND     fwdwrd,y
        AND     #$1234      ; imm
        AND     #bakbyt
        AND     #fwdbyt
        AND     $1234       ; zp
        AND     bakbyt
        AND     fwdbyt
        AND     ($1234),y   ; zpiy
        AND     (bakbyt),y
        AND     (fwdbyt),y
        AND     $1234,x     ; zpx
        AND     bakbyt,x
        AND     fwdbyt,x
        AND     ($1234,x)   ; zpxi
        AND     (bakbyt,x)
        AND     (fwdbyt,x)

        ASL     $12345678   ; ab
        ASL     bakwrd
        ASL     fwdwrd
        ASL     $12345678,x ; abx
        ASL     bakwrd,x
        ASL     fwdwrd,x
        ASL                 ; acc
        ASL     a           ; acc
        ASL     $1234       ; zp
        ASL     bakbyt
        ASL     fwdbyt
        ASL     $1234,x     ; zpx
        ASL     bakbyt,x
        ASL     fwdbyt,x

baktarget:

        BCC     baktarget   ; rel
        BCC     fwdtarget

        BCS     baktarget   ; rel
        BCS     fwdtarget

        BEQ     baktarget   ; rel
        BEQ     fwdtarget

        BGE     baktarget   ; rel (wdc)
        BGE     fwdtarget

        BIT     $12345678   ; ab
        BIT     bakwrd
        BIT     fwdwrd
        BIT     $1234       ; zp
        BIT     bakbyt
        BIT     fwdbyt

        BLT     baktarget   ; rel (wdc)
        BLT     fwdtarget

        BMI     baktarget   ; rel
        BMI     fwdtarget

        BNE     baktarget   ; rel
        BNE     fwdtarget

        BPL     baktarget   ; rel
        BPL     fwdtarget

        BRK     #$1234      ; imm (hxa)
        BRK     #bakbyt
        BRK     #fwdbyt
        BRK                 ; imp
        BRK     $1234       ; zp (hxa)
        BRK     bakbyt
        BRK     fwdbyt

        BVC     baktarget   ; rel
        BVC     fwdtarget

        BVS     baktarget   ; rel
        BVS     fwdtarget

fwdtarget:

        CLC                 ; imp

        CLD                 ; imp

        CLI                 ; imp

        CLV                 ; imp

        CMP     $12345678   ; ab
        CMP     bakwrd
        CMP     fwdwrd
        CMP     $12345678,x ; abx
        CMP     bakwrd,x
        CMP     fwdwrd,x
        CMP     $12345678,y ; aby
        CMP     bakwrd,y
        CMP     fwdwrd,y
        CMP     #$1234      ; imm
        CMP     #bakbyt
        CMP     #fwdbyt
        CMP     $1234       ; zp
        CMP     bakbyt
        CMP     fwdbyt
        CMP     ($1234),y   ; zpiy
        CMP     (bakbyt),y
        CMP     (fwdbyt),y
        CMP     $1234,x     ; zpx
        CMP     bakbyt,x
        CMP     fwdbyt,x
        CMP     ($1234,x)   ; zpxi
        CMP     (bakbyt,x)
        CMP     (fwdbyt,x)

        CPX     $12345678   ; ab
        CPX     bakwrd
        CPX     fwdwrd
        CPX     #$1234      ; imm
        CPX     #bakbyt
        CPX     #fwdbyt
        CPX     $1234       ; zp
        CPX     bakbyt
        CPX     fwdbyt

        CPY     $12345678   ; ab
        CPY     bakwrd
        CPY     fwdwrd
        CPY     #$1234      ; imm
        CPY     #bakbyt
        CPY     #fwdbyt
        CPY     $1234       ; zp
        CPY     bakbyt
        CPY     fwdbyt

        DEC     $12345678   ; ab
        DEC     bakwrd
        DEC     fwdwrd
        DEC     $12345678,x ; abx
        DEC     bakwrd,x
        DEC     fwdwrd,x
        DEC     $1234       ; zp
        DEC     bakbyt
        DEC     fwdbyt
        DEC     $1234,x     ; zpx
        DEC     bakbyt,x
        DEC     fwdbyt,x
        
        DEX                 ; imp

        DEY                 ; imp

        EOR     $12345678   ; ab
        EOR     bakwrd
        EOR     fwdwrd
        EOR     $12345678,x ; abx
        EOR     bakwrd,x
        EOR     fwdwrd,x
        EOR     $12345678,y ; aby
        EOR     bakwrd,y
        EOR     fwdwrd,y
        EOR     #$1234      ; imm
        EOR     #bakbyt
        EOR     #fwdbyt
        EOR     $1234       ; zp
        EOR     bakbyt
        EOR     fwdbyt
        EOR     ($1234),y   ; zpiy
        EOR     (bakbyt),y
        EOR     (fwdbyt),y
        EOR     $1234,x     ; zpx
        EOR     bakbyt,x
        EOR     fwdbyt,x
        EOR     ($1234,x)   ; zpxi
        EOR     (bakbyt,x)
        EOR     (fwdbyt,x)

        INC     $12345678   ; ab
        INC     bakwrd
        INC     fwdwrd
        INC     $12345678,x ; abx
        INC     bakwrd,x
        INC     fwdwrd,x
        INC     $1234       ; zp
        INC     bakbyt
        INC     fwdbyt
        INC     $1234,x     ; zpx
        INC     bakbyt,x
        INC     fwdbyt,x
        
        INX                 ; imp

        INY                 ; imp

        JMP     $12345678   ; ab
        JMP     bakwrd
        JMP     fwdwrd
        JMP     ($1234)     ; abi
        JMP     (bakwrd)
        JMP     (fwdwrd)

        JSR     $12345678   ; ab
        JSR     bakwrd
        JSR     fwdwrd

        LDA     $12345678   ; ab
        LDA     bakwrd
        LDA     fwdwrd
        LDA     $12345678,x ; abx
        LDA     bakwrd,x
        LDA     fwdwrd,x
        LDA     $12345678,y ; aby
        LDA     bakwrd,y
        LDA     fwdwrd,y
        LDA     #$1234      ; imm
        LDA     #bakbyt
        LDA     #fwdbyt
        LDA     $1234       ; zp
        LDA     bakbyt
        LDA     fwdbyt
        LDA     ($1234),y   ; zpiy
        LDA     (bakbyt),y
        LDA     (fwdbyt),y
        LDA     $1234,x     ; zpx
        LDA     bakbyt,x
        LDA     fwdbyt,x
        LDA     ($1234,x)   ; zpxi
        LDA     (bakbyt,x)
        LDA     (fwdbyt,x)

        LDX     $12345678   ; ab
        LDX     bakwrd
        LDX     fwdwrd
        LDX     $12345678,y ; aby
        LDX     bakwrd,y
        LDX     fwdwrd,y
        LDX     #12         ; imm
        LDX     #bakbyt
        LDX     #fwdbyt
        LDX     $1234       ; zp
        LDX     bakbyt
        LDX     fwdbyt
        LDX     $12,y       ; zpy
        LDX     bakbyt,y
        LDX     fwdbyt,y

        LDY     $12345678   ; ab
        LDY     bakwrd
        LDY     fwdwrd
        LDY     $12345678,x ; abx
        LDY     bakwrd,x
        LDY     fwdwrd,x
        LDY     #12         ; imm
        LDY     #bakbyt
        LDY     #fwdbyt
        LDY     $1234       ; zp
        LDY     bakbyt
        LDY     fwdbyt
        LDY     $1234,x     ; zpx
        LDY     bakbyt,x
        LDY     fwdbyt,x

        LSR     $12345678   ; ab
        LSR     bakwrd
        LSR     fwdwrd
        LSR     $12345678,x ; abx
        LSR     bakwrd,x
        LSR     fwdwrd,x
        LSR                 ; acc
        LSR     a           ; acc
        LSR     $1234       ; zp
        LSR     bakbyt
        LSR     fwdbyt
        LSR     $1234,x     ; zpx
        LSR     bakbyt,x
        LSR     fwdbyt,x

        NOP                 ; imp

        ORA     $12345678   ; ab
        ORA     bakwrd
        ORA     fwdwrd
        ORA     $12345678,x ; abx
        ORA     bakwrd,x
        ORA     fwdwrd,x
        ORA     $12345678,y ; aby
        ORA     bakwrd,y
        ORA     fwdwrd,y
        ORA     #$1234      ; imm
        ORA     #bakbyt
        ORA     #fwdbyt
        ORA     $1234       ; zp
        ORA     bakbyt
        ORA     fwdbyt
        ORA     ($1234),y   ; zpiy
        ORA     (bakbyt),y
        ORA     (fwdbyt),y
        ORA     $1234,x     ; zpx
        ORA     bakbyt,x
        ORA     fwdbyt,x
        ORA     ($1234,x)   ; zpxi
        ORA     (bakbyt,x)
        ORA     (fwdbyt,x)

        PHA                 ; imp

        PHP                 ; imp

        PLA                 ; imp

        PLP                 ; imp

        ROL     $12345678   ; ab
        ROL     bakwrd
        ROL     fwdwrd
        ROL     $12345678,x ; abx
        ROL     bakwrd,x
        ROL     fwdwrd,x
        ROL                 ; acc
        ROL     a           ; acc
        ROL     $1234       ; zp
        ROL     bakbyt
        ROL     fwdbyt
        ROL     $1234,x     ; zpx
        ROL     bakbyt,x
        ROL     fwdbyt,x

        ROR     $12345678   ; ab
        ROR     bakwrd
        ROR     fwdwrd
        ROR     $12345678,x ; abx
        ROR     bakwrd,x
        ROR     fwdwrd,x
        ROR                 ; acc
        ROR     a           ; acc
        ROR     $1234       ; zp
        ROR     bakbyt
        ROR     fwdbyt
        ROR     $1234,x     ; zpx
        ROR     bakbyt,x
        ROR     fwdbyt,x

        RTI                 ; imp

        RTS                 ; imp

        SBC     $12345678   ; ab
        SBC     bakwrd
        SBC     fwdwrd
        SBC     $12345678,x ; abx
        SBC     bakwrd,x
        SBC     fwdwrd,x
        SBC     $12345678,y ; aby
        SBC     bakwrd,y
        SBC     fwdwrd,y
        SBC     #$1234      ; imm
        SBC     #bakbyt
        SBC     #fwdbyt
        SBC     $1234       ; zp
        SBC     bakbyt
        SBC     fwdbyt
        SBC     ($1234),y   ; zpiy
        SBC     (bakbyt),y
        SBC     (fwdbyt),y
        SBC     $1234,x     ; zpx
        SBC     bakbyt,x
        SBC     fwdbyt,x
        SBC     ($1234,x)   ; zpxi
        SBC     (bakbyt,x)
        SBC     (fwdbyt,x)

        SEC                 ; imp

        SED                 ; imp

        SEI                 ; imp

        STA     $12345678   ; ab
        STA     bakwrd
        STA     fwdwrd
        STA     $12345678,x ; abx
        STA     bakwrd,x
        STA     fwdwrd,x
        STA     $12345678,y ; aby
        STA     bakwrd,y
        STA     fwdwrd,y
        STA     $1234       ; zp
        STA     bakbyt
        STA     fwdbyt
        STA     ($1234),y   ; zpiy
        STA     (bakbyt),y
        STA     (fwdbyt),y
        STA     $1234,x     ; zpx
        STA     bakbyt,x
        STA     fwdbyt,x
        STA     ($1234,x)   ; zpxi
        STA     (bakbyt,x)
        STA     (fwdbyt,x)

        STX     $12345678   ; ab
        STX     bakwrd
        STX     fwdwrd
        STX     $1234       ; zp
        STX     bakbyt
        STX     fwdbyt
        STX     $12,y       ; zpy
        STX     bakbyt,y
        STX     fwdbyt,y

        STY     $12345678   ; ab
        STY     bakwrd
        STY     fwdwrd
        STY     $1234       ; zp
        STY     bakbyt
        STY     fwdbyt
        STY     $1234,x     ; zpx
        STY     bakbyt,x
        STY     fwdbyt,x

        TAX                 ; imp

        TAY                 ; imp

        TSX                 ; imp

        TXA                 ; imp

        TXS                 ; imp

        TYA                 ; imp

; forward reference

fwdbyt  .equ    $1234       ; zero page value
fwdwrd  .equ    $56789ABC   ; non-zero page value

; -------------------------------

        .end

Top

teamtempest

Post subject:

Posted: Sun Jun 12, 2011 4:14 am

Joined: Sun Nov 08, 2009 1:56 am
Posts: 390
Location: Minnesota

Code:

HXA v0.180 Listing File - T_32_L16 Instruction Set - Sat Jun 11 21:13:33 
                        2011

*** Object Code Listing

                        ; Hobby Cross-Assembler Demo 034b
                        ; Macro Instruction Set\6502
                        ; ok: 65Org16 instruction set

                        ; by Anton Treuenfels

                        ; first created: 06/11/11
                        ; last revised:  06/11/11

                        ; no errors to detect

                                .listfile
                                .errfile

                        ; -------------------------------

                                .listoff    includes
                                .liston     stats

                        cpu65Org16    =   1          ; 32-bit 
                        little-endian, 16-bit "bytes"

                                .include "i6502.a"

                        ;        .cpu    "6502"      ; required psop
                                .org    $FFFF0000    ; required psop

                        ; -------------------------------

                        ; backward reference

                        bakbyt  .equ    $1234       ; 
                        bakwrd  .equ    $56789ABC   ;

                        ; a simple test of all legal instructions using 
                        legal address modes
                        ; - no complicated expressions
                        ; - references to "fwdbyt" in contexts where both 
                        zero-page and absolute
                        ; modes are possible are resolved as absolute

                        ; some instructions produce the same code but use
                        ; a different mnemonic or syntax:
                        ; - "(wdc)" = WDC-recommended (fairly portable)
                        ; - "(hxa)" = HXA-specific (not portable)

                                ADC     $12345678   ; ab
^FFFF:0000  00 6D               .byte ]opc+8
^FFFF:0001  56 78 12 34         .uword val(]adr$)
                                ADC     bakwrd
^FFFF:0003  00 6D               .byte ]opc+8
^FFFF:0004  9A BC 56 78         .uword val(]adr$)
                                ADC     fwdwrd
^FFFF:0006  00 6D               .byte ]opc+8
^FFFF:0007  9A BC 56 78         .uword val(]adr$)
                                ADC     $12345678,x ; abx
^FFFF:0009  00 7D               .byte ]opc+8
^FFFF:000A  56 78 12 34         .uword val(]adr$)
                                ADC     bakwrd,x
^FFFF:000C  00 7D               .byte ]opc+8
^FFFF:000D  9A BC 56 78         .uword val(]adr$)
                                ADC     fwdwrd,x
^FFFF:000F  00 7D               .byte ]opc+8
^FFFF:0010  9A BC 56 78         .uword val(]adr$)
                                ADC     $12345678,y ; aby
^FFFF:0012  00 79               .byte ]opc+8
^FFFF:0013  56 78 12 34         .uword val(]adr$)
                                ADC     bakwrd,y
^FFFF:0015  00 79               .byte ]opc+8
^FFFF:0016  9A BC 56 78         .uword val(]adr$)
                                ADC     fwdwrd,y
^FFFF:0018  00 79               .byte ]opc+8
^FFFF:0019  9A BC 56 78         .uword val(]adr$)
                                ADC     #$1234      ; imm
^FFFF:001B  00 69               .byte ]opc, val(mid$(]adr$, 2))
^FFFF:001C  12 34
                                ADC     #bakbyt
^FFFF:001D  00 69               .byte ]opc, val(mid$(]adr$, 2))
^FFFF:001E  12 34
                                ADC     #fwdbyt
^FFFF:001F  00 69               .byte ]opc, val(mid$(]adr$, 2))
^FFFF:0020  12 34
                                ADC     $1234       ; zp
^FFFF:0021  00 65               .byte ]opc
^FFFF:0022  12 34               .ubyte val(]adr$)
                                ADC     bakbyt
^FFFF:0023  00 65               .byte ]opc
^FFFF:0024  12 34               .ubyte val(]adr$)
                                ADC     fwdbyt
^FFFF:0025  00 6D               .byte ]opc+8
^FFFF:0026  12 34 00 00         .uword val(]adr$)
                                ADC     ($1234),y   ; zpiy
^FFFF:0028  00 71               .byte ]opc
^FFFF:0029  12 34               .ubyte val(]adr$)
                                ADC     (bakbyt),y
^FFFF:002A  00 71               .byte ]opc
^FFFF:002B  12 34               .ubyte val(]adr$)
                                ADC     (fwdbyt),y
^FFFF:002C  00 71               .byte ]opc
^FFFF:002D  12 34               .ubyte val(]adr$)
                                ADC     $1234,x     ; zpx
^FFFF:002E  00 75               .byte ]opc
^FFFF:002F  12 34               .ubyte val(]adr$)
                                ADC     bakbyt,x
^FFFF:0030  00 75               .byte ]opc
^FFFF:0031  12 34               .ubyte val(]adr$)
                                ADC     fwdbyt,x
^FFFF:0032  00 7D               .byte ]opc+8
^FFFF:0033  12 34 00 00         .uword val(]adr$)
                                ADC     ($1234,x)   ; zpxi
^FFFF:0035  00 61               .byte ]opc
^FFFF:0036  12 34               .ubyte val(mid$(]adr$,2,indexr(]adr$,",
                        ")-2))
                                ADC     (bakbyt,x)
^FFFF:0037  00 61               .byte ]opc
^FFFF:0038  12 34               .ubyte val(mid$(]adr$,2,indexr(]adr$,",
                        ")-2))
                                ADC     (fwdbyt,x)
^FFFF:0039  00 61               .byte ]opc
^FFFF:003A  12 34               .ubyte val(mid$(]adr$,2,indexr(]adr$,",
                        ")-2))

                                AND     $12345678   ; ab
^FFFF:003B  00 2D               .byte ]opc+8
^FFFF:003C  56 78 12 34         .uword val(]adr$)
                                AND     bakwrd
^FFFF:003E  00 2D               .byte ]opc+8
^FFFF:003F  9A BC 56 78         .uword val(]adr$)
                                AND     fwdwrd
^FFFF:0041  00 2D               .byte ]opc+8
^FFFF:0042  9A BC 56 78         .uword val(]adr$)
                                AND     $12345678,x ; abx
^FFFF:0044  00 3D               .byte ]opc+8
^FFFF:0045  56 78 12 34         .uword val(]adr$)
                                AND     bakwrd,x
^FFFF:0047  00 3D               .byte ]opc+8
^FFFF:0048  9A BC 56 78         .uword val(]adr$)
                                AND     fwdwrd,x
^FFFF:004A  00 3D               .byte ]opc+8
^FFFF:004B  9A BC 56 78         .uword val(]adr$)
                                AND     $12345678,y ; aby
^FFFF:004D  00 39               .byte ]opc+8
^FFFF:004E  56 78 12 34         .uword val(]adr$)
                                AND     bakwrd,y
^FFFF:0050  00 39               .byte ]opc+8
^FFFF:0051  9A BC 56 78         .uword val(]adr$)
                                AND     fwdwrd,y
^FFFF:0053  00 39               .byte ]opc+8
^FFFF:0054  9A BC 56 78         .uword val(]adr$)
                                AND     #$1234      ; imm
^FFFF:0056  00 29               .byte ]opc, val(mid$(]adr$, 2))
^FFFF:0057  12 34
                                AND     #bakbyt
^FFFF:0058  00 29               .byte ]opc, val(mid$(]adr$, 2))
^FFFF:0059  12 34
                                AND     #fwdbyt
^FFFF:005A  00 29               .byte ]opc, val(mid$(]adr$, 2))
^FFFF:005B  12 34
                                AND     $1234       ; zp
^FFFF:005C  00 25               .byte ]opc
^FFFF:005D  12 34               .ubyte val(]adr$)
                                AND     bakbyt
^FFFF:005E  00 25               .byte ]opc
^FFFF:005F  12 34               .ubyte val(]adr$)
                                AND     fwdbyt
^FFFF:0060  00 2D               .byte ]opc+8
^FFFF:0061  12 34 00 00         .uword val(]adr$)
                                AND     ($1234),y   ; zpiy
^FFFF:0063  00 31               .byte ]opc
^FFFF:0064  12 34               .ubyte val(]adr$)
                                AND     (bakbyt),y
^FFFF:0065  00 31               .byte ]opc
^FFFF:0066  12 34               .ubyte val(]adr$)
                                AND     (fwdbyt),y
^FFFF:0067  00 31               .byte ]opc
^FFFF:0068  12 34               .ubyte val(]adr$)
                                AND     $1234,x     ; zpx
^FFFF:0069  00 35               .byte ]opc
^FFFF:006A  12 34               .ubyte val(]adr$)
                                AND     bakbyt,x
^FFFF:006B  00 35               .byte ]opc
^FFFF:006C  12 34               .ubyte val(]adr$)
                                AND     fwdbyt,x
^FFFF:006D  00 3D               .byte ]opc+8
^FFFF:006E  12 34 00 00         .uword val(]adr$)
                                AND     ($1234,x)   ; zpxi
^FFFF:0070  00 21               .byte ]opc
^FFFF:0071  12 34               .ubyte val(mid$(]adr$,2,indexr(]adr$,",
                        ")-2))
                                AND     (bakbyt,x)
^FFFF:0072  00 21               .byte ]opc
^FFFF:0073  12 34               .ubyte val(mid$(]adr$,2,indexr(]adr$,",
                        ")-2))
                                AND     (fwdbyt,x)
^FFFF:0074  00 21               .byte ]opc
^FFFF:0075  12 34               .ubyte val(mid$(]adr$,2,indexr(]adr$,",
                        ")-2))

                                ASL     $12345678   ; ab
^FFFF:0076  00 0E               .byte ]opc+8
^FFFF:0077  56 78 12 34         .uword val(]adr$)
                                ASL     bakwrd
^FFFF:0079  00 0E               .byte ]opc+8
^FFFF:007A  9A BC 56 78         .uword val(]adr$)
                                ASL     fwdwrd
^FFFF:007C  00 0E               .byte ]opc+8
^FFFF:007D  9A BC 56 78         .uword val(]adr$)
                                ASL     $12345678,x ; abx
^FFFF:007F  00 1E               .byte ]opc+8
^FFFF:0080  56 78 12 34         .uword val(]adr$)
                                ASL     bakwrd,x
^FFFF:0082  00 1E               .byte ]opc+8
^FFFF:0083  9A BC 56 78         .uword val(]adr$)
                                ASL     fwdwrd,x
^FFFF:0085  00 1E               .byte ]opc+8
^FFFF:0086  9A BC 56 78         .uword val(]adr$)
                                ASL                 ; acc
^FFFF:0088  00 0A               .byte ]opc+4
                                ASL     a           ; acc
^FFFF:0089  00 0A               .byte ]opc+4
                                ASL     $1234       ; zp
^FFFF:008A  00 06               .byte ]opc
^FFFF:008B  12 34               .ubyte val(]adr$)
                                ASL     bakbyt
^FFFF:008C  00 06               .byte ]opc
^FFFF:008D  12 34               .ubyte val(]adr$)
                                ASL     fwdbyt
^FFFF:008E  00 0E               .byte ]opc+8
^FFFF:008F  12 34 00 00         .uword val(]adr$)
                                ASL     $1234,x     ; zpx
^FFFF:0091  00 16               .byte ]opc
^FFFF:0092  12 34               .ubyte val(]adr$)
                                ASL     bakbyt,x
^FFFF:0093  00 16               .byte ]opc
^FFFF:0094  12 34               .ubyte val(]adr$)
                                ASL     fwdbyt,x
^FFFF:0095  00 1E               .byte ]opc+8
^FFFF:0096  12 34 00 00         .uword val(]adr$)

                        baktarget:

                                BCC     baktarget   ; rel
^FFFF:0098  00 90               .byte ]opc
^FFFF:0099  FF FE               .rbyte baktarget
                                BCC     fwdtarget
^FFFF:009A  00 90               .byte ]opc
^FFFF:009B  00 41               .rbyte fwdtarget

                                BCS     baktarget   ; rel
^FFFF:009C  00 B0               .byte ]opc
^FFFF:009D  FF FA               .rbyte baktarget
                                BCS     fwdtarget
^FFFF:009E  00 B0               .byte ]opc
^FFFF:009F  00 3D               .rbyte fwdtarget

                                BEQ     baktarget   ; rel
^FFFF:00A0  00 F0               .byte ]opc
^FFFF:00A1  FF F6               .rbyte baktarget
                                BEQ     fwdtarget
^FFFF:00A2  00 F0               .byte ]opc
^FFFF:00A3  00 39               .rbyte fwdtarget

                                BGE     baktarget   ; rel (wdc)
^FFFF:00A4  00 B0               .byte ]opc
^FFFF:00A5  FF F2               .rbyte baktarget
                                BGE     fwdtarget
^FFFF:00A6  00 B0               .byte ]opc
^FFFF:00A7  00 35               .rbyte fwdtarget

                                BIT     $12345678   ; ab
^FFFF:00A8  00 2C               .byte ]opc+8
^FFFF:00A9  56 78 12 34         .uword val(]adr$)
                                BIT     bakwrd
^FFFF:00AB  00 2C               .byte ]opc+8
^FFFF:00AC  9A BC 56 78         .uword val(]adr$)
                                BIT     fwdwrd
^FFFF:00AE  00 2C               .byte ]opc+8
^FFFF:00AF  9A BC 56 78         .uword val(]adr$)
                                BIT     $1234       ; zp
^FFFF:00B1  00 24               .byte ]opc
^FFFF:00B2  12 34               .ubyte val(]adr$)
                                BIT     bakbyt
^FFFF:00B3  00 24               .byte ]opc
^FFFF:00B4  12 34               .ubyte val(]adr$)
                                BIT     fwdbyt
^FFFF:00B5  00 2C               .byte ]opc+8
^FFFF:00B6  12 34 00 00         .uword val(]adr$)

                                BLT     baktarget   ; rel (wdc)
^FFFF:00B8  00 90               .byte ]opc
^FFFF:00B9  FF DE               .rbyte baktarget
                                BLT     fwdtarget
^FFFF:00BA  00 90               .byte ]opc
^FFFF:00BB  00 21               .rbyte fwdtarget

                                BMI     baktarget   ; rel
^FFFF:00BC  00 30               .byte ]opc
^FFFF:00BD  FF DA               .rbyte baktarget
                                BMI     fwdtarget
^FFFF:00BE  00 30               .byte ]opc
^FFFF:00BF  00 1D               .rbyte fwdtarget

                                BNE     baktarget   ; rel
^FFFF:00C0  00 D0               .byte ]opc
^FFFF:00C1  FF D6               .rbyte baktarget
                                BNE     fwdtarget
^FFFF:00C2  00 D0               .byte ]opc
^FFFF:00C3  00 19               .rbyte fwdtarget

                                BPL     baktarget   ; rel
^FFFF:00C4  00 10               .byte ]opc
^FFFF:00C5  FF D2               .rbyte baktarget
                                BPL     fwdtarget
^FFFF:00C6  00 10               .byte ]opc
^FFFF:00C7  00 15               .rbyte fwdtarget

                                BRK     #$1234      ; imm (hxa)
^FFFF:00C8  00 00               .byte ]opc, val(mid$(]adr$, 2))
^FFFF:00C9  12 34
                                BRK     #bakbyt
^FFFF:00CA  00 00               .byte ]opc, val(mid$(]adr$, 2))
^FFFF:00CB  12 34
                                BRK     #fwdbyt
^FFFF:00CC  00 00               .byte ]opc, val(mid$(]adr$, 2))
^FFFF:00CD  12 34
                                BRK                 ; imp
^FFFF:00CE  00 00               .byte $00
                                BRK     $1234       ; zp (hxa)
^FFFF:00CF  00 00               .byte ]opc
^FFFF:00D0  12 34               .ubyte val(]adr$)
                                BRK     bakbyt
^FFFF:00D1  00 00               .byte ]opc
^FFFF:00D2  12 34               .ubyte val(]adr$)
                                BRK     fwdbyt
^FFFF:00D3  00 00               .byte ]opc
^FFFF:00D4  12 34               .ubyte val(]adr$)

                                BVC     baktarget   ; rel
^FFFF:00D5  00 50               .byte ]opc
^FFFF:00D6  FF C1               .rbyte baktarget
                                BVC     fwdtarget
^FFFF:00D7  00 50               .byte ]opc
^FFFF:00D8  00 04               .rbyte fwdtarget

                                BVS     baktarget   ; rel
^FFFF:00D9  00 70               .byte ]opc
^FFFF:00DA  FF BD               .rbyte baktarget
                                BVS     fwdtarget
^FFFF:00DB  00 70               .byte ]opc
^FFFF:00DC  00 00               .rbyte fwdtarget

                        fwdtarget:

                                CLC                 ; imp
^FFFF:00DD  00 18               .byte $18

                                CLD                 ; imp
^FFFF:00DE  00 D8               .byte $D8

                                CLI                 ; imp
^FFFF:00DF  00 58               .byte $58

                                CLV                 ; imp
^FFFF:00E0  00 B8               .byte $B8

                                CMP     $12345678   ; ab
^FFFF:00E1  00 CD               .byte ]opc+8
^FFFF:00E2  56 78 12 34         .uword val(]adr$)
                                CMP     bakwrd
^FFFF:00E4  00 CD               .byte ]opc+8
^FFFF:00E5  9A BC 56 78         .uword val(]adr$)
                                CMP     fwdwrd
^FFFF:00E7  00 CD               .byte ]opc+8
^FFFF:00E8  9A BC 56 78         .uword val(]adr$)
                                CMP     $12345678,x ; abx
^FFFF:00EA  00 DD               .byte ]opc+8
^FFFF:00EB  56 78 12 34         .uword val(]adr$)
                                CMP     bakwrd,x
^FFFF:00ED  00 DD               .byte ]opc+8
^FFFF:00EE  9A BC 56 78         .uword val(]adr$)
                                CMP     fwdwrd,x
^FFFF:00F0  00 DD               .byte ]opc+8
^FFFF:00F1  9A BC 56 78         .uword val(]adr$)
                                CMP     $12345678,y ; aby
^FFFF:00F3  00 D9               .byte ]opc+8
^FFFF:00F4  56 78 12 34         .uword val(]adr$)
                                CMP     bakwrd,y
^FFFF:00F6  00 D9               .byte ]opc+8
^FFFF:00F7  9A BC 56 78         .uword val(]adr$)
                                CMP     fwdwrd,y
^FFFF:00F9  00 D9               .byte ]opc+8
^FFFF:00FA  9A BC 56 78         .uword val(]adr$)
                                CMP     #$1234      ; imm
^FFFF:00FC  00 C9               .byte ]opc, val(mid$(]adr$, 2))
^FFFF:00FD  12 34
                                CMP     #bakbyt
^FFFF:00FE  00 C9               .byte ]opc, val(mid$(]adr$, 2))
^FFFF:00FF  12 34
                                CMP     #fwdbyt
^FFFF:0100  00 C9               .byte ]opc, val(mid$(]adr$, 2))
^FFFF:0101  12 34
                                CMP     $1234       ; zp
^FFFF:0102  00 C5               .byte ]opc
^FFFF:0103  12 34               .ubyte val(]adr$)
                                CMP     bakbyt
^FFFF:0104  00 C5               .byte ]opc
^FFFF:0105  12 34               .ubyte val(]adr$)
                                CMP     fwdbyt
^FFFF:0106  00 CD               .byte ]opc+8
^FFFF:0107  12 34 00 00         .uword val(]adr$)
                                CMP     ($1234),y   ; zpiy
^FFFF:0109  00 D1               .byte ]opc
^FFFF:010A  12 34               .ubyte val(]adr$)
                                CMP     (bakbyt),y
^FFFF:010B  00 D1               .byte ]opc
^FFFF:010C  12 34               .ubyte val(]adr$)
                                CMP     (fwdbyt),y
^FFFF:010D  00 D1               .byte ]opc
^FFFF:010E  12 34               .ubyte val(]adr$)
                                CMP     $1234,x     ; zpx
^FFFF:010F  00 D5               .byte ]opc
^FFFF:0110  12 34               .ubyte val(]adr$)
                                CMP     bakbyt,x
^FFFF:0111  00 D5               .byte ]opc
^FFFF:0112  12 34               .ubyte val(]adr$)
                                CMP     fwdbyt,x
^FFFF:0113  00 DD               .byte ]opc+8
^FFFF:0114  12 34 00 00         .uword val(]adr$)
                                CMP     ($1234,x)   ; zpxi
^FFFF:0116  00 C1               .byte ]opc
^FFFF:0117  12 34               .ubyte val(mid$(]adr$,2,indexr(]adr$,",
                        ")-2))
                                CMP     (bakbyt,x)
^FFFF:0118  00 C1               .byte ]opc
^FFFF:0119  12 34               .ubyte val(mid$(]adr$,2,indexr(]adr$,",
                        ")-2))
                                CMP     (fwdbyt,x)
^FFFF:011A  00 C1               .byte ]opc
^FFFF:011B  12 34               .ubyte val(mid$(]adr$,2,indexr(]adr$,",
                        ")-2))

                                CPX     $12345678   ; ab
^FFFF:011C  00 EC               .byte ]opc+8
^FFFF:011D  56 78 12 34         .uword val(]adr$)
                                CPX     bakwrd
^FFFF:011F  00 EC               .byte ]opc+8
^FFFF:0120  9A BC 56 78         .uword val(]adr$)
                                CPX     fwdwrd
^FFFF:0122  00 EC               .byte ]opc+8
^FFFF:0123  9A BC 56 78         .uword val(]adr$)
                                CPX     #$1234      ; imm
^FFFF:0125  00 E0               .byte ]opc, val(mid$(]adr$, 2))
^FFFF:0126  12 34
                                CPX     #bakbyt
^FFFF:0127  00 E0               .byte ]opc, val(mid$(]adr$, 2))
^FFFF:0128  12 34
                                CPX     #fwdbyt
^FFFF:0129  00 E0               .byte ]opc, val(mid$(]adr$, 2))
^FFFF:012A  12 34
                                CPX     $1234       ; zp
^FFFF:012B  00 E4               .byte ]opc
^FFFF:012C  12 34               .ubyte val(]adr$)
                                CPX     bakbyt
^FFFF:012D  00 E4               .byte ]opc
^FFFF:012E  12 34               .ubyte val(]adr$)
                                CPX     fwdbyt
^FFFF:012F  00 EC               .byte ]opc+8
^FFFF:0130  12 34 00 00         .uword val(]adr$)

                                CPY     $12345678   ; ab
^FFFF:0132  00 CC               .byte ]opc+8
^FFFF:0133  56 78 12 34         .uword val(]adr$)
                                CPY     bakwrd
^FFFF:0135  00 CC               .byte ]opc+8
^FFFF:0136  9A BC 56 78         .uword val(]adr$)
                                CPY     fwdwrd
^FFFF:0138  00 CC               .byte ]opc+8
^FFFF:0139  9A BC 56 78         .uword val(]adr$)
                                CPY     #$1234      ; imm
^FFFF:013B  00 C0               .byte ]opc, val(mid$(]adr$, 2))
^FFFF:013C  12 34
                                CPY     #bakbyt
^FFFF:013D  00 C0               .byte ]opc, val(mid$(]adr$, 2))
^FFFF:013E  12 34
                                CPY     #fwdbyt
^FFFF:013F  00 C0               .byte ]opc, val(mid$(]adr$, 2))
^FFFF:0140  12 34
                                CPY     $1234       ; zp
^FFFF:0141  00 C4               .byte ]opc
^FFFF:0142  12 34               .ubyte val(]adr$)
                                CPY     bakbyt
^FFFF:0143  00 C4               .byte ]opc
^FFFF:0144  12 34               .ubyte val(]adr$)
                                CPY     fwdbyt
^FFFF:0145  00 CC               .byte ]opc+8
^FFFF:0146  12 34 00 00         .uword val(]adr$)

                                DEC     $12345678   ; ab
^FFFF:0148  00 CE               .byte ]opc+8
^FFFF:0149  56 78 12 34         .uword val(]adr$)
                                DEC     bakwrd
^FFFF:014B  00 CE               .byte ]opc+8
^FFFF:014C  9A BC 56 78         .uword val(]adr$)
                                DEC     fwdwrd
^FFFF:014E  00 CE               .byte ]opc+8
^FFFF:014F  9A BC 56 78         .uword val(]adr$)
                                DEC     $12345678,x ; abx
^FFFF:0151  00 DE               .byte ]opc+8
^FFFF:0152  56 78 12 34         .uword val(]adr$)
                                DEC     bakwrd,x
^FFFF:0154  00 DE               .byte ]opc+8
^FFFF:0155  9A BC 56 78         .uword val(]adr$)
                                DEC     fwdwrd,x
^FFFF:0157  00 DE               .byte ]opc+8
^FFFF:0158  9A BC 56 78         .uword val(]adr$)
                                DEC     $1234       ; zp
^FFFF:015A  00 C6               .byte ]opc
^FFFF:015B  12 34               .ubyte val(]adr$)
                                DEC     bakbyt
^FFFF:015C  00 C6               .byte ]opc
^FFFF:015D  12 34               .ubyte val(]adr$)
                                DEC     fwdbyt
^FFFF:015E  00 CE               .byte ]opc+8
^FFFF:015F  12 34 00 00         .uword val(]adr$)
                                DEC     $1234,x     ; zpx
^FFFF:0161  00 D6               .byte ]opc
^FFFF:0162  12 34               .ubyte val(]adr$)
                                DEC     bakbyt,x
^FFFF:0163  00 D6               .byte ]opc
^FFFF:0164  12 34               .ubyte val(]adr$)
                                DEC     fwdbyt,x
^FFFF:0165  00 DE               .byte ]opc+8
^FFFF:0166  12 34 00 00         .uword val(]adr$)

                                DEX                 ; imp
^FFFF:0168  00 CA               .byte $CA

                                DEY                 ; imp
^FFFF:0169  00 88               .byte $88

                                EOR     $12345678   ; ab
^FFFF:016A  00 4D               .byte ]opc+8
^FFFF:016B  56 78 12 34         .uword val(]adr$)
                                EOR     bakwrd
^FFFF:016D  00 4D               .byte ]opc+8
^FFFF:016E  9A BC 56 78         .uword val(]adr$)
                                EOR     fwdwrd
^FFFF:0170  00 4D               .byte ]opc+8
^FFFF:0171  9A BC 56 78         .uword val(]adr$)
                                EOR     $12345678,x ; abx
^FFFF:0173  00 5D               .byte ]opc+8
^FFFF:0174  56 78 12 34         .uword val(]adr$)
                                EOR     bakwrd,x
^FFFF:0176  00 5D               .byte ]opc+8
^FFFF:0177  9A BC 56 78         .uword val(]adr$)
                                EOR     fwdwrd,x
^FFFF:0179  00 5D               .byte ]opc+8
^FFFF:017A  9A BC 56 78         .uword val(]adr$)
                                EOR     $12345678,y ; aby
^FFFF:017C  00 59               .byte ]opc+8
^FFFF:017D  56 78 12 34         .uword val(]adr$)
                                EOR     bakwrd,y
^FFFF:017F  00 59               .byte ]opc+8
^FFFF:0180  9A BC 56 78         .uword val(]adr$)
                                EOR     fwdwrd,y
^FFFF:0182  00 59               .byte ]opc+8
^FFFF:0183  9A BC 56 78         .uword val(]adr$)
                                EOR     #$1234      ; imm
^FFFF:0185  00 49               .byte ]opc, val(mid$(]adr$, 2))
^FFFF:0186  12 34
                                EOR     #bakbyt
^FFFF:0187  00 49               .byte ]opc, val(mid$(]adr$, 2))
^FFFF:0188  12 34
                                EOR     #fwdbyt
^FFFF:0189  00 49               .byte ]opc, val(mid$(]adr$, 2))
^FFFF:018A  12 34
                                EOR     $1234       ; zp
^FFFF:018B  00 45               .byte ]opc
^FFFF:018C  12 34               .ubyte val(]adr$)
                                EOR     bakbyt
^FFFF:018D  00 45               .byte ]opc
^FFFF:018E  12 34               .ubyte val(]adr$)
                                EOR     fwdbyt
^FFFF:018F  00 4D               .byte ]opc+8
^FFFF:0190  12 34 00 00         .uword val(]adr$)
                                EOR     ($1234),y   ; zpiy
^FFFF:0192  00 51               .byte ]opc
^FFFF:0193  12 34               .ubyte val(]adr$)
                                EOR     (bakbyt),y
^FFFF:0194  00 51               .byte ]opc
^FFFF:0195  12 34               .ubyte val(]adr$)
                                EOR     (fwdbyt),y
^FFFF:0196  00 51               .byte ]opc
^FFFF:0197  12 34               .ubyte val(]adr$)
                                EOR     $1234,x     ; zpx
^FFFF:0198  00 55               .byte ]opc
^FFFF:0199  12 34               .ubyte val(]adr$)
                                EOR     bakbyt,x
^FFFF:019A  00 55               .byte ]opc
^FFFF:019B  12 34               .ubyte val(]adr$)
                                EOR     fwdbyt,x
^FFFF:019C  00 5D               .byte ]opc+8
^FFFF:019D  12 34 00 00         .uword val(]adr$)
                                EOR     ($1234,x)   ; zpxi
^FFFF:019F  00 41               .byte ]opc
^FFFF:01A0  12 34               .ubyte val(mid$(]adr$,2,indexr(]adr$,",
                        ")-2))
                                EOR     (bakbyt,x)
^FFFF:01A1  00 41               .byte ]opc
^FFFF:01A2  12 34               .ubyte val(mid$(]adr$,2,indexr(]adr$,",
                        ")-2))
                                EOR     (fwdbyt,x)
^FFFF:01A3  00 41               .byte ]opc
^FFFF:01A4  12 34               .ubyte val(mid$(]adr$,2,indexr(]adr$,",
                        ")-2))

                                INC     $12345678   ; ab
^FFFF:01A5  00 EE               .byte ]opc+8
^FFFF:01A6  56 78 12 34         .uword val(]adr$)
                                INC     bakwrd
^FFFF:01A8  00 EE               .byte ]opc+8
^FFFF:01A9  9A BC 56 78         .uword val(]adr$)
                                INC     fwdwrd
^FFFF:01AB  00 EE               .byte ]opc+8
^FFFF:01AC  9A BC 56 78         .uword val(]adr$)
                                INC     $12345678,x ; abx
^FFFF:01AE  00 FE               .byte ]opc+8
^FFFF:01AF  56 78 12 34         .uword val(]adr$)
                                INC     bakwrd,x
^FFFF:01B1  00 FE               .byte ]opc+8
^FFFF:01B2  9A BC 56 78         .uword val(]adr$)
                                INC     fwdwrd,x
^FFFF:01B4  00 FE               .byte ]opc+8
^FFFF:01B5  9A BC 56 78         .uword val(]adr$)
                                INC     $1234       ; zp
^FFFF:01B7  00 E6               .byte ]opc
^FFFF:01B8  12 34               .ubyte val(]adr$)
                                INC     bakbyt
^FFFF:01B9  00 E6               .byte ]opc
^FFFF:01BA  12 34               .ubyte val(]adr$)
                                INC     fwdbyt
^FFFF:01BB  00 EE               .byte ]opc+8
^FFFF:01BC  12 34 00 00         .uword val(]adr$)
                                INC     $1234,x     ; zpx
^FFFF:01BE  00 F6               .byte ]opc
^FFFF:01BF  12 34               .ubyte val(]adr$)
                                INC     bakbyt,x
^FFFF:01C0  00 F6               .byte ]opc
^FFFF:01C1  12 34               .ubyte val(]adr$)
                                INC     fwdbyt,x
^FFFF:01C2  00 FE               .byte ]opc+8
^FFFF:01C3  12 34 00 00         .uword val(]adr$)

                                INX                 ; imp
^FFFF:01C5  00 E8               .byte $E8

                                INY                 ; imp
^FFFF:01C6  00 C8               .byte $C8

                                JMP     $12345678   ; ab
^FFFF:01C7  00 4C               .byte ]adr$ ~ /^\(.+\)$/ ? $6C : $4C
^FFFF:01C8  56 78 12 34         .uword val(]adr$)
                                JMP     bakwrd
^FFFF:01CA  00 4C               .byte ]adr$ ~ /^\(.+\)$/ ? $6C : $4C
^FFFF:01CB  9A BC 56 78         .uword val(]adr$)
                                JMP     fwdwrd
^FFFF:01CD  00 4C               .byte ]adr$ ~ /^\(.+\)$/ ? $6C : $4C
^FFFF:01CE  9A BC 56 78         .uword val(]adr$)
                                JMP     ($1234)     ; abi
^FFFF:01D0  00 6C               .byte ]adr$ ~ /^\(.+\)$/ ? $6C : $4C
^FFFF:01D1  12 34 00 00         .uword val(]adr$)
                                JMP     (bakwrd)
^FFFF:01D3  00 6C               .byte ]adr$ ~ /^\(.+\)$/ ? $6C : $4C
^FFFF:01D4  9A BC 56 78         .uword val(]adr$)
                                JMP     (fwdwrd)
^FFFF:01D6  00 6C               .byte ]adr$ ~ /^\(.+\)$/ ? $6C : $4C
^FFFF:01D7  9A BC 56 78         .uword val(]adr$)

                                JSR     $12345678   ; ab
^FFFF:01D9  00 20               .byte $20
^FFFF:01DA  56 78 12 34         .uword $12345678
                                JSR     bakwrd
^FFFF:01DC  00 20               .byte $20
^FFFF:01DD  9A BC 56 78         .uword bakwrd
                                JSR     fwdwrd
^FFFF:01DF  00 20               .byte $20
^FFFF:01E0  9A BC 56 78         .uword fwdwrd

                                LDA     $12345678   ; ab
^FFFF:01E2  00 AD               .byte ]opc+8
^FFFF:01E3  56 78 12 34         .uword val(]adr$)
                                LDA     bakwrd
^FFFF:01E5  00 AD               .byte ]opc+8
^FFFF:01E6  9A BC 56 78         .uword val(]adr$)
                                LDA     fwdwrd
^FFFF:01E8  00 AD               .byte ]opc+8
^FFFF:01E9  9A BC 56 78         .uword val(]adr$)
                                LDA     $12345678,x ; abx
^FFFF:01EB  00 BD               .byte ]opc+8
^FFFF:01EC  56 78 12 34         .uword val(]adr$)
                                LDA     bakwrd,x
^FFFF:01EE  00 BD               .byte ]opc+8
^FFFF:01EF  9A BC 56 78         .uword val(]adr$)
                                LDA     fwdwrd,x
^FFFF:01F1  00 BD               .byte ]opc+8
^FFFF:01F2  9A BC 56 78         .uword val(]adr$)
                                LDA     $12345678,y ; aby
^FFFF:01F4  00 B9               .byte ]opc+8
^FFFF:01F5  56 78 12 34         .uword val(]adr$)
                                LDA     bakwrd,y
^FFFF:01F7  00 B9               .byte ]opc+8
^FFFF:01F8  9A BC 56 78         .uword val(]adr$)
                                LDA     fwdwrd,y
^FFFF:01FA  00 B9               .byte ]opc+8
^FFFF:01FB  9A BC 56 78         .uword val(]adr$)
                                LDA     #$1234      ; imm
^FFFF:01FD  00 A9               .byte ]opc, val(mid$(]adr$, 2))
^FFFF:01FE  12 34
                                LDA     #bakbyt
^FFFF:01FF  00 A9               .byte ]opc, val(mid$(]adr$, 2))
^FFFF:0200  12 34
                                LDA     #fwdbyt
^FFFF:0201  00 A9               .byte ]opc, val(mid$(]adr$, 2))
^FFFF:0202  12 34
                                LDA     $1234       ; zp
^FFFF:0203  00 A5               .byte ]opc
^FFFF:0204  12 34               .ubyte val(]adr$)
                                LDA     bakbyt
^FFFF:0205  00 A5               .byte ]opc
^FFFF:0206  12 34               .ubyte val(]adr$)
                                LDA     fwdbyt
^FFFF:0207  00 AD               .byte ]opc+8
^FFFF:0208  12 34 00 00         .uword val(]adr$)
                                LDA     ($1234),y   ; zpiy
^FFFF:020A  00 B1               .byte ]opc
^FFFF:020B  12 34               .ubyte val(]adr$)
                                LDA     (bakbyt),y
^FFFF:020C  00 B1               .byte ]opc
^FFFF:020D  12 34               .ubyte val(]adr$)
                                LDA     (fwdbyt),y
^FFFF:020E  00 B1               .byte ]opc
^FFFF:020F  12 34               .ubyte val(]adr$)
                                LDA     $1234,x     ; zpx
^FFFF:0210  00 B5               .byte ]opc
^FFFF:0211  12 34               .ubyte val(]adr$)
                                LDA     bakbyt,x
^FFFF:0212  00 B5               .byte ]opc
^FFFF:0213  12 34               .ubyte val(]adr$)
                                LDA     fwdbyt,x
^FFFF:0214  00 BD               .byte ]opc+8
^FFFF:0215  12 34 00 00         .uword val(]adr$)
                                LDA     ($1234,x)   ; zpxi
^FFFF:0217  00 A1               .byte ]opc
^FFFF:0218  12 34               .ubyte val(mid$(]adr$,2,indexr(]adr$,",
                        ")-2))
                                LDA     (bakbyt,x)
^FFFF:0219  00 A1               .byte ]opc
^FFFF:021A  12 34               .ubyte val(mid$(]adr$,2,indexr(]adr$,",
                        ")-2))
                                LDA     (fwdbyt,x)
^FFFF:021B  00 A1               .byte ]opc
^FFFF:021C  12 34               .ubyte val(mid$(]adr$,2,indexr(]adr$,",
                        ")-2))

                                LDX     $12345678   ; ab
^FFFF:021D  00 AE               .byte ]opc+8
^FFFF:021E  56 78 12 34         .uword val(]adr$)
                                LDX     bakwrd
^FFFF:0220  00 AE               .byte ]opc+8
^FFFF:0221  9A BC 56 78         .uword val(]adr$)
                                LDX     fwdwrd
^FFFF:0223  00 AE               .byte ]opc+8
^FFFF:0224  9A BC 56 78         .uword val(]adr$)
                                LDX     $12345678,y ; aby
^FFFF:0226  00 BE               .byte ]opc+8
^FFFF:0227  56 78 12 34         .uword val(]adr$)
                                LDX     bakwrd,y
^FFFF:0229  00 BE               .byte ]opc+8
^FFFF:022A  9A BC 56 78         .uword val(]adr$)
                                LDX     fwdwrd,y
^FFFF:022C  00 BE               .byte ]opc+8
^FFFF:022D  9A BC 56 78         .uword val(]adr$)
                                LDX     #12         ; imm
^FFFF:022F  00 A2               .byte ]opc, val(mid$(]adr$, 2))
^FFFF:0230  00 0C
                                LDX     #bakbyt
^FFFF:0231  00 A2               .byte ]opc, val(mid$(]adr$, 2))
^FFFF:0232  12 34
                                LDX     #fwdbyt
^FFFF:0233  00 A2               .byte ]opc, val(mid$(]adr$, 2))
^FFFF:0234  12 34
                                LDX     $1234       ; zp
^FFFF:0235  00 A6               .byte ]opc
^FFFF:0236  12 34               .ubyte val(]adr$)
                                LDX     bakbyt
^FFFF:0237  00 A6               .byte ]opc
^FFFF:0238  12 34               .ubyte val(]adr$)
                                LDX     fwdbyt
^FFFF:0239  00 AE               .byte ]opc+8
^FFFF:023A  12 34 00 00         .uword val(]adr$)
                                LDX     $12,y       ; zpy
^FFFF:023C  00 B6               .byte ]opc
^FFFF:023D  00 12               .ubyte val(]adr$)
                                LDX     bakbyt,y
^FFFF:023E  00 B6               .byte ]opc
^FFFF:023F  12 34               .ubyte val(]adr$)
                                LDX     fwdbyt,y
^FFFF:0240  00 BE               .byte ]opc+8
^FFFF:0241  12 34 00 00         .uword val(]adr$)

                                LDY     $12345678   ; ab
^FFFF:0243  00 AC               .byte ]opc+8
^FFFF:0244  56 78 12 34         .uword val(]adr$)
                                LDY     bakwrd
^FFFF:0246  00 AC               .byte ]opc+8
^FFFF:0247  9A BC 56 78         .uword val(]adr$)
                                LDY     fwdwrd
^FFFF:0249  00 AC               .byte ]opc+8
^FFFF:024A  9A BC 56 78         .uword val(]adr$)
                                LDY     $12345678,x ; abx
^FFFF:024C  00 BC               .byte ]opc+8
^FFFF:024D  56 78 12 34         .uword val(]adr$)
                                LDY     bakwrd,x
^FFFF:024F  00 BC               .byte ]opc+8
^FFFF:0250  9A BC 56 78         .uword val(]adr$)
                                LDY     fwdwrd,x
^FFFF:0252  00 BC               .byte ]opc+8
^FFFF:0253  9A BC 56 78         .uword val(]adr$)
                                LDY     #12         ; imm
^FFFF:0255  00 A0               .byte ]opc, val(mid$(]adr$, 2))
^FFFF:0256  00 0C
                                LDY     #bakbyt
^FFFF:0257  00 A0               .byte ]opc, val(mid$(]adr$, 2))
^FFFF:0258  12 34
                                LDY     #fwdbyt
^FFFF:0259  00 A0               .byte ]opc, val(mid$(]adr$, 2))
^FFFF:025A  12 34
                                LDY     $1234       ; zp
^FFFF:025B  00 A4               .byte ]opc
^FFFF:025C  12 34               .ubyte val(]adr$)
                                LDY     bakbyt
^FFFF:025D  00 A4               .byte ]opc
^FFFF:025E  12 34               .ubyte val(]adr$)
                                LDY     fwdbyt
^FFFF:025F  00 AC               .byte ]opc+8
^FFFF:0260  12 34 00 00         .uword val(]adr$)
                                LDY     $1234,x     ; zpx
^FFFF:0262  00 B4               .byte ]opc
^FFFF:0263  12 34               .ubyte val(]adr$)
                                LDY     bakbyt,x
^FFFF:0264  00 B4               .byte ]opc
^FFFF:0265  12 34               .ubyte val(]adr$)
                                LDY     fwdbyt,x
^FFFF:0266  00 BC               .byte ]opc+8
^FFFF:0267  12 34 00 00         .uword val(]adr$)

                                LSR     $12345678   ; ab
^FFFF:0269  00 4E               .byte ]opc+8
^FFFF:026A  56 78 12 34         .uword val(]adr$)
                                LSR     bakwrd
^FFFF:026C  00 4E               .byte ]opc+8
^FFFF:026D  9A BC 56 78         .uword val(]adr$)
                                LSR     fwdwrd
^FFFF:026F  00 4E               .byte ]opc+8
^FFFF:0270  9A BC 56 78         .uword val(]adr$)
                                LSR     $12345678,x ; abx
^FFFF:0272  00 5E               .byte ]opc+8
^FFFF:0273  56 78 12 34         .uword val(]adr$)
                                LSR     bakwrd,x
^FFFF:0275  00 5E               .byte ]opc+8
^FFFF:0276  9A BC 56 78         .uword val(]adr$)
                                LSR     fwdwrd,x
^FFFF:0278  00 5E               .byte ]opc+8
^FFFF:0279  9A BC 56 78         .uword val(]adr$)
                                LSR                 ; acc
^FFFF:027B  00 4A               .byte ]opc+4
                                LSR     a           ; acc
^FFFF:027C  00 4A               .byte ]opc+4
                                LSR     $1234       ; zp
^FFFF:027D  00 46               .byte ]opc
^FFFF:027E  12 34               .ubyte val(]adr$)
                                LSR     bakbyt
^FFFF:027F  00 46               .byte ]opc
^FFFF:0280  12 34               .ubyte val(]adr$)
                                LSR     fwdbyt
^FFFF:0281  00 4E               .byte ]opc+8
^FFFF:0282  12 34 00 00         .uword val(]adr$)
                                LSR     $1234,x     ; zpx
^FFFF:0284  00 56               .byte ]opc
^FFFF:0285  12 34               .ubyte val(]adr$)
                                LSR     bakbyt,x
^FFFF:0286  00 56               .byte ]opc
^FFFF:0287  12 34               .ubyte val(]adr$)
                                LSR     fwdbyt,x
^FFFF:0288  00 5E               .byte ]opc+8
^FFFF:0289  12 34 00 00         .uword val(]adr$)

                                NOP                 ; imp
^FFFF:028B  00 EA               .byte $EA

                                ORA     $12345678   ; ab
^FFFF:028C  00 0D               .byte ]opc+8
^FFFF:028D  56 78 12 34         .uword val(]adr$)
                                ORA     bakwrd
^FFFF:028F  00 0D               .byte ]opc+8
^FFFF:0290  9A BC 56 78         .uword val(]adr$)
                                ORA     fwdwrd
^FFFF:0292  00 0D               .byte ]opc+8
^FFFF:0293  9A BC 56 78         .uword val(]adr$)
                                ORA     $12345678,x ; abx
^FFFF:0295  00 1D               .byte ]opc+8
^FFFF:0296  56 78 12 34         .uword val(]adr$)
                                ORA     bakwrd,x
^FFFF:0298  00 1D               .byte ]opc+8
^FFFF:0299  9A BC 56 78         .uword val(]adr$)
                                ORA     fwdwrd,x
^FFFF:029B  00 1D               .byte ]opc+8
^FFFF:029C  9A BC 56 78         .uword val(]adr$)
                                ORA     $12345678,y ; aby
^FFFF:029E  00 19               .byte ]opc+8
^FFFF:029F  56 78 12 34         .uword val(]adr$)
                                ORA     bakwrd,y
^FFFF:02A1  00 19               .byte ]opc+8
^FFFF:02A2  9A BC 56 78         .uword val(]adr$)
                                ORA     fwdwrd,y
^FFFF:02A4  00 19               .byte ]opc+8
^FFFF:02A5  9A BC 56 78         .uword val(]adr$)
                                ORA     #$1234      ; imm
^FFFF:02A7  00 09               .byte ]opc, val(mid$(]adr$, 2))
^FFFF:02A8  12 34
                                ORA     #bakbyt
^FFFF:02A9  00 09               .byte ]opc, val(mid$(]adr$, 2))
^FFFF:02AA  12 34
                                ORA     #fwdbyt
^FFFF:02AB  00 09               .byte ]opc, val(mid$(]adr$, 2))
^FFFF:02AC  12 34
                                ORA     $1234       ; zp
^FFFF:02AD  00 05               .byte ]opc
^FFFF:02AE  12 34               .ubyte val(]adr$)
                                ORA     bakbyt
^FFFF:02AF  00 05               .byte ]opc
^FFFF:02B0  12 34               .ubyte val(]adr$)
                                ORA     fwdbyt
^FFFF:02B1  00 0D               .byte ]opc+8
^FFFF:02B2  12 34 00 00         .uword val(]adr$)
                                ORA     ($1234),y   ; zpiy
^FFFF:02B4  00 11               .byte ]opc
^FFFF:02B5  12 34               .ubyte val(]adr$)
                                ORA     (bakbyt),y
^FFFF:02B6  00 11               .byte ]opc
^FFFF:02B7  12 34               .ubyte val(]adr$)
                                ORA     (fwdbyt),y
^FFFF:02B8  00 11               .byte ]opc
^FFFF:02B9  12 34               .ubyte val(]adr$)
                                ORA     $1234,x     ; zpx
^FFFF:02BA  00 15               .byte ]opc
^FFFF:02BB  12 34               .ubyte val(]adr$)
                                ORA     bakbyt,x
^FFFF:02BC  00 15               .byte ]opc
^FFFF:02BD  12 34               .ubyte val(]adr$)
                                ORA     fwdbyt,x
^FFFF:02BE  00 1D               .byte ]opc+8
^FFFF:02BF  12 34 00 00         .uword val(]adr$)
                                ORA     ($1234,x)   ; zpxi
^FFFF:02C1  00 01               .byte ]opc
^FFFF:02C2  12 34               .ubyte val(mid$(]adr$,2,indexr(]adr$,",
                        ")-2))
                                ORA     (bakbyt,x)
^FFFF:02C3  00 01               .byte ]opc
^FFFF:02C4  12 34               .ubyte val(mid$(]adr$,2,indexr(]adr$,",
                        ")-2))
                                ORA     (fwdbyt,x)
^FFFF:02C5  00 01               .byte ]opc
^FFFF:02C6  12 34               .ubyte val(mid$(]adr$,2,indexr(]adr$,",
                        ")-2))

                                PHA                 ; imp
^FFFF:02C7  00 48               .byte $48

                                PHP                 ; imp
^FFFF:02C8  00 08               .byte $08

                                PLA                 ; imp
^FFFF:02C9  00 68               .byte $68

                                PLP                 ; imp
^FFFF:02CA  00 28               .byte $28

                                ROL     $12345678   ; ab
^FFFF:02CB  00 2E               .byte ]opc+8
^FFFF:02CC  56 78 12 34         .uword val(]adr$)
                                ROL     bakwrd
^FFFF:02CE  00 2E               .byte ]opc+8
^FFFF:02CF  9A BC 56 78         .uword val(]adr$)
                                ROL     fwdwrd
^FFFF:02D1  00 2E               .byte ]opc+8
^FFFF:02D2  9A BC 56 78         .uword val(]adr$)
                                ROL     $12345678,x ; abx
^FFFF:02D4  00 3E               .byte ]opc+8
^FFFF:02D5  56 78 12 34         .uword val(]adr$)
                                ROL     bakwrd,x
^FFFF:02D7  00 3E               .byte ]opc+8
^FFFF:02D8  9A BC 56 78         .uword val(]adr$)
                                ROL     fwdwrd,x
^FFFF:02DA  00 3E               .byte ]opc+8
^FFFF:02DB  9A BC 56 78         .uword val(]adr$)
                                ROL                 ; acc
^FFFF:02DD  00 2A               .byte ]opc+4
                                ROL     a           ; acc
^FFFF:02DE  00 2A               .byte ]opc+4
                                ROL     $1234       ; zp
^FFFF:02DF  00 26               .byte ]opc
^FFFF:02E0  12 34               .ubyte val(]adr$)
                                ROL     bakbyt
^FFFF:02E1  00 26               .byte ]opc
^FFFF:02E2  12 34               .ubyte val(]adr$)
                                ROL     fwdbyt
^FFFF:02E3  00 2E               .byte ]opc+8
^FFFF:02E4  12 34 00 00         .uword val(]adr$)
                                ROL     $1234,x     ; zpx
^FFFF:02E6  00 36               .byte ]opc
^FFFF:02E7  12 34               .ubyte val(]adr$)
                                ROL     bakbyt,x
^FFFF:02E8  00 36               .byte ]opc
^FFFF:02E9  12 34               .ubyte val(]adr$)
                                ROL     fwdbyt,x
^FFFF:02EA  00 3E               .byte ]opc+8
^FFFF:02EB  12 34 00 00         .uword val(]adr$)

                                ROR     $12345678   ; ab
^FFFF:02ED  00 6E               .byte ]opc+8
^FFFF:02EE  56 78 12 34         .uword val(]adr$)
                                ROR     bakwrd
^FFFF:02F0  00 6E               .byte ]opc+8
^FFFF:02F1  9A BC 56 78         .uword val(]adr$)
                                ROR     fwdwrd
^FFFF:02F3  00 6E               .byte ]opc+8
^FFFF:02F4  9A BC 56 78         .uword val(]adr$)
                                ROR     $12345678,x ; abx
^FFFF:02F6  00 7E               .byte ]opc+8
^FFFF:02F7  56 78 12 34         .uword val(]adr$)
                                ROR     bakwrd,x
^FFFF:02F9  00 7E               .byte ]opc+8
^FFFF:02FA  9A BC 56 78         .uword val(]adr$)
                                ROR     fwdwrd,x
^FFFF:02FC  00 7E               .byte ]opc+8
^FFFF:02FD  9A BC 56 78         .uword val(]adr$)
                                ROR                 ; acc
^FFFF:02FF  00 6A               .byte ]opc+4
                                ROR     a           ; acc
^FFFF:0300  00 6A               .byte ]opc+4
                                ROR     $1234       ; zp
^FFFF:0301  00 66               .byte ]opc
^FFFF:0302  12 34               .ubyte val(]adr$)
                                ROR     bakbyt
^FFFF:0303  00 66               .byte ]opc
^FFFF:0304  12 34               .ubyte val(]adr$)
                                ROR     fwdbyt
^FFFF:0305  00 6E               .byte ]opc+8
^FFFF:0306  12 34 00 00         .uword val(]adr$)
                                ROR     $1234,x     ; zpx
^FFFF:0308  00 76               .byte ]opc
^FFFF:0309  12 34               .ubyte val(]adr$)
                                ROR     bakbyt,x
^FFFF:030A  00 76               .byte ]opc
^FFFF:030B  12 34               .ubyte val(]adr$)
                                ROR     fwdbyt,x
^FFFF:030C  00 7E               .byte ]opc+8
^FFFF:030D  12 34 00 00         .uword val(]adr$)

                                RTI                 ; imp
^FFFF:030F  00 40               .byte $40

                                RTS                 ; imp
^FFFF:0310  00 60               .byte $60

                                SBC     $12345678   ; ab
^FFFF:0311  00 ED               .byte ]opc+8
^FFFF:0312  56 78 12 34         .uword val(]adr$)
                                SBC     bakwrd
^FFFF:0314  00 ED               .byte ]opc+8
^FFFF:0315  9A BC 56 78         .uword val(]adr$)
                                SBC     fwdwrd
^FFFF:0317  00 ED               .byte ]opc+8
^FFFF:0318  9A BC 56 78         .uword val(]adr$)
                                SBC     $12345678,x ; abx
^FFFF:031A  00 FD               .byte ]opc+8
^FFFF:031B  56 78 12 34         .uword val(]adr$)
                                SBC     bakwrd,x
^FFFF:031D  00 FD               .byte ]opc+8
^FFFF:031E  9A BC 56 78         .uword val(]adr$)
                                SBC     fwdwrd,x
^FFFF:0320  00 FD               .byte ]opc+8
^FFFF:0321  9A BC 56 78         .uword val(]adr$)
                                SBC     $12345678,y ; aby
^FFFF:0323  00 F9               .byte ]opc+8
^FFFF:0324  56 78 12 34         .uword val(]adr$)
                                SBC     bakwrd,y
^FFFF:0326  00 F9               .byte ]opc+8
^FFFF:0327  9A BC 56 78         .uword val(]adr$)
                                SBC     fwdwrd,y
^FFFF:0329  00 F9               .byte ]opc+8
^FFFF:032A  9A BC 56 78         .uword val(]adr$)
                                SBC     #$1234      ; imm
^FFFF:032C  00 E9               .byte ]opc, val(mid$(]adr$, 2))
^FFFF:032D  12 34
                                SBC     #bakbyt
^FFFF:032E  00 E9               .byte ]opc, val(mid$(]adr$, 2))
^FFFF:032F  12 34
                                SBC     #fwdbyt
^FFFF:0330  00 E9               .byte ]opc, val(mid$(]adr$, 2))
^FFFF:0331  12 34
                                SBC     $1234       ; zp
^FFFF:0332  00 E5               .byte ]opc
^FFFF:0333  12 34               .ubyte val(]adr$)
                                SBC     bakbyt
^FFFF:0334  00 E5               .byte ]opc
^FFFF:0335  12 34               .ubyte val(]adr$)
                                SBC     fwdbyt
^FFFF:0336  00 ED               .byte ]opc+8
^FFFF:0337  12 34 00 00         .uword val(]adr$)
                                SBC     ($1234),y   ; zpiy
^FFFF:0339  00 F1               .byte ]opc
^FFFF:033A  12 34               .ubyte val(]adr$)
                                SBC     (bakbyt),y
^FFFF:033B  00 F1               .byte ]opc
^FFFF:033C  12 34               .ubyte val(]adr$)
                                SBC     (fwdbyt),y
^FFFF:033D  00 F1               .byte ]opc
^FFFF:033E  12 34               .ubyte val(]adr$)
                                SBC     $1234,x     ; zpx
^FFFF:033F  00 F5               .byte ]opc
^FFFF:0340  12 34               .ubyte val(]adr$)
                                SBC     bakbyt,x
^FFFF:0341  00 F5               .byte ]opc
^FFFF:0342  12 34               .ubyte val(]adr$)
                                SBC     fwdbyt,x
^FFFF:0343  00 FD               .byte ]opc+8
^FFFF:0344  12 34 00 00         .uword val(]adr$)
                                SBC     ($1234,x)   ; zpxi
^FFFF:0346  00 E1               .byte ]opc
^FFFF:0347  12 34               .ubyte val(mid$(]adr$,2,indexr(]adr$,",
                        ")-2))
                                SBC     (bakbyt,x)
^FFFF:0348  00 E1               .byte ]opc
^FFFF:0349  12 34               .ubyte val(mid$(]adr$,2,indexr(]adr$,",
                        ")-2))
                                SBC     (fwdbyt,x)
^FFFF:034A  00 E1               .byte ]opc
^FFFF:034B  12 34               .ubyte val(mid$(]adr$,2,indexr(]adr$,",
                        ")-2))

                                SEC                 ; imp
^FFFF:034C  00 38               .byte $38

                                SED                 ; imp
^FFFF:034D  00 F8               .byte $F8

                                SEI                 ; imp
^FFFF:034E  00 78               .byte $78

Oops - previews nicely but doesn't post nicely; I'll split this at "STA"

Last edited by teamtempest on Sun Jun 12, 2011 4:20 am, edited 1 time in total.

Top

teamtempest

Post subject:

Posted: Sun Jun 12, 2011 4:19 am

Joined: Sun Nov 08, 2009 1:56 am
Posts: 390
Location: Minnesota

Code:

HXA v0.180 Listing File - T_32_L16 Instruction Set - Sat Jun 11 21:13:33 
                        2011

                                STA     $12345678   ; ab
^FFFF:034F  00 8D               .byte ]opc+8
^FFFF:0350  56 78 12 34         .uword val(]adr$)
                                STA     bakwrd
^FFFF:0352  00 8D               .byte ]opc+8
^FFFF:0353  9A BC 56 78         .uword val(]adr$)
                                STA     fwdwrd
^FFFF:0355  00 8D               .byte ]opc+8
^FFFF:0356  9A BC 56 78         .uword val(]adr$)
                                STA     $12345678,x ; abx
^FFFF:0358  00 9D               .byte ]opc+8
^FFFF:0359  56 78 12 34         .uword val(]adr$)
                                STA     bakwrd,x
^FFFF:035B  00 9D               .byte ]opc+8
^FFFF:035C  9A BC 56 78         .uword val(]adr$)
                                STA     fwdwrd,x
^FFFF:035E  00 9D               .byte ]opc+8
^FFFF:035F  9A BC 56 78         .uword val(]adr$)
                                STA     $12345678,y ; aby
^FFFF:0361  00 99               .byte ]opc+8
^FFFF:0362  56 78 12 34         .uword val(]adr$)
                                STA     bakwrd,y
^FFFF:0364  00 99               .byte ]opc+8
^FFFF:0365  9A BC 56 78         .uword val(]adr$)
                                STA     fwdwrd,y
^FFFF:0367  00 99               .byte ]opc+8
^FFFF:0368  9A BC 56 78         .uword val(]adr$)
                                STA     $1234       ; zp
^FFFF:036A  00 85               .byte ]opc
^FFFF:036B  12 34               .ubyte val(]adr$)
                                STA     bakbyt
^FFFF:036C  00 85               .byte ]opc
^FFFF:036D  12 34               .ubyte val(]adr$)
                                STA     fwdbyt
^FFFF:036E  00 8D               .byte ]opc+8
^FFFF:036F  12 34 00 00         .uword val(]adr$)
                                STA     ($1234),y   ; zpiy
^FFFF:0371  00 91               .byte ]opc
^FFFF:0372  12 34               .ubyte val(]adr$)
                                STA     (bakbyt),y
^FFFF:0373  00 91               .byte ]opc
^FFFF:0374  12 34               .ubyte val(]adr$)
                                STA     (fwdbyt),y
^FFFF:0375  00 91               .byte ]opc
^FFFF:0376  12 34               .ubyte val(]adr$)
                                STA     $1234,x     ; zpx
^FFFF:0377  00 95               .byte ]opc
^FFFF:0378  12 34               .ubyte val(]adr$)
                                STA     bakbyt,x
^FFFF:0379  00 95               .byte ]opc
^FFFF:037A  12 34               .ubyte val(]adr$)
                                STA     fwdbyt,x
^FFFF:037B  00 9D               .byte ]opc+8
^FFFF:037C  12 34 00 00         .uword val(]adr$)
                                STA     ($1234,x)   ; zpxi
^FFFF:037E  00 81               .byte ]opc
^FFFF:037F  12 34               .ubyte val(mid$(]adr$,2,indexr(]adr$,",
                        ")-2))
                                STA     (bakbyt,x)
^FFFF:0380  00 81               .byte ]opc
^FFFF:0381  12 34               .ubyte val(mid$(]adr$,2,indexr(]adr$,",
                        ")-2))
                                STA     (fwdbyt,x)
^FFFF:0382  00 81               .byte ]opc
^FFFF:0383  12 34               .ubyte val(mid$(]adr$,2,indexr(]adr$,",
                        ")-2))

                                STX     $12345678   ; ab
^FFFF:0384  00 8E               .byte ]opc+8
^FFFF:0385  56 78 12 34         .uword val(]adr$)
                                STX     bakwrd
^FFFF:0387  00 8E               .byte ]opc+8
^FFFF:0388  9A BC 56 78         .uword val(]adr$)
                                STX     fwdwrd
^FFFF:038A  00 8E               .byte ]opc+8
^FFFF:038B  9A BC 56 78         .uword val(]adr$)
                                STX     $1234       ; zp
^FFFF:038D  00 86               .byte ]opc
^FFFF:038E  12 34               .ubyte val(]adr$)
                                STX     bakbyt
^FFFF:038F  00 86               .byte ]opc
^FFFF:0390  12 34               .ubyte val(]adr$)
                                STX     fwdbyt
^FFFF:0391  00 8E               .byte ]opc+8
^FFFF:0392  12 34 00 00         .uword val(]adr$)
                                STX     $12,y       ; zpy
^FFFF:0394  00 96               .byte ]opc
^FFFF:0395  00 12               .ubyte val(]adr$)
                                STX     bakbyt,y
^FFFF:0396  00 96               .byte ]opc
^FFFF:0397  12 34               .ubyte val(]adr$)
                                STX     fwdbyt,y
^FFFF:0398  00 96               .byte ]opc
^FFFF:0399  12 34               .ubyte val(]adr$)

                                STY     $12345678   ; ab
^FFFF:039A  00 8C               .byte ]opc+8
^FFFF:039B  56 78 12 34         .uword val(]adr$)
                                STY     bakwrd
^FFFF:039D  00 8C               .byte ]opc+8
^FFFF:039E  9A BC 56 78         .uword val(]adr$)
                                STY     fwdwrd
^FFFF:03A0  00 8C               .byte ]opc+8
^FFFF:03A1  9A BC 56 78         .uword val(]adr$)
                                STY     $1234       ; zp
^FFFF:03A3  00 84               .byte ]opc
^FFFF:03A4  12 34               .ubyte val(]adr$)
                                STY     bakbyt
^FFFF:03A5  00 84               .byte ]opc
^FFFF:03A6  12 34               .ubyte val(]adr$)
                                STY     fwdbyt
^FFFF:03A7  00 8C               .byte ]opc+8
^FFFF:03A8  12 34 00 00         .uword val(]adr$)
                                STY     $1234,x     ; zpx
^FFFF:03AA  00 94               .byte ]opc
^FFFF:03AB  12 34               .ubyte val(]adr$)
                                STY     bakbyt,x
^FFFF:03AC  00 94               .byte ]opc
^FFFF:03AD  12 34               .ubyte val(]adr$)
                                STY     fwdbyt,x
^FFFF:03AE  00 94               .byte ]opc
^FFFF:03AF  12 34               .ubyte val(]adr$)

                                TAX                 ; imp
^FFFF:03B0  00 AA               .byte $AA

                                TAY                 ; imp
^FFFF:03B1  00 A8               .byte $A8

                                TSX                 ; imp
^FFFF:03B2  00 BA               .byte $BA

                                TXA                 ; imp
^FFFF:03B3  00 8A               .byte $8A

                                TXS                 ; imp
^FFFF:03B4  00 9A               .byte $9A

                                TYA                 ; imp
^FFFF:03B5  00 98               .byte $98

                        ; forward reference

                        fwdbyt  .equ    $1234
                        fwdwrd  .equ    $56789ABC

                        ; -------------------------------

                                .end

*** Symbol Table Listing

Numeric Name     Ref Cnt   Hex Value    Dec Value

 BAKBYT              142   $    1234         4660
 BAKTARGET            10   $FFFF0098   4294901912
 BAKWRD              122   $56789ABC   1450744508
 CPU65ORG16            1   $      01            1
 FWDBYT               68   $    1234         4660
 FWDTARGET            10   $FFFF00DD   4294901981
 FWDWRD               48   $56789ABC   1450744508
 ZP_MASK             148   $FFFF0000   4294901760
 ]OPC                640   $      94          148

Numeric Value    Ref Cnt   Hex Value    Dec Value

 CPU65ORG16            1   $      01            1
 BAKBYT              142   $    1234         4660
 FWDBYT               68   $    1234         4660
 BAKWRD              122   $56789ABC   1450744508
 FWDWRD               48   $56789ABC   1450744508
 ZP_MASK             148   $FFFF0000   4294901760
 BAKTARGET            10   $FFFF0098   4294901912
 FWDTARGET            10   $FFFF00DD   4294901981

String Name      Ref Cnt   Value

 ]ADR$              1060  "fwdbyt"
 ]NDX$               637  "x"

Macro Name       Exp Cnt

 AB.ABX.ZP.ZPX        24
 AB.ACC.ZP            32
 AB.IMM.ZP            36
 AB.IMM.ZP.ZPXI       93
 AB.ZP               222
 ABY.ZPIY             48
 ADC                  24
 AND                  24
 ARITH.LOGIC         189
 ASL                  14
 BADMODE               -
 BCC                   2
 BCS                   2
 BEQ                   2
 BGE                   2
 BIT                   6
 BLT                   2
 BMI                   2
 BNE                   2
 BPL                   2
 BRK                   7
 BVC                   2
 BVS                   2
 CLC                   1
 CLD                   1
 CLI                   1
 CLV                   1
 CMP                  24
 CPX                   9
 CPY                   9
 DEC                  12
 DEX                   1
 DEY                   1
 EOR                  24
 IMM                  36
 INC                  12
 INX                   1
 INY                   1
 JMP                   6
 JSR                   3
 LDA                  24
 LDX                  15
 LDY                  15
 LSR                  14
 NOP                   1
 ORA                  24
 PCR                  20
 PHA                   1
 PHP                   1
 PLA                   1
 PLP                   1
 ROL                  14
 ROR                  14
 RTI                   1
 RTS                   1
 SBC                  24
 SEC                   1
 SED                   1
 SEI                   1
 SHIFT                56
 STA                  21
 STX                   9
 STY                   9
 TAX                   1
 TAY                   1
 TSX                   1
 TXA                   1
 TXS                   1
 TYA                   1
 ZP                    9
 ZPXI                 24

*** Assembly Statistics Listing

Pass One time= 00:00:13

Source lines= 993
 Macro lines= 7404
 Total lines= 8397

Lines/Sec= 645.9

Pass Two time= 00:00:01

Data Values= 769

Values/Sec= 769.0

   Total time= 00:00:14

Object Bytes= 950

Expressions cached= 25
 Cache hits= 1920
Regexes cached= 7
 Cache hits= 772

Top

ElEctric_EyE

Post subject:

Posted: Mon Jun 13, 2011 12:02 am

Joined: Mon Mar 02, 2009 7:27 pm
Posts: 3258
Location: NC, USA

Teamtempest, Thanks for your hard work!
I don't fully understand everything you've done here as I have not yet experimented with HXA. It looks like you are creating opcodes by using macros, then defining sub-actions?...Just by looking at the opcode values in the last section you posted, it looks like HXA follows the 65Org16 architecture. What language do you use for HXA?

I'm sure BigEd will respond to your efforts in due time, but I thought I would chime in for now...

_________________
65Org16:https://github.com/ElEctric-EyE/verilog-6502

Top

teamtempest

Post subject:

Posted: Tue Jun 14, 2011 4:13 am

Joined: Sun Nov 08, 2009 1:56 am
Posts: 390
Location: Minnesota

Hi EE,

Mostly what I've done so far is change two things: (1) CPU initialization and (2) byte extractions, so 8-, 16- and 32-bit "bytes" are supported. There are some additional minor changes here and there, all of which are related to these two. Taken together these are enough to support all the data storage pseudo ops that are related to numeric quantities (data storage of strings and string-like things still has to be tackled).

I did not actually add any new data types as I had earlier mused about. It's more like subtracting them, or more properly restricting the allowed data types to the smallest that supports one "byte" and every multiple of that size which has 32 bits or less (HXA's implementation language doesn't have the numeric precision necessary to go to beyond that).

This version hasn't yet been posted. It'll be 0.180 when it is, whether or not these particular changes survive; currently the 0.170 version is what's on the website.

The 6502-instruction macro file (1) was created years ago as a demo to show off how powerful HXA's expression evaluation had become. Some top-level "instruction" macros call on nested macros to analyze address modes, etc. These might be the "sub-actions" you're referring to. I'm basically exploiting regularities in the instruction set to avoid writing out each individual instruction in full.

There's already a native 65xx version of HXA, so the point was more about versatility than speed. I arranged things so that both the native and macro versions could assemble the same test file of 6502 instructions (2).

When I realized I could easily dynamically assign "BYTE" and "WORD" as aliases for different "byte" sizes, it became apparent that I could use the same macro instruction file again.

I should mention that numeric data storage of any type comes in four flavors. For example, "BYTE" stores the lowest "byte" of an originally 32-bit value, ignoring all other "bytes". "UBYTE" (unsigned byte) and "SBYTE" (signed byte) do the same but also make sure the value actually fits in a "byte" (ie., the unstored "bytes" are not ignored). "RBYTE" (pc-relative byte) first adjusts the 32-bit value and then acts like "SBYTE".

This is why there's no explicit range-checking of stored values in the macro file. HXA handles all that internally based on what pseudo op is used.

A similar scheme exists for "WORD" aliases. When I reviewed the macro file and saw it just used "BYTE"- and "WORD"-family aliases I realized just one change to the cpu initialization would be necessary. Oops, two: the mask value that helps determine if a quantity fits on zero page or is absolute had to change to reflect a larger "zero page"

The test file (4) is modified from (2), mainly in that I used larger absolute quantities on some of the test values so they'd fill out 32 bits.

Files (3) and (5) are just the output of (2) and (4) for comparison purposes and to see if (5) is what the 65Org16 cpu expects to see. If not, now's the time to make changes.

The language I use is Thompson AWK (TAWK), a compiled and extended version of the original AWK language. I use it as a hammer on anything that looks like a text file. Worth every penny I paid for it. Unfortunately it's been withdrawn from commercial distribution for quite a few years (to hazard a guess, I think Perl might have killed it).

Gnu AWK (GAWK) is free and finally starting to develop some of the capabilities of TAWK. It's interpreted rather than compiled, but a port might not be too difficult. Javascript and D might be other possible port languages because they support regular expressions and associative arrays.

Top

teamtempest

Post subject:

Posted: Sun Jun 19, 2011 9:08 pm

Joined: Sun Nov 08, 2009 1:56 am
Posts: 390
Location: Minnesota

Not to throw a damper on anything, but the code I wrote to make the byte values comes out the way they did was - ugly. Really, really ugly. So ugly I threw it out rather than try to pretty it up.

Instead I've extended the ASSUME pseudo op to allow custom byte extraction sequences. HXA now still knows only two natively, LSB-first and MSB-first, but can be told to use any other sequence for any particular -BIT-- pseudo op.

So initializing the 65Org16 in a macro file now looks like this:

Code:

.cpu T_32_L16                    ; 32-bit PC range, 16-bit "byte"
.assume BIT16=10, BIT32=1032

given that HXA's native representation of a 32-bit value is in 3210 order, highest octet to lowest octet. Left alone, the "L"-for-LSB designation yields the default equivalent of BIT16=01, BIT32=0123.

Naturally the routines that implement this are accessible to a native implementation (and calling them looks pretty much just like this, except without the overhead of going through the pseudo op dispatcher).

So whatever the desired sequence of octets turns out to be, there's a mechanism for creating it without requiring a re-write of the base code.

I've added zero-padding of 8-bit char values out to 16- and 32-bits. That was easy but exposed some address reporting issues when listing. Those are resolved, but it occured to me there's another place where this is important: Intel and Motorola hexadecimal output files. Intel uses address offsets and Motorola uses absolute addresses, but in both cases a data line contains an address indication as part of the text.

The question is what that indication should be based on. My first thought is to base it on the actual "byte size", so that it reflects the actual address of the next value stored in terms of the destination processor.

However I'm not certain what existing loader programs would do with that. As a highly simplified example for illustration, suppose in an 8-bit byte world we have data lines like this:

Code:

1000 0001020304050607
1008 08090A0B0C0D0E0F

In a 16-bit byte world I think it would be simplest to output this:

Code:

1000 00000100020003000400050006000700
1008 080009000A000B000C000D000E000F00

Not least because the identical address indications would make it easy to check against the earlier 8-bit byte version

Also there's a mechanism to adjust the number of data bytes output, and I don't want to have to verify that it's a multiple of the "byte size" (otherwise a "byte" could be split over two lines, and what's the address of that?). Instead I want to simply output that number of "bytes", however many characters it takes.

Now what I'm wondering about is loaders that think only in terms of 8-bit bytes. It seems to me that in the 16-bit case, the first line would get loaded in the range 1000-100F, and the second in the range 1008-1017. That is, the second line would partially overwrite the first at load time.

Is this a valid concern? Or can I just go ahead and write it the simple way I have in mind?

Top

Page 2 of 9

[ 132 posts ]

Go to page Previous 1, 2, 3, 4, 5 ... 9 Next

Board index » 6502.org Users Forum » Programming

All times are UTC

Who is online

Users browsing this forum: No registered users and 2 guests

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