AULA 5 - Microprocessadores - Graduação

CONJUNTO DE INSTRUÇÕES

Um programador de linguagem de alto nível normalmente conhece muito pouco acerca da arquitetura da máquina que está usando.

O conjunto de instruções da máquina é o limite em que o projetista de CPU e o programador de baixo nível enxergam, da mesma máquina.

Implementar uma CPU é uma tarefa que envolve, em grande parte, implementar um conjunto de instruções de máquina.

Já programar em linguagem de máquina (na verdade, em linguagem de montagem, Assembly) exige um conhecimento acerca do conjunto de registradores da CPU, a estrutura de memória, os tipos de dados disponíveis na máquina e o funcionamento da ULA.

Porém, da descrição do conjunto de instruções à uma compreensão sobre o funcionamento da CPU, há um longo caminho.

CARACTERÍSTICAS DE INSTRUÇÕES DE MÁQUINA

A operação de uma CPU é determinada pelas instruções que ela executa, conhecidas como instruções de máquina.

A coleção de instruções que uma determinada CPU é capaz de executar é conhecida como conjunto de instruções da CPU.

Elementos de instrução de máquina

Cada instrução deve conter toda a informação necessária para que a CPU possa executá-la.

A figura acima ajuda a definir os elementos da instrução:

• Código de operação (OPCODE) - Especifica a operação a ser efetuada (por exemplo, ADD, ou E/S, etc). A operação é especificada por um código binário.

• Referência a operando fonte - a operação pode envolver um ou mais operandos fonte, ou seja, que constituem dados de entrada para a operação.

Exemplos:

• • operação com um único operando: INV(A)
  • operação com dois operandos: ADD(A,B)
  • operação com três ou mais operandos: DEV(GE(A,B),C,D)

• Referência a um operando de destino - a operação pode eventualmente produzir um resultado, que deverá ser enviado a um endereço de memória, ou registrador

• Endereço da próxima instrução - indica aonde a CPU deve buscar a próxima instrução (memória principal ou virtual), depois que a instrução corrente for completada, quando for o caso.

Os operandos fonte e destino podem estar localizados em:

• Memória principal ou virtual - implica em busca na memória RAM, ou no HD (quando virtual)
• Registrador da CPU - se houver apenas um registrador, a referência a ele poderá ser implícita. Quando há acumulador, a referência a ele é default. Caso hajam vários registradores, normalmente a referência a cada um, individualmente, é feita por um número inteiro correspondente.
• Dispositivo de E/S - indicado diretamente na instrução. Se for usada a E/S mapeada na memória, esta informação se resumirá a um endereço de memória, como os demais. Pode ser também um registrador específico (Ex: porta serial).

REPRESENTAÇÃO DE INSTRUÇÕES

Internamente, cada instrução é representada por uma sequência de bits.

É dividida em campos, correspondentes aos elementos da instrução.

Exemplos:

A maioria das CPUs têm mais de um formato de instrução.

Durante a execução, uma instrução é lida em um registrador de instruções (IR) da CPU. A CPU extrai os dados dos vários campos da instrução e efetua a operação correspondente.

Os códigos de operação normalmente são representados por abreviações, chamadas mnemônicos, que evitam que os programadores tenham que trabalhar diretamente com valores binários.

Alguns exemplos mais comuns são:

ADD  -------------  Adição
SUB  -------------  Subtração
MPY  -------------  Multiplição
DIV  -------------  Divisão
GT   -------------  Operação >
LT   -------------  Operação <
GE   -------------  Operação ≥
LE   -------------  Operação ≤

Os operandos também são representados por símbolos.

Por exemplo:

  ADD R, Y

pode significar adicionar o valor contido na posição Y, com o valor contido no registrador R. Neste caso, Y é um endereço de memória e R, um registrador da própria CPU.

TIPO DE INSTRUÇÃO

Como já vimos, uma única instrução escrita em linguagem de alto nível pode requerer várias instruções de máquina.

Os tipos de instrução de máquina que existem são:

• Processamento de dados - instruções aritméticas e lógicas
• Armazenamento de dados - instruções de memória
• Movimentação de dados - instruções de E/S
• Controle - instruções de teste e de desvio

NÚMERO DE ENDEREÇOS

Uma das maneiras tradicionais de se descrever uma arquitetura é em termos do número de endereços contidos em cada instrução.

CONJUNTO DE INSTRUÇÕES DO ARM

A arquitetura ARM trabalha com dois tipos de instruções: o ARM e o THUMB.

O conjunto de instruções ARM pode ser dividido em 6 classes:

• instruções de branch
• instruções de processamento de dados
• instruções de acesso ao registrador de estado
• instruções de load e store
• instruções do coprocessador
• instruções geradoras de exceções

A maioria destas instruções contêm um campo de condição de 4 bits.

Estas condições são ativadas através de sufixos que são colocados junto com os minemônicos das instruções.

Por exemplo, um salto (B) pode ser acompanhado de um NE (not equal), o que gera uma expressão BNE.

Essa instrução só será executada caso a condição seja verdadeira.

　

INSTRUÇÕES DE BRANCH

Todos os processadores ARM suportam instruções de branch com saltos condicionais para frente ou para trás de até 32M. Saltos mais longos podem ser feitos através de chamadas de subrotinas como por exemplo o Branch whith Link (BL) que mantem o endereço de retorno no LR (R14).

A instrução BX permite a troca entre o estado ARM e o estado THUMB. Esta instrução copia o conteudo de um registrador de propósito geral para o PC. Caso o bit[0] do valor transferido para o PC seja 1, o processador troca para o estado THUMB.

INSTRUÇÕES DE PROCESSAMENTO DE DADOS

O ARM possui 16 instruções mostrada na tabela a seguir:

INSTRUÇÕES DE ACESSO AO REGISTRADOR DE ESTADO

Existem duas instruções para mover os conteúdos de um registrador de propósito geral e de um registrador de estado, que são as seguintes: MRS – move o conteúdo do registrador de estado para um registrador de propósito geral. MSR – move o conteúdo do registrador de propósito para um registrador de estado.

　

INSTRUÇÕES DE LOAD E STORE

A arquitetura ARM suporta dois tipos de instruções de load e store que transferem o conteudo de um registrador para a memória ou ao contrário.

O primeiro tipo pode carregar ou escrever uma parava de 32 bits ou um byte sem sinal.

O segundo tipo pode ler ou escrever meia palavra de 16 bit sem sinal, e pode carregar e sinalizar meia palavra de 16 bit ou um byte. Este tipo de instrução está disponível apenas para a arquitetura ARM versão 4 ou posterior.

Codificação das instruções:

Instrução que lê e carrega palavra ou byte sem sinal:

  I,P, U, W – são bits para distinguir diferenças entre tipos de <addressing_mode>.
       L bit – Diferencia instrução de load (L==1) e store (L==0)
       B bit – Diferencia byte sem sinal (B==1) e palavra(B==0)
       Rn – Especifica o registrador base utilizado por <addressing_mode>
       Rd – Especifica o registrador onde vai ser carregado ou de onde vai ser escrito.

Instrução que lê e carrega meia palavra ou lê um byte sinalizado :

  I,P,U,W – são registradores que especificam o tipo de endereçamento
       L bit - Diferencia Load (L==1) e Store (L==0)
       S bit – Diferencia meia palavra sinalizada (S==1) e não sinalizada (L==0).
       H bit – diferencia meia palavra (H==1) e byte sinalizado (H==0).
       Rn – Especifica o registrador base a ser utilizado pelo modo de endereçamento.
       Rd – Especifica o registrador do qual será lido ou onde será carregado a informação.

INSTRUÇÕES GERADORAS DE EXCESSÕES

Existe duas instruções deste tipo:

• a SWI que causa uma interrupção de software. É o mecanismo principal utilizado pelo ARM para poder executar codigos do Sistema Operacional no modo de usuário (User Mode).

• E existe o BKPT. Esta instrução é usada para breakpoints na arquitetura ARM da versão 5 em diante.

       A codificação destas instruções é a seguinte:

INSTRUÇÕES DO COPROCESSADOR

São instruções para fazer a comunicação com coprecessadores. Elas permitem o processador ARM iniciar uma operação de processamento de um coprecessador. Permite fazer transferencias entre os registradores do processador e dos coprocessadores. E permite também o processador criar enderenços para o coprocessador carregar e escrever instruções.

O CONJUNTO DE INSTRUÇÕES THUMB

O THUMB possui instruções com as mesmas finalidades das instruções ARM, porém são codificadas com 16 bits. Estas instruções THUMB geram códigos menores porém muitas vezes ocorre de aumentar o número de instruções que o processador deve executar. Uma solução para isso são aplicações que utilizam ambos tipos de instruções ( ARM e THUMB). Aplicações deste tipo conseguem reduzir o tamanho do seu código significativamente e conseguem manter o consumo de energia baixo. As codificações de algumas instruções THUMB são as seguintes:

Estrutura de Procedures e Functions (De C para Assembler)

A chamada de funções e procedures é dividida em 6 passos:

1º Passo: Parâmetros

As funções de até 4 parâmetros tem como destino os registradores de R0-R3 , com o primeiro parâmetro no r0. Os demais são colocados na pilha e são acessados utilizando [SP+Displacement].

void func1 (

 long  b,     //Primeiro parâmetro passado em R0
 int  *c,     //Segundo parâmetro passado em R1
 short d,     //Quarto parâmetro passado em R2
 float e)     //Quinto parâmetro passado em R3

No caso acima, todos os argumentos cabem nos registradores.

void func2 (

 long long f,  //Primeiro parâmetro passado em R0/R1          
 int g,        //Segundo parâmetro passado em R2    
 double h)     //Terceiro parâmetro passado em R3 e Pilha
 long i)       //Quarto parâmetro passado somente na Pilha

Já aqui, os primeiros dois são passados nos registradores, o terceiro é passado parcialmente no registrador e o quarto é passado diretamente na pilha.

2º Passo: Chamada

É chamada executando o comando de Branch and Link (Expansão e linkagem).

BL minhafunção

3º Passo: Preservação dos registradores.

A primeira instrução em uma função normalmente é assim:

stmdb sp!, {r4 - r6, lr} Ela faz um Push LR, Push R6, Push R5, Push R4.

Esta instrução preserva os valores dos registradores de R4 até R11, e o R13. É total responsabilidade da função preservar esses.

4º Passo:Variáveis Locais

Em seguida, uma operação é realizada na pilha para reservar espaço para as variáveis locais.

sub sp, sp, #0xC

5º Passo: Corpo Então, o corpo da função é executado, em algum momento o compilador decide que o registrador R0 será responsável pelo retorno da função.

6º Passo: Retorno

Se o espaço foi alocado para variáveis locais, ele é então desalocado:

add sp, sp, #0xC

Os registradores salvos no começo são restaurados:

ldmia sp!, {r4 – r6, lr}

pop(r4); pop(r5); pop(r6); pop(lr);

E finalmente o endereço de retorno:

Bx lr