`testl` eax contra eax?

Estoy tratando de entender alguna asamblea.

El montaje de la siguiente manera, me interesa la testllínea:

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

Estoy tratando de entender ese punto testlentre %eaxy %eax? Creo que los detalles de lo que este código no es importante, solo estoy tratando de entender la prueba consigo misma, ¿no sería siempre cierto el valor?

Prueba si eaxes 0, superior o inferior. En este caso, el salto se realiza si eaxes 0.

El significado de testes hacer Y los argumentos juntos, y verificar que el resultado sea cero. Entonces, este código prueba si EAX es cero o no. jesaltará si es cero.

Por cierto, esto genera una instrucción más pequeña cmp eax, 0que la razón por la que los compiladores generalmente lo hacen de esta manera.

La instrucción de prueba realiza una operación Y lógica entre los operandos pero no escribe el resultado en un registro. Solo se actualizan las banderas.

En su ejemplo, la prueba eax, eax establecerá el indicador cero si eax es cero, el indicador de signo si se establece el bit más alto y también algunos otros indicadores.

La instrucción Jump if Equal (je) salta si se establece el indicador de cero.

Puede traducir el código a un código más legible como este:

cmp eax, 0
je  somewhere

Tiene la misma funcionalidad pero requiere algunos bytes más de espacio de código. Esa es la razón por la que el compilador emitió una prueba en lugar de una comparación.

testes como and, excepto que solo escribe BANDERAS, dejando ambas entradas sin modificar. Con dos entradas diferentes , es útil para probar si algunos bits son todos cero, o si al menos uno está configurado. (por ejemplo, test al, 3establece ZF si EAX es un múltiplo de 4 (y por lo tanto tiene ambos bits bajos de 2 en cero).

test eax,eaxestablece todas las banderas de la misma manera que cmp eax, 0lo haría :

• CF y OF despejados (AND / TEST siempre hace eso; restar cero nunca produce un acarreo)
• ZF, SF y PF según el valor en EAX. ( a = a&a = a-0).
  (PF, como de costumbre, solo se establece de acuerdo con los 8 bits bajos )

Excepto por el AF obsoleto (indicador de transporte auxiliar, utilizado por las instrucciones ASCII / BCD). TEST lo deja sin definir , pero CMP lo establece "según el resultado" . Dado que restar cero no puede producir un acarreo del cuarto al quinto bit, CMP siempre debe borrar AF.

TEST es más pequeño (no inmediato) y, a veces, más rápido (puede macro-fusionarse en un uop de comparación y ramificación en más CPU en más casos que CMP). Eso lo convierte en testel idioma preferido para comparar un registro con cero . Es una optimización de mirilla cmp reg,0que puede utilizar independientemente del significado semántico.

La única razón común para usar CMP con un 0 inmediato es cuando desea comparar con un operando de memoria. Por ejemplo, cmpb $0, (%esi)para comprobar si hay un byte de terminación cero al final de una cadena de estilo C de longitud implícita.

AVX512F agregakortestw k1, k2 y AVX512DQ / BW (Skylake-X pero no KNL) agrega ktestb/w/d/q k1, k2, que operan en registros de máscara AVX512 (k0..k7) pero aún establecen BANDERAS regulares como lo testhacen, de la misma manera que lo hacen los números enteros ORo las ANDinstrucciones. (Algo así como SSE4 ptesto SSE ucomiss: entradas en el dominio SIMD y dan como resultado BANDERAS enteras).

kortestw k1,k1es la forma idiomática de bifurcar / cmovcc / setcc basada en un resultado de comparación AVX512, reemplazando SSE / AVX2 (v)pmovmskb/ps/pd+ testo cmp.

El uso de jzvs. jepuede resultar confuso.

jzy jeson literalmente la misma instrucción , es decir, el mismo código de operación en el código de máquina. Hacen lo mismo, pero tienen un significado semántico diferente para los humanos . Los desensambladores (y generalmente la salida de asm de los compiladores) solo usarán uno, por lo que se pierde la distinción semántica.

cmpy subestablecer ZF cuando sus dos entradas son iguales (es decir, el resultado de la resta es 0). je(saltar si es igual) es el sinónimo semánticamente relevante.

test %eax,%eax/ and %eax,%eaxnuevamente establece ZF cuando el resultado es cero, pero no hay una prueba de "igualdad". ZF después de la prueba no le dice si los dos operandos eran iguales. Entonces jz(saltar si cero) es el sinónimo semánticamente relevante.

Este fragmento de código es de una subrutina a la que se le dio un puntero a algo, probablemente alguna estructura u objeto. La segunda línea elimina la referencia de ese puntero, obteniendo un valor de esa cosa, posiblemente en sí mismo un puntero o tal vez solo un int, almacenado como su segundo miembro (desplazamiento +4). Las líneas 3 y 4 prueban este valor para cero (NULL si es un puntero) y omiten las siguientes operaciones (no se muestran) si es cero.

La prueba de cero a veces se codifica como una comparación con un valor cero literal inmediato, pero el compilador (¿o el humano?) Que escribió esto podría haber pensado que una operación de prueba se ejecutaría más rápido, teniendo en cuenta todas las cosas modernas de la CPU como la canalización y el registro. renombrar. Es de la misma bolsa de trucos que sostiene la idea de borrar un registro con XOR EAX, EAX (¡que vi en la matrícula de alguien en Colorado!) En lugar del obvio pero quizás más lento MOV EAX, # 0 (uso una notación anterior ).

En asm, como perl, TMTOWTDI.

Si eax es cero, realizará el salto condicional, de lo contrario continuará la ejecución en 319e9

En algunos programas, se pueden utilizar para comprobar si hay un desbordamiento del búfer. En la parte superior del espacio asignado se coloca un 0. Después de ingresar datos en la pila, busca el 0 al comienzo del espacio asignado para asegurarse de que el espacio asignado no se desborde.

Se usó en el ejercicio stack0 de exploits-ejercicios para verificar si estaba desbordado y si no lo había y había un cero allí, mostraría "Intentar de nuevo"

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

podríamos ver jg , jle Si testl %edx,%edx. jle .L3pudiéramos encontrar fácilmente jle es adecuado (SF^OF)|ZF, si% edx es cero, ZF = 1, pero si% edx no es cero y es -1, después de la prueba, OF = 0 y SF = 1, entonces la bandera = verdadera, que implementa salto. Lo siento, mi inglés es pobre