One undocumented feature of multiplication and division on x86 processors

Starting with the 80286 processor, Intel has maintained full bottom-up compatibility in the instruction set. That is, if any of the processor instructions gives such and such a result on the 8086, then on later processors the result will be exactly the same (now we will not consider errors such as incorrect division in Pentium I).

But is it? What a question! After all, if compatibility was not preserved, then old programs could not run, and you can still feel nostalgic on any computer by running Norton Commander or Tetris. However, not everything is so simple ... Starting with the 8080, Intel processors have a flags register, the state of which is determined by the result of the last data calculation command. All flags have been described in it for a long time and their behavior is strictly fixed. Except for two 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. On divide operations, all Intel processors set the parity bit the same (but it does not match the parity of the bits of the last bytes of the division and modulo result).

   
   
   
   
   

4. AF bit after division is set to 0 in Intel processors, except for Yonah families and earlier.

   
   
   
   
   

5. AMD after division sets AF = 1 and PF = 0.

   
   
   
   
   

The complete test table can be downloaded

If anyone has access to processors that have not been tested, please take part.

UPD Little by little I add the submitted processor tests. Details are in the comments.