CDA 3101 Fall 2013 Introduction to Computer Organization Procedure Support & Number...

CDA 3101 Fall 2013

Introduction to Computer Organization

Procedure Support

& Number Representations

11,13 September 2013

Review• 3 formats of MIPS instructions in binary:

– Op field determines format

• Operands– Registers: $0 to $31 mapped onto: $zero, $at, $v_, $a_, $s_, $t_, $gp, $sp, $fp, $ra

– Memory : Mem[0], Mem[4], … , Mem[4294967292]• Index is the “address” (Array index => Memory index)

• Stored program concept (instructions are numbers!)

op immediaters rt

op functrs rt shamtrd

op destination address

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

RI

J

Overview

• Memory layout

• C functions

• MIPS support (instructions) for procedures

• The stack

• Procedure Conventions

• Manual Compilation

• Conclusion

Memory Layout

Stack segment

Data segment

Text segment

Dynamic data

Static data

0xFFFFFFFF

0x7FFFFFFF

0x10000000

0x00400000

0x00000000

(2GB)

(4MB)

$gp (0x10008000)

0x10010000

Data Segment

lw $v0, 0x0020($gp)

0xFFFFFFFF

0x10000000

$gp (0x10008000)

0x10010000

2 instructions (lui and lw) are needed to access this memory

(64KB) lui $s0, 0x1001 # s0 = 0x10010000lw $v0, 0x8020($s0) # 0x8020 = (-7fe0)16

0x10008020

C Functions / Procedures

main() {int i, j, k;

…

i = fact(j,k);

…

}

int fact (int mcand, int mlier) {int product;

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

}

What information must compiler keep track of?

Procedure Call Bookkeeping

• Problems– Procedure address– Return address– Arguments– Return value– Local variables

• Register conventionsLabels

$ra

$a0, $a1, $a2, $a3

$v0, $v1

$s0, $s1, …, $s7

• Dynamic nature of procedures• Procedure call frames

• Arguments, save registers, local variables

Procedure Call Convention• Software rules for using registers

Name Register Number Usage Preserved on call

$zero 0 the constant value 0 n.a.$at 1 reserved for the assembler n.a.

$v0-$v1 2-3 expr. evaluation and function result no$a0-$a3 4-7 arguments (procedures/functions) yes$t0-$t7 8-15 temporaries no$s0-$s7 16-23 saved yes$t8-$t9 24-25 more temporaries no$k0-$k1 26-27 reserved for the operating system n.a.

$gp 28 global pointer yes$sp 29 stack pointer yes$fp 30 frame pointer yes$ra 31 return address yes

ProcedureOne

The Stack

0xFFFFFFFF

0x7FFFFFFF

main

ProcedureTwo

Stack Frames

ProcedureOne’s (callee) frame

Main’s (caller) frame

Stack Frames

argument 5argument 6

local variables

saved registers

$fp, $ra, S-registers

$fp

$sp

Saved VAT registers

$a0

$a3

$a2

$a1

$v0

$v1

Caller / Callee Conventions• Immediately before the caller invokes the callee

– Pass arguments ($a0 - $a3). Extra args: push on the stack– Save caller-saved registers ($a0 - $a3; $t0 - $t9)– Execute jal (jumps and links to callee; saves return addr)

• Just before the callee starts executing– Allocate memory for the frame ($sp = $sp – fsize)– Save callee-saved registers ($s0-$s7; $fp; $ra)– $fp = $sp + (fsize – 4)

• Immediately before the callee returns to caller– Place the returned value in register $v0– Restore all callee-saved registers– Pop the stack frame ($sp = $sp + fsize); restore $fp– Return by jumping to the address in $ra

Procedure Support

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

2000 sum: add $v0,$a0,$a12004 jr $ra # jump to 1016

main( ) {…

s = sum (a, b); …}

int sum(int x, int y) {return x + y;

}

Jump and Link Instruction• Single instruction to jump and save return address

– jal: jump and link (Make the common case fast)– J Format Instruction: jal label– Should be called laj

1. (link): save address of next instruction into $ra2. (jump): jump to label

1000 add $a0,$s0,$zero # $a0 = x 1004 add $a1,$s1,$zero # $a1 = y 1008 jal sum # $ra = 1012; jump to sum 1012 ... 2000 sum: add $v0,$a0,$a1 2004 jr $ra # jump to 1012

Nested Proceduresint sumSquare(int x, int y) {

return mult(x,x) + y;

}sumSquare:

subi $sp,$sp,12 # space on stack sw $ra,$ 8($sp) # save ret addr

sw $a0,$ 0($sp) # save x sw $a1,$ 4($sp) # save y

addi $a1,$a0,$zero # mult(x,x) jal mult # call mult lw $ra,$ 8($sp) # get ret addr lw $a0,$ 0($sp) # restore x

lw $a1,$ 4($sp) # restore y add $vo,$v0,$a1 # mult()+y addi $sp,$sp,12 # free stack space

jr $ra

Example (1/2)main( ) {

int f; f = fact (10); printf (“Fact(10) = %d\n”, f); }

int fact ( int n) { if (n < 1)

return (1); else

return (n * fact(n-1);}

Old $raOld $fp

Old $a0Old $raOld $fp

Old $a0Old $raOld $fp

Old $a0Old $raOld $fp

main

fact (10)

fact (8)

fact (9)

Example (2/2)main: subu $sp, $sp, 32

sw $ra, 20($sp)sw $fp, 16($sp)addiu $fp, $sp, 28li $v0, 4la $a0, strsyscallli $a0, 10jal factaddu $a0, $v0, $zero li $v0, 1syscalllw $ra, 20($sp) lw $fp, 16($sp)addiu $sp, $sp, 32jr $ra

fact: subu $sp, $sp, 32sw $ra, 20($sp) sw $fp, 16($sp) addiu $fp, $sp, 28sw $a0, 0($fp) lw $v0, 0($fp) bgtz $v0, L2li $v0, 1j L1

L2: lw $v1, 0($fp)subu $v0, $v1, 1move $a0, $v0jal factlw $v1, 0($fp) mul $v0, $v0, $v1

L1: lw $ra, 20($sp) lw $fp, 16($sp) addiu $sp, $sp, 32jr $ra

Summary• Caller / callee conventions

– Rights and responsibilities– Callee uses VAT registers freely– Caller uses S registers without fear of being overwritten

• Instruction support: jal label and jr $ra• Use stack to save anything you need. Remember to

leave it the way you found it• Register conventions

– Purpose and limits of the usage– Follow the rules even if you are writing all the code

yourself

New Topic – Number Systems

CompilerOperating

System(Linux, Win)

Application (browser)

Digital Logic

Circuit Design

Instruction Set Architecture (ISA)

Datapath & Control

Transistors

Hardware

Software

Assembler

Memory I/O System

The Arithmetic and Logic Unit

0000 1001 1100 0110 1010 1111 0101 10001010 1111 0101 1000 0000 1001 1100 0110 1100 0110 1010 1111 0101 1000 0000 1001 0101 1000 0000 1001 1100 0110 1010 1111

...

Memory

program & data

I / O

Datapath

Control

load/store

add $t0, $s1, $s2 # $s1 + $s2and $t0, $s1, $s2 # $s1 AND $s2lw $t0, 100($s1) # $s1 + 100beq $s1, $s2, L # $s1 = = $s2

Computer Arithmetic• Computer arithmetic vs. Mathematical theory

– Fixed-precision numbers• Not closed with respect to +, -, *, /

– Overflow– Underflow– Undefined

• Laws of normal algebra do not always hold in computers– a + (b - c) = (a + b) - c– a * (b – c) = a * b – a * c

– Binary numbers• Base: 2• Digits: 0 and 1

• Decimal number = Σ di * 2i (d31 d30 d29 . . . d2 d1 d0) i = 0

n-1

-231 231-1 Expressible Integers

( 1101 1010 1101 )2

( B A D )16

Data Representation

Bits can represent anything:• Characters

– 26 letters => 5 bits– Upper/lower case + punctuation => 7 bits (in 8)– Rest of the world’s languages => 16 bits (unicode)

• Unsigned numbers (0, 1, …, 2n-1)• Logical values

– 0 -> False, 1 => True

• Colors• Locations / addresses / commands• But n bits can only represent 2n distinct objects

Negative Numbers

• We discussed unsigned numbers – What about the sign?• Naive solution: define leftmost bit to be sign

– 0 means +, 1 means - => sign bit

– Remainder of bits can be numerical value of number

• This representation called sign and magnitude• MIPS uses 32-bit integers (16-bit immediates/displacements)

+1ten would be:

0000 0000 0000 0000 0000 0000 0000 0001

- 1ten would be:

1000 0000 0000 0000 0000 0000 0000 0001

Problems with Sign and Magnitude

1. Arithmetic circuit more complicated– Special steps depending whether signs are the

same or different (e.g., -x . -y = xy = x * y)

2. Two zero representations– 0x00000000 = +0ten

– 0x80000000 = -0ten

– Programming implications (+0 == -0)

• Sign and magnitude was abandoned because of confusion over zero

Let’s Try: One’s Complement

• Complement the bits to get the negative• Example: 710 = 001112 -710 = 110002

• Positive numbers have leading 0s, negative numbers have leadings 1s.

00000 00001 01111...

111111111010000 ...

• Still two zeros (oops.. )– 0x00000000 = +0ten

– 0xFFFFFFFF = -0ten

• Arithmetic not too hard

Better: Two’s Complement

• Positive numbers start with 0• Negative numbers are the inverse of positive + ONE• Example

110 = 000000012

-110 = 111111102 + 12 = 111111112

710 = 000001112

-710 = 111110002 + 12 = 111110012

• Positive numbers can have infinitely many leading 0’s• Negative numbers can also have infinitely many leading

1’s

Two’s Complement Number Line

• 2 n-1 non-negatives • 2 n-1 negatives• one zero• 2 n-1-1 positives• comparison• Overflow due to

circulant domain

00000001

00101111

1110

1000 01111001

0 12

-1-2

-7 -87

0011

0100

0101

01101010

1011

1100

11013

4

5

6

-3

-4

-5

-6

0-8 -6 -4 -2 2 4 6 8

Example: Two’s Complement

0000 ... 0000 0000 0000 0000two =

0ten

0000 ... 0000 0000 0000 0001two =

1ten

0000 ... 0000 0000 0000 0010two =

2ten

. . .0111 ... 1111 1111 1111 1101two =

2,147,483,645ten

0111 ... 1111 1111 1111 1110two =

2,147,483,646ten

0111 ... 1111 1111 1111 1111two =

2,147,483,647ten

1000 ... 0000 0000 0000 0000two =

–2,147,483,648ten

1000 ... 0000 0000 0000 0001two =

–2,147,483,647ten

1000 ... 0000 0000 0000 0010two =

–2,147,483,646ten

. . . 1111 ... 1111 1111 1111 1101two =

–3ten

1111 ... 1111 1111 1111 1110two =

–2ten

1111 ... 1111 1111 1111 1111two =

–1ten

Two’s Complement How-To

• Can represent positive and negative numbers by first bit (MSB) as –231 position, then positive 2n:d31 x -231 + d30 x 230 + ... + d2 x 22 + d1 x 21 + d0 x 20

• Example1111 1111 1111 1111 1111 1111 1111 1100two

= 1x-231 +1x230 +1x229+... +1x22+0x21+0x20

= -231 + 230 + 229 + ... + 22 + 0 + 0

= -2,147,483,648ten + 2,147,483,644ten

= -4ten

• Note! Must specify width to find MSB => 32bits is used in MIPS, so d31 is MSB

Two’s Complement Negation• Invert (every 0 to 1 and every 1 to 0), then

add 1 to the result– Sum of number and its one’s complement must be

111...111two = -1ten

– Let x’ denote the inverted representation of x– Then x + x’ = -1 x + x’ + 1 = 0 x’ + 1 = -x

• Example: x = -4 to +4 to -4 x=-4 : 1111 1111 1111 1111 1111 1111 1111 1100two

x’ : 0000 0000 0000 0000 0000 0000 0000 0011two

x’ + 1: 0000 0000 0000 0000 0000 0000 0000 0100two

invert: 1111 1111 1111 1111 1111 1111 1111 1011two

add 1 : 1111 1111 1111 1111 1111 1111 1111 1100two

Signed vs. Unsigned Comparisons

• X = 1111 1111 1111 1111 1111 1111 1111 1100two

• Y = 0011 1011 1001 1010 1000 1010 0000 0000two

Ambiguity:• Is X > Y?

– Unsigned: YES

– Signed: NO

• Converting to decimal to check– Signed comparison:

-4ten < 1,000,000,000ten?

– Unsigned comparison: -4,294,967,292ten < 1,000,000,000ten

2’s Compl. Sign Extension• Problem: Convert 2’s complement number using

n bits to more than n bits• Solution: Replicate the most significant bit (sign

bit) of smaller to fill new bits–2’s comp. positive number has infinite 0s to the left–2’s comp. negative number has infinite 1s to the left–Bit representation hides leading bits; sign extension restores some of the infinite number of leading bits–16-bit -4ten to 32-bit:

1111 1111 1111 1100two

1111 1111 1111 1111 1111 1111 1111 1100two

16-bit

32-bit

MSB

Conclusion• We represent objects in computers as bit patterns:

n bits =>2n distinct patterns• Decimal for humans, binary for computers• 2’s complement universal in computing: cannot

avoid, so we will learn• Computer operations on the representation are

abstraction of real operations on the real thing• Overflow:

- Numbers infinite- Computer finite

• Enjoy: Weekend!