R0/R1
and results will be returned in register(s). You may find that you do not
have enough registers to keep all of your variables in registers. In this case,
you will create variables (labels) to hold them.
The following list is the set of subroutines you must implement.
Part A:
pack(b1, b0)
- Pack (combines) the lower 8 bits of R0
and the lower 8 bits of R1
and pack them into a single
16 bit quantity in R0
. The lower 8 bits of R0
will be in the upper 8 bits of the result. Here is a visual example:
unpack(b)
- Unpack the 16 bits in R0
into
registers R0/R1
such that the upper 8 bits of R0
are stored in the lower 8 bits of R0
and the lower 8 bits
of R0
are stored in the lower 8 bits of R1
. The
rest of R0
and R1
needs to be padded with 0's.
Here is a visual example:
printCC()
- Print the word NEGATIVE, ZERO, POSITIVE
depending on the value in register R0
. At exit, register
R0
contains the original value. Each
word is followed by a newline. Do not depend on the condition code
being set to the correct value on entry. The test of
strcmp()
uses this method.Part B:
strlen(s)
- On entry R0
contains the
address of a valid (null terminated) C string. On exit, R0
contains the length.strcpy(dest, src)
- On entry R0
contains
a pointer to the start of the destination string
(dest
), and R1
contains a pointer to the start of the
null-terminated source string (src
). On exit,
src
has been copied to dest
(including the null
terminator) and R0
contains a pointer to the start of
dest
.strcat(dest, src)
- On entry R0
contains
a pointer to the start of the destination string (dest
), and R1
contains a pointer to the start of the source string (src
).
On exit, src
has been appended to the end of dest
and R0
contains a pointer to the start of the destination string. For example,
if "cdf" is to be appended to "abc", the destination string becomes "abccdf" and
R0
is a pointer to the "a". The destination string must be null terminated.strcmp(s1, s2)
- On entry R0
contains
a pointer to the start of a string (s1
), and R1
contains
another pointer to the start of a string (s2
). On exit R0
contains a negative number if s1 < s2
, zero if s1 == s2
and a positive number if s1 > s2
, based on the lexicographic
ordering (using ASCII values: e.g., Z is less than a).
Do not assume the strings have the same length (or even that they contain something).
When in doubt, use the strcmp
function as a reference.
Enter
key. As with any
project, incremental development will improve your efficiency.
You might first write pseudo-code in a C or Java syntax to understand the algorithum for a subroutine. If your pseudo code uses variables, you may want to declare these variables for you subroutine. Declare them before the first statement of the subroutine. Although using variables may make your code a little longer, it is likely that you will get correct results more quickly if you use them. When you need a value, simply load it from the memory. When you update the value, write it back to memory. This is the load/store model.
When you write the LC-3 code for a subroutine, you may find it helpful if you
add comments in each subroutine that explain how you are allocating the registers.
For example, you might write ; R4 holds the count
.
Testing/debugging each individual subroutines follows a pattern:
lc3as
.Option
to the index of the routine you wish
to test. You may want to change the .FILL
value so that
you do not need to continually reset it as you write, and debug your
subroutine.Continue
the simulator/debugger. If you have set a breakpoint,
it will stop when your program reaches that line. Use Step/Next
to watch your code execute and examine registers and memory locations for
correctness. You will want to use Next
so that you do NOT
step into the traps GETS, PUTS, PUTSP, GETC, OUT
. You may step
into them, but you will find them very tedious to step through.
You may want to call one subroutine from another, or add subroutines to
accomplish specific tasks. Do not duplicate code in multiple places. Recall that
calling a subroutine from another subroutine requires careful handling of the
return address (R7
), and that registers from the calling routine
may be overwritten.
Important: After your
subroutine completes, control must return to the corresponding
Test_
subroutine in the reserved section. For example, when your
printCC
subroutine gets to the RET
, the program needs
to return to right after JSR printCC
in the Test_printCC
subroutine. Otherwise, it means that you are not handling R7
correctly.
string.asm
using the Checkin tab of the
course website.