|
|
@@ -5101,7 +5101,7 @@ of the \key{if} is taken. The element at index $0$ of \code{t} is
|
|
|
&\mid& (\key{vector}\;\Exp^{+})
|
|
|
\mid (\key{vector-ref}\;\Exp\;\Int) \\
|
|
|
&\mid& (\key{vector-set!}\;\Exp\;\Int\;\Exp)\\
|
|
|
- &\mid& (\key{void}) \\
|
|
|
+ &\mid& (\key{void}) \mid (\key{has-type}~\Exp~\Type)\\
|
|
|
R_3 &::=& \Exp
|
|
|
\end{array}
|
|
|
\]
|
|
|
@@ -5145,7 +5145,7 @@ of the \key{if} is taken. The element at index $0$ of \code{t} is
|
|
|
&\mid& \VECTOR{\Exp} \\
|
|
|
&\mid& \VECREF{\Exp}{\Int}\\
|
|
|
&\mid& \VECSET{\Exp}{\Int}{\Exp}\\
|
|
|
- &\mid& \VOID{} \\
|
|
|
+ &\mid& \VOID{} \mid \LP\key{HasType}~\Exp~\Type \RP \\
|
|
|
R_3 &::=& \PROGRAM{\key{'()}}{\Exp}
|
|
|
\end{array}
|
|
|
\]
|
|
|
@@ -5627,7 +5627,7 @@ $R_3$ with the three new forms that we use in the translation of the
|
|
|
\Exp &::=& \cdots
|
|
|
\mid (\key{collect} \,\itm{int})
|
|
|
\mid (\key{allocate} \,\itm{int}\,\itm{type})
|
|
|
- \mid (\key{global-value} \,\itm{name})
|
|
|
+ \mid (\key{global} \,\itm{name})
|
|
|
\end{array}
|
|
|
\]
|
|
|
The $(\key{collect}\,n)$ form runs the garbage collector, requesting
|
|
|
@@ -5636,7 +5636,7 @@ $n$ bytes. It will become a call to the \code{collect} function in
|
|
|
$(\key{allocate}\,n\,T)$ form creates an tuple of $n$ elements. The
|
|
|
$T$ parameter is the type of the tuple: \code{(Vector $\Type_1 \ldots
|
|
|
\Type_n$)} where $\Type_i$ is the type of the $i$th element in the
|
|
|
-tuple. The $(\key{global-value}\,\itm{name})$ form reads the value of
|
|
|
+tuple. The $(\key{global}\,\itm{name})$ form reads the value of
|
|
|
a global variable, such as \code{free\_ptr}.
|
|
|
|
|
|
In the following, we show the transformation for the \code{vector}
|
|
|
@@ -5650,8 +5650,8 @@ vector, which is 8 for the tag plus \itm{len} times 8.
|
|
|
(has-type (vector |$e_0 \ldots e_{n-1}$|) |\itm{type}|)
|
|
|
|$\Longrightarrow$|
|
|
|
(let ([|$x_0$| |$e_0$|]) ... (let ([|$x_{n-1}$| |$e_{n-1}$|])
|
|
|
- (let ([_ (if (< (+ (global-value free_ptr) |\itm{bytes}|)
|
|
|
- (global-value fromspace_end))
|
|
|
+ (let ([_ (if (< (+ (global free_ptr) |\itm{bytes}|)
|
|
|
+ (global fromspace_end))
|
|
|
(void)
|
|
|
(collect |\itm{bytes}|))])
|
|
|
(let ([|$v$| (allocate |\itm{len}| |\itm{type}|)])
|
|
|
@@ -5711,7 +5711,7 @@ Figure~\ref{fig:expose-alloc-output} shows the output of the
|
|
|
\section{Remove Complex Operands}
|
|
|
\label{sec:remove-complex-opera-R2}
|
|
|
|
|
|
-The new forms \code{collect}, \code{allocate}, and \code{global-value}
|
|
|
+The new forms \code{collect}, \code{allocate}, and \code{global}
|
|
|
should all be treated as complex operands. A new case for
|
|
|
\code{HasType} is needed and the case for \code{Prim} needs to be
|
|
|
handled carefully to prevent the \code{Prim} node from being separated
|
|
|
@@ -5721,6 +5721,32 @@ from its enclosing \code{HasType}.
|
|
|
\section{Explicate Control and the $C_2$ language}
|
|
|
\label{sec:explicate-control-r3}
|
|
|
|
|
|
+\begin{figure}[tbp]
|
|
|
+\fbox{
|
|
|
+\begin{minipage}{0.96\textwidth}
|
|
|
+\small
|
|
|
+\[
|
|
|
+\begin{array}{lcl}
|
|
|
+\Atm &::=& \gray{ \Int \mid \Var \mid \itm{bool} } \\
|
|
|
+\itm{cmp} &::= & \gray{ \key{eq?} \mid \key{<} } \\
|
|
|
+\Exp &::=& \gray{ \Atm \mid \key{(read)} \mid \key{(-}~\Atm\key{)} \mid \key{(+}~\Atm~\Atm\key{)} } \\
|
|
|
+ &\mid& \gray{ \LP \key{not}~\Atm \RP \mid \LP \itm{cmp}~\Atm~\Atm\RP } \\
|
|
|
+&\mid& \LP \key{allocate}~\Int~\Type \RP \\
|
|
|
+ &\mid& (\key{vector-ref}\;\Atm\;\Int) \mid (\key{vector-set!}\;\Atm\;\Int\;\Atm)\\
|
|
|
+ &\mid& \LP \key{global}~\Var \RP \mid \LP \key{void} \RP \\
|
|
|
+\Stmt &::=& \gray{ \Var~\key{=}~\Exp\key{;} } \mid \LP\key{collect}~\Int \RP\\
|
|
|
+\Tail &::= & \gray{ \key{return}~\Exp\key{;} \mid \Stmt~\Tail }
|
|
|
+ \mid \gray{ \key{goto}~\itm{label}\key{;} }\\
|
|
|
+ &\mid& \gray{ \key{if}~\LP \itm{cmp}~\Atm~\Atm \RP~ \key{goto}~\itm{label}\key{;} ~\key{else}~\key{goto}~\itm{label}\key{;} } \\
|
|
|
+C_2 & ::= & \gray{ (\itm{label}\key{:}~ \Tail)^{+} }
|
|
|
+\end{array}
|
|
|
+\]
|
|
|
+\end{minipage}
|
|
|
+}
|
|
|
+\caption{The concrete syntax of the $C_2$ intermediate language.}
|
|
|
+\label{fig:c2-concrete-syntax}
|
|
|
+\end{figure}
|
|
|
+
|
|
|
\begin{figure}[tp]
|
|
|
\fbox{
|
|
|
\begin{minipage}{0.96\textwidth}
|
|
|
@@ -5735,13 +5761,13 @@ from its enclosing \code{HasType}.
|
|
|
&\mid& (\key{Allocate} \,\itm{int}\,\itm{type}) \\
|
|
|
&\mid& \BINOP{\key{'vector-ref}}{\Atm}{\Int} \\
|
|
|
&\mid& (\key{Prim}~\key{'vector-set!}\,(\key{list}\,\Atm\,\Int\,\Atm))\\
|
|
|
- &\mid& (\key{GlobalValue} \,\itm{name}) \mid (\key{Void})\\
|
|
|
+ &\mid& (\key{GlobalValue} \,\Var) \mid (\key{Void})\\
|
|
|
\Stmt &::=& \gray{ \ASSIGN{\VAR{\Var}}{\Exp} }
|
|
|
\mid (\key{Collect} \,\itm{int}) \\
|
|
|
\Tail &::= & \gray{ \RETURN{\Exp} \mid \SEQ{\Stmt}{\Tail}
|
|
|
\mid \GOTO{\itm{label}} } \\
|
|
|
&\mid& \gray{ \IFSTMT{\BINOP{\itm{cmp}}{\Atm}{\Atm}}{\GOTO{\itm{label}}}{\GOTO{\itm{label}}} }\\
|
|
|
-C_2 & ::= & \PROGRAM{\itm{info}}{\CFG{(\itm{label}\,\key{.}\,\Tail)^{+}}}
|
|
|
+C_2 & ::= & \gray{ \PROGRAM{\itm{info}}{\CFG{(\itm{label}\,\key{.}\,\Tail)^{+}}} }
|
|
|
\end{array}
|
|
|
\]
|
|
|
\end{minipage}
|
|
|
@@ -5752,10 +5778,11 @@ C_2 & ::= & \PROGRAM{\itm{info}}{\CFG{(\itm{label}\,\key{.}\,\Tail)^{+}}}
|
|
|
\end{figure}
|
|
|
|
|
|
The output of \code{explicate-control} is a program in the
|
|
|
-intermediate language $C_2$, whose abstract syntax is defined in
|
|
|
-Figure~\ref{fig:c2-syntax}. The new forms of $C_2$ include the
|
|
|
-\key{allocate}, \key{vector-ref}, and \key{vector-set!}, and
|
|
|
-\key{global-value} expressions and the \code{collect} statement. The
|
|
|
+intermediate language $C_2$, whose concrete syntax is defined in
|
|
|
+Figure~\ref{fig:c2-concrete-syntax} and whose abstract syntax is
|
|
|
+defined in Figure~\ref{fig:c2-syntax}. The new forms of $C_2$ include
|
|
|
+the \key{allocate}, \key{vector-ref}, and \key{vector-set!}, and
|
|
|
+\key{global} expressions and the \code{collect} statement. The
|
|
|
\code{explicate-control} pass can treat these new forms much like the
|
|
|
other forms.
|
|
|
|
|
|
@@ -5839,12 +5866,12 @@ start:
|
|
|
%% collect (callq collect)
|
|
|
%% vector-ref
|
|
|
%% vector-set!
|
|
|
-%% global-value (postpone)
|
|
|
+%% global (postpone)
|
|
|
|
|
|
In this pass we generate x86 code for most of the new operations that
|
|
|
-were needed to compile tuples, including \code{allocate},
|
|
|
-\code{collect}, \code{vector-ref}, \code{vector-set!}, and
|
|
|
-\code{(void)}. We postpone \code{global-value} to \code{print-x86}.
|
|
|
+were needed to compile tuples, including \code{Allocate},
|
|
|
+\code{Collect}, \code{vector-ref}, \code{vector-set!}, and
|
|
|
+\code{void}. We postpone \code{GlobalValue} to \code{print-x86}.
|
|
|
|
|
|
The \code{vector-ref} and \code{vector-set!} forms translate into
|
|
|
\code{movq} instructions with the appropriate \key{deref}. (The
|
|
|
@@ -5882,8 +5909,8 @@ pointer mask region of the tag.
|
|
|
\begin{lstlisting}
|
|
|
(assign |$\itm{lhs}$| (allocate |$\itm{len}$| (Vector |$\itm{type} \ldots$|)))
|
|
|
|$\Longrightarrow$|
|
|
|
- (movq (global-value free_ptr) |$\itm{lhs}'$|)
|
|
|
- (addq (int |$8(\itm{len}+1)$|) (global-value free_ptr))
|
|
|
+ (movq (global free_ptr) |$\itm{lhs}'$|)
|
|
|
+ (addq (int |$8(\itm{len}+1)$|) (global free_ptr))
|
|
|
(movq |$\itm{lhs}'$| (reg r11))
|
|
|
(movq (int |$\itm{tag}$|) (deref r11 0))
|
|
|
\end{lstlisting}
|
|
|
@@ -5911,7 +5938,7 @@ the register allocator.
|
|
|
\Arg &::=& \gray{ \INT{\Int} \mid \REG{\Reg}
|
|
|
\mid (\key{deref}\,\Reg\,\Int) } \\
|
|
|
&\mid& \gray{ (\key{byte-reg}\; \Reg) }
|
|
|
- \mid (\key{global-value}\; \itm{name}) \\
|
|
|
+ \mid (\key{global}\; \itm{name}) \\
|
|
|
\itm{cc} & ::= & \gray{ \key{e} \mid \key{l} \mid \key{le} \mid \key{g} \mid \key{ge} } \\
|
|
|
\Instr &::=& \gray{(\key{addq} \; \Arg\; \Arg) \mid
|
|
|
(\key{subq} \; \Arg\; \Arg) \mid
|
|
|
@@ -5960,18 +5987,18 @@ Figure~\ref{fig:select-instr-output-gc} shows the output of the
|
|
|
(jmp block61)))
|
|
|
(block62 . (block () (movq (int 0) (var collectret46)) (jmp block61)))
|
|
|
(block61 . (block ()
|
|
|
- (movq (global-value free_ptr) (var alloc43))
|
|
|
- (addq (int 16) (global-value free_ptr))
|
|
|
+ (movq (global free_ptr) (var alloc43))
|
|
|
+ (addq (int 16) (global free_ptr))
|
|
|
(movq (var alloc43) (reg r11))
|
|
|
(movq (int 3) (deref r11 0))
|
|
|
(movq (var alloc43) (reg r11))
|
|
|
(movq (var vecinit44) (deref r11 8))
|
|
|
(movq (int 0) (var initret45))
|
|
|
(movq (var alloc43) (var vecinit48))
|
|
|
- (movq (global-value free_ptr) (var tmp54))
|
|
|
+ (movq (global free_ptr) (var tmp54))
|
|
|
(movq (var tmp54) (var tmp55))
|
|
|
(addq (int 16) (var tmp55))
|
|
|
- (movq (global-value fromspace_end) (var tmp56))
|
|
|
+ (movq (global fromspace_end) (var tmp56))
|
|
|
(cmpq (var tmp56) (var tmp55))
|
|
|
(jmp-if l block59)
|
|
|
(jmp block60)))
|
|
|
@@ -5984,8 +6011,8 @@ Figure~\ref{fig:select-instr-output-gc} shows the output of the
|
|
|
(movq (int 0) (var collectret50))
|
|
|
(jmp block58)))
|
|
|
(block58 . (block ()
|
|
|
- (movq (global-value free_ptr) (var alloc47))
|
|
|
- (addq (int 16) (global-value free_ptr))
|
|
|
+ (movq (global free_ptr) (var alloc47))
|
|
|
+ (addq (int 16) (global free_ptr))
|
|
|
(movq (var alloc47) (reg r11))
|
|
|
(movq (int 131) (deref r11 0))
|
|
|
(movq (var alloc47) (reg r11))
|
|
|
@@ -5998,10 +6025,10 @@ Figure~\ref{fig:select-instr-output-gc} shows the output of the
|
|
|
(jmp conclusion)))
|
|
|
(start . (block ()
|
|
|
(movq (int 42) (var vecinit44))
|
|
|
- (movq (global-value free_ptr) (var tmp51))
|
|
|
+ (movq (global free_ptr) (var tmp51))
|
|
|
(movq (var tmp51) (var tmp52))
|
|
|
(addq (int 16) (var tmp52))
|
|
|
- (movq (global-value fromspace_end) (var tmp53))
|
|
|
+ (movq (global fromspace_end) (var tmp53))
|
|
|
(cmpq (var tmp53) (var tmp52))
|
|
|
(jmp-if l block62)
|
|
|
(jmp block63))))))
|
|
|
@@ -6059,7 +6086,7 @@ stack.
|
|
|
|
|
|
|
|
|
\margincomment{\scriptsize We need to show the translation to x86 and what
|
|
|
- to do about global-value. \\ --Jeremy}
|
|
|
+ to do about global. \\ --Jeremy}
|
|
|
|
|
|
Figure~\ref{fig:print-x86-output-gc} shows the output of the
|
|
|
\code{print-x86} pass on the running example. In the prelude and
|
|
|
@@ -6887,7 +6914,7 @@ the function definitions.
|
|
|
\mid (\key{not}\;\Arg) \mid (\itm{cmp}\;\Arg\;\Arg) } \\
|
|
|
&\mid& \gray{ (\key{allocate}\,\Int\,\Type)
|
|
|
\mid (\key{vector-ref}\, \Arg\, \Int) } \\
|
|
|
- &\mid& \gray{ (\key{vector-set!}\,\Arg\,\Int\,\Arg) \mid (\key{global-value} \,\itm{name}) \mid (\key{void}) } \\
|
|
|
+ &\mid& \gray{ (\key{vector-set!}\,\Arg\,\Int\,\Arg) \mid (\key{global} \,\itm{name}) \mid (\key{void}) } \\
|
|
|
&\mid& (\key{fun-ref}\,\itm{label}) \mid (\key{call} \,\Arg\,\Arg^{*}) \\
|
|
|
\Stmt &::=& \gray{ \ASSIGN{\Var}{\Exp} \mid \RETURN{\Exp}
|
|
|
\mid (\key{collect} \,\itm{int}) }\\
|
|
|
@@ -6928,7 +6955,7 @@ language, whose syntax is defined in Figure~\ref{fig:x86-3}.
|
|
|
\Arg &::=& \gray{ \INT{\Int} \mid \REG{\Reg}
|
|
|
\mid (\key{deref}\,\Reg\,\Int) } \\
|
|
|
&\mid& \gray{ (\key{byte-reg}\; \Reg)
|
|
|
- \mid (\key{global-value}\; \itm{name}) } \\
|
|
|
+ \mid (\key{global}\; \itm{name}) } \\
|
|
|
&\mid& (\key{fun-ref}\; \itm{label})\\
|
|
|
\itm{cc} & ::= & \gray{ \key{e} \mid \key{l} \mid \key{le} \mid \key{g} \mid \key{ge} } \\
|
|
|
\Instr &::=& \gray{ (\key{addq} \; \Arg\; \Arg) \mid
|
Jeremy Siek