Chapter 14 Functions
Post on 03-Jan-2016
48 Views
Preview:
DESCRIPTION
Transcript
Chapter 14Functions
BYU CS/ECEn 124 Variables and Operators 2
Topics to Cover…
Functions C Functions Function Examples Function Notes main Function Activation Records Run-time Stack Function Calls
BYU CS/ECEn 124 Variables and Operators 3
Functions
Smaller, simpler, subcomponent of program Provides abstraction
hide low-level details give high-level structure to program, easier to
understand overall program flow enables separable, independent development
Decomposition Functions break large computing tasks into smaller
ones. Functions enlarge the set of elementary building blocks.
In other languages, called procedures, methods, subroutines, ...
Functions
BYU CS/ECEn 124 Variables and Operators 4
Example of High-Level Structure
int main(){ SetupBoard(); /* place pieces on board */ DetermineSides(); /* choose black/white */
/* Play game */ do
{ WhitesTurn(); BlacksTurn(); } while (NoOutcomeYet());}
Structure of programis evident, even withoutknowing implementation.
Functions
BYU CS/ECEn 124 Variables and Operators 5
The Power of Functions
Decomposition Functions break large computing tasks into smaller
ones. Functions enlarge the set of elementary building
blocks. Abstraction
Separate the “function” of a component from the details of how it is accomplished.
The component can be used as a building block while hiding the details in the function.
Functions
BYU CS/ECEn 124 Variables and Operators 6
Functions in C
Functions have been in all programming languages since the very early days of computing.
Support for functions is provided directly in all instruction set architectures.
C is heavily oriented around functions. A C program is organized as a collection of functions. Every C statement belongs to a function All C programs start and finish execution in the function main
Functions may call other functions which, in turn, call more functions.
Functions
BYU CS/ECEn 124 Variables and Operators 7
Parts of a C Function
The Declaration: Informs the compiler about the function.
The Definition: The function body contained inside braces {...}.
The Return Value: Calculated by the function, and returned by a return statement in the body.
The Call: Arguments (actual parameters) from the caller are transmitted to the function parameters (formal parameters).
C Functions
BYU CS/ECEn 124 Variables and Operators 8
Parts of a C Function
The Declaration:
type name(type, type, ... ); Informs the compiler about the function Only argument types needed Ends in a semi-colon The function prototype declares:
The function name The type of the output value returned by the function
(void = nothing returned) The types of input arguments that the function accepts as
input
C Functions
BYU CS/ECEn 124 Variables and Operators 9
Parts of a C Function
The Definition:
type name(type param, type param,...){ body } The first line matches type in the declaration (but
without the semicolon) The list of input arguments (formal parameters) by type
and name The function body contained inside braces {...}
C Functions
BYU CS/ECEn 124 Variables and Operators 10
Parts of a C Function
The Return Value:
return expression; Returned by a return statement in the body Must match declaration return type
The Call:
name(expression, expression, ... ) Arguments (actual parameters) from the caller are
transmitted to the function parameters (formal parameters)
Function definitions and function calls must having matching prototypes.
C Functions
BYU CS/ECEn 124 Variables and Operators 11
Example #1
#include <stdio.h>
int addNumbers(int, int);
int main(){ printf("\nResult is: %d", addNumbers(4, 5));}
int addNumbers(int x, int y){ return (x+y);}
function prototype(declaration)
formal parameters
arguments
function definition
Function Examples
BYU CS/ECEn 124 Variables and Operators 12
#include <stdio.h>
void PrintBanner(); /* function declaration */
int main(){ PrintBanner(); /* function call */ printf("\nA simple C program."); PrintBanner(); /* function call */}
void PrintBanner() /* function definition */{ printf("\n==================================");} /* no return value needed */
Example #2Function Examples
BYU CS/ECEn 124 Variables and Operators 13
Example #3
#include <stdio.h>int Factorial(int n); // function declarationint main(){ int number, answer; ... answer = Factorial(number); // function call ...}int Factorial(int n) // function definition{ int i; int result = 1; for(i=1; i<=n; i++) result = result * i; return result; // return value to caller}
Function Examples
BYU CS/ECEn 124 Variables and Operators 14
Function Notes
Minimal do-nothing functionvoid dummy( ) {}
Default return type is integerthree( ) { return 3; }int three( ) { return 3; }
Function definitions cannot nest Function arguments are local to the function Function arguments are passed “by value”
Temporary (private) variables rather than the originals Value could be a reference (such as with an array) Call by value is an asset, not a liability
These arethe same
Function Notes
BYU CS/ECEn 124 Variables and Operators 15
Function Notes
The scope of a name (variable or function) is the part of the program within which the name can be used.
A function prototype “extends” the scope of a function and helps the compiler check function call syntax.
int xyz(int x, int y){ ...}...
/* end of file */
scope of xyz
without prototypewith prototype
...int xyz(int, int);...
Function Notes
BYU CS/ECEn 124 Variables and Operators 16
The main Function
Must be present in every program Is “called” by the operating system when program
is run Returning from main exits the program Is pre-declared as:
int main (int argc, char *argv[]); The definition doesn’t have to match.
int main() { ... }main() { ... }
The return statement can be omitted.
Don’t worry about what this means.
These are OK
main Function
BYU CS/ECEn 124 Variables and Operators 17
Implementing Functions in C
Functions are the C equivalent of subroutine in assembly language.
Function calls involve three basic steps1) Parameters from caller are passed to the callee.
Control is passed to callee.2) Callee does the task3) Return value is passed back to caller.
Control returns to the caller. Functions must be caller-independent, i.e.
callable from any function.
Activation Records
BYU CS/ECEn 124 Variables and Operators 18
Activation Records
When a function is called, it needs to be activated, that is, local variables must be given locations in memory.
An activation record for a function is a template of the relative positions of its local variables in memory.
A frame is a local data storage area allocated on the stack each time a function is called for the activation record.
Frame variables are for temporary storage and are lost when the function returns.
The stack pointer is used for the frame pointer. Data is stored and retrieved via indexed stack instructions.
mov.w r12,0(sp) ; save parameter 1mov.w 0(sp),r12 ; return value
Activation Records
BYU CS/ECEn 124 Variables and Operators 19
Run-time Stack Operation
main
Memory
SP
Program starts
main
func A
SP
Memory
main calls A
main
SP
func A
func B
A calls B
Run-time Stack
BYU CS/ECEn 124 Variables and Operators 20
Runtime Stack Operation
main
Memory
SP
A returns to main
main
func A
SP
Memory
B returns to A
Run-time Stack
BYU CS/ECEn 124 Variables and Operators 21
Stack Frames / Parameter Passing
Each function call creates a new stack frame. The parameters of a called function are passed
to a function in a right to left order. Up to four left most parameters are passed in
registers unless they are defined as a struct or union type, in which case they are also passed on the stack. The remaining parameters are always passed on the stack.
Activation Records
BYU CS/ECEn 124 Variables and Operators 22
Stack Frames / Parameter Passing
Each function call creates a new stack frame.
Parameters(When more than 4)
Return Address
Saved Registers (if any)
Local Variables
Low Address
High Address
Sta
ck
Stack Pointer (SP)
Frame orActivation Record
Activation Records
BYU CS/ECEn 124 Variables and Operators 23
Activation Record (Frame)
a int 0(SP) func
b int 2(SP) func
x int 4(SP) func
y int 6(SP) func
z int 8(SP) func
Name Type Offset Scope
Symbol Table
int func(int a, int b){ int x, y, z; … return y;}
y
z
x
aSP
Return Address Bookkeeping Info
b
Local variables
Memory
Activation Records
BYU CS/ECEn 124 Variables and Operators 24
Stack Frames / Parameter Passing
Example:int func(a, b, c, d, e, f){ int x, y, z; x = 1; y = 2; z = 3; return a+b+c+d+e+f+x+y+z;}int main(){ func(10, 20, 30, 40, 50, 60); return 0;}
main:0x8762: 8221 SUB.W #4,SP0x8764: 40B1 0032 0000 MOV.W #0x0032,0x0000(SP)0x876a: 40B1 003C 0002 MOV.W #0x003c,0x0002(SP)0x8770: 403C 000A MOV.W #0x000a,R120x8774: 403D 0014 MOV.W #0x0014,R130x8778: 403E 001E MOV.W #0x001e,R140x877c: 403F 0028 MOV.W #0x0028,R150x8780: 12B0 853C CALL #func0x8784: 430C CLR.W R120x8786: 5221 ADD.W #4,SP0x8788: 4130 RET func:0x853c: 8031 000E SUB.W #0x000e,SP0x8540: 4F81 0006 MOV.W R15,0x0006(SP)0x8544: 4E81 0004 MOV.W R14,0x0004(SP)0x8548: 4D81 0002 MOV.W R13,0x0002(SP)0x854c: 4C81 0000 MOV.W R12,0x0000(SP)0x8550: 4391 0008 MOV.W #1,0x0008(SP)0x8554: 43A1 000A MOV.W #2,0x000a(SP)0x8558: 40B1 0003 000C MOV.W #0x0003,0x000c(SP)0x855e: 411C 0002 MOV.W 0x0002(SP),R120x8562: 512C ADD.W @SP,R120x8564: 511C 0004 ADD.W 0x0004(SP),R120x8568: 511C 0006 ADD.W 0x0006(SP),R120x856c: 511C 0010 ADD.W 0x0010(SP),R120x8570: 511C 0012 ADD.W 0x0012(SP),R120x8574: 511C 0008 ADD.W 0x0008(SP),R120x8578: 511C 000A ADD.W 0x000a(SP),R120x857c: 511C 000C ADD.W 0x000c(SP),R120x8580: 5031 000E ADD.W #0x000e,SP0x8584: 4130 RET
f 60 0x0012(SP)e 50 0x0010(SP)
Return adrz 3 0x000c(SP)y 2 0x000a(SP)x 1 0x0008(SP)d 40 0x0006(SP)c 30 0x0004(SP)b 20 0x0002(SP)a 10 0x0000(SP)SP
Run-time Stack
BYU CS/ECEn 124 Variables and Operators 25
Function Calls
Caller If more than 4 arguments, push function arguments on
stack (right-to-left) Put 1st argument in R12, 2nd argument in R13,… Transfer control to function with call instruction
Callee Create activation record on the stack Save arguments in activation record Save any callee-saved registers that are altered in
activation record.
Function Calls
BYU CS/ECEn 124 Variables and Operators 26
The Return
Callee Put return value in R12 Restore any saved registers Pop activation record Return control to caller (RET = mov.w @sp+,pc)
Caller Return value is in R12
Function Calls
BYU CS/ECEn 124 Variables and Operators 27
Activation Record (Frame)
int main(){ int n; int m; … m = func(n, 10); …}
int func(int a, int b){ int x, y, z; … return y;}
SP
Memory
Function Calls
y
z
x
a
Return Address
b
Localvariables
ActivationRecord forfunc
n
m
Return Address
Localvariables
ActivationRecord formain
BYU CS/ECEn 124 Variables and Operators 28
top related