`testl` eax contre eax?

J'essaie de comprendre un assemblage.

Le montage comme suit, je suis intéressé par la testlligne:

000319df  8b4508        movl   0x08(%ebp), %eax  
000319e2  8b4004        movl   0x04(%eax), %eax  
000319e5  85c0          testl  %eax, %eax  
000319e7  7407          je     0x000319f0  

J'essaie de comprendre ce point testlentre %eaxet %eax? Je pense que les spécificités de ce code ne sont pas importantes, j'essaie simplement de comprendre le test avec lui-même - la valeur ne serait-elle pas toujours vraie?

Il teste si la valeur eaxest 0, supérieure ou inférieure. Dans ce cas, le saut est effectué si eaxvaut 0.

La signification de testest de ET les arguments ensemble, et vérifiez le résultat pour zéro. Donc, ce code teste si EAX est égal à zéro ou non. jesautera si zéro.

BTW, cela génère une instruction plus petite que cmp eax, 0ce qui est la raison pour laquelle les compilateurs le feront généralement de cette façon.

L'instruction de test effectue une opération ET logique entre les opérandes mais ne réécrit pas le résultat dans un registre. Seuls les drapeaux sont mis à jour.

Dans votre exemple, le test eax, eax définira l'indicateur zéro si eax vaut zéro, l'indicateur de signe si le bit le plus élevé est défini et quelques autres indicateurs également.

L'instruction Jump if Equal (je) saute si l'indicateur zéro est défini.

Vous pouvez traduire le code en un code plus lisible comme celui-ci:

cmp eax, 0
je  somewhere

Cela a la même fonctionnalité mais nécessite quelques octets de plus d'espace de code. C'est la raison pour laquelle le compilateur a émis un test au lieu d'une comparaison.

testest comme and, sauf qu'il n'écrit que des FLAGS, laissant ses deux entrées inchangées. Avec deux entrées différentes , il est utile pour tester si certains bits sont tous à zéro ou si au moins un est défini. (par exemple, test al, 3définit ZF si EAX est un multiple de 4 (et a donc tous les deux ses deux bits inférieurs à zéro).

test eax,eaxdéfinit tous les drapeaux de la même manière que le cmp eax, 0ferait :

• CF et OF effacés (AND / TEST fait toujours cela; soustraire zéro ne produit jamais de report)
• ZF, SF et PF selon la valeur en EAX. ( a = a&a = a-0).
  (PF comme d'habitude n'est défini qu'en fonction des 8 bits bas )

Sauf pour l'AF obsolète (indicateur de report auxiliaire, utilisé par les instructions ASCII / BCD). TEST le laisse indéfini , mais CMP le définit "en fonction du résultat" . Étant donné que la soustraction de zéro ne peut pas produire de report du 4ème au 5ème bit, CMP doit toujours effacer AF.

TEST est plus petit (pas immédiat) et parfois plus rapide (peut macro-fusionner en un uop de comparaison et de branchement sur plus de processeurs dans plus de cas que CMP). Cela fait de testl'idiome préféré pour comparer un registre à zéro . C'est une optimisation de judas cmp reg,0que vous pouvez utiliser quelle que soit la signification sémantique.

La seule raison courante d'utiliser CMP avec un 0 immédiat est lorsque vous souhaitez effectuer une comparaison avec un opérande mémoire. Par exemple, cmpb $0, (%esi)pour rechercher un octet de fin de zéro à la fin d'une chaîne de style C de longueur implicite.

AVX512F ajoutekortestw k1, k2 et AVX512DQ / BW (Skylake-X mais pas KNL) ajoute ktestb/w/d/q k1, k2, qui fonctionnent sur les registres de masque AVX512 (k0..k7) mais définissent toujours des FLAGs réguliers comme le testfont, de la même manière que les entiers ORou les ANDinstructions. (Un peu comme SSE4 ptestou SSE ucomiss: les entrées dans le domaine SIMD et aboutissent à des FLAGS entiers.)

kortestw k1,k1est la manière idiomatique de créer un branchement / cmovcc / setcc basé sur un résultat de comparaison AVX512, en remplaçant SSE / AVX2 (v)pmovmskb/ps/pd+ testou cmp.

L'utilisation de jzvs. jepeut être déroutante.

jzet jesont littéralement la même instruction , c'est-à-dire le même opcode dans le code machine. Ils font la même chose, mais ont une signification sémantique différente pour les humains . Les désassembleurs (et généralement la sortie asm des compilateurs) n'en utiliseront qu'un seul, donc la distinction sémantique est perdue.

cmpet subdéfinissez ZF lorsque leurs deux entrées sont égales (c'est-à-dire que le résultat de la soustraction est 0). je(jump if equal) est le synonyme sémantiquement pertinent.

test %eax,%eax/ and %eax,%eaxdéfinit à nouveau ZF lorsque le résultat est nul, mais il n'y a pas de test "d'égalité". ZF après le test ne vous dit pas si les deux opérandes étaient égaux. Donc jz(sauter si zéro) est le synonyme sémantiquement pertinent.

Cet extrait de code provient d'une sous-routine qui a reçu un pointeur vers quelque chose, probablement une structure ou un objet. La 2ème ligne déréférence ce pointeur, récupérant une valeur de cette chose - peut-être lui-même un pointeur ou peut-être juste un int, stocké comme son 2ème membre (offset +4). Les 3e et 4e lignes testent cette valeur pour zéro (NULL s'il s'agit d'un pointeur) et sautent les quelques opérations suivantes (non illustrées) s'il est égal à zéro.

Le test pour zéro est parfois codé comme une comparaison avec une valeur zéro littérale immédiate, mais le compilateur (ou l'humain?) Qui a écrit cela aurait pu penser qu'une opération de test fonctionnerait plus rapidement - en tenant compte de tous les éléments du processeur modernes tels que le pipelining et le registre renommer. C'est à partir du même sac d'astuces qui contient l'idée d'effacer un registre avec XOR EAX, EAX (que j'ai vu sur la plaque d'immatriculation de quelqu'un dans le Colorado!) Plutôt que l'évident mais peut-être plus lent MOV EAX, # 0 (j'utilise une notation plus ancienne ).

Dans asm, comme perl, TMTOWTDI.

Si eax vaut zéro, il effectuera le saut conditionnel, sinon il continuera l'exécution à 319e9

Dans certains programmes, ils peuvent être utilisés pour vérifier un dépassement de mémoire tampon. Tout en haut de l'espace alloué, un 0 est placé. Après avoir entré des données dans la pile, il recherche le 0 au tout début de l'espace alloué pour s'assurer que l'espace alloué n'est pas débordé.

Il a été utilisé dans l'exercice stack0 des exploits-exercices pour vérifier s'il avait débordé et s'il n'y en avait pas et qu'il y avait un zéro, il afficherait "Try again"

0x080483f4 <main+0>:    push   ebp
0x080483f5 <main+1>:    mov    ebp,esp
0x080483f7 <main+3>:    and    esp,0xfffffff0
0x080483fa <main+6>:    sub    esp,0x60                     
0x080483fd <main+9>:    mov    DWORD PTR [esp+0x5c],0x0 ;puts a zero on stack
0x08048405 <main+17>:   lea    eax,[esp+0x1c]
0x08048409 <main+21>:   mov    DWORD PTR [esp],eax
0x0804840c <main+24>:   call   0x804830c <gets@plt>
0x08048411 <main+29>:   mov    eax,DWORD PTR [esp+0x5c] 
0x08048415 <main+33>:   test   eax,eax                  ; checks if its zero
0x08048417 <main+35>:   je     0x8048427 <main+51>
0x08048419 <main+37>:   mov    DWORD PTR [esp],0x8048500 
0x08048420 <main+44>:   call   0x804832c <puts@plt>
0x08048425 <main+49>:   jmp    0x8048433 <main+63>
0x08048427 <main+51>:   mov    DWORD PTR [esp],0x8048529
0x0804842e <main+58>:   call   0x804832c <puts@plt>
0x08048433 <main+63>:   leave
0x08048434 <main+64>:   ret

nous pourrions voir le jg，jle Si testl %edx,%edx. jle .L3nous pouvions trouver facilement jle est suit (SF^OF)|ZF, si% edx est nul, ZF = 1, mais si% edx n'est pas nul et vaut -1, après le testl, l'OF = 0, et le SF = 1, donc le drapeau = true, qui implémente le saut. Désolé, mon anglais est médiocre