`testl` eax contre eax?
-
02-07-2019 - |
Question
J'essaie de comprendre un assemblage.
L'assemblage comme suit m'intéresse la ligne testl
:
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 de testl
entre % eax
et % eax
? Je pense que les détails de ce que ce code n’a pas d’importance, j’essaie simplement de comprendre le test avec lui-même - la valeur ne serait-elle pas toujours vraie?
La solution
Il teste si eax
est égal à 0, ou supérieur ou inférieur. Dans ce cas, le saut est pris si eax
est 0.
Autres conseils
La signification de test
est de combiner ET les arguments ensemble et de vérifier le résultat pour zéro. Donc, ce code teste si EAX est égal à zéro ou non. je
sautera si zéro.
BTW, cela génère une instruction plus petite que cmp eax, 0
, raison pour laquelle les compilateurs le font généralement de cette façon.
L'instruction de test effectue une opération logique AND entre les opérandes mais ne réécrit pas le résultat dans un registre. Seuls les drapeaux sont mis à jour.
Dans votre exemple, test eax, eax définira l'indicateur zéro si eax est égal à zéro, l'indicateur de signe si le bit le plus élevé est défini, ainsi que d'autres indicateurs.
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 ceci:
cmp eax, 0
je somewhere
Cela a la même fonctionnalité mais nécessite quelques octets plus d'espace de code. C'est la raison pour laquelle le compilateur a émis un test au lieu d'une comparaison.
test
est comme et
, sauf qu'il écrit uniquement FLAGS, en laissant ses deux entrées non modifiées. Avec deux entrées différentes , il est utile de vérifier si certains bits sont tous nuls ou si au moins un est défini. (Par exemple, test al, 3
définit ZF si EAX est un multiple de 4 (et a donc ses deux bits les plus bas mis à zéro).
test eax, eax
définit tout les drapeaux exactement de la même manière que cmp eax, 0
aurait :
- CF et OF effacés (AND / TEST fait toujours cela; et soustraire zéro ne produit jamais de report)
- ZF, SF et PF en fonction de la valeur dans EAX. (
a = a & a; a = a-0
)
(Sauf pour l'AF obsolète (indicateur de port auxiliaire utilisé par les instructions ASCII / BCD). TEST le laisse non défini , mais CMP le définit "en fonction du résultat" . Puisque la soustraction de zéro ne peut pas produire de retenue du 4ème au 5ème bit, CMP doit toujours effacer l’AF).
TEST est plus petit (pas d’immédiat) et parfois plus rapide (possibilité de fusionner des macros en un uop de comparaison et de branchement sur plus de processeurs dans plus de cas que CMP). Cela permet à de tester
l'idiome préféré pour tester un registre à zéro ou non .
La seule raison courante pour utiliser CMP avec un 0 immédiat, c’est lorsque vous souhaitez comparer un opérande mémoire (par exemple, cmpb $ 0, (% esi)
pour rechercher un octet final de fin la fin d'une chaîne de style C de longueur implicite).
AVX512F ajoute les kortestw k1, k2
. a> et AVX512DQ / BW (Skylake mais pas KNL), ajoutez ktestb / w / d / q k1, k2
, qui fonctionnent sur les registres de masque AVX512 (k0..k7) mais définissent tout de même les DRAPEAUX normaux, comme le fait test
, de la même manière que entier OU
ou ET
instructions faire.
kortestw k1, k1
est la méthode idiomatique de branchement / cmovcc / setcc basée sur un résultat de comparaison AVX512, remplaçant SSE / AVX2 (v) pmovmskb / ps / pd
+ test
ou cmp
.
L'utilisation de jz
ou je
peut être source de confusion.
jz
et je
sont littéralement les 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 les sorties asm des compilateurs) n’en utiliseront jamais qu’un seul, la distinction sémantique est alors perdue.
cmp
et sous
définissent ZF lorsque leurs deux entrées sont égales (c'est-à-dire que le résultat de la soustraction est 0). je
(saut si égal) est le synonyme sémantiquement pertinent.
test% eax,% eax
/ et% eax,% eax
définit à nouveau ZF lorsque le résultat est égal à zéro, mais il n'y a pas d '"égalité". tester. ZF après test ne vous dit pas si les deux opérandes étaient égaux. Donc jz
(saut si zéro) est le synonyme sémantiquement pertinent.
Cet extrait de code provient d'un sous-programme auquel un pointeur a été attribué, probablement une structure ou un objet. La 2ème ligne supprime ce pointeur en récupérant une valeur de cette chose - éventuellement un pointeur ou peut-être simplement un int, stocké comme son 2ème membre (offset +4). Les 3ème et 4ème lignes testent cette valeur à zéro (NULL s'il s'agit d'un pointeur) et ignorent les quelques opérations suivantes (non affichées) si elle est égale à 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'homme?) qui l'a écrit aurait pu penser qu'un test serait plus rapide - en prenant en compte tous les éléments modernes de la CPU, comme pipelining et register renommer. C'est dans le même sac à mal que l'idée de nettoyer un registre avec XOR EAX, EAX (que j'ai vu sur la plaque d'immatriculation de quelqu'un dans le Colorado!) Plutôt que sur le MOV EAX, # 0 (j'utilise une notation plus ancienne, mais peut-être plus lente) ).
Dans asm, comme Perl, TMTOWTDI.
Si eax est égal à zéro, il effectuera le saut conditionnel, sinon il poursuivra son exécution à 319e9
Dans certains programmes, ils peuvent être utilisés pour vérifier un débordement de mémoire tampon. Tout en haut de l'espace alloué, un 0 est placé. Une fois les données saisies dans la pile, il recherche le 0 au tout début de l’espace alloué pour s’assurer que cet espace n’est pas saturé.
Il a été utilisé dans l'exercice d'empilage d'exploits-exercices pour vérifier s'il débordait et s'il n'y en avait pas et s'il y avait un zéro, l'affichage s'affichera "Réessayer"
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 avons pu voir le jg jle
Si testl% edx,% edx. jle .L3
nous pourrions facilement trouver jle comme (SF ^ OF) | ZF
, si% edx est égal à zéro, ZF = 1, mais si% edx n'est pas zéro et vaut -1, après le testl, le OF = 0 et le SF = 1, donc l'indicateur = true, qui implémente le saut
désolé, mon anglais est médiocre