#LyX 1.3 created this file. For more info see http://www.lyx.org/
\lyxformat 221
\textclass article
\begin_preamble
\usepackage{hyperref}
\hypersetup {
pdftex=true,
hyperindex=true,
colorlinks=true,
bookmarks=true,
bookmarksnumbered=false,
pdfpagemode=None,
bookmarksopen=false,
pdftitle=Zentraldokument Modul SysProg1.SchmidtKH,
pdfauthor=Matthias Ansorg,
pdfcreator=pdfTeX (Web2C 7.3.1) 3.14159-0.13d,
pdfstartview=FitBH
}
\end_preamble
\language german
\inputencoding auto
\fontscheme default
\graphics default
\paperfontsize default
\spacing single
\papersize a4paper
\paperpackage a4
\use_geometry 1
\use_amsmath 1
\use_natbib 0
\use_numerical_citations 0
\paperorientation portrait
\secnumdepth 3
\tocdepth 3
\paragraph_separation indent
\defskip medskip
\quotes_language danish
\quotes_times 2
\papercolumns 1
\papersides 1
\paperpagestyle default
\layout Title
Vorlesungsmodul Systemprogrammierung\SpecialChar ~
1
\newline
- VorlMod SysProg1 -
\layout Author
Matthias Ansorg
\layout Date
20.
März 2003 bis
\begin_inset ERT
status Collapsed
\layout Standard
\backslash
today
\end_inset
\layout Abstract
Studentische Mitschrift zur Vorlesung Systemprogrammierung\SpecialChar ~
1 bei Dr.-Ing.
Karl-Heinrich Schmidt (Sommersemester 2003) im Studiengang Informatik an
der Fachhochschule Gießen-Friedberg.
In den Übungen dieser Veranstaltung wurde bisher Turbo Assembler und Turbo
Linker verwendet, nun MS Visual C++ 6.0 zur 32-Bit Assemblerprogrammierung.
Die Gliederung dieser studentischen Mitschrift ist identisch mit
\begin_inset LatexCommand \cite{WuestSkript}
\end_inset
.
\begin_deeper
\layout Itemize
\series bold
Bezugsquelle:
\series default
Die vorliegende studentische Mitschrift steht im Internet zum Download
bereit:
\begin_inset LatexCommand \url[Persönliche Homepage Matthias Ansorg]{http://matthias.ansorgs.de/InformatikDiplom/Modul.SysProg1.Schmidt/}
\end_inset
.
\layout Itemize
\series bold
Lizenz:
\series default
Diese studentische Mitschrift ist public domain, darf also ohne Einschränkungen
oder Quellenangabe für jeden beliebigen Zweck benutzt werden, kommerziell
und nichtkommerziell; jedoch enthält sie keinerlei Garantien für Richtigkeit
oder Eignung oder sonst irgendetwas, weder explizit noch implizit.
Das Risiko der Nutzung dieser studentischen Mitschrift liegt allein beim
Nutzer selbst.
Einschränkend sind außerdem die Urheberrechte der angegebenen Quellen zu
beachten.
\layout Itemize
\series bold
Korrekturen und Feedback:
\series default
Fehler zur Verbesserung in zukünftigen Versionen, sonstige Verbesserungsvorschl
äge und Wünsche bitte dem Autor per e-mail mitteilen: Matthias Ansorg <
\begin_inset LatexCommand \url{mailto:matthias@ansorgs.de}
\end_inset
>.
\layout Itemize
\series bold
Format:
\series default
Die vorliegende studentische Mitschrift wurde mit dem Programm LyX (graphisches
Frontend zu
\begin_inset ERT
status Collapsed
\layout Standard
\backslash
LaTeX
\end_inset
) unter Linux geschrieben und mit pdf
\begin_inset ERT
status Collapsed
\layout Standard
\backslash
LaTeX
\end_inset
als pdf-Datei erstellt.
Grafiken wurden mit dem Programm xfig unter Linux erstellt und als pdf-Dateien
exportiert.
\layout Itemize
\series bold
Dozent:
\series default
Lehrbeauftragter Dr.-Ing.
Karl-Heinrich Schmidt.
Nur stundenweise und nicht ganztags an der FH Gießen-Friedberg anzutreffen.
\layout Itemize
\series bold
Verwendete Quellen:
\series default
Die angegebene Literatur beschreibt fast ausschließlich 16-Bit Programmierung.
Die Befehle zur 32-Bit Programmierung, auf die in dieser Veranstaltung
eingegangen wird, sind identisch, nur die Operanden haben ein vorangestelltes
E (
\begin_inset Quotes ald
\end_inset
extended
\begin_inset Quotes ard
\end_inset
).
\layout Itemize
\series bold
Klausur:
\series default
\begin_deeper
\layout Itemize
Hilfsmittel: das Skript von Prof.
Wüst und beliebig viele andere Referenzhandbücher.
Nützlich ist
\begin_inset LatexCommand \cite[S. 55]{WuestSkript}
\end_inset
.
Alle Skripte und Bücher dürfen verwendet werden, auch eigene Mitschriften.
Taschenrechner und Notebook und andere Elektronik sind nicht erlaubt.
Aufgabensammlungen, alte Klausuren und andere Notizen sind ebenfalls erlaubt.
Also: Papier in jeder Form.
\layout Itemize
Teilnahmevoraussetzung: zwei anerkannte Hausübungen
\layout Itemize
Die Klausur wird von K.-H.
Schmidt gestellt.
\layout Itemize
Die erlaubten Hilfsmittel hat K.-H.
Schmidt noch nicht festgelegt.
\layout Itemize
Die MMX-Erweiterungen des Pentium werden in der Veranstaltung behandelt.
\layout Itemize
Die Klausur wird ähnlich den alten Klausuren von Prof.
Wüst sein.
Diese kann man also als Vorlage nutzen, sie müssen irgendwo im Internet
zu finden sein.
Schwerpunkte der Klausur:
\begin_deeper
\layout Itemize
Inline-Prozeduren mit Parameterübergabe über Stack und Rückgabe über EAX
oder ST0.
\layout Itemize
Aufgaben zu den Basisbefehlen MOV, ADD, SUB, ROL, ROR, XOR usw.
\layout Itemize
Aufgaben zu Gleitkommaarithmetik.
\layout Itemize
Im Gegensatz zu Klausuren von Prof.
Wüst werden stets 32bit-Register verwendet, jedoch kein Int 21h usw..
Ausgelassen werden aus dem Skript: Ein- und Ausgabe; Betriebssystemfunktionen;
MMX-Einheit.
Im Gegensatz zu Klausuren von Prof.
Wüst werden weniger reine TurboAssembler-Prozeduren verlangt, eher C-kompatible
Prozeduren und Inline-Assembler.
\layout Itemize
Aufgaben, in denen man eine Prozedur schreiben muss und dabei den Lösungsweg
überlegen muss (etwa mit Bitoperationen).
Eine solche Aufgabe, in der man den Lösungsweg selbst entwickeln muss statt
nur einen vorgegebenen Algorithmus in Assembler zu implementieren hat,
ist natürlich aufwendig zu korrigieren, wird deshalb wahrscheinlich nicht
vorkommen.
\layout Itemize
Rechnungen in der Klausur sind grundsätzlich so gestellt, dass man sie im
Kopf lösen kann.
Divisor und Faktoren sind also Zweierpotenzen, so dass man Bitschieben
zur Division und Multiplikation verwenden kann.
\layout Itemize
Tabelle zur Umwandlung von dezimalen, hexadezimalen und binären Zahlen als
Hilfsmittel erstellen.
\end_deeper
\end_deeper
\end_deeper
\layout Standard
\begin_inset LatexCommand \tableofcontents{}
\end_inset
\layout Standard
\begin_inset FloatList figure
\end_inset
\layout Section
Einführung
\layout Subsection
Maschinencode und Assemblersprache
\layout Paragraph
Was heißt Systemprogrammierung?
\layout Standard
Assemblerprogrammierung wird hauptsächlich für geschwindigkeitskritische
Bereiche des Betriebssystems eingesetzt.
Daher die Bezeichnung
\begin_inset Quotes ald
\end_inset
Systemprogrammierung
\begin_inset Quotes ard
\end_inset
, bezogen auf das Betriebssystem und nicht auf die Hardware.
Andere Bezeichnungen sind
\begin_inset Quotes ald
\end_inset
Maschinennahe Programmierung
\begin_inset Quotes ard
\end_inset
und
\begin_inset Quotes ald
\end_inset
Assemblerprogrammierung
\begin_inset Quotes ard
\end_inset
.
Eigenschaften:
\layout Itemize
prozessororientierte und prozessorspezifische Programmierung
\layout Itemize
maschinenoptimierte und nicht problemorientierte bzw.
objektorientierte Art der Programmierung
\layout Itemize
hardwarenah
\layout Itemize
nicht portabel auf andere Prozessoren
\layout Itemize
programmiert wird mit Maschinenbefehlen
\layout Itemize
ein Assembler übernimmt die Umsetzung von Mnemonics in Bytecodes.
\layout Itemize
zu jedem Prozessor wurde mindestens eine Assemblersprache spezifiziert;
in dieser Veranstaltung wird die Assemblersprache der Prozessorfamilie
Intel 80x86 und Pentium behandelt.
\layout Paragraph
Wozu Assemblerprogrammierung?
\layout Itemize
Sie kann nicht zum Lösen komplexer Probleme verwendet werden.
\layout Itemize
Laufzeitoptimierung.
Assemblerprogramme sind um etwa Faktor 10 schneller als ein mit C++ entwickelte
s Programm.
Etwa bei Videobearbeitung ist dies auch heute noch notwendig.
Es gab stets Anwendungen, die den Rechner überlasten, und das wird sich
auch in Zukunft nicht ändern.
Natürlich wird heute kein Programm mehr in reinem Assembler programmiert,
sondern nur die sehr häufig ausgeführten Programmteile werden zuerst in
einer höheren Programmiersprache geschrieben und dann durch Assembler ersetzt.
\layout Itemize
optimale Prozessorausnutzung.
\layout Itemize
vollständige Kontrolle des Prozessors.
Dies ist unter Multitasking-Betriebssystemen aufgrund der
\begin_inset Quotes ald
\end_inset
hardware abstraction layer
\begin_inset Quotes ard
\end_inset
nur eingschränkt möglich.
\layout Itemize
kompakter Code.
Kompakte und übersichtliche Beschreibung eines Problems.
\layout Itemize
besseres Verständnis der Arbeitsweise eines Computers.
Dies ist der Hauptgrund für diese Veranstaltung.
\layout Paragraph
Nachteile der Assemblerprogrammierung
\layout Itemize
große Programme werden schnell unübersichtlich.
\layout Itemize
nicht portabel.
\layout Itemize
der Pentium-Befehlssatz enthält viel historischen Ballast.
Diese Abwärtskompatibilität ist für Softwarehersteller natürlich vorteilhaft,
weil so auch die ältesten Programme auch auf den modernsten Prozessoren
und unter den neuesten Betriebssystemen laufen können.
\layout Subsection
Register und Flags des 80386
\layout Standard
Alle Register EAX, EBX, ECX, EDX können für beliebige Zwecke verwendet werden.
\layout Subsection
Ein erstes Programm in Assembler
\layout Standard
\SpecialChar ~
\layout Section
Organisation und Benutzung des Hauptspeichers
\layout Subsection
Speichervariablen definieren
\layout Standard
\SpecialChar ~
\layout Subsection
16-Bit-Umgebungen: Der segmentierte Hauptspeicher
\layout Standard
\SpecialChar ~
\layout Subsection
31-Bit-Umgebungen: Der unsegmentierte Hauptspeicher
\layout Standard
\SpecialChar ~
\layout Subsection
Addressierungsarten
\layout Standard
\SpecialChar ~
\layout Subsection
Testfragen
\layout Section
Daten transportieren
\layout Subsection
Daten gleicher Bitbreite kopieren - MOV
\layout Standard
\SpecialChar ~
\layout Subsection
Daten austauschen - XCHG
\layout Standard
\SpecialChar ~
\layout Subsection
Daten in größere Register transportieren
\layout Standard
\SpecialChar ~
\layout Subsection
Bedingtes Setzen von Registern oder Speicherplätzen
\layout Standard
\SpecialChar ~
\layout Subsection
Testfragen
\layout Standard
\SpecialChar ~
\layout Section
Ein- und Ausgabe
\layout Standard
\SpecialChar ~
\layout Section
Betriebssystemaufrufe
\layout Subsection
Allgemeines
\layout Standard
\SpecialChar ~
\layout Subsection
Ausführung von Betriebssystemaufrufen in Assembler
\layout Standard
\SpecialChar ~
\layout Subsection
Einige Nützliche Betriebssystemaufrufe
\layout Standard
\SpecialChar ~
\layout Subsection
Testfragen
\layout Standard
\SpecialChar ~
\layout Section
Bitverarbeitung
\layout Subsection
Bitweise logische Befehle
\layout Standard
\SpecialChar ~
\layout Subsection
Schiebe- und Rotationsbefehle
\layout Standard
\SpecialChar ~
\layout Subsection
Einzelbit-Befehle
\layout Standard
\SpecialChar ~
\layout Subsection
Testfragen
\layout Standard
\SpecialChar ~
\layout Section
Sprungbefehle
\layout Subsection
Unbedingter Sprungbefehl - JMP
\layout Standard
\SpecialChar ~
\layout Subsection
Bedingte Sprungbefehle
\layout Standard
\SpecialChar ~
\layout Subsection
Verzweigungen und Schleifen
\layout Standard
\SpecialChar ~
\layout Subsection
Die Loop-Befehle
\layout Standard
\SpecialChar ~
\layout Subsection
Testfragen
\layout Standard
\SpecialChar ~
\layout Section
Arithmetische Befehle
\layout Subsection
Die Darstellung von ganzen Zahlen
\layout Standard
\SpecialChar ~
\layout Subsection
Addition und Subtraktion
\layout Standard
\SpecialChar ~
\layout Subsection
Multiplikation
\layout Standard
\SpecialChar ~
\layout Subsection
Division
\layout Standard
\SpecialChar ~
\layout Subsection
Vorzeichenumkehr: NEG
\layout Standard
\SpecialChar ~
\layout Subsection
Beispiel
\layout Standard
\SpecialChar ~
\layout Subsection
Testfragen
\layout Standard
\SpecialChar ~
\layout Section
Stack und Stackbefehle
\layout Subsection
Stackorganisation
\layout Standard
\SpecialChar ~
\layout Subsection
Stacküberlauf
\layout Standard
\SpecialChar ~
\layout Subsection
Anwendungsbeispiele
\layout Standard
\SpecialChar ~
\layout Subsection
Testfragen
\layout Standard
\SpecialChar ~
\layout Section
Unterprogramme
\layout Standard
\SpecialChar ~
\layout Section
Die Gleitkommaeinheit
\layout Subsection
Gleitkommazahlen
\layout Standard
\SpecialChar ~
\layout Subsection
Aufbau der Gleitkommaeinheit
\layout Standard
\SpecialChar ~
\layout Subsection
Befehlssatz
\layout Standard
\SpecialChar ~
\layout Section
Die MMX-Einheit
\layout Subsection
SIMD, Sättigungsarithmetik und MAC-Befehle
\layout Standard
\SpecialChar ~
\layout Subsection
Register, Datenformate und Befehle
\layout Standard
\SpecialChar ~
\layout Subsection
Der PMADDWD-Befehl: Unterstützung der digitalen Signalverarbeitung
\layout Standard
\SpecialChar ~
\layout Subsection
Befehlsübersicht
\layout Standard
\SpecialChar ~
\layout Section
Die Schnittstelle zwischen Assembler und C/C++
\layout Subsection
Übersicht
\layout Standard
\SpecialChar ~
\layout Subsection
16-/32-Bit-Umgebungen
\layout Standard
\SpecialChar ~
\layout Subsection
Aufbau und Funktion des Stack
\layout Standard
\SpecialChar ~
\layout Subsection
Erzeugung von Assemblercode durch Compiler
\layout Standard
\SpecialChar ~
\layout Subsection
Steuerung der Kompilierung
\layout Standard
\SpecialChar ~
\layout Subsection
Einbindung von Assemblercode in C/C++-Programme
\layout Standard
\SpecialChar ~
\layout Section
Assemblerpraxis
\layout Subsection
Der Zeichensatz
\layout Standard
\SpecialChar ~
\layout Subsection
Die DOS-Kommandozeile - zurück in die Steinzeit
\layout Standard
\SpecialChar ~
\layout Subsection
Assemblieren, Linken, Debuggen
\layout Standard
\SpecialChar ~
\layout Subsection
Ein Rahmenprogramm
\layout Standard
\SpecialChar ~
\layout Section
Lösungen zu den Testfragen
\layout Standard
\SpecialChar ~
\layout Section
Assemblerbefehle nach Gruppen
\layout Subsection
Allgemeines
\layout Standard
\SpecialChar ~
\layout Subsection
Transportbefehle
\layout Standard
\SpecialChar ~
\layout Subsection
Logische Befehle
\layout Standard
\SpecialChar ~
\layout Subsection
Schiebe- und Rotationsbefehle
\layout Standard
\SpecialChar ~
\layout Subsection
Einzelbit-Befehle
\layout Standard
\SpecialChar ~
\layout Subsection
Arithmetische Befehle
\layout Standard
\SpecialChar ~
\layout Subsection
Stackbefehle
\layout Standard
\SpecialChar ~
\layout Subsection
Programmfluss-Steuerungsbefehle
\layout Standard
\SpecialChar ~
\layout Subsection
Stringbefehle
\layout Standard
\SpecialChar ~
\layout Subsection
Ein- und Ausgabebefehle (Input/Output)
\layout Standard
\SpecialChar ~
\layout Subsection
Schleifenbefehle
\layout Standard
\SpecialChar ~
\layout Subsection
Prozessorkontrollbefehle
\layout Standard
\SpecialChar ~
\layout Section
Übungsaufgaben und Lösungen
\layout Standard
Die folgenden Aufgaben stammen von den Übungsblättern von Lehrbeauftragtem
Dr.-Ing.
Karl-Heinrich Schmidt aus dem Sommersemester 2003
\begin_inset LatexCommand \cite{Schmidt}
\end_inset
.
\layout Subsection
Übungsblatt 2, Aufgabe 1
\layout Standard
Das
\begin_inset Quotes ald
\end_inset
Hallo Welt
\begin_inset Quotes ard
\end_inset
-C-Programm wurde hier mit GNU gcc realisiert.
Es ist in der beiligeneden Datei
\family typewriter
AufgBl2.Lsg/HelloWorld.c
\family default
enthalten, das zugehörige hier analysierte Assemblerlisting in der beiliegenden
Datei
\family typewriter
AufgBl2.Lsg/HelloWorld.listing
\family default
.
\layout Paragraph
Auch die geschweiften Klammern {} erzeugen Assemblercode.
Wozu dient der?
\layout Standard
Die öffnende geschweifte Klammer meint eigentlich den Funktionsbeginn.
main() wird dabei wie jede andere Funktion auch behandelt: zuerst den Basepoint
er der rufenden Funktion sichern und den bisherigen
\begin_inset Quotes ald
\end_inset
top of stack
\begin_inset Quotes ard
\end_inset
als eigenen
\begin_inset Quotes ald
\end_inset
bottom of stack
\begin_inset Quotes ard
\end_inset
verwenden.
Dies ist notwendig, weil indirekte Adressierung nicht mit esp, wohl aber
mit ebp möglich ist.
\layout LyX-Code
26:HelloWorld.c **** int main() {
\layout LyX-Code
29 0000 55 pushl %ebp
\layout LyX-Code
31 0001 89E5 movl %esp, %ebp
\layout Standard
Die nächsten beiden Zeilen ergeben vermutlich
\begin_inset Quotes ald
\end_inset
.align 4
\begin_inset Quotes ard
\end_inset
: die Adressen eventuell folgender lokaler Variable sollen durch 4 teilbar
sein, um schnelleren Hauptspeicherzugriff zu gewährleisten:
\layout LyX-Code
33 0003 83EC08 subl $8, %esp
\layout LyX-Code
35 0006 83E4F0 andl $-16, %esp ;letztes Byte in %esp loeschen
\layout Standard
Platz schaffen für lokale Variable; da es keine lokalen Variablen gibt,
wird auch kein Platz (
\begin_inset Quotes ald
\end_inset
\family typewriter
$0
\family default
\begin_inset Quotes ard
\end_inset
) freigemacht.
Zwar wird
\family typewriter
%esp
\family default
nicht benötigt, um die lokalen Variablen anzusprechen, sondern nur
\family typewriter
%ebp
\family default
und ein negativer Index - die Variablen müssen aber trotzdem im Stack liegen,
weshalb
\family typewriter
%esp
\family default
trotzdem verändert werden muss.
\layout LyX-Code
36 0009 B8000000 movl $0, %eax
\layout LyX-Code
37 000e 29C4 subl %eax, %esp
\layout Standard
Die schließende Klammer meint eigentlich das Funktionsende:
\layout LyX-Code
29:HelloWorld.c **** }
\layout LyX-Code
47 0025 C9 leave
\layout LyX-Code
48 0026 C3 ret
\layout Paragraph*
Was macht das Maschinenprogramm für den printf() Aufruf?
\layout LyX-Code
27:HelloWorld.c **** printf("Hello World
\backslash
n");
\layout Standard
Parameterablage: dies ist eine Aufgabe des rufenden Programms.
Hier werden 12 Byte im Stack bereitgestellt, um die Textkonstante
\begin_inset Quotes ald
\end_inset
Hello World
\backslash
n
\begin_inset Quotes ard
\end_inset
hineinzukopieren, und die Adresse dieser Textkonstanten.
Das eigentliche Hineinkopieren geschieht wohl in
\family typewriter
printf
\family default
selbst.
\layout LyX-Code
39 0010 83EC0C subl $12, %esp
\layout LyX-Code
40 0013 68000000 pushl $.LC0
\layout Standard
Anschließend wird die Funktion aufgerufen:
\layout LyX-Code
42 0018 E8FCFFFF call printf
\layout Standard
Und schließlich werden die Parameter wieder vom Stack entfernt.
Es sind 16 Byte, nämlich 12 Byte die in Zeile 39 reserviert wurden und
4 Byte die in Zeile 40 für die Adresse der Textkonstanten benötigt wurden.
\layout LyX-Code
43 001d 83C410 addl $16, %esp
\layout Paragraph*
Wie wird
\family typewriter
return 0;
\family default
umgesetzt?
\layout Standard
Der Rückgabewert wird im Register
\family typewriter
%eax
\family default
zurückgegeben:
\layout LyX-Code
28:HelloWorld.c **** return 0;
\layout LyX-Code
45 0020 B8000000 movl $0, %eax
\layout Subsection
Übungsblatt 2, Aufgabe 2
\layout Paragraph*
Welche Probleme treten bei der Umsetzung von 16bit- in 32bit-Code auf?
\layout Standard
Vergleiche
\begin_inset LatexCommand \cite[Kap. 13.2]{WuestSkript}
\end_inset
.
\layout Itemize
16bit-Code verwendet ein segmentiertes Speichermodell, 32bit-Code verwendet
ein flaches Speichermodell und benutzt die Segmentregister für andere Zwecke.
\layout Itemize
Stackbefehle beziehen sich in 16bit-Code auf ein Maschinenwort von 16 Bit,
in 32bit-Code auf ein Maschinenwort von 32 Bit.
\layout Itemize
Betriebssystemanbindung unterscheidet sich: über Software-Interrupts in
16bit-Code, über Funktionsaufrufe in 32bit-Code.
\layout Paragraph*
Warum funktioniert der int- Befehl nicht?
\layout Standard
\family typewriter
int 21h
\family default
ist ein Software-Interrupt.
Er benötigt einen korrekten Verweis auf die Interrupt-Service-Routine (ISR)
in der Interrupttabelle.
Ein solcher existiert in 32bit-Umgebungen nicht.
\layout Subsection
Übungsblatt 4, Aufgabe 4
\layout Standard
Das Programm für GNU Assembler ist in der beiliegenden Datei
\family typewriter
./AufgBl04.Lsg/Int2ASCII.s
\family default
enthalten.
\layout Subsection
Übungsblatt 5, Aufgabe 1
\layout Paragraph
\begin_inset Quotes ald
\end_inset
Wählen Sie eine dieser Standardfunktionen aus (z.B.
memcpy) und implementieren Sie diese als normale C Funktion mit ähnlichem
Namen (z.B.
MemCopy).
Erstellen Sie dazu ein neues Microsoft Visual C++ Projekt (Win32-Konsolenanwend
ung).
\begin_inset Quotes ard
\end_inset
\layout Standard
Die Lösung in Form eines Microsoft Visual C++ Projektes befindet sich in
\family typewriter
./AufgBl05.Lsg
\family default
/
\family typewriter
StringCompare_VisualC++Prj/
\family default
.
\layout Paragraph
\begin_inset Quotes ald
\end_inset
Kompilieren Sie ihre C Funktion mit eingeschalteter Listing-Option und schauen
Sie sich im Listing den vom Compiler erzeugten Assembler-Code an.
\begin_inset Quotes ard
\end_inset
\layout Standard
Der Assembler-Code befindet sich vollständig in
\family typewriter
./AufgBl05.Lsg/Loesung.StringCompare.orig.asm
\family default
.
\layout Paragraph
»Führen Sie Ihr Programm im Disassembler-Fenster schrittweise aus und erläutern
Sie, was passiert.«
\layout Standard
Hier wird mit
\family typewriter
./AufgBl05.Lsg/Loesung.StringCompare.annotated.asm
\family default
eine kommentierte Version des Assemblerprogramms zur Verfügung gestellt,
was einer erläuterten Ausführung im Disassembler entspricht.
\layout Subsection
Übungsblatt 5, Aufgabe 2
\layout Paragraph
\begin_inset Quotes ald
\end_inset
Erläutern Sie (in Stichworten), wie Microsoft versucht, die Laufzeit zu
optimieren.
Welche Fähigkeiten des Prozessors werden genutzt? Welche Voraussetzung
sollte der Aufrufer beachten, damit dies gelingt?
\begin_inset Quotes ard
\end_inset
\layout Standard
Lösung ist in Form von Kommentaren zur Microsoft-Funktion enthalten in
\family typewriter
./AufgBl05.Lsg/Microsoft.strcmp.annotated.asm
\family default
.
\layout Standard
Für die Laufzeitoptimierung sind allein die häufig ausgeführten Teile wichtig,
nur diese wurden daher kommentiert.
In der Microsoft-Version ist dies das Assembler-Äquivalent zu
\layout LyX-Code
while( ! (ret = *src - *dst) && *dst)
\layout LyX-Code
++src, ++dst;
\layout Standard
also der Codeabschnitt
\family typewriter
dodwords
\family default
.
Die Codeabschnitte
\family typewriter
dopartial
\family default
und
\family typewriter
doword
\family default
werden dagegen höchstens einmal zu Beginn ausgeführt.
Da es hier allein um Assemblerprogrammierung gehen soll, wird dir unterschiedli
che Effizienz der Algorithmen selbst nicht untersucht, sondern nur die unterschi
edlich effiziente Art, den jeweiligen Algorithmus in Assembler zu implementieren.
\layout Subsection
Übungsblatt 5, Aufgabe 3
\layout Paragraph
\begin_inset Quotes ald
\end_inset
Schätzen Sie, um wie viel die Microsoft Funktion schneller ist als Ihre
Version.
(Begründung)
\begin_inset Quotes ard
\end_inset
\layout Standard
Lösung enthalten in
\family typewriter
./AufgBl05.Lsg/Microsoft.strcmp.annotated.asm
\family default
.
\layout Paragraph
\begin_inset Quotes ald
\end_inset
Stoppen Sie die Ausführungsdauer Ihrer Funktion.
[...] Rufen sie zum Vergleich die C-Standardfunktion auf.
Stoppen Sie wieder die Zeit.
\begin_inset Quotes ard
\end_inset
\layout Standard
Das Programm zum Stoppen der Ausführungszeiten für beide Funktionen ist
in
\family typewriter
./AufgBl05.Lsg/Profiler.StringCompare-vs-strcmp.cpp
\family default
enthalten.
\layout Paragraph
\begin_inset Quotes ald
\end_inset
War Ihre Schätzung richtig?
\begin_inset Quotes ard
\end_inset
\layout Standard
Ausgabe des Programms für hinreichend große Felder: Die Version von Microsoft
ist etwa 4,5\SpecialChar ~
mal schneller.
Die Schätzung »10\SpecialChar ~
mal schneller« ist wohl deshalb so ungenau, weil sie nur
auf den Speichertransferzeiten basiert (und nicht auch auf den unterschiedliche
n Ausführungszeiten der Algorithmik) und die Speichertransferzeiten nicht
so ausschlaggebend wie gedacht sind da die Routine zum Messen der Ausführungsze
it die Cache-Effekte nicht ausschließt, sondern einen Durchschnitt ermittelt.
\layout Subsection
Übungsblatt 7
\layout Subsection
Übungsblatt 8, Aufgabe 1
\layout Enumerate
Wie werden die Variablen i1, i2, f1, f2, d1, d2 initalisiert? (Assembler-Befehle
, Werte)
\begin_deeper
\layout Description
i1 (Initialisierungswert
\begin_inset Formula $99$
\end_inset
)
\begin_deeper
\layout LyX-Code
movl $99, -4(%ebp)
\end_deeper
\layout Description
i2 (Initialisierungswert
\begin_inset Formula $-1$
\end_inset
)
\begin_deeper
\layout LyX-Code
movl $-1, -8(%ebp)
\end_deeper
\layout Description
f1 (Initialisierungswert
\begin_inset Formula $42C76666_{16}$
\end_inset
)
\begin_deeper
\layout LyX-Code
movl $0x42c76666, -16(%ebp)
\end_deeper
\layout Description
f2 (Initialisierungswert
\begin_inset Formula $BE99999A_{16}$
\end_inset
)
\begin_deeper
\layout LyX-Code
movl $0xbe99999a, -20(%ebp)
\end_deeper
\layout Description
d1 (Initialisierungswert in den niederwertigen 4 Byte
\begin_inset Formula $-858993459$
\end_inset
, in den höherwertigen 4 Byte
\begin_inset Formula $1079569612$
\end_inset
)
\begin_deeper
\layout LyX-Code
movl $-858993459, -32(%ebp)
\layout LyX-Code
movl $1079569612, -28(%ebp)
\end_deeper
\layout Description
d2 (Initialisierungswert in den niederwertigen 4 Byte
\begin_inset Formula $-858993459$
\end_inset
, in den höherwertigen 4 Byte
\begin_inset Formula $1076677837$
\end_inset
)
\begin_deeper
\layout LyX-Code
movl $858993459, -40(%ebp)
\layout LyX-Code
movl $-1076677837, -36(%ebp)
\end_deeper
\end_deeper
\layout Enumerate
Wie werden diese Variablen an die jeweilige Differenzfunktion übergeben?
\begin_deeper
\layout Description
i1,\SpecialChar ~
i2 werden über den Stack übergeben, 1
\family typewriter
pushl
\family default
pro Variable
\layout Description
f1,\SpecialChar ~
f2 werden über den Stack übergeben, 1
\family typewriter
pushl
\family default
pro Variable
\layout Description
d1,\SpecialChar ~
d2 werden über den Stack übergeben, 2
\family typewriter
pushl
\family default
pro Variable
\end_deeper
\layout Enumerate
Wie werden die Parameter in der Differenzfunktion referenziert?
\begin_deeper
\layout Description
idifferenz
\begin_deeper
\layout LyX-Code
movl 12(%ebp), %edx
\layout LyX-Code
movl 8(%ebp), %eax
\end_deeper
\layout Description
fdifferenz
\begin_deeper
\layout LyX-Code
flds 8(%ebp)
\layout LyX-Code
fsubs 12(%ebp)
\end_deeper
\layout Description
ddifferenz
\begin_deeper
\layout LyX-Code
fldl -8(%ebp)
\layout LyX-Code
fsubl -16(%ebp)
\end_deeper
\end_deeper
\layout Enumerate
Mit welchen Befehlen wird die Subtraktion jeweils ausgeführt?
\begin_deeper
\layout Description
idifferenz
\family typewriter
subl
\layout Description
fdifferenz
\family typewriter
fsubs
\layout Description
ddifferenz
\family typewriter
fsubl
\end_deeper
\layout Enumerate
Wie werden die Funktionswerte an den Aufrufer zurückgeliefert?
\begin_deeper
\layout Description
idifferenz
\begin_deeper
\layout LyX-Code
movl -4(%ebp), %eax
\end_deeper
\layout Description
fdifferenz
\begin_deeper
\layout LyX-Code
movl -4(%ebp), %eax
\layout LyX-Code
movl %eax, -8(%ebp)
\layout LyX-Code
flds -8(%ebp)
\end_deeper
\layout Description
ddifferenz
\begin_deeper
\layout LyX-Code
movl -24(%ebp), %eax
\layout LyX-Code
movl -20(%ebp), %edx
\layout LyX-Code
movl %eax, -32(%ebp)
\layout LyX-Code
movl %edx, -28(%ebp)
\layout LyX-Code
fldl -32(%ebp)
\end_deeper
\end_deeper
\layout Enumerate
Und wie kopiert der Aufrufer diese in die Ergebnisvariablen?
\begin_deeper
\layout Description
idifferenz
\begin_deeper
\layout LyX-Code
movl %eax, -12(%ebp)
\end_deeper
\layout Description
fdifferenz
\begin_deeper
\layout LyX-Code
fstps -24(%ebp)
\end_deeper
\layout Description
ddifferenz
\begin_deeper
\layout LyX-Code
fstpl -48(%ebp)
\end_deeper
\end_deeper
\layout Enumerate
Wie sehen die Gleitkomma-Werte f1, f2, f3, d1, d2, d3 in hexadezimaler Form
aus? Ermittelt per Debugger bzw.
direkt aus dem Assemblerlisting.
\begin_deeper
\layout Description
f1
\begin_inset Formula $42C76666_{16}$
\end_inset
, war im Assemblerlisting in diesem Format gegeben.
\begin_inset Note
collapsed true
\layout Standard
Ermittlung mit gdb:
\begin_inset Quotes ald
\end_inset
x/1xw $ebp-16
\begin_inset Quotes ard
\end_inset
; Adresse relativ zu ebp ist aus dem Assemblerlistung zu ermitteln.
\end_inset
\layout Description
f2
\begin_inset Formula $BE99999A_{16}$
\end_inset
, war im Assemblerlisting in diesem Format gegeben.
\begin_inset Note
collapsed true
\layout Standard
Ermittlung mit gdb:
\begin_inset Quotes ald
\end_inset
x/1xw $ebp-20
\begin_inset Quotes ard
\end_inset
; Adresse relativ zu ebp ist aus dem Assemblerlistung zu ermitteln.
\end_inset
\layout Description
f3
\begin_inset Formula $42C80000_{16}$
\end_inset
\layout Description
d1
\begin_inset Formula $4058eccccccccccd_{16}$
\end_inset
\layout Description
d2
\begin_inset Formula $42c800004058eccc_{16}$
\end_inset
\layout Description
d3
\begin_inset Formula $4059000000000000_{16}$
\end_inset
\end_deeper
\layout Subsection
Übungsblatt 8, Aufgabe 2
\layout Standard
Zugehöriger Quelltext in
\family typewriter
Solution.PiValue.cc
\family default
.
\layout Description
ST(0)
\begin_deeper
\layout Description
Dezimal
\begin_inset Formula $3.1415926535897932385128089594061862$
\end_inset
\layout Description
Hexadezimal
\begin_inset Formula $4000C90FDAA22168C235_{16}$
\end_inset
\end_deeper
\layout Description
d3
\begin_deeper
\layout Description
Dezimal
\begin_inset Formula $3.1415926535897931$
\end_inset
\layout Description
Hexadezimal
\begin_inset Formula $400921fb54442d18_{16}$
\end_inset
\layout Description
Hexadezimal\SpecialChar ~
Interpretiert
\begin_deeper
\layout Description
Mantisse
\begin_inset Formula $921fb54442d18_{16}$
\end_inset
\layout Description
Exponent
\begin_inset Formula $400_{16}$
\end_inset
\layout Description
Vorzeichen
\begin_inset Formula $0_{16}$
\end_inset
\end_deeper
\end_deeper
\layout Description
f3
\begin_deeper
\layout Description
Dezimal
\begin_inset Formula $3.14159274$
\end_inset
\layout Description
Hexadezimal
\begin_inset Formula $40490fdb_{16}$
\end_inset
\layout Description
Hexadezimal\SpecialChar ~
Interpretiert
\begin_deeper
\layout Description
Mantisse
\begin_inset Formula $490fdb_{16}$
\end_inset
\layout Description
Exponent
\begin_inset Formula $40_{16}$
\end_inset
\layout Description
Vorzeichen
\begin_inset Formula $0_{16}$
\end_inset
\end_deeper
\end_deeper
\layout Subsection
Übungsblatt 8, Aufgabe 3
\layout Standard
\begin_inset Tabular
\begin_inset Text
\layout Standard
float
\end_inset
|
\begin_inset Text
\layout Standard
binär als
\family typewriter
Vorzeichen:Exponent:Mantisse
\end_inset
|
\begin_inset Text
\layout Standard
hexadezimal
\end_inset
|
\begin_inset Text
\layout Standard
\begin_inset Formula $1.0$
\end_inset
\end_inset
|
\begin_inset Text
\layout Standard
\family typewriter
0:0111111 1:0000000 00000000 00000000b
\end_inset
|
\begin_inset Text
\layout Standard
\family typewriter
3f80 0000h
\end_inset
|
\begin_inset Text
\layout Standard
\begin_inset Formula $2.0$
\end_inset
\end_inset
|
\begin_inset Text
\layout Standard
\family typewriter
0:1000000 0:0000000 00000000 00000000b
\end_inset
|
\begin_inset Text
\layout Standard
\family typewriter
4000 0000h
\end_inset
|
\begin_inset Text
\layout Standard
\begin_inset Formula $5.0$
\end_inset
\end_inset
|
\begin_inset Text
\layout Standard
\family typewriter
0:1000000 1:0100000 00000000 00000000b
\end_inset
|
\begin_inset Text
\layout Standard
\family typewriter
40a0 0000h
\end_inset
|
\begin_inset Text
\layout Standard
\begin_inset Formula $100.0$
\end_inset
\end_inset
|
\begin_inset Text
\layout Standard
\family typewriter
0:1000010 1:1001000 00000000 00000000b
\end_inset
|
\begin_inset Text
\layout Standard
\family typewriter
42c8 0000h
\end_inset
|
\begin_inset Text
\layout Standard
\begin_inset Formula $256.0$
\end_inset
\end_inset
|
\begin_inset Text
\layout Standard
\family typewriter
0:1000011 1:0000000 00000000 00000000b
\end_inset
|
\begin_inset Text
\layout Standard
\family typewriter
4380 0000h
\end_inset
|
\begin_inset Text
\layout Standard
\begin_inset Formula $0.2$
\end_inset
\end_inset
|
\begin_inset Text
\layout Standard
\family typewriter
0:0111110 0:1001100 11001100 11001101b
\end_inset
|
\begin_inset Text
\layout Standard
\family typewriter
3e4c cccdh
\end_inset
|
\begin_inset Text
\layout Standard
\begin_inset Formula $0.125$
\end_inset
\end_inset
|
\begin_inset Text
\layout Standard
\family typewriter
0:0111110 0:0000000 00000000 00000000b
\end_inset
|
\begin_inset Text
\layout Standard
\family typewriter
3e00 0000h
\end_inset
|
\begin_inset Text
\layout Standard
\begin_inset Formula $-0.5$
\end_inset
\end_inset
|
\begin_inset Text
\layout Standard
\family typewriter
1:0111111 0:0000000 00000000 00000000b
\end_inset
|
\begin_inset Text
\layout Standard
\family typewriter
bf00 0000h
\end_inset
|
\end_inset
\layout Subsection
Klausur Wüst 1999-07, Aufgabe 1
\layout Standard
Geben Sie bitte in hexadezimaler Schreibweise an, welchen Ingalt die Register
AX, BX, CX und DX nach dem Durchlaufen des folgenden Programmstücks haben:
\layout Standard
Als Schreibtischtest:
\layout Standard
\begin_inset Tabular
\begin_inset Text
\layout Standard
nach Anweisung
\begin_inset Formula $\downarrow$
\end_inset
ist:
\end_inset
|
\begin_inset Text
\layout Standard
AX
\end_inset
|
\begin_inset Text
\layout Standard
BX
\end_inset
|
\begin_inset Text
\layout Standard
CX
\end_inset
|
\begin_inset Text
\layout Standard
DX
\end_inset
|
\begin_inset Text
\layout Standard
xor dx,dx
\end_inset
|
\begin_inset Text
\layout Standard
\end_inset
|
\begin_inset Text
\layout Standard
\end_inset
|
\begin_inset Text
\layout Standard
\end_inset
|
\begin_inset Text
\layout Standard
0000h
\end_inset
|
\begin_inset Text
\layout Standard
mov ax,5
\end_inset
|
\begin_inset Text
\layout Standard
0005h
\end_inset
|
\begin_inset Text
\layout Standard
\end_inset
|
\begin_inset Text
\layout Standard
\end_inset
|
\begin_inset Text
\layout Standard
\end_inset
|
\begin_inset Text
\layout Standard
mov bx,2
\end_inset
|
\begin_inset Text
\layout Standard
\end_inset
|
\begin_inset Text
\layout Standard
0002h
\end_inset
|
\begin_inset Text
\layout Standard
\end_inset
|
\begin_inset Text
\layout Standard
\end_inset
|
\begin_inset Text
\layout Standard
div bx
\end_inset
|
\begin_inset Text
\layout Standard
0002h
\end_inset
|
\begin_inset Text
\layout Standard
\end_inset
|
\begin_inset Text
\layout Standard
\end_inset
|
\begin_inset Text
\layout Standard
0001h
\end_inset
|
\begin_inset Text
\layout Standard
div bx
\end_inset
|
\begin_inset Text
\layout Standard
8001h
\end_inset
|
\begin_inset Text
\layout Standard
\end_inset
|
\begin_inset Text
\layout Standard
\end_inset
|
\begin_inset Text
\layout Standard
0000h
\end_inset
|
\begin_inset Text
\layout Standard
mov cx,092A2h
\end_inset
|
\begin_inset Text
\layout Standard
\end_inset
|
\begin_inset Text
\layout Standard
\end_inset
|
\begin_inset Text
\layout Standard
92A2h
\end_inset
|
\begin_inset Text
\layout Standard
\end_inset
|
\begin_inset Text
\layout Standard
sub cl,ch
\end_inset
|
\begin_inset Text
\layout Standard
\end_inset
|
\begin_inset Text
\layout Standard
\end_inset
|
\begin_inset Text
\layout Standard
9210h
\end_inset
|
\begin_inset Text
\layout Standard
\end_inset
|
\begin_inset Text
\layout Standard
xor ch,ch
\end_inset
|
\begin_inset Text
\layout Standard
\end_inset
|
\begin_inset Text
\layout Standard
\end_inset
|
\begin_inset Text
\layout Standard
0010h
\end_inset
|
\begin_inset Text
\layout Standard
\end_inset
|
\begin_inset Text
\layout Standard
or bx,cx
\end_inset
|
\begin_inset Text
\layout Standard
\end_inset
|
\begin_inset Text
\layout Standard
0012h
\end_inset
|
\begin_inset Text
\layout Standard
\end_inset
|
\begin_inset Text
\layout Standard
\end_inset
|
\begin_inset Text
\layout Standard
rol bx,1
\end_inset
|
\begin_inset Text
\layout Standard
\end_inset
|
\begin_inset Text
\layout Standard
0024h
\end_inset
|
\begin_inset Text
\layout Standard
\end_inset
|
\begin_inset Text
\layout Standard
\end_inset
|
\end_inset
\layout Subsection
Klausur Wüst 2002-07, Aufgabe 2
\layout Standard
Schreiben Sie in Asssembler eine Prozedur, die zwei Bitmuster vergleicht
und feststellt, welches die niedrigste Bitposition ist, auf der die beiden
Bitmuster übereinstimmen.
Beispiel: Bei den Bitmustern 00110011 und 01011100 ist die niedrigste übereinst
immende Bitposition die Bitposition 4.
Die Schnittstelle soll sein:
\layout Description
Vor\SpecialChar ~
Aufruf: \SpecialChar ~
\newline
EAX: erstes Bitmuster
\newline
EBX: zweites Bitmuster
\layout Description
Nach\SpecialChar ~
Aufruf: \SpecialChar ~
\newline
ECX: Die niedrigste übereinstimmende Bitposition.
\layout LyX-Code
xor eax,ebx
\layout LyX-Code
not eax
\layout LyX-Code
mov ecx,0
\layout LyX-Code
cmp eax,0
\layout LyX-Code
jz ende
\layout LyX-Code
schleife:
\layout LyX-Code
test eax,1
\layout LyX-Code
jnz ende
\layout LyX-Code
shr eax
\layout LyX-Code
inc ecx
\layout LyX-Code
jmp schleife
\layout LyX-Code
ende:
\layout Section
Assembler unter Linux
\layout Standard
Unter Linux ergibt sich eine Möglichkeit, mit freier Software Assembler
zu üben.
Hier einige Hinweise, was man dazu braucht und wie man es verwendet.
\layout Subsection
Informationsquellen
\layout Standard
Siehe
\begin_inset LatexCommand \cite{LinuxAssembly}
\end_inset
,
\begin_inset LatexCommand \cite{GAS-Annot}
\end_inset
,
\begin_inset LatexCommand \cite{GAS-Doku}
\end_inset
,
\begin_inset LatexCommand \cite{LinuxSyscall}
\end_inset
.
\layout Subsection
Programm-Grundgerüst
\layout Standard
In der beiliegenden Datei
\family typewriter
LinuxAsm.HelloWorld.s
\family default
ein einfaches HelloWorld-Programm als Grundgerüst für eigene Programme.
Ähnlich dem in
\begin_inset LatexCommand \cite[6.2. Hello, world!]{LinuxAssembly}
\end_inset
(siehe hier für weitere Informationen \SpecialChar \ldots{}
), jedoch angepasst auf Verwendung
von Intel-Syntax statt AT&T-Syntax in GAS.
\layout Bibliography
\bibitem {WuestSkript}
Prof.
Dr.
Klaus Wüst:
\begin_inset Quotes ald
\end_inset
Die Assemblersprache der intel 80x86-Prozessoren«.
Ein sehr empfehlenswertes Skript von einem Professor der FH Gießen-Friedberg.
Diese Veranstaltung orientiert sich hauptsächlich hieran, weicht davon
jedoch zugunsten von 32-Bit-Programmierung ab.
Wer sich die Veranstaltung selbst erarbeiten will, sollte sich hieran orientier
en.
Bezugsquelle: für 2,50EUR zu kaufen in der Veranstaltung Systemprogrammierung\SpecialChar ~
1
oder Download auf der
\begin_inset LatexCommand \url[Homepage von Prof. Dr. Wüst :: Maschinennahe Programmierung]{http://homepages.fh-giessen.de/~hg6458/mprog.html}
\end_inset
.
Auch referenziert auf
\begin_inset LatexCommand \cite{Schmidt}
\end_inset
.
\layout Bibliography
\bibitem {IA32}
\begin_inset Quotes ald
\end_inset
IA-32 Intel Architektur Software Developer's Manual
\begin_inset Quotes ard
\end_inset
.
Download unter
\begin_inset LatexCommand \url{http://www.intel.com/design/pentium4/manuals}
\end_inset
oder
\begin_inset LatexCommand \url{ftp://download.intel.com/design/pentium4/manuals}
\end_inset
.
\layout Bibliography
\bibitem {MSVC-ASM}
\begin_inset Quotes ald
\end_inset
Microsoft Visual C++ Assembler (Inline) Topics
\begin_inset Quotes ard
\end_inset
.
Ein Kapitel aus dem Microsoft Developers Network (MSDN), dem online-Handbuch
im Microsoft Visual C++ Developer Studio.
Quelle:
\begin_inset LatexCommand \url{http://homepages.fh-giessen.de/~hg13025/msvc_asm.html}
\end_inset
.
\layout Bibliography
\bibitem {Backer}
Rainer Backer:
\begin_inset Quotes ald
\end_inset
Programmiersprache Assembler
\begin_inset Quotes ard
\end_inset
; rororo Verlag.
Es befasst sich ausschließlich mit den Prozessoren 8086 bis 80486.
Es ist in einigen Exemplaren in der Bibliothek der FH Gießen-Friedberg
vorhanden.
\layout Bibliography
\bibitem {Link}
Wolfgang Link:
\begin_inset Quotes ald
\end_inset
Assembler Programmierung
\begin_inset Quotes ard
\end_inset
; Franzis Verlag.
\layout Bibliography
\bibitem {Schmidt}
\begin_inset LatexCommand \url[Homepage von Lehrbeauftragtem Dr.-Ing. K.-H. Schmidt]{http://homepages.fh-giessen.de/~13025}
\end_inset
.
Hier stehen alle Übungsblätter und wichtige Ankündigungen zur Veranstaltung
\begin_inset Quotes ald
\end_inset
Systemprogrammierung\SpecialChar ~
1
\begin_inset Quotes ard
\end_inset
zur Verfügung, außerdem auch
\begin_inset LatexCommand \cite{WuestSkript}
\end_inset
.
\layout Bibliography
\bibitem {LinuxAssembly}
Konstantin Boldyshev und Francois-Rene Rideau:
\begin_inset Quotes ald
\end_inset
Linux Assembly HOWTO
\begin_inset Quotes ard
\end_inset
.
Wohl Teil des Linux Documentation Project.
Mit vielen Linux-Distributionen standardmäßig mitinstalliert, etwa unter
\family typewriter
/usr/share/doc/howto/en/html/Assembly-HOWTO/index.html
\family default
.
\layout Bibliography
\bibitem {GAS-Annot}
\begin_inset Quotes ald
\end_inset
2.12, 2.13 vs previous versions:
\begin_inset Quotes ard
\end_inset
Einige Anmerkungen zum GNU-Assembler GAS.
Quelle
\begin_inset LatexCommand \url{http://www.lxhp.in-berlin.de/lhpas86.html}
\end_inset
.
\layout Bibliography
\bibitem {GAS-Doku}
Dokumentation zum GNU-Assembler GAS.
Wenn GAS installiert wurde, ist diese Dokumentation als TeX-Info-Manual
\begin_inset Quotes ald
\end_inset
as
\begin_inset Quotes ard
\end_inset
erreichbar, etwa mit
\begin_inset Quotes ald
\end_inset
info as
\begin_inset Quotes ard
\end_inset
.
\layout Bibliography
\bibitem {LinuxSyscall}
H.-Peter Recktenwald:
\begin_inset Quotes ald
\end_inset
Reference to Linux 2.{2,4} System Calls for Assembly Level Access
\begin_inset Quotes ard
\end_inset
.
Quelle
\begin_inset LatexCommand \url{http://www.lxhp.in-berlin.de/lhpsyscal.html}
\end_inset
.
\layout Bibliography
\bibitem {Mueller}
Martin Müller:
\begin_inset Quotes ald
\end_inset
Oft geschriebene Programme in Maschinennahe Programmierung bei Prof.
Dr.
K.
Wüst«; Version vom 26.6.2002.
\begin_inset LatexCommand \url{http://homepages.fh-giessen.de/~hg11474/dateien/Assembler/MaschProg_-_Oft_geschriebene_Programme.pdf}
\end_inset
.
Der Link wurde vom Autor großzügigerweise zur Verfügung gestellt.
\layout Bibliography
\bibitem {WuestKlausur}
Klausuren von Prof.
Dr.
Wüst.
Dateinamen etwa Asmkl702.pdf, Amkl799.pdf.
\layout Standard
\begin_inset LatexCommand \printindex{}
\end_inset
\the_end