Une fonctionnalité non documentée de multiplication et de division sur les processeurs x86

À partir du processeur 80286, Intel a maintenu une compatibilité ascendante complète dans le jeu d'instructions. Autrement dit, si certaines des instructions du processeur donnent tel ou tel résultat sur 8086, alors le résultat sera exactement le même sur les processeurs ultérieurs (maintenant nous ne considérerons pas les erreurs telles que la division incorrecte dans Pentium I).

Mais est-ce vrai? Quelle question! Après tout, si la compatibilité n'était pas préservée, les anciens programmes ne pourraient pas fonctionner et vous pouvez toujours vous sentir nostalgique sur n'importe quel ordinateur en exécutant Norton Commander ou Tetris. Cependant, tout n'est pas si simple ... A partir du 8080, les processeurs Intel ont un registre de drapeau dont l'état est déterminé par le résultat de la dernière commande de calcul de données. Tous les drapeaux y sont décrits depuis longtemps et leur comportement est strictement fixé. Sauf pour deux exceptions.

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. Lors des opérations de division, tous les processeurs Intel définissent le bit de parité de la même manière (mais il ne correspond pas à la parité des bits des derniers octets de la division et du résultat modulo).

   
   
   
   
   

4. Le bit AF après la division est défini sur 0 dans les processeurs Intel, sauf pour les familles Yonah et antérieures.

   
   
   
   
   

5. AMD après la division définit AF = 1 et PF = 0.

   
   
   
   
   

Le tableau de test complet peut être téléchargé

Si quelqu'un a accès à des processeurs qui n'ont pas été testés, veuillez participer.

UPD J'ajoute petit à petit les tests de processeurs soumis. Les détails sont dans les commentaires.