CESAR (As bases da civilização atual). Cesar - características Largura de dados e endereços de 16 bits Dados representados em complemento de dois 8 registradores

CESAR

(As bases da civilização atual)

Cesar - características

• Largura de dados e endereços de 16 bits• Dados representados em complemento de dois• 8 registradores de uso geral de 16 bits (R0-R7)• 1 registrador de estado com 4 códigos de

condição: negativo (N), zero (Z), carry (C) e overflow (V)

• 8 modos de endereçamento• instruções com 2, 1 e zero operandos• suporte para pilha (stack)

Registradores

• 8 registradores (R0-R7)• R7 = program counter (PC)• R6 = stack pointer (SP)• três bits para seleção de registrador

• R7 e R6 tem funções específicas,

mas também são de uso geral

Modos de endereçamento

• 000 = registrador• 001 = registrador pós-incrementado• 010 = registrador pré-decrementado• 011 = indexado• 100 = registrador indireto• 101 = pós-incrementado indireto• 110 = pré-decrementado indireto• 111 = indexado indireto

Endereçamento de memória

• Arquitetura de 16 bits• Memória organizada em bytes (8 bits)• Big endian - byte mais significativo armazenado no

endereço menor (PDP, Motorola, Cesar)• Little endian - byte menos significativo armazenado

no endereço menor (Intel)• Exemplo:

mem(128) = 0

mem(129) = 1

mem(130) = 2• Cesar - sem restrições no endereçamento

(par ou ímpar)

Modo Registrador

R7

instrução

memóriaregistradores

R0

operando

MOV R0, R1 R1 R0

Pós-incrementado

R7

instrução

memória

operando

registradoresR0

endereço

+2

1

2

34

MOV R0, (R1)+ Mem(R1) R0; R1 R1 + 2

Pré-decrementado

R7

instrução

memória

operando

registradoresR0

endereço

1

R7

operando

R0

endereço 4

23

-2

MOV R0, -(R1) R1 R1 - 2 ;Mem(R1) R0

Indexado

R7

instrução

memória

operando

registradoresR0

endereçodeslocamento

+

MOV R0, ddd(R1) Mem(R1+ddd) R0

Registrador indireto

R7

instrução

memória

operando

registradoresR0

endereço

MOV R0, (R1) Mem(R1) R0

Pós-incrementado indireto

R7

instrução

memória

operando

registradoresR0

endereço

+2

1

2

45

endereço

3

MOV R0, ((R1)+) Mem(Mem(R1)) R0; R1 R1 + 2

Pré-decrementado indireto

R7

instrução

memória

operando

registradoresR0

endereço

-2

1

4

23

endereço

5

MOV R0, (-(R1)) R1 R1 - 2 ;Mem(Mem(R1)) R0

Indexado indireto

instrução

R7

registradoresR0

endereçodeslocamento

+

memória

endereço

operando

MOV R0, (ddd(R1)) Mem(Mem(R1+ddd)) R0

ExemplosModo registradorCLR R0 R0 0Modo registrador indiretoCLR (R0) Mem(R0) 0Modo indexadoCLR ddd(R0) Mem(R0+ddd) 0;Modo pós-incrementadoCLR (R0)+ Mem(R0) 0 ; R0 R0 + 2Modo pré-decrementado CLR -(R0) R0 R0 - 2 ; Mem(R0) 0Modo indexado indiretoCLR (ddd(R0)) Mem(Mem(R0+ddd)) 0Modo pós-incrementado indiretoCLR ((R0)+) Mem(Mem(R0)) 0; R0 R0 + 2 Modo pré-decrementado indiretoCLR (-(R0)) R0 R0 - 2 ; Mem(Mem(R0)) 0

Endereçamento com PC (R7)MOV R0, R7 R7 R0MOV R7, R0 R0 R7MOV R0, (R7)+ Mem(R7) R0; R7 R7 + 2MOV (R7)+, R0 R0 Mem(R7) ; R7 R7 + 2 MOV R0, -(R7) R7 R7 - 2 ;Mem(R7) R0MOV -(R7), R0 R7 R7 - 2 ;R0 Mem(R7)MOV R0, ddd(R7) Mem(R7+ddd) R0MOV ddd(R7), R0 R0 Mem(R7+ddd)MOV R0, (R7) Mem(R7) R0MOV (R7), R0 R0 Mem(R7)MOV R0, ((R7)+) Mem(Mem(R7)) R0; R7 R7 + 2MOV ((R7)+), R0 R0 Mem(Mem(R7)); R7 R7 + 2MOV R0, (-(R7)) R7 R7 - 2 ;Mem(Mem(R7)) R0MOV (-(R7)), R0 R7 R7 - 2 ; R0 Mem(Mem(R7))MOV R0, (ddd(R7)) Mem(Mem(R7+ddd)) R0MOV (ddd(R7)), R0 R0 Mem(Mem(R7+ddd))

Endereçamento com PC (R7)MOV R0, R7 R7 R0MOV R7, R0 R0 R7MOV R0, (R7)+ Mem(R7) R0; R7 R7 + 2MOV (R7)+, R0 R0 Mem(R7) ; R7 R7 + 2 MOV R0, -(R7) R7 R7 - 2 ;Mem(R7) R0MOV -(R7), R0 R7 R7 - 2 ;R0 Mem(R7)MOV R0, ddd(R7) Mem(R7+ddd) R0MOV ddd(R7), R0 R0 Mem(R7+ddd)MOV R0, (R7) Mem(R7) R0MOV (R7), R0 R0 Mem(R7)MOV R0, ((R7)+) Mem(Mem(R7)) R0; R7 R7 + 2MOV ((R7)+), R0 R0 Mem(Mem(R7)); R7 R7 + 2MOV R0, (-(R7)) R7 R7 - 2 ;Mem(Mem(R7)) R0MOV (-(R7)), R0 R7 R7 - 2 ; R0 Mem(Mem(R7))MOV R0, (ddd(R7)) Mem(Mem(R7+ddd)) R0MOV (ddd(R7)), R0 R0 Mem(Mem(R7+ddd))

Útil Cuidado ! Não usar !!

Pilha

• Cresce dos endereços superiores para os inferiores• Ponteiro da pilha aponta para o dado no topo da

pilha• Colocação de um dado na pilha (push)

SP SP - 2

Mem(SP) dado

• Retirada de um dado da pilha (pop)

dado Mem(SP)

SP SP + 2

Pilha

• Cresce dos endereços superiores para os inferiores• Ponteiro da pilha aponta para o dado no topo da

pilha• Colocação de um dado na pilha (push)

SP SP - 2

Mem(SP) dado

MOV origem,-(R6)• Retirada de um dado da pilha (pop)

dado Mem(SP)

SP SP + 2

MOV (R6)+,destino

Endereçamento com SP (R6)MOV R0, R6 R6 R0

MOV R0, (R6)+ Mem(R6) R0; R6 R6 + 2

MOV R0, -(R6) R6 R6 - 2 ;Mem(R6) R0






MOV (R6)+, R0 R0 Mem(R6) ; R6 R6 + 2

MOV -(R6), R0 R6 R6 - 2 ;R0 Mem(R6)

MOV (R6), R0 R0 Mem(R6)

Endereçamento com SP (R6)MOV R0, R6 R6 R0

MOV R0, (R6)+ Mem(R6) R0; R6 R6 + 2

MOV R0, -(R6) R6 R6 - 2 ;Mem(R6) R0 ; (PUSH)






MOV (R6)+, R0 R0 Mem(R6) ; R6 R6 + 2 ;

(POP)

MOV -(R6), R0 R6 R6 - 2 ;R0 Mem(R6)

MOV (R6), R0 R0 Mem(R6) ; (COPIAR SEM REMOVER)

Útil Cuidado ! Não usar !!

Código Tipo0000 instrução de NOP

0001 e 0010 instruções sobre os códigos de condição0011 instruções de desvio condicional0100 instrução de desvio incondicional (JMP)0101 instrução de controle de laço (SOB)0110 instrução de desvio para subrotina (JSR)0111 instrução de retorno de subrotina (RTS)1000 instruções de um operando

1001 a 1110 instruções de dois operandos1111 instrução de parada (HLT)

Identificação da instrução: 4 bits mais significativos

0 0 0 1 n z v c

07

CCC

0 0 1 0 n z v cSCC

0 0 0 0 x x x x07

NOP

1 1 1 1 x x x x07

HLT

0cccc

0 1 1 c c c c

07

Bcccc

d d d d d d d dd d d d d d d d

cccc mnemônico Condição dedesvio

0000 BR (always) sempre verdadeira0001 BNE (Not Equal) z = 00010 BEQ (EQual) z = 10011 BPL (PLus) n = 00100 BMI (MInus) n = 10101 BVC (oVerflow Clear) v = 00110 BVS (oVerflow Set) v = 10111 BCC (Carry Clear) c = 01000 BCS (Carry Set) c = 11001 BGE (Greater or Equal) n = v1010 BLT (Less Than) n < > v1011 BGT (GreaTer) n = v and z = 01100 BLE (Less or Equal) n < > v or z = 11101 BHI (HIgher) c = 0 and z = 01110 BLS (Lower or Same) c = 1 or z = 1

0 1 0 0 x x x x07

JMP

x x m m m r r r

0 1 0 1 x r r r

07

SOB

d d d d d d d dd d d d d d d d

r r - 1; if r<>0 then PC PC - d

PC endereço de desvio (modo 0 = NOP)

0 1 1 0 x r r r07

JSR

x x m m m r r r

temp endereço de desvio (modo 0 = NOP)pilha registrador rregistrador r PCPC temp

RTS 0 1 1 1 x r r r07

PC registrador r registrador r pilha

1 0 0 0 c c c c07

x x m m m r r r

cccc instrução significado N Z C V0000 CLR op 0 t t 0 00001 NOT op NOT op t t 1 00010 INC op op + 1 t t t t0011 DEC op op - 1 t t not(t) t0100 NEG op - op t t not(t) t0101 TST op op t t 0 00110 ROR op SHR(c & op) t t lsb xor0111 ROL op SHL(op & c) t t msb xor1000 ASR op SHR(msb & op) t t lsb xor1001 ASL op SHL(op & 0) t t msb xor1010 ADC op op + c t t t t1011 SBC op op - c t t t t

Obs: após uma subtração, C = 1 indica BORROW !

1 c c c m m m r07

r r m m m r r r

ccc instrução significado N Z V C001 MOV dst src t t 0 -010 ADD dst dst + src t t t t011 SUB dst dst - src t t t not(t)100 CMP src - dst t t t not(t)101 AND dst dst AND src t t 0 -110 OR dst dst OR src t t 0 -

Primeiro operando = origemSegundo operando = destino

Obs: após uma subtração, C = 1 indica BORROW !

Exemplos de somas - codificar• R1 = R1 +R2

• R1 = R1 + MEM(2000)

• MEM(3000) = MEM(3000) + r2

• MEM(3000) = MEM(3000) + MEM(2000)

• R1 = R1 + 5

• MEM(1300) = MEM(1300) + 300

ADD R2,R1

ADD 2000,R1

ADD R2,3000

ADD 2000,3000

ADD #5,R1

ADD #300,1300

Exemplos de somas - codificar

• R1 = R1 + Topo da pilha, sem retirar da pilha

• R1 = R1 + Topo da pilha, retirando da pilha

• Somar as duas palavras do topo da pilha, e devolver o resultado para o topo da pilha

ADD (R6),R1

ADD (R6)+,R1

ADD (R6)+,(R6)

Entrada e Saída

• visor alfanumérico de 36 posições, que permite visualizar letras (maiúsculas e minúsculas), dígitos (0 a 9) e caracteres especiais do conjunto ASCII padrão americano (códigos ASCII 0 a 127).

• teclado que permite ler um caractere (ASCII) e testar se uma tecla foi pressionada.

Entrada e Saída

• E/S mapeada na memória.

• os últimos 38 endereços de memória (65498 a 65535) são mapeados para os dois periféricos.

• transferências para esta área são sempre de 1 byte - somente os 8 bits menos significativos do operando são transferidos.

Visor

• Mapeado para os endereços 65500 a 65535 da memória

• Somente caracteres representáveis do conjunto ASCII padrão americano são visíveis (3210 código ASCII 12610 - ver Tabela 8.12)

• Todos os demais caracteres são mostrados como um espaço em branco

Teclado• A interface com o teclado é mapeada para

dois bytes da memória

• O byte 65499 contém o último caractere digitado (“buffer”)

• O byte 65498 indica o estado do teclado– Valor 128 (80H) : foi digitado um caractere– Valor 0: nenhuma tecla foi pressionada

Uso do teclado

• Esperar até que o endereço 65498 contenha 128

• Ler do endereço 65499 o código ASCII digitado

• Após, o endereço 65498 deve ser zerado

• Isto indica que outro caractere pode ser recebido

do teclado

• Enquanto o endereço 65498 não for zerado, todas

as teclas pressionadas são ignoradas

Exemplo de E/S• Rotina para ler um caractere

CLR 65498TST 65498BEQ -6 ; (250)

• Alternativa mais eficiente - para digitadores profissionais ;-)MOV #65498, R3CLR (R3)TST (R3)BEQ -4

Exemplo de E/S

• Leitura de caractere com eco (exibição no visor)

MOV #65498, R3

CLR (R3)

TST (R3)

BEQ -4 ; (252)

MOV 65499, 65500

BR -14 ; (242)

Exemplo de E/S

• Leitura de caractere com eco e fila (exibição em posições consecutivas do visor)

MOV #65498, R3MOV #65500, R1CLR (R3)TST (R3)BEQ -4 ; (252)MOV 65499, (R1)INC R1BR -14 ; (242)

Exemplo de E/S• Resolvendo o problema de “estouro” do visor

MOV #65498, R3

MOV #65500, R1

CLR (R3)

TST (R3)

BEQ -4 ; (252)

MOV 65499, (R1)

INC R1

BEQ -18 ; (238)

BR -16 ; (240)

Subrotina - caso 1

• Três parâmetros, por valor100 JSR R5, 1000 1000 MOV (R5)+,R1

104 param1 1002 MOV (R5)+,R2

106 param2 1004 MOV (R5)+,R3

108 param3 1006 ….

110 <próx.instr.> …..

1100 RTS R5

Subrotina - caso 2

• Três parâmetros, último por nome (endereço)100 JSR R5, 1000 1000 MOV (R5)+,R1

104 param1 1002 MOV (R5)+,R2

106 param2 1004 MOV ((R5)+),R3

108 end.param3 1006 ….


1100 RTS R5

Subrotina - caso 3• Dois parâmetros e um resultado

100 JSR R5, 1000 1000 MOV (R5)+,R1

104 param1 1002 MOV (R5)+,R2

106 param2 1004 MOV (R5)+,R4

108 end.resultado 1006 ….


1096 MOV resul,(R4)

1100 RTS R5

Subrotina - parâmetros na pilha

• Três parâmetros100 MOV param1, -(R6)

102 MOV param2, -(R6)


106 JSR R7, 1000

110 <próx.instr.>

• Como obter os parâmetros e deixar a pilha em ordem ?


• Como deixar a pilha em ordem ?

• Não mexer na pilha !100 MOV param1, -(R6)



106 JSR R7, 1000

110 ADD #6, R6 ; 6 bytes = 3 parâmetros

114 <próx.instr.>


• Como obter os parâmetros ?

• Modo indexado !100 MOV param1, -(R6) 1000 MOV 6(R6),R1

102 MOV param2, -(R6) 1002 MOV 4(R6),R2

104 MOV param3, -(R6) 1004 MOV 2(R6),R3

106 JSR R7, 1000 1006 ….

110 ADD #6, R6 …..

114 <próx.instr.> 1100 RTS R7


• Como obter os parâmetros ?100 MOV R6,R5 1000 MOV -2(R5),R1

102 MOV param1, -(R6) 1002 MOV -4(R5),R2

104 MOV param2, -(R6) 1004 MOV -6(R5),R3

106 MOV param3, -(R6) 1006 ….

108 JSR R7, 1000 …..

112 ADD #6, R6 1100 RTS R7

116 <próx.instr.>

Programa ExemploSomar (totalizar) n posições consecutivas de memória, a partir doendereço inicial e. (Sem consistência sobre os valores de n e e).

Em alto nível, o programa seria:

total:=0ponteiro := econtador := n

laço: if contador = 0, terminatotal := total + mem(ponteiro)ponteiro := ponteiro + 1contador := contador – 1goto laço

Endereço Instrução 0 LDA 132 ; inicializa (zera) o total 2 STA 130 4 LDA 129 ; inicializa ponteiro 6 STA 17 8 LDA 128 ; inicializa contador 10 STA 131 12 JZ 34 ; testa se contador é zero 14 LDA 130 ; carrega total no acumulador 16 ADD 17 ; soma com posição de memória 18 STA 130 ; atualiza total 20 LDA 17 ; incrementa ponteiro 22 ADD 134 24 STA 17 26 LDA 131 ; decrementa contador 28 ADD 133 30 STA 131 32 JMP 12 ; retorna ao início do laço 34 HLT 128 n número de posições 129 e endereço inicial 130 tot total 131 cont contador 132 0 constante zero 133 255 constante -1 134 1 constante 1

Neander

Endereço Instrução 0 LDR A #0 ; inicializa (zera) o total 2 LDR X 129 ; inicializa ponteiro 4 LDR B 128 ; inicializa contador 6 JZ 16 ; testa se contador é zero 8 ADD A 0,X ; soma com posição de memória 10 ADD X #1 ; incrementa ponteiro 12 SUB B #1 ; decrementa contador 14 JMP 6 ; retorna ao início do laço 16 STR A 130 ; atualiza total 18 HLT 128 n número de posições 129 e endereço inicial 130 total

Implementação Ramses

Endereço Instrução 0 MOV #0, R0 ; inicializa (zera) o total 4 MOV 1026, R2 ; inicializa ponteiro 8 MOV 1024, R1 ; inicializa contador 12 BEQ +14 ; testa se contador é zero 14 ADD (R2), R0 ; soma com posição de memória 16 ADD #2, R2 ; incrementa ponteiro 20 SUB #1, R1 ; decrementa contador 24 JMP 12 ; retorna ao início do laço 28 MOV R0, 1028 ; atualiza total 32 HLT 1024 n número de posições 1026 e endereço inicial 1028 total

Implementação Cesar• Tradução literal de cada instrução

Endereço Instrução 0 CLR R0 ; inicializa (zera) o total 2 MOV 1026, R2 ; inicializa ponteiro 6 MOV 1024, R1 ; inicializa contador 10 BEQ +10 ; testa se contador é zero 12 ADD (R2), R0 ; soma com posição de memória 14 ADD #2, R2 ; incrementa ponteiro 18 DEC R1 ; decrementa contador 20 BR -12 ; retorna ao início do laço 22 MOV R0, 1028 ; atualiza total 26 HLT 1024 n número de posições 1026 e endereço inicial 1028 total

Implementação Cesar• Usando instruções específicas do Cesar

Endereço Instrução 0 CLR R0 ; inicializa (zera) o total 2 MOV 1026, R2 ; inicializa ponteiro 6 MOV 1024, R1 ; inicializa contador 10 BEQ +10 ; testa se contador é zero 12 ADD (R2), R0 ; soma com posição de memória 14 ADD #2, R2 ; incrementa ponteiro 18 DEC R1 ; decrementa contador 20 BNE -10 ; retorna ao início do laço 22 MOV R0, 1028 ; atualiza total 26 HLT 1024 n número de posições 1026 e endereço inicial 1028 total

Implementação Cesar• Usando instruções específicas do Cesar

Endereço Instrução 0 CLR R0 ; inicializa (zera) o total 2 MOV 1026, R2 ; inicializa ponteiro 6 MOV 1024, R1 ; inicializa contador 10 BEQ +6 ; testa se contador é zero 12 ADD (R2)+, R0 ; soma com posição de memória ; e incrementa ponteiro 14 DEC R1 ; decrementa contador 16 BR -14 ; retorna ao início do laço 18 MOV R0, 1028 ; atualiza total 22 HLT 1024 n número de posições 1026 e endereço inicial 1028 total

Implementação Cesar• Usando endereçamento pós incrementado

Endereço Instrução 0 CLR R0 ; inicializa (zera) o total 2 MOV 1026, R2 ; inicializa ponteiro 6 MOV 1024, R1 ; inicializa contador 10 BEQ +4 ; testa se contador é zero 12 ADD (R2)+, R0 ; soma com posição de memória ; e incrementa ponteiro 14 SOB R1, 4 ; decrementa contador ; retorna ao início do laço 16 MOV R0, 1028 ; atualiza total 20 HLT 1024 n número de posições 1026 e endereço inicial 1028 total

Implementação Cesar• Usando instrução SOB

Soma de variáveis de 32 bits

MOV 1026, R0 ; Bits menos significativos da primeira variávelADD 1030, R0 ; Soma com bits menos significativos da segunda variávelMOV R0, 1034 ; Salva resultado da soma (nos bits menos significativos )MOV #0, R0 ; Zera o registrador R0 (prepara para receber o carry)ADC R0 ; Soma o carry da soma anteriorADD 1024, R0 ; Soma com bits mais significativos da primeira variávelADD 1028, R0 ; Soma com bits mais significativos da segunda variávelMOV R0, 1032 ; Salva o resultado (bits mais significativos)HLT

RDM

R E M

MEM

UAL

X Y

Unidade de Controle

Sinais de Controle para a UCP

carga REM

carga RDM

read

write

s1

RI

carga RI

DECOD.

carry in

carga liga

desliga V N C Z

sel reg

read reg

write regReg. Gerais e

Temporário

ZN CV

carga RauxRaux

• Movimento de blocos de n posições: faça um programa para mover (sem zerar a origem) um número qualquer de posições consecutivas na memória. O número de posições é determinado pelo conteúdo da posição 1024 de memória, a posição inicial do bloco de memória a ser movido é dada pelo conteúdo da posição 1026 de memória e o endereço inicial do bloco de destino é dado pela posição 1028.

– posição 1024: número de posições

– posição 1026: posição inicial da origem

– posição 1028: posição inicial do destino

MOV 1024, R0 ; Tamanho do bloco (em palavras)

MOV 1026, R1 ; Endereço inicial da origem

MOV 1028, R2 ; Endereço inicial do destino

CMP R2, R1 ; Compara endereço de destino com o de origem

BGT 5 ; Desvia de end.destino > end.origem

MOV (R1)+, (R2)+ ; Move uma palavra no sentido crescente

SOB R0, 4 ; Laço para mover toda a área

HLT ; Fim do programa

ASL R0 ; Multiplica tamanho por dois (obtém tamanho em bytes)

ADD R0, R1 ; Endereço final da origem (+ 2 bytes)

ADD R0, R2 ; Endereço final do destino (+ 2 bytes)

MOV 1024, R0 ; Restaura tamanho para palavras

MOV -(R1), -(R2) ; Move uma palavra, no sentido decrescente

SOB R0, 4 ; Laço para mover toda a área

HLT

Pesquisa em vetores: faça um programa para determinar o maior valor armazenado em um vetor (array). O tamanho do vetor é determinado pelo conteúdo da posição 1024 de memória e a posição inicial do vetor é dada pelo conteúdo da posição 1026. O maior valor encontrado deve ser colocado na posição 1028, e a posição relativa desse valor no vetor (1º, 2º, ..., n-ésimo) na posição 1030.

– posição 1024: número de posições (tamanho do vetor)

– posição 1026: posição inicial do vetor

– posição 1028: resultado: maior valor encontrado

– posição 1030: resultado: posição relativa do maior valor

MOV 1024, R0 ; Tamanho do vetor (em palavras)MOV 1026, R1 ; Endereço inicial do vetorMOV (R1)+, R2 ; Inicializa o primeiro elemento como sendo o maiorMOV R0, R3 ; Inicializa R3 com o índice (“tamanho”) do maior elementoDEC R0 ; Inicializa contador (tamanho – 1)CMP (R1), R2 ; Compara um elemento com o maior atualBLE 4 ; Desvia se for menor ou igualMOV (R1), R2 ; Se for maior, atualiza R2MOV R0, R3 ; Salva índice do novo maior valor (“contador atual”)ADD #2, R1 ; Em qualquer caso, incrementa ponteiroSOB R0, 14; Controle do laçoMOV R2, 1028 ; Fornece maior valor encontradoMOV 1024, R4 ; Calcula índice do maior valorSUB R3, R4 ; índice = tamanho – contador + 1INC R4 ; índice = mem(1024) – R3 + 1MOV R4, 1030 ; Fornece o índice do maior valorHLT

• Alteração de bits: escreva um programa que zere (clear) ou ligue (set) um bit qualquer de uma palavra qualquer da memória, conforme indicado por um parâmetro na memória.

– posição 1024: endereço da palavra a ser alterada

– posição 1026: posição do bit a ser alterado (0 é o lsb)

– posição 1028: conteúdo = 0, para zerar

conteúdo = 1, para ligar

MOV 1026, R1 ; Obtém índice do bit a ser alteradoJSR R7, 100 ; Chama a subrotina de geração da máscaraTST 1028 ; Testa se o bit deve ser ligado ou desligadoBEQ 6 ; Deve ser desligadoOR R0, 1024 ; Deve ser ligado, usar ORBR 6 ; Vai para o fim do programaNOT R0 ; Desligar bit: inverte a máscaraAND R0, 1024 ; Desliga o bit usando ANDHLT

No endereço 100:MOV #1, R0 ; R0 contém a máscara (inicializada com 0000000000000001)TST R1 ; R1 contém o índice do bit a ser isolado (0 é o bit menos sign.)BEQ 4 ; Se o índice é zero, a máscara está prontaASL R0 ; Desloca o bit da máscara para esquerdaSOB R1, 4 ; Decrementa o índice e desloca a máscara até o índice ser zeroRTS R7 ; Retorna ao programa principal (máscara em R0)

Documents

CESAR (As bases da civilização atual). Cesar - características Largura de dados e endereços de 16 bits Dados representados em complemento de dois 8 registradores