Esta pregunta ya tiene una respuesta aquí:

Hay dos formas conocidas de establecer un registro entero en valor cero en x86.

Ya sea

mov reg, 0

o

xor reg, reg

Existe la opinión de que la segunda variante es mejor, ya que el valor 0 no se almacena en el código y eso guarda varios bytes del código de máquina producido. Esto es definitivamente bueno: se usa menos caché de instrucciones y esto puede permitir una ejecución más rápida del código. Muchos compiladores producen tal código.

Sin embargo, hay una dependencia formal entre la instrucción xor y cualquier instrucción anterior que cambie el mismo registro. Dado que hay una dependencia, la última instrucción debe esperar hasta que se complete la primera, lo que podría reducir la carga de las unidades del procesador y perjudicar el rendimiento.

add reg, 17
;do something else with reg here
xor reg, reg

Es obvio que el resultado de xor será exactamente el mismo independientemente del valor de registro inicial. ¿Pero es capaz el procesador de reconocer esto?

Probé la siguiente prueba en VC ++ 7:

const int Count = 10 * 1000 * 1000 * 1000;
int _tmain(int argc, _TCHAR* argv[])
{
    int i;
    DWORD start = GetTickCount();
    for( i = 0; i < Count ; i++ ) {
        __asm {
            mov eax, 10
            xor eax, eax
        };
    }
    DWORD diff = GetTickCount() - start;
    start = GetTickCount();
    for( i = 0; i < Count ; i++ ) {
        __asm {
            mov eax, 10
            mov eax, 0
        };
    }
    diff = GetTickCount() - start;
    return 0;
}

Con las optimizaciones desactivadas, ambos bucles toman exactamente el mismo tiempo. ¿Esto prueba razonablemente que el procesador reconoce que no hay dependencia dexor reg, reg instrucción sobre el anteriormov eax, 0 ¿instrucción? ¿Qué podría ser una mejor prueba para comprobar esto?