Inhaltsverzeichnis

Aus der User-Archiv Datenbank: alle Einträge zum Thema Programmieren in Assembler


http://de.wikibooks.org/wiki/Assembler_%2880x86_Prozessor%29-Programmierung
Rubrik: Programmieren; Typ: Sonstige_Literatur
http://www.programmiersprachen.de/wbb2/board.php?boardid=21
Rubrik: Programmieren; Typ: Diskussionsforen
http://de.wikibooks.org/wiki/Assembler_%2880x86_Prozessor%29-Programmierung
Rubrik: Programmieren; Typ: Tutorials
http://de.wikibooks.org/wiki/Interrupts_80x86
Rubrik: Programmieren; Typ: Tutorials
http://www.it-academy.cc/article/889/InlineAssembler%28x86%29+in+C+C++.html
Rubrik: Programmieren; Typ: Sonstige_Literatur
http://www.sprut.de/electronic/pic/assemble/assembler.html
Rubrik: Programmieren; Typ: Sonstige_Literatur
http://www.sprut.de/electronic/pic/assemble/befehle.html
Rubrik: Programmieren; Typ: Sonstige_Literatur
http://wirthi.cjb.net/
Rubrik: Programmieren; Typ: Sonstige_Literatur

Bücher bei Amazon


Wikipedia zu Assembler (Informatik)

http://de.wikipedia.org/wiki/Assembler_%28Informatik%29

Assembler (Informatik)

aus Wikipedia, der freien Enzyklopädie

Wechseln zu: Navigation, Suche

Ein Assembler in der Informatik ist ein spezieller Compiler, der ein in einer maschinennahen Assemblersprache geschriebenes Programm in Maschinensprache übersetzt. Oft wird der Ausdruck Assembler auch als Abkürzung oder Synonym für Assemblersprache verwendet.

Zu beachten ist, dass verschiedene Prozessorarchitekturen grundverschiedene Assembler- und Maschinensprachen haben, so dass jeweils ein zur aktuellen Architektur passender Assembler benötigt wird. Es gibt jedoch Assemblerfamilien, welche bei gleich bleibender Makrosprache und Arbeitsumgebung mehrere Prozessoren unterstützen (z. B. GNU Assembler).

Die einfachste Version eines Assemblers, kombiniert mit der Möglichkeit, Programme interaktiv zu testen und zu analysieren, wird Maschinensprachemonitor genannt. Makroassembler gestatten die Bildung von parametrisierbaren Befehlsgruppen. Eine Makroanweisung wird im allgemeinen in mehr als einen Maschinenbefehl umgesetzt.

Assemblersprache wird immer seltener eingesetzt. Der Möglichkeit der Erstellung effizienter Programme steht die erschwerte Wartbarkeit von Assemblerprogrammen gegenüber. Maschinennahe Programmierung – die Domäne von Assembler – kann heute fast vollständig durch höhere Programmiersprachen abgedeckt werden. Auch ist die Programmierung heutiger Prozessoren in Assemblersprache zur Geschwindigkeitsoptimierung schwierig, da zahlreiche Nebenbedingungen eingehalten werden müssen, damit der Prozessor in optimaler Geschwindigkeit läuft, während auf der anderen Seite optimierende Compiler für Hochsprachen immer besseren Code erzeugen und diese Bedingungen automatisch erfüllen können.
Einige Programmiersysteme für höhere Programmiersprachen gestatten es, Assemblerbefehle in den Quelltext mittels Inline-Assembler zu integrieren. Die Anwendung kann sich dann auf die Situationen beschränken, in denen es aus funktionalen oder Effizienzgründen notwendig oder nützlich ist, maschinennah zu programmieren.

Siehe auch: Cross-Assembler

Inhaltsverzeichnis

[Verbergen]

Abgrenzung zu Hochsprachencompilern [Bearbeiten]

Im Unterschied zu Compilern, die eine maschinenunabhängige, mehr oder weniger standardisierte Hochsprache wie z. B. C oder Pascal in Maschinensprache übersetzen, sind Assembler immer spezifisch auf einen oder wenige Prozessortypen ausgerichtet.

Beim Assembler werden die Opcodes der jeweiligen CPU mit Namen, den sogenannten Mnemonics, angegeben, während Hochsprachen die Umsetzung in Opcodes über mehrere automatisierte Abstraktionsebenen hinweg bewerkstelligen. Dadurch werden Eigenschaften wie etwa eine bestimmte Registerbreite vor dem Programmierer versteckt. In Assembler sind nur Operationen im Rahmen der möglichen Register- und Operationsgrößen der CPU möglich. Oftmals sind Pragma-, Präprozessor- und Makrofähigkeiten in Assemblern möglich, die sich aber nur bedingt mit den Möglichkeiten von Hochsprachen vergleichen lassen.

Assembler sind häufig extrem einfach aufgebaut und daher meist auch sehr schnell. Compiler hingegen übersetzen oft zunächst das Programm in eine Zwischensprache, die dann an einen Assembler weitergeleitet und in das letztlich benötigte Maschinenprogramm umgewandelt wird. Bei modernen Compilern erfolgt dieser Schritt implizit.

Disassembler [Bearbeiten]

Ein Programm zum Rückübersetzen von Maschinensprache in Assemblersprache wird als Disassembler bezeichnet. Diese Rückübersetzung ist generell möglich, da es – anders als bei Hochsprachen – eine Eins-zu-Eins-Beziehung zwischen einfacher Assemblersprache und Maschinensprache gibt. Dabei können jedoch Bezeichner und Kommentare nicht wiederhergestellt werden, da diese durch die Assemblierung verloren gehen. Meist werden Assemblersprachen um Makrofähigkeiten ergänzt, so dass diese direkte Abbildung nur noch teilweise möglich ist.

Die Tätigkeit des Disassemblierens ist bei urheberrechtlich geschützten Programmen durch Copyright-Bestimmungen reglementiert bis verboten, da das Disassemblieren die Möglichkeit eröffnet, den Code einfach zu ändern und danach wieder in ein Programm zu assemblieren. So könnte z. B. von erfahreneren Assembler-Programmieren und Crackern eine Passwortabfrage entfernt, eine aus lizenzrechtlichen Gründen abgeschaltete Funktion aktiviert, oder ein Virus unbemerkt in das Programm eingeschleust werden. Ausführliche Erläuterungen zu diesem Aspekt von Disassemblern und vergleichbaren Werkzeugen finden sich im Artikel Reverse Engineering.

Hersteller und Produkte [Bearbeiten]

Für die x86-Prozessoren-Familie und kompatible Prozessoren (z. B. Intels Pentium oder AMDs Athlon) sind der Microsoft Macro Assembler (MASM), der Borland Turbo Assembler (TASM) und der unter der LGPL verfügbare Netwide Assembler (NASM) weit verbreitet. Auch der Flat Assembler (FASM) bietet viele Features, die ein moderner Assembler benötigt. Neben Assemblern, die die Intel-Syntax kennen, gibt es noch solche, die Assemblercode in der AT&T-Syntax assemblieren können, wie den unter Linux hauptsächlich genutzten GNU Assembler (GAS).

Auf IBM-Großrechnern (zSeries) wird der High Level Assembler verwendet, Hercules-Anwender müssen entweder den veralteten Assembler Assembler-F benutzen oder aber den Tachyon Legacy Assembler verwenden, welcher unter Linux für z/Series läuft.

Für die Mikrocontrollerfamilie MCS-51 von Intel, deren erster Vertreter der 8051 war, gibt es den freien Macroassembler ASEM-51. Heute gibt es bereits hunderte von 8051-Derivaten von über 50 Halbleiterherstellern.

Siehe auch: Betriebssystem

Weblinks [Bearbeiten]

Wikibooks: Assembler – Lern- und Lehrmaterialien

Dieser Artikel basiert auf dem Artikel aus der freien Enzyklopädie Wikipedia und steht unter der GNU-Lizenz für freie Dokumentation. In der Wikipedia ist eine Liste der Autoren verfügbar.

ebay-Angebote


Wikibook "Assembler"

Befehlsreferenz

Quelle: http://de.wikibooks.org/wiki/Assembler_%2880x86_Prozessor%29-Programmierung:_Befehlsreferenz

Assembler (80x86 Prozessor)-Programmierung: Befehlsreferenz

Aus Wikibooks


Dieser Artikel basiert auf dem Artikel aus der freien Enzyklopädie Wikipedia und steht unter der GNU-Lizenz für freie Dokumentation. In der Wikipedia ist eine Liste der Autoren verfügbar.


Die Syntax besteht aus drei Teilen: Dem Opcode in Hexadezimal, der eigentlichen Syntax und dem Prozessor, seit dem der Befehl existiert. Der Aufbau Opcode soll in Zukunft in einem eigenen Kapitel beschrieben werden. Die Syntax hat die folgenden Bedeutungen:

  • r8: Einer der folgenden 8Bit Register kann verwendet werden: AH, AL, BH, BL, CH, CL, DH oder DL .
  • r16: Einer der folgenden 16Bit Register kann verwendet werden: AX, BX, CX oder DX, BP, SP, DI oder SI.
  • r32: Einer der folgenden 32Bit Register kann verwendet werden: EAX, EBX, ECX oder EDX, EBP, ESP, EDI oder ESI.
  • imm8: Ein Bytewert zwischen –128 bis +127.
  • imm16: Ein Wortwert zwischen –32.768 bis +32.767
  • r/m8: Der Wert kann entweder ein allgemeiner 8Bit Register (AH, AL, BH, BL, CH, CL, DH oder DL) sein oder ein Bytewert aus dem Arbeitsspeicher.
  • r/m16: Der Wert kann entweder ein allgemeiner 16Bit (AX, BX, CX oder DX, BP, SP, DI oder SI.) sein oder ein Bytewert aus dem Arbeitsspeicher
  • SReg: Segmentregister

Der Aufbau des Opcodes hat die folgende Bedeutung:

  • ib Operation bezieht sich auf 8-Bit Daten. (byte)
  • iw Operation bezieht sich auf 16-Bit Daten. (word)
  • id Operation bezieht sich auf 32-Bit Daten. (double word)
  • /0 bis /7, /r, r+b, r+w, r+d: Interne Information zum Aufbau des Maschenenbefehls.

Wenn nicht explizit etwas anderes angegeben, haben die Flags die folgende Bedeutung:

  • OF - Overflow Flag / Überlauf
  • SF - Sign Flag / Vorzeichen
  • ZF - Zero Flag / Ist 1 falls das Resultat 0 ist, sonst 0
  • AF - Auxiliary Flag / Hilfs-Übertragsflag bei Übertrag von Bit 3 auf 4. Dies macht nur Sinn bei BCD-Zahlen
  • PF - Parity Flag / Paritätsflag
  • CF - Carry Flag / Übertrag

Inhaltsverzeichnis

[Verbergen]

[bearbeiten] ADD (Add)

ADD addiert zu einem Speicherbereich oder einem Register einen festen Wert oder einen Wert eines Registers.

04 ib       add AL, imm8       8086
05 iw add AX, imm16 8086
80 /0 ib add r/m8, imm8 8086
81 /0 iw add r/m16, imm16 8086
83 /0 ib add r/m16, imm8 8086
00 /r add r/m8, r8 8086
01 /r add r/m16, r16 8086
02 /r add r8, r/m8 8086
03 /r add r16, r/m16 8086
05 id add eax,imm32 80386
81 /0 id add r/m32, imm32 80386
83 /0 ib add r/m32, imm8 80386
01 /r add r/m32, r32 80386
03 /r add r32, r/m32 80386

Flags:
OF, SF, ZF, AF, CF, PF
Beispiel:

ADD eax,10
ADD eax,ebx

[bearbeiten] ADC (Add with carry)

ADD addiert zu einem Speicherbereich oder einem Register einen festen Wert sowie das Carryflag oder einen Wert eines Registers.

14 ib       adc AL, imm8       8086
15 iw adc AX, imm16 8086
80 /2 ib adc r/m8, imm8 8086
81 /2 iw adc r/m16, imm16 8086
83 /2 ib adc r/m16, imm8 8086
10 /r adc r/m8, r8 8086
11 /r adc r/m16, r16 8086
12 /r adc r8, r/m8 8086
13 /r adc r16, r/m16 8086
15 id adc EAX,imm32 80386
83 /2 ib adc r/m32, imm8 80386
11 /r add r/m32, r32 80386
13 /r add r32, r/m32 80386

Flags:
OF, SF, ZF, AF, CF, PF

[bearbeiten] AND

Verknüpft die Operatoren durch ein logisches AND

24 ib       and AL, imm8       8086
25 iw and AX, imm16 8086
80 /4 ib and r/m8, imm8 8086
81 /4 iw and r/m16, imm16 8086
83 /4 ib and r/m16, imm8 8086
20 /r and r/m8, r8 8086
21 /r and r/m16, r16 8086
22 /r and r8, r/m8 8086
23 /r and r16, r/m16 8086
25 id and EAX, imm32 80386
81 /4 id and r/m32, imm32 80386
21 /r and r/m32, r32 80386
83 /4 ib and r/m32, imm8 80386
23 /r add r32, r/m32 80386

Flags:

  • OF und CF werden gelöscht
  • SF, ZF und PF
  • AF ist undefiniert

[bearbeiten] CLC (Clear Carry Flag)

Löscht das Carry Flag.

F8          clc                 8086

Flags:
CF wird gelöscht

[bearbeiten] CLI (Clear Interrupt Flag)

Löscht das Interrupt Flag. Die CPU bearbeitet keine Interrupt-Requests (Hardware-Interrupts) mehr.

FA          cli                 8086

Flags:
IF wird gelöscht

[bearbeiten] CMC (Complement Carry Flag)

Dreht den Wahrheitswert des Carry Flags um.

F4          cmc                 8086

Flags:
CF wird gelöscht

[bearbeiten] DEC (Decrement)

Subtrahiert 1 zum Zieloperanden.

FE /1       dec r/m8            8086
FF /1 dec r/m16 8086
48 r+w dec r16 8086
FF /1 dec r/m32 80386
48 r+w dec r32 80386

Flags:

  • OF, SF, ZF, AF, CF, PF
  • Das Carry Flag wird nicht beeinflust

Beispiel:

DEC eax
DEC [eax]

[bearbeiten] DIV (Unsigned Divide)

Dividiert den AX, DX:AX oder EDX:EAX durch den Quelloperanden und speichert das Ergebnis im AX, DX:AX oder EDX:EAX Register.

F6 /6       div r/m8           8086
F7 /6 div r/m16 8086
F7 /6 div r/m32 80386

Flags:
CF, OF, SF, ZF, AF und PF sind undefiniert

[bearbeiten] IMUL (Signed Multiply)

Multipliziert eine vorzeichenbehaftete Zahl

F6 /5      imul r/m8               8086
F7 /5 imul r/m16 8086
F7 /5 imul r/m32 80386
0F AF /r imul r16, r/m16 80386
0F AF /r imul r32, r/m32 80386
6B /r ib imul r16, r/m16, imm8 80186
6B /r ib imul r32, r/m32, imm8 80386
6B /r ib imul r16, imm8 80186
6B /r ib imul r32, imm8 80386
69 /r iw imul r16, r/m16, imm16 80186
69 /r id imul r32, r/m32, imm32 80386
69 /r iw imul r16, imm16 80186
69 /r id imul r32, imm32 80386

Flags

  • Wenn imul nur einen Operand hat, ist das Carry Flag und das Overflow Flag gesetzt, wenn ein Übertrag in die höherwertige Hälfte des Ergebnisses stattfindet. Passt das Ergebnis exakt in die untere Hälfte des Ergebnisses werden Carry- und Overflow Flag gelöscht. Hat imul zwei oder drei Operanden, wird das Carry- und Overflowflag zu groß für den Zieloperanden ist, andernfalls wird es gelöscht.
  • SF, ZF, AF und PF sind undefiniert.

[bearbeiten] INC (Increment)

Addiert 1 zum Zieloperanden.

FE /0        inc r/m8        8086
FF /0 inc r/m16 8086
40 r+w inc r16 8086
FF /6 inc r/m32 80386
40 r+d inc r32 80386

Flags

  • OF, SF, ZF, AF, PF
  • Das Carry Flag wird nicht beeinflusst.

Beispiel:

INC eax
INC [eax]

[bearbeiten] INT (Interrupt)

INT löst einen Software-Interrupt aus. Dies ist vergleichbar mit dem Aufruf eines Unterprogramms (hier ein Interrupt-Handler). Über die allgemeinen CPU-Register können dem Interrupt-Handler Werte übergeben werden. Der Interrupt-Handler kann über diese Register auch Werte zurückliefern. Nach INT steht eine Interrupt-Nummer, die zwischen 00h und FFh liegt. Über diese kann man die Lage der Einsprungadresse für den entsprechenden Interrupt-Handler in der Interrupt-Vektor-Tabelle ermitteln.

CD           int imm8        8086

Flags

Beispiel:

MOV ah,4Ch;  Der Wert 4Ch (= Beenden des Programms) wird dem Interrupt-Handler übergeben  
INT 21h; Der Interrupt-Handler wird aufgerufen. Die Interrupt-Nummer ist 21h (MS-DOS).

[bearbeiten] IRET (Interrupt Return)

Rückkehr aus dem Interrupt-Handler, welcher mit INT aufgerufen wurde. Dieser Befehl ist vergleichbar mit RET, jedoch werden hier die Flags restauriert.

CF           iret            8086

Flags

[bearbeiten] MOV (Move)

Mit dem MOV Befehl wird der zweite Operand in den ersten Operanden kopiert.

88 /r       mov r/m8, r8       8086
89 /r mov r/m16, r16 8086
8A /r mov r8, r/m8 8086
8B /r mov r16, r/m16 8086
C6 /0 mov r/m8, imm8 8086
C7 /0 mov r/m16, imm16 8086
8C /r mov r/m16, SReg 8086
8E /r mov SReg, r/m16 8086
A0 mov al, moffs8 8086
A1 mov ax, moffs16 8086
A2 mov moffs8, al 8086
A3 mov moffs16, ax 8086

Flags
(keine)
Beispiel:

mov eax,10
mov eax,ebx

[bearbeiten] MUL (unsigned Multiplication)

Multipliziert den Zieloperanden mit dem AL, AX oder EAX Register. Das Ergebnis wird im AX, DX:AX oder EDX:EAX Register abgelegt (abhängig von der Größe des Zieloperanden). Der höherwertige Anteil des Ergebnisses befindet sich im AH, DX bzw. EDX Register.

F6 /4       mul r/m8           8086
F7 /4 mul r/m16 8086
F7 /4 mul r/m32 80386

Flags

  • OF und CF werden auf 0 gesetzt, wenn der höherwertige Anteil des Ergebnisses 0 ist.

[bearbeiten] NEG (Two’s Complement Negation)

Bildet das Zweierkomplement indem der Operand von 0 abgezogen wird.

F6/3        neg r/m8            8086
F7/3 neg r/m16 8086
F7/3 neg r/m32 80386

Flags

  • OF, SF, ZF, AF und PF.
  • Setzt das Carryflag auf 0 wenn das Ergebnis 0 ist, andernfalls wird es auf 1 gesetzt.

[bearbeiten] NOP (No Operation)

Führt keine Aktion aus

90         nop                 8086

(Der Opcode entspricht dem xchg ax, ax bzw. xchg eax, eax )

Flags
keine

[bearbeiten] NOT

Dreht den Wahrheitswert der Bits um. Entspricht dem Einerkomplement.

F6 /2       not r/m8          8086
F7 /2 not r/m16 8086
F7 /2 not r/m32 80386

Flags:
keine

[bearbeiten] OR

Verknüpft die Operatoren durch ein logisches ODER

0C ib       or AL, imm8       8086
0D iw or AX, imm16 8086
80 /1 ib or r/m8, imm8 8086
81 /1 iw or r/m16, imm16 8086
83 /1 ib or r/m16, imm8 8086
08 /r or r/m8, r8 8086
09 /r or r/m16, r16 8086
0A /r or r8, r/m8 8086
0B /r or r16, r/m16 8086
0D id or EAX, imm32 80386
81 /1 id or r/m32, imm32 80386
09 /r or r/m32, r32 80386
83 /1 ib or r/m32, imm8 80386
0B /r or r32, r/m32 80386

Flags:

  • OF und CF werden gelöscht
  • SF, ZF und PF
  • AF ist undefiniert

[bearbeiten] SBB (Subtraction with Borrow)

SBB subtrahiert von einem Speicherbereich oder einem Register den Wert von einem Speicherbereich oder einem Register und berücksichtigt dabei das Carryflag.

1C ib       sbb AL, imm8       8086
1D iw sbb AX, imm16 8086
80 /3 ib sbb r/m8, imm8 8086
81 /5 iw sbb r/m16, imm16 8086
83 /3 ib sbb r/m16, imm8 8086
18 /r sbb r/m8, r8 8086
19 /r sbb r/m16, r16 8086
1A /r sbb r8, r/m8 8086
1B /r sbb r16, r/m16 8086
1D id sbb EAX, imm32 80386
81 /3 id sbb r/m32, imm32 80386
83 /3 ib sbb r/m32, imm8 80386
19 /r sbb r/m32, r32 80386
1B /r sbb r32, r/m32 80386

Flags
OF, SF, ZF, AF, PF, CF

[bearbeiten] SHL (Shift Left)

Verschiebt alle Bit im Register um x Stellen nach links. Mathematisch wird der Wert im Register zum Beispiel beim Verschieben um eine Stelle mit 2 multipliziert. Beim multiplizieren mit 2, 4 und so weiter sollte dieser Befehl eingesetzt werden, da er gegenüber dem Befehl MUL von der CPU schneller abgearbeitet wird.

shl r8,x                    8086
shl r16,x 8086
shl r32,x 80386

Beispiel:

 mov al,00000001b (al = 00000001b)
shl al,1 (al = 00000010b)

Flags
CF

[bearbeiten] SHR (Shift Right)

Verschiebt alle Bit im Register um x Stellen nach rechts. Mathematisch wird der Wert im Register zum Beispiel beim Verschieben um eine Stelle mit 2 dividiert.

shr r8,x                    8086
shr r16,x 8086
shr r32,x 80386

Beispiel:

 mov al,00000010b (al = 00000010b)
shr al,1 (al = 00000001b)

Flags
ZF?

[bearbeiten] STC (Set Carry Flag)

Setzt das Carry Flag

F9          stc                8086

Flags
CF

[bearbeiten] STI (Set Interrupt Flag)

Setzt das Interrupt Flag.

FB          sti                8086

Flags
IF

[bearbeiten] SUB (Subtract)

SUB subtrahiert von einem Speicherbereich oder einem Register den Wert von einem Speicherbereich oder einem Register.

2C ib       sub AL, imm8       8086
2D iw sub AX, imm16 8086
80 /5 ib sub r/m8, imm8 8086
81 /5 iw sub r/m16, imm16 8086
83 /5 ib sub r/m16, imm8 8086
28 /r sub r/m8, r8 8086
29 /r sub r/m16, r16 8086
2A /r sub r8, r/m8 8086
2B /r sub r16, r/m16 8086
2D id sub EAX, imm32 80386
81 /5 id sub r/m32, imm32 80386
83 /5 ib sub r/m32, imm8 80386
29 /r sub r/m32, r32 80386
2B /r sub r32, r/m32 80386

Flags
OF, SF, ZF, AF, PF, CF

Beispiel:

SUB eax,10
SUB eax,ebx

[bearbeiten] XCHG (Exchange)

Der erste und zweite Operand wird vertauscht.

90+rw       xchg ax, r16       8086
90+rw xchg r16, ax 8086
86 /r xchg r/m8, r8 8086
86 /r xchg r8, r/m8 8086
87 /r xchg r/m16, r16 8086
87 /r xchg r16, r/m16 8086

Flags:
keine

[bearbeiten] XOR

Verknüpft die Operatoren durch ein logisches exklusives Oder (Antivalenz)

34 ib       xor AL, imm8       8086
35 iw xor AX, imm16 8086
80 /6 ib xor r/m8, imm8 8086
81 /6 iw xor r/m16, imm16 8086
83 /6 ib xor r/m16, imm8 8086
30 /r xor r/m8, r8 8086
31 /r xor r/m16, r16 8086
32 /r xor r8, r/m8 8086
33 /r xor r16, r/m16 8086
35 id xor EAX, imm32 80386
81 /6 id xor r/m32, imm32 80386
31 /r xor r/m32, r32 80386
83 /6 ib xor r/m32, imm8 80386
33 /r xor r32, r/m32 80386

Flags:

  • OF und CF werden gelöscht
  • SF, ZF und PF
  • AF ist undefiniert

Produkte