MIPSbazilio/cursos/arqcomp/MIPS.pdfOperandos em Mem ória • Operandos de instruções em memória...

MIPSMIPS

Prof. Carlos Bazilio

http://www.ic.uff.br/~bazilio

[email protected]

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


• 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


• 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?


• 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];


• 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


• 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


• 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


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


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



• 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


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



• 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


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


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



• 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



• 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:



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


• (... 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)


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


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)


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)

MIPSbazilio/cursos/arqcomp/MIPS.pdfOperandos em Mem ória • Operandos de instruções em memória...

Documents

Transcript of MIPSbazilio/cursos/arqcomp/MIPS.pdfOperandos em Mem ória • Operandos de instruções em memória...