Faire des conditions sans instruction J*

Bonjour,

Quand je fais un programme Delphi, je dois souvent faire des IF :
  if MaVariable then
    {quelque chose};

Qui se traduit par les instructions ASM suivantes:
  CMP
ou par la succession
  TEST
  LEA
  JNE/JE

Je me demandais si on ne pouvait pas faire des instructions conditionnelles sans faire apparaître de telles commandes ASM, histoire qu'elles passent un peu plus inaperçues ?

Je m'en réferre donc aux gourous de l'assembleur...
Cordialement

=============
ViewVite : HTML

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

re,

a ce moment là, la demande devrait etre Faire des conditions sans instruction C*

@++

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é

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

re,

les exceptions ( notament l'instruction bound )

@++

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