2A03:7846:B93F:101:93BB:EBBB:DD0A:99DC am 12. Juni 2025 um 19:15 Uhr

2025-06-12T19:15:04Z

Neue Seite

Eine '''Assemblersprache''', kurz auch '''Assembler''' genannt (von {{enS|to assemble|de=zusammenfügen}}), ist eine [[Programmiersprache]], die auf den [[Befehlssatz|Befehlsvorrat]] eines bestimmten Computertyps (d. h. dessen [[Prozessor]]architektur) ausgerichtet ist.

Assemblersprachen bezeichnet man deshalb als maschinenorientierte Programmiersprachen und – als Nachfolger der direkten Programmierung mit Zahlencodes – als Programmiersprachen der [[Programmiersprache#Sprachgenerationen|zweiten Generation]]: Anstelle eines [[Binärcode]]s der [[Maschinensprache]] können [[Anweisung (Programmierung)|Befehle]] und deren Operanden durch leichter verständliche ''mnemonische Symbole'' in Textform (z. B. „MOVE“), Operanden z. T. als [[Speicheradresse|symbolische Adresse]] (z. B. „PLZ“), notiert und dargestellt werden.<ref name="InfDud">''Informatik Duden''. ISBN 3-411-05232-5.</ref>

Der [[Quelltext]] eines Assemblerprogramms wird mit Hilfe einer Übersetzungssoftware ([[Assembler (Informatik)|Assembler]] oder Assemblierer) in Maschinencode übersetzt. Dagegen übersetzt in [[Höhere Programmiersprache|höheren Programmiersprachen]] (Hochsprachen, dritte Generation) ein sogenannter [[Compiler]] abstraktere (komplexere, nicht auf den Prozessor-Befehlssatz begrenzte) Befehle in den Maschinencode der gegebenen Zielarchitektur – oder in eine Zwischensprache.<ref>Hering, Gutekunst, Dyllon: ''Handbuch der praktischen und technischen Informatik''. S. 302, [http://books.google.de/books?id=YrcRhsYrVYgC&hl=de books.google.de]</ref>

Umgangssprachlich werden die Ausdrücke „Maschinensprache“ und „Assembler(sprache)“ häufig synonym verwendet.

== Übersicht ==
Ein Quelltext in Assemblersprache wird auch als ''Assemblercode'' bezeichnet. Programme in Assemblersprachen zeichnen sich dadurch aus, dass alle Möglichkeiten des [[Mikroprozessor]]s genutzt werden können, was heutzutage selten erforderlich ist. Sie werden im Allgemeinen nur noch dann verwendet, wenn Programme bzw. einzelne Teile davon sehr zeitkritisch sind, z. B. beim [[Hochleistungsrechnen]] oder bei [[Echtzeitsystem]]en. Ihre Nutzung kann auch dann sinnvoll sein, wenn für die Programme nur sehr wenig Speicherplatz zur Verfügung steht (z. B. in [[Eingebettetes System|eingebetteten Systemen]]).

Unter dem Aspekt der Geschwindigkeitsoptimierung kann der Einsatz von Assemblercode auch bei verfügbaren hochoptimierenden Compilern noch seine Berechtigung haben, Vor- und Nachteile sollten aber für die spezifische Anwendung abgewogen werden.
Bei komplexer Technik wie [[Intel Itanium]] und verschiedenen [[Digitaler Signalprozessor|digitalen Signalprozessoren]] kann ein Compiler u. U. durchaus besseren Code erzeugen als ein durchschnittlicher Assemblerprogrammierer, da das Ablaufverhalten solcher Architekturen mit komplexen mehrstufigen intelligenten Optimierungen (z. B. [[Out-of-order execution]], [[Pipeline-Hazard|Pipeline-Stalls]], …) hochgradig nichtlinear ist.
Die Geschwindigkeitsoptimierung wird immer komplexer, da zahlreiche Nebenbedingungen eingehalten werden müssen. Dies ist ein gleichermaßen wachsendes Problem sowohl für die immer besser werdenden Compiler der [[Höhere Programmiersprache|Hochsprache]]n als auch für Programmierer der Assemblersprache. Für einen optimalen Code wird immer mehr Kontextwissen benötigt (z. B. [[Cache]]nutzung, räumliche und zeitliche [[Lokalitätseigenschaft|Lokalität]] der Speicherzugriffe), welches der Assemblerprogrammierer teilweise (im Gegensatz zum Compiler) durch [[Profiler (Programmierung)|Laufzeitprofiling]] des ausgeführten Codes in seinem angestrebten Anwendungsfeld gewinnen kann. Ein Beispiel hierfür ist der [[Streaming SIMD Extensions|SSE]]-Befehl MOVNTQ, welcher wegen des fehlenden Kontextwissens von Compilern kaum optimal eingesetzt werden kann.

Die Rückwandlung von Maschinencode in Assemblersprache wird [[Disassembler|Disassemblierung]] genannt. Der Prozess ist allerdings bei fehlenden Debug-Informationen hochgradig verlustbehaftet, da sich viele Informationen wie ursprüngliche [[Bezeichner]] oder [[Kommentar (Programmierung)|Kommentare]] nicht wiederherstellen, da diese beim Assemblieren nicht in den Maschinencode übernommen oder berechnet wurden.

== {{Anker|Mnemonic}}Beschreibung ==
Programmbefehle in [[Maschinensprache]] bilden sich aus dem Operationscode ([[Opcode]]) und meist weiteren, je nach Befehl individuell festgelegten Angaben wie Adressen, im Befehl eingebettete Literale, Längenangaben etc. Da die Zahlenwerte der Opcodes schwierig zu merken sind, verwenden Assemblersprachen leichter merkbare Kürzel, sogenannte ''mnemonische Symbole'' (kurz ''Mnemonics'').<ref>Jörg Roth: ''Die Maschinenprogrammebene eines Rechners'' [https://web.archive.org/web/20181017123735/https://www.in.th-nuernberg.de/professors/roth/WS0607/GDI/Zusatzmaterial/Kap5_B_Assembler_und_Befehle.pdf Kapitel ''Maschinensprache und Assembler''] (Archiv-Version vom 17. Oktober 2018), abgerufen am 19. November 2020.</ref>

Beispiel: Der folgende Befehl in der Maschinensprache von [[x86-Prozessor]]en

10110000 01100001 ''(in [[Hexadezimalsystem|hexadezimaler]] Darstellung: 'B0 61')''

entspricht dem Assemblerbefehl
<syntaxhighlight lang="asm" style="overflow:auto; white-space:pre;">
movb $0x61, %al # AT&T-Syntax (alles nach „#“ ist Kommentar)
# mnemonisches Kürzel bedeutet „move_byte von/was , nach“
</syntaxhighlight>
bzw.
<syntaxhighlight lang="asm" style="overflow:auto; white-space:pre;">
mov al, 61h ; Intel-Syntax; das ‚mov‘ als mnemotechnisches Kürzel erkennt
; aus dem angesprochenen ‚al‘, dass nur 1 Byte kopiert werden soll.
; „mov wohin , was/woher“
</syntaxhighlight>
und bedeutet, dass der hexadezimale Wert „61“ (dezimal 97) in den niederwertigen Teil des [[Register (Computer)|Registers]] „ax“ geladen wird; „ax“ bezeichnet das ganze Register, „al“ (für low) den niederwertigen Teil des Registers. Der hochwertige Teil des Registers kann mit „ah“ angesprochen werden (für „high“).

Am Beispiel ist zu erkennen, dass – obwohl in denselben Maschinencode übersetzt wird – die beiden Assembler-Dialekte deutlich verschieden formulieren.
* Die Information, dass ein Byte zu kopieren ist, steckt bei AT&T im „mov'''b'''“; der Intel-mov entnimmt sie dem Umstand, dass Register(teil) „al“ ein Byte groß ist.
* Quelle und Ziel des Kopierens werden vertauscht angegeben.
* Auch das Format zum Ansprechen eines Registers sowie zur Angabe eines direkten Zahlenwerts ist verschieden.

Mit Computerhilfe kann man das eine in das andere weitgehend eins zu eins übersetzen. Jedoch werden Adressumformungen vorgenommen, so dass man symbolische Adressen benutzen kann. Die Eingabedaten für einen Assembler enthalten neben den eigentlichen Codes/Befehlen (die er in Maschinencode übersetzt) auch ''Steueranweisungen,'' die seine Arbeitsweise bestimmen/festlegen, zum Beispiel zur Definition eines Basisregisters.

Häufig werden komplexere Assemblersprachen ([[Makro]]assembler) verwendet, um die Programmierarbeit zu erleichtern. Makros sind dabei im [[Quelltext]] enthaltene Aufrufe, die vor dem eigentlichen Assemblieren automatisch durch (meist kurze) Folgen von Assemblerbefehlen ersetzt werden. Dabei können einfache, durch Parameter steuerbare Ersetzungen vorgenommen werden. Die Disassemblierung von derart generiertem Code ergibt allerdings den reinen Assemblercode ohne die beim Übersetzen expandierten Makros.

== Beispielprogramm ==
Ein sehr einfaches Programm, das zu Demonstrationszwecken häufig benutzte [[Hallo-Welt-Programm|''Hallo-Welt''-Beispielprogramm]], kann zum Beispiel in der Assemblersprache [[Microsoft Macro Assembler|MASM]] für [[MS-DOS]] aus folgendem Assemblercode bestehen:
<syntaxhighlight lang="asm" style="overflow:auto; white-space:pre;">
ASSUME CS:CODE, DS:DATA ;- dem Assembler die Zuordnung der Segmentregister zu den Segmenten mitteilen

DATA SEGMENT ;Beginn des Datensegments
Meldung db "Hallo Welt" ;- Zeichenkette „Hallo Welt“
db 13, 10 ;- Neue Zeile
db "$" ;- Zeichen, das die Textausgabefunktion (INT 21h, Unterfunktion 09h) als Zeichenkettenende versteht
DATA ENDS ;Ende des Datensegments

CODE SEGMENT ;Beginn des Codesegments
Anfang: ;- Einsprung-Label fuer den Anfang des Programms
mov ax, DATA ;- Adresse des Datensegments in das Register „AX“ laden
mov ds, ax ; In das Segmentregister „DS“ uebertragen (das DS-Register kann nicht direkt mit einem Wert beschrieben werden)
mov dx, OFFSET Meldung ;- die zum Datensegment relative Adresse des Textes in das „DX“ Datenregister laden
; die vollstaendige Adresse von „Meldung“ befindet sich nun im Registerpaar DS:DX
mov ah, 09h ;- die Unterfunktion 9 des Betriebssysteminterrupts 21h auswaehlen (Textausgaberoutine)
int 21h ;- den Betriebssysteminterrupt 21h aufrufen (hier erfolgt die Ausgabe des Textes am Schirm)
mov ax, 4C00h ;- die Unterfunktion 4Ch (Programmbeendigung) des Betriebssysteminterrupts 21h festlegen
int 21h ;- damit wird die Kontrolle wieder an das Betriebssystem zurueckgegeben (Programmende)
CODE ENDS ;Ende des Codesegments

END Anfang ;- dem Assembler- und Linkprogramm den Programm-Einsprunglabel mitteilen
;- dadurch erhaelt der Befehlszaehler beim Aufruf des Programmes diesen Wert
</syntaxhighlight>

Vergleichende Gegenüberstellungen für das ''Hallo-Welt''-Programm in unterschiedlichen Assemblerdialekten enthält [[Liste von Hallo-Welt-Programmen/Assembler|diese Liste.]]

In einem [[Pascal (Programmiersprache)|Pascal]]-Quelltext (eine Hochsprache) kann der Programmcode für <code>„Hallo Welt“</code> dagegen deutlich kürzer sein:

<syntaxhighlight lang="pascal">
program Hallo(output);
begin
writeln('Hallo Welt')
end.
</syntaxhighlight>

== Verschiedene Assemblersprachen ==
Jede Computerarchitektur hat ihre eigene Maschinensprache und damit Assemblersprache. Mitunter existieren auch mehrere Assemblersprachen-Dialekte („verschiedene Assemblersprachen“, sowie zugehörige Assembler) für die gleiche Prozessorarchitektur. Die Sprachen verschiedener Architekturen unterscheiden sich in Anzahl und Typ der Operationen.

Jedoch haben alle Architekturen die folgenden grundlegenden Operationen:
* Daten lesen und schreiben von/nach Hauptspeicher in/aus dem Prozessor (i. A. von/zu einem [[Register (Computer)|Register]]); fast immer auch von-Register-zu-Register, meistens auch von-Hauptspeicher-zu-Hauptspeicher,
* einfache logische Operationen (z. B. [[Bitweiser Operator|Bit-Operationen wie AND/OR/NOT/SHIFT]]),
* einfache Kontrolle des Programmflusses (v. a. durch [[Flag (Informatik)#Flags im Prozessor|Prozessor-Flag]]-bedingte Sprünge),
* einfache arithmetische Operationen (z. B. Ganzzahl-Addition, Ganzzahl-Vergleich).

Bestimmte Rechnerarchitekturen haben oft auch komplexere Befehle ([[Complex Instruction Set Computer|CISC]]) wie z. B.:
* Aufrufe von Ein- bzw. Ausgabegeräten,
* eine einfache Operation (z. B. Addition) auf einen Vektor von Werten anwenden,
* Speicherblock-Operationen (z. B. kopieren oder mit Nullen füllen),
* höhere Arithmetik: Befehle, die durch (mehrere) einfache nachgebaut werden könnten (z. B. „Verringere Wert in Register A um 1; wenn es nun =0 ist, springe an Programmstelle xyz“ (<code>DJZ A,xyz</code> ~ 'decrement A, Jump if Zero to xyz')),
* Gleitkomma-Arithmetik wie Gleitkomma-Addition, -Multiplikation, [[Sinus und Kosinus|Sinus-, Kosinus]]- und Wurzelberechnung (entweder über spezielle Zusatzprozessoren realisiert oder über Softwareroutinen),
* massive, direkte Parallelprogrammierbarkeit des Prozessors, etwa bei [[Digitaler Signalprozessor|digitalen Signalprozessoren]],
* Synchronisation mit anderen Prozessoren für [[Symmetrisches Multiprozessorsystem|SMP]]-Systeme,
* Unterbrechungssteuerungen, die besonders für [[Prozessrechner]] benötigt werden.

== Geschichte ==
Die erste Assemblersprache wurde 1947 von [[Kathleen Booth]] entwickelt.<ref name="Dufresne_2018">{{Internetquelle |autor=Steven Dufresne |url=https://hackaday.com/2018/08/21/kathleen-booth-assembling-early-computers-while-inventing-assembly |titel=Kathleen Booth: Assembling Early Computers While Inventing Assembly |datum=2018-08-21 |archiv-url=https://web.archive.org/web/20200324150537/https://hackaday.com/2018/08/21/kathleen-booth-assembling-early-computers-while-inventing-assembly/ |archiv-datum=2020-03-24 |abruf=2019-02-10 |sprache=en}}</ref><ref name="Booth_1947">{{Literatur |Autor=[[Andrew Donald Booth]], [[Kathleen Booth|Kathleen Hylda Valerie Britten]] |Titel=General considerations in the design of an all purpose electronic digital computer |Auflage=2 |Verlag=[[Birkbeck College, London]] |Ort=The Institute for Advanced Study, Princeton, New Jersey, USA |Datum=1947-09 |Sprache=en |Online=[https://web.archive.org/web/20200324161441/http://mt-archive.info/Booth-1947.pdf Online] |Abruf=2019-02-10 |Zitat=The non-original ideas, contained in the following text, have been derived from a number of sources, ... It is felt, however, that acknowledgement should be made to Prof. John von Neumann and to Dr. Herman Goldstein for many fruitful discussions ...}}</ref> Sie entwarf im Anschluss den [[Assembler (Informatik)|Assembler]] für die ersten Computersysteme am [[Birkbeck, University of London|Birkbeck College der University of London]]. Zwischen 1948 und 1950 schrieb [[Nathaniel Rochester]] einen der frühsten symbolischen [[Assembler (Informatik)|Assembler]] für eine [[IBM 701]].

In den 1980er und frühen 1990er Jahren wechselte die Sprache, in der Betriebssysteme für größere Rechner geschrieben wurden, von Assembler zu Hochsprachen hin, meist C, aber auch C++ oder Objective C. Hauptauslöser war die steigende Komplexität von Betriebssystemen bei größerem verfügbaren Speicher im Bereich oberhalb von einem Megabyte.
In Assembler verblieben zum Beispiel das Zwischenspeichern von Registern bei Prozesswechsel (siehe [[Prozess-Scheduler|Scheduler]]), oder bei der [[X86-Prozessor|x86]]-Architektur der Teil des Boot-Loaders, der innerhalb des 512 Byte großen [[Master Boot Record]]s untergebracht sein muss. Auch Teile von [[Gerätetreiber]]n werden in Assemblersprache geschrieben, falls aus den Hochsprachen kein effizienter Hardware-Zugriff möglich ist. Manche Hochsprachencompiler erlauben es, direkt im eigentlichen [[Quelltext|Quellcode]] Assemblercode, sogenannte [[Integrierter Assembler|Inline-Assembler]], einzubetten.

Bis ca. 1990 wurden die meisten [[Computerspiel]]e in Assemblersprachen programmiert, da nur so auf [[Heimcomputer]]n und den damaligen [[Spielkonsole]]n eine akzeptable Spielgeschwindigkeit und eine den kleinen Speicher dieser Systeme nicht sprengende Programmgröße zu erzielen war. Noch heute gehören Computerspiele zu den Programmen, bei denen am ehesten kleinere assemblersprachliche Programmteile zum Einsatz kommen, um so Prozessorerweiterungen wie [[Internet Streaming SIMD Extensions|SSE]] zu nutzen.

Bei vielen Anwendungen für Geräte, die von [[Mikrocontroller]]n gesteuert sind, war früher oft eine Programmierung in Assembler notwendig, um die knappen Ressourcen dieser Mikrocontroller optimal auszunutzen. Um Assemblercode für solche Mikrocontroller zu Maschinencode zu übersetzen, werden [[Cross-Assembler]] bei der Entwicklung eingesetzt.
Heute sind Mikrocontroller so günstig und leistungsfähig, dass moderne C-Compiler auch in diesem Bereich die Assembler weitgehend abgelöst haben. Nicht zuletzt aufgrund größerer Programmspeicher bei geringen Aufpreisen für die Chips fallen die Vorteile von Hochsprachen gegenüber den teils geringen Vorteilen der Assemblersprache immer mehr ins Gewicht.

== Vergleich zur Programmierung in einer Hochsprache ==
=== Nachteile ===
Assemblerprogramme sind sehr ''hardwarenah'' geschrieben, da sie direkt die unterschiedlichen Spezifikationen und [[Befehlssatz|Befehlssätze]] der einzelnen Computerarchitekturen (Prozessorarchitektur) abbilden. Daher kann ein Assemblerprogramm im Allgemeinen nicht auf ein anderes Computersystem (andere Prozessorarchitektur) übertragen werden, ohne dass der [[Quelltext]] angepasst wird. Das erfordert, abhängig von den Unterschieden der Assemblersprachen, hohen Umstellungsaufwand, unter Umständen ist ein komplettes Neuschreiben des Programmtextes erforderlich. Im Gegensatz dazu muss bei Hochsprachen oft nur ein [[Compiler]] für die neue Zielplattform verwendet werden.

Quelltexte in Assemblersprache sind fast immer ''deutlich länger'' als in einer Hochsprache, da die Instruktionen weniger komplex sind und deshalb gewisse Funktionen/Operationen mehrere Assemblerbefehle erfordern; z. B. müssen beim logischen Vergleich von Daten (= > < …) ungleiche [[Datenformat]]e oder -Längen zunächst angeglichen werden. Die dadurch ''größere Befehlsanzahl'' erhöht das Risiko, unübersichtlichen, schlecht strukturierten und schlecht wartbaren [[Programmcode]] herzustellen.

=== Vorteile ===
Nach wie vor dient Assembler zur Mikro-Optimierung von Berechnungen, für die der Hochsprachencompiler nicht ausreichend effizienten Code generiert.<ref name="bit-fild">{{Internetquelle |autor=Måns Rullgård |url=http://hardwarebug.org/2010/01/30/bit-field-badness/ |titel=Bit-field-badness |hrsg=hardwarebug.org |datum=2010-01-30 |archiv-url=https://web.archive.org/web/20100205120952/http://hardwarebug.org/2010/01/30/bit-field-badness/ |archiv-datum=2010-02-05 |abruf=2010-03-04 |sprache=en}}</ref><ref name="gcc-mess">{{Internetquelle |autor=Måns Rullgård |url=http://hardwarebug.org/2009/05/13/gcc-makes-a-mess/ |titel=GCC makes a mess |hrsg=hardwarebug.org |datum=2009-05-13 |archiv-url=https://web.archive.org/web/20100316212040/http://hardwarebug.org/2009/05/13/gcc-makes-a-mess/ |archiv-datum=2010-03-16 |abruf=2010-03-04 |sprache=en}}</ref> In solchen Fällen können Berechnungen effizienter direkt in Assembler programmiert werden. Beispielsweise sind im Bereich des wissenschaftlichen Rechnens die schnellsten Varianten mathematischer Bibliotheken wie [[BLAS]]<ref name="goto">{{Internetquelle |autor=John Markoff |url=http://www.nytimes.com/2005/11/28/technology/28super.html |titel=Writing the Fastest Code, by Hand, for Fun: A Human Computer Keeps Speeding Up Chips |hrsg=[[New York Times]] |datum=2005-11-28 |abruf=2010-03-04 |sprache=en}}</ref><ref name="goto-bench">{{Internetquelle |url=http://eigen.tuxfamily.org/index.php?title=Benchmark-August2008 |titel=BLAS Benchmark-August2008 |hrsg=eigen.tuxfamily.org |datum=2008-08-01 |abruf=2010-03-04 |sprache=en}}</ref> oder bei architekturabhängigen Funktionen wie der C-Standardfunktion <code>memcpy</code><ref name="amd2002">{{Internetquelle |autor=Mike Wall |url=http://web.mit.edu/ehliu/Public/ProjectX/Meetings/AMD_block_prefetch_paper.pdf |titel=Using Block Prefetch for Optimized Memory Performance (2001, Archiv-Version) |hrsg=[[Massachusetts Institute of Technology|mit.edu]] |archiv-url=https://web.archive.org/web/20170830073838/http://web.mit.edu/ehliu/Public/ProjectX/Meetings/AMD_block_prefetch_paper.pdf |archiv-datum=2017-08-30 |abruf=2020-11-19 |format=PDF; 136 kB |sprache=en}}</ref><ref name="fog2012">{{Internetquelle |autor=Agner Fog |url=http://www.agner.org/optimize/optimizing_assembly.pdf |titel=Optimizing subroutines in assembly language |hrsg=Copenhagen University College of Engineering |datum=2012-02-29 |seiten=100 |abruf=2012-09-22 |format=PDF; 873 kB |sprache=en |zitat=12.11 Loop unrolling}}</ref> weiterhin die mit Assembler-Code. Auch lassen sich gewisse, sehr systemnahe Operationen unter Umgehung des Betriebssystems (z. B. direktes Schreiben in den Bildschirmspeicher) nicht in allen Hochsprachen ausführen.

Der Nutzen von Assembler liegt auch im Verständnis der Arbeits- und Funktionsweise eines Systems, das durch Konstrukte in Hochsprachen versteckt wird. Auch heute noch wird an vielen Hochschulen Assembler gelehrt, um ein Verständnis für die Rechnerarchitektur und seine Arbeitsweise zu bekommen.

== Siehe auch ==
* [[C−−]] – eine „portable“ Assemblersprache

== Literatur ==
* Gerhard Niemeyer: ''Einführung in das Programmieren in ASSEMBLER. Systeme IBM, Siemens, Univac, Comparex, IBM-PC/370''. 6. bearbeitete und erweiterte Auflage. de Gruyter, Berlin u. a. 1989, ISBN 3-11-012174-3 (''De-Gruyter-Lehrbuch'').
* Joachim Rohde: ''Assembler ge-packt. (Schnelles und effektives Nachschlagen aller relevanten Befehlssätze für AMD und Intel. MMX und 3DNow! SSE und seine Erweiterungen)''. 2. aktualisierte Auflage. Mitp-Verlag, Heidelberg 2007, ISBN 978-3-8266-1756-0 (''Die ge-packte Referenz'').
* Joachim Rohde, Marcus Roming: ''Assembler. Grundlagen der Programmierung. (Theorie und Praxis unter DOS und Windows. MMX und 3DNOW! Programme optimieren und Reverse Engineering)''. 2. aktualisierte und erweiterte Auflage. Mitp-Verlag, Bonn 2006, ISBN 3-8266-1469-0 (''3-8266-1469-0'').
* Jeff Duntemann: ''Assembly Language Step-by-Step. Programming with DOS and Linux''. 2. Auflage. Wiley, New York NY u. a. 2000, ISBN 0-471-37523-3 (mit 1 CD-ROM).
* Paul Carter: [http://pacman128.github.io/pcasm/ ''PC Assembly Language''], 2001.
* Robert Britton: ''MIPS Assembly Language Programming''. Prentice Hall, Upper Saddle River NJ 2003, ISBN 0-13-142044-5.
* [[Steve McConnell]]: ''Code Complete. A practical Handbook of Software Construction''. Microsoft Press, Redmond WA 1993, ISBN 1-55615-484-4.
* Randall Hyde: ''The Art of Assembly Language.'' 2. Auflage, No Starch Press, 2010, ISBN 978-1593272074.

== Weblinks ==
{{Wiktionary}}
{{Wikibooks|Assembler-Programmierung für x86-Prozessoren|Assembler-Programmierung}}
* Ed Jorgensen: ''[http://www.egr.unlv.edu/~ed/assembly64.pdf x86-64 Assembly Language Programming with Ubuntu.]'' (PDF; 2,4 MB)
* [https://godbolt.org/ Compiler Explorer – interaktive Übersetzung verschiedener Ausgangssprachen im Webbrowser] (englisch)

== Einzelnachweise ==
<references />

{{Normdaten|TYP=s|GND=4003255-3|LCCN=|NDL=|VIAF=}}

[[Kategorie:Assembler]]
[[Kategorie:Programmiersprachklasse]]

Assemblersprache - Versionsgeschichte

2A03:7846:B93F:101:93BB:EBBB:DD0A:99DC am 12. Juni 2025 um 19:15 Uhr