Skip to content
Snippets Groups Projects
Commit d5b8de22 authored by Peter Gerwinski's avatar Peter Gerwinski
Browse files

Vortragsfolien und Beispiele 25.5.2021

parent 6b395e69
No related branches found
No related tags found
No related merge requests found
Showing
with 1066 additions and 0 deletions
;name Knirps 2
;assert 1
start mov 0, 2
end start
../common/logo-hochschule-bochum-cvh-text-v2.pdf
\ No newline at end of file
../common/logo-hochschule-bochum.pdf
\ No newline at end of file
../common/pgslides.sty
\ No newline at end of file
File added
% rtech-20210518.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: 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{18.\ 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{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}
\setcounter{section}{1}
\section{Vom Schaltkreis zum Computer}
\setcounter{subsection}{6}
\subsection{Programmieren in Assembler}
\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) -- Core War[s] (Krieg der Kerne)\\
Virtuelle Maschine: Memory Array Redcode Simulator (MARS)
\bigskip
\begin{minipage}[t]{7.2cm}
Instruktionen:\\[\smallskipamount]
\lstinline{dat B} -- Daten \only<1->{-- "`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}
\iffalse
\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}
\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{Ehemaliger Praktikumsversuch (2014)}}
\hfill Inspiration für Projekt?
\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}
\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
\item[2.7] Programmieren in Assembler
\color{medgreen}
\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}
\fi
\end{document}
;name Cat Can
;author A. Kirchner, F. Uy
;assert 1
;
; Your basic two sweep methodical bomber.
; Fires SPL 0 and JMP -1 at every eight
; addresses, then erases the core with
; DAT bombs.
start mov trap2, < bomb
mov trap1, < bomb
sub # 6, bomb
jmn start, bomb ; trap loop
set mov # -12, bomb
kill mov bomb, @ bomb
djn kill, bomb ; kill loop
reset jmp set, 0
jmp set, 0
dat # 0, # 0 ; buffer
bomb dat # 0, # -1024
trap1 spl 0, 2
trap2 jmp -1, 1
end start
;redcode
;name Dwarf
;author A. K. Dewdney
;strategy Throw DAT bombs around memory, hitting every 4th memory cell.
;strategy This program was presented in the first Corewar article.
bomb DAT #0
dwarf ADD #4, bomb
MOV bomb, @bomb
JMP dwarf
END dwarf ; Programs start at the first line unless
; an "END start" pseudo-op appears to indicate
; the first logical instruction. Also, nothing
; after the END instruction will be assembled.
;name Gemini
;assert 1
dat1 dat #0
dat2 dat #99
start mov @dat1, @dat2
add #1, dat1
add #1, dat2
cmp dat1, dat3
jmp start
mov #99, 94
jmp 94
dat3 dat #10
end start
;name Knirps 2
;assert 1
start mov 0, 2
end start
;name Knirps
;assert 1
start mov 0, 1
end start
../common/logo-hochschule-bochum-cvh-text-v2.pdf
\ No newline at end of file
../common/logo-hochschule-bochum.pdf
\ No newline at end of file
;name Mice
;author Chip Wendell
;assert 1
ptr dat #0
start mov #12, ptr ; n = 12
loop mov @ptr, <dest ; *dest = *(ptr+(*ptr))
djn loop, ptr ; if(--ptr != 0)
; goto loop
spl @dest ; split(*dest)
add #653, dest ; dest += 653
jmz start, ptr ; if(!ptr)
; goto start
dest dat #833
end start
;name Nothing
;assert 1
start jmp 0
end start
;redcode
;name oft
;version 1.0 (8.1990)
;author Olaf Klein
;assert 1
; +----------------------------------+
; | O F T by O.K. AUG. 1990 |
; +----------------------------------+
SPL <456
JMP -1
../common/pgslides.sty
\ No newline at end of file
File added
% rtech-20210525.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: Krieg der Kerne (Fortsetzung)
\documentclass[10pt,t]{beamer}
\usepackage{pgslides}
\lstdefinestyle{asm}{basicstyle=\color{structure},
language={},
gobble=4}
\title{Rechnertechnik}
\author{Prof.\ Dr.\ rer.\ nat.\ Peter Gerwinski}
\date{25.\ 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
\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}
\setcounter{section}{1}
\section{Vom Schaltkreis zum Computer}
\setcounter{subsection}{7}
\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) -- Core War[s] (Krieg der Kerne)\\
Virtuelle Maschine: Memory Array Redcode Simulator (MARS)
\bigskip
\begin{minipage}[t]{7.2cm}
Instruktionen:\\[\smallskipamount]
\lstinline{dat B} -- Daten \only<1->{-- "`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}
\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{Ehemaliger Praktikumsversuch (2014)}}
\hfill Inspiration für Projekt?
\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}
\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
\item[2.7] Programmieren in Assembler
\color{medgreen}
\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}
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment