1. Introduction to LC-3 Assembly Language

2. 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

3. Assembler Directives Opcode Operand Meaning Pseudo-operations
do not refer to operations executed by program
used by assembler
look like instruction, but “opcode” starts with dot
Opcode
Operand
Meaning
.ORIG
address
starting address of program
.END
end of program
.BLKW n
allocate n words of storage
.FILL
allocate one word, initialize with value n
.STRINGZ
n-character string
allocate n+1 locations, initialize w/characters and null terminator

4. 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?
R4  M[R1] R3  R3+R4 R1  R1+1
R2  R2-1 NO
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

5. Compute the Sum of 12 Integers
Address
Instruction
Comments
x3000
R1  x3100
x3001
R3  0
x3002
R2  0
x3003
R2  12
x3004
If Z, goto x300A
x3005
Load next value to R4
x3006
Add to R3
x3007
Increment R1 (pointer)
X3008
Decrement R2 (counter)
x3009
Goto x3004
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

6. Compute the Sum of 12 Integers
.ORIG x3000
; Add 12 integers
; R1: Pointer to integer
; R2: Loop counter
; R3: Accumulator
; R4: Temporary register
LD R1 DATAADDR ; Load pointer to integers
AND R3 R3 #0 ; Accumulator = 0
AND R2 R2 #0 ; Counter = 12
ADD R2 R2 #12
; Add integers
LOOP BRZ STOP ; Stop when done
LDR R4 R1 #0 ; Add next integer
ADD R3 R3 R4
ADD R1 R1 #1 ; Inc pointer
ADD R2 R2 #-1 ; Dec counter
BRNZP LOOP
STOP BRNZP STOP ; Stop
DATAADDR .FILL x3100
.END
Note: Used DATAADDR to hold address of DATA. Why?

7. Compute the Sum of 12 Integers
.ORIG x3100
; Data section
DATA .FILL x ; 12 integers
.FILL x0002
.FILL x0004
.FILL x0008
.FILL xFFFF
.FILL xFFFE
.FILL xFFFC
.FILL xFFF8
.FILL x0007
.FILL x0003
.END

8. 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)

9. Compute the Sum of 12 Integers
.ORIG x3000
; Add 12 integers
; R1: Pointer to integer
; R2: Loop counter
; R3: Accumulator
; R4: Temporary register
LEA R1 DATA ; Load pointer to integers
AND R3 R3 #0 ; Accumulator = 0
AND R2 R2 #0 ; Counter = 12
ADD R2 R2 #12
LOOP BRZ STOP ; Stop when done
LDR R4 R1 #0 ; Add next integer
ADD R3 R3 R4
ADD R1 R1 #1 ; Inc pointer
ADD R2 R2 #-1 ; Dec counter
BRNZP LOOP
STOP BRNZP STOP ; Stop
; Data section
DATA .FILL x ; 12 integers
.FILL x0002
.FILL x0004
.FILL x0008
.FILL xFFFF
.FILL xFFFE
.FILL xFFFC
.FILL xFFF8
.FILL x0007
.FILL x0003
.END
Note: Used LEA to load pointer to data. Why?

10. 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)

11. 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?

12. An Assembly Language Program;
; Program to multiply a number by the constant 6
.ORIG x3050
LD R1, SIX ; Load the number 6 (counter)
LD R2, NUMBER ; Load the number
AND R3, R3, #0 ; Clear R3. It will
; contain the product.
; The multiply loop
AGAIN ADD R3, R3, R2
ADD R1, R1, #-1 ; R1 (counter) keeps track of
BRp AGAIN ; the iteration.
HALT
NUMBER .BLKW ; Value of number is stored here
SIX .FILL x0006
.END
Symbol Table: Symbol Address
AGAIN x3053
NUMBER x3057
SIX x3059

13. More than One Object (Load) File
Example Symbol Table:
Symbols Externals Exports Addresses
Start x3000
Number x300A
Data ?
Value ?
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.

14. 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.

15. Program to add two single digit integers
.ORIG x3000 ; begin at x3000
; input two numbers
IN ;input an integer character (ascii) {TRAP 23}
LD R3, HEXN30 ;subtract x30 to get integer
ADD R0, R0, R3
ADD R1, R0, x0 ;move the first integer to register 1
IN ;input another integer {TRAP 23}
ADD R0, R0, R3 ;convert it to an integer
; add the numbers
ADD R2, R0, R1 ;add the two integers
; print the results
LEA R0, MESG ;load the address of the message string
PUTS ;"PUTS" outputs a string {TRAP 22}
ADD R0, R2, x0 ;move the sum to R0, to be output
LD R3, HEX30 ;add 30 to integer to get integer character
OUT ;display the sum {TRAP 21}
; stop
HALT ;{TRAP 25}
; data
MESG .STRINGZ "The sum of those two numbers is: “
HEXN30 .FILL xFFD0 ; -30 HEX
HEX30 .FILL x ; 30 HEX
.END

16. Program to add two single digit integers
Enter,
assemble,
Execute,
And test the program.

17. HW, due November 10
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.

18. 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.

19. Write a program to count the 1’s in register R0
Flow Diagram
Assembly code

20. 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 ;test highest bit
BRZP NEXT ;count if neg
ADD R1, R1, #1
NEXT AND R2, R2, #0 ;check remaining 15 bits
ADD R2, R2, # ; R2 = -15 (count)
LOOP ADD R3, R3, R3 ;shift R3 left
BRZP AGAIN
ADD R1, R1, # ;count if neg
AGAIN ADD R2, R2, # ;inc count
BRN LOOP
HALT
.END

21. 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

22. Program to Check for overflow
; Add R3=R0+R1, R2=0 indicates no overflow ;
.ORIG x3000
AND R2, R2, #0 ;Initially R2=0 (no Overflow assumed)
ADD R3, R0, R1 ;R3=R0+R1
; test for overflow
ADD R0, R0, #0 ;test R0
BRN NEG ;Branch if RO negative
ADD R1, R1, #0 ;R0 pos, test R1
BRN DONE ;R0 pos, R1 neg -> No overflow
ADD R3, R3, #0 ;R0 pos, R1 pos, maybe, test R3
BRZP DONE ;R3 also pos -> no overflow
ADD R2, R2, #1 ;Set R2=1 indicating overflow
BRNZP DONE
R0NEG ADD R1, R1, #0 ;R0 neg, test R1
BRZP DONE ;R0 neg, R1 pos -> No overflow
ADD R3, R3, #0 ;R0 neg, R1 neg, maybe, test R3
BRN DONE ;R3 also neg -> no overflow
ADD R2, R2, #1 ;Set R2=1 indicating overflow
DONE HALT
.END

23. Sample Program
Count the occurrences of a character in a file.

24. 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 x3000
AND R2, R2, #0 ; R2 is counter, initially 0
LD R3, PTR ; R3 is pointer to character file
GETC ; R0 gets input character
LDR R1, R3, #0 ; R1 gets first character from file
; 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

25. 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