Download Assembly Language Programming

Assembly Language Programming
Challenge -1 (assignment #10) quick link
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
-----------15 Lines
0 Errors
0 Warnings
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
♦ Top
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 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
♦ Top
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
+
Upper
Byte
Address
P
MSB
8-bit
Upper
Byte
Upper
Byte
Lower
Byte
P+1
8-bit
Upper
Byte
Lower
Byte
Lower
Byte
8-bit
Lower
Byte
partial product: MLNL
Partial Product: MHNL
Partial Product: ML NH
Partial Product: MHNH
P+2
P+3
LSB
Final Product: M N
Test your solution for the given case:
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.
Due Friday March 9th.
♦ Top
Sample Results:
-
-
the equate and reserved memory bytes are at starting location $200
the main program starts at location $2000
here is a sample start:
ORG $200
M
N
P
RMB 2
RMB 2
RMB 4
ORG $2000
LDD #$241A
STD M
LDD #$41B7
STD N
CLRA
CLRB
Anytime you run cass11, if you end up with errors, view the .lst file to see
better, however you must make the changes/edits to the .asm file, then
cass11 it, and load it into the sim11 again…
here is the correct output:
notice M = $241A (at $0200, $0201), N =$41b7 (at $0202, $0203) and the answer: P =
$09446896 at locations($0204 - $0207)