Arquitetura e Assembly* Processador MIPS Arquitetura e Assembly* Wang Jiang Chau Grupo de Projeto de Sistemas Eletrônicos e Software Aplicado Laboratório de Microeletrônica – LME Depto. Sistemas Eletrônicos- EPUSP * Baseado no livro de Robert Britton

MIPS MIPS Diagrama do Datapath

Programação de um microprocessador Linguagem Estruturada Linguagem Assembly Linguagem de Máquina Para o hardware (memória) Abstração de Software Montagem Compilação

Pseudo-código Linguagem Assembly Montagem Linguagem de Máquina No nosso caso …. Pseudo-código Linguagem Assembly Montagem Linguagem de Máquina

Arquitetura do MIPS Registradores disponíveis para o programador Conjunto de instruções Modos de endereçamento Tipos de dados

Classificação das ISA- 1

Classificação das ISA-2 Sequência de código para C:= A+B Stack Acumulador Registrador (reg - mem) (load store) Push A Load A Load R1, A Load R1, A Push B Add B Add R1, B Load R2, B Add Store C Store C, R1 Add R3, R1, R2 Pop C Store C, R3

A Arquitetura MIPS - 1 Unidade de controle Banco de registradores (de 32 bits cada um) Unidade lógica e aritmética Contador de programa (PC) Memória Registrador de instruções

A Arquitetura MIPS - 2 Incorpora todos os princípios fundamentais de todas as arquiteturas RISC contemporâneas: Memória contém dados e instruções Acesso a memória por instruções load-store Instruções diretamente executadas em hardware Registradores de propósito geral de 32 bits Tipo de Dados: byte, half-word, word e double- word. Barramentos de 32 bits

A Unidade de Controle Comando de: MUXes (Seleção) REGs (Load) ALU (tipo de operação) Memória (Read/Write) Banco de registradores (Load)

O Banco de Registradores Contém 32 REGs de 32 bits cada um Capaz de armazenar dados inteiros (positivos e negativos) entre (-2**31) a (2**31-1) Registradores tem nomes e são usados para finalidades específicas. Ex. Reg[0] armazena o valor 0. Reg[1] serve para implementar macro-intruções e não deve ser usado pelo programador. Etc.

Banco de Registradores Número $zero 1 $at 2 $v0 3 $v1 4 $a0 5 $a1 6 $a2 7 $a3 8 $t0 9 $t1 10 $t2 11 $t3 12 $t4 13 $t5 14 $t6 15 $t7 16 $s0 17 $s1 18 $s2 19 $s3 20 $s4 21 $s5 22 $s6 23 $s7 24 $t8 Valor Nome Valores de retorno de funções Argumentos passados para funções Banco de Registradores Registradores Temporários para funções Registradores para valores que devem ser mantidos através de funções. Etc ...

Banco de registradores MIPS Convenção de Nomenclatura (Ver Tabela 1.1) $0 : Constante- Zero $v0-v1 : Valores de retorno de funções $a0-a3 : Argumentos passados a funções $t0-t9 : Registradores temporários (funções) $s0-s7 : Registradores salvos (programa main) $sp : Stack Pointer $ra : Endereço de retorno (funções)

PC e Memória PC contém o endereço da próxima instrução a ser executada. PC é iniciado pelo OS com o endereço da instrução inicial. Após a busca da instrução, o PC é incrementado (PC+4) ou recebe o valor calculado por alguma operação de desvio. Memória 4Gbytes x 8 (2**32 bits de endereçamento e cada endereço armazena 8 bits)

Registrador de instruções Contém uma cópia da última instrução buscada na memória. Existem 3 formatos de instruções: Register (tipo R) Immediate (tipo I) Jump (tipo J)

Formato de Instruções Formato Registrador – Tipo R Formato Imediato – Tipo I Formato Salto (Jump)- Tipo J Op-Code Rs Rt Rd 00000 Code 6 5 5 5 5 6 Op-Code Rs Rt 16 - Bit Immediate Value 6 5 5 16 Op-Code 26 Bit Current Segment Address 6 26

Conjunto de Instruções MIPS* Aritméticas, Lógicas e Deslocamento Desvio Condicional Load e Store Chamada a Função * Apêndice C do livro-texto contém uma descrição detalhada de cada instrucão

Quick Reference – Apêndice A Integer Instruction Set Name Syntax Space/Time Add: add Rd, Rs, Rt 1/1 Add Immediate: addi Rt, Rs, Imm 1/1 Add Immediate Unsigned: addiu Rt, Rs, Imm 1/1 Add Unsigned: addu Rd, Rs, Rt 1/1 And: and Rd, Rs, Rt 1/1 And Immediate: andi Rt, Rs, Imm 1/1 Branch if Equal: beq Rs, Rt, Label 1/1 Branch if Greater Than or Equal to Zero: bgez Rs, Label 1/1 Branch if Greater Than or Equal to Zero and Link: bgezal Rs, Label 1/1 Branch if Greater Than Zero: bgtz Rs, Label 1/1 Branch if Less Than or Equal to Zero: blez Rs, Label 1/1 Branch if Less Than Zero and Link: bltzal Rs, Label 1/1 Branch if Less Than Zero: bltz Rs, Label 1/1 Branch if Not Equal: bne Rs, Rt, Label 1/1 Divide: div Rs, Rt 1/38 Divide Unsigned: divu Rs, Rt 1/38 Jump: j Label 1/1 Jump and Link: jal Label 1/1 Jump and Link Register: jalr Rd, Rs 1/1 Jump Register: jr Rs 1/1

Integer Instruction Set Name Syntax Space/Time Load Byte: lb Rt, offset(Rs) 1/1 Load Byte Unsigned: lbu Rt, offset(Rs) 1/1 Load Halfword: lh Rt, offset(Rs) 1/1 Load Halfword Unsigned: lhu Rt, offset(Rs) 1/1 Load Upper Immediate: lui Rt, Imm 1/1 Load Word: lw Rt, offset(Rs) 1/1 Load Word Left: lwl Rt, offset(Rs) 1/1 Load Word Right: lwr Rt, offset(Rs) 1/1 Move From Coprocessor 0 mfc0 Rd, Cs 1/1 Move From High: mfhi Rd 1/1 Move From Low: mflo Rd 1/1 Move To Coprocessor 0 mtc0 Rt, Cd 1/1 Move to High: mthi Rs 1/1 Move to Low: mtlo Rs 1/1 Multiply: mult Rs, Rt 1/32 Multiply Unsigned: multu Rs, Rt 1/32 NOR: nor Rd, Rs, Rt 1/1 OR: or Rd, Rs, Rt 1/1 OR Immediate: ori Rt, Rs, Imm 1/1 Return From Exception: rfe 1/1 Store Byte: sb Rt, offset(Rs) 1/1 Store Halfword: sh Rt, offset(Rs) 1/1 Shift Left Logical: sll Rd, Rt, sa 1/1 Shift Left Logical Variable: sllv Rd, Rt, Rs 1/1

Integer Instruction Set Name Syntax Space/Time Set on Less Than: slt Rd, Rt, Rs 1/1 Set on Less Than Immediate: slti Rt, Rs, Imm 1/1 Set on Less Than Immediate Unsigned: sltiu Rt, Rs, Imm 1/1 Set on Less Than Unsigned: sltu Rd, Rt, Rs 1/1 Shift Right Arithmetic: sra Rd, Rt, sa 1/1 Shift Right Arithmetic Variable: srav Rd, Rt, Rs 1/1 Shift Right Logical: srl Rd, Rt, sa 1/1 Shift Right Logical Variable: srlv Rd, Rt, Rs 1/1 Subtract: sub Rd, Rs, Rt 1/1 Subtract Unsigned: subu Rd, Rs, Rt 1/1 Store Word: sw Rt, offset(Rs) 1/1 Store Word Left: swl Rt, offset(Rs) 1/1 Store Right: swr Rt, offset(Rs) 1/1 System Call: syscall 1/1 Exclusive OR: xor Rd, Rs, Rt 1/1 Exclusive OR Immediate: xori Rt, Rs, Imm 1/1

Exemplos de Macro-Instruções (ver apêndice D no livro texto) Load Address la $s0, table Load Immediate li $v0, 10 Move mov $t8, $sp Multiply mul $t2, $a0, $a1 Divide div $s1, $v1, $t7 Remainder rem $s2, $v1, $t7 Negate neg $s0, $s0

Instrução Load Load Word: a instrução acessa o valor da memória e copia o valor encontrado num registrador. Exemplo: lw $s1, 8($a0) O endereço efetivo da memória a ser acessado é o valor da soma entre o conteúdo do registrador $a0 (o endereço base) e o valor constante 8 (o deslocamento). A instrução equivalente em pseudocódigo seria:   $s1 = Mem[$a0 + 8]

Instrução Store Store Word: a instrução acessa o valor do registrador e copia o valor encontrado na memória. Exemplo: sw $s1, 6($a0) O endereço efetivo da memória a ser acessado é o valor da soma entre o conteúdo do registrador $a0 (o endereço base) e o valor constante 6 (o deslocamento). A instrução equivalente em pseudocódigo seria:   Mem[$a0 + 6] = $s1

Um Exemplo Supondo que queremos implementar o equivalente ao comando abaixo em pseudocódigo: $v1 = $a1 + $s1 A programação em Assembly é: add $v1, $a1, $s1  

Instruções de Controle Existem instruções para implementar estruturas de controle, por exemplo, “if ... then ... else ...” Em pseudocódigo: if ($s6 >= 0) then ($s6 = $s6 – 1) else goto Quit As instruções em assembly para realizá-la são: bltz $s6, Quit addi $s6, $s6, -1

Instrução de Multiplicação-1 A instrução “mult” multiplica dois valores binários de 32 bits e produz um produto de 64 bits que é armazenado em dois registradores especiais denominados High e Low. Neste caso, a destinação para o resultado é implicitamente entendido (ex. mult $a1, $s1) O registrador High é carregado com os 32 bits mais significativos do produto; o registrador Low é carregado com os 32 bits menos significativos.

Instrução de Multiplicação-2 Para mover uma cópia dos valores nos registradores High e Low para o banco de registradores, deve-se usar as instruções mfhi e mflo, respectivamente. O trecho de código a seguir mostra como o produto de 64 bits entre $a1 X $s1 pode ser movido para $v0 e $v1: mult $a1, $s1 mfhi $v0 mflo $v1

Instrução de Divisão A instrução de divisão é similar: o quociente é armazenado no registrador Low enquanto o resto é armazenado em High. Exemplo: div $a1, $s1 - divide o conteúdo de $a1 pelo conteúdo de $s1 mflo $v0 - move o quociente para $v0 mfhi $v1 - move o resto para $v1   Na arquitetura MIPS, a divisão por zero é indefinida. Cabe ao programador evitar a situação pelo controle do divisor.

Tipos de endereçamento As operações Load/Store só admitem um tipo de endereçamento: Base address plus displacement Ex. lw $s1, 8($a0)

Tipos de endereçamento lw $s1, 8($a0) Significa: Primeiro calcule o endereço da memória somando (conteúdo reg $a0 + 8) Depois transfira o conteúdo deste endereço de memória para o reg $s1 Em termos de pseudo-código: $s1 = Mem($a0+8)

Execução passo-a-passo 1 – Instruction fetch 2 – Operand fetch 3 – Execute (op) 4 – Write back

Diagrama do DataPath Contador de Programa (PC) Program Counter (PC) Cache Memory Memória Registrador de Instruções Instruction Register Out ULA ALU Out Endereço Rs Rs Lógica Control Address Logic de Controle Rt Rt Rd Rd 4 4 Dados In Data In Register File Banco de Registradores

Sequência de Operações IR = Mem[PC] PC = PC + 4 Decodificar Instrução Ler do Banco de Regs. Memória (lw/sw) Desvios (beqz) Address = Rs + Offset R-Type If (Rs == 0 ) then PC = PC + Offset sw Memory[Address] = Rt lw Reg. File[Rt] = Memory[Address] Reg. File[Rd] = Rs operation Rt

Capítulo 2 Desenvolvimento de algoritmos em pseudo-código

Assembly e pseudo-código A fim de se programar o MIPS em linguagem assembly , o programador inicialmente escreve o programa usando um pseudo-código baseado em símbolos mnemônicos. Cada registrador tem um nome (usado no pseudo- código) e um número (de 0 a 31). Não esquecer que alguns registradores são de uso específico. O formato de cada instrução é: [label:] Op-Code [operand], [operand], [operand] [#com]

Exemplo de um código assembly Label Op-Code Dest. S1, S2 move $a0, $0 li $t0, 99 loop: add $a0, $a0, $t0 addi $t0, $t0, -1 bnez $t0, loop li $v0, 1 syscall li $v0, 10 # o que faz o programa?

Exemplo: soma de inteiros de 1 a 99 Label Op-Code Dest. S1, S2 move $a0, $0 # $a0 = 0 li $t0, 99 # $t0 = 99 loop: add $a0, $a0, $t0 # $a0 = $a0 + $t0 addi $t0, $t0, -1 # $t0 = $t0 - 1 bnez $t0, loop # se ($t0 != zero) desvia p/ loop li $v0, 1 # armazena o valor em $v0 syscall li $v0, 10 # termina a execução

Programando em assembly-1 Maximizar o uso de registradores do processador. Usar pseudocódigo para documentar o programa em assembly Descrever no pseudocódigo os nomes dos registradores que serão utilizados no código em assembly. Montar tabela de referência cruzada entre os nomes dos registradores do processador e o que está sendo usado no programa em assembly e no pseudocódigo .

Tradução de Expressão Aritmética Dado o pseudo-código: $s0 = srt ( $a0 * $a0 + $a1 * $a1) Admite-se que exista a função srt numa biblioteca O argumento será passado para srt através de $a0 O resultado será colocado em $v0 Assembly: mult $a0, $a0 # quadrado de $a0 mflo $t0 # t0 = LS 32 bits do produto mult $a1, $a1 # quadrado de $a1 mflo $t1 # t1 = LS 32 bits do produto add $a0, $t0, $t1 # a0 = t0 + t1 jal srt # Chama a função raiz quadrada move $s0, $v0 # Por convenção, o resultado de sqr # retorna em $v0

Área de um círculo: pseudo-dódigo: $s0 = π * $t8 * $t8 Area: li $t0, 314156 # Load immediate Pi (scaled up) 100,000 mult $t8, $t8 # Radius squared mflo $t1 # Move lower 32-bits of product in # Low register to $t1 mult $t1, $t0 # Multiply by scaled Pi mflo $s0 # Move lower 32-bits of product in # Low register to $s0 li $t1, 100000 # Load immediate scale factor of 100,000 div $s0, $t1 # Divide by scale factor mflo $s0 # Truncated integer result left in $s0

Tradução de “if … then … else …” if ($t8 < 0) then {$s0 = 0 - $t8; $t1 = $t1 +1} else {$s0 = $t8; $t2 = $t2 + 1} bgez $t8, else # se ($t8 for maior ou igual a) # desviar para posição else sub $s0, $zero, $t8 # $s0 recebe o negativo de $t8 addi $t1, $t1, 1 # incrementar $t1 de 1 b next # desvio do código do else else: move $s0, $t8 # $s0 obtém uma cópia de $t8 addi $t2, $t2, 1 # incrementar $t2 de 1 next:

Tradução de “while” while ($a1 < $a2) do { $a1 = $a1 + 1 $a2 = $a2 - 1} while: bgeu $a1, $a2, done # se ($a1 >= $a2) desviar a done addi $a1, $a1, 1 # $a1 = $a1 + 1 addi $a2, $a2, -1 # $a2 = $a2 - 1 b while # desviar a while done:

Tradução de laço “for” $a0 = 0; for ( $t0 =10; $t0 > 0; $t0 = $t0 -1) do {$a0 = $a0 + $t0} li $a0, 0 # $a0 = 0 li $t0, 10 # Inicia contador do laço em 10 loop: add $a0, $a0, $t0 addi $t0, $t0, -1 # Decrementar contador do laço bgtz $t0, loop # Se ($t0 > 0) Desviar para laço

Tradução de “switch” s0 = 32; top: cout << “Input a value from 1 to 3” cin >> $v0 switch ($v0) { case(1):{$s0 = $s0 << 1; break;} case(2):{$s0 = $s0 << 2; break;} case(3):{$s0 = $s0 << 3; break;} default: goto top; } cout << $s0

.data .align 2 jumptable: .word top, case1, case2, case3 prompt: .asciiz “\n\n Input a value from 1 to 3: ” .text top: li $v0, 4 # Imprimir string la $a0, prompt syscall li $v0, 5 # Ler um inteiro blez $v0, top # Inicia se inteiro positivo li $t3, 3 bgt $v0, $t3, top # Volta se inteiro for > 3

la $a1, jumptable # Carrega endereço de jumptable sll $t0, $v0, 2 # Computar o offset em byte (x 4) add $t1, $a1, $t0 # Ponteiro para o jumptable lw $t2, 0($t1) # Load um endereço do jumptable jr $t2 # Salto para o caso especifico case1: sll $s0, $s0, 1 # Shift de 1 bit b outpt case2: sll $s0, $s0, 2 # Shift de 2 bits case3: sll $s0, $s0, 3 # Shift de 3 bits outpt: li $v0, 1 # Code to print an integer is 1 move $a0, $s0 # Argument ao sistema por $a0 syscall # Resultado na saída

Diretivas para o Montador Alocação de Espaço em Memória :   Exemplo em C: int ARRAY[1024] ; Na linguagem assembly MIPS, a construção correspondente é: .data ARRAY: .space 4096

Para iniciar os valores no memory array antes da execução: Em C: Int Pof2[16] ={ 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768 }   Na linguagem assembly MIPS: .data Pof2: .word 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768 Para acessar o valor 4:   la $a0, Pof2 # a0 = &Pof2 lw $s0, 8($a0) # s0 = MEM[a0 + 8]

Input/Output System Calls Ver Apêndice A $v0 Serviço Call Code Argumentos Resultados Print_integer 1 $a0 = integer Print_ string 4 $a0 = &string Read_integer 5 $v0= integer Read_string 8 $a0 = &buffer $a1 = Length of buffer Exit 10