15-213 recitation 2 – 2/4/02 outline floating point typecasting machine model assembly programming...
TRANSCRIPT
15-213 Recitation 2 – 2/4/02
Outline• Floating Point• Typecasting
• Machine Model• Assembly
Programming– Structure– Addressing Modes
• L2 Practice Stuff
Mengzhi Wang
e-mail:
Office Hours:
Thursday 1:30 – 3:00
Wean Hall 3108
Floating Point(Better known as “I’m going to kill the person that thought this
up”)
• IEEE Floating Point– Standard notation– Tons of features we won’t look at
• Floating Point at a bit level:
– s – sign bit (S)– exp – exponent (maps to E, has e bits)– frac – significand (maps to M, has f bits)
• Numerical Equivalent: –1s M 2E
• “Normalized” and “Denormalized” encoding
s exp frac
“Normalized” Encoding
• exp 0 and exp 111…1– If exp = 111…1, it’s or NAN
• E = exp – B– B is the “Bias”– Usually 2e-1 – 1, but can be different– exp: Unsigned integer value [1, 2e – 1]
• M = 1.{frac}– {frac} are the bits of frac– frac is a fractional binary number
• Normalized Numbers have range [21-B, 2B+1)– And their negatives
“Denormalized” Encoding
• exp = 0• E = -B+1• M = 0.{frac}• Denormalized Numbers have Range [0, 21-B)
– And their negatives
NaNNaN
+
0
+Denorm +Normalized-Denorm-Normalized
+0
FP Examples
• 8 bit FP, 1 bit sign, 4 bit exponent, 3 bit significand
Q: What is the bias?
0.343750.0097656
25-28.0
0 0101 0110 0000 1011 1011 110
Representation -> Number
A: Bias is 7. (2(4-1)-1)
More FP Examples• 8 bit FP, 1 bit sign, 4 bit exponent, 3 bit significand, Bias
of 7
Number -> Representation
9.6-15
0 1010 0010 0110 0011 1010 111
Typecasting
• What is typecasting?– Some types can be converted (or typecast) to
others in C.– Typecasting is often unavoidable and essential.
• How to typecasting?– Assume:
• x has type type_a• y has some type that can be cast to type_a
– cast y to type_a and assign it to x:• x = (type_a)y;
• What types can be cast?– All primitive types in C can be cast to another.– Pointers can be also be cast.
Typecasting Examples• Casting integers from large size data types to small ones
– C integer types• long, int, short, char
– Possible overflow• Occurs when the data is out of the range of the small data type
Normal:int a = 1024;short s = (short)a; -or-short s = a;
-> S = 1024;
Overflow:
int x = 0x0034a140;
short s = x;
-> s = 0xa140 = -24256
Typecasting Examples• Casting integers from small size data types to large ones
– Sign Extension: the sign bit is copied to every higher bit for signed types
Positive numbers:short s = 0xf0;int i=s;unsigned u = s;
-> i = 240-> u = 240
Negative numbers:signed char c = 0xf0;unsigned char uc = 0xf0;int i = c;unsigned c2u = c;unsigned uc2u = uc;
-> i = -16, NOT 240-> c2u = 4294967280-> uc2u = 240
Typecasting with FPs
• Casting floating point numbers to integers– Rounded to the nearest integer value
Example 1:float a = -3.5; int i = (int)a;
-> i = -3(note round to zero behavior)
Example 2:int i = 4;double x = (double)i;int root = (int)sqrt(x);
-> x = 4.0->root = 2
Typecasting with FPs (cont.)
• Casting integers to floating point numbers– Some large integers can not be represented exactly
in floating point.
Rounding error example:unsigned int i = 0xfffffff0;float f = (float)i;double d = (double)i;
-> i = 4294967280-> f = 4294967296.0-> d = 4294967280.0
Machine Model
EIP
Registers
CPU Memory
Object CodeProgram Data
Addresses
Data
Instructions
Stack
ConditionCodes
Special Registers
• %eax Return Value• %eip Instruction Pointer• %ebp Base (Stack Frame) Pointer• %esp Stack Pointer
Assembly Programming: Structure
Function Setup• Save Old Base Pointer (pushl %ebp)• Set up own base pointer (movl %esp,
%ebp)– Note that this saves the old stack pointer
• Save any registers that could be clobbered– Where?
Function Body• Operations on data, loops, function calls
Assembly Programming: Structure
Function Cleanup• Return value placed in %eax
– What about returning larger values? (structs, doubles, etc.)
• Restore Caller’s Stack Pointer (movl %ebp, %esp)
• Restore Old Base Pointer (popl %ebp)• Return
– Where does it return to?
Assembly Programming:Simple Addressing Modes
Examples• (R) Mem[R]• $10(R) Mem[R + 10]• $0x10(R) Mem[R + 16]
Assembly Programming:Indexed Addressing Modes
Generic FormD(Rb, Ri, S) Mem[Reg[Rb]+S*Reg[Ri]+ D]
Examples
• (Rb,Ri) Mem[Reg[Rb]+Reg[Ri]]
• D(Rb,Ri) Mem[Reg[Rb]+Reg[Ri]+D]• (Rb,Ri,S) Mem[Reg[Rb]+S*Reg[Ri]]
Example 1: Simple Stuff
int foo(int x, int y){ int t, u; t = 3*x-6*y; t = t - 1; u = 16*t; return -u*t;}
Method 1
foo:pushl %ebp
movl %esp,%ebp
movl 8(%ebp),%edx movl 12(%ebp),%eax
movl $3, %ecximull %ecx,%edxmovl $6, %ecximull %ecx,%eaxsubl %eax,%edxdecl %edxmovl %edx,%eaxsall $4,%eaximull %edx,%eaxnegl %eax
movl %ebp,%esppopl %ebpret
Example 1: Simple Stuff (cont.)
Method 2foo:
pushl %ebp movl %esp,%ebp
movl 8(%ebp),%edx movl 12(%ebp),%eax
leal (%edx,%edx,2),%edxleal (%eax,%eax,2),%eaxaddl %eax,%eaxsubl %eax,%edxdecl %edxmovl %edx,%eaxsall $4,%eaximull %edx,%eaxnegl %eax
movl %ebp,%esppopl %ebpret
int foo(int x, int y){ int t, u; t = 3*x-6*y; t = t - 1; u = 16*t; return -u*t;}
Example 2: More Simple Stuff
int absdiff(int x, int y){ if (x>=y) return x-y; else return y-x;}
absdiff: pushl %ebp movl %esp,%ebp
movl 8(%ebp),%edx movl 12(%ebp),%eax cmpl %eax,%edx jl .L3 subl %eax,%edx movl %edx,%eax jmp .L6.L3: subl %edx,%eax
.L6: movl %ebp,%esp popl %ebp ret
If condition
Then part
Else part
Example 3: Backwards
get_sum: pushl %ebp movl %esp,%ebp pushl %ebx
movl 8(%ebp),%ebx movl 12(%ebp),%ecx
xorl %eax,%eax movl %eax,%edx cmpl %ecx,%eax jge .L4.L6: addl (%ebx,%edx,4),%eax incl %edx cmpl %ecx,%edx jl .L6
.L4: popl %ebx movl %ebp,%esp popl %ebp ret
# ebx = 1st arg# ecx = 2nd arg# eax = 0# edx = 0## if (ecx >= 0) goto L4# eax += Mem[ebx+edx*4]# edx ++## if (ecx < edx) goto L6
Example 3: Answer
int get_sum(int * array, int size){ int sum = 0; int i=0; for (i=0; i<size; i++) sum += array[i]; return sum;}
get_sum: pushl %ebp movl %esp,%ebp pushl %ebx
movl 8(%ebp),%ebx movl 12(%ebp),%ecx
xorl %eax,%eax movl %eax,%edx cmpl %ecx,%eax jge .L4.L6: addl (%ebx,%edx,4),%eax incl %edx cmpl %ecx,%edx jl .L6
.L4: popl %ebx movl %ebp,%esp popl %ebp ret
Example 4: Jump Tables
#include <stdio.h>
int main(int argc, char *argv[]){ int operation, x, y;
if(argc < 4) { printf("Not enough arguments\n"); exit(0); }
operation = atoi(argv[1]); x = atoi(argv[2]); y = atoi(argv[3]);
switch(operation) { case 0: printf("Sum is: %d\n", x + y); break; case 1: printf("Diff is: %d\n", x - y); break; case 2: printf("Mult is: %d\n", x * y); break; case 3: printf("Div is: %d\n", x / y); break; case 4: printf("Mod is: %d\n", x % y); default: printf("Unknown command\n"); break; }
return 0;}
A0: mystery:A1: movl 8(%ebp), %edxA2: movl $0x0, %eaxA3: cmpl $0x0, 12(%ebp)A4: je .L11A5: .L8A6: cmpl $0x0, 12(%ebp)A7: jle .L9A8: add %edx, %eaxA9: decl 12(%ebp)A10: jmp .L10A11:.L9A12: sub %edx, %eaxA13: incl 12(%ebp)A14:.L10A15: compl $0x0, 12(%ebp)A16: jne .L8A17:.L11A18: mov %ebp, %espA19: pop %ebpA20: ret
Example 5
# Get x# Set result = 0# Compare y:0# If(y == 0) goto Done# Loop:# Compare y:0# If(y <= 0) goto Negative# result += x# y—# goto Check# Negative:# result -= x# y++# Check:# Compare y:0# If(y != 0) goto Loop# Done:## Cleanup#
int multiply(int x, int y){ int result = 0; while (y != 0) { if (y > 0) { result += x; y--; } else { result -= x; y++; } } return result;}
A0: mystery:A1: movl 8(%ebp), %edxA2: movl $0x0, %eaxA3: cmpl $0x0, 12(%ebp)A4: je .L11A5: .L8A6: cmpl $0x0, 12(%ebp)A7: jle .L9A8: add %edx, %eaxA9: decl 12(%ebp)A10: jmp .L10A11:.L9A12: sub %edx, %eaxA13: incl 12(%ebp)A14:.L10A15: compl $0x0, 12(%ebp)A16: jne .L8A17:.L11A18: mov %ebp, %espA19: pop %ebpA20: ret
Example 5
A function with prototype
int mystery2(int *A, int x, int N)
is compiled into the assembly on the next page.
Hint: A is an array of integers, and N is the length of the array.
What is this mystery function computing?
Challenge Problem
A0: mystery2:A1: push %ebpA2: movl %esp, %ebpA3: movl 8(%ebp), %ebxA4: movl 16(%ebp), %edxA5: movl $0xffffffff, %eaxA6: movl $0x0, 0xfffffff4(%ebp)A7: decl %edxA8: compl %edx, %ecxA9: jg .L13A10: .L9A11: add %edx, %ecxA12: sarl $0x1, %ecxA13: cmpl 12(%ebp), (%ebx,%ecx,4)A14: jge .L10A15: incl %ecxA16: movl %ecx, 0xfffffff4(%ebp)A17: jmp .L12
Challenge Problem: Code
A18: .L10A19: cmpl (%ebx,%ecx,4), 12(%ebp)A20: jle .L11A21: movl %ecx, %edxA22: decl %edxA23: jmp .L12A24: .L11A25: movl %ecx, %eaxA26: jmp .L13A27: .L12A28: cmpl %edx, 0xfffffff4A29: jle .L9A30: .L13A31: movl %ebp, %espA32: pop %ebpA33: ret
Answer: Binary Search# Set up## ebx = Array A# edx = High = N# result = -1# Low = 0# ecx = Mid = Low# High—# Compare Low:High# If Low > High goto Done# Loop:# Mid += High# Mid /= 2# Compare A[Mid]:X# If >=, goto High# Mid++# Low = Mid# goto Check
Challenge Problem: Answer
A0: mystery2:A1: push %ebpA2: movl %esp, %ebpA3: movl 8(%ebp), %ebxA4: movl 16(%ebp), %edxA5: movl $0xffffffff, %eaxA6: movl $0x0, 0xfffffff4(%ebp)A7: decl %edxA8: compl %edx, %ecxA9: jg .L13A10: .L9A11: add %edx, %ecxA12: sarl $0x1, %ecxA13: cmpl 12(%ebp), (%ebx,%ecx,4)A14: jge .L10A15: incl %ecxA16: movl %ecx, 0xfffffff4(%ebp)A17: jmp .L12
Challenge Problem (continued)
# High:# Compare X:A[Mid]# If <=, goto Found# High = Mid# High—# goto Check# Found:# Result = Mid# goto Done# Check:# Compare Low:High# If <=, goto Loop# Done:## Cleanup#
A18: .L10A19: cmpl (%ebx,%ecx,4), 12(%ebp)A20: jle .L11A21: movl %ecx, %edxA22: decl %edxA23: jmp .L12A24: .L11A25: movl %ecx, %eaxA26: jmp .L13A27: .L12A28: cmpl %edx, 0xfffffff4A29: jle .L9A30: .L13A31: movl %ebp, %espA32: pop %ebpA33: ret
Challenge Problemint binsearch(int *A, int X, int N){ int Low, Mid, High;
Low = 0; High = N - 1; while ( Low <= High ) { Mid = ( Low + High ) / 2; if ( A[ Mid ] < X ) Low = Mid + 1; else if ( A[ Mid ] > X ) High = Mid - 1; else return Mid; /* Found */ } return -1;}