Uma Visão Geral das Arquiteturas RISCs para Computadores...

ERISC: qualquer computador anunciado após 1985.

Steven PrzybylskicUm projetista do MIPS de Stanford

Uma Visão Geral das Arquiteturas RISCs para Computadores Desktop, Servidores e Embutidos

A P Ê N D I C E

E.1 Introduçã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çõesespecíficasdoMIPS-64 E-25

E.8 InstruçõesespecíficasdoAlpha E-27

E.9 InstruçõesespecíficasdoSPARCv.9 E-29

E.10 InstruçõesespecíficasdoPowerPC E-32

E.11 InstruçõesespecíficasdoPA-RISC2.0 E-34

E.12 InstruçõesespecíficasdoARM E-36

E.13 InstruçõesespecíficasdoThumb E-38

E.14 InstruçõesespecíficasdoSuperH E-39

E.15 InstruçõesespecíficasdoM32R E-40

E.16 InstruçõesespecíficasdoMIPS-16 E-40

E.17 Comentáriosfinais 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 per-mite 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 MIPS I PA-RISC 1.1 PowerPC SPARC v.8

Data do anúncio 1992 1986 1986 1993 1987Tamanho de instrução (bits) 32 32 32 32 32Espaço de endereçamento (tamanho, modelo)

64 bits, contínuo 32 bits, contínuo 48 bits, segmentado 32 bits, contínuo 32 bits, contínuo

Alinhamento de dados Alinhado Alinhado Alinhado Desalinhado AlinhadoModos de endereçamento de dados 1 1 5 4 2Proteção Página Página Página Página PáginaTamanho de página mínimo 8KB 4KB 4KB 4KB 8KBE/S Mapeada em memória Mapeada em memória Mapeada em memória Mapeada em memória Mapeada em memóriaRegistradores de inteiros (número, modelo, tamanho)

31GPR × 64 bits 31GPR × 32 bits 31GPR × 32 bits 32GPR × 32 bits 31GPR × 32 bits

Registradores de ponto flutuante separados

31 × 32 ou 31 × 64 bits

16 × 32 ou 16 × 64 bits

56 × 32 ou 28 × 64 bits

32 × 32 ou 32 × 64 bits

32 × 32 ou 32 × 64 bits

Formato do ponto flutuante IEEE 754 simples, duplo

IEEE 754 simples, duplo




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 MIPS-16

Data do anúncio 1985 1995 1992 1997 1996Tamanho de instrução (bits) 32 16 16 16/32 16/32Espaço de endereços (tamanho, modelo) 32 bits, contínuo 32 bits, contínuo 32 bits, contínuo 32 bits, contínuo 32/64 bits,

contínuoAlinhamento de dados Alinhado Alinhado Alinhado Alinhado AlinhadoModos de endereçamento de dados 6 6 4 3 2Registradores de inteiros (número, modelo, tamanho) 15GPR × 32 bits 8GPR + SP,

LR × 32 bits16GPR × 32 bits 16GPR × 32 bits 8GPR + SP,

RA × 32/64 bitsE/S Mapeada em

memóriaMapeada em memória

Mapeada em memória

Mapeada em memória

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... 5

Observe que os RISCs embutidos costumam ter 8 a 16 registradores de uso geral en-quanto 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 arquite-tura 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 ende-reç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 prin-cipal.

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 sintetiza-do 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ça-mento 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 arquite-turas 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.


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 ins-truçõ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 cur-to 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 ARM v.4 Thumb SuperH M32R MIPS-16

Registrador + offset (deslocamento ou baseado) X X X X XRegistrador + registrador (indexado) X X X – –Registrador + registrador escalado (escalado) X – – – –Registrador + offset e registrador de atualização X – – – –Registrador + registrador e registrador de atualização X – – – –Registrador indireto – – X X –Autoincremento, autodecremento X X X X –Dados relativos ao PC X X (loads) 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 registra-dor 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 em-butidas. 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.


FIGURA E.2.3 Formatos de instrução para arquiteturas RISC desktop/servidores. Esses quatro formatos são encon-trados 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.


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.


Formato: categoria de instrução Alpha MIPS-64 PA-RISC 2.0 PowerPC SPARC v.9

Branch: Tudo Sinal Sinal Sinal Sinal SinalJump/Call: Tudo Sinal — Sinal Sinal SinalRegistrador-imediato: transferência de dados Sinal Sinal Sinal Sinal SinalRegistrador-imediato: aritmética Zero Sinal Sign Sinal SinalRegistrador-imediato: lógico Zero Zero — Zero 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 ARM v.4 Thumb SuperH M32R MIPS-16

Branch: Tudo Sinal Sinal Sinal Sinal SinalJump/Call: Tudo Sinal Sinal/Zero Sinal Sinal —Registrador-imediato: transferência de dados Zero Zero Zero Sinal ZeroRegistrador-imediato: aritmética Zero Zero Sinal Sinal Zero/SinalRegistrador-imediato: lógico Zero — Zero Zero —

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 arqui-teturas, 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 ca-tegoria (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-e-ví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.


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 LDBU; SEXTB LB LDB; EXTRW,S 31,8 LBZ; EXTSB LDSBLoad byte unsigned LDBU LBU LDB, LDBX, LDBS LBZ LDUBLoad half word signed LDWU; SEXTW LH LDH; EXTRW,S 31,16 LHA LDSHLoad half word unsigned LDWU LHU LDH, LDHX, LDHS LHZ LDUHLoad word LDLS LW LDW, LDWX, LDWS LW LDLoad SP float LDS* LWC1 FLDWX, FLDWS LFS LDFLoad DP float LDT LDC1 FLDDX, FLDDS LFD LDDFStore byte STB SB STB, STBX, STBS STB STBStore half word STW SH STH, STHX, STHS STH STHStore word STL SW STW, STWX, STWS STW STStore SP float STS SWC1 FSTWX, FSTWS STFS STFStore DP float STT SDC1 FSTDX, FSTDS STFD STDFRead, write special registers MF_, MT_ MF, MT_ MFCTL, MTCTL MFSPR, MF_, MTSPR, MT_ RD, WR, RDPR, WRPR, LDXFSR, STXFSRMove integer to FP register ITOFS MFC1/DMFC1 STW; FLDWX STW; LDFS ST; LDFMove FP to integer register FTTOIS MTC1/DMTC1 FSTWX; LDW STFS; LW 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


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!)


Controle (formatos de instrução)

B, J/C B, J/C B, J/C B, J/C B, J/C


Branch on integer compare

B_ (<, >, <=, >=, =, not=)

BEQ, BNE, B_Z (<, >, <=, >=)

COMB, COMIB BC BR_Z, BPcc (<, >, <=, >=, =, not=)

Branch on floating-point compare

FB_(<, >, <=, >=, =, not=)

BC1T, BC1F FSTWX f0; LDW t; BB t

BC FBPfcc (<, >, <=, >=, =,...)

Jump, jump register BR, JMP J, JR BL r0, BLR r0

B, BCLR, BCCTR BA, JMPL r0,...

Call, call register BSR JAL, JALR BL, BLE BL, BLA, BCLRL, BCCTRL

CALL, JMPL

Trap CALL_PAL GENTRAP

BREAK BREAK TW, TWI Ticc, SIR

Return from interrupt CALL_PAL REI JR; ERET RFI, RFIR RFI DONE, RETRY, RETURN

FIGURA 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


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

Move R-R ADDT, Fd, F31, Fs MOV.S, MOV.D FCPY FMV FMOVS/D/Q

Convert (single, double, integer) to (single, double, integer)

CVTST, CVTTS, CVTTQ, CVTQS, CVTQT

CVT.S.D, CVT.E.S, CVT.S.W, CVT.E.W, CVT.W.S, CVT.W.D

FCNVFF,s,d FCNVFF,d,s FCNVXF,s,s FCNVXF,d,d FCNVFX,s,s FCNVFX,d,s

–, FRSP, –, FCTIW,–, –

FSTOD, FDTOS, FSTOI, FDTOI, FITOS, FITOD

FIGURA 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 r31 (origem) r0 r0 r0 (endereçamento) r0Registrador de endereço de retorno (qualquer) r31 r2, r31 link (especial) r31

No-op LDQ_U r31,... SLL r0, r0, r0 OR r0, r0, r0 ORI r0, r0, #0 SETHI r0, 0

Mover inteiro R-R BIS..., r31,... 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.


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

Read, write special registers MRS, MSR –1 LDC, STC MVFC, MVTC MOVE

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

Multiply (trap if overflow) –

Divide – – DIV1, DIVoS, DIVoU DIV, DIVU DIV, DIVU

Divide (trap if overflow) – – –

And AND AND AND AND, AND3 AND

Or ORR ORR OR OR, OR3 OR

Xor EOR EOR XOR XOR, XOR3 XOR

Load high part register – – SETH –1

Shift left logical LSL3 LSL2 SHLL, SHLLn SLL, SLLI, SLL3 SLLV, SLL

Shift right logical LSR3 LSR2 SHRL, SHRLn SRL, SRLI, SRL3 SRLV, SRL

Shift right arithmetic ASR3 ASR2 SHRA, SHAD SRA, SRAI, SRA3 SRAV, SRA

Compare CMP,CMN, TST,TEQ CMP, CMN, TST CMP/cond, TST CMP/I, CMPU/I CMP/I2, SLT/I, SLT/IU

FIGURA 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.


Controle (formatos de instrução) B, J, C B, J, C B, J, C B, J, C B, J, C

Nome de instrução ARM v.4 Thumb SuperH M32R MIPS-16

Branch on integer compare B/cond B/cond BF, BT BEQ, BNE, BC,BNC, B__Z BEQZ2, BNEZ2, BTEQZ2, BTNEZ2

Jump, jump register MOV pc,ri MOV pc,ri BRA, JMP BRA, JMP B2, JRCall, call register BL BL BSR, JSR BL, JL JAL, JALR, JALX2

Trap SWI SWI TRAPA TRAP BREAKReturn from interrupt MOVS pc, r14 –1 RTS RTE –1

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 ARM v.4 Thumb SuperH M32R MIPS-16

Registrador de endereço de retorno

R14 R14 PR (special) R14 RA (special)

No-op MOV r0,r0 MOV r0,r0 NOP NOP SLL r0, r0Operandos, ordem OP Rd, Rs1, Rs2 OP Rd, Rs1 OP Rs1, Rd OP Rd, Rs1 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.


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 registra-dores e colocam um terceiro em 1 se a condição é satisfeita e em 0 caso contrário. As com-paraçõ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 tradi-cionais 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 registra-dor 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)


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 MIPS-64 PA-RISC 2.0 PowerPC SPARC v.9

Número de bits do código de condição (inteiro e FP)

0 8 FP 8 FP 8 × 4 ambos 2 × 4 inteiro, 4 × 2 FP

Instruções de comparação básicas (inteiro e FP)

1 inteiro, 1 FP 1 inteiro, 1 FP 4 inteiro, 2 FP 4 inteiro, 2 FP 1 FP

Instruções de desvio básicas (inteiro e FP)

1 2 inteiro, 1 FP 7 inteiro 1 both 3 inteiro, 1 FP

Comparação de registrador com registrador/const e desvio

– =, not= =, not=, <, <=, >, >=, even, odd

– –

Comparação de registrador com zero e desvio

=, not=, <, <=, >, >=, even, odd

=, not=, <, <=, >, >= =, not=, <, <=, >, >=, even, odd

– =, not=, <, <=, >, >=

FIGURA 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.

ARM v.4 Thumb SuperH M32R MIPS-16

Número de bits do código de condição 4 4 1 1 1Instruções de comparação básicas 4 3 2 2 2Instruções de desvio básicas 1 1 2 3 2Comparação de registrador com registrador/const e desvio

– – =, >, >= =, not= –

Comparação de registrador com zero e desvio – – =, >, >= =, 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 acrescen-tar 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 ope-raçõ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, parti-cionando 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


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 Alpha MAX MIPS MDMX PA-RISC MAX2 PowerPC SPARC VIS

Add/subtract 8B, 4H 4H 4H, 2WAdd/sub com saturação 8B, 4H 4HMultiply 8B, 4H 4B/HCompare 8B (>=) 8B, 4H (=,<,<=) 4H, 2W (=, not=, >, <=)Shift right/left 8B, 4H 4HShift right arithmetic 4H 4HMultiply and add 8B, 4HShift and add (saturação) 4HAnd/or/xor 8B, 4H, 2W 8B, 4H, 2W 8B, 4H, 2W 8B, 4H, 2WAbsolute difference 8B 8BMax/min 8B, 4W 8B, 4HPack (2n bits -> n bits) 2W->2B, 4H->4B 2*2W->4H, 2*4H->8B 2*4H->8B 2W->2H, 2W->2B, 4H->4BUnpack/merge 2B->2W, 4B->4H 2*4B->8B, 2*2H->4H 4B->4H, 2*4B->8BPermute/shuffle 8B, 4H 4HConjuntos de registradores Integer Fl. Pt. + 192b Acc. Integer 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.


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 ope-raçõ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-ac-cumulate é 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 32B × 32B – 32B × 32B, 16B × 16B 32B × 16B, 16B × 16B –Tamanho do acumulador 32B/64B – 32B/42B, 48B/64B 56B –Nome do acumulador Qualquer GPR ou pares de GPRs – MACH, MACL ACC –Operações Produto 32B/64B + 64B

acumulado com ou sem sinal– Produto 32B + 42B/32B

acumulado (operandos na memória); 64B produto + 64B/48B acumulado (operandos na memória); MAC limpo

Produto 32B/48B + 64B acumulado, arredondar, mover

–

Nomes das instruções correspondentes

MLA, SMLAL, UMLAL – MAC, MACS, MAC.L, MAC.LS, CLRMAC

MACHI/MACLO, MACWHI/ MACWLO, RAC, RACH, MVFACHI/MVFACLO, MVTACHI/MVTACLO

–

FIGURA E.5.1 Resumo dos cinco métodos dos RISCs embutidos para multiply-accumulate.


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ên-cias 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 comple-tados 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.


Nome Definição Alpha MIPS-64 PA-RISC 2.0 PowerPC SPARC v.9

Atomic swap R/M (para locks e semáforos)

Temp<–-Rd; Rd<–-Mem[x]; Mem[x]<–-Temp

LDL/Q_L; STL/Q_C

LL; SC – (veja E.8) LWARX; STWCX CASA, CASX

Load 64-bit integer Rd<–-64 Mem[x] LDQ LD LDD LD LDX

Store 64-bit integer Mem[x]<–-64 Rd STQ SD STD STD STX

Load 32-bit integer unsigned Rd32..63<–-32 Mem[x]; Rd0..31<–-32 0

LDL; EXTLL LWU LDW LWZ LDUW

Load 32-bit integer signed Rd32..63<–-32 Mem[x]; 32 Rd0..31<–-32 Mem[x]0

LDL LW LDW; EXTRD ,S 63, 8

LWA LDSW

Prefetch Cache[x]<–-hint FETCH, FETCH_M*

PREF, PREFX LDD, r0 LDW, r0

DCBT, DCBTST PRE-FETCH

Load coprocessor Coprocessor<–- Mem[x] – LWCi CLDWX, CLDWS – –

Store coprocessor Mem[x]<–- Coprocessor – SWCi CSTWX, CSTWS – –

Endian (Big/Little Endian?) Ambos Ambos Ambos Ambos Ambos

Cache flush (Realiza flush no bloco de cache neste endereço)

ECB CP0op FDC, FIC DCBF FLUSH

Shared-memory synchronization (Todas as transferências de dados anteriores são completadas para que a próxima transferência de dados possa iniciar)

WMB SYNC SYNC SYNC MEMBAR

FIGURA 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 desk-top. 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).


Operações aritméticas com inteiros de 64 bits

Rd<–-64Rs1 op64 Rs2 ADD, SUB, MUL DADD, DSUB DMULT, DDIV

ADD, SUB, SHLADD, DS

ADD, SUBF, MULLD, DIVD

ADD, SUB, MULX, S/UDIVX

Operações lógicas com inteiros de 64 bits

Rd<–-64Rs1 op64 Rs2 AND, OR, XOR AND, OR, XOR AND, OR, XOR AND, OR, XOR AND, OR, XOR

Deslocamentos com 64 bits Rd<–-64Rs1 op64 Rs2 SLL, SRA, SRL DSLL/V, DSRA/V, DSRL/V

DEPD,Z EXTRD,S EXTRD,U

SLD, SRAD, SRLD SLLX, SRAX, SRLX

move Condicional if (cond) Rd<–-Rs CMOV_ MOVN/Z SUBc, n; ADD – MOVcc, MOVr

Suporte a adição de inteiros com mais de uma word

CarryOut, Rd <–- Rs1 + Rs2 + OldCarryOut

– ADU; SLTU; ADDU, DADU; SLTU; DADDU

ADDC ADDC, ADDE ADDcc

Suporte a subtração de inteiros com mais de uma word

CarryOut, Rd <–- Rs1 Rs2 + OldCarryOut

– SUBU; SLTU; SUBU, DSUBU; SLTU; DSUBU

SUBB SUBFC, SUBFE SUBcc

And not Rd <–- Rs1 & ~(Rs2) BIC – ANDCM ANDC ANDN

Or not Rd <–- Rs1 | ~(Rs2) ORNOT – – ORC ORN

Add high immediate Rd0..15<–-Rs10..15 + (Const<<16);

– – ADDIL (R-I) ADDIS (R-I) –

Coprocessor operations (Definidas pelo coprocessador)

– COPi COPR,i – IMPDEPi

FIGURA 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.



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.


Multiply and add Fd <–- (Fs1 × Fs2) + Fs3 – MADE.S/D FMPYFADD sgl/dbl FMADD/S

Multiply and sub Fd <–- ( Fs1 × Fs2) – Fs3 – MSUB.S/D FMSUB/S

Neg mult and add Fd <–- -(( Fs1 × Fs2) + Fs3) – NMADE.S/D FMPYFNEG sgl/dbl FNMADD/S

Neg mult and sub Fd <–- -(( Fs1 × Fs2) – Fs3) – NMSUB.S/D FNMSUB/S

Raiz Quadrada Fd <–- SQRT(Fs) SQRT_ SQRT.S/D FSQRT sgl/dbl FSQRT/S FSQRTS/D

move Condicional if (cond) Fd<–-Fs FCMOV_ MOVF/T, MOVF/T.S/D FTESTFCPY – FMOVcc

Negar Fd <–- Fs ^ x80000000

CPYSN NEG.S/D FNEG sgl/dbl FNEG FNEGS/D/Q

Valor Absoluto Fd <–- Fs & x7FFFFFFF

– ABS.S/D FABS/dbl FABS FABSS/D/Q

FIGURA 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 Definição ARM v.4 Thumb SuperH M32R MIPS-16

Atomic swap R/M (para semáforos) Temp<–-Rd; Rd<–-Mem[x]; Mem[x]<–-Temp

SWP, SWPB –1 (see TAS) LOCK; UNLOCK

–1

Memory management unit Tradução de endereço paginado Via instruções do coprocessador –1 LDTLB –1

Endian (Big/Little Endian?) Ambos Ambos Ambos Big Ambos

FIGURA 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.


Load immediate Rd<–-Imm MOV MOV MOV, MOVA LDI, LD24 LI

Suporte a adição de inteiros com mais de uma word

CarryOut, Rd <–- Rd + Rs1 + OldCarryOut ADCS ADC ADDC ADDX –1

Suporte a subtração de inteiros com mais de uma word

CarryOut, Rd <–- Rd – Rs1 + OldCarryOut SBCS SBC SUBC SUBX –1

Negar Rd <–- 0 – Rs1 NEG2 NEG NEG NEG

Not Rd <–- ~(Rs1) MVN MVN NOT NOT NOT

Move Rd <–- Rs1 MOV MOV MOV MV MOVE

Rotate right Rd <–- Rs i, >> Rd0... i–1 <–- Rs31–i...31

ROR ROR ROTC

And not Rd <–-Rs1 & ~(Rs2) BIC BIC

FIGURA 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.



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 des-vios, 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 se-guinte.) 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 é dada pela largura do destino; a extensão é especificada quando não for clara.

Regs[R1]<–Regs[R2]; Transfere o conteúdo de R2 para R1. Os registradores possuem uma largura fixa, de modo que as transferências mais curtas do que o tamanho do registrador precisam indicar quais bits são usados.

M Array de memória acessado em bytes. O endereço inicial para uma transferência é indicado como o índice para o array de memória.

Regs[R1]<–M[x]; Coloca o conteúdo do local de memória x em R1. Se uma transferência começa em M[i] e exige 4 bytes, os bytes transferidos são M[i], M[i+1], M[i+2] e M[i+3].

<–n Transfere um campo de n bits, usado sempre que a largura da transferência não é clara.

M@N1 = <–16M[x]; Transfere 16 bits iniciando no local de memória x para o local de memória y. A largura dos dois lados deve coincidir.

Xn O subscrito seleciona um bit. Regs[R1]0<–0; Muda o bit de sinal de R1 para 0. (Os bits são numerados por meio de MSB iniciando em 0.)

Xm..n O subscrito seleciona um campo. Regs[R3]24..31<–M[x]; Move o conteúdo do local de memória x para o byte menos significativo de R3.

Xn O sobrescrito duplica um campo de bit. Regs[R3]0..23<–024; Define os três bytes mais significativos de R3 como 0.## Concatena dois campos. Regs[R3]<–240## M[x];

F2##F3<–64M[x];Move o conteúdo do local x para o byte menos significativo de R3; limpa os três bytes mais significativos. Move 64 bits da memória iniciando no local x; os primeiros 32 bits vão para F2, os próximos 32 bits para F3.

*, & Segue um ponteiro; obtém o endereço de uma variável.

p*<–&x; Atribui o endereço da variável x ao objeto apontado por p.

<<, >> Shifts lógicos C (esquerda, direita). Regs[R1] << 5 Desloca R1 5 bits para a esquerda.==, !=, >, <, >=, <=

Operadores relacionais C; equal, not equal, greater, less, greater or equal, less or equal.

(Regs[R1]== Regs[R2]) & (Regs[R3]!=Regs[R4])

Verdadeiro se o conteúdo de R1 é igual ao conteúdo de R2 e o conteúdo de R3 não é igual ao conteúdo de R4.

&, |, ^, ! Operações lógicas bit-a-bit C: and, or, or exclusivo e complemento

(Regs[R1] & (Regs[R2]| Regs[R3]))

AND bit-a-bit de R1 e OR bit-a-bit de R2 e R3.

FIGURA E.6.8 Notação de descrição de hardware (e alguns operadores C padrão).


Branch (simples) Delayed Branch Delayed Branch com anulação

Encontrado nas arquiteturas Alpha, PowerPC, ARM, Thumb, SuperH, M32R, MIPS 16

MIPS-64, PA-RISC, SPARC, SuperH

MIPS-64, SPARC PA-RISC

Executado após a instrução Apenas se o desvio não é tomado Sempre Apenas se o desvio é tomado Apenas se um desvio para a frente não for tomado ou um desvio para trás for tomado

FIGURA 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çõesespecíficasdoMIPS-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 peculia-res que se destacam no MIPS, sendo que os primeiros eram encontrados no conjunto de instruções original.

Transferênciasdedadosnãoalinhados

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 minicompu-tador 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 é acrescen-tado ao PC. Ele é deslocado 2 bits à esquerda e substitui os 28 bits menos significativos do PC. Isso só faria diferença se o programa fosse localizado próximo à barreira dos 256MB.


Instruções TLB – Falhas na TLB (Translation Lookaside Buffer) são tratadas por sof-tware 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 ar-quitetura 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!)


Na arquitetura MIPS, não há qualquer provisão específica para execução de ponto flu-tuante 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çõesespecíficasdoAlpha

O Alpha foi criado para ser uma arquitetura que permitisse a fácil construção de imple-mentaçõ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 ins-truçõ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 im-plementar 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 inter-rupçõ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 sig-nifica 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.


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çõesespecíficasdoSPARCv.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 win-dows), uma otimização para reduzir o tráfego de registradores nas chamadas de pro-cedimento. 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.


O risco das janelas de registradores é que o maior número de registradores pode di-minuir 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.

Trapsrá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 ope-rando é um inteiro (codificado como 00); assim, TADDcc e TSUBcc ligam o bit de over-flow 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.


FIGURA E.9.1 O SPARC usa os dois bits menos significativos para codificar tipos de dados diferentes para as ins-truçõ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çõessobrepostasdeinteirosepontoflutuante

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 processa-dor com um valor de 32 bits (64 bits) na memória; se e somente se eles forem iguais, ele troca o valor na memória pelo valor em um segundo registrador de processador. Essa instrução da versão 9 pode ser usada para construir algoritmos de sincronização livres de espera que não exigem o uso de locks.

XNOR calcula o OR exclusivo com o complemento do segundo operando.


BPcc, BPr e FBPcc incluem um bit de previsão de desvios, de modo que o compilador possa dar indicações à máquina sobre se um desvio provavelmente é tomado ou não.

ILLTRAP causa uma trap de instrução ilegal. Muchnick [1988] explica como isso é usado para a execução correta dos procedimentos de retorno agregados em C.

POPC conta o número de bits definidos em 1 em um operando, também encontrado na terceira versão da arquitetura Alpha.

Loads infalíveis permitem que os compiladores movam instruções load para adiante das 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 du-pla, 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çõesespecíficasdoPowerPC

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.

Registradoresdebranch:linkecount

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 prova-velmente 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 decidi-ram 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).


Outras instruções

Diferente da maioria das outras máquinas RISCs, o registrador 0 não é fisicamente conec-tado 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 regis-trador 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ên-cia 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 comple-mento 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çõesespecíficasdoPA-RISC2.0

O PA-RISC foi expandido ligeiramente em 1990 com a versão 1.1 e mudou significativa-mente 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 so-mar 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.


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 ins-truçã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 sin-tetizadas 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 an-terior. 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.


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 se-lecionados 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 registra-dor 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 inter-rupçã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.


E.12 InstruçõesespecíficasdoARM

É difícil escolher o recurso mais incomum do ARM, mas talvez ele seja a execução condi-cional 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 signifi-cativos 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 regis-trador 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 arqui-tetura 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).


E.13 InstruçõesespecíficasdoThumb

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 normal-mente 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 opcio-nalmente, 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 regis-tradores 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 é es-pecificado 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çõesespecíficasdoSuperH

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.


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 resul-tado 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 ins-truçõ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 deslocamen-tos 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 me-mó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çõesespecíficasdoM32R

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.


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 ins-truçõ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çõesespecíficasdoMIPS-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 regis-tradores 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 op-codes 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 redu-zidos 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


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, adicionan-do-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 ar-quitetura 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 set-on-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 ortogonali-dade são companheiras estranhas no MIPS-16!


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 im-mediate, 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 Comentáriosfinais

Este apêndice aborda os modos de endereçamento, os formatos de instrução e todas as ins-truçõ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. (Ima-gine 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 1964/1970 1978 1980 1977Tamanho(s) das instruções (bits) 16, 32, 48 8, 16, 24, 32, 40, 48 16, 32, 48, 64, 80 8, 16, 24, 32, ..., 432Endereçamento (tamanho, modelo) 24 bits, flat/31 bits,

flat4 + 16 bits, segmentado 24 bits, flat 32 bits, flat

Dados alinhados? Sim 360/Não 370 Não Alinhado em 16 bits NãoModos de endereçamento de dados 2/3 5 9 14Proteção Página Nenhuma Opcional PáginaTamanho da página 2 KB & 4 KB — 0.25 a 32 KB 0.5 KBE/S Código da operação Código da operação Mapeado em memória Mapeado em memóriaRegistradores inteiros (tamanho, modelo, número) 16 GPR × 32 bits 8 dados dedicados ×

16 bits8 dados e 8 endereço × 32 bits

15 GPR × 32 bits

Registradores de ponto flutuante separados 4 × 64 bits Opcionais: 8 × 80 bits Opcionais: 8 × 80 bits 0Formato de ponto flutuante IBM (hexadecimal

floating)IEEE 754 single, double, extended

IEEE 754 single, double, extended

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.


1960

CDC 6600

1963

Cray-1

1976

M32R

1997

Thumb

1995

ARM v.4

1995

ARM3

1990

ARM2

1987

ARM1

1985

SPARC v.8

1987

SPARC v.9

1994

MIPS-16

1996

MIPS I

1986

MIPS II

1989

MIPS III

1992Alpha

1992

PA-RISC

1986

PA-RISC 1.1

1990

PA-RISC 2.0

1996

RT/PC

1986

Power1

1990

PowerPC

1993

Power2

1993Alpha v.3

1996

MIPS IV

1994

MIPS V

1996

MIPS-64

2002

MIPS-32

2002

Berkeley RISC-1

1981Stanford MIPS

1982

Digital PRISM

1988

IBM ASC 1968

IBM 801

1975

America

1985

SuperH

1992

1965

1970

1975

1980

1985

1990

1995

2000

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 frontei-ras 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 Bhan-darkar, Intel Corporation; Dr. Earl Killian, Silicon Graphics/MIPS; e Dr. Hiokazu Takata, Mitsubishi Electric Corporation.


PA-RISC SPARC MIPS Power

Recurso 1.0 1.1 2.0 v.8 v.9 I II III IV V 1 2 PC

Loads com interlock X “ “ X “ + “ “ X “ “Load-store FP double X “ “ X “ + “ “ X “ “Semáforo X “ “ X “ + “ “ X “ “Raiz quadrada X “ “ X “ + “ “ + “Ops FP de precisão simples X “ “ X “ X “ “ “ +Sincronismo de memória X “ “ X “ + “ “ X “ “Coprocessador X “ “ X – X “ “ “Endereçamento base + índice X “ “ X “ + X “ “Equivalência a 32 registradores FP de 64 bits “ “ + + “ X “ “Anulação de delayed branch X “ “ X “ + “ “Conteúdo do registrador de desvio X “ “ + X “ “ “Big/Little Endian + “ + X “ “ “ +Bit de previsão de desvios + + “ “ X “ “Move condicional + + X “ –Prefetch de dados na cache + + + X “ “Ops endereçamento/int. 64 bits + + + “ +Multiplicação, divisão de 32 bits + “ + X “ “ “ X “ “Load-store FP quad + + –Fused FP mul/add + + X “ “Instruções de string X “ “ X “ –Suporte a multimídia 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 adicionalBhandarkar, 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.


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 (se-tembro).

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 Kau-fmann, 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.

Uma Visão Geral das Arquiteturas RISCs para Computadores...

Documents

Transcript of Uma Visão Geral das Arquiteturas RISCs para Computadores...