Homework 5
A Simulator for the LC-1: an LC-3 Assembly Language Program

Due Tuesday, December 12, 2006 at 11:59 pm

Outcomes

• Write an LC-3 assembly language program that uses subroutines
• Write an LC-3 assembly language program that uses the stack
• Simulate a simple machine using an LC-3 assembly language program

Before Starting

Description of Problem

In this assignment, you will write a simulator for a new "machine", the LC-1, in LC-3 assembly language. You will use the simulator you write to simulate the execution of a program written in LC-1 machine language.

The LC-1 ISA

LC-1 Instruction Set

• CALL

  opcode	bits <12:0>
  000	address13

  Description:  PC is pushed on the stack
                PC <- address13
  

• RETURN

  opcode	bits <12:0>
  001	0000000000000

  Description:  The stack is popped into PC
  

• ADD

  opcode	bits <12:0>
  010	address13

  Description:  Acc <- Acc + mem[address13]
  (The content of memory location address13 is added to the accumulator.
  The result is stored back in the accumulator.)
  

• BRANCH

  opcode	bits <12:0>
  011	address13

  Description:  If (n), PC <- address13
  (If the n condition bit is set, address13 is stored into the PC.)
  

• LOAD

  opcode	bits <12:0>
  100	address13

  Description:  Acc <- mem[address13]
  (The content of memory location address13 is loaded into the accumulator.)
  

• STORE

  opcode	bits <12:0>
  101	address13

  Description:  mem[address13] <- Acc
  (The accumulator is stored into memory location address13.)
  

• STOP

  opcode	bits <12:0>
  110	0000000000000

  Description:  Prints the message "Stopping the LC-1 simulator" to the console and stops execution
  

• SUBTRACT

  opcode	bits <12:0>
  111	address13

   
  Description:  Acc <- Acc - mem[address13]
  (The content of memory location address13 is subtracted from the accumulator.
  The result is stored back in the accumulator.)
   
  

Design Considerations

• The simulator you write in LC-3 assembly language should be placed starting at memory location x3000
• The program you write in LC-1 machine code should be placed starting at memory location x6000
• The PC for the LC-1 should be placed at memory location x3100. Each time the PC changes during the simulation of the LC-1 program, memory location x3100 should be updated to reflect this change.
• The accumulator for the LC-1 should be placed at memory location x3200. Each time the accumulator changes during the simulation of the LC-1 program, memory location x3200 should be updated to reflect this change.
• The stack for the CALL and RETURN instructions should use memory locations x4000 - x4005 (maximum 5 locations for stack information). Initialize the stack pointer to x4005. You do not have to check for stack overflow or underflow.
• You do not have to check for valid instructions. You may assume that the LC-1 machine language program contains only valid instructions.
• Since an address specified in LC-1 is 13 bits and an address specified in LC-3 is 16 bits, you can not simply use an LC-3 load/store instruction to simulate an LC-1 load/store instruction. To get around this problem, apply a simple workaround. Concatenate the 3-bit bit pattern, 011, to the 13 bits of the LC-1 address. For example, suppose you have the following LC-1 instruction,

  100 0 0001 0000 0010 ; Load from address 0 0001 0000 0010

  You can emulate this LC-1 instruction using the LC-3 LDR instruction. First, concatenate 011 to the address specified in the the LC-1 LOAD instruction. This produces the address

  0110 0001 0000 0010.

  Next, put this value into one of the LC-3 registers, for example, R2. The LC-3 instruction LDR R1, R2, #0 will perform the load, and the result will be stored into R1. Last, R1 should be stored into the accumulator to complete the simulation of the LC-1 LOAD instruction.

• Algorithm - To begin writing your simulator, start with the code template shown below. The majority of the work is performed in the subroutine DECODE. The main loop of the simulator calls the FETCH and DECODE subroutines for each LC-1 instruction to simulate.

         .ORIG x3000
  ;=========================
  ; initialization block
  ;=========================
         ; ...
  
  ;=======================
  ; fetch the instruction
  ;=======================
  AGAIN JSR FETCH
  
  ;=======================
  ; decode the instruction
  ;=======================
        JSR DECODE
        BRnzp AGAIN
  
  ;===============================
  ; subroutine to perform fetch
  ;===============================
  FETCH ; ...
        ; ...
        RET
  
  ;===============================
  ; subroutine to perform decode
  ; and the rest of the
  ; instruction cycle
  ;===============================
  DECODE ; ...
         ; ...
         RET
         .END
  

  Once you can identify each opcode, tackle each of the LC-1 instructions one at a time. Thoroughly test each LC-1 instruction before going on to the next.
• In a separate file, you should write an LC-1 program using the .FILL pseudo-op. The LC-1 program begins with the line .ORIG x6000 indicating where this program is to be loaded into memory. Here is a sample LC-1 program:

        .ORIG x6000 ; An LC-1 program which starts at location x6000
  .FILL x8003 ; Load #10 into the accumulator
  .FILL x4004 ; Add #20 to the accumulator
  .FILL xC000 ; Stop the LC-1 simulator 
              ; (location x3200 should contain #30)
  .FILL #10   ;
  .FILL #20   ;
        .END
  

  You should load both the LC-1 program and the main simulator program into memory before running your simulation.

  You will be asked to turn in your LC-1 test program(s) along with the simulator program. Your LC-1 programs should demonstrate the full functionality of your simulator.

Documentation Guidelines

Each instruction in the LC-1 test program(s) should be commented.

Deliverables