trabalho processador h8

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:
O H8 suporta um espaço de endereçamento de 64K bytes.
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
#xor
xor
#slt
r2l,r3l
$18, $16, $17
r1l,r3l
$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
_cont2: shll
shll
shll
shll
$17, $17, 16
r2l
r2l
r2l
r2l
#move 16 bits para a esquerda
#add
#add
mov.b
#_multp:and
_multp: mov.b
and
#beq
beq
#add
add.b
#_avanca:srl
_avanca: shlr
#add
add.b
#bne
bne
#beq
cmp.b
bpl
#nor
not
#add
add.b
$8, $0, 1#cria mascara
$10, $0, 16
#contador de looping
#4,r2h
$9, $8, $16
#looping da multiplicacao
#1,r1h
r1l,r1h
$9, $0, _avanca
_avanca
$16, $16, $17
r2l,r1l
$16, $16, 1
r1l
$10, $10, -1
#(0-1),r2h
$10, $0, _multp
_multp
$18, $0, saida
#0,r3l
_saida
$16, $16, $0
r1l
$16, $16, 1
#1,r1l
#coloca sinal se necessario
_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.