Arquitetura FPU: Implementação MIPS32
Guilherme Fernandes Raphanelli
Diogo D. Fonseca dos Santos
Introdução
O suporte para operações de ponto flutuante nas diferentes arquiteturas é normalmente dado através de componentes diferentes de onde ocorrem as operações com inteiros.
Floating-Point Unit (FPU)
Co-processador 1, Floating-point accelerator (FPA).
Representação Binária
A arquitetura MIPS segue o padrão IEEE 754, o IEEE Standard for Binary Floating-Point Arithmetic.
Tipos de dados:Ponto flutuante double 64-bit (tipo D)Ponto flutuante single 32-bit (tipo S)Ponto fixo, word, 32-bit (tipo W)
Formatos de Representação
formato tipo D
formato tipo S
formato tipo W
Registradores
As CPUs MIPS possuem 32 registradores de ponto flutuante, normalmente referidos como $f0-f$31.
A convenção de uso é análoga à dos registrados de uso geral
Floating Point Control registers (FCRs). Existem 5 registradores para controle da FPU, com 32 bits cada. FIR - FP Implementation and
Revision register FEXR - FP Exceptions register FENR - FP Enables register FCSR - FP Control/Status register FCCR - FP Condition Codes
register
Temporários. ft4-ft5 $f16,$f18
Variáveis de registro.
fs0-fs5 $f20,$f22,$f24
$f26,$f28,$f30
Argumentos de funções.
fa0-fa1 $f12,$f14
Temporários. ft0-ft3 $f4,$f6
$f8,$f10
Valor retornado por funções.
fv0-fv1 $f0,$f2
UsoNomeRegistrador
Formato de Valores para FPRs
FPU não interpreta a codificação binária dos operadores de origem nem produz uma codificação binária para o resultado de cada operação. Um valor guardado em um FPR tem um dos seguintes formatos: uninterpreted (não interpretado) unknown (desconhecido) ou um dos tipos numéricos válidos: single, double ou word.
Um valor é definido como uninterpreted após ser carregado em um registrador ponto flutuante como dado binário, o que acontece usando moves a partir de inteiros ou loads. Assim que este registrador for utilizado por uma função de formato específico, o valor será definido como sendo do mesmo formato.
O formato unknown é utilizado quando uma operação de um formato utiliza um registrador de origem com um valor de formato diferente. Neste caso, tanto o valor utilizado quanto o resultado são definidos como unknown.
Instruções
• Os co-processadores, assim como a CPU, operam em dados naturalmente alinhados. A FPU possui loads e stores que usam o mesmo tipo de endereçamento registrador+offset usado pela CPU.
• As intruções podem ser separadas em 6 classes distintas: – Instruções para transferência de dados– Instruções aritméticas– Instruções de conversão– Instruções para mover valores de operando formatados– Instruções condicionais – Instruções variadas.
Exemplo de Instruções
rd = fs. Move de registrador fp para registrador inteiro. 32bits não interpretados
mfc1 rd, fs
fd = fs1 x fs2. mul.s fd, fs1, fs2
mul.d fd, fs1, fs2
fd = fs. Move entre registradores fp. mov.s fs,fd
mov.d fs,fd
*(rs+disp) = fd. Store do registrador para memória. Pseudo-instruções: s.s ou s.d.
swc1 fd, disp(rs)
fd = *(rs + disp). Load da memória para registrador. Pode-se usar as pseudo-intruções l.s fd, address (single) ou l.d(double).
lwc1 fd, disp(rs)
UsoInstrução
Exceções na FPU
• As exceções FPU são implementadas na arquitetura MIPS FPU com os campos Cause, Enable e campos de Flag do registrador Control/Status.
• 5 Tipos de Exceção:– Invalid-Operation Exception (Operação Inválida)
– Division-By-Zero Exception (Divisão por zero)– Underflow Exception– Overflow Exception – Inexact Exception.
Exercício I - Multiplicação
• Os números de ponto flutuante, segundo o padrão IEEE 754 implementado pelo MIPS32, possuem um indicador próprio de overflow, tornando desnecessária a técnica anterior.
• Diferenças para receber dados do usuário e para mostrar os números para ele.
Exercício I - Multiplicaçãola $a0, get_v1
li $v0, 4 syscall li $v0, 6 syscall
mov.d $f12, $f0
mul.s $f12, $f12, $f0 mfc1 $t0, $f12 srl $t0, $t0, 23
addi $t1, $zero, 255 and $t0, $t0, $t1
bne $t0, $t1, result
Exercício II – Visualizar Contexto
• Registradores completamente independentes do fluxo normal dos programas.
• Falta de acesso direto através do template de assembly para C.
• Utilizar registrador de uso geral.
Exercícios II – Visualizar Contexto
.datan1: .float 3.5n2: .float 23.001
l.s $f4, n1l.s $f6, n2
mul.s $f12, $f4, $f6
cvt.d.s $f22, $f12mul.d $f24, $f22, $f22mul.d $f26, $f24, $f24
mfc1 $16, $f0addi $4, $0, 16addi $5, $0, 0
jal print_register
Exercício II - Visualizar Contexto
Dúvidas?
Top Related