Maschinensprache

aus Wikipedia, der freien Enzyklopädie
(Weitergeleitet von Maschinencode)
Wechseln zu: Navigation, Suche
Maschinenprogramm ist eine Weiterleitung auf diesen Artikel. Im Detail unterschiedliche Bedeutungen, die jedoch beide HIER im Artikel behandelt werden
Maschinencode ist eine Weiterleitung auf diesen Artikel. Maschinensprache und Maschinencode werden zum Teil als Synonyme benutzt

Maschinensprache (auch Maschinencode oder nativer Code genannt) ist eine Programmiersprache, in der die Instruktionen, die vom Prozessor eines Computers direkt ausgeführt werden können, als Sprachelemente festgelegt sind – die „Programmiersprache eines Computers“.[1] Die Menge und die formale Struktur/Syntax dieser auch „Anweisungen“ oder „Befehle“ genannten Instruktionen sind je Prozessortyp als Befehlssatz definiert.

Ein Befehl ist hierbei eine Anweisung an den Prozessor, eine bestimmte Operation durchzuführen, beispielsweise eine Addition oder einen Wertevergleich. Jede funktionelle Leistung eines Prozessors ist Ergebnis der Ausführung von Maschinencode bzw. eines Maschinenprogramms, das heißt eines in Maschinensprache vorliegenden Programms.

Abgrenzung zu anderen Programmiersprachen:

Programmcode in Maschinensprache wird heutzutage kaum mehr von Programmierern direkt erzeugt, sondern unter Nutzung einer höheren Programmiersprache oder einer Assemblersprache, wobei erst mithilfe eines Compilers und/oder Assemblers und/oder Linkers ausführbarer Maschinencode entsteht. Wird von „Programmierung in Maschinensprache“ gesprochen, ist heute üblicherweise die Programmierung in Assemblersprache gemeint. Aus den Anweisungen eines in einer Interpretersprache erstellten Programms erzeugt ein Interpreter programmintern die Maschinenbefehle, die vom Prozessor auszuführen sind.

Alternative Bezeichnungen:

Im Sprachgebrauch werden Ausdrücke wie „Maschinensprache, Maschinencode, Binärcode, nativer Code, Maschinenprogramm, ausführbare(s) Programm/Datei, Programmcode, EXE“, usw. häufig als Synonyme benutzt (Beispiel siehe [2]). Dabei stehen sie je nach Kontext für zwei unterschiedliche Bedeutungen:

  • für den Programmcode eines bestimmten Programms: z. B. „Binärcode für Programm ABC“ oder XYZ ...
... der in unterschiedlichen Speichermedien vorliegen kann: Programmbibliothek, Datei, Hauptspeicher, ggf. auch auf Papier
  • für die typisierende Bezeichnung für einen Code: z. B. „Maschinencode“ oder „Binärcode“ oder „Maschinensprache“ als Syntaxbestimmung

Maschinenprogramm[Bearbeiten]

,Maschinenprogramm‘, Begriffszusammenhänge und im Sprachgebrauch auftretende Synonyme

Maschinenprogramme finden in allen Geräten mit einem Prozessor Verwendung, also von Großrechnern über Personal Computer und Smartphones bis hin zu eingebetteten (embedded) Systemen in modernen Waschmaschinen, Radios oder Steuerungen im Kraftfahrzeug für ABS oder Airbag. Auf PCs stehen sie unter anderem in ausführbaren Dateien. Zusätzlich gibt es eine BIOS oder UEFI genannte Firmware, die den Bootvorgang einleitet und einige wichtige Funktionen fürs Betriebssystem bereitstellt.

Maschinenprogramme findet man beispielsweise auf Windows-PCs in Dateien mit der Dateinamenserweiterung „.exe“. Unter vielen anderen Betriebssystemen werden ausführbare Dateien auch ohne besondere Endung und meist in speziellen Programmbibliotheken geführt und anders bezeichnet, z. B. unter z/OS als „Lademodul“. Bei vielen eingebetteten (embedded) Systemen oder Mikrocontrollern befinden sich das Maschinenprogramm oder Teile davon, z. B. ein Bootloader, permanent im ROM.

Maschinenprogramme in einer Datei können mit einem Hex-Editor betrachtet, theoretisch auch verändert oder sogar erstellt werden. Üblicherweise erfolgt beides jedoch über den Quelltext des Programms, der programmiersprachenabhängig von einem Assembler oder Compiler in ein Maschinenprogramm übersetzt wird. Maschinencode kann durch einen Disassembler wieder in Assemblerformat rückübersetzt werden, die Umwandlung in eine höhere Programmiersprache durch einen Decompiler unterliegt jedoch starken Einschränkungen.

Unterschiede zur Assemblersprache[Bearbeiten]

Das Programm im Maschinencode besteht aus einer Folge von Bytes, die sowohl Befehle als auch Daten repräsentieren. Da dieser Code für den Menschen schwer lesbar ist, werden in der Assemblersprache die Befehle durch besser verständliche Abkürzungen, sogenannte Mnemonics, dargestellt. Quell- und Zielfelder sowie andere Angaben in den Befehlen können mit symbolischen Namen (z. B. 'ZEILE') notiert werden, ggf. ergänzt um numerische Zahlenwerte (z. B. für eine individuelle Längenangabe, Registernummern usw.).

Dateiformat
Ein Assemblerprogramm liegt, wie bei Quelltexten üblich, meist als Textdatei vor, während der Maschinencode in der Regel in einer Binärdatei gespeichert ist.
Anweisungen
Das Programmieren im Textformat mit anschließender Übersetzung in den Maschinencode durch einen Assembler gestattet dem Programmierer eine weit schnellere und einfachere Programmerstellung als das Codieren im Maschinencode. In der Regel entspricht einem Assemblerbefehl genau ein Befehl im Maschinencode außer bei Makroassemblern, die aus einer Anweisung mehrere Maschinenbefehle generieren können.
Zeichenformate
Gängige Assembler erlauben es dem Programmierer, Zeichen und Zahlen in unterschiedlichen Codeformaten (Text, dezimal, Hexadezimal, oktal, binär) zu codieren, und stellen diese im Maschinenbefehl in einem der Anweisung entsprechenden Format ein. Beispiel: Die Quelltextangaben ‚A‘ oder ‚X'C1'‘ oder ‚B'11000001'‘ (im EBCDIC-Code) bedeuten dasselbe und werden im Maschinencode zu X'C1' – was bei Befehlen für duale Operationen dem Wert +193, bei Zeichenoperationen dem Zeichen 'A' entspricht.
Datendeklaration
Ein Assembler bietet dem Programmierer die Möglichkeit, Datenfelder als solche zu kennzeichnen und zu benennen, sie in verschiedenen Formaten zu deklarieren und sie mit symbolischen Namen zu versehen. Im erzeugten Maschinencode wird gemäß diesen Angaben Speicherplatz reserviert und (bei Konstanten) mit Inhalt vorbelegt. In den erzeugten Maschinenbefehlen wird die symbolische Adresse durch die numerische Adresse ersetzt und die Länge der definierten Felder eingesetzt.
Adressierung
Ein Assembler ermöglicht es, die Speicherorte für Daten und Befehle symbolisch zu benennen, sodass dem Programmierer deren numerische Adresse nicht bekannt sein muss. In der Maschinensprache sind Speicheradressen direkt angegeben. Selbst bei einer kleinen Änderung des Programms würden sich die Adressen aller nachfolgenden Programmteile verschieben, was (bei Programmierung in Maschinensprache) eine Anpassung all dieser Adressen erforderlich machen würde. Durch die symbolische Adressierung sind in der Assemblersprache auch Unterprogramme aufrufbar, deren tatsächliche Adresse im Maschinencode erst vom Assembler oder einem ‚Linker‘ eingesetzt wird.
Programmumfang
Ein Assemblerprogramm bezieht sich normalerweise auf eine (1) definierte Aufgabenstellung und ist zur Assemblierungszeit von anderen Programmen unabhängig. Durch Techniken wie das ‚Linken‘ können je nach Entwicklungsplattform die Ergebnisse mehrerer Assemblierungen (z. B. Objektmodule genannt)‚ zusammengefasst werden, die als Gesamtheit das Maschinenprogramm ergeben.
Dokumentation
Ein Assembler ermöglicht es, einem Programm Kommentare und weitergehende Dokumentation hinzuzufügen. In das Maschinenprogramm werden diese Quellcodeteile nicht übernommen.

Die meisten der vorgenannten, zur Assemblersprache genannten Aspekte gelten in ähnlicher Weise auch für höhere Programmiersprachen – wobei diese sich gegenüber der Assemblersprache durch weitere (Leistungs-)Merkmale unterscheiden.

Programmerstellung[Bearbeiten]

Intern ist jeder Befehl der Maschinensprache durch ein oder mehrere Zahlenwerte kodiert. Diese Zahlenwerte bestehen aus dem Opcode, der die Art des Befehls festlegt, eventuell gefolgt von einem oder mehreren Bytes an Daten zu diesem Befehl. Eine sinnvolle Folge von solchen Zahlencodes im Hauptspeicher bzw. als Datei gespeichert bildet demnach ein Programm. Es gibt nun verschiedene Arten, solche Programme zu erstellen:

  • Direkte Eingabe der Binärcodes über eine Reihe von Schaltern (äußerst kryptisch und unpraktisch, seit den 1970er Jahren völlig außer Gebrauch gekommen)
  • Über einen Hex-Editor den Zahlen-Code in Opcodes zu schreiben. (immer noch sehr kryptisch und unpraktisch)
  • Mit einem Assembler: Assemblersprachen formulieren die Prozessorbefehle des Maschinencodes als Mnemonics in einer einfachen, relativ leicht lesbaren Syntax. Dieser Quelltext wird danach vom Assembler in den Maschinencode konvertiert.
  • Ein Programm wird in einer relativ abstrakten Hochsprache geschrieben, danach von einem Compiler in Maschinencode übersetzt (kompiliert). In einem Zwischenschritt wird dabei häufig zuerst Objektcode erzeugt.
  • Alternativ können Programme in einer Hochsprache auch – entweder nach Kompilierung in einen Zwischencode oder direkt – durch einen Interpreter abgearbeitet werden. Ein Beispiel hierfür ist die Programmiersprache Java, deren Zwischencode (auch Bytecode genannt) von einem Interpreter ausgeführt wird. Dies geschieht für den Benutzer transparent, wenn zum Beispiel ein Applet im Internet Browser ausgeführt wird. Neben Java werden auch sämtliche .NET Sprachen, wie beispielsweise C#, in einen Zwischencode (engl. Intermediate Language) übersetzt, welcher anschließend zur Laufzeit innerhalb der CLR von einem JIT-Compiler in die entsprechende Maschinensprache übersetzt wird.
  • Bei der Installation von Software, einschließlich des Betriebssystems, liegt diese oft bereits in Maschinencode übersetzt vor, dies erspart die Kompilierung für jeden einzelnen Rechner.

Beispiel[Bearbeiten]

Programmiersprache C[Bearbeiten]

Gegeben sei das folgende Programm in der Programmiersprache C, das die Summe der Zahlen a=2 und b=3 berechnet und das Ergebnis c an den Aufrufer zurückliefert:

int main() {
    int a = 2;
    int b = 3;
    int c = a + b;
    return c;
}

Das Kompilieren dieses Programms kann folgenden Maschinencode ergeben:

Maschinencode
(hexadezimal)
zugehöriger Assemblercode zugehöriger C-Code Erläuterung
55
48 89 E5
push rbp

mov  rbp, rsp

int main() { Sichere Register RBP auf dem Stack und setze RBP auf den Wert von Register RSP, dem Stackpointer (gehört nicht zur eigentlichen Berechnung). Diese Vorbereitung ist notwendig, um die Werte der Variablen a, b und c auf dem Stack speichern zu können.
C7 45 FC 02 mov  DWORD PTR [rbp-4], 2 int a = 2; Setze Variable a, die durch Register RBP adressiert wird, auf den Wert 2.
C7 45 F8 03 mov  DWORD PTR [rbp-8], 3 int b = 3; Setze Variable b, die durch Register RBP adressiert wird, auf den Wert 3.
8B 45 F8
8B 55 FC
01 D0
89 45 F4
mov  eax, DWORD PTR [rbp-8]

mov  edx, DWORD PTR [rbp-4]
add  eax, edx
mov  DWORD PTR [rbp-12], eax

int c = a + b; Setze Register EAX auf den Wert von Variable b.

Setze Register EDX auf den Wert von Variable a.
Addiere den Wert von EDX zum Wert von EAX.
Setze Variable c, die durch RBP adressiert wird, auf den Wert von EAX.

8B 45 F4 mov  eax, DWORD PTR [rbp-12] return c; Setze Register EAX auf den Wert von Variable c. Weil Register EAX diesen Wert bereits enthält, könnte diese Anweisung in einem optimierten Programm entfallen.
5D
C3
pop  rbp

ret

} Setze RBP wieder auf seinen ursprünglichen Wert.

Springe zurück an die Stelle des Aufrufs von main. Register EAX enthält den Rückgabewert.

Der Compiler schreibt diesen Maschinencode, gemeinsam mit weiteren zur Ausführung notwendigen Informationen, in eine sogenannte ausführbare Datei. Zur Ausführung wird der Maschinencode vom Lader des Betriebssystems in den Arbeitsspeicher geladen. Anschließend ruft es die Funktion main des Programms auf, und die CPU beginnt mit der Abarbeitung der Maschinenbefehle.

Beispiel IBM-Serie OS/390[Bearbeiten]

Das Beispiel beschreibt Maschinencode für IBM-Großrechner, z. B. der Serie OS/390:

Der Maschinencode entsteht beim Assemblieren bzw. beim Compilieren der Quellcodedateien und wird vom „Linkage Editor“, ggf. unter Hinzufügen weiterer Module, als ausführbares Programm in einer Programmbibliothek bereitgestellt. Zur Ausführung wird dieses Programm in den Hauptspeicher geladen. Der Maschinencode dieser Programme enthält Befehle und Daten gemischt - wie dies bei Computern der Von-Neumann-Architektur möglich ist (im Gegensatz z. B. zur Harvard-Architektur).

Die Daten werden entsprechend dem festgelegten Speicherformat angelegt. Der Wert „12“ kann dabei z. B. folgendes Aussehen haben (Darstellung hexadezimal, in minimaler Länge):

F1F2 Text oder ungepackte Zahl
012C gepackt positiv, Speicherung je Zahl ein Halbbyte, am Ende ein Vorzeichen-Halbbyte.
012D gepackt negativ (dto)
0C binär positiv, entspricht B'00001100'

Bei längeren Datenfeldern existieren ggf. führende Nullen zusätzlich oder bei Text nachfolgende Leerstellen. Für jedes vorgesehene Datenfeld ist eine 'Adresse' festgelegt, an der es beginnt und wo es entsprechend seiner Länge und seinem Format gespeichert ist.

Die Befehle bestehen aus dem Befehlscode und – je nach Befehl – Parametern unterschiedlicher Struktur. Die nachfolgenden Beispiele sind hexadezimal dargestellt. Befehlsbeispiele:

C5.1C.92A4.8C2B (Trennpunkte nur zur besseren Lesbarkeit eingefügt):

C5 = Befehlscode für CLC = Compare logical character; Zeichenvergleich
1C = Länge minus 1 der zu vergleichenden Felder (bei 00 wird 1 Byte verglichen usw., hier also 29 Bytes)
92A4 = Adresse erster Operand: 9 = Basisregister, 2A4 = Distanz zum Register
8C2B = Adresse zweiter Operand: 8 = Basisregister, C2B = Distanz zum Register

47.80.B654:

47 = Befehlscode für BC = Branch on Condition: Sprungbefehl wenn Bedingung (aus Vorbefehl) erfüllt ist
8 = Bedingung; hier: wenn 'gleich', mnemotechnischer Assemblercode BE (branch on equal)
0 = optional Register, dessen Inhalt zur Sprungadresse hinzuaddiert wird; nicht bei '0'
B = Zieladresse (Basisregister)
654 = Zieladresse (Distanz); bei Inhalt von B = 6C4410 würde nach Adresse 6C4A64 verzweigt werden.

<usw>

Im Assemblercode könnte diese Codierung z. B. wie folgt aussehen:

CLC FELDA(29),FELDB
BE XXX

Von einer Hochsprache generiert könnte der Quellcode dagegen lauten:

IF Feld_A = Feld_B then GOTO XXX.

Bei „Bedingung erfüllt“ wird nach XXX (= reale Adresse 6C4A64) verzweigt, andernfalls wird im Maschinencode mit <usw> fortgefahren. Häufig generieren Hochsprachen zusätzliche Befehle, z. B. um Feldlängen oder Datenformate zu egalisieren, Register zu laden oder Adressen in Arrays zu berechnen.

Man erkennt, dass die Befehle unterschiedliche Längen aufweisen. Das Steuerwerk des Rechners erkennt die Länge an den ersten beiden Bits des Befehlscodes und schaltet das Befehlszählregister dementsprechend weiter. An genau dieser Stelle wird das Programm fortgesetzt – falls kein Sprungbefehl auszuführen ist.

Speicheradressen werden im Maschinencode immer durch eine (oder zwei) Registerangabe(n), zusätzlich optional durch eine im Befehl angegebene „Distanz“ dargestellt. Zur Ausführung wird beim Programmstart ein bestimmtes Register vom Betriebssystem mit der Adresse geladen, an die das Programm in den Speicher geladen wurde. Von diesem Wert ausgehend, werden im Programmcode (bei ASS programmiert, bei Hochsprachen generiert) die Basisregister geladen, wodurch die mit relativen Adressen versehenen Befehle die tatsächlichen Speicherstellen ansprechen.

Zur Ausführung von Systemfunktionen (wie Ein-/Ausgabebefehle, Abfrage von Datum/Uhrzeit, Tastatureingabe, Laden von Unterprogrammen u. v. a.) wird im Maschinenprogramm lediglich ein Systemaufruf mit dem Befehl 'SVC' (Supervisor Call) abgesetzt. Im zweiten Byte ist die auszuführende Funktion spezifiziert (Verzeichnis siehe [3]); weitere Parameter für die Funktion werden über eine in ihrer Struktur festgelegte Datenschnittstelle übergeben, auf deren Adresse ein implizit vereinbartes (nicht im Befehl angegebenes) Register zeigt. Beispiel: X'05 08' = LOAD, Parameter = Pgm-Name etc. Die die aufgerufenen Funktionen ausführenden Befehle sind Maschinencode des Betriebssystems. Sie werden dort ausgeführt und führen anschließend zu dem dem SVC folgenden Befehl zurück. (Siehe auch den englischen Wikipedia-Artikel Supervisor Call instruction[4].)

Überblick über die typische Funktionalität einer Maschinensprache[Bearbeiten]

Befehlsvorrat[Bearbeiten]

Hauptartikel: Befehlssatz

Hinweis: Die genannten Befehlskürzel sind nur Beispiele; Befehle werden prozessorabhängig unterschiedlich benannt.

Adressierung und Ergebnisanzeige: Fast alle Befehle adressieren die betroffenen Speicherpositionen (häufig Quelle/Ziel, zu vergleichend/Vergleichswert, usw.) über definierte Register. Ebenso gibt der Prozessor seine Ergebnisse und relevante Zusatzinformationen über festgelegte Register und/oder über Flags im Statusregister zurück. Dies ermöglicht es, im weiteren Programmablauf diese Informationen auszuwerten und darauf zu reagieren. Die Länge der Befehle und die Größe von Quell- und Zieloperanden können je nach Architektur unterschiedlich sein.

Beispiel: Ein Additionsbefehl wie ADC (add with carry) signalisiert dem weiteren Programmablauf ein Überschreiten des gültigen Wertebereichs über das Setzen des Carry- und Overflow-Flags hinaus.

Unterschiede: Der Befehlsvorrat einzelner Prozessoren ist unterschiedlich. Nicht alle Befehle sind auf jedem Prozessortyp und in jeder Prozessor-Generation verfügbar.

Beispiel: Ein einfacher Grundbefehl wie SHL/SHR, der einen Registerwert um eine bestimmte Anzahl von Stellen nach links oder rechts verschiebt ist schon im 8086 vorhanden. Die mächtigere Variante SHLD/SHRD, welche zusätzlich die entstehenden Leerstellen aus einem anderen Integerwert auffüllt, ist erst ab dem 80386 implementiert.

Mächtigkeit: Der Befehlsvorrat eines Prozessors stellt dabei Befehle unterschiedlich mächtiger Funktionalität bereit. Neben einfachen, einstufigen Grundoperationen stehen auch Befehle zur Verfügung, die mehrere Operationen in einem Befehl bündeln.

Beispiele: Der Befehl CMP (compare) ermöglicht den Vergleich zweier Werte auf <,>, =. Der Befehl XCHG (exchange) vertauscht die Positionen zweier Operanden. Der Befehl CMPXCHG (compare and exchange) kombiniert diese beiden Befehle und ermöglicht einen bedingungsabhängigen Datenaustausch in einem Befehl. Während der Befehl BT (bit test) nur den Zustand eines einzelnen Bits in einem Integerwert prüft, ermöglichen es die Befehle BTC, BTR, und BTS darüber hinaus, das geprüfte Bit abhängig vom Ergebnis der Prüfung zu setzen (BTS), zu löschen (BTR), oder zu invertieren (BTC).

Generell unterscheidet man zwischen CPUs mit RISC- (Reduced instruction set computer) oder CISC- (Complex instruction set computer) Befehlssatz. Erstere haben einen bedeutend weniger mächtigen Befehlssatz, können jeden einzelnen Befehl aber typischerweise in einem Taktzyklus abarbeiten. Moderne CPUs mit CISC-Befehlssatz (darunter fallen heute fast ausschließlich x86-kompatible CPUs) dekodieren zur schnelleren Abarbeitung die komplexen CISC-Befehle zur Ausführung intern in eine RISC-ähnliche Mikrocontroller-Sprache.

Performance: Jeder Befehl wird in einer in Datenblättern angegebenen Anzahl von Taktzyklen des Prozessors abgearbeitet. Deren Kenntnis ermöglicht es dem Programmierer (bei extrem zeitkritischen Anwendungen) beispielsweise, Befehle mit vielen Taktzyklen durch mehrere, in der Summe aber effizientere Befehle zu ersetzen.

Kategorisierung der Befehle[Bearbeiten]

Grundlegende Maschinen-Befehle lassen sich in folgende Kategorien unterteilen:

  • Arithmetische Operationen: Führen Berechnungen durch (ADD, ADC, SUB, SBB, DIV, MUL, INC, DEC)
  • Logische Operationen: Verknüpfen Bitfelder logisch miteinander (AND, OR, XOR, NOT)
  • Bit-orientierte Operationen: Mit ihnen kann man einzelne Bits in einem Bitfeld genau ansprechen, auslesen (BSF, BSR), verschieben (SHL, SHR, RCL, RCR, ROL, ROR) bzw. manipulieren (BT, BTC, BTR)
  • Speicheroperationen: Übertragen Daten zwischen Prozessorregistern (MOV, MOVSX, MOVZX, XCHG), innerhalb eines Registers (BSWAP), sowie Registern und Speicher
  • Vergleichsoperationen: Vergleich von Werten mittels <, >, sowie = (CMP, TEST)
  • Kombinierte Befehle aus Vergleichsoperationen, arithmetischen Operationen, und Datenaustausch (XADD, CMPXCHG)
  • Steueroperationen: Verzweigungen, die den Ablauf des Programms beeinflussen
  • Datenkonvertierung: Diese Befehle wandeln Werte von einer Darstellung in eine andere um, u. U. auch mit Verlust. Zum Beispiel: ein Byte in ein Word (CBW), einen Long-Integer in ein Byte (CVTLB) oder eine doppelte genaue Fließkommazahl in einen Integer (CVTSD2SI).

In vielen modernen Prozessoren sind die Befehle der Maschinensprache, zumindest die komplexeren unter ihnen, intern durch Mikroprogramme realisiert. Das ist insbesondere bei der CISC-Architektur der Fall.

Literatur[Bearbeiten]

  • Assembler – Maschinennahes Programmieren von Anfang an. rororo Taschenbücher Nr. 61224; (2003); ISBN 3-499-61224-0

Weblinks[Bearbeiten]

Einzelnachweise[Bearbeiten]

  1. Duden Informatik ISBN 3-411-05232-5
  2. Gabler Verlag (Herausgeber), Gabler Wirtschaftslexikon, Maschinencode,
  3. Tabelle der SVC-Codes für IBM's MVS & OS/390 & z/OS
  4. en:Supervisor Call instruction