Lowlevel

Lowlevel => Lowlevel-Coding => Thema gestartet von: RedEagle am 05. August 2009, 14:33

Titel: g++ entfernt trotz volatile relevanten code
Beitrag von: RedEagle am 05. August 2009, 14:33

Hi
Ich habe folgende Funktion:

Code: [Auswählen]

volatile bool NewKOT = false; //global

void WaitForKOT_()
{
 while(!NewKOT); //NewKOT wird beim interrup gesetzt
 return;
}
mein g++ 4.3.1 macht da folgendes raus:

Code: [Auswählen]

00000175 <_ZN3KOT11WaitForKOT_Ev>:
 175:   55                      push   %ebp
 176:   89 e5                   mov    %esp,%ebp
 178:   a0 00 00 00 00          mov    0x0,%al
 17d:   84 c0                   test   %al,%al
 17f:   74 f7                   je     178 <_ZN3KOT11WaitForKOT_Ev+0x3>
 181:   5d                      pop    %ebp
 182:   c3                      ret
Warum?
Ich habe doch durch volatile angegeben, dass sich der Wert von NewKOT unabhängig von der Funktion ändern kann.
Das sieht ohnehin so aus, als würde er NewKOT als Konstant annehmen, da der Wert nicht einmal aus dem Speicher geholt wird.

ps.: meine Compiler-einstellungen
[/i]COMPILERSETTINGS="-I $HEADERS -DCPU=586 -m32 -c -Os -nostdlib -fno-builtin -fno-rtti -fno-exceptions"[/i]

Titel: Re: g++ entfernt trotz volatile relevanten code
Beitrag von: kevin am 05. August 2009, 14:57

Hm, und wo ist dein Problem? Ist doch eine schöne Schleife, die ständig auf Null prüft?

Titel: Re: g++ entfernt trotz volatile relevanten code
Beitrag von: RedEagle am 05. August 2009, 15:12

der code, den der Kompiler daraus erzeugt ist das Problem:

Code: [Auswählen]

mov    0x0,%al ; al = 0
test   %al,%al ; al==al (bzw al==0)
je     178 <_ZN3KOT11WaitForKOT_Ev+0x3> ; wenn al==al (oder al==0) springe zurück
Das Problem ist, das al sich niemals ändert - al ist immer 0 oder sehe ich das falsch?
Es wird zu keinem Zeitpunkt der Wert geholt, der unter NewKOT liegt

Was mich jetzt noch weiter verwirrt:
Eigentlich sollte es eine endlosschleife sein, da test %al, %al das ZF immer auf 0 setzt weil al immer 0 ist und somit je immer zurück springt.

Aufgefallen ist mir die Funktion aber dadurch, dass sie NICHT wartet  :?

Titel: Re: g++ entfernt trotz volatile relevanten code
Beitrag von: Jidder am 05. August 2009, 15:21

Das ist nur die Objekt-Datei, die du da disassembliert hast, oder?

Der lädt nämlich nicht AL mit 0, sondern AL mit dem Wert an der Adresse 0. Weil da kein $ vor der 0 ist. Wenn du die Datei linkst, sollte der Linker die 0 auch noch durch eine vernünftige Adresse ersetzen.

Titel: Re: g++ entfernt trotz volatile relevanten code
Beitrag von: RedEagle am 05. August 2009, 15:37

bin ich auch gerade drauf gekommen :D (bin die AT&T-Syntax nicht gewohnt)

Das macht die Sache aber nur noch mysteriöser :(

Code: [Auswählen]

void WaitForKOT_()
{
 while(!NewKOT); //NewKOT wird beim interrup gesetzt
BREAKPOINT;
 return;
}
Aber auch wenn NewKOT == false ist, gehts zum breakpoint.
Ich habe mir vor & nach der schleife den Wert von NewKOT ausgeben lassen - er ist auf jeden fall immer false... - zumindest lt Ausgabe.

Ich werde mal gucken, ob das NewKOT im opcode das selbe ist, wie meins...

--edit--

Ja, die Adressen stimmen überein (war ja auch so zu erwarten)
Allerdings bleibt der Wert von NewKOT = false  :?

Hm... Dann mache ich mal von neuem auf die Suche...
Vieleicht ist er ja nur für einige millisekunden true...