PDF ing. sumoso 15-5-2015 Etc2 0304 cs2

CS2: Unidad de datos (UD)

Cambios respecto al CS1:

• Ancho datos: 12 bits

• Ancho direcciones:

8 bits

• Rotación del registro AC con carry

• Decremento y detección de cero en RT

• PC accesible desde el bus de datos

• Puntero de pila

RTWT, RT,

DT

AC[12]

WAC, RR, RL

sr

ALU

12

8

R W

AB

DB

RAM 28x12

CONTROLXs

IR[12]

4

8

W4, W8, R8

MAR[8]TPC, TIR, TSP

PC[8]

8

CLPC, IPC,

WPC, RPC

C

SP[8]

8

CLS, DS,IS

ZAC,RAC,

0000

4

CIM

DB11-8

DB11-8DB7-0

8 4

IR11-8

IR7-0

Cout

SC,CC

Z

C

ZC

TPC TIRTSP

DB7-08

CS2: UD. Cambios relacionados con el registro AC

• Ahora es un registro universal, permitiendo desplazamientos en ambos sentidos (RR, RL)

• Sus entradas y salidas serie están conectadas al biestable C

• Al activar las señales de desplazamiento RR ó RL, lo que se produce es una rotación del contenido de AC con C: instruccionesROR y ROL

AC[12]

WAC, RR, RL

rALU

C

ZAC,RAC,

CIM Cout

SC,CC

C

AC[12]

WAC, RR, RL

rALU

C

ZAC,RAC,

CIM Cout

SC,CC

C

Ejemplo:C=1, AC11-0=011101110111

ROL ↓C=0, AC11-0=111011101111

C=1, AC11-0=011101110111ROR ↓

C=1, AC11-0=101110111011

• El biestable C almacena el carry generado en las operaciones realizadas con la ALU, y también puede ser puesto a 0 ó 1 (CC, SC) en cualquier momento: instrucciones CLC y SEC

CS2: UD. Cambios relacionados con el registro RT

• En el CS2 es un contador descendente: incorpora una entrada de decremento (DT) y una salida de borrow (Z) [detección de 0]

• Sus salidas está conectadas al bus de datos, por lo que puede escribir a memoria (además de leer desde ella, que ya era posible en el CS1)

• Por tanto, permite decrementar datos almacenados en memoria

• Instrucción DBZ dir_dato

RTWT, RT,

DT

12

R W

AB

DB

RAM 28x12

Z

RTWT, RT,

DT

12

R W

AB

DB

RAM 28x12

Z88

CS2: UD. Cambios relacionados con el registro PC

• El registro PC (Program Counter), al igual que en el CS1, contiene la dirección de la próxima instrucción a ejecutar

• En el CS2 las direcciones son de 8 bits, por lo que el PC ha tenido que ser redimensionado a ese tamaño

• El PC se incrementa automáticamente en la fase de búsqueda de cada instrucción, al igual que en el CS1

• Además, en el CS2, el valor del PC puede ser modificado desde el bus de datos, en particular, desde IR7-0

• Esto permite romper la ejecución secuencial de instrucciones y saltar a cualquier punto del programa

• instrucción de salto incondicional: JMP dir_destino

• instrucción de salto condicional (carry = 1): BCS dir_destino

CS2: UD. Registro SP. La pila (stack)

• La pila es una estructura de datos que reside en memoria

• El registro SP (Stack Pointer, puntero de pila) apunta a la cima de la pila

• En el CS2, la pila crece desde la dirección más alta ($FF) hacia direcciones más bajas

• Operaciones sobre la pila:

• PUSH: añadir un elemento en la cima de la pila

• PULL: extraer el elemento situado en la cima de la pila

• La pila permite los saltos y retornos de subrutinas: en el CS2, éste es el único uso que se hace de ella, instrucciones JSR y RTS

CS2: UD. Pila. Operaciones

Añadir un elementoPUSH

SP SP – 1RAM(SP) pN+1

Extraer un elementoPULL

pN RAM(SP)SP SP + 1

p1

p2

pN

pN-1

pN+1SP

$FF$FE

p1

p2

pN

pN-1SP

$FF$FE

Memoria

Memoria

p1

p2

pN

pN-1

SP

$FF$FE

Memoria

CS2: UD. Pila. Subrutinas

• Una subrutina es una secuencia de instrucciones que realizan una cierta tarea a partir de unos datos de entrada, generando unos datos de salida

• Cuando un programa necesita realizar la tarea, hace una llamada a la subrutina, ésta se ejecuta y cuando termina, el programa se reanuda por donde se había quedado (retorno de subrutina)• Una subrutina se puede llamar todas las veces que el programa lo necesite

• Una subrutina puede llamar a su vez a otra subrutina: ejecución anidada de subrutinas

• Una subrutina puede llamarse a sí misma: subrutinas recursivas

tarea

tarea

tarea

tarea

Programa principal

Subrutina

Programa (sin uso de subrutinas)

...llamada a subr...

...llamada a subr...llamada a subr...

...retorno

tarea

tarea

tarea

tarea

Programa principal

Subrutina

Programa (sin uso de subrutinas)

...llamada a subr...

...llamada a subr...llamada a subr...

...retorno

CS2: UD. Pila. Subrutinas: llamada y retorno (1)

En el CS2:JSR = instrucción de salto a subrutinaRTS = instrucción de retorno de subrutina

Memoria

$2A

$29

$2B

$2C RTSsubr

uti

na

SP $00

JSR $29

$011. Salto a subrutina en $29,guardando la dirección de retorno $03 en la pila

2. Ejecución de la subrutina3. Retorno al programa principal,

extrayendo la dirección de retorno desde la pila

PC $02

$03

Para que el CS2, tras la ejecución de la subrutina, pueda volver al programa principal, debe almacenar la dirección de retorno($03, en este caso) antes de efectuar el salto: para ello se usa la pila

$FE

$FF



Memoria

$2A

$29

$2B

$2C

PC

RTSsubr

uti

na

JSR $29

$00




$02

$03

$003

$FE

SP $FF



Memoria

$2A

$29

$2B

$2C

PC

RTSsubr

uti

na

JSR $29

$00




$02

$03

$003

$FE

SP $FF



Memoria

$2A

$29

$2B

$2C

PCRTSsu

bru

tin

a

JSR $29

$00




$02

$03

$003

$FE

SP $FF



Memoria

$2A

$29

$2B

$2CPC RTSsubr

uti

na

JSR $29

$00




$02

$03

$003

$FE

SP $FF

CS2: UD. Pila. Subrutinas: llamada y retorno (fin)


Memoria

$2A

$29

$2B

$2C RTSsubr

uti

na

SP $00

JSR $29




$02

PC $03

$003

$FE

$FF

CS2: UD. Pila. Subrutinas: subrutinas anidadas

JSR $29

SP

$FF$FE

Memoria$00

$02$01

$03

$29

PC

RTS

subr

1

$FD

$3C

RTS

subr

2

JSR $3C$2A$2B$2C

Prog. principal Subrutina 1 Subrutina 2

JSR $3C

RTS

JSR $29

RTS

CS2: UD. Pila. Subrutinas: subrutinas anidadas (2)

Memoria

$29PC

RTS

subr

1 JSR $3C$2A$2B$2C

JSR $29

SP $FF$FE

$00

$02$01

$03

$FD

$3C

RTS

subr

2

$003


JSR $3C

RTS

JSR $29

RTS


Memoria

$29PC

RTS

subr

1 JSR $3C$2A$2B$2C

JSR $29

SP $FF$FE

$00

$02$01

$03

$FD

$3C

RTS

subr

2

$003


JSR $3C

RTS

JSR $29

RTS


Memoria

JSR $29

SP$FF$FE

$00

$02$01

$03

$29

PC

RTS

subr

1

$FD

$3C

RTS

subr

2

JSR $3C

$003

$2A$2B$2C

$02B


JSR $3C

RTS

JSR $29

RTS


Memoria

JSR $29

SP$FF$FE

$00

$02$01

$03

$29

PC

RTS

subr

1

$FD

$3C

RTS

subr

2

JSR $3C

$003

$2A$2B$2C

$02B


JSR $3C

RTS

JSR $29

RTS


Memoria

$29

PCRTS

subr

1 JSR $3C$2A$2B$2C

JSR $29

SP $FF$FE

$00

$02$01

$03

$FD

$3C

RTS

subr

2

$003$02B


JSR $3C

RTS

JSR $29

RTS


Memoria

$29

PC RTS

subr

1 JSR $3C$2A$2B$2C

JSR $29

SP $FF$FE

$00

$02$01

$03

$FD

$3C

RTS

subr

2

$003$02B


JSR $3C

RTS

JSR $29

RTS


JSR $29

SP

$FF$FE

Memoria$00

$02$01

$03

$29

PC

RTS

subr

1

$FD

$3C

RTS

subr

2

JSR $3C

JSR $29

JSR $3C

RTS

RTS

$003

$2A$2B$2C

$02B • La ejecución anidada de subrutinas es posible gracias a la pila (íd. recursiva)


CS2: Instrucciones. Conjunto de instrucciones(*) Nótese que el registro PC es incrementado durante la fase de búsqueda de la instrucción (al igual que el CS1), por lo que, al comenzar la fase de ejecución, PC estáapuntando a la siguiente instrucción.

M = RAM C = bit de carry - = no importa

El modo de direccionamiento(Direcc.) de una instrucción indica cómo ésta referencia al operando. Según el modo, los bits A7-0 del código de instrucción pueden indicar:

• Inmediato: A7-0 ≡ dato = operando (8 bits)

• Directo:A7-0 ≡ dir (dirección del operando)M(dir) = operando (12 bits)

• Indirecto:A7-0 ≡ punt (puntero al operando)M7-0(punt) = dirección del operandoM(M7-0(punt)) = operando (12 bits)

Instrucción Mnemónico Operación Tipo Direcc. Descripción

0000 A7 ... A0 LAIM dato AC ← dato Transf. Inmediato Carga AC con valor inmediato

0001 A7 ... A0 LDA dir AC ← M(dir) Transf. Directo Carga AC desde RAM

0010 A7 ... A0 STA dir M(dir) ← AC Transf. Directo Almacena AC en RAM

0011 A7 ... A0 ADD dir AC ← AC + M(dir) Aritm. Directo Suma

0100 A7 ... A0 SUB dir AC ← AC – M(dir) Aritm. Directo Resta

0101 A7 ... A0 ADDI punt AC ← AC + M(M7-0(punt)) Aritm. Indirecto Suma indirecta

0110 -------- ROR AC ← SHR(AC, C), C ← AC0 Lógica Implícito Rotación a la dch. con carry

0111 -------- ROL C ← AC11, AC ← SHL(AC, C) Lógica Implícito Rotación a la izq. con carry

1000 A7 ... A0 JMP dir PC ← dir Salto

incond.

Directo Salto incondicional

1001 A7 ... A0 BCS dir C: PC ← dir Salto

cond.

Directo Salto condicional si carry

1010 A7 ... A0 DBZ dir M(dir) ← M(dir) – 1

Z: PC ← PC+1 (*)

Salto

cond.

Directo Salto condicional si cero

(bit Z)

1011 -------- CLC C ← 0 Estado Implícito Pone carry a 0

1100 -------- SEC C ← 1 Estado Implícito Pone carry a 1

1101 -------- STOP Control Implícito Detiene la ejecución

1110 A7 ... A0 JSR dir SP ← SP – 1

M(SP) ← PC (*)

PC ← dir

Salto Directo Salto a subrutina

1111 -------- RTS PC ← M(SP)

SP ← SP + 1

Salto Implícito Retorno de subrutina

CS2: Instrucciones. Modos de direccionamiento

• Inmediato: • el dato (operando) está incluido en la propia instrucción

LAIM $9FPC

Memoria

CO CD$9FLAIM

instrucción

dato

AC ← $9FLAIM $9F

CS2: Instrucciones. Modos de direccionamiento (2)

$9F

• Directo: • hay que buscar el dato (operando) en la memoria; • la instrucción incluye la dirección del dato

$A2

ADD $9FPC

Memoria

$9Fdirección del dato

dato

CO CD$9FADD

instrucción

AC ← AC + $A2ADD $9F


$9F$9F

• Indirecto: • hay que buscar el dato (operando) en la memoria; • la instrucción incluye un puntero al dato

$A2

ADDI $9FPC

Memoria

$9Fpuntero

dato

CO CD$9FADDI

instrucción

$1C$A2

dirección del dato

$A2

AC ← AC + $1CADDI $9F


• Implícito: • el dato (operando) se sobreentiende, no está almacenado en ningún sitio

CLCPC

Memoria

CO CD--CLC

instrucción

C ← 0CLC

CS2: Instrucciones. Desarrollo en µops

Fase de búsquedaOperación Nivel RT Señales de control(cualquiera) 1. MAR ← PC

2. IR ← RAM; PC ← PC + 1

TPCR, W4, W8, IPC

Tras la fase de búsqueda: • IR11-8 contiene el código de operación de la instrucción• IR7-0 puede contener, según el tipo de direccionamiento de la instrucción:

• el operando (direccionamiento inmediato, IR7-0 ≡ dato de 8 bits)• la dirección del operando (direccionamiento directo, IR7-0 ≡ dir)• un puntero al operando (direccionamiento indirecto, IR7-0 ≡ punt)

CS2: Instrucciones. Desarrollo en µops (2)

Fase de ejecuciónOperación Nivel RT Señales de controlLAIM dato

AC ← dato1. RT ← 011-8 IR7-0 ; AC ← 02. AC ← AC + RT

R8, CIM, WT, ZACRT, s, WAC

LDA dirAC ← M(dir)

1. MAR ← IR2. RT ← RAM; AC ← 03. AC ← AC + RT

TIRZAC, WT, RRT, s, WAC

STA dirM(dir) ← AC

1. MAR ← IR2. RAM ← AC

TIRRAC, W

ADD dirAC ← AC + M(dir)

1. MAR ← IR2. RT ← RAM3. AC ← AC + RT

TIRWT, RRT, s, WAC

SUB dirAC ← AC – M(dir)

1. MAR ← IR2. RT ← RAM3. AC ← AC – RT

TIRWT, RRT, r, WAC

ADDI puntAC ← AC + M(M7-0(punt))

1. MAR ← IR2. IR7-0 ← RAM7-03. MAR ← IR4. RT ← RAM5. AC ← AC + RT

TIRR, W8TIRR, WTRT, s, WAC

RORAC ← SHR(AC, C)

1. AC ← SHR(AC, C); C ← AC0

RR

ROLAC ← SHL(AC, C)

1. AC ← SHR(AC, C); C ← AC11

RL

CS2: Instrucciones. Desarrollo en µops (3)

Fase de ejecuciónOperación Nivel RT Señales de controlJMP dir

PC ← dir1. PC ← IR7-0 R8, WPC

BCS dir C: PC ← dir

1. C: PC ← IR7-0 R8, WPC

DBZ dir M(dir) ← M(dir) - 1Z: PC ← PC+1

1. MAR ← IR7-02. RT ← RAM3. RT ← RT – 14. RAM ← RT;

Z: PC ← PC + 1

TIRR, WTDTRT, W, IPC

CLCC ← 0

1. C ← 0 CC

SECC ← 1

1. C ← 1 SC

STOP NOP -

JSR dir SP ← SP – 1M(SP) ← PCPC ← dir

1. SP ← SP – 12. MAR ← SP3. RAM ← PC4. PC ← IR7-0

DSTSPRPC, WR8, WPC

RTSPC ← M(SP)SP ← SP + 1

1. MAR ← SP2. PC ← RAM;

SP ← SP + 1

TSPR, WPC, IS

CS2: Instrucciones. Ejecución de DBZ: estado previo

1. MAR ← IR7-0

2. RT ← RAM

3. RT ← RT – 1

4. RAM ← RT; Z: PC ← PC + 1

RTWT, RT,

DT

AC[12]

WAC, RR, RL

ALU

8

AB

DB

RAM 28x12

CONTROL

IR[12]W4, W8, R8

MAR[8]

PC[8]CLPC, IPC,

WPC, RPC

C

SP[8]

8

CLS, DS,IS

0000

DB11-8

DB7-0

8 4IR7-0

Cout

SC,CC

Z

C

DB7-0

$A $A0(DBZ)

$05

$AA0$04

$A0 $001

$06

≡ DBZ $A0$803$D00

R WTPC, TIR, TSP

8

8 12

8

DB11-8

4

IR11-84

TPC TIRTSP s

rCIM

Xs

PC $05

ZC

ZAC,RAC,

CS2: Instrucciones. Ejecución de DBZ: ciclo 1

1. MAR ← IR7-0

2. RT ← RAM

3. RT ← RT – 1

4. RAM ← RT; Z: PC ← PC + 1

RTWT, RT,

DT

AC[12]

WAC, RR, RL

ALU

8

AB

DB

RAM 28x12

CONTROL

IR[12]W4, W8, R8

MAR[8]

CLPC, IPC,

WPC, RPC

C

SP[8]

8

CLS, DS,IS

0000

DB11-8

DB7-0

8 4IR7-0

Cout

SC,CC

Z

C

DB7-0

$04

$A0

PC[8]$05

PC $05

$06

$001

$A $A0(DBZ)

$AA0 ≡ DBZ $A0$803$D00

R WTPC, TIR, TSP

8

8 12

8

DB11-8

4

IR11-84

TPC TIRTSP s

rCIM

Xs

ZC

ZAC,RAC,

CS2: Instrucciones. Ejecución de DBZ: ciclo 2

1. MAR ← IR7-0

2. RT ← RAM

3. RT ← RT – 1

4. RAM ← RT; Z: PC ← PC + 1

RTWT, RT,

DT

AC[12]

WAC, RR, RL

ALU

8

AB

DB

RAM 28x12

CONTROL

IR[12]8

W4, W8, R8

MAR[8]TPC, TIR, TSP

8

CLPC, IPC,

WPC, RPC

C

SP[8]

8

CLS, DS,IS

0000

DB11-8

DB7-0

8 4IR7-0

Cout

SC,CC

Z

C

DB7-08

$A0

$A0

$04

$A0

PC[8]$05

PC $05

$06

$001

$A $A0(DBZ)

$AA0 ≡ DBZ $A0$803$D00

R W

$00112

DB11-8

4

IR11-84

TPC TIRTSP s

rCIM

Xs

ZC

ZAC,RAC,

CS2: Instrucciones. Ejecución de DBZ: ciclo 3 (operando=1)

1. MAR ← IR7-0

2. RT ← RAM

3. RT ← RT – 1

4. RAM ← RT; Z: PC ← PC + 1

RTWT, RT,

DT

AC[12]

WAC, RR, RL

ALU

8

AB

DB

RAM 28x12

CONTROL

IR[12]8

W4, W8, R8

MAR[8]TPC, TIR, TSP

8

CLPC, IPC,

WPC, RPC

C

SP[8]

8

CLS, DS,IS

0000

DB11-8

DB7-0

8 4IR7-0

Cout

SC,CC

Z

C

DB7-08

$001

$A0

$A0

$04

$A0

PC[8]$05

PC $05

$06

$001

$A $A0(DBZ)

$AA0 ≡ DBZ $A0$803$D00

R W

12

DB11-8

4

IR11-84

TPC TIRTSP s

rCIM

Xs

ZC

ZAC,RAC,

CS2: Instrucciones. Ejecución de DBZ: ciclo 4 (operando=1)

1. MAR ← IR7-0

2. RT ← RAM

3. RT ← RT – 1

4. RAM ← RT; Z: PC ← PC + 1

RTWT, RT,

DT

AC[12]

WAC, RR, RL

ALU

8

AB

DB

RAM 28x12

CONTROL

IR[12]8

W4, W8, R8

MAR[8]TPC, TIR, TSP

8

CLPC, IPC,

WPC, RPC

C

SP[8]

8

CLS, DS,IS

0000

DB11-8

DB7-0

8 4IR7-0

Cout

SC,CC

Z

C

DB7-08

$000

$A0

$A0

$04

$A0

PC[8]$05

PC $05

$06

$001

$A $A0(DBZ)

$AA0 ≡ DBZ $A0$803$D00

R W

$00012

DB11-8

4

IR11-84

TPC TIRTSP s

rCIM

Xs

ZC

ZAC,RAC,

CS2: Instrucciones. Ejecución de DBZ: final (operando=1)

1. MAR ← IR7-0

2. RT ← RAM

3. RT ← RT – 1

4. RAM ← RT; Z: PC ← PC + 1

RTWT, RT,

DT

AC[12]

WAC, RR, RL

ALU

8

AB

DB

RAM 28x12

CONTROL

IR[12]W4, W8, R8

MAR[8]

CLPC, IPC,

WPC, RPC

C

SP[8]

8

CLS, DS,IS

0000

DB11-8

DB7-0

8 4IR7-0

Cout

SC,CC

Z

C

DB7-0

$000

$04

$A0 $000

PC[8]$06

PC

$05

$06

$A $A0(DBZ)

$AA0 ≡ DBZ $A0$803$D00

R WTPC, TIR, TSP

8

8 12

8

DB11-8Esta instrucción

no es ejecutada

4

IR11-84

TPC TIRTSP s

rCIM

Xs

ZC

ZAC,RAC,

CS2: Instrucciones. Ejecución de DBZ: ciclo 3 (operando≠1)

1. MAR ← IR7-0

2. RT ← RAM

3. RT ← RT – 1

4. RAM ← RT; Z: PC ← PC + 1

RTWT, RT,

DT

AC[12]

WAC, RR, RL

ALU

8

AB

DB

RAM 28x12

CONTROL

IR[12]8

W4, W8, R8

MAR[8]TPC, TIR, TSP

8

CLPC, IPC,

WPC, RPC

C

SP[8]

8

CLS, DS,IS

0000

DB11-8

DB7-0

8 4IR7-0

Cout

SC,CC

Z

C

DB7-08

$020

$A0

$A0

$04

$A0

PC[8]$05

PC $05

$06

$020

$A $A0(DBZ)

$AA0 ≡ DBZ $A0$803$D00

R W

12

Si $A0 contuviese un valor distinto a $001, por ejemplo $020:

DB11-8

4

IR11-84

TPC TIRTSP s

rCIM

Xs

ZC

ZAC,RAC,

CS2: Instrucciones. Ejecución de DBZ: ciclo 4 (operando≠1)

1. MAR ← IR7-0

2. RT ← RAM

3. RT ← RT – 1

4. RAM ← RT; Z: PC ← PC + 1

RTWT, RT,

DT

AC[12]

WAC, RR, RL

ALU

8

AB

DB

RAM 28x12

CONTROL

IR[12]8

W4, W8, R8

MAR[8]TPC, TIR, TSP

8

CLPC, IPC,

WPC, RPC

C

SP[8]

8

CLS, DS,IS

0000

DB11-8

DB7-0

8 4IR7-0

Cout

SC,CC

Z

C

DB7-08

$01F

$A0

$A0

$04

$A0 $020

PC[8]$05

PC $05

$06

$A $A0(DBZ)

$AA0 ≡ DBZ $A0$803$D00

R W

12

DB11-8

4

IR11-84

TPC TIRTSP s

rCIM

Xs

ZC

ZAC,RAC,

CS2: Instrucciones. Ejecución de DBZ: final (operando≠1)

1. MAR ← IR7-0

2. RT ← RAM

3. RT ← RT – 1

4. RAM ← RT; Z: PC ← PC + 1

RTWT, RT,

DT

AC[12]

WAC, RR, RL

ALU

8

AB

DB

RAM 28x12

CONTROL

IR[12]W4, W8, R8

MAR[8]

CLPC, IPC,

WPC, RPC

C

SP[8]

8

CLS, DS,IS

0000

DB11-8

DB7-0

8 4IR7-0

Cout

SC,CC

Z

C

DB7-0

$01F

$04

$A0 $01F

PC[8]$05

PC $05

$06

$A $A0(DBZ)

$AA0 ≡ DBZ $A0$803$D00

R WTPC, TIR, TSP

8

8 12

8

DB11-8

4

IR11-84

TPC TIRTSP s

rCIM

Xs

ZC

ZAC,RAC,

CS2: Programación. Ensambladormi_programa.txt

Etiquetas de datos:constantes

o direcciones de variables en memoria

Sección para directivas(palabras reservadas que no son instrucciones) de definición de

etiquetas de datos

equ RES $A0equ MD $A1equ MR $A2

laim 25sta MDlaim 12sta MRjsr multstop

mult: laim $00sta RES

bucle: lda RESadd MDsta RESdbz MRjmp buclerts

Sección del programa principal

Etiquetas de salto:representan direcciones de memoria (destinos de

saltos) Sección para la definición de subrutinas

CS2: Programación. Ensamblador. Directiva equ

mi_programa.txtEtiquetas de datos:constantes

o direcciones de variables en memoria

equ RES $A0equ MD $A1equ MR $A2

laim 25sta MDlaim 12sta MRjsr multstop


bucle: lda RESadd MDsta RESdbz MRjmp buclerts

equ RES $A0

Nombre de la directiva

Etiqueta

ValorEtiquetas de salto:representan direcciones de memoria (destinos de

saltos)

CS2: Programación. Especificación de programas

equ RES $A0

equ MD $A1

equ MR $A2

$019$2A1$00C$2A2$E06$D00$000$2A0$1A0$3A1$2A0$AA2$808$F00

Memoria$00$01$02$03$04$05$06$07$08$09$0A$0B$0C$0D

laim $19

sta $A1

laim $0C

sta $A2

jsr $06

stop

laim $00

sta $A0

lda $A0

add $A1

sta $A0

dbz $A2

jmp $08

rts

laim $19

sta MD

laim $0C

sta MR

jsr mult

stop

mult: laim $00

sta RES

bucle: lda RES

add MD

sta RES

dbz MR

jmp bucle

rts

Pseudocódigo/Lenguaje de programación

MD ← 25

MR ← 12

R ← mult(MD,MR)fin

subr mult(MD,MR) dev R

R ← 0hacer

R ← R + MD

MR ← MR - 1

mientras MR ≠ 0fin mult

Código máquina Mnemónicos Ensamblador

CS2: Programación. Especificación de programas (2)

100010101001010100101010101000011110001010100101010010101010100001111111000101010

Código máquina

Compilador Ensamblador

Pseudocódigo/Lenguaje de

programaciónMD ← 25MR ← 12R ← mult(MD,MR)finsubr mult(MD,MR) dev R

R ← 0hacer

R ← R + MDMR ← MR - 1

mientras MR ≠ 0fin mult

Ensambladorequ RES $A0equ MD $A1equ MR $A2

laim $19sta MDlaim $0Csta MRjsr multstop


bucle: lda RES

This is a workstation.

File Edit View Insert Window About


File Edit View Insert Window AboutThis is a workstation.



File Edit View Insert Window AboutThis is a workstation.








CS2: Programación. Pseudocódigo: asignaciones...

laim C

sta VARIABLE

...

...

VARIABLE ← C

...

C ≡ constante

...

lda VARIABLE2

sta VARIABLE1

...

...

VARIABLE1 ← VARIABLE2

...

...

laim 0

addi PUNTERO

sta VARIABLE

...

...

VARIABLE ← PUNTERO[]

...

PUNTERO[] ≡ dato apuntado por el PUNTERO

CS2: Programación. Pseudocódigo: comparaciones

...

laim 1

add A

sub B

sta TEMP

dbz TEMP

jmp distintos

... {iguales}

jmp seguir

distintos: ... {distintos}

seguir: ...

TEMP ← A – B + 1

TEMP ≠ 0

TEMP ← TEMP – 1 (= A – B),¿TEMP = 0? (≡ ¿A = B?)

TEMP = 0

...

si (A = B)

... {iguales}

sino

... {distintos}

fsi

...

CS2: Programación. Pseudocódigo: comparaciones (2)

...

lda A

sub B

bcs AmenorqB

... {A ≥ B}

jmp seguir

AmenorqB: ... {A < B}

seguir: ...

AC ← A – B, C ← 1 si A – B < 0 (≡ A < B)

¿C = 1? (≡ ¿A < B?)

C = 1 C = 0

...

si (A < B)

... {A < B}

sino

... {A ≥ B}

fsi

...

Nota: válido sólo si A y B son ambos positivos o ambos negativos.

CS2: Programación. Pseudocódigo: bucles

...

laim N

sta CONT

bucle: ... {cuerpo}

dbz CONT

jmp bucle

...

CONT ← N

CONT = 0

CONT ← CONT – 1¿CONT = 0?

CONT ≠ 0

N ≡ número de iteraciones (N > 0)

...

CONT ← N

hacer

... {cuerpo}

CONT ← CONT - 1

mientras (CONT ≠ 0)

...

CS2: Programación. Pseudocódigo: subrutinas

subr NOMBRE(P1,P2,...) dev R1,R2,...

...

fin NOMBRE

Declaración:

NOMBRE:

...

rts

P1, P2, ... = parámetros de entradaR1, R2, ... = parámetros de salidaNota: un parámetro de entrada puede ser también parámetro de salida

...

<R1,R2,...> ← NOMBRE(P1,P2,...)

...

Llamada:...

jsr NOMBRE

...

CS2: Programación. Ejemplo: Suma de 16 sumandos

• Los sumandos están almacenados en $D0 .. $DF• El resultado debe almacenarse en la dirección $BB• En caso de overflow, detener el programa

CONT ← 16

PUNT ← $DF

SUMA ← 0hacer

SUMA ← SUMA + PUNT[]si (carry)

terminar

fsi

PUNT ← PUNT – 1

CONT ← CONT - 1

mientras CONT ≠ 0fin

pseudocódigoSolución:Se plantea como un bucle en el que la variable SUMA ($BB) irá acumulando los sumandos recorridos hasta el momento. Para poder acceder a cada sumando, usamos un puntero PUNT que decrementamos en cada iteración. Su valor inicial será $DF.El número de iteraciones es controlado por la variable contador, CONT.

CS2: Programación. Ej.: Suma de 16 sumandos (2)

ensamblador CS2

CONT ← 16

PUNT ← $DF

SUMA ← 0

hacer

SUMA ← SUMA + PUNT[]si (carry) terminar fsiPUNT ← PUNT – 1CONT ← CONT - 1

mientras CONT ≠ 0

fin

equ SUMA $BBequ CONT $AAequ PUNT $AB

laim 16sta CONTlaim $DFsta PUNTlaim 0sta SUMA

bucle:lda SUMAaddi PUNTsta SUMAbcs terminardbz PUNTdbz CONTjmp bucle

terminar:stop

pseudocódigo

CS2: Programación. Ej.: Suma de 16 sumandos (3)

• Podemos mejorar el programa resultante usando el AC para acumular los sumandos en el bucle en lugar de usar la variable SUMA.

• Únicamente habría que actualizar SUMA al finalizar el bucle, cuando AC contenga la suma de los 16 sumandos.


laim 16sta CONTlaim $DFsta PUNTlaim 0sta SUMA

bucle:lda SUMAaddi PUNTsta SUMAbcs terminardbz PUNTdbz CONTjmp bucle

terminar:

stop


laim 16sta CONTlaim $DFsta PUNTlaim 0

bucle:

addi PUNT

bcs terminardbz PUNTdbz CONTjmp bucle

terminar:sta SUMAstop

Automotive

PDF ing. sumoso 15-5-2015 Etc2 0304 cs2