4/11/18

B E M - V I N D O

Sistemas
Microprocessados
2018
Marcelo Pias
mpias@furg.br

Complemento-2 (Inteiros com Sinal) Complemento-2 (Inteiros com Sinal)

Dado um número de n-bit Bit 32 é o bit de sinal
1: números negativos
0: números positivos
!  Intervalo: –2n – 1 to +2n – 1 – 1
!  Exemplo Números específicos
!  1111 1111 … 1111 11002 0: 0000 0000 … 0000
= –1×231 + 1×230 + … + 1×22 +0×21 +0×20 –1: 1111 1111 … 1111
= –2,147,483,648 + 2,147,483,644 = –410
Mais negativo: 1000 0000 … 0000
Mais positivo: 0111 1111 … 1111
!  U?lizando 64 bits: −9,223,372,036,854,775,808
to 9,223,372,036,854,775,807

Shortcut-1 (Negação de sinal) Shortcut-2 (Extensão de Sinal)

Como transformar número +2 em -2? Ou como “negar” +2?
Complementa & adiciona 1
Complementar significa 1 → 0, 0 → 1
!  Exemplo: negar +2
!  +2 = 0000 0000 … 0010dois
!  –2 = 1111 1111 … 1101dois + 1
= 1111 1111 … 1110dois
Representar um número usando mais bits
Preservar o valor numérico
Replicar o bit de sinal à esqueda
c.f. números sem sinal: extender com 0s
Exemplos: 8-bit p/ 16-bit
+2: 0000 0010 => 0000 0000 0000 0010
–2: 1111 1110 => 1111 1111 1111 1110
RISC-V (conjunto de instruções)
lb: carrega byte com extensão de sinal

1
 4/11/18

Representando Instruções RISC-V R-formato (Instruções)

Instruções são codificadas em binário funct7 rs2 rs1 funct3 rd opcode

Chamado código de máquina
7 bits 5 bits 5 bits 3 bits 5 bits 7 bits

Campos da Instrução
Instruções RISC-V opcode: código operação
Codificado como palavras instruçoes de 32-bit rd: registrador destino (número)
Número pequeno de formatos para representar funct3: 3-bit código funcionalidade (opcode adicional)
código da operação (opcode), número de rs1: primeiro registrador de origem (número)
registradores, rs2: segundo registrador de origem (número)
funct7: 7-bit código funcionalidade (opcode adicional)

R-formato (Exemplo) RISC-V I-formato (Instrução)

funct7 rs2 rs1 funct3 rd opcode immediate rs1 funct3 rd opcode

7 bits 5 bits 5 bits 3 bits 5 bits 7 bits 12 bits 5 bits 3 bits 5 bits 7 bits

add x9,x20,x21 Imediato (constante): instruções aritmética e load

rs1: origem ou número registrado endereço base
immediate: operando constante, ou offset adicionado a end.
0 21 20 0 9 51 base
complemento-2, sinal extendido
000000 1010 1010 000 0100 011001
0 1 0 1 1
0000 0001 0101 1010 0000 0100 1011 0011dois =
015A04B3hex

RISC-V S-formato (Instruções) Lab-Exercício-1 (ref 2.1)

Para o código C abaixo, escreva o código assembly RISC-V.

imm[11:5] rs2 rs1 funct3 imm[4:0] opcode Considere que as variáveis f, g e h foram colocadas nos
7 bits 5 bits 5 bits 3 bits 5 bits 7 bits registradores x5, x6 e x7, respectivamente.

Formato diferente p/ instruções store

rs1: endereço base (número registrador)
rs2: operando origem (número registrador) f = g + (h – 5);
immediate: offset/deslocamento adicionado à end. base
Dividido em 2 pedaços para que rs1 e rs2 fiquem sempre na
mesma posição

2
 4/11/18

Lab-Exercício-2 (ref. 2.2) Lab-Exercício-3 (ref. 2.8)

Escreva a única linha de código C que corresponde às duas Traduza o código RISC-V abaixo para C. Considere que as variáveis
instruções abaixo: f, g, h, i e j são linkados aos registradores x5, x6, x7, x28 e x29,
respectivamente. Considere que o endereço base dos arrayx A e B
estão nos registradores x10 e x11, respectivamente.
add f, g, h
add f, i, f
addi x30, x10, 8
addi x31, x10, 0
sd x31, 0(x30)
ld x30, 0(x30)
add x5, x30, x31

Lab-Exercicio-4 (ref. 2.10)

Considere que registradores X5 e X6 tem os valores

0x8000000000000000 e 0XD000000000000000,
respectivamente:
a) Qual o valor em x30 para o código abaixo
Aula 5 – RISC-V
add x30, x5, x6
Funções
b) Para os conteúdos de registradores x5 e x6 como especificada
acima. Qual o valor x30 para o código abaixo: 04/04/2018 & 11/04/2018

sub x30, x5, x6

Roadmap Roadmap

RISC-V ISA & C-RISC-V (Resumo) RISC-V ISA & C-RISC-V (Resumo)
Execução de Programa Execução de Programa
Chamada de Função Chamada de Função
Chamada de Função: Exemplo Chamada de Função: Exemplo
Mensagem Final … Mensagem Final …

4/11/18 4/11/18

3
 4/11/18

Níveis de Representação/Interpretação Resumo da aula anterior …

temp = v[k];
Programa – v[k] = v[k+1];
Linguagem Alto Nível v[k+1] = temp; Palavras ( “words”) & “vocabulário” são chamados de instructions &
(e.x, C)
Compilado # x12 <-> v[k]; x10 <-> temp;
conjunto de instruções, respectivamente
r
lw x10, 0(x12) # Reg x10 recebe v[k]
Tudo pode ser representado
Programa Linguagem lw
sw
x11, 4(x12)
x11, 0(x12)
# Reg x11 recebe v[k+1]
# v[k] recebe v[k+1] com número RISC-V é um exemplo de conjunto de instruções RISC
Assembly (e.x., RISC-V) sw x10, 4(x12) # v[k+1] recebe v[k]
i.e., data ou instruções
Assembler (Montador)
Programa Linguagem
0000
1010
1001
1111
1100
0101
0110
1000
1010
0000
1111
1001
0101
1100
1000
0110
Formato fixo: uma operação, dois operandos origem, um destino
Máquina (RISC-V) 1100 0110 1010 1111 0101 1000 0000 1001 add,sub,mul,div,and,or,sll,srl,sra
0101 1000 0000 1001 1100 0110 1010 1111
lw,sw,lb,sb p/ mover dado de/para registradores de/para memória
Máquina beq, bne, j p/ decisão/controle de fluxo
Interpretação

Descrição Arquitetura Hardware

(e.x., diagrama de blocos) Mapeamento simplificado de expressões aritméticas, acesso a
arrays, em C para RISC-V instruções
Implementação
Arquitetura

Descrição Circuito Lógico

(Diagramas Esquemá?cos
4/11/18
Circuitos)

Recapitular: Registradores moram dentro do Processador Exemplo cláusula if-else

Processador Memória
Habilita? Considerando as traduções abaixo
Read/Write Entrada
Controle f → x10 g → x11 h → x12
i → x13 j → x14
Caminho Dados
Programa if (i == j) bne x13,x14,Else
Endereço f = g + h; add x10,x11,x12
PC
Escrita
else j Exit
Dado f = g – h; Else: sub x10,x11,x12
Exit:
Dado
Leitur Saída
a
Dado

Processador-Memória: interface E/S-Memória Interfaces

4/11/18

Comparação de Magnitudes no RISC-V C Loop Mapeado no RISC-V Assembly

Testamos apenas igualdades (== , != in C);

Programas de uso genérico precisam testar < , >. int A[20]; addi x9, x8, 0 #
RISC-V desvios c/ comparação:
x9=&A[0]
int sum = 0;
“Desvie se Menor Que” addi x10, x0, 0 # sum=0
Syntaxe: blt reg1,reg2,rótulo for (int i=0; i<20; i++)
addi x11, x0, 0 # i=0
Significado: if (reg1 < reg2) // considere regs como inteiros c/ sinal. Vá p/ rótulo; sum += A[i];
Loop:
lw x12, 0(x9) #
“Desvie se Menor que (sem sinal)” x12=A[i]
Syntaxe: bltu reg1,reg2, rótulo add x10,x10,x12 # sum+=
Significado: if (reg1 < reg2) // considere regs como inteiros sem sinal. Vá
p/ rótulo; addi x9,x9,4 # &A[i+
+]
addi x11,x11,1 # i++
addi x13,x0,20 # x13=20
4/11/18 blt x11,x13,Loop

4
 4/11/18

Resolver com colega ao lado Resolver com colega ao lado

4/11/18

Roadmap
Assembler (montador) p/ Código de Máquina
RISC-V ISA & C-RISC-V (Resumo)
cachorros.S gatos.S arquivo fonte (Assembler/Montador))
Execução de Programa
Chamada de Função Assembler/Montador converte
Chamada de Função: Exemplo Assembler código em assembly para padrões
Assembler
Mensagem Final … (Montador) de bits de instruções
(Montador)

cachorros.o gatos.o Arquivos com código de máquina

Linker pets-lib.o Arquivo de biblioteca

(linkador) pré-criada

a.out Arquivo executável (código máquina)

4/11/18

Como um programa é armazenado Execução Programa

Memória
Processador Lê Bits de
Instrução
Memória Controle

Programa
Caminho de dados
PC
Programa Endereço
Instrução

Uma instrução RISC-V = 32 bits Dados

Dados

•  PC (program counter, contador de instrução, contador de programa) é um registro interno

ao processador que armazena o endereço da próxima instrução a ser executada
•  Instrução é buscada da memória, então a unidade de controle executa a instrução usando o
caminho de dados e o sistema de memória, atualiza o contador de programa (PC) (o default
is add +4 bytes ao PC, para mover a próxima instrução na sequência)
4/11/18

5
 4/11/18

Por que computadores rápidos tem relevância Break!

supercomputador ECMWF: European Weather

50 toneladas
~120,000 cores (Intel Broadwell)
10 PetaBytes de armazenamento
Roda Linux em cada nodo

CS 61c 31 4/11/18 32

RISC-V Nomes Simbólicos p/ Registradores

RISC-V: Ajuda do Assembler
Registradores: nomes simbólicos
Números
E.x., a0-a7 p/ registradores de argumentos (x10-x17) hardware
E.x., zero p/ registrador x0 entende

Pseudo-instrução
Sintaxe simplificada para alguns casos especiais
E.x., mv rd, rs = addi rd, rs, 0
E.x.2, li rd, 13 = addi rd, x0, 13

Nomes amigáveis e
simbólicos em
código assembly

34