MIPS. Prof. Carlos Bazilio

Transcrição

1 MIPS Prof. Carlos Bazilio

2 Introduçã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:

3 Introduçã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 M n com linguagem de máquina L n... Nível 2: Máquina Virtual M 2 com linguagem de máquina L 2 Nível 1: Máquina Virtual M 1 com linguagem de máquina L 1 Nível 0: Máquina Virtual M 0 com linguagem de máquina L 0 (circuitos eletrônicos)

4 Operaçõ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

5 Operaçõ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

6 Operaçõ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?

7 Operaçõ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

8 Operandos das Instruçõ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

9 Convençã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

10 Operandos em Memória 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];

11 Operandos em Memória 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

12 Operandos em Memória 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

13 Operandos em Memória 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

14 Operandos em Memória 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: Somamos o valor de h lw $t0, 0($t1) add $t0, $t0, $s2 Finalmente, armazenamos em A[12] sw $t0, 48($t0)

15 Algumas Observações Iniciais 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

16 Algumas Observações Iniciais 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

17 Representação de Instruçõ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): opcode rs rt rd shamt funct 6 bits 5 bits 5 bits 5 bits 5 bits 6 bits

18 Representação de Instruçõ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: opcode rs rt rd shamt funct

19 Representação de Instruções Para as instruções de acesso a memória, 5 bits permitiriam o endereçamento de apenas 32 (2 5 ) células de memória De forma a ampliar esta limitação, o formato das instruções é modificado da seguinte forma: opcode rs rt constante ou endereço 6 bits 5 bits 5 bits 16 bits No MIPS, este formato é chamado de formato do tipo I, enquanto o primeiro é chamado de tipo R

20 Representação de Instruções Exemplificanto a representação do tipo I, a instrução lw $t0, 32($s3) é traduzida para a seguinte sequência de bits: opcode rs rt endereço, onde $s3 (registrador 19) é colocado em rs, $t0 (registrador 8) é colocado em rt e 32 é colocado no campo endereço

21 Representação de Instruçõ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=$s opcode rs rt endereço

22 Resumo das Instru Resumo das Instruções ões endereço n.a. n.a. n.a. reg reg 43 I sw endereço n.a. n.a. n.a. reg reg 35 I lw constante n.a. n.a. n.a. reg reg 8 I addi n.a reg reg reg 0 R sub n.a reg reg reg 0 R add endereço funct shamt rd rt rs op Tipo Instrução

23 Instruções de Operadores Lógicos 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 opcode rs rt rd shamt funct

24 Instruções de Deslocamento 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 opcode rs rt rd shamt funct

25 Resumo de Instruções Lógicas e Deslocamento Instrução Tipo op rs rt rd shamt funct endereço and R 0 reg reg reg 0 36 n.a. or R 0 reg reg reg 0 37 n.a. andi I 12 reg reg n.a. n.a. n.a. c te ori I 13 reg reg n.a. n.a. n.a. c te nor R 0 reg reg n.a. n.a. 39 n.a. sll R 0 n.a. reg reg c te 0 n.a. srl R 0 n.a. reg reg c te 2 n.a.

26 Instruções para Tomada de Decisão beq (branch if equal) e bne (branch if not equal) 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

27 Instruções para Tomada de 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 Podemos ter o seguinte código em MIPS beq $s3, $s4, L1 add $s0, $s1, $s2 L1: sub $s0, $s0, $s3

28 Instruções para Tomada de Decisão Supondo o seguinte código em C if (i == j) else f = g + h; f = g h; // onde, f.. j em $s0.. $s4 Podemos ter o seguinte código em MIPS bne $s3, $s4, Else add $s0, $s1, $s2 j Exit # desvio incondicional Else: sub $s0, $s1, $s2 Exit:

29 Loops while (save[i] == k) i = i + j; save em $s6 // onde i, j, k em $s3..5 e 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:

30 Instruções para Tomada de 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 Less se $t0<>0 (s3<s4)

31 Switch / Case switch(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

32 Procedimentos 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)

33 Procedimentos (... 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)

34 Procedimentos Registradores e Instruçõ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 return address) 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

35 Procedimentos Registradores e Instruçõ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)

36 Procedimentos Exemplo int 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... jal rotina # chamada da função f_exemplo()... 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

37 Convençã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

38 Procedimentos Recursivos Exemplo do fatorial

39 Mais Registradores $fp (frame pointer) $gp (global pointer)

40 Descrição Completa dos Registradores Nome No. Uso Preservado $zero 0 Cte Não $v0-$v1 2-3 Resultado Não $a Argumentos Sim $t Temporários Não $s Salvos Sim $t Temporários Não $gp 28 Global Sim $sp 29 Pilha Sim $fp 30 Frame Sim $ra 31 End. Retorno Sim

41 Caracteres / Strings 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)

42 Strings em 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, 4 sw $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, L1 lw $s0, 0($sp) addi $sp, $sp, 4 jr $ra

43 Estilos de Endereçamento 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

44 Tradução dos Labels while (save[i] == k) i = i + j; save em $s // onde i, j, k em $s3..5 e 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:

45 Traduçã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

46 Tradução de um Programa Um programa em Linguagem de Montagem (Assembly) é composto de instruções e pseudoinstruçõ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

47 Arquivo Objeto Típico T em Sistemas 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)

48 Ligador / Link-Editor O papel do ligador é unir as diferentes partes de um programa de forma a se ter um único arquivo executável

49 Carregador / Loader 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

50 Vetores x Ponteiros

51 Outras Arquiteturas Baseadas em Acumulador A = B + C é traduzido para: load AddressB add AddressC store AddressA Arquiteturas em Pilha A = B + C é traduzido para: push AddressC push AddressB add pop AddressA

52 Outras 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)

53 IA-32 80x86 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

54 IA-32 80x86 Tipos de Instruçõ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)

55 IA-32 80x86 Codificação das Instruçõ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

56 IA-32 80x86 Falácias 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

57 IA-32 80x86 Falácias 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

58 Aritmética tica Computacional Utilização de complemento a 2 Qual é o maior número negativo em 32 bits? Lembre que:

59 Aritmética tica Computacional Em C, temos: int e unsigned int No MIPS, temos: lb e lbu, slt e sltu, slti e sltiu Por exemplo, suponha: $s0 = $s1 = Quanto vale $t0 em: slt $t0, $s0, $s1 sltu $t0, $s0, $s1 1 e 0, respectivamente

60 Regras de Transformação de Valores Regra para a Negação Inversão dos bits e adição de 1, descartando o carry do 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)