Run-Time Check Failure #2

cthome

Grünschnabel
Hallo,

habe folgendes Problem und weiß nicht woran es liegt evtl kann mir ja jemand helfen.
Erstmal der Fehler.
Run-Time Check Failure #2 - Stack around the variable 'test' was corrupted.

Hier mal das Programm:

#include <stdio.h>

void main()
{
struct x
{
char a;
char b;
int c;
int d;
};

int wert;
struct x test;
struct x *ptr;
ptr = &test;

test.a = 'a';
test.b = 'b';
test.c = 1;
test.d = 3;

_asm
{
lea esp,[test]
add esp,8
mov eax,[esp]
mov wert,eax
}

printf("Wert: %i ",wert);

getchar();
}

Ein Kollege hat das gleich Programm und bei ihm kommt kein Fehler. Vielleicht kann mir ja jemand helfen. Habe schon gesucht aber finde kein vergleichbares Problem. (Das Programm ist ziemlich Sinnlos, einfach nur eine Übung)

MFG
 
Also bei mir kommt dieser Fehler auch. Baue ich das Stück Assembler allerdings so um, dann gehts:

Code:
	_asm
	{
		mov ebx, esp
		lea esp, [test]
		add esp, 8
		mov eax, [esp]
		mov wert, eax
		mov esp,ebx
	}

Ich hab davon auch nicht viel Ahnung, aber ich würde sagen, dass du "esp" wieder auf seinen Ausgangswert setzen musst, nachdem dem damit rumhantiert hast? Der SP zeigt ja auf die Spitze vom Stack. Und wenn du die einfach verschiebst...?
Ich arbeite übrigens mit Vista x64.
 
Zuletzt bearbeitet:
Hallo,

danke also funktionieren tut es nun, noch eine kleine Anmerkung der esp (Stackpointer) zeigt nicht auf den Anfang vom Stack sondern "willkürlich" dahin wo er gerade benötigt wird. Der ebp (Basepointer) zeigt auf den Anfang vom Stack. Du kannst jedoch recht haben das der esp wieder an seine Ausgangposition gesetzt werden muss.

MFG
 
Siehst, dass es Stackpointer heißt, hab ich noch gewusst... ist aber schon eine Zeit her, seit ich mich damit das letzte Mal beschäftigt hab :rolleyes:
 
...der esp (Stackpointer) zeigt nicht auf den Anfang vom Stack sondern "willkürlich" dahin wo er gerade benötigt wird. Der ebp (Basepointer) zeigt auf den Anfang vom Stack...

das ist nicht ganz richtig.. der stackpointer zeigt natürlich auf die spitze vom stack, sonst würde er nicht stackpointer heißen... das mag vielleicht willkürlich aussehen, da der stack auch für die lokalen variablen benutzt wird... die adresse wird im realmode einer x86 CPU mit BP:SP gebildet.. wie das windows im 32bit protected mode macht, weiß ich nicht... jedenfalls is der ESP 32bit breit un zeigt auf die spitze des stapels, fertig :)
 
Also ich kann nur sagen was mir mein Professor gesagt hat.
Alles für x86 Architektur!
Der Stack ist 16Bit breit, am Anfang des Stacks steht die Parametrierung, dann die Rücksprungadresse und sofort danach steht der EBP (Basepointer), der Stackpointer wandert eben da wo gerade Daten geschrieben bzw. gelesen werden. Nach dem Basepointer kommen die einzelnen Register und danach die lokalen Variablen.
Sinn und Zweck des Basepointers ist es eben eine feste Bezugsadresse im Stack zu haben.

MFG
 
Aber letztendlich sieht es ja so aus, dass der EBP auf 0 zeigt, und der Stack nach unten wächst. Du hast deine Parameter bis sagen wir -8 und danach die Rücksprungadresse. Wenn du jetzt aber so wie in deinem Code oben den SP, der im Moment vielleicht auf die Rücksprungadresse zeigt, einfach auf -4 einstellst, dann kann das Programm ja nicht mehr aus dem Assembler-Teil raus in den C-Teil springen? Vorausgesetzt, dass der Compiler aus jedem _asm-Block eine eigene Funktion mit Sprungmarke und ret macht?
Wahrscheinlich totaler nonsense :) .
 
und ich hab mich da verplappert, die adresse wird natürlich mit SS:SP gebildet... uff

-> http://sandpile.org/ia32/index.htm

der STACKPOINTER ist 16/32bit breit (386+)

SP <- 16bit
ESP <- 32bit
x64 vergessen wir mal^^

so.. und wie die register geladen werden, hat in dem fall nix mit der x86 architektur zu tun, sondern mit der C/C++ calling convention

-> http://www.3rd-evolution.de/docs/windows/callconv/

hier wird der EBP genutzt um den ESP zu sichern, das kann man machen, muss man aber nicht... EBP ist auch nur ein general purpose register...
 
Zurück