Version imprimable
Bonjour,
je voudrais savoir comment on récupere le resultat d'un call sur une fonction quand le resultat est un double car je sais que par defaut le retour se place dans EAX et que si c'est trop long (+32 bits) ca va dans EDX aussi mais je fais quoi avec mon EDX et mon EAX lol sachant que je recupere mon resultat dans du C
merci d'avance
Boarf !
A priori, tu balances le résultat dans la pile où le programme appelant ira le chercher.
Non ?
Bein le probleme c'est que je passe un tableau générique avec tous les parametres dans eax et je parcours le tableau pour empiler les arguments de la fonction
mais comme au debut je faisais pas ca avec le type Double j'avais le tableau mis à jour apres l'appel mais maintenant j'ai le probleme d'avoir n'importe quel donnée donc ces ***** de doubles
Sinon merci pour la reponse et pourquoi pas je vais essayer d'isoler les données de type double et les mettres sur la pile, l'instruction c'est bien FSTP et pour le retour dans le C de declarer une variable du type de retour et de faire :
variable ret = maFonctionAsm(...);
Hoa,
Ça dépend de l'implémentation C que tu utilises, il faut en lire la doc pour savoir comment il attend le retour de telles valeurs.
Alternative si tu n'as pas la doc (?) : tu écris en C une fonction qui retourne un double, tu l'appelles, et tu déassembles pour aller voir le code généré.
Pas bete effectivement,
pour le passage des valeurs c'est en cdecl mais à part ca non j'ai rien de plus
j'ai eu le meme probleme pour les entrées de la fonction car c'est le meme tableau generique et en connaissant le rang du double j'arrive à le traiter pour bien l'empiler mais y a pas moyen de trouver des explications plus claires sur le retour d'un call à part que ca va dans EAX lol
Bonjour,
Le retour des flottants est parfois problématique pour l'interaction assembleur et C.
Dans ton cas particulier, si j'ai bien suivi on a :
Où l'assembleur joue un rôle de pont (passage d'argument et récupération des résultats) entre deux parties en C.Citation:
C (1) ---> Asm ---> C (2) => [traitement en C (2)] => C (2) ---> Asm ---> C (1)
Il est possible qu'en fait, dans ton cas concernant les flottants, tu n'ai rien à faire. Le résultat d'opération sur les flottants est souvent laissé sur la pile FPU (registre ST(x)) par le C.
Dans ce cas là, ta fonction assembleur n'a pas à essayer de passer le résultat au C, qui se chargera tout seul d'aller piocher sur le FPU, en ST(0).
Comme le suggérait Droggo, la seule façon de s'en convaincre c'est de débugger directement en assembleur (ou faire une analyse statique) sur ton code et suivre ce qu'il se passe, en se focalisant sur :
1) La manière dont l'appelant [C (1)] veut récupérer le résultat (directement sur le FPU, par pointeur, par valeur ?)
2) Comment l'appelé [C (2)] retourne les résultats (valeur, référence, sur registre ALU ou FPU ?)
A ce moment là tu saura la manière dont doit procéder ta fonction assembleur, ce qui t'obligera peut être à créer un nouveau type de "pont assembleur" pour gérer les fonctions flottantes.
En fait il est difficile de te répondre concrètement sans avoir les détails des implémentations de l'appelant et de l'appelé en assembleur.
Merci à tous,
pour expliciter mieux je charge dans un tableau de pointeur sur type générique en C les arguments d'une fonction, les arguments sont placés dans le tableau selon la signature (si un pointeur sur long en sorti je met un pointeur sur un long initialisé à 0 etc...).
j'appelle le prog assembleur comme ceci:
AppelDLL(tabgen,nbE+nbS,ptrFunct);
Je passe en assembleur le tableau de void** tabgen et l'assembleur appelle le pointeur sur la fonction de la DLL avec tous les parametres (correctemnt empilé) et apres le call le tableau est mis à jour automatiquement.
et je retourne dans le C ou mon tableau est correctement remplis normalement (comme un mise à jour dans un programme en C il est en entrée et en sortie) mais avec les double j'arrive à bien empiler les 64bits pour le call mais je ne sais pas du tout le comportement du retour et de la mise a jour du tableau et j'obtiens donc toujours ma valeur initiale du tableau (pas de màj de la sortie) càd 0.00000
En fait je ne récupere pas la valeur pas défauts mais quelque soit la valeur apres l'appel je recupere 0.00000 alors ca vient soit du retour entre la DLL et l'assembleur soit du retour Assembleur programme principale.
encore plus bizarre si dans la signature de la dll la sortie n'est plus un pointeur sur double mais un double je recupere une la valeur par défaut de la sortie
On peut difficilement t'apporter une solution adéquate à partir du moment où nous n'avons pas tout les clés en main.
A première vue ta fonction en asm est bonne, c'est plutôt ta fonction appelée en C qui semble avoir un comportement "étrange". A partir de là, on ne peut pas dire grand chose de plus...
Généralement, à ce moment là, il faut sortir un débuggeur et tracer les fonctions pour voir où ça bloque exactement.
Tu poses un point d'arrêt (breakpoint) sur le CALL de ta fonction asm et tu vérifie ton cadre de pile (stack frame) avant le CALL pour voir si tes paramètres ont été poussés correctement. en comparant avec ton prototype de fonction.
S'ils le sont, il faut tracer en pas à pas dans la fonction C (step-in) ou passer sur le CALL sans y entrer (step over) et regarder tes registres (voir même la pile), aussi bien sur l'ALU que sur le FPU, afin de savoir où est exactement le retour de fonction.
Sans savoir où ce situe le retour de la fonction en C, tu ne peux que travailler en aveugle et faire des suppositions. A mon avis, l'utilisation d'un débuggeur lèverait immédiatement le doute.
Peut être que quelqu'un aura une meilleur idée que moi...
Okje vais debugger comme il faut enfin essayer d'habitude je debugge via les test ou le pas a pas sans regarder la memoire, la pile etc...
merci de votre aide
Bon j'ai identifié le problème ca vient du C et le seul moyen pour moi de le contourner serait de creer un nouveau pont vers le C avant de repartir dans l'assembleur pour appeler ma DLL :aie:
Merci encore de votre aide.