Vortragsfolien und Beispiele 17.5.2021

20210517/Makefile

+%.s: %.c
+	avr-gcc -Wall -Os -mmcu=atmega328p $< -S -o $@
+
+%.elf: %.c
+	avr-gcc -Wall -Os -mmcu=atmega328p $< -o $@
+
+%.hex: %.elf
+	avr-objcopy -O ihex $< $@
+
+download:
+	./download.sh

20210517/add-1.c

+#include <stdio.h>
+
+int main (void)
+{
+  int a = 7;
+  int b = 13;
+  int c = a + b;
+  printf ("%d + %d = %d\n", a, b, c);
+  return 0;
+}

20210517/add-1.s

+	.file	"add-1.c"
+	.text
+	.section	.rodata.str1.1,"aMS",@progbits,1
+.LC0:
+	.string	"%d + %d = %d\n"
+	.text
+	.globl	main
+	.type	main, @function
+main:
+.LFB11:
+	.cfi_startproc
+	subq	$8, %rsp
+	.cfi_def_cfa_offset 16
+	movl	$20, %ecx
+	movl	$13, %edx
+	movl	$7, %esi
+	leaq	.LC0(%rip), %rdi
+	movl	$0, %eax
+	call	printf@PLT
+	movl	$0, %eax
+	addq	$8, %rsp
+	.cfi_def_cfa_offset 8
+	ret
+	.cfi_endproc
+.LFE11:
+	.size	main, .-main
+	.ident	"GCC: (Debian 8.3.0-6) 8.3.0"
+	.section	.note.GNU-stack,"",@progbits

20210517/blink-2.c

+#include <avr/io.h>
+
+#define F_CPU 16000000l
+#include <util/delay.h>
+
+int main (void)
+{
+  DDRD = 0x40;
+  while (1)
+    {
+      PORTD |= 0x40;
+      _delay_ms (500);
+      PORTD &= ~0x40;
+      _delay_ms (500);
+    }
+  return 0;
+}

20210517/blink-2.hex

+:100000000C9434000C943E000C943E000C943E0082
+:100010000C943E000C943E000C943E000C943E0068
+:100020000C943E000C943E000C943E000C943E0058
+:100030000C943E000C943E000C943E000C943E0048
+:100040000C943E000C943E000C943E000C943E0038
+:100050000C943E000C943E000C943E000C943E0028
+:100060000C943E000C943E0011241FBECFEFD8E04C
+:10007000DEBFCDBF0E9440000C9451000C940000E4
+:1000800080E48AB98BB990E42FEF34E38CE02150FF
+:1000900030408040E1F700C000008BB189278BB968
+:0600A000F3CFF894FFCF3E
+:00000001FF

20210517/blink-2.s

+	.file	"blink-2.c"
+__SP_H__ = 0x3e
+__SP_L__ = 0x3d
+__SREG__ = 0x3f
+__tmp_reg__ = 0
+__zero_reg__ = 1
+	.section	.text.startup,"ax",@progbits
+.global	main
+	.type	main, @function
+main:
+/* prologue: function */
+/* frame size = 0 */
+/* stack size = 0 */
+.L__stack_usage = 0
+	ldi r24,lo8(64)
+	out 0xa,r24
+.L2:
+	sbi 0xb,6
+	ldi r18,lo8(1599999)
+	ldi r24,hi8(1599999)
+	ldi r25,hlo8(1599999)
+1:	subi r18,1
+	sbci r24,0
+	sbci r25,0
+	brne 1b
+	rjmp .
+	nop
+	cbi 0xb,6
+	ldi r18,lo8(1599999)
+	ldi r24,hi8(1599999)
+	ldi r25,hlo8(1599999)
+1:	subi r18,1
+	sbci r24,0
+	sbci r25,0
+	brne 1b
+	rjmp .
+	nop
+	rjmp .L2
+	.size	main, .-main
+	.ident	"GCC: (GNU) 5.4.0"

20210517/blink-2s.hex

+:100000000C9434000C943E000C943E000C943E0082
+:100010000C943E000C943E000C943E000C943E0068
+:100020000C943E000C943E000C943E000C943E0058
+:100030000C943E000C943E000C943E000C943E0048
+:100040000C943E000C943E000C943E000C943E0038
+:100050000C943E000C943E000C943E000C943E0028
+:100060000C943E000C943E0011241FBECFEFD8E04C
+:10007000DEBFCDBF0E9440000C945E000C940000D7
+:10008000EAE2F0E020E42083E395208120642083ED
+:100090007FEF89E698E1715080409040E1F70000E1
+:1000A000000020812F7B20837FEF84E39CE0715050
+:1000B00080409040E1F700000000E7CFF894FFCFC8
+:00000001FF

20210517/blink-2s.s

+	.text                     ; "Dies ist ein Programm."
+
+.global	main                      ; Exportiere das Symbol "main"
+
+                                  ; DDRD = 0x40
+
+main:	ldi r30,0x2a              ; lade 0x2a in das Register r30
+	ldi r31,0x00              ; lade 0x00 in das Register r31
+	ldi r18,0x40              ; lade 0x40 in das Register r18
+        st Z,r18                  ; speichere r18 dort, wohin das Z-Register zeigt
+                                  ;   (Z-Register = Kombination von r30 und r31, hier 0x002a)
+
+        inc r30                   ; inkrementiere r30; danach ist Z = 0x002b
+
+loop:	ld r18,Z                  ; Speicherzelle in Register laden
+        ori r18,0x40              ; Und-Verknüpfung mit dem Binärmuster 0100 0000
+                                  ;   (Bit auf 1 setzen: Schalte LED an)
+        st Z,r18                  ; Register in Speicherzelle schreiben
+
+                                  ; 0.5 Sekunden warten
+
+	ldi r23,lo8(1599999)      ; Lade die untersten 8 Bit der Zahl 1599999 in r23
+	ldi r24,hi8(1599999)      ; Lade die mittleren 8 Bit der Zahl 1599999 in r24
+	ldi r25,hlo8(1599999)     ; Lade die obersten 8 Bit der Zahl 1599999 in r25
+wait1:	subi r23,1                ; Subtrahiere die Integer 1 von r23
+	sbci r24,0                ; Subtrahiere die Integer 0 mit Carry (Übertrag) von r24
+	sbci r25,0                ; Subtrahiere die Integer 0 mit Carry (Übertrag) von r25
+                                  ; --> Subtrahiere 1 von der Zahl (r25/r24/r23) (anfangs 1599999)
+	brne wait1                ; "branch if not equal" - Sprung, wenn nicht 0
+                                  ; Ausführungsdauer: je 1 Taktzyklus für subi/sbci
+                                  ;  + 2 Taktzyklen für brne = 5 Taktzyklen pro Durchlauf
+                                  ;  Schleife = 1599999 Durchläufe
+                                  ;           = 7999995 Taktzyklen (bei 5 Takten pro Durchlauf)
+                                  ;           = 0.4999996875 Sekunden (bei 16 MHz Taktfrequenz)
+                                  ; Zusammen mit den 3 Taktzyklen für die 3 ldi-Befehle
+                                  ; ergibt sich ziemlich genau 0.5 Sekunden.
+        nop
+        nop                       ; Zusammen mit 2 nops je 1 Taktzyklus: genau 0.5 Sekunden
+
+        ld r18,Z                  ; Speicherzelle in Register laden
+        andi r18,0xbf             ; Und-Verknüpfung mit dem Binärmuster 1011 1111
+                                  ;   (Bit auf 0 setzen: Schalte LED aus)
+        st Z,r18                  ; Register in Speicherzelle schreiben
+
+                                  ; 0.5 Sekunden warten
+
+	ldi r23,lo8(799999)
+	ldi r24,hi8(799999)
+	ldi r25,hlo8(799999)
+wait2:	subi r23,1
+	sbci r24,0
+	sbci r25,0
+	brne wait2
+        nop
+        nop
+
+	rjmp loop                 ; Endlosschleife

20210517/download.sh

+port=$(ls -rt /dev/ttyACM* | tail -1)
+echo avrdude -P $port -c arduino -p m328p -U flash:w:$(ls -rt *.hex | tail -1)
+avrdude -P $port -c arduino -p m328p -U flash:w:$(ls -rt *.hex | tail -1) 2>/dev/null

20210517/logo-hochschule-bochum-cvh-text-v2.pdf

+../common/logo-hochschule-bochum-cvh-text-v2.pdf
\ No newline at end of file

20210517/logo-hochschule-bochum.pdf

+../common/logo-hochschule-bochum.pdf
\ No newline at end of file

20210517/pgslides.sty

+../common/pgslides.sty
\ No newline at end of file

20210517/rtech-20210517.tex

+% rtech-20210517.pdf - Lecture Slides on Computer Technology
+% Copyright (C) 2012, 2013, 2014, 2021  Peter Gerwinski
+%
+% This document is free software: you can redistribute it and/or
+% modify it either under the terms of the Creative Commons
+% Attribution-ShareAlike 3.0 License, or under the terms of the
+% GNU General Public License as published by the Free Software
+% Foundation, either version 3 of the License, or (at your option)
+% any later version.
+%
+% This document is distributed in the hope that it will be useful,
+% but WITHOUT ANY WARRANTY; without even the implied warranty of
+% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+% GNU General Public License for more details.
+%
+% You should have received a copy of the GNU General Public License
+% along with this document.  If not, see <http://www.gnu.org/licenses/>.
+%
+% You should have received a copy of the Creative Commons
+% Attribution-ShareAlike 3.0 Unported License along with this
+% document.  If not, see <http://creativecommons.org/licenses/>.
+
+% README: Programmieren in Assembler: Arduino, Krieg der Kerne
+
+\documentclass[10pt,t]{beamer}
+
+\usepackage{pgslides}
+
+\lstdefinestyle{asm}{basicstyle=\color{structure},
+                     language={},
+                     gobble=4}
+
+\title{Rechnertechnik}
+\author{Prof.\ Dr.\ rer.\ nat.\ Peter Gerwinski}
+\date{17.\ Mai 2021}
+
+\begin{document}
+
+\maketitleframe
+
+\sectionnonumber{\inserttitle}
+
+\begin{frame}
+
+  \showsectionnonumber
+
+  \begin{itemize}
+    \item[\textbf{1}] \textbf{Einführung}
+    \item[\textbf{2}] \textbf{Vom Schaltkreis zum Computer}
+      \begin{itemize}
+        \item[2.1] Logik-Schaltkreise
+        \item[2.2] Binärdarstellung von Zahlen
+        \item[2.3] Vom Logik-Schaltkreis zum Addierer
+        \item[2.4] Negative Zahlen
+        \item[2.5] Vom Addierer zum Computer
+        \item[2.6] Computer-Sprachen
+        \color{orange}
+        \item[2.7] Programmieren in Assembler
+        \color{red}
+        \item[2.8] Struktur von Assembler-Programmen
+      \end{itemize}
+    \color{gray}
+    \item[\textbf{3}] \textbf{Architekturmerkmale von Prozessoren}
+    \item[\textbf{4}] \textbf{Der CPU-Stack}
+%    \item[\textbf{5}] \textbf{Hardwarenahe Programmierung}
+%    \item[\textbf{6}] \textbf{Anwender-Software}
+%    \item[\textbf{7}] \textbf{Bus-Systeme}
+%    \item[\textbf{8}] \textbf{Pipelining}
+    \item[\textbf{\dots\hspace{-0.75em}}]
+%    \item[\textbf{9}] \textbf{Ausblick}
+  \end{itemize}
+
+\end{frame}
+
+\setcounter{section}{1}
+\section{Vom Schaltkreis zum Computer}
+\setcounter{subsection}{6}
+\subsection{Programmieren in Assembler}
+
+\begin{frame}
+
+  \showsubsection
+
+  Beispiel: PC, 1980er bis 1990er Jahre
+  \begin{itemize}
+    \item
+      Prozessor: Intel 8086
+    \item
+      Takt: 4,77--100\,MHz
+  \end{itemize}
+  Anwendung von Assembler: zeitkritische Programmteile,\\
+  z.\,B.\ Text- und Grafikausgabe
+
+%  \begin{onlyenv}<1>
+%    \begin{center}
+%      \vspace*{-0.15cm}
+%      \includegraphics[width=9.8cm,trim={0cm 0cm 0cm 0.8cm},clip]{hello-world-maschinensprache.png}
+%      \vspace*{-10cm}
+%    \end{center}
+%  \end{onlyenv}
+%
+%  \pause
+  \bigskip
+
+  Beispiel: Arduino Uno
+  \begin{itemize}
+    \item
+      Prozessor: ATmega 328p
+    \item
+      Takt: 16\,MHz
+  \end{itemize}
+  Anwendung von Assembler: zeitkritische Programmteile,\\
+  z.\,B.\ Mikrosekunden-Timing
+
+\end{frame}
+
+\begin{frame}[fragile]
+
+  \showsubsection
+
+  Beispiel: Arduino Uno
+  \begin{itemize}
+    \item
+      Prozessor: ATmega 328p
+    \item
+      Takt: 16\,MHz
+  \end{itemize}
+  Anwendung von Assembler: zeitkritische Programmteile,\\
+  z.\,B.\ Mikrosekunden-Timing
+
+  \bigskip
+
+  Cross-Entwicklung
+  \begin{itemize}
+    \item
+      Programmieren auf PC
+    \item
+      Compilieren auf PC:
+      \begin{lstlisting}[style=cmd,gobble=8]
+        avr-gcc -Wall -Os -mmcu=atmega328p blink.c -o blink.elf
+      \end{lstlisting}
+    \item
+      Speicherabbild auf PC erstellen:
+      \begin{lstlisting}[style=cmd,gobble=8]
+        avr-objcopy -O ihex blink.elf blink.hex
+      \end{lstlisting}
+    \item
+      Speicherabbild auf den Mikrocontroller herunterladen:
+      \begin{lstlisting}[style=cmd,gobble=8]
+        avrdude -P /dev/ttyACM0 -c arduino -p m328p \
+                -U flash:w:blink.hex
+      \end{lstlisting}
+  \end{itemize}
+
+\end{frame}
+
+\begin{frame}[fragile]
+
+  \showsubsection
+
+  Cross-Entwicklung
+  \begin{itemize}
+    \item
+      Programmieren auf PC
+    \item
+      Compilieren auf PC:
+      \begin{lstlisting}[style=cmd,gobble=8]
+        avr-gcc -Wall -Os -mmcu=atmega328p blink.c -o blink.elf
+      \end{lstlisting}
+    \item
+      Speicherabbild auf PC erstellen:
+      \begin{lstlisting}[style=cmd,gobble=8]
+        avr-objcopy -O ihex blink.elf blink.hex
+      \end{lstlisting}
+    \item
+      Speicherabbild auf den Mikrocontroller herunterladen:
+      \begin{lstlisting}[style=cmd,gobble=8]
+        avrdude -P /dev/ttyACM0 -c arduino -p m328p \
+                -U flash:w:blink.hex
+      \end{lstlisting}
+    \medskip
+    \item
+      Präprozessor auf PC:
+      \begin{lstlisting}[style=cmd,gobble=8]
+        avr-gcc -Wall -Os -mmcu=atmega328p blink.c \
+                -E -o blink.E
+      \end{lstlisting}
+    \item
+      Compilieren auf PC, Assembler-Quelltext erzeugen:
+      \begin{lstlisting}[style=cmd,gobble=8]
+        avr-gcc -Wall -Os -mmcu=atmega328p blink.c -S
+      \end{lstlisting}
+  \end{itemize}
+
+\end{frame}
+
+\begin{frame}[fragile]
+
+  \showsubsection
+  
+  C nach Assembler übersetzen:
+  \begin{lstlisting}[style=terminal]
+    $ ¡gcc -S pruzzel.c¿
+  \end{lstlisting}
+  erzeugt \file{pruzzel.s},\\
+  Assembler für den Standard-Prozessor\\
+  (hier: 64-Bit-AMD-Architektur -- amd64).
+
+  \bigskip
+%  \pause
+  
+  \begin{lstlisting}[style=terminal]
+    $ ¡avr-gcc -S pruzzel.c¿
+  \end{lstlisting}
+  erzeugt \file{pruzzel.s},\\
+  Assembler für 8-Bit-Atmel-AVR-Prozessoren.
+
+\end{frame}
+
+\begin{frame}[fragile]
+
+  \showsubsection
+
+  C-Programme auf Assembler-Ebene debuggen:
+  \begin{lstlisting}[style=terminal]
+    $ ¡gcc -g pruzzel.c -o pruzzel¿
+    $ ¡gdb -tui ./pruzzel¿
+    (gdb) ¡break main¿
+    (gdb) ¡run¿
+    (gdb) ¡layout split¿
+    (gdb) ¡nexti¿
+  \end{lstlisting}
+
+\end{frame}
+
+\subsection{Struktur von Assembler-Programmen}
+
+\begin{frame}[fragile]
+
+  \showsubsection
+
+  Beispiel 1: IA-32-Assembler \only<3>{-- Adressierungsarten}
+
+  \vspace{2cm}
+
+  \begin{lstlisting}
+    addl    $1, %eax
+    movb    %al, b
+    cmpb    (%ebx), %dl
+    jbe     .L2
+  \end{lstlisting}
+
+  \begin{onlyenv}<2-3>
+    \begin{picture}(0,0)
+      \color{red}
+      \put(0.4,2.8){\vector(0,-1){0.7}}
+      \put(0.4,2.9){\makebox(0,0)[b]{Befehl}}
+      \only<2>{%
+        \put(1.4,2.8){\vector(-1,-1){0.7}}
+        \put(2.3,2.9){\makebox(0,0)[b]{Größen-Suffix}}}
+      \only<3>{%
+        \put(1.4,2.8){\vector(-1,-2){0.35}}
+        \put(1.4,2.8){\vector(1,-2){0.35}}
+        \put(2.0,2.9){\makebox(0,0)[b]{Operanden}}}
+    \end{picture}
+  \end{onlyenv}
+  \begin{onlyenv}<4>
+    \begin{picture}(0,0)
+      \color{red}
+      \put(1.4,2.8){\vector(-1,-2){0.35}}
+      \put(2.0,2.9){\makebox(0,0)[b]{unmittelbar}}
+      \put(3.0,1.8){\vector(-1,0){0.7}}
+      \put(3.1,1.8){\makebox(0,0)[l]{Register}}
+      \put(4.8,1.4){\vector(-1,0){2.7}}
+      \put(4.9,1.4){\makebox(0,0)[l]{Speicher (absolut)}}
+      \put(2.3,-0.0){\vector(-1,1){0.7}}
+      \put(3.5,-0.1){\makebox(0,0)[t]{indirekt mit Register}}
+      \put(0.8,-0.6){\vector(0,1){0.9}}
+      \put(0.0,-0.7){\makebox(0,0)[tl]{Speicher (relativ)}}
+    \end{picture}
+  \end{onlyenv}
+
+\end{frame}
+
+\begin{frame}[fragile]
+
+  \showsubsection
+
+  Beispiel 2: Redcode (ICWS '88)\pause\ -- Core War[s] (Krieg der Kerne)\\
+  Virtuelle Maschine: Memory Array Redcode Simulator (MARS)
+
+  \pause
+  \bigskip
+
+  \begin{minipage}[t]{7.2cm}
+    Instruktionen:\\[\smallskipamount]
+    \lstinline{dat B} -- Daten \only<4->{-- "`Du hast verloren!"'}\\
+    \lstinline{mov A, B} -- kopiere A nach B\\
+    \lstinline{add A, B} -- addiere A zu B\\
+    \lstinline{sub A, B} -- subtrahiere A von B\\
+    \lstinline{jmp A} -- unbedingter Sprung nach A\\
+    \lstinline{jmz A, B} -- Sprung nach A, wenn B $=$ 0\\
+    \lstinline{jmn A, B} -- Sprung nach A, wenn B $\ne$ 0\\
+    \lstinline{djn A, B} -- "`decrement and jump if not zero"'\\
+    \lstinline{cmp A, B} -- "`compare"': überspringe, falls gleich\\
+    \lstinline{spl A} -- "`split"': Programm verzweigen
+  \end{minipage}\hfill
+  \begin{minipage}[t]{4.7cm}
+    Adressierungsarten:\\[\smallskipamount]
+    grundsätzlich: Speicher relativ\\[\smallskipamount]
+    \lstinline{#} -- unmittelbar\\
+    \lstinline{$} -- direkt\\
+    \lstinline{@} -- indirekt\\
+    \lstinline{<} -- indirekt mit Prä-Dekrement
+
+    \pause[5]
+    \bigskip
+    Programm "`Nothing"':
+    \begin{lstlisting}[gobble=6]
+      jmp 0
+    \end{lstlisting}
+    \pause
+    \bigskip
+    Programm "`Knirps"':
+    \begin{lstlisting}[gobble=6]
+      mov 0, 1
+    \end{lstlisting}
+
+  \end{minipage}
+
+\end{frame}
+
+\begin{frame}[fragile]
+
+  \showsubsection
+
+  Unbedingte Verzweigung
+
+  Beispiel: Endlosschleife von "`Dwarf"'
+
+  \begin{minipage}[t]{1.2cm}
+    \begin{lstlisting}[style=asm,gobble=6]
+      bomb
+      start
+    \end{lstlisting}
+  \end{minipage}%
+  \begin{minipage}[t]{3cm}
+    \begin{lstlisting}[style=asm,gobble=6]
+      dat #0
+      add #4, bomb
+      mov bomb, @bomb
+      jmp start
+      end start
+    \end{lstlisting}
+  \end{minipage}\hfill
+  \begin{minipage}[t]{3.9cm}
+    \small
+    \bigskip
+    Instruktionen:\\[\smallskipamount]
+    \lstinline{dat B}\\
+    \lstinline{mov A, B}\\
+    \lstinline{add A, B}\\
+    \lstinline{sub A, B}\\
+    \lstinline{jmp A}\\
+    \lstinline{jmz A, B} -- "`jump if zero"'\\
+    \lstinline{jmn A, B} -- "`if not zero"'\\
+    \lstinline{djn A, B} -- "`dec. \& jmn"'\\
+    \lstinline{cmp A, B} -- vgl.\ \& überspr.\\
+    \lstinline{spl A} -- verzweigen
+  \end{minipage}%
+  \begin{minipage}[t]{2.7cm}
+    \small
+    \bigskip
+    Adressierungsarten:\\[\medskipamount]
+    grundsätzlich:\\
+    Speicher relativ\\[\medskipamount]
+    \lstinline{#} -- unmittelbar\\[\smallskipamount]
+    \lstinline{$} -- direkt\\[\smallskipamount]
+    \lstinline{@} -- indirekt\\[\smallskipamount]
+    \lstinline{<} -- indirekt mit\\
+    \hspace*{0.52cm}Prä-Decrement
+  \end{minipage}
+
+\end{frame}
+
+\begin{frame}[fragile]
+
+  \showsubsection
+
+  \alt<2->{Mehrere Threads}{Bedingte Verzweigung}
+
+  Beispiel: \alt<2->{Multithreading}{Kopierschleife} von "`Mice"'
+
+  \begin{minipage}[t]{1.2cm}
+    \begin{lstlisting}[style=asm,gobble=6]
+      ptr
+      start
+      loop
+
+
+
+
+      dest
+
+    \end{lstlisting}
+  \end{minipage}%
+  \begin{minipage}[t]{3cm}
+    \begin{lstlisting}[style=asm,gobble=6]
+      dat              #0
+      mov     #12,     ptr
+      mov     @ptr,    <dest
+      djn     loop,    ptr
+      spl     @dest
+      add     #653,    dest
+      jmz     start,   ptr
+      dat              #833
+      end start
+    \end{lstlisting}
+  \end{minipage}\hfill
+  \begin{minipage}[t]{3.9cm}
+    \small
+    \bigskip
+    Instruktionen:\\[\smallskipamount]
+    \lstinline{dat B}\\
+    \lstinline{mov A, B}\\
+    \lstinline{add A, B}\\
+    \lstinline{sub A, B}\\
+    \lstinline{jmp A}\\
+    \lstinline{jmz A, B} -- "`jump if zero"'\\
+    \lstinline{jmn A, B} -- "`if not zero"'\\
+    \lstinline{djn A, B} -- "`dec. \& jmn"'\\
+    \lstinline{cmp A, B} -- vgl.\ \& überspr.\\
+    \lstinline{spl A} -- verzweigen
+  \end{minipage}%
+  \begin{minipage}[t]{2.7cm}
+    \small
+    \bigskip
+    Adressierungsarten:\\[\medskipamount]
+    grundsätzlich:\\
+    Speicher relativ\\[\medskipamount]
+    \lstinline{#} -- unmittelbar\\[\smallskipamount]
+    \lstinline{$} -- direkt\\[\smallskipamount]
+    \lstinline{@} -- indirekt\\[\smallskipamount]
+    \lstinline{<} -- indirekt mit\\
+    \hspace*{0.52cm}Prä-Decrement
+  \end{minipage}
+
+\end{frame}
+
+\iffalse
+
+\begin{frame}[fragile]
+
+  \showsubsection
+
+  Selbstmodifizierender Code
+
+  Beispiel: Selbsterkennung von "`Fini"'
+
+  \begin{minipage}[t]{1.2cm}
+    \begin{lstlisting}[language={},gobble=6]
+      num
+      start
+
+      pos
+
+    \end{lstlisting}
+  \end{minipage}%
+  \begin{minipage}[t]{0.9cm}
+    \begin{lstlisting}[language={},gobble=6]
+      dat #-2
+      mov num, <pos
+      jmp start
+      dat
+      end start
+    \end{lstlisting}
+  \end{minipage}\hfill
+  \begin{minipage}[t]{3.9cm}
+    \small
+    \bigskip
+    Instruktionen:\\[\smallskipamount]
+    \lstinline{dat B}\\
+    \lstinline{mov A, B}\\
+    \lstinline{add A, B}\\
+    \lstinline{sub A, B}\\
+    \lstinline{jmp A}\\
+    \lstinline{jmz A, B} -- "`jump if zero"'\\
+    \lstinline{jmn A, B} -- "`if not zero"'\\
+    \lstinline{djn A, B} -- "`dec. \& jmn"'\\
+    \lstinline{cmp A, B} -- vgl.\ \& überspr.\\
+    \lstinline{spl A} -- verzweigen
+  \end{minipage}%
+  \begin{minipage}[t]{2.7cm}
+    \small
+    \bigskip
+    Adressierungsarten:\\[\medskipamount]
+    grundsätzlich:\\
+    Speicher relativ\\[\medskipamount]
+    \lstinline{#} -- unmittelbar\\[\smallskipamount]
+    \lstinline{$} -- direkt\\[\smallskipamount]
+    \lstinline{@} -- indirekt\\[\smallskipamount]
+    \lstinline{<} -- indirekt mit\\
+    \hspace*{0.52cm}Prä-Decrement
+  \end{minipage}
+
+\end{frame}
+
+\begin{frame}[fragile]
+
+  \showsubsection
+
+  \strut
+ 
+  \strut\makebox(0,0)[bl]{\large\color{structure}\textbf{Praktikumsversuch}}
+
+  \begin{minipage}[t]{5cm}
+    \medskip
+    Schreiben Sie ein\\
+    Redcode-Programm,\\
+    das die Gegner\\
+    \file{Nothing}, \file{Knirps}\\
+    und \file{Mice} besiegt.
+
+    \medskip
+
+    ICWS-88-Standard,\\
+    max.\ 64 Prozesse,\\
+    Speichergröße zufällig
+
+    \medskip
+
+    Teams bis zu 3 Personen\\
+    sind zulässig.
+  \end{minipage}\hfill
+  \begin{minipage}[t]{3.9cm}
+    \small
+    \bigskip
+    Instruktionen:\\[\smallskipamount]
+    \lstinline{dat B}\\
+    \lstinline{mov A, B}\\
+    \lstinline{add A, B}\\
+    \lstinline{sub A, B}\\
+    \lstinline{jmp A}\\
+    \lstinline{jmz A, B} -- "`jump if zero"'\\
+    \lstinline{jmn A, B} -- "`if not zero"'\\
+    \lstinline{djn A, B} -- "`dec. \& jmn"'\\
+    \lstinline{cmp A, B} -- vgl.\ \& überspr.\\
+    \lstinline{spl A} -- verzweigen
+  \end{minipage}%
+  \begin{minipage}[t]{2.7cm}
+    \small
+    \bigskip
+    Adressierungsarten:\\[\medskipamount]
+    grundsätzlich:\\
+    Speicher relativ\\[\medskipamount]
+    \lstinline{#} -- unmittelbar\\[\smallskipamount]
+    \lstinline{$} -- direkt\\[\smallskipamount]
+    \lstinline{@} -- indirekt\\[\smallskipamount]
+    \lstinline{<} -- indirekt mit\\
+    \hspace*{0.52cm}Prä-Decrement
+  \end{minipage}
+
+\end{frame}
+
+\fi
+
+\sectionnonumber{\inserttitle}
+
+\begin{frame}
+
+  \showsectionnonumber
+
+  \begin{itemize}
+    \item[\textbf{1}] \textbf{Einführung}
+    \item[\textbf{2}] \textbf{Vom Schaltkreis zum Computer}
+      \begin{itemize}
+        \item[2.1] Logik-Schaltkreise
+        \item[2.2] Binärdarstellung von Zahlen
+        \item[2.3] Vom Logik-Schaltkreis zum Addierer
+        \item[2.4] Negative Zahlen
+        \item[2.5] Vom Addierer zum Computer
+        \item[2.6] Computer-Sprachen
+        \color{medgreen}
+        \item[2.7] Programmieren in Assembler
+        \color{orange}
+        \item[2.8] Struktur von Assembler-Programmen
+      \end{itemize}
+    \color{gray}
+    \item[\textbf{3}] \textbf{Architekturmerkmale von Prozessoren}
+    \item[\textbf{4}] \textbf{Der CPU-Stack}
+%    \item[\textbf{5}] \textbf{Hardwarenahe Programmierung}
+%    \item[\textbf{6}] \textbf{Anwender-Software}
+%    \item[\textbf{7}] \textbf{Bus-Systeme}
+%    \item[\textbf{8}] \textbf{Pipelining}
+    \item[\textbf{\dots\hspace{-0.75em}}]
+%    \item[\textbf{9}] \textbf{Ausblick}
+  \end{itemize}
+
+\end{frame}
+
+\end{document}