1 Chapter 2. Instruction: Language of the Computer

1

Chapter 2. Instruction:Language of the Computer

2

Five Basic Components

Control

Datapath

Memory

Processor

Input

Output

Since 1946 all computers have had 5 components!!!

3

A Translation Hierarchy

• High Level Language (HLL) programs first compiled (possibly into assembly), then linked and finally loaded into main memory.

Assembler

Assembly language program

Compiler

C program

Linker

Executable: Machine language program

Loader

Memory

Object: Machine language module Object: L ibrary routine (machine language)

4

Machine Language v.s. Assembly Language

• In C, we can havea = b+c+d;

• The MIPS assembly code will look like this:add a, b, cadd a, a, d

where a, b, c and d are registers• The MIPS machine language will look like:

000000 00010 00011 00001 00000 100000 000000 00001 00100 00001 00000 100000

• Comparison– The high level language is most efficient and readable– The assembly language is less efficient yet readable– The machine language directly corresponds to the assembly

language, but not readable

5

High Level Language Operators/Operands

• Consider C or C++

• Operators: +, -, *, /, % (mod); (7/4 equals 1, 7%4 equals 3)

• Operands:– Variables: fahr, celsius– Constants: 0, 1000, -17, 15.4

• In most High Level Languages, variables declared and given a type– int fahr, celsius;– int a, b, c, d, e;

6

Assembly Operators/Instructions° MIPS Assembly Syntax is rigid:

for arithmetic operations, 3 variables

Why? Directly corresponds to the machine language and makes hardware simple via regularity

° Consider the following C statement: a = b + c + d - e;

° It will be executed as multiple instructions add a, b, c # a = sum of b & cadd a, a, d # a = sum of b,c,d sub a, a, e # a = b+c+d-e

° The right of # is a comment terminated by end of the line. Applies only to current line.

7

Compilation

° How to turn the notation that programmers prefer into notation computer understands?

° Program to translate C statements into Assembly Language instructions; called a compiler

° Example: compile by hand this C code:a = b + c;d = a - e;

° Easy:

add a, b, csub d, a, e

° Compile an entire program of 10,000 lines of C code by hand?

° Big Idea: compiler translates notation from one level of computing abstraction to lower level

8

Compilation 2° Example: compile by hand this C code:

f = (g + h) - (i + j);

° First sum of g and h. Where to put result?

add f, g, h # f contains g+h

° Now sum of i and j. Where to put result?

Compiler creates temporary variable to hold sum: t1add t1, i, j # t1 contains i+j

° Finally produce differencesub f, f, t1 # f = (g+h)-(i+j)

9

Compilation -- Summary

° C statement (5 operands, 3 operators):

f = (g + h) - (i + j);

° Becomes 3 assembly instructions

(6 unique operands, 3 operators):

add f,g,h # f contains g+h

add t1,i,j # t1 contains i+j

sub f,f,t1 # f=(g+h)-(i+j)

° In general, each line of C produces many assembly instructions

Why people program in C vs. Assembly?

10

Assembly Design: Key Concepts

• Assembly language is essentially directly supported in hardware, therefore ...

• It is kept very simple!

– Limit on the type of operands

– Limit on the set operations that can be done to absolute minimum.

• if an operation can be decomposed into a simpler operation, don’t include it.

11

MIPS R3000 Instruction Set Architecture (Summary)

° Instruction Categories Load/Store Computational Jump and Branch Floating Point (coprocessor)

OP Rs Rt Rd sa funct

OP Rs Rt Immediate

OP jump target

3 Instruction Formats: all 32 bits wide

R0 - R31

PCHILO

Registers

I:R:

J:

Different Instruction Sets

Compute C = A + B under different instruction sets:

Stack Accumulator

Register

(load-store)

Push A Load A lw R1,A

Push B Add B lw R2,B

Add Store C

Register

(register-memory)

Load R1,A

Add R1,B

Store C, R1 add R3,R1,R2

Pop C sw C,R3

MIPS

13

Assembly Variables: Registers (1/4)

• Unlike HLL, assembly cannot use variables

– Why not? Keep Hardware Simple

• Assembly Operands are registers

– limited number of special locations built directly into the hardware

– operations can only be performed on these!

• Benefit: Since registers are directly in hardware, they are very

fast

• Registers are not what we normally call “memory”

14


• 32 registers in MIPS

– Why 32? Smaller is faster

– Each register can be referred to by number or name

– Number references: $0, $1, $2, … $30, $31

• Each MIPS register is 32 bits wide

– Groups of 32 bits called a word in MIPS

• Drawback: Since registers are in hardware, there are a predetermined number of them

– Solution: MIPS code must be very carefully put together to efficiently use registers

15


• By convention, each register also has a name to make it easier to code

• For now:

$16 - $23 $s0 - $s7 (correspond to C variables)

$8 - $15 $t0 - $t7 (correspond to temporary variables)

• In general, use register names to make your code more readable

16

Comments in Assembly

• Another way to make your code more readable: comments!

• Hash (#) is used for MIPS comments

– anything from hash mark to end of line is a comment and will be ignored

• Note: Different from C.

– C comments have format /* comment */ , so they can span many lines

17

Addition and Subtraction (1/4)

• Syntax of Instructions:

add a, b, c

where:

add: operation by name

a: operand getting result (destination)

b: 1st operand for operation (source1)

c: 2nd operand for operation (source2)

• Syntax is rigid:

– 1 operator, 3 operands

– Why? Keep Hardware simple via regularity

18


• Addition in Assembly

– Example (in MIPS): add $s0, $s1, $s2

– Equivalent to (in C): a = b + c

where registers $s0, $s1, $s2 are associated with variables a, b, c

• Subtraction in Assembly

– Example (in MIPS): sub $s3, $s4, $s5

– Equivalent to (in C): d = e - f

where registers $s3, $s4, $s5 are associated with variables d, e, f

19


• How to do the following C statement?

a = b + c + d - e;

• Break it into multiple instructions:

add $s0, $s1, $s2 # a = b + c

add $s0, $s0, $s3 # a = a + d

sub $s0, $s0, $s4 # a = a - e

20

Immediates

• Immediates are numerical constants.

• They appear often in code, so there are special instructions for them.

• ''Add Immediate'':

addi $s0, $s1, 10 (in MIPS)

f = g + 10 (in C)

where registers $s0, $s1 are associated with variables f, g

• Syntax similar to add instruction, except that last argument is a number instead of a register.

21

Register Zero

• One particular immediate, the number zero (0), appears very often in code.

• So we define register zero ($0 or $zero) to always have the value 0.

• This is defined in hardware, so an instruction like

addi $0, $0, 5

will not do anything.

• Use this register, it’s very handy!

22

Assembly Operands: Memory• C variables map onto registers; what about large data

structures like arrays?

• 1 of 5 components of a computer: memory contains such data structures

• But MIPS arithmetic instructions only operate on registers, never directly on memory.

° Data transfer instructions transfer data between registers and memory:

– Memory to register

– Register to memory

23

MIPS Addressing Formats (Summary)

• How memory can be addressed in MIPS

Byte Halfword Word

Registers

Memory

Memory

Word

Memory

Word

Register

Register

1. Immediate addressing

2. Register addressing

3. Base addressing

4. PC-relative addressing

5. Pseudodirect addressing

op rs rt

op rs rt

op rs rt

op

op

rs rt

Address

Address

Address

rd . . . funct

Immediate

PC

PC

+

+

24

Data Transfer: Memory to Reg (1/4)

• To transfer a word of data, we need to specify two things:

– Register: specify this by number (0 - 31)

– Memory address: more difficult

- Think of memory as a single one-dimensional array, so we

can address it simply by supplying a pointer to a memory

address.

- Other times, we want to be able to offset from this pointer.

25


• To specify a memory address to copy from, specify two things:

– A register which contains a pointer to memory

– A numerical offset (in bytes)

• The desired memory address is the sum of these two values.

• Example: 8($t0)

– specifies the memory address pointed to by the value in $t0, plus 8 bytes

26


• Load Instruction Syntax:

lw a, 100(b)

– where

lw operation (instruction) name

a register that will receive value

100 numerical offset in bytes

b register containing pointer to memory

• Instruction Name:

– lw (meaning Load Word, so 32 bits or one word are loaded at a time)

27


• Example: lw $t0, 12($s0)

This instruction will take the pointer in $s0, add 12 bytes to it, and then load the value from the memory pointed to by this calculated sum into register $t0

• Notes:

– $s0 is called the base register

– 12 is called the offset

– offset is generally used in accessing elements of array or structure: base register points to beginning of array or structure

28

Data Transfer: Reg to Memory

• Also want to store value from a register into memory

• Store instruction syntax is identical to Load instruction syntax

• Instruction Name:

sw (meaning Store Word, so 32 bits or one word are loaded at a time)

• Example: sw $t0, 12($s0)

This instruction will take the pointer in $s0, add 12 bytes to it, and then store the value from register $t0 into the memory address pointed to by the calculated sum

29

Pointers vs. Values

° Key Concept: A register can hold any 32-bit value. That value can be a (signed) int, an unsigned int, a pointer (memory address), etc.

• If you write

lw $t2, 0($t0)

then, $t0 better contain a pointer

• What is this for:

add $t2,$t1,$t0

30

Addressing: Byte vs. word

• Every word in memory has an address, similar to an index in an array

• Early computers numbered words like C numbers elements of an array:

– Memory[0], Memory[1], Memory[2], …

Called the “address” of a word

Computers needed to access 8-bit bytes as well as words (4 bytes/word)

Today machines address memory as bytes, hence word addresses differ by 4

Memory[0], Memory[4], Memory[8],

31

Compilation with Memory

• What offset in lw to select A[8] in C?

• 4x8=32 to select A[8]: byte vs. word

• Compile by hand using registers:g = h + A[8];

– g: $s1, h: $s2, $s3: base address of A

• 1st transfer from memory to register:

lw $t0, 32($s3) # $t0 gets A[8]

– Add 32 to $s3 to select A[8], put into $t0

• Next add it to h and place in gadd $s1, $s2, $t0 # $s1 = h + A[8]

32

Notes about Memory

• Pitfall: Forgetting that sequential word addresses in machines with byte addressing do not differ by 1.

– Many an assembly language programmer has toiled over errors made by assuming that the address of the next word can be found by incrementing the address in a register by 1 instead of by the word size in bytes.

– So remember that for both lw and sw, the sum of the base address and the offset must be a multiple of 4 (to be word aligned)

33

More Notes about Memory: Alignment

• MIPS requires that all words start at addresses that are multiples of 4 bytes

Called Alignment: objects must fall on address that is multiple of their size.

0 1 2 3

Aligned

NotAligned

Bytes in Word

Word Location

34

Role of Registers vs. Memory• What if more variables than registers?

– Compiler tries to keep most frequently used variable in registers

– Writing less frequently used to memory: spilling

• Why not keep all variables in memory?

– Smaller is faster:registers are faster than memory

– Registers more versatile:

• MIPS arithmetic instructions can read 2, operate on them, and write 1 per instruction

• MIPS data transfer only read or write 1 operand per instruction, and no operation

35

So Far...

• All instructions have allowed us to manipulate data.

• So we’ve built a calculator.

• To build a computer, we need ability to make decisions

36

C Decisions: if Statements• 2 kinds of if statements in C

– if (condition) clause

– if (condition) clause1 else clause2

• Rearrange 2nd if into following:

if (condition) goto L1; clause2; go to L2;L1: clause1;

L2:

– Not as elegant as if - else, but same meaning

37

MIPS Decision Instructions• Decision instruction in MIPS:

– beq a, b, L

– beq is ‘Branch if (registers are) equal’ Same meaning as (using C): if (a == b) goto L

• Complementary MIPS decision instruction

– bne a, b, L

– bne is ‘Branch if (registers are) not equal’ Same meaning as (using C): if (a!=b) goto L1

• Called conditional branches

38

MIPS Goto Instruction• In addition to conditional branches, MIPS has an unconditional

branch:

j label

• Called a Jump Instruction: jump (or branch) directly to the given label without needing to satisfy any condition

• Same meaning as (using C):

goto label

• Technically, it’s the same as:

beq $0, $0, label

since it always satisfies the condition. But j has a longer address field (26 bits) while beg has a shorter address field (16 bits)

39

Compiling C if into MIPS (1/2)• Compile by hand

if (i == j)

f = g+h;

else f = g-h;

• Use this mapping:– f: $s0, – g: $s1, – h: $s2, – i: $s3, – j: $s4

Exit

i == j?

f=g+h f=g-h

(false) i != j

(true) i == j

40

Compiling C if into MIPS (2/2)

° Final compiled MIPS code:beq $s3, $s4, True # branch i==j

sub $s0, $s1, $s2 # f=g-h(false)

j Fin # go to Fin

True: add $s0,$s1,$s2 # f=g+h (true)

Fin:° Note: Compilers automatically create labels to handle decisions (branches) appropriately. Generally not found in HLL code.

Exit

i == j?

f=g+h f=g-h

(false) i != j

(true) i == j

41

Instruction Support for Functions ... sum(a,b);... /* a, b: $s0,$s1 */}int sum(int x, int y) {

return x+y;}

address1000 add $a0,$s0,$zero # x = a1004 add $a1,$s1,$zero # y = b 1008 addi $ra,$zero,1016 #$ra=10161012 j sum #jump to sum1016 ...

2000 sum: add $v0,$a0,$a1

2004 jr $ra # new instruction

C

MIPS

42

Instruction Support for Functions

• Single instruction to jump and save return address: jump and link (jal)

• Before:

1008 addi $ra,$zero,1016 #$ra=10161012 j sum #go to sum

• After:

1012 jal sum # $ra=1016,go to sum

• Why have a jal? Make the common case fast: functions are very common.

43

Instruction Support for Functions• Syntax for jr (jump register):

jr register

• Instead of providing a label to jump to, the jr instruction provides a register which contains an address to jump to.

• Very useful for function calls:

–jal stores return address in register ($ra)

–jr jumps back to that address

44

Nested Proceduresint sumSquare(int x, int y) {

return mult(x,x)+ y;}

• Routine called sumSquare; now sumSquare is calling mult.

• So there’s a value in $ra that sumSquare wants to jump back to, but this will be overwritten by the call to mult.

• Need to save sumSquare return address before call to mult.

45

Nested Procedures• In general, may need to save some other info in addition to

$ra.

• When a C program is run, there are 3 important memory areas allocated:

– Static: Variables declared once per program, cease to exist only after execution completes

– Heap: Variables declared dynamically

– Stack: Space to be used by procedure during execution; this is where we can save register values

46

C memory Allocation

0

Address

Code Program

Static Variables declaredonce per program

HeapExplicitly created space, e.g., malloc(); C pointers

StackSpace for saved procedure information$sp

stackpointer

47

0

$sp

$gp

0040 0000 hex

1000 0000 hex

Text

Static data

Dynamic data

Stack7fff ffff hex

1000 8000 hex

pc

Reserved

Run-Time Memory Allocation in Executable Programs

Program instructions

Variables allocated once per program (global, C static)

Explicitly allocated space, (C malloc()library proc)

$sp stack

pointer

globalpointer$gp

0

Local data in functions,stack frames

48

Using the Stack

• So we have a register $sp which always points to the last used space in the stack.

• To use stack, we decrement this pointer by the amount of space we need and then fill it with info.

• So, how do we compile this?

int sumSquare(int x, int y) {

return mult(x,x)+ y;° }

49

Using the Stack (2/2)°Compile by hand

sumSquare:

addi $sp, $sp, -8 #space on stack

sw $ra, 4($sp) #save ret addr

sw $a1, 0($sp) # save y

add $a1, $a0, $zero # mult(x,x)

jal mult # call mult

lw $a1, 0($sp) # restore y

add $v0, $v0, $a1 # mult()+ y

lw $ra, 4($sp) # get ret addr

addi $sp, $sp, 8 # restore stack

jr $ra

50

Steps for Making a Procedure Call

1) Save necessary values onto stack.

2) Assign argument(s), if any.

3) jal call

4) Restore values from stack.

51

Rules for Procedures

• Called with a jal instruction, returns with a jr $ra

• Accepts up to 4 arguments in $a0, $a1, $a2 and $a3

• Return value is always in $v0 (and if necessary in $v1)

• Must follow register conventions (even in functions that only you will call)! So what are they?

Return address $ra

Arguments $a0, $a1, $a2, $a3

Return value $v0, $v1

Local variables $s0, $s1, , $s7

52

Register Conventions (1/6)

• Caller: the calling function

• Callee: the function being called

• When callee returns from executing, the caller needs to know which registers may have changed and which are guaranteed to be unchanged.

° Register Conventions: A set of generally accepted rules as to which registers will be unchanged after a procedure call (jal) and which may be changed.

53


• $0: No Change. Always 0.

• $v0-$v1: Change. These are expected to contain new values.

• $a0-$a3: Change. These are volatile argument registers.

• $t0-$t9: Change. That’s why they’re called temporary: any procedure may change them at any time.

54


•$s0-$s7: No Change. Very important, that’s why they’re called saved registers. If the callee changes these in any way, it must restore the original values before returning.

•$sp: No Change. The stack pointer must point to the same place before and after the jal call, or else the caller won’t be able to restore values from the stack.

•$ra: Change. The jal call itself will change this register.

55


• What do these conventions mean?

– If function A calls function B, then function A must save any temporary registers that it may be using onto the stack before making a jal call.

– Function B must save any S (saved) registers it intends to use before garbling up their values

– Remember: Caller/callee need to save only temporary / saved registers they are using, not all registers.

56


• Note that, if the callee is going to use some s registers, it must:

– save those s registers on the stack– use the registers– restore s registers from the stack–jr $ra

• With the temp registers, the callee doesn’t need to save onto the stack.

• Therefore the caller must save those temp registers that it would like to preserve though the call.

57

Other Registers (6/6)

• $at: may be used by the assembler at any time; always unsafe to use

• $k0-$k1: may be used by the kernel at any time; unsafe to use

• $gp: don’t worry about it

• $fp: don’t worry about it

• Note: Read up on $gp and $fp in Appendix A.

58

Example: Compile This

main() { int i,j,k,m; /* i-m:$s0-$s3 */

i = mult(j,k); ... ; m = mult(i,i); ...

}int mult (int mcand, int mlier){ int product;

product = 0; while (mlier > 0) { product += mcand; mlier -= 1;

} return product;

}

59

Example: Compile This__start: add $a0, $s1, $0 # arg0 = j

add $a1, $s2, $0 # arg1 = k


add $s0, $v0, $0 # i = mult()

..

add $a0, $s0, $0 # arg0 = i

add $a1, $s0, $0 # arg1 = i


add $s3, $v0, $0 # m = mult()...

done:

60


• Notes:

– main function ends with done, not jr $ra, so there’s no

need to save $ra onto stack

– all variables used in main function are saved registers, so

there’s no need to save these onto stack

61

Example: Compile Thismult:

add $t0,$0,$0 # prod = 0

Loop:slt $t1,$0,$a1 # mlr > 0?

beq $t1,$0,Fin # no => Fin add $t0,$t0,$a0 # prod += mc addi $a1,$a1,-1 # mlr -= 1 j Loop # goto Loop

Fin:

add $v0,$t0,$0 # $v0 = prod

jr $ra # return

62


• Notes:

– no jal calls are made from mult and we don’t use any saved registers, so we don’t need to save anything onto stack

– temp registers are used for intermediate calculations (could have used s registers, but would have to save the caller’s on the stack.)

– $a1 is modified directly (instead of copying into a temp register) since we are free to change it

– result is put into $v0 before returning

63

Loops in C/Assembly• There are three types of loops in C:

– while

– Do while

– for

° Key Concept: Though there are multiple ways of writing a loop

in MIPS, conditional branch is key to decision making

64

Inequalities in MIPS• Until now, we’ve only tested equalities

(== and != in C). General programs need to test < and > as well.

• Create a MIPS Inequality Instruction:

– <Set on Less Than>

– Syntax: slt reg1,reg2,reg3

– Meaning:

if (reg2 < reg3) reg1 = 1;

else

reg1 = 0;

– In computereeze, “set” means “set to 1”, “reset” or “clear” means “set to 0”.

65

Inequalities in MIPS• How do we use this?

• Compile by hand:

if (g < h) goto Less;

• Use this mapping:

g: $s0, h: $s1

66

Inequalities in MIPS

• Final compiled MIPS code:

slt $t0,$s0,$s1 # $t0 = 1 if g<h

bne $t0,$0,Less # goto Less

# if $t0!=0 # (if (g<h)) Less:

• Branch if $t0 != 0 or (g < h)

– Register $0 always contains the value 0, so bne and beq often use it for comparison after an slt instruction.

67

Inequalities in MIPS (5/5) 4 combinations of slt & beq/bneq:

slt $t0,$s0,$s1 # $t0 = 1 if g<hbne $t0,$0,Less # if(g<h) goto Less

slt $t0,$s1,$s0 # $t0 = 1 if g>hbne $t0,$0,Grtr # if(g>h) goto Grtr

slt $t0,$s0,$s1 # $t0 = 1 if g<hbeq $t0,$0,Gteq # if(g>=h) goto Gteq

slt $t0,$s1,$s0 # $t0 = 1 if g>hbeq $t0,$0,Lteq # if(g<=h) goto Lteq

68

Immediates in Inequalities• There is also an immediate version of slt to test against

constants: slti

– Helpful in for loops

if (g >= 1) goto Loop

Loop: . . .

slti $t0,$s0,1 # $t0 = 1 if # $s0<1 (g<1)

beq $t0,$0,Loop # goto Loop # if $t0==0# (if (g>=1))

C

MIPS

69

Example: The C Switch Statement

• Choose among four alternatives depending on whether k has the value 0, 1, 2 or 3. Compile this C code:

switch (k) {

case 0: f=i+j; break; /* k=0*/

case 1: f=g+h; break; /* k=1*/

case 2: f=g-h; break; /* k=2*/

case 3: f=i-j; break; /* k=3*/

}

70

Example: The C Switch Statement

• This is complicated, so simplify.

• Rewrite it as a chain of if-else statements, which we already know how to compile:

if(k==0) f= i + j; else if(k==1) f= g + h; else if(k==2) f= g - h; else if(k==3) f= - j;

• Use this mapping:

f: $s0, g: $s1, h: $s2, i: $s3, j: $s4, k: $s5

71

Example: The C Switch Statement• Final compiled MIPS code:

bne $s5, $0, L1 # branch k!=0 add $s0, $s3, $s4 # k==0 so f=i+j j Exit # end of case so ExitL1:addi $t0, $s5, -1 # $t0 = k-1bne $t0, $0, L2 # branch k != 1 add $s0, $s1, $s2 # k==1 so f=g+hj Exit # end of case so Exit

L2:addi $t0, $s5, -2 # $t0=k-2bne $t0, $0, L3 # branch k != 2sub $s0, $s1, $s2 # k==2 so f=g-hj Exit # end of case so Exit

L3:addi $t0, $s5, -3 # $t0 = k-3 bne $t0, $0, Exit # branch k != 3sub $s0, $s3, $s4 # k==3 so f=i-j

Exit:

72

Case/Switch via Jump Address Table

• Notice that last case must wait for n-1 tests before executing, making it slow

• Alternative tries to go to all cases equally fast: jump address table for scalability

– Idea: encode alternatives as a table of addresses of the cases

– Table is an array of words with addresses corresponding to case labels

– Program indexes into table and jumps

• MIPS instruction "jump register" (jr) unconditionally branches to address in register; use load to get address

73

Jump Address Table

0

4

k 4

8

Baddr + 0

Baddr + 4

Baddr + k 4

Baddr + 8

Base register:beginning ofjump table

Code blocks for each one of the cases in the switch statementNo testing for each case condition is necessary here.

Code for alt1

Code for alt2

Code for alt3

Code for altk

74


• Use k to index a jump address table, and then jump via the value loaded

• 1st test that k matches 1 of cases (0 k 3); if not, the code exits

slti $t3, $s5, 0 # Test if k < 0

bne $t3, $zero, LOW # if k<0,goto Exit

slti $t3, $s5, 4 # Test if k < 4

beq $t3, $zero, LOW # if k>=4,goto Exit

• Multiply k by 4 to index table of words:

add $t1, $s5, $s5 # Temp reg $t1 = 2*k

add $t1, $t1, $t1 # Temp reg $t1 = 4*k

75


• Assume 4 sequential words in memory, base address in $t2, have addresses corresponding to labels L0, L1, L2, L3.

add $t1, $t1, $t2 # $t1 = &JumpTable[k]

lw $t1, 0($t1) # $t1 = JumpTable[k]

• Now jump using address in register $t1:

jr $t1 # jump based on reg $t1

76


• Cases jumped to by jr:L0:add $s0, $s3, $s4 # k=0 so f = i + jj Exit # end case, goto ExitL1: add $s0, $s1, $s2 # k=1 so f = g + hj Exit # end case, goto ExitL2: sub $s0, $s1, $s2 # k=2 so f = g + hj Exit # end case, goto ExitL3: sub $s0, $s3, $s4 # k=3 so f = i –j Exit # end of switch statement

LOW: addi $s0, $0, -1 # f = -1;Exit:

77

Jump Address Table: Summary slti $t3, $s5, 0 # Test if k < 0

bne $t3, $zero, LOW # if k < 0, goto otherwise slti $t3, $s5, 4 # Test if k < 4 beq $t3, $zero, LOW # if k >= 4, goto otherwise add $t1, $s5, $s5 # Temp reg $t1 = 2*k add $t1, $t1, $t1 # Temp reg $t1 = 4*k add $t1, $t1, $t2 # $t1 = & JumpTable[k] lw $t1, 0($t1) # $t1 = JumpTable[k] jr $t1 # jump based on $t1 L0: add $s0, $s3, $s4 # k=0 so f = i + j j Exit # end case, goto ExitL1: add $s0, $s1, $s2 # k=1 so f = g + hj Exit # end case, goto Exit

L2: sub $s0, $s1, $s2 # k=2 so f = g – h j Exit # end case, goto ExitL3: sub $s0, $s3, $s4 # k=3 so f = i – jLOW: addi $s0, $0, -1 # f = -1;Exit:Exit: # end of switch statement

78

Things to Remember• A Decision allows us to decide which pieces of code to execute

at run-time rather than at compile-time.

• C Decisions are made using conditional statements within an if, while, do while or for.

• MIPS Decision making instructions are the conditional branches: beq and bne.

• To help the conditional branches make decisions concerning inequalities, we introduce a single instruction: <Set on Less Than> called slt, slti, sltu, sltui

79

Announcements

• Lab 2 will be released this week• Ensure that your CS accounts have been activated• Make sure your key card lets you get into the lab

(HRBB Rm 209)• Keep up-to-date with material taught in class

Documents

1 Chapter 2. Instruction: Language of the Computer