====================================================================
DR 6502 AER 201S Engineering Design 6502 Execution Simulator
====================================================================
Supplementary Notes By: M.J.Malone
Starting to Program in 6502 Assembly Code
=========================================
Quotes of Murphy's Kin:
1) It is impossible to make anything fool-proof because fools are
so ingenious.
2) If you explain something so thoroughly and clearly so that
everyone will understand, someone will not understand.
Introduction to the 6502
------------------------
Accumulator and Assembler Basics
The 6502 has several 'registers'. Registers are special memory
locations that are internal to the processor and are directly
involved in processor instruction codes. The accumulator (.ACC) is
one such register. The code fragment that would transfer data from
one memory location (A_loc) to another (B_loc) would be coded as:
(Note that the numbers $0400 and $0800 are hexidecimal numbers which
do have decimal equivalents. The conversion between hex, decimal
and binary will be explained later.)
;
A_loc = $0400
B_loc = $0800
;
LDA A_loc
STA B_loc
;
Where LDA is the mnemonic for LoaD Accumulator and STA is the
mnemonic for STore Accumulator. In this example the two
assignments 'A_loc=' and 'B_loc=' give values to the labels A_loc
and B_loc. Note that A_loc and B_loc are NOT variables but labels
or constants used to replace numerical values and make the code more
readable. The locations described by A_loc and B_loc will contain
data important to the running of the program, the variables. Now
A_loc and B_loc are not very descriptive but 'Abs_Value' and
'Buffer_ptr' are also legal labels. The assembler sees the above
code fragment as:
;
LDA $0400
STA $0800
;
with the labels substituted into the code. This fragment loads the
value from address $0400 into the accumulator and then stores the
value into memory address $0800.
page 2
You may think of labels 'Buffer_ptr' as a variable as in a high
level language when you go 'LDA Buffer_ptr' to get the value of the
variable into the accumulator. Remember that the assembler sees
Buffer_ptr as an address of a location in memory, it is the
programmer who decides that that location has a special meaning or
purpose and gives it a meaningful name.
The .X and .Y Registers and Indexing
The .X and .Y registers are similar to the .ACC in most
respects, data can be loaded into them and stored into memory from
them. The above example could as easily be programmed with LDX and
STX as it was with LDA and STA as follows:
;
A_loc = $0400
B_loc = $0800
;
LDX A_loc
STX B_loc
;
The same code could also be written for the .Y but there is a
special purpose reserved for the .X and .Y registers. In the
previous section we saw that labels were used to name important
memory locations and simulate the function of variables for the
programmer. The assignment 'b=a' in a higher level language may be
coded using the example above. If the programmer wanted to use an
array and say assign 'b~[3]=a' it may be done as follows:
;
A_loc = $0400
B_array_start = $0800
;
LDA A_loc
LDX #3
STA B_array_start,X
;
As before, the value of memory location 'A_loc' is loaded into
memory. The value of the array index '3' is loaded into the X
register. The statement 'STA B_array_start,X' takes the value in
the memory and stores it into the location (B_array_start+.X). Here
B_array_start is the first address for the array and .X acts as the
offset INDEX into the memory space that follows. This is called
simple indexing and can be used to store and recall data that is
organized into tables.
The 6502 as an 8 bit Processor
For programmers accustomed to high level languages often the
assembly language of processors seems very limiting. So far the
implementation of higher level language assignment statements has
seemed to be as simple as a few substitutions, a few LDA and STA to
page 3
get the job done. Unfortunately this is about the easiest high
level language concept to transfer to assembly and then only in very
restricted cases.
The 6502 is an 8 bit processor and all memory fetches (LDA etc)
read values from 8 bit memory locations. All numbers stored in the
accumulator are in the range of 0-255 or $00-$FF. The .X and .Y
registers are also 8 bit as is the .SP the stack pointer for the
6502. This limits the stack to 256 memory locations (located
between addresses $0100-$01FF). The program counter is a 16 bit
number which varies between $0000 and $FFFF. The address space is
defined as the range of memory locations that can be pointed to by
the program counter. In the case of the 6502, 16 bits, $0000-$FFFF,
0-65535 represents an address space of 64K, where 1K is defined as
1024 for binary applications.
Number Conversions
The conversions between hex and decimal representation can be
done however students should be aware that since the 6502 is an 8
bit machine, everything is much more convenient in hex. For
instance the address $8000 is immediately recognizable as the first
address in the upper half of memory (because it begins $80), at the
beginning of a memory page (because it ends in 00). The equivalent
number in decimal 32768, unless memorized for what it is, cannot be
recognized as easily. Similarly it is necessary when dealing with
I/O ports to control individual bits of a memory location. In this
case the binary representation of %1010000 is immediately
recognizable as bits 7 and 5 of the byte set whereas the meaning of
the equivalent decimal number 160 is not nearly so clear.
It is advisable to use hexidecimal numbers for addresses,
binary numbers where bit on/off states are important. Decimal
numbers should be used only when 'magic' numbers are such as 26
letters in the alphabet, 24 hours in a day, 30 days in a month etc
that we are accustomed to seeing as decimal are needed. Note that
numbers 9 or smaller are the same in hex as decimal so there is no
problem for small constants.
The conversion between hex, binary and decimal will most likely
be done on students hand calculators however recalling what you
learned in grade 3: There are 10 symbols for digits in the decimal
number system 0-9. All numbers are stated with these 10 symbols
(note the number 10 is expressed in decimal). Numbers larger than 9
are stated using ten's and unit's digits:
98 = 9*10 + 8
or more generally:
34256 = 3*10^4 + 4*10^3 + 2*10^2 + 5*10^1 + 6*10^0
Hexidecimal numbers are represented with 16 symbols ($10 = 16 in
hex), the symbols 0-9 and the letters A-F. As units digits, 0-9
correspond to the decimal numbers 0-9, ie: 5 = $5 etc. As units
digits, A-F correspond to the decimal numbers 10-15. A hexidecimal
number can be expressed:
$7A3F = $7*$10^3 + $A*$10^2 + $3*$10^1 + $F*$10^0
page 4
So far this is parallel to the representation of a decimal number as
above. To perform a conversion you would simply convert the
hexidecimal numbers in the expansion to decimal.
$7A3F = 7*16^3 + 10*16^2 + 3*16^1 + 15*16^0 = 31295 decimal
A similar operation can be done in binary but once the meaning of
units, ten's and hundreds digits is understood then the expansions
of binary numbers are as easily calculated as for hexidecimal
numbers.
Often conversions between hexidecimal and binary or the reverse
are necessary. Similar expansions as above could be performed but
there is a short cut. Noting that 2^4 = 16 and 2 is the base of the
binary system and 16 is base of the hexidecimal system, groups of
four binary digits must somehow correspond to hexidecimal digits.
Observing that:
%0000 = $0 %1000 = $8
%0001 = $1 %1001 = $9
%0010 = $2 %1010 = $A
%0011 = $3 %1011 = $B
%0100 = $4 %1100 = $C
%0101 = $5 %1101 = $D
%0110 = $6 %1110 = $E
%0111 = $7 %1111 = $F
The conversion of multidigit hexidecimal numbers becomes
straight forward.
$7A3F = $7,A,3,F = %0111,1010,0011,1111 = %0111101000111111
This is very useful when hardware tests have to be done. If
the program counter of the 6502 were pointing at address $7A3F then
the binary representation would be useful for understanding the
voltage values on the address pins of the 6502 chip. In digital
circuits, 5 volts corresponds to logic 1 or binary 1; 0 volts
corresponds to logic 0 or binary 0. The binary representation of
the address %0111101000111111 is also the logic levels for the
address lines Adr15-Adr0 and hence the voltages on the address lines
would read (counting from Adr15 to 0): 0V, 5V, 5V, 5V, 5V, 0V, 5V,
0V, 0V, 0V, 5V, 5V, 5V, 5V, 5V and 5V. Summary of 6502 Basic
Structure
By now you should be realizing that operation of digital
computers are really not so mysterious at all. True the internal
workings of a 6502 are very complex, it is not hard to imagine it
being made up of a great number of smaller blocks that interpret
voltages as logic levels and perform logical operations. The
acculumator is in fact eight circuits that can each hold a voltage
of 0 or 5 volts, organized into a unit that is routed out of the
processor to memory by the STA instruction for instance. Since the
actual operations, when reduced to voltages and switching
transistors are very simple, they are very fast. Even the 6502, a
relatively slow processor can perform a STA operation in as little
as 3 microseconds or perform 333,333 such STA's in one second of
page 5
operation in the slowest 1 MHz implementation.
We have been introduced to the accumulator and the .X and .Y
index registers. As mentioned before the system 8 bit stack
pointer .SP points into an area of memory from $0100-$01FF. For now
suffice it to say that the stack is very important to the operation
of the processor and the actual instructions that involve the stack
will be discussed later. The program counter is a 16 bit register
that points to the instruction in memory that is currently being
executed. The processor status register which has not been
discussed until now, is a group of flags that represent the current
state of the processor and the results of the last calculation
performed.
Classes of 6502 Instructions
----------------------------
The reader will be introduced to several classes of 6502
instructions. Some instructions require arguments and some do not
and this is indicated where appropriate.
Data Transfer Instructions
There are several instructions in the family of data transfer
instructions but basically they fall into two categories, those
which move data between memory and registers and those that move
data between registers.
LDA, LDX, LDY arg Load 'arg' into Accumulator, X or Y registers
STA, STX, STY arg Store the Accumulator, X or Y registers to memory 'arg'
STZ arg *Store the value zero into a memory location 'arg'
TAX, TAY Transfer .A to .X, .A to .Y
TXA, TYA Transfer .X to .A, .Y to .A
TXS, TSX Transfer .X to .SP, .SP to .X
*65C02 Only
These instructions are very straight forward, they move an 8
bit value ($00-$FF) from the one place to another. After the
instruction, the data is in two places, where it was and where it
was moved to.
Go to Instructions
The go to instructions are as follows:
JMP dest Jump, Set the Program Counter = 'dest'
JSR dest Jump to a Subroutine, saving the return address
RTS Return from subroutine
The JMP statement is a pure 'go to' which simply sets the
program counter to a new address and continues the execution of the
code at that point. The JSR statement first takes that current
program counter position and pushes it into the stack and then jumps
page 6
to the new address. When the RTS instruction is encountered at the
end of the subroutine, the previous program location is pulled from
the stack and the processor continues after the subroutine call.
Compare Instructions
So far we have examined ways of moving data and unconditionally
changing the path of the program. We will now look at ways to
conditionally change the path of the program. In machine language
this is divided into two operations, a comparison and a branch.
There are three compare statements:
CMP arg Compare the .A
CPX arg .X
CPY arg .Y to 'arg'
The results of these comparisons are recorded in the system
flags N-negative, Z-zero and C-carry for later use in branch
instructions.
Branch Instructions
Branch instructions test the state of one of the flags and
either branch or not. Branches are relative jumps up to 128 bytes
forward or back in the code determined by the offset argument. The
branch instructions are:
BNE offset Branch on result not equal , result not zero: Z=0
BEQ offset Branch on result equal , result zero : Z=1
BMI offset Branch on result greater , result <0 : N=1
BPL offset Branch on result less or equal, result =>0 : N=0
BCC offset Branch on carry clear : C=0
BCS offset Branch on carry set : C=1
BVC offset Branch on overflow clear : V=0
BVS offset Branch on overflow set : V=1
BRA offset *Branch always
*65C02 only
Arithmetic and Logical Instructions
We have examined data moving and comparing instructions,
conditional branches and unconditional changes to the program flow.
The last class of instructions we will examine are the arithmetic
and logical instructions where actual computations occur. All of
these instructions involve the accumulator as one of the arguments.
ADC arg Add with carry .A + 'arg' + C ==> .A (C,V,N,Z)
SBC arg Subtract with borrow .A - 'arg' - !C ==> .A (C,V,N,Z)
AND arg Logical bitwise And .A and 'arg' ==> .A (N,Z)
ORA arg Logical bitwise Or .A or 'arg' ==> .A (N,Z)
EOR arg Logical bitwise XOr .A xor 'arg' ==> .A (N,Z)
The ADC and SBC use the carry to allow multibyte additions to
be done using the C flag to carry to or borrow from the next higher
page 7
byte of the operation. The V flag is the overflow flag. It is set
whenever a computation exceeds $FF or goes under $00. Note that the
overflow flag can also be set using the SO set overflow pin on the
6502 allowing an additional input line to the processor.
Instruction Summary
-------------------
There are other instructions for the 6502 but they are less
commonly used then those introduced above. It would be most useful
now to attempt to use the instructions learned in a few code
fragments to see how instructions interrelate.