Download Assembly Language Programming SP08_projection

Assembly Language Programming
Assembly Language Programming is a method of creating
instructions that are the symbolic equivalent of machine
code. Thus, an assembler is a program that accepts the
source code (.s19) as an input file and produces the 1s and
0s that are to be placed in the memory of the computer this is called the machine code. There is a one to one
correspondence between the assembly instructions and the
machine code in memory.
Wide View
An assembly language program is divided into four
sections that contain the main program components:
Assembler directives:
o These instructions are provided by the user.
o They define data and symbols, allocate data
storage locations, specify output format
o Assembler directives do not produce machine
code
Assembly language instructions: The 68HC11
instructions
Comments: Explain a line code or a group of
lines
END directive: Last statement – ignored also in
assembler
Assembly Source Code Fields:
Each line of the 68HC11 (in general) comprises of
four distinct fields- some of the fields may be empty.
The order of the fields is:
1- Label Field
a. symbols or identifiers
b. optional
c. when used provides symbolic memory reference
such as a branch instruction address
d. labels are also used to define constants
e. Rules: (USUALLY)
i. start with an alphabetic character or period
or underscore in the FIRST Column
ii. may contain digits and other characters like
the “_” , “.” , ”$”
iii. limitations on the number of characters (1 to
15)
iv. case sensitive
v. may end up with a “:”
Example:
Label:
_TEST
_Test
$TEST
TEST$
TEST$DATA
Test_Data
1_TEST
Test_DATA
TEST DATA
NO
NO
NO
NO
2- Operation Filed
a. The op-code field contains mnemonics for the
operation or an assembler directive.
b. It must be proceeded by at least one white space
from the left margin or a label
c. The assembler is INSENSITIVE to the cases of
the mnemonics
3- Operand Filed
a. The operand field (if present) follows the
operation field by at least one space.
b. The operand field may contain operands for
instructions or arguments for assembler
directives.
Examples:
ABC
LOOP:
Operation
Field
ADDA
EQU
BNE
Operand
Field
#$10
0
HERE
4- Comment Filed
a. The comment field is added for documentation
and is ignored by the assembler
b. * at start (first column)
c. ; as an in-line comment
♣
♣
♣
♣
♣
♣
Before we continue, let us put it all together in a simple
example:
Main ( )
{
int i,j,k
i=10;
j=20;
k=i+j;
}
/* these are 8-bit inter variables
Write the equivalent assembly code:
* Declare the data storage
ORG $0200
i
RMB 1
; variable i
j
RMB 1
;variable j
k
RMB 1
;variable k
1
2
3
4
5
* Program section
start ORG $2000
LDAA #10
STAA i
LDAA #20
STAA j
ADDA i
STAA k
END
6
7
8
9
10
11
12
13
14
;starting address of the program
;initialize i to 10
;======
;initialize j to 20
;= = = = = = = =
;i+j
;store value in k location
Before continuing further, let us do the following
1- Write the above program in Motpad and save it as .asm
file (example1.asm)
2- generate program listing .l file
cas11 –l example1.asm (note it is –L not –ONE)
Here is the generated program listing
CalU 68HC11 Cross Assembler, ver. 2.04
3/04/2007 16:35:12
Page 1
1
0200
2
0200 (0001)
0201 (0001)
0202 (0001)
2000
2000
2002
2005
2007
200A
200D
2010
86
B7
86
B7
BB
B7
0A
02
14
02
02
02
00
01
00
02
3
4
5
6
7
8
9
10
11
12
13
14
15
* Declare the data storage
ORG $0200
i
j
k
RMB
RMB
RMB
1
1
1
; variable i
;variable j
;variable k
* Program section
start ORG $2000 ;start add. of the prog.
LDAA #10
;initialize i to 10
STAA i
; = = = = = =
LDAA #20
;initialize j to 20
STAA j
;= = = = = = = =
ADDA i
;i+j
STAA k
;store value in k location
END
-----------15 Lines
0 Errors
0 Warnings
DISCUSS the above program.
Now, let us discuss some directives:
Directives:
Assembler directives are important part of an assembler program.
They can define the program’s location in memory, they allow us
to define symbols and contents of memory locations.
Let us visit some of the directives:
ORG
sets the value of the location counter and
thus it tells the assembler where to put the next byte it generates
after the ORG directive. The syntax is as follows:
ORG < expression>
Example:
ORG $2000
LDAB #$EE
Will place the opcode byte for the instruction LDAB #$EE at
location $2000.
RMB (Reserve Memory Byte) reserves a block of memory whose
size is specified by the number that follows the directive. The
syntax is:
<label> RMB <expression>
Example:
BUFFER RMB 80
allocates 80 decimal bytes for some data. The programmer
can refer to it using the label BUFFER.
Example:
Suppose we want to load the first byte in BUFFER into
accumulator A we do:
LDAA BUFFER
To load the 8th byte we do:
LDAA BUFFER + 7
Also, we can use the directive ORG to specify where the
block of memory be reserved:
ORG $100
BUFFER RMB 80
this will cause a block of 80 bytes be reserved at the starting
address of $100.
EQU (Equate a symbol to a value)
Examples:
zero
TRUE
EQU 0
EQU 1
syntax:
<label> EQU <expression>
A
EQU 2
B
EQU 4*A
-
BSZ (Block Storage of zeros) causes the assembler to
allocate a block of bytes and assign each a value of
zero. The number of bytes is specified in the
expression.
Syntax:
<label>
BSZ <expression>
Example:
ABC
EQU 60
BUFFER BSZ ABC
allocates and sets to zero a storage buffer of 60
-
FCB (Form Constant Byte) this directive will put a byte
in memory for each argument of the directive. The
syntax is:
<label> FCB <expression1>,<expression2>, ….
Example:
ORG $1000
XYZ FCB $10,$18,$25,$40
This will initialize the contents of memory locations $1000, $1001,
$1002, and $1003 to the values: $10, $18, $25, and $40.
-
Form Constant Character: FCC
o will generate the code bytes for the letters in the
argument of the directives, using ASCII code. ALL
letters to be coded and stored are enclosed in double
quotes. The format is:
o <label> FCC “<string>” ; comments
o Example:
LETTERS FCC “DEF” ; this is an example
This will generate the following values in memory:
$44, $45, $ 46
Also, it will let the assembler know that the label LETTERS refers
to the address of the first letter.
-
SPACE
Define Constant Block Directive DCB
o will reserve an area of memory and initializes each
byte to the same constant value
o The format of this directive is:
o <label> DCB <length>,<value>
o Example:
DCB
80,$20
A line of 80 space characters is generated. The label SPACE
refers to the first space character. The value $20, is the ASCII
code to the space character.
Sometimes, DCB is not supported by most freeware (ours does not
support it)
Let us write some programs:
Challenge -1
Write a program that will multiply 16 bit numbers stored at
locations {M, M+1} and {N, N+1} and store the product at
memory locations { P, P+1, P+2, P+3} Where P is the highest
memory byte (H) and P+3 is the lowest memory byte (L).
Here is a graphical illustration of the process:
8-bit
8-bit
8-bit
8-bit
Upper Lower
Byte
Byte
Upper Lower
Byte
Byte
Upper Lower
Byte
Byte
+
Upper Lower
Byte Byte
Address
P
P+1
P+2
P+3
MSB
LSB
Test your solution for the given case:
partial product:
MLNL
Partial Product:
MHNL
Partial Product: ML
NH
Partial Product:
MHNH
Final Product: M N
M: = $24A1 at location $200, $201
N = $41B7 at location $202, $203
P, the result should be at locations: $20A, $20B, $20C, $20D
use assembly, Sim11 and MotPad.