Was bedeutet die Klammer in " movl (%eax), %eax` bedeuten?

Habe ich genug gegoogelt, konnte aber nicht herausfinden, was die Halterung () bedeutet. Außerdem sehe ich einige syntax als movl 8(%ebp), %eax

Könnte jemand einige empfehlen mir ein paar gute Referenz? Ich habe nicht in der Lage zu finden in den top-20-Ergebnisse von Google.

Möglicherweise behindert die Suche ist die Tatsache, dass AT&T und Intel haben Ihre eigenen Versionen von Montage-das ist AT&T-syntax.
Ich hatte herausgefunden, aber ich war nicht in der Lage zu finden, eine anständige Referenz, erklärte die GNU-syntax.

InformationsquelleAutor Lord Loh. | 2011-07-25

14

%eax register EAX; (%eax) ist der Speicherstelle, deren Adresse in dem register enthaltenen EAX; 8(%eax) ist der Speicherstelle, deren Adresse ist der Wert des EAX-plus 8.

InformationsquelleAutor LaC
8

http://web.archive.org/web/20080215230650/http://sig9.com/articles/att-syntax ist eine schnelle Einführung in Unix (AT&T) - asm-syntax. Gegoogelt von at&t asm syntax.

Die post ist "AT&T Assembly-Syntax" von vivek (http://web.archive.org/web/20080228052132/http://sig9.com/blog/vivek), 2003-09-01. Es ist eine wichtige info über AT&T es:
Beispielsweise das Allgemeine format einer basic-data-Bewegung Unterricht in INTEL-syntax ist,
```
mnemonic    destination, source
```
in der Erwägung, dass im Fall von AT&T, die Allgemeine format ist
```
mnemonic    source, destination
```
(Ich erinnere mich an diese Reihenfolge, wie der Aufruf von AT&T asm als echte Unix asm, so ist es Recht ein, und es fließt die Daten auf der rechten Seite, während die Intel-syntax basiert auf einigen falschen masms doc, die eindeutig nicht das richtige für Unix-Welt, Sie sind Links und Datenflüsse auf der linken Seite)
Alle register Namen der IA-32-Architektur muss vorangestellt werden ein ' % ' - Zeichen, wie zB. %al,%bx, %TS, %cr0 etc.

Alle Literale Werte müssen mit einem Präfix versehen sein, die durch ein " $ " - Zeichen. Zum Beispiel,
```
mov $100,   %bx
mov $A, %al
```
Die erste Anweisung verschiebt den Wert 100 in das register AX und die zweite bewegt sich der numerische Wert des ascii Ein in das AL register.

In der AT&T-Syntax, Speicher wird in der folgenden Weise
```
segment-override:signed-offset(base,index,scale)
```
Teile davon können weggelassen werden, abhängig von der Adresse, die Sie wollen.> %es zu:100(%eax,%ebx,2)

Bitte beachten Sie, dass die offsets und die Waage sollte nicht mit vorangestelltem '$'. Ein paar weitere Beispiele mit den entsprechenden NASM-syntax, um das etwas zu verdeutlichen,
```
GAS memory operand      NASM memory operand
------------------      -------------------

100                     [100]
%es:100                 [es:100]
(%eax)                  [eax]
(%eax,%ebx)             [eax+ebx]
(%ecx,%ebx,2)           [ecx+ebx*2]
(,%ebx,2)               [ebx*2]
-10(%eax)               [eax-10]
%ds:-10(%ebp)           [ds:ebp-10]
Example instructions,
mov %ax,    100
mov %eax,   -100(%eax)
```
Operanden-Größen. Mal, vor allem beim verschieben von literal-Werten in den Speicher, wird es notwendig, um die Größe festzulegen-der-Weitergabe oder der Operanden-Größe. Zum Beispiel die Anweisung,
```
mov    $10,    100
```
nur spezifiziert, dass der Wert 10 ist, bewegt werden, um den Speicher-offset 100, nicht aber die übertragung Größe. In NASM dies geschieht, indem Sie die casting-keyword-byte/word/dword-etc. zu jedem der Operanden. Im AT&T-syntax, dies geschieht durch hinzufügen eines suffix - b/w/l - für die Belehrung. Zum Beispiel,
```
movb    $10,    %es:(%eax)
```
bewegt ein byte mit dem Wert 10 auf dem Speicherort [ea:eax], in der Erwägung,
```
movl    $10,    %es:(%eax)
```
bewegt sich ein long-Wert (dword) 10 an den gleichen Ort.

Jmp, call, ret, etc., Anweisungen übertragen der Steuerung von einem Teil eines Programms zum anderen. Sie können klassifiziert werden als control-transfers auf der gleichen code-segment (in der Nähe) oder um andere Codesegmente (far). Die möglichen Arten von branch-Adressierung - relative offset (label), register -, Speicher-Operanden, und der segment-offset-Zeiger.

Relativen offsets, angegeben sind, die Verwendung von Etiketten, wie unten gezeigt.
```
label1:
    .
    .
  jmp   label1
```
Zweig Adressierung über die Register-oder speicheroperanden muss vorangestellt werden, die durch ein '*'. Um anzugeben, eine "fern" - Steuern, tranfers, ein 'l' muss vorangestellt werden, wie in 'ljmp', 'lcall', etc. Zum Beispiel,
```
GAS syntax        NASM syntax
==========        ===========

jmp   *100        jmp  near [100]
call  *100        call near [100]
jmp   *%eax       jmp  near eax
jmp   *%ecx       call near ecx
jmp   *(%eax)     jmp  near [eax]
call  *(%ebx)     call near [ebx]
ljmp  *100        jmp  far  [100]
lcall *100        call far  [100]
ljmp  *(%eax)     jmp  far  [eax]
lcall *(%ebx)     call far  [ebx]
ret               retn
lret              retf
lret $0x100       retf 0x100
```
Segment-offset-Zeiger werden im folgenden format angegeben:
```
jmp    $segment, $offset
```
Er empfiehlt auch gnu-as (gas) docs: http://web.archive.org/web/20080313132324/http://sourceware.org/binutils/docs-2.16/as/index.html

InformationsquelleAutor osgx
3

Sind Sie bewegen Anweisungen, verschieben von Daten von einem Ort zum anderen - in diesen Fällen aus dem Speicher in ein register:
```
register_eax = *(unsigned long *)register_eax;
```
Ihre anderen Beispiel so etwas wie:
```
register_eax = *(unsigned long *)(register_ebp + 8);
```
InformationsquelleAutor Carl Norum

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.