TRABALHO
PROCESSADOR H8
abel ferreira – 05132002 eberle rambo- 05132118
Monografia
abel ferreira – 05132002 eberle rambo - 05132118
Prefácio.
A família do micro processador h8 inclui diversas versões.
Nesse trabalho abordaremos o micro processador da família H8/300.
O H8/300 é um processador de alta velocidade caracterizado com poderosas instruções de manipulação de bit, projetado para controle de aplicações de tempo real.
Arquitetura RISC, tendo oito 16-bit (ou dezesseis 8-bit) registradores de uso geral com um conciso e otimizado conjunto de instruções.
Fornece suporte de módulos on-chip ROM, RAM, quatro tipos de timers, portas de entrada e saída, uma interface de comunicação serial, I2c bus interface, sistema de controle de alta velocidade.
Característica Descrição
CPU Arquitetura de registradores de uso geral
• Oito registradores de 16-bit de uso geral (R0 to R7) ou
• Dezesseis registradores de 8-bit de uso geral (R0H, R0L, ..., R7H, R7L), Alta velocidade
• Taxa de clock máxima: 16 MHz/5 V, 12 MHz/4 V, 10 MHz/3 V (ø clock) • Add/subtract: 125 ns (16 MHz operation), 167 ns (12 MHz operation), 200 ns (10 MHz operation)
• Multiplicação/divisão: 875 ns (16 MHz operation), 1167 ns (12 MHz operation), 1400 ns (10 MHz operation)
Conciso e otimizado conjunto de instruções • Todas instruções são de 2 ou 4 bytes long
• Registrador-registrador para aritméticas e operações lógicas
• Registrador-memória para transferência de dados pela instrução MOV (máquina load-store)
Características do conjunto de instruções • Instrução de multiplicação (8 bits × 8 bits) • Instrução de divisão (16 bits ÷ 8 bits) • Instrução de acumulador de bit
Tipos de bit de dados
• 4-bit (pacote BCD), byte, word (2 bytes) Registradores de controle
• Program counter (PC)
• Condition code register (CCR) Modos de Endereçamento
• direto • indireto
• indireto com deslocamento de 16 bit • indireto com pós-incremento
• indireto com pré-incremento • endereço absolute ( 8 ou 16 bits) • imediato (8 ou 16 bit de dado)
• relativo ao PC ( deslocamento de 8-bit) • Memoria indireta
Conjunto de instruções
O H8 é um processador com arquitetura RISC, como o MIPS. São no total 57 instruções:
● 3 tipos de instruções para transferência de dados:
MOV, MOVFPE, MOVTPE, POP*, PUSH*
(POP Rn é equivalente a MOV.W @SP+,Rn) (PUSH Rn é equivalente a MOV.W @SP+, Rn)
● 14 tipos de instruções para operações aritméticas:
ADD, SUB, ADDX, SUBX, INC, DEC, ADDS, SUBS, DAA, DAS, MULXU, DIVXU, CMP, NEG
● 4 tipos de instruções para operações lógicas:
AND, OR, XOR, NOT
● 8 tipos de instruções para deslocamento:
SHAL, SHAR, SHLL, SHLR, ROTL, ROTR, ROTXL, ROTXR
● 14 tipos de instruções para manupulações de bit:
BSET, BCLR, BNOT, BTST, BAND, BIAND, BOR, BIOR, BXOR, BIXOR, BLD, BILD, BST, BIST
● 5 tipos de instruções branch:
Bcc**, JMP, BSR, JSR, RTS
● 9 tipos para controle do sistema:
RTE, SLEEP, LDC, STC, ANDC, ORC, XORC, NOP
● 1 tipo para transferência de bloco de dados:
EEPMOV
Similaridades/diferenças com o MIPS:
Apesar do H8 ser também uma maquina RISC, como o MIPS, suas instruções diferem um pouco.
O H8 tem as instruções PUSH e POP já implementadas, enquanto no MIPS é necessario implamentar usando um load/store na memoria e somar/subtrair o Stack Point.
No H8 existe mais instruções condicionais do que no MIPS, enquanto o segundo possui apenas “branch if equal” e “brach if not equal”, o H8 possui 5 tipos condicionais.
O H8 assim como o MIPS é uma máquina load/store, ou seja, as isntruções aritméticas e as outras não podem trabalhar direto coma memória, somente usando a instrução MOV.W no H8 e usando SW/LW no MIPS.
Estrutura dos dados nos registradores de uso geral.
O H8 pode processar dados de 1 bit, 4 bit (packed BCD),de 8 bits, e dados de 16 bits (palavra)
Todas instruções operacionais, exceto ADDS e SUBS podem operar em dados de byte. As instruções MOV.W, ADD.W, SUB.W, CMP>W, ADDS, SUBS, MULXU (8 bits x 8 bits), e DIVXU (16 bits / 8 bits) operam em dados de palavra.
Dados de todos os tamanhos podem ser gravados nos registradores de uso geral como mostrado na figura:
Similaridades/diferenças com o MIPS:
A arquitetura de registradores de uso geral é bem diferente do MIPS, enquanto o MIPS possui somente 32 registradores de 32 bits de uso geral, o H8 possui registradores mutantes.
Dados de palavras gravados na memoria devem começar sempre no mesmo endereço. Em acesso na memoria, o bit menos significativo do endereço é considerado como zero. Se um endereço impar é expecificado, não ocorre erros mas o acesso será no endereço precedente.
Essa regra afeta instruções MOV.W e condicionais. Formato de dados na memória:
Espaço de endereçamento:
Registradores:
A figura abaixo mostra a estrutura dos registradores da CPU H8/300. Existem 16
registradores geral de 8 bits (R0H, R0L, ..., R7H, R7L), que também podem ser acessador como 8 registradores de 16 bits (R0 até R7).
Há também 2 registradores de controle: o PC (program counter) de 16 bits e o condition code register (CCR) de 8 bits.
Todos os registradores de uso geral podem ser usados como registradores de dados e endereço. Quando usado como registrador de endereço, os registradores são acessados como registradores de 16 bits. Quando usado como registradores de dados, eles podem ser acessados como registradores de 16 bits, ou como registradores de 8 bits. O tamanho do registrador é determinado pela instrução.
R7 também tem função de Stack Pointer, usado implicitamente pelo hardware em
processamento de interrupções e chamada de subrotinas. Em linguagem assembly, as letras SP podem ser codificadas como um sinonimo para R7.
Como indicato na figura abaixo, o R7 (SP) aponta para o topo da pilha.
Similaridades/diferenças com o MIPS:
Enquanto o MIPS possui um registrador especifico para o Stack Point, o H8 usa um dos registradores de uso geral como SP.
Registradores de controle: Program Counter (PC):
Esse registrador de16 bit indica o endereço da proxima instrução que a CPU executará. Instruções são buscadas em acessos de 16 bits, então o bit menos significativo é ignorado.
Condition Code Register (CCR):
Esse registrador de 8 bits indica status interno da CPU com um bit de mascara de
interrupção e 5 bits de flag: half-cary (H), negativo (N), zero (Z), overflow (V), e carry (C) flags. Os 2 bits não usados são disponibilizado ao usuario.
bit 7 - bit de mascara de interrupção (I): Quando esse bit é setado para "1", todas exceções
de interrupções são mascarado. O bit é setado para "1" automaticamente por um reset e no começo de manipulação de interrupção.
Bits 6 e 4 - bits de usuário (U): Esses bits podem ser escrito e lido pelo software para o
propósito que o usuário necessitar.
Bit 5 - Half-carry(H): Esse bit é usado pelas instruções de adição, subtração e comparação.
É referenciado por instruções de ajustes decimais.
Bit 3 - negative (N): Esse bit indica o bit mais significativo (o bit de sinal) do resultado de
uma instrução.
Bit 2 - Zero (Z): Esse bit seta para "1" para indicar um resultado nulo (zero) e seta para "0"
para indicar um resultado não nulo.
Bit 1 - OverFlow(V): Esse bit seta para "1" quando ocorre uma overflow aritmético, e seta
para zero em outras horas.
Bit 0 - Carry (C): Esse bit é usado por:
- instruções de adição, subtração e comparação para indicar um carry do bit mais significativo
- instrução de deslocamento para gravar o valor deslocado do bit mais ou menos significativo
- instruções de manipulação de bit, como um acumulador de bit.
Valores de registrador inicial:
Quando a CPU é resetada, o Program Counter (PC) é carregado da tabela de vetor e o bit de mascara de interrupção no CCR é setado para "1". Outros bits do CCR e os registradores de uso geral não são inicializados.
Em particular, o stack pointer (R7) não é inicializado. Para prevenir erros de programas um stack pointer deve ser inicializado por software, pela primeira instrução executada após o reset.
Interrupt Programming
#include <stdio.h>
void mostraRegistradores(unsigned int * sp) { unsigned int i;
for (i = 0; i <= 7; i++){
printf("r%i: %i\n", i, sp[i]); } } void salvarRegistradores(){ asm( "mov.w #26, r0\n" "mov.w #55, r1\n" "mov.w #-15, r2\n" "mov.w #7, r3\n" "mov.w #32, r4\n" "mov.w #66, r5\n" "push r7\n" "push r6\n" "push r5\n" "push r4\n" "push r3\n" "push r2\n" "push r1\n" "push r0\n" "mov.w r7,r0\n" "jsr _mostraRegistradores\n" "pop r0\n" "pop r1\n" "pop r2\n" "pop r3\n" "pop r4\n" "pop r5\n" "pop r6\n" "pop r7\n" ); } main(){ salvarRegistradores(); }
Exploring Arithmetic and Logical Operations .LC0: .string "\nResultado: " .LC1: .string "%#10x\n" .section .text .align 1 .globl _main _main: mov.w r6,@-r7 mov.w r7,r6 subs #2,r7 #valores a serem multiplicados
mov.b #6,r1l #carrega o valor 6 no registrador de 8 bits r1l mov.b #5,r2l #carrega o valor 5 no registrador de 8 bits r2l #
# Implemente o algoritmo de multiplicacao aqui # Os valores que devem ser multiplicados estao nos
# registradores $16 (R1L) e $17 (R2L). Armazene o resultado no # proprio registrador $16 (R3l)
mov.b r2l,r3l #xor $18, $16, $17 xor r1l,r3l #slt $18, $18, $0
# torna primeiro valor positivo, caso necessite #slt $9, $16, $0 cmp.b #0, r1l #beq $9, $0, _cont bpl _cont #nor $16, $16, $0 not r1l #add $16, $16, 1 add.b #1,r1l #_cont: slt $9, $17, $0 _cont: cmp.b #0,r2l #beq $9, $0, _cont2 bpl _cont2 #nor $17, $17, $0 not r2l #add $17, $17, 1 add.b #1,r2l
#_cont2:sll $17, $17, 16 #move 16 bits para a esquerda _cont2: shll r2l
shll r2l shll r2l shll r2l
#add $8, $0, 1#cria mascara
#add $10, $0, 16 #contador de looping mov.b #4,r2h
#_multp:and $9, $8, $16 #looping da multiplicacao _multp: mov.b #1,r1h and r1l,r1h #beq $9, $0, _avanca beq _avanca #add $16, $16, $17 add.b r2l,r1l #_avanca:srl $16, $16, 1 _avanca: shlr r1l #add $10, $10, -1 add.b #(0-1),r2h #bne $10, $0, _multp bne _multp
#beq $18, $0, saida #coloca sinal se necessario cmp.b #0,r3l bpl _saida #nor $16, $16, $0 not r1l #add $16, $16, 1 add.b #1,r1l _saida: # Fim da implementacao ---#imprime resultado na tela
mov.w r1,r2 mov.w r2,@(-2,r6) mov.w #.LC0,r2 mov.w r2,@-r7 jsr @_printf adds #2,r7 mov.w @(-2,r6),r2 mov.w r2,@-r7 mov.w #.LC1,r2 mov.w r2,@-r7 jsr @_printf mov.w @r7+,r6 rts
Bibliografia: Hitachi Single-Chip Microcomputer H8/3217 Series H8/3217, H8/3216 H8/3214, H8/3212 H8/3202 Hardware Manual
H8/300 Programming Manual Todas imagens foram retiradas da bibliografia. Nota: * H8 is a trademark of Renesas, Ltd.
