UE1-Verfahren/verfahren.tex

% !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{Vererbung mit Interfaces}
\begin{itemize}
	\item Statische Bestimmung der V-Table-Indizes nicht mehr möglich
	\item Pro Kombination aus Klasse \texttt{A} und Interface \texttt{I} wird eine Interface-V-Table \texttt{A:I} angelegt, in der Interface-Funktionen an statisch bekannten Indizes liegen:\begin{itemize}
		\item Interface-V-Table enthält Verweis auf Klassendeskriptor von \texttt{A}
		\item Da von Klasse implementierte Funktionen erwarten, dass \texttt{this} auf Objektbeginn zeigt, müssen Hilfsmethoden, die \texttt{this} korrigieren, erstellt und in die Interface-V-Table eingetragen werden
	\end{itemize}
	\item Objekt enthält \enquote{hinter} Attributen noch Verweise auf alle assoziierten Interface-V-Tables
	\item Klassendeskriptor enthält Anzahl der von einer Klasse implementierten Interfaces sowie Verweis auf Interface-Tabelle der Klasse
	\item Interface-Tabelle enthält Tripel aus (Offset, Verweis auf Interface-Deskriptor, Verweis auf Interface-V-Table) für alle von Klasse implementierten Interfaces: \begin{itemize}
		\item Offset gibt Offset von Verweis auf jeweilige Interface-V-Table zum Anfang des Objekts an
	\end{itemize}
	\item Dynamischer Methodenaufruf falls statischer Typ Interface ist (sonst wie bei Einfachvererbung):\begin{enumerate}
		\item Hilfsmethode mit statisch bekanntem Offset in der Interface-V-Table nachschlagen
		\item Hilfsmethode verschiebt \texttt{this}-Zeiger um statisch bekannten Offset auf Objektanfang und ruft statisch bekannte, in \texttt{A} implementierte Methode auf
	\end{enumerate}
	\item Casts:\begin{itemize}
		\item Klasse $\rightarrow$ Interface:\begin{enumerate}
			\item Objektzeiger zu Klassendeskriptor zu Interface-Tabelle verfolgen
			\item In Interface-Tabelle nach Eintrag für Interface suchen (ggf. komplettes Durchlaufen)
			\item Im Erfolgsfall ist Cast gültig, sonst Laufzeitfehler
			\item Referenz für neue Variable aus Objektanfang + zu Interface gehörigem Offset aus Interface-Tabelle bestimmen
		\end{enumerate}
		\item Interface $\rightarrow$ Klasse:\begin{enumerate}
			\item Objektzeiger zu Interface-V-Table zu Klassendeskriptor verfolgen
			\item Falls Klassendeskriptor nicht Zielklasse entspricht, Verfolgung zu Oberklasse(n)
			\item Im Erfolgsfall ist Cast gültig, sonst Laufzeitfehler
			\item Zeiger von Klassendeskriptor zu Interface-Tabelle verfolgen
			\item In Interface-Tabelle Eintrag für Interface nachschlagen (garantiert vorhanden)
			\item Referenz für neue Variable aus aktuellem Zeiger - zu Interface gehörigem Offset aus Interface-Tabelle bestimmen
		\end{enumerate}
	\end{itemize}
	\item Interface mit Standardimplementierung:\begin{itemize}
		\item Wird Standardimplementierung verwendet, muss der Objektzeiger beim Aufruf mit Interface als statischem Typ nicht korrigiert werden; allerdings ist Hilfsmethode anzulegen und in Klassen-V-Table einzutragen
	\end{itemize}
	\item Interface mit veränderlichem Zustand:\begin{itemize}
		\item Implementierende Klassen erhalten Instanzvariablen des Interfaces als eigene Instanzvariablen
		\item Interface hat implizite Getter-/Setter-Methjoden, die von Klasse implementiert werden
	\end{itemize}
\end{itemize}

\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}