Java-Bytecode.tex

%!TEX root = Programmierparadigmen.tex
\chapter{Java Bytecode}
\index{Java Bytecode|(}
\begin{definition}[Bytecode]\xindex{Bytecode}%
    Der Bytecode ist eine Sammlung von Befehlen für eine virtuelle Maschine.
\end{definition}

Bytecode ist unabhängig von realer Hardware.

\begin{definition}[Heap]\xindex{Heap}\xindex{Speicher!dynamischer}%
    Der dynamische Speicher, auch Heap genannt, ist ein Speicherbereich, aus dem
    zur Laufzeit eines Programms zusammenhängende Speicherabschnitte angefordert
    und in beliebiger Reihenfolge wieder freigegeben werden können.
\end{definition}

\textit{Activation Record} ist ein \textit{Stackframe}.\index{Activation Record|see{Stackframe}}
\section{Instruktionen}\xindex{imul@\texttt{imul}}\xindex{iadd@\texttt{iadd}}\xindex{fadd@\texttt{fadd}}\xindex{iaload@\texttt{iaload}}\xindex{faload@\texttt{faload}}\xindex{iastore@\texttt{iastore}}\xindex{fastore@\texttt{fastore}}\xindex{iconst\_<i>@\texttt{iconst\_<i>}}\xindex{fconst\_<f>@\texttt{fconst\_<f>}}\xindex{idiv@\texttt{idiv}}\xindex{fdiv@\texttt{fdiv}}\xindex{imul@\texttt{imul}}%
\begin{table}[h]
    \begin{tabular}{p{6cm}|ll}
    \textbf{Beschreibung}                               & \textbf{int} & \textbf{float} \\ \hline
    Addition                                            & iadd         & fadd           \\
    Element aus Array auf Stack packen                  & iaload       & faload         \\
    Element aus Stack in Array speichern                & iastore      & fastore        \\
    Konstante auf Stack legen                           & iconst\_<i>  & fconst\_<f> \\
    Divide second-from top by top                       & idiv         & fdiv           \\
    Multipliziere die obersten beiden Zahlen des Stacks & imul         & fmul           \\
    \end{tabular}
\end{table}

Weitere:\xindex{iload\_0@\texttt{iload\_0}}%

\begin{itemize}
    \item \texttt{iload\_0}: Läd die lokale Variable 0 auf den Stack.
    \item \texttt{iload\_1}: Läd die lokale Variable 1 auf den Stack.
    \item \texttt{iload\_2}: Läd die lokale Variable 2 auf den Stack.
    \item \texttt{iload\_3}: Läd die lokale Variable 3 auf den Stack.
\end{itemize}

\subsection{if-Abfragen}\xindex{if\_icmp<comperator>@\texttt{if\_icmp<comperator>}}%
Im Java-Bytecode gibt es einige verschiedene if-Abfragen. Diese sind immer nach
dem Schema \texttt{<if> <label>} aufgebaut. Wenn also \texttt{<if>} wahr ist,
wird zu \texttt{<label>} gesprungen.

Im Folgenden sei $a$ tiefer im Stack als $b$. Die Operation \texttt{push(a)} wurde also
vor \texttt{push(b)} durchgeführt.

Eine Gruppe von if-Abfragen hat folgendes Schema:

\begin{center}
    \texttt{if\_icmp<comperator> <label>}
\end{center}

Dabei steht das erste \texttt{i} für \enquote{integer} und \texttt{cmp} für
\enquote{compare}. \texttt{<comperator>} kann folgende Werte annehmen:

\xindex{eq@\texttt{eq}}\xindex{ge@\texttt{ge}}\xindex{gt@\texttt{gt}}\xindex{le@\texttt{le}}
\xindex{lt@\texttt{lt}}\xindex{ne@\texttt{ne}}%
\begin{itemize}
    \item \texttt{eq}: equal -- $a == b$
    \item \texttt{ge}: greater equal -- $a \ge b$
    \item \texttt{gt}: greater than -- $a > b$
    \item \texttt{le}: less equal -- $a \le b$
    \item \texttt{lt}: less than -- $a < b$
    \item \texttt{ne}: not equal -- $a \neq b$
\end{itemize}

Weitere if-Abfragen haben das Schema

\begin{center}
    \texttt{if<comperator>} -- $b \text{\texttt{<comperator>}} 0$
\end{center}

\subsection{Konstanten}\xindex{iconst\_<i>@\texttt{iconst\_<i>}}\xindex{iconst\_m1@\texttt{iconst\_m1}}%
\begin{itemize}
    \item \texttt{iconst\_m1}: Lade -1 auf den Stack
    \item \texttt{iconst\_<i>}, wobei \texttt{<i>} die Werte 0, 1, 2, 3, 4, 5
          annehmen kann.
\end{itemize}


\section{Weiteres}
\xindex{aload\_<i>@\texttt{aload\_<i>}}\xindex{invokevirtual@\texttt{invokevirtual}}
\begin{itemize}
    \item \texttt{aload\_<i>} wobei \texttt{<i>} entweder 0, 1, 2 oder 3 ist: Lade eine
          Referenz von einer lokalen Variable \texttt{<i>} auf den Stack.
    \item \texttt{invokevirtual}: Rufe die Methode auf, die auf dem Stack liegt,
          wobei die Objektreferenz direkt darunter auf dem Stack liegen muss.
\end{itemize}

\section{Polnische Notation}
\begin{definition}[Schreibweise von Rechenoperationen]
    Sei $f: A \times B \rightarrow C$ eine Funktion, $a \in A$ und $b \in B$.

    \begin{defenum}
        \item Die Schreibweise $a\ f\ b$ heißt \textbf{Infix-Notation}\xindex{Infix-Notation}.
        \item Die Schreibweise $f\ a\ b$ heißt \textbf{Präfixnotation}\xindex{Präfixnotation}
        \item Die Schreibweise $a\ b\ f$ heißt \textbf{Postfixnotation}\xindex{Postfixnotation}.
    \end{defenum}
\end{definition}

\textit{Polnische Notation}\index{Notation!polnische|see{Präfixnotation}} ist ein Synonym für die Präfixnotation.

\textit{Umgekehrte polnische Notation}\index{Notation!umgekehrte polnische|see{Postfixnotation}} ist ein Synonym für die Postfixnotation.

\begin{beispiel}[Schreibweise von Rechenoperationen]
    \begin{bspenum}
        \item $1 + 2$ nutzt die Infix-Notation.
        \item $f\ a\ b$ nutzt die polnische Notation.
        \item Wir der Ausdruck $1 + 2 \cdot 3$ in Infix-Notation ohne Operatoren-Präzedenz
              ausgewertet, so gilt:
              \[1 + 2 \cdot 3 = 9\]
              Wird er mit Operatoren-Präzendenz ausgewertet, so gilt:
              \[1 + 2 \cdot 3 = 7\]
        \item Der Ausdruck
              \[1 + 2 \cdot 3 = 7\]
              entspricht
              \[+\ 1\ \cdot\ 2\ 3\]
              in der polnischen Notation und
              \[1\ 2\ 3\ \cdot\ +\]
              in der umgekehrten polnischen Notation.
    \end{bspenum}
\end{beispiel}

\begin{bemerkung}[Eigenschaften der Prä- und Postfixnotation]
    \begin{bemenum}
        \item Die Reihenfolge der Operanden kann beibehalten und gleichzeitig
              auf Klammern verzichtet werden, ohne dass sich das Ergebnis
              verändert.
        \item Die Infix-Notation kann in einer Worst-Case Laufzeit von $\mathcal{O}(n)$,
              wobei $n$ die Anzahl der Tokens ist mittels des
              \textit{Shunting-yard-Algorithmus}\xindex{Shunting-yard-Algorithmus} in
              die umgekehrte Polnische Notation überführt werden.
    \end{bemenum}
\end{bemerkung}

\section{Weitere Informationen}
\begin{itemize}
    \item \url{https://en.wikipedia.org/wiki/Java_bytecode_instruction_listings}
    \item \url{http://cs.au.dk/~mis/dOvs/jvmspec/ref-Java.html}
    \item \href{http://scanftree.com/Data_Structure/prefix-postfix-infix-online-converter}{scanftree.com}:
          Infix $\leftrightarrow$ Postfix Konverter
\end{itemize}
\index{Java Bytecode|)}