1. 10/4: Lecture Topics Overflow and underflow Logical operations
Procedure calls

2. Overflow and Underflow
Overflow occurs when a number is too big to represent usually as the result of a numerical operation
unsigned ints, > 232-1
signed ints, > 231-1
floats, > e+38
doubles, > e+308
Underflow means the number is too small to represent
unsigned ints < 0
signed ints, < -231
floats, > e-38
doubles, > e-308

3. Logical Operations Bitwise operations (and/andi & or/ori)
Shift operations
left shift << 2 = (sll)
right shift >> 2 =
Signed >>
>> 2 =
sra
Unsigned >>
>> 2 =
srl

4. Examples Evaluate the following Fill in the body of this procedure
( & ) |
( >> 3) |
Fill in the body of this procedure
int GetBitFromPosition( int num, int pos ) {
if( ( pos < 0 ) || ( pos >= 32 ) ) {
fprintf( stderr, “You idiot.\n” );
return 0; }
return

5. Examples Continued
f is a single precision floating point number write code to extract the actual exponent from f

6. Procedure calls in assembly
int fact( int n ) {
int result;
if( n <= 1 )
result = 1;
else
result = n * fact(n-1);
return result; }
main() {
int i;
i = fact( 5 );

7. Procedure Call More than just a branch and a return Data goes in
arguments, parameters
Data goes back out
return value
What makes this possible?
the stack

8. Review of Stacks Two operations: push an item onto the stack
pop an item off the stack

9. Stack Implementations
Pretty easy to do with a linked list
You probably saw this in 143 or 373
Top

10. A Stack in an Array Linked lists are nice if you have them
Arrays are a lot faster
A[5]
A[4]
Top
A[3]
A[2]
A[1]
A[0]

11. Calling Conventions
Sequence of steps to follow when calling a procedure
Determines:
where arguments are passed to the callee
how to transfer control from caller to callee and back
where return values passed back out
no unexpected side effects
such as overwritten registers

12. Calling Conventions Mostly governed by the compiler
We’ll see a MIPS calling convention
Not the only way to do it, even on MIPS
Most important: be consistent
Procedure call is one of the most unpleasant things about writing assembly for RISC architectures

13. A MIPS Calling Convention
1. Place parameters where the procedure can get them
2. Transfer control to the procedure
3. Get the storage needed for the procedure
4. Do the work
5. Place the return value where the calling code can get it
6. Return control to the point of origin

14. Step 1: Parameter Passing
The first four parameters are easy - use registers $a0, $a1, $a2, and $a3
You’ve seen this already
What if there are more than four parameters?

15. Step 2: Transfer Control
Getting from caller to callee is easy -- just jump to the address of the procedure
Need to leave a way to get back again
Special register: $ra (for return address)
Special instruction: jal

16. Jump and Link
Calling code
Procedure
proc: add ..
jal proc

17. Step 3: Acquire Storage What storage do we need?
Registers
Other local variables
Where do we get the storage?
From the stack

18. Refining Program Layout
Address
Reserved 0x
Program instructions
Text 0x
Static data
Global variables 0x
Dynamic data
heap
Local variables, saved registers
Stack
0x7fffffff

19. Saving Registers on the Stack
$sp
$s2
$s1
$s0
$sp
$sp
Before Procedure
During Procedure
After Procedure

20. Assembly for Saving Registers
We want to save $s0, $s1, and $s2 on the stack
sub $sp, $sp, 12 # make room for 3 words
# “addi $sp, $sp, -12”
sw $s0, # store $s0
sw $s1, # store $s1
sw $s2, # store $s2

21. Step 4: Do the work
We called the procedure so that it could do some work for us
Now is the time for it to do that work
Resources available:
Registers freed up by Step 3
All temporary registers ($t0-$t9)

22. Callee-saved vs. Caller-saved
Some registers are the responsibility of the callee
callee-saved registers
$s0-$s7
Other registers are the responsibility of the caller
caller-saved registers
$t0-$t9

23. Step 5: Return values MIPS allows for two return values
Place the results in $v0 and $v1
You’ve seen this too
Why are there two return values?
What if the procedure needs more than two return values?

24. Step 6: Return control
Because we laid the groundwork in step 2, this is easy
Address of the point of origin + 4 is in register $ra
Just use jr $ra to return

25. An Example
int leaf(int g, int h, int i, int j) {
int f;
f = (g + h) - (i + j);
return f; }
Let g, h, i, j be passed in $a0, $a1, $a2, $a3, respectively
Let the local variable f be stored in $s0

26. Compiling the Example leaf: sub $sp, $sp, 4 # make room for $s0
# addi $sp, $sp, -4
sw $s0, 0($sp) # store $s0
add $t0, $a0, $a1 # $t0 = g + h
add $t1, $a2, $a3 # $t1 = i + j
sub $s0, $t0, $t1 # $s0 = f
add $v0, $s0, $zero # copy result
lw $s0, 0($sp) # restore $s0
addi $sp, $sp, 4 # put $sp back
jr $ra # jump back to caller

27. Nested Procedures Suppose we have code like this:
Potential problem: the return address is stored in $ra which will get overwritten
main() {
foo(); }
int foo() {
return bar();
int bar() {
return 6;

28. A Trail of Bread Crumbs
The registers $s0-$s7 are not the only ones we save on the stack
What can the caller expect to have preserved across procedure calls?
What can the caller expect to have overwritten during procedure calls?

29. Preservation Conventions
Preserved
Not Preserved
Saved registers: $s0-$s7
Stack pointer register: $sp
Return address register: $ra
Stack above the stack pointer
Temporary registers: $t0-$t9
Argument registers: $a0-$a3
Return value registers: $v0-$v1
Stack below the stack pointer

30. A Brainteaser in C What does this program print? Why?
#include <stdio.h>
int* foo() {
int b = 6;
return &b; }
void bar() {
int c = 7;
main() {
int *a = foo();
bar();
printf(“The value at a is %d\n”, *a);

31. Activation Record
For a procedure call, the activation record is the portion of the stack containing
saved registers
local variables
Also known as procedure frame