Faire des conditions sans instruction J*
Résolu
cs_grandvizir
Messages postés
1106
Date d'inscription
samedi 8 novembre 2003
Statut
Membre
Dernière intervention
3 septembre 2006
-
22 juin 2005 à 11:08
cs_grandvizir Messages postés 1106 Date d'inscription samedi 8 novembre 2003 Statut Membre Dernière intervention 3 septembre 2006 - 18 août 2006 à 10:53
cs_grandvizir Messages postés 1106 Date d'inscription samedi 8 novembre 2003 Statut Membre Dernière intervention 3 septembre 2006 - 18 août 2006 à 10:53
A voir également:
- Faire des conditions sans instruction J*
- L'instruction insert est en conflit avec la contrainte foreign key ✓ - Forum VB.NET
- Probleme avec une nouvelle foreign key - Forum SQL
- Instruction incorrecte à l'extérieur d'une procédure - Forum Visual Basic
- Problème avec une instruction VBA ✓ - Forum Visual Basic 6
- INSTRUCTION NON VALIDE EN DEHORS DU BLOC TYPE ... - Forum Visual Basic
9 réponses
cs_patatalo
Messages postés
1466
Date d'inscription
vendredi 2 janvier 2004
Statut
Modérateur
Dernière intervention
14 février 2014
2
22 juin 2005 à 12:41
22 juin 2005 à 12:41
salut,
si, par exemple:
reponses dd rep1,rep2,0
xor edx,edx
cmp eax,1
sete dl
call [reponses+edx*4]
...
ret
rep1:
; code 1
ret
rep2
; code 2
ret
@++
si, par exemple:
reponses dd rep1,rep2,0
xor edx,edx
cmp eax,1
sete dl
call [reponses+edx*4]
...
ret
rep1:
; code 1
ret
rep2
; code 2
ret
@++
cs_Nasman
Messages postés
202
Date d'inscription
mardi 17 mai 2005
Statut
Membre
Dernière intervention
29 septembre 2008
3
24 juin 2005 à 15:03
24 juin 2005 à 15:03
En fait une bonne partie des instructions assembleur affecte les flags
(signe, carry, ...), il est possible de convertir le résultat, retenue
par exemple, en un offset qui permettra de moduler un déplacement.
A partir du moment ou le registre d'état aura été affecté les instructions suivantes:
LAHF, RCL (RCR), SALC permettront de définir un déplacement qui pourra être mis à profit lors d'un JMP indirect.
Autre possibilité de saut (à risque), utiliser les instructions suivantes:
instuction précédente xxx
instruction de saut
Call Routine
instruction normale après appel yyy
Routine
comparaison (discrète)
calcul d'une adresse
mov [esp],adresse souhaitée
ret
L'instruction mov [esp],adresse remplace l'adresse de retour empilée
(eip) par la nouvelle adresse. Le Call est en fait un jump déguisé
(signe, carry, ...), il est possible de convertir le résultat, retenue
par exemple, en un offset qui permettra de moduler un déplacement.
A partir du moment ou le registre d'état aura été affecté les instructions suivantes:
LAHF, RCL (RCR), SALC permettront de définir un déplacement qui pourra être mis à profit lors d'un JMP indirect.
Autre possibilité de saut (à risque), utiliser les instructions suivantes:
instuction précédente xxx
instruction de saut
Call Routine
instruction normale après appel yyy
Routine
comparaison (discrète)
calcul d'une adresse
mov [esp],adresse souhaitée
ret
L'instruction mov [esp],adresse remplace l'adresse de retour empilée
(eip) par la nouvelle adresse. Le Call est en fait un jump déguisé
cs_grandvizir
Messages postés
1106
Date d'inscription
samedi 8 novembre 2003
Statut
Membre
Dernière intervention
3 septembre 2006
22
18 août 2006 à 10:53
18 août 2006 à 10:53
J'ai trouvé la solution pour Pascal... et vient de remarquer l'exactitude des informations de Patatalo et Nasman. Mais c'est tellement technique que Delphi ne l'autorise pas facilement. Merci à vous.
program Saut;
procedure Faux;
begin
//le code
end;
procedure Vrai;
begin
//le code
end;
const TableSaut : array[boolean] = (Faux, Vrai);
var Condition : boolean;
begin
Condition: =true;
TableSaut[Condition];
end.
Il suffit tout simplement de faire un tableau de procédures. C'est ce qui se fait aussi en asm.
===========
ViewVite XP : HTML
program Saut;
procedure Faux;
begin
//le code
end;
procedure Vrai;
begin
//le code
end;
const TableSaut : array[boolean] = (Faux, Vrai);
var Condition : boolean;
begin
Condition: =true;
TableSaut[Condition];
end.
Il suffit tout simplement de faire un tableau de procédures. C'est ce qui se fait aussi en asm.
===========
ViewVite XP : HTML
cs_grandvizir
Messages postés
1106
Date d'inscription
samedi 8 novembre 2003
Statut
Membre
Dernière intervention
3 septembre 2006
22
22 juin 2005 à 14:06
22 juin 2005 à 14:06
C'est sympa patatelo, mais je dirais qu'il y a toujours un CMP...
J'ai classé la question en "Delphi + ASM", donc ça risque d'être chaud par ce que la syntaxe n'est pas pareil... Mon idée était de faire un truc du genre:
var AdressesFichier : array[boolean] of Label = (Label1, Label2);
b : boolean
begin
b: =true;
goto AdressesFichier[b];
asm
Label1: //si valeur fausse de b
JMP @Sortie
Label2: //si valeur vraie de b
//JMP @Sortie
Sortie:
end;
end;
On fait un saut en considérant des tableaux, et a priori, il n'y a pas besoin de faire des conditions, sachant que boolean est un type énuméré (il se comporte comme de nombre).
Techniquement, il y a des choses qui ne se font pas...
Alors
===========
ViewVite : HTML
J'ai classé la question en "Delphi + ASM", donc ça risque d'être chaud par ce que la syntaxe n'est pas pareil... Mon idée était de faire un truc du genre:
var AdressesFichier : array[boolean] of Label = (Label1, Label2);
b : boolean
begin
b: =true;
goto AdressesFichier[b];
asm
Label1: //si valeur fausse de b
JMP @Sortie
Label2: //si valeur vraie de b
//JMP @Sortie
Sortie:
end;
end;
On fait un saut en considérant des tableaux, et a priori, il n'y a pas besoin de faire des conditions, sachant que boolean est un type énuméré (il se comporte comme de nombre).
Techniquement, il y a des choses qui ne se font pas...
Alors
===========
ViewVite : HTML
Vous n’avez pas trouvé la réponse que vous recherchez ?
Posez votre question
cs_patatalo
Messages postés
1466
Date d'inscription
vendredi 2 janvier 2004
Statut
Modérateur
Dernière intervention
14 février 2014
2
23 juin 2005 à 10:13
23 juin 2005 à 10:13
re,
a ce moment là, la demande devrait etre Faire des conditions sans instruction C*
@++
a ce moment là, la demande devrait etre Faire des conditions sans instruction C*
@++
cs_Nasman
Messages postés
202
Date d'inscription
mardi 17 mai 2005
Statut
Membre
Dernière intervention
29 septembre 2008
3
23 juin 2005 à 11:36
23 juin 2005 à 11:36
Je pense que plusieurs solutions sont possibles à partir du moment ou
le résultat d'une comparaison a été stocké quelque part (par exemple
AND eax,eax affecte les flags de signe, de zero etc). Tu peux alors
faire un jmp indirect à partir d'une table dont l'adresse pointée
dépendra du résultat de ta comparaison.
Autre solution pour la discretion, leurrer un désassembleur en effectuant un décalage des octets.
depart: mov eax,dword 0x12345678
jmp depart+13
add eax,0x432b0000
or eax,0x04eb0374
ret
nop
nop
nop
ret
après desassemblage celà donne
00000205 B878563412 mov eax,0x12345678
0000020A E903000000 jmp 0x212
0000020F 0500002B43 add eax,0x432b0000
00000214 0D7403EB04 or eax,0x4eb0374
00000219 C3 ret
0000021A 90 nop
0000021B 90 nop
0000021C 90 nop
0000021D C3 ret
Il ne semble pas y avoir de comparaisons ; par compte à l'exécution il
en sera tout autrement. En effet le jmp envoie à une l'adresse 212 où
se trouvent les octets suivants:
212 2B430D sub eax,[ebx+0xd] comparaison
215 7403 jz
21A
si nul aller en 21A
217 EB04 jmp short
21D sinon terminé
le résultat d'une comparaison a été stocké quelque part (par exemple
AND eax,eax affecte les flags de signe, de zero etc). Tu peux alors
faire un jmp indirect à partir d'une table dont l'adresse pointée
dépendra du résultat de ta comparaison.
Autre solution pour la discretion, leurrer un désassembleur en effectuant un décalage des octets.
depart: mov eax,dword 0x12345678
jmp depart+13
add eax,0x432b0000
or eax,0x04eb0374
ret
nop
nop
nop
ret
après desassemblage celà donne
00000205 B878563412 mov eax,0x12345678
0000020A E903000000 jmp 0x212
0000020F 0500002B43 add eax,0x432b0000
00000214 0D7403EB04 or eax,0x4eb0374
00000219 C3 ret
0000021A 90 nop
0000021B 90 nop
0000021C 90 nop
0000021D C3 ret
Il ne semble pas y avoir de comparaisons ; par compte à l'exécution il
en sera tout autrement. En effet le jmp envoie à une l'adresse 212 où
se trouvent les octets suivants:
212 2B430D sub eax,[ebx+0xd] comparaison
215 7403 jz
21A
si nul aller en 21A
217 EB04 jmp short
21D sinon terminé
cs_grandvizir
Messages postés
1106
Date d'inscription
samedi 8 novembre 2003
Statut
Membre
Dernière intervention
3 septembre 2006
22
23 juin 2005 à 14:37
23 juin 2005 à 14:37
Au final, je pense que Delphi n'est pas suffisamment avancé pour ce genre de trucs. Comment lui dire de sauter à une adresse qui se situe dans des lignes prochainement interprétées. La fenêtre CPU du logiciel propose les codes ASM associés aux commandes Pascal, mais tout ça va finir par devenir de la bidouille. Alors, étant propre, je ne ferais rien. C'était juste une petite curiosité technique...
Si des membres ont d'autres propositions, n'hésitez pas à les déposer...
===========
ViewVite : HTML
Si des membres ont d'autres propositions, n'hésitez pas à les déposer...
===========
ViewVite : HTML
cs_patatalo
Messages postés
1466
Date d'inscription
vendredi 2 janvier 2004
Statut
Modérateur
Dernière intervention
14 février 2014
2
24 juin 2005 à 11:43
24 juin 2005 à 11:43
re,
les exceptions ( notament l'instruction bound )
@++
les exceptions ( notament l'instruction bound )
@++
cs_grandvizir
Messages postés
1106
Date d'inscription
samedi 8 novembre 2003
Statut
Membre
Dernière intervention
3 septembre 2006
22
24 juin 2005 à 16:21
24 juin 2005 à 16:21
Je pensais faire une autre structure :
var NbJump : array[boolean] of byte = (3,6); //nombre d'instructions ASM-compilé à sauter
b : boolean ;
label Sortie:
begin
b: =true;
asm
JMP AdresseEnCours + NbJump[b]
end;
//PREMIERE PARTIE: valeur FALSE
JAppelleLaFonctionNumeroUn;
goto Sortie:
//DEUXIEMME PARTIE: valeur TRUE
JAppelleLaFonctionNumeroDeux;
Sortie:
end;
Le fait de faire un appel à fonction devrait forcer l'optimiseur de Delphi à faire un CALL, ce qui réduit le nombre d'instructions à sauter...
Ainsi, la première cellule de NbJump est le nombre d'instuctions entre JMP et l'appel à fonction N°1, la deuxième cellule entre JMP et l'appel à la fonction N°2.
On s'aidera de la fenêtre CPU afin de déterminer ces nombres...
On résumé, ma question est: comment dire à l'ASM de Delphi de sauter N instructions de code compilé Après, ça devrait se simplifier...
Note importante: la technique de résolution doit être très propre. Pas de bidouille !
===========
ViewVite : HTML
var NbJump : array[boolean] of byte = (3,6); //nombre d'instructions ASM-compilé à sauter
b : boolean ;
label Sortie:
begin
b: =true;
asm
JMP AdresseEnCours + NbJump[b]
end;
//PREMIERE PARTIE: valeur FALSE
JAppelleLaFonctionNumeroUn;
goto Sortie:
//DEUXIEMME PARTIE: valeur TRUE
JAppelleLaFonctionNumeroDeux;
Sortie:
end;
Le fait de faire un appel à fonction devrait forcer l'optimiseur de Delphi à faire un CALL, ce qui réduit le nombre d'instructions à sauter...
Ainsi, la première cellule de NbJump est le nombre d'instuctions entre JMP et l'appel à fonction N°1, la deuxième cellule entre JMP et l'appel à la fonction N°2.
On s'aidera de la fenêtre CPU afin de déterminer ces nombres...
On résumé, ma question est: comment dire à l'ASM de Delphi de sauter N instructions de code compilé Après, ça devrait se simplifier...
Note importante: la technique de résolution doit être très propre. Pas de bidouille !
===========
ViewVite : HTML