Ariana, Andrew, Jonah Submission

.gitignore

@@ -0,0 +1,12 @@
+# Ignore compiled binaries
+*
+!/**/
+!*.*
+!makefile
+*.out
+
+# Ignore gtkwave files
+*.vcd
+
+# Ignore temporary memory file
+mem.dat

AssemblyPrograms/bne_unit_test.asm

@@ -0,0 +1,17 @@
+main:
+addi $t3, $zero, 0
+addi $t4, $zero, 4
+
+whileloop:
+bne $t3, $t4, branchtaken
+
+saveres:
+addi $t5, $t3, 0
+j end
+
+branchtaken:
+addi $t3, $t3, 1
+j whileloop
+
+end:
+j end

AssemblyPrograms/combined_unit_tests.asm

@@ -0,0 +1,96 @@
+# Test the addi command
+additest:
+addi $t0, $zero, 5	# $t0 = 5
+addi $t1, $t0, 125	# $t1 = 130
+addi $t0, $t0, 4	# $t0 = 9
+
+# Test the xori command
+xoritest:
+# Reset the designated result register
+addi $t0, $zero, 0
+
+addi $t1, $zero, 2
+addi $t2, $zero, 11
+
+xori $t0, $t1, 7	# $t0 = 5
+xori $t0, $t2, 11	# $t0 = 0
+
+# Test the add command
+addtest:
+# Reset the designated result register
+addi $t0, $zero, 0
+
+# Two positive numbers
+addi $t1, $zero, 6
+addi $t2, $zero, 57
+
+# One positive and one negative number
+addi $t3, $zero, -9
+addi $t4, $zero, 20
+
+# Two negative numbers
+addi $t5, $zero, -5
+addi $t6, $zero, -11
+
+add $t0, $t1, $t2	# $t0 = 57 + 6 = 63
+add $t0, $t3, $t4	# $t0 = -9 + 20 = 11
+add $t0, $t5, $t6	# $t0 = -5 + -11 = -16
+
+# Test the sub command
+subtest:
+# Reset the designated result register
+addi $t0, $zero, 0
+
+sub $t0, $t1, $t2	# $t0 = 6 - 57 = -51
+sub $t0, $t3, $t4	# $t0 = -9 - 20 = -29
+sub $t0, $t5, $t6	# $t0 = -5 - -11 = 6
+
+# Test the slt command
+slttest:
+# Reset the designated result register
+addi $t0, $zero, 0
+
+slt $t0, $t1, $t2	# $t0 = 57 < 6 = 1
+slt $t0, $t3, $t4	# $t0 = -9 < 20 = 1
+slt $t0, $t5, $t6	# $t0 = -5 < 11 = 0
+
+# Test the bne command
+breginit:
+addi $t3, $zero, 0
+addi $t4, $zero, 4
+
+whileloop:
+bne $t3, $t4, branchtaken
+
+saveres:
+addi $t5, $t3, 0	# $t5 = 4
+j swtest
+
+branchtaken:
+addi $t3, $t3, 1
+j whileloop
+
+swtest:
+addi $sp, $zero, 64
+addi $t1, $zero, 2
+addi $t2, $zero, 169
+
+sw $t1, 0($sp)
+sw $t2, -4($sp)
+
+lwtest:
+lw $t3, 0($sp)	# $t3 = $t1 = 2
+lw $t4, -4($sp)	# $t4 = $t2 = 169
+
+jaltest:
+addi $t1, $zero 100	# $t1 = 100
+jal jrtest
+addi $t1, $t1, 1	# $t1 = 102
+j end
+
+jrtest:
+addi $t1, $t1, 1	# $t1 = 101
+jr $ra
+
+end:
+j end

AssemblyPrograms/fibonacci.asm

@@ -0,0 +1,134 @@
+
+# Function call example: recursive Fibonacci
+
+main: 
+
+addi $sp, $zero, 64
+# Set up arguments for call to fib_test
+addi  $a0, $zero, 7	# arg0 = 4
+addi  $a1, $zero, 3	# arg1 = 10
+jal   fib_test
+
+# Print result
+add   $a0, $zero, $v0	# Copy result into argument register a0
+
+# Jump to "exit", rather than falling through to subroutines
+j     program_end
+
+#------------------------------------------------------------------------------
+# Fibonacci test function. Equivalent C code:
+#     int fib_test(arg0, arg1) {
+#         return Fibonacci(arg0) + Fibonacci(arg1);
+#     }
+# By MIPS calling convention, expects arguments in 
+# registers a0 and a1, and returns result in register v0.
+fib_test:
+# We will use s0 and s1 registers in this function, plus the ra register 
+# to return at the end. Save them to stack in case caller was using them.
+addi  $sp, $sp, -12	# Allocate three words on stack at once for three pushes
+sw    $ra, 8($sp)	# Push ra on the stack (will be overwritten by Fib function calls)
+sw    $s0, 4($sp)	# Push s0 onto stack
+sw    $s1, 0($sp)	# Push s1 onto stack
+
+# a1 may be overwritten by called functions, so save it to s1 (saved temporary),
+# which called function won't change, so we can use it later for the second fib call
+add  $s1, $zero, $a1
+
+# Call Fib(arg0), save result in s0
+# arg0 is already in register a0, placed there by caller of fib_test
+jal   fib		# Call fib(4), returns in register v0
+add   $s0, $zero, $v0	# Move result to s0 so we can call fib again without overwriting
+
+# Call Fib(arg1), save result in s1
+add   $a0, $zero, $s1	# Move original arg1 into register a0 for function call
+jal   fib
+add   $s1, $zero, $v0	# Move result to s1
+
+# Add Fib(arg0) and Fib(arg1) into v0 (return value for fib_test)
+add   $v0, $s0, $s1
+
+# Restore original values to s0 and s1 registers from stack before returning
+lw    $s1, 0($sp)	# Pop s1 from stack
+lw    $s0, 4($sp)	# Pop s0 from stack
+lw    $ra, 8($sp)	# Pop ra from the stack so we can return to caller
+addi  $sp, $sp, 12	# Adjust stack pointer to reflect pops
+
+jr    $ra		# Return to caller
+
+#------------------------------------------------------------------------------
+# Recursive Fibonacci function. Equivalent C code:
+#
+#     int Fibonacci(int n) {
+#         if (n == 0) return 0;  // Base case
+#         if (n == 1) return 1;  // Base case
+#         int fib_1 = Fibonacci(n - 1);
+#         int fib_2 = Fibonacci(n - 2);
+#         return fib_1+fib_2;
+#     }
+fib:
+# Test base cases. If we're in a base case, return directly (no need to use stack)
+bne   $a0, 0, testone
+add   $v0, $zero, $zero		# a0 == 0 -> return 0
+jr    $ra
+testone:
+bne   $a0, 1, fib_body
+add   $v0, $zero, $a0		# a0 == 1 -> return 1
+jr    $ra
+
+fib_body:
+# Create stack frame for fib: push ra and s0
+addi  $sp, $sp, -8	# Allocate two words on stack at once for two pushes
+sw    $ra, 4($sp)	# Push ra on the stack (will be overwritten by recursive function calls)
+sw    $s0, 0($sp)	# Push s0 onto stack
+
+# Call Fib(n-1), save result in s0
+add   $s0, $zero, $a0	# Save a0 argument (n) in register s0
+addi  $a0, $a0, -1	# a0 = n-1
+jal   fib
+add   $a0, $s0, -2	# a0 = n-2
+add   $s0, $zero, $v0	# s0 = Fib(n-1)
+
+# Call Fib(n-2), compute final result
+jal   fib
+add   $v0, $v0, $s0	# v0 = Fib(n-2) + Fib(n-1)
+
+# Restore registers and pop stack frame
+lw    $ra, 4($sp)
+lw    $s0, 0($sp)
+addi  $sp, $sp, 8
+
+jr    $ra	# Return to caller
+
+#------------------------------------------------------------------------------
+# Utility function to print results
+print_result:
+# Create stack frame for ra and s0
+addi  $sp, $sp, -8
+sw    $ra, 4($sp)
+sw    $s0, 0($sp)
+
+add   $s0, $zero, $a0	# Save argument (integer to print) to s0
+
+addi    $v0, $zero, 4		# Service code to print string
+la    $a0, result_str	# Argument is memory address of string to print
+syscall
+
+addi    $v0, $zero, 1		# Service code to print integer
+add   $a0, $zero, $s0	# Argument is integer to print
+syscall
+
+# Restore registers and pop stack frame
+lw    $ra, 4($sp)
+lw    $s0, 0($sp)
+addi  $sp, $sp, 8
+
+#------------------------------------------------------------------------------
+# Jump loop to end execution, so we don't fall through to .data section
+program_end:
+j    program_end
+
+
+#------------------------------------------------------------------------------
+.data
+# Null-terminated string to print as part of result
+result_str: .asciiz "\nFib(4)+Fib(10) = "

AssemblyPrograms/slt_unit_test.asm

@@ -0,0 +1,18 @@
+# Set Less Than unit tests
+main:
+addi $t1, $zero, 6
+addi $t2, $zero 57
+
+addi $t3, $zero, -9
+addi $t4, $zero, 20
+
+addi $t5, $zero, -5
+addi $t6, $zero, -11
+
+slt $t0, $t1, $t2
+slt $t0, $t3, $t4
+slt $t0, $t5, $t6
+j end
+
+end:
+j end

AssemblyPrograms/sub_unit_test.asm

@@ -0,0 +1,18 @@
+# Subtraction unit tests
+main:
+addi $t1, $zero, 6
+addi $t2, $zero 57
+
+addi $t3, $zero, -9
+addi $t4, $zero, 20
+
+addi $t5, $zero, -5
+addi $t6, $zero, -11
+
+sub $t0, $t1, $t2
+sub $t0, $t3, $t4
+sub $t0, $t5, $t6
+j end
+
+end:
+j end

AssemblyPrograms/testCPU.asm

@@ -0,0 +1,17 @@
+main:
+addi $t3, $zero, 0
+addi $t4, $zero, 4
+
+whileloop:
+bne $t3, $t4, branchtaken
+
+saveres:
+addi $t5, $t3, 0
+j end
+
+branchtaken:
+addi $t3, $t3, 1
+j whileloop
+
+end:
+j end

CPU.v

@@ -0,0 +1,56 @@
+// 32 Bit CPU
+// Ariana Olson, Andrew Pan, Jonah Spear
+
+`include "Instruction_Parser/Instruction_Parser.v"
+`include "Core/Core.v"
+`include "PC_Calc/PC_Calc.v"
+`include "DFF.v"
+
+module CPU
+(
+    input CLK
+);
+    // PC is the current program counter, new_PC is what it's next value will be.
+    wire[31:0] PC, new_PC;
+    reg en;
+
+    initial begin
+        en = 0; #1000;
+        en = 1;
+    end
+
+    DFF #(32) pc(.trigger(CLK), .enable(en), .out(PC), .in(new_PC));
+
+    wire[4:0]  Rs, Rd, Rt;
+    wire[15:0] imm;
+    wire[25:0] addr;
+    wire[2:0]  ALUCtrl;
+    wire[1:0]  MemToReg, RegDst, PCSel;
+    wire       MemWr, ALUSrc, RegWr, AddSel;
+    InstructionParser ip(
+        .PC(PC),
+        .Rs(Rs), .Rd(Rd), .Rt(Rt),
+        .imm(imm), .addr(addr),
+        .ALUCtrl(ALUCtrl), .MemToReg(MemToReg),
+        .MemWr(MemWr), .ALUSrc(ALUSrc), .PCSel(PCSel),
+        .RegDst(RegDst), .RegWr(RegWr), .AddSel(AddSel)
+    );
+
+
+    wire[31:0] Da;
+    wire isZero;
+    wire[31:0] added_PC;
+    Core c(
+        .CLK(CLK), .Rd(Rd), .Rt(Rt), .Rs(Rs), .imm(imm), .addedPC(added_PC),
+        .RegDst(RegDst), .RegWr(RegWr), .MemWr(MemWr),
+        .ALUSrc(ALUSrc), .MemToReg(MemToReg), .ALUCntrl(ALUCtrl),
+        .Da(Da), .isZero(isZero)
+    );
+
+    PC_Calc pc_calc(
+        .old_PC(PC), .isZero(isZero), .PCSel(PCSel), .AddSel(AddSel),
+        .Da(Da), .addr(addr), .imm(imm), .added_PC(added_PC), .new_PC(new_PC)
+    );
+
+
+endmodule