x86-Aufrufkonvention: Sollen Argumente, die vom Stack übergeben werden, schreibgeschützt sein?

Question

Offenbar behandeln Compiler nach dem Stand der Technik Argumente, die vom Stack als schreibgeschützt übergeben werden. Beachten Sie, dass der Aufrufer in der x86-Aufrufkonvention Argumente auf den Stack überträgt und der Aufgerufene die Argumente im Stack verwendet. Zum Beispiel kann die folgende C-Code:

extern int goo(int *x); 
int foo(int x, int y) { 
    goo(&x); 
    return x; 
} 

wird durch clang -O3 -c g.c -S -m32 in OS X 10.10 in kompilierte:

.section __TEXT,__text,regular,pure_instructions 
    .macosx_version_min 10, 10 
    .globl _foo 
    .align 4, 0x90 
_foo:         ## @foo 
## BB#0: 
    pushl %ebp 
    movl %esp, %ebp 
    subl $8, %esp 
    movl 8(%ebp), %eax 
    movl %eax, -4(%ebp) 
    leal -4(%ebp), %eax 
    movl %eax, (%esp) 
    calll _goo 
    movl -4(%ebp), %eax 
    addl $8, %esp 
    popl %ebp 
    retl 


.subsections_via_symbols 

Hier wird der Parameter x (8(%ebp)) zuerst in %eax geladen; und dann in -4(%ebp) gespeichert; und die Adresse -4(%ebp) wird in %eax gespeichert; und %eax wird an die Funktion goo übergeben.

Ich frage mich, warum Clang-Code generiert, der den Wert in 8(%ebp) zu -4(%ebp) gespeichert kopieren, anstatt nur die Adresse vorbei 8(%ebp) an die Funktion goo. Es würde Speichervorgänge speichern und zu einer besseren Leistung führen. Ich habe auch in GCC ein ähnliches Verhalten beobachtet (unter OS X). Um genauer zu sein, frage ich mich, warum Compiler erzeugt nicht:

.section __TEXT,__text,regular,pure_instructions 
    .macosx_version_min 10, 10 
    .globl _foo 
    .align 4, 0x90 
_foo:         ## @foo 
## BB#0: 
    pushl %ebp 
    movl %esp, %ebp 
    subl $8, %esp 
    leal 8(%ebp), %eax 
    movl %eax, (%esp) 
    calll _goo 
    movl 8(%ebp), %eax 
    addl $8, %esp 
    popl %ebp 
    retl 


.subsections_via_symbols 

ich für Dokumente durchsucht, wenn die x86-Aufrufkonvention verlangt, um die übergebenen Argumente nur gelesen werden, aber ich kann nichts zu diesem Thema finden. Hat jemand darüber nachgedacht?

Answer 1

Eigentlich habe ich kompiliert nur diese Funktion GCC:

int foo(int x) 
{ 
    goo(&x); 
    return x; 
} 

Und es erzeugt diesen Code:

_foo: 
     pushl  %ebp 
     movl  %esp, %ebp 
     subl  $24, %esp 
     leal  8(%ebp), %eax 
     movl  %eax, (%esp) 
     call  _goo 
     movl  8(%ebp), %eax 
     leave 
     ret 

Dies wird mit GCC 4.9.2 (auf 32-Bit-Cygwin, wenn es darauf ankommt), keine Optimierungen. In der Tat hat GCC genau das getan, von dem Sie dachten, dass es das tun sollte, und das Argument direkt von dem Punkt aus verwendet, an dem der Aufrufer es auf den Stapel geschoben hat.

Answer 2

Die C programming language schreibt vor, dass Argumente übergeben werden by value. Jede Änderung eines Arguments (wie zB eine x++; als erste Anweisung von foo) ist lokal für die Funktion und wird nicht an den Aufrufer weitergegeben.

^{Daher sollte eine allgemeine Aufrufkonvention das Kopieren von von Argumenten an jeder Aufrufstelle erfordern. Aufrufkonventionen sollten allgemein genug sein für unbekannte Anrufe, z.B. durch einen Funktionszeiger!}

Natürlich, wenn Sie eine Adresse an eine Speicherzone übergeben, ist die aufgerufene Funktion frei diesen Zeiger zu dereferenzieren, z. BTW wie in

int goo(int *x) { 
    static int count; 
    *x = count++; 
    return count % 3; 
} 

, können Sie Link-Zeitoptimierungen nutzen (durch Kompilieren und Linken mit clang -flto -O2 oder gcc -flto -O2), um vielleicht den Compiler zu ermöglichen zu verbessern oder einige Anrufe zwischen Übersetzungseinheiten inline.

Beachten Sie, dass sowohl Clang/LLVM als auch free software Compiler sind. Fühlen Sie sich frei, ihnen einen Verbesserungs-Patch anzubieten, wenn Sie das möchten (aber da beide sehr komplexe Teile von Software sind, müssen Sie einige Monate arbeiten, um diesen Patch zu erstellen).

NB. Wenn Sie in den produzierten Assemblercode schauen, übergeben Sie 10 an Ihren Compiler!

Answer 3

Die Regeln für C sind, dass Parameter als Wert übergeben werden müssen. Ein Compiler konvertiert von einer Sprache (mit einem Regelwerk) in eine andere Sprache (möglicherweise mit einem völlig anderen Regelwerk). Die einzige Einschränkung ist, dass das Verhalten gleich bleibt.Die Regeln der Sprache C gelten nicht für die Zielsprache (z. B. Assembly).

Das bedeutet, wenn ein Compiler Lust hat, eine Assemblersprache zu erzeugen, in der Parameter als Referenz übergeben werden und nicht als Wert übergeben werden; dann ist das vollkommen legal (solange das Verhalten gleich bleibt).

Die wirkliche Einschränkung hat überhaupt nichts mit C zu tun. Die wirkliche Einschränkung ist das Verknüpfen. Damit verschiedene Objektdateien miteinander verknüpft werden können, sind Standards erforderlich, um sicherzustellen, dass der Aufrufer in einer Objektdatei Übereinstimmungen erwartet, die der Aufrufer in einer anderen Objektdatei bereitstellt. Dies ist, was als ABI bekannt ist. In einigen Fällen (z. B. 64-Bit 80 × 86) gibt es mehrere verschiedene ABIs für die exakt gleiche Architektur.

Sie können sogar Ihre eigene ABI erfinden, die radikal anders ist (und Ihre eigenen Tools implementieren, die Ihre eigenen radikal unterschiedlichen ABI unterstützen) und das ist vollkommen legal, soweit die C-Standards es erlauben; selbst wenn Ihr ABI für alles "durch Referenz" verlangt (solange das Verhalten gleich bleibt).