imported>SchlurcherBot: Bot: http → https

2026-01-22T20:02:16Z

Bot: http → https

Neue Seite

Unter '''Aufrufkonvention''' ({{enS|calling convention}}) versteht man die Methode, mit der in [[Computerprogramm]]en 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 [[Modul (Software)|Module]] kompatible Aufrufkonventionen verwenden.

== Aufrufkonventionen der x86-Architektur ==
Die [[X86-Prozessor|x86-Architektur]] besitzt viele verschiedene Aufrufkonventionen.<ref name="history"/> 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 ===
Die so genannte '''cdecl'''-Aufrufkonvention wird von vielen [[C (Programmiersprache)|C-]] und [[C++]]-Compilern verwendet, die auf der [[X86-Prozessor|x86-Architektur]] laufen.<ref name=agnerfog/> Hierbei werden die [[Parameter (Informatik)|Parameter]] nacheinander von rechts nach links auf den [[Stapelspeicher|Stack]] gelegt. Rückgabewerte werden von der aufgerufenen Funktion in der Regel im EAX-[[Register (Computer)|Register]] der [[Hauptprozessor|CPU]] abgelegt. Eine Ausnahme bilden [[Gleitkommazahl]]en, die in ST0 abgelegt werden. Die Register EAX, ECX und EDX stehen für die Verwendung innerhalb der Funktion zur Verfügung.<ref>[http://publib.boulder.ibm.com/infocenter/ratdevz/v7r1m1/index.jsp?topic=/com.ibm.etools.cbl.win.doc/topics/rpsubw29.htm IBM: Developing COBOL and PL/I applications for Windows, CDECL] (Stand: 7. Dezember 2008)</ref> 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:

<syntaxhighlight lang="c">
int function(int, int, int); /* Prototyp der Funktion */
int a, b, c, x; /* Variablendeklaration */

x = function(a, b, c); /* Funktionsaufruf */
</syntaxhighlight>

Der Funktionsaufruf in der letzten Zeile erzeugt den folgenden x86-[[Assemblersprache|Assembler]]-Code (in [[Microsoft Macro Assembler|MASM]]-Syntax):

<syntaxhighlight lang="asm">
; 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
</syntaxhighlight>

Der Aufrufer baut nach der Rückkehr 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 (Datentyp)|Integer]], also 12 [[Byte]]s, 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:

<syntaxhighlight lang="c">
int _cdecl function(int, int, int);
</syntaxhighlight>

=== stdcall ===
Die '''stdcall'''-Aufrufkonvention ist de facto die Standard-Aufrufkonvention für die [[WinAPI|Microsoft Win32-API]].<ref name=msdn/> 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 der Aufrufer. Wegen dieser Tatsache unterstützen stdcall-Funktionen keine variablen Argumentenlisten.

Beispiel (Deklaration einer stdcall-Funktion in C):

<syntaxhighlight lang="c">
int _stdcall function(int, int, int);
</syntaxhighlight>

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 12 Byte von Stack entfernen.

<syntaxhighlight lang="asm">
ret 12
</syntaxhighlight>

=== 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.<ref name=agnerfog/>

=== Register (FastCall) ===
Die '''Register'''- oder '''FastCall'''-Aufrufkonvention ist compilerspezifisch.<ref name=agnerfog/> 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.<ref>[https://docwiki.embarcadero.com/RADStudio/XE3/en/Program_Control Aufrufkonventionen in Delphi]</ref> Die Rückgabewerte werden in den Registern AL, AX, oder EAX zurückgegeben. Bei x64-Systemen werden bis zu vier Argumente mit 64 bit oder weniger in speziellen Registern übergeben, der Rest auf dem Stack.

Diese Konvention wird unter anderem im [[Linux (Kernel)|Linux-Kernel]] benutzt, um Argumente an [[System Call|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 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 [[GNU Compiler Collection|GCC]] ist '''thiscall''' fast identisch mit '''cdecl''', der Aufrufer bereinigt den Stack und die Parameter werden von rechts nach links auf dem Stack abgelegt. Der Unterschied liegt im [[Methodenzeiger|'''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 der Aufrufer 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 ===
{| class="wikitable"
|-
! Architektur !!Aufrufkonvention !!Betriebssystem, Compiler !!Parameter in Registern !!Parameterreihenfolge auf dem Stack !!Stack wird aufgeräumt von... !!Rückgabeparameter, Kommentar
|-
|rowspan="6"| 16 bit || 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 ||[[Turbo C|Borland]] ||ax, dx, bx ||Pascal ||function || „this“ auf der niedrigen Stack-Address. return ptr auf der oberen Stack-Address
|-
| ||[[Watcom C/C++|Watcom]] ||ax, dx, bx, cx ||C ||function ||return pointer in si
|-
|rowspan ="7"|[[IA-32|32bit]] || cdecl || || ||C ||caller ||
|- || stdcall || ||C ||function ||
|-
|- pascal ||Pascal || function ||
|-
| || [[GNU Compiler Collection|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
|-
|rowspan="2"|[[X86-64|64bit]] || Microsoft x64 calling convention<ref name="ms"/> || Windows ([[Microsoft Visual C++|Microsoft-Compiler]], [[Intel C++ 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 und 4 verwendet werden (z. B. entweder rcx oder xmm0, aber nicht beide, deswegen insgesamt nur 4).
|-
|AMD64 ABI convention<ref name="AMD"/> || 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.
|}<ref name=agnerfog />

== Einzelnachweise ==
<references>
<ref name="agnerfog">
{{Internetquelle |autor=Agner Fog |url=https://www.agner.org/optimize/calling_conventions.pdf |titel=Calling conventions for different C++ compilers and operating systems |datum=2010-02-16 |abruf=2010-08-30 |format=PDF; 416 kB |sprache=en}}
</ref>
<ref name="msdn">
{{Internetquelle |url=http://msdn.microsoft.com/en-us/library/zxk0tw93%28v=VS.80%29.aspx |titel=___stdcall |hrsg=msdn.microsoft.com |datum=2010-02-16 |abruf=2010-09-24 |sprache=en}}
</ref>
<ref name="AMD">{{Literatur |Autor=Michael Matz, Jan Hubicka, Andreas Jaeger, and Mark Mitchell |Titel=System V Application Binary Interface AMD64 Architecture Processor Supplement |Verlag=Advanced Micro Devices |Datum=2010-09-03 |Sprache=en |Online=[http://www.x86-64.org/documentation/abi.pdf Online] |Format=PDF |Abruf=2010-09-26 }} {{Webarchiv|url=http://www.x86-64.org/documentation/abi.pdf |wayback=20110716085220 |text=Online |archiv-bot=2023-03-11 02:51:41 InternetArchiveBot }}</ref>
<ref name="history">
{{Internetquelle |autor=Raymond Chen |url=http://blogs.msdn.com/b/oldnewthing/archive/2004/01/02/47184.aspx |titel=The history of calling conventions, part 1 |hrsg=The Old New Thing |datum=2004-01-02 |abruf=2010-09-26 |sprache=en}}
</ref>
<ref name="ms">
{{Internetquelle |url=https://docs.microsoft.com/en-us/cpp/build/x64-calling-convention?view=msvc-170 |titel=x64 calling convention |hrsg=Microsoft |datum=2021-08-03 |abruf=2021-12-06 |sprache=en}}
</ref>
</references>

[[Kategorie:Compilerbau]]
[[Kategorie:Unterprogramm]]

Aufrufkonvention - Versionsgeschichte

imported>SchlurcherBot: Bot: http → https