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

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

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