Question 5

Input: If you load (with lw) from the special address 0xffff0004, MIPS will read one byte (8 bits) from standard input and store the byte in the destination register (padded with 0s to turn it into a 32-bit word). If there are no bytes left to read (the "end of file" is reached) then the destination register will contain 0xffffffff (the two's complement encoding of -1).

Output: If you store (with sw) to the special address 0xffff000c, MIPS will take the least significant byte (rightmost 8 bits) of the source register and write this byte to standard output.

Example: Read a byte from standard input, then print the byte to standard output, followed by a newline (ASCII 0x0a).

lis $20
.word 0xffff000c ; output address
lis $21
.word 0xffff0004 ; input address
lis $10
.word 0x0A       ; newline character
lw $3,  0($21)   ; read byte
sw $3,  0($20)   ; write byte
sw $10, 0($20)   ; write newline
jr $31

Suppose this program is stored in a file called example.asm. We can assemble this file as follows (after running source /u/cs241/setup):

cs241.binasm < example.asm > example.mips

Now, let's run the MIPS machine code with mips.stdin, and provide it some input on standard input. (Here we are just using Bash's <<< syntax for providing a single-line string as input.)

mips.stdin example.mips <<< "A"
Running MIPS program.
A
MIPS program completed normally.
$01 = 0x00000000   $02 = 0x00000000   $03 = 0x00000041   $04 = 0x00000000
$05 = 0x00000000   $06 = 0x00000000   $07 = 0x00000000   $08 = 0x00000000
$09 = 0x00000000   $10 = 0x0000000a   $11 = 0x00000000   $12 = 0x00000000
$13 = 0x00000000   $14 = 0x00000000   $15 = 0x00000000   $16 = 0x00000000
$17 = 0x00000000   $18 = 0x00000000   $19 = 0x00000000   $20 = 0xffff000c
$21 = 0xffff0004   $22 = 0x00000000   $23 = 0x00000000   $24 = 0x00000000
$25 = 0x00000000   $26 = 0x00000000   $27 = 0x00000000   $28 = 0x00000000
$29 = 0x00000000   $30 = 0x01000000   $31 = 0x8123456c

Notice that A (followed by a newline) is printed in between "Running MIPS program" and "MIPS program completed normally". If you only want to see standard output and suppress the other information, you can redirect standard error to /dev/null:

mips.stdin example.mips <<< "A" 2> /dev/null
A

To translate the assembly language line .word 241 into a 32-bit binary word, you need to convert the string "241" and to an actual integer. In C++, you might do this with a function like stoi, or using stream extraction with an int variable. In Racket, you could use string->number.

If you couldn't rely on the standard library of a high-level language, how would you implement this functionality? Let's write a simple version – for 8-bit numbers only – in MIPS assembly.

You can make the following assumptions about the input:

• It is a string encoded using ASCII and terminated by a line feed character (ASCII 0x0a).
• The line feed character only appears once in the input, as the last character.
• Aside from the line feed, only these eleven ASCII characters can appear in the input: '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', and '-' (minus sign).
• The '-' (minus sign) character cannot appear anywhere except as the first character of the input, and it might not appear at all.
• If the input starts with a '-' (minus sign), then it represents a decimal number in the range -128 to -1, inclusive. The first character after the '-' will never be a '0'. That is, leading zeroes in negative numbers are not allowed.
• If the input does not start with a '-' (minus sign), then it represents a decimal number in the range 0 to 255. If the first character is '0', then there are no other characters in the string, and the number represented is 0 (zero). That is, leading zeroes in positive numbers are not allowed.
• The input only represents a single number. Once you encounter the terminating line feed character, you have read all digits of the number.
• The input will not be empty, nor will it consist only of a single '-' sign. It will contain at least one digit character.

For valid input, the expected output is the same as the following C++ program:

#include <iostream>
int main() { 
  int n;  std::cin >> n; 
  std::cout << (char) n;
}

mips.stdin <(cs241.binasm < decimal.asm) <<< "33" 
Running MIPS program.
!MIPS program completed normally.
$01 = ...

To confirm that your output is correct for bytes that are not printable ASCII characters, you could perhaps redirect the output to a file, and examine the file using the same techniques you used in Question 1.