Assembler Befehle < Technische Inform. < Praktische Inform. < Hochschule < Informatik < Vorhilfe
|
| Status: |
(Frage) beantwortet  | | Datum: | 16:00 Di 18.01.2011 | | Autor: | Parkan |
| Aufgabe | Angenommen, die folgendenWerte sind in den angegebenen Registern bzw. Speicheradressen gespeichert:
Register Wert
%eax 0x00000100
%ecx 0x00000001
%edx 0x0000000C
Adresse Wert
0x100 0x0000BEEF
0x104 0x000000AC
0x108 0x00000013
0x10c 0x00078900
Überlegen Sie sich, welche Adressen bzw. Register als Ziel der folgenden Befehle ausgewaählt werden
und welche Resultatwerte sich ergeben:
addl %ecx, (%eax)
subl %edx,4(%eax)
imull $16,(%eax,%edx)
incl 8(%eax)
decl %ecx
subl %edx,%eax
Hinweis:
Beim gnu-Assembler steht der Zieloperand rechts, und eine runde Klammer um ein Register bedeutet
einen Speicherzugriff auf die entsprechende Adresse, ggf. mit dem vor der Klammer notierten Byte-
Offset. Zum Beispiel bewirkt
der Befehl: addl %ecx,12(%eax)
die Operation: MEM[0x0000010c] = 0x00078901 |
Ich möchte erste mal das hier anschauen addl %ecx, (%eax)
Ich hätte es so gemacht.
addl ist die addition
berechnet wird 0 + (%eax)
dann das Ergebnis in %ecx gespeichert.
Aber wenn ich das Beispiel da angucke addl %ecx,12(%eax) denke das mein Weg falsch ist.
Kann mir jemand erklären wie ich da vorgehen muss?
Gruß
Janina
|
|
| |
|
| Status: |
(Antwort) fertig  | | Datum: | 19:38 Di 18.01.2011 | | Autor: | felixf |
Moin Janina!
> Angenommen, die folgendenWerte sind in den angegebenen
> Registern bzw. Speicheradressen gespeichert:
>
> Register Wert
> %eax 0x00000100
> %ecx 0x00000001
> %edx 0x0000000C
> Adresse Wert
> 0x100 0x0000BEEF
> 0x104 0x000000AC
> 0x108 0x00000013
> 0x10c 0x00078900
>
> Überlegen Sie sich, welche Adressen bzw. Register als Ziel
> der folgenden Befehle ausgewaählt werden
> und welche Resultatwerte sich ergeben:
>
> addl %ecx, (%eax)
> subl %edx,4(%eax)
> imull $16,(%eax,%edx)
> incl 8(%eax)
> decl %ecx
> subl %edx,%eax
>
> Hinweis:
> Beim gnu-Assembler steht der Zieloperand rechts, und eine
> runde Klammer um ein Register bedeutet
> einen Speicherzugriff auf die entsprechende Adresse, ggf.
> mit dem vor der Klammer notierten Byte-
> Offset. Zum Beispiel bewirkt
> der Befehl: addl %ecx,12(%eax)
> die Operation: MEM[0x0000010c] = 0x00078901
>
> Ich möchte erste mal das hier anschauen addl %ecx, (%eax)
> Ich hätte es so gemacht.
> addl ist die addition
> berechnet wird 0 + (%eax)
> dann das Ergebnis in %ecx gespeichert.
Wie kommst du auf die 0?
> Aber wenn ich das Beispiel da angucke addl %ecx,12(%eax)
> denke das mein Weg falsch ist.
Warum?
> Kann mir jemand erklären wie ich da vorgehen muss?
Schreib ein wenig mehr warum du irgendwas meinst, dann kann man dir sagen wo du dich irrst. Wenn du meine beiden Fragen beantwortest kommen wir der Sache wohl naeher.
LG Felix
|
|
|
| |
|
| Status: |
(Frage) beantwortet | | Datum: | 20:35 Di 18.01.2011 | | Autor: | Parkan |
Ok fange wir an mit
Wie kommst du auf die 0?
Hier bei
addl %ecx, (%eax)
ist doch eine addition vorhanden. Der erste Wert ist in %eax (oder nicht?) gespeichert und weil kein anderer da steht würde ich sagen es ist die null.
Bei deiner Frage warum ich denk das mein Weg Falsch ist, naja weil ich das gegebene Beispiel nicht nachvollziehen kann bzw nach konstruieren.
|
|
|
| |
|
| Status: |
(Antwort) fertig | | Datum: | 01:07 Mi 19.01.2011 | | Autor: | felixf |
Moin!
> Ok fange wir an mit
>
> Wie kommst du auf die 0?
> Hier bei
> addl %ecx, (%eax)
> ist doch eine addition vorhanden. Der erste Wert ist in
> %eax (oder nicht?) gespeichert und weil kein anderer da
> steht würde ich sagen es ist die null.
Ok, nochmal ganz langsam von vorne.
Erstmal hast du:
> Register Wert
> %eax 0x00000100
> %ecx 0x00000001
> %edx 0x0000000C
> Adresse Wert
> 0x100 0x0000BEEF
> 0x104 0x000000AC
> 0x108 0x00000013
> 0x10c 0x00078900
Jetzt hast du addl %ecx, (%eax).
Lies dir nochmal den Hinweis durch:
> Beim gnu-Assembler steht der Zieloperand rechts, und eine runde Klammer
> um ein Register bedeutet einen Speicherzugriff auf die entsprechende Adresse,
> ggf. mit dem vor der Klammer notierten Byte-Offset. Zum Beispiel bewirkt
> der Befehl: addl %ecx,12(%eax)
> die Operation: MEM[0x0000010c] = 0x00078901
%eax = 0x100, %eax + 12 = 0x10c, und %ecx = 1
im Speicher unter der Adresse 0x10c stand vorher 0x78900, nun steht da 0x78901
Offensichtlich wurde an der Adresse 0x10c der Wert im Speicher um 1 erhoeht, also um den Wert von %ecx.
Und die Adresse 0x10c berechnet sich aus %eax + 12
Jetzt hast du addl %ecx, (%eax).
Die Adresse ist also %eax + 0 = 0x100
An 0x100 steht vorher der Wert 0xBEEF (siehe Tabelle oben)
Und %ecx hat den Wert 1
Also, was passiert bei addl %ecx, (%eax)?
LG Felix
|
|
|
| |
|
| Status: |
(Frage) beantwortet | | Datum: | 15:46 Mi 19.01.2011 | | Autor: | Parkan |
MEM[0x0000100] = 0x000BEF0
?
|
|
|
| |
|
| Status: |
(Antwort) fertig | | Datum: | 16:37 Mi 19.01.2011 | | Autor: | felixf |
Moin!
> MEM[0x0000100] = 0x000BEF0
> ?
Genau.
Und jetzt versuch dich doch mal an den Aufgaben, die du loesen sollst. Was passiert dort?
LG Felix
|
|
|
|
