Bonjour,
Je cherche comment sont enregistrer les adresses de retour des
fonctions. Exemple : on a une fonction qui en appelle une autre, pour
retourner a la premiere, en ASM, cela se traduit par un RET.
Seulement, j'aimerais savoir ou est stocke l'adresse qu'il va
appeller lors du RET. Je suppose qu'elle est sur la pile, mais comment il
(il : le
processeur ou le compilo ??) gere ces adresses : y'a t-il une methode
lors du stockage pour qu'on puisse les retrouver lors d'un debug ou
d'un dump de la pile ??
J'espere avoir ete clair.
Merci d'avance
Bonjour,
Je cherche comment sont enregistrer les adresses de retour des
fonctions. Exemple : on a une fonction qui en appelle une autre, pour
retourner a la premiere, en ASM, cela se traduit par un RET.
Seulement, j'aimerais savoir ou est stocke l'adresse qu'il va
appeller lors du RET. Je suppose qu'elle est sur la pile, mais comment il
(il : le
processeur ou le compilo ??) gere ces adresses : y'a t-il une methode
lors du stockage pour qu'on puisse les retrouver lors d'un debug ou
d'un dump de la pile ??
J'espere avoir ete clair.
Merci d'avance
Bonjour,
Je cherche comment sont enregistrer les adresses de retour des
fonctions. Exemple : on a une fonction qui en appelle une autre, pour
retourner a la premiere, en ASM, cela se traduit par un RET.
Seulement, j'aimerais savoir ou est stocke l'adresse qu'il va
appeller lors du RET. Je suppose qu'elle est sur la pile, mais comment il
(il : le
processeur ou le compilo ??) gere ces adresses : y'a t-il une methode
lors du stockage pour qu'on puisse les retrouver lors d'un debug ou
d'un dump de la pile ??
J'espere avoir ete clair.
Merci d'avance
Bonjour,
Je cherche comment sont enregistrer les adresses de retour des fonctions.
Exemple : on a une fonction qui en appelle une autre, pour retourner a
la premiere, en ASM, cela se traduit par un RET. Seulement, j'aimerais
savoir ou est stocke l'adresse qu'il va appeller lors du RET.
Je suppose qu'elle est sur la pile, mais comment il (il : le processeur
ou le compilo ??) gere ces adresses : y'a t-il une methode lors du
stockage pour qu'on puisse les retrouver lors d'un debug ou d'un dump de
la pile ??
Bonjour,
Je cherche comment sont enregistrer les adresses de retour des fonctions.
Exemple : on a une fonction qui en appelle une autre, pour retourner a
la premiere, en ASM, cela se traduit par un RET. Seulement, j'aimerais
savoir ou est stocke l'adresse qu'il va appeller lors du RET.
Je suppose qu'elle est sur la pile, mais comment il (il : le processeur
ou le compilo ??) gere ces adresses : y'a t-il une methode lors du
stockage pour qu'on puisse les retrouver lors d'un debug ou d'un dump de
la pile ??
Bonjour,
Je cherche comment sont enregistrer les adresses de retour des fonctions.
Exemple : on a une fonction qui en appelle une autre, pour retourner a
la premiere, en ASM, cela se traduit par un RET. Seulement, j'aimerais
savoir ou est stocke l'adresse qu'il va appeller lors du RET.
Je suppose qu'elle est sur la pile, mais comment il (il : le processeur
ou le compilo ??) gere ces adresses : y'a t-il une methode lors du
stockage pour qu'on puisse les retrouver lors d'un debug ou d'un dump de
la pile ??
Bonjour,
Je cherche comment sont enregistrer les adresses de retour des
Exemple : on a une fonction qui en appelle une autre, pour retourner
la premiere, en ASM, cela se traduit par un RET. Seulement,
savoir ou est stocke l'adresse qu'il va appeller lors du RET.
Je suppose qu'elle est sur la pile, mais comment il (il : le
ou le compilo ??) gere ces adresses : y'a t-il une methode lors du
stockage pour qu'on puisse les retrouver lors d'un debug ou d'un dump
la pile ??
Bonjour,
Je cherche comment sont enregistrer les adresses de retour des
Exemple : on a une fonction qui en appelle une autre, pour retourner
la premiere, en ASM, cela se traduit par un RET. Seulement,
savoir ou est stocke l'adresse qu'il va appeller lors du RET.
Je suppose qu'elle est sur la pile, mais comment il (il : le
ou le compilo ??) gere ces adresses : y'a t-il une methode lors du
stockage pour qu'on puisse les retrouver lors d'un debug ou d'un dump
la pile ??
Bonjour,
Je cherche comment sont enregistrer les adresses de retour des
Exemple : on a une fonction qui en appelle une autre, pour retourner
la premiere, en ASM, cela se traduit par un RET. Seulement,
savoir ou est stocke l'adresse qu'il va appeller lors du RET.
Je suppose qu'elle est sur la pile, mais comment il (il : le
ou le compilo ??) gere ces adresses : y'a t-il une methode lors du
stockage pour qu'on puisse les retrouver lors d'un debug ou d'un dump
la pile ??
Bonjour,
Je cherche comment sont enregistrer les adresses de retour des fonctions.
Exemple : on a une fonction qui en appelle une autre, pour retourner a
la premiere, en ASM, cela se traduit par un RET. Seulement, j'aimerais
savoir ou est stocke l'adresse qu'il va appeller lors du RET.
Je suppose qu'elle est sur la pile, mais comment il (il : le processeur
ou le compilo ??) gere ces adresses : y'a t-il une methode lors du
stockage pour qu'on puisse les retrouver lors d'un debug ou d'un dump de
la pile ??
Bonjour,
Je cherche comment sont enregistrer les adresses de retour des fonctions.
Exemple : on a une fonction qui en appelle une autre, pour retourner a
la premiere, en ASM, cela se traduit par un RET. Seulement, j'aimerais
savoir ou est stocke l'adresse qu'il va appeller lors du RET.
Je suppose qu'elle est sur la pile, mais comment il (il : le processeur
ou le compilo ??) gere ces adresses : y'a t-il une methode lors du
stockage pour qu'on puisse les retrouver lors d'un debug ou d'un dump de
la pile ??
Bonjour,
Je cherche comment sont enregistrer les adresses de retour des fonctions.
Exemple : on a une fonction qui en appelle une autre, pour retourner a
la premiere, en ASM, cela se traduit par un RET. Seulement, j'aimerais
savoir ou est stocke l'adresse qu'il va appeller lors du RET.
Je suppose qu'elle est sur la pile, mais comment il (il : le processeur
ou le compilo ??) gere ces adresses : y'a t-il une methode lors du
stockage pour qu'on puisse les retrouver lors d'un debug ou d'un dump de
la pile ??
"yarocco" wrote in message
news:41e7bee8$0$15692$Bonjour,
Je cherche comment sont enregistrer les adresses de retour des fonctions.
Exemple : on a une fonction qui en appelle une autre, pour retourner a
la premiere, en ASM, cela se traduit par un RET. Seulement, j'aimerais
savoir ou est stocke l'adresse qu'il va appeller lors du RET.
Je suppose qu'elle est sur la pile, mais comment il (il : le processeur
ou le compilo ??) gere ces adresses : y'a t-il une methode lors du
stockage pour qu'on puisse les retrouver lors d'un debug ou d'un dump de
la pile ??
bon, je crois que tout le monde a expliqué le RET...
ajoutons alors la fenetre CALL STACK dans le menu View / Debug Window de
VC++ qui permet d'avoir la pile d'appel sous les yeux : très pratique.
VB
"yarocco" <aol@aol.com> wrote in message
news:41e7bee8$0$15692$626a14ce@news.free.fr...
Bonjour,
Je cherche comment sont enregistrer les adresses de retour des fonctions.
Exemple : on a une fonction qui en appelle une autre, pour retourner a
la premiere, en ASM, cela se traduit par un RET. Seulement, j'aimerais
savoir ou est stocke l'adresse qu'il va appeller lors du RET.
Je suppose qu'elle est sur la pile, mais comment il (il : le processeur
ou le compilo ??) gere ces adresses : y'a t-il une methode lors du
stockage pour qu'on puisse les retrouver lors d'un debug ou d'un dump de
la pile ??
bon, je crois que tout le monde a expliqué le RET...
ajoutons alors la fenetre CALL STACK dans le menu View / Debug Window de
VC++ qui permet d'avoir la pile d'appel sous les yeux : très pratique.
VB
"yarocco" wrote in message
news:41e7bee8$0$15692$Bonjour,
Je cherche comment sont enregistrer les adresses de retour des fonctions.
Exemple : on a une fonction qui en appelle une autre, pour retourner a
la premiere, en ASM, cela se traduit par un RET. Seulement, j'aimerais
savoir ou est stocke l'adresse qu'il va appeller lors du RET.
Je suppose qu'elle est sur la pile, mais comment il (il : le processeur
ou le compilo ??) gere ces adresses : y'a t-il une methode lors du
stockage pour qu'on puisse les retrouver lors d'un debug ou d'un dump de
la pile ??
bon, je crois que tout le monde a expliqué le RET...
ajoutons alors la fenetre CALL STACK dans le menu View / Debug Window de
VC++ qui permet d'avoir la pile d'appel sous les yeux : très pratique.
VB
Vincent Burel wrote:
> "yarocco" wrote in message
> news:41e7bee8$0$15692$
>
>>Bonjour,
>>Je cherche comment sont enregistrer les adresses de retour des
>>Exemple : on a une fonction qui en appelle une autre, pour retourner a
>>la premiere, en ASM, cela se traduit par un RET. Seulement, j'aimerais
>>savoir ou est stocke l'adresse qu'il va appeller lors du RET.
>>Je suppose qu'elle est sur la pile, mais comment il (il : le processeur
>>ou le compilo ??) gere ces adresses : y'a t-il une methode lors du
>>stockage pour qu'on puisse les retrouver lors d'un debug ou d'un dump de
>>la pile ??
>
>
> bon, je crois que tout le monde a expliqué le RET...
> ajoutons alors la fenetre CALL STACK dans le menu View / Debug Window de
> VC++ qui permet d'avoir la pile d'appel sous les yeux : très pratique.
>
> VB
>
>
Merci a tous.
Et je connais deja la fenetre de la pile :)
Mais la je voudrais faire un "hook" sur une procedure de TObject (dans
Delphi, c'est l'ancetre de tous les objets),
donc je fais pointer
l'adresse de son call vers ma procedure, mais apres il faudrait quand
meme que je lui redonne la main et c'est ca que je ne sais pas faire, vu
que je ne sais pas ou retourner :)
Vincent Burel wrote:
> "yarocco" <aol@aol.com> wrote in message
> news:41e7bee8$0$15692$626a14ce@news.free.fr...
>
>>Bonjour,
>>Je cherche comment sont enregistrer les adresses de retour des
>>Exemple : on a une fonction qui en appelle une autre, pour retourner a
>>la premiere, en ASM, cela se traduit par un RET. Seulement, j'aimerais
>>savoir ou est stocke l'adresse qu'il va appeller lors du RET.
>>Je suppose qu'elle est sur la pile, mais comment il (il : le processeur
>>ou le compilo ??) gere ces adresses : y'a t-il une methode lors du
>>stockage pour qu'on puisse les retrouver lors d'un debug ou d'un dump de
>>la pile ??
>
>
> bon, je crois que tout le monde a expliqué le RET...
> ajoutons alors la fenetre CALL STACK dans le menu View / Debug Window de
> VC++ qui permet d'avoir la pile d'appel sous les yeux : très pratique.
>
> VB
>
>
Merci a tous.
Et je connais deja la fenetre de la pile :)
Mais la je voudrais faire un "hook" sur une procedure de TObject (dans
Delphi, c'est l'ancetre de tous les objets),
donc je fais pointer
l'adresse de son call vers ma procedure, mais apres il faudrait quand
meme que je lui redonne la main et c'est ca que je ne sais pas faire, vu
que je ne sais pas ou retourner :)
Vincent Burel wrote:
> "yarocco" wrote in message
> news:41e7bee8$0$15692$
>
>>Bonjour,
>>Je cherche comment sont enregistrer les adresses de retour des
>>Exemple : on a une fonction qui en appelle une autre, pour retourner a
>>la premiere, en ASM, cela se traduit par un RET. Seulement, j'aimerais
>>savoir ou est stocke l'adresse qu'il va appeller lors du RET.
>>Je suppose qu'elle est sur la pile, mais comment il (il : le processeur
>>ou le compilo ??) gere ces adresses : y'a t-il une methode lors du
>>stockage pour qu'on puisse les retrouver lors d'un debug ou d'un dump de
>>la pile ??
>
>
> bon, je crois que tout le monde a expliqué le RET...
> ajoutons alors la fenetre CALL STACK dans le menu View / Debug Window de
> VC++ qui permet d'avoir la pile d'appel sous les yeux : très pratique.
>
> VB
>
>
Merci a tous.
Et je connais deja la fenetre de la pile :)
Mais la je voudrais faire un "hook" sur une procedure de TObject (dans
Delphi, c'est l'ancetre de tous les objets),
donc je fais pointer
l'adresse de son call vers ma procedure, mais apres il faudrait quand
meme que je lui redonne la main et c'est ca que je ne sais pas faire, vu
que je ne sais pas ou retourner :)
Merci a tous.
Et je connais deja la fenetre de la pile :)
Mais la je voudrais faire un "hook" sur une procedure de TObject (dans
Delphi, c'est l'ancetre de tous les objets), donc je fais pointer
l'adresse de son call vers ma procedure, mais apres il faudrait quand
meme que je lui redonne la main et c'est ca que je ne sais pas faire, vu
que je ne sais pas ou retourner :)
Merci a tous.
Et je connais deja la fenetre de la pile :)
Mais la je voudrais faire un "hook" sur une procedure de TObject (dans
Delphi, c'est l'ancetre de tous les objets), donc je fais pointer
l'adresse de son call vers ma procedure, mais apres il faudrait quand
meme que je lui redonne la main et c'est ca que je ne sais pas faire, vu
que je ne sais pas ou retourner :)
Merci a tous.
Et je connais deja la fenetre de la pile :)
Mais la je voudrais faire un "hook" sur une procedure de TObject (dans
Delphi, c'est l'ancetre de tous les objets), donc je fais pointer
l'adresse de son call vers ma procedure, mais apres il faudrait quand
meme que je lui redonne la main et c'est ca que je ne sais pas faire, vu
que je ne sais pas ou retourner :)
peut-être votre prototype de procedure n'est pas bon, vérifier la convention
d'appel de votre procédure, qu'elle corresponde à celle des methode de
l'objet TObject. Sinon tracez l'appelle à la procédure initiale de TObject
et regardez comment donc le retour est organisé... notons l'éxistence de la
fenêtre Disassembly dans le menu View / Debug Window de VC++ qui vous
permettra de passer sur le code ASM en mode debug / trace... :-)
peut-être votre prototype de procedure n'est pas bon, vérifier la convention
d'appel de votre procédure, qu'elle corresponde à celle des methode de
l'objet TObject. Sinon tracez l'appelle à la procédure initiale de TObject
et regardez comment donc le retour est organisé... notons l'éxistence de la
fenêtre Disassembly dans le menu View / Debug Window de VC++ qui vous
permettra de passer sur le code ASM en mode debug / trace... :-)
peut-être votre prototype de procedure n'est pas bon, vérifier la convention
d'appel de votre procédure, qu'elle corresponde à celle des methode de
l'objet TObject. Sinon tracez l'appelle à la procédure initiale de TObject
et regardez comment donc le retour est organisé... notons l'éxistence de la
fenêtre Disassembly dans le menu View / Debug Window de VC++ qui vous
permettra de passer sur le code ASM en mode debug / trace... :-)
yarocco a écrit :
[...]Merci a tous.
Et je connais deja la fenetre de la pile :)
Mais la je voudrais faire un "hook" sur une procedure de TObject (dans
Delphi, c'est l'ancetre de tous les objets), donc je fais pointer
l'adresse de son call vers ma procedure, mais apres il faudrait quand
meme que je lui redonne la main et c'est ca que je ne sais pas faire,
vu que je ne sais pas ou retourner :)
Sous Delphi (et dans d'autres langages), durant toute la procédure,
l'adresse de retour, celle que le RET trouvera, est en [EBP + 4]. Toute
procédure (que "Optimisation" et/ou "Cadres de pile" soient ou non
cochés) commence par:
push ebp
mov ebp, esp
(EBP ne doit normalement pas changer au cours de la procédure, c'est par
rapport à lui que sont accédées variables locales et paramètres).
Je trouve votre problème intéressant, mais on manque sérieusement
d'éléments. Comment atterrissez-vous dans votre procédure ? Les
fonctions API comme SteWindowsHookEx() ne sont pas utilisables ici, et
ne posent pas se genre de problème.
Ce serait gentil de préciser votre problème. Vous pouvez même poster un
bout de code (en privé si vous voulez, mon email est valide). J'ai
Delphi 7 installé, il me semble avoir lu qu'à partir de 8 il n'y aplus
d'asm, donc c'est baisé.
C'est marrant, pouvoir obtenir rapidement l'ensemble des adresses de la
Call Stack est un classique en ... débogage crapuleux ;-).
yarocco a écrit :
[...]
Merci a tous.
Et je connais deja la fenetre de la pile :)
Mais la je voudrais faire un "hook" sur une procedure de TObject (dans
Delphi, c'est l'ancetre de tous les objets), donc je fais pointer
l'adresse de son call vers ma procedure, mais apres il faudrait quand
meme que je lui redonne la main et c'est ca que je ne sais pas faire,
vu que je ne sais pas ou retourner :)
Sous Delphi (et dans d'autres langages), durant toute la procédure,
l'adresse de retour, celle que le RET trouvera, est en [EBP + 4]. Toute
procédure (que "Optimisation" et/ou "Cadres de pile" soient ou non
cochés) commence par:
push ebp
mov ebp, esp
(EBP ne doit normalement pas changer au cours de la procédure, c'est par
rapport à lui que sont accédées variables locales et paramètres).
Je trouve votre problème intéressant, mais on manque sérieusement
d'éléments. Comment atterrissez-vous dans votre procédure ? Les
fonctions API comme SteWindowsHookEx() ne sont pas utilisables ici, et
ne posent pas se genre de problème.
Ce serait gentil de préciser votre problème. Vous pouvez même poster un
bout de code (en privé si vous voulez, mon email est valide). J'ai
Delphi 7 installé, il me semble avoir lu qu'à partir de 8 il n'y aplus
d'asm, donc c'est baisé.
C'est marrant, pouvoir obtenir rapidement l'ensemble des adresses de la
Call Stack est un classique en ... débogage crapuleux ;-).
yarocco a écrit :
[...]Merci a tous.
Et je connais deja la fenetre de la pile :)
Mais la je voudrais faire un "hook" sur une procedure de TObject (dans
Delphi, c'est l'ancetre de tous les objets), donc je fais pointer
l'adresse de son call vers ma procedure, mais apres il faudrait quand
meme que je lui redonne la main et c'est ca que je ne sais pas faire,
vu que je ne sais pas ou retourner :)
Sous Delphi (et dans d'autres langages), durant toute la procédure,
l'adresse de retour, celle que le RET trouvera, est en [EBP + 4]. Toute
procédure (que "Optimisation" et/ou "Cadres de pile" soient ou non
cochés) commence par:
push ebp
mov ebp, esp
(EBP ne doit normalement pas changer au cours de la procédure, c'est par
rapport à lui que sont accédées variables locales et paramètres).
Je trouve votre problème intéressant, mais on manque sérieusement
d'éléments. Comment atterrissez-vous dans votre procédure ? Les
fonctions API comme SteWindowsHookEx() ne sont pas utilisables ici, et
ne posent pas se genre de problème.
Ce serait gentil de préciser votre problème. Vous pouvez même poster un
bout de code (en privé si vous voulez, mon email est valide). J'ai
Delphi 7 installé, il me semble avoir lu qu'à partir de 8 il n'y aplus
d'asm, donc c'est baisé.
C'est marrant, pouvoir obtenir rapidement l'ensemble des adresses de la
Call Stack est un classique en ... débogage crapuleux ;-).
