Visão Geral das Arquiteturas RISC

E
A P Ê N D I C E
RISC: qualquer computador
anunciado após 1985.
Steven Przybylskic
Um projetista do MIPS de Stanford
Uma Visão Geral das
Arquiteturas RISCs
para Computadores
Desktop, Servidores e
Embutidos
E.1Introdução E-3
E.2
Modos de endereçamento e formatos de instrução E-5
E.3
Instruções: o subconjunto do núcleo MIPS E-9
E.4
Instruções: extensões para multimídia dos RISCs desktop/
servidores E-16
E.5
Instruções: extensões para processamento de sinais digitais dos
RISCs embutidos E-19
E.6
Instruções: extensões comuns ao núcleo MIPS E-20
E.7
Instruções específicas do MIPS-64 E-25
E.8
Instruções específicas do Alpha E-27
E.9
Instruções específicas do SPARC v.9 E-29
E.10
Instruções específicas do PowerPC E-32
E.11
Instruções específicas do PA-RISC 2.0 E-34
E.12
Instruções específicas do ARM E-36
E.13
Instruções específicas do Thumb E-38
E.14
Instruções específicas do SuperH E-39
E.15
Instruções específicas do M32R E-40
E.16
Instruções específicas do MIPS-16 E-40
E.17
Comentários finais E-43
E.1 Introdução
Neste apêndice, abordaremos dois grupos de arquiteturas RISCs (Reduced Instruction Set
Computer). O primeiro grupo é composto pelos RISCs desktop e servidores:

Alpha da Digital

PA-RISC da Hewlett-Packard

PowerPC da IBM e da Motorola

MIPS-64 da MIPS INC

SPARC da Sun Microsystems
4
Material Complementar
ELSEVIER
O segundo grupo é composto pelos RISCs embutidos:

ARM da Advanced RISC Machines.

Thumb da Advanced RISC Machines.

SuperH da Hitachi.

M32R da Mitsubishi.

MIPS-16 da MIPS INC.
Nunca houve outra classe de computadores tão semelhantes. Essa semelhança permite a apresentação de 10 arquiteturas em aproximadamente 50 páginas. Os recursos
dos RISCs desktop e servidores são encontrados na Figura E.1.1 e dos RISCs embutidos
na Figura E.1.2.
Alpha
Data do anúncio
Tamanho de instrução (bits)
Espaço de endereçamento
(tamanho, modelo)
Alinhamento de dados
Modos de endereçamento de dados
Proteção
Tamanho de página mínimo
E/S
Registradores de inteiros (número,
modelo, tamanho)
Registradores de ponto flutuante
separados
Formato do ponto flutuante
MIPS I
PA-RISC 1.1
PowerPC
SPARC v.8
1992
32
64 bits, contínuo
1986
32
32 bits, contínuo
1986
32
48 bits, segmentado
1993
32
32 bits, contínuo
1987
32
32 bits, contínuo
Alinhado
1
Página
8KB
Mapeada em memória
31GPR × 64 bits
Alinhado
1
Página
4KB
Mapeada em memória
31GPR × 32 bits
Alinhado
5
Página
4KB
Mapeada em memória
31GPR × 32 bits
Desalinhado
4
Página
4KB
Mapeada em memória
32GPR × 32 bits
Alinhado
2
Página
8KB
Mapeada em memória
31GPR × 32 bits
31 × 32 ou
31 × 64 bits
IEEE 754 simples,
duplo
16 × 32 ou
16 × 64 bits
IEEE 754 simples,
duplo
56 × 32 ou
28 × 64 bits
IEEE 754 simples,
duplo
32 × 32 ou
32 × 64 bits
IEEE 754 simples,
duplo
32 × 32 ou
32 × 64 bits
IEEE 754 simples,
duplo
FIGURA E.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 E.17.1. As versões posteriores dessas arquiteturas suportam um espaço de endereçamento contínuo de 64 bits.
ARM
Thumb
SuperH
M32R
Data do anúncio
Tamanho de instrução (bits)
Espaço de endereços (tamanho, modelo)
1985
32
32 bits, contínuo
1995
16
32 bits, contínuo
1992
16
32 bits, contínuo
1997
16/32
32 bits, contínuo
Alinhamento de dados
Modos de endereçamento de dados
Registradores de inteiros (número, modelo, tamanho)
Alinhado
6
15GPR × 32 bits
Alinhado
4
16GPR × 32 bits
Alinhado
3
16GPR × 32 bits
E/S
Mapeada em
memória
Alinhado
6
8GPR + SP,
LR × 32 bits
Mapeada em
memória
Mapeada em
memória
Mapeada em
memória
MIPS-16
1996
16/32
32/64 bits,
contínuo
Alinhado
2
8GPR + SP,
RA × 32/64 bits
Mapeada em
memória
FIGURA E.1.2 Resumo das cinco arquiteturas para aplicações embutidas. Com exceção do número de modos de endereçamento 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 E.17.1.
Apêndice E Uma Visão Geral das Arquiteturas RISCs para Computadores Desktop...
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 embutidos mas sempre 32 bits nos RISCs desktop/servidores.
Embora mostrados como arquiteturas de conjunto de instruções embutidas separadas,
Thumb e MIPS-16 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 programas
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 longo dos anos. Decidimos descrever a última versão das arquiteturas: MIPS-64, 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 MIPS-16 versão 1 para embutidos.
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 especulação sobre os caminhos para o futuro dos RISCs.
E.2 Modos de endereçamento e formatos de
instrução
A Figura E.2.1 mostra os modos de endereçamento de dados suportados pelas arquiteturas
de desktop. Como todos possuem um registrador que sempre tem o valor 0 quando usado
em modos de endereç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 E.2.2 mostra os modos de endereçamento de dados suportados pelas arquiteturas embutidas. 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çamento que pode deslocar um registrador por qualquer
quantidade, adicioná-lo aos outros registradores para formar o endereço e, depois, atualizar
um registrador com esse novo endereço.
5
6
Material Complementar
ELSEVIER
As referências ao código normalmente são relativas ao PC, embora o jump register
indireto também seja suportado para retorno de procedimentos, para instruções case
e 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 funciona porque a largura de todas as instruções para os RISCs desktop é 32 bits e as instruções precisam 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.
Modo de endereçamento
Alpha
MIPS-64
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 E.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 MIPS-64 indexou o endereçamento para loads e stores de ponto flutuante. (Esses modos de endereçamento são
descritos na Figura 2.24.)
Modo de endereçamento
Registrador + offset (deslocamento ou baseado)
Registrador + registrador (indexado)
Registrador + registrador escalado (escalado)
Registrador + offset e registrador de atualização
Registrador + registrador e registrador de atualização
Registrador indireto
Autoincremento, autodecremento
Dados relativos ao PC
ARM v.4
Thumb
SuperH
M32R
MIPS-16
X
X
X
X
X
–
X
X
X
X
–
–
–
–
X
X (loads)
X
X
–
–
–
X
X
X
X
–
–
–
–
X
X
–
X
–
–
–
–
–
–
X (loads)
Figura E.2.2 Resumo dos modos de endereçamento suportados pelas arquiteturas embutidas. O SuperH e o M32R possuem 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 dados for word ou halfwords. (Esses modos de endereçamento são descritos na Figura 2.24.)
A Figura E.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 Figura E.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.
Apêndice E Uma Visão Geral das Arquiteturas RISCs para Computadores Desktop...
FIGURA E.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 principal, Opx = uma extensão de opcode, Rd = o registrador
de destino, Rs1 = registrador origem 1, Rs2 = registrador origem 2 e Const = uma constante (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.
7
8
Material Complementar
ELSEVIER
FIGURA E.2.4 Formatos de instrução para arquiteturas RISC embutidas. Esses seis formatos são encontrados em
todas as cinco arquiteturas. A notação é a mesma da Figura E.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.
Apêndice E Uma Visão Geral das Arquiteturas RISCs para Computadores Desktop...
Formato: categoria de instrução
Branch: Tudo
Jump/Call: Tudo
Registrador-imediato: transferência de dados
Registrador-imediato: aritmética
Registrador-imediato: lógico
9
Alpha
MIPS-64
PA-RISC
2.0 PowerPC
SPARC v.9
Sinal
Sinal
Sinal
Zero
Zero
Sinal
—
Sinal
Sinal
Zero
Sinal
Sinal
Sinal
Sign
—
Sinal
Sinal
Sinal
Sinal
Zero
Sinal
Sinal
Sinal
Sinal
Sinal
FIGURA E.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.
Formato: categoria de instrução
Branch: Tudo
Jump/Call: Tudo
Registrador-imediato: transferência de dados
Registrador-imediato: aritmética
Registrador-imediato: lógico
ARM v.4
Thumb
SuperH
M32R
MIPS-16
Sinal
Sinal
Zero
Zero
Zero
Sinal
Sinal/Zero
Zero
Zero
—
Sinal
Sinal
Zero
Sinal
Zero
Sinal
Sinal
Sinal
Sinal
Zero
Sinal
—
Zero
Zero/Sinal
—
FIGURA E.2.6 Resumo da extensão de constante para RISCs embutidos. As instruções de 16 bits de tamanho possuem imediatos 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 sequenciais. 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 imediatos. Por exemplo, todas as potências de 2 são imediatos no ARM.
As Figuras E.2.5 e E.2.6 mostram as variações na forma de estender os campos de
constante à largura total dos registradores. Nessa questão sutil, os RISCs são semelhantes
mas não idênticos.
E.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 E.3.1 a E.3.5. (Para consulta, as definições das instruções
MIPS são encontradas 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 E.3.1); aritméticas e lógicas
(Figura E.3.2); controle (Figura E.3.3); e ponto flutuante (Figura E.3.4). Uma quinta categoria (Figura E.3.5) mostra convenções para uso dos registradores e pseudo-instruções
em cada arquitetura. Se uma instrução de núcleo MIPS exigir uma curta sequência de
instruções em outras arquiteturas, essas instruções são separadas por sinais de ponto-evírgula nas Figuras E.3.1 a E.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 E.3.6 a E.3.9 mostram a listagem equivalente
para os RISCs embutidos. Note que o ponto flutuante geralmente não é definido para os
RISCs embutidos.
10
Material Complementar
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
MIPS-64
PA-RISC 2.0
PowerPC
SPARC v.9
Load byte signed
Load byte unsigned
Load half word signed
Load half word unsigned
Load word
Load SP float
Load DP float
Store byte
Store half word
Store word
Store SP float
Store DP float
Read, write special registers
Move integer to FP register
Move FP to integer register
LDBU; SEXTB
LDBU
LDWU; SEXTW
LDWU
LDLS
LDS*
LDT
STB
STW
STL
STS
STT
MF_, MT_
ITOFS
FTTOIS
LB
LBU
LH
LHU
LW
LWC1
LDC1
SB
SH
SW
SWC1
SDC1
MF, MT_
MFC1/DMFC1
MTC1/DMTC1
LDB; EXTRW,S 31,8
LDB, LDBX, LDBS
LDH; EXTRW,S 31,16
LDH, LDHX, LDHS
LDW, LDWX, LDWS
FLDWX, FLDWS
FLDDX, FLDDS
STB, STBX, STBS
STH, STHX, STHS
STW, STWX, STWS
FSTWX, FSTWS
FSTDX, FSTDS
MFCTL, MTCTL
STW; FLDWX
FSTWX; LDW
LBZ; EXTSB
LBZ
LHA
LHZ
LW
LFS
LFD
STB
STH
STW
STFS
STFD
MFSPR, MF_, MTSPR, MT_
STW; LDFS
STFS; LW
LDSB
LDUB
LDSH
LDUH
LD
LDF
LDDF
STB
STH
ST
STF
STDF
RD, WR, RDPR, WRPR, LDXFSR, STXFSR
ST; LDF
STF; LD
FIGURA E.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. Quando há 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 flutuante de precisão simples em precisão dupla e carrega o registrador
de 64 bits inteiro.
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
MIPS-64
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 E.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 sequê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 categoria “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!)
Apêndice E Uma Visão Geral das Arquiteturas RISCs para Computadores Desktop...
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
MIPS-64
PA-RISC 2.0
PowerPC
SPARC v.9
Branch on integer
compare
B_ (<, >, <=, BEQ, BNE, B_Z COMB, COMIB
>=, =, not=) (<, >, <=, >=)
BC
BR_Z, BPcc (<,
>, <=, >=, =,
not=)
Branch on floating-point FB_(<, >, <=, BC1T, BC1F
compare
>=, =, not=)
Jump, jump register
BR, JMP
J, JR
FSTWX f0;
LDW t; BB t
BC
FBPfcc (<, >,
<=, >=, =,...)
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
11
FIGURA E.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.
Ponto flutuante
(formatos de instrução)
R-R
R-R
R-R
R-R
R-R
Nome da instrução
Alpha
MIPS-64
PA-RISC 2.0
PowerPC
SPARC v.9
Add single, double
ADDS, ADDT
ADE.S, ADE.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
FCPY
FMV
FMOVS/D/Q
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
Move R-R
ADDT, Fd, F31, Fs
MOV.S, MOV.D
Convert (single, double, integer) CVTST, CVTTS, CVTTQ, CVT.S.D, CVT.E.S,
to (single, double, integer)
CVTQS, CVTQT
CVT.S.W, CVT.E.W,
CVT.W.S, CVT.W.D
FIGURA E.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 equivalentes ao núcleo MIPS, elas estão separadas por vírgulas.
Convenções
Alpha
MIPS-64
PA-RISC 2.0
PowerPC
SPARC v.9
Registrador com valor 0
Registrador de endereço de retorno
r31 (origem)
r0
r0
r0 (endereçamento)
r0
(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,...
ADE..., 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 E.3.5 Convenções das arquiteturas RISCs desktop equivalentes ao núcleo MIPS.
12
Material Complementar
ELSEVIER
Nome da instrução
ARM v.4
Thumb
SuperH
M32R
MIPS-16
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
MRS, MSR
–1
LDC, STC
MVFC, MVTC
MOVE
Read, write special registers
FIGURA E.3.6 Instruções de transferência de dados dos RISCs embutidos equivalentes ao núcleo MIPS. Uma sequência 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 MIPS-16
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 sequências disponíveis no modo de 32 bits mas não no modo de 16 bits no Thumb ou MIPS-16.
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
MIPS-16
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
Divide
–
–
DIV1, DIVoS, DIVoU
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
Shift right logical
Multiply (trap if overflow)
–
DIV, DIVU
–
LSL
LSL
2
SHLL, SHLLn
SLL, SLLI, SLL3
SLLV, SLL
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
3
FIGURA E.3.7 Instruções lógicas e aritméticas dos RISCs embutidos 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 sequê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. Thumb e MIPS-16 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 sequências disponíveis no
modo de 32 bits mas não no modo de 16 bits no Thumb ou MIPS-16. O 2 sobrescrito mostra novas instruções encontradas apenas no modo de 16 bits do Thumb
ou MIPS-16, 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.
Apêndice E Uma Visão Geral das Arquiteturas RISCs para Computadores Desktop...
Controle (formatos de instrução)
B, J, C
B, J, C
B, J, C
B, J, C
Nome de instrução
ARM v.4
Thumb
SuperH
M32R
13
B, J, C
MIPS-16
Branch on integer compare
Jump, jump register
Call, call register
B/cond
MOV pc,ri
BL
B/cond
MOV pc,ri
BL
BF, BT
BRA, JMP
BSR, JSR
BEQ, BNE, BC,BNC, B__Z
BRA, JMP
BL, JL
BEQZ , BNEZ , BTEQZ2, BTNEZ2
B2, JR
JAL, JALR, JALX2
Trap
Return from interrupt
SWI
MOVS pc, r14
SWI
–1
TRAPA
TRAP
BREAK
RTS
RTE
–1
2
2
FIGURA E.3.8 Instruções de controle dos RISCs embutidos equivalentes ao núcleo MIPS. Thumb e MIPS-16 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
sequências disponíveis no modo de 32 bits mas não no modo de 16 bits no Thumb ou MIPS-16. O 2 sobrescrito mostra novas instruções encontradas apenas
no modo de 16 bits do Thumb ou MIPS-16, como BTEQZ2.
Convenções
Registrador de endereço
de retorno
No-op
Operandos, ordem
ARM v.4
R14
Thumb
R14
MOV r0,r0
MOV r0,r0
OP Rd, Rs1, Rs2 OP Rd, Rs1
SuperH
M32R
MIPS-16
PR (special)
R14
RA (special)
NOP
OP Rs1, Rd
NOP
OP Rd, Rs1
SLL r0, r0
OP Rd, Rs1, Rs2
FIGURA E.3.9 Convenções das instruções para RISCs embutidos equivalentes ao núcleo MIPS.
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 condiçã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 testam códigos de condição para
determinar todas as relações com ou sem sinal possíveis. O ponto flutuante usa códigos
de condição separados para codificar as condições IEEE 754, exigindo uma instrução de
comparação em ponto flutuante. A versão 9 expandiu os desvios do SPARC de quatro
maneiras: 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
summary 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 instruções de inteiros possuem um bit de
opção que se comporta como se a operação de inteiro fosse seguida 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 sejam testadas por um único desvio.
14
Material Complementar
ELSEVIER
O MIPS usa o conteúdo dos registradores para avaliar desvios condicionais. Quaisquer
dois registradores podem ser comparados por igualdade (BEQ) ou por desigualdade (BNE)
e, então, o desvio é tomado 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 comparaçõ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ódigos de condição de ponto flutuante, com as instruções de
comparação e desvio de ponto flutuante especificando a condição a definir ou testar.
As comparações do Alpha (CMPEQ, CMPLT, CMPLE, CMPULT, CMPULE) testam dois registradores e colocam um terceiro em 1 se a condição é satisfeita e em 0 caso contrário. As comparações de ponto flutuante (CMTEQ, CMTLT, CMTLE, CMTUN) colocam o resultado
em 2.0 se a condição é satisfeita e em 0 caso contrário. As instruções de desvio comparam
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 E.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.
O ARM é semelhante ao SPARC, em que fornece quatro códigos de condição tradicionais definidos 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 outro, e a soma
define os códigos de condição. TST realiza AND lógico e os 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 E.9, uma caracterí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 E.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 permitem menos instruções de comparação.
O Mitsubishi M32R também oferece um único bit de código de condição (C) usado para
comparações com e sem sinal (CMP, CMPI, CMPU, CMPUI) para ver se um registrador é menor
que 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 MIPS-16 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 MIPS-16 é 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
MIPS-16 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)
Apêndice E Uma Visão Geral das Arquiteturas RISCs para Computadores Desktop...
15
que calculam o OR exclusivo de dois registradores e colocam o resultado no registrador
T. Compare foi incluído porque o MIPS-16 não tinha instruções para comparar e desviar
se os registradores são iguais ou não (BEQ e BNE).
As Figuras E.3.10 e E.3.11 resumem os esquemas usados para desvios condicionais.
Alpha
Número de bits do código de condição
(inteiro e FP)
Instruções de comparação básicas
(inteiro e FP)
Instruções de desvio básicas
(inteiro e FP)
Comparação de registrador com
registrador/const e desvio
Comparação de registrador com zero e
desvio
MIPS-64
PA-RISC 2.0
PowerPC
SPARC v.9
0
8 FP
8 FP
8 × 4 ambos
2 × 4 inteiro, 4 × 2 FP
1 inteiro, 1 FP
1 inteiro, 1 FP
4 inteiro, 2 FP
4 inteiro, 2 FP
1 FP
1
2 inteiro, 1 FP
7 inteiro
1 both
3 inteiro, 1 FP
–
=, not=
–
–
=, not=, <, <=, >, >=,
even, odd
=, not=, <, <=, >, >=
=, not=, <, <=, >, >=,
even, odd
=, not=, <, <=, >, >=,
even, odd
–
=, not=, <, <=, >, >=
FIGURA E.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.
Número de bits do código de condição
Instruções de comparação básicas
Instruções de desvio básicas
Comparação de registrador com registrador/const
e desvio
Comparação de registrador com zero e desvio
ARM v.4
Thumb
SuperH
M32R
MIPS-16
4
4
1
–
4
3
1
–
1
2
2
=, >, >=
1
2
3
=, not=
1
2
2
–
–
–
=, >, >=
=, not=, <, <=, >, >=
=, not=
FIGURA E.3.11 Resumo dos cinco métodos dos RISCs embutidos para desvios condicionais.
E.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 operaçõ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 espaço quando armazenados na memória, mas, devido à pouca frequência de operações aritméticas nesses tamanhos de dados em programas de inteiros típicos, há pouco
suporte além das transferências 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 realizar 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
16
Material Complementar
ELSEVIER
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
Instruction, Multiple Data – instrução única, dados múltiplos) (veja o Capítulo 7). Como
o marketing da Intel usa SIMD para descrever a extensão MMX do 8086, esse se tornou o
nome popular. A Figura E.4.1 resume o suporte por arquitetura.
Na Figura E.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 E.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 aritmé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.
Categoria da instrução
Add/subtract
Add/sub com saturação
Multiply
Compare
Shift right/left
Shift right arithmetic
Multiply and add
Shift and add (saturação)
And/or/xor
Absolute difference
Max/min
Pack (2n bits -> n bits)
Unpack/merge
Permute/shuffle
Conjuntos de registradores
Alpha MAX
8B (>=)
8B, 4H, 2W
8B
8B, 4W
2W->2B, 4H->4B
2B->2W, 4B->4H
Integer
MIPS MDMX
8B, 4H
8B, 4H
8B, 4H
8B, 4H (=,<,<=)
8B, 4H
4H
8B, 4H
8B, 4H, 2W
8B, 4H
2*2W->4H, 2*4H->8B
2*4B->8B, 2*2H->4H
8B, 4H
Fl. Pt. + 192b Acc.
PA-RISC MAX2
4H
4H
PowerPC
SPARC VIS
4H, 2W
4B/H
4H, 2W (=, not=, >, <=)
4H
4H
4H
8B, 4H, 2W
2*4H->8B
4H
Integer
8B, 4H, 2W
8B
2W->2H, 2W->2B, 4H->4B
4B->4H, 2*4B->8B
Fl. Pt.
FIGURA E.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 atribuir constantes a registradores. Essa tabela também
não inclui a operação de alinhamento de memória do MDMX, do MAX e do VIS.
Apêndice E Uma Visão Geral das Arquiteturas RISCs para Computadores Desktop...
17
Essas máquinas usavam largamente conjuntos de registradores existentes para conter
operandos: registradores de inteiros para Alpha e HP PA-RISC e registradores de ponto
flutuante para MIPS e Sun. Consequentemente, 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 acumular 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 desempenho de
2 a 4 vezes para o acumulador.
Talvez, a conclusão surpreendente dessa tabela é a falta de consistência. As únicas operações encontradas 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 problemático.
E.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 MIPS-16 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 MIPS-64.
A Figura E.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ínimo se as operações ocasionarem overflow.
ARM v.4
Thumb
SuperH
M32R
MIPS-16
Tamanho da multiplicação
Tamanho do acumulador
Nome do acumulador
Operações
32B × 32B
32B/64B
Qualquer GPR ou pares de GPRs
Produto 32B/64B + 64B
acumulado com ou sem sinal
–
–
–
–
32B × 32B, 16B × 16B
32B/42B, 48B/64B
MACH, MACL
Produto 32B + 42B/32B
acumulado (operandos na
memória); 64B produto +
64B/48B acumulado
(operandos na memória);
MAC limpo
32B × 16B, 16B × 16B
56B
ACC
–
–
–
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 E.5.1 Resumo dos cinco métodos dos RISCs embutidos para multiply-accumulate.
18
Material Complementar
ELSEVIER
E.6 Instruções: extensões comuns ao núcleo
MIPS
As Figuras E.6.1 a E.6.7 listam instruções não encontradas nas Figuras E.3.5 a E.3.11 nas
mesmas quatro categorias. Essas listas contêm instruções que aparecem em mais de uma
das arquiteturas padrão. As instruções são definidas usando a linguagem de descrição de
hardware definida na Figura E.6.8.
Embora a maioria das categorias seja autoexplicativa, 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 2.11, no Capítulo 2).

As linhas “64-bit data transfer” e “operation” mostram como MIPS, PowerPC e
SPARC definem o endereçamento e as operações de inteiros de 64 bits. O SPARC
simplesmente define todas 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 inclui as mesmas instruções e ainda
acrescenta instruções aritméticas de 64 bits com sinal separadas. 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 provavelmente serão lidos ou escritos apenas uma vez ou se provavelmente
serão lidos ou escritos muitas 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 B). 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 loads e stores após a instrução possam iniciar. (Veja o Capítulo 2.)

A linha “coprocessor operations” relaciona várias categorias que permitem que o
processador seja estendido com hardware de uso especial.
Apêndice E Uma Visão Geral das Arquiteturas RISCs para Computadores Desktop...
Nome
Atomic swap R/M (para locks e
semáforos)
Definição
Alpha
MIPS-64
19
PA-RISC 2.0
PowerPC
SPARC v.9
LDL/Q_L;
STL/Q_C
Load 64-bit integer
Temp<–-Rd;
Rd<–-Mem[x];
Mem[x]<–-Temp
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
LL; SC
– (veja E.8)
LWARX; STWCX
CASA, CASX
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)
(Todas as transferências de dados
anteriores são completadas para
que a próxima transferência de
dados possa iniciar)
ECB
CP0op
FDC, FIC
DCBF
FLUSH
WMB
SYNC
SYNC
SYNC
MEMBAR
Shared-memory synchronization
FIGURA E.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 é conseguido com 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).
Nome
Definição
Alpha
MIPS-64
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
Deslocamentos com 64 bits
Rd<–-64Rs1 op64 Rs2
AND, OR, XOR
AND, OR, XOR
AND, OR, XOR
AND, OR, XOR
AND, OR, XOR
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 CarryOut, Rd <–- Rs1 +
mais de uma word
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);
(Definidas pelo
coprocessador)
–
–
ADDIL (R-I)
ADDIS (R-I)
–
–
COPi
COPR,i
–
IMPDEPi
Coprocessor operations
FIGURA E.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.
20
Material Complementar
Nome
Definição
ELSEVIER
Alpha
MIPS-64
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 E.6.3 Instruções de controle não encontradas no núcleo MIPS mas encontradas em duas ou mais das cinco arquiteturas de desktop.
Nome
Definição
Alpha
MIPS-64
PA-RISC 2.0
PowerPC
SPARC v.9
Multiply and add
Fd <–- (Fs1 × Fs2) + Fs3
–
MADE.S/D
Multiply and sub
Fd <–- ( Fs1 × Fs2) – Fs3
–
MSUB.S/D
Neg mult and add
Fd <–- -(( Fs1 × Fs2) + Fs3)
–
NMADE.S/D
Neg mult and sub
Fd <–- -(( Fs1 × Fs2) – Fs3)
–
NMSUB.S/D
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
Fd <–- Fs &
x7FFFFFFF
CPYSN
NEG.S/D
FNEG sgl/dbl
FNEG
FNEGS/D/Q
–
ABS.S/D
FABS/dbl
FABS
FABSS/D/Q
Valor Absoluto
FMPYFADD sgl/dbl
FMADD/S
FMSUB/S
FMPYFNEG sgl/dbl
FNMADD/S
FNMSUB/S
FIGURA E.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.
Nome
Atomic swap R/M (para semáforos)
Definição
ARM v.4
Thumb
SuperH
M32R
(see TAS)
LOCK;
UNLOCK
SWP, SWPB
–
Memory management unit
Temp<–-Rd; Rd<–-Mem[x];
Mem[x]<–-Temp
Tradução de endereço paginado
Via instruções do coprocessador
–1
LDTLB
Endian
(Big/Little Endian?)
Ambos
Ambos
Ambos
1
MIPS-16
–1
–1
Big
Ambos
FIGURA E.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 sequências disponíveis no modo de 32 bits mas não no modo de 16 bits no Thumb ou MIPS-16.
Nome
Load immediate
Definição
Thumb
SuperH
M32R
MIPS-16
MOV
MOV
MOV, MOVA
LDI, LD24
LI
Suporte a adição de inteiros com mais CarryOut, Rd <–- Rd + Rs1 + OldCarryOut
de uma word
Suporte a subtração de inteiros com
CarryOut, Rd <–- Rd – Rs1 + OldCarryOut
mais de uma word
Negar
Rd <–- 0 – Rs1
ADCS
ADC
ADDC
ADDX
–1
SBCS
SBC
SUBC
SUBX
–1
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
Rd <–-Rs1 & ~(Rs2)
ROR
ROR
ROTC
BIC
BIC
And not
Rd<–-Imm
ARM v.4
FIGURA E.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 sequências disponíveis no modo de 32 bits mas não no modo de 16 bits no Thumb ou MIPS-16. O 2 sobrescrito mostra novas instruções
encontradas apenas no modo de 16 bits do Thumb ou MIPS-16, como NEG2.
Apêndice E Uma Visão Geral das Arquiteturas RISCs para Computadores Desktop...
21
Nome
Definição
ARM v.4
Thumb
SuperH
M32R
MIPS-16
Num. de registradores de controle
Misc. registers
21
29
9
5
36
FIGURA E.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 E.6.9 mostra as opções. O Alpha e o PowerPC oferecem desvios que entram em
operação imediatamente, como os desvios nas arquiteturas mais antigas. Para acelerar desvios, essas máquinas usam previsão de desvios (veja o Capítulo 4). Todos os outros RISCs
desktop oferecem delayed branches (veja o Apêndice B). 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 tomado; 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 definido 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.
Notação
Significado
Exemplo
Significado
<–
Transferência de dados. A extensão da transferência Regs[R1]<–Regs[R2];
é dada pela largura do destino; a extensão é
especificada quando não for clara.
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.
Transfere um campo de n bits, usado sempre que a
largura da transferência não é clara.
Regs[R1]<–M[x];
Xn
O subscrito seleciona um bit.
Regs[R1]0<–0;
Xm..n
O subscrito seleciona um campo.
Regs[R3]24..31<–M[x];
Xn
O sobrescrito duplica um campo de bit.
Regs[R3]0..23<–024;
Define os três bytes mais significativos de R3 como 0.
##
Concatena dois campos.
Regs[R3]<–240## M[x];
F2##F3<–64M[x];
*, &
Segue um ponteiro; obtém o endereço de uma
variável.
Shifts lógicos C (esquerda, direita).
p*<–&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.
Atribui o endereço da variável x ao objeto apontado por p.
<–n
<<, >>
M@N1 = <–16M[x];
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.
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].
Transfere 16 bits iniciando no local de memória x para
o local de memória y. A largura dos dois lados deve
coincidir.
Muda o bit de sinal de R1 para 0. (Os bits são numerados
por meio de MSB iniciando em 0.)
Move o conteúdo do local de memória x para o byte
menos significativo de R3.
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.
&, |, ^, !
(Regs[R1] & (Regs[R2]|
Regs[R3]))
AND bit-a-bit de R1 e OR bit-a-bit de R2 e R3.
Operações lógicas bit-a-bit C: and, or, or exclusivo e
complemento
FIGURA E.6.8 Notação de descrição de hardware (e alguns operadores C padrão).
22
Material Complementar
Branch (simples)
Encontrado nas arquiteturas
Executado após a instrução
ELSEVIER
Delayed Branch
Alpha, PowerPC, ARM, Thumb,
SuperH, M32R, MIPS 16
Apenas se o desvio não é tomado
MIPS-64, PA-RISC,
SPARC, SuperH
Sempre
Delayed Branch com anulação
MIPS-64, SPARC
PA-RISC
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 E.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
arquitetura. 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.
E.7 Instruções específicas do MIPS-64
O MIPS atravessou cinco gerações de conjuntos de instruções, e essa evolução geralmente
acrescentou 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.
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ê tentar carregar uma word ou armazenar uma word em
um endereço desalinhado, em todas as arquiteturas, as words desalinhadas poderão ser
acessadas sem traps usando quatro instruções load byte e, depois, 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 E.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 MIPS-64:

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 E.2.3.

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 inteiros 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.
Apêndice E Uma Visão Geral das Arquiteturas RISCs para Computadores Desktop...

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 considerados parte do “coprocessador do sistema”. Desde o
MIPS I, as instruções diferem entre as versõ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 valorizam 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
conteúdo de Rs1 é maior que ou igual a zero, e BLTZAL faz o mesmo para menor que
zero. A finalidade 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 MIPS-64 também aceita
duas operações paralelas de ponto flutuante de 32 bits nos registradores de 64 bits em
uma única instrução. As operações “paired single” incluem add (ADE.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 (MADE.PS) e multiply-subtract (MSUB.PS).
Figura E.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 primeiro
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)
é simplesmente 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!)
23
24
Material Complementar
ELSEVIER
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.
E.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 nenhuma 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 sejam 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 vezes 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 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 valor de ECC precisa ser recalculado. Essa omissão significa que os stores para bytes exigem a sequência 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), insert 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.
Outras 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 oferece um modo que roda com todos os privilégios habilitados, interrupções
desabilitadas e mapeamento 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.
Apêndice E Uma Visão Geral das Arquiteturas RISCs para Computadores Desktop...

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 endereços que ignoram os três bits menos significativos. As instruções de
extração, então, selecionam 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 formatos 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.
E.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 otimizaçã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 custo-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 registradores únicos, uma implementação do SPARC pode ter entre 40 e 520
registradores físicos, embora 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 instruçã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 registradores origem são da janela do callee e o registrador destino da janela do caller.
Isso libera automaticamente o frame de pilha. Os compiladores também podem fazer uso
dela para gerar o valor de retorno final do callee.
25
26
Material Complementar
ELSEVIER
O risco das janelas de registradores é que o maior número de registradores pode diminuir a velocidade de clock. Esse não foi o caso para as primeiras implementações.
A arquitetura SPARC (com janelas de registradores) e a arquitetura MIPS R2000 (sem
janelas) foram construídas em diversas tecnologias 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 gerenciamento 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 janela 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 de usuário, a instrução RETURN irá
retornar da trap no modo não privilegiado.
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 influenciou alguns dos recursos do SPARC já discutidos: janelas de
registradores, instruções de trap condicionais, 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 operaçõ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 subsequente 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 dados marcados, já que
carregar de um ponteiro com a tag errada pode ser um acesso inválido. A Figura E.9.1
mostra os dois tipos de suporte de tag.
Apêndice E Uma Visão Geral das Arquiteturas RISCs para Computadores Desktop...
FIGURA E.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 operandos 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).
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 processador 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, especi-
ficar r31 o torna semelhante a JALR no MIPS e especificar r0 o torna como JR.
 LDSTUB carrega o valor do byte em Rd e, depois, armazena 0xFF16 no byte endereçado.
Essa instrução da versão 8 pode ser usada para implementar a sincronização (veja o
Capítulo 2).

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.
27
28
Material Complementar
ELSEVIER
 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 estruturas de controle condicional que controlam seu uso. Consequentemente,
os loads infalíveis serã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 operandos 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.
E.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 8800.
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 chamada 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
for 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 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 desvios, e um dos problemas na previsão de desvios é obter o endereço
de destino no início do pipeline (veja o Apêndice B), os arquitetos do PowerPC decidiram fazer um segundo uso desses registradores. 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).
Apêndice E Uma Visão Geral das Arquiteturas RISCs para Computadores Desktop...
Outras instruções
Diferente da maioria das outras máquinas RISCs, o registrador 0 não é fisicamente conectado ao valor 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 PowerPC são os seguintes:

Load multiple e store multiple salvam ou restauram até 32 registradores em uma única
instrução.
 LSW e STSW permitem a busca e o armazenamento de strings de comprimento variável
que possuem 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 2 que seja arredondada para 0 pode ser conseguida com um SRAWI
seguido de ADDZE, o que adiciona CA ao registrador.

CBTLZ conta zeros à esquerda.

SUBFIC calcula (imediato – RA), que pode ser usado para desenvolver um complemento a um ou a dois.

Instruções logical shifted immediate deslocam o imediato de 16 bits para a esquerda
em 16 bits antes de realizar AND, OR ou XOR.
E.11 Instruções específicas do PA-RISC 2.0
O PA-RISC foi expandido ligeiramente em 1990 com a versão 1.1 e mudou significativamente na versão 2.0 com extensões de 64 bits em 1996. O PA-RISC talvez possua os recursos
mais incomuns de todas as máquinas RISC. Por exemplo, ele possui a maioria dos modos
de endereçamento, formatos de instrução e, como veremos, várias instruções que são, na
verdade, a combinação de duas instruções mais simples.
Nulificação
Como mostrado na Figura E.6.9, várias máquinas RISCs podem escolher não executar a
instrução seguinte a um delayed branch para melhorar a utilização do branch slot. Isso é
chamado nulificação no PA-RISC e foi generalizado para se aplicar a qualquer instrução
lógica e aritmética, bem como a todos os desvios. Portanto, uma instrução add pode somar dois operandos, armazenar a soma e fazer com que a instrução seguinte seja saltada
se a soma for zero. Assim como as instruções move condicional, a nulificação permite ao
PA-RISC evitar desvios em casos em que há apenas uma instrução na parte then de uma
instrução if.
29
30
Material Complementar
ELSEVIER
Uma profusão de desvios condicionais
Com a nulificação, o PA-RISC não precisava ter instruções de desvio condicional separadas.
Os inventores poderiam ter recomendado que as instruções de nulificação precedessem os
desvios condicionais, simplificando, portanto, o conjunto de instruções. Em vez disso, no
entanto, o PA-RISC possui o maior número de desvios condicionais de todas as máquinas
RISC. A Figura E.11.1 mostra os desvios condicionais do PA-RISC. Como você pode ver,
vários deles são, na verdade, combinações de duas instruções.
Nome
Instrução
Notação
COMB
Compare e branch
if (cond(Rs1,Rs2))
{PC <— PC + offset12}
COMIB
Compare imm. e branch
if (cond(imm5,Rs2))
{PC <— PC + offset12}
MOVB
Move e branch
Rs2 <— Rs1, if (cond(Rs1,0))
{PC <— PC + offset12}
MOVIB
Move immediate e branch
Rs2 <— imm5, if (cond(imm5,0))
{PC <— PC + offset12}
ADDB
Add e branch
Rs2 <— Rs1 + Rs2, if (cond(Rs1 + Rs2,0))
{PC <— PC + offset12}
ADDIB
Add imm. e branch
Rs2 <— imm5 + Rs2, if (cond(imm5 + Rs2,0))
{PC <— PC + offset12}
BB
Branch on bit
if (cond(Rsp,0)
{PC <— PC + offset12}
BVB
Branch on variable bit
if (cond(Rssar,0)
{PC <— PC + offset12}
Figura E.11.1 Instruções de desvio condicional do PA-RISC. O offset de 12 bits é chamado offset12 nessa tabela, e o imediato de 5 bits é chamado imm5.
As 16 condições são =, <, <=, ímpar, overflow com sinal, sem sinal sem overflow, zero ou sem overflow sem sinal, nunca e seus respectivos complementos. A instrução BB seleciona um dos 32 bits do registrador e desvia dependendo de seu valor ser 0 ou 1. A instrução BVB seleciona o bit para desvio usando o registrador
shift amount, um registrador de uso especial. A notação subscrita especifica um campo de bit.
Multiplicação e divisão sintetizadas
O PA-RISC fornece várias primitivas para que a multiplicação e a divisão possam ser sintetizadas por software. As instruções que deslocam um operando 1, 2 ou 3 bits e, depois,
somam, gerando ou não trap no caso de ocorrer overflow, são úteis nas multiplicações. (O
Alpha também inclui instruções que multiplicam o segundo operando de adds e subtracts
por 4 ou 8: S4ADD, S8ADD, S4SUB e S8SUB.) A etapa de divisão realiza a etapa crítica da
divisão sem restauração, somando ou subtraindo, dependendo do sinal do resultado anterior. Magenheimer et al. [1988] mediram o tamanho dos operandos em multiplicações e
divisões para mostrar como a etapa de multiplicação funcionaria bem. Usando esses dados
para programas C, Muchnick [1988] descobriu que criando casos especiais, a multiplicação
média por uma constante leva 6 ciclos de clock e a multiplicação de variáveis leva 24 ciclos
de clock. O PA-RISC possui 10 instruções para essas operações.
A arquitetura SPARC original usava otimizações semelhantes, mas com o crescente
número de transistores, o conjunto de instruções foi expandido para incluir operações de
multiplicação e divisão completas. O PA-RISC oferece algum suporte desse tipo colocando
uma multiplicação inteira de 32 bits completa na unidade de ponto flutuante; entretanto,
os dados de inteiros precisam primeiro ser movidos para registradores de ponto flutuante.
Operações decimais
Os programas Cobol realizam cálculos com valores decimais, armazenados como 4 bits por
dígito, em vez de converter entre binário e decimal e vice-versa. O PA-RISC possui instruções que convertem a soma de um add de 32 bits normal em dígitos decimais apropriados.
Ele também fornece operações lógicas e aritméticas que definem os códigos de condição
para testar carries de dígitos, bytes ou halfwords. Essas operações também testam se bytes
ou halfwords são zero. Essas operações seriam úteis na aritmética em caracteres ASCII de
8 bits. Cinco instruções PA-RISC fornecem suporte decimal.
Apêndice E Uma Visão Geral das Arquiteturas RISCs para Computadores Desktop...
Outras instruções
Aqui estão as outras instruções PA-RISC:

Branch vetorizado desloca um registrador de índice 3 bits à esquerda, o adiciona a
um registrador de base e, depois, desvia para o endereço calculado. É usado para
instruções case.

Instruções extract e deposit permitem que campos de bit arbitrários sejam selecionados de ou inseridos em registradores. As variações incluem se o campo
extraído possui extensão de sinal, se o campo de bit é especificado diretamente
na instrução ou indiretamente em outro registrador e se o restante do registrador
é colocado em zero ou deixado inalterado. O PA-RISC possui 12 instruções desse
tipo.

Para simplificar o uso das constantes de endereço de 32 bits, o PA-RISC inclui
ADDIL, que soma uma constante de 21 bits ajustada à esquerda com um registrador e coloca o resultado no registrador 1. A instrução seguinte de transferência
de dados usa endereçamento de offset para somar os 11 bits menos significativos
do endereço com o registrador 1. Esse par de instruções permite que o PA-RISC
some uma constante de 32 bits com um registrador de base, ao custo de modificar
o registrador 1.

O PA-RISC possui nove instruções de depuração que pode definir pontos de interrupção em instruções ou endereços de dados e retornar os endereços interceptados.

Instruções load e clear fornecem um semáforo ou lock que lê um valor da memória
e, depois, escreve zero.

Store bytes short otimiza movimentações de dados desalinhados, movendo os bytes
mais à esquerda ou mais à direita em uma word para o endereço real, dependendo
das opções de instrução e dos bits de código de condição.

Loads e stores funcionam bem com caches tendo opções que fornecem indicações
sobre se os dados devem ser carregados na cache se já não estiverem lá. Por exemplo,
load com um destino do registrador 0 é definido para ser prefetch de cache controlado
pelo software.

O PA-RISC 2.0 estendeu as indicações de cache para stores para indicar cópias em
bloco, recomendando que o processador não carregue dados na cache se eles ainda
não estiverem lá. Ele também pode sugerir que, nos loads e stores, haja localidade
espacial para preparar a cache para acessos sequenciais subsequentes.

O PA-RISC 2.0 também fornece uma pilha de destinos de desvio opcional para prever
jumps indiretos usados em retornos de sub-rotina. O software pode sugerir quais
endereços são colocados na pilha dos destinos de desvio e removidos dela, mas o
hardware controla se esses endereços são válidos ou não.

Multiply/add e multiply/subtract são operações de ponto flutuante que podem iniciar
duas operações de ponto flutuante independentes em uma única instrução, além das
operações reunidas multiply/add e multiply/negate/add introduzidas na versão 2.0
do PA-RISC.
31
32
Material Complementar
E.12 ELSEVIER
Instruções específicas do ARM
É difícil escolher o recurso mais incomum do ARM, mas talvez ele seja a execução condicional de instruções. Cada instrução começa com um campo de 4 bits que determina se
ela agirá como uma instrução nop ou como uma instrução real, dependendo dos códigos
de condição. Portanto, os desvios condicionais são apropriadamente considerados como
executando condicionalmente a instrução branch incondicional. A execução condicional
permite evitar que um branch salte sobre uma única instrução. Ela exige menos espaço de
código e tempo para executar condicionalmente uma instrução.
O campo imediato de 12 bits possui uma nova interpretação. Os 8 bits menos significativos são estendidos em zero para um valor de 32 bits e, então, girados para a direita no
número de bits especificado nos primeiros 4 bits do campo multiplicados por 2. Se essa
divisão realmente captura mais imediatos do que um campo de 12 bits simples seria um
estudo interessante. Uma vantagem é que esse esquema pode representar todas as potências
de 2 em uma word de 32 bits.
O deslocamento de operando não está limitado a imediatos. O segundo registrador de
todas as operações de processamento lógicas e aritméticas tem a opção de ser deslocado
antes de ser operado. As opções de deslocamento são shift left logical, shift right logical,
shift right arithmetic e rotate right. Novamente, seria interessante ver com que frequência
operações como rotate-and-add, shift-right-and-test etc. ocorrem nos programas ARM.
Outras instruções
A seguir está uma lista das instruções restantes que são únicas da arquitetura ARM:

Block loads e stores – Sob o controle de uma máscara de 16 bits dentro das instruções,
qualquer um dos 16 registradores pode ser carregado ou armazenado na memória em
uma única instrução. Essas instruções podem salvar e restaurar registradores na entrada
e no retorno do procedimento. Essas instruções também podem ser usadas para cópia
de memória em bloco – oferecendo até quatro vezes a largura de banda de um único
load-store de registrador –, e, hoje, as cópias de bloco são o uso mais importante.

Reverse subtract – RSB permite que o primeiro registrador seja subtraído do registrador imediato ou deslocado. RSC faz a mesma coisa, mas inclui o carry quando
calcula a diferença.

Long multiplys – Semelhante ao MIPS, os registradores Hi e Lo obtêm o produto com
sinal de 64 bits (SMULL) ou o produto sem sinal de 64 bits (UMULL).

No divide – Como o Alpha, divisão de inteiros não é suportada no hardware.

Trap condicional – Uma extensão comum ao núcleo MIPS encontrada nos RISCs
desktop (Figuras E.6.1 a E.6.4) que vem gratuitamente na execução condicional de
todas as instruções ARM, inclusive SWI.

Interface de coprocessador – Como a maioria dos RISCs desktop, o ARM define um
conjunto completo de instruções de coprocessador: movimentação de dados, move
entre registradores de uso geral e de coprocessador, e operações de coprocessador.

Arquitetura de ponto flutuante – Usando a interface de coprocessador, uma arquitetura de ponto flutuante foi definida para o ARM. Ela foi implementada como o
coprocessador FPA10.

Conjuntos de instruções branch e exchange – A instrução BX é a transição entre o ARM
e o Thumb, usando os 31 bits menos significativos do registrador para definir o PC
e o bit mais significativo para determinar se o modo é ARM (1) ou Thumb (0).
Apêndice E Uma Visão Geral das Arquiteturas RISCs para Computadores Desktop...
E.13 Instruções específicas do Thumb
No modelo do ARM versão 4, os procedimentos frequentemente executados usarão instruções ARM para obter o máximo desempenho, com os procedimentos menos executados
usando o Thumb para reduzir o tamanho de código geral do programa. Como normalmente apenas alguns procedimentos dominam o tempo de execução, a esperança é que
essa hibridez alcance o melhor dos dois mundos.
Embora as instruções do Thumb sejam traduzidas pelo hardware em instruções ARM
convencionais para execução, existem várias restrições. Primeiro, a execução condicional é
descartada de quase todas as instruções. Segundo, apenas os 8 primeiros registradores estão
facilmente disponíveis em todas as instruções, com o stack pointer, o registrador link e o
contador de programa usados implicitamente em algumas instruções. Terceiro, o Thumb usa
um formato de dois operandos para poupar espaço. Quarto, os imediatos únicos deslocados
e os segundos operandos deslocados desapareceram e foram substituídos por instruções de
deslocamento separadas. Quinto, os modos de endereçamento estão simplificados. Por fim,
colocar todas as instruções em 16 bits força muito mais formatos de instrução.
Em muitos aspectos, a arquitetura Thumb simplificada é mais convencional do que o
ARM. Aqui estão mudanças adicionais feitas do ARM para o Thumb:

Abandono das instruções lógicas imediatas – As imediatas lógicas acabaram.

Códigos de condição implícitos – Em vez de ter códigos de condição definidos opcionalmente, eles são definidos pelo opcode. Todas as instruções da ALU e nenhuma
das transferências de dados definem os códigos de condição.

Acesso aos registradores Hi/Lo – Os 16 registradores ARM são divididos em registradores Lo e registradores Hi, com os 8 registradores Hi incluindo o stack pointer
(SP), registrador link e o PC. Os registradores Lo estão disponíveis em todas as
operações da ALU. Variações de ADD, BX, CMP e MOV também funcionam com todas
as combinações dos registradores Hi e Lo. Os registradores SP e PC também estão
disponíveis em variações das transferências de dados e adds imediatos. Quaisquer
outras operações nos registradores Hi exigem um MOV para colocar o valor em um
registrador Lo, realizar a operação lá e, depois, transferir os dados de volta para o
registrador Hi.

Distância do branch/call – Como as instruções possuem 16 bits de largura, o endereço
do branch condicional de 8 bits é deslocado de 1 em vez de 2. O branch com link é especificado em duas instruções, concatenando 11 bits de cada instrução e os deslocando
para a esquerda para formar um endereço de 23 bits para carregar no PC.

Distância para offsets de transferência – O offset agora é de 5 bits para os registradores
de uso geral e de 8 bits para SP e PC.
E.14 Instruções específicas do SuperH
O registrador 0 desempenha um papel especial nos modos de endereçamento do SuperH.
Ele pode ser adicionado a outro registrador para formar um endereço no endereçamento
indexado indireto e no endereçamento relativo ao PC. R0 é usado para carregar constantes
a fim de fornecer uma faixa de endereçamento mais ampla do que pode caber facilmente
nas instruções de 16 bits do SuperH. R0 também é o único registrador que pode ser um
operando para versões imediatas de AND, CMP, OR e XOR.
33
34
Material Complementar
ELSEVIER
A seguir, está uma lista dos outros detalhes exclusivos da arquitetura SuperH:

Decrement and test – DT decrementa um registrador e coloca o bit T em 1 se o resultado for 0.

Delayed branch opcional – Embora as outras máquinas RISC embutidas geralmente
não usem delayed branches (veja o Apêndice B), o SuperH oferece execução opcional
de delayed branches para BT e BF.

Muitos multiplys – Dependendo se a operação é com ou sem sinal, se os operandos são
de 16 ou 32 bits, ou se o produto é de 32 ou 64 bits, a instrução multiply apropriada é
MULS, MULU, DMULS, DMULU ou MUL. O produto é encontrado nos registradores MACL
e MACH.

Extensão de zeros e de sinal – Bytes ou halfwords possuem extensão de zeros (EXTU)
ou de sinal (EXTS) dentro de um registrador de 32 bits.

Deslocamentos de um bit – Talvez numa tentativa de fazê-las caberem dentro de instruções de 16 bits, as instruções de deslocamento apenas deslocam um único bit de
cada vez.

Deslocamento dinâmico – Esses deslocamentos variáveis testam o sinal da quantidade
em um registrador para determinar se ele desloca para a esquerda (positivo) ou para
a direita (negativo). São aceitas instruções lógicas (SHLD) e aritméticas (SHAD). Essas
instruções ajudam a deslocar de quantidades constantes de 1 bit com os deslocamentos padrão.

Rotate – O SuperH oferece rotações de 1 bit à esquerda (ROTL) e à direita (ROTR), que
colocam o bit T com o valor girado, e também possui variações que incluem o bit T
nas rotações (ROTCL e ROTCR).

SWAP – Esta instrução troca os bytes alto e baixo de uma word de 32 bits ou os dois
bytes dos 16 bits mais à direita.

Extract word (XTRCT) – Os 32 bits intermediários de um par de registradores de 32
bits são colocados em outro registrador.

Negate com carry – Como SUBC (Figura E.6.6), exceto que o primeiro operando é 0.

Prefetch de cache – Como muitos RISCs desktop (Figuras E.6.1 a E.6.4), o SuperH
possui uma instrução (PREF) para realizar prefetch de dados na cache.

Test-and-set – O SuperH usa a antiga instrução test-and-set (TAS) para realizar locks
atômicos ou semáforos (veja o Capítulo 2). TAS primeiro carrega um byte da memória. Depois, ele coloca o bit T em 1 se o byte é 0 ou em 0 se o byte não é zero. Por
fim, ele coloca o bit mais significativo do byte em 1 e escreve o resultado novamente
na memória.
E.15 Instruções específicas do M32R
O recurso mais comum do M32R é um pequeno método VLIW para o par de instruções
de 16 bits. Um bit é reservado na primeira instrução do par para dizer se essa instrução
pode ser executada em paralelo com a próxima instrução – ou seja, as duas instruções são
independentes –, ou se as duas precisam ser executadas sequencialmente. (Uma máquina
anterior que oferecia uma opção semelhante foi o Intel i860.) Esse recurso está incluído
para futuras implementações da arquitetura.
Apêndice E Uma Visão Geral das Arquiteturas RISCs para Computadores Desktop...
Uma surpresa é que todos os deslocamentos de desvio são deslocados 2 bits à esquerda
antes de serem somados ao PC, e os 2 bits inferiores do PC são colocados em 0. Como
algumas instruções possuem apenas 16 bits de tamanho, esse deslocamento significa que
um desvio não pode ir para qualquer instrução no programa: ele só pode desviar para instruções nos limites de word. Uma restrição semelhante é colocada no endereço de retorno
para as instruções de link branch-and-link e jump-and-link: elas só podem retornar para
um limite de word. Portanto, para uma distância de desvio ligeiramente maior, o software
precisa garantir que todos os endereços de desvio e todos os endereços de retorno estejam
alinhados a um limite de word. O espaço de código do M32R é provavelmente um pouco
maior e talvez execute mais instruções NOP do que executaria se o endereço de desvio
fosse deslocado apenas 1 bit à esquerda.
Entretanto, o recurso VLIW acima significa que um NOP pode ser executado em paralelo
com outra instrução de 16 bits, de modo que o enchimento não leve mais ciclos de clock.
A expansão do tamanho de código depende da capacidade do compilador em programar
código e parear instruções de 16 bits sucessivas; a Mitsubishi afirma que o tamanho de
código geral é apenas 7% maior do que para a arquitetura Motorola 6800.
O último novo recurso é que o resultado da operação de divisão é o resto em vez do
quociente.
E.16 Instruções específicas do MIPS-16
O MIPS-16 não é realmente um conjunto de instruções separado, mas sim uma extensão
de 16 bits da arquitetura MIPS completa de 32 bits. Ele é comparável com qualquer uma
das arquiteturas MIPS de endereçamento de 32 bits (MIPS I, MIPS II) ou as arquiteturas de
64 bits (MIPS III, IV, V). O bit de modo ISA determina a largura das instruções: 0 significa
instruções de 32 bits e 1 significa instruções de 16 bits de largura. A nova instrução JALX
alterna o bit de modo ISA para o outro ISA. JR e JALR foram reconfigurados para definir
o bit de modo ISA do bit mais significativo do registrador contendo o endereço de desvio,
e esse bit não é considerado parte do endereço. Todas as instruções jump-and-link salvam
o bit de modo atual como o bit mais significativo do endereço de retorno.
Portanto, o MIPS possui suporte para procedimentos inteiros contendo instruções
de 16 bits ou de 32 bits, mas ele não suporta a mistura das duas extensões em um único
procedimento. As únicas exceções são o JAL e o JALX: essas duas instruções precisam de
32 bits mesmo no modo de 16 bits, presumivelmente para obter um endereço grande o
bastante para desviar para procedimentos distantes.
Ao optar por esse subconjunto, o MIPS decidiu incluir opcodes para algumas instruções
de três operandos e manter 16 opcodes para operações de 64 bits. A combinação desses
muitos opcodes e operandos em 16 bits levou os arquitetos a fornecerem apenas 8 registradores fáceis de usar – assim como o Thumb –, enquanto os outros RISCs embutidos
oferecem aproximadamente 16 registradores. Como o hardware precisa incluir todos os
32 registradores do modo ISA de 32 bits, o MIPS-16 inclui instruções de movimentação
para copiar valores entre os 8 registradores do MIPS-16 e os outros 24 registradores da
arquitetura MIPS completa. Para reduzir a carga sobre os 8 registradores visíveis, o stack
pointer é considerado um registrador separado. O MIPS-16 inclui uma variedade de opcodes separados para realizar transferências de dados usando SP como um registrador de
base e para incrementar SP: LWSP, LDSP, SWSP, SDSP, ADJSP, DADJSP, ADDIUSPD e DADDIUSP.
Para permanecerem no limite de 16 bits, os campos imediatos geralmente foram reduzidos para 5 a 8 bits. O MIPS-16 oferece um meio de estender seus imediatos mais curtos
para a largura total dos imediatos no modo de 32 bits. Usando um truque do Intel 8086, a
instrução EXTEND é, na verdade, um prefixo de 16 bits que pode ser prefixado em qualquer
instrução do MIPS-16 com um campo de endereço ou imediato. O prefixo fornece bits
suficientes para transformar os campos de 5 bits das transferências de dados e os campos
35
36
Material Complementar
ELSEVIER
de 5 a 8 bits dos imediatos aritméticos em constantes de 16 bits. Infelizmente, existem duas
exceções. ADDIU e DADDIU iniciam com campos imediatos de 4 bits, mas, como EXTEND só
pode fornecer mais 11 bits, o imediato mais largo é limitado a 15 bits. EXTEND também
estende os campos de deslocamento de 3 bits para campos de 5 bits. (Caso esteja curioso,
o prefixo EXTEND não precisa começar em um limite de 32 bits.)
Para melhorar mais o suprimento de constantes, o MIPS-16 incluiu um novo modo
de endereçamento! O endereçamento relativo ao PC para load word (LWPC) e load double
(LDPC) desloca um campo imediato de 8 bits por 2 ou 3 bits, respectivamente, adicionando-o ao PC com os 2 ou 3 bits menos significativos limpos. A word constante ou a double
constante é, então, carregada em um registrador. Portanto, constantes de 32 ou de 64 bits
podem ser incluídas com código do MIPS-16, apesar da perda do LIU para atribuir valores
aos bits mais significativos de um registrador. Devido ao novo modo de endereçamento, há
também uma instrução (ADDIUPC) para calcular um endereço relativo ao PC e colocá-lo
em um registrador.
O MIPS-16 difere dos outros RISCs embutidos em que ele pode subdividir uma arquitetura de endereçamento de 64 bits. Como resultado, ele possui versões, com tamanho
de instrução de 16 bits, das operações de dados de 64 bits: transferência de dados (LD,
SD, LWU), operações aritméticas (DADDU/IU, DSUBU, DMULT/U, DDIV/U), e deslocamentos
(DSLL/V, DSRA/V, DSRL/V).
Dado o importante papel desempenhado pelo MIPS neste livro, mostramos todas as
mudanças feitas nas instruções do núcleo MIPS para o MIPS-16:

Retirada das instruções aritméticas com sinal – As instruções aritméticas que podem
gerar trap foram removidas para economizar espaço de opcode: ADD, ADDI, SUB, DADD,
DADDI, DSUB.

Retirada das instruções lógicas imediatas – As imediatas se foram também: ANDI, ORI,
XORI.

Instruções de desvio reduzidas – Comparar dois registradores e depois desviar não
coube na nova arquitetura, nem as outras comparações de um registrador com zero.
Consequentemente, estas instruções foram abandonadas: BEQ, BNE, BGEZ, BGTZ, BLEZ
e BLTZ. Como mencionado na Seção E.3, para ajudar a compensar, o MIPS-16 inclui
instruções compare para testar se dois registradores são iguais. Como compare e seton-less-than definem o novo registrador T, foram acrescentados desvios para testar
o registrador T.

Distância de desvio – Como as instruções possuem 16 bits de largura, o endereço de
desvio é deslocado de 1 em vez de 2.

Os delayed branches desapareceram – Os desvios entram em efeito antes da próxima
instrução. Os jumps ainda têm um delay de um slot.

Extensão e distância para offsets de transferência de dados – Os campos de 5 e 8 bits
possuem extensão de zero em vez de extensão de sinal no modo de 32 bits. Para obter
uma faixa maior, os campos imediatos são deslocados em 1, 2 ou 3 bits à esquerda
dependendo de se os dados são halfword, word ou double word. Se o prefixo EXTEND
for anexado a essas instruções, elas usarão o imediato de 16 bits com sinal do modo
de 32 bits.

Extensão dos imediatos aritméticos – Os campos de 5 e 8 bits possuem extensão de
zero para instruções set-on-less-than e compare, para formar um endereço relativo
ao PC, e para acrescentar ao SP e colocar o resultado em um registrador (ADDIUSP,
DADDIUSP). Novamente, se o prefixo EXTEND for anexado a essas instruções, elas
usarão o imediato de 16 bits com sinal convencional do modo de 32 bits. Elas ainda
têm extensão de sinal para adds gerais e para adicionar ao SP e colocar o resultado
novamente no SP (ADJSP, DADJSP). Pena que a densidade de código e a ortogonalidade são companheiras estranhas no MIPS-16!
Apêndice E Uma Visão Geral das Arquiteturas RISCs para Computadores Desktop...

Redefinição do deslocamento de 0 – O MIPS-16 define o valor de 0 no campo shift de
3 bits para representar um deslocamento de 8 bits.

Novas instruções acrescentadas devido à perda do registrador 0 como zero – Load immediate, negate e not foram acrescentados, já que essas operações não podem mais
ser sintetizadas das outras instruções usando r0 como origem.
E.17 37
Comentários finais
Este apêndice aborda os modos de endereçamento, os formatos de instrução e todas as instruções encontradas nas 10 arquiteturas RISCs. Embora as últimas seções se concentrem nas
diferenças, não seria possível cobrir 10 arquiteturas nestas poucas páginas se não houvesse
tanta semelhança. Na verdade, acreditamos que mais de 90% das instruções executadas
para qualquer uma dessas arquiteturas seriam encontradas nas Figuras E.3.5 a E.3.11. Para
contrastar essa homogeneidade, a Figura E.17.1 fornece um resumo das quatro arquiteturas
desde a década de 1970 em um formato semelhante ao mostrado na Figura E.1.1. (Imagine tentar escrever um único capítulo nesse estilo para essas arquiteturas!) Na história
da computação, nunca existiu tamanha concordância na arquitetura de computadores.
IBM 360/370
Intel 8086
Motorola 68000
DEC VAX
Data de anúncio
Tamanho(s) das instruções (bits)
Endereçamento (tamanho, modelo)
1964/1970
16, 32, 48
24 bits, flat/31 bits,
flat
1978
1980
8, 16, 24, 32, 40, 48
16, 32, 48, 64, 80
4 + 16 bits, segmentado 24 bits, flat
1977
8, 16, 24, 32, ..., 432
32 bits, flat
Dados alinhados?
Modos de endereçamento de dados
Proteção
Tamanho da página
E/S
Registradores inteiros (tamanho, modelo, número)
Sim 360/Não 370
2/3
Página
2 KB & 4 KB
Código da operação
16 GPR × 32 bits
Não
14
Página
0.5 KB
Mapeado em memória
15 GPR × 32 bits
Registradores de ponto flutuante separados
Formato de ponto flutuante
4 × 64 bits
IBM (hexadecimal
floating)
Não
5
Nenhuma
—
Código da operação
8 dados dedicados ×
16 bits
Opcionais: 8 × 80 bits
IEEE 754 single, double,
extended
Alinhado em 16 bits
9
Opcional
0.25 a 32 KB
Mapeado em memória
8 dados e 8 endereço ×
32 bits
Opcionais: 8 × 80 bits
IEEE 754 single, double,
extended
0
DEC
FIGURA E.17.1 Resumo de quatro arquiteturas da década de 1970. Ao contrário das arquiteturas na E.1.1, existe pouco acordo entre essas arquiteturas em
qualquer categoria.
Esse estilo de arquitetura, no entanto, não pode permanecer estático. Assim como as
pessoas, os conjuntos de instruções tendem a se tornar cada vez maiores conforme ficam
mais velhos. A Figura E.17.2 mostra a genealogia desses conjuntos de instruções, e a Figura
E.17.3 mostra quais registradores foram acrescentados ou removidos das gerações de RISCs
desktop ao longo do tempo.
Como você pode ver, todas as máquinas RISCs desktop evoluíram para arquiteturas de
64 bits, e fizeram isso de maneira bastante tranquila.
38
Material Complementar
ELSEVIER
1960
CDC 6600
1963
1965
IBM ASC 1968
1970
1975
1980
Berkeley RISC-1
Stanford MIPS
1981
1982
ARM2
1987
1995
America
1985
ARM1
1985
1985
1990
IBM 801
1975
Cray-1
1976
SuperH
1992
ARM3
1990
Thumb ARM v.4
1995
M32R 1995
1997
SPARC v.8
1987
SPARC v.9
1994
MIPS-16
1996
MIPS I
1986
PA-RISC
1986
MIPS II Digital PRISM
1988
1989
PA-RISC 1.1
MIPS III
1990
Alpha
1992
1992
MIPS IV
1994
MIPS V
1996
RT/PC
1986
Power1
1990
Power2 PowerPC
1993
1993
Alpha v.3 PA-RISC 2.0
1996
1996
2000
2002
MIPS-32
2002
MIPS-64
2002
FIGURA E.17.2 A linhagem dos conjuntos de instruções RISCs. As máquinas comerciais são mostradas em texto
regular e as máquinas de pesquisa, em negrito. O CDC-6600 e o Cray-1 eram máquinas load-store com registrador 0
fixo em 0, e os registradores de inteiros e de ponto flutuante separados. As instruções não podiam cruzar as fronteiras mundiais. Uma máquina de pesquisa da IBM anterior levou aos projetos de pesquisa 801 e America, com o 801
levando ao malsucedido RT/PC e o America levando à bem-sucedida arquitetura Power. Mais tarde, algumas pessoas
que trabalhavam no 801 se juntaram à Hewlett-Packard para trabalhar no PA-RISC. Os dois projetos de universidade
foram a base das máquinas MIPS e SPARC. Segundo Furber [1996], o projeto RISC de Berkeley foi a inspiração da
arquitetura ARM. Embora ARM1, ARM2 e ARM3 tenham sido nomes de arquiteturas e de chips, o ARM versão 4 é o
nome da arquitetura usada nos chips ARM7, ARM8 e StrongARM. (Não existem chips ARM v.4 e ARM5, mas os chips
ARM6 e os primeiros chips ARM7 usam a arquitetura ARM3.) A DEC construiu um microprocessador RISC em 1988
mas não o introduziu no mercado. Em vez disso, a DEC lançou estações de trabalho usando microprocessadores MIPS
pelos três anos antes de lançarem seu próprio conjunto de instruções RISC, o Alpha 21064, muito semelhante ao MIPS
III e PRISM. A arquitetura Alpha teve pequenas extensões, mas não foram formalizadas com números de versão; nós
usamos “versão 3” porque essa é a versão do manual de referência. O chip Alpha 21164A acrescentou loads e stores para
bytes e halfwords, e o Alpha 21264 inclui as instruções MAX de multimídia e contagem de bit. Internamente, a Digital
nomeia os chips conforme a tecnologia de fabricação: EV4 (21064), EV45 (21064A), EV5 (21164), EV56 (21164A) e
EV6 (21264). “EV” significa “extended VAX” (ou “VAX estendido”).
Gostaríamos de agradecer as seguintes pessoas pelos comentários sobre os rascunhos
deste apêndice: professor Steven B. Furber, University of Manchester; Dr. Dileep Bhandarkar, Intel Corporation; Dr. Earl Killian, Silicon Graphics/MIPS; e Dr. Hiokazu Takata,
Mitsubishi Electric Corporation.
Apêndice E Uma Visão Geral das Arquiteturas RISCs para Computadores Desktop...
PA-RISC
Recurso
Loads com interlock
Load-store FP double
Semáforo
Raiz quadrada
Ops FP de precisão simples
Sincronismo de memória
Coprocessador
Endereçamento base + índice
Equivalência a 32 registradores FP de 64 bits
Anulação de delayed branch
Conteúdo do registrador de desvio
Big/Little Endian
Bit de previsão de desvios
Move condicional
Prefetch de dados na cache
Ops endereçamento/int. 64 bits
Multiplicação, divisão de 32 bits
Load-store FP quad
Fused FP mul/add
Instruções de string
Suporte a multimídia
SPARC
1.0
1.1
2.0
v.8
v.9
X
X
X
X
X
X
X
X
“
“
“
“
“
“
“
“
“
“
“
+
“
“
“
“
“
“
“
“
“
“
“
“
X
X
X
X
X
X
X
X
“
“
“
“
“
“
–
“
+
“
+
+
+
+
+
+
+
+
X
X
+
X
+
+
“
MIPS
I
X
X
X
X
X
“
X
“
Power
II
III
IV
+
+
+
+
“
+
“
“
“
“
“
“
“
“
+
“
“
+
+
“
“
“
“
“
+
“
“
“
“
“
“
“
“
+
“
“
“
“
“
+
+
“
“
+
X
39
V
+
X
“
X
1
2
PC
X
X
X
“
“
“
+
X
“
“
“
“
“
+
“
X
X
“
“
“
“
X
X
X
“
“
“
X
“
+
“
“
X
X
+
“
–
“
+
“
–
“
–
FIGURA E.17.3 Recursos acrescentados às máquinas RISCs desktop. X significa na máquina original, + significa acrescentado posteriormente, “ significa
continuado da máquina anterior e – significa removido da arquitetura. O Alpha não está incluído, mas acrescentou loads e stores para bytes e words, além de
extensões para multimídia e contagem de bits na versão 3. O MIPS V incluiu as instruções MDMX e pareou operações de ponto flutuante simples.
Leitura adicional
Bhandarkar, E. P. [1995]. Alpha Architecture and Implementations, Newton, MA: Digital Press.
Darcy, J. E. e E. Gay [1996]. “FLECKmarks: Measuring floating point performance using a full IEEE
compliant arithmetic benchmark”, projeto de classe CS 252, U.C. Berkeley (veja HTTP.CS.Berkeley.
EDU/~darcy/Projects/cs252/).
Digital Semiconductor [1996]. Alpha Architecture Handbook, Version 3, Maynard, MA: Digital Press,
Número de pedido EC-QD2KB-TE (outubro).
Furber, S. B. [1996]. ARM System Architecture, Harlow, England: Addison-Wesley. (veja www.cs.man.
ac.uk/amulet/publications/books/ARMsysArch).
Hewlett-Packard [1994]. PA-RISC 2.0 Architecture Reference Manual, 3a ed.
Hitachi [1997]. SuperH RISC Engine SH7700 Series Programming Manual (veja www.halsp.hitachi.com/
tech_prod/ e procure o título).
IBM [1994]. The PowerPC Architecture, San Francisco: Morgan Kaufmann.
Kane, G. [1996]. PA-RISC 2.0 Architecture, Upper Saddle River, N.J.: Prentice-Hall PTR.
Kane, G. e J. Heinrich [1992]. MIPS RISC Architecture, Englewood Cliffs, NJ: Prentice-Hall.
Kissell, K. E. [1997]. MIPS16: High-Density for the Embedded Market (veja www.sgi.com/MIPS/ arch/
MIPS16/MIPS16.whitepaper.pdf).
Magenheimer, D. J., L. Peters, K. W. Pettis e D. Zuras [1988]. “Integer multiplication and division on the
HP precision architecture”, IEEE Trans. on Computers 37:8, 980–90.
40
Material Complementar
ELSEVIER
MIPS [1997]. MIPS16 Application Specific Extension Product Description (veja www.sgi .com/MIPS/
arch/MIPS16/mips16.pdf).
Mitsubishi [1996]. Mitsubishi 32-Bit Single Chip Microcomputer M32R Family Software Manual (setembro).
Muchnick, S. S. [1988]. “Optimizing compilers for SPARC”, Sun Technology 1:3 (Verão), 64–77.
Seal, D. Arm Architecture Reference Manual, segunda edição, Morgan Kaufmann, 2000.
Silicon Graphics [1996]. MIPS V Instruction Set (veja http://www.sgi.com/MIPS/arch /ISA5/#MIPSV_indx).
Sites, R. L. e R. Witek (eds.) [1995]. Alpha Architecture Reference Manual, segunda edição. Newton, MA:
Digital Press.
Sloss, A. N., D. Symes e C. Wright, ARM System Developer’s Guide, San Francisco: Elsevier Morgan Kaufmann, 2004.
Sun Microsystems [1989]. The SPARC Architectural Manual, Version 8, Part no 800-1399-09, 25 de agosto.
Sweetman, D. Ver MIPS Run, segunda edição, Morgan Kaufmann, 2006.
Taylor, G., P. Hilfinger, J. Larus, E. Patterson e B. Zorn [1986]. “Evaluation of the SPUR LISP architecture”,
Proc. 13th Symposium on Computer Architecture (junho), Tóquio.
Ungar, D., R. Blau, P. Foley, D. Samples e D. Patterson [1984]. “Architecture of SOAR: Smalltalk on a RISC”,
Proc. 11th Symposium on Computer Architecture (junho), Ann Arbor, MI, 188–97.
Weaver, D. L. e T. Germond [1994]. The SPARC Architectural Manual, Versão 9, Englewood Cliffs, NJ:
Prentice-Hall.
Weiss, S. e J. E. Smith [1994]. Power and PowerPC, São Francisco: Morgan Kaufmann.