ARSITEKTUR DAN ORGANISASI KOMPUTER

1. Assembly Language
Instructions: commands in a computer’s language
a. Assembly language: human-readable format of instructions
b. Machine language: computer-readable format (1’s and 0’s)
MIPS architecture:
c. Developed by John Hennessy and his colleagues at Stanford and in the 1980’s.
d. Used in many commercial systems, including Silicon Graphics, Nintendo, and Cisco
Once you’ve learned one architecture, it’s easy to learn others

2. Architecture Design Principles

Underlying design principles, as articulated by Hennessy and Patterson:
1. Simplicity favors regularity
2. Make the common case fast
3. Smaller is faster
4. Good design demands good compromises

3. Instructions: Addition, subtraction

 Add, sub: mnemonic indicates operation to perform
 b, c: source operands (on which the operation is performed)
 a: destination operand (to which the result is written)

4. Design Principle 1
Simplicity favors regularity
• Consistent instruction format
• Same number of operands (two sources and one destination)
• Easier to encode and handle in hardware

5. Multiple Instructions
More complex code is handled by multiple MIPS instructions.

6. Design Principle 2
Make the common case fast
• MIPS includes only simple, commonly used instructions
• Hardware to decode and execute instructions can be simple, small, and fast
• More complex instructions (that are less common) performed using multiple simple instructions
• MIPS is a reduced instruction set computer (RISC), with a small number of simple instructions
• Other architectures, such as Intel’s x86, are complex instruction set computers (CISC)

7. Operands
Operand location: physical location in computer
a. Registers
b. Memory
c. Constants (also called immediates)
8. Operands: Registers
 MIPS has 32 32-bit registers
 Registers are faster than memory
 MIPS called “32-bit architecture” because it operates on 32-bit data

9. Design Principle 3
Smaller is Faster
• MIPS includes only a small number of registers

10. MIPS Register Set

Name Register Number Usage

$0 0 the constant value 0
$at 1 assembler temporary
$v0-$v1 2-3 Function return values
$a0-$a3 4-7 Function arguments
$t0-$t7 8-15 temporaries
$s0-$s7 16-23 saved variables
$t8-$t9 24-25 more temporaries
$k0-$k1 26-27 OS temporaries
$gp 28 global pointer
$sp 29 stack pointer
$fp 30 frame pointer
$ra 31 Function return address

11. Operands: Registers

 Registers:
a. $ before name
b. Example: $0, “register zero”, “dollar zero”
 Registers used for specific purposes:
i. $0 always holds the constant value 0.
ii. the saved registers, $s0-$s7, used to hold variables
iii. the temporary registers, $t0 - $t9, used to hold intermediate values during a larger
computation
iv. Discuss others later

12. Instructions with Registers

Revisit add instruction
13. Operands: Memory
 Too much data to fit in only 32 registers
 Store more data in memory
 Memory is large, but slow
 Commonly used variables kept in registers

14. Word-Addressable Memory

 Each 32-bit data word has a unique address
Word Address Data

00000003 4 0 F 3 0 7 8 8 Word 3
00000002 0 1 E E 2 8 4 2 Word 2
00000001 F 2 F 1 A C 0 7 Word 1
00000000 A B C D E F 7 8 Word 0

15. Reading Word-Addressable Memory

• Memory read called load
• Mnemonic: load word (lw)
• Format:
lw $s0, 5($t1)
• Address calculation:
– add base address ($t1) to the offset (5)
– address = ($t1 + 5)
• Result:
– $s0 holds the value at address ($t1 + 5)
Any register may be used as base address

16. Reading Word-Addressable Memory

 Example: read a word of data at memory address 1 into $s3
a. address = ($0 + 1) = 1
b. $s3 = 0xF2F1AC07 after load
 Assembly code
lw $s3, 1($0) # read memory word 1 into $s3
Word Address Data

00000003 4 0 F 3 0 7 8 8 Word 3
00000002 0 1 E E 2 8 4 2 Word 2
00000001 F 2 F 1 A C 0 7 Word 1
00000000 A B C D E F 7 8 Word 0
17. Writing Word-Addressable Memory
 Memory write are called store
 Mnemonic: store word (sw)
 Example: Write (store) the value in $t4 into memory address 7
- add the base address ($0) to the offset (0x7)
- address: ($0 + 0x7) = 7
Offset can be written in decimal (default) or hexadecimal
Assembly code
sw $t4, 0x7($0) # write the value in $t4
# to memory word 7
Word Address Data

00000003 4 0 F 3 0 7 8 8 Word 3
00000002 0 1 E E 2 8 4 2 Word 2
00000001 F 2 F 1 A C 0 7 Word 1
00000000 A B C D E F 7 8 Word 0

18. Byte-Addressable Memory

• Each data byte has unique address
• Load/store words or single bytes: load byte (lb) and store byte (sb)
• 32-bit word = 4 bytes, so word address increments by 4
Word Address Data

0000000C 4 0 F 3 0 7 8 8 Word 3
00000008 0 1 E E 2 8 4 2 Word 2
00000004 F 2 F 1 A C 0 7 Word 1
00000000 A B C D E F 7 8 Word 0

width = 4 bytes

19. Reading Byte-Addressable Memory

• The address of a memory word must now be multiplied by 4. For example,
a. the address of memory word 2 is 2 × 4 = 8
b. the address of memory word 10 is 10 × 4 = 40 (0x28)
• MIPS is byte-addressed, not word-addressed
• Example: Load a word of data at memory address 4 into $s3.
• $s3 holds the value 0xF2F1AC07 after load
MIPS assembly code
lw $s3, 4($0) # read word at address 4 into $s3
Word Address Data

0000000C 4 0 F 3 0 7 8 8 Word 3
00000008 0 1 E E 2 8 4 2 Word 2
00000004 F 2 F 1 A C 0 7 Word 1
00000000 A B C D E F 7 8 Word 0

width = 4 bytes
20. Writing Byte-Addressable Memory
• Example: stores the value held in $t7 into memory address 0x2C (44)
• MIPS assembly code
sw $t7, 44($0) # write $t7 into address 44
Word Address Data

0000000C 4 0 F 3 0 7 8 8 Word 3
00000008 0 1 E E 2 8 4 2 Word 2
00000004 F 2 F 1 A C 0 7 Word 1
00000000 A B C D E F 7 8 Word 0

width = 4 bytes

21. Big-Endian & Little-Endian Memory

• How to number bytes within a word?
• Little-endian: byte numbers start at the little (least significant) end
• Big-endian: byte numbers start at the big (most significant) end
• Word address is the same for big- or little-endian
Big-Endian Little-Endian
Byte Word Byte
Address Address Address

C D E F C F E D C
8 9 A B 8 B A 9 8
4 5 6 7 4 7 6 5 4
0 1 2 3 0 3 2 1 0
MSB LSB MSB LSB

• Jonathan Swift’s Gulliver’s Travels: the Little-Endians broke their eggs on the little end of the egg
and the Big-Endians broke their eggs on the big end
• It doesn’t really matter which addressing type used – except when the two systems need to
share data!
Big-Endian & Little-Endian Example
• Suppose $t0 initially contains 0x23456789
• After following code runs on big-endian system, what value is $s0?
• In a little-endian system?
sw $t0, 0($0)
lb $s0, 1($0)
• Big-endian: 0x00000045
• Little-endian: 0x00000067
Big-Endian Little-Endian
Word
Byte Address 0 1 2 3 Address 3 2 1 0 Byte Address
Data Value 23 45 67 89 0 23 45 67 89 Data Value
MSB LSB MSB LSB

22. Design Principle 4

Good design demands good compromises
• Multiple instruction formats allow flexibility
- add, sub: use 3 register operands
- lw, sw: use 2 register operands and a constant
 • Number of instruction formats kept small
- to adhere to design principles 1 and 3 (simplicity favors regularity and smaller is faster).

23. Operands: Constants/Immediates

• lw and sw use constants or immediates
• immediately available from instruction
• 16-bit two’s complement number
• addi: add immediate
• Subtract immediate (subi) necessary?

24. Machine Language

• Binary representation of instructions
• Computers only understand 1’s and 0’s
• 32-bit instructions
- Simplicity favors regularity: 32-bit data & instructions
• 3 instruction formats:
a. R-Type: register operands
b. I-Type: immediate operand
c. J-Type: for jumping (discuss later)

25. R-Type
• Register-type
• 3 register operands:
- rs, rt: source registers
- rd: destination register
• Other fields:
a. op: the operation code or opcode (0 for R-type instructions)
b. funct: the function
with opcode, tells computer what operation to perform
c. shamt: the shift amount for shift instructions, otherwise it’s 0
R-Type
op rs rt rd shamt funct
6 bits 5 bits 5 bits 5 bits 5 bits 6 bits

R-Type Examples

Field Values
Assembly Code op rs rt rd shamt funct

0 17 18 16 0 32
add $s0, $s1, $s2 0 11 13 8 0 34
6 bits 5 bits 5 bits 5 bits 5 bits 6 bits
. sub $t0, $t3, $t5
 Machine Code
op rs rt rd shamt funct

000000 10001 10010 10000 00000 100000 (0x02328020)

000000 01011 01101 01000 00000 100010 (0x016D4022)

6 bits 5 bits 5 bits 5 bits 5 bits 6 bits

Note the order of registers in the assembly code:

add rd, rs, rt

26. I-Type
 Immediate-type
 3 operands:
- rs, rt: register operands
- imm: 16-bit two’s complement immediate
 Other fields:
a. op: the opcode
b. Simplicity favors regularity: all instructions have opcode
c. Operation is completely determined by opcode

I-Type
op rs rt imm
6 bits 5 bits 5 bits 16 bits

I-Type Examples

Assembly Code Field Values

op rs rt imm

addi $s0, $s1, 5 8 17 16 5

addi $t0, $s3, -12 8 19 8 -12

lw $t2, 32($0) 35 0 10 32

sw $s1, 4($t1) 43 9 17 4
6 bits 5 bits 5 bits 16 bits

Machine Code
op rs rt imm

001000 10001 10000 0000 0000 0000 0101 (0x22300005)

001000 10011 01000 1111 1111 1111 0100 (0x2268FFF4)

100011 00000 01010 0000 0000 0010 0000 (0x8C0A0020)

101011 01001 10001 0000 0000 0000 0100 (0xAD310004)

6 bits 5 bits 5 bits 16 bits

• Note the differing order of registers in assembly and

machine codes:
addi rt, rs, imm
 lw rt, imm(rs)
sw rt, imm(rs)

27. Machine Language: J-Type

• Jump-type
• 26-bit address operand (addr)
• Used for jump instructions (j)
J-Type
op addr
6 bits 26 bits

28. Power of the Stored Program

• 32-bit instructions & data stored in memory
• Sequence of instructions: only difference between two applications
• To run a new program:
- No rewiring required
- Simply store new program in memory
• Program Execution:
- Processor fetches (reads) instructions from memory in sequence
- Processor performs the specified operation

29. The Stored Program

Program Counter (PC): keeps track of current instruction
Assembly Code Machine Code
lw $t2, 32($0) 0x8C0A0020
30. add $s0, $s1, $s2 0x02328020 Interpreting Machine Code
• addi $t0, $s3, -12 0x2268FFF4 Start with opcode: tells how to parse rest
sub $t0, $t3, $t5
• If 0x016D4022 opcode all 0’s
Stored Program – R-type instruction
Address Instructions – Function bits tell operation
• Otherwise
0040000C 0 1 6 D 4 0 2 2 – opcode tells operation
00400008 2 2 6 8 F F F 4
00400004 0 2 3 2 8 0 2 0
00400000 8 C 0 A 0 0 2 0 PC

Main Memory

Machine Code Field Values Assembly Code

op rs rt imm op rs rt imm
(0x2237FFF1) 001000 10001 10111 1111 1111 1111 0001 8 17 23 -15 addi $s7, $s1, -15
2 2 3 7 F F F 1

op rs rt rd shamt funct op rs rt rd shamt funct

(0x02F34022) 000000 10111 10011 01000 00000 100010 0 23 19 8 0 34 sub $t0, $s7, $s3
0 2 F 3 4 0 2 2
31. Programming
• High-level languages:
- e.g., C, Java, Python
- Written at higher level of abstraction
• Common high-level software constructs:
- if/else statements
- for loops
- while loops
- arrays
- function calls

32. Logical Instructions

• and, or, xor, nor
– and: useful for masking bits
• Masking all but the least significant byte of a value:
0xF234012F AND 0x000000FF = 0x0000002F
– or: useful for combining bit fields
• Combine 0xF2340000 with 0x000012BC:
0xF2340000 OR 0x000012BC = 0xF23412BC
– nor: useful for inverting bits:
• A NOR $0 = NOT A
• andi, ori, xori
– 16-bit immediate is zero-extended (not sign-extended)
– nori not needed

33. Logical Instructions Example 1

Source Registers
$s1 1111 1111 1111 1111 0000 0000 0000 0000

$s2 0100 0110 1010 0001 1111 0000 1011 0111

Assembly Code Result

and $s3, $s1, $s2 $s3 0100 0110 1010 0001 0000 0000 0000 0000
or $s4, $s1, $s2 $s4 1111 1111 1111 1111 1111 0000 1011 0111
xor $s5, $s1, $s2 $s5 1011 1001 0101 1110 1111 0000 1011 0111
nor $s6, $s1, $s2 $s6 0000 0000 0000 0000 0000 1111 0100 1000

34. Logical Instructions Example 2

 Source Values
$s1 0000 0000 0000 0000 0000 0000 1111 1111

imm 0000 0000 0000 0000 1111 1010 0011 0100

zero-extended
Assembly Code Result
andi $s2, $s1, 0xFA34 $s2 0000 0000 0000 0000 0000 0000 0011 0100
ori $s3, $s1, 0xFA34 $s3 0000 0000 0000 0000 1111 1010 1111 1111
xori $s4, $s1, 0xFA34 $s4 0000 0000 0000 0000 1111 1010 1100 1011

35. Shift Instructions

• sll: shift left logical
Example: sll $t0, $t1, 5 # $t0 <= $t1 << 5
• srl: shift right logical
Example: srl $t0, $t1, 5 # $t0 <= $t1 >> 5
• sra: shift right arithmetic
Example: sra $t0, $t1, 5 # $t0 <= $t1 >>> 5
Assembly Code Field Values
op rs rt rd shamt funct

sll $t0, $s1, 2 0 0 17 8 2 0

srl $s2, $s1, 2 0 0 17 18 2 2

sra $s3, $s1, 2 0 0 17 19 2 3

6 bits 5 bits 5 bits 5 bits 5 bits 6 bits

Machine Code
op rs rt rd shamt funct

000000 00000 10001 01000 00010 000000 (0x00114080)

000000 00000 10001 10010 00010 000010 (0x00119082)

000000 00000 10001 10011 00010 000011 (0x00119883)

6 bits 5 bits 5 bits 5 bits 5 bits 6 bits

36. Variable Shift Instructions

• sllv: shift left logical variable
Example: sllv $t0, $t1, $t2 # $t0 <= $t1 << $t2
• srlv: shift right logical variable
Example: srlv $t0, $t1, $t2 # $t0 <= $t1 >> $t2
• srav: shift right arithmetic variable
Example: srav $t0, $t1, $t2 # $t0 <= $t1 >>> $t2

37. Generating Constants

• 16-bit constants using addi:

• 32-bit constants using load upper immediate (lui) and ori:

38. Multiplication, Division
• Special registers: lo, hi
• 32 × 32 multiplication, 64 bit result
- mult $s0, $s1
- Result in {hi, lo}
• 32-bit division, 32-bit quotient, remainder
- div $s0, $s1
- Quotient in lo
- Remainder in hi
• Moves from lo/hi special registers
- mflo $s2
- mfhi $s3

39. Branching
• Execute instructions out of sequence
• Types of branches:
- Conditional
• branch if equal (beq)
• branch if not equal (bne)
- Unconditional
• jump (j)
• jump register (jr)
• jump and link (jal)

40. Review: The Stored Program

Assembly Code Machine Code
lw $t2, 32($0) 0x8C0A0020
add $s0, $s1, $s2 0x02328020
addi $t0, $s3, -12 0x2268FFF4
sub $t0, $t3, $t5 0x016D4022

Stored Program
Address Instructions

0040000C 0 1 6 D 4 0 2 2
00400008 2 2 6 8 F F F 4
00400004 0 2 3 2 8 0 2 0
00400000 8 C 0 A 0 0 2 0 PC

Main Memory
41. Conditional Branching (beq)
# MIPS assembly
addi $s0, $0, 4 # $s0 = 0 + 4 = 4
addi $s1, $0, 1 # $s1 = 0 + 1 = 1
sll $s1, $s1, 2 # $s1 = 1 << 2 = 4
beq $s0, $s1, target # branch is taken
addi $s1, $s1, 1 # not executed
sub $s1, $s1, $s0 # not executed
target: # label
add $s1, $s1, $s0 # $s1 = 4 + 4 = 8
Labels indicate instruction location. They can’t be reserved words and must be followed by colon (:)

42. The Branch Not Taken (bne)

# MIPS assembly
addi $s0, $0, 4 # $s0 = 0 + 4 = 4
addi $s1, $0, 1 # $s1 = 0 + 1 = 1
sll $s1, $s1, 2 # $s1 = 1 << 2 = 4
bne $s0, $s1, target # branch not taken
addi $s1, $s1, 1 # $s1 = 4 + 1 = 5
sub $s1, $s1, $s0 # $s1 = 5 – 4 = 1
target:
add $s1, $s1, $s0 # $s1 = 1 + 4 = 5

43. Unconditional Branching (j)

# MIPS assembly
addi $s0, $0, 4 # $s0 = 4
addi $s1, $0, 1 # $s1 = 1
j target # jump to target
sra $s1, $s1, 2 # not executed
addi $s1, $s1, 1 # not executed
sub $s1, $s1, $s0 # not executed
target:
add $s1, $s1, $s0 # $s1 = 1 + 4 = 5

44. Unconditional Branching (jr)

# MIPS assembly
0x00002000 addi $s0, $0, 0x2010
0x00002004 jr $s0
0x00002008 addi $s1, $0, 1
0x0000200C sra $s1, $s1, 2
0x00002010 lw $s3, 44($s1)
jr is an R-type instruction.

45. High-Level Code Constructs

 • if statements
• if/else statements
• while loops
• for loops

46. If Statement => (Assembly tests opposite case (i != j) of high-level code (i == j) )

47. If/Else Statement

48. While Loops => Assembly tests for the opposite case (pow == 128) of the C code (pow != 128).

49. For Loops

for (initialization; condition; loop operation)
statement
• initialization: executes before the loop begins
• condition: is tested at the beginning of each iteration
• loop operation: executes at the end of each iteration
• statement: executes each time the condition is met
50. Less Than Comparison

51. Arrays
• Access large amounts of similar data
• Index: access each element
• Size: number of elements
• 5-element array
• Base address = 0x12348000 (address of first element, array[0])
• First step in accessing an array: load base address into a register

0x12340010 array[4]
0x1234800C array[3]
0x12348008 array[2]
0x12348004 array[1]
0x12348000 array[0]
52. Accessing Arrays

53. Arrays using For Loops

 .

54. ASCII Code

• American Standard Code for Information Interchange
• Each text character has unique byte value
a. For example, S = 0x53, a = 0x61, A = 0x41
b. Lower-case and upper-case differ by 0x20 (32)

55. Function Calls

• Caller: calling function (in this case, main)
• Callee: called function (in this case, sum)

56. Function Conventions

• Caller:
- passes arguments to callee
- jumps to callee
• Callee:
- performs the function
- returns result to caller
 - returns to point of call
- must not overwrite registers or memory needed by caller

57. MIPS Function Conventions

• Call Function: jump and link (jal)
• Return from function: jump register (jr)
• Arguments: $a0 - $a3
• Return value: $v0

58. Function Calls => void means that simple doesn’t return a value

jal: jumps to simple

$ra = PC + 4 = 0x00400204
jr $ra: jumps to address in $ra (0x00400204)

59. Input Arguments & Return Value

MIPS conventions:
• Argument values: $a0 - $a3
• Return value: $v0
 • diffofsums overwrote 3 registers: $t0, $t1, $s0
• diffofsums can use stack to temporarily store registers

60. The Stack

• Memory used to temporarily save variables
• Like stack of dishes, last-in-first-out (LIFO) queue
• Expands: uses more memory when more space needed
• Contracts: uses less memory when the space is no longer needed
• Grows down (from higher to lower memory addresses)
• Stack pointer: $sp points to top of the stack
Address Data Address Data

7FFFFFFC 12345678 $sp 7FFFFFFC 12345678

7FFFFFF8 7FFFFFF8 AABBCCDD
7FFFFFF4 7FFFFFF4 11223344 $sp
7FFFFFF0 7FFFFFF0
61. How Functions use the Stack
• Called functions must have no unintended side effects
• But diffofsums overwrites 3 registers: $t0, $t1, $s0

62. Storing Register Values on the Stack

63. The stack during diffofsums Call

Address Data Address Data Address Data

FC ? $sp FC ? FC ? $sp
s ta c k fra m e

F8 F8 $s0 F8
F4 F4 $t0 F4
F0 F0 $t1 $sp F0

(a) (b) (c)

64. Registers

Preserved Nonpreserved
Callee-Saved Caller-Saved
$s0-$s7 $t0-$t9
$ra $a0-$a3
$sp $v0-$v1
stack above $sp stack below $sp

65. Multiple Function Calls

66. Storing Saved Registers on the Stack

67. Recursive Function Call

68. Stack During Recursive Call

Address Data Address Data Address Data

FC $sp FC $sp FC $sp $v0 = 6

F8 F8 $a0 (0x3) F8 $a0 (0x3)

$a0 = 3
F4 F4 $ra $sp F4 $ra $sp $v0 = 3 x 2
F0 F0 $a0 (0x2) F0 $a0 (0x2)
$a0 = 2
EC EC $ra (0xBC) $sp EC $ra (0xBC) $sp
$v0 = 2 x 1
E8 E8 $a0 (0x1) E8 $a0 (0x1)
$a0 = 1
E4 E4 $ra (0xBC) $sp E4 $ra (0xBC) $sp $v0 = 1
E0 E0 E0
DC DC DC
69. Function Call Summary
- Caller
- Put arguments in $a0-$a3
- Save any needed registers ($ra, maybe $t0-t9)
- jal callee
- Restore registers
- Look for result in $v0
- Callee
- Save registers that might be disturbed ($s0-$s7)
- Perform function
- Put result in $v0
- Restore registers
- jr $ra

70. Addressing Modes

How do we address the operands?
• Register Only
Operands found in registers
- Example: add $s0, $t2, $t3
- Example: sub $t8, $s1, $0
• Immediate
16-bit immediate used as an operand
- Example: addi $s4, $t5, -73
- Example: ori $t3, $t7, 0xFF
• Base Addressing
Address of operand is:
base address + sign-extended immediate
– Example: lw $s4, 72($0)
• address = $0 + 72
– Example: sw $t2, -25($t1)
• address = $t1 - 25
• PC-Relative

Assembly Code Field Values

op rs rt imm

beq $t0, $0, else 4 8 0 3

(beq $t0, $0, 3) 6 bits 5 bits 5 bits 5 bits 5 bits 6 bits
 • Pseudo Direct

71. How to Compile & Run a Program

High Level Code

Compiler

Assembly Code

Assembler

Object Files
Object File
Library Files

Linker

Executable

Loader

Memory

72. What is Stored in Memory?

• Instructions (also called text)
• Data
- Global/static: allocated before program begins
- Dynamic: allocated within program
• How big is memory?
- At most 232 = 4 gigabytes (4 GB)
- From address 0x00000000 to 0xFFFFFFFF
73. MIPS Memory Map
Address Segment
0xFFFFFFFC

Reserved

0x80000000
0x7FFFFFFC Stack

Dynamic Data

0x10010000 Heap
0x1000FFFC

Static Data

0x10000000
0x0FFFFFFC

Text

0x00400000
0x003FFFFC

Reserved

0x00000000

74. Example Program: C Code

 .

75. Example Program: Symbol Table

Symbol Address
f 0x10000000
g 0x10000004
y 0x10000008
main 0x00400000
 sum 0x0040002C

76. Example Program: Executable

Executable file header Text Size Data Size

0x34 (52 bytes) 0xC (12 bytes)

Text segment Address Instruction

0x00400000 0x23BDFFFC addi $sp, $sp, -4
0x00400004 0xAFBF0000 sw $ra, 0 ($sp)
0x00400008 0x20040002 addi $a0, $0, 2
0x0040000C 0xAF848000 sw $a0, 0x8000 ($gp)
0x00400010 0x20050003 addi $a1, $0, 3
0x00400014 0xAF858004 sw $a1, 0x8004 ($gp)
0x00400018 0x0C10000B jal 0x0040002C
0x0040001C 0xAF828008 sw $v0, 0x8008 ($gp)
0x00400020 0x8FBF0000 lw $ra, 0 ($sp)
0x00400024 0x23BD0004 addi $sp, $sp, -4
0x00400028 0x03E00008 jr $ra
0x0040002C 0x00851020 add $v0, $a0, $a1
0x00400030 0x03E00008 jr $ra

Data segment Address Data

0x10000000 f
0x10000004 g
0x10000008 y

77. Example Program: In Memory

 Address Memory

Reserved
0x7FFFFFFC Stack $sp = 0x7FFFFFFC

0x10010000 Heap

$gp = 0x10008000

y
g
0x10000000 f

0x03E00008
0x00851020
0x03E00008
0x23BD0004
0x8FBF0000
0xAF828008
0x0C10000B
0xAF858004
0x20050003
0xAF848000
0x20040002
0xAFBF0000
0x00400000 0x23BDFFFC PC = 0x00400000
Reserved

78.