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).

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". By default, the assembler 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 <filename> [-t] [-x] [-<input>]. 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, all files are in 16-bit space-delimited hexadecimal. If a program has multiple input data files <filename>.dmem.in1, <filename>.dmem.in2, you can choose them using the option -1 or -2, respectively.

The [-t] option is quite useful as well. With -t, the simulator 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. The simulator prints out values in integer format. If you would rather debug values in hexadecimal format (which is easier for certain things) add the [-x] option.

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: CNST R1, -1. To set a register to the first heap address, however, you need a sequence of multiple instructions: CNST R1, 0; ORHI R1, -128.