You are encouraged to work on the problem set in groups and turn in one problem set for the entire group. Remember to put all your names on the solution sheet. Also remember to put the name of the TA in whose discussion section you would like the problem set turned back to you.
Bob Computer just bought a fancy new graphics display
for his LC-3. In order to test out how fast it is, he rewrote the OUT trap
handler so it would not check the DSR before outputting. Sadly he discovered
that his display was not fast enough to keep up with the speed at which the LC-3
was writing to the DDR. How was he able to tell?
Bob also rewrote the handler for GETC, but when he typed
ABCD into the keyboard, the following values were input:
AAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDD
What did Bob do wrong?
The following program does not do anything useful. However, being an “electronic idiot,” the LC-3 will still execute it.
.ORIG x3000
LD R0, Addr1
LEA R1, Addr1
LDI R2, Addr1
LDR R3, R0, #-5
LDR R4, R1, #0
ADD R1, R1, #3
ST R2, #4
STR R1, R0, #3
STI R4, Addr4
Addr1 .FILL x300A
Addr2 .FILL x000A
Addr3 .BLKW 1
Addr4 .FILL x300C
Addr5 .FILL x300B
.END
Without using the simulator, answer the following questions:
What will the values of registers R0 through R4 be after the LC-3 finishes executing the ADD instruction?
What will the values of memory locations Addr1 through Addr5 be after the LC-3 finishes executing the STI instruction?
The LC-3 has just finished executing a large program. A careful examination of each clock cycle reveals that the number of executed store instructions (ST, STR, and STI) is greater than the number of executed load instructions (LD, LDR, and LDI). However, the number of memory write accesses is less than the number of memory read accesses, excluding instruction fetches. How can that be? Be sure to specify which instructions may account for the discrepancy.
Assume that an integer greater than 2 and less than 32,768 is deposited in memory location A by another module before the program below is executed.
.ORIG x3000
AND R4, R4, #0
LD R0, A
NOT R5, R0
ADD R5, R5, #2
ADD R1, R4, #2
;
REMOD JSR MOD
BRz STORE0
;
ADD R7, R1, R5
BRz STORE1
ADD R1, R1, #1
BR REMOD
;
STORE1 ADD R4, R4, #1
STORE0 ST R4, RESULT
TRAP x25
;
MOD ADD R2, R0, #0
NOT R3, R1
ADD R3, R3, #1
DEC ADD R2, R2, R3
BRp DEC
RET
;
A .BLKW 1
RESULT .BLKW 1
.END
In 20 words or fewer, what does the above program do?
Hint: if you do not know what RET does, try the Index at the back of the book. In fact, you might even take care to look at footnotes on the referenced pages, in addition to the body of the page.
Write an LC-3 assembly language subroutine BIN_OUT that prints the value in R0 as a 16-bit binary number.
Write a similar subroutine BIN_GET that puts the zero-extended binary number input by the user into R0. Assume that the user will enter at least one and no more than 16 zeroes and/or ones. The user will then hit the “Enter” key (ASCII code x0A) to indicate the end of the binary number. Make sure to echo the input to the screen.
Assume that you have the following table in your program:
MASKS .FILL x0001
.FILL x0002
.FILL x0004
.FILL x0008
.FILL x0010
.FILL x0020
.FILL x0040
.FILL x0080
.FILL x0100
.FILL x0200
.FILL x0400
.FILL x0800
.FILL x1000
.FILL x2000
.FILL x4000
.FILL x8000
Write a subroutine SET in LC-3 assembly language that sets a bit in R0 using the table above. The index of the bit to set is specified in R1.
Write a similar subroutine CLEAR that clears the specified bit instead of setting it.
(This problem was added on 11/06/06) (Adapted from 7.18) The following LC-3 program compares two character strings of the same length. The source strings are in the .STRINGZ form. The first string starts at memory location x4000, and the second string starts at memory location x4100. If the strings are the same, the program terminates with the value 1 in R5, otherwise the program terminates with the value 0 in R5. Insert instructions at (a), (b), and (c) that will complete the program. There should be only 1 instruction per blank.
.ORIG x3000
LD R1, FIRST
LD R2, SECOND
AND R0, R0, #0
LOOP _________________ ; (a)
LDR R4, R2, #0
BRz NEXT
ADD R1, R1, #1
ADD R2, R2, #1
_________________ ; (b)
_________________ ; (c)
ADD R3, R3, R4
BRz LOOP
AND R5, R5, #0
BRnzp DONE
NEXT AND R5, R5, #0
ADD R5, R5, #1
DONE TRAP x25
FIRST .FILL x4000
SECOND .FILL x4100
.END
Jane Computer (Bob's adoring wife), not to be outdone
by her husband, decided to rewrite the TRAP x22 handler at a different place in
memory. Consider her implementation below. If a user writes a program that uses this
TRAP handler to output an array of characters, how many times is the ADD
instruction with label A executed? Assume that the
user only calls this TRAP handler once. What is wrong with this TRAP handler?
Now add the necessary instructions so the TRAP handler executes properly.
Hint: RET uses R7 as linkage back to the caller.
; TRAP handler
; Outputs ASCI characters stored in consecutive memory locations.
; R0 points to the first ASCI character.
; The null character (x00) provides a sentinel that terminates the output sequence.
.ORIG x020F
START LDR R1, R0, #0
BRz DONE
ST R0, SAVER0
ADD R0, R1, #0
TRAP x21
LD R0, SAVER0
A ADD R0, R0, #1
BRnzp START
DONE RET
SAVER0 .BLKW #1
.END
How many TRAP service routines can be implemented in the LC-3? Why?
Why must a RET instruction be used to return from a TRAP routine? Why won't
a BRnzp (unconditional BR) instruction work instead?
How many accesses to memory are made during the processing of a TRAP instruction?