✔ Disassemblierte Variablen

Ü

üäpöol

Erfahrenes Mitglied
Hi,

es tut mir wirklich Leid, wenn es dieses Thema schon mal gab oder man durch Googlen sofort die Antwort findet, aber ich weiß nicht wonach ich suchen soll.
Ich habe eine Frage zum Disassemblieren und/oder "Dateiformaten".
Wenn ich eine kleine Assemblerdatei zu *.bin assembliere und diese Date wieder disassemliere kann ich den Code ohne Problem lesen. Mein Problem tritt auf, wenn ich die Datei über eine *.obj zu einer *.exe mache. Nicht nur, dass der Code jetzt recht schwer zu verstehen ist (was eigentlich klar ist), sondern ich kann Variablen nicht mehr zurückverfolgen.
Ich zeig einfach mal meinen Code:

Meine *.asm
Code: 
mov ax, a
mov al, 01h
int 16h

a db "a"

Das Ergebnis der disassemblierten *.bin
Code: 
00000000  B80700            mov ax,0x7
00000003  B001              mov al,0x1
00000005  CD16              int 0x16
00000007  61                popaw
was ja immer noch zu lesen und verstehen ist.
Wenn ich den Code richtig verstehe wird in der ersten Zeile einfach nur das geladen, was an der Position (?) 00000007 steht.
Jetzt meine erste Frage: Wie kann der Computer entscheiden ob das, was bei 00000007 steht oder 0x7 in das Register geschrieben werden soll?
Ich bin begeistert, wenn jmd. noch bis hier gelesen hat. :)
OK, weiter.

Das Ergebnis der disassemblierten *.exe
Code: 
00000000  4D                dec bp
00000001  5A                pop dx
00000002  48                dec ax
00000003  0001              add [bx+di],al
00000005  0000              add [bx+si],al
00000007  0004              add [si],al
00000009  0000              add [bx+si],al
0000000B  00FF              add bh,bh
0000000D  FF00              inc word [bx+si]
0000000F  0000              add [bx+si],al
00000011  0000              add [bx+si],al
00000013  0000              add [bx+si],al
00000015  0000              add [bx+si],al
00000017  004000            add [bx+si+0x0],al
0000001A  0000              add [bx+si],al
0000001C  0000              add [bx+si],al
0000001E  0000              add [bx+si],al
00000020  0000              add [bx+si],al
00000022  0000              add [bx+si],al
00000024  0000              add [bx+si],al
00000026  0000              add [bx+si],al
00000028  0000              add [bx+si],al
0000002A  0000              add [bx+si],al
0000002C  0000              add [bx+si],al
0000002E  0000              add [bx+si],al
00000030  0000              add [bx+si],al
00000032  0000              add [bx+si],al
00000034  0000              add [bx+si],al
00000036  0000              add [bx+si],al
00000038  0000              add [bx+si],al
0000003A  0000              add [bx+si],al
0000003C  0000              add [bx+si],al
0000003E  0000              add [bx+si],al
00000040  B80700            mov ax,0x7
00000043  B001              mov al,0x1
00000045  CD16              int 0x16
00000047  61                popaw
Jetzt kann ich erkennen, dass wohl nur die letzten vier Zeile wichtig sind. Aber ich kann jetzt nicht mehr zurückverfolgen, was an der Position 00000007 steht, denn "popaw" steht jetzt bei 00000047.
Meine zweite Frage: Gibt es eine Möglichkeit entweder *.exe in *.bin umwandeln oder herauszufinden, was die Position 00000007 ist?

OK, ich hoffe, das ist jetzt nicht zu viel.
Vielen Dank für eure Hilfe!

EDIT:
Falls irgendjemand langweilig sein sollte, kann der mir ja vielleicht erklären, was es mit dem Rest des disassemblierten *.exe Codes auf sich hat. :D
 
Zuletzt bearbeitet:
es ist lange her das ich mich mit assembler beschaeftigt habe, also keine garantie auf korrekte infos;)

was mir seltsam vorkommt:
du laedst register ax, ein wort register mit einer byte variablen...
mov ax, a (wort)
a db "a" (byte)

auch dass die definition von "a" unterhalb der verwendung steht... hmm, noergelt da nicht der assembler rum?

das > 00000000 B80700 mov ax,0x7
laedt ax mit einer konstanten (0x7 - woher die 0x7 ist mir noch nicht ganz klar;), scheinbar aber nicht mit deiner variablen "a"

die steht hier > 00000007 61 popaw (der ascii hex code fuer "a" ist 0x61)

mehr kann ich derzeit leider auch nicht sagen;)
 
Zuletzt bearbeitet:
Hi,

dass ich ein Byte in ein Word lade, kam mir auch komisch vor.
Ich muss es aber sogar, wenn ich in eine *.obj Datei assemblieren will.
Bei binärem Format ist das dem Compiler egal.
Ich arbeite mit NASM, vielleicht ist das der Grund für die seltsame Syntax.
Das mit der 61 ist mir auch schon aufgefallen, hilft mir aber auch nicht wirklich weiter, weil ich eh weiß, dass popaw a bedeutet.

Schonmal danke für deine Hilfe!
 
Hi.
üäpöol hat gesagt.:
Mein Problem tritt auf, wenn ich die Datei über eine *.obj zu einer *.exe mache. Nicht nur, dass der Code jetzt recht schwer zu verstehen ist (was eigentlich klar ist), sondern ich kann Variablen nicht mehr zurückverfolgen.
Zum Vergrößern anklicken....
Das ist klar. Es gibt keine Variablen in Maschinencode.

Die 7 bei "mov ax, 7" ist einfach die Adresse des Datums "a" ausgehend vom data Segment addressiert.

Schau dir mal IDA Pro an, das bietet eine sehr gute Analyse von Maschinencode.

Gruß
 
:D Dann habe ich mich entweder zu unpräzise ausgedrückt oder die Antwort nicht verstanden:
Nochmal die Frage anders gestellt:
In diesem Fall möchte ich die Zahl 7 in das ax Register stecken.
Code: 
mov ax, 7
mov al, 01h
int 16h

a db "a"

In diesem Fall möchte ich die Variable a in das ax Register tun.
Code: 
mov ax, a
mov al, 01h
int 16h

a db "a"

Das Ergebnis des Disassemblierens ist in beiden Fällen
Code: 
00000000  B80700            mov ax,0x7
00000003  B001              mov al,0x1
00000005  CD16              int 0x16
00000007  61                popaw

Wie kann ich die beiden Fälle unterscheiden (wie macht das der Computer)?
Ich hoffe, die Frage ist jetzt ein bisschen präziser.
 
Um antworten zu können musst du eingeloggt sein.

Neue Beiträge

Zurück