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?