Virtual machine code

Example 1: int -> int case

let rec f x = x + 1 in p(f 5)

Asm.Prog ([],
 [{Asm.name = L "f.4"; args = ["x.5"]; fargs = [];
   body = Asm.Let (("Ti3.8", Int), Set 1, Ans (Asm.Add ("x.5", V "Ti3.8")));
   ret = Int}],
 Asm.Let (("Ti1.7", Int), Set 5,
  Asm.Let (("Ti2.6", Int), CallDir (L "f.4", ["Ti1.7"], []),
   Ans (CallDir (L "min_caml_p", ["Ti2.6"], [])))))

f.4(x.5) {
  Ti3.8 <- 1;
  return x.5 + Ti3.8;
}
Ti1.7 <- 5;
Ti2.6 <- f.4(Ti1.7);
return min_caml_p(Ti2.6);

Example 2: float -> float case

let rec f x = x +. 3.141592 in p(f 1.23456789)    (* is translated to *)

Asm.Prog ([(L "l.11", 1.23456789); (L "l.9", 3.141592)],
 [{Asm.name = L "f.4"; args = []; fargs = ["x.5"];
   body =
    Asm.Let (("l.10", Int), SetL (L "l.9"),
     Asm.Let (("Td3.8", Float), LdDF ("l.10", C 0, 1),
      Ans (FAddD ("x.5", "Td3.8"))));
   ret = Float}],
 Asm.Let (("l.12", Int), SetL (L "l.11"),
  Asm.Let (("Td1.7", Float), LdDF ("l.12", C 0, 1),
   Asm.Let (("Td2.6", Float), CallDir (L "f.4", [], ["Td1.7"]),
    Ans (CallDir (L "min_caml_p", [], ["Td2.6"]))))))

FP: {l.11: 1.23456789, l.9: 3.141592};
f.4( ; x.5) {
  l.10 <- FP[l.9];
  Td3.8 <- FP[l.10]
}

“Virtual” Format

\[\begin {align} {\cal V}^p &: \text {Closure.prog} \rightarrow \text {SparcAsm.prog} \\ {\cal V}^f &: \text {Closure.fundef} \rightarrow \text {SparcAsm.fundef} \\ {\cal V}^e &: \text {Closure.t} \rightarrow \text {Type.t M.t} \rightarrow \text {SparcAsm.t} \end {align}\]

Caption of Fig 18

• Variables that occur in RHS but not in LHS are fresh.

• \(\mathtt {R_{hp}}\) is a register specifically used as heap pointer.

• \(e_1; e_2\) is a short hand notation for \(x \leftarrow e_1; e_2\).

• \(x \leftarrow E_1; E_2\) is a short hand notation for \(x_1 \rightarrow e_1; \ldots; x_n \rightarrow e_n; E_2\), where \((x_1 \rightarrow e_1; \ldots; x_n \rightarrow e_n; E_2) = E_1\).

V-Code for a Function

\[\begin {align} {\cal V}^F&(\mathtt {L_x}(y_1, \ldots, y_m)(z_1, \ldots, z_n) = e) = \\ & \mathtt {L_x}(y_1, \ldots, y_m) = \\ & z_1 \leftarrow \mathtt R_0.(4); \quad \ldots; \quad z=n \leftarrow \mathtt R_0.(4n); \\ & {\cal V}^e(e) \end {align}\]

• The implementation is a bit more complicated: Offsets into \(\mathtt R_0\) takes in account different sizes of int and float values (four and eight, respectively).

V-Code for Tupple Creation

\[\begin {align} {\cal V}^e&((x_1, \ldots, x_n)) =\\ & y \leftarrow \mathtt {R_{hp}}; \quad \mathtt {R_{hp}} \leftarrow \mathtt {R_{hp}} + 4n; \\ & y.(0) \leftarrow x_1; \quad \ldots; \quad y.(4(n - 1)) \leftarrow x_n; \\ & y \end {align}\]

• \(y\) is a fresh register

V-Code for make_closure

\[\begin {align} {\cal V}^e&(\mathit {make\_closure}\ x = (\mathtt {L_x}, (y_1, \ldots, y_m)) \text { in } e) \\ & x \leftarrow \mathtt {R_{hp}}; \quad \mathtt {R_{hp}} \leftarrow \mathtt {R_{hp}} + r(n + 1); \\ & z \leftarrow \mathtt L_x; \\ & x.(0) \leftarrow z; \\ & x.(1) \leftarrow y_1; \quad \ldots; \quad x.(m) \leftarrow y_m; \\ & {\cal V}^e(e) \end {align}\]

• \(z\) is a fresh register

V-Code for let

\[\begin {align} {\cal V}^e &(\text {let } x = e_1 \text { in } e_2) = \\ & x \leftarrow {\cal V}(e_1) \\ & {\cal V}(e_2) \end {align}\]

V-Code for let tuple

\[\begin {align} {\cal V}^e &(\text {let }(x_1, \ldots, x_n) = y \text { in } e) = \\ & x_{i_1} \leftarrow y.(4(i_1 - 1)); \\ & \ldots \\ & x_{i_m} \leftarrow y.(4(i_m - 1)); \\ & \text {where } \{x_{i_1}, \ldots, x_{i_m}\} = \{x_1, \ldots, x_n\} \cap \mathit {FV}(e) \end {align}\]

V-Code for Array Access

\[\begin {align} {\cal V}& (x.(y)) = \\ & y' \leftarrow 4 y; \\ & x.(y') \\ \\ {\cal V}& (x.(y) \leftarrow z) = \\ & y' \leftarrow 4 y; \\ & x.(y') \leftarrow z \end {align}\]