Consider the following Cool class and method definition:

class C {
    opVal(x: Int, y: Int, flag: Bool): Int {
        if flag then
            if x + y = 0 then 0 else x + y fi
        else {
            x <- x + y;
            x + y;
        }
        fi
    };
};

What is the size (in bytes) of the activation record for the above function, assuming that the minimum space needed for temporaries is allocated in the activation record?

For the class and method definition in the last question, which of the following statements are true?
[Choose all that apply]

{ g = 4; opVal(g,2,false); g }

Consider the following Cool program:

class Main inherits IO {
    s(): Int { { out_string("s"); 1; } };
    cmp(x:Int, y:Int): Bool { not(x <= y) };
    r(x:Int): Int { {
        out_string("r");
        if cmp(x,2) then r(r(x - 1)) + r(x - 1) else s() fi;
    } };
    main(): Object { r(3) };
};

In the activation tree, what is the maximum number of children for any activation record? What is the maximum depth?
Assume a single root as a tree has a depth of 1.

Assume the current runtime stack contains activation records main, r, r, cmp (reading from the bottom of the stack to the top). What are the possible outputs of the program up to this point?
[Choose all that apply]

Consider the following program.

 1. k := i + j
 2. x := k * 10
 3. if x > z goto line 7
 4. x := z - y
 5. f := x * j
 6. goto line 10
 7. x := y + 1
 8. i := j
 9. j := j + 2
10. y := f * 2
11. a := x + y
12. if x = 0 goto line 7

Assuming only variable "a" is live on exit, and that no register spilling is allowed, which of the following pairs of variables could potentially be assigned to the same register?
[Choose all that apply]

In Cool, if class C already has method foo defined, it is not permitted to define a new method foo with a different number of arguments or with arguments of different types. However, it is possible to do so in languages like Java and C++, which support method overloading. You have decided to implement method overloading in Cool by using the same algorithm as in Java and C++.

Consider a dispatch expression $e.foo(e_1,...,e_n)$ in which $e_0:T_0$ and for each $i$, $e_i:T_i$.
Class $T_0$ may have a set of one or more definitions of $foo$ with different numbers or types of arguments (but no two definitions may have the same number and same types of arguments.) There are no constraints on the return types of the definitions - return types are not considered in the selection algorithm. From this set $S_{foo}$ we choose a definition such that:
(1) the definition $foo(x_1:T_1',...,x_n:T_n'):T_r'$ has n arguments,
(2) for all $i \in [1,n]$, $T_i \leq T_i'$,
(3) for any other definition $foo(y_1:T_1'',...,y_n:T_n''):T_r''$ that satisfies (1) and (2) it is the case that for all $i \in [1,n]$, $T_i' \leq T_i''$.
If there is not a unique method that satisfies all three rules, then type checking fails.

The type rules in Cool have the form:
O,M,C $\vdash$ e: T
What parts of the type environment must be changed to support method overloading?
[Choose all that apply]

Using the definitions in Problem 6, consider a program with an overloaded method f. Assuming there are at least two definitions of f that have different signatures, what is the minimum number of definitions of f and number of arguments to f for the overloading resolution algorithm to possibly report that there is not a unique best choice of f?