Um recurso não documentado de multiplicação e divisão em processadores x86

Começando com o processador 80286, a Intel manteve compatibilidade total de baixo para cima no conjunto de instruções. Ou seja, se algumas das instruções do processador fornecem tal e tal resultado no 8086, o resultado será exatamente o mesmo nos processadores posteriores (agora não consideraremos erros como divisão incorreta no Pentium I).

Mas é isso? Que pergunta! Afinal, se a compatibilidade não fosse preservada, os programas antigos não poderiam ser executados e você ainda pode sentir saudades de qualquer computador executando o Norton Commander ou Tetris. Porém, nem tudo é tão simples ... A partir do 8080, os processadores Intel possuem um registrador de flag, cujo estado é determinado pelo resultado do último comando de cálculo de dados. Todos os sinalizadores foram descritos nele por um longo tempo e seu comportamento é estritamente fixo. Exceto por duas exceções.

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. Nas operações de divisão, todos os processadores Intel definem o bit de paridade da mesma forma (mas não corresponde à paridade dos bits dos últimos bytes da divisão e do resultado do módulo).

   
   
   
   
   

4. O bit AF após a divisão é definido como 0 nos processadores Intel, exceto para famílias Yonah e anteriores.

   
   
   
   
   

5. A AMD após a divisão define AF = 1 e PF = 0.

   
   
   
   
   

A tabela de teste completa pode ser baixada

Se alguém tiver acesso a processadores que não foram testados, participe.

UPD Aos poucos, adiciono os testes de processador enviados. Os detalhes estão nos comentários.