1. Chapter 6 Programming in Machine Language The LC-3 Simulator
The LC-3 Editor

2. The LC-3 Computer a von Neumann machine
The Instruction Cycle:
Fetch: Next Instruction from Memory
(PC)  (points to) next instruction
PC (PC) + 1
Decode: Fetched Instruction
Evaluate: Instr & Address (es)
(find where the data is)
Load: Operand (s)
(get data as specified)
Execute: Operation
Store: Result
(if specified)
PSW
Memory
PSW (Program Status Word):
Bits:
| S| |Priority| | N| Z| P|

3. Important Registers in the LC-3
CPU Registers:
8 General Purpose Registers (R0 – R7) – Holds Data or Addresses
Program Counter (PC) - Points to the next instruction
Instruction Register (IR) – holds the instruction being executed
Program Status Word (PSW) – holds the status of the program being executed, including N Z P: Negative, Zero, Positive result of an operate instruction
Memory Access Registers:
Memory Address Register (MAR) – Holds the address of a memory location being accessed
Memory Data Register (MDR) – Hold the data to be written into memory or the date read from memory
Note: These are all 16 bit registers

4. LC-3 Memory Map (64K of 16 bit words) 256 words
(We will get to these later)
23.5 K words
39.5 K words
512 words

5. LC-3 Instructions Addressing Modes Register
(Operand is in one of the 8 registers)
PC-relative
(Operand is “offset” from where the PC points
- offsets are sign extended to 16 bits)
Base + Offset (Base relative)
(Operand is “offset” from the contents of a register)
Immediate
(Operand is in the instruction)
Indirect
(The “Operand” points to the real address of Operand
– rather than being the operand)
Note: The LC-3 has No Direct Addressing Mode

6. - ADD Register mode [0001 DR SR1 0 00 SR2]
Operate Instructions
There are only three operate Instructions:
- ADD Register mode [0001 DR SR SR2]
Register/Immediate mode [0001 DR SR1 1 imm5]
- AND Register mode [0101 DR SR SR2]
Register/Immediate mode [0101 DR SR1 1 imm5]
- NOT Register mode [1001 DR SR ]
The Source and Destination operands are:
CPU Registers or Immediate Values

7. Data Movement Instructions
Load - read data from memory to a register
LD: PC-relative mode [0010 DR PCoffset9]
LDI: Indirect mode [1010 DR PCoffset9]
LDR: Base+offset mode [0110 DR BaseR offset6]
Store - write data from a register to memory
ST: PC-relative mode [0011 DR PCoffset9]
STI: Indirect mode [1011 DR PCoffset9]
STR: Base+offset mode [0111 DR BaseR offset6]
Load effective address – address saved in register
LEA: PC-relative mode [1110 DR PCoffset9]
All have 2 or 3 operands

8. Go to New Location in Program – “GO TO”
Control Instructions
Go to New Location in Program – “GO TO”
BR: PC-relative mode [0000 NZP PCoffset9]
JMP: Indirect mode [ BaseR ]
Trap Service Routine Call
TRAP: Indirect [ TrapVec8]
Jump to Subroutine (will be covered later)
JSR: PC-relative mode [ PCoffset11]
JSRR: Indirect mode [ BaseR ]
Return from Trap/Subroutine
RET: No operand [ ]
Return from Interrupt (will be covered later)
RTI: No operand [ ]

9. TRAP Instruction RET [1100 000 111 000000]
Calls a service routine, identified by 8-bit “trap vector.”
Register R7 is loaded with the incremented contents of the PC.
The PC is loaded with the address in the Trapvector Table at position “trapvector8”
R0 is typically used for passing values between the Program and the Trap Routine
RET [ ]
When service routine is done, an RET will load R7 (the incremented value of the PC before jumping to the TRAP routine) into the PC, and the program will continue with the next instruction after the TRAP, i.e. the program will “return” from the TRAP Routine.
Note: an RET is a JMP Base-relative with Base = R7
vector
Service routine (Partial List)
x23
input a character from the keyboard
x21
output a character to the monitor
x25
halt the program

10. TRAPS
See page 543.

11. Example: Program to multiply [R4] x [R5] and place the result in R2
clear R2
add R4 to R2
decrement R5
R5 = 0?
HALT No
Yes
R4 – Multiplicand
R5 – Multiplier
R2 – Accumulator

12. LC-3 Instructions Addressing Modes Register
(Operand is in one of the 8 registers)
PC-relative
(Operand is “offset” from where the PC points
- offsets are sign extended to 16 bits)
Base + Offset (Base relative)
(Operand is “offset” from the contents of a register)
Immediate
(Operand is in the instruction)
Indirect
(The “Operand” points to the real address of Operand
– rather than being the operand)
Note: The LC-3 has No Direct Addressing Mode

13. Example: Program to multiply [R4] x [R5] and place the result in R2
clear R2
add R4 to R2
decrement R5
R5 = 0?
HALT No
Yes
R2 <- 0
R2 <- R2 + R4
R5 <- R5 – 1
BRz x3201
HALT
x3200 ?

14. Example: Program to multiply [R4] x [R5] and place the result in R2
clear R2
add R4 to R2
decrement R5
R5 = 0?
HALT No
Yes
R2 <- 0
R2 <- R2 + R4
R5 <- R5 – 1
BRz x3201
HALT x x x x x

15. Example: Program to multiply [R4] x [R5] and place the result in R2
clear R2
add R4 to R2
decrement R5
R5 = 0?
HALT No
Yes
R2 <- 0
R2 <- R2 + R4
R5 <- R5 – 1
BRzp x3201
HALT
x A0 x
x B7F
x FD
x FO25

16. LC3 Editor / Simulator Go to Author’s Web Site:
Get:
LC3 Edit
LC3 Simulator

17. LC3 Edit Screen

18. LC3 Edit Enter (or Load) the program into LC3 Edit
- Store it as prog.bin for a binary file, or
Store it as prog.hex for a hex file
- Create a prog.obj file with the Editor

19. LC-3 Simulator Screen

20. Open LC-3 Simulator LC-3 Simulator - Load prog.obj - Load data.obj
- Set breakpoint(s) or
- Step through program

21. LC-3 Simulator
Open LC-3 Simulator
- Load prog.obj
- Load data.obj
- Initialize values (PC, memory, registers)
- Set breakpoint(s)
- Step through program checking registers
and “memory map”
- Debug program

22. Example: Program to multiply [R4] x [R5] and place the result in R2
clear R2
add R4 to R2
decrement R5
R5 = 0?
HALT No
Yes
R2 <- 0
R2 <- R2 + R4
R5 <- R5 – 1
BRzp x3201
HALT
x A0 x
x B7F
x FD
x FO25

23. Example: Program to multiply [R4] x [R5] and place the result in R2
Enter Program in Simulator and test it:
Enter Program
Run
Single Step
Add Breakpoints

24. The Sum program in “binary”
;start x3000
x ;R1=x3100
x ;R3=0
x ;R2=0
x ;R2=R2+12
x ;If z goto x300A
x ;Load next value into R4
x ;R3=R3+R4
x ;R1=R1+1
x ;R2=R2-1
x ;goto x3004
x300A ;halt

25. The Sum program in “hex”
3000 ;start x3000
x E2FF ;R1=x3100
x E0 ;R3=0
x A0 ;R2=0
x AC ;R2=R2+12
x ;If z goto x300A
x ;Load next value into R4
x C4 ;R3=R3+R4
x ;R1=R1+1
x BF ;R2=R2-1
x FFA ;goto x3004
x300A F025 ;halt

26. The Sum program Data in “hex”
3100 ; Begin data at x3100
x ; Loc x3100 x x x
x FFFF
x C10
x B1 x
x F07 x
x310A 0A00
x310B 400F ; Loc x310B

27. Example Compute the Sum of 12 Integers Program
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

28. Example: Compute the Sum of 12 Integers Program
Enter Program in Simulator and test it:
Enter Program
Enter Data
Run
Single Step
Add Breakpoints

29. Example: # of Occurrences of an Inputted Char from a string
R3 – ptr to char string, R1 – input char buffer, R2 – char count, R0 – output buffer

30. Example: Counting Occurrences of a Character
Address
Instruction
Comments
x3000
R2  0 (counter)
x3001
R3  M[x3102] (ptr)
x3002
Input to R0(TRAP x23)
x3003
R1  M[R3]
x3004
R4  R1 – 4 (EOT)
x3005
If Z, goto x300E
x3006
R1  NOT R1
x3007
R1  R1 + 1
X3008
R1  R1 + R0
x3009
If N or P, goto x300B
x300A
R2  R2 + 1
x300B
R3  R3 + 1
x300C
R1  M[R3]
x300D
Goto x3004
x300E
R0  M[x3013]
x300F
R0  R0 + R2
x3010
Print R0 (TRAP x21)
x3011
HALT (TRAP x25)
X3012
Starting Address of File
x3013
ASCII x30 (‘0’)
R3 – ptr to char string, R1 – input char buffer,
R2 – char count, R0 – Keyboard char /Output display char

31. HW 6: After reading the Simulator manual:
Write a program to place the absolute value of the [R2] in R2.
The program should begin in memory location 3000
Test it on the LC-3 Simulator.
Provide Simulator Snapshots with your homework.
2) Write a program to read a value of N from memory and calculate N factorial. The result should be in R4.
The program should begin in memory location 3050
N should be in memory location 3000
Test the program on the LC-3 Simulator