From f9db247bd6f2505ea7765c2e4105051e073dc4ed Mon Sep 17 00:00:00 2001 From: Christos Choutouridis Date: Thu, 14 May 2020 20:57:54 +0300 Subject: [PATCH] Init commit: Combine all COD projects to one repo --- .gitignore | 10 ++ Q3-qsort/mips1.asm | 207 ++++++++++++++++++++++++++++++++++++++++ Q3-qsort/quiz3.s | 207 ++++++++++++++++++++++++++++++++++++++++ Q3-qsort/src/main.c | 58 +++++++++++ Q5-mips_fpmul/fpmul.asm | 203 +++++++++++++++++++++++++++++++++++++++ 5 files changed, 685 insertions(+) create mode 100644 .gitignore create mode 100644 Q3-qsort/mips1.asm create mode 100644 Q3-qsort/quiz3.s create mode 100644 Q3-qsort/src/main.c create mode 100644 Q5-mips_fpmul/fpmul.asm diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..1d79102 --- /dev/null +++ b/.gitignore @@ -0,0 +1,10 @@ +# Mars related +*.jar + +# Eclipse related +Debug/ +Release/ +bin/ +.settings/ +.project +.cproject diff --git a/Q3-qsort/mips1.asm b/Q3-qsort/mips1.asm new file mode 100644 index 0000000..dba9112 --- /dev/null +++ b/Q3-qsort/mips1.asm @@ -0,0 +1,207 @@ +.data +v: .word 3, 10, 8, 2, 7, 1, 5, 9, 6, 4 + +.text +.globl main +main: + # intro - stack-frame + addi $sp, $sp, -12 # main + sw $ra, 8($sp) + sw $fp, 4($sp) + sw $s0, 0($sp) + addi $fp, $sp, 8 + + li $t0, 10 + + li $a0, 0 + li $a1, 9 + la $s0, v + jal qsort + + # epilogue - stack-frame + lw $s0, 0($sp) + lw $fp, 4($sp) + lw $ra, 8($sp) + addi $sp, $sp, 12 + jr $ra + + +# swap(int i, int j) : swaps elements of v[] +# at positions i and j +# $a0 = i +# $a1 = j +# $s0 = v +.text +swap: + # intro - stack-frame + addi $sp, $sp, -28 + sw $ra, 24($sp) + sw $fp, 20($sp) + + sw $s0, 16($sp) # v + sw $t0, 12($sp) # temp + sw $t1, 8($sp) # *v[i] + sw $t2, 4($sp) # *v[j] + sw $t3, 0($sp) # buffer + addi $fp, $sp, 24 + + + move $t1, $s0 # pointer assignements + sll $a0, $a0, 2 + add $t1, $t1, $a0 + move $t2, $s0 + sll $a1, $a1, 2 + add $t2, $t2, $a1 + + lw $t0, 0($t1) # temp = v[i] + lw $t3, 0($t2) # v[i] = v[j] + sw $t3, 0($t1) + sw $t0, 0($t2) # v[j] = temp + + # epilogue - stack-frame + lw $t3, 0($sp) + lw $t2, 4($sp) + lw $t1, 8($sp) + lw $t0, 12($sp) + lw $s0, 16($sp) + + lw $fp, 20($sp) + lw $ra, 24($sp) + addi $sp, $sp, 28 + jr $ra + +# partition(int f, int l) : partitions elements in vector v[] +# between positions f and l, using as pivot the element v[l], such +# that +# i < p ==> v[i] <= v[p] +# i > p ==> v[p] < v[i] +# The function returns the position p of the pivot. +# $a0 = f +# $a1 = l +# $s0 = v +# $v0 = p +.text +partition: + # intro - stack-frame + addi $sp, $sp, -40 + sw $ra, 36($sp) + sw $fp, 32($sp) + + sw $s0, 28($sp) # v + sw $s1, 24($sp) # pivot + sw $s2, 20($sp) # i + sw $s3, 16($sp) # j + sw $s4, 12($sp) # a0 (f) + sw $s5, 8($sp) # a1 (l) + sw $t0, 4($sp) + sw $t1, 0($sp) + addi $fp, $sp, 36 + + move $s4, $a0 + move $s5, $a1 + move $t0, $s0 # make *v[l] + move $t1, $a1 # t1 = l + sll $t1, $t1, 2 # t1 *= 4 + add $t0, $t0, $t1 + lw $s1, 0($t0) # pivot = v[l] + + move $s2, $s4 # i = f; + + # for () { + move $s3, $s4 # j = f; + _part_loop0: + slt $t0, $s3, $s5 # j < l + beq $t0, $0, _part_loop_end + move $t0, $s0 # make *v[j] + move $t1, $s3 + sll $t1, $t1, 2 + add $t0, $t0, $t1 + lw $t1, 0($t0) # t1 = v[j] + # if (v[j] < pivot) + slt $t0, $t1, $s1 + beq $t0, $0, _part_loop_else + + move $a0, $s2 # swap (i, j); + move $a1, $s3 + jal swap + addi $s2, $s2, 1 # i++ + + _part_loop_else: + addi $s3, $s3, 1 # j++ + j _part_loop0 # } + _part_loop_end: + move $a0, $s2 # swap (i, l) + move $a1, $s5 + jal swap + + move $v0, $s2 #return i + + # epilogue - stack-frame + lw $t1, 0($sp) + lw $t0, 4($sp) + lw $s5, 8($sp) + lw $s4, 12($sp) + lw $s3, 16($sp) + lw $s2, 20($sp) + lw $s1, 24($sp) + lw $s0, 28($sp) + + lw $fp, 32($sp) + lw $ra, 36($sp) + addi $sp, $sp, 40 + jr $ra + + +# qsort(int f, int l) : sorts the elements of v[] +# between positions f:l +# $a0 = f +# $a1 = l +# $s0 = v +.text +qsort: # qsort entry point + # intro - stack-frame with 4byte local var @ fp + addi $sp, $sp, -28 # qsort + sw $ra, 24($sp) + sw $fp, 20($sp) + + sw $s0, 16($sp) # v + sw $s2, 12($sp) # a0 (f) + sw $s3, 8($sp) # a1 (l) + sw $t0, 4($sp) + addi $fp, $sp, 24 + + move $s2, $a0 # get f, l + move $s3, $a1 + # if (f < l) { + slt $t0, $s2, $s3 + beq $t0, $0, _qsort_end + + move $a0, $s2 # pivot = partition(f, l); + move $a1, $s3 + jal partition + sw $v0, 0($sp) + + move $a0, $s2 # qsort(f, pivot - 1); + lw $t0, 0($sp) + addi $t0, $t0, -1 + move $a1, $t0 + jal qsort + + lw $t0, 0($sp) # qsort(pivot + 1, l); + addi $t0, $t0, 1 + move $a0, $t0 + move $a1, $s3 + jal qsort + # } + _qsort_end: + # epilogue - stack-frame + lw $t0, 4($sp) + lw $s3, 8($sp) + lw $s2, 12($sp) + lw $s0, 16($sp) + + lw $fp, 20($sp) + lw $ra, 24($sp) + addi $sp, $sp, 28 + jr $ra # return to caller + diff --git a/Q3-qsort/quiz3.s b/Q3-qsort/quiz3.s new file mode 100644 index 0000000..2baaa0c --- /dev/null +++ b/Q3-qsort/quiz3.s @@ -0,0 +1,207 @@ +.data +v: .word 3, 10, 8, 2, 7, 1, 5, 9, 6, 4 + + +# swap(int i, int j) : swaps elements of v[] +# at positions i and j +# $a0 = i +# $a1 = j +# $s0 = v +.text +swap: + # intro - stack-frame + addi $sp, $sp, -28 + sw $ra, 24($sp) + sw $fp, 20($sp) + + sw $s0, 16($sp) # v + sw $t0, 12($sp) # temp + sw $t1, 8($sp) # *v[i] + sw $t2, 4($sp) # *v[j] + sw $t3, 0($sp) # buffer + addi $fp, $sp, 24 + + + move $t1, $s0 # pointer assignements + sll $a0, $a0, 2 + add $t1, $t1, $a0 + move $t2, $s0 + sll $a1, $a1, 2 + add $t2, $t2, $a1 + + lw $t0, 0($t1) # temp = v[i] + lw $t3, 0($t2) # v[i] = v[j] + sw $t3, 0($t1) + sw $t0, 0($t2) # v[j] = temp + + # epilogue - stack-frame + lw $t3, 0($sp) + lw $t2, 4($sp) + lw $t1, 8($sp) + lw $t0, 12($sp) + lw $s0, 16($sp) + + lw $fp, 20($sp) + lw $ra, 24($sp) + addi $sp, $sp, 28 + jr $ra + +# partition(int f, int l) : partitions elements in vector v[] +# between positions f and l, using as pivot the element v[l], such +# that +# i < p ==> v[i] <= v[p] +# i > p ==> v[p] < v[i] +# The function returns the position p of the pivot. +# $a0 = f +# $a1 = l +# $s0 = v +# $v0 = p +.text +partition: + # intro - stack-frame + addi $sp, $sp, -40 + sw $ra, 36($sp) + sw $fp, 32($sp) + + sw $s0, 28($sp) # v + sw $s1, 24($sp) # pivot + sw $s2, 20($sp) # i + sw $s3, 16($sp) # j + sw $s4, 12($sp) # a0 (f) + sw $s5, 8($sp) # a1 (l) + sw $t0, 4($sp) + sw $t1, 0($sp) + addi $fp, $sp, 36 + + move $s4, $a0 + move $s5, $a1 + move $t0, $s0 # make *v[l] + move $t1, $a1 # t1 = l + sll $t1, $t1, 2 # t1 *= 4 + add $t0, $t0, $t1 + lw $s1, 0($t0) # pivot = v[l] + + move $s2, $s4 # i = f; + + # for () { + move $s3, $s4 # j = f; + _part_loop0: + slt $t0, $s3, $s5 # j < l + beq $t0, $0, _part_loop_end + move $t0, $s0 # make *v[j] + move $t1, $s3 + sll $t1, $t1, 2 + add $t0, $t0, $t1 + lw $t1, 0($t0) # t1 = v[j] + # if (v[j] < pivot) + slt $t0, $t1, $s1 + beq $t0, $0, _part_loop_else + + move $a0, $s2 # swap (i, j); + move $a1, $s3 + jal swap + addi $s2, 1 # i++ + + _part_loop_else: + addi $s3, 1 # j++ + j _part_loop0 # } + _part_loop_end: + move $a0, $s2 # swap (i, l) + move $a1, $s5 + jal swap + + move $v0, $s2 #return i + + # epilogue - stack-frame + lw $t1, 0($sp) + lw $t0, 4($sp) + lw $s5, 8($sp) + lw $s4, 12($sp) + lw $s3, 16($sp) + lw $s2, 20($sp) + lw $s1, 24($sp) + lw $s0, 28($sp) + + lw $fp, 32($sp) + lw $ra, 36($sp) + addi $sp, $sp, 40 + jr $ra + + +# qsort(int f, int l) : sorts the elements of v[] +# between positions f:l +# $a0 = f +# $a1 = l +# $s0 = v +.text +qsort: # qsort entry point + # intro - stack-frame with 4byte local var @ fp + addi $sp, $sp, -28 # qsort + sw $ra, 24($sp) + sw $fp, 20($sp) + + sw $s0, 16($sp) # v + sw $s2, 12($sp) # a0 (f) + sw $s3, 8($sp) # a1 (l) + sw $t0, 4($sp) + addi $fp, $sp, 24 + + move $s2, $a0 # get f, l + move $s3, $a1 + # if (f < l) { + slt $t0, $s2, $s3 + beq $t0, $0, _qsort_end + + move $a0, $s2 # pivot = partition(f, l); + move $a1, $s3 + jal partition + sw $v0, 0($sp) + + move $a0, $s2 # qsort(f, pivot - 1); + lw $t0, 0($sp) + addi $t0, $t0, -1 + move $a1, $t0 + jal qsort + + lw $t0, 0($sp) # qsort(pivot + 1, l); + addi $t0, $t0, 1 + move $a0, $t0 + move $a1, $s3 + jal qsort + # } + _qsort_end: + # epilogue - stack-frame + lw $t0, 4($sp) + lw $s3, 8($sp) + lw $s2, 12($sp) + lw $s0, 16($sp) + + lw $fp, 20($sp) + lw $ra, 24($sp) + addi $sp, $sp, 28 + jr $ra # return to caller + + +.text +.globl main +main: + # intro - stack-frame + addi $sp, $sp, -12 # main + sw $ra, 8($sp) + sw $fp, 4($sp) + sw $s0, 0($sp) + addi $fp, $sp, 8 + + li $t0, 10 + + li $a0, 0 + li $a1, 9 + la $s0, v + jal qsort + + # epilogue - stack-frame + lw $s0, 0($sp) + lw $fp, 4($sp) + lw $ra, 8($sp) + addi $sp, $sp, 12 + jr $ra diff --git a/Q3-qsort/src/main.c b/Q3-qsort/src/main.c new file mode 100644 index 0000000..5d0e0c4 --- /dev/null +++ b/Q3-qsort/src/main.c @@ -0,0 +1,58 @@ +//============================================================================ +// Name : quiz3.cpp +// Author : Christos Choutouridis +// Version : +// Copyright : Your copyright notice +// Description : Hello World in C++, Ansi-style +//============================================================================ + + + +int v[] = { + 3, 10, 8, 2, 7, 1, 5, 9, 6, 4 +}; + + +void swap (int i, int j) { + int t = v[i]; + v[i] = v[j]; + v[j] = t; +} + +// partition(int f, int l) : permutes the values in vector v[] +// between positions f and l, using as pivot the element v[l], such +// that +// f <= i < p ==> v[i] <= v[p] +// p < i <= l ==> v[p] < v[i] +// The function returns the position p of the pivot. +int partition(int f, int l) { + int pivot = v[l]; // element v[l] is the pivot + int i = f; // i points to the beginning of the vector + + // loop over vector + for (int j = f; j < l; j++) + if (v[j] < pivot) // element smaller than pivot + swap(i++,j); // swap it with position pointed by i + + swap(i, l ); // swap pivot to its correct position + return (i); // return pivot's position +} + +// qsort(int f, int l) : sorts the elements of v[] between positions f:l +void qsort(int f, int l) { + int pivot; + if (f < l) { + pivot = partition(f, l); + + qsort(f, pivot - 1); // Before pi + qsort(pivot + 1, l); // After pi + } +} + + +int main() { + int n = 10; + + qsort (0, 9); + return 0; +} diff --git a/Q5-mips_fpmul/fpmul.asm b/Q5-mips_fpmul/fpmul.asm new file mode 100644 index 0000000..be79ba6 --- /dev/null +++ b/Q5-mips_fpmul/fpmul.asm @@ -0,0 +1,203 @@ +.text +.globl main +main: + # intro - stack-frame + addi $sp, $sp, -8 # main + sw $ra, 4($sp) + sw $fp, 0($sp) + addi $fp, $sp, 0 # stack arguments (no) + + li $a0, 0xbf800000 # <-- test case goes here + li $a1, 0x3f800000 + jal multFloat + + # epilogue - stack-frame + lw $fp, 0($sp) + lw $ra, 4($sp) + addi $sp, $sp, 8 + jr $ra + +# +# encodeFloat (sign, exp, mant) +# Arguments +# $a0: The sign +# $a1: The exponent without the bias +# $a2: The normalized mantissa 24bit, with the implied bit +# Retuen +# $v0: The floating point word +encodeFloat: + # intro - stack-frame + addi $sp, $sp, -8 # encodeFloat + sw $ra, 4($sp) + sw $fp, 0($sp) + addi $fp, $sp, 0 # stack arguments (no) + + sll $v0, $a0, 31 # v0 = sign << 31 + + addi $a1, $a1, 127 # v0 |= (exp + offset) << 23 + sll $a1, $a1, 23 + or $v0, $v0, $a1 + + li $t0, 0x7FFFFF # v0 |= (mant & 0x7FFFFF); + and $a2, $a2, $t0 + or $v0, $v0, $a2 + + # epilogue - stack-frame + lw $fp, 0($sp) + lw $ra, 4($sp) + addi $sp, $sp, 8 + jr $ra + +# +# decodeFloat(number) +# arguments +# $a0 : 32bit floating point +# return +# $v0 : sign unsigned int 0 or 1 +# $v1 : exponent the value of bits(30:24) - 127, signed integer +# $a1 : mantissa with bits 1 followed by bits (22:0) +decodeFloat: + # intro - stack-frame + addi $sp, $sp, -8 # decodeFloat + sw $ra, 4($sp) + sw $fp, 0($sp) + addi $fp, $sp, 0 # stack arguments (no) + + srl $v0, $a0, 31 # sign[v0] = a0 >> 31; + + srl $t0, $a0, 23 # exp[v1] = ((a0 >> 23) & 0xFF) - 127; + and $t0, $t0, 0xFF + addi $v1, $t0, -127 + + li $t0, 0x7FFFFF # Mantissa[a1] = (a0 & 0x7FFFFF) | 0x800000; + and $a1, $a0, $t0 + li $t0, 0x800000 + or $a1, $a1, $t0 + + # epilogue - stack-frame + lw $fp, 0($sp) + lw $ra, 4($sp) + addi $sp, $sp, 8 + jr $ra # return + +# +# multFloat(f1, f2) +# arguments +# $a0 : 32bit floating point 1 +# $a1 : 32bit floating point 2 +# return +# $v0 : 32bit floating point multiplication result +multFloat: + # s0: sign and argument 2 + # s1: exp + # s2: mantissa + # intro - stack-frame + addi $sp, $sp, -20 # multFloat + sw $ra, 16($sp) + sw $fp, 12($sp) + sw $s2, 8($sp) + sw $s1, 4($sp) + sw $s0, 0($sp) + addi $fp, $sp, 0 # stack arguments (no) + + move $s0, $a1 # save 2nd argument + jal decodeFloat # decodeFloat(arg1) : [v0, v1, a1] <- [s, e, m] + move $t0, $s0 # $s0 change variable to $t0 + move $s0, $v0 # load return values to variable regs + move $s1, $v1 + move $s2, $a1 + + move $a0, $t0 # load back argument 2 + jal decodeFloat # decodeFloat(arg2) : [v0, v1, a1] <- [s, e, m] + xor $s0, $s0, $v0 # sign = s1 ^ s2 + add $s1, $s1, $v1 # exp = e1 + e2 + + multu $s2, $a1 # mantissa = m1 * m2 + mfhi $t4 # t4: mantissa-hi + mflo $t3 # t3: mantissa-low + addi $s2, $zero, 0 + + li $t9, 0x8000 # if (HI & (1<<15)) + and $t8, $t9, $t4 + beq $t8, $zero, _multf_l0 + # (true)not zero, 48-bits result, normalize + sll $s2, $t4, 8 # mant = HI << 8 + srl $t9, $t3, 24 # mant |= LOW >> (32-8) + or $s2, $s2, $t9 + addi $s1, $s1, 1 # ++exp, normalize + li $t9, 0x800000 # if (ml & (1<<23)), rounding check + and $t8, $t9, $t3 + beq $t8, $zero, _multf_l0_end + addi $s2, $s2, 1 # ++mant, round-up + j _multf_l0_end + _multf_l0: + # (false)zero, 47-bits result + sll $s2, $t4, 9 # mant = HI << 9 + srl $t9, $t3, 23 # mant |= LOW >> (32-9) + or $s2, $s2, $t9 + li $t9, 0x400000 # if (ml & (1<<22)), rounding check + and $t8, $t9, $t3 + beq $t8, $zero, _multf_l0_end + addi $s2, $s2, 1 # ++mant, round-up + _multf_l0_end: + + move $a0, $s0 + move $a1, $s1 + move $a2, $s2 + jal encodeFloat # encodeFloat(s, e, m) : float(v0) + + # epilogue - stack-frame + lw $s0, 0($sp) + lw $s1, 4($sp) + lw $s2, 8($sp) + lw $fp, 12($sp) + lw $ra, 16($sp) + addi $sp, $sp, 20 + jr $ra # return + + +# +# fprod(vector, size) +# Calculates the product x[0] * x[1] * x[2] * ... * x[n-1] as +# Left fold of product operator on a vector of numbers - foldl(*, x) +# +# Arguments +# $a0: Pointer to array x[] in RAM +# $a1: Number of elements +# Return +# $v0: The product +fprod: + # intro - stack-frame + addi $sp, $sp, -20 # fprod + sw $ra, 16($sp) + sw $fp, 12($sp) + sw $s2, 8($sp) + sw $s1, 4($sp) + sw $s0, 0($sp) + addi $fp, $sp, 0 # stack arguments (no) + + # keep input arguments + move $s0, $a0 # x[] + move $s1, $a1 # n + + lw $v0, 0($s0) # Acc = *x + addi $s2, $zero, 1 # i=1 + _fprod_loop: # for ( ; i