-- ___________ _/ _ _`_`_`_) Serge PACCALIN -- sp ad mailclub.net _L_) Il faut donc que les hommes commencent -'(__) par n'être pas fanatiques pour mériter _/___(_) la tolérance. -- Voltaire, 1763
Le lundi 13 août 2007 à 03:56:22, Dan1024 a écrit dans
fr.comp.lang.c++ :
J'ai un code ASM à passer en C++ et j'arrive à un résultat qui marche
mais très, très moche, n'y aurait il pas une méthode beaucoup plus
élégante ?
Le code ASM: ESI contient une adresse, résultat dans EDX.
--
___________
_/ _ _`_`_`_) Serge PACCALIN -- sp ad mailclub.net
_L_) Il faut donc que les hommes commencent
-'(__) par n'être pas fanatiques pour mériter
_/___(_) la tolérance. -- Voltaire, 1763
-- ___________ _/ _ _`_`_`_) Serge PACCALIN -- sp ad mailclub.net _L_) Il faut donc que les hommes commencent -'(__) par n'être pas fanatiques pour mériter _/___(_) la tolérance. -- Voltaire, 1763
Sylvain Togni
Dan1024 wrote:
J'ai un code ASM à passer en C++ et j'arrive à un résultat qui marche mais très, très moche, n'y aurait il pas une méthode beaucoup plus élégante ?
Pas vraiment, faire mumuse avec la mémoire n'est jamais très élégant en C++.
Le code ASM: ESI contient une adresse, résultat dans EDX.
La question principale est: pourquoi ne pas mettre temp1 directement du bon type ? DWORD ***temps1 = *reinterpret_cast<DWORD****>(ReturnData+0x278); DWORD *temp2 = *(*temp1 + 0xfc); DWORD result = *(temp2+0x24);
Pierre
On 12 août, 19:56, "Dan1024" <nos...@nospam.inv> wrote:
Bonjour,
J'ai un code ASM à passer en C++ et j'arrive à un résultat qui marc he
mais très, très moche, n'y aurait il pas une méthode beaucoup plus
élégante ?
Le code ASM: ESI contient une adresse, résultat dans EDX.
La question principale est: pourquoi ne pas mettre temp1 directement
du bon type ?
DWORD ***temps1 = *reinterpret_cast<DWORD****>(ReturnData+0x278);
DWORD *temp2 = *(*temp1 + 0xfc);
DWORD result = *(temp2+0x24);
La question principale est: pourquoi ne pas mettre temp1 directement du bon type ? DWORD ***temps1 = *reinterpret_cast<DWORD****>(ReturnData+0x278); DWORD *temp2 = *(*temp1 + 0xfc); DWORD result = *(temp2+0x24);
Pierre
Sylvain Togni
Pierre Barbier de Reuille wrote:
La question principale est: pourquoi ne pas mettre temp1 directement du bon type ? DWORD ***temps1 = *reinterpret_cast<DWORD****>(ReturnData+0x278); DWORD *temp2 = *(*temp1 + 0xfc); DWORD result = *(temp2+0x24);
Certainement parce que ce n'est pas équivalent.
-- Sylvain Togni
Pierre Barbier de Reuille wrote:
La question principale est: pourquoi ne pas mettre temp1 directement
du bon type ?
DWORD ***temps1 = *reinterpret_cast<DWORD****>(ReturnData+0x278);
DWORD *temp2 = *(*temp1 + 0xfc);
DWORD result = *(temp2+0x24);
La question principale est: pourquoi ne pas mettre temp1 directement du bon type ? DWORD ***temps1 = *reinterpret_cast<DWORD****>(ReturnData+0x278); DWORD *temp2 = *(*temp1 + 0xfc); DWORD result = *(temp2+0x24);
Certainement parce que ce n'est pas équivalent.
-- Sylvain Togni
Pierre Barbier de Reuille
On 13 août, 09:44, Sylvain Togni <"sylvain.togni at visionobjects.com"> wrote:
Pierre Barbier de Reuille wrote:
La question principale est: pourquoi ne pas mettre temp1 directement du bon type ? DWORD ***temps1 = *reinterpret_cast<DWORD****>(ReturnData+0x278); DWORD *temp2 = *(*temp1 + 0xfc); DWORD result = *(temp2+0x24);
Certainement parce que ce n'est pas équivalent.
Mmmmhhh ... on va dire que c'est autant équivalent que tous les autre codes proposés ! Ou alors il faut m'expliquer plus que ça. Mais en effet, il faut corriger car les décalages d'adresses doivent être divisés par la taille d'un pointeur... Du coup ça donnerait (en supposant une architecture 32bits et en supposant que ReturnData est un void* ou un char*):
Si ReturnData est d'un autre type, il faut aussi corriger le 0x278 de la même façon ...
Pierre
On 13 août, 09:44, Sylvain Togni <"sylvain.togni at
visionobjects.com"> wrote:
Pierre Barbier de Reuille wrote:
La question principale est: pourquoi ne pas mettre temp1 directement
du bon type ?
DWORD ***temps1 = *reinterpret_cast<DWORD****>(ReturnData+0x278);
DWORD *temp2 = *(*temp1 + 0xfc);
DWORD result = *(temp2+0x24);
Certainement parce que ce n'est pas équivalent.
Mmmmhhh ... on va dire que c'est autant équivalent que tous les autre
codes proposés ! Ou alors il faut m'expliquer plus que ça.
Mais en effet, il faut corriger car les décalages d'adresses doivent
être divisés par la taille d'un pointeur... Du coup ça donnerait (en
supposant une architecture 32bits et en supposant que ReturnData est
un void* ou un char*):
On 13 août, 09:44, Sylvain Togni <"sylvain.togni at visionobjects.com"> wrote:
Pierre Barbier de Reuille wrote:
La question principale est: pourquoi ne pas mettre temp1 directement du bon type ? DWORD ***temps1 = *reinterpret_cast<DWORD****>(ReturnData+0x278); DWORD *temp2 = *(*temp1 + 0xfc); DWORD result = *(temp2+0x24);
Certainement parce que ce n'est pas équivalent.
Mmmmhhh ... on va dire que c'est autant équivalent que tous les autre codes proposés ! Ou alors il faut m'expliquer plus que ça. Mais en effet, il faut corriger car les décalages d'adresses doivent être divisés par la taille d'un pointeur... Du coup ça donnerait (en supposant une architecture 32bits et en supposant que ReturnData est un void* ou un char*):
Génial, ca marche est c'est assez joli, merci beaucoup, je vais essayer de piger le truc pour faire les autres, autant l'asm c'est limpide autant j'ai de la peine avec les reinterpret_cast. (enfin en relisant c'est assez clair quand même)
"Pierre Barbier de Reuille" a écrit dans le message de news:
La question principale est: pourquoi ne pas mettre temp1 directement du bon type ? DWORD ***temps1 = *reinterpret_cast<DWORD****>(ReturnData+0x278); DWORD *temp2 = *(*temp1 + 0xfc); DWORD result = *(temp2+0x24);
Désolé Pierre, la ca plante sur la derniere ligne.
En tout cas merci à tous pour vos réponses.
Dan
"Serge Paccalin" a écrit dans le message de news:
Déjà, c'est dommage de mélanger casts à la C et reinterpret_cast<>.
Ensuite, pourquoi caster deux fois certaines expressions ?
Génial, ca marche est c'est assez joli, merci beaucoup, je vais essayer
de piger le truc pour faire les autres, autant l'asm c'est limpide autant
j'ai de la peine avec les reinterpret_cast. (enfin en relisant c'est assez
clair quand même)
"Pierre Barbier de Reuille" a écrit dans le message de news:
La question principale est: pourquoi ne pas mettre temp1 directement
du bon type ?
DWORD ***temps1 = *reinterpret_cast<DWORD****>(ReturnData+0x278);
DWORD *temp2 = *(*temp1 + 0xfc);
DWORD result = *(temp2+0x24);
Désolé Pierre, la ca plante sur la derniere ligne.
Génial, ca marche est c'est assez joli, merci beaucoup, je vais essayer de piger le truc pour faire les autres, autant l'asm c'est limpide autant j'ai de la peine avec les reinterpret_cast. (enfin en relisant c'est assez clair quand même)
"Pierre Barbier de Reuille" a écrit dans le message de news:
La question principale est: pourquoi ne pas mettre temp1 directement du bon type ? DWORD ***temps1 = *reinterpret_cast<DWORD****>(ReturnData+0x278); DWORD *temp2 = *(*temp1 + 0xfc); DWORD result = *(temp2+0x24);
Désolé Pierre, la ca plante sur la derniere ligne.
En tout cas merci à tous pour vos réponses.
Dan
Fabien LE LEZ
On Tue, 14 Aug 2007 04:06:35 +0200, "Dan1024" :
autant l'asm c'est limpide autant j'ai de la peine avec les reinterpret_cast.
C'est logique : la manière de penser et de faire les choses utilisée en assembleur x86, est très différente de celle utilisée en C++. Du coup, les méthodes assembleur s'appliquent mal au C++.
On Tue, 14 Aug 2007 04:06:35 +0200, "Dan1024" <nospam@nospam.inv>:
autant l'asm c'est limpide autant
j'ai de la peine avec les reinterpret_cast.
C'est logique : la manière de penser et de faire les choses utilisée
en assembleur x86, est très différente de celle utilisée en C++. Du
coup, les méthodes assembleur s'appliquent mal au C++.
autant l'asm c'est limpide autant j'ai de la peine avec les reinterpret_cast.
C'est logique : la manière de penser et de faire les choses utilisée en assembleur x86, est très différente de celle utilisée en C++. Du coup, les méthodes assembleur s'appliquent mal au C++.
Pierre Barbier de Reuille
On 13 août, 20:06, "Dan1024" wrote:
"Serge Paccalin" a écrit dans le message de news:
Déjà, c'est dommage de mélanger casts à la C et reinterpret_cast <>. Ensuite, pourquoi caster deux fois certaines expressions ?
Génial, ca marche est c'est assez joli, merci beaucoup, je vais essayer de piger le truc pour faire les autres, autant l'asm c'est limpide autant j'ai de la peine avec les reinterpret_cast. (enfin en relisant c'est assez clair quand même)
"Pierre Barbier de Reuille" a écrit dans le message de news:
La question principale est: pourquoi ne pas mettre temp1 directement du bon type ? DWORD ***temps1 = *reinterpret_cast<DWORD****>(ReturnData+0x278); DWORD *temp2 = *(*temp1 + 0xfc); DWORD result = *(temp2+0x24);
Désolé Pierre, la ca plante sur la derniere ligne.
En tout cas merci à tous pour vos réponses.
Dan
Oups ... j'ai oublié de convertir le premier décalage ^^ donc il fallait lire:
DWORD* temp2 = *(*temp1 + 0x3f);
Désolé,
Pierre Pierre
On 13 août, 20:06, "Dan1024" <nos...@nospam.inv> wrote:
"Serge Paccalin" a écrit dans le message de news:
Déjà, c'est dommage de mélanger casts à la C et reinterpret_cast <>.
Ensuite, pourquoi caster deux fois certaines expressions ?
Génial, ca marche est c'est assez joli, merci beaucoup, je vais essayer
de piger le truc pour faire les autres, autant l'asm c'est limpide autant
j'ai de la peine avec les reinterpret_cast. (enfin en relisant c'est assez
clair quand même)
"Pierre Barbier de Reuille" a écrit dans le message de news:
La question principale est: pourquoi ne pas mettre temp1 directement
du bon type ?
DWORD ***temps1 = *reinterpret_cast<DWORD****>(ReturnData+0x278);
DWORD *temp2 = *(*temp1 + 0xfc);
DWORD result = *(temp2+0x24);
Désolé Pierre, la ca plante sur la derniere ligne.
En tout cas merci à tous pour vos réponses.
Dan
Oups ... j'ai oublié de convertir le premier décalage ^^
donc il fallait lire:
Génial, ca marche est c'est assez joli, merci beaucoup, je vais essayer de piger le truc pour faire les autres, autant l'asm c'est limpide autant j'ai de la peine avec les reinterpret_cast. (enfin en relisant c'est assez clair quand même)
"Pierre Barbier de Reuille" a écrit dans le message de news:
La question principale est: pourquoi ne pas mettre temp1 directement du bon type ? DWORD ***temps1 = *reinterpret_cast<DWORD****>(ReturnData+0x278); DWORD *temp2 = *(*temp1 + 0xfc); DWORD result = *(temp2+0x24);
Désolé Pierre, la ca plante sur la derniere ligne.
En tout cas merci à tous pour vos réponses.
Dan
Oups ... j'ai oublié de convertir le premier décalage ^^ donc il fallait lire:
DWORD* temp2 = *(*temp1 + 0x3f);
Désolé,
Pierre Pierre
Falk Tannhäuser
Fabien LE LEZ schrieb:
On Tue, 14 Aug 2007 04:06:35 +0200, "Dan1024" :
autant l'asm c'est limpide autant j'ai de la peine avec les reinterpret_cast.
C'est logique : la manière de penser et de faire les choses utilisée en assembleur x86, est très différente de celle utilisée en C++. Du coup, les méthodes assembleur s'appliquent mal au C++.
En C++ ou C "idiomatique", l'équivalent du code posté aurait probablement consisté à dé-référencer des pointeurs sur des struct dont les champs sont d'autres pointeurs... Il est même possible que ce code assembleur soit issu d'un compilateur C++, les offset (00000278h, 000000FCh, 24h) correspondant à des offset des champs dans des différentes structures pointées.
Falk
Fabien LE LEZ schrieb:
On Tue, 14 Aug 2007 04:06:35 +0200, "Dan1024" <nospam@nospam.inv>:
autant l'asm c'est limpide autant
j'ai de la peine avec les reinterpret_cast.
C'est logique : la manière de penser et de faire les choses utilisée
en assembleur x86, est très différente de celle utilisée en C++. Du
coup, les méthodes assembleur s'appliquent mal au C++.
En C++ ou C "idiomatique", l'équivalent du code posté aurait
probablement consisté à dé-référencer des pointeurs sur des struct dont
les champs sont d'autres pointeurs... Il est même possible que ce code
assembleur soit issu d'un compilateur C++, les offset (00000278h,
000000FCh, 24h) correspondant à des offset des champs dans des
différentes structures pointées.
autant l'asm c'est limpide autant j'ai de la peine avec les reinterpret_cast.
C'est logique : la manière de penser et de faire les choses utilisée en assembleur x86, est très différente de celle utilisée en C++. Du coup, les méthodes assembleur s'appliquent mal au C++.
En C++ ou C "idiomatique", l'équivalent du code posté aurait probablement consisté à dé-référencer des pointeurs sur des struct dont les champs sont d'autres pointeurs... Il est même possible que ce code assembleur soit issu d'un compilateur C++, les offset (00000278h, 000000FCh, 24h) correspondant à des offset des champs dans des différentes structures pointées.
Falk
Dan1024
From: "Falk Tannhäuser"
Il est même possible que ce code assembleur soit issu d'un compilateur C++, les offset (00000278h, 000000FCh, 24h) correspondant à des offset des champs dans des différentes structures pointées.
C'est exactement ca. Et rassurez vous ce n'est pas du tout pour pirater un truc... Je rajoute juste des fonctionnalités ;) (SDK incomplete)
Dan
From: "Falk Tannhäuser"
Il est même possible que ce code assembleur soit issu d'un compilateur
C++, les offset (00000278h, 000000FCh, 24h) correspondant à des
offset des champs dans des différentes structures pointées.
C'est exactement ca. Et rassurez vous ce n'est pas du tout
pour pirater un truc... Je rajoute juste des fonctionnalités ;)
(SDK incomplete)
Il est même possible que ce code assembleur soit issu d'un compilateur C++, les offset (00000278h, 000000FCh, 24h) correspondant à des offset des champs dans des différentes structures pointées.
C'est exactement ca. Et rassurez vous ce n'est pas du tout pour pirater un truc... Je rajoute juste des fonctionnalités ;) (SDK incomplete)
