====================================================================
DR 6502 AER 201S Engineering Design 6502 Execution Simulator
====================================================================
Supplementary Notes By: M.J.Malone
Addressing Modes - The Meaning of Arg, Offset and Dest
======================================================
Arg, Offset and Dest are the arguments for various
instructions. Since the arguments of instructions are usually
referred to by their addresses, the different methods of expressing
arguments are called addressing modes. 'Arg' type addressing modes
refer to a piece of data usually by its address. The 'Offset'
addressing mode is used by branch statements to give a program
destination by an offset byte. 'Dest' addressing modes are used to
point to a destination in the program.
The Use of Labels
=================
Assembly code more often uses assembler labels than actual
numbers as arguments to increase the readability. In the following
example the address of the VIA port, a commonly used memory
location, will be assigned a descriptive name to make its later
occurrences in assembly code more legible:
;
Port_A = $A001
;
Here is another example where a label is assigned the value of a
commonly used constant for improved readability:
;
MotorBit_Mask = %0000111
;
The use of labels can vastly change the appearance of assembly
but does not alter the behavior of addressing modes at all.
The Addressing Modes
====================
If there are No Arguments:
- ————————-
0) Implied
Some instructions (ie. CLC, SEC, CLD, NOP, BRK, PHA, RTI, RTS
etc) do not require arguments. In this case the argument is said to
be 'IMPLIED' in the instruction. This is called the implied
addressing mode.
In Assembly: CLC
page 2
'Arg': Refers to a place to find data, usually a memory location
- —————————————————————-
1) Accumulator
The vast majority of statements manipulate data in one way or
another and require data for arguments. The first and easiest piece
of data to use as an argument is the .A accumulator. Operator
instructions such as ROL, ROR, ASL and LSR (and INC and DEC in the
65C02) can use the ACCUMULATOR addressing mode.
In Assembly: ROR A
2) Immediate
Often a constant (a number) is required in calculations. LDA
#$00 takes the number (#) $00 and places it in the accumulator.
This is called the IMMEDIATE addressing mode. The following
statements can be used with the immediate addressing mode: ADC, AND,
CMP, CPX, CPY, EOR, LDA, LDX, LDY, ORA and SBC.
In Assembly: ADC #$01
LDA #Constant EOR #Bit_Mask CMP #5
3) Zero Page
The memory of the 6502 is divided into $100 (256) pages of
$100 (256) bytes each. The pages are numbered from 0 through $FF.
Page 0 address are in the range $0000-$00FF. Because 'Zero Page'
addresses can be specified in just one byte, instructions using them
as arguments can be executed more quickly by the 6502. The
statement LDA $80 causes the 6502 to fetch the value from memory
location $0080 and place it in the accumulator. Note that the only
difference between the immediate and zero page syntax is the #
number sign. LDA #$80 means load the number (#) $80 into the
accumulator. LDA $80 means load the contents of memory location
$0080 into the accumulator. When reading assembly code, the
difference is subtle but very important. Zero page addressing can
be used with every instruction that uses a data type argument.
(This excludes only those that use no argument: CLC, RTI, NOP etc.
or a program go to type argument JMP xxxx, JSR xxxx etc.)
In Assembly: ADC $80
LDA Temp ( Assuming $00 <= Temp <= $FF )
4) X and Y Indexed Zero Page
Often data is organized into groups of bytes as a table, an
array or a record. In this case it is convenient to specify an
address as an offset relative to the beginning of the data
page 3
structure. The 6502 implements this method using INDEXED
addressing. In this case the .X or .Y register is used to add to a
zero page address to result in an effective address. IE: LDA $80,X
(when .X=#$05) results in a fetch from memory location
($0080+$05)=$0085. This is called the ZERO PAGE X INDEXED
addressing mode. The zero page x indexed addressing mode can be
used with all instructions except BIT, CPX, CPY, LDX and STX. Note
that the .X and .Y registers can take on values of only $00-$FF so
the data table is limited in size to $100 bytes.
There is also a Y indexed zero page addressing mode but it can
be used only with the LDX and STX instructions. This may seem very
limiting at first but consider the high level expression:
code = Data[ Index_Pointer[i] ];
Where Index_Pointer[] is a small look-up table of pointers to data
in the look-up table Data[]. This can be coded easily as:
LDY i
LDX Index_Pointer,Y LDA Data,X STA code ; 14 machine cycles total
Note that indexed zero page addressing cannot result in an effective
address outside the zero page. If the sum of the value in the .X
register and the base address exceed $FF then the fetch will wrap
around to $00 again. For example if the .X register were #$20 then
the following memory fetch 'LDA $F0,X' would result in the effective
address of ($00F0+$20)=$0110 but the memory fetch would be done on
address $0010, still on the zero page.
Note that indexed zero page addressing always takes one machine
cycle more than non-indexed zero page addressing and hence should be
avoided. Often programmers get in the habit of creating small
indexed loops to perform operations resulting in a shorter length of
assembly code. In the case of mathematics subroutines that
manipulate multibyte numbers on the zero page, loops should never be
used. The extra overhead required in the INcrement or DEcrement and
the Branch instructions as well as the extra machine cycle in each
indexed reference can make these routines take almost twice as long
to execute as the unravelled equivalent non-indexed routines. 5)
Absolute
Usually arguments are not stored only on the zero page but
come from anywhere in memory. The easiest way to specify a general
memory address is to give the full 16 bit address. For example LDA
$8000, loads the 8 bit number ($00-$FF) from the memory location
$8000. This method of specifying an address is called the ABSOLUTE
addressing mode.
In Assembly: LDA Port_A
ADC $C000
page 4
6) X and Y Indexed Absolute
As with zero page addressing, absolute addressing can be
indexed as well allowing the entire address space of the 6502 to be
used in data tables. The X indexed absolute addressing mode may not
be used with: BIT, CPX, CPY, LDX, STX or STY but may be used with
LDY. The Y indexed absolute addressing has a similar list except it
can be used for LDX and not LDY and cannot be used for the operator
instructions ASL, DEC, INC, LSR, ROL or ROR.
The absolute X and Y indexed addressing modes require the SAME
number of clock cycles to perform as the non-indexed absolute mode.
There is therefore NO PENALTY in access time for referring to data
as part of a table through indexed addressing in absolute mode.
There is of course the INcrement or DEcrement statement, the Branch
and possibly the ComParison to create the indexed loop that requires
more time over sequential, direct, absolute fetches. The large size
of data tables located outside the zero page usually makes
sequential absolute fetches impractical since the number of assembly
language statements is directly dependent on the size of the table.
If the size of the table is variable then indexing must be used. It
is often desirable therefore to use indexed absolute addressing and
data tables to organize data and reduce the length of the code
through indexed loops.
There are exceptions to the above statement that indexed and
non-indexed absolute addressing require the same number of cycles to
execute. The first exception is the use of X indexing with the
operator instructions (Y indexing is not available) ASL, DEC, INC,
LSR, ROL and ROR. For these instructions, the indexed absolute
addressing mode always takes one additional cycle over the regular
absolute addressing mode.
The second exception has to do with memory pages. For absolute
indexed addressing, if the effective address calculation crosses to
the next memory page then an additional machine cycle is required
for the calculation of the effective address. If the .Y register
is #$80 then the memory fetch 'LDA $80C0,Y' crosses from memory
page $80 into memory page $81, since the effective address is $8140,
and therefore requires an extra machine cycle to perform. It is
recommended that data tables be placed entirely on one memory page
whenever possible to speed program execution.
In Assembly: LDA Game_Board,X
STA $1000,Y
7) Indirect
The indirect addressing mode is available on the 65C02 only.
In this mode a pointer is used to point to an address where the
actual data is stored. The 16 bit pointer is stored in two
consecutive memory locations on the zero page. The indirect memory
fetch 'LDA ($80)' causes the 6502 to look at memory locations $0080
and $0081 to form a 16 bit address. Memory location $0080 is
interpreted as the low byte of the address and $0081 as the high
byte. If the memory locations $0080 and $0081 hold the values $00
and $20 respectively then the vector ($80) is said to point to
address $2000. This method of indirection is standard in high level
page 5
languages and is very useful for pointer operations as in the C
programming language. The indirect addressing mode is used only for
the ADC, AND, CMP, EOR, LDA, ORA, SBC and STA.
In Assembly: LDA ($80)
STA (Data_Pointer)
8) Indexed Indirect
This addressing mode is used for tables of pointers to data.
Only the X index register can be used for the indexed indirect
addressing mode. In this case the .X register indexes through a
data table that is interpreted as 16 bit pointers. If the X
register is $04 then the statement: LDA ($80,X) takes value stored
in ($0080+$04)=$0084 as the low byte of the 16 bit pointer and the
value in $0085 as the high byte of the pointer. If the vector fetch
address exceeds $FF then it wraps around to $00 again as in zero
page indexed addressing. Note that the X register can only take on
meaningful values as an even number since each pointer is two bytes
long. One can easily remember how this mode works by remembering
that it is called 'Indexed Indirect' where the indexing is done
first and then the indirect pointer interpretation is done. Indexed
indirect addressing is used only for ADC, AND, CMP, EOR, LDA, ORA,
SBC and STA. Page boundaries have no effect on the indexed indirect
addressing mode.
In Assembly: LDA ($80,X)
ADC (Array_of_Pointers,X)
9) Indirectly Indexed
This addressing mode is used to index within a data table that
is pointed to by a vector on the zero page. Only the Y register can
be used for the indirectly indexed address mode. In this case a
vector on the zero page points to the first address in a data table
and then the Y register indexes through the table. If the Y
register is $04 and $0080 and $0081 contain the values $00 and $20
respectively then the instruction 'LDA ($80),Y' first fetches the
vector at $0080 and $0081 which points to $2000. The Y register is
then added for an effective fetch address of ($2000+$04)=$2004. One
can easily remember how this mode works by remembering that it is
called 'Indirectly Indexed'. This mode does the indirect pointer
interpretation first and then performs the indexing. Indirectly
indexed addressing is used only for ADC, AND, CMP, EOR, LDA, ORA,
SBC and STA.
Page boundaries do effect the indirectly indexed address mode.
If the Y index causes the effective address to cross into the next
memory page then the fetch requires an additional machine cycle.
The indirectly indexed addressing mode is very useful for
accessing very large arrays of data. When the size of the array
surpasses the $00-$FF limit of the Y index register, the high order
byte of the pointer can be incremented to point into the next memory
page 6
page. The following is an example of addressing such a large
array.
;
LDY #$00
Next_Char LDA (String_of_Char),Y ; Get the character from the
; string
BEQ End_Of_String ; String ends with a NULL - #$00
JSR Print_Char ; A Subroutine to print
; characters
INY ; Go on to next character
BNE Next_Char ; If have not finished the page
; - Next
INC String_of_Char+1 ; Finished page - Point to next
; page
JMP Next_Char ; Go on to first char of next
; page
;
;
End_Of_String
'Offset': Branch Destination
- —————————-
10) Relative
The relative addressing mode is used by the Branch statements:
BCC, BCS, BEQ, BMI, BNE, BPL, BRA, BVC and BVS. The argument in
this case uses one byte as an offset byte. This offset byte allows
the branch instruction to branch up to 128 bytes forward and 127
bytes backward in the program machine code. This must seem like a
very 'coded', inconvenient, method of doing things. In actuality
this is taken care of by the assembler. This is one case where
assembler directives are used to make life easy for the programmer.
The programmer must however keep in mind that there are limits to
the range of relative branches when using them. The following is an
example of the assembly code use of a relative branch statement:
;
Check_Again LDA Port_A ; Wait for a bit to go high on Port A
BEQ Check_Again
;
In this example, the assembler records the position of the label
'Check_Again'. When the label is used in the relative branch
statement 'BEQ' the ASSEMBLER calculates the required offset byte
for the relative addressing mode used for the argument of 'BEQ'
instruction.
For the user, the only worry is a 'Branch Out of Range Error'
at assembly time. If this occurs, then the logic of the branch must
page 7
be reversed and a JuMP statement used. For example:
;
BEQ Where_to_Go ; <=== This branch is out of range
;
becomes:
;
BNE Continue_On ; <=== This branch is short - No problem
JMP Where_to_Go ; <=== JMP instructions are never out of
; range
Continue_On
;
The addition of the BRA - branch always statement to the 65C02 is
very helpful. If the user knows that the length of a JMP is within
range of a branch, it can be converted to a 'BRA Label' instruction
saving one machine cycle, critical on maximum repeat rate loops.
'Dest': Jump Destination
- ————————
11) Absolute
This addressing mode is exactly the same in syntax as the
absolute addressing mode (see 5 above) except the memory location is
not used as a data argument as before but as a memory location at
which to find the next instruction operation code. The absolute
mode is used by the JMP and JSR instructions and is not influenced
by memory pages. Once again as in the relative addressing mode, the
ASSEMBLER keeps track of actual addresses within programs and the
program merely communicates their desires through the use of labels.
In Assembly: JMP Try_Another
JSR Print_a_Char JMP $E000
12) Absolute Indirect
This addressing mode is used by the JuMP statement to jump to
an address pointed to by a vector. The vector, similar to the
pointers used in indirect data addressing, is stored as a 16 bit
pointer, low byte and high byte. The vector used in absolute
indirect addressing may be located anywhere in memory, not
necessarily based on the zero page as with indirect data argument
addressing. The following is an example:
;
JMP ($2000)
JMP (Prog_Start_Vector)
JMP ($FFFC) ; Simulate a Reset
;
Note that the address given in the instructions is an absolute, 16
bit address.
page 8
13) Indexed Absolute Indirect
This addressing mode is also used by the JuMP statement to jump
to an address pointed to by a vector. As in absolute indirect, the
vector is stored as a 16 bit pointer, the low byte then the high
byte. In indexed absolute indirect addressing, the X register is
used to index a table of JuMP vectors in very much the same way as
Indexed Indirect (mode 8) data addressing indexes a table of data
pointers. Unlike the absolute indirect address mode, the table of
jump vectors must be based on the zero page. The following is an
example:
;
LDX Control_Var
JMP (On_Goto_List,X)
;
This is an example of using the indexed absolute indirect addressing
mode to simulate a BASIC 'ON GOTO' statement, similar to the case
and switch statements of structured languages.
In Assembly: JMP ($80,X)
page 9
Summary Table of Addressing Modes
- ——————————–
Type of Addressing Example Comments
=====================================================================
Implied CLC What no arguments is called
Accumulator ROR A When the .A accumulator is the arg
Immediate LDA #$00 When a (#) number is the argument
Zero Page LDA $00 When an address <$100 is used
Zero Page,X LDA $00,X Indexes a table starting at <$100
Zero Page,Y LDX $00,Y Indexes a table starting at <$100
Absolute LDA $1000 When a general address is used
Absolute,X LDA $1000,X Indexes a table anywhere in memory
Absolute,Y LDA $1000,Y Indexes a table anywhere in memory
*Indirect LDA ($80) Uses $80, $81 as a pointer to arg
Indexed Indirect LDA ($80,X) For a table of pointers to arg
Indirectly Indexed LDA ($80),Y For a pointer to a table of args
Relative BEQ $FE For relative branches
Absolute JMP $E000 JMPs to a particular address
Absolute Indirect JMP ($0080) Uses $80,$81 as a JMP vector
*Indexed Absolute
Indirect JMP ($80,X) Uses a table of JMP vectors
page 10
Summary of Addressing Mode Restrictions:
- —————————————
The instruction classes are listed from the most to the least
limiting and the modes available or unavailable to each instruction
class. Simply, BIT, TRB and TSB, the bit manipulating instructions
are most restrictive. CPx, LDx and STx for the X and Y registers
are next most restrictive. The operator instructions ASL, ROR, ROL,
LSR, INC and DEC are next most restrictive. The arithmetic and
logical instructions: ADC, AND, EOR, ORA, SBC and the accumulator
LDA, CMP and STA are least restrictive.
Instructions 6502 65C02
====================================================================
BIT Zero Page and Added: Immediate, and X indexed
Absolute only Zero Page and Absolute
TRB, TSB Zero Page and Absolute only
CPX, CPY Immediate, Zero Page
and Absolute only
STX Zero Page,Y \
Zero Page and Absolute STY Zero Page,X /
STZ Absolute, Zero Page and
X indexed Absolute and Zero Page
LDX Y indexed Zero Page and Absolute \
and: LDY X indexed Zero Page and Absolute /
Immediate, Zero Page and Absolute
ASL, LSR, Accumulator, Zero Page,
ROR, ROL Absolute, X indexed
Zero Page and Absolute
page 11
DEC, INC, Zero Page, Absolute and Added: Accumulator
X indexed Zero Page and
Absolute
STA All except Immediate
and: Added: Indirect
ADC, AND, CMP, All except Accumulator
EOR, LDA, ORA, and Zero Page,Y
SBC