Aufrufkonvention

aus Wikipedia, der freien Enzyklopädie
Wechseln zu: Navigation, Suche

Unter Aufrufkonvention versteht man die Methode, mit der in Computerprogrammen einem Unterprogramm 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[Bearbeiten]

Die x86-Architektur besitzt viele verschiedene Aufrufkonventionen.[1] Wegen der begrenzten Zahl an Registern 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 Argumente, was der Performance für einfache, häufig aufgerufene Funktionen zugutekommt (z. B. Funktionen, welche keine anderen aufrufen und in die dadurch nicht zurückgekehrt wird).

cdecl[Bearbeiten]

Die so genannte 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] Wenn darüber hinaus andere Register verwendet werden sollen, muss der Inhalt dieser Register von der Funktion gesichert (meist durch Ablegen auf den Stack) und vor dem Rücksprung wiederhergestellt werden.

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:

int _cdecl function(int,int,int);

stdcall[Bearbeiten]

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):

int _stdcall function(int,int,int);

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[Bearbeiten]

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)[Bearbeiten]

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. Der Borland- und Delphi-Compiler hingegen legen die übrigen Argumente wie bei der Pascal-Aufrufkonvention von links nach rechts auf dem Stack ab.[5] 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[Bearbeiten]

Diese Aufrufkonvention wird für den Aufruf nicht-statischer C++-Member-Funktionen benutzt. Es gibt 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 Argument 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 Elementfunktionen aus nativem Code heraus, wenn Klassen standardmäßig die clrcall-Aufrufkonvention verwenden (managed code).

Übersichtstabelle Aufrufkonventionen[2][Bearbeiten]

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-Address. return pointer in ax
fastcall Borland ax, dx, bx Pascal function "this" auf der niedrigen Stack-Address. return ptr auf der oberen Stack-Address
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[Bearbeiten]

  1. Raymond Chen: The history of calling conventions, part 1. The Old New Thing. 2. Januar 2004. Abgerufen am 26. September 2010.
  2. a b c d Agner Fog: Calling conventions for different C++ compilers and operating systems (PDF; 416 kB) 16. Februar 2010. 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. Aufrufkonventionen in Delphi
  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).