Transcript Slides11_03

Introduction to
LC-3
Assembly Language
LC-3 Assembly Language Syntax
• Each line of a program is one of the following:
– an instruction
– an assember directive (or pseudo-op)
– a comment
• Whitespace (between symbols) and case are ignored.
• Comments (beginning with “;”) are also ignored.
• An instruction has the following format:
LABEL OPCODE OPERANDS ;COMMENTS
optional
mandatory
Assembler Directives
• Pseudo-operations
– do not refer to operations executed by program
– used by assembler
– look like instruction, but “opcode” starts with dot
Opcode Operand
.ORIG
address
.END
Meaning
starting address of program
end of program
.BLKW
n
allocate n words of storage
.FILL
n
allocate one word, initialize with value n
.STRINGZ
n-character
string
allocate n+1 locations,
initialize w/characters and null
terminator
Compute the Sum of 12 Integers
• Program begins at location x3000.
• Integers begin at location x3100.
R1  x3100
R3  0 (Sum)
R2  12(count)
R2=0?
NO
R4
R3
R1
R2




M[R1]
R3+R4
R1+1
R2-1
YES
R1: “Array” index pointer (Begin with location 3100)
R3: Accumulator for the sum of integers
R2: Loop counter (Count down from 12)
R4: Temporary register to store next integer
Compute the Sum of 12 Integers
Address
Instruction
Comments
x3000
1 1 1 0 0 0 1 0 1 1 1 1 1 1 1 1
R1  x3100
x3001
0 1 0 1 0 1 1 0 1 1 1 0 0 0 0 0
R3  0
x3002
0 1 0 1 0 1 0 0 1 0 1 0 0 0 0 0
R2  0
x3003
0 0 0 1 0 1 0 0 1 0 1 0 1 1 0 0
R2  12
x3004
0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 1
If Z, goto x300A
x3005
0 1 1 0 1 0 0 0 0 1 0 0 0 0 0 0 Load next value to R4
x3006
0 0 0 1 0 1 1 0 1 1 0 0 0 1 0 0
x3007
0 0 0 1 0 0 1 0 0 1 1 0 0 0 0 1 Increment R1 (pointer)
X3008
0 0 0 1 0 1 0 0 1 0 1 1 1 1 1 1
Decrement R2
(counter)
x3009
0 0 0 0 1 1 1 1 1 1 1 1 1 0 1 0
Goto x3004
Add to R3
R1: “Array” index pointer (Begin with location 3100)
R3: Accumulator for the sum of integers
R2: Loop counter (Count down from 12)
R4: Temporary register to store next integer
Compute the Sum of 12 Integers
.ORIG x3000
; Add 12 integers
;
R1: Pointer to integer
;
R2: Loop counter
;
R3: Accumulator
;
R4: Temporary register
LD
AND
AND
ADD
R1
R3
R2
R2
DATAADDR ; Load pointer to integers
R3 #0
; Accumulator = 0
R2 #0
; Counter = 12
R2 #12
; Add integers
LOOP
STOP
BRZ
LDR
ADD
ADD
ADD
BRNZP
STOP
R4 R1
R3 R3
R1 R1
R2 R2
LOOP
#0
R4
#1
#-1
BRNZP STOP
; Stop when done
; Add next integer
; Inc pointer
; Dec counter
; Stop
DATAADDR .FILL x3100
.END
Note: Used DATAADDR to hold address of DATA. Why?
Compute the Sum of 12 Integers
.ORIG x3100
; Data section
DATA
.END
.FILL
.FILL
.FILL
.FILL
.FILL
.FILL
.FILL
.FILL
.FILL
.FILL
.FILL
.FILL
x0001
x0002
x0004
x0008
xFFFF
xFFFE
xFFFC
xFFF8
x0007
x0004
x0002
x0003
; 12 integers
Compute the Sum of 12 Integers
• Use the LC3 Editor to enter the program and data
and store them as
add1.asm
data1.asm
• Use the LC3 Editor to assemble them:
add1.asm  add1.obj
data1.asm  data1.obj
• Then use the LC3 Simulator to test them:
load add1.obj and data1.obj
Set the PC, appropriate breakpoints, and execute the
program (single step or run)
Compute the Sum of 12 Integers
.ORIG x3000
; Add 12 integers
;
R1: Pointer to integer
;
R2: Loop counter
;
R3: Accumulator
;
R4: Temporary register
LOOP
STOP
LEA
AND
AND
ADD
BRZ
LDR
ADD
ADD
ADD
BRNZP
BRNZP
R1 DATA
R3 R3 #0
R2 R2 #0
R2 R2 #12
STOP
R4 R1 #0
R3 R3 R4
R1 R1 #1
R2 R2 #-1
LOOP
STOP
; Load pointer to integers
; Accumulator = 0
; Counter = 12
; Stop when done
; Add next integer
; Inc pointer
; Dec counter
; Stop
; Data section
DATA
.END
.FILL
.FILL
.FILL
.FILL
.FILL
.FILL
.FILL
.FILL
.FILL
.FILL
.FILL
.FILL
x0001
x0002
x0004
x0008
xFFFF
xFFFE
xFFFC
xFFF8
x0007
x0004
x0002
x0003
; 12 integers
Note: Used LEA to load pointer to data. Why?
Compute the Sum of 12 Integers
• Use the LC3 Editor to enter the program and data
and store it as
add2.asm
• Use the LC3 Editor to assemble it:
add2.asm  add1.obj
• Then use the LC3 Simulator to test it:
load add2.obj
Set the PC, appropriate breakpoints, and execute the
program (single step or run)
One Pass vs Two Pass Assemblers
• Two Pass – Checks for syntax errors and builds
the Symbol Table during first pass, resolves
operand addresses during second pass.
• One Pass – Checks for syntax errors, builds the
Symbol Table, and resolves operand addresses
during the first pass. So why have a two pass?
An Assembly Language Program
;
; Program to multiply a number by the constant 6
;
.ORIG
x3050
LD
LD
AND
;
R1, SIX
R2, NUMBER
R3, R3, #0
The multiply loop
AGAIN
ADD
ADD
BRp
; Load the number 6 (counter)
; Load the number
; Clear R3. It will
;
contain the product.
R3, R3, R2
R1, R1, #-1
AGAIN
; R1 (counter) keeps track of
;
the iteration.
2
x0006
; Value of number is stored here
HALT
NUMBER
SIX
.BLKW
.FILL
.END
Symbol Table:
Symbol
Address
AGAIN
x3053
NUMBER
x3057
SIX
x3059
More than One Object (Load) File
•
Example Symbol Table:
Symbols
Start
Number
Externals
Data
Exports
Value
Addresses
x3000
x300A
?
?
• The “Linker/Loader” would generate another “global symbol table”
to resolve Externals & Exports at Load time. It would only
address the Externals (Imports) and Exports.
Trap Codes
•
LC-3 assembler provides “pseudo-instructions” for
each trap code, so you don’t have to remember them.
Code
Equivalent
Description
HALT
TRAP x25
Halt execution and print message to console.
IN
TRAP x23
Print prompt on console,
read (and echo) one character from keybd.
Character stored in R0[7:0].
OUT
TRAP x21
Write one character (in R0[7:0]) to console.
GETC
TRAP x20
Read one character from keyboard.
Character stored in R0[7:0].
PUTS
TRAP x22
Write null-terminated string to console.
Address of string is in R0.
Program to add two single digit integers
;
;
;
;
.ORIG x3000
input two numbers
IN
LD R3, HEXN30
ADD R0, R0, R3
ADD R1, R0, x0
IN
ADD R0, R0, R3
add the numbers
ADD R2, R0, R1
print the results
LEA R0, MESG
PUTS
ADD R0, R2, x0
LD R3, HEX30
ADD R0, R0, R3
OUT
stop
HALT
; data
MESG
HEXN30
HEX30
.STRINGZ
.FILL
.FILL
.END
; begin at x3000
;input an integer character (ascii) {TRAP 23}
;subtract x30 to get integer
;move the first integer to register 1
;input another integer {TRAP 23}
;convert it to an integer
;add the two integers
;load the address of the message string
;"PUTS" outputs a string {TRAP 22}
;move the sum to R0, to be output
;add 30 to integer to get integer character
;display the sum {TRAP 21}
;{TRAP 25}
"The sum of those two numbers is: “
xFFD0
; -30 HEX
x0030
; 30 HEX
Program to add two single digit integers
• Enter,
• assemble,
• Execute,
• And test the program.
HW, due November 10
1) Write and test an LC-3 assembly language
program to calculate and print on the console,
the sum of two double digit hexidecimal
numbers entered from the console.
Show:
– A snapshot of your well commented
Assembly program in the LC-3 Editor
Window with the Assembly response.
– A snapshot of the Simulator execution and
the Console Display Window with the input
and output displayed.
HW, due November 10 (continued)
2) Write and test an LC-3 assembly language program to
calculate and print all the numbers in the Fibonacci
series that can be stored in words of the LC-3. The
program should stop when it determines it has found
the largest number.
Show:
– A snapshot of your well commented Assembly
program in the LC-3 Editor Window with the
Assembly response.
– A snapshot of the Simulator execution and the
Console Display Window with the Fibonacci
numbers displayed.
Write a program to count the 1’s in register R0
•
•
Flow Diagram
Assembly code
Write a program to count the 1’s in register R0
; Program to count 1's in Register R0
;
R3 is a working copy of R0
;
R1 contains the count
;
R2 is a loop counter
.orig x3100
ADD R3, R0, #0
;copy R0 into R3
AND R1, R1, #0
;clear count
ADD R3, R3, #0
BRZP NEXT
ADD R1, R1, #1
;test highest bit
;count if neg
NEXT
AND R2, R2, #0
ADD R2, R2, #-15
;check remaining 15 bits
;
R2 = -15 (count)
LOOP
ADD R3, R3, R3
BRZP AGAIN
ADD R1, R1, #1
ADD R2, R2, #1
BRN LOOP
;shift R3 left
AGAIN
HALT
.END
;count if neg
;inc count
Program to Check for Overflow
Write a program to add the contents of R0 and R1, and indicate in R2 if
there was an overflow
•Flow Diagram
•Assembly Code
Program to Check for overflow
;
;
Add R3=R0+R1, R2=0 indicates no overflow
.ORIG
x3000
AND R2, R2, #0
ADD R3, R0, R1
; test for overflow
ADD R0, R0, #0
BRN
NEG
ADD R1, R1, #0
BRN
DONE
ADD R3, R3, #0
BRZP DONE
ADD R2, R2, #1
BRNZP DONE
R0NEG ADD R1, R1, #0
BRZP DONE
ADD R3, R3, #0
BRN
DONE
ADD R2, R2, #1
DONE
HALT
.END
;Initially R2=0 (no Overflow assumed)
;R3=R0+R1
;test R0
;Branch if RO negative
;R0 pos, test R1
;R0 pos, R1 neg -> No overflow
;R0 pos, R1 pos, maybe, test R3
;R3 also pos -> no overflow
;Set R2=1 indicating overflow
;R0 neg, test R1
;R0 neg, R1 pos -> No overflow
;R0 neg, R1 neg, maybe, test R3
;R3 also neg -> no overflow
;Set R2=1 indicating overflow
Sample Program
•
Count the occurrences of a character in a file.
Count = 0
(R2 = 0)
Done?
YES
(R1 ?= EOT)
Ptr = 1st file character
Convert count to
ASCII character
(R0 = x30, R0 = R2 + R0)
NO
(R3 = M[x3012])
Print count
YES
Match?
NO
(TRAP x21)
(R1 ?= R0)
Input char
from keybd
(TRAP x23)
HALT
Incr Count
Load char from file
(R2 = R2 + 1)
(R1 = M[R3])
Load next char from file
(R3 = R3 + 1, R1 = M[R3])
(TRAP x25)
Count the occurrences of a character in a file (1 0f 2).
;
;
;
;
;
;
;
;
;
Program to count occurrences of a character in a file.
Character to be input from the keyboard.
Result to be displayed on the monitor.
Program only works if no more than 9 occurrences are found.
Initialization
.ORIG
AND
LD
GETC
LDR
x3000
R2, R2, #0
R3, PTR
;
;
;
;
R2
R3
R0
R1
is counter, initially 0
is pointer to character file
gets input character
gets first character from file
R1, R3, #0
;
; Test character for end of file
;
TEST
ADD
R4, R1, #-4
; Test for EOT (ASCII x04)
BRz
OUTPUT
; If done, prepare the output
;
; Test character for match. If a match, increment count.
;
NOT
R1, R1
ADD
R1, R1, R0
; If match, R1 = xFFFF
NOT
R1, R1
; If match, R1 = x0000
BRnp
GETCHAR
; If no match, do not increment
ADD
R2, R2, #1
;
; Get next character from file.
;
GETCHAR
ADD
R3, R3, #1
; Point to next character.
LDR
R1, R3, #0
; R1 gets next char to test
BRnzp
TEST
Count the occurrences of a character in a file (2 of 2).
;
; Output the count.
;
OUTPUT
LD
R0, ASCII
; Load the ASCII template
ADD
R0, R0, R2
; Covert binary count to ASCII
OUT
; ASCII code in R0 is displayed.
HALT
; Halt machine
;
; Storage for pointer and ASCII template
;
ASCII
.FILL
x0030
; ASCII offset
PTR
.FILL
x4000
; PTR to character file
.END