hws/hw08.tex
author Christian Urban <christian.urban@kcl.ac.uk>
Sat, 04 Nov 2023 18:28:09 +0000
changeset 953 5e070fb0332a
parent 941 66adcae6c762
child 956 ae9782e62bdd
permissions -rw-r--r--
updated

\documentclass{article}
\usepackage{../style}
\usepackage{../langs}
\usepackage{../graphics}

\begin{document}

\section*{Homework 8}

%%\HEADER

\begin{enumerate}
\item Write a program in the WHILE-language that calculates
      the factorial function.

\item What optimisations could a compiler perform when
      compiling a WHILE-program?

\item What is the main difference between the Java assembler
      (as processed by Jasmin) and Java Byte Code?

\item Remember symbolic labels in the Jasmin-assembler are meant to
      be used for jumps (like in loops or if-conditions). Assume
      you generated a Jasmin-file with some redundant
      labels, that is some labels are not used in your code for any jumps. For
      example \texttt{L\_begin} and \texttt{L\_end} are not used
      in the fol,lowing code-snippet:

\begin{lstlisting}[language=JVMIS,numbers=none]
L_begin:        
ldc 1
ldc 2
ldc 3
imul
ldc 4
ldc 3
isub
iadd
iadd
L_end:
\end{lstlisting}
      
      Do these redundant labels affect the size of the generated
      JVM-code? (Hint: What are the labels translated to by
      the Jasmin-assembler?).

      \solution{The answer is no. The reason is that assemblers
        calculate for labels either relative or explicit adresses,
        which are then used in the JVM-byte-code. Relative addresses
        are like ``jump 10 bytes forward'' or ``12 bytes backward''. So
      additional labels do not increase the size of the generated code.}

      
\item Consider the following Scala snippet. Are the two functions
\texttt{is\_even} and \texttt{is\_odd} tail-recursive?     

\begin{lstlisting}[numbers=none]
def is_even(n: Int) : Boolean = {
    if (n == 0) true else is_odd(n - 1)
}

def is_odd(n: Int) : Boolean = {
    if (n == 0) false 
    else if (n == 1) true else is_even(n - 1)
}
\end{lstlisting}
      
Do they cause stack-overflows when compiled to the JVM (for example by Scala)?


\item Explain what is meant by the terms lazy evaluation and eager
  evaluation.

\item \POSTSCRIPT    
\end{enumerate}

\end{document}

%%% Local Variables: 
%%% mode: latex
%%% TeX-master: t
%%% End: