Erstes Assembler-Programm

[CDW]

RE: Arbeitsspeicher

Stack "wächst" von unten nach oben - von größeren Adressen zu kleineren. Das ist aber nur eine Konvention. D.h der Stack hat nicht dieselbe Adresse wie der Code/Daten, sondern ist ein anderer Speicherbreich.

Wieso wächst der von unten nach oben?

siehe das Wort Konvention.
Wurde so vereinbart.

Und was genau meinst du mit "der Stack hat nicht dieselbe Adresse wie der Code/Daten??Haben die etwa ne spezielle Adresse? Oder meintest du Adressbereich??
Denn so wie du das im Beispiel gezeigt hast, sind Code/Daten und Stack genauso hintereinander angeordnet.

in deinem Bild hat Stack wieder die Adresse 0001, die ja schon vom Code belegt ist.
Als Stack wird einfach ein freier Speicherbreich genommen - Anfangs und Endadresse sind dann Stackanfangsadresse und Stackendadresse.

Der Assembler trennt Code und Daten durch seperate Segmente voneinander, richtig?
Also sprich: Mein Programm besteht aus 2 Segmenten. Wo aber stehen infos zu diesen Segmenten (Anfangs/End - Adresse)?
Die Segmente sind ja wohl nicht einfach durch ein paar "leere Adressen" voneinander getrennt, oder?
Und das selbe ist dann mit dem Stack, oder? Der ist dann einfach ein drittes Segment, oder?

Du brinst jetzt zwei unterschiedliche Speicherzugriffsverfahren durcheinander. Segmentierung so wie es im Helloworld steht ist eine DOS Krücke, um mehr Specher anzusprechen. Denn in 16-Bit Registern kann man "as is" erstmal auch nur Werte bis 65535 haben. Also hat man noch Segmentregister eingefügt - aus dem Wert im Segmentregister und dem im 16-Bit "normalregister" setzt sich dann die tatsächliche Adresse - man kann also nicht nur 65k Speicher ansprechen, sondern irgendwas mit 1MB
Durch die SEGMENT Deklarierungen sagst du dem Assembler, dass er die Daten in unterschiedlichen maximal auf einmal ansprechbaren Speicherbereichen (Segmenten) platzieren soll.
Zu der Trennung:
In 32-Bit Asm kann man nun alles durcheinander schreiben:

.data
x dd 0
.code
mov eax,x
.data
  hello db "helloworld",0
.code
add eax, offset hello
call ausgabe

der Assembler bringt dann .data Einträge zusammen in einem Block(genauso mit .code)
und platziert die Blöcke so, wie er lustig ist (Codebereich vor Daten oder auch andersrum).
Es gibt keinerlei Trennung durch Markierungen - alles wird linear in den Speicher geladen. D.h wenn du am Ende deines Asm Codes keinen RET/JMP "ENDE" hast und danach Daten folgen, gibt es lustige Fehlermeldungen, wenn die CPU versucht, Daten als Anweisungen zu interpretieren.

also:

So stelle ich mir das vor:
Beispielprogramm:

0001:  code
0002:  code
0003:  code
0004:  code
0005:  leere Adresse     <---- hier ist der Zwischenraum der Segmente Code - Daten

nein.

Steht die Stackanfangsadresse im ESP oder im EBP ?

Es kommt auf die Konvention an, an die sich der Compiler/Asmprogrammierer hält.Es ist nur so, dass bestimmte CPU Anweisungen (push, pop,call,ret) automatisch die Werte aus PTR [ESP] auslesen und den ESP Register modifizieren.
Wenn du in Windows ein Programm startest, dann ist in EBP die "Stackbasis" und ESP verweist auf den aktuellen "oberen" Wert. Die Daten, die zu diesem Zeitpunkt auf dem Stack liegen, gehören dem Aufrufer (also Windows). Nach konvention wird man also vor der Nutzung des Stacks erstmal die alten Werte sichern und den Stackspeicher reservieren (also PUSH EBP; MOV EBP,ESP; ADD ESP,Größe; usw).

Zu deinem Codebeispiel der Funktion habe ich auch noch eine Frage:

push ebp ;alten Wert sichern

Verstehe ich nicht...
Wenn EBP beim Programmstart eine Adresse (Anfangsadresse des Stacks) beinhaltet, dann bewirkt dieser Befehl doch nur, dass diese Adresse als Wert in eine neue Adresse auf den Stack gelegt wird, oder? Aber was bringt das??

Wenn man seinen Code nur in der Mainfunktion unterbringt, bringt es tatsächlich nichts.
aber was ist mit

int main()
{
   l337_output("hello");
   return 0
}

void l337_output(String str)
{
   for (int i=0;i<str.len();i++)
    {
      if (str[i]=='e') str[i]='3';
      if (str[i]=='o') str[i]='0';
    }
   printf("%s",str);
}

?

Sofern man nur eigene Funktionen nutzt, kann man sich als Asmprogrammierer noch irgendwas überlegen - als Compilerentwickler oder Nutzer von Fremdfunktionen muss man allerdings an eine Konvention halten. Eine gebräuchliche Konvention ist also, den
Stackzustand nach dem Funktionsaufruf genauso zurückzugeben, wie er vor dem Aufruf war. D.h wenn man lokale Variablen hat, spricht man sie in Asm für gewöhnlich mit [EBP-Position] an (genauso übersetzt es auch meistens der Compiler). Wenn man den EBP Wert vor der Codeausführung nicht sichert, hat man 2 Optionen - diesen Überschreiben (dann erhält der Aufrufer einen anderen Wert als er vor dem Funktionsaufruf hatte - und findet seine lokalen Variablen nicht mehr) oder man verändert EBP Wert nicht. Dann kann man aber in dieser Funktion lokale Variablen nicht per [EBP-Position] ansprechen, weil der EBP Wert ja nicht bekannt ist und je nach dem, von welcher anderen Funktion diese Funktion aufgerufen wurde, unterschiedlich.
Also sicher man den alten EBP, kopiert den ESP darauf (damit bildet EBP also die Basisstackadresse in der Funktion) und kann lokale Variablen reservieren oder andere Sachen machen. Zum Schluss stellt man den alten Zustand wieder her.

 

[Gapa]

Assembler

Schön

Ich glaube ich bin übern Berg

Klingt auf einmal sogar alles logisch!

Er heftet einfach den Datenteil hinter den Codeteil und es kann nichts passieren, da man bei richtiger Programmierung ja nen RETN / JMP - Befehl ans Ende des Codes setzt...Ich frage mich wieso es so lange gebraucht hat, bis ich das verstanden habe^^

Wie genau das mit dem Stack jetzt noch läuft, werde ich wohl im Laufe der Zeit herausfinden. Aber es stimmt doch, dass ich den Stack eig für kleine Programme gar nicht bräuchte, oder? Ich könnte ja immer die Daten des Daten-abschnitts meines Programms nutzen...

Du brinst jetzt zwei unterschiedliche Speicherzugriffsverfahren durcheinander. Segmentierung so wie es im Helloworld steht ist eine DOS Krücke, um mehr Specher anzusprechen. Denn in 16-Bit Registern kann man "as is" erstmal auch nur Werte bis 65535 haben. Also hat man noch Segmentregister eingefügt - aus dem Wert im Segmentregister und dem im 16-Bit "normalregister" setzt sich dann die tatsächliche Adresse - man kann also nicht nur 65k Speicher ansprechen, sondern irgendwas mit 1MB Durch die SEGMENT Deklarierungen sagst du dem Assembler, dass er die Daten in unterschiedlichen maximal auf einmal ansprechbaren Speicherbereichen (Segmenten) platzieren soll. Zu der Trennung: In 32-Bit Asm kann man nun alles durcheinander schreiben:

Das heißt, dass man mit 32-Bit ASM keine Segmentregister mehr braucht??

Was ich noch nicht ganz verstehe ist:
1. das Zusammenspiel Virtueller Adressen und den physischen Adressen
2. Wo und wie das Betriebssystem Bibliotheken wie Kernel32 oder User32 mit in den Programmspeicher einfügt

Aber da ich nun im Stande bin, ein Hallo Welt - Programm in Assembler zu schreiben und auch weiß, wie man zu einer Adresse springt, kann ich mich wieder einem ALTEN Thema widmen^^ - http://www.hackerboard.de/thread.php?postid=283429#post283429


VIELEN DANK AN ALLE DIE MIR HIER WEITERGEHOLFEN HABEN!!!!

Viele Grüße
Gapa

 

[xrayn]

RE: Assembler

Original von Gapa
1. das Zusammenspiel Virtueller Adressen und den physischen Adressen

Lies mal diesen Wikiartikel und die Links, die weiterfuehren. Wenn dann noch Fragen offen sind

Original von Gapa
2. Wo und wie das Betriebssystem Bibliotheken wie Kernel32 oder User32 mit in den Programmspeicher einfügt

Beim Laden deines Prozesses und machen tut das der PE-Loader. Diese Libs nennt man auch WinAPI und sie sind die Schnittstelle zwischen deinem Programm und Windows. Kein Win32-Programm kommt ohne das WinAPI aus.