Organização e Projeto de Computadores - 3ª Edição - APENDICE D

Prévia do material em texto

Uma Visão Geral
das Arquiteturas RISCs
para Computadores Desktop,
Servidores e Embutidos
RISC: qualquer computador
anunciado após 1985.
Steven Przybylskic
Um projetista do MIPS de Stanford
D
D.1 Introdução D-2
D.2 Modos de endereçamento e formatos de instrução D-4
D.3 Instruções: o subconjunto do núcleo MIPS D-7
D.4 Instruções: extensões para multimídia dos RISCs desktop/servidores D-13
D.5 Instruções: extensões para processamento de sinais digitais dos RISCs
embutidos D-15
D.6 Instruções: extensões comuns ao núcleo MIPS D-15
D.7 Instruções específicas do MIPS64 D-19
D.8 Instruções específicas do Alpha D-21
D.9 Instruções específicas do SPARC v.9 D-23
D.10 Instruções específicas do PowerPC D-25
D.11 Instruções específicas do PA-RISC 2.0 D-26
D.12 Instruções específicas do ARM D-29
D.13 Instruções específicas do Thumb D-30
D.14 Instruções específicas do SuperH D-30
D.15 Instruções específicas do M32R D-31
D.16 Instruções específicas do MIPS16 D-32
D.17 Comentários finais D-34
D.18 Agradecimentos D-35
D.19 Referências D-36
D.1 Introdução
Neste apêndice, abordaremos dois grupos de arquiteturas RISCs (Reduced Instruction Set Compu-
ter). O primeiro grupo é composto pelos RISCs desktop e servidores:
� Alpha da Digital
� PA-RISC da Hewlett-Packard
� PowerPC da IBM e da Motorola
� MIPS da Silicon Graphics
� SPARC da Sun Microsystems
O segundo grupo é composto pelos RISCs embutidos:
� ARM da Advanced RISC Machines
� Thumb da Advanced RISC Machines
� SuperH da Hitachi
� M32R da Mitsubishi
� MIPS16 da Silicon Graphics
Nunca houve outra classe de computadores tão semelhantes. Essa semelhança permite a apresen-
tação de 10 arquiteturas em aproximadamente 50 páginas. Os recursos dos RISCs desktop e servido-
res são encontrados na Figura D.1.1 e dos RISCs embutidos na Figura D.1.2.
D.1 Introdução D-2
Alpha MIPS I PA-RISC 1.1 PowerPC SPARC v.8
Data do anúncio 1992 1986 1986 1993 1987
Tamanho de instrução (bits) 32 32 32 32 32
Espaço de endereçamento
(tamanho, modelo)
64 bits, contínuo 32 bits, contínuo 48 bits,
segmentado
32 bits, contínuo 32 bits, contínuo
Alinhamento de dados Alinhado Alinhado Alinhado Desalinhado Alinhado
Modos de endereçamento de
dados
1 1 5 4 2
Proteção Página Página Página Página Página
Tamanho de página mínimo 8KB 4KB 4KB 4KB 8KB
E/S Mapeada em
memória
Mapeada em
memória
Mapeada em
memória
Mapeada em
memória
Mapeada em
memória
Registradores de inteiros
(número, modelo, tamanho)
31GPR × 64 bits 31GPR × 32 bits 31GPR × 32 bits 32GPR × 32 bits 31GPR × 32 bits
Registradores de ponto
flutuante separados
31 × 32 ou
31 × 64 bits
16 × 32 ou
16 × 64 bits
56 × 32 ou
28 × 64 bits
32 × 32 ou
32 × 64 bits
32 × 32 ou
32 × 64 bits
Formato do ponto flutuante IEEE 754 simples,
duplo
IEEE 754 simples,
duplo
IEEE 754 simples,
duplo
IEEE 754 simples,
duplo
IEEE 754 simples,
duplo
FIGURA D.1.1 Resumo da primeira versão das cinco arquiteturas para desktops e servidores. Com exceção do número
de modos de endereçamento de dados e alguns detalhes de conjunto de instruções, os conjuntos de instruções de inteiros dessas arquiteturas são
muito semelhantes. Compare esta figura com a Figura D.17.1. As versões posteriores dessas arquiteturas suportam um espaço de endereçamento
contínuo de 64 bits.
ARM Thumb SuperH M32R MIPS16
Data do anúncio 1985 1995 1992 1997 1996
Tamanho de instrução (bits) 32 16 16 16/32 16/32
Espaço de endereços (tamanho, modelo) 32 bits, contínuo 32 bits, contínuo 32 bits, contínuo 32 bits, contínuo 32/64 bits, contínuo
Alinhamento de dados Alinhado Alinhado Alinhado Alinhado Alinhado
Modos de endereçamento de dados 6 6 4 3 2
Registradores de inteiros (número,
modelo, tamanho)
15GPR × 32 bits 8GPR + SP,
LR × 32 bits
16GPR × 32 bits 16GPR × 32 bits 8GPR + SP,
RA × 32/64 bits
E/S Mapeada em
memória
Mapeada em
memória
Mapeada em
memória
Mapeada em
memória
Mapeada em
memória
FIGURA D.1.2 Resumo das cinco arquiteturas para aplicações embutidas. Com exceção do número de modos de endereça-
mento de dados e alguns detalhes do conjunto de instruções, os conjuntos de instruções de inteiros dessas arquiteturas são muito semelhantes.
Compare esta figura com a Figura D.17.1.
Observe que os RISCs embutidos costumam ter 8 a 16 registradores de uso geral enquanto os
RISCs desktop/servidores possuem 32, e que a largura das instruções é de 16 a 32 bits nos RISCs em-
butidos mas sempre 32 bits nos RISCs desktop/servidores.
Embora mostrados como arquiteturas de conjunto de instruções embutidas separadas, Thumb e
MIPS16 são, na verdade, modos opcionais do ARM e MIPS chamados por instruções call. Quando
estão nesse modo, eles executam um subconjunto da arquitetura nativa usando instruções de 16 bits
de largura. Esses conjuntos de instruções de 16 bits não se destinam a ser arquiteturas completas,
mas são suficientes para codificar a maioria dos procedimentos. As duas máquinas esperam que os
procedimentos sejam homogêneos, com todas as instruções no modo de 16 bits ou de 32 bits. Os pro-
gramas consistirão em procedimentos no modo de 16 bits para densidade ou no modo de 32 bits para
desempenho.
Uma complicação dessa descrição é que alguns dos RISCs mais antigos foram estendidos ao lon-
go dos anos. Decidimos descrever a última versão das arquiteturas: MIPS64, Alpha versão 3,
PA-RISC 2.0 e SPARC versão 9 para desktop/servidores; ARM versão 4, Thumb versão 1, Hitachi
SuperH SH-3, M32R versão 1 e MIPS16 versão 1 para embutidos.
D-3 Apêndice D Uma Visão Geral das Arquiteturas RISCs para Computadores Desktop, Servidores e Embutidos ELSEVIER
As outras seções continuam da seguinte forma. Após discutirmos os modos de endereçamento e
os formatos de instrução de nossas arquiteturas RISCs, apresentaremos uma visão geral das instru-
ções em cinco etapas:
� Instruções encontradas no núcleo MIPS, definido nos Capítulos 2 e 3 do texto principal
� Extensões para multimídia dos RISCs desktop/servidores
� Extensões para processamento de sinais digitais dos RISCs embutidos
� Instruções não encontradas no núcleo MIPS mas encontradas em duas ou mais arquiteturas
� As instruções e recursos únicos de cada uma das 10 arquiteturas
Fornecemos a evolução dos conjuntos de instruções na última seção e concluímos com uma espe-
culação sobre os caminhos para o futuro dos RISCs.
D.2 Modos de endereçamento e formatos de instrução
A Figura D.2.1 mostra os modos de endereçamento de dados suportados pelas arquiteturas de desk-
top. Como todos possuem um registrador que sempre tem o valor 0 quando usado em modos de en-
dereço, o modo de endereço absoluto com faixa limitada pode ser sintetizado usando zero como a
base no endereçamento com deslocamento. (Esse registrador pode ser mudado pelas operações da
ALU no PowerPC; ele é sempre 0 nas outras máquinas.) Da mesma forma, o endereçamento indireto
por registrador é sintetizado usando endereçamento por deslocamento com um offset de 0. Os modos
de endereçamento simplificados é uma característica peculiar das arquiteturas RISCs.
A Figura D.2.2 mostra os modos de endereçamento de dados suportados pelas arquiteturas embu-
tidas. Diferente dos RISCs desktop, essas máquinas embutidas não reservam um registrador para
conter 0. Embora a maioria tenha dois a três modos de endereçamento, o ARM e o SuperH possuem
vários modos, incluindo cálculos extremamente complexos. O ARM possui um modo de endereça-
mento que pode deslocar um registrador por qualquer quantidade, adicioná-lo aos outros registrado-
res para formar o endereço e, depois, atualizar um registrador com esse novo endereço.
As referências ao código normalmente são relativas ao PC, embora o jump register indireto tam-
bém seja suportado para retorno de procedimentos, para instruções casee para chamadas de função.
Uma variação é que os endereços de desvio relativos ao PC são deslocados 2 bits à esquerda antes de
serem acrescentados ao PC para RISCs desktop, aumentando, assim, a distância do desvio. Isso fun-
ciona porque a largura de todas as instruções para os RISCs desktop é 32 bits e as instruções preci-
sam estar alinhadas nas words de 32 bits na memória. As arquiteturas embutidas com instruções de
16 bits de largura geralmente deslocam o endereço relativo ao PC de 1 por questões semelhantes.
A Figura D.2.3 mostra o formato das instruções RISCs desktop, que inclui o tamanho do endereço
nas instruções. Cada conjunto de instruções usa esses quatro formatos de instrução primários. A Fi-
gura D.2.4 mostra os seis formatos para as máquinas RISCs embutidas. O desejo de ter um tamanho
de código menor por meio de instruções de 16 bits leva a mais formatos de instrução.
D.2 Modos de endereçamento e formatos de instrução D-4
Modo de endereçamento Alpha MIPS64 PA-RISC 2.0 PowerPC SPARC v.9
Registrador + offset (deslocamento ou de base) X X X X X
Registrador + registrador (indexado) – X (FP) X (Loads) X X
Registrador + registrador escalado (escalado) – – X – –
Registrador + offset e registrador de atualização – – X X –
Registrador + registrador e registrador de atualização – – X X –
FIGURA D.2.1 Resumo dos modos de endereçamento de dados suportados pelas arquiteturas desktop. O PA-RISC também possui
versões de endereço curto dos modos de endereçamento de offset. O MIPS64 indexou o endereçamento para loads e stores de ponto flutuante.
(Esses modos de endereçamento são descritos na Figura 2.24.)
D-5 Apêndice D Uma Visão Geral das Arquiteturas RISCs para Computadores Desktop, Servidores e Embutidos ELSEVIER
Modo de endereçamento ARM v.4 Thumb SuperH M32R MIPS16
Registrador + offset (deslocamento ou baseado) X X X X X
Registrador + registrador (indexado) X X X – –
Registrador + registrador escalado (escalado) X – – – –
Registrador + offset e registrador de atualização X – – – –
Registrador + registrador e registrador de atualização X – – – –
Registrador indireto – – X X –
Auto-incremento, autodecremento X X X X –
Dados relativos ao PC X X (loads) X – X (loads)
Figura D.2.2 Resumo dos modos de endereçamento suportados pelas arquiteturas embutidas. O SuperH e o M32R pos-
suem modos de endereçamento registrador indireto e registrador + offset separados em vez de apenas colocar 0 no offset do último modo. Isso
aumenta o uso das instruções de 16 bits no M32R e fornece um conjunto de modos de endereço mais amplo para instruções de transferência de
dados no SuperH. Para obter uma faixa de endereçamento maior, o ARM e o Thumb deslocam o offset 1 ou 2 bits à esquerda se o tamanho de da-
dos for word ou halfwords. (Esses modos de endereçamento são descritos na Figura 2.24.)
FIGURA D.2.3 Formatos de instrução para arquiteturas RISC desktop/servidores. Esses quatro formatos são encontrados
em todas as cinco arquiteturas. (A notação sobrescrita nesta figura significa a largura de um campo em bits.) Embora os campos de registradores
estejam localizados em partes semelhantes da instrução, note que o destino e os dois campos de origem estão misturados. Op = o opcode princi-
pal, Opx = uma extensão de opcode, Rd = o registrador de destino, Rs1 = registrador origem 1, Rs2 = registrador origem 2 e Const = uma cons-
tante (usada como um imediato ou como um endereço). Diferente de outros RISCs, o Alpha possui um formato para imediatos nas operações
lógicas e aritméticas que é diferente do formato de transferência de dados mostrado aqui. Ele fornece um imediato de 8 bits nos bits 20 a 13 do
formato RR, com os bits 12 a 5 permanecendo como uma extensão de opcode.
Format: instruction category Alpha MIPS64 PA-RISC 2.0 PowerPC SPARC v.9
Branch: all Sign Sign Sign Sign Sign
Jump/call: all Sign — Sign Sign Sign
Register-immediate: data transfer Sign Sign Sign Sign Sign
Register-immediate: arithmetic Zero Sign Sign Sign Sign
Register-immediate: logical Zero Zero — Zero Sign
FIGURA D.2.5 Resumo da extensão de constante para RISCs de desktop. As constantes nas instruções de salto e chamada do
MIPS não estendem o sinal, pois só substituem os 28 bits inferiores do PC, deixando os 4 bits superiores inalterados. PA-RISC não possui instruções
lógicas imediatas.
D.2 Modos de endereçamento e formatos de instrução D-6
FIGURA D.2.4 Formatos de instrução para arquiteturas RISC embutidas. Esses seis formatos são encon-
trados em todas as cinco arquiteturas. A notação é a mesma da Figura D.2.3. Observe as semelhanças nos formatos branch,
jump e call, e a diferença nos formatos registrador-registrador, registrador-imediato e transferência de dados. As diferen-
ças resultam de se a arquitetura tem 8 ou 16 registradores, se é um formato de 2 ou 3 operandos e se a largura da instrução é
de 16 ou 32 bits.
Format: instruction category ARM v.4 Thumb SuperH M32R MIPS16
Branch: all Sign Sign Sign Sign Sign
Jump/call: all Sign Sign/Zero Sign Sign —
Register-immediate: data transfer Zero Zero Zero Sign Zero
Register-immediate: arithmetic Zero Zero Sign Sign Zero/Sign
Register-immediate: logical Zero — Zero Zero —
FIGURA D.2.6 Resumo da extensão de constante para RISCs embutidos As instruções de 16 bits de tamanho possuem imedia-
tos muito mais curtos do que aqueles dos RISCs de desktop, normalmente apenas de 5 a 8 bits. A maioria dos RISCs embutidos, porém, possui
um meio de obter um endereço longo para chamadas de procedimento a partir de duas meias palavras seqüenciais. As constantes nas instruções
de salto e chamada do MIPS não estendem o sinal, pois só substituem os 28 bits inferiores do PC, deixando os 4 bits superiores inalterados. Os
imediatos de 8 bits no ARM podem ser girados para a direita por um número par de bits entre 2 e 30, gerando uma grande faixa de valores imedia-
tos. Por exemplo, todas as potências de 2 são imediatos no ARM.
As Figuras D.2.5 e D.2.6 mostram as variações na forma de estender os campos de constante à lar-
gura total dos registradores. Nessa questão sutil, os RISCs são semelhantes mas não idênticos.
D.3 Instruções: o subconjunto do núcleo MIPS
As semelhanças de cada arquitetura permitem descrições simultâneas, começando com as operações
equivalentes ao núcleo MIPS.
Instruções do núcleo MIPS
Quase toda instrução encontrada no núcleo MIPS também é encontrada nas outras arquiteturas, como
mostram as Figuras D.3.1 a D.3.5. (Para consulta, as definições das instruções MIPS são encontradas
D-7 Apêndice D Uma Visão Geral das Arquiteturas RISCs para Computadores Desktop, Servidores e Embutidos ELSEVIER
Transferência de dados
(formatos de instrução) R-I R-I R-I, R-R R-I, R-R R-I, R-R
Nome da instrução Alpha MIPS64 PA-RISC 2.0 PowerPC SPARC v.9
Load byte signed LDBU; SEXTB LB LDB; EXTRW,S 31,8 LBZ; EXTSB LDSB
Load byte unsigned LDBU LBU LDB, LDBX, LDBS LBZ LDUB
Load half word signed LDWU; SEXTW LH LDH; EXTRW,S 31,16 LHA LDSH
Load half word unsigned LDWU LHU LDH, LDHX, LDHS LHZ LDUH
Load word LDLS LW LDW, LDWX, LDWS LW LD
Load SP float LDS* LWC1 FLDWX, FLDWS LFS LDF
Load DP float LDT LDC1 FLDDX, FLDDS LFD LDDF
Store byte STB SB STB, STBX, STBS STB STB
Store half word STW SH STH, STHX, STHS STH STH
Store word STL SW STW, STWX, STWS STW ST
Store SP float STS SWC1 FSTWX, FSTWS STFS STF
Store DP float STT SDC1 FSTDX, FSTDS STFD STDF
Read, write special registers MF_, MT_ MF, MT_ MFCTL, MTCTL MFSPR, MF_, MTSPR,
MT_
RD, WR, RDPR, WRPR,
LDXFSR, STXFSR
Move integer to FP register ITOFS MFC1/DMFC1 STW; FLDWX STW; LDFS ST; LDF
Move FP to integer register FTTOIS MTC1/DMTC1 FSTWX; LDW STFS; LW STF; LD
FIGURA D.3.1 Instruções de transferência de dados RISC equivalentes ao núcleo MIPS. Uma seqüência de instruções para
sintetizar uma instrução MIPS é mostrada separada por sinais de ponto-e-vírgula. Quandohá várias opções de instruções equivalentes ao núcleo
MIPS, elas são separadas por vírgulas. Para essa figura, halfword é 16 bits e word é 32 bits. Observe que, no Alpha, o LDS converte ponto flutu-
ante de precisão simples em precisão dupla e carrega o registrador de 64 bits inteiro.
na Seção 2.12 e no Guia de referência rápida no início do livro.) As instruções são listadas sob quatro
categorias: transferência de dados (Figura D.3.1); aritméticas e lógicas (Figura D.3.2); controle (Figura
D.3.3); e ponto flutuante (Figura D.3.4). Uma quinta categoria (Figura D.3.5) mostra convenções para
uso dos registradores e pseudo-instruções em cada arquitetura. Se uma instrução de núcleo MIPS exi-
gir uma curta seqüência de instruções em outras arquiteturas, essas instruções são separadas por sinais
de ponto-e-vírgula nas Figuras D.3.1 a D.3.5. (Para evitar confusão, o registrador de destino sempre
será o operando mais à esquerda neste apêndice, independente da notação normalmente utilizada com
cada arquitetura.) As Figuras D.3.6 a D.3.9 mostram a listagem equivalente para os RISCs embutidos.
Note que o ponto flutuante geralmente não é definido para os RISCs embutidos.
Lógicas/aritméticas
(formatos de instrução) R-R, R-I R-R, R-I R-R, R-I R-R, R-I R-R, R-I
Nome da instrução Alpha MIPS64 PA-RISC 2.0 PowerPC SPARC v.9
Add ADDL ADDU, ADDU ADDL, LD0, ADDI,
UADDCM
ADD, ADDI ADD
Add (trap se overflow) ADDLV ADD, ADDI ADD0, ADDI0 ADD0; MCRXR; BC ADDcc; TVS
Sub SUBL SUBU SUB, SUBI SUBF SUB
Sub (trap se overflow) SUBLV SUB SUBT0, SUBI0 SUBF/oe SUBcc; TVS
Multiply MULL MULT, MULTU SHiADD;...; (i=1,2,3) MULLW, MULLI MULX
Multiply (trap se overflow) MULLV – SHiADD0;...; – –
Divide – DIV, DIVU DS;...; DS DIVW DIVX
Divide (trap se overflow) – – – – –
And AND AND, ANDI AND AND, ANDI AND
Or BIS OR, ORI OR OR, ORI OR
Xor XOR XOR, XORI XOR XOR, XORI XOR
Load high part register LDAH LUI LDIL ADDIS SETHI (formato B)
Shift left logical SLL SLLV, SLL DEPW, Z 31-i,32-i RLWINM SLL
Shift right logical SRL SRLV, SRL EXTRW, U 31, 32-i RLWINM 32-i SRL
Shift right arithmetic SRA SRAV, SRA EXTRW, S 31, 32-i SRAW SRA
Compare CMPEQ,
CMPLT, CMPLE
SLT/U, SLTI/U COMB CMP(I)CLR SUBcc r0,...
FIGURA D.3.2 Instruções lógicas e aritméticas do RISC desktop equivalentes ao núcleo MIPS. Os traços significam que
a operação não está disponível nessa arquitetura ou não está sintetizada em poucas instruções. Essa seqüência de instruções é mostrada separada
por ponto-e-vírgulas. Se houver várias escolhas de instruções equivalentes ao núcleo MIPS, elas estão separadas por vírgulas. Note que na cate-
goria “Lógicas/aritméticas” todas as máquinas exceto SPARC usam mnemônicos de instrução separados para indicar um operando imediato; o
SPARC oferece versões imediatas dessas instruções mas usa um único mnemônico. (Naturalmente, são opcodes separados!)
Controle (formatos de
instrução) B, J/C B, J/C B, J/C B, J/C B, J/C
Nome da instrução Alpha MIPS64 PA-RISC 2.0 PowerPC SPARC v.9
Branch on integer compare B_ (<, >, <=, >=, =,
not=)
BEQ, BNE,
B_Z(<, >, <=,
>=)
COMB, COMIB BC BR_Z, BPcc (<, >, <=,
>=, =, not=)
Branch on floating-point
compare
FB_(<, >, <=, >=, =,
not=)
BC1T, BC1F FSTWX f0; LDW t;
BB t
BC FBPfcc (<, >, <=, >=,
=,...)
Jump, jump register BR, JMP J, JR BL r0, BLR r0 B, BCLR, BCCTR BA, JMPL r0,...
Call, call register BSR JAL, JALR BL, BLE BL, BLA, BCLRL,
BCCTRL
CALL, JMPL
Trap CALL_PAL GENTRAP BREAK BREAK TW, TWI Ticc, SIR
Return from interrupt CALL_PAL REI JR; ERET RFI, RFIR RFI DONE, RETRY, RETURN
FIGURA D.3.3 Instruções de controle do RISC desktop equivalentes ao núcleo MIPS. Se houver várias opções de instru-
ções equivalentes ao núcleo MIPS, elas estão separadas por vírgulas.
D.3 Instruções: o subconjunto do núcleo MIPS D-8
Ponto flutuante (formatos
de instrução) R-R R-R R-R R-R R-R
Nome da instrução Alpha MIPS64 PA-RISC 2.0 PowerPC SPARC v.9
Add single, double ADDS, ADDT ADD.S, ADD.D FADD FADD/dbl FADDS, FADD FADDS, FADDD
Subtract single, double SUBS, SUBT SUB.S, SUB.D FSUB FSUB/dbl FSUBS, FSUB FSUBS, FSUBD
Multiply single, double MULS, MULT MUL.S, MUL.D FMPY FMPY/dbl FMULS, FMUL FMULS, FMULD
Divide single, double DIVS, DIVT DIV.S, DIV.D FDIV, FDIV/dbl FDIVS, FDIV FDIVS, FDIVD
Compare CMPT_ (=, <, <=, UN) C_.S, C_.D (<, >,
<=, >=, =,...)
FCMP, FCMP/dbl(<, =, >) FCMP FCMPS, FCMPD
Move R-R ADDT, Fd, F31, Fs MOV.S, MOV.D FCPY FMV FMOVS/D/Q
Convert (single, double,
integer) to (single, double,
integer)
CVTST, CVTTS, CVTTQ,
CVTQS, CVTQT
CVT.S.D, CVT.D.S,
CVT.S.W, CVT.D.W,
CVT.W.S, CVT.W.D
FCNVFF,s,d FCNVFF,d,s
FCNVXF,s,s FCNVXF,d,d
FCNVFX,s,s FCNVFX,d,s
–, FRSP, –,
FCTIW,–, –
FSTOD, FDTOS,
FSTOI, FDTOI,
FITOS, FITOD
FIGURA D.3.4 Instruções de ponto flutuante do RISC desktop equivalentes ao núcleo MIPS. Os traços significam que a
operação não está disponível nessa arquitetura ou não está sintetizada em poucas instruções. Se houver várias escolhas de instruções equivalen-
tes ao núcleo MIPS, elas estão separadas por vírgulas.
Convenções Alpha MIPS64 PA-RISC 2.0 PowerPC SPARC v.9
Registrador com valor 0 r31 (origem) r0 r0 r0 (endereçamento) r0
Registrador de endereço de retorno (qualquer) r31 r2, r31 link (especial) r31
No-op LDQ_U r31,... SLL r0, r0, r0 OR r0, r0, r0 ORI r0, r0, #0 SETHI r0, 0
Mover inteiro R-R BIS..., r31,... ADD..., r0,... OR..., r0,... OR rx, ry, ry OR..., r0,...
Ordem dos operandos OP Rs1, Rs2, Rd OP Rd, Rs1, Rs2 OP Rs1, Rs2, Rd OP Rd, Rs1, Rs2 OP Rs1, Rs2, Rd
FIGURA D.3.5 Convenções das arquiteturas RISCs desktop equivalentes ao núcleo MIPS.
Nome da instrução ARM v.4 Thumb SuperH M32R MIPS16
Transferência de dados (formatos de instrução) DT DT DT DT DT
Load byte signed LDRSB LDRSB MOV.B LDB LB
Load byte unsigned LDRB LDRB MOV.B; EXTU.B LDUB LBU
Load half word signed LDRSH LDRSH MOV.W LDH LH
Load half word unsigned LDRH LDRH MOV.W; EXTU.W LDUH LHU
Load word LDR LDR MOV.L LD LW
Store byte STRB STRB MOV.B STB SB
Store half word STRH STRH MOV.W STH SH
Store word STR STR MOV.L ST SW
Read, write special registers MRS, MSR –1 LDC, STC MVFC, MVTC MOVE
FIGURA D.3.6 Instruções de transferência de dados dos RISCs embutidos equivalentes ao núcleo MIPS. Uma seqüên-
cia de instruções para sintetizar uma instrução MIPS é mostrada separada por ponto-e-vírgulas. Observe que o ponto flutuante geralmente não é
definido para os RISCs embutidos. Thumb e MIPS16 são apenas subconjuntos de instrução de 16 bits das arquiteturas ARM e MIPS; portanto, as
máquinas podem mudar de modo e executar o conjunto de instruções completo. Usamos –-1 para mostrar seqüências disponíveis no modo de 32
bits mas não no modo de 16 bits no Thumb ou MIPS16.
D-9 Apêndice D Uma Visão Geral das Arquiteturas RISCs para Computadores Desktop, Servidores e Embutidos ELSEVIER
Lógico/aritmético (formatos
de instrução) R-R, R-I R-R, R-I R-R, R-I R-R, R-I R-R, R-I
Nome da instrução ARM v.4 Thumb SuperH M32R MIPS16
Add ADD ADD ADD ADD, ADDI, ADD3 ADDU, ADDIU
Add (trap if overflow) ADDS; SWIVS ADD; BVC .+4;
SWI
ADDV ADDV, ADDV3 –1
Subtract SUB SUB SUB SUB SUBU
Subtract (trap if overflow) SUBS; SWIVS SUB; BVC .+1;
SWI
SUBV SUBV –1
Multiply MUL MUL MUL MUL MULT, MULTU
Multiply (trap if overflow) –
Divide – – DIV1, DIVoS, DIVoU DIV, DIVU DIV, DIVU
Divide (trap if overflow) – – –
And AND AND AND AND, AND3 AND
Or ORR ORR OR OR, OR3 OR
Xor EOR EOR XOR XOR, XOR3 XOR
Load high part register – – SETH –1
Shift left logical LSL3 LSL2 SHLL, SHLLn SLL, SLLI, SLL3 SLLV, SLL
Shift right logical LSR3 LSR2 SHRL, SHRLn SRL, SRLI, SRL3 SRLV, SRL
Shift right arithmetic ASR3 ASR2 SHRA, SHAD SRA, SRAI, SRA3 SRAV, SRA
Compare CMP,CMN,
TST,TEQ
CMP, CMN, TST CMP/cond, TST CMP/I, CMPU/I CMP/I2, SLT/I, SLT/IU
FIGURA D.3.7 Instruções lógicas e aritméticas dos RISCs embutidosequivalentes ao núcleo MIPS. Os traços significam
que a operação não está disponível nessa arquitetura ou não está sintetizada em poucas instruções. Essa seqüência de instruções é mostrada sepa-
rada por ponto-e-vírgulas. Se houver várias escolhas de instruções equivalentes ao núcleo MIPS, elas estão separadas por vírgulas. Thumb e
MIPS16 são apenas subconjuntos de instrução de 16 bits das arquiteturas ARM e MIPS; portanto, as máquinas podem mudar de modo e executar
o conjunto de instruções completo. Usamos –1 para mostrar seqüências disponíveis no modo de 32 bits mas não no modo de 16 bits no Thumb ou
MIPS16. O 2 sobrescrito mostra novas instruções encontradas apenas no modo de 16 bits do Thumb ou MIPS16, como CMP/I2. O ARM inclui
deslocamentos como parte de cada instrução de operação de dados; portanto, os deslocamentos com 3 sobrescrito são apenas uma variação de
uma instrução move, como LSR3.
Controle (formatos de instrução) B, J, C B, J, C B, J, C B, J, C B, J, C
Nome de instrução ARM v.4 Thumb SuperH M32R MIPS16
Branch on integer compare B/cond B/cond BF, BT BEQ, BNE, BC,BNC, B__Z BEQZ2, BNEZ2, BTEQZ2, BTNEZ2
Jump, jump register MOV pc,ri MOV pc,ri BRA, JMP BRA, JMP B2, JR
Call, call register BL BL BSR, JSR BL, JL JAL, JALR, JALX2
Trap SWI SWI TRAPA TRAP BREAK
Return from interrupt MOVS pc, r14 –1 RTS RTE –1
FIGURA D.3.8 Instruções de controle dos RISCs embutidos equivalentes ao núcleo MIPS. Thumb e MIPS16 são apenas
subconjuntos de instrução de 16 bits das arquiteturas ARM e MIPS; portanto, as máquinas podem mudar de modo e executar o conjunto de ins-
truções completo. Usamos –1 para mostrar seqüências disponíveis no modo de 32 bits mas não no modo de 16 bits no Thumb ou MIPS16. O 2 so-
brescrito mostra novas instruções encontradas apenas no modo de 16 bits do Thumb ou MIPS16, como BTEQZ2.
Convenções ARM v.4 Thumb SuperH M32R MIPS16
Registrador de endereço de retorno R14 R14 PR (special) R14 RA (special)
No-op MOV r0,r0 MOV r0,r0 NOP NOP SLL r0, r0
Operandos, ordem OP Rd, Rs1, Rs2 OP Rd, Rs1 OP Rs1, Rd OP Rd, Rs1 OP Rd, Rs1, Rs2
FIGURA D.3.9 Convenções das instruções para RISCs embutidos equivalentes ao núcleo MIPS.
D.3 Instruções: o subconjunto do núcleo MIPS D-10
Toda arquitetura precisa ter um esquema para comparação e desvio condicional, mas, apesar de
todas as semelhanças, cada uma dessas arquiteturas encontrou uma maneira diferente de realizar a
operação.
Comparação e desvio condicional
O SPARC usa os quatro bits do código de condição tradicionais armazenados na word de status do
programa: negative, zero, carry e overflow. Eles podem ser ativados por qualquer instrução lógica ou
aritmética; diferente das arquiteturas anteriores, essa ativação é opcional em cada instrução. Uma
opção explícita causa menos problemas na implementação em pipeline. Embora os códigos de con-
dição possam ser definidos como um efeito colateral de uma operação, comparações explícitas são
sintetizadas com uma subtração usando r0 como o destino. Os desvios condicionais do SPARC tes-
tam códigos de condição para determinar todas as relações com ou sem sinal possíveis. O ponto flu-
tuante usa códigos de condição separados para codificar as condições IEEE 754, exigindo uma ins-
trução de comparação em ponto flutuante. A versão 9 expandiu os desvios do SPARC de quatro ma-
neiras: um conjunto separado de códigos de condição para operações de 64 bits; um branch que testa
o conteúdo de um registrador e desvia se o valor é =, not=, <, <=, >= ou <= 0 (veja o MIPS a seguir);
mais três conjuntos de códigos de condição de ponto flutuante; e instruções branch que codificam
previsão de desvios estática.
O PowerPC também usa quatro códigos de condição: less than, greater than, equal e sumary
overflow, mas possui oito cópias deles. Essa redundância permite que as instruções do PowerPC
usem diferentes códigos de condição sem entrarem em conflito, dando essencialmente ao PowerPC
oito registradores extras de 4 bits. Qualquer um desses oito códigos de condição pode ser o destino
de uma instrução de comparação, e qualquer um pode ser a origem de um desvio condicional. As ins-
truções de inteiros possuem um bit de opção que se comporta como se a operação de inteiro fosse se-
guida de uma comparação com zero que ativa o primeiro “registrador” de condição. O PowerPC
também permite que o segundo “registrador” seja ativado opcionalmente por instruções de ponto
flutuante. O PowerPC fornece operações lógicas entre estes oito registradores de código de condição
de 4 bits (CRAND, CROR, CRXOR, CRNAND, CRNOR, CREQV), permitindo que condições mais complexas se-
jam testadas por um único desvio.
O MIPS usa o conteúdo dos registradores para avaliar desvios condicionais. Quaisquer dois regis-
tradores podem ser comparados por igualdade (BEQ) ou por desigualdade (BNE) e, então, o desvio é to-
mado se a condição for satisfeita. As instruções set-on-less-than (SLT, SLTI, SLTU, SLTIU) comparam
dois operandos e, depois, colocam o registrador destino em 1 se menor e em 0 caso contrário. Essas
instruções são suficientes para sintetizar o conjunto completo de relações. Devido à popularidade
das comparações com 0, o MIPS inclui instruções compare-and-branch especiais para todas as com-
parações: maior que ou igual a zero (BGEZ), maior que zero (BGTZ), menor que ou igual a zero (BLEZ) e
menor que zero (BLTZ). É claro que igual e não igual a zero podem ser sintetizados usando r0 com BEQ
e BNE. Assim como o SPARC, o MIPS I usa um código de condição para ponto flutuante com instru-
ções de comparação e desvios de ponto flutuante separados; o MIPS IV expandiu isso para oito códi-
gos de condição de ponto flutuante, com as instruções de comparação e desvio de ponto flutuante es-
pecificando a condição a definir ou testar.
As comparações do Alpha (CMPEQ, CMPLT, CMPLE, CMPULT, CMPULE) testam dois registradores e colo-
cam um terceiro em 1 se a condição é satisfeita e em 0 caso contrário. As instruções de desvio com-
param um registrador com 0 (BEQ, BGE, BGT, BLE, BLT, BNE) ou seu bit menos significativo com 0 (BLBC,
BLBS) e, depois, desvia se a condição é satisfeita.
O PA-RISC possui muitas opções de branch, que veremos na Seção D.8. A mais simples delas é
uma instrução compare e branch (COMB) que compara dois registradores, desvia dependendo das rela-
ções padrão e, depois, testa o bit menos significativo do resultado da comparação.
D-11 Apêndice D Uma Visão Geral das Arquiteturas RISCs para Computadores Desktop, Servidores e Embutidos ELSEVIER
O ARM é semelhante ao SPARC, em que fornece quatro códigos de condição tradicionais defini-
dos opcionalmente. CMP subtrai um operando do outro e a diferença define os códigos de condição.
Compare negative (CMN) soma um operando a dois operandos para ativar todos os códigos de condi-
ção exceto overflow, enquanto TEQ usa OR exclusivo para ativar os três primeiros códigos de condi-
ção. Como o SPARC, a versão condicional da instrução branch do ARM testa códigos de condição
para determinar todas as relações com e sem sinal possíveis. Como veremos na Seção D.9, uma ca-
racterística incomum do ARM é que toda instrução tem a opção de ser executada condicionalmente
dependendo dos códigos de condição. (Isso representa semelhanças com a opção de anulação do
PA-RISC, vista na Seção D.8.)
Não surpreendentemente, o Thumbs segue o ARM. As diferenças são que a ativação de códigos
de condição não é opcional, a instrução TEQ é descartada e não há qualquer execução condicional de
instruções.
O Hitachi SuperH usa uma condição de bit T definida por instruções de comparação. Duas instru-
ções de desvio decidem desviar se o bit T é 1 (BT) ou o bit T é 0 (BF). Os dois tipos de desvios permi-
tem menos instruções de comparação.
O Mitsubishi M32R também oferece um único bit de código de condição (C) usado para compa-
rações com e sem sinal (CMP, CMPI, CMPU, CMPUI) para ver se um registrador é menorque o outro ou
não, semelhante às instruções set-on-less-than do MIPS. Duas instruções de desvio testam se o bit
C é 1 ou 0: BC e BNC. O M32R também inclui instruções para desviar na igualdade ou desigualdade
dos registradores (BEQ e BNE) e todas as relações de um registrador com 0 (BGEZ, BGTZ, BLEZ, BLTZ,
BEQZ, BNEZ). Diferente de BC e BNC, essas últimas instruções são todas de 32 bits de largura.
O MIPS16 mantém instruções set-on-less-than (SLT, SLTI, SLTU, SLTIU), mas, em vez de colocar o
resultado em um dos oito registradores, ele é colocado em um registrador especial chamado T. O
MIPS16 é sempre implementado em máquinas que também possuem as instruções e registradores
MIPS de 32 bits completos; portanto, o registrador T é, na verdade, o registrador 24 na arquitetura
MIPS completa. As instruções de desvio MIPS16 testam se um registrador é ou não igual a zero
(BEQZ e BNEZ). Também há instruções que desviam se o registrador T for ou não igual a zero (BTEQZ e
BTNEZ). Para testar se dois registradores são iguais, o MIPS acrescentou instruções de comparação
(CMP, CMPI) que calculam o OR exclusivo de dois registradores e colocam o resultado no registrador
T. Compare foi incluído porque o MIPS16 não tinha instruções para comparar e desviar se os regis-
tradores são iguais ou não (BEQ e BNE).
As Figuras D.3.10 e D.3.11 resumem os esquemas usados para desvios condicionais.
Alpha MIPS64 PA-RISC 2.0 PowerPC SPARC v.9
Número de bits do código
de condição (inteiro e FP)
0 8 FP 8 FP 8 × 4 ambos 2 × 4 inteiro, 4 × 2 FP
Instruções de
comparação básicas
(inteiro e FP)
1 inteiro, 1 FP 1 inteiro, 1 FP 4 inteiro, 2 FP 4 inteiro, 2 FP 1 FP
Instruções de desvio
básicas (inteiro e FP)
1 2 inteiro, 1 FP 7 inteiro 1 both 3 inteiro, 1 FP
Comparação de
registrador com
registrador/const e
desvio
– =, not= =, not=, <, <=, >, >=,
even, odd
– –
Comparação de
registrador com zero e
desvio
=, not=, <, <=, >, >=,
even, odd
=, not=, <, <=, >, >= =, not=, <, <=, >, >=,
even, odd
– =, not=, <, <=, >, >=
FIGURA D.3.10 Resumo dos cinco métodos do RISC desktop para desvios condicionais. O desvio de ponto flutuante no
PA-RISC é realizado copiando o registrador de status FP em um registrador de inteiros e, depois, usando a instrução branch on bit para testar o bit
de comparação FP. O compare de inteiros no SPARC é sintetizado com uma instrução aritmética que ativa os códigos de condição usando r0
como o destino.
D.3 Instruções: o subconjunto do núcleo MIPS D-12
ARM v.4 Thumb SuperH M32R MIPS16
Número de bits do código de condição 4 4 1 1 1
Instruções de comparação básicas 4 3 2 2 2
Instruções de desvio básicas 1 1 2 3 2
Comparação de registrador com
registrador/const e desvio
– – =, >, >= =, not= –
Comparação de registrador com zero e desvio – – =, >, >= =, not=, <, <=, >, >= =, not=
FIGURA D.3.11 Resumo dos cinco métodos dos RISCs embutidos para desvios condicionais.
D.4 Instruções: extensões para multimídia dos RISCs
desktop/servidores
Como todo microprocessador de desktop por definição possui seus próprios monitores gráficos, à
medida que a disponibilidade de transistores aumentou , foi inevitável acrescentar suporte para ope-
rações gráficas. Muitos sistemas gráficos usam 8 bits para representar cada uma das três cores primá-
rias mais 8 bits para o local de um pixel.
A inclusão de alto-falantes e microfones para teleconferência e jogos também sugerem suporte a
som. As amostras de áudio precisam de mais de 8 bits de precisão, mas 16 bits são suficientes.
Cada microprocessador possui suporte especial para que os bytes e halfwords ocupem menos es-
paço quando armazenados na memória, mas, devido à pouca freqüência de operações aritméticas
nesses tamanhos de dados em programas de inteiros típicos, há pouco suporte além das transferên-
cias de dados. Os arquitetos do Intel i860, que foi justificado como um acelerador gráfico dentro da
empresa, reconheceram que muitas aplicações gráficas e de áudio realizariam a mesma operação nos
vetores desses dados. Embora uma unidade vetorial estivesse além da disponibilidade de transistores
do i860 em 1989, particionando as cadeias de carry dentro de uma ALU de 64 bits, ela poderia reali-
zar operações simultâneas em vetores curtos de oito operandos de 8 bits, quatro operandos de 16 bits
ou dois operandos de 32 bits. O custo dessas ALUs particionadas era pequeno. As aplicações que se
prestam a esse suporte incluem MPEG (vídeo), jogos como DOOM (gráficos 3D), Adobe Photoshop
(fotografia digital) e teleconferência (processamento de áudio e imagem).
Como um vírus, ao longo do tempo, esse suporte para multimídia se espalhou por quase todos os
microprocessadores de desktop. O HP foi o primeiro RISC desktop a incluir com sucesso tal suporte.
Como veremos, esse “vírus” proliferou desigualmente. O PowerPC é o único que resiste, e existem
rumores de que ele está com “febre”.
Essas extensões foram chamadas de paralelismo de subword, vetorial ou SIMD (Single Instructi-
on, Multiple Data – instrução única, dados múltiplos) (veja o Capítulo 9). Como o marketing da Intel
usa SIMD para descrever a extensão MMX do 80x86, esse se tornou o nome popular. A Figura D.4.1
resume o suporte por arquitetura.
Na Figura D.4.1, você pode ver que, em geral, o MDMX MIPS opera em 8 bytes ou 4 halfwords
por instrução, o HP PA-RISC MAX2 opera em 4 halfwords, o SPARC VIS opera em 4 halfwords ou
2 words e o Alpha não é grande coisa. As operações do Alpha MAX são apenas versões para bytes de
compare, min, max e absolute difference, deixando a cargo do software isolar campos e realizar adi-
ções, subtrações e multiplicações paralelas em bytes e halfwords. O MIPS também incluiu opera-
ções para operar em dois operandos de ponto flutuante de 32 bits por ciclo, mas elas são consideradas
parte do MIPS V e não simplesmente extensões para multimídia (veja a Seção D.7).
Um recurso normalmente não encontrado nos microprocessadores de uso geral são as operações
de saturação. Saturação significa que, quando um cálculo ocasiona overflow, o resultado recebe o
maior número positivo ou o número mais negativo, em vez de um cálculo de módulo como na arit-
mética de complemento a dois. Comumente encontradas nos processadores de sinais digitais (veja a
próxima seção), essas operações de saturação são úteis em rotinas para filtragem.
D-13 Apêndice D Uma Visão Geral das Arquiteturas RISCs para Computadores Desktop, Servidores e Embutidos ELSEVIER
Categoria da instrução Alpha MAX MIPS MDMX PA-RISC MAX2 PowerPC SPARC VIS
Add/subtract 8B, 4H 4H 4H, 2W
Add/sub com saturação 8B, 4H 4H
Multiply 8B, 4H 4B/H
Compare 8B (>=) 8B, 4H (=,<,<=) 4H, 2W (=, not=, >,
<=)
Shift right/left 8B, 4H 4H
Shift right arithmetic 4H 4H
Multiply and add 8B, 4H
Shift and add (saturação) 4H
And/or/xor 8B, 4H, 2W 8B, 4H, 2W 8B, 4H, 2W 8B, 4H, 2W
Absolute difference 8B 8B
Max/min 8B, 4W 8B, 4H
Pack (2n bits -> n bits) 2W->2B, 4H->4B 2*2W->4H,
2*4H->8B
2*4H->8B 2W->2H, 2W->2B,
4H->4B
Unpack/merge 2B->2W, 4B->4H 2*4B->8B,
2*2H->4H
4B->4H, 2*4B->8B
Permute/shuffle 8B, 4H 4H
Conjuntos de registradores Integer Fl. Pt. + 192b Acc. Integer Fl. Pt.
FIGURA D.4.1 Resumo do suporte para multimídia dos RISCs desktop. B significa byte (8 bits), H significa halfword (16 bits)
e W significa word (32 bits). Portanto, 8B representa uma operação em 8 bytes em uma única instrução. Pack e unpack usam a notação 2*2W
para indicar 2 operandos cada um com 2 words. Observe que o MDMX possui operações de vetor/escalar, onde o escalar é especificado como um
elemento de um dos registradores vetoriais. Essa tabela é uma simplificação das arquiteturas de multimídia completas, omitindo muitos detalhes.
Por exemplo, o MIPS MDMX inclui instruções para multiplexar entre dois operandos, o HP MAX2 inclui uma instrução para calcular médias, e
o SPARC VIS inclui instruções para atribuirconstantes a registradores. Essa tabela também não inclui a operação de alinhamento de memória do
MDMX, do MAX e do VIS.
Essas máquinas usavam largamente conjuntos de registradores existentes para conter operan-
dos: registradores de inteiros para Alpha e HP PA-RISC e registradores de ponto flutuante para
MIPS e Sun.
Conseqüentemente, as transferências de dados são realizadas com instruções load e store comuns.
O MIPS também acrescentou um registrador largo de 192 bits (3*64) para agir como um acumulador
para algumas operações. Tendo 3 vezes a largura de dados nativa, ele pode ser particionado para acu-
mular 8 bytes com 24 bits por campo ou 4 halfwords com 48 bits por campo. Esse acumulador largo
pode ser usado para instruções add, subtract e multiply/add. O MIPS alega vantagens de desempe-
nho de 2 a 4 vezes para o acumulador.
Talvez, a conclusão surpreendente dessa tabela é a falta de consistência. As únicas operações en-
contradas em todos os quatro são as operações lógicas (AND, OR, XOR), que não precisam de uma
ALU particionada. Se ignorarmos o Alpha frugal, então, as únicas outras operações comuns são adi-
ções e subtrações paralelas em 4 halfwords.
Cada fabricante afirma que essas são instruções destinadas a serem usadas em bibliotecas de
sub-rotina manualmente otimizadas, uma intenção que provavelmente será seguida, já que um
compilador que funcione bem com todas as extensões de multimídia do RISC desktop seria pro-
blemático.
D.4 Instruções: extensões para multimídia dos RISCs desktop/servidores D-14
D.5 Instruções: extensões para processamento de sinais
digitais dos RISCs embutidos
Um recurso encontrado em toda arquitetura DSP (Digital Signal Processor – processador de sinais
digitais) é o suporte para multiply-accumulate de inteiros. As multiplicações costumam estar em
words mais curtas do que os inteiros regulares, como 16 bits, e o acumulador tende a estar em words
mais longas, como 64 bits. A razão para multiply-accumulate é implementar eficientemente filtros
digitais, comuns nas aplicações DSP. Como o Thumb e o MIPS16 são arquiteturas de subconjunto,
elas não fornecem esse suporte. Em vez disso, os programadores devem usar as extensões DSP ou
multimídia encontradas nas instruções de modo de 32 bits do ARM e MIPS64.
A Figura D.5.1 mostra o tamanho da multiplicação, o tamanho do acumulador e os nomes das
operações e da instrução para os RISCs embutidos. As máquinas com tamanhos de acumulador
maiores que 32 e menores que 64 bits forçarão os bits mais significativos a permanecerem como os
bits de sinal, portanto, “saturando” a soma para definir em valores de ponto flutuante máximo e míni-
mo se as operações ocasionarem overflow.
ARM v.4 Thumb SuperH M32R MIPS16
Tamanho da multiplicação 32B × 32B – 32B × 32B, 16B × 16B 32B × 16B, 16B × 16B –
Tamanho do acumulador 32B/64B – 32B/42B, 48B/64B 56B –
Nome do acumulador Qualquer GPR ou pares
de GPRs
– MACH, MACL ACC –
Operações Produto 32B/64B +
64B acumulado com
ou sem sinal
– Produto 32B + 42B/32B
acumulado (operandos na
memória); 64B produto +
64B/48B acumulado
(operandos na memória); MAC
limpo
Produto 32B/48B + 64B
acumulado, arredondar,
mover
–
Nomes das instruções
correspondentes
MLA, SMLAL, UMLAL – MAC, MACS, MAC.L, MAC.LS,
CLRMAC
MACHI/MACLO, MACWHI/
MACWLO, RAC, RACH,
MVFACHI/MVFACLO,
MVTACHI/MVTACLO
–
FIGURA D.5.1 Resumo dos cinco métodos dos RISCs embutidos para multiply-accumulate.
D.6 Instruções: extensões comuns ao núcleo MIPS
As Figuras D.6.1 a D.6.7 listam instruções não encontradas nas Figuras D.3.5 a D.3.11 nas mesmas
quatro categorias. Essas listas contêm instruções que aparecem em mais de uma das arquiteturas pa-
drão. As instruções são definidas usando a linguagem de descrição de hardware definida na Figura
D.6.8.
Embora a maioria das categorias seja auto-explicativa, algumas merecem um comentário:
� A linha “atomic swap” representa uma primitiva que pode trocar um registrador com a memó-
ria sem interrupção. Isso é útil para semáforos de sistema operacional em um uniprocessador e
também para sincronização em multiprocessadores (veja a Seção 9.3).
� As linhas “64-bit data transfer” e “operation” mostram como MIPS, PowerPC e SPARC defi-
nem o endereçamento e as operações de inteiros de 64 bits. O SPARC simplesmente define to-
das as operações de registrador e endereçamento para serem de 64 bits, incluindo apenas
instruções especiais para deslocamentos, transferências de dados e desvios de 64 bits. O MIPS
D-15 Apêndice D Uma Visão Geral das Arquiteturas RISCs para Computadores Desktop, Servidores e Embutidos ELSEVIER
inclui as mesmas instruções e ainda acrescenta instruções aritméticas de 64 bits com sinal sepa-
radas. O PowerPC inclui right shift, load, store, divide e compare de 64 bits e possui um modo
separado determinando se as instruções são interpretadas como operações de 32 ou 64 bits; as
operações de 64 bits não funcionarão em uma máquina que aceite apenas o modo de 32 bits. O
PA-RISC está expandido para endereçamento e operações de 64 bits na versão 2.0.
� A instrução “prefetch” fornece um endereço e indicação para a implementação sobre os dados.
As indicações incluem se os dados provavelmente serão lidos ou escritos logo, se provavel-
mente serão lidos ou escritos apenas uma vez ou se provavelmente serão lidos ou escritos mui-
tas vezes. Prefetch não causa exceções. O MIPS tem uma versão que adiciona dois registradores
para obter o endereço para programas de ponto flutuante, diferente de programas MIPS, não
são de ponto flutuante.
� Na linha “Endian”, “Big/Little” significa que há um bit no registrador de status do programa
que permite ao processador agir como Big Endian ou Little Endian (veja o Apêndice A). Isso
pode ser conseguido simplesmente complementando alguns dos bits menos significativos do
endereço nas instruções de transferência de dados.
� “Shared-memory synchronization” ajuda com os multiprocessadores com coerência de cache:
todos os loads e stores executados antes da instrução precisam ser completados para que os lo-
ads e stores após a instrução possam iniciar. (Veja o Capítulo 9.)
� A linha “coprocessor operations” relaciona várias categorias que permitem que o processador
seja estendido com hardware de uso especial.
Nome Definição Alpha MIPS64 PA-RISC 2.0 PowerPC SPARC v.9
Atomic swap R/M (para
locks e semáforos)
Temp<–-Rd;
Rd<–-Mem[x];
Mem[x]<–-Temp
LDL/Q_L;
STL/Q_C
LL; SC – (veja D.8) LWARX; STWCX CASA, CASX
Load 64-bit integer Rd<–-64 Mem[x] LDQ LD LDD LD LDX
Store 64-bit integer Mem[x]<–-64 Rd STQ SD STD STD STX
Load 32-bit integer
unsigned
Rd32..63<–-32 Mem[x];
Rd0..31<–-32 0
LDL; EXTLL LWU LDW LWZ LDUW
Load 32-bit integer signed Rd32..63<–-32 Mem[x]; 32
Rd0..31<–-32 Mem[x]0
LDL LW LDW; EXTRD ,S
63, 8
LWA LDSW
Prefetch Cache[x]<–-hint FETCH,
FETCH_M*
PREF, PREFX LDD, r0
LDW, r0
DCBT, DCBTST PRE-FETCH
Load coprocessor Coprocessor<–- Mem[x] – LWCi CLDWX, CLDWS – –
Store coprocessor Mem[x]<–- Coprocessor – SWCi CSTWX, CSTWS – –
Endian (Big/Little Endian?) Ambos Ambos Ambos Ambos Ambos
Cache flush (Realiza flush no bloco de
cache neste endereço)
ECB CP0op FDC, FIC DCBF FLUSH
Shared-memory
synchronization
(Todas as transferências de
dados anteriores são
completadas para que a
próxima transferência de
dados possa iniciar)
WMB SYNC SYNC SYNC MEMBAR
FIGURA D.6.1 Instruções de transferência de dados não encontradas no núcleo MIPS mas encontradas em duas ou
mais das cinco arquiteturas de desktop. O par de instruções load linked/store conditional oferece ao Alpha e ao MIPS operações atô-
micas para semáforos, permitindo que os dados sejam lidos da memória, modificados e armazenados sem a possibilidade de traps ou outras má-
quinas acessarem os dados em um multiprocessador (veja o Capítulo 9). O prefetch no Alpha para caches externas é conseguidocom FETCH e
FETCH_M; o prefetch para caches on-chip usam LD_Q A, R31 e LD_Y A. F31 é usado no Alpha 21164 (veja Bhandarkar [1995], p. 190).
D.6 Instruções: extensões comuns ao núcleo MIPS D-16
Nome Definição Alpha MIPS64 PA-RISC 2.0 PowerPC SPARC v.9
Operações aritméticas com
inteiros de 64 bits
Rd<–-64Rs1 op64 Rs2 ADD, SUB, MUL DADD, DSUB
DMULT, DDIV
ADD, SUB,
SHLADD, DS
ADD, SUBF,
MULLD, DIVD
ADD, SUB,
MULX, S/UDIVX
Operações lógicas com
inteiros de 64 bits
Rd<–-64Rs1 op64 Rs2 AND, OR, XOR AND, OR, XOR AND, OR, XOR AND, OR, XOR AND, OR, XOR
Deslocamentos com 64 bits Rd<–-64Rs1 op64 Rs2 SLL, SRA, SRL DSLL/V,
DSRA/V,
DSRL/V
DEPD,Z
EXTRD,S
EXTRD,U
SLD, SRAD,
SRLD
SLLX, SRAX,
SRLX
move Condicional if (cond) Rd<–-Rs CMOV_ MOVN/Z SUBc, n; ADD – MOVcc, MOVr
Suporte a adição de inteiros
com mais de uma word
CarryOut, Rd <–- Rs1
+ Rs2 + OldCarryOut
– ADU; SLTU;
ADDU, DADU;
SLTU; DADDU
ADDC ADDC, ADDE ADDcc
Suporte a subtração de
inteiros com mais de uma
word
CarryOut, Rd <–- Rs1
Rs2 + OldCarryOut
– SUBU; SLTU;
SUBU, DSUBU;
SLTU; DSUBU
SUBB SUBFC, SUBFE SUBcc
And not Rd <–- Rs1 & ~(Rs2) BIC – ANDCM ANDC ANDN
Or not Rd <–- Rs1 | ~(Rs2) ORNOT – – ORC ORN
Add high immediate Rd0..15<–-Rs10..15 +
(Const<<16);
– – ADDIL (R-I) ADDIS (R-I) –
Coprocessor operations (Definidas pelo
coprocessador)
– COPi COPR,i – IMPDEPi
FIGURA D.6.2 Instruções lógicas e aritméticas não encontradas no núcleo MIPS mas encontradas em duas ou mais das
cinco arquiteturas de desktop.
Nome Definição Alpha MIPS64 PA-RISC 2.0 PowerPC SPARC v.9
Delayed Branches
otimizados
(Branch nem sempre
delayed)
– BEQL, BNEL, B_ZL
(<, >, <=, >=)
COMBT, n, COMBF,
n
– BPcc, A,
FPBcc, A
traps Condicionais if (COND) {R31<–-PC;
PC <–-0..0#i}
– T_,,T_I (=, not=,
<, >, <=, >=)
SUBc, n; BREAK TW, TD, TWI,
TDI
Tcc
Num. de registradores de
controle
Misc. regs (memória
virtual, traps, ...)
6 equiv. 12 32 33 29
FIGURA D.6.3 Instruções de controle não encontradas no núcleo MIPS mas encontradas em duas ou mais das cinco ar-
quiteturas de desktop.
Nome Definição Alpha MIPS64 PA-RISC 2.0 PowerPC SPARC v.9
Multiply and add Fd <–- (Fs1 × Fs2) +
Fs3
– MADD.S/D FMPYFADD sgl/dbl FMADD/S
Multiply and sub Fd <–- ( Fs1 × Fs2) –
Fs3
– MSUB.S/D FMSUB/S
Neg mult and add Fd <–- -(( Fs1 × Fs2) +
Fs3)
– NMADD.S/D FMPYFNEG sgl/dbl FNMADD/S
Neg mult and sub Fd <–- -(( Fs1 × Fs2) –
Fs3)
– NMSUB.S/D FNMSUB/S
Raiz Quadrada Fd <–- SQRT(Fs) SQRT_ SQRT.S/D FSQRT sgl/dbl FSQRT/S FSQRTS/D
move Condicional if (cond) Fd<–-Fs FCMOV_ MOVF/T,
MOVF/T.S/D
FTESTFCPY – FMOVcc
Negar Fd <–- Fs ^
x80000000
CPYSN NEG.S/D FNEG sgl/dbl FNEG FNEGS/D/Q
Valor Absoluto Fd <–- Fs &
x7FFFFFFF
– ABS.S/D FABS/dbl FABS FABSS/D/Q
FIGURA D.6.4 Instruções de ponto flutuante não encontradas no núcleo MIPS mas encontradas em duas ou mais das
cinco arquiteturas de desktop.
D-17 Apêndice D Uma Visão Geral das Arquiteturas RISCs para Computadores Desktop, Servidores e Embutidos ELSEVIER
Nome Definição ARM v.4 Thumb SuperH M32R MIPS16
Atomic swap R/M (para semáforos) Temp<–-Rd; Rd<–-Mem[x];
Mem[x]<–-Temp
SWP, SWPB –1 (see TAS) LOCK;
UNLOCK
–1
Memory management unit Tradução de endereço
paginado
Via instruções do
coprocessador
–1 LDTLB –1
Endian (Big/Little Endian?) Ambos Ambos Ambos Big Ambos
FIGURA D.6.5 Instruções de transferência de dados não encontradas no núcleo MIPS mas encontradas em duas ou mais
das cinco arquiteturas embutidas. Usamos –1 para mostrar seqüências disponíveis no modo de 32 bits mas não no modo de 16 bits no
Thumb ou MIPS16.
Nome Definição ARM v.4 Thumb SuperH M32R MIPS16
Load immediate Rd<–-Imm MOV MOV MOV, MOVA LDI, LD24 LI
Suporte a adição de inteiros com
mais de uma word
CarryOut, Rd <–- Rd + Rs1
+ OldCarryOut
ADCS ADC ADDC ADDX –1
Suporte a subtração de inteiros
com mais de uma word
CarryOut, Rd <–- Rd – Rs1 +
OldCarryOut
SBCS SBC SUBC SUBX –1
Negar Rd <–- 0 – Rs1 NEG2 NEG NEG NEG
Not Rd <–- ~(Rs1) MVN MVN NOT NOT NOT
Move Rd <–- Rs1 MOV MOV MOV MV MOVE
Rotate right Rd <–- Rs i, >> Rd0... i–1 <–-
Rs31–i...31
ROR ROR ROTC
And not Rd <–-Rs1 & ~(Rs2) BIC BIC
FIGURA D.6.6 Instruções lógicas e aritméticas não encontradas no núcleo MIPS mas encontradas em duas ou mais das
cinco arquiteturas embutidas. Usamos –1 para mostrar seqüências disponíveis no modo de 32 bits mas não no modo de 16 bits no Thumb
ou MIPS16. O 2 sobrescrito mostra novas instruções encontradas apenas no modo de 16 bits do Thumb ou MIPS16, como NEG2.
Nome Definição ARM v.4 Thumb SuperH M32R MIPS16
Num. de registradores de controle Misc. registers 21 29 9 5 36
FIGURA D.6.7 Informações de controle nas cinco arquiteturas embutidas.
Uma diferença que precisa de uma explicação mais longa são os desvios otimizados. A Figura
D.6.9 mostra as opções. O Alpha e o PowerPC oferecem desvios que entram em operação imediata-
mente, como os desvios nas arquiteturas mais antigas. Para acelerar desvios, essas máquinas usam
previsão de desvios (veja o Capítulo 6). Todos os outros RISCs desktop oferecem delayed branches
(veja o Apêndice A). Os RISCs embutidos geralmente não suportam delayed branch, com a exceção
do SuperH, que o tem como uma opção.
Os outros RISCs desktop fornecem uma versão de delayed branch que facilita preencher o delay
slot. O branch com anulação do SPARC executa a instrução no delay slot apenas se o branch for to-
mado; caso contrário, a instrução é anulada. Isso significa que a instrução no destino do branch pode
ser seguramente copiada no delay slot, já que ela só será executada se o branch for tomado. As restri-
ções são que o destino não é outro branch e que o destino é conhecido em tempo de compilação. (O
SPARC também oferece um nondelayed jump porque um unconditional branch com o bit annul defi-
nido não executa a instrução seguinte.) As versões posteriores da arquitetura MIPS incluíram uma
instrução branch likely que também anula a instrução seguinte se o branch não for tomado. O
PA-RISC permite que quase qualquer instrução anule a próxima instrução, incluindo desvios. Sua
opção de branch com anulação executará a próxima instrução dependendo da direção do branch e se
ele é tomado (ou seja, se um branch para a frente não for tomado ou um branch para trás for tomado).
Presumivelmente, essa opção foi feita para otimizar loops, permitindo que as instruções seguintes ao
exit branch e ao looping branch sejam executadas no caso comum.
D.6 Instruções: extensões comuns ao núcleo MIPS D-18
Notação Significado Exemplo Significado
<– Transferência de dados. A extensão da
transferência é dada pela largura do destino; a
extensão é especificada quando não for clara.
Regs[R1]<–Regs[R2]; Transfere o conteúdo de R2 para R1. Os
registradores possuem uma largura fixa, de modo
que as transferências mais curtas do que o tamanho
do registrador precisam indicar quais bits são
usados.
M Array de memória acessado em bytes. O
endereço inicial para uma transferência é
indicado como o índice para o array de
memória.
Regs[R1]<–M[x]; Coloca o conteúdo do local de memória x em R1. Se
uma transferência começa em M[i] e exige 4 bytes,
os bytes transferidos são M[i], M[i+1], M[i+2] e
M[i+3].
<–n Transfere um campo de n bits, usado sempre
que a largura da transferência não é clara.
M@N1 = <–16M[x]; Transfere 16 bits iniciando no local de memória x
para o local de memória y. A largura dos dois lados
deve coincidir.
Xn O subscrito seleciona um bit. Regs[R1]0<–0; Muda o bit de sinal de R1 para 0. (Os bits são
numerados por meio de MSB iniciando em 0.)
Xm..n O subscrito seleciona um campo. Regs[R3]24..31<–M[x]; Move o conteúdo do local de memória x para o byte
menos significativo de R3.
Xn O sobrescrito duplica um campo de bit. Regs[R3]0..23<–024; Define os três bytesmais significativos de R3 como 0.
## Concatena dois campos. Regs[R3]<–240## M[x];
F2##F3<–64M[x];
Move o conteúdo do local x para o byte menos
significativo de R3; limpa os três bytes mais
significativos. Move 64 bits da memória iniciando no
local x; os primeiros 32 bits vão para F2, os
próximos 32 bits para F3.
*, & Segue um ponteiro; obtém o endereço de uma
variável.
p*<–&x; Atribui o endereço da variável x ao objeto apontado
por p.
<<, >> Shifts lógicos C (esquerda, direita). Regs[R1] << 5 Desloca R1 5 bits para a esquerda.
==, !=, >,
<, >=, <=
Operadores relacionais C; equal, not equal,
greater, less, greater or equal, less or equal.
(Regs[R1]== Regs[R2]) &
(Regs[R3]!=Regs[R4])
Verdadeiro se o conteúdo de R1 é igual ao conteúdo de
R2 e o conteúdo de R3 não é igual ao conteúdo de R4.
&, |, ^, ! Operações lógicas bit-a-bit C: and, or, or
exclusivo e complemento
(Regs[R1] & (Regs[R2]|
Regs[R3]))
AND bit-a-bit de R1 e OR bit-a-bit de R2 e R3.
FIGURA D.6.8 Notação de descrição de hardware (e alguns operadores C padrão).
Branch (simples) Delayed Branch Delayed Branch com anulação
Encontrado nas
arquiteturas
Alpha, PowerPC, ARM, Thumb,
SuperH, M32R, MIPS 16
MIPS64, PA-RISC,
SPARC, SuperH
MIPS64, SPARC PA-RISC
Executado após a instrução Apenas se o desvio não é
tomado
Sempre Apenas se o desvio é
tomado
Apenas se um desvio para a
frente não for tomado ou um
desvio para trás for tomado
FIGURA D.6.9 Quando a instrução seguindo o branch é executada para três tipos de desvios.
Agora que abordamos as semelhanças, iremos focalizar os recursos peculiares de cada arquitetu-
ra. Primeiro, examinaremos os RISCs desktop/servidores, ordenando-os pela extensão da descrição
dos recursos únicos da mais curta para a mais longa e, depois, os RISCs embutidos.
D.7 Instruções específicas do MIPS64
O MIPS atravessou cinco gerações de conjuntos de instruções, e essa evolução geralmente acrescen-
tou recursos encontrados em outras arquiteturas. Aqui estão os recursos peculiares que se destacam
no MIPS, sendo que os primeiros eram encontrados no conjunto de instruções original.
D-19 Apêndice D Uma Visão Geral das Arquiteturas RISCs para Computadores Desktop, Servidores e Embutidos ELSEVIER
Transferências de dados não alinhados
O MIPS possui instruções especiais para tratar words desalinhadas na memória. Um evento raro na
maioria dos programas, ele é incluído para suportar aplicações de minicomputador de 16 bits e para
realizar memcpy e strcpy mais rapidamente. Embora a maioria dos RISCs gere uma trap se você ten-
tar carregar uma word ou armazenar uma word em um endereço desalinhado, em todas as arquitetu-
ras, as words desalinhadas poderão ser acessadas sem traps usando quatro instruções load byte e, de-
pois, montando o resultado usando deslocamentos e Ors lógicos. As instruções load word left e load
word right do MIPS (LWL, LWR, SWL, SWR) permitem que isso seja feito em apenas duas instruções: LWL
carrega a parte esquerda do registrador e LWR carrega a parte direita do registrador. SWL e SWR realizam
os stores correspondentes. A Figura D.7.1 mostra como elas funcionam. Também existem versões
de 64 bits dessas instruções.
Outras instruções
A seguir está uma lista dos outros detalhes específicos da arquitetura MIPS64:
� NOR – Esta instrução lógica calcula ~ (Rs1 | Rs2).
� Quantidade de deslocamento constante – Deslocamentos não variáveis usam o campo constant
de 5 bits mostrado no formato registrador-registrador na Figura D.2.3.
D.7 Instruções específicas do MIPS64 D-20
Figura D.7.1 As instruções MIPS para leituras de words não alinhadas. Essa figura considera a opera-
ção no modo Big Endian. O caso 1 primeiro carrega os 3 bytes 101, 102 e 103 na esquerda de R2, deixando o byte menos
significativo inalterado. O LWR seguinte simplesmente carrega o byte 104 no byte menos significativo de R2, deixando
os outros bytes do registrador inalterados usando LWL. O caso 2 primeiro carrega o byte 203 no byte mais significativo de
R4, e o LWR seguinte carrega os outros 3 bytes de R4 dos bytes de memória 204, 205 e 206. LWL lê a word com o primei-
ro byte da memória, desloca para a esquerda para descartar o(s) byte(s) desnecessário(s) e muda apenas os bytes em Rd.
O(s) byte(s) transferido(s) é(são) do primeiro byte para o byte menos significativo da word. O LWR seguinte endereça o
último byte, desloca para a direita para descartar o(s) byte(s) desnecessário(s) e, finalmente, muda apenas os bytes em Rd.
O(s) byte(s) transferido(s) é(são) do último byte até o byte mais significativo da word. Store word left (SWL) é simples-
mente o inverso de LWL, e store word right (SWR) é o inverso de LWR. Mudar para o modo Little Endian inverte os bytes
selecionados e descartados. (Se grande-pequeno, esquerda-direita, carregar-armazenar parece confuso, não se preocupe;
eles funcionam!)
� SYSCALL – Esta instrução de trap especial é usada para chamar o sistema operacional.
� Move dos/para os registradores de controle – CTCi e CFCi movem entre os registradores de in-
teiros e os registradores de controle.
� Jump/call não relativo ao PC – O endereço de 26 bits dos jumps e calls não é acrescentado ao
PC. Ele é deslocado 2 bits à esquerda e substitui os 28 bits menos significativos do PC. Isso só
faria diferença se o programa fosse localizado próximo à barreira dos 256MB.
� Instruções TLB – Falhas na TLB (Translation Lookaside Buffer) são tratadas por software no
MIPS I; portanto, o conjunto de instruções também tinha instruções para tratar os registradores
da TLB (veja o Capítulo 7 para saber mais sobre as TLBs). Esses registradores são considera-
dos parte do “coprocessador do sistema”. Desde o MIPS I, as instruções diferem entre as ver-
sões da arquitetura; elas são mais parte das implementações do que parte do conjunto de
instruções.
� Reciprocal e reciprocal square root – Estas instruções, que não seguem as diretrizes do IEEE
754 de arredondamento apropriado, são incluídas aparentemente para aplicações que valori-
zam mais a velocidade da divisão e da raiz quadrada do que valorizam a precisão.
� Instruções conditional procedure call – BGEZAL salva o endereço de retorno e desvia se o con-
teúdo de Rs1 é maior que ou igual a zero, e BLTZAL faz o mesmo para menor que zero. A finali-
dade dessas instruções é obter uma chamada relativa ao PC. (Também existem versões “likely”
dessas instruções.)
� Operações paralelas de ponto flutuante de precisão simples – Além de estender a arquitetura
com operações de inteiros paralelas no MDMX, o MIPS64 também aceita duas operações para-
lelas de ponto flutuante de 32 bits nos registradores de 64 bits em uma única instrução. As ope-
rações “paired single” incluem add (ADD.PS), subtract (SUB.PS), compare (C._.PS), convert
(CVT.PS.S, CVT.S.PL, CVT.S.PU), negate (NEG.PS), absolute value (ABS.PS), move (MOV.PS,
MOVF.PS, MOVT.PS), multiply (MUL.PS), multiply-add (MADD.PS) e multiply-subtract (MSUB.PS).
Na arquitetura MIPS, não há qualquer provisão específica para execução de ponto flutuante para
continuar em paralelo com execução de inteiros, mas as implementações MIPS de ponto flutuante
permitem que isso ocorra verificando se as interrupções aritméticas são possíveis no início do ciclo.
Normalmente, a detecção de exceção forçaria a serialização da execução das operações de inteiros e
de ponto flutuante.
D.8 Instruções específicas do Alpha
O Alpha foi criado para ser uma arquitetura que permitisse a fácil construção de implementações de alto
desempenho. Em vistas a esse objetivo, os arquitetos originalmente tomaram duas decisões controversas:
exceções de ponto flutuante imprecisas e nenhuma transferência de dados de byte ou halfword.
Para simplificar a execução em pipeline, o Alpha não exige que uma exceção aja como se nenhu-
ma instrução após um certo ponto seja executada e que todas antes desse ponto fossem executadas.Ele fornece a instrução TRAPB, que faz um stall até que todas as instruções aritméticas anteriores se-
jam completadas sem incorrer em exceções aritméticas. No modo mais conservador, colocar um
TRAPB para cada instrução causadora de exceção retarda a execução em aproximadamente cinco ve-
zes mas fornece exceções precisas (veja Darcy e Gay [1996]).
O código que não inclui TRAPB não obedece ao padrão de ponto flutuante IEEE 754. O motivo é
que partes do padrão (NaNs, infinities e denormal) são implementadas em software no Alpha, como
D-21 Apêndice D Uma Visão Geral das Arquiteturas RISCs para Computadores Desktop, Servidores e Embutidos ELSEVIER
em muitos outros microprocessadores. Entretanto, para implementar essas operações no software, os
programas precisam encontrar a instrução e valores de operandos que causaram o problema, o que
não pode ser feito com interrupções imprecisas!
Quando a arquitetura foi desenvolvida, os arquitetos acreditavam que loads e stores para bytes
tornariam as transferências de dados mais lentas. Os loads para bytes exigem um deslocador extra no
caminho da transferência de dados e os stores para bytes exigem que o sistema de memória realize
um read-modify-write para sistemas de memória com códigos de correção de erro, já que o novo va-
lor de ECC precisa ser recalculado. Essa omissão significa que os stores para bytes exigem a seqüên-
cia carregar word, substituir byte desejado e, então, armazenar word. (Incoerentemente, os loads de
ponto flutuante experimentam uma considerável troca de bytes para converter os obtusos formatos
de ponto flutuante VAX em uma forma canônica.)
Para reduzir o número de instruções para obter os dados desejados, o Alpha inclui um elaborado
conjunto de instruções de manipulação de bytes: extract field and zero rest of a register (EXTxx), in-
sert field (INSxx), mask rest of a register (MSKxx), zero fields of a register (ZAP) e compare multiple
bytes (CMPGE).
Aparentemente, os implementadores não ficaram tão aborrecidos com o load e store para bytes
quanto os arquitetos originais. Começando com o encolhimento da segunda versão do chip Alpha
(21164A), a arquitetura inclui loads e stores para bytes e halfwords.
Ouras instruções
A seguir, está uma lista das outras instruções específicas da arquitetura Alpha:
� Código PAL – Para fornecer as operações que o VAX realizava em microcódigo, o Alpha ofe-
rece um modo que roda com todos os privilégios habilitados, interrupções desabilitadas e ma-
peamento de memória virtual desativado para instruções. O código PAL (Privileged
Architecture Library) é usado para operações de gerenciamento de TLB, operações de memó-
ria atômicas e algumas primitivas de sistema operacional. O código PAL é chamado por meio
da instrução CALL_PAL.
� No divide – Divisão de inteiros não é suportada no hardware.
� Load-store “desalinhado” – LDQ_U e STQ_U carregam e armazenam dados de 64 bits usando en-
dereços que ignoram os três bits menos significativos. As instruções de extração, então, sele-
cionam a word desalinhada desejada usando os bits de endereço menos significativos. Essas
instruções são semelhantes ao LWL/R, SWL/R no MIPS.
� Precisão simples de ponto flutuante representada como precisão dupla – Os dados de precisão
simples são mantidos na memória como formato convencional de 32 bits mas são convertidos
para o formato de precisão dupla de 64 bits nos registradores.
� O registrador de ponto flutuante F31 é fixo em zero – Para simplificar comparações com zero.
� Formatos de ponto flutuante VAX – Para manter compatibilidade com a arquitetura VAX, além
dos formatos de precisão simples e dupla do IEEE 754, chamados S e T, o Alpha suporta os for-
matos de precisão simples e dupla do VAX, chamados F e G, mas não o formato D do VAX. (D
tinha um campo exponent muito restrito para que fosse útil para precisão dupla e foi substituído
por G no código do VAX.)
� Instruções de contagem de bits – A versão 3 da arquitetura incluiu instruções para contar o nú-
mero de zeros à esquerda (CTLZ), contar o número de zeros à direita (CTTZ) e contar o número de
uns em uma word (CTPOP). Originalmente encontrado nos computadores Cray, essas instruções
ajudam com a decriptografia.
D.8 Instruções específicas do Alpha D-22
D.9 Instruções específicas do SPARC v.9
Vários recursos são peculiares ao SPARC.
Janelas de registradores
O principal recurso exclusivo do SPARC são as janelas de registradores (register windows), uma oti-
mização para reduzir o tráfego de registradores nas chamadas de procedimento. São usados vários
bancos de registradores, com um novo banco alocado em cada chamada de procedimento. Embora
isso pudesse limitar a profundidade das chamadas de procedimento, a limitação é evitada operando
os bancos como um buffer circular, o que fornece profundidade ilimitada. O ápice da curva de cus-
to-desempenho parece ser seis a oito bancos.
O SPARC pode ter entre 2 e 32 janelas, normalmente usando oito registradores cada uma para
globais, locais, parâmetros de entrada e parâmetros de saída. (Visto que cada janela possui 16 regis-
tradores únicos, uma implementação do SPARC pode ter entre 40 e 520 registradores físicos, embo-
ra a maioria tenha de 128 a 136, até agora.) Em vez de vincular as mudanças de janela a instruções
call e return, o SPARC possui as instruções separadas SAVE e RESTORE. SAVE é usado para “salvar” a
janela do caller apontando para a próxima janela de registradores, além de realizar uma instrução
add. O truque é que os registradores origem da operação de adição são da janela do caller, enquanto o
registrador destino está na janela do callee. Os compiladores do SPARC normalmente usam essa ins-
trução para mudar o stack pointer para alocar variáveis locais em um novo frame. RESTORE é o inverso
de SAVE, trazendo de volta a janela do caller enquanto age como uma instrução add, com os registra-
dores origem são da janela do callee e o registrador destino da janela do caller. Isso libera automati-
camente o frame de pilha. Os compiladores também podem fazer uso dela para gerar o valor de retor-
no final do callee.
O risco das janelas de registradores é que o maior número de registradores pode diminuir a veloci-
dade de clock. Esse não foi o caso para as primeiras implementações. A arquitetura SPARC (com ja-
nelas de registradores) e a arquitetura MIPS R2000 (sem janelas) foram construídas em diversas tec-
nologias desde 1987. Por várias gerações, a velocidade de clock do SPARC não é mais lenta do que a
do MIPS para implementações em tecnologias similares, provavelmente porque os tempos de acesso
à cache superam os tempos de acesso aos registrador nessas implementações. As máquinas da gera-
ção atual adotaram estratégias de implementação diferentes – ordenadas em vez de desordenadas – e
é improvável que o número de registradores por si só tenha determinado a velocidade de clock em
qualquer máquina. Recentemente, outras arquiteturas incluíram janelas de registradores: Tensilica e
IA-64.
Outro recurso de transferência de dados é a opção de espaço alternado para loads e stores. Isso
simplesmente permite ao sistema de memória identificar os acessos à memória para dispositivos de
entrada/saída, ou controlar registradores para dispositivos como a cache e a unidade de gerencia-
mento de memória.
Traps rápidas
A versão 9 do SPARC inclui suporte para tornar as traps rápidas. Ele expande o nível único das traps
para pelo menos quatro níveis, permitindo que os handlers das traps de overflow e underflow de ja-
nela sejam interrompidos. Os níveis extras significam que o handler não precisa verificar faltas de
página ou stack pointer desalinhados explicitamente no código, o que torna o handler mais rápido.
Duas novas instruções foram acrescentadas para retornar desse handler multinível: RETRY (que tenta
executar novamente a instrução interrompida) e DONE (que não tenta). Para suportar as traps em nível
deusuário, a instrução RETURN irá retornar da trap no modo não privilegiado.
D-23 Apêndice D Uma Visão Geral das Arquiteturas RISCs para Computadores Desktop, Servidores e Embutidos ELSEVIER
Suporte para LISP e Smalltalk
O principal recurso de aritmética restante é a adição e subtração marcadas (com tags). Os projetistas
do SPARC gastaram algum tempo pensando nas linguagens como LISP e Smalltalk, e isso influen-
ciou alguns dos recursos do SPARC já discutidos: janelas de registradores, instruções de trap con-
dicionais, chamadas com endereços de instrução de 32 bits e aritmética multiword (veja Taylor et al.
[1986] e Ungar et al. [1984]). Um pequeno suporte é oferecido para tipos de dados marcados com o-
perações para adição, subtração e, portanto, comparação. Os dois bits menos significativos indicam
se o operando é um inteiro (codificado como 00); assim, TADDcc e TSUBcc ligam o bit de overflow se o
operando não é marcado como um inteiro ou se o resultado é muito grande. Uma instrução trap ou
branch condicional subseqüente pode decidir o que fazer. (Se os operandos não forem inteiros, o
software recupera os operandos, verifica os tipos de operandos e chama a operação correta com base
nesses tipos.) Ocorre que a trap de acesso à memória desalinhado também pode ser utilizada para da-
dos marcados, já que carregar de um ponteiro com a tag errada pode ser um acesso inválido. A Figura
D.9.1 mostra os dois tipos de suporte de tag.
Operações sobrepostas de inteiros e ponto flutuante
O SPARC permite que a execução de instruções de ponto flutuante se sobreponha às instruções de
inteiros. Para recuperar-se de uma interrupção durante uma situação desse tipo, o SPARC possui
uma fila de instruções de ponto flutuante pendentes e seus endereços. RDPR permite que o processa-
dor esvazie a fila. O segundo recurso de ponto flutuante é a inclusão das instruções square root de
ponto flutuante FSQRTS, FSQRTD e FSQRTQ.
Instruções restantes
Os outros recursos únicos do SPARC são os seguintes:
� JMPL usa Rd para especificar o registrador de endereço de retorno; portanto, especificar r31 o
torna semelhante a JALR no MIPS e especificar r0 o torna como JR.
D.9 Instruções específicas do SPARC v.9 D-24
TADDcc r7, r5, r6
±
00
00
00
(R5)
(R7)
(R6)
(b) Loading via
valid pointer
(coded as 11)
LD rD, r4, –3
–
11
00
3
(R4)
(a) Add, sub ou
compare de inteiros
(codificado como 00)
(b) Carregando via ponteiro válido (codificado como 11)
(Endereço
de word)
FIGURA D.9.1 O SPARC usa os dois bits menos significativos para codificar tipos de dados diferentes
para as instruções aritméticas marcadas. (a) Aritmética de inteiros, que usa um único ciclo desde que os ope-
randos e o resultado sejam inteiros. (b) A trap desalinhada pode ser usada para detectar acessos à memória inválidos, como
tentar usar um inteiro como um ponteiro. Para linguagens com dados pareados como LISP, um offset de –3 pode ser usado
para acessar a word par de um par (CAR) e +1 pode ser usado para a word ímpar de um par (CDR).
� LDSTUB carrega o valor do byte em Rd e, depois, armazena 0xFF16 no byte endereçado. Essa ins-
trução da versão 8 pode ser usada para implementar um semáforo (veja o Capítulo 9).
� CASA (CASXA) compara automaticamente um valor em um registrador de processador com
um valor de 32 bits (64 bits) na memória; se e somente se eles forem iguais, ele troca o valor na
memória pelo valor em um segundo registrador de processador. Essa instrução da versão 9
pode ser usada para construir algoritmos de sincronização livres de espera que não exigem o
uso de locks.
� XNOR calcula o OR exclusivo com o complemento do segundo operando.
� BPcc, BPr e FBPcc incluem um bit de previsão de desvios, de modo que o compilador possa dar
indicações à máquina sobre se um desvio provavelmente é tomado ou não.
� ILLTRAP causa uma trap de instrução ilegal. Muchnick [1988] explica como isso é usado para a
execução correta dos procedimentos de retorno agregados em C.
� POPC conta o número de bits definidos em 1 em um operando, também encontrado na terceira
versão da arquitetura Alpha.
� Loads infalíveis permitem que os compiladores movam instruções load para adiante das estru-
turas de controle condicional que controlam seu uso. Conseqüentemente, os loads infalíveis se-
rão executados de forma especulativa.
� Aritmética e transferência de dados de ponto flutuante de precisão quádrupla permitem que os
registradores de ponto flutuante ajam como oito registradores de 128 bits para operações de
ponto flutuante e transferências de dados.
� Resultados de ponto flutuante de precisão múltipla para multiplicação significam que dois
operandos de precisão simples possam resultar em um produto de precisão dupla, e dois ope-
randos de precisão dupla possam resultar em um produto de precisão quádrupla. Essas instru-
ções podem ser úteis na aritmética complexa e em alguns modelos de cálculos de ponto
flutuante.
D.10 Instruções específicas do PowerPC
O PowerPC é o resultado de várias gerações de máquinas RISCs comerciais da IBM – IBM RT/PC,
IBM Power1 e IBM Power2 – mais o Motorola 88x00.
Registradores de branch: link e count
Em vez de dedicar um dos 32 registradores de uso geral para salvar o endereço de retorno na chama-
da de procedimento, o PowerPC coloca o endereço em um registrador especial chamado registrador
de link. Como muitos procedimentos retornarão sem chamar outro procedimento, o link nem sempre
precisa ser salvo. Colocar o endereço de retorno em um registrador especial torna o jump de retorno
mais rápido, já que o hardware não precisa passar pelo estágio de leitura de registradores do pipeline
para jumps de retorno.
De modo semelhante, o PowerPC possui um registrador count para ser usado em loops nos quais
o número de iterações é fixo. Usando um registrador especial, o hardware de desvio pode determinar
rapidamente se um desvio baseado no registrador count provavelmente irá desviar, já que o valor do
D-25 Apêndice D Uma Visão Geral das Arquiteturas RISCs para Computadores Desktop, Servidores e Embutidos ELSEVIER
registrador é conhecido logo no início do ciclo de execução. Testes do valor do registrador count em
uma instrução de desvio irão diminuir automaticamente o registrador count.
Como o registrador count e o registrador de link já estão juntos com o hardware que controla des-
vios, e um dos problemas na previsão de desvios é obter o endereço de destino no início do pipeline
(veja o Apêndice A), os arquitetos do PowerPC decidiram fazer um segundo uso desses registrado-
res. Qualquer registrador pode conter um endereço de destino de um desvio condicional. Portanto, o
PowerPC suplementa seu desvio condicional básico com duas instruções que obtêm o endereço de
destino desses registradores (BCLR, BCCTR).
Outras instruções
Diferente da maioria das outras máquinas RISCs, o registrador 0 não é fisicamente conectado ao va-
lor 0. Ele não pode ser usado como um registrador de base – isto é, ele gera um 0 nesse caso – mas, no
endereçamento base + índice, ele pode ser usado como o índice. Os outros recursos únicos do Po-
werPC são os seguintes:
� Load multiple e store multiple salvam ou restauram até 32 registradores em uma única ins-
trução.
� LSW e STSW permitem a busca e o armazenamento de strings de comprimento variável que possu-
em alinhamento arbitrário.
� Instruções rotate com mask suportam extração e inserção de campos de bit. Uma versão gira os
dados e, depois, realiza AND lógico com uma máscara de uns, extraindo, assim, um campo. A
outra versão gira os dados mas apenas coloca os bits no registrador de destino onde há um bit 1
correspondente na máscara, inserindo, assim, um campo.
� Right shift algébrico define o bit de carry (CA) se o operando é negativo e quaisquer bits 1 são
deslocados para fora. Portanto, uma divisão com sinal por qualquer potência constante de