A precisão de números duplicados é apenas um caso especial de precisão arbitrária . No nível da linguagem assembly, como isso é implementado depende do ISA. (Mesmo que você tenha perguntado especificamente sobre o x86, eu fornecerei algumas informações adicionais.)
Para adição e subtração, muitos ISAs (por exemplo, ARM, Power, x86) fornecem um bit carry (emprestar para subtração) e especial adicionar com carry e subtrair com instruções de empréstimo.
ADD r1, r2, r3; // r1 = r2 + r3, set or clear carry bit
ADDC r4, r5, r6; // r4 = r5 + r6 + carry bit (also sets/clears carry)
Alguns ISAs (por exemplo, Alpha [que sempre foi 64 bits], MIPS) não fornecem um carry e instruções especiais de adição / subtração. Eles podem usar uma instrução set-on-less-than (configurando um registrador para zero se não menor que e para um se menor que) para testar se o resultado é menor que um dos operandos (o que determina se o resultado gerou um carry ).
ADD r1, r2, r3; // r1 = r2 + r3
ADD r4, r5, r6; // r4 = r5 + r6
SLT r7, r1, r2; // r7 = (r1 < r2)? 1 : 0 (determining carry)
ADD r4, r4, r7; // r4 = r4 + r7 (adding in carry)
(Os projetistas do ISA que optaram por não fornecer carry não o fizeram porque a operação de precisão múltipla não é comum, um bit carry único introduz uma dependência de dados que dificulta a operação superescalar e bits especiais tornam a renomeação de registradores fora de ordem execução mais complexa.)
Para multiplicação, a precisão duplicada pode não ser suficiente para tornar os algoritmos sofisticados mais eficientes, de modo que o método simples de gerar produtos parciais e somar os resultados pode ser preferido. Isso usa a fórmula (onde a e c são a metade superior do valor de precisão duplicada):
(a + b) * (c + d) = a*c + a*d + b*c + b*d.
(Por simplicidade, o seguinte assume um resultado de precisão dobrada, com qualquer excesso sendo ignorado. Isso significa que o termo produto a * c é completamente ignorado.)
Para um ISA (por exemplo, MIPS, x86) que fornece um resultado alto e baixo de uma única multiplicação, a operação é razoavelmente direta. O seguinte é uma aproximação aproximada para x86 (não estou familiarizado com os detalhes):
MUL r2:r0, r3, r7; // multiply a*d
MOV r1, r0; // preserve low result of a*d
MUL r2:r0, r5, r6; // multiply b*c
MOV [temp], R0; // preserve low result on stack at temp
MUL r2:r0, r5, r7; // multiply b*d
ADD r2, r1; // add high b*d and low b*c for part of
// higher result
ADD r2, [temp]; // add partial higher result and low a*d
// doubled precision product is now in r2:r0
Para um ISA (por exemplo, Alpha) que fornece instruções de multiplicação separada para alto resultado e múltipla para baixo resultado (a multiplicação naturalmente produz um valor de precisão duplicada), essa operação é um pouco semelhante:
// a*c result is beyond doubled precision range
MULL r16, r1, r4; // low multiply result (a*d)
// high a*d result is beyond doubled precision range
MULL r17, r2, r3; // low multiply result (b*c)
// high b*c result is beyond doubled precision range
MULL r18, r2, r4; // low multiply result (b*d)
MULH r19, r2, r4; // high multiply result (b*d)
ADD r20, r19, r17; // sum high (b*d) and low (b*c)
// for part of higher result
ADD r20, r20, r16; // sum partial result and low (a*d)
// double precision result is in r20:r16
(Algumas ISAs não fornecem um meio de obter o maior resultado de uma multiplicação. Para tais ISAs, os operandos podem ser divididos em unidades de metade do tamanho e uma multiplicação de precisão quádrupla executada, embora haja provavelmente um algoritmo mais sofisticado. ISAs com instruções de multiplicação de adição podem, obviamente, fundir as adições e dois dos multiplos em multiplicações.)
O código de pseudo-montagem acima supõe que o estouro não é uma preocupação (e não é otimizado para desempenho). Uma implementação real lidaria com isso adequadamente.
A Biblioteca Aritmética de Precisão Múltipla GNU , uma biblioteca de código aberto para aritmética de precisão arbitrária, forneceria detalhes de uma implementação do mundo real. / p>
Limitações do espaço de endereço
O motivo pelo qual um processador de 32 bits pode (em um sentido simples) usar apenas 4 GiB de memória é que ele usa ponteiros / endereços de 32 bits e usa o endereçamento de bytes (então 2 32 endereços) Estão disponíveis). Tradicionalmente, mesmo com sistemas de memória virtual, o suporte a um espaço de endereço físico (que inclui endereços de E / S mapeados por memória, a propósito) maior que 4 GiB era considerado desnecessário. (Um espaço de endereço físico de 4 GiB também é conveniente para entradas de tabela de página de 32 bits, permitindo o uso de 10 bits para definir validade, permissões e outros metadados ao usar 4 páginas KiB. Usar entradas de tabela de página de 64 bits tenderia a usar excesso de memória para sistemas pequenos e sistemas iniciais de 32 bits eram pequenos.)
Para estender a vida útil dos ISAs de 32 bits, alguns ISAs (por exemplo, ARM, x86) adicionaram Extensões de Endereço Físico, que usam uma entrada de tabela de página de 64 bits para permitir um endereço físico maior. Esta solução alternativa é inábil, especialmente para o sistema operacional (que deve gerenciar toda a memória física).
Alguns ISAs (como o HP PA-RISC) forneceram um sistema de segmentação que permitia que os programas no nível do usuário tratassem de um espaço de endereçamento maior anexando registradores de segmento de finalidade especial ao topo do endereço. (O Power [PC] também usa segmentos, mas os valores não podem ser modificados por software sem privilégios [por exemplo, aplicativo].)
(Em teoria, um ISA poderia usar um par de registradores para expandir os recursos de endereçamento de memória, como alguns processadores de 8 bits. Entretanto, nesse ponto, mover para um ISA de 64 bits geralmente faz mais sentido.)