////////////////

Números de ponto flutuante são aproximados, nunca exatos. Na maioria das vezes, é bom
o suficiente. Ao usar REAL4 e
a exatidão e a precisão não são aceitáveis, então use REAL8. Mesmas regras aqui como
em C ao decidir usar float
ou double porque REAL4 é float e REAL8 é double.

DD=REAL4 =FLOAT =32=6A7

DD=DWORD=LONG INT=32

DQ=REAL8=DOUBLE=64=15A16
DW=WOED=SHORT INT=16

\\\\\\\\\\\\\\\\\\

OK, então como é um número de ponto flutuante ao usar a linguagem assembly? Em

primeiro lugar, não vamos
preocupe-se com o que realmente parece na memória!

fp1 REAL4 25.23

fp2 REAL8 2.523E1
fp3 REAL4 -25.23
fp4 REAL8 -2.523E1
fp5 REAL4 0.2523
fp6 REAL8 2.523E-1

////////////////////

Vejamos 2.523E1. Temos uma mantissa e um expoente. A mantissa é 2,523 e o expoente é

1. Eles podem
ser positivo ou negativo e em qualquer combinação! Vejamos um REAL8 em detalhes.

Existem três componentes no ponto flutuante longo:

-O bit de sinal (1 se negativo e zero se positivo. (bit 63)

-Os bits expoentes (a potência de dois!!!). (bits 52-62)
-A mantissa. (bits 0 - 51)

\\\\\\\\\\\\\\\\\\\\\

ARQUITETURA DOS REGISTRADORES

Existem oito registradores, referidos como ST(0), ST(1), ...., ST(7). ST é outra maneira de
se referir a ST(0). os registradores
são tratados como uma pilha e ST(0) é sempre o valor superior. Quando um novo valor é
colocado na pilha, torna-se

ST(0) e o antigo ST(0) torna-se ST(1), com todos os outros diminuindo um. Quando o topo
da pilha é
estourado, o antigo ST(1) torna-se ST(0) e todos os outros sobem um.

///////////////////////

Operandos para os formatos de instrução do coprocessador

O tutorial de ponto flutuante masm32 (C:/masm32/tutorial/fputute/fpuchap2.htm) nos diz:
A instrução adequada deve ser usada com o tipo de dados adequado
Essa mesma regra também se aplica ao usar a indexação indireta para valores de ponto
flutuante. Ao usar registradores de CPU como
ponteiros para dados de ponto flutuante na memória, é imperativo que o índice seja
qualificado como apontando para o
tamanho. Exemplos de uso de ponteiros para dados de ponto flutuante na memória quando
usados com as instruções FPU apropriadas são:

dword ptr [eax] ;informa o processador que EAX aponta para um valor REAL4

dword ptr [esi+12] ;ESI apontaria para um array de valores REAL4

qword ptr [edi+ebx] ;EDI ou EBX aponta para um array de valores REAL8

tbite ptr [edx] ;EDX aponta para um valor REAL10

dword ptr [ebp+8] ;codificação típica para parâmetros de procedimentos REAL4

pressionados quando codificados pelo montador

Os valores de ponto flutuante nos registros de dados da FPU também podem ser
acessados com várias instruções da FPU. Desde aqueles
são sempre valores de 80 bits, obviamente não há necessidade de especificar seu
tamanho. Como indicado no capítulo anterior, seus
modo de endereçamento é simplesmente:
ST(0), ST(1), ...., ST(7)

\\\\\\\\\\\\\\\\\\\\\\\
Grupos básicos de instruções do coprocessador
Os operandos para o processador de ponto flutuante têm os seguintes formatos possíveis:

Formato do Operando

Stack Clássico Finstruction ST, ST(1) fadd

Memory Finstruction memory ST fadd memloc
Registro Instrução ST(num), ST fadd st(5),st
Instrução ST, ST(num) fadd st,st(3)
Register pop FinstructionP ST(num), ST

Com uma exceção, se a segunda letra da instrução for um i, t trabalhando com um

operando inteiro. (A exceção é
FINIT, que inicializa a FPU).

\\\\\\\\\\\\\\\\\\\\\\

Instruções de carregamento e armazenamento de dados selecionadas

O gráfico a seguir fornece um conjunto de instruções de ponto flutuante usadas para enviar
(carregar) e inserir (armazenar) dados.

FLD, FST, FSTP Carrega e armazena números reais

FILD, FIST, FISTP Carrega e armazena números inteiros
FXCH Valores de registro Exchanges
FLDZ Empurra 0 para ST
FLD1 Empurra 1 para ST
FLDPI Empurra o valor pi para ST
FLDL2E Empurra o valor de log2e para ST
FLD2T Empurra o valor de log210 para ST
FLDG2 Empurra o valor de loge2 para ST

\\\\\\\\\\\\\\\\\\\\\\
Instruções aritméticas selecionadas
A tabela a seguir fornece um conjunto de instruções de ponto flutuante para aritmética
básica.

FADD, FADDP Adicionar/adicionar e pop

FIADD Inteiro adicionar
FSUB/FSUBP Subtrair/subtrair e pop

FSUBR/FSUBRP Subtrair/subtrair e pop com invertido operandos

FISUB Subtração inteira
FISUBR Subtração inteira com operandos invertidos

FDIV/FDIVP Divide/divide e pop

FIDIV Divide inteiro
FDIVR/FDIVRP Dividir/dividir e pop com invertido operandos
FIDIVR Divisão inteira com operandos invertidos

/////////////////
Instruções de fluxo de controle selecionadas
FCOM Comparação
FCOMP Compare e pop(Recupera o dado do topo da pilha para um registrador
especificado ou uma variável.)
FICOM Comparação inteira
FTST Integer comparar e pop
FUCOM Comparação não ordenada
FUCOMP Comparação não ordenada e pop
FXAM Definir bits de condição para valor no topo da pilha
FSTSW Armazena a palavra de status