Arquitetura do Conjunto de

Instruções
ISA: a Identidade da Máquina
Nivel 4
Orientada a Problemas

Montagem

Sistema Operacional

ISA (Máquina)

Microarquitetura

Lógica Digital

Dispositivos Eletrônicos
 Conjunto de Instruções ISA
• Limite onde o projetista de computador e o programador podem ver a
mesma máquina

• A coleção completa de instruções que são entendidas por uma CPU

• Código ou linguagem de máquina

• Binário

• Normalmente, representado por mnemônicos em assembly

 Decisões de Projeto
• Como interpretar os bits da memória
– Organização: big endian ou little endian
– Acesso a palavras ou a bytes no endereçamento
– Acesso alinhado ou não

• Repertório de operações
– Quantas operações?
– Quais operações? O que elas podem fazer?
– Qual a complexidade delas?

• Tipos de dados (operandos) e seus tamanhos

 Decisões de Projeto

• Formatos de instrução
– Tamanho e formato dos campos
– Número de endereços e modos de endereçamento

• Registradores
– Número de registradores da CPU disponíveis
– Quais operações podem ser realizadas sobre quais registradores?

• Modos de endereçamento
 Decisões de Projeto
Para executar: c = a + b

Existem várias opções para isso...

Pilha Acumulador Registrador-memória Registrador

Push A Load A Load R1, A Load R1, A

Push B Add B Add R1, B Load R2, B

Add Store C Store C, R1 Add R3, R1, R2

Pop C Store R3
 Classificação da ISA
TOS … … …
…

… … … …
Memória Memória Memória Memória

… …
Pilha

Acumulador
… …

ULA ULA ULA ULA

CPU CPU CPU CPU

Pilha Acumulador Reg-Memória Load/Store

 Outras Questões
• Coisas que não estão sendo cobertas até aqui:

• Suporte a procedures

• Manipulação de strings e ponteiros

• Interrupções e exceções

• Alguns desses pontos serão tratados no futuro e também em outros

cursos (sistemas operacionais, microprocessadores, ...)
 Elementos da Instrução
• Código de operação (Opcode)
– O que fazer

• Referência a operando fonte

– Usando de dados

• Referência a operando de destino

– Onde fica a resultado

• Referência à próxima instrução

– Para onde ir depois
 Operandos Fonte e Destino
• Memória principal ou virtual
– Como as referências à próxima instrução

• Registrador do processador
– Com raras exceções, um processador contém um ou mais registradores
– Registradores podem ser referenciados por instruções
– Se houver apenas 1 registrador, a referência é implícita

• Imediato
– O valor do operando está contido na instrução

• Dispositivo de E/S
– A instrução precisa especificar o módulo de E/S
 Representação da Instrução
• Em código de máquina, cada instrução tem um padrão de bits exclusivo

• Formato de instrução simples

– Registrador de instruções (IR) do processador

4 bits 6 bits 6 bits

Opcode Referência ao operando Referência ao operando

16 bits
 Tipos de Instrução
• Processamento de dados
– Aritmética e lógica

• Armazenamento de dados
– Fluxo de dados para dentro ou fora do registrador e/ou memória

• Movimentação de dados (E/S)

– Instruções e E/S

• Controle de fluxo do programa

– Instruções de teste e desvio
Repertório de Operações
Arquitetura ISA
 Transferência de Dados
• Especificam
– Origem
– Destino
– Quantidade de dados

• Podem ser instruções diferentes para diferentes movimentações

Ex: IBM 370

• Ou uma instrução e diferentes endereços

Ex: VAX
 Aritméticas
• Adição, Subtração, Multiplicação, Divisão

• Inteiro com ou sem sinal

• Opcionalmente Ponto Flutuante

• Pode incluir
– Incremento
– Decremento
– Negação
 Lógicas

• Operações lógicas básicas sobre dados booleanos ou binários*

– NOT
– AND
– OR
– Exclusive OR (XOR)
– EQUAL teste binário útil
 Deslocamentos
À direita À esquerda

0 0
Deslocamento Lógico … …

0
Deslocamento Aritmético S … S …

Rotação … …
Em alguns casos pode usar o carry
 Conversão

• Mudam o formato ou operam sobre o formato dos dados

– Decimal para Binário (0000 11002 ! 0001 0010BCD)

– Inteiro para Ponto Flutuante
– Extensão de sinal
 Entrada e Saída

• Podem ser instruções específicas

• Pode ser feita usando instruções de movimentação de dados (mapeadas

na memória)

• Pode ser feita por um controlador separado (DMA)

 Controle do Sistema

• Instruções privilegiadas

• CPU precisa estar em estado específico

– Anel 0 no 80x86
– Modo kernel
– Interrupções de software

• Para uso dos sistemas operacionais

 Transferência de Controle
• Desvio (Branch)
Diversas condições possíveis dependendo dos flags

• Salto (Jump)

• Chamadas a sub-rotinas

• Interrupções por software (system calls)

• Retorno
de sub-rotinas, interrupções etc.
 Resumo
Tipo de operador Exemplos

Aritmético e lógico Operações aritméticas e lógicas inteiras: add, and, sub, or

Tranferência de dados load-stores (instruções de movimentação de dados entre memória e registrador)

Controle Saltos, desvios, chamadas e procedimentos e armadilhas (traps)

Sistema Chamadas ao Sistema Operacional, gerenciamento de memória virtual

Ponto flutuante Operações em ponto flutuante: add, multiply

Decimal Operações em decimal: add, multiply e conversão decimal em caractere

String (cadeia de caracteres) Movimentação, comparação e busca em string

Gráficos Operações compiles, operações de compressão/descompressão

Tipos de Dados
Arquitetura ISA
 Tipos de Dados
• Endereços

• Numéricos
– Valores (Inteiros com ou sem sinal, Ponto-Flutuante, BCD)
– Endereços

• Não Numéricos
– Caracteres (ASCII, unicode etc.)
– Cadeias de caracteres (strings)
– Outros

• Lógicos (bits, flags)

Formatos de Instrução
Arquitetura ISA
 Formatos de Instrução
• Uma instrução consiste em um opcode e informações sobre os
operandos

• Chamamos as informações sobre os operandos de endereços (discutido

adiante)

• Intimamente ligado ao Modelo de Memória

• Compromisso entre tamanhos da instrução, consumo de memória,

consumo de banda do barramento, flexibilidade e abrangência da
linguagem, dificuldade de decodificar
 Formatos de Instrução
• Alocação de bits
– Número de modos de endereçamento
– Número de operandos
– Registrador versus memória
– Número de registradores
– Intervalo de endereços
– Granularidade do endereço
 Tamanho da Instrução
• Afetado por e afeta

– Tamanho da memória

– Organização da memória

– Estrutura de barramento

– Complexidade da CPU

– Velocidade da CPU

• Escolha entre repertório de instrução poderoso e economia de espaço

 Tamanho da Instrução
tamanho da
arquitetura (bits)

instrução instrução instrução instrução

instrução instrução

instrução instrução instrução instrução instrução instrução instrução instrução

instrução instrução instrução instrução

 Números de Endereços
• Variável (ex: VAX)

Opcode Especific. 1 Endereço 1 Especific. 2 Endereço 2 … Especific. n Endereço n

• Fixo (ex: DLX, MIPS, PowerPC, SPARC, Precision Architecture)

Opcode Endereço 1 Endereço 2 Endereço 3

• Híbrido (ex: IBM 360/370, Intel 80x86)

Opcode Especific. Endereço

Opcode Especific. 1 Especific. 2 Endereço

Opcode Especific. Endereço 1 Endereço 2

 Números de Endereços
• Zero endereço

Opcode

• 1 endereço

Opcode Endereço 1

• 2 endereços

Opcode Endereço 1 Endereço 2

• 3 endereços

Opcode Endereço 1 Endereço 2 Endereço 3

 Número de Endereços
• Mais endereços
– Instruções mais complexas (poderosas?)
– Mais registradores
– Operações entre registradores são mais rápidas
– Menos instruções por programa

• Menos endereços
– Instruções menos complexas (poderosas?)
– Mais instruções por programa
– Busca/execução de instruções mais rápida
 Expansão de opcodes
• Compromisso entre o tamanho do opcode e o espaço para outras
informações

• Utilização de opcodes de tamanho variável ou códigos de prefixo de

instruções

• Dificuldade de decodificação
Opcode Endereço 1 Endereço 2 Endereço 3

Código de Expansão Opcode Endereço 1 Endereço 2

 Algumas Arquiteturas
bits 2 5 6 5 1 8 5
00 Destino opcode Fonte 1 0 FP-OP Fonte 2 ULA 3 Reg

13
00 Destino opcode Fonte 1 1 Imediato ULA Imediato

3 22
SPARC
01 Destino opcode Imediato SETHI

1 4
10 A Condição opcode Deslocamento em relação ao PC BRANCH

30
11 Deslocamento em relação ao PC CALL
 Algumas Arquiteturas
bits 8
opcode

5 3
opcode Reg
8
Intel 8051
opcode Operando

11
opcode Endereço

16
opcode Endereço

8
opcode Operando Operando
 Algumas Arquiteturas
bytes 0−1 0−1 0−1 0−1
Prefixo Segmento T.Operando T.Endereço

Intel x86
32 bits bytes 0−4 1−3 0−1 0−1 0−4 0−4
Prefixos Opcode ModR/m SIB Deslocamento Imediato

bits 2 3 3 bits 2 3 3
Mod Reg/Opcode R/M eScala Índice Base
Registradores
Arquitetura ISA
 Registradores

• Presentes em todas as arquiteturas ISA

• Servem para controlar a execução de programas, reter resultados

temporários e outras finalidades

• Podem ser visíveis ou invisíveis ao usuário, os resistradores invisíveis

servem para controle e status do processador
 Registradores Visíveis

• Registradores de Propósito Geral vs Propósito Especial

• Compromisso entre flexibilidade, tamanho das instruções,

complexidade de decodificação etc.

• Influência direta sobre o ISA

 Propósito Geral
• Variedade de funções pelo programador

• Função principal é prover acesso rápido aos dados

‣ Conter variáveis locais fundamentais (inteiros, caracteres)

‣ Armazenar dados e resultado de cálculos

‣ Também usados em cálculos de endereços (segmentos, pilha, índice)

• Qualquer opcode pode conter um operando armazenado nesses

registradores
 Propósito Geral

• Em algumas arquiteturas são totalmente simétricos e intercambiáveis

• Arquiteturas atuais tendem a apresentar um grande número deles

• Podem não ser “exatamente de uso geral”

• Ex: dedicados a ponto-flutuante/inteiro

• Seu uso pode ser restrito/especializado

 Propósito Especial
• Contador de Programa (PC) ou Ponteiro de Instruções (IP)

• Ponteiro de Pilha (SP)

• Registradores para controle de cache, memória, características do

hardware são são visíveis apenas no modo Kernel

• Registradores de Controle como Program Status Word (PSW) ou Flags,

são visíveis em modo Kernel, mas podem controlar instruções no modo
Usuário

• Outros
 Propósito Especial
• Existem três registradores de propósito especial no ISA MIPS:

• Registradores HI / LO usados para armazenar o resultado da

multiplicação

• Registrador PC (contador de programa)*

• Sempre mantém o ponteiro no ponto de execução do programa atual; a

busca de instruções ocorre no endereço no PC

• Não é diretamente visível e manipulado pelos programadores no MIPS

 Registradores Não Visíveis

• São usados em várias operações no

• Contador de programa (PC)* ou Ponteiro
processador
de Instrução (IP)
• Registrador de buffer de memória (MBR)
• Acumulador (AC) e quociente/
multiplicador (MQ)
• Registrador de endereço de memória
(MAR)
• Registradores para Códigos Condicionais
• Registrador de instruções (IR)
• Registrador de Flags ou Palavra de
Estado do Processador (PSW)
• Registrador de buffer de instruções (IBR)
 Número de Registradores

• O número de registradores de Propósito Geral varia muito, mas está entre

8 – 32 nas arquiteturas atuais

• Máquinas RISC, load-store podem ter centenas de registradores

• Menos = mais referências à memória

• Mais ≠ garantia de redução de referências à memória

Comparação de Processadores
CISC RISC Superscalar

MIPS
Processador IBM 370/168 VAX 11/780 Intel 80486 SPARC Mips R4000 Power PC Ultra Sparc
R10000

Ano de Desenvolvimento 1973 1978 1989 1987 1991 1993 1996 1996

Número de Instruções 208 303 235 69 94 225

Tamanho da Instrução
2-6 2-57 1-11 4 4 4 4 4
(bytes)

Modos de
4 22 22 1 1 2 1 1
Endereçamento

Número de Registradores
16 16 8 40-520 32 32 40-520 32
de Propósito Geral

Tamanho da Memória de
420 480 246 - - - - -
Controle (Kbits)

Tamanho da Cache
64 64 8 32 128 16-32 32 64
(KBytes)

Stallings, Cap.12
 Tamanho de um Registrador
• Registrador de Endereços: o suficiente para armazenar um endereço
completo

• Registrador de dados: o suficiente para armazenar uma palavra completa

• É possível combinar 2 registradores de dados, ex. em C:
long int a;

• MIPS: registradores 32 bits, que combinados por trabalhar com até 64 bits
• Multiplicação, divisão, operações ponto-flutuante etc.
Algumas Organizações de Registradores
MC68000 8086 Pentium II
Registradores de Dados Gerais Registradores Gerais
D0 AX Acumulador EAX Acumulador AX
D1 BX Base EBX Base BX
D2 CX Contador ECX Contador CX
D3 DX Dados EDX Dados DX
D4
D5 Ponteiros e Índices Registradores Ponteiros e Índices
D6 SP Ponteiro de Pilha ESP Ponteiro de Pilha SP
D7 BP Ponteiro Base EBP Ponteiro Base BP
SI Índice Fonte ESI Índice Fonte SI
Registradores de Dados DI Índice Destino EDI Índice Destino DI
A0
A1 Segmento Segmento
A2 CS Código CS Código
A3 DS Dados DS Dados
A4 SS Pilha SS Pilha
A5 ES Extra ES Extra
A6
A7
A7’

Registradores de Estado Estado Programa Registradores de Estado do Programa

PC Contador de Programa IP Ponteiro Instruções IP Ponteiro de Instruções
Status Flags Flags

Stallings, Cap.12
Modos de Endereçamento
Arquitetura ISA
 Implícito vs Explícito

• Podemos encontrar endereçamentos explícitos quanto implícitos, no nível

ISA

• No explícito, o endereço do operando deve estar especificado na

instrução, ocupando alguns bits da mesma

• Quando uma instrução utiliza um endereço padrão (default) para aquele

tipo de operação, este endereço não precisa estar codificado na mesma,
sendo obtido de forma implícita ou inerente
Endereçamento de Operandos
 Imediato
• Endereçamento mais simples, pois o operando faz parte da instrução, faz
parte da mesma, mas é um valor constante

• Não requer acesso adicional à memória (economia de tempo)

• Faixa de valores possíveis limitada ao tamanho do campo

Opcode Operando
 Direto
• O endereço de memória onde está o operando faz parte da instrução

• Modo de endereçamento amplamente utilizado, também conhecido como

direto à memória, ou endereçamento absoluto

• Usado para trabalhar com variáveis globais em memória, cujo endereço

é conhecido em tempo de compilação
Memória

Opcode Endereço

Operando
 Registrador
• Mesmo que endereçamento direto, entretanto é o endereço do registrador
que faz parte da instrução

• Endereçamento muito rápido em com poucos bits

• É o tempo de endereçamento mais comum de ser encontrado, também

conhecido como direto a registrador
Registradores
R1
Opcode Registrador …
R2

R3 Operando

R4
 Indireto de Registrador
• A instrução traz o endereço do registrador que armazena o endereço de
memória onde está o operando

• O registrador é um ponteiro para a memória

• A grande vantagem é se ter uma operação em memória sem a sobrecarga

de trazer o endereço de memória completo na instrução
Registradores Memória

R1
Opcode Registrador …
Operando
R2

R3 Endereço

R4
 Indireto de Memória
• A instrução traz o endereço do registrador que armazena o ponteiro para
endereço de memória onde está o operando

• A grande vantagem é se ter uma operação em memória sem a sobrecarga

de trazer o endereço de memória completo na instrução

Registradores Memória

R1
Opcode Registrador …
Operando
R2

R3 Endereço A
Endereço B
R4
 Indireto
• O campo de endereço da instrução contém um endereço da memória
cujo conteúdo é o endereço do operando na memória (ponteiro)

• Grande espaço de endereçamento, porém apresenta múltiplo acesso à

memória

Memória

Opcode Endereço A
Operando

Endereço B
 Auto Incremento
• É equivalente a um endereçamento indireto a registrador, com o
incremento automático do conteúdo do registrador selecionado após
calcular o endereço efetivo

• O registrador é um ponteiro para a memória

Registradores Memória

R1
Opcode Registrador …
Operando
R2

R3 Endereço

R3 = R3 + 1 R4
 Auto Decremento
• É equivalente a um endereçamento indireto a registrador, com o
decremento automático do conteúdo do registrador selecionado após
calcular o endereço efetivo

• O registrado é um ponteiro para a memória

Registradores Memória

R1
Opcode Registrador …
Operando
R2

R3 Endereço

R3 = R3 - 1 R4
 por Deslocamento
• É uma combinação dos modos Direto e Indireto via Registrador

• É um endereçamento muito flexível, porém complexo

Registradores Memória

R1
Opcode Registrador P1
+ Operando
R2

R3 P2

R4
 Base com Deslocamento
• É uma generalização do endereçamento Relativo, onde o número
(endereço) do registrador Base faz parte da instrução

Memória

Opcode Reg Base Deslocamento P

+

Registrador Base P
Operando
 Indexado
• Interpretação oposta ao modo via Registrador Base

• Útil na implementação de operações iterativas, como acesso seqüencial a

elementos de um vetor

Memória

Opcode Reg Índice Endereço P P

+

Registrador Índice Índice

Operando
 Indexado Escalado
• É o modo indexado, onde o índice é multiplicado pelo fator de escala de
1, 2, 4, 8, de acordo com o tamanho dos elementos do vetor a ser
trabalhado

Escala Memória

Opcode Reg Índice Endereço P P

× +

Registrador Índice Índice

Operando
 Auto-Indexado
• Os registradores de índice são habitualmente utilizados para tarefas
iterativas, e tipicamente há necessidade de incrementar ou decrementar o
registrador índice depois de cada referência ao mesmo

• O modo auto indexado, o incremento e/ou decremento é feito

automaticamente como parte do mesmo ciclo de instrução

• Se a indexação utiliza registros especializados, a auto-indexação pode

ser evocada implicitamente e automaticamente

• Se forem usados registos de uso-geral, a operação de auto-indexação

pode necessitar de ser sinalizada por um bit na instrução
 Pós Indexado
• Utiliza endereçamento indireto e indexação no mesmo operando, com a
indexação ocorrendo após o endereçamento direto

Memória

Opcode Reg Índice Endereço P1 P2

+
Operando
Registrador Índice Índice
P
 Pré Indexado
• Utiliza endereçamento indireto e indexação no mesmo operando, com a
indexação ocorrendo antes do endereçamento direto

Memória

Opcode Reg Índice Endereço P1

+ P

Registrador Índice Índice

Operando
 Base Indexado
• O endereço efetivo é calculado com a adição do conteúdo de um
registrador Base com o conteúdo do registrador Indexador, podendo
existir ainda um deslocamento dado por um imediato

Registrador Base Base

Memória

Opcode Reg Índice Reg Base Imediato + Base

Registrador Índice Índice

Operando
 Base Indexado e Escalado
• O endereço efetivo é calculado com a adição do conteúdo de um
registrador Base com o conteúdo do registrador Indexador multiplicado
pela Escala, com deslocamento opcional

• Este é o modo de endereçamento mais versátil de todos

Registrador Base Base

Memória

Opcode Reg Índice Reg Base Imediato + Base

Registrador Índice Índice ×

Operando
Escala
 Pilha
• Pilha: Fila LIFO (Last In First Out)

• Operações: PUSH (escrita em memória), POP (leitura em memória),

operações unárias, operações binárias

• É muito utilizado para salvar o conteúdo de registradores e posições de

memória que posteriormente serão recarregado sem suas posições
originais

• Uso típico em subrotinas e interrupções

 Pilha
• No endereçamento de pilha é utilizado o endereçamento indireto via
registrador implícito com autodecremento ou autodecremento

• O registrador implícito que é o ponteiro para o topo da pilha (stack

pointer) e o autoincremento e autodecremento são usados nas instruções
de escrita ou leitura, em função da direção de crescimento da pilha

Memória

Opcode … Operando

Implícito SP P
Endereçamento de Desvios
 Absoluto
• Usado em instruções de transferência de controle

• O endereço de memória da próxima instrução faz parte da instrução

Memória

Opcode Endereço

Próxima Instrução
 Relativo
• Explora o conceito de localidade, economizando bits do campo de
endereço da instrução, com valor de deslocamento em complemento,
permitindo acréscimos e decréscimos de endereço

• Utiliza o registrador PC de forma implícita, para transferência de controle

Memória

Opcode Deslocamento P
+

Implícito PC P
Proxima Instrução
 Indireto
• A instrução traz o endereço do registrador que armazena o endereço de
memória onde está a próxima instrução

• A grande vantagem é ter uma instrução que ocupa poucos bits para
codificar o endereço

Registradores Memória

R1
Opcode Registrador …
Próxima Instrução
R2

R3 Endereço

R4
Análise de Dados
Análise baseada em Benchmarks
 Freqüência de cada Modo
50%
Registrador 50%
50%
0,5%
Indireto à memória 3%
0,5%
0%
Escalado 8%
3%
12%
Indireto a Registrador 1,5%
5,5%
21,5%
Imediato 8,5%
19,5%
16% TeX
Deslocamento 27,5%
spice
20%
0% gcc
Outros 3%
3%

0% 10% 20% 30% 40% 50% 60%

Freqüência do Modo de Endereçamento
Distância dos Deslocamentos
30%
Percentual dos Deslocamentos

25%
Inteiro
Ponto Flutuante
20%

15%

10%

5%

0%
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
Número de bits necessário para o valor do deslocamento
 Uso dos Operandos Imediatos

10%
Cargas (loads)
45%

87%
Comparações
77%

58%
Operações com ULA
78%

35%
Todas Instruções Inteiros
10% Ponto-Flutuante

0% 20% 40% 60% 80% 100%

Percentual das instruções que usam imediatos
Tamanho dos Imediatos
72% a 80% 99%
60%
gcc
50% TeX
spice
40%

30%

20%

10%

0%
0 4 8 12 16 20 24 28 32
Tamanho do Operando Imediato em bits
 Tipos de Operandos

59%
Double word
70%

29%
Word
26%

0%
Half word
5%

1% Inteiros
Byte Ponto Flutuante
10%

0% 20% 40% 60% 80%

Instruções Mais Usadas
Instruções 80x86 Média*

Carga (load) 22%

Desvio condicional (branch) 20%

Comparação 16%

Armazenamento (store) 12%

Adição (add) 8%

E (and) 6%

Subtração (sub) 5%

Movimentação registrador-registrador 4%

Chamada a procedimento 1%

Retorno de procedimento 1%

Total 96%
 Controle do Fluxo
Inteiro
13% Ponto Flutuante
Chamada/Retorno
11%

6%
Salto
4%

81%
Desvio Condicional
86%

0% 25% 50% 75% 100%

Freqüência das instruções de Desvio
Modelos de Memória
Arquitetura ISA
 Memória

• Dividida em células com endereços consecutivos

• Células apresentam um número fixo de bits (normalmente 8, ou um byte)

• Os byte podem ser agrupados em palavras de tamanho maior

• As palavras normalmente estão localizadas (alinhadas na fronteira

natural) em endereços múltiplos de seu tamanho em bytes,
 Memória
0
1 célula
2
3
4
endereço 5
bit
6
7
8
…

1020
1021 memória
1022
1023
 Alinhamento de Palavras

endereços 8 bytes

8 8 9 10 11 12 13 14 15

palavra de 8 16
bytes alinhada
no endereço 8 24
 Alinhamento de Palavras

endereços 8 bytes

8 12 13 14 15

palavra de 8 16 16 17 18 19
bytes não-
alinhada no
24
endereço 12
 Ordem de Bytes

• Os bytes dentro da palavra, podem ser organizados da direita para

esquerda ou da esquerda para a direita na representação gráfica

• Os bytes dentro da palavra, podem ser organizados nos endereços de

memória do menor para o maior ou do maior para o maior

‣ Big Endian mais significativo primeiro (endereço menor)

‣ Little Endian menos significativo primeiro (endereço menor)

 Big Endian
msB lsB lsB msB
Palavra +0 +1 +2 +3 offset offset +3 +2 +1 +0 Palavra

0 0

4 0x03 0x00 0x00 0x00 0x00 0x00 0x00 0x03 4

8 ’A’ ’T’ ‘E’ ’N’ ’N’ ‘E’ ‘T’ ‘A’ 8

12 Ç ‘Ã’ ‘O’ /0 /0 ‘O’ ‘Ã’ ‘Ç’ 12

Esquerda para Direita Direita para Esquerda

 Little Endian
msB lsB lsB msB
Palavra +0 +1 +2 +3 offset offset +3 +2 +1 +0 Palavra

0 0

4 0x00 0x00 0x00 0x03 0x03 0x00 0x00 0x00 4

8 ’A’ ’T’ ‘E’ ’N’ ’N’ ‘E’ ‘T’ ‘A’ 8

12 Ç ‘Ã’ ‘O’ /0 /0 ‘O’ ‘Ã’ ‘Ç’ 12

Esquerda para Direita Direita para Esquerda

 Algumas Arquiteturas
• Intel 8088 – células de 8 bits, arquitetura de 16 bits, não alinhado

• Intel 80x86 – células do mesmo tamanho que a arquitetura (16, 32 ou 64

bits), não alinhado*, little Endian

• MIPS – células de 32 bits, alinhado, configura-se o hardware para big ou

little Endian

• SPARC e PowerPC (IBM) – big endian (compatibilidade com a linha

Motorola 68K usada pela SUN)

• VAX – little endian

ISA do MIPS
Arquitetura ISA
Memória na Arquitetura MIPS (Patterson)

• Os endereços podem ser armazenados em palavras

• Cada posição endereçada conterá 32 bits

• Em geral, as arquiteturas não acessam bits diretamente, mas blocos ou

conjuntos de bits

• O tamanho dos blocos variam de acordo com os níveis de memória

endereçados...

• Manipulação posterior para acessar pedaços da palavra buscada

 Acesso à Memória MIPS
• Acesso de “palavras” por seus endereços

• Múltiplos de 4 (32 bits = 4 bytes)

• Endereços alinhados: desalinhamento → perda de desempenho

• Depende da arquitetura da CPU (32 ou 64 bits) e do SO

Organização da Memória MIPS
• O acesso a bytes é interessante, mas geralmente “palavras” com alguns
bytes são acessadas.

• No MIPS, uma palavra possui 32 bits (4 bytes)

• Isso traz diversas implicações para a arquitetura:

Registradores armazenam 32 bits de dados
Instruções possuem 32 bits
Operandos possuem 32 bits

• 232 bytes (4 Gi bytes) com endereços byte de 0 a 232-1

• 230 palavras (1Gi words) com endereços 0, 4, 8, ... 232-4

Considere o Programa em C
// none of these allocate any storage
#define MAX_SIZE 256
#define IF(a) if (a) {
#define ENDIF }
typedef struct {
unsigned char red; // 'unsigned char' is an unsigned, 8-bit int
unsigned char green;
unsigned char blue;
unsigned char alpha;
} RGBa;

// these allocate storage

int i;
int N = 20;
char prompt[] = "Enter an integer:";
int A[MAX_SIZE];
int* pBArray;
int BSize;
RGBa background = {0xff, 0xff, 0xff, 0x0};
 Layout da memória
Notas:

} •
Segmento
de código O SO ajusta $gp antes de iniciar os
…
instruções programas
PC • Labels na esquerda são offsets relativos ao
…
$gp
$gp 0 0xCCCCCCCC i • As variáveis não são inicializadas, logo seu
Segmento
4 0x00000014 N
conteúdo é indefinido (aleatório)
8 ‘E’‘n’‘t’‘e’ prompt
de dados
12 0x7220616E • Se assume que a máquina opera no modo
16 0x20696E74 “Big endian”, então, os bytes estão escritos
20 0X65676572
0x3A00CCCC
da direita para esquerda dentro da palavra
24
28 A[0] (A) • O vetor A deve ser alinhado nas palavras
32
…
A[1]
(pode haver algum “padding” antes dele.
1048 A[255] • Se assume que pBArray é inicializado
•
1052 pBArray
1056 BSize
Apesar deste layout seguir a ordem das
1060 0xFFFFFF00 background declarações, não há nenhuma razão para o
…
compilador fazê-lo. Compiladores C
diferentes, farão coisas diferentes
Gerando um Programa Executável
Programa em C Conteúdo dos arquivos objeto (Unix)
Cabeçalho: tamanho e posição dos componentes
Segmento de texto: código de máquina
Compilador Segmento de dados: variáveis dinâmicas e
estáticas
Informação de relocação: referências absolutas
de memória
Programa em Assembly Tabela de símbolos: nome e localização dos
labels, procedimentos e variáveis
Informação de Debugging: mapeamento de
Montador códigos fontes para objetos, break
points etc.

Objeto: módulo em linguagem de máquina Objeto: biblioteca de rotinas (em LM)

Linker
• Coloca módulos de dados e de
código simbolicamente na
memória Executável: programa em LM
• Determina o endereço dos labels
de dados e de instruções
• Relaciona referências internas e Carregador
externas

Memória
Carregando um Programa Executável
• Para carregar um executável, o SO realiza os seguintes passos:

1. Lê o cabeçalho do arquivo executável e determina o tamanho dos segmentos de

texto (código) e dados

2. Cria um espaço de endereçamento grande o suficiente para texto (código) e dados

3. Copia instruções e dados do arquivo executável para a memória

4. Copia os parâmetros (seu houver) do programa principal para a pilha

5. Inicializa os registradores e "seta" o ponteiro da pilha para a primeira alocação livre

6. Salta para a "rotina de start-up" que copia os parâmetros nos registradores de

argumentos e chama a rotina principal do programa
Processador MIPS
0xffffffff

Sistema Operacional

0x80000000
Total = 4 GiBytes $sp ! 0x7fffffff
pilha

dados dinâmicos

dados estáticos
$gp ! 0x10010000
segmento de código
pc ! 0x00400000
0x00000000 reservado
Simuladores MARS
0xffffffff

e SPIM
Sistema Operacional

0x80000000
Total = 4 GiBytes $sp !
0x7fffffff
0x7fffeffc
reservado pelo MARS
pilha

dados dinâmicos

0x10010000 dados estáticos

$gp ! 0x10008000
segmento de código
pc ! 0x00400000
0x00000000 reservado
 Ao final do Processo...
• O programa foi carregado na memória

• Dados e instruções (MIPS, em nosso caso) estarão na memória

• CPU aponta para endereços de instruções ou de dados a serem lidos

• Mais questões intrigantes:

• Qual tipo de instrução estou lendo da memória?

• Qual tipo de dado estou lendo/escrevendo na memória?

• Fluxo de execução e busca de instruções?

• Como faço com as operações de entrada/saída, por exemplo, ler uma entrada do teclado e
imprimir na tela?
 Visão Geral da Instrução
• Instruções simples, todas com largura de 32 bits

• Bastante estruturada, pouca “carga” desnecessária nas instruções

• Somente 3 formatos* de instruções (inteiras)

R opcode rs rt rd shamt funct

I opcode rs rt Imediato de 16 bits

J opcode Pseudo-endereço de 26 de bits

 Visão Geral da Instrução
• Instruções de ponto-flutuante

FR opcode fmt ft fs fd funct

FI opcode fmt ft Imediato de 16 bits

 opcode(31:26)
000 001 010 011 100 101 110 111

000 formato R bltz/gez j jal beq bne blez bgtz

001 addi addiu slti sltiu andi ori xori lui

010 TLB FlPt

011

100 lb lh lwl lw lbu lhu lwr

101 sb sh swl sw swr

110 lwc0 lwc1

111 swc0 swc1

Formato R, op(31:26) = 000000
000 001 010 011 100 101 110 111

000 sll srl sra sllv srlv srav

001 jr jalr syscall break

010 mfhi mthi mflo mtlo

011 mult multu div divu

100 add addu sub subu and or xor nor

101 slt sltu

110

111
 FlPt, op(31:26) = 010001
000 001 010 011 100 101 110 111

000 add.f sub.f mul.f div.f sqrt.f abs.f mov.f neg.f

001 round.w.f trunc.w.f ceil.w.f floor.w.f

010 BC1x movz.f movn.f 16:17 BC1x

00 bc1f
011
01 bc1t
100 cvt.s.f cvt.d.f cvt.w.f 10 bc1fl
11 bc1tl
101

110 c.f.f c.un.f c.eq.f c.ueq.f c.olt.f c.ult.f c.ole.f c.ule.f

111 c.sf.f c.ngle.f c.seq.f c.ngl.f c.lt.f c.nge.f c.le.f c.ngt.f

 TLB, op(31:26)=010000

000 001 010 011 100 101 110 111

00 mfc0 cfc0 mtc0 ctc0

01

10

11
 (16:16) (16:16)
0 movf 0 movf.f
1 movt 1 movt.f

10 16 op(31:26) 10 funct(5:0) 10 funct(5:0) funct(5:0)

0 00 0 sll 0 add.f 0 madd

Mapa de opcode
1 01 1 1 sub.f 1 maddu
2 02 j 2 srl 2 mul.f 2 mul
3 03 jal 3 sra 3 div.f 3
4 04 beq 4 sllv 4 sqrt.f 4 msub
5 05 bne 5 5 abs.f 5 msubu
6 06 blez 6 srlv 6 mov.f 6

do MIPS
7 07 bgtz 7 srav 7 neg.f 7
8 08 addi 8 jr 8 8
9 09 addiu 9 jalr 9 9
10 0a slti 10 movz 10 10
11 0b sltiu 11 movn 11 11
12 0c andi 12 syscall 12 round.w.f 12
13 0d ori 13 break 13 trunc.w.f 13

É um pouco mais complexo que nas tabelas 14

15
0e
0f
xori
lui
14
15 sync
14
15
cell.w.f
floor.w.f
14
15

anteriores
16 10 z=0 16 mfhi 16 16
17 11 z=1 17 mthi 17 17
18 12 z=2 18 mflo 18 movz.f 18
19 13 19 mtlo 19 movn.f 19
20 14 beql 20 20 20
21 15 bnel 21 21 21
22 16 blezl 22 22 22
23 17 bgtzl 23 23 23
24 18 24 mult 24 24
25 19 25 multu 25 25
26 1a 26 div 26 26
27 1b 27 divu 27 27
28 1c 28 28 28
29 1d 29 29 29
rs if z = 1 or z = 2 funct rt
30 1e 30 30 30
31 1f (25:21) (17:16) (4:0) (20:16) 31 31 31
32 20 lb 0 mfcz 0 bczf 0 0 bltz 32 add 32 cvt.s.f 32 clz
33 21 lh 1 1 bczt 1 tlbr 1 bgez 33 addu 33 cvt.d.f 33 clo
34 22 lwl 2 cfcz 2 bczfl 2 tlbwi 2 bltzl 34 sub 34 34
35 23 lw 3 3 bcztl 3 3 bgezl 35 subu 35 35
36 24 lbu 4 mtcz 4 4 36 and 36 cvt.w.f 36
37 25 lhu 5 5 5 37 or 37 37
38 26 lwr 6 ctcz 6 tlbwr 6 38 xor 38 38
39 27 7 7 7 39 nor 39 39
40 28 sb 8 8 tlbp 8 tgei 40 40 40
41 29 sh 9 9 9 tgeiu 41 41 41
42 2a swl 10 10 10 tlti 42 slt 42 42
43 2b sw 11 11 11 tltiu 43 sltu 43 43
44 2c 12 12 12 tegi 44 44 44
45 2d 13 13 13 45 45 45
46 2e swr 14 if z = 0 14 14 tnei 46 46 46
47 2f cache 15 15 15 47 47 47
48 30 ll 16 copz 16 16 bltzal 48 tge 48 c.f.f 48
49 31 lwc1 17 copz 17 17 bgezal 49 tgeu 49 c.un.f 49
50 32 lwc2 18 if z = 1, if z = 1, 18 18 bltzall 50 tlt 50 c.eq.f 50
51 33 pref 19 f=d f=s 19 19 bgczall 51 tltu 51 c.ueq.f 51
52 34 20 20 20 52 teq 52 c.olt.f 52
53 35 ldc1 21 21 21 53 53 c.ult.f 53
54 36 ldc2 22 22 22 54 tne 54 c.ole.f 54
55 37 23 23 23 55 55 c.ule.f 55
56 38 sc 24 24 eret 24 56 56 c.sf.f 56
57 39 swc1 25 25 25 57 57 c.ngle.f 57
58 3a swc2 26 26 26 58 58 c.seq.f 58
59 3b 27 27 27 59 59 c.ngl.f 59
60 3c 28 28 28 60 60 c.lt.f 60
61 3d sdc1 29 29 29 61 61 c.nge.f 61
62 3e sdc2 30 30 30 62 62 c.le.f 62
63 3f 31 31 deret 31 63 63 c.ngt.f 63
 LM MIPS para PF
Nome Formato Exemplo Instrução Codificada
6 bits 5 bits 5 bits 5 bits 5 bits 6 bits
add.s R add.s $f2, $f4, $f6 010001 10000 00100 00110 00010 00000
sub.s R sub.s $f2, $f4, $f6 010001 10000 00100 00110 00010 00001
mul.s R mul.s $f2, $f4, $f6 010001 10000 00100 00110 00010 00010
div.s R div.s $f2, $f4, $f6 010001 10000 00100 00110 00010 00011
add.d R add.d $f2, $f4, $f6 010001 10001 00100 00110 00010 00000
sub.d R sub.d $f2, $f4, $f6 010001 10001 00100 00110 00010 00001
mul.d R mul.d $f2, $f4, $f6 010001 10001 00100 00110 00010 00010
div.d R div.d $f2, $f4, $f6 010001 10001 00100 00110 00010 00011
lwcl I lwcl $f1, 127($2) 110001 00010 00001 0000 0000 0111 1111
swcl I swd1 $f1, 127($2) 111001 00010 00001 0000 0000 0111 1111
bclt I bclt 25 010001 01000 00001 0000 0000 0001 1001
bclf I bclf 25 010001 01000 00000 0000 0000 0001 1001
c.lt.s R c.lt.s $f2, $f4 010001 10000 00100 00010 00000 111100
c.le.d R c.le.d $f2, $f4 010001 10001 00100 00010 00000 111110
Montagem na Prática
"Assembler" Manual
 add $t1, $s5, $s3

add $9, $21, $19

Formato R

R 000 000 10101 10011 01001 00000 100 000

0x02B34820
 lui $at, 0x00001001

lui $1, 0x1001

I 001 111 00000 00001 0001 0000 0000 0001

0x3c011001
 beq $t0, $at, 0x00001a8c

beq $8, $1, 0x06a3

I 000 100 00001 01000 0000 0100 1010 0011

0x102806a3
 ori $t0, $at, 0x000010c2

ori $8, $1, 0x10c2

I 001 101 00001 01000 0001 0000 1100 0010

0x342810c2
 syscall

syscall
Formato R

R 000 000 00000 00000 00000 00000 001 100

0x0000000c
 j 0x042BDC0C
retirar 2 zeros menos
significativos

j 0x010af703

J 000 010 01 0000 1010 1111 0111 0000 0011

0x0900f103
 Uso da Pilha no MIPS

# PUSH # POP
# coloca um registrador na pilha # retirar um registrador da pilha
.macro push($reg) .macro pop($reg)
sw $reg, ($sp) addi $sp, $sp, 4
addi $sp, $sp, -4 lw $reg, ($sp)
.end_macro .end_macro