IT253: Computer Organization Lecture 5: Assembly Language and an Introduction to MIPS Tonga Institute of Higher Education

Computer Organization CPU contains three components: Registers — Hold data values for CPU ALU — Arithmetic Logic Unit; performs arithmetic and logic functions. Takes values from and returns values to the registers Control — Determines what operation to perform, directs data flow to/from memory, directs data flow between registers and ALU. Actions are determined by the current Instruction.

Where a program lives

How are programs executed? Individual instructions (like add $r1,$r2 ) are taken from memory (ex. the RAM). These instructions are decoded and they tell the processor what to do. The operands (the variables) are then taken from memory and the operation is performed (executed). The result of the operation is stored The next instruction starts everything over again.

What does the processor need to know? We have to create our instructions and operands (variables) so that the computer hardware can use them –We need to specify the Instruction format = the format of the binary machine language Where to find operands (variables) in memory How many operands (variables) will we use What operations are supported Successor instructions (how do we get to another instruction or the next instruction)

Categories of MIPS Instructions Arithmetic –add, subtract, multiply, divide… Logical –Like boolean logic, AND, OR, NOR… Data transfer –Store and load things from memory Branching –if – else statements Jumping –When we program functions, we need to “jump” out of the current instruction set

MIPS Architecture MIPS uses a three address format for instructions This means, for most instructions, you need to specify three registers, or at least two registers and a constant number Examples –add $1, $2, $3 # $1 = $2 + $3 –addi $1, $1, 4 # $1 = $1 + 4

MIPS Registers Registers are where the CPU saves the data it is working on in the present This memory is very fast because it is built into the processor. On MIPS machines, the registers are all 32 bits. –They can hold integers that use up to 32 bits (2^32) –They can also store addresses (pointers) to places in memory –Since there are 32 bits, MIPS can access 2^32 places in memory

MIPS Registers The registers you will use are called General Registers There are 31 of them available in MIPS (R0 always equals 0, so you can’t change that one). You can use R1-R31. There are also 32 frame pointers. These are used to keep track of where you have saved data in the memory. There are also a few floating point registers which allow you to store and manipulate floating point numbers

MIPS Registers There are also special registers –The PC register – The program counter. This holds the address of the next instruction that will be executed. –The GP register – global pointer. Contains the address of where the program starts

Registers

MIPS Instructions MIPS math functions are the simplest to use and understand –They use three operands (registers) –Math is done in the registers. –Registers must be loaded with the right values –The result of a math function is saved in the first operand Example –C++/Java code  int x = y + z; –MIPS code  add $s0,$s1,$s2 # s0 = x, s1 = y, s2 = z # s0 = s1 + s2

MIPS Adding If we only have three operands, how can we do the following –int a = w + x + y + z; We have to store in temporary values add $t0,$s0,$s1 # t0 = w + x; add $t1,$s2,$s3 # t1 = y + z; add $s4,$t0,$t1 # a = t0 + t1 These commands work the same for "sub" as well.

Different MIPS Adding The "add" command in MIPS can only take 3 registers at a time: –Example: add $s0,$t0,$t1 To add a constant number with a register there is a different command called "addi" or add immediate In MIPS, "immediate" means a constant number Example: –JAVA: int x = 7 + y; –MIPS: addi $s0,$s1,7# s0 = x, s1 = y If you must add a constant number, you must use "addi"

Add-Immediate Sometimes, you might want to use only one register and two immediates, like –int x = 5 + 7; There is no command in MIPS that allows this in one step. Instead you must break this line into two and add the first number to the zero register –addi $t0,$zero,5 –addi $s0,$t0,7

Available Registers What registers are you allowed to use? –You can use any registers you want, even special ones to save your data, but you should only use the s0-s7 and t0-t9 registers –The "s" registers are supposed to be for data you want to save for a longer time (like a variable) –The "t" registers are "temporary" which means that the data is not important and you can throw it away immediately if you want to.

Loading and Storing Registers need to be able to save items in memory and load them from memory. There are a few MIPS commands to help you –la – load address. Put an address into a register –lw – load word – put a whole word into a register –sw – store word – take a word from a register and save in memory Load Address – this command will put an address location into a register. You need to do this in order to use the address later on Load Word – This takes an address in memory (located in a register) and then puts the data from the address into another register Store Word – This takes data from a register and stores data into a place in memory (place in memory is stored in a register)

Memory in MIPS: LA Memory in MIPS is broken into two parts. The ".text" segment, which contains the code and the ".data" segment which contains data (don’t worry about the stack) You don't need to actually know the real address of memory in MIPS, instead you can use labels for your memory For example, to store an integer in memory you would type.data myNumber:.word 25 This indicates that you're storing 32 bits of data (a word) in a place that is accessed by the word "myNumber" If you want to load or store this word later, you need to load the address that "myNumber" represents into a register This is done with the command "la" – load address la $t0, myNumber # put address of myNumber # into $t0

Memory in MIPS: LW Once you've loaded the address into a register, you're able to retrieve the data or store new data into that place in memory Load Word is used to retrieve data. It requires a register that will store the new data, the register that is storing the address and an integer that determines how many addresses farther you want to move Example: –lw $t0,0($t3) # take the address in ($t3 + 0) and take #the data from the address and store in $t0 –lw $s3,16($t1) # take the address from ($t1 + 16) and take the # data from the address and store in $s3

Memory in MIPS: SW The Store Word command is used to take data from a register and save it at a place in memory The place in memory is taken from another register plus a constant Example: –sw $t0,0($t3) # take the data from $t0 and store at the # address at ($t3+0) –sw $s3,16($t1) # take the data from $s3 and store at the # address at ($t1 + 16)

Example Load and Store // take the value of A[8]+5 and store in A[8] int [] A = new int[16]; A[12] = 5 + A[8]; la $t3, A # load address of array A lw $t0,32($t3) # load A[8] into $t0 addi $t0,$t0,5 # 5 + A[8] sw $t0,48($t3) # save $t0 at address A[12] Why is it 32($t3) if we want to get A[8]? Because (32 = 4 bytes for one integer * position 8 in array)

MIPS mini-review So far we’ve learned the following MIPS commands We know registers need to be loaded from memory Also remember, we load words (4 bytes), but need to get them using bytes!!

Instruction Formatting We know a little about instructions and registers. When we use instructions and registers, it is using a format that can be easily changed into binary, a language the processor can understand Different instructions have different formatting. Each instruction is 32-bits, and the different parts of the instruction are separated and placed in specific spots within the 32 bits Just like with floating point numbers, different parts of the 32 bits were used for different things. It’s the same with instruction formatting

Instruction Formatting Op – the opcode or the bits used to tell what kind of instruction is being executed Rs, Rt and Rd – are registers Immediate – is a constant number Target – is an address in memory

Types of Instructions There are three types of instructions that are used in MIPS R-type instructions – These use 3 variables (operands). –Ex. A = B+C I-type instructions – These use 2 variables and a constant. –Ex. A = B+7 J-type instructions – These change the control of the program and require only an address to Jump to –Ex. Function calls, loops, branch statements

R-Type Instructions (Register-Register)

I-Type Instructions (Register – Immediate) “Immediate” is the word used for a constant Add Immediate Example –addi $1,$2,100 // $1= $ ; The immediate is the constant (16 bits of it)

I-Type with Load/Store A load and store operation will also use the “immediate” I-Type format. It uses the immediate part to store how much to add to the memory address Load Word Example lw $1,100($2) # $1 = Memory[100+$2]

J-Type Instruction (Jump) J Type is used to jump to another address in memory (the address is usually a label, like the "la" command) Jump Example - jump will change what the next instruction to be executed is –j 1000 This “j” will go to address It will cause the processor to start executing whatever command is at address 1000

The Program Counter The program counter (PC) is a special register that keeps track of where the next instruction is in memory. After the current instruction finishes, the CPU will look in the PC to see where the next one is Operations like “J-Type” can change the PC because they go to somewhere else in the program. They change the PC, so the computer executes a different instruction The PC is sequential, (meaning it goes 1,2,3,4,5) in the order of instructions executed A jump or branch instruction can change the order

Program Counter The PC stores the address of the next instruction Every time an instruction finishes, the counter goes to the next address in memory, unless a J-type tells it something different. If we are doing byte addressing and each instruction is 32 bits (4 bytes), every instruction is 4 bytes away. The PC might start at 0x100 -> 0x104 -> 0x108

The PC and If Statements Does the PC go to address 0x1000c?? No!! We branch to another statement Text

Branch Statements There are a few useful branch statements which allow assembly programmers to use the if/else condition beq – Branch on Equal – this command will go to an address in memory if two registers are equal –Example: beq $t0,$t1,label1 –If $t0 == $t1, then go to the address that is marked by the label "label1" bne – Branch not equal – this command will go to an address in memory if the two registers are not equal –Example: bne $s0,$s1,loop –If $s0 != $s1 then go to the address marked by the label "loop"

I-Type Instruction (branching) Branching instructions also change the PC. A branch will use the I-type format Branch Not Equal Example bne $1, $2, 100 # If ($1!= $2) goto [PC+4+(100*4)]

Another J-Type Example Jump Register will change the PC to the address that is stored in register 31. By setting the PC to this value, the program will continue running, but at the new address that was in the register 31

How functions work Notice the “jal 0x30408”. That will set PC to 0x30408 and R31 to 0x1000c Notice “jr $31” will jump to the address stored in R31, which is 0x1000c

MIPS Instructions There is also a file on the website that shows all MIPS Instructions Arithmetic Operations add add $1,$2,$3 $1 = $2 + $3 3 operands subtract sub $1,$2,$3 $1 = $2 – $3 3 operands add immediate addi $1,$2,5 $1 = $ constant add unsigned addu $1,$2,$3 $1 = $2 + $3 3 operands subtract unsigned subu $1,$2,$3 $1 = $2 – $3 3 operands add imm. unsign. addiu $1,$2,5 $1 = $ constant multiply mult $2,$3 Hi, Lo = $2 x $3 64-bit signed product multiply unsigned multu $2,$3 Hi, Lo = $2 x $3 64-bit unsigned product divide div $2,$3 Lo = $2 ÷ $3, Lo = quotient, Hi = $2 mod $3 divide unsigned divu $2,$3 Lo = $2 ÷ $3,Hi = Rem. Move from Hi mfhi $1 $1 = Hi Used to get copy of Hi Move from Lomflo $1 $1 = Lo Used to get copy of Lo

MIPS Instructions Logical Operations and and $1,$2,$3 $1 = $2 & $3 Bitwise AND or or $1,$2,$3 $1 = $2 | $3 Bitwise OR xor xor $1,$2,$3 $1 = $2 XOR $3 Bitwise XOR nor nor $1,$2,$3 $1 = ~($2 | $3) Bitwise NOR and immediate andi $1,$2,10 $1 = $2 & 10 Bitwise AND reg, const or immediate ori $1,$2,10 $1 = $2 | 10 Bitwise OR reg, const xor immediate xori $1, $2,10 $1 = ~$2 &~10 Bitwise XOR reg, const shift left logical sll $1,$2,10 $1 = $2 << 10 Shift left by constant shift right logical srl $1,$2,10 $1 = $2 >> 10 Shift right by constant shift right arithm. sra $1,$2,10 $1 = $2 >> 10 Shift right (sign extend) shift left logical sllv $1,$2,$3 $1 = $2 << $3 Shift left by var shift right logical srlv $1,$2, $3 $1 = $2 >> $3 Shift right by var shift right arithm. srav $1,$2, $3 $1 = $2 >> $3 Shift right arith. by var

MIPS Instructions Data Transfer Operations Store word SW R3, 500(R4) # Memory[500+R4] = R3 Store half word SH R3, 502(R2) Store byte SB R2, 41(R3) Load WordLW R1, 30(R2) # R1 =Memory[R2 + 30] Load HalfwordLH R1, 40(R3) Load Halfword UnsLHU R1, 40(R3) Load ByteLB R1, 40(R3) Load Byte Unsigned LBU R1, 40(R3) Load Upper Imm.LUI R1, 40 (16 bits shifted left by 16) Pseudo-Commands (special commands that make things easier for humans, but that do not really exist in the ISA) Load Addressla $t0,x # load address of label x into $t0 Load Immediateli $t0,56 # load immediate value into $t0

MIPS Instructions Compare and Branch branch on equal beq $1,$2,100 if ($1 == $2) go to PC branch on not eq. bne $1,$2,100 if ($1!= $2) go to PC+4+100*4 set on less than slt $1,$2,$3 if ($2 < $3) $1=1; else $1=0 set less than imm. slti $1,$2,100 if ($2 < 100) $1=1; else $1=0 set less than uns. sltu $1,$2,$3 if ($2 < $3) $1=1; else $1=0 set l. t. imm. uns. sltiu $1,$2,100 if ($2 < 100) $1=1; else $1=0 jump j go to jump register jr $31 go to $31 jump and link jal $31 = PC + 4; go to 40000

Summary of MIPS Assembly We have begun to look at how MIPS works We know a few instructions and we know that they have corresponding instruction formats, which the machine uses to run the instruction We know about the Program Counter and how we get the next instruction that needs to run Next time we will start looking at programming a MIPS program