iskm/learnxinyminutes-docs
1
0
Fork 0
mirror of https://github.com/adambard/learnxinyminutes-docs.git synced 2024-12-24 10:01:38 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #3182 from Spiderpig86/master

Browse Source 
[MIPS/en] pull request
This commit is contained in:
Adam Bard 2018-08-23 21:58:09 -07:00 committed by GitHub
commit 5befc57081
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 366 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

366
mips.html.markdown Normal file
View File

@ -0,0 +1,366 @@
---
language: "MIPS Assembly"
filename: MIPS.asm
contributors:
- ["Stanley Lim", "https://github.com/Spiderpig86"]
---
The MIPS (Microprocessor without Interlocked Pipeline Stages) Assembly language
is designed to work with the MIPS microprocessor paradigm designed by J. L.
Hennessy in 1981. These RISC processors are used in embedded systems such as
gateways and routers.
[Read More](https://en.wikipedia.org/wiki/MIPS_architecture)
```assembly
# Comments are denoted with a '#'
# Everything that occurs after a '#' will be ignored by the assembler's lexer.
# Programs typically contain a .data and .text sections
.data # Section where data is stored in memory (allocated in RAM), similar to
# variables in higher level languages
# Declarations follow a ( label: .type value(s) ) form of declaration
hello_world: .asciiz "Hello World\n" # Declare a null terminated string
num1: .word 42 # Integers are referred to as words
# (32 bit value)
arr1: .word 1, 2, 3, 4, 5 # Array of words
arr2: .byte 'a', 'b' # Array of chars (1 byte each)
buffer: .space 60 # Allocates space in the RAM
# (not cleared to 0)
# Datatype sizes
_byte: .byte 'a' # 1 byte
_halfword: .half 53 # 2 bytes
_word: .word 3 # 4 bytes
_float: .float 3.14 # 4 bytes
_double: .double 7.0 # 8 bytes
.align 2 # Memory alignment of data, where
# number indicates byte alignment in
# powers of 2. (.align 2 represents
# word alignment since 2^2 = 4 bytes)
.text # Section that contains instructions
# and program logic
.globl _main # Declares an instruction label as
# global, making it accessible to
# other files
_main: # MIPS programs execute instructions
# sequentially, where the code under
# this label will be executed firsts
# Let's print "hello world"
la $a0, hello_world # Load address of string stored in
# memory
li $v0, 4 # Load the syscall value (indicating
# type of functionality)
syscall # Perform the specified syscall with
# the given argument ($a0)
# Registers (used to hold data during program execution)
# $t0 - $t9 # Temporary registers used for
# intermediate calculations inside
# subroutines (not saved across
# function calls)
# $s0 - $s7 # Saved registers where values are
# saved across subroutine calls.
# Typically saved in stack
# $a0 - $a3 # Argument registers for passing in
# arguments for subroutines
# $v0 - $v1 # Return registers for returning
# values to caller function
# Types of load/store instructions
la $t0, label # Copy the address of a value in
# memory specified by the label into
# register $t0
lw $t0, label # Copy a word value from memory
lw $t1, 4($s0) # Copy a word value from an address
# stored in a register with an offset
# of 4 bytes (addr + 4)
lb $t2, label # Copy a byte value to the lower order
# portion of the register $t2
lb $t2, 0($s0) # Copy a byte value from the source
# address in $s0 with offset 0
# Same idea with 'lh' for halfwords
sw $t0, label # Store word value into memory address
# mapped by label
sw $t0, 8($s0) # Store word value into address
# specified in $s0 and offset of 8 bytes
# Same idea using 'sb' and 'sh' for bytes and halfwords. 'sa' does not exist
### Math ###
_math:
# Remember to load your values into a register
lw $t0, num # From the data section
li $t0, 5 # Or from an immediate (constant)
li $t1, 6
add $t2, $t0, $t1 # $t2 = $t0 + $t1
sub $t2, $t0, $t1 # $t2 = $t0 - $t1
mul $t2, $t0, $t1 # $t2 = $t0 * $t1
div $t2, $t0, $t1 # $t2 = $t0 / $t1 (Might not be
# supported in some versons of MARS)
div $t0, $t1 # Performs $t0 / $t1. Get the quotient
# using 'mflo' and remainder using 'mfhi'
# Bitwise Shifting
sll $t0, $t0, 2 # Bitwise shift to the left with
# immediate (constant value) of 2
sllv $t0, $t1, $t2 # Shift left by a variable amount in
# register
srl $t0, $t0, 5 # Bitwise shift to the right (does
# not sign preserve, sign-extends with 0)
srlv $t0, $t1, $t2 # Shift right by a variable amount in
# a register
sra $t0, $t0, 7 # Bitwise arithmetic shift to the right
# (preserves sign)
srav $t0, $t1, $t2 # Shift right by a variable amount
# in a register
# Bitwise operators
and $t0, $t1, $t2 # Bitwise AND
andi $t0, $t1, 0xFFF # Bitwise AND with immediate
or $t0, $t1, $t2 # Bitwise OR
ori $t0, $t1, 0xFFF # Bitwise OR with immediate
xor $t0, $t1, $t2 # Bitwise XOR
xori $t0, $t1, 0xFFF # Bitwise XOR with immediate
nor $t0, $t1, $t2 # Bitwise NOR
## BRANCHING ##
_branching:
# The basic format of these branching instructions typically follow <instr>
# <reg1> <reg2> <label> where label is the label we want to jump to if the
# given conditional evaluates to true
# Sometimes it is easier to write the conditional logic backwards, as seen
# in the simple if statement example below
beq $t0, $t1, reg_eq # Will branch to reg_eq if
# $t0 == $t1, otherwise
# execute the next line
bne $t0, $t1, reg_neq # Branches when $t0 != $t1
b branch_target # Unconditional branch, will always execute
beqz $t0, req_eq_zero # Branches when $t0 == 0
bnez $t0, req_neq_zero # Branches when $t0 != 0
bgt $t0, $t1, t0_gt_t1 # Branches when $t0 > $t1
bge $t0, $t1, t0_gte_t1 # Branches when $t0 >= $t1
bgtz $t0, t0_gt0 # Branches when $t0 > 0
blt $t0, $t1, t0_gt_t1 # Branches when $t0 < $t1
ble $t0, $t1, t0_gte_t1 # Branches when $t0 <= $t1
bltz $t0, t0_lt0 # Branches when $t0 < 0
slt $s0, $t0, $t1 # Instruction that sends a signal when
# $t0 < $t1 with reuslt in $s0 (1 for true)
# Simple if statement
# if (i == j)
# f = g + h;
# f = f - i;
# Let $s0 = f, $s1 = g, $s2 = h, $s3 = i, $s4 = j
bne $s3, $s4, L1 # if (i !=j)
add $s0, $s1, $s2 # f = g + h
L1:
sub $s0, $s0, $s3 # f = f - i
# Below is an example of finding the max of 3 numbers
# A direct translation in Java from MIPS logic:
# if (a > b)
# if (a > c)
# max = a;
# else
# max = c;
# else
# max = b;
# else
# max = c;
# Let $s0 = a, $s1 = b, $s2 = c, $v0 = return register
ble $s0, $s1, a_LTE_b # if (a <= b) branch(a_LTE_b)
ble $s0, $s2, max_C # if (a > b && a <=c) branch(max_C)
move $v0, $s1 # else [a > b && a > c] max = a
j done # Jump to the end of the program
a_LTE_b: # Label for when a <= b
ble $s1, $s2, max_C # if (a <= b && b <= c) branch(max_C)
move $v0, $s1 # if (a <= b && b > c) max = b
j done # Jump to done
max_C:
move $v0, $s2 # max = c
done: # End of program
## LOOPS ##
_loops:
# The basic structure of loops is having an exit condition and a jump
instruction to continue its execution
li $t0, 0
while:
bgt $t0, 10, end_while # While $t0 is less than 10, keep iterating
addi $t0, $t0, 1 # Increment the value
j while # Jump back to the beginning of the loop
end_while:
# 2D Matrix Traversal
# Assume that $a0 stores the address of an integer matrix which is 3 x 3
li $t0, 0 # Counter for i
li $t1, 0 # Counter for j
matrix_row:
bgt $t0, 3, matrix_row_end
matrix_col:
bgt $t1, 3, matrix_col_end
# Do stuff
addi $t1, $t1, 1 # Increment the col counter
matrix_col_end:
# Do stuff
addi $t0, $t0, 1
matrix_row_end:
## FUNCTIONS ##
_functions:
# Functions are callable procedures that can accept arguments and return
values all denoted with labels, like above
main: # Programs begin with main func
jal return_1 # jal will store the current PC in $ra
# and then jump to return_1
# What if we want to pass in args?
# First we must pass in our parameters to the argument registers
li $a0, 1
li $a1, 2
jal sum # Now we can call the function
# How about recursion?
# This is a bit more work since we need to make sure we save and restore
# the previous PC in $ra since jal will automatically overwrite on each call
li $a0, 3
jal fact
li $v0, 10
syscall
# This function returns 1
return_1:
li $v0, 1 # Load val in return register $v0
jr $ra # Jump back to old PC to continue exec
# Function with 2 args
sum:
add $v0, $a0, $a1
jr $ra # Return
# Recursive function to find factorial
fact:
addi $sp, $sp, -8 # Allocate space in stack
sw $s0, ($sp) # Store reg that holds current num
sw $ra, 4($sp) # Store previous PC
li $v0, 1 # Init return value
beq $a0, 0, fact_done # Finish if param is 0
# Otherwise, continue recursion
move $s0, $a0 # Copy $a0 to $s0
sub $a0, $a0, 1
jal fact
mul $v0, $s0, $v0 # Multiplication is done
fact_done:
lw $s0, ($sp)
lw $ra, ($sp) # Restore the PC
addi $sp, $sp, 8
jr $ra
## MACROS ##
_macros:
# Macros are extremly useful for substituting repeated code blocks with a
# single label for better readability
# These are in no means substitutes for functions
# These must be declared before it is used
# Macro for printing new lines (since these can be very repetitive)
.macro println()
la $a0, newline # New line string stored here
li $v0, 4
syscall
.end_macro
println() # Assembler will copy that block of
# code here before running
# Parameters can be passed in through macros.
# These are denoted by a '%' sign with any name you choose
.macro print_int(%num)
li $v0, 1
lw $a0, %num
syscall
.end_macro
li $t0, 1
print_int($t0)
# We can also pass in immediates for macros
.macro immediates(%a, %b)
add $t0, %a, %b
.end_macro
immediates(3, 5)
# Along with passing in labels
.macro print(%string)
la $a0, %string
li $v0, 4
syscall
.end_macro
print(hello_world)
## ARRAYS ##
.data
list: .word 3, 0, 1, 2, 6 # This is an array of words
char_arr: .asciiz "hello" # This is a char array
buffer: .space 128 # Allocates a block in memory, does
# not automatically clear
# These blocks of memory are aligned
# next each other
.text
la $s0, list # Load address of list
li $t0, 0 # Counter
li $t1, 5 # Length of the list
loop:
bgt $t0, $t1, end_loop
lw $a0, ($s0)
li $v0, 1
syscall # Print the number
addi $s0, $s0, 4 # Size of a word is 4 bytes
addi $t0, $t0, 1 # Increment
j loop
end_loop:
## INCLUDE ##
# You do this to import external files into your program (behind the scenes,
# it really just takes whatever code that is in that file and places it where
# the include statement is)
.include "somefile.asm"
```