Subroutines – parameter passing
• passing data to/from a subroutine can be done through
the parameters and through the return value of a
function subroutine
• parameter passing methods include:
call-by-value
- input parameters (declared with "IN") in Ada
- default method for parameters in C, C++, and
Pascal
- parameters of primitive type in Java
call-by-result
- output parameters (declared with "OUT") in Ada
Subroutines – parameter passing
Parameter passing methods (cont’d):
call-by-value-result
- in/out parameters (declared with "IN OUT") in Ada
call-by-reference
- large array parameters in Ada
- array parameters in C and C++
- reference parameters (declared with "&") in C++
- reference parameters (declared with "VAR") in
Pascal
- object parameters in Java
- default method for parameters in Fortran
Subroutines – parameter passing
Parameter passing (cont’d)
call-by-value
– copy values of actual parameters into memory
locations of formal parameters before executing the
body of the subroutine; do nothing on return
main
a=1
b=2
call subr(a,b) pass 1,2 via stack
print a,b
subr(x,y)
x=x+1
y=x+y
return
a: 1
b: 2
print 1,2
copy 1,2 into x,y
^
x: /1/ 2
|
y: /2/ 4
|
---------------------'
Subroutines – parameter passing
Parameter passing (cont’d)
• call-by-result - do nothing prior to executing the body
of the subroutine; copy the final values of the formal
parameters into the memory locations of the actual
parameters on return
main
a=1
a: 1
b=2
b: 2
call subr(a,b) pass nothing
receive ?,? from subr into a,b
a: /1/ ?
b: /2/ ?
print a,b
print ?,?
subr(x,y)
copy ?,? into x,y
^
x=x+1
x: /?/ ?
|
y=x+y
y: /?/ ?
|
return
pass ?,? back via stack -------'
Subroutines – parameter passing
Parameter passing (cont’d)
• call-by-value-result - perform copying of values both
before and after executing the body of the subroutine
main
a=1
a: 1
b=2
b: 2
call subr(a,b) pass 1,2 via stack
receive 2,4 from subr into a,b
a: /1/ 2
b: /2/ 4
print a,b
print 2,4
subr(x,y)
copy 1,2 into x,y
^
x=x+1
x: /1/ 2
|
y=x+y
y: /2/ 4
|
return
pass 2,4 back via stack --'
Subroutines – parameter passing
Parameter passing (cont’d)
• call-by-reference
– pass the addresses of the actual parameters
– copy these addresses into the memory locations of
the formal parameters
– on each reference to a formal parameter in the body
of the subroutine, perform an indirect reference to
the corresponding actual parameter;
o i.e. the formal parameter is an alias of the actual
parameter, thus both the formal and actual
parameter "name" refer to the same object
o changes made using the formal parameter are
being executed on the object passed as the actual
parameter
Subroutines – parameter passing
Parameter passing (cont’d)
• call-by-reference (cont’d)
main
a=1
a: 1
a: /1/ 2 action in subr
b=2
b: 2
b: /2/ 4 action in subr
call subr(a,b)
pass &a,&b via stack
print a,b
print 2,4
subr(x,y)
copy &a,&b into x,y
^
x=x+1
x: &a thus a = a + 1 |
y=x+y
y: &b thus b = a + b |
return
------------------------------------'
Subroutines – parameter passing
Consider the following code:
int a = 5; /* global variable */
int subr( int b, int c ){ a = 4*a;
b = b + 3;
c = c + 2;
return( a + b + c ); }
void main(void){ int d = 1, e;
e = subr( a, d ); }
Show final values after calls to subr() for the variables listed below, by
column, according to the specified parameter passing methods. (18
pts. total)
b:call by value b:call by value-result b:call by reference
c:call by value c:call by value-result c:call by reference
a
20
8
23
d
1
3
3
e
31
31
49
Subroutines – parameter passing
consider Fortran's call-by-reference applied to a constant
parameter - what should the following code print?
SUBROUTINE ADDONE( I )
I=I+1
RETURN
END
...
ADDONE( 2 )
WRITE(6,10) 2
10 FORMAT('CONSTANT 2 =',I1)
Subroutines – parameter passing (tradeoffs)
advantages
disadvantages
Call-byvalue
loads and stores operate
directly on formal parms
copying overhead
Call-byreference
no copying, allows subr
to change the values of
the actual parms
indirect reference
through addresses in
formal parms to
actual parms (i.e.,
you have to chase
pointers)
optimizations
can pass parameters in registers (not using stack)
can sometimes not save/restore registers when executing
a leaf routine