L'appel de printf en x86_64 utilisant l'assembleur GNU

J'ai écrit un programme en utilisant AT&T syntaxe pour une utilisation avec de l'assembleur GNU:

            .data
format:   .ascii "%d\n"  

            .text
            .global main  
main:
            mov    $format, %rbx
            mov    (%rbx), %rdi
            mov    $1, %rsi
            call     printf
            ret

- Je utiliser GCC de les assembler et de les lien avec:

gcc-o main.s

Je le lance avec cette commande:

./principal

Quand je lance le programme, j'obtiens un seg fault. Par l'utilisation de gdb, il dit printf pas trouvé. J'ai essayé ".extern printf", qui ne fonctionne pas. Quelqu'un m'a suggéré de stocker le pointeur de pile avant l'appel de printf et restaurer avant de RET, Comment dois-je faire?

Vous devriez vraiment lire sur le SysV x86-64 ABI. D'un coup d'oeil, vous avez un mauvais alignement de la pile avant l'appel, vous n'avez pas de zéro %rax, vous n'utilisez pas le droit de registres pour les bons arguments et je soupçonne que vous êtes un déréférencement format lorsque vous ne devriez pas.

InformationsquelleAutor L's World | 2016-07-12

19

Il y a un certain nombre de questions avec ce code. Le Système AMD64 V ABI convention d'appel utilisé par Linux a besoin de quelques choses. Il exige que juste avant un APPEL que la pile soit au moins de 16 octets (ou 32 octets) alignés:

La fin de l'argument d'entrée de la zone doit être alignée sur une 16 (32, si __m256 est
passés sur la pile) limite d'octets.

Après la C d'exécution des appels de votre main fonction de la pile n'est pas correctement alignée par 8 car le retour pointeur est placé sur la pile par APPEL. Le réalignement de 16 octets à la limite vous pouvez simplement POUSSER tout registre sur la pile et POP à la fin.

L'appel de la convention exige également que AL contenir le nombre de vecteurs registres utilisés pour une variable en fonction d'argument:

%al est utilisé pour indiquer le nombre de vecteurs arguments passés à une fonction nécessitant un nombre variable d'arguments

printf est une variable en fonction d'argument, donc AL doit être défini. Dans ce cas, vous ne passez pas tous les paramètres en un vecteur de registre de sorte que vous pouvez définir AL à 0.

Vous aussi déréférencer le format de $pointeur lorsqu'il est déjà une adresse. Donc, c'est faux:
```
mov  $format, %rbx
mov  (%rbx), %rdi 
```
Cela prend l'adresse de format et le place dans RBX. Ensuite, vous prenez les 8 octets à l'adresse RBX et de les placer dans RDI. RDI doit être un pointeur à une chaîne de caractères, pas les personnages eux-mêmes. Les deux lignes pourrait être remplacé par:
```
lea  format(%rip), %rdi
```
Il utilise RIP Adressage Relatif.

Vous devez également NUL mettre fin à vos chaînes. Plutôt que d'utiliser .ascii vous pouvez utiliser .asciz sur la plate-forme x86.

Une version de travail de votre programme pourrait ressembler à:
```
# global data  #
    .data
format: .asciz "%d\n"
.text
    .global main
main:
  push %rbx
  lea  format(%rip), %rdi
  mov  $1, %esi           # Writing to ESI zero extends to RSI.
  xor %eax, %eax          # Zeroing EAX is efficient way to clear AL.
  call printf
  pop %rbx
  ret
```
Autres Recommandations/Suggestions

Vous devriez aussi être conscient de la 64 bits de Linux ABI, que la convention d'appel exige également des fonctions que vous écrivez à l'honneur la préservation de certains registres. La liste des registres et s'ils devraient préservé est comme suit:

Un registre qui dit Yes dans le Conservé dans le
Registre colonne sont celles que vous devez vous assurer sont conservées dans votre fonction. Fonction main est comme tous les autres C fonction.

Si vous avez des cordes, des données que vous savez sera en lecture seule, vous pouvez les placer dans .rodata section avec .section .rodata plutôt que .data

En mode 64 bits: si vous avez un opérande de destination qui est une version 32 bits de registre, le PROCESSEUR zéro étendre le registre à travers l'ensemble de la 64 bits de registre. Cela peut économiser des octets sur le codage d'instruction.

Il est possible que votre exécutable est compilé en code indépendant de la position. Vous pouvez recevoir un message d'erreur similaire à:

réinstallation R_X86_64_PC32 contre le symbole `printf@@GLIBC_2.2.5 " ne peut pas être utilisée lors de la prise d'un objet partagé; recompiler avec -fPIC

Pour y remédier, vous devrez appeler la fonction externe printf de cette façon:
```
call printf@plt 
```
Ce appels externes de la fonction de la bibliothèque via le Procedure Linkage Table (PLT)
- J'ai réorganisé mon code et il fonctionne. Je pensais que c'était un problème d'importation de printf, qui n'est pas nécessaire. Merci beaucoup.
- Dans cet exemple de code car il n'existe qu'un seul appel et il apparaît à la fin on peut JMP pour printf plutôt que APPEL et d'éliminer la pile de l'alignement avec le PUSH/POP. Qui était en dehors de la portée de ma réponse, mais on peut toujours regarder la littérature sur QUEUE APPEL optimisations
- D'excellentes recommandations. Les futurs voyageurs, voir aussi: nickdesaulniers.github.io/blog/2014/04/18/...
- Le changelog message de mon édition contient les points importants. . L'ABI doc lien est rompu. Les autres changements sont en option, parce xor %eax,%eax est la meilleure façon de mettre en AL ou RAX à zéro (il n'est donc pas nocif pour dire que variadic fonctions de regarder %rax au lieu de %al), et les autres étaient juste des détails supplémentaires / commentaires que j'ai fait depuis une modification était nécessaire de toute façon pour corriger l'ABI lien.
InformationsquelleAutor Michael Petch
2

Vous pouvez regarder code assembleur généré à partir d'un équivalent c fichier.

L'exécution de gcc -o - -S -fno-asynchronous-unwind-tables test.c avec ce test.c
```
#include <stdio.h>
int main() {
   return printf("%d\n", 1);
}
```
Cette sortie de l'assemblée de code:
```
        .file   "test.c"
        .section        .rodata
.LC0:
        .string "%d\n"
        .text
        .globl  main
        .type   main, @function
main:
        pushq   %rbp
        movq    %rsp, %rbp
        movl    $1, %esi
        movl    $.LC0, %edi
        movl    $0, %eax
        call    printf
        popq    %rbp
        ret
        .size   main, .-main
        .ident  "GCC: (GNU) 6.1.1 20160602"
        .section        .note.GNU-stack,"",@progbits
```
Cela vous donne un exemple d'un assemblage de code d'appel de printf, que vous pourrez ensuite modifier.

La comparaison avec votre code, vous devez modifier 2 choses:
- %de l'aqr doit pointer vers le format, vous ne devriez pas non référencées %rbx, ce qui pourrait être fait avec mov $format, %rdi
- printf a un nombre variable d'arguments, alors vous devriez ajouter mov $0, %eax
L'application de ces modifications va donner quelque chose comme :
```
    .data
format: .ascii "%d\n"  
.text
    .global main  
main:
  mov  $format, %rdi
  mov  $1, %rsi
  mov  $0, %eax
  call printf
  ret
```
Puis de l'exécuter d'impression :

1
- Votre code modifié n'est pas de 16 octets aligner la pile avant l'appel àprintf. Il peut travailler dans de nombreux scénarios, mais pas tous. Poussant un 64-bit registre après votre fonction main commence et de les restaurer à la fin permettrait de garder les choses alignés. La version 64 bits de Linux ABI nécessite un minimum de 16 octets d'alignement (32 octets aligné si le passage de 256 vecteurs de bits à une fonction). Au point juste avant l'appel de la fonction de la pile besoins 16(ou 32) alignement d'octets. Après le APPEL instruction transfère le contrôle à une fonction (main est comme les autres C function)l'adresse de retour est placé sur la pile à désaligner par 8.
- J'ai essayé de donner un code qui fonctionne avec un minimum de modifications, sinon, la gcc a généré de l'assemblée, c'est mieux.
- Malheureusement, les 16 octets de l'alignement est la chance de code de travail dans ce cas. Je suppose que sur un niveau d'optimisation comme O2 ou plus, il serait réellement supprimer le PUSH/POP/RET et puis faire un appel tail JMP pour printf. Dans ce cas, l'alignement est maintenue (sans le PUSH/POP) depuis JMP ne place pas une adresse de retour sur la pile comme un APPEL.
- Michael est correct: gcc émet un code optimal si vous demandez à optimiser (en utilisant -O3): godbolt.org/g/sX5yCe. Il utilise un jmp pour la queue-appel de sorte que la pile de l'alignement reste la même que lors de l'entrée sur main. Il utilise également xor à zéro %al, au lieu d'un moins efficace mov. Et bien sûr, il met la constante de chaîne dans .rodata, pas .data. À l'aide de sortie du compilateur comme un point de départ pour l'optimisation est un bon plan, mais uniquement si vous démarrez avec -O2 ou -O3 de sortie! Sinon, vous pourriez faire pire que le compilateur.
InformationsquelleAutor mpromonet

Vous devez vous connecter pour publier un commentaire.

Autres Recommandations/Suggestions