"void" main ist explizit nicht erlaubt.
Ah ja. Süsses kleines MSVC++
Und zumindest bei neuen Standardversionen (oder auch allen)
ist der Returnwert implizit 0, wenn nichts angegeben wird.
Tatsächlich, eine Ausnahmeregelung für die main()
. Soweit ich gesehen habe, war das nicht immer so, sodass der Wert einfach undefiniert war. Aber schon C99 scheint das zu haben.
Dies verwirrt aber auch stark: Der ASM-Code ist wird dadurch nicht konsistent übersetzt: Für keine int-Funktion ausser der main() ist eine implizite Rückgabe erlaubt. Grund: Das EAX-Register muss gefüllt werden. "return" ist eigentlich nichts anderes als:
Code:
(013D179E xor eax,eax); Nur bei Rückgabe 0
(mov eax, Wert; Wert ist hierbei der Rückgabewert (hinter "return")); Nur bei nicht-void-Funktionen
} //Ende der Funktion
013D17A0 pop edi
013D17A1 pop esi
013D17A2 pop ebx
013D17A3 mov esp,ebp
013D17A5 pop ebp
013D17A6 ret [Anzahl Bytes der Parameter]; (Nur unter _stdcall. _cdecl lässt den caller aufräumen)
"void" heisst ja gerade, dass "nichts" zurückkommt bzw. das EAX-Register nicht beachtet werden soll.
In diesem Falle ist MSVC++ sicher falsch: Denn void müsste bedeuten, dass eben nichts mit dem EAX-Register gemacht wird, was schlicht nicht zutrifft.
Auf der anderen Seite ist eine Funktion mit Rückgabetyp "int" falsch (und schmeisst einen Compiler Error), wenn sie eben _keinen_ Wert zurückgibt.
Interessanter wird es bei einer Funktion, bei der nicht alle "Steuerelementpfade" einen Wert zurückgeben:
C++:
int testInt(char a, char b)
{
int c = a + b;
if (c < 0)
return 0;
}
Hier sieht das Disassembly so aus:
Code:
int testInt(char a, char b)
{
00231780 push ebp
00231781 mov ebp,esp
00231783 sub esp,0CCh
00231789 push ebx
0023178A push esi
0023178B push edi
0023178C lea edi,[ebp-0CCh]
00231792 mov ecx,33h
00231797 mov eax,0CCCCCCCCh
0023179C rep stos dword ptr es:[edi]
int c = a + b;
0023179E movsx eax,byte ptr [a] ;eax ist nun a
002317A2 movsx ecx,byte ptr [b]
002317A6 add eax,ecx ;add speichert das Ergebnis in EAX
002317A8 mov dword ptr [ c],eax
if (c < 0)
002317AB jns testInt+2Fh (02317AFh) ;Überbrückt das folgende XOR
return 0;
002317AD xor eax,eax
}
002317AF pop edi
002317B0 pop esi
002317B1 pop ebx
002317B2 mov esp,ebp
002317B4 pop ebp
002317B5 ret
Entsprechend ergibt der folgende Code einen Wert in testEAX von 13.
C++:
int testEAX;
testInt(10, 3);
_asm
{
mov dword ptr [testEAX], eax
}
return 1;
Ist es gesucht? Sicherlich. Aber das zeigt gerade den Vorteil von void: Dieser Rückgabetyp lässt EAX in Ruhe. Wenn man also saumässig performanten Code schreiben will und mit void eine mov-Operation sparen kann, warum nicht? Und ja: Natürlich kann ich alles in ASM schreiben, um die maximale Performance zu haben (oder auch nicht, je nachdem
). Aber: C sollte nicht mehr machen, als ASM zu abstrahieren, gewissermassen Makros zu definieren.
So, und jetzt zur alles entscheidenden Frage: Was passiert, wenn ich mithilfe des "Steuerelementpfades" eine Überbrückung des xor eax, eax zu erzwingen versuche?
Code:
int main()
{
;Normale Initialisierung
volatile int one = 1;
0006143E mov dword ptr [one],1
volatile int two = 2;
00061445 mov dword ptr [two],2
if (one == two)
0006144C mov eax,dword ptr [two]
0006144F cmp dword ptr [one],eax
00061452 jne main+3Bh (06145Bh)
{
return 10;
00061454 mov eax,0Ah
00061459 jmp main+41h (061461h)
}
else
{
}
}
0006145B jmp main+3Fh (06145Fh) ;Hier wird getrickst, um doch noch auf eine 0 zu kommen
0006145D jmp main+41h (061461h) ;Hier wird dafür gesorgt, dass bestehende Rückgabewerte nicht überschrieben werden (Vorhergehende returns _müssen_ auf die Adresse 6145D oder 61461 jumpen)
0006145F xor eax,eax
00061461 pop edi
00061462 pop esi
00061463 pop ebx
00061464 mov esp,ebp
00061466 pop ebp
00061467 ret
Dasselbe, aber mit explizitem Return:
Code:
int main()
{
;Wieder Initialisierung
volatile int one = 1;
0089143E mov dword ptr [one],1
volatile int two = 2;
00891445 mov dword ptr [two],2
if (one == two)
0089144C mov eax,dword ptr [two]
0089144F cmp dword ptr [one],eax
00891452 jne main+3Bh (089145Bh)
{
return 10;
00891454 mov eax,0Ah
00891459 jmp main+3Dh (089145Dh)
}
else
{
}
return 0;
0089145B xor eax,eax
}
0089145D pop edi
0089145E pop esi
0089145F pop ebx
00891460 mov esp,ebp
00891462 pop ebp
00891463 ret
Es werden 2 Instruktionen weniger benötigt, sieht sauberer aus und braucht keine Extrawurst.
Nun möchte ich dennoch einen undefinierten Wert erzeugen.
C++:
int main()
{
volatile int one = 1;
volatile int two = 2;
int ret = 100;
if (one == two)
{
return 10;
}
else
{
_asm
{
mov eax, dword ptr[ret]; Leicht zu erkennen
;Hoffentlich haut mir dieser Kaese nicht das System um die Ohren...
pop edi
pop esi
pop ebx
mov esp, ebp
pop ebp
ret
}
}
return 0;
}
Uuuuuuuund:
Code:
Das Programm "[4204] Projekt1.exe" wurde mit Code 100 (0x64) beendet.
Tadaaaa!
Ok, wieder mal einen Nachmittag lang rumgespielt
Ganz kleinlaut muss ich mich dennoch für Falschinformation entschuldigen
Ich denke, man kann daraus 3 Lehren ziehen:
1. Solcher Syntaktischer Zucker gehört verboten. 2 Instruktionen mögen nicht viel sein, und der Fall hier ist konstruiert (der Code Cromons ist identisch mit einem, der ein "return 0" zusätzlich hat), aber es kann vorkommen und ist unnötige Verschwendung. "return 0" tippt man in vielleicht 1.5 Sekunden beim Erstellen des Projektes und gut ist.
2. MSVC++ hat seltsame Definitionen.
3. Wer auch immer C standardisiert, mag ASM nicht.
Kleiner Funfact zum Schluss: Man kann durch die ASM-Eigenschaften auch problemlos einen char als Rückgabewert angeben. Dann wird aber entsprechend nur AL gesetzt. Was sich da wieder für Möglichkeiten auftun...
Gruss
cwriter
