Aufrufkonvention

Unter Aufrufkonvention (engl. calling convention) versteht man die Methode, mit der in Computerprogrammen einer Funktion Daten übergeben werden. In der Regel liegt es am Compiler, welche Konvention zum Einsatz kommt, so dass der Programmierer sich nicht damit beschäftigen muss. Bei der Entwicklung von Software in mehreren Sprachen ist es jedoch erforderlich, dass alle Module kompatible Aufrufkonventionen verwenden.

Aufrufkonventionen der x86-Architektur

Die x86-Architektur besitzt viele verschiedene Aufrufkonventionen^[1]. Wegen der begrenzten Zahl Register werden bei vielen x86-Aufrufkonventionen die Argumente überwiegend über den Stack übertragen, während der Rückgabewert (oder ein Zeiger auf ihn) über ein Register zurückgegeben wird. Einige Konventionen nutzen Register für die ersten paar Argumente, was der Performance für einfache, häufig aufgerufene Funktionen zugute kommt (z.B. Funktionen welche keine anderen aufrufen und in die dadurch nicht zurückgekehrt wird).

cdecl

Die cdecl-Aufrufkonvention wird von vielen C- und C++-Compilern verwendet, die auf der x86-Architektur laufen^[2]. Hierbei werden die Parameter nacheinander von rechts nach links auf den Stack gelegt. Rückgabewerte werden von der aufgerufenen Funktion in der Regel im EAX-Register der CPU abgelegt. Eine Ausnahme bilden Gleitkommazahlen, die in ST0 abgelegt werden. Die Register EAX, ECX und EDX stehen für die Verwendung innerhalb der Funktion zur Verfügung.^[3]

Beispiel in C-Code:

int function(int, int, int); /* Prototyp der Funktion */
int a, b, c, x; /* Variablendeklaration */
 
x = function(a, b, c);    /* Funktionsaufruf */

Der Funktionsaufruf in der letzten Zeile erzeugt den folgenden x86-Assembler-Code (in MASM-Syntax):

 ; Argumente in umgekehrter Reihenfolge auf den Stack legen
 push c
 push b
 push a
 
 ; Funktion aufrufen
 call function
 
 ; Stack-Pointer zurücksetzen
 add esp, 12
 
 ; Rückgabewert der Funktion sichern
 mov x, eax

Die aufrufende Funktion baut nach dem Aufruf den Stack selbst wieder ab, indem der Stack-Pointer (gespeichert im ESP-Register) so gesetzt wird, dass er wieder auf die Position im Speicher zeigt, auf die er vor den Push-Operationen zeigte. Im Beispiel oben werden drei Integer, also 12 Bytes, auf den Stack gelegt. Da der Stack in x86-Systemen von oben nach unten wächst, wird dabei ESP um 12 dekrementiert. Um wieder auf die Position von vorher zu kommen, muss im Anschluss an den Aufruf wieder 12 auf den Wert im ESP-Register addiert werden. So können auch Funktionen mit variabler Argumenten-Anzahl und Länge realisiert werden.

Die cdecl-Aufrufkonvention ist gewöhnlich die Standard-Aufrufkonvention eines x86-C-Compilers. Allerdings verfügen viele Compiler über die Option, eine andere Konvention zu verwenden.

Eine Funktion kann manuell mit folgender Syntax als cdecl-Funktion deklariert werden:

void _cdecl function(params);

stdcall

Die stdcall-Aufrufkonvention ist de facto die Standard-Aufrufkonvention für die Microsoft Win32-API^[4]. Funktionsparameter werden von rechts nach links übergeben. Die Register EAX, ECX, und EDX sind reserviert für die Verwendung innerhalb der Funktion, werden also unter Umständen verändert. Rückgabewerte werden im EAX-Register zurückgegeben. Anders als bei cdecl bereinigt die aufgerufene Funktion den Stack, nicht die aufrufende Funktion. Wegen dieser Tatsache unterstützen stdcall-Funktionen keine variablen Argumentenlisten.

Beispiel (Deklaration einer stdcall-Funktion in C):

void _stdcall function(params);

Funktionen, die die stdcall-Methode benutzen, sind in Assembler-Code leicht zu erkennen, da sie vor dem Rücksprung zum aufrufenden Code den Stack immer selbst abbauen. Der x86-Befehl ret erlaubt einen optionalen Parameter, der die Größe des abzubauenden Stacks angibt.

Beispiel: Beim Rücksprung 14 Byte von Stack entfernen.

ret 14

Pascal

Bei der Pascal-Aufrufkonvention werden die Parameter, im Gegensatz zur cdecl-Konvention, in der Reihenfolge von links nach rechts auf dem Stack abgelegt, und die aufgerufene Funktion muss den Stack-Pointer vor dem Rücksprung zum aufrufenden Code selbst zurücksetzen^[2].

Register (FastCall)

Die Register- oder FastCall-Aufrufkonvention ist compilerspezifisch^[2]. Im Allgemeinen besagt sie, dass die ersten zwei oder drei Funktions-Argumente mit einer Größe von 32 Bit oder weniger in den Registern EAX, EDX, und möglicherweise auch ECX übergeben werden anstatt über den Stack. Die übrigen Argumente werden von rechts nach links auf dem Stack abgelegt, ähnlich wie bei cdecl. Die Rückgabewerte werden in den Registern AL, AX, oder EAX zurückgegeben. Bei x64-Systemen werden bis zu vier Argumente mit 64bit oder weniger in speziellen Registern übergeben, der Rest auf dem Stack.

Diese Konvention wird unter anderem im Linux-Kernel benutzt, um Argumente an System-Calls zu übergeben. Die System-Call-Nummer, die jeden möglichen Aufruf eindeutig bestimmt, wird im EAX-Register abgelegt, während alle Argumente an die Kernel-Funktion in den Registern EBX, ECX, EDX, ESI und EDI gespeichert werden. Müssen mehr Argumente übergeben werden, wird einfach eine Datenstruktur mit den benötigten Elementen im Speicher abgelegt und ein Zeiger auf diese als Argument an die Funktion weitergereicht.

thiscall

Diese Aufrufkonvention wird für den Aufruf nicht-statischer C++ Member-Funktionen benutzt. Es existieren zwei Hauptversionen von thiscall, die abhängig vom Compiler und abhängig davon benutzt werden, ob die Funktion variable Argumentlisten unterstützt oder nicht.

Beim GCC ist thiscall fast identisch mit cdecl, die aufrufende Funktion bereinigt den Stack und die Parameter werden von rechts nach links auf dem Stack abgelegt. Der Unterschied liegt im this-Zeiger, der als letztes auf dem Stack abgelegt wird, so, als wäre er der erste zu übergebende Parameter der Funktion.

Beim Microsoft Visual C++ Compiler wird der this-Zeiger im ECX-Register übergeben und die aufgerufene Funktion bereinigt den Stack, es wird also wie bei der stdcall Aufrufkonvention verfahren. Werden hingegen variable Argumentlisten verwendet bereinigt die aufrufende Funktion den Stack (also wie bei cdecl).

Die thiscall Aufrufkonvention kann explizit nur bei Microsoft Visual C++ 2005 und späteren Versionen verwendet werden und ermöglicht den Aufruf von Member-Funktionen aus nativem Code heraus, wenn Klassen standardmäßig die clrcall Aufrufkonvention verwenden (managed code).

Übersichtstabelle Aufrufkonventionen x86^[2]

Architektur	Aufrufskonvention	Betriebssystem, Compiler	Parameter in Registern	Parameterreihenfolge auf dem Stack	Stack wird aufgeräumt von...	Rückgabeparameter, Kommentar
16bit	cdecl			C	caller
	pascal			Pascal	function
	fastcall	Microsoft (non-member)	ax, dx, bx	Pascal	function	return pointer in bx
	fastcall	Microsoft (member function)	ax, dx	Pascal	function	"this" auf der niedrigen stack adresse. return pointer in ax
	fastcall	Borland[5]	ax, dx, bx	Pascal	function	"this" auf der niedrigen stack adresse. return ptr auf der oberen Stack addr.
		Watcom	ax, dx, bx, cx	C	function	return pointer in si
32bit	cdecl			C	caller
		Gnu-Compiler		C	hybrid	Stack möglicherweise auf 16 aligned.
	fastcall	Microsoft	ecx, edx	C	function	return pointer auf dem Stack falls nicht member function
	fastcall	Gnu	ecx, edx	C	function
	fastcall	Borland	eax, edx, ecx	Pascal	function
	thiscall	Microsoft	ecx	C	function	default für member functions
		Watcom	eax, edx, ebx, ecx	C	function	return pointer in esi
64bit	Microsoft x64 calling convention[6]	Windows (Microsoft-Compiler, Intel-Compiler)	rcx/xmm0, rdx/xmm1, r8/xmm2, r9/xmm3	C	caller	Stack aligned auf 16. 32 bytes shadow space auf dem stack. Die spezifizierten 8 Register können nur für Parameter 1, 2, 3 and 4 verwendet werden (z.B. entweder rcx oder xmm0, aber nicht beide, deswegen insgesamt nur 4).
	AMD64 ABI convention[7]	Linux, BSD, Mac (Gnu-Compiler, Intel-Compiler)	rdi, rsi, rdx, rcx, r8, r9, xmm0-7	C	caller	Stack aligned auf 16. Red zone unter dem Stack.

Einzelnachweise

1. ↑ Raymond Chen (2. Januar 2004): The history of calling conventions, part 1. The Old New Thing. Abgerufen am 26. September 2010.
2. ↑ ^{a b c d} Agner Fog (16. Februar 2010): Calling conventions for different C++ compilers and operating systems. Abgerufen am 30. August 2010.
3. ↑ IBM: Developing COBOL and PL/I applications for Windows, CDECL (Stand: 7. Dezember 2008)
4. ↑ ___stdcall. msdn.microsoft.com (16. Februar 2010). Abgerufen am 24. September 2010.
5. ↑ Borland C/C++ version 3.1 User Guide (PDF), S. 158,189–191, Borland 1992
6. ↑ x64 Software Conventions: Calling Conventions. msdn.microsoft.com (2010). Abgerufen am 27. September 2010.
7. ↑ Michael Matz, Jan Hubicka, Andreas Jaeger, and Mark Mitchell: System V Application Binary Interface AMD64 Architecture Processor Supplement (PDF), Advanced Micro Devices 3. September 2010 (Zugriff am 26. September 2010)