Zum Inhalt springen

„Opcode“ – Versionsunterschied

aus Wikipedia, der freien Enzyklopädie
[gesichtete Version][gesichtete Version]
Inhalt gelöscht Inhalt hinzugefügt
K Der 8-Bit-Prozessor Z80: Tippfehler ausgebessert
K link ergänzt
 
(38 dazwischenliegende Versionen von 26 Benutzern werden nicht angezeigt)
Zeile 1: Zeile 1:
Ein '''Opcode''', auch '''op code''' oder '''operation code''', ist eine Zahl, die die Nummer eines [[Maschinensprache|Maschinenbefehls]] für einen bestimmten [[Prozessor (Hardware)|Prozessor]]typ angibt. Alle Opcodes zusammen bilden den [[Befehlssatz]] des Prozessors oder der Prozessorfamilie. Jeder Befehl hat einen eigenen Opcode, etwa die Addition, Multiplikation, das Kopieren von [[Register (Computer)|Registern]], Laden und Speichern von Registern aus dem [[Arbeitsspeicher]], Ein- und Ausgabe usw. Einfache Opcodes stellen bereits einen Maschinenbefehl dar. Auf einen Teil der Opcodes müssen Adressen, Konstanten oder Ähnliches folgen, die dann zusammen mit dem Opcode einen Maschinenbefehl bilden.
Ein '''Opcode''', auch '''op code''' oder '''operation code''', ist eine Zahl, die die Nummer eines [[Maschinensprache|Maschinenbefehls]] für einen bestimmten [[Prozessor]]typ angibt. Alle Opcodes zusammen bilden den [[Befehlssatz]] des Prozessors oder der Prozessorfamilie. Jeder Befehl hat einen eigenen Opcode, etwa die Addition, Multiplikation, das Kopieren von [[Register (Computer)|Registern]], Laden und Speichern von Registern aus dem [[Arbeitsspeicher]], Ein- und Ausgabe usw. Einfache Opcodes stellen bereits einen Maschinenbefehl dar. Auf einen Teil der Opcodes müssen Adressen, Konstanten oder Ähnliches folgen, die dann zusammen mit dem Opcode einen Maschinenbefehl bilden.


Jedem Opcode wird ein kurzes Wort oder eine Abkürzung, ein so genanntes [[Mnemonic]], zugeordnet. Mit den Mnemonics ergeben sich die [[Assemblersprache]]n, bei denen jeweils ein Mnemonic, gegebenenfalls gefolgt von Adressen oder Konstanten, in eine Zeile einer Textdatei geschrieben wird. Ein spezielles Programm, der [[Assembler (Informatik)|Assembler]], erzeugt Maschinencode, indem es im Wesentlichen die Mnemonics durch ihre jeweiligen Opcodes ersetzt.
Jedem Opcode wird ein kurzes Wort oder eine Abkürzung, ein [[Mnemotechnik|Mnemonic]], zugeordnet. Mit den Mnemonics ergeben sich die [[Assemblersprache]]n, bei denen jeweils ein Mnemonic, gegebenenfalls gefolgt von Adressen oder Konstanten, in eine Zeile einer Textdatei geschrieben wird. Ein spezielles Programm, der [[Assembler (Informatik)|Assembler]], erzeugt Maschinencode, indem es im Wesentlichen die Mnemonics durch ihre jeweiligen Opcodes ersetzt.


Die meisten modernen Prozessoren besitzen einige hundert Opcodes.
Die meisten modernen Prozessoren besitzen einige hundert Opcodes.
Zeile 7: Zeile 7:
Ältere Prozessoren hatten oft „undefinierte“ oder „illegale“ Opcodes. Bestimmte, für die Programmierung gar nicht vorgesehene Opcodes konnten durch ihre Nebenwirkungen auf den internen Schaltungsaufbau des Prozessors allerhand seltsame, schädliche oder seltener auch nützliche Effekte haben. Solche Opcodes wurden manchmal bei der Programmierung von [[Computerspiel]]en auf [[Heimcomputer]]n und frühen [[Spielkonsole]]n benutzt, um bestimmte Vorgänge ein wenig schneller ablaufen zu lassen oder um die Funktionsweise eines [[Kopierschutz]]es zu verschleiern. Nachteilig war, dass solche „undefinierten Opcodes“ vom Hersteller nicht garantiert wurden und auf Nachfolgemodellen eines Prozessors oft nicht mehr funktionierten. Heutige Prozessoren tun dagegen entweder überhaupt nichts, wenn sie in einem Programm einen unbekannten Opcode antreffen, oder aber sie begeben sich in einen klar definierten Fehlerzustand.
Ältere Prozessoren hatten oft „undefinierte“ oder „illegale“ Opcodes. Bestimmte, für die Programmierung gar nicht vorgesehene Opcodes konnten durch ihre Nebenwirkungen auf den internen Schaltungsaufbau des Prozessors allerhand seltsame, schädliche oder seltener auch nützliche Effekte haben. Solche Opcodes wurden manchmal bei der Programmierung von [[Computerspiel]]en auf [[Heimcomputer]]n und frühen [[Spielkonsole]]n benutzt, um bestimmte Vorgänge ein wenig schneller ablaufen zu lassen oder um die Funktionsweise eines [[Kopierschutz]]es zu verschleiern. Nachteilig war, dass solche „undefinierten Opcodes“ vom Hersteller nicht garantiert wurden und auf Nachfolgemodellen eines Prozessors oft nicht mehr funktionierten. Heutige Prozessoren tun dagegen entweder überhaupt nichts, wenn sie in einem Programm einen unbekannten Opcode antreffen, oder aber sie begeben sich in einen klar definierten Fehlerzustand.


== Der 8-Bit-Prozessor [[Z80]] ==
== Der 8-Bit-Prozessor Z80 ==
{| class="prettytable"
{| class="wikitable"
|- class="hintergrundfarbe6"
|- class="hintergrundfarbe6"
! Opcode || Mnemonic || Beschreibung
! Opcode<br />in&nbsp;[[Hexadezimalsystem|hex]] || Mnemonic || Beschreibung
|-
|-
| 4 || '''INC B''' || erhöhe Register B um eins (engl. '''inc'''''rement'' '''B''')
| 04 || '''INC B''' || erhöhe Register B um eins (engl. '''inc'''''rement'' '''B''')
|-
|-
| 5 || '''DEC A''' || vermindere Register A um eins (engl. '''dec'''''rement'' '''A''')
| 05 || '''DEC A''' || vermindere Register A um eins (engl. '''dec'''''rement'' '''A''')
|-
|-
| 144 || '''SUB B''' || '''sub'''trahiere Register '''B''' von Akkumulator A
| 90 || '''SUB B''' || '''sub'''trahiere Register '''B''' von Akkumulator A
|-
| 21 ll hh || '''LD HL,hhll''' || '''l'''oa'''d''' HL mit der Konstante hhll
|-
|-
| … || … || ''weitere Befehle''
| … || … || ''weitere Befehle''
|}
|}
Bemerkung: Für den [[Z80]] gibt es zwei verschiedene Mnemonics (LD M,B bzw. LD (HL),B), hinzu kommt eine dritte für die Vorgänger-CPU Intel 8085 (MOV M,B).


Folgende Z80-Mnemonics
Für den Z80-Prozessor kann man das folgende Assemblerprogrammfragment in eine Textdatei schreiben:
DEC A
DEC A
INC B
INC B
SUB B
SUB B
LD HL,1234h


Ein Z80-Assembler erzeugt daraus das Maschinenprogramm:
erzeugen folgendes Z80-Maschinenprogramm
05 04 90 21 34 12
5,4,144


Maschinenprogramme werden heutzutage praktisch immer [[hexadezimal]] dargestellt (seltene Alternativen: dezimal, [[Oktalsystem|oktal]]). Manchmal werden 16-Bit-Werte nicht als zwei 8-Bit-Worte in der Bytereihenfolge im Hauptspeicher, sondern als ein 16-Bit-Wort in der logischen Reihenfolge angezeigt:
wobei jeder Opcode beim Z80 ein [[Byte]] belegt. Häufig werden Maschinenprogramme [[hexadezimal]] dargestellt. Bei 8-Bit-Rechnern kann jedes Byte durch zwei Hexadezimalziffern dargestellt werden, hier also:
05 04 90
05 04 90 21 1234


== Der Relaisrechner [[Zuse Z3]] ==
== Der Relaisrechner Zuse Z3 ==
Die Z3 von [[Konrad Zuse]] aus dem Jahre [[1941]] hatte zwei Register R1 und R2, 64 Speicherzellen und beherrschte die Ein-/Ausgabe, die Grundrechenarten, Wurzelberechnung von Gleitkommazahlen. Programme wurden auf Lochstreifen abgelegt, die Opcodes der neun Befehle bestanden aus den folgenden Lochstreifencodierungen:
Die [[Zuse Z3|Z3]] von [[Konrad Zuse]] aus dem Jahre [[1941]] hatte zwei Register R1 und R2, 64 Speicherzellen und beherrschte die Ein-/Ausgabe, die vier [[Grundrechenart]]en und die [[Wurzelziehen|Wurzelberechnung]] von Gleitkommazahlen. Programme wurden auf [[Lochstreifen]] abgelegt, die Opcodes der neun Befehle bestanden aus den folgenden Lochstreifencodierungen:


{| class="prettytable"
{| class="wikitable"
|- class="hintergrundfarbe6"
|- class="hintergrundfarbe6"
! Opcode || Mnemonic || Beschreibung
! Opcode<br />auf dem<br />Lochstreifen || Mnemonic || Beschreibung
|-
|-
| <code>-O.OO----</code> || '''Lu''' || Anhalten, Eingabe R1 einer Dezimalzahl von der Tastatur, R2:=undef
| <code>-O·OO----</code> || '''Lu''' || Anhalten, Eingabe R1 einer Dezimalzahl von der Tastatur, R2:=undef
|-
|-
| <code>-O.OOO---</code> || '''Ld''' || Anhalten, dezimale Anzeige des Ergebnisses
| <code>-O·OOO---</code> || '''Ld''' || Anhalten, dezimale Anzeige des Ergebnisses
|-
|-
| <code>OO.zzzzzz</code> || '''Pr z''' || Lesen der Speicherzelle ''z'' (erst R1, danach immer R2)
| <code>OO·zzzzzz</code> || '''Pr z''' || Lesen der Speicherzelle ''z'' (erst R1, danach immer R2)
|-
|-
| <code>O-.zzzzzz</code> || '''Ps z''' || Schreiben der Speicherzelle ''z''
| <code>O-·zzzzzz</code> || '''Ps z''' || Schreiben von R1 in Speicherzelle ''z''
|-
|-
| <code>-O.O-----</code> || '''La''' || Addition R1:=R1+R2, R2:=0
| <code>-O·O-----</code> || '''La''' || Addition R1:=R1+R2, R2:=0
|-
|-
| <code>-O.O-O---</code> || '''Ls''' || Subtraktion R1:=R1-R2, R2:=0
| <code>-O·O-O---</code> || '''Ls''' || Subtraktion R1:=R1-R2, R2:=0
|-
|-
| <code>-O.--O---</code> || '''Lm''' || Multiplikation R1:=R1*R2, R2:=0
| <code>-O·--O---</code> || '''Lm''' || Multiplikation R1:=R1*R2, R2:=0
|-
|-
| <code>-O.-O----</code> || '''Li''' || Division R1:=R1/R2, R2:=0
| <code>-O·-O----</code> || '''Li''' || Division R1:=R1/R2, R2:=0
|-
|-
| <code>-O.-OO---</code> || '''Lw''' || Wurzelberechnung R1:=Wurzel(R1), R2:=0
| <code>-O·-OO---</code> || '''Lw''' || Wurzelberechnung R1:=Wurzel(R1), R2:=0
|}
|}
O : Loch, - : kein Loch, · : Transportloch, zzzzzz : binär codierte Speicherstelle 0…63


Der Lochstreifen ist 8 Bits breit. Die Opcodes für die Speicherzugriffe belegen nur 2 Bits, gefolgt von der Adresse der Speicherzelle. Die anderen Opcodes belegen 5 Bits, 3 Bits sind unbenutzt.
Der Lochstreifen ist 8 Bits breit und weist ein asymmetrisches Transportloch zwischen dem zweiten und dritten Bit auf. Die Opcodes für die Speicherzugriffe belegen nur 2&nbsp;Bits, gefolgt von der Adresse der Speicherzelle. Die anderen Opcodes belegen 5&nbsp;Bits, 3&nbsp;Bits sind unbenutzt.


== Weblinks ==
== Weblinks ==
* {{Literatur |Autor=RAÚL ROJAS |Titel=Konrad Zuse’s Legacy: The Architecture of the Z1 and Z3 |Sammelwerk=IEEE Annals of the History of Computing |Band=Vol. 19 |Nummer=2 |Datum=1997 |Seiten=5-16 |Sprache=en |Online=https://ed-thelen.org/comp-hist/Zuse_Z1_and_Z3.pdf |Format=PDF |KBytes=305 |Abruf=2018-10-11}}

* [http://runtime-basic.net/Assembler:Funktionen:Beschreibung-Kurz-CPU Assembler X86 Befehlslisten/OpCode und Beschreibungen]
* [http://www.arl.wustl.edu/~lockwood/class/cse306-s04/resources/opcodes.html Liste der X86-Opcodes und Assembler-Mnemonics (englisch)]


[[Kategorie:Assembler]]
[[Kategorie:Assembler]]
[[Kategorie:Programmierung]]
[[Kategorie:Programmierung]]

[[en:Opcode]]
[[es:Opcode]]
[[fr:Langage machine]]
[[ru:Код операции (информатика)]]

Aktuelle Version vom 7. Juni 2024, 21:53 Uhr

Ein Opcode, auch op code oder operation code, ist eine Zahl, die die Nummer eines Maschinenbefehls für einen bestimmten Prozessortyp angibt. Alle Opcodes zusammen bilden den Befehlssatz des Prozessors oder der Prozessorfamilie. Jeder Befehl hat einen eigenen Opcode, etwa die Addition, Multiplikation, das Kopieren von Registern, Laden und Speichern von Registern aus dem Arbeitsspeicher, Ein- und Ausgabe usw. Einfache Opcodes stellen bereits einen Maschinenbefehl dar. Auf einen Teil der Opcodes müssen Adressen, Konstanten oder Ähnliches folgen, die dann zusammen mit dem Opcode einen Maschinenbefehl bilden.

Jedem Opcode wird ein kurzes Wort oder eine Abkürzung, ein Mnemonic, zugeordnet. Mit den Mnemonics ergeben sich die Assemblersprachen, bei denen jeweils ein Mnemonic, gegebenenfalls gefolgt von Adressen oder Konstanten, in eine Zeile einer Textdatei geschrieben wird. Ein spezielles Programm, der Assembler, erzeugt Maschinencode, indem es im Wesentlichen die Mnemonics durch ihre jeweiligen Opcodes ersetzt.

Die meisten modernen Prozessoren besitzen einige hundert Opcodes.

Ältere Prozessoren hatten oft „undefinierte“ oder „illegale“ Opcodes. Bestimmte, für die Programmierung gar nicht vorgesehene Opcodes konnten durch ihre Nebenwirkungen auf den internen Schaltungsaufbau des Prozessors allerhand seltsame, schädliche oder seltener auch nützliche Effekte haben. Solche Opcodes wurden manchmal bei der Programmierung von Computerspielen auf Heimcomputern und frühen Spielkonsolen benutzt, um bestimmte Vorgänge ein wenig schneller ablaufen zu lassen oder um die Funktionsweise eines Kopierschutzes zu verschleiern. Nachteilig war, dass solche „undefinierten Opcodes“ vom Hersteller nicht garantiert wurden und auf Nachfolgemodellen eines Prozessors oft nicht mehr funktionierten. Heutige Prozessoren tun dagegen entweder überhaupt nichts, wenn sie in einem Programm einen unbekannten Opcode antreffen, oder aber sie begeben sich in einen klar definierten Fehlerzustand.

Der 8-Bit-Prozessor Z80

[Bearbeiten | Quelltext bearbeiten]
Opcode
in hex
Mnemonic Beschreibung
04 INC B erhöhe Register B um eins (engl. increment B)
05 DEC A vermindere Register A um eins (engl. decrement A)
90 SUB B subtrahiere Register B von Akkumulator A
21 ll hh LD HL,hhll load HL mit der Konstante hhll
weitere Befehle

Bemerkung: Für den Z80 gibt es zwei verschiedene Mnemonics (LD M,B bzw. LD (HL),B), hinzu kommt eine dritte für die Vorgänger-CPU Intel 8085 (MOV M,B).

Folgende Z80-Mnemonics

 DEC A
 INC B
 SUB B
 LD HL,1234h

erzeugen folgendes Z80-Maschinenprogramm

 05 04 90 21 34 12

Maschinenprogramme werden heutzutage praktisch immer hexadezimal dargestellt (seltene Alternativen: dezimal, oktal). Manchmal werden 16-Bit-Werte nicht als zwei 8-Bit-Worte in der Bytereihenfolge im Hauptspeicher, sondern als ein 16-Bit-Wort in der logischen Reihenfolge angezeigt:

 05 04 90 21 1234

Der Relaisrechner Zuse Z3

[Bearbeiten | Quelltext bearbeiten]

Die Z3 von Konrad Zuse aus dem Jahre 1941 hatte zwei Register R1 und R2, 64 Speicherzellen und beherrschte die Ein-/Ausgabe, die vier Grundrechenarten und die Wurzelberechnung von Gleitkommazahlen. Programme wurden auf Lochstreifen abgelegt, die Opcodes der neun Befehle bestanden aus den folgenden Lochstreifencodierungen:

Opcode
auf dem
Lochstreifen
Mnemonic Beschreibung
-O·OO---- Lu Anhalten, Eingabe R1 einer Dezimalzahl von der Tastatur, R2:=undef
-O·OOO--- Ld Anhalten, dezimale Anzeige des Ergebnisses
OO·zzzzzz Pr z Lesen der Speicherzelle z (erst R1, danach immer R2)
O-·zzzzzz Ps z Schreiben von R1 in Speicherzelle z
-O·O----- La Addition R1:=R1+R2, R2:=0
-O·O-O--- Ls Subtraktion R1:=R1-R2, R2:=0
-O·--O--- Lm Multiplikation R1:=R1*R2, R2:=0
-O·-O---- Li Division R1:=R1/R2, R2:=0
-O·-OO--- Lw Wurzelberechnung R1:=Wurzel(R1), R2:=0

O : Loch, - : kein Loch, · : Transportloch, zzzzzz : binär codierte Speicherstelle 0…63

Der Lochstreifen ist 8 Bits breit und weist ein asymmetrisches Transportloch zwischen dem zweiten und dritten Bit auf. Die Opcodes für die Speicherzugriffe belegen nur 2 Bits, gefolgt von der Adresse der Speicherzelle. Die anderen Opcodes belegen 5 Bits, 3 Bits sind unbenutzt.

  • RAÚL ROJAS: Konrad Zuse’s Legacy: The Architecture of the Z1 and Z3. In: IEEE Annals of the History of Computing. Vol. 19, Nr. 2, 1997, S. 5–16 (englisch, ed-thelen.org [PDF; 305 kB; abgerufen am 11. Oktober 2018]).