SlidesAulasAOC

Esta é uma pré-visualização de arquivo. Entre para ver o arquivo original

SlidesAulasAOC/Apresentacao.pdf
Arquitetura e Organização de Computadores
Apresentação Geral da Disciplina
Prof. Alair Dias Júnior Prof. Janier Arias Garcia Prof. Ricardo de O. Duarte
2
⚫ Sou Colombiano 
⚫ Mestrado / Doutorado em Engenharia Sistemas
Mecatrônicos (Universidade de Brasília)
⚫ Atividades em Pesquisa:
Projeto de Sistemas Embarcados
 Sistemas Reconfiguráveis 
Projeto de processadores de alto desempenho para operações 
matriciais 
... 
Sobre Mim
⚫ Capacitação do aluno ao entendimento do funcionamento de 
um processador, suas partes, como as mesmas se integram e se 
comunicam para realizar as funções para as quais foi projetado
⚫ Capacitação do aluno a compreender as diferentes alternativas
para organização de um computador e sua arquitetura
⚫ Compreensão dos elementos necessários para desenvolver um 
projeto de hardware de um processador
⚫ Saber identificar e caracterizar um periférico, sua forma de 
comunicação com processadores e seus modos de operação
3
Objetivos do curso
⚫ Aulas expositivas
⚫ Apresentação de exemplos em sala de aula
⚫ Material para atividades no ambiente Moodle
 Vídeos, Roteiros e Documentos para referência e consulta
⚫ Pergunte, se você não entende alguma coisa!
⚫ Para mais perguntas e/ou pessoas tímidas:
 E-mail: janier-arias@ufmg.br
 Tel.: 3409-3460
 Escritório: EE - Bloco I - sala 2601
4
Dinâmica do curso
⚫ 03 provas
⚫ P1 = 30 Pontos
⚫ P2 = 35 Pontos
⚫ P3 = 35 Pontos
⚫ Consulte as datas das provas no documento com o 
planejamento das aulas
⚫ Nota final (NF):
Avaliação
321 PPP=NF ++
5
⚫ Digital Design and Computer Architecture - David Money Harris & 
Sarah L. Harris Morgan Kaufman 2nd Edition 2013 - Versão em 
Português no Moodle: Projeto Digital e Arquitetura de Computadores 
By David Money Harris & Sarah L. Harris 2015.
6
Bibliografia Básica
⚫ David A. Patterson, John L. Hennessy. Computer Organization and Design -
The Hardware/ Software Interface. 4th Edition (Revised Edition) . Morgan 
Kaufmann, November 2011.
Bibliografia Básica
7
SlidesAulasAOC/cap1.pdf
Capítulo 1
Abstrações e 
tecnologias
computacionais
Tradução e Adaptação
Prof. Ricardo de Oliveira Duarte
DELT – Escola de Engenharia
UFMG
Auxílio na tradução:
Paulo Eduardo da Silva Dias
Princípio do Computador Moderno
• Alan Turing → Máquina de Turing (1936) 
"Universal Computing Machine"
• Uma fita dividida em células, uma adjacente à outra.
• Um cabeçote móvel e deslizante sobre a fita.
• Um registrador de estados: que armazena o estado 
atual da máquina.
• Uma tabela de instruções: que diz à máquina o que 
fazer (mover o cabeçote para direita; para esquerda; 
escrever um símbolo na célula; avaliar o símbolo da 
célula; atualizar o seu próximo estado).
turing machine doodle app Vídeos: 
https://www.youtube.com/watch?v=-ZS_zFg4w5k
https://www.youtube.com/watch?v=gJQTFhkhwPA&t=186s
https://www.youtube.com/watch?v=-ZS_zFg4w5k
https://www.youtube.com/watch?v=gJQTFhkhwPA&t=186s
Colossus (UK) e o ENIAC (USA)
Primeiro Computador
Eletrônico Programável
1943
Programa: conexão de cabos e
combinação de chaves
John Von Neumann (1942)
• Conceito de Programa Armazenado
• Instruções assim como os dados poderiam ser 
representadas na forma binária como uma sequencia 
de 0´s e 1´s.
• Programa: sequencia de instruções.
• Programa armazenado na memória → Acelerar o processo 
de computação. 
• Projeto de uma máquina poderia ser realizado a partir 
de um conjunto de instruções definido.
John Von Neumann (1942)
• Ciclo de Instrução (Ciclo Busca-Execução) 
1. Busca da instrução (Instruction Fetch)
2. Decodificação da instrução corrente e cálculo do 
endereço de memória da próxima instrução.
3. Busca dos operandos (Operand Fetch) ou cálculo 
do endereço dos operandos
4. Execução da operação representada pela instrução.
5. Armazenamento do resultado em um endereço de 
memória
Manchester Small-Scale Experimental Machine
• Primeiro Computador Eletrônico Programável aplicando o 
Conceito de Programa Armazenado e Ciclo de Instrução
• Victoria University of Manchester: Frederic C. Williams, Tom Kilburn
and Geoff Tootill.
• Executou o primeiro programa em 21 Junho de 1948 !!
Lei de Moore
• Primeiro CI (Circuito Integrado) – Jack Kilby da Texas Instruments e Robert 
Noyce, da Fairchild Semiconductor em 1958. 
• Até meados de 1965 não havia nenhuma previsão real sobre o futuro dos 
circuitos integrados, quando o então presidente da Intel, Gordon E. Moore 
enunciou uma observação, na qual o número de transistores dos chips teria 
um aumento de 100% dentro da mesma área do DIE, pelo mesmo custo, a 
cada período de 18 meses.
• Esse enunciado tornou-se realidade, é observado esse crescimento até os 
dias atuais e acabou ganhando o nome de Lei de Moore.
INTEL 4004
Primeiro processador
1971
2.300 transistores em 12 mm2
contra
1.170.000.000 transistores em 240 mm2
Fonte: http://en.wikipedia.org/wiki/Transistor_count
Chapter 1 — Computer Abstractions and Technology —
A Revolução Computacional
▪ Progresso da tecnologia computacional
▪ Sustentado pela Lei de Moore. 
▪ Até quando?
▪ Possibilitam novas aplicações surjam:
▪ Computadores em automóveis.
▪ Celulares.
▪ Projeto do genoma humano.
▪ World Wide Web.
▪ Veículos autônomos.
▪ Computadores são encontrados em tudo e
em todos os lugares.
§
1
.1
 In
tro
d
u
c
tio
n
Chapter 1 — Computer Abstractions and Technology —
Classes de Computadores
▪ Desktops:
▪ Computadores de propósito geral, variedade de software.
▪ Sujeito a compromissos entre custo e performance.
▪ Servidores:
▪ Baseados em redes.
▪ Alta capacidade, performance
e confiabilidade.
▪ Variam de pequenos servidores até servidores do 
tamanho de prédios.
▪ Computadores embarcados:
▪ Escondidos como componentes dentro de um sistema.
▪ Demandam severas restrições de energia, custo e 
performance.
Chapter 1 — Computer Abstractions and Technology —
/
Componentes de um Computador
▪ Os mesmos componentes são
encontrados em todos as 
classes de computadores
▪ Desktop, servidor, embarcado.
▪ Entrada e saída incluem:
▪ Dispositivos para interface com o 
usuário.
▪ Tela, teclado, mouse.
▪ Dispositivos de armazenamento
▪ HD, CD/DVD, Pen drive.
▪ Adaptadores de rede
▪ Para comunicação com outros
computadores.
§
1
.3
 U
n
d
e
r th
e
 C
o
v
e
rs
The BIG Picture
MIPSfpga 2.0 © Copyright Imagination Technologies 
2017
11June 25, 2017
MIPSfpga Core
MIPSfpga 2.0 © Copyright Imagination Technologies 
2017
12June 25, 2017
MIPSfpga Core
MIPSfpga 2.0 © Copyright Imagination Technologies 
2017
13June 25, 2017
MIPSfpga Core
• Processes instructions
• Co-processor: system registers, handles reset
MIPSfpga 2.0 © Copyright Imagination Technologies 
2017
14June 25, 2017
MIPSfpga: Registers, MDU
GPR: 
General 
Purpose 
Registers
MDU: 
Multiply/
Divide Unit
MIPSfpga 2.0 © Copyright Imagination Technologies 
2017
15June 25, 2017
MIPSfpga: MMU, Caches
MMU: 
Memory 
Management 
Unit
Caches: 
Instruction 
& Data
Cache 
Controller: 
Instruction 
& Data 
Caches
MIPSfpga 2.0 © Copyright Imagination Technologies 
2017
16June 25, 2017
MIPSfpga: Cache Controller
Cache 
Controller: 
Interfaces 
with I & D 
Caches and 
external 
memory 
(called 
scratch 
RAM, 
SRAM)
MIPSfpga 2.0 © Copyright Imagination Technologies 
2017
17June 25, 2017
MIPSfpga: (E)JTAG Interface
JTAG (also 
called
EJTAG):
Used for 
programmin
g and real-
time 
debugging of 
the core
MIPSfpga 2.0 © Copyright Imagination Technologies 
2017
18June 25, 2017
MIPSfpga: AHB-Lite Bus
AHB-Lite 
Bus: Used 
for 
interacting
with memory 
& 
peripherals
MIPSfpga 2.0 © Copyright Imagination Technologies 
2017
19June 25, 2017
MIPSfpga: UDI Interface, Interrupts
UDI (User-
Defined 
Interface 
Unit):
Enables 
user-defined 
instructions
Interrupt 
Interface:
used for 
hardware 
interrupts
MIPSfpga 2.0 © Copyright Imagination Technologies 
2017
20June 25, 2017
MIPSfpga: Coprocessor 2 Interface
COP2 
Interface:
Co-
processor 2 
Interface
MIPSfpga 2.0 © Copyright Imagination Technologies 
2017
21June 25, 2017
MIPSfpga Core
Chapter 1 — Computer Abstractions and Technology —
Dentro do Processador (ou CPU)
▪ Caminho de Dados: realiza operações sobre os dados.
▪ Unidade de Controle: controla os componentes e a 
sequencia de passos da via de dados, comunicação com a 
memória, comunicação com as interfaces de E/S.
▪ Memória Cache
▪ Pequena e rápida memória SRAM para acesso imediato
aos dados.
Chapter 1 — Computer Abstractions and Technology —
Dentro do Processador (ou CPU)
▪ CPU Barcelona da AMD: 4 núcleos de processamento (4 
CPUs em um só chip)
▪ Microarquitetura K10 (AMD) lançada em Setembro de 2017
• Outros periféricos são necessários para o seu funcionamento 
(como memória RAM/ROM, Temporizadores, ... )
→ conectados por um ou mais barramentos.
Características de Microprocessadores (CPUs)
CPU
ROM
Temporizador
Portas de 
E/S
Barramento
RAM
24
25
• Barateamento dos CIs + surgimento de microprocessadores (CPUs) 
mais poderosos → começou-se a usar CPUs mais simples para 
implementar tarefas dedicadas (controle de impressora, reguladores 
de velocidade, acionadores de motores de passo, ...)
• Contudo: Qualquer controle implicaria em um hardware muito grande, 
que muitas vezes encareceria o custo do controlador 
→ Solução: Integração do controle e periféricos dedicados a essas 
tarefas de controle e comunicação externa no mesmo chip → MCU
Microcontroladores (1971-74)
Organização de um Microcontrolador (MCU)
CPU
Memória
(ROM/RAM/Flash/...)
Te
m
p
o
ri
za
d
o
r
(o
p
ci
o
n
al
)
C
o
n
ve
rs
o
re
s 
 
A
/D
 –
D
/A
(o
p
ci
o
n
al
)
Portas de E/S
O
sc
ila
d
o
r
M
ai
s 
co
m
p
o
n
en
te
s
(o
p
ci
o
n
al
)
Barramento
(cristal 
exterior)
Microcontrolador
Características de Microcontroladores 
• Fundamentalmente é um 
componente que integra os três 
blocos principais no mesmo chip: 
CPU, memória e periféricos 
(temporizadores, conversores, ...)
• Abreviação: MCU (unidade de 
microcontrolador)
• Muito usado para aplicações 
embarcadas.
• Facilita o desenvolvimento de 
sistemas com poucos 
componentes.
• Baixo custo (dependendo do 
modelo).
• Fácil gravação e regravação de 
programas.
• Dispositivos que permitem 
gravação (carga) automática 
pela sua interface serial.
27
• Memória:
• Memória de programa:
• EPROM(Erasable Programmable Read Only Memory)
• ROM(Read Only Memory)
• OTP (One Time Programmable)
• FLASH (EEPROM de acesso rápido)
• Memória de dados:
• RAM (volátil)
• EEPROM (não volátil)
Recursos Típicos de um Microcontrolador 
28
• Entrada e Saída de Dados.
• Os terminais (pinos) do MCU são agrupados em 
portais. 
• Cada terminal pode ser configurado individualmente
como entrada ou saída. 
• Portanto os terminais (pinos) do MCU são 
programáveis pelo usuário.
• Cada terminal tem capacidade para acionar
pequenas cargas.
Recursos Típicos de um Microcontrolador 
29
Fonte: Souza, Cerne, 2007
• Periféricos
• Temporizadores
• Temporizador de ‘watchdog’
• Contadores
• PWM 
• Comunicação serial 
• Conversor analógico/digital 
• Protocolos Industriais e Automobilísticos
• USB / Ethernet
• ...
Recursos Típicos de um Microcontrolador 
30
Chapter 1 — Computer Abstractions and Technology —
Abstrações
▪ Abstrações nos ajudam a lidar com complexidades.
▪ Omitem detalhes dos níveis inferiores.
▪ Arquitetura de Conjunto de Instruções (ISA)
▪ A interface entre hardware e software.
▪ Interface binária a nível de Aplicação.
▪ ISA + Sistema de interface ou Sistema Operacional.
▪ Implementação
▪ Os detalhes essenciais e a própria interface.
Chapter 1 — Computer Abstractions and Technology —
Níveis de Abstração de Software
▪ Software Aplicativo
▪ Escrito em linguagem de alto nível.
▪ Softwares de sistema
▪ Compilador: traduz linguagens de alto 
nível para linguagem de máquina
▪ Sistema Operacional:
▪ Lida com entrada e saída.
▪ Gerencia memória e armazenamento.
▪ Programa tarefas e recursos
compartilhados.
▪ Hardware
▪ Processador, memória, entrada e 
saída.
§
1
.2
 B
e
lo
w
 Y
o
u
r P
ro
g
ra
m
Chapter 1 — Computer Abstractions and Technology —
Níveis de Códigos de Programa
▪ Linguagem de alto nível
▪ Nível de abstração mais próximo do 
domínio da aplicação.
▪ Proporciona produtividade e 
portabilidade.
▪ Linguagem Assembly
▪ Representação textual das 
instruções.
▪ Linguagem de Máquina
(Representação entendida pela CPU)
▪ Dígitos binários (bits)
▪ Instruções e informações
codificadas
• Arquitetura são os atributos do 
computador visíveis para o 
programador:
o Conjunto de instruções.
o Número de bits utilizado para a 
representação de dados.
o Mecanismos de E/S.
o Técnicas de endereçamento.
• Exemplos:
o Existe uma instrução de 
divisão?
o Quais os formatos de 
endereçamento existentes?
• Organização (ou Microarquitetura) 
é como as características da 
arquitetura são implementadas:
o Sinais de controle disponíveis
o Interfaces
o Tecnologias de Memória
o Como o conjunto de instruções é 
projetado e implementado.
• Exemplo:
o Existe uma unidade para divisão 
ou a divisão é feita por subtrações 
sucessivas?
Conceito de Arquitetura e Organização
34
35
• Complex Instruction Set Computer (Computador com um 
Conjunto Complexo de Instruções).
• Caracterizam-se por:
• Conjunto muito grande de instruções.
• Instruções complexas.
• Instruções altamente especializadas.
• Existência de vários formatos de instruções.
• Suporte de vários modos de endereçamento.
• Suporte para busca de operandos em memória.
• Baseado em microprogramação.
• Exemplos:
• 80x86 de Intel, 680x0 de Motorola.
Arquitetura CISC
• Programação do código de máquina mais fácil.
• Código binário normalmente pequeno → requer pouca 
memória de programa.
• Instruções memória-a-memória (carregar e armazenar 
dados com mesma instrução) → menos registradores
são necessários.
Solução ótima encontrada nos primeiros
computadores (na época em que o custo de 
memórias e registradores era muito alto)
Arquitetura CISC – Vantagens
36
• Muitas instruções especiais – muito dedicadas, mas pouco 
usadas.
• Execução de varias instruções complexas mais lenta do 
que o correspondente de uma sequencia de instruções 
mais simples.
• Alta complexidade
• Paralelismo complicado → frequência de clock reduzida.
• Tratamento de eventos externos (Interrupções) mais lento e 
complicado.
• A execução de instruções mais simples (comuns) demora mais do 
que necessário.
Pouco aplicável em computadores atuais.
CISC – Desvantagens
37
• Reduced Instruction Set Computer (Computador com 
um Conjunto Reduzido de Instruções).
• Menor quantidade de instruções.
• CPU CISC:Intel 80486 com 200 instruções contra 
• CPU RISC: SPARC com 50 instruções.
• Instruções mais simples.
• Largura fixa de cada instrução.
• Cada instrução demora em média um ciclo de clock (ou 
menos).
• Exemplos: MIPS, SPARC, ARM (Apple iPhone -
ARM1176JZF), Processadores novos da Intel (alguns 
são um mix de RISC e CISC).
Arquitetura RISC
38
• Demanda menos transistores (área) para implementar 
lógica.
• Maior parte das instruções usam REGISTRADORES
como 
operandos, o que implica em maior velocidade de 
processamento.
• Poucas instruções para acesso à memória.
• Acesso a memória é mais lento que acessar dados em registradores 
de um banco.
• Complexidade baixa
• Menos sujeito às falhas.
• Tempo de decodificação da instrução reduzido.
Arquitetura RISC - Vantagens
39
• Cada vez mais um número maior de registradores são 
necessários.
• Compilação de código de máquina mais complicado.
• Tarefas mais complexas demandam a combinação de uma 
grande sequencia de instruções simples.
• Código mais complexo / maior
• Uma tarefa mais complexa que se poderia fazer com uma única 
instrução CISC, demanda normalmente duas ou mais instruções 
RISC.
Arquitetura RISC – Desvantagens
40
• Fronteiras indistintas
• Processadores RISC atuais usam técnicas CISC (por exemplo, 
mais instruções, instruções mais complexas).
• Processadores CISC atuais usam técnicas RISC (p.e., um ciclo 
de clock por instrução – ou menos, menos instruções). 
• Técnicas avançadas (p.e., pipelining, branch prediction) 
aplicadas em processadores RISC e CISC.
• Outros fatores podem ser mais importantes (p.e. Cache).
• Mas: Sistemas embutidos só usam processadores RISC !!
• Área (CISC grande demais).
• Consumo de energia alto / dissipação de calor alta.
Comparação: RISC vs. CISC - Hoje
41
Chapter 1 — Computer Abstractions and Technology —
Multiprocessadores
▪ Microprocessadores com vários núcleos:
▪ Mais de um processador dentro de um único CI.
▪ Exigem explicitamente programação paralela.
▪ O hardware executa múltiplas instruções por vez.
▪ Despercebido pelo programador.
SlidesAulasAOC/cap3.pdf
1
Sistemas Processadores e Periféricos
Aritmética Computacional
Adaptado a partir dos Slides de Organização de Computadores 2006/02 do professor
Leandro Galvão DCC/UFAM - galvao@dcc.ufam.edu.br
Prof. Janier Arias Garcia
DELT – Escola de Engenharia
UFMG
Prefixos do Sistema Internacional de Medidas
Sistema Internacional de Medidas: SI
Padroniza unidades de medidas e seus 
prefixos
Dois grandes grupos de prefixos:
Múltiplos de 10
Submúltiplos de 10
Prefixos do Sistema Internacional de Medidas
Prefixo Símbolo Potência de 10
Kilo K 103
Mega M 106
Giga G 109
Tera T 1012
Peta P 1015
Exa E 1018
Zetta Z 1021
Yotta Y 1024
Prefixos do Sistema Internacional de Medidas
Prefixo Símbolo Potência de 10
mili m 10-3
micro μ 10-6
nano n 10-9
pico p 10-12
femto f 10-15
atto a 10-18
zepto z 10-21
yocto y 10-24
Prefixos do Sistema Internacional de Medidas
Costuma-se utilizar os mesmos prefixos das 
potências de 10 como aproximação de potências 
de 2.
A conversão é feita de seguinte forma:
Exemplo:
3
10
210
n
n

→
BBBG B 3 03
9
1 0
9 25251055 =→=

10
3
102
n
n

→ou
Prefixos do Sistema Internacional de Medidas
Quando representa uma aproximação de 210, o 
prefixo kilo é escrito como Kilo, ou seja, com a 
inicial maiúscula.
Dessa forma, quando tratamos com potências 
de 2, temos:
Prefixos maiúsculos: múltiplos de 2.
Prefixos minúsculos: submúltiplos de 2.
Prefixos do Sistema Internacional de Medidas
:: Correspondência entre potências de 10 e de 2
Prefixo Símbolo
Potência de 
10
Potência de 
2
kilo K 103 210
mega M 106 220
giga G 109 230
tera T 1012 240
peta P 1015 250
exa E 1018 260
zetta Z 1021 270
yotta Y 1024 280
Prefixos da IEC
Em 1998, a IEC (International Electrotechnical
Commission) aprovou novos prefixos 
especialmente dedicados a potências de 2.
Dessa forma:
5 Gigabytes (GB) deveriam significar 
exatamente 5 × 109 bytes.
5 Gibibytes (GiB) deveriam significar 
exatamente 5 × 230 bytes.
Tal convenção está cada vez mais se tornando 
popular, sobretudo no meio científico e entre 
engenheiros.
Prefixos da IEC
Prefixo Símbolo Potência de 2
kibi Ki 210
mebi Mi 220
gibi Gi 230
tebi Ti 240
pebi Pi 250
exbi Ei 260
Prefixo de potência de 10 + bi (binário)
Representação de números
Notação de ponto fixo (inteiros)
Notação de ponto flutuante (real)
Representação de número de ponto fixo
Temos somente os algarismos 0 e 1 para 
representar todos os números inteiros
Inteiros positivos são transformados em 
binário:
41 = 0010 1001
1 = 0000 0001
64 = 0100 0000
Representação de número de ponto fixo
Essa representação de números inteiros 
em binário é direta e não se preocupa 
com sinal, nem com formatação dos bits.
Ponto fixo
:: Complemento de dois
maxint
minint
32 bits
Ponto fixo
:: Extensão de sinal :: Exemplo
-4dec (16 bits) para 32 bits:
1111 1111 1111 1100 bin
1111 1111 1111 1100 bin1111 1111 1111 1111 
12a
exemplos/12a_ponto_fixo.s
Ponto fixo
:: Comparação
MIPS suporta comparação com e sem sinal 
Com sinal:
Set on less than (slt)
Set on less than immediate (slti)
Sem sinal
Set on less than unsigned (sltu) 
Set on less than immediate unsigned (sltiu) 
Comparações sem sinal são geralmente usadas 
para manipular endereços de memória
Ponto fixo
:: Comparação
Instruções interpretam o tipo de representação
$s0 = 1111 1111 1111 1111 1111 1111 1111 1100bin
$s1 = 0011 1011 1001 1010 1000 1010 0000 0000bin
slt $t0, $s0, $s1 # comparação COM sinal
$t0: -4dec < 1 000 000 000dec?
$t0 = 1
Ponto fixo
:: Comparação
Instruções interpretam o tipo de representação
$s0 = 1111 1111 1111 1111 1111 1111 1111 1100bin
$s1 = 0011 1011 1001 1010 1000 1010 0000 0000bin
sltu $t3, $s0, $s1 # comparação SEM sinal
$t3 = 0
$t3: 4 294 967 292dec < 1 000 000 000dec?
Operações com ponto fixo
:: Overflow
Situação anormal que ocorre quando o 
resultado de uma operação não pode ser 
representado com um dada quantidade de bits.
Na arquitetura MIPS o limite é 32 bits
Tratamento de overflow depende do 
compilador e do sistema operacional.
Operações com ponto fixo
:: Overflow
Em MIPS, algumas instruções aritméticas 
geram exceções quando ocorre overflow.
O endereço da instrução que gerou overflow é 
salvo em um registrador especial: EPC 
(Exception Program Counter).
Operações com ponto fixo
:: Overflow
A execução é desviada para um endereço pré-
definido onde uma rotina apropriada é 
executada.
O Sistema Operacional (SO) decide o que fazer:
Execução pode abortar
Execução pode continuar após uma ação corretiva
Operações com ponto fixo
:: Overflow
Adição:
Quando os sinais dos operando são iguais, 
pode ocorrer overflow
Subtração:
Quando os sinais dos operando são 
diferentes, pode ocorrer overflow
Operações com ponto fixo
:: Overflow
O projetista de computador precisa 
oferecer uma maneira de:
Reconhecer overflow em alguns casos.
Ignorar overflow em outros casos 
(endereçamento de memória, por exemplo).
Operações com ponto fixo
:: Overflow
Solução MIPS:
Causam exceções no overflow:
Adição (add)
Adição imediata (addi)
Subtração (sub)
Não causam exceções no overflow:
Adição sem sinal (addu)
Adição imediata sem sinal (addiu)
Subtração sem sinal (subu)
Operações com ponto fixo
:: Formato de instruções MIPS
add $t0, $s1, $s2 # $t0 ← $s1 + $s2
addi $t0, $s1, 123 # $t0 ← $s1 + 123
sub $t0, $s1, $s2 # $t0 ← $s1 - $s2
addu $t0, $s1, $s2 # $t0 ← $s1 + $s2
addiu $t0, $s1, 123 # $t0 ← $s1 + 123
Operações com ponto fixo
:: Multiplicação
× 0111 (multiplicador) +7 decimal
0010 (multiplicando) +2 decimal
0010
0010
0010
+ 0000
00001110 (produto) +14 decimal
1110
Operações com ponto fixo
:: Multiplicação
Mais complexa do que a adição, pois envolve:
Deslocamentos
Adição
№ de bits do produto > № de bits dos operandos
m bits no multiplicando
n bits no multiplicador (m+n) bits no produto
Operações com ponto fixo
:: Multiplicação
Algoritmo (esboço):
1. Se bit da posição i do multiplicador for 1:
desloca-se
o multiplicando em i posições.
2. Se bit do multiplicador for 0, coloca-se 0.
3. Somar acumulativamente os produtos 
parciais.
Números negativos
converta e multiplique
Operações com ponto fixo
:: Multiplicação
Algoritmo (1a. versão em hardware):
1. Carregar operandos em registradores.
2. Carregar registrador-produto com zero.
3. Se bit mais à direita do multiplicador for 1:
Prod = Prod + Multiplicando
4. Se bit mais à direita do multiplicador for 0:
sem operação
5. Deslocar multiplicando à esquerda.
6. Deslocar multiplicador à direita.
7. Voltar ao passo 3 até 32 repetições.
1a. P ← P + Mndo
Início
Mdr0 = 1 Mdr0 = 0
2. Mnd << 1 bit
3. Mdr >> 1 bit
Fim
№ repet < 32
32
1. Mdr0 ?
Multiplicando Mnd
Multiplicador Mdr
Produto P
Multiplicação de inteiros
1a. versão
Operações com ponto fixo
:: Multiplicação
Operações com ponto fixo
:: Multiplicação
O multiplicador inicia na metade direita do 
produto 
Escrever
32 bits
64 bits
Shift right
Multiplicando
ALU 32 bits
Produto
Teste de 
controle
1a. P[esq] ← P[esq] + Mndo
Início
Mdr0 = 1 Mdr0 = 0
2. P >> 1 bit
3. Mdr >> 1 bit
Fim
№ repet < 32
32
1. Mdr0 ?
Multiplicando Mnd
Multiplicador Mdr
Produto P
Multiplicação de inteiros
2a. versão
Multiplicação com sinal
Multiplicação sem sinal
Onde é colocado o resultado?
mult $s1, $s2 # $s1 * $s2
multu $s1, $s2 # $s1 * $s2
Operações com ponto fixo
:: Multiplicação no MIPS
Produto (64 bits) é colocado em um par 
de registradores de 32 bits:
Hi – armazena a parte mais significativa
Lo – armazena a parte menos significativa
Não gera exceção de overflow.
Operações com ponto fixo
:: Multiplicação no MIPS
Duas instruções movem o produto dos 
registradores HI/LO para registradores de 
propósito geral:
Move from HI
Move from LO
mfhi $s1 # $s1 ← HI
mflo $t3 # $t3 ← LO
Operações com ponto fixo
:: Multiplicação no MIPS
Para mover dados para os registradores 
HI/LO utilizam-se as seguintes instruções:
Move to HI
Move to LO
mthi $s1 # HI ← $s1
mtlo $t3 # LO ← $t3
15
Operações com ponto fixo
:: Multiplicação no MIPS
exemplos/15_aritmetica_multiplicacao.s
O assembler MIPS oferece uma pseudo-
instrução que coloca diretamente o produto no 
registrador de destino desejado:
Exemplos:
mul Rdest, Rsrc1, Src2
mul $t0, $s1, $s2 # t0 ← $s1 * $s2
mul $t0, $s1, 123 # t0 ← $s1 * 123
Operações com ponto fixo
:: Multiplicação no MIPS
O assembler MIPS oferece mais duas pseudo-
instruções para multiplicação:
Multiplicação com detecção de overflow:
Multiplicação sem sinal (com overflow)
mulo Rdest, Rsrc1, Src2
mulou Rdest, Rsrc1, Src2
16
Operações com ponto fixo
:: Multiplicação no MIPS
exemplos/16_aritmetica_multiplicacao_over.s
1011
00001101
10010011
1011
00111
1011
1011
100
Quociente
Dividendo Divisor
0011
00001101
’ ’ ’ ’ ’ ’ ’ ’
0
11
Resto
Operações com ponto fixo
:: Divisão
64-bit ALU
Teste de
controle
Quociente
Resto Escrever
Divisor
Deslocar à direita
64 bits
64 bits
32 bits
Deslocar à esquerda
Operações com ponto fixo
:: Divisão
Pronto
2a) Quociente << 1, 
Quociente[0] =1
n = 33
Início, n = 0
Resto >= 0 Resto < 0
2b) Resto = Resto + Divisor,
Quociente << 1, 
Quociente[0] = 0
3) Divisor >> 1
1) Resto = Resto – Divisor, 
n++
Não
Sim
Teste do
 Resto
Operações com ponto fixo
:: Divisão: Passo a passo
No Iteração Resto 
(inclui o
dividendo)
Divisor Resto
menos o 
Divisor
Quociente Teste do 
algoritmo
1 0000 0101 0010 0000 1110 0101 0000 negativo
2 0000 0101 0001 0000 1111 0101 0000 negativo
3 0000 0101 0000 1000 1111 1101 0000 negativo
4 0000 0101 0000 0100 0000 0001 0001 positivo
5 0000 0001 0000 0010 0010 negativo
Vamos fazer: 5 / 2 usando 4 bits 
Dividendo: 0101
Divisor: 0010
Registradores do Resto e Divisor terão 8 bits
Registrador do Quociente terá 4 bits
No início a parte menos significativa do Registrador Resto conterá o dividendo
e os 4 bits mais significativos do registrador Divisor, o valor inicial do divisor.
Teste de
controleQuociente
32 bits
64 bits
Divisor
32-bit ALU
Resto
Operações com ponto fixo
:: Divisão
Tamanho da ULA 
é só 32 bits!
Shift Left
Shift Right
WE
Dividendo
Resto [63]
Teste de
controle
4 bits
8 bits
4-bit ALU
Operações com ponto fixo
:: Exemplo de uma Divisão com HW simplificado 
Resto [7]
Vamos fazer: 5 / 2 usando 4 bits 
Dividendo = Carregado na mesma parte onde vai 
ficar o Quociente (LO): 0101
Divisor: 0010
Registradores do Resto e Divisor terão 4 bits
Registrador do Quociente terá 4 bits
No início a parte menos significativa do 
Registrador Quociente 
conterá o dividendo.
0101
0010
0000
Divisor
Quociente Resto 
Início
Teste de
controle
4 bits
8 bits
4-bit ALU
Operações com ponto fixo
:: Exemplo de uma Divisão com HW simplificado 
Resto [7]
Vamos fazer: 5 / 2 usando 4 bits 
Dividendo = Carregado na mesma parte onde vai 
ficar o Quociente (LO): 0101
Divisor: 0010
Registradores do Resto e Divisor terão 4 bits
Registrador do Quociente terá 4 bits
No início a parte menos significativa do 
Registrador Quociente 
conterá o dividendo.
101?
0010
0000
Divisor
Quociente Resto 
Iteração 1 – Passo 1
<< 1
Teste de
controle
4 bits
8 bits
4-bit ALU
Operações com ponto fixo
:: Exemplo de uma Divisão com HW simplificado 
Resto [7]
Vamos fazer: 5 / 2 usando 4 bits 
Dividendo = Carregado na mesma parte onde vai 
ficar o Quociente (LO): 0101
Divisor: 0010
Registradores do Resto e Divisor terão 4 bits
Registrador do Quociente terá 4 bits
No início a parte menos significativa do 
Registrador Quociente 
conterá o dividendo.
101?
0010
1110
Divisor
Quociente Resto 
Iteração 1 – Passo 2
Subtração
Teste de
controle
4 bits
8 bits
4-bit ALU
Operações com ponto fixo
:: Exemplo de uma Divisão com HW simplificado 
Resto [7] = 1
Vamos fazer: 5 / 2 usando 4 bits 
Dividendo = Carregado na mesma parte onde vai 
ficar o Quociente (LO): 0101
Divisor: 0010
Registradores do Resto e Divisor terão 4 bits
Registrador do Quociente terá 4 bits
No início a parte menos significativa do 
Registrador Quociente 
conterá o dividendo.
101?
0010
1110
Divisor
Quociente Resto 
Iteração 1 – Passo 3
Teste
Teste de
controle
4 bits
8 bits
4-bit ALU
Operações com ponto fixo
:: Exemplo de uma Divisão com HW simplificado 
Resto [7] = 1
Vamos fazer: 5 / 2 usando 4 bits 
Dividendo = Carregado na mesma parte onde vai 
ficar o Quociente (LO): 0101
Divisor: 0010
Registradores do Resto e Divisor terão 4 bits
Registrador do Quociente terá 4 bits
No início a parte menos significativa do 
Registrador Quociente 
conterá o dividendo.
1010
0010
1110
Divisor
Quociente Resto 
Iteração 1 – Passo 4
Negativo
(inclui 0)
Teste de
controle
4 bits
8 bits
4-bit ALU
Operações com ponto fixo
:: Exemplo de uma Divisão com HW simplificado 
Resto [7]
Vamos fazer: 5 / 2 usando 4 bits 
Dividendo = Carregado na mesma parte onde vai 
ficar o Quociente (LO): 0101
Divisor: 0010
Registradores do Resto e Divisor terão 4 bits
Registrador do Quociente terá 4 bits
No início a parte menos significativa do 
Registrador Quociente 
conterá o dividendo.
1010
0010
0000
Divisor
Quociente Resto 
Iteração 1 – Passo 5
Soma (restauração)
Teste de
controle
4 bits
8 bits
4-bit ALU
Operações com ponto fixo
:: Exemplo de uma Divisão com HW simplificado 
Resto [7]
Vamos fazer: 5 / 2 usando 4 bits 
Dividendo = Carregado na mesma parte onde vai 
ficar o Quociente (LO): 0101
Divisor: 0010
Registradores do Resto e Divisor terão 4 bits
Registrador do Quociente terá 4 bits
No início a parte menos
significativa do 
Registrador Quociente 
conterá o dividendo.
010?
0010
0001
Divisor
Quociente Resto 
Iteração 2 – Passo 1
<< 1
Teste de
controle
4 bits
8 bits
4-bit ALU
Operações com ponto fixo
:: Exemplo de uma Divisão com HW simplificado 
Resto [7]
Vamos fazer: 5 / 2 usando 4 bits 
Dividendo = Carregado na mesma parte onde vai 
ficar o Quociente (LO): 0101
Divisor: 0010
Registradores do Resto e Divisor terão 4 bits
Registrador do Quociente terá 4 bits
No início a parte menos significativa do 
Registrador Quociente 
conterá o dividendo.
010?
0010
1111
Divisor
Quociente Resto 
Iteração 2 – Passo 2
Subtração
Teste de
controle
4 bits
8 bits
4-bit ALU
Operações com ponto fixo
:: Exemplo de uma Divisão com HW simplificado 
Resto [7] = 1
Vamos fazer: 5 / 2 usando 4 bits 
Dividendo = Carregado na mesma parte onde vai 
ficar o Quociente (LO): 0101
Divisor: 0010
Registradores do Resto e Divisor terão 4 bits
Registrador do Quociente terá 4 bits
No início a parte menos significativa do 
Registrador Quociente 
conterá o dividendo.
010?
0010
1111
Divisor
Quociente Resto 
Iteração 2 – Passo 3
Teste
Teste de
controle
4 bits
8 bits
4-bit ALU
Operações com ponto fixo
:: Exemplo de uma Divisão com HW simplificado 
Resto [7] = 1
Vamos fazer: 5 / 2 usando 4 bits 
Dividendo = Carregado na mesma parte onde vai 
ficar o Quociente (LO): 0101
Divisor: 0010
Registradores do Resto e Divisor terão 4 bits
Registrador do Quociente terá 4 bits
No início a parte menos significativa do 
Registrador Quociente 
conterá o dividendo.
0100
0010
1111
Divisor
Quociente Resto 
Iteração 2 – Passo 4
Negativo
(inclui 0)
Teste de
controle
4 bits
8 bits
4-bit ALU
Operações com ponto fixo
:: Exemplo de uma Divisão com HW simplificado 
Resto [7]
Vamos fazer: 5 / 2 usando 4 bits 
Dividendo = Carregado na mesma parte onde vai 
ficar o Quociente (LO): 0101
Divisor: 0010
Registradores do Resto e Divisor terão 4 bits
Registrador do Quociente terá 4 bits
No início a parte menos significativa do 
Registrador Quociente 
conterá o dividendo.
0100
0010
0001
Divisor
Quociente Resto 
Iteração 2 – Passo 5
Soma (restauração)
Teste de
controle
4 bits
8 bits
4-bit ALU
Operações com ponto fixo
:: Exemplo de uma Divisão com HW simplificado 
Resto [7]
Vamos fazer: 5 / 2 usando 4 bits 
Dividendo = Carregado na mesma parte onde vai 
ficar o Quociente (LO): 0101
Divisor: 0010
Registradores do Resto e Divisor terão 4 bits
Registrador do Quociente terá 4 bits
No início a parte menos significativa do 
Registrador Quociente 
conterá o dividendo.
100?
0010
0010
Divisor
Quociente Resto 
Iteração 3 – Passo 1
<< 1
Teste de
controle
4 bits
8 bits
4-bit ALU
Operações com ponto fixo
:: Exemplo de uma Divisão com HW simplificado 
Resto [7]
Vamos fazer: 5 / 2 usando 4 bits 
Dividendo = Carregado na mesma parte onde vai 
ficar o Quociente (LO): 0101
Divisor: 0010
Registradores do Resto e Divisor terão 4 bits
Registrador do Quociente terá 4 bits
No início a parte menos significativa do 
Registrador Quociente 
conterá o dividendo.
100?
0010
0000
Divisor
Quociente Resto 
Iteração 3 – Passo 2
Subtração
Teste de
controle
4 bits
8 bits
4-bit ALU
Operações com ponto fixo
:: Exemplo de uma Divisão com HW simplificado 
Resto [7] = 0
Vamos fazer: 5 / 2 usando 4 bits 
Dividendo = Carregado na mesma parte onde vai 
ficar o Quociente (LO): 0101
Divisor: 0010
Registradores do Resto e Divisor terão 4 bits
Registrador do Quociente terá 4 bits
No início a parte menos significativa do 
Registrador Quociente 
conterá o dividendo.
100?
0010
0000
Divisor
Quociente Resto 
Iteração 3 – Passo 3
Teste
Teste de
controle
4 bits
8 bits
4-bit ALU
Operações com ponto fixo
:: Exemplo de uma Divisão com HW simplificado 
Resto [7] = 0
Vamos fazer: 5 / 2 usando 4 bits 
Dividendo = Carregado na mesma parte onde vai 
ficar o Quociente (LO): 0101
Divisor: 0010
Registradores do Resto e Divisor terão 4 bits
Registrador do Quociente terá 4 bits
No início a parte menos significativa do 
Registrador Quociente 
conterá o dividendo.
1001
0010
0000
Divisor
Quociente Resto 
Iteração 3 – Passo 4
Positivo
(inclui 1)
Teste de
controle
4 bits
8 bits
4-bit ALU
Operações com ponto fixo
:: Exemplo de uma Divisão com HW simplificado 
Resto [7]
Vamos fazer: 5 / 2 usando 4 bits 
Dividendo = Carregado na mesma parte onde vai 
ficar o Quociente (LO): 0101
Divisor: 0010
Registradores do Resto e Divisor terão 4 bits
Registrador do Quociente terá 4 bits
No início a parte menos significativa do 
Registrador Quociente 
conterá o dividendo.
1001
0010
0000
Divisor
Quociente Resto 
Iteração 3 – Passo 5
Faz nada
Teste de
controle
4 bits
8 bits
4-bit ALU
Operações com ponto fixo
:: Exemplo de uma Divisão com HW simplificado 
Resto [7]
Vamos fazer: 5 / 2 usando 4 bits 
Dividendo = Carregado na mesma parte onde vai 
ficar o Quociente (LO): 0101
Divisor: 0010
Registradores do Resto e Divisor terão 4 bits
Registrador do Quociente terá 4 bits
No início a parte menos significativa do 
Registrador Quociente 
conterá o dividendo.
001?
0010
0001
Divisor
Quociente Resto 
Iteração 4 – Passo 1
<< 1
Teste de
controle
4 bits
8 bits
4-bit ALU
Operações com ponto fixo
:: Exemplo de uma Divisão com HW simplificado 
Resto [7]
Vamos fazer: 5 / 2 usando 4 bits 
Dividendo = Carregado na mesma parte onde vai 
ficar o Quociente (LO): 0101
Divisor: 0010
Registradores do Resto e Divisor terão 4 bits
Registrador do Quociente terá 4 bits
No início a parte menos significativa do 
Registrador Quociente 
conterá o dividendo.
001?
0010
1111
Divisor
Quociente Resto 
Iteração 4 – Passo 2
Subtração
Teste de
controle
4 bits
8 bits
4-bit ALU
Operações com ponto fixo
:: Exemplo de uma Divisão com HW simplificado 
Resto [7] = 1
Vamos fazer: 5 / 2 usando 4 bits 
Dividendo = Carregado na mesma parte onde vai 
ficar o Quociente (LO): 0101
Divisor: 0010
Registradores do Resto e Divisor terão 4 bits
Registrador do Quociente terá 4 bits
No início a parte menos significativa do 
Registrador Quociente 
conterá o dividendo.
001?
0010
1111
Divisor
Quociente Resto 
Iteração 4 – Passo 3
Teste
Teste de
controle
4 bits
8 bits
4-bit ALU
Operações com ponto fixo
:: Exemplo de uma Divisão com HW simplificado 
Resto [7] = 1
Vamos fazer: 5 / 2 usando 4 bits 
Dividendo = Carregado na mesma parte onde vai 
ficar o Quociente (LO): 0101
Divisor: 0010
Registradores do Resto e Divisor terão 4 bits
Registrador do Quociente terá 4 bits
No início a parte menos significativa do 
Registrador Quociente 
conterá o dividendo.
0010
0010
1111
Divisor
Quociente Resto 
Iteração 4 – Passo 4
Positivo
(inclui 0)
Teste de
controle
4 bits
8 bits
4-bit ALU
Operações com ponto fixo
:: Exemplo de uma Divisão com HW simplificado 
Resto [7]
Vamos fazer: 5 / 2 usando 4 bits 
Dividendo = Carregado na mesma parte onde vai 
ficar o Quociente (LO): 0101
Divisor: 0010
Registradores do Resto e Divisor terão 4 bits
Registrador do Quociente terá 4 bits
No início a parte menos significativa do 
Registrador Quociente 
conterá o dividendo.
0010
0010
0001
Divisor
Quociente Resto 
Iteração 4 – Passo 5
Soma (restauração)
Divisão com sinal
Divisão sem sinal
div $s1, $s2 # $s1 / $s2
divu $s1, $s2 # $s1 / $s2
Operações com ponto fixo
:: Divisão
Resultado da divisão é colocado no par 
de registradores HI/LO:
Hi – armazena o resto
Lo – armazena o quociente
Não gera exceção de overflow.
Deve-se
verificar se o divisor é zero, caso 
contrário o resultado é indefinido.
17
Operações com ponto fixo
:: Divisão no MIPS
exemplos/17_aritmetica_divisao.s
O assembler MIPS também oferece uma 
pseudo-instrução para obter o quociente:
Exemplos:
div Rdest, Rsrc1, Src2
div $t0, $s1, $s2 # t0 ← $s1 / $s2
div $t0, $s1, 123 # t0 ← $s1 / 123
Operações com ponto fixo
:: Divisão no MIPS
Pesudo-instrução MIPS para obter o resto:
Exemplos:
rem Rdest, Rsrc1, Src2
rem $t0, $s1, $s2 # t0 ← $s1 % $s2
rem $t0, $s1, 123 # t0 ← $s1 % 123
18
Operações com ponto fixo
:: Divisão no MIPS
exemplos/18_aritmetica_divisao_quociente.s
Para operar números sem sinal:
Para forçar a instrução real de divisão:
divu Rdest, Rsrc1, Src2
div $0, Rsrc1, Rsrc2
Operações com ponto fixo
:: Divisão no MIPS
Ponto flutuante (Padrão IEEE 754)
Um número real pode ser representado 
no seguinte formato:
(-1)s × m × Be
s – sinal
m – significando (mantissa)
B – base
e – expoente
Ponto flutuante (Padrão IEEE 754)
:: Sinal
O bit mais à esquerda guarda o sinal do 
número:
bit = 0 → número positivo
bit = 1 → número negativo
Não há mais notação de complemento de 2 
para o número representado!
Ponto flutuante (Padrão IEEE 754) 
:: Fração
O significando é representado na forma 
normalizada (base binária):
1.xxxxx
E não na forma científica:
0.1xxxx
Nessa forma, o significando é composto por:
Algarismo 1
Ponto de separação 
Fração
O algarismo 1 e o ponto de numeração não 
precisam ser armazenados, pois são os mesmos 
para todos os números reais representados.
Caso a fração possua menos bits que o 
esperado, zeros devem ser colocados à direita, 
pois não têm significância.
Ponto flutuante (Padrão IEEE 754)
:: Fração
11001100000000000000000
23 bits
fração
fração = 1,110011
Ponto flutuante (Padrão IEEE 754)
:: Base
A base B é implícita (binária) e não 
precisa ser guardada, pois é a mesma 
para todos os números representados.
Ponto flutuante (Padrão IEEE 754)
:: Expoente
O expoente é representado na notação 
deslocada, ou excesso de N, onde:
N = 2(n-1) -1, onde n é o número de bits 
dedicado para representar o expoente.
Maior expoente representável: 2n-1
Representado por: 11...11
Menor expoente representável: -(2n-1 - 1)
Representado por: 00...00
Decimal
Complemento 
de dois
Notação 
deslocada
+4 -- 111
+3 011 110
+2 010 101
+1 001 100
0 000 011
-1 111 010
-2 110 001
-3 101 000
-4 100 --
Ponto flutuante (Padrão IEEE 754)
:: Notação deslocada
Representação do valor zero: 01...11
Representação do valor um: 10...00
Demais valores: somar ao zero (o deslocamento N)
Vantagem: facilita a comparação de expoentes
entre números de mesmo sinal
Ponto flutuante (Padrão IEEE 754)
:: Notação deslocada
Ponto flutuante
O formato IEEE 754 de precisão simples 
(float) ocupa 32 bits
23 bits8 bits1 bit
fraçãoexpoentesinal
Ponto flutuante
O formato IEEE 754 de precisão dupla 
(double) ocupa 64 bits
52 bits11 bits1 bit
fraçãoexpoentesinal
Exemplo:
(10)bin = +1.0 × 2
1
0
1 bit
sinal
0000 0000 0000 0000 0000 000
23 bits
fração
1000 0000
8 bits
expoente
Ponto flutuante
Mais exemplos:
Ponto flutuante
Conversão número real (decimal) para
Notação IEEE 754 (precisão simples)
Exemplo: Converter 23,5467
1) Divido o número pela maior potência de 2 imediatamente 
menor que o número original
23,5467/24 = 23,5467/16 = 1,47166875
Dessa forma o número original fica reescrito dessa forma:
1,47166875 x 24
Agora convertemos o número 1,47166875 x 24 para a notação 
IEEE754 (precisão simples)
Número positivo = bit mais significativo igual a 0 (bit31)
Expoente = +4 01111111  Expoente 0 (+127)
+00000100  Somo 4 ao Expoente 0
Expoente final na notação deslocada → 10000011 (+131)
Conversão número real (decimal) para
Notação IEEE 754 (precisão simples)
Resta agora converter a mantissa 0,47166875 para a notação 
IEEE754 (precisão simples)
Como temos 23 bits para a mantissa na notação IEEE754 
(precisão simples), podemos escrever a parte fracionária 
com 6 algarismos em Hexadecimal (6 x 4 = 24) fazendo a 
correção necessária do último bit.
Fração ou 
Resto
0,47166875 0,5467 0,7472 0,9552 0,2832 0,5312
X 16 7,5467 8,7472 11,9552 15,2832 4,5312 8,4992
Inteiro(Hexa) 7 (7) 8 (8) 11 (B) 15 (F) 4 (4) 8 (8)
Mantissa em Hexadecimal → 7 8 B F 4 8
Mantissa em Binário → 0111 1000 1011 1111 0100 1000X
Mantissa agora com os 23 bits da Notação IEEE 754 
Conversão número real (decimal) para 
Notação IEEE 754 (precisão simples)
Número final na notação IEEE 754 (precisão simples)
0 10000011 01111000101111110100100
01000001101111000101111110100100
Separando de 4 em 4 bits para escrevê-lo em Hexadecimal fica:
0100 0001 1011 1100 0101 1111 1010 0100
4 1 B C 5 F A 4
Conversão de número em Notação
IEEE 754 (precisão simples) para real
• Exemplo: Converter: 41BC5FA4
1) Converto o número para binário:
0100 0001 1011 1100 0101 1111 1010 0100
2) Reagrupo o número binário na notação:
sinal + expoente deslocado + mantissa
0 10000011 01111000101111110100100
3) Incluo mais um bit igual a zero ao fim da mantissa para 
completar 24 bits (6 algarismos hexa) e reorganizo a mantissa 
grupando-a de 4 em 4 bits.
0 10000011 0111 1000 1011 1111 0100 1000
131-127=4
sinal expoente mantissa
+ 24 * (1,0 + 7*16-1 + 8*16-2 + 11*16-3 + 15*16-4 + 4*16-5 + 8*16-6)
7 8 B F 4 8
23,54669952392578125
Overflow: ocorre quando o expoente é muito 
grande para ser representado no campo 
expoente.
Underflow: ocorre quando o expoente é muito 
pequeno (= pequena fração) para ser 
representado no campo expoente.
Ponto flutuante
Ponto flutuante × Ponto fixo
0 2
31 - 1-231
Inteiros representados
0- (2 - 2
-23) × 2127
underflow 
positivo
- 2-126 2-126 (2 - 2-23) × 2127
underflow 
negativo
números 
representados
números 
representados
overflow 
positivo
overflow 
negativo
Densidade de números de ponto flutuante
Números representados em ponto flutuante 
não são igualmente espaçados, tal como na 
notação de ponto fixo. 
Alguns cálculos podem produzir resultados que 
não são exatos e tenham de ser arredondados
para a notação mais próxima.
Como o zero é representado em ponto 
flutuante?
Ponto flutuante
:: Zero
0 00000000 0000000000000000000000
fraçãoexpoentesinal
1 00000000 0000000000000000000000
fraçãoexpoentesinal
“+ 0”
“- 0”
Notação especial para representar eventos 
incomuns:
permite que os programas possam manipulá-los sem 
que sejam interrompidos.
Ponto flutuante
:: Infinito
0 11111111 0000000000000000000000
fraçãoexpoentesinal +∞
1 11111111 0000000000000000000000
fraçãoexpoentesinal -∞
É uma representação do resultado de 
operações inválidas, tais como:
0/0
∞ - ∞
∞/∞
0 × ∞
√x, x < 0
Ponto flutuante
:: NaN – Not a Number
x 11111111 axx...xx ≠ 0
fraçãoexpoentesinal
Se a = 1 quiet NaN
Se a = 0 Silent NaN
Quiet NaN: propaga o resultado
Silent NaN: provoca uma exceção
Servem para lidar com casos de underflow.
Quando o expoente é muito pequeno para ser 
representado em 8 bits (menor que -126), o 
número é deslocado à direita até que o 
expoente seja igual a -126.
Ponto flutuante
:: Números desnormalizados
x 00000000 xxx...xx ≠ 0
fraçãoexpoentesinal
Ponto flutuante
Veja a diferença 
entre um e outro 
no slide 92
Ponto flutuante
:: Números desnormalizados
Single-Precision Range
Exponents 00000000 and 11111111 reserved
Smallest value normalized
Exponent: 00000001
 actual exponent = 1 – 127 = –126
Fraction: 000…00  significand = 1.0
±1.0 × 2–126 ≈ ±1.2 × 10–38
Largest value normalized
exponent: 11111110
 actual exponent
= 254 – 127 = +127
Fraction: 111…11  significand ≈ 2.0
±2.0 × 2+127 ≈ ±3.4 × 10+38
Double-Precision Range
Exponents 0000…00 and 1111…11 reserved
Smallest value normalized
Exponent: 00000000001
 actual exponent = 1 – 1023 = –1022
Fraction: 000…00  significand = 1.0
±1.0 × 2–1022 ≈ ±2.2 × 10–308
Largest value normalized
Exponent: 11111111110
 actual exponent = 2046 – 1023 = +1023
Fraction: 111…11  significand ≈ 2.0
±2.0 × 2+1023 ≈ ±1.8 × 10+308
Summary – IEEE – 754 Precision Range
Floating-Point Precision
Relative precision
all fraction bits are significant
Single: approx 2–23
Equivalent to 23 × log102 ≈ 23 × 0.3 ≈ 6 decimal 
digits of precision
Double: approx 2–52
Equivalent to 52 × log102 ≈ 52 × 0.3 ≈ 16 decimal 
digits of precision
http://steve.hollasch.net/cgindex/coding/ieeefloat.html
Resumo de Faixas de Representação
SlidesAulasAOC/chapter3modif.pdf
Chapter 3
Arithmetic for Computers
Chapter 3 — Arithmetic for Computers — 2
Floating-Point Addition
◼ Consider a 4-digit decimal example
◼ 9.999 × 101 + 1.610 × 10–1
◼ 1. Align decimal points
◼ Shift number with smaller exponent
◼ 9.999 × 101 + 0.016 × 101
◼ 2. Add significands
◼ 9.999 × 101 + 0.016 × 101 = 10.015 × 101
◼ 3. Normalize result & check for over/underflow
◼ 1.0015 × 102
◼ 4. Round and renormalize if necessary
◼ 1.002 × 102
Chapter 3 — Arithmetic for Computers — 3
Floating-Point Addition
◼ Now consider a 4-digit binary example
◼ 1.0002 × 2
–1 + –1.1102 × 2
–2 (0.5 + –0.4375)
◼ 1. Align binary points
◼ Shift number with smaller exponent
◼ 1.0002 × 2
–1 + –0.1112 × 2
–1
◼ 2. Add significands
◼ 1.0002 × 2
–1 + –0.1112 × 2
–1 = 0.0012 × 2
–1
◼ 3. Normalize result & check for over/underflow
◼ 1.0002 × 2
–4, with no over/underflow
◼ 4. Round and renormalize if necessary
◼ 1.0002 × 2
–4 (no change) = 0.0625
Chapter 3 — Arithmetic for Computers — 4
FP Adder Hardware
◼ Much more complex than integer adder
◼ Doing it in one clock cycle would take too 
long
◼ Much longer than integer operations
◼ Slower clock would penalize all instructions
◼ FP adder usually takes several cycles
◼ Can be pipelined
Chapter 3 — Arithmetic for Computers — 5
FP Adder Hardware
Step 1
Step 2
Step 3
Step 4
Chapter 3 — Arithmetic for Computers — 6
FP Instructions in MIPS
◼ Single-precision arithmetic
◼ add.s, sub.s, mul.s, div.s
◼ e.g., add.s $f0, $f1, $f6
◼ Double-precision arithmetic
◼ add.d, sub.d, mul.d, div.d
◼ e.g., mul.d $f4, $f4, $f6
◼ Single- and double-precision comparison
◼ c.xx.s, c.xx.d (xx is eq, lt, le, …)
◼ Sets or clears FP condition-code bit
◼ e.g. c.lt.s $f3, $f4
◼ Branch on FP condition code true or false
◼ bc1t, bc1f
◼ e.g., bc1t TargetLabel
Chapter 3 — Arithmetic for Computers — 7
FP Example: °F to °C
◼ C code:
float f2c (float fahr) {
return ((5.0/9.0)*(fahr - 32.0));
}
◼ fahr in $f12, result in $f0, literals in global memory 
space
◼ Compiled MIPS code:
f2c: lwc1 $f16, const5($gp)
lwc1 $f18, const9($gp)
div.s $f16, $f16, $f18
lwc1 $f18, const32($gp)
sub.s $f18, $f0, $f18
mul.s $f12, $f16, $f18
jr $ra
Chapter 3 — Arithmetic for Computers — 8
FP Example: Array Multiplication
◼ X = X + Y × Z
◼ All 32 × 32 matrices, 64-bit double-precision elements
◼ C code:
void mm (double x[][],
double y[][], double z[][]) {
int i, j, k;
for (i = 0; i! = 32; i = i + 1)
for (j = 0; j! = 32; j = j + 1)
for (k = 0; k! = 32; k = k + 1)
x[i][j] = x[i][j]
+ y[i][k] * z[k][j];
}
◼ Addresses of x, y, z in $a0, $a1, $a2, and
i, j, k in $s0, $s1, $s2
Chapter 3 — Arithmetic for Computers — 9
FP Example: Array Multiplication
◼ MIPS code:
li $t1, 32 # $t1 = 32 (row size/loop end)
li $s0, 0 # i = 0; initialize 1st for loop
L1: li $s1, 0 # j = 0; restart 2nd for loop
L2: li $s2, 0 # k = 0; restart 3rd for loop
sll $t2, $s0, 5 # $t2 = i * 32 (size of row of x)
addu $t2, $t2, $s1 # $t2 = i * size(row) + j
sll $t2, $t2, 3 # $t2 = byte offset of [i][j]
addu $t2, $a0, $t2 # $t2 = byte address of x[i][j]
l.d $f4, 0($t2) # $f4 = 8 bytes of x[i][j]
L3: sll $t0, $s2, 5 # $t0 = k * 32 (size of row of z)
addu $t0, $t0, $s1 # $t0 = k * size(row) + j
sll $t0, $t0, 3 # $t0 = byte offset of [k][j]
addu $t0, $a2, $t0 # $t0 = byte address of z[k][j]
l.d $f16, 0($t0) # $f16 = 8 bytes of z[k][j]
…
Chapter 3 — Arithmetic for Computers — 10
FP Example: Array Multiplication
…
sll $t0, $s0, 5 # $t0 = i*32 (size of row of y)
addu $t0, $t0, $s2 # $t0 = i*size(row) + k
sll $t0, $t0, 3 # $t0 = byte offset of [i][k]
addu $t0, $a1, $t0 # $t0 = byte address of y[i][k]
l.d $f18, 0($t0) # $f18 = 8 bytes of y[i][k]
mul.d $f16, $f18, $f16 # $f16 = y[i][k] * z[k][j]
add.d $f4, $f4, $f16 # f4=x[i][j] + y[i][k]*z[k][j]
addiu $s2, $s2, 1 # $k k + 1
bne $s2, $t1, L3 # if (k != 32) go to L3
s.d $f4, 0($t2) # x[i][j] = $f4
addiu $s1, $s1, 1 # $j = j + 1
bne $s1, $t1, L2 # if (j != 32) go to L2
addiu $s0, $s0, 1 # $i = i + 1
bne $s0, $t1, L1 # if (i != 32) go to L1
SlidesAulasAOC/DDCA_Ch6.pdf
Chapter 6 <1> 
Digital Design and Computer Architecture, 2nd Edition
Chapter 6
David Money Harris and Sarah L. Harris
Chapter 6 <2> 
Chapter 6 :: Topics
• Introduction
• Assembly Language
• Machine Language
• Programming
• Addressing Modes
• Lights, Camera, Action: Compiling, 
Assembling, & Loading
• Odds and Ends
Chapter 6 <3> 
• Jumping up a few levels 
of abstraction
• Architecture:
programmer’s view of 
computer
– Defined by instructions & 
operand locations
• Microarchitecture: how 
to implement an 
architecture in hardware 
(covered in Chapter 7)
Physics
Devices
Analog
Circuits
Digital
Circuits
Logic
Micro-
architecture
Architecture
Operating
Systems
Application
Software
electrons
transistors
diodes
amplifiers
filters
AND gates
NOT gates
adders
memories
datapaths
controllers
instructions
registers
device drivers
programs
Introduction
Chapter 6 <4> 
• Instructions: commands in a computer’s 
language
– Assembly language: human-readable format of 
instructions
– Machine language: computer-readable format 
(1’s and 0’s)
• MIPS architecture:
– Developed by John Hennessy and his colleagues at 
Stanford and in the 1980’s.
– Used in many commercial systems, including 
Silicon Graphics, Nintendo, and Cisco
Once you’ve learned one architecture, it’s easy to learn others
Assembly Language
Chapter 6 <5> 
• President of Stanford University
• Professor of Electrical Engineering 
and Computer Science at Stanford 
since 1977
• Coinvented the Reduced 
Instruction Set Computer (RISC) 
with David Patterson
• Developed the MIPS architecture at 
Stanford in 1984 and cofounded 
MIPS Computer Systems 
• As of 2004, over 300 million MIPS 
microprocessors have been sold
John Hennessy
Chapter 6 <6> 
Underlying design principles, as articulated by 
Hennessy and Patterson:
1.Simplicity favors regularity
2.Make the common case fast
3.Smaller is faster
4.Good design demands good compromises
Architecture Design Principles
Chapter 6 <7> 
• add: mnemonic indicates operation to perform
• b, c: source operands (on which the operation is 
performed)
• a: destination operand (to which the result is written)
C Code
a = b + c;
MIPS assembly code
add a, b, c
Instructions: Addition
Chapter 6 <8> 
• Similar to addition - only mnemonic changes
• sub: mnemonic
• b, c: source operands
• a: destination operand
C Code
a = b - c;
MIPS assembly code
sub a, b, c
Instructions: Subtraction
Chapter 6 <9> 
Simplicity favors regularity
• Consistent instruction format
• Same number of operands (two sources and 
one
destination)
• Easier to encode and handle in hardware
Design Principle 1
Chapter 6 <10> 
• More complex code is handled by multiple 
MIPS instructions.
C Code
a = b + c - d;
MIPS assembly code
add t, b, c # t = b + c
sub a, t, d # a = t - d
Multiple Instructions
Chapter 6 <11> 
Make the common case fast
• MIPS includes only simple, commonly used instructions
• Hardware to decode and execute instructions can be 
simple, small, and fast
• More complex instructions (that are less common) 
performed using multiple simple instructions
• MIPS is a reduced instruction set computer (RISC), with 
a small number of simple instructions
• Other architectures, such as Intel’s x86, are complex 
instruction set computers (CISC)
Design Principle 2
Chapter 6 <12> 
• Operand location: physical location in 
computer
– Registers
– Memory
– Constants (also called immediates)
Operands
Chapter 6 <13> 
• MIPS has 32 32-bit registers
• Registers are faster than memory
• MIPS called “32-bit architecture” because 
it operates on 32-bit data
Operands: Registers
Chapter 6 <14> 
Smaller is Faster
• MIPS includes only a small number of 
registers
Design Principle 3
Chapter 6 <15> 
• Registers:
– $ before name 
– Example: $0, “register zero”, “dollar zero”
• Registers used for specific purposes: 
• $0 always holds the constant value 0.
• the saved registers, $s0-$s7, used to hold 
variables
• the temporary registers, $t0 - $t9, used to 
hold intermediate values during a larger 
computation
• Discuss others later
Operands: Registers
Chapter 6 <16> 
Name Register Number Usage
$0 0 the constant value 0
$at 1 assembler temporary
$v0-$v1 2-3 Function return values
$a0-$a3 4-7 Function arguments
$t0-$t7 8-15 temporaries
$s0-$s7 16-23 saved variables
$t8-$t9 24-25 more temporaries
$k0-$k1 26-27 OS temporaries
$gp 28 global pointer
$sp 29 stack pointer
$fp 30 frame pointer
$ra 31 Function return address
MIPS Register Set
Chapter 6 <17> 
• Revisit add instruction
C Code
a = b + c
MIPS assembly code
# $s0 = a, $s1 = b, $s2 = c
add $s0, $s1, $s2
Instructions with Registers
Chapter 6 <18> 
• Too much data to fit in only 32 registers
• Store more data in memory
• Memory is large, but slow
• Commonly used variables kept in registers
Operands: Memory
Chapter 6 <19> 
Data
00000003 4 0 F 3 0 7 8 8
0 1 E E 2 8 4 2
F 2 F 1 A C 0 7
A B C D E F 7 8
00000002
00000001
00000000
Word Address
Word 3
Word 2
Word 1
Word 0
• Each 32-bit data word has a unique 
address
Word-Addressable Memory
Note: MIPS uses byte-addressable memory, which we’ll talk about next.
Chapter 6 <20> 
• Memory read called load
• Mnemonic: load word (lw)
• Format:
lw $s0, 5($t1)
• Address calculation:
– add base address ($t1) to the offset (5)
– address = ($t1 + 5)
• Result:
– $s0 holds the value at address ($t1 + 5)
Any register may be used as base address
Reading Word-Addressable Memory
Chapter 6 <21> 
Data
00000003 4 0 F 3 0 7 8 8
0 1 E E 2 8 4 2
F 2 F 1 A C 0 7
A B C D E F 7 8
00000002
00000001
00000000
Word Address
Word 3
Word 2
Word 1
Word 0
• Example: read a word of data at memory 
address 1 into $s3
– address = ($0 + 1) = 1
– $s3 = 0xF2F1AC07 after load
Assembly code
lw $s3, 1($0) # read memory word 1 into $s3
Reading Word-Addressable Memory
Chapter 6 <22> 
• Memory write are called store
• Mnemonic: store word (sw)
Writing Word-Addressable Memory
Chapter 6 <23> 
Data
00000003 4 0 F 3 0 7 8 8
0 1 E E 2 8 4 2
F 2 F 1 A C 0 7
A B C D E F 7 8
00000002
00000001
00000000
Word Address
Word 3
Word 2
Word 1
Word 0
• Example: Write (store) the value in $t4
into memory address 7 
– add the base address ($0) to the offset (0x7) 
– address: ($0 + 0x7) = 7
Offset can be written in decimal (default) or hexadecimal
Assembly code
sw $t4, 0x7($0) # write the value in $t4 
# to memory word 7
Writing Word-Addressable Memory
Chapter 6 <24> 
Word Address Data
0000000C
00000008
00000004
00000000
width = 4 bytes
4 0 F 3 0 7 8 8
0 1 E E 2 8 4 2
F 2 F 1 A C 0 7
A B C D E F 7 8
Word 3
Word 2
Word 1
Word 0
• Each data byte has unique address
• Load/store words or single bytes: load byte (lb) and 
store byte (sb) 
• 32-bit word = 4 bytes, so word address increments by 4
Byte-Addressable Memory
Chapter 6 <25> 
• The address of a memory word must now 
be multiplied by 4. For example,
– the address of memory word 2 is 2 × 4 = 8
– the address of memory word 10 is 10 × 4 = 40 
(0x28)
• MIPS is byte-addressed, not word-
addressed
Reading Byte-Addressable Memory
Chapter 6 <26> 
Word Address Data
0000000C
00000008
00000004
00000000
width = 4 bytes
4 0 F 3 0 7 8 8
0 1 E E 2 8 4 2
F 2 F 1 A C 0 7
A B C D E F 7 8
Word 3
Word 2
Word 1
Word 0
• Example: Load a word of data at memory 
address 4 into $s3.
• $s3 holds the value 0xF2F1AC07 after 
load
MIPS assembly code
lw $s3, 4($0) # read word at address 4 into $s3
Reading Byte-Addressable Memory
Chapter 6 <27> 
Word Address Data
0000000C
00000008
00000004
00000000
width = 4 bytes
4 0 F 3 0 7 8 8
0 1 E E 2 8 4 2
F 2 F 1 A C 0 7
A B C D E F 7 8
Word 3
Word 2
Word 1
Word 0
• Example: stores the value held in $t7
into memory address 0x2C (44)
MIPS assembly code
sw $t7, 44($0) # write $t7 into address 44
Writing Byte-Addressable Memory
Chapter 6 <28> 
0 1 2 3
MSB LSB
4 5 6 7
8 9 A B
C D E F
Byte
Address
3 2 1 00
7 6 5 44
B A 9 88
F E D CC
Byte
Address
Word
Address
Big-Endian Little-Endian
MSB LSB
• How to number bytes within a word?
• Little-endian: byte numbers start at the little (least 
significant) end
• Big-endian: byte numbers start at the big (most 
significant) end
• Word address is the same for big- or little-endian
Big-Endian & Little-Endian Memory
Chapter 6 <29> 
0 1 2 3
MSB LSB
4 5 6 7
8 9 A B
C D E F
Byte
Address
3 2 1 00
7 6 5 44
B A 9 88
F E D CC
Byte
Address
Word
Address
Big-Endian Little-Endian
MSB LSB
• Jonathan Swift’s Gulliver’s Travels: the Little-Endians
broke their eggs on the little end of the egg and the Big-
Endians broke their eggs on the big end
• It doesn’t really matter which addressing type used –
except when the two systems need to share data!
Big-Endian & Little-Endian Memory
Notice that "big end" 
refers to position within 
the word, not the value 
of the byte.
Chapter 6 <30> 
• Suppose $t0 initially contains 0x23456789
• After following code runs on big-endian system, what 
value is $s0? 
• In a little-endian system?
sw $t0, 0($0)
lb $s0, 1($0)
Big-Endian & Little-Endian Example
Chapter 6 <31> 
• Suppose $t0 initially contains 0x23456789
• After following code runs on big-endian system, what 
value is $s0? 
• In a little-endian system?
sw $t0, 0($0)
lb $s0, 1($0)
• Big-endian: 0x00000045
• Little-endian: 0x00000067
Big-Endian & Little-Endian Example
23 45 67 89
0 1 2 3
23 45 67 890
3 2 1 0
Word
Address
Big-Endian Little-Endian
Byte Address
Data Value
Byte Address
Data Value
MSB LSB MSB LSB
Chapter 6 <32> 
Good design demands good compromises
• Multiple instruction formats allow flexibility
- add, sub: use 3 register operands
- lw, sw: use 2 register operands and a constant
• Number of instruction formats kept small
- to adhere to design principles 1 and 3 
(simplicity favors regularity and smaller is 
faster).
Design Principle 4
Chapter 6 <33> 
• lw and sw use constants or immediates
• immediately available from instruction
• 16-bit two’s complement number
• addi: add immediate
• Subtract immediate (subi) necessary?
C Code
a = a + 4;
b = a – 12;
MIPS assembly code
# $s0 = a, $s1 = b
addi $s0, $s0, 4
addi $s1, $s0, -12
Operands: Constants/Immediates
Chapter 6 <34> 
• Binary representation of instructions
• Computers only understand 1’s and 0’s
• 32-bit instructions 
– Simplicity favors regularity: 32-bit data & 
instructions
• 3 instruction formats:
– R-Type: register operands
– I-Type: immediate operand
– J-Type: for jumping (discuss later)
Machine Language
Chapter 6 <35> 
op rs rt rd shamt funct
6 bits 5 bits 5 bits 5 bits 5 bits 6 bits
R-Type
• Register-type
• 3 register operands:
– rs, rt: source registers
– rd: destination register
• Other fields:
– op: the operation code or opcode (0 for R-type instructions)
– funct: the function
with opcode, tells computer what operation to perform
– shamt: the shift amount for shift instructions, otherwise it’s 0
R-Type
Chapter 6 <36> 
add $s0, $s1, $s2
sub $t0, $t3, $t5
Assembly Code
 0 17 18 16 0 32
Field Values
 0 11 13 8 0 34
op rs rt rd shamt funct
6 bits 5 bits 5 bits 5 bits 5 bits 6 bits
000000 10001 10010 10000 00000 100000
op rs rt rd shamt funct
000000 01011 01101 01000 00000 100010
Machine Code
6 bits 5 bits 5 bits 5 bits 5 bits 6 bits
(0x02328020)
(0x016D4022)
Note the order of registers in the assembly code: 
add rd, rs, rt
R-Type Examples
Chapter 6 <37> 
op rs rt imm
6 bits 5 bits 5 bits 16 bits
I-Type
• Immediate-type
• 3 operands:
– rs, rt: register operands
– imm: 16-bit two’s complement immediate
• Other fields:
– op: the opcode
– Simplicity favors regularity: all instructions have opcode
– Operation is completely determined by opcode
I-Type
Chapter 6 <38> 
Assembly Code
 8 17 16 5
Field Values
op rs rt imm
6 bits 5 bits 5 bits 16 bits
addi $s0, $s1, 5
addi $t0, $s3, -12
lw $t2, 32($0)
sw $s1, 4($t1)
 8 19 8 -12
 35 0 10 32
 43 9 17 4
(0x22300005)
(0x2268FFF4)
(0x8C0A0020)
(0xAD310004)
001000 10001 10000 0000 0000 0000 0101
op rs rt imm
Machine Code
6 bits 5 bits 5 bits 16 bits
001000 10011 01000 1111 1111 1111 0100
100011 00000 01010 0000 0000 0010 0000
101011 01001 10001 0000 0000 0000 0100
Note the differing order of 
registers in assembly and 
machine codes:
addi rt, rs, imm
lw rt, imm(rs)
sw rt, imm(rs)
I-Type Examples
Chapter 6 <39> 
op addr
6 bits 26 bits
J-Type
• Jump-type
• 26-bit address operand (addr)
• Used for jump instructions (j)
Machine Language: J-Type
Chapter 6 <40> 
op rs rt rd shamt funct
6 bits 5 bits 5 bits 5 bits 5 bits 6 bits
R-Type
op rs rt imm
6 bits 5 bits 5 bits 16 bits
I-Type
op addr
6 bits 26 bits
J-Type
Review: Instruction Formats
Chapter 6 <41> 
• 32-bit instructions & data stored in memory
• Sequence of instructions: only difference 
between two applications
• To run a new program:
– No rewiring required
– Simply store new program in memory
• Program Execution:
– Processor fetches (reads) instructions from memory 
in sequence 
– Processor performs the specified operation
Power of the Stored Program
Chapter 6 <42> 
addi $t0, $s3, -12
Machine CodeAssembly Code
lw $t2, 32($0)
add $s0, $s1, $s2
sub $t0, $t3, $t5
0x8C0A0020
0x02328020
0x2268FFF4
0x016D4022
Address Instructions
0040000C 0 1 6 D 4 0 2 2
2 2 6 8 F F F 4
0 2 3 2 8 0 2 0
8 C 0 A 0 0 2 0
00400008
00400004
00400000
Stored Program
Main Memory
PC
The Stored Program
Program Counter 
(PC): keeps track of 
current instruction
Chapter 6 <43> 
001000 10001 10111 1111 1111 1111 0001
op rs rt imm
addi $s7, $s1, -15
Machine Code Assembly Code
 8 17 23 -15
Field Values
(0x2237FFF1)
op rs rt imm
2 2 3 7 F F F 1
000000 10111 10011 01000 00000 100010
op rs rt rd shamt funct
sub $t0, $s7, $s3 0 23 19 8 0 34(0x02F34022)
op rs rt rd shamt funct
0 2 F 3 4 0 2 2
• Start with opcode: tells how to parse rest
• If opcode all 0’s
– R-type instruction
– Function bits tell operation 
• Otherwise
– opcode tells operation
Interpreting Machine Code
Chapter 6 <44> 
• High-level languages: 
– e.g., C, Java, Python
– Written at higher level of abstraction
• Common high-level software constructs:
– if/else statements
– for loops
– while loops
– arrays
– function calls
Programming
Chapter 6 <46> 
• and, or, xor, nor
– and: useful for masking bits
• Masking all but the least significant byte of a value: 
0xF234012F AND 0x000000FF = 0x0000002F
– or: useful for combining bit fields
• Combine 0xF2340000 with 0x000012BC: 
0xF2340000 OR 0x000012BC = 0xF23412BC
– nor: useful for inverting bits: 
• A NOR $0 = NOT A
• andi, ori, xori
– 16-bit immediate is zero-extended (not sign-extended)
– nori not needed
Logical Instructions
Chapter 6 <47> 
1111 1111 1111 1111 0000 0000 0000 0000$s1
0100 0110 1010 0001 1111 0000 1011 0111$s2
$s3
$s4
$s5
$s6
Source Registers
ResultAssembly Code
and $s3, $s1, $s2
or $s4, $s1, $s2
xor $s5, $s1, $s2
nor $s6, $s1, $s2
Logical Instructions Example 1
Chapter 6 <48> 
1111 1111 1111 1111 0000 0000 0000 0000$s1
0100 0110 1010 0001 1111 0000 1011 0111$s2
0100 0110 1010 0001 0000 0000 0000 0000$s3
1111 1111 1111 1111 1111 0000 1011 0111$s4
1011 1001 0101 1110 1111 0000 1011 0111$s5
0000 0000 0000 0000 0000 1111 0100 1000$s6
Source Registers
ResultAssembly Code
and $s3, $s1, $s2
or $s4, $s1, $s2
xor $s5, $s1, $s2
nor $s6, $s1, $s2
Logical Instructions Example 1
Chapter 6 <49> 
0000 0000 0000 0000 0000 0000 1111 1111$s1
Assembly Code
0000 0000 0000 0000 1111 1010 0011 0100imm
$s2
$s3
$s4
andi $s2, $s1, 0xFA34
Source Values
Result
ori $s3, $s1, 0xFA34
xori $s4, $s1, 0xFA34
zero-extended
Logical Instructions Example 2
Chapter 6 <50> 
0000 0000 0000 0000 0000 0000 1111 1111$s1
Assembly Code
0000 0000 0000 0000 1111 1010 0011 0100imm
0000 0000 0000 0000 0000 0000 0011 0100$s2
0000 0000 0000 0000 1111 1010 1111 1111$s3
0000 0000 0000 0000 1111 1010 1100 1011$s4
andi $s2, $s1, 0xFA34
Source Values
Result
ori $s3, $s1, 0xFA34
xori $s4, $s1, 0xFA34
zero-extended
Logical Instructions Example 2
Chapter 6 <51> 
• sll: shift left logical
– Example: sll $t0, $t1, 5 # $t0 <= $t1 << 5
• srl: shift right logical
– Example: srl $t0, $t1, 5 # $t0 <= $t1 >> 5
• sra: shift right arithmetic
– Example: sra $t0, $t1, 5 # $t0 <= $t1 >>> 5
Shift Instructions
Chapter 6 <52> 
• sllv: shift left logical variable
– Example: sllv $t0, $t1, $t2 # $t0 <= $t1 << $t2
• srlv: shift right logical variable
– Example: srlv $t0, $t1, $t2 # $t0 <= $t1 >> $t2
• srav: shift right arithmetic variable
– Example: srav $t0, $t1, $t2 # $t0 <= $t1 >>> $t2
Variable Shift Instructions
Chapter 6 <53> 
sll $t0, $s1, 2
srl $s2, $s1, 2
sra $s3, $s1, 2
Assembly Code
 0 0 17 8 2 0
Field Values
op rs rt rd shamt funct
6 bits 5 bits 5 bits 5 bits 5 bits 6 bits
 0 0 17 18 2 2
 0 0 17 19 2 3
000000 00000 10001 01000 00010 000000
op rs rt rd shamt funct
Machine Code
6 bits 5 bits 5 bits 5 bits 5 bits 6 bits
000000 00000 10001 10010 00010 000010
000000 00000 10001 10011 00010 000011
(0x00114080)
(0x00119082)
(0x00119883)
Shift Instructions
Chapter 6 <54> 
• 16-bit constants using addi:
• 32-bit constants using load upper immediate 
(lui) and ori:
C Code
int a = 0xFEDC8765;
MIPS assembly code
# $s0 = a
lui $s0, 0xFEDC
ori $s0, $s0, 0x8765
C Code
// int is a 32-bit signed word
int a = 0x4f3c;
MIPS assembly code
# $s0 = a
addi $s0, $0, 0x4f3c
Generating Constants
Chapter 6 <55> 
Assembly Code
High Level Code
Compiler
Object File
Assembler
Executable
Linker
Memory
Loader
Object Files
Library Files
How to Compile & Run a Program
Chapter 6 <57> 
• Instructions (also called text)
• Data
– Global/static: allocated before program begins
– Dynamic: allocated within program
• How big is memory?
– At most 232 = 4 gigabytes (4 GB)
– From address 0x00000000 to 0xFFFFFFFF
What is Stored in Memory?
Chapter 6 <58> 
SegmentAddress
0xFFFFFFFC
0x80000000
0x7FFFFFFC
0x10010000
0x1000FFFC
0x10000000
0x0FFFFFFC
0x00400000
0x003FFFFC
0x00000000
Reserved
Stack
Heap
Static Data
Text
Reserved
Dynamic Data
MIPS Memory Map
Chapter 6 <59> 
int f, g, y; // global variables
int main(void) 
{
f = 2;
g = 3;
y = sum(f, g);
return y;
}
int sum(int a, int b) {
return (a + b);
}
Example Program: C Code
Chapter 6 <60> 
int f, g, y; // global
int main(void) 
{
f = 2;
g = 3;
y = sum(f, g);
return y;
}
int sum(int a, int b) {
return (a + b);
}
.data
f:
g:
y:
.text
main:
addi $sp, $sp, -4 # stack frame
sw $ra, 0($sp) # store $ra
addi $a0, $0, 2 # $a0 = 2
sw $a0, f # f = 2
addi $a1, $0, 3 # $a1 = 3
sw $a1, g # g = 3
jal sum # call sum
sw $v0, y # y = sum()
lw $ra, 0($sp) # restore $ra
addi $sp, $sp, 4 # restore $sp
jr $ra # return to OS
sum:
add $v0, $a0, $a1 # $v0 = a + b
jr $ra # return
Example Program: MIPS Assembly
Chapter 6 <61> 
Symbol Address
Example Program: Symbol Table
Chapter 6 <62> 
Symbol Address
f 0x10000000
g 0x10000004
y 0x10000008
main 0x00400000
sum 0x0040002C
Example Program: Symbol Table
Chapter 6 <63> 
Executable file header Text Size Data Size
Text segment
Data segment
Address Instruction
Address Data
0x00400000
0x00400004
0x00400008
0x0040000C
0x00400010
0x00400014
0x00400018
0x0040001C
0x00400020
0x00400024
0x00400028
0x0040002C
0x00400030
addi $sp, $sp, -4
sw $ra, 0 ($sp)
addi $a0, $0, 2
sw $a0, 0x8000 ($gp)
addi $a1, $0, 3
sw $a1, 0x8004 ($gp)
jal 0x0040002C
sw $v0, 0x8008 ($gp)
lw $ra, 0 ($sp)
addi $sp, $sp, -4
jr $ra
add $v0, $a0, $a1
jr $ra
0x10000000
0x10000004
0x10000008
f
g
y
0xC (12 bytes)0x34 (52 bytes)
0x23BDFFFC
0xAFBF0000
0x20040002
0xAF848000
0x20050003
0xAF858004
0x0C10000B
0xAF828008
0x8FBF0000
0x23BD0004
0x03E00008
0x00851020
0x03E00008
Example Program: Executable
Chapter 6 <64> 
y
g
f
0x03E00008
0x00851020
0x03E00008
0x23BD0004
0x8FBF0000
0xAF828008
0x0C10000B
0xAF858004
0x20050003
0xAF848000
0x20040002
0xAFBF0000
0x23BDFFFC
MemoryAddress
$sp = 0x7FFFFFFC0x7FFFFFFC
0x10010000
0x00400000
Stack
Heap
$gp = 0x10008000
PC = 0x00400000
0x10000000
Reserved
Reserved
Example Program: In Memory
Chapter 6 <65> 
• Execute instructions out of sequence
• Types of branches:
– Conditional
• branch if equal (beq)
• branch if not equal (bne)
– Unconditional
• jump (j)
• jump register (jr)
• jump and link (jal)
Branching
Chapter 6 <66> 
addi $t0, $s3, -12
Machine CodeAssembly Code
lw $t2, 32($0)
add $s0, $s1, $s2
sub $t0, $t3, $t5
0x8C0A0020
0x02328020
0x2268FFF4
0x016D4022
Address Instructions
0040000C 0 1 6 D 4 0 2 2
2 2 6 8 F F F 4
0 2 3 2 8 0 2 0
8 C 0 A 0 0 2 0
00400008
00400004
00400000
Stored Program
Main Memory
PC
Review: The Stored Program
Chapter 6 <67> 
# MIPS assembly
addi $s0, $0, 4 # $s0 = 0 + 4 = 4
addi $s1, $0, 1 # $s1 = 0 + 1 = 1
sll $s1, $s1, 2 # $s1 = 1 << 2 = 4
beq $s0, $s1, target # branch is taken
addi $s1, $s1, 1 # not executed
sub $s1, $s1, $s0 # not executed
target: # label
add $s1, $s1, $s0 # $s1 = 4 + 4 = 8
Labels indicate instruction location. They can’t be reserved words and 
must be followed by colon (:)
Conditional Branching (beq)
Chapter 6 <68> 
# MIPS assembly
addi $s0, $0, 4 # $s0 = 0 + 4 = 4
addi $s1, $0, 1 # $s1 = 0 + 1 = 1
sll $s1, $s1, 2 # $s1 = 1 << 2 = 4
bne $s0, $s1, target # branch not taken
addi $s1, $s1, 1 # $s1 = 4 + 1 = 5
sub $s1, $s1, $s0 # $s1 = 5 – 4 = 1
target:
add $s1, $s1, $s0 # $s1 = 1 + 4 = 5
The Branch Not Taken (bne)
Chapter 6 <69> 
# MIPS assembly
addi $s0, $0, 4 # $s0 = 4
addi $s1, $0, 1 # $s1 = 1
j target # jump to target
sra $s1, $s1, 2 # not executed
addi $s1, $s1, 1 # not executed
sub $s1, $s1, $s0 # not executed
target:
add $s1, $s1, $s0 # $s1 = 1 + 4 = 5
Unconditional Branching (j)
Chapter 6 <70> 
# MIPS assembly
0x00002000 addi $s0, $0, 0x2010
0x00002004 jr $s0 
0x00002008 addi $s1, $0, 1
0x0000200C sra $s1, $s1, 2
0x00002010 lw $s3, 44($s1)
jr is an R-type instruction.
Unconditional Branching (jr)
Chapter 6 <71> 
• if statements
• if/else statements
• while loops
• for loops
High-Level Code Constructs
Chapter 6 <72> 
C Code
if (i == j)
f = g + h;
f = f – i;
MIPS assembly code
# $s0 = f, $s1 = g, $s2 = h
# $s3 = i, $s4 = j
If Statement
Chapter 6 <73> 
C Code
if (i == j)
f = g + h;
f = f – i;
MIPS assembly code
# $s0 = f, $s1 = g, $s2 = h
# $s3 = i, $s4 = j
bne $s3, $s4, L1
add $s0, $s1, $s2
L1: sub $s0, $s0, $s3
Assembly tests opposite case (i != j) of high-level code (i == j)
If Statement
Chapter 6 <74> 
C Code
if (i == j)
f = g + h;
else
f = f – i;
MIPS assembly code
If/Else Statement
Chapter 6 <75> 
C Code
if (i == j)
f = g + h;
else
f = f – i;
MIPS assembly code
# $s0 = f, $s1 = g, $s2 = h
# $s3 = i, $s4 = j
bne $s3, $s4, L1
add $s0, $s1, $s2
j done
L1: sub $s0, $s0, $s3
done:
If/Else Statement
Chapter 6 <76> 
C Code
// determines the power
// of x such that 2x = 128
int pow = 1;
int x = 0;
while (pow != 128) {
pow = pow * 2;
x = x + 1;
}
MIPS assembly code
Assembly tests for the opposite case (pow == 128) of the C 
code (pow != 128).
While Loops
Chapter 6 <77> 
C Code
// determines the power
// of x such that 2x = 128
int pow = 1;
int x = 0;
while (pow != 128) {
pow = pow * 2;
x = x + 1;
}
MIPS assembly code
# $s0 = pow, $s1 = x
addi $s0, $0, 1
add $s1, $0, $0
addi $t0, $0, 128
while: beq $s0, $t0, done
sll $s0, $s0, 1
addi $s1, $s1, 1
j while
done:
Assembly tests for the opposite case (pow == 128) of the C 
code (pow != 128).
While Loops
Chapter 6 <78> 
for (initialization; condition; loop operation)
statement
• initialization: executes before the loop begins
• condition: is tested at the beginning of each iteration
• loop operation: executes at the end of each iteration
• statement: executes each time the condition is met
For Loops
Chapter 6 <79> 
High-level code
// add the numbers from 0 to 9
int sum = 0;
int i;
for (i=0; i!=10; i = i+1) {
sum = sum + i;
}
MIPS assembly code
# $s0 = i, $s1 = sum
For Loops
Chapter 6 <80> 
C Code
// add the numbers from 0 to 9
int sum = 0;
int i;
for (i=0; i!=10; i = i+1) {
sum = sum + i;
}
MIPS assembly code
For Loops
Chapter 6 <81> 
C Code
// add the numbers from 0 to 9
int sum = 0;
int i;
for (i=0; i!=10; i = i+1) {
sum = sum + i;
}
MIPS assembly code
# $s0 = i, $s1 = sum
addi $s1, $0, 0
add $s0, $0, $0
addi $t0, $0, 10
for: beq $s0, $t0, done
add $s1, $s1, $s0
addi $s0, $s0, 1
j for
done:
For