R372 ISA

• Opcode names have been changed so that they are all four characters long (MIPS has variable length opcode names).
• The ISA is 16 bit, i.e., virtual addresses are assumed to be 16 bits long (MIPS uses 32 bit virtual addresses).
• All instructions are 16 bits long (MIPS instructions are 32 bits long).
• There is only one load/store data size, 16 bits (MIPS supports four load/store data sizes: 8, 16, 32 and 64 bits).
• There are no floating point instructions or registers (MIPS has floating point instructions and 32 32-bit floating point registers).
• There are 8 general purpose 16-bit integer registers (MIPS has 32 32-bit integer registers).
• There are no hardwired register values (In MIPS, register 0 is hardwired to 0).
• There are two counter registers, the instruction counter COUNTERS[0] and cycle counter COUNTERS[1], which are accessible via the instructions LCTR and CCTR (MIPS has no counters).
• There are eight LEDs which are accessible via the instruction SLED (MIPS has no LEDs).
• There are four SWITCHes which are accessible via the instruction LSWI (MIPS has no SWITCHes) .

R372 Definition

R372 Tools

There are two primary tools.

assembler: assembler -[x|b] <filename>. Given a file <filename>.a containing R372 assembly code will generate a file <filename>.imem.in which is an R372 "executable". The -x flag formats the executable in 16-bit space-delimited hexadecimal. The -b option formats the executable in binary. When initially developing programs, it helps to do everything in hexadecimal mode. In this mode, it is easy to create sample input files. Use binary mode only when you are ready to run your programs on the simulated hardware in the lab. In addition to the instruction mnemonics in the table above, the assembler also accepts comments (which it recognizes as lines starting with //) and labels (which it recognizes as lines starting with :). The assembler is not industrial strength, and will get confused by blank lines, extra spaces, missing commas, etc. Watch out for this and send mail to the newsgroup if you are having problems.

simulator: simulator -[x|b] -[s|t] <filename>. Given input files <filename>.imem.in containing R372 machine code and <filename>.dmem.in containing an input data memory image, will run the executable and generate a file <filename>.dmem.out which is the output data memory image of the program. Again, with the -x option, all files are in 16-bit space-delimited hexadecimal. With the -b option, they are all binary. The -[s|t] option is quite useful as well. With -s, the simulator runs silently. With -t, it prints out an annotated instruction level trace of your program, including the data inputs and outputs to each dynamic instruction. This should make it easier to debug your programs.

Here are a few more notes you should understand about the structure of the simulator and its input and output files.

R372 is a 16-bit ISA which means it can address 64K 16-bit memory words. These memory words are divided into two regions: instructions and data. Instruction memory is the lower 32K words starting at address 0 and ending at address (1<<15)-1. In 16-bit hex, these addresses are 0000 and 7FFF. The start PC (i.e., the address of the instruction that executes when the processor first boots is 0000. Data memory is the upper 32K words and goes from address (1<<15) to (1<<16)-1, or from 8000 to FFFF. When the simulator boots, it loads the file <filename>.imem.in into the instruction memory region, starting at address 0000. It also loads the file <filename>.dmem.in into the data memory region starting at address 8000. The <filename>.imem.in file is created by the assembler. The <filename>.dmem.in file is created by you. Hexadecimal files (the ones expected by the simulator when run in -x mode) can be easily created in emacs or any other text editor. For instance to create an initial data memory image with the number 11 in the first memory word and the number 3 in the second memory word, simply create a file called <filename>.dmem.in and make the contents of that file be "000B 0003".

As far as data memory, programs typically need both a "stack" area and a "heap" area, and the convention is that the heap area starts at the lower end of memory (8000) and grows up while the stack starts at the upper end (FFFF) of memory and grows down. The reason for this is that arrays are typically placed in the heap and it is easier to have a stack that grows down than to have a compiler that reverses all array access calculations. Anyway, you are free to use whatever convention you want, but this is probably easiest. The first thing your program should do when it boots is set up pointers to the stack and heap. R372 has 8 registers. You basically have to reserve one of them to be the stack pointer. You can initialize register R1 to FFFF using the following instruction sequence: SUBR R1, R1, R1; ORHI R1, -1; ORLO R1, -1. The first instruction sets R1 to 0. The second ors the bits FF into the upper half of R1 (the 8 bit binary representation of -1 is FF). After the second instruction, the contents of R1 are FF00. The final instruction ors the bits FF into the lower half of R1. You can set a register to the value of the first heap address in a similar manner.