Clarifications

HOW TO SUBMIT

• Make sure you have a Makefile and a README, indicating what works and what doesn't. Include anything special that might be working (extra credit).
• When running make p2, it should create an executable called p2. If you are implementing it in Java, use the same technique for submitting as you did in p1.
• Submit a tar file with Makefile, README, and all the other files needed.
• The program will run your code on the following:

  p2 -d 0x0400 -t 0x0800 -f primary.file -s < primary.input
  

  This is essentially the code in run.sh.

Sunday, July 7

• When running step, you should print the instruction number (if you see the output, the instructions are numbered 0 to like 35 or 36). This is NOT the number of instructions run so far.
• Also, when running step, the output of "Running instruction..." might appear on the same line as a print statement without a newline at the end. To precent this, print a newline BEFORE printing "Running instruction...". This will generate blank lines, but at least it won't run into some of the lines.
• S. Parker notices that the output for printing the registers should be 8 hex digits (32 bits), not 4. For example, it should look like:

  Reg[ 10 ] = -1  0xFFFFFFFF
  Reg[ 11 ] = 12  0x0000000C
  Reg[ 12 ] =  7  0x00000007
  

Saturday, July 6

• lb should really be lbu (load byte unsigned). lb does sign extension, which is not what I want (though it shouldn't matter for ASCII). If you want, handle both lb and lbu identically.
• Logical operators are zero-extended, not sign-extended, i.e., the upper 16 bits are zeroes.
• M. Gebremichael notices that instruction 6 and 10 cause the address of value (and value + 3) to be stored in a register.

  The original (incorrect) program, then prints the contents of the register, which contains an address. That's incorrect (based on the comment---which is why you should always comment every line of assembly). Instead, it should treat the register content as an address, and find the contents of the memory address.

  This is called register addressing, where you load something from memory based on an address in a register. jr uses register addressing.

  In order to print a byte value in memory, two more interrupts are required. Fortunately, they are similar to the ones listed below.

  • swi print byte int memory reg

    reg stores an address of a byte in memory. Print the byte in unsigned base 10 (thus values will print between 0 and 255) located at that address.

  • swi print byte hex memory reg

    reg stores an address of a byte in memory. Print the byte in unsigned hex (thus values will print between 0x00 and 0xFF) located at that address.

Thursday, July 4

• In the output, when you print the code, also print the instruction number, starting at instruction 0 prior to the hex address.
• Hex address should be printed to 4 hex digits
• When printing the labels, add the instruction number in parentheses afterwards.
• See sample.output for example.
• As usual, send errors, corrections to clin (at) umd5.umd.edu

Monday, July 1

• A new software interrupt has been added.

  swi exit

  Quit execution of the program.

• Also, following interrupts are used.

  • swi print word int memory reg

    Print the contents at memory address stored in register, reg, (written as, e.g. $r10) as an signed int. Assume that the address stored in reg is word-aligned. (Can print error message if not).

  • swi print word hex memory reg

    Print the contents at memory address, stored in register reg, as unsigned hex. Assume that it's word-aligned memory. (Can print error message if not). addr can be base 10 or hex.

  • swi print char memory reg

    Print the contents at memory address, stored in register reg, as a char. The address does not have to be word-aligned. This time, print out the character. So, if the register contains "\n", actually print out the newline character.

  • swi print string memory reg

    Print the contents at memory address, stored in register reg, as a string. reg appears as something like $r10. This should print character by character, until you reach a null character (which should not be printed), at which point you stop.

• Also, there's a new switch for the command line: -s

  If it exists, then you print out all the information from before during a load, i.e. [ label = val, type = byte, num bytes = 1, start addr = 100A ], etc.

  If the switch does NOT exist, then just print.

  Program [<filename>] successfully loaded.
  

• load has the -s flag, too, which may or may not appear. If it appears, then print all the usual info. If not, then print the message above.

• reload is not affected by the -s option, i.e., it doesn't appear for the command.

• (EXTRA CREDIT) Implement the following:

  display prog-info

  This will print the [ label = val, type = byte, num bytes = 1, start addr = 100A ], etc. for the program that is currently loaded.

• (EXTRA CREDIT) Pseudo-commands The following commands don't exists, but can be rewritten.
  • bge (branch on greater than or equal)
  • bgt (branch on greater than),
  • ble (branch on less than or equal)
  • blt (branch on less than)
  • sle (set on less than or equal)
  • sge (set on greater than or equal)
  • sgt (set on greater than)
  • mov $rd, $rs (Reg[ $rd ] = Reg[ $rs ]).
  • movi $rd, immed

  These instructions should be rewritten using one or more valid MIPS instructions. When you load the instruction, they should be rewritten to the new instructions. Add a comment to those instructions indicating the original instruction.

  Key issues in rewriting instructions. mov can be implemented by using addi or ori. movi is tough, becuaes you can also use addi or ori, but you need to check how big immed is. If it's more than 16 bits, you need to use two commands (such as lui and ori together.)

See the class syllabus for policies concerning email Last Modified: Mon Jul 1 23:26:44 EDT 2002

Web Accessibility