Contents

• Overview
• Value Parameters
  • Test Yourself #1
• Reference Parameters
  • Test Yourself #2
  • Test Yourself #3
• Value-Result Parameters
  • Creating Aliases via Pointers
  • Creating Aliases by Passing Globals as Arguments
  • Creating Aliases by Passing Same Argument Twice
  • Test Yourself #4
• Name Parameters
• Comparison

Overview

In a Java program, all parameters are passed by value. However, there are three other parameter-passing modes that have been used in programming languages:

1. pass by reference
2. pass by value-result (also called copy-restore)
3. pass by name

First, here's some useful terminology:

1. Given a method header, e.g.:

          void f(int a, boolean b, int c)
     

   we will use the terms parameters, formal parameters, or just formals to refer to a, b, and c.

2. Given a method call, e.g.:

          f(x, x==y, 6);
     

   we will use the terms arguments, actual parameters, or just actuals to refer to x, x==y, and 6.

3. The term r-value refers to the value of an expression. So for example, assuming that variable x has been initialized to 2, and variable y has been initialized to 3:

   expression		r-value
   x		2
   y		3
   x+y		5
   x==y		false

4. The term l-value refers to the location or address of an expression. For example, the l-value of a global variable is the location in the static data area where it is stored. The l-value of a local variable is the location on the stack where it is (currently) stored. Expressions like x+y and x==y have no l-value. However, it is not true that only identifiers have l-values; for example, if A is an array, the expression A[x+y] has both an r-value (the value stored in the x+y^th element of the array), and an l-value (the address of that element).

Value Parameters

Parameters can only be passed by value in Java and in C. In Pascal, a parameter is passed by value unless the corresponding formal has the keyword var; similarly, in C++, a parameter is passed by value unless the corresponding formal has the symbol & in front of its name. For example, in the Pascal and C++ code below, parameter x is passed by value, but not parameter y:

// Pascal procedure header
Procedure f(x: integer; var y: integer);

// C++ function header
void f(int x; int & y);

void f( int[] A ) {
    A[0] = 10;   // change an element of parameter A
    A = null;    // change A itself (but not the corresponding actual)
}

void g() {
    int[] B = new int [3];
    B[0] = 5;
    f(B);
    //*** B is not null here, because B was passed by value
    //*** however, B[0] is now 10, because method f changed the first element
    //*** of the array pointed to by B
}

What is printed when the following Java program executes and why?

class Person {
    int age;
    String name;
}

class Test {
    static void changePerson(Person P) {
        P.age = 10;
	P = new Person();
	P.name = "Joe";
    }

    public static void main(String[] args) {
        Person P = new Person();
	P.age = 2;
	P.name = "Ann";
	changePerson(P);
	System.out.println(P.age);
	System.out.println(P.name);
    }
}

solution

Reference Parameters

When a parameter is passed by reference, the calling method copies the l-value of the argument into the called method's AR (i.e., it copies a pointer to the argument instead of copying the argument's value). Each time the formal is used, the pointer is followed. If the formal is used as an r-value (e.g., its value is printed, or assigned to another variable), the value is fetched from the location pointed to by the pointer. If the formal is assigned a new value, that new value is written into the location pointed to by the pointer (the new value is not written into the called method's AR).

If an argument passed by reference has no l-value (e.g., it is an expression like x+y), the compiler may consider this an error (that is what happens in Pascal, and is also done by some C++ compilers), or it may give a warning, then generate code to evaluate the expression, to store the result in some temporary location, and to copy the address of that location into the called method's AR (this is is done by some C++ compilers).

In terms of language design, it seems like a good idea to consider this kind of situation an error. Here's an example of code in which an expression with no l-value is used as an argument that is passed by reference (the example was actually a Fortran program, but Java-like syntax is used here):

        void mistake(int x) {  // x is a reference parameter
	   x = x+1;
	}

        void main() {
           int a;
	   mistake(1);
	   a = 1;
           print(a);
        }

To understand why reference parameters are useful, remember that, although in Java all non-primitive types are really pointers, that is not true in other languages. For example, consider the following C++ code:

class Person {
  public:
     String name;
     int age;
};

void birthday(Person per) {
   per.age++;
}

void main() {
   Person P;
   P.age = 0;
   birthday(P);
   print(P.age);
}

This motivates some reasons for using reference parameters:

1. When the job of the called method is to modify the parameter (e.g., to update the fields of a class), the parameter must be passed by reference so that the actual parameter, not just a copy, is updated.
2. When the called method will not modify the parameter, and the parameter is very large, it would be time-consuming to copy the parameter; it is better to pass the parameter by reference so that a single pointer can be passed.

Consider writing a method to sort the values in an array of integers. An operation that is used by many sorting algorithms is to swap the values in two array elements. This might be accomplished using a swap method:

static void swap(int x, int y) {
    int tmp = x;
    x = y;
    y = tmp;
}

swap(A[0], A[1]);

solution

It is important to realize that the code generator will generate different code for a use of a parameter in a method, depending on whether it is passed by value or by reference. If it is passed by value, then it is in the called method's AR (accessed using an offset from the FP). However, if it is passed by reference, then it is in some other storage (another method's AR, or in the static data area). The value in the called method's AR is the address of that other location.

To make this more concrete, assume the following code:

void f(int a) {
   a = a - 5;
}

void main() {
    int x = 10;
    f(a);
}

Notice that when passing by reference the cell at address FP contains the address of a and not its value. Therefore, the first instruction will copy the location of a into t0 and the second instruction will extract the value at such a location and copy it into t1. Finally, the last instruction will copy the result into the location pointed by t0-i.e., the location of a.

The code generator will also generate different code for a method call depending on whether the arguments are to be passed by value or by reference. Consider the following code:

    int x, y;
    x = y = 3;
    f(x, y);

solution

solution

Value-Result Parameters

Value-result parameter passing was used in Fortran IV and in Ada. The idea is that, as for pass-by-value, the value (not the address) of the actual parameters are copied into the called method's AR. However, when the called method ends, the final values of the parameters are copied back into the arguments. Value-result is equivalent to call-by-reference except when there is aliasing (note: "equivalent" means the program will produce the same results, not that the same code will be generated).

Two expressions that have the same l-value are called aliases. Aliasing can happen:

• via pointer manipulation,
• when a parameter is passed by reference and is also global to the called method,
• when a parameter is passed by reference using the same expression as an argument more than once; e.g., call test(x,y,x).

Creating Aliases via Pointers

Pointer manipulation can create aliases, as illustrated by the following Java code. (Note: this kind of aliasing does not make pass-by-reference different from pass-by-value-result; it is included here only for completeness of the discussion of aliasing.)

Person p, q;
  p = new Person();
  q = p;
  // now p.name and q.name are aliases (they both refer to the same location)
  // however, p and q are not aliases (they refer to different locations)

Pictorially:

Creating Aliases by Passing Globals as Arguments

This way of creating aliases (and the difference between reference parameters and value-result parameters in the presence of this kind of aliasing) are illustrated by the following C++ code:

int x = 1;      // a global variable

void f(int & a)
{ a = 2;        // when f is called from main, a and x are aliases
  x = 0;
}

main()
{ f(x);
  cout << x;
}

Creating Aliases by Passing Same Argument Twice

Consider the following C++ code:

  void f(int &a, &b)
  { a = 2;
    b = 4;
  }
   
  main()
  { int x;
    f(x, x);
    cout << x;
  } 

With value-result parameter passing, the value of x after the call is undefined, since it is unknown whether a or b gets copied back into x first. This may be handled in several ways:

• Code like this (where multiple actual parameters that are passed by value have the same l-value) may cause a compile-time error.
• The order in which parameter values are copied back after a call may be defined by the specific language.
• The order in which parameter values are copied back after a call may be left as implementation dependent (so code like the above may produce different outputs when compiled with different compilers).

Assume that all parameters are passed by value-result.

Question 1: Give a high-level description of what the code generator must do for a method call.

Question 2: Give the specific code that would be generated for the call shown below, assuming that variables x and y are stored at offsets -8 and -12 in the calling method's AR.

int x, y;
f(x, y);

solution

Name Parameters

Call-by-name parameter passing was used in Algol. The way to understand it (not the way it is actually implemented) is as follows:

• Every call statement is replaced by the body of the called method.
• Each occurrence of a parameter in the called method is replaced with the corresponding argument -- the actual text of the argument, not its value.

Call-by-name parameter passing is not really implemented like macro expansion however; it is implemented as follows. Instead of passing values or addresses as arguments, a method (actually the address of a method) is passed for each argument. These methods are called 'thunks'. Each 'thunk' knows how to determine the address of the corresponding argument. So for the above example:

• 'thunk' for j - return address of j
• 'thunk' for A[j] - return the address of the jth element of A, using the current value of j

For the example above, call-by-reference would execute A[0] = 0 ten times, while call-by-name initializes the whole array!

The effect of evaluating argument expressions in the callee as needed can have some surprising effects. For example, an argument that would otherwise cause a runtime crash (say divide-by-zero) won't cause any problems until it is actually used (if at all). Factors like these often make call-by-name programs hard to understand - it may require looking at every call of a method to figure out what that method is doing.

Call-by-name is interesting for historical, research, and academic reasons, However, it is considered too confusing for developers in practice and industry has largely passed it by in favor of call-by-value or call-by-reference.

Comparisons of These Parameter Passing Mechanisms

Here are some advantages of each of the parameter-passing mechanisms discussed above:

Call-by-Value (when not used to pass pointers)

• Doesn't cause aliasing.
• Arguments unchanged by method call, so easier to understand calling code (no need to go look at called method to see what it does to actual parameters).
• Easier for static analysis (for both programmer and compiler). For example:

          x = 0;
          f(x);           {call-by-value so x not changed}
          z = x + 1;      {can replace by z = 1 when optimizing}
  	

• Compared with call-by-reference, the code in the called method is faster because there is no need for indirection to access formals.

Call-by-Reference

• More efficient when passing large objects (only need to copy addresses, not the objects themselves).
• Permits actuals to be modified (e.g., can implement swap method for integers).

Call-by-Value-Result

• As for call-by-value, more efficient than call-by-reference for small objects (because there is no overhead of pointer dereferencing for each use).
• If there is no aliasing, can implement call-by-value-result using call-by-reference for large objects, so it is still efficient.

Call-by-Name

• More efficient than other approaches when passing parameters that are never used. For example:
  If the condition b in method f is not 1, then using call-by-name, it is never necessary to evaluate the first actual at all! That's good because doing so would take a long time^{* The Ackermann function is famously slow to evaluate. In this example, the result is an integer of nearly 20,000 digits.} .