Menu
CoddyTech

Was ist Maschinencode?

Maschinencode, auch Maschinensprache genannt, sind die binären Befehle, die ein Prozessor direkt ausführt. Jeder Befehl ist eine kurze Folge von Bytes wie b8 01 00 00 00, die der CPU sagt, dass sie verschieben, addieren, vergleichen oder springen soll, und jede Prozessorfamilie hat ihren eigenen Satz.

Von Kevin Spektor, Mitgründer & CTO

Aktualisiert am 16. November 2026

Dieses Programm schaut sich drei seiner eigenen Befehle an, die unter sample:, und gibt die Bytes aus, die der Prozessor sieht. Klicke auf Run:

b8 01 00 00 00 bf 01 00 00 00 0f 05

Diese zwölf Bytes sind der Maschinencode für die drei Zeilen unter sample:, hexadezimal geschrieben, zwei Ziffern pro Byte. Im Speicher sind sie Bits: b8 ist 10111000. Das Programm führt sie nie aus. Es liest sie wie beliebige andere Daten, denn für den Computer sind Befehle einfach Bytes im Speicher.

Die Bytes lesen

BytesAssemblerWas der Prozessor tut
b8 01 00 00 00mov rax, 1Legt die 32-Bit-Zahl 1 in eax, was auch die obere Hälfte von rax löscht
bf 01 00 00 00mov rdi, 1Dasselbe, in edi
0f 05syscallRuft das Betriebssystem auf

In den ersten beiden Befehlen ist das erste Byte der Opcode, der Teil, der sagt, was zu tun ist. Hier bedeuten b8 bis bf alle „lege die nächsten 4 Bytes in ein Register“, und das Register ergibt sich aus dem Abstand des Opcodes zu b8: eax ist Register 0, also ist sein Opcode b8, und edi ist Register 7, also ist sein Opcode b8 + 7, also bf. Nicht jeder x86-64-Befehl ist so einfach aufgebaut: Manche beginnen mit einem Präfixbyte, etwa der 48 vor vielen 64-Bit-Befehlen, und manche Opcodes sind zwei Bytes lang, wie 0f 05.

Die 4 folgenden Bytes enthalten die Zahl 1, aber rückwärts: 01 00 00 00. x86-64 ist Little-Endian, das heißt, eine Zahl aus mehreren Bytes wird mit ihrem niedrigsten Byte zuerst gespeichert. Die Zahl 258 wäre 02 01 00 00.

Auch der Assembler hat hier eine Entscheidung getroffen. Im Quelltext stand mov rax, 1, ein 64-Bit-Register, aber NASM hat den 5-Byte-Befehl für eax geschrieben, weil das Schreiben eines 32-Bit-Registers die oberen 32 Bits auf null setzt und das Ergebnis dasselbe ist. Die lange Form, 48 c7 c0 01 00 00 00, hätte 7 Bytes.

Wie der Prozessor Maschinencode ausführt

Der Prozessor hält die Adresse des nächsten Befehls in einem besonderen Register, auf x86-64 rip, genannt Befehlszeiger oder Programmzähler. Er wiederholt drei Schritte Milliarden Mal pro Sekunde:

  1. Holen (Fetch). Die Bytes an der Adresse in rip lesen.
  2. Dekodieren (Decode). Herausfinden, welcher Befehl es ist und wie lang er ist. Befehle auf x86-64 sind 1 bis 15 Bytes lang, also muss der Prozessor die ersten Bytes lesen, um zu wissen, wo der Befehl endet. ARM64-Befehle sind immer 4 Bytes lang.
  3. Ausführen (Execute). Den Befehl ausführen und dann rip auf den nächsten Befehl setzen, oder auf eine andere Adresse, wenn der Befehl ein Sprung war.

Nichts sagt dem Prozessor, ob die Bytes bei rip als Befehle gedacht waren. Schickt ihn ein Fehler an eine Adresse voller Text, dekodiert er den Text als Befehle und führt sie aus, oder er hält mit einem Fehler wegen eines ungültigen Befehls an. Moderne Betriebssysteme markieren Datenspeicher als nicht ausführbar, sodass ein Sprung dorthin stattdessen das Programm beendet; unter Linux wird das als Segmentation Fault gemeldet.

Maschinencode und Assemblersprache im Vergleich

Assemblersprache ist die Textform von Maschinencode. Die beiden entsprechen sich fast eins zu eins, sind aber nicht dasselbe:

MaschinencodeAssemblersprache
Was es istBytes, die der Prozessor ausführtText, den ein Mensch schreibt
Beispielbf 01 00 00 00mov rdi, 1
Gelesen vonDem ProzessorEinem Assembler wie NASM
Labels und KommentareKeine, nur Adressen_start:, ; comment
Daten im QuelltextEinfach weitere BytesDirektiven wie db "Hello"
An eine Prozessorfamilie gebundenJaJa

Ein Assembler geht von der rechten Spalte zur linken. Ein Disassembler wie objdump -d geht zurück: Er macht aus Bytes Assemblercode. Kommentare werden nie im Maschinencode gespeichert, sie sind also verloren. Label-Namen überleben nur in der Symboltabelle der Datei: Beim Programm oben zeigt objdump das jnz der Schleife als jne 401019 <next_byte> (zwei Namen für denselben Befehl) und, nachdem strip die Symbole entfernt hat, nur noch jne 0x401019. So lesen Menschen Programme, für die sie keinen Quellcode haben.

Maschinencode und Bytecode im Vergleich

Nicht jedes kompilierte Programm ist Maschinencode. Ein Compiler für C, C++, Go oder Rust erzeugt Maschinencode für einen Prozessor. Java kompiliert zu Bytecode in .class-Dateien, und Python kompiliert deinen Code zu Bytecode, bevor sein Interpreter ihn ausführt. Auch Bytecode hat Befehle, aber sie sind für eine virtuelle Maschine, also ein Programm, nicht für einen physischen Chip.

Deshalb läuft eine .class-Datei auf jedem Computer mit einer Java-Laufzeitumgebung, während ein kompiliertes C-Programm für jeden Prozessor und jedes Betriebssystem neu gebaut werden muss. Die beiden treffen sich in Just-in-time-Compilern (JIT): Die JVM und JavaScript-Engines wie V8 verwandeln den meistgenutzten Bytecode während der Laufzeit in Maschinencode.

Warum Maschinencode nur auf einer Art von Computer läuft

Drei Dinge müssen passen, bevor der Maschinencode eines Programms laufen kann:

  • Der Befehlssatz. x86-64 und ARM64 verwenden unterschiedliche Bytes für unterschiedliche Operationen. Mit Apples Rosetta 2 können Macs mit Apple Silicon x86-64-Programme ausführen, indem ihr Maschinencode in ARM64-Maschinencode übersetzt wird.
  • Das Dateiformat. Linux verwendet ELF-Dateien, Windows PE (.exe) und macOS Mach-O. Jedes sagt dem Betriebssystem, wo Code und Daten liegen und wo es beginnen soll.
  • Die Systemaufrufe. Das Beispiel oben bittet Linux um den Systemaufruf 1, write. Windows und macOS nummerieren ihre Dienste anders, also würden dieselben Bytes um etwas anderes bitten, oder um gar nichts.

Wie es weitergeht

Ändere die Befehle unter sample: im Assembler-Playground und führe das Programm erneut aus, um ihre Bytes zu sehen: Probiere add rax, rbx oder ret. Die Seite über Assemblersprache erklärt die Sprache, in der diese Befehle geschrieben sind, der Assembler-Spickzettel listet die gängigen Befehle, und der kostenlose Assembler-Kurs bringt dir x86-64 ab dem ersten Systemaufruf bei. Wie Bits und Bytes alles andere speichern, zeigt die Seite über das Byte.

Häufig gestellte Fragen

Besteht Maschinencode nur aus Nullen und Einsen?
Ja. Im Speicher ist jeder Befehl ein Bitmuster, und die Schaltkreise des Prozessors reagieren direkt auf diese Bits. Als Nullen und Einsen schreibt man ihn aber fast nie: Hexadezimal ist kürzer und leichter zu lesen, also wird der Befehl 10111000 00000001 00000000 00000000 00000000 als b8 01 00 00 00 geschrieben.
Was ist der Unterschied zwischen Maschinencode und Assemblersprache?
Maschinencode sind die Bytes, die der Prozessor ausführt. Assemblersprache ist eine Textform derselben Befehle, mit Namen wie mov statt Zahlen wie b8, dazu Labels und Kommentare für Menschen. Ein Assembler übersetzt Assembler in Maschinencode, und ein Disassembler übersetzt ihn zurück, wobei Labels und Kommentare unterwegs verloren gehen.
Ist Maschinencode auf jedem Computer gleich?
Nein. Jede Prozessorfamilie hat ihren eigenen Befehlssatz: Die Bytes 0f 05 bedeuten auf x86-64 syscall, während ein ARM64-Chip Befehle in Stücken von 4 Bytes liest und diesen Bytes keine solche Bedeutung gibt. Selbst auf demselben Prozessor verpacken Windows, macOS und Linux Programme in verschiedene Dateiformate und bieten verschiedene Systemaufrufe, also wird ein Programm für einen Prozessor und ein Betriebssystem gebaut.
Was ist der Unterschied zwischen Maschinencode und Bytecode?
Maschinencode läuft auf einem physischen Prozessor. Bytecode ist ein Satz von Befehlen für eine virtuelle Maschine, ein Programm, das jeden Befehl liest und ausführt. Java-Dateien .class und Python-Dateien .pyc enthalten Bytecode, der auf jedem Computer läuft, auf dem die virtuelle Maschine vorhanden ist, und ein JIT-Compiler kann die meistgenutzten Teile während der Laufzeit in Maschinencode verwandeln.
Können Menschen Maschinencode schreiben?

Ja, und die ersten Programmierer haben genau das getan: Sie gaben Zahlen von Hand über Schalter oder Lochkarten ein. Das ist langsam und fehleranfällig, weil jede Adresse von Hand ausgerechnet werden muss, und deshalb entstanden Assemblersprachen schon Ende der 1940er Jahre. Heute lesen Menschen Maschinencode in einem Debugger weit öfter, als sie ihn schreiben.

Illustration der Programmiersprachen bei Coddy

Lerne mit Coddy zu programmieren

Los geht's