mipsbazilio/cursos/arqcomp/mips.pdfoperandos em mem ória • operandos de instruções em memória...
TRANSCRIPT
IntroduIntroduççãoão
• Plataforma projetada da parceria entre NEC, Nintendo, Silicon Graphics e Sony
• Possui um conjunto de instruções que e utilizado em muitos produtos destes fabricantes
• Possui um simulador que permite a experimentação durante o curso: http://pages.cs.wisc.edu/~larus/spim.html
IntroduIntroduççãoão
• Visualizando um computador como uma máquina de vários níveis, o MIPS se localiza no nível 1
Nível n: Máquina Virtual Mn com linguagem de máquina Ln ...
Nível 2: Máquina Virtual M2 com linguagem de máquina L2
Nível 1: Máquina Virtual M1 com linguagem de máquina L1
Nível 0: Máquina Virtual M0 com linguagem de máquina L0 (circuitos eletrônicos)
OperaOperaçções no Hardwareões no Hardware
• As instruções utilizadas para se programar um hardware são comumente chamadas de conjuntos de instruções
• Operações aritméticas são suportadas por todos os computadores
• Em MIPS,
add a, b, c
instrui o computador a somar b e c e armazenar em a o resultado
OperaOperaçções no Hardwareões no Hardware
• Entretanto, o conjunto de instruções do MIPS érígido, só permitindo, para as instruções de adição, 3 argumentos
• Ou seja, para realizarmos a soma
a = b + c + d + e
• Temos que quebrar a atribuição em várias somas:
add a, b, c
add a, a, d
add a, a, e
OperaOperaçções no Hardwareões no Hardware
• Esta característica rígida de 3 operandos para estas operações aritméticas favorece a simplicidade do projeto do hardware
• Suponha agora a seguinte atribuição em linguagem de alto nível
f = (g + h) – (i + j);
• A instrução de subtração no MIPS é sub e possui o mesmo número de operados da instrução add
• Como traduzimos para a linguagem do MIPS?
OperaOperaçções no Hardwareões no Hardware
• Iniciamos a tradução da instrução f = (g + h) – (i + j); como as anteriores
add f, g, h
• Entretanto, a soma de i e j não pode ser atribuída a f, nem a i ou j
• Como isso, vemos a necessidade de utilizarmos temporárias
add t0, i, j
sub f, f, t0
OperandosOperandos das Instrudas Instruççõesões
• Diferentemente das linguagens de alto nível, as linguagens de montagem possuem restrições quanto ao tamanho de suas instruções
• No MIPS, os operandos das operações aritméticas são os registradores
• Nesta arquitetura estão disponíveis 32 registradores, cada qual com 32 bits de tamanho
• Esta limitação possibilita eficiência no uso dos recursos
ConvenConvençção no MIPSão no MIPS
• No MIPS, os identificadores dos registradores são precedidos por um $s para variáveis de um programa e $t para temporárias
• Dessa forma, o resultado da última tradução ficaria, supondo f, g, h, i, j em $s0, $s1, $s2, $s3, $s4:
add $s0, $s1, $s2
add $t0, $s3, $s4
sub $s0, $s0, $t0
OperandosOperandos em Memem Memóóriaria
• Operandos de instruções em memória precisam ser trazidos para a CPU para que possam ser manipulados
• As instruções do MIPS que realizam acesso àmemória são lw (load word) e sw (store word)
• Suponha que A seja um vetor de 100 palavras (palavra – word - possui tamanho de 32 bits)
• Como compilamos a expressão
g = h + A[8];
OperandosOperandos em Memem Memóóriaria
• Suponha que para a expressão g = h + A[8];, g esteja em $s1, h esteja em $s2 e o endereço base de A esteja em $s3
• Relembrando que acessamos elementos diferentes num vetor realizando deslocamentos (offsets) à partir da base, temos:
lw $t0, 8($s3)
add $s1, $s2, $t0
OperandosOperandos em Memem Memóóriaria
• Observe que, para o MIPS, a memória estáorganizada em palavras (sequências de 32 bits)
• Além disso, as instruções lw e sw realizam transferências de 32 bits
• Com isso, o offset fornecido precisa ser multiplicado por 4 para obter o elemento do vetor correto
lw $t0, 32($s3)
add $s1, $s2, $t0
OperandosOperandos em Memem Memóóriaria
• Como compilamos a seguinte instrução para MIPS:
A[12] = h + A[i];
• Suponha que o endereço base de A estáem $s3, h em $s2 e i em $s4
• Inicialmente, temos que multiplicar o índice i por 4 para endereçar palavras
add $t1, $s4, $s4
add $t1, $t1, $t1
OperandosOperandos em Memem Memóóriaria
Compilando A[12]=h+A[i];Compilando A[12]=h+A[i];
• Podemos adicionar a i o endereço base de A
add $t1, $t1, $s3
• Carregamos o valor de A[i] para memória:
lw $t0, 0($t1)
• Somamos o valor de h
add $t0, $t0, $s2
• Finalmente, armazenamos em A[12]
sw $t0, 48($t0)
Algumas ObservaAlgumas Observaçções ões
IniciaisIniciais
• Transferências entre registradores e memória, na verdade, são cópias
• A memória pode ser vista como um vetor unidimensional
• Considerando que é tarefa do compilador alocar área de memória para um programa, fica fácil realizar a associação entre variáveis e registradores
Algumas ObservaAlgumas Observaçções ões
IniciaisIniciais
• Máquinas que endereçam palavras (sequências de 32 bits) podem ser:
– Big endians: consideram o byte mais à direita como endereço da palavra
– Little endians: consideram o byte mais àesquerda como endereço da palavra
RepresentaRepresentaçção de ão de
InstruInstruççõesões
• A convenção entre os registradores e seus valores no MIPS é:
– $s0..$s7 � 16 a 23
– $t0..$t7 � 8 a 15
• Assim, a instrução
add $t0, $s1, $s2
tem a seguinte representação (em decimal):
320818170
funct
6 bits
shamt
5 bits
rd
5 bits
rt
5 bits
rs
5 bits
opcode
6 bits
RepresentaRepresentaçção de ão de
InstruInstruççõesões• Descrição dos campos:
– op (opcode): operação básica da instrução– rs: registrador do primeiro operando de origem– rt: registrador do segundo operando de origem– rd: registrador do operando de destino– shamt (shift ammount): quantidade de deslocamento
(não utilizado na adição)– funct: seleciona a variante da operação básica
definida
• Instrução add $t0, $s1, $s2 em representação binária:
10000000000010001001010001000000
functshamtrdrtrsopcode
RepresentaRepresentaçção de ão de
InstruInstruççõesões
• Para as instruções de acesso a memória, 5 bits permitiriam o endereçamento de apenas 32 (25) células de memória
• De forma a ampliar esta limitação, o formato das instruções é modificado da seguinte forma:
constante ou endereço
16 bits
rt
5 bits
rs
5 bits
opcode
6 bits
• No MIPS, este formato é chamado de formato do tipo I, enquanto o primeiro é chamado de tipo R
RepresentaRepresentaçção de ão de
InstruInstruççõesões• Exemplificanto a representação do tipo I, a
instrução lw $t0, 32($s3) é traduzida para a seguinte sequência de bits:
00000000001000000100010011100011
endereçortrsopcode
, onde $s3 (registrador 19) é colocado em rs, $t0 (registrador 8) é colocado em rt e 32 écolocado no campo endereço
RepresentaRepresentaçção de ão de
InstruInstruççõesões
• Outro exemplo de instrução do tipo I é a adição imediata (addi)
• Esta instrução permite a adição de constantes
• Por exemplo:
addi $s3, $s3, 4 # $s3=$s3+4
00000000000001001001110011001000
endereçortrsopcode
Resumo das InstruResumo das Instruççõesões
endereçon.a.n.a.n.a.regreg43Isw
endereçon.a.n.a.n.a.regreg35Ilw
constanten.a.n.a.n.a.regreg8Iaddi
n.a.340regregreg0Rsub
n.a.320regregreg0Radd
endereçofunctshamtrdrtrsopTipoInstrução
InstruInstruçções de Operadores ões de Operadores
LLóógicosgicos
• O MIPS oferece operações lógicas and (& em C), andi, or (| em C), ori e nor (~ em C)
• As instruções and, or e nor utilizam o formato R, enquanto que andi e ori utilizam o formato I
• Por exemplo:
and $t0, $t1, $t2 #$t0=$t1&$t2
é representado pela seguinte sequência de bits
10010000000010000100101010000000
functshamtrdrtrsopcode
InstruInstruçções de ões de
DeslocamentoDeslocamento
• Também são oferecidas operações de deslocamento: sll (<< - shift à esquerda), srl (>> - shift à direita)
• Por exemplo:
sll $t2, $s0, 4 #$t2=$s0<<4
é representado pela sequência
00000000100010101000000000000000
functshamtrdrtrsopcode
Resumo de InstruResumo de Instruçções ões
LLóógicas e Deslocamentogicas e Deslocamento
n.a.39n.a.n.a.regreg0Rnor
n.a.2cteregregn.a.0Rsrl
n.a.0cteregregn.a.0Rsll
cten.a.n.a.n.a.regreg13Iori
cten.a.n.a.n.a.regreg12Iandi
n.a.370regregreg0Ror
n.a.360regregreg0Rand
endereçofunctshamtrdrtrsopTipoInstrução
InstruInstruçções para Tomada ões para Tomada
de Decisãode Decisão
• beq (branch if equal) e bne (branch if notequal) são instruções de desvio condicional
• O formato geral destas instruções é:
(bne / beq) reg1, reg2, L1
onde reg1 e reg2 são os operandos da instrução e L1 é o endereço para onde a execução desviará caso a condição seja válida
InstruInstruçções para Tomada ões para Tomada
de Decisãode Decisão
• Supondo o seguinte código em C
if (i == j) go to L1;
f = g + h;
L1: f = f – i; // onde, f..j em $s0 .. $s4
beq $s3, $s4, L1
add $s0, $s1, $s2
L1: sub $s0, $s0, $s3
• Podemos ter o seguinte código em MIPS
InstruInstruçções para Tomada ões para Tomada
de Decisãode Decisão
• Supondo o seguinte código em C
if (i == j)
f = g + h;
else
f = g – h; // onde, f .. j em $s0 .. $s4
bne $s3, $s4, Else
add $s0, $s1, $s2
j Exit # desvio incondicional
Else: sub $s0, $s1, $s2
Exit:
• Podemos ter o seguinte código em MIPS
LoopsLoopswhile (save[i] == k)
i = i + j; // onde i, j, k em $s3..5 e save em $s6
Loop: add $t1, $s3, $s3
add $t1, $t1, $t1 # $t1 = 4*i
add $t1, $t1, $s6
lw $t0, 0($t1)
bne $t0, $s5, Exit
add $s3, $s3, $s4
j Loop
Exit:
InstruInstruçções para Tomada ões para Tomada
de Decisãode Decisão
• slt (set on less than): compara 2 operandos e define 1 se o 1º. é menor que o 2º.
• Exemplo:
slt $t0, $s3, $s4 # t0 é 1 se s3<s4
bne $t0, $zero, Less #desvia para Lessse $t0<>0 (s3<s4)
SwitchSwitch / Case/ Caseswitch(k) {
case 0: f = i + j; break;
case 1: f = g + h; break;
case 2: f = g – h; break;
} // f .. k em $s0..5, $t2 = 3, L0..2 iniciando em $t4
ProcedimentosProcedimentos
• Passos a serem tomados na execução de um procedimento:
1. Colocar os argumentos num local onde possam ser acessados pelo procedimento chamado (responsabilidade do chamador)
2. Garantir os recursos de memória necessários para execução do procedimento (chamador)
3. Transferir o controle para o procedimento (chamador)
ProcedimentosProcedimentos
• (... continuação da execução de um procedimento):
4. Realizar a tarefa desejada (chamado)
5. Colocar o resultado em local acessível (chamado)
6. Retornar ao ponto de origem e liberar os recursos (chamador ou chamado)
ProcedimentosProcedimentos
Registradores e InstruRegistradores e Instruççõesões• $a0 - $a3: 4 registradores utilizados como parâmetros
de um procedimento
• $v0 - $v1: 2 registradores utilizados para o retorno de valores por um procedimento
• $ra: registrador que guarda o ponto de desvio na chamada do procedimento (endereço de retorno – returnaddress)
• jal Endereço # desvia a execução para Endereço e salva o endereço da instrução seguinte em $ra
• jr $ra # após a execução do procedimento, retorna para o procedimento chamador
ProcedimentosProcedimentos
Registradores e InstruRegistradores e Instruççõesões
• Procedimentos que requerem mais registradores (parâmetros e retorno) devem utilizar uma pilha para a passagem de valores
• Esta pilha é acessada pelo registrador $sp(stack pointer)
ProcedimentosProcedimentos
ExemploExemploint f_exemplo (int g, int h, int i, int j)
{
int f;
f = (g + h) - (i + j);
return f;
} // onde g .. j em $a0..3, f em $s0
f_exemplo:
sub $sp, $sp, 12
sw $t1, 8 ($sp)
sw $t0, 4 ($sp)
sw $s0, 0 ($sp)
add $t0, $a0, $a1
add $t1, $a2, $a3
sub $s0, $t0, $t1
add $v0, $s0, $zero
lw $s0, 0($sp)
lw $t0, 4($sp)
lw $t1, 8($sp)
add $sp, $sp, 12
jr $ra
...
jal rotina # chamada da função f_exemplo()
...
ConvenConvençção do MIPSão do MIPS
• $t0..9 são registradores temporários que não precisam ser preservados
• $s0..7 são de salvamento que precisam ser preservados
Procedimentos RecursivosProcedimentos Recursivos
• Exemplo do fatorial
Mais RegistradoresMais Registradores
• $fp (frame pointer)
• $gp (global pointer)
DescriDescriçção Completa dos ão Completa dos
RegistradoresRegistradores
SimArgumentos4-7$a0..3
NãoTemporários8-15$t0..7
SimSalvos16-23$s0..7
NãoTemporários24-25$t8..9
SimGlobal28$gp
SimPilha29$sp
SimFrame30$fp
SimEnd. Retorno31$ra
NãoResultado2-3$v0-$v1
NãoCte0$zero
PreservadoUsoNo.Nome
Caracteres / Caracteres / StringsStrings
• http://www.tabelaascii.com
• Cada caracter ocupa 1 byte (8 bits)
• Como o MIPS trabalha com transferências de 4 bytes, precisamos de operações específicas
• lb e sb são operações que lêem e escrevem 1 byte
lb $t0, 0($sp) # lê 1 byte (8 bits + à direita)
sb $t0, 0($gp) # escreve 1 byte (8 bits + à direita)
StringsStrings em Cem C
• Terminam com o caracter \0 (caracter 0 na tabela ASCII)
• Ex.: “cal” é definido por: 67, 97, 108, 0 void strcpy (char x[], char y[]) {
int i = 0;
while ((x[i] = y[i]) != 0)
i++
}
onde x,y em $a0,$a1 e i em $s0
strcpy: subi $sp, $sp, 4sw $s0, 0($sp)add $s0, $zero, $zero
L1: add $t1, $a1, $s0 # y[i]lb $t2, 0($t1)add $t3, $a0, $s0 # x[i]
sb $t2, 0($t3)addi $s0, $s0, 1 # i++
bne $t2, $zero, L1lw $s0, 0($sp)addi $sp, $sp, 4jr $ra
Estilos de EndereEstilos de Endereççamentoamento
• Em Registrador– Operando é um registrador
• Base ou Deslocamento– Operando em memória, cujo endereço é a soma de um
registrador com constante na instrução
• Imediato– Operando é uma constante dentro da instrução
• Relativo ao PC– Soma do PC a uma constante na instrução
• Pseudodireto– Endereço de desvio são os 26 bits da instrução concatenados
com os bits mais altos do PC
TraduTraduçção dos ão dos LabelsLabelswhile (save[i] == k)
i = i + j; // onde i, j, k em $s3..5 e save em $s6
Loop: add $t1, $s3, $s3
add $t1, $t1, $t1
add $t1, $t1, $s6
lw $t0, 0($t1)
bne $t0, $s5, Exit
add $s3, $s3, $s4
j Loop
Exit:
80028
80000280024
320192019080020
8218580016
0993580012
3209229080008
320999080004
32091919080000
TraduTraduçção de um Programaão de um Programa
• Programa C � Compilador �
Programa em Assembly � Montador �
Módulo em Linguagem de Máquina + Bibliotecas � Link-Editor �
Executável em Linguagem de Máquina �Loader �
Memória
TraduTraduçção de um Programaão de um Programa
• Um programa em Linguagem de Montagem (Assembly) é composto de instruções e pseudo-instruções
• A instrução move no MIPS é um exemplo de pseudo-instrução, pois é traduzida numa instrução equivalente:
move $t0, $t1 � add $t0, $zero, $t1
• Outro exemplo de pseudo-instrução é blt(branch on less than) que é traduzida para slt/bne
Arquivo Objeto TArquivo Objeto Tíípico em pico em
Sistemas UnixSistemas Unix• Cabeçalho do Arquivo Objeto: tamanho e posição das
demais partes do arquivo
• Segmento de Texto: código do programa em linguagem de máquina
• Segmento de Dados: dados necessários à execução do programa
• Informações sobre relocação: identificar as palavras que dependem de endereços absolutos
• Tabela de símbolos: labels não definidos, como por exemplo, as referências externas
• Informações para análise de erro (auxílio para o depurador)
LigadorLigador / Link/ Link--EditorEditor
• O papel do ligador é unir as diferentes partes de um programa de forma a se ter um único arquivo executável
Carregador / Carregador / LoaderLoader
• Etapas de um carregador:
– Leitura do cabeçalho para identificar tamanhos
– Alocação de espaço para armazenamento do programa
– Cópia para a memória
– Cópia de parâmetros para a pilha
– Inicialização dos registradores
Vetores x PonteirosVetores x Ponteiros
Outras ArquiteturasOutras Arquiteturas
• Baseadas em Acumulador– A = B + C é traduzido para:
load AddressBadd AddressCstore AddressA
• Arquiteturas em Pilha– A = B + C é traduzido para:
push AddressCpush AddressBaddpop AddressA
Outras ArquiteturasOutras Arquiteturas
• Registradores de Propósito Geral
– Nome define seu significado
– Podem ser do tipo:
• registrador – memória (permitem operando na memória; por ex., acumulador)
• load/store ou reg/reg (só operandos em registradores; por ex., MIPS)
• mem/mem (por ex., add EndA, EndB, EndC)
IAIA--32 32 –– 80x8680x86
• Ao contrário do MIPS, esta plataforma foi desenvolvida ao longo de anos (quase 20) por muitos projetistas
• Esse longo período torna ainda mais difícil a evolução de uma arquitetura, pois épreciso manter uma compatibilidade com versões anteriores (softwares específicos)– Análogo a este problema temos o IE e os
websites voltados especificamente para o seu funcionamento
IAIA--32 32 –– 80x8680x86
Tipos de InstruTipos de Instruççõesões
• Instruções de movimentos de dados
• Instruções aritméticas e lógicas; operações de teste e sobre binários e decimais
• Instruções para controle do fluxo de execução
• Instruções para manipulação de strings(movimento e comparação, herança do 8080)
IAIA--32 32 –– 80x8680x86
CodificaCodificaçção das Instruão das Instruççõesões
• Complexa, com muitos formatos diferentes
• Tamanho varia de 1 a 17 bytes (possibilidade de + de 1 acesso àmemória)
• Usualmente 1 bit indica o tamanho dos operandos (8 ou 32) e a sequência inicial de bits (opcode) indica o formato da instrução
IAIA--32 32 –– 80x8680x86
FalFaláácias e Armadilhascias e Armadilhas
• Instruções mais poderosas significam melhor desempenho
– O IA-32 usa prefixos, os quais podem modificar o comportamento da instrução seguinte (por ex., repetir sua execução atéum contador chegar a 0)
– Realizar a replicação simples desta instrução diminuía significativamente o tempo de execução destas instruções
IAIA--32 32 –– 80x8680x86
FalFaláácias e Armadilhascias e Armadilhas
• Programar diretamente em linguagem de montagem para obter melhor desempenho
– Atualmente os compiladores geram código bastante otimizado
– Incoerência atual em C: uso de variável register pode tornar a execução mais lenta
– Amarração com a plataforma destino
AritmAritméética Computacionaltica Computacional
• Utilização de complemento a 2
• Qual é o maior número negativo em 32 bits?
• Lembre que:
-1111
-2110
-3101
-4100
3011
2010
1001
0000
AritmAritméética Computacionaltica Computacional
• Em C, temos: int e unsigned int
• No MIPS, temos: lb e lbu, slt e sltu, slti e sltiu
• Por exemplo, suponha:
$s0 = 1111 1111 ... 1111
$s1 = 0000 0000 ... 0001
• Quanto vale $t0 em:
slt $t0, $s0, $s1
sltu $t0, $s0, $s1
1 e 0, respectivamente
Regras de TransformaRegras de Transformaçção ão
de Valoresde Valores
• Regra para a Negação
– Inversão dos bits e adição de 1, descartando o carrydo overflow
– As instruções add, addi, sub, ... sinalizam a ocorrência de overflow
– As instruções addu, addiu, subu, ... não sinalizam
• Regra para extensão de sinal
– Como converter o valor -2 em 16 bits para 32 bits?
– Adição de bits de sinal à esquerda (16 bits)