Skip to content

Latest commit

 

History

History
193 lines (159 loc) · 8.04 KB

README.md

File metadata and controls

193 lines (159 loc) · 8.04 KB
Raw

Lite Mips Simulator (LMS)

Lite Mips Simulator is a MIPS inspired (subset implementation) VM/CPU implementation.

Registers

LMS has :

  • 32 32-bit sized general-purpose registers
  • 3 special registers

General purpose registers

Register Number Alternative/Assembly Name Description
0 $zero the value 0
1 $at (assembler temporary) reserved by the assembler
2-3 $v0 - $v1 (values) from expression evaluation and function results
4-7 $a0 - $a3 (arguments) First four parameters for subroutine. Not preserved across procedure calls
8-15 $t0 - $t7 (temporaries) Caller saved if needed. Subroutines can use w/out saving. Not preserved across procedure calls
16-23 $s0 - $s7 (saved values) - Callee saved. A subroutine using one of these must save original and restore it before exiting. Preserved across procedure calls
24-25 $t8 - $t9 (temporaries) Caller saved if needed. Subroutines can use w/out saving. These are in addition to $t0 - $t7 above. Not preserved across procedure calls.
26-27 $k0 - $k1 reserved for use by the interrupt/trap handler
28 $gp global pointer. Points to the middle of the 64K block of memory in the static data segment.
29 $sp stack pointer Points to last location on the stack.
30 $s8/$fp saved value / frame pointer Preserved across procedure calls
31 $ra return address

Special purpose registers

  • HI register : Holds the high-part of a multiplication operation and the quotient of a division operation
  • LO register : Holds the low-part of a multiplication operation and the remainder of a division operation
  • PC register : Program Counter register

Instructions

Instructions within LMS are 32bit long with the first 6bits reserved to OpCode. Following formats are possible

  • R-type formats
31       25     20     15     10     5           0
+--------+------+------+------+------+-----------+
| OpCode |  Rs  |  Rt  |  Rd  |  SA  | Func Code |
+--------+------+------+------+------+-----------+
  • I-type formats
31       25     20     15                        0
+--------+------+------+-------------------------+
| OpCode |  Rs  |  Rt  | 2’s complement constant |
+--------+------+------+-------------------------+
  • J-type formats
31       25                                      0
+--------+---------------------------------------+
| OpCode |               Jump target             |
+--------+---------------------------------------+

Instructions

Following instructions are supported

  • Arithmetic and Logical Instructions
Instruction Opcode/Function Syntax Operation
add 100000 f $d, $s, $t $d = $s + $t
addu 100001 f $d, $s, $t $d = $s + $t
addi 001000 f $d, $s, i $d = $s + SE(i)
addiu 001001 f $d, $s, i $d = $s + SE(i)
and 100100 f $d, $s, $t $d = $s & $t
andi   001100 f $d, $s, i $t = $s & ZE(i)
div 011010 f $s, $t lo = $s / $t; hi = $s % $t
divu   011011 f $s, $t lo = $s / $t; hi = $s % $t
mult 011000 f $s, $t hi:lo = $s * $t
multu 011001 f $s, $t hi:lo = $s * $t
nor 100111 f $d, $s, $t $d = ~($s | $t)
or 100101 f $d, $s, $t $d = $s | $t
ori 001101 f $d, $s, i $t = $s | ZE(i)
sll 000000 f $d, $t, a $d = $t << a
sllv 000100 f $d, $t, $s d = $t << $s
sra 000011 f $d, $t, a $d = $t >> a
srav 000111 f $d, $t, $s $d = $t >> $s
srl 000010 f $d, $t, a $d = $t >>> a
srlv 000110 f $d, $t, $s $d = $t >>> $s
sub 100010 f $d, $s, $t $d = $s - $t
subu 100011 f $d, $s, $t $d = $s - $t
xor 100110 f $d, $s, $t $d = $s ^ $t
xori 001110 f $d, $s, i $d = $s ^ ZE(i)
lui 001111 f $t, i $t = i << 16
  • Comparison Instructions
Instruction Opcode/Function Syntax Operation
slt 101010 f $d, $s, $t $d = ($s < $t)
sltu 101001 f $d, $s, $t $d = ($s < $t)
slti 001010 f $d, $s, i $t = ($s < SE(i))
sltiu 001001 f $d, $s, i $t = ($s < SE(i))
  • Branch Instructions
Instruction Opcode/Function Syntax Operation
beq 000100 o $s, $t, offset if ($s == $t) pc += i << 2
bgtz 000111 o $s, offset if ($s > 0) pc += i << 2
bgez 000001 o $s, offset if ($s >= 0) pc += i << 2
bltz 000000 o $s, offset if ($s < 0) pc += i << 2
blez 000110 o $s, offset if ($s <= 0) pc += i << 2
bne 000101 o $s, $t, offset if ($s != $t) pc += i << 2
  • Jump Instructions
Instruction Opcode/Function Syntax Operation
j 000010 o index pc += i << 2
jal 000011 o index $31 = pc; pc += i << 2
jalr 001001 f labelR $31 = pc; pc = $s
jr 001000 f labelR pc = $s
  • Load Instructions
Instruction Opcode/Function Syntax Operation
lb 100000 o $t, i ($s) $t = SE (MEM [$s + i]:1)
lbu 100100 o $t, i ($s) $t = ZE (MEM [$s + i]:1)
lh 100001 o $t, i ($s) $t = SE (MEM [$s + i]:2)
lhu 100101 o $t, i ($s) $t = ZE (MEM [$s + i]:2)
lw 100011 o $t, i ($s) $t = MEM [$s + i]:4
  • Store Instructions
Instruction Opcode/Function Syntax Operation
sb 101000 o $t, i ($s) MEM [$s + i]:1 = LB ($t)
sh 101001 o $t, i ($s) MEM [$s + i]:2 = LH ($t)
sw 101010 o $t, i ($s) MEM [$s + i]:4 = LW ($t)
  • Data Movement Instructions
Instruction Opcode/Function Syntax Operation
mfhi 010000 f $d $d = hi
mflo 010010 f $d $d = lo
mthi 010001 f $s hi = $s
mtlo 010011 f $s lo = $s
  • Trap Instructions
Instruction Opcode/Function Syntax Operation
syscall 001100 o Cause a System Call exception.

Internal representation

The LMS will consist of two main components:

  • The assembler : That will translate program from assembly to runnable code (machine/byte code)
  • The virtual machine (that we can call MIPS CPU) that will run the generated code

Executable file format

The LMS executable file has the following format:

  • File header
  • Sections
  • String Table
  • Section Header Table

File header

It consists of several parts, each having a predefined size :

  • A magic number : 32-bit : [0x10, L, E, F]
  • Target major version : 8-bit
  • Target minor version : 8-bit
  • Entry point virtual-address : 32-bit Program entry point's file offset in bytes
  • Section Header Table's virtual-address : 32-bit SHT's file offset in bytes
  • Section Header count : 8-bit

Sections

It contains all defined sections storing them contiguously to each other

String Table

It's a 1-dimensional array holding the null-terminated string objects in the program. Its offset 0 as well as its last offset must contain '\0' to guarantee all strings are null-terminated.

Section Header Table

An array of all sections header each one having the following structure:

  • Name(16-bit) : It specifies the section name. Its value is an index into the String Table.
  • Type(8-bit) : One of the following :
    • SHT_EXEC (0x01) : Contains executable code
    • SHT_STRTAB (0x02) : Contains string table
    • SHT_ALLOC (0x04 ) : Contains program data
  • Offset(32-bit) : Section first byte offset from the beginning of the file
  • Size(32-bit) : Section size