LC-3 Programming Introduction for CS270

Recitation R6 - LC-3 Programming Introduction

CS270: Computer Organization

Goals

To learn how to write a basic LC-3 program with functions, conditionals, and a loop.
To learn how to use the LC-3 assembler and simulator to debug assembly code.

The Assignment

Make a subdirectory called R6 for the recitation; all files should reside in this subdirectory. Copy the file from the link below to the R6 directory, a listing of the code is shown below. R6.asm contains:

; Recitation 6
; Author:      <name>
; Date:        <date>
; Email:       <email>
; Class:       CS270
;
; Description: Implements integer (16-bit) addition, subtraction, and
;              multiplication.
;
;------------------------------------------------------------------------------
; Begin reserved section: do not change ANYTHING in reserved section!

                .ORIG x3000
                BR Main

Functions       .FILL IntAdd         ; Address of IntAdd routine (option 0)
                .FILL IntSub         ; Address of IntSub routine (option 1)
                .FILL IntMul         ; Address of IntMul routine (option 2)

Main            LEA R0,Functions     ; The main routine calls one of the 
                LD  R1,Option        ; subroutines below based on the value of
                ADD R0,R0,R1         ; the Option parameter.
                LDR R0,R0,0          ;
                JSRR R0              ;
EndProg         HALT                 ;

; Parameters and return values for all functions
Option          .FILL #0             ; Which function to call
Param1          .BLKW 1              ; Space to specify first parameter
Param2          .BLKW 1              ; Space to specify second parameter
Result          .BLKW 1              ; Space to store result

; End reserved section: do not change ANYTHING in reserved section!
;------------------------------------------------------------------------------
IntAdd                               ; Your code goes here
                                     ; Solution has ~4 instructions
                                     ; DON'T USE REGISTERS 5, 6, or 7!
                RET
;------------------------------------------------------------------------------
IntSub                               ; Your code goes here
                                     ; Solution has ~6 instructions
                                     ; DON'T USE REGISTERS 5, 6, or 7!
                RET

;------------------------------------------------------------------------------
IntMul                               ; Your code goes here
                                     ; Solution has ~9 instructions
                                     ; DON'T USE REGISTERS 5, 6, or 7!
                RET

;------------------------------------------------------------------------------
               .END

Use the LC-3 assembler to transform your assembly code into object code that can run on the LC-3 simulator:
```
    ~cs270/lc3tools/lc3as R6.asm
```
Load the LC-3 simulator and the TA will help you step through an invocation of one of the LC-3 subroutines:
```
    ~cs270/lc3tools/lc3sim-tk & 
```
When programming in assembly, it is easy to forget the syntax of each instruction (e.g., where do the source and destination registers go). Please refer to this document (starting on page 6) for a description of the assembly syntax for each LC-3 instruction.
Implement the IntAdd subroutine, using the following algorithm:
- Note: Don't use registers R5, R6, or R7. These registers will be reserved for other uses. In particular, R7 stores the return address. That way, when the RET instruction is executed, your program will go back to the caller correctly.
- Load the Param1 parameter into a register
- Load the Param2 parameter into a register
- Add the registers storing Param1 and Param2 into another register
- Store the result into the Result memory location and return
Test the IntAdd subroutine in the simulator using Option = 0, Param1 = 0x1234, and Param2 = 0x3456. Do the operation by hand to check your subroutine. Try a negative value as well. Make sure your program reaches the HALT in the main routine (otherwise, your program is considered wrong).
Implement the IntSub subroutine which computes Param1 - Param2. It is basically a clone of IntAdd. However you must negate the second operand before the addition. Use the 2’s complement to do this, as follows:
- Note: Don't use registers R5, R6, or R7.
- Invert the register storing Param2
- Increment Param2 using an immediate add
Test the IntSub subroutine in the simulator using Option = 1, Param1 = 0x8765, and Param2 = 0x3456. Do the operation by hand to check your subroutine. Try a negative value as well. Make sure your program reaches the HALT in the main routine (otherwise, your program is considered wrong).
Implement the IntMul subroutine, using this terrible algorithm:
- Note: Don't use registers R5, R6, or R7.
- Initialize a register for the result to zero
- Load the Param1 parameter into a register
- If zero, go to the exit code (see the last bullet)
- Load the Param2 parameter into a register
- If zero, go to the exit code (see the last bullet)
- In a loop, add the Param1 to the result, and decrement Param2
- Continue in the loop while Param2 is positive
- In the exit code store the Result value and return
Test the IntMul subroutine in the simulator, using Option = 2, Param1 = 0x1234, and Param2 = 0x0003. Do the operation by hand to check your subroutine. Try a negative value for Param1 as well. You may assume that Param2 will be 0 or positive (why do you think this important?). Make sure your program reaches the HALT in the main routine (otherwise, your program is considered wrong).