La valeur de retour toujours aller dans le registre eax après un appel de méthode?

J'ai écrit un accrochage de la bibliothèque, qui examine un exécutables PE dll table d'importation, afin de créer une bibliothèque qui permet de changer des paramètres et valeurs de retour. J'ai quelques questions sur la façon dont la valeur de retour est transmise à partir d'une fonction.

J'ai appris que la valeur de retour d'une fonction est enregistré dans le registre accumulateur. Est-ce toujours le cas? Si non, comment le compilateur de savoir où chercher pour le résultat de la fonction?

Ce que le type de retour de la taille? Un nombre entier s'adapter facilement, mais qu'une structure plus grande? L'appelant réserve de la pile de l'espace, donc la méthode qu'il appelle pouvait écrire le résultat sur la pile?

Pourquoi ne pas dresser un couple d'exemples et de voir par vous-même?
Non, le processeur ARM7 ne dispose pas d'un registre EAX. Ni faire d'autres processeurs.
Évidemment, si le type de retour ne rentre pas dans eax, il ne peut pas être en elle. Reportez-vous à la documentation de ce convention d'appel vous êtes en utilisant.
Bottom line: il dépend entièrement le compilateur et les conventions qu'il utilise. (Je construire un compilateur qui passe double float args EAX/EDX [parfois]).
pas si vos méthodes de retour void et de transmettre des valeurs à travers des références ou des pointeurs.

OriginalL'auteur Bartlomiej Lewandowski | 2014-01-17

assembly c++compiler-construction x86

6

C'est tous spécifiques à la convention d'appel.

Pour la plupart des conventions d'appel des nombres à virgule flottante sont retournés sur la FPU-pile ou dans des registres XMM.

Appel à la fonction renvoi d'une structure
```
    some_struct foo(int arg1, int arg2);
    some_struct s = foo(1, 2);
```
seront compilées dans certains équivalent de:
```
    some_struct* foo(some_struct* ret_val, int arg1, int arg2);
    some_struct s; //constructor isn't called
    foo(&s, 1, 2); //constructor will be called in foo
```
Modifier: (ajouter des infos)

juste pour clarifier: ce qui fonctionne pour toutes les structures et les classes, même lorsque sizeof(some_struct) <= 4. Donc, si vous définissez les petits utile de classe comme ip4_type avec la seule unsigned champ et certains constructeurs/convertisseurs/trom unsigned, in_addr, char* il manque d'efficacité par rapport à l'utilisation de matières premières unigned valeur.

simple et efficace:)
ce qui répond à la plupart de mes questions, merci
plus: 64-bit valeurs autant que je sache, sont retournés dans edx:eax sur x86
oui, vous avez raison, si c'est vrai pour les valeurs entières seulement.
Eh bien, pour l'entier des valeurs autres que COMP 🙂

OriginalL'auteur qwm

Si la fonction obtenir inline, le résultat n'est pas enregistré dans eax, même si les résultats sont passés par référence/pointeur, ce registre ne sera pas utilisé.

regardez ce qui se passe à une fonction qui retourne doubles (sur un ordinateur 32 bits)

double func(){
    volatile double val=5.0;
    return val;
}

int main(){
    double val = func();
    return 0;
}

doubles ne sont pas dans eax.

func():
    pushq   %rbp
    movq    %rsp, %rbp
    movabsq $4617315517961601024, %rax
    movq    %rax, -8(%rbp)
    movq    -8(%rbp), %rax
    movq    %rax, -24(%rbp)
    movsd   -24(%rbp), %xmm0
    popq    %rbp
    ret
main:
    pushq   %rbp
    movq    %rsp, %rbp
    subq    $24, %rsp
    call    func()
    movsd   %xmm0, -24(%rbp)
    movq    -24(%rbp), %rax
    movq    %rax, -8(%rbp)
    movl    $0, %eax
    leave
    ret

votre code est de 64 bits au lieu de 32. Il n'y a pas de rax, rbp, pnr... sur 32 bits x86

OriginalL'auteur GameDeveloper

1

Cela dépend vraiment de la convention d'appel utilisé, mais en général, EAX est utilisé pour 32-bit et les petits intégrale des types de données, les valeurs à virgule flottante ont tendance à utiliser la FPU ou les registres MMX, et 64 bits intégrale types ont tendance à utiliser une combinaison de EAX et EDX à la place. Ensuite, il ya la question de complexe class/struct types, auquel cas le compilateur peut décider d'optimiser loin la valeur de retour et utiliser un paramètre de sortie sur la pile d'appel pour passer l'objet retourné par la référence à l'appelant.

OriginalL'auteur Remy Lebeau
1

Vous poser des questions sur l'ABI (Application Binary Interface). Cela varie en fonction du système d'exploitation. Vous devriez regarder. Vous pouvez trouver quelques bonnes infos et des liens vers d'autres documents à http://en.wikipedia.org/wiki/X86_calling_conventions

Pour répondre à votre question, oui, autant que je sache, tous les systèmes d'exploitation courants d'utiliser le registre de retourner le résultat.

Le MS Windows32 coventions ne pas passer des arguments dans EAX: Standard CDECL appelle push arguments dans la pile; fastcall premier argument est dans ECX. Oh, tu veux dire populaire systèmes d'exploitation, contrairement à Windows :- }
Juste pour le plaisir de l'exhaustivité: Borland compilateurs sur Windows utiliser eax comme premier argument avec __fastcall 😉
Oh, vous avez raison. Comment embarrassant.

OriginalL'auteur Zan Lynx

Vous devez vous connecter pour publier un commentaire.