WebDesign Redes de Computadores Aula 05 Linguagem de máquina WebDesign Redes de Computadores Aula 05

Máquinas multiníveis a = b + c Nível de linguagem orientado a problemas Nível 4 Tradução (compilador) add c, b, a Linguagem de montagem (assembly) Nível 3 Tradução (assembler) 0011001001010 Nível de arquitetura de conjunto de instruções Nível 2 Interpretação ou execução direta Nível de microarquitetura Nível 1 Hardware Nível lógico digital Nível 0

Instruções Para comandar o hardware de um computador, precisamos falar a linguagem dele. As palavras da linguagem da máquina são chamadas de instruções. O conjunto de instruções formam um vocabulário. Normalmente representados por um código assembly

Linguagem de máquina Os projetistas de máquina buscam: Um conjunto de instruções que facilite a construção do hardware e do compilador. Maximizar a performance Minimizar o custo Após aprender a linguagem de uma máquina torna-se fácil aprender outras mais. Mesmos princípios Estudaremos as instruções do processador MIPS.

Processador MIPS O processador MIPS é usado nos produtos da Nintendo, Sony, Silicon graphics, entre outras. É um processador de 32 bits. Sua linguagem de montagem apresenta uma estrutura bastante regular. É um processador RISC ( conjunto reduzido de instruções). Possui 32 registradores de 32 bits em sua arquitetura.

Linguagem de máquina Linguagem assemby é essencialmente suportada diretamente em hardware. Simplicidade -> regularidade Limite nos tipos de operandos (registradores) Limite no conjunto de operações

Elementos de uma instrução Código da operação (codop) Faça isto Endereço do operando fonte Use isto Endereço do operando resultado Coloque o resultado aqui

Operações aritméticas MIPS: add a,b,c # a = b + c Obs. Os nomes dos operandos não são a, b e c Instruções são mais rígidas que em linguagem de alto nível MIPS: apenas 3 operandos Exemplo: a = b + c + d + e add a, b, c # a = b + c add a, a, d # a = a + d add a, a, e #a = a + e

Variáveis Assembly : Registradores Assembly não utiliza variáveis Operandos Assembly são registradores Número limitado de localizações especiais construídas diretamente no hardware Operações podem somente ser realizadas nestes Como os registradores estão diretamente no hardware eles são muito rápidos.

Variáveis Assembly : Registradores Exemplo: MIPS: 32 registradores de 32 bits Cada registrador tem um nome Os nomes começam com $ $s0, $s1, $s2... ,$s7-> correspondem às variáveis de programa $t0, $t1, $t2...,$t9 -> registradores temporários Zero: $zero

Variáveis Assembly : Registradores Banco de Registradores 31 . $s7 23 $s6 22 $s5 21 $s4 20 $s3 19 $s2 18 $s1 17 $s0 16 $t7 15 $t6 14 $t5 13 $t4 12 $t3 11 $t2 10 $t1 9 $t0 8 .

Tradução Linguagem de máquina para código de instruções Instruções aritméticas com imediatos addi $t0, $s1,4 Linguagem de máquina opcode Registrador destino Registrador fonte Imediato 6 bits 5 bits 5 bits 16 bits 001000 10001 10010 0000000000000100 6 bits 5 bits 5 bits 16 bts Código da instrução

Adição e Subtração Sintaxe das instruções: Nome da operação (add, sub) Operando destino Primeiro operando fonte Segundo operando fonte add $t0, $s1, $s2

Adição e subtração Exemplo: f = (g + h) – (i + j); add $t0, $s1, $s2 sub $s0, $t0, $t1 f $s0 g $s1 h $s2 i $s3 j $s4

Adição e subtração Exemplo: a = b + c + d – e; add $s0, $s1, $s2 sub $s0, $s0, $s4 a $s0 b $s1 c $s2 d $s3 e $s4

Instruções Lógicas Operações AND e OR; Sintaxe semelhante às operações aritméticas; Exemplos: and $t0,$s0,$s1 or $t0,$s0,$s1

Tradução Linguagem de máquina para código de instruções Instruções aritméticas e lógicas add $t0, $s1,$s2 Linguagem de máquina opcode Registrador destino Registrador fonte 1 Registrador fonte 2 Não utilizado 6 bits 5 bits 5 bits 5 bits Não utilizado 000000 10001 10010 01000 00000000000 6 bits 5 bits 5 bits 5 bits Não utilizado Código da instrução

Operandos Imediatos Imediatos são costantes numéricos. São comuns em códigos, logo existem instruções especiais para eles. Somar imediato: addi $t0, $t1, 10 # $t0 = $t1 + 10 Imediato

Tradução Linguagem de máquina para código de instruções Instruções aritméticas com imediatos addi $t0, $s1,4 Linguagem de máquina opcode Registrador destino Registrador fonte Imediato 6 bits 5 bits 5 bits 16 bits 001000 10001 10010 0000000000000100 6 bits 5 bits 5 bits 16 bts Código da instrução

Transferência de dados Transferem dados entre registradores e memória Memória para registrador Registrador para memória

Transferência de dados Cada palavra na memória tem um endereço; Primeiros computadores numeravam palavras como elementos de um array C. memory[0], memory[1], memory[2]... Endereçamento por palavra 3 2 1 10001110010100010011010101010111 10000110110100010011010101010111 10001110010100011101010101010110 01110011010110100011010101010111 dados

Transferência memória para registrador Para transferir uma palavra de dados, nós devemos especificar duas coisas: Registrador (destino); Endereço da memória; A memória é um array uni-dimensional Podemos endereçá-la através de um ponteiro Podemos deslocar o ponteiro

Transferência memória para registrador Para especificar um endereço de mémória: Registrador que contém um ponteiro para a memória; Um deslocamento numérico (em bytes); O endereço é a soma desses dois valores; Ex: 8($t0) Especifica o endereço de memória apontado pelo valor em $t0 mais 8 bytes

Memória para registrador Sintaxe da instrução de carga (load) Nome da operação (instrução) Registrador que receberá o valor Deslocamento numérico em bytes No MIPS deslocamento possui 16 bits, podendo ser positivo ou negativo. Registrador contendo um ponteiro para a memória. Nome da instrução: lw (load word) 32 bits são transferidos de uma vez

Transferência memória para registrador Exemplo: lw $t0, 3($s0) $s0 é o registrador base 3 é o deslocamento (offset) Ex. $s0 = 1 => Endereço = 1 + 3 = 4 2 1 4 3 6 5 7 9 8 11 10 12 $t0

Memória para registrador Pergunta: Suponha que temos um vetor A Qual é o offset para selecionar A[8]? g = h + A[8]; g: $s1; h: $s2; $s3: endereço base de A, ou seja, endereço de A[0];

Transferência memória para registrador 8 palavras lw $t0,8($s3) add $s1, $s2, $t0 A[3] A[1] A[0]

Registrador para memória Também queremos armazenar o valor de um registrador na memória. Nome da instrução sw (store word); Sintaxe idêntica a instrução load; sw $t0,12($s0) Essa instrução tomará o ponteiro em $s0, somará 12 bytes a ele, e então armazenará o valor do registrador $t0 no endereço de memória apontado pela soma calculada

Transferência registrador para memória Exemplo: A[12] = h + A[8]; h : $s2 $s3: tem o endereço base de A Passos: 1 – carregar A[8] para registrador temporário 2 – somar 3 – Armazenar resultado em A[12]

Registrador para memória Passo 1: Determinar o offset de A[8]: Offset = 8 lw $t0,8($s3) Passo 2: add $t0, $s2, $t0 Passo 3: Determinar offset de A[12]: Offset = 12; sw $t1,12($s3)

Tradução Linguagem de máquina para código de instruções Instruções transferência de dados lw $t0, 1200 ($t1) Linguagem de máquina opcode Registrador destino Registrador base deslocamento 6 bits 5 bits 5 bits 16 bits 100011 01001 01000 0000010010110000 6 bits 5 bits 5 bits 16 bts Código da instrução

Exercícios de fixação Realize as seguinte operação utilizando a linguagem de máquina do MIPS: a) A[15] = h + B[6]; $s0 : h $s1: endereço base de A $s2: endereço base de B b) A[15] = A[5] + B[6] + B[0]; c) A[4] = A[12] – A[5] + A[3]

Instruções de Desvio

Instruções de desvio Todas as instruções executadas até agora nos permitem manipular dados - > calculadora Para construirmos um computador precisamos da habilidade de tomar decisões Ex. Como representar o seguinte trecho de código em assembly (ling. de máquina): if (a == 0) a = a+1; else a = a-1;

Instruções de desvio beq beq registrador1, registrador2, L1 O MIPS possui duas instruções de desvio condicional beq (branch if equal) – desvie se igual bne (branch if not equal) – desvie se não igual Sintaxe beq beq registrador1, registrador2, L1 Se conteúdo de registrador1 igual ao conteúdo de registrador2, desvie para o label L1 Exemplo: beq $t1, $t0, L1

Instruções de desvio bne bne registrador1, registrador2, L1 Sintaxe Se conteúdo de registrador1 é diferente do conteúdo do registrador2, desvie para o label L1 Exemplo: bne $t1, $t0, L1

Instruções de desvio A instrução de desvio incondicional no MIPS é a jump(pule, ou desvie para) sintaxe: j L1 # desvie para o label L1 Essa instrução é equivalente ao goto

Instruções de desvio Vamos rearranjar o código: if (a == 0) goto L1; a = a - 1; goto L2; L1: a = a + 1; L2: if (a == 0) a = a+1; else a = a-1; Observação: L1 é um label que representa o endereço onde a instrução a = a + 1 está armazenada.

Desvios condicionais Vamos executar o nosso trecho de código na linguagem do MIPS: a : $s0 beq $s0,$zero,L1 # se a = 0 vai para L1 subi $s0,$s0,1 # faz a = a -1 j L2 # vai para L2 L1: addi $s0,$s0,1 # faz a = a+1 L2: if (a == 0) a = a+1; else a = a-1;

Laços Como faríamos para executar o seguinte código: Reescrevendo: LOOP: a = a + 1; if(a != 10) goto LOOP; do{ a = a + 1; }while (a != 10);

Laços Em linguagem de máquina teríamos: LOOP: add $s0,$s0,1 a: $s0 , 10 : $s1 LOOP: add $s0,$s0,1 bne $s0,$s1,LOOP do{ a = a + 1; }while (a != 10);

Exercícios de fixação Traduza os seguintes trechos de código para o assembly do MIPS: b = 0; do{ b = b + 5; }while(b != 50); b) if (b == 10) b = b - 1; else b = b*2;