Una característica indocumentada de multiplicación y división en procesadores x86

A partir del procesador 80286, Intel ha mantenido una compatibilidad ascendente total en el conjunto de instrucciones. Es decir, si algunas de las instrucciones del procesador dan tal o cual resultado en 8086, entonces el resultado será exactamente el mismo en procesadores posteriores (ahora no consideraremos errores como la división incorrecta en Pentium I).

¿Pero es? ¡Que pregunta! Después de todo, si no se conservó la compatibilidad, los programas antiguos no podrían ejecutarse y aún puede sentirse nostálgico en cualquier computadora ejecutando Norton Commander o Tetris. Sin embargo, no todo es tan simple ... A partir del 8080, los procesadores Intel tienen un registro de banderas, cuyo estado está determinado por el resultado del último comando de cálculo de datos. Todas las banderas se han descrito en él durante mucho tiempo y su comportamiento está estrictamente fijado. Salvo dos excepciones.

AF – . . 8- 8080 . 16- x86 – ? Intel – AF . 8080 . 16- AF !

, - ! AF PF !

:

#include <iostream>
#include <iomanip> 

int main()
{
    using namespace std;
    const int min_i = -20, max_i = 50,min_j=-10, max_j = 50;
    short int i, j, k, pf;
    cout << "Name;i;j;Result;AF;PF;Calculated parity\n";
    
    for (i = min_i; i < max_i; i++) {
        for (j = min_j; j < max_j; j++) {
            __asm {
                mov ax, i
                mov dx, j
                imul dx
                pushf
                pop ax
                mov k, ax
            }
            pf = i * j;  pf = ((pf >> 7) ^ (pf >> 6) ^ (pf >> 5) ^ (pf >> 4) ^ (pf >> 3) ^ (pf >> 2) ^ (pf >> 1) ^ pf ^ 1) & 1;
            cout << "Mul ;" << setw(4) << i << "; " << setw(4) << j << "; " << setw(4) << i * j << "; " << ((k & 0x10) ? "1" : "0") << "; " << ((k & 0x04) ? "1" : "0") << "; " << pf <<"\n";

        }
    }
        
    for (i = min_i; i < max_i; i++) {
        for (j = min_j; j < max_j; j++) {
            if (j == 0) continue;
            __asm {
                mov ax, i
                mov cx, j
                cwd
                idiv cx
                pushf                
                pop ax
                mov k, ax
            }
            pf = i / j;  pf = ((pf >> 7) ^ (pf >> 6) ^ (pf >> 5) ^ (pf >> 4) ^ (pf >> 3) ^ (pf >> 2) ^ (pf >> 1) ^ pf ^ 1) & 1;
            std::cout << "Div ;" << setw(4) << i << "; " << setw(4) << j << "; " << setw(4) << i / j << "; " << ((k & 0x10) ? "1" : "0") << "; " << ((k & 0x04) ? "1" : "0") << "; " << pf << "\n";
        }
    }
}


      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

AF PF . ( ) .

16 . :

, :

1. Intel ( Wolfdale – «» , Sandy Bridge – «» (Nehalem )). «» AF 0, PF – ( ). «» .

   
   
   
   
   

2. AMD , «» Intel.

   
   
   
   
   

3. En las operaciones de división, todos los procesadores Intel establecen el mismo bit de paridad (pero no coincide con la paridad de los bits de los últimos bytes de la división y el resultado del módulo).

   
   
   
   
   

4. El bit AF después de la división se establece en 0 en los procesadores Intel, excepto para las familias Yonah y versiones anteriores.

   
   
   
   
   

5. AMD después de la división establece AF = 1 y PF = 0.

   
   
   
   
   

La tabla de prueba completa se puede descargar

Si alguien tiene acceso a procesadores que no han sido probados, participe.

UPD Poco a poco agrego las pruebas de procesador enviadas. Los detalles están en los comentarios.