Program 2 Instruction
Overview
In program 1, you have written an assembler for MIPS Assembly Language, which you take an
MIPS code input and convert it to its corresponding machine language (binary) code. Program 2
is called a MIPS Simulator, in which you will take a MIPS code input and simulate executing the
code. For example, if an adder MIPS code is given to you, your first program should translate it
into a binary code file, and your second program should prompt the user to enter two integers
and output the correct answer.
Logic
Unlike the first program in which you are allowed to achieve the goal however you wanted to,
you will have some restrictions this time. That is, you will execute the MIPS code just like how a
machine does it. The logic behind this program is fairly easy if you understand how machine
works. Recall the basic machine cycle, where you load an instruction, increment PC, and execute
the loaded instruction. You will do the exact same thing.
With that being said, you will need to:
1. Simulate memory. In your C/C++ program, allocate a block of memory of 6MB, which
should be sufficient. This is used to simulate the main memory. For more details of
simulating main memory in case you forgot, refer to page A20-A22 of the book (Appendix
A). In our case, reserve 1MB for text section. You are going to map the memory address of
the block you allocated to 0x00400000, which is a 32 bit address. When you do operations
that involve memory, you simply reversely map the 32 bit address back to 64 bit, for access
in your computer’s memory. For example, you called malloc for allocating a 6MB of
memory, it returned 0x100000000022000, which is a 64 bit address. Then, you give it a
name of 0x00400000, which is a 32 bit address. After you do this, everything else will just
act normal. In your MIPS when you want to access some memory address, you will simply
calculate the offset of that address from 0x00400000, and add that offset to
0x100000000022000. In short, you will give the 64 bit address a 32 bit “name”.
2. Allocate and maintain memory spaces to simulate the regular 32 registers. Correctly use
them, including $fp, $sp, etc. Since we are using a mapping from 64 bit address to 32 bit
address, the address can be put in a 32 bit register. You can allocate 4 bytes for each register.
3. Maintain a PC, which indicates the next instruction to load.
4. Maintain a code section in your simulated memory, where the assembled MIPS machine
code is put.
5. Maintain a data section in your simulated memory, where the pre-defined data in MIPS code
(.data section) is put. Located on top of text section. For dynamic data, it grows towards
higher memory address. For the data you read in from .data section, you will line them up in
order in data segment of your simulated memory. The first piece of data in .data section of
MIPS code will be put at the lowest memory address of your data segment. The rule to put
data is each piece of data is going to occupy the full block (4 bytes) even if it used only part
of a block. For example, a string of length 11 is using 11 bytes in memory, and put at address
0x0. Then it used up two full blocks (8 bytes), and 3/4 of the third block, which starts at 0x8.
The next piece of data should not be put at address 0xB, instead, it should be put at address
0xC.
6. Maintain a stack section in your simulated memory, which grows towards lower memory
address.
7. Simulate what each instruction does using C/C++. This could be done by writing a function
for each instruction.
8. Simulate the execution. You are expected to follow the machine cycle. Judge which
instruction it is, call the function.
9. You need to support syscall instruction (in your assembler and simulator), which is down
below. You also need to support SPIM syscalls below.
Grading
Instruction/syscall execution - 40%
each wrongly implemented instruction/syscall will result in 2% deduction.
Memory and register simulation - 30%
Machine cycle - 10%
Coding style/comments - 10%
Report - 10%