% !TeX spellcheck = de_DE
\documentclass[11pt,a4paper,toc]{scrartcl}
\usepackage[a4paper,left=2.5cm,right=2.5cm,top=2.5cm,bottom=2.5cm]{geometry}
\usepackage[ngerman]{babel}
\usepackage{amssymb}
\usepackage{scrextend}
\usepackage[utf8]{inputenc}
\usepackage{amsmath}
\usepackage{enumitem}
\usepackage{mathtools}
\usepackage[load=named]{siunitx}
\usepackage{csquotes}
\usepackage[hidelinks]{hyperref}
%\usepackage{listings}
\usepackage{algorithmicx}
\usepackage{algpseudocode}
%\usepackage{pgfplots}
\usepackage{tikz}
%\usetikzlibrary{positioning}
%\usetikzlibrary{arrows.meta}
%\usetikzlibrary{quotes}
%\usetikzlibrary{angles}
%\usetikzlibrary{babel}
%\usetikzlibrary{fit}
%\usepackage{datetime}
%\usepackage{xcolor}

%\pdfminorversion=7 % Import-Unterstützung für PDFs bis Version 1.7
%\pgfplotsset{compat=1.16} % verhindern, dass pgfplots im Rückwärtskompatibilitätsmodus arbeitet


\setlist[enumerate,1]{label={\arabic*.}}
\setlist[enumerate,2]{label={\alph*)}}

\title{Grundlagen des Übersetzerbaus: Verfahren}
\author{Marco Ammon (my04mivo)}
\date{\today}

\begin{document}
\maketitle

\tableofcontents
\clearpage
\section{AST-Transformationen}

\subsection{Innere Klassen}
\begin{description}
	\item[innere Klasse:] in \texttt{Outer} enthaltene, nicht statische Klasse \texttt{Inner}
\end{description}

\begin{enumerate}
	\item flache Hierarchie durch Verschieben der inneren Klasse außerhalb der umgebenden Klasse(n): \texttt{Outer.Inner} $\rightarrow$ \texttt{Outer\$Inner}
	\item Konstruktor der inneren Klasse um Parameter ggf. erzeugen und um Parameter \texttt{Outer this\$i} ergänzen (mit $i$ als Schachtelungstiefe von \texttt{Outer}), zusätzlich gleichnamige Instanzvariable einfügen
	\item Zugriffen auf Instanzvariablen von \texttt{Outer} ein \texttt{this\$i.} voranstellen
	\item Hilfsmethoden für Zugriff auf private Instanzvariablen von \texttt{Outer} in \texttt{Outer} einfügen (mit aktueller Java-Version durch spezielles Attribut in Klassendatei nicht mehr notwendig)
	\item Alle Auftreten von \texttt{Inner} durch \texttt{Outer\$Inner} ersetzen
	\item Bei von \texttt{Inner} erbenden Klassen \texttt{(new Outer()).super();} im Konstruktor ergänzen, damit \text{Outer}-Instanz erzeugt wird
	\item Bei in Blöcken deklarierten inneren Klassen wird der Zugriff auf finale (oder \enquote{effectively-final}) Variablen durch Ergänzen des Konstruktors um diese Variablen ermöglicht
\end{enumerate}

\subsection{Generics}
\begin{enumerate}
	\item \enquote{Ausradieren} der Typen (\enquote{type erasure}):\begin{itemize}
		\item \texttt{GenericClass<TypeParameter>} $\rightarrow$ \texttt{GenericClass}
		\item Typ \texttt{A} bleibt gleich
		\item Typparameter \texttt{A} $\rightarrow$ \texttt{Object}
	\end{itemize}
	\item Brückenmethoden einfügen, die \texttt{Object} zu \texttt{A} casten und dann eigentliche Implementierung aufrufen
	\item Wenn Typparameter \texttt{A} einer Methode nicht aus den Argumenten ableitbar ist, Verwendung des abgeleiteten Typs \texttt{*}, der Untertyp aller Typen ist
\end{enumerate}

\section{Transformation zu Zwischensprache}
\begin{itemize}
	\item mehrdimensionale Arrays meistens zu eindimensionalen Array linearisiert
	\item Operatorenabbildung in \enquote{Post-Order}-Reihenfolge
	\item Kurzschlusssemantik: \begin{itemize}
		\item code(\texttt{a \&\& b}, $\texttt{L}_\texttt{true}$, $\texttt{L}_\texttt{false}$) $\rightarrow$ code(\texttt{a}, $\texttt{L1}$, $\texttt{L}_\texttt{false}$); \texttt{L1:} code(\texttt{b}, $\texttt{L}_\texttt{true}$, $\texttt{L}_\texttt{false}$)
		\item code(\texttt{a || b}, $\texttt{L}_\texttt{true}$, $\texttt{L}_\texttt{false}$) $\rightarrow$  code(\texttt{a}, $\texttt{L}_\texttt{true}$, $\texttt{L1}$); \texttt{L1:} code(\texttt{b}, $\texttt{L}_\texttt{true}$, $\texttt{L}_\texttt{false}$)
		\item  code(\texttt{!a}, $\texttt{L}_\texttt{true}$, $\texttt{L}_\texttt{false}$) $\rightarrow$ code(\texttt{a}, $\texttt{L}_\texttt{false}$, $\texttt{L}_\texttt{true}$
	\end{itemize}
	\item code(\texttt{while e do st od}) $\rightarrow$ $\texttt{jmp L}_\texttt{cond}$; $\texttt{L}_\texttt{true}$: code(\texttt{st}); $\texttt{L}_\texttt{cond}$: code(\texttt{e}, $\texttt{L}_\texttt{true}$, $\texttt{L}_\texttt{false}$); $\texttt{L}_\texttt{false}$:
	\item \texttt{switch-case}: \begin{itemize}
		\item \texttt{if}-Kaskade
		\item \texttt{lookupswitch}: Tabelle aus $(c_i, \texttt{L}_i)$-Tupel von Konstante $c_i$ und Sprungziel $\texttt{L}_i$ wird durchsucht
		\item \texttt{tableswitch}: Konstante wird als Index in Tabelle mit Sprungzielen (\enquote{jump table}) gewählt
	\end{itemize}
\end{itemize}

\section{Funktionsaufrufe}
\begin{enumerate}
	\item Vorbereitung: \begin{enumerate}
		\item Argumentauswertung gemäß Übergabemechanismus
		\item Sichern von Caller-Save-Registern auf dem Stack
		\item Argumente in Registern/auf dem Stack ablegen
		\item Funktionsaufruf
	\end{enumerate}
	\item Prolog: \begin{enumerate}
		\item Sichern des alten FP und Allokation des Stackframes
		\item Sichern von Callee-Save-Registern im Stackframe
	\end{enumerate}
	\item Funktionsrumpf
	\item Epilog: \begin{enumerate}
		\item Ablage des Rückgabewerts in Register/auf dem Stack
		\item Restauration von Callee-Save-Registern
		\item Freigabe des Stackframes und Restauration des FP
		\item Rückkehr
	\end{enumerate}
	\item Nachbereitung: \begin{enumerate}
		\item Abspeichern des Ergebnis an vorgesehener Stelle
		\item Entfernen der Argumente vom Stack
		\item Restauration der Caller-Save-Register
	\end{enumerate}
\end{enumerate}

\section{Geschachtelte Funktionen}
\begin{itemize}
	\item ohne Display: \begin{itemize}
		\item Aufruf der geschachtelte Funktion mit Zeiger auf Aktivierungsrahmen der umschließenden Funktion (sog. statischer Vorgängerverweis SV)
		\item bei Aufruf aus tieferer Schachtelungstiefe SV des Aufrufers ggf. bis zum relevanten Aktivierungsrahmen verfolgen
	\end{itemize}
	\item mit Display (gesondertes, globales Array) zur Speicherung der SV: \begin{itemize}
		\item Bei Betreten von Funktion der Schachtelungstiefe $t$, ihren FP an Index $t$ im Display speichern und ggf. bereits bestehenden Wert einer Schwesterfunktion im eigenen Aktivierungsrahmen sichern
		\item Durch statisch bekannte Schachtelungstiefe Größe des Displays zur Übersetzungszeit bekannt und Zugriff auf lokale Variablen aus umschließenden Kontext durch Dereferenzieren des SV aus statisch bekannter Position im Display
	\end{itemize}
	\item Funktionszeiger: auch Argumentwerte müssen mit Zeiger gespeichert werden
\end{itemize}

\section{Objekt-orientierte Sprachen}

\subsection{Methodenauswahl in Java}
\begin{enumerate}
	\item Bestimmung der Klasse (des Interfaces), in der nach Methode zu suchen ist
	\item Bestimmung der zu Argumenttypen passenden, anwendbaren/zugreifbaren Methoden \begin{enumerate}
		\item Auswahl der Methodendeklarationen, deren Parameter in Anzahl und Typ zu den statischen Argumenttypen passen
		\item Verwerfen der in Sichtbarkeit eingeschränkte Methoden
		\item Auswahl der spezifischsten Methode
	\end{enumerate}
	\item Kontextüberprüfung (z.B. statische Funktionen, \texttt{void} Rückgabetyp, etc.)
\end{enumerate}

\subsection{Einfachvererbung}
\begin{itemize}
	\item Attribute aus Oberklasse \texttt{O} liegen auch in Unterklasse \texttt{U} am selben statischen Offset zum Objektanfang $\rightarrow$ einfacher, statischer Zugriff
	\item Objekt enthält Zeiger auf Klassendeskriptor
	\item Klassendeskriptor enthält:\begin{itemize}
		\item V-Table mit Adressen der Funktionen(Indizes in Tabelle wie Attribute)
		\item Verweis auf Klassendeskriptor der Elternklasse
	\end{itemize}
	\item Dynamischer Methodenaufruf: \begin{enumerate}
		\item Verfolgung des Zeigers zum Klassendeskriptor
		\item Index in V-Table im Klassendeskriptor ist für auszuführende Methode bereits vom Compiler bekannt
		\item Indirekter Sprung
	\end{enumerate}
	\item Casts: \begin{itemize}
		\item Upcasts können vom Übersetzer verifiziert werden
		\item Downcasts müssen zur Laufzeit überprüft werden:\begin{itemize}
			\item ohne Display: \begin{enumerate}
				\item Verfolgung des Zeigers zum Klassendeskriptor
				\item Vergleich des Klassendeskriptors des Objekts mit Klassendeskriptor der Zielklasse
				\item Solange keine Übereinstimmung, Vergleich mit Klassendeskriptor der Elternklasse
				\item Beim Erreichen von gesuchtem Klassendeskriptor ist Casts erlaubt, ansonsten Laufzeitfehler
			\end{enumerate}
			\item mit Display: \begin{enumerate}
				\item (maximale) Vererbungstiefe statisch feststellbar $\rightarrow$ pro Klasse kann Array aus Oberklassen angelegt werden
				\item Zur Überprüfung in Array vergleichen, ob an (statisch aus der Schachtelungstiefe bekannter) Position der Zielklasse wirklich Zielklasse eingetragen ist
			\end{enumerate}
		\end{itemize}
	\end{itemize}
\end{itemize}	

\subsection{Interfaces}

\subsubsection{Dynamischer Methodenaufruf}

\subsubsection{Casts/Typprüfung zur Laufzeit}

\subsection{Mehrfachvererbung}

\subsubsection{Dynamischer Methodenaufruf}

\subsubsection{Casts/Typprüfung zur Laufzeit}

\section{Code-Selektion}

\subsection{Mit Registerzuteilung}

\subsubsection{Naiver Code-Generator}

\subsubsection{getreg}

\subsubsection{Sethi-Ullman-Algorithmus}

\subsection{Ohne Registerzuteilung}

\subsubsection{Baumtransformationen}

\subsubsection{Verfahren von Graham/Glanville}

\subsubsection{Dynamische Programmierung}

\section{Registerzuteilung}
%\printbibliography
\end{document}
