Download - 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
CS2: UD. Pila. Subrutinas: llamada y retorno (2)
En el CS2:JSR = instrucción de salto a subrutinaRTS = instrucción de retorno de subrutina
Memoria
$2A
$29
$2B
$2C
PC
RTSsubr
uti
na
JSR $29
$00
$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
$02
$03
$003
$FE
SP $FF
CS2: UD. Pila. Subrutinas: llamada y retorno (2)
En el CS2:JSR = instrucción de salto a subrutinaRTS = instrucción de retorno de subrutina
Memoria
$2A
$29
$2B
$2C
PC
RTSsubr
uti
na
JSR $29
$00
$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
$02
$03
$003
$FE
SP $FF
CS2: UD. Pila. Subrutinas: llamada y retorno (2)
En el CS2:JSR = instrucción de salto a subrutinaRTS = instrucción de retorno de subrutina
Memoria
$2A
$29
$2B
$2C
PCRTSsu
bru
tin
a
JSR $29
$00
$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
$02
$03
$003
$FE
SP $FF
CS2: UD. Pila. Subrutinas: llamada y retorno (3)
En el CS2:JSR = instrucción de salto a subrutinaRTS = instrucción de retorno de subrutina
Memoria
$2A
$29
$2B
$2CPC RTSsubr
uti
na
JSR $29
$00
$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
$02
$03
$003
$FE
SP $FF
CS2: UD. Pila. Subrutinas: llamada y retorno (fin)
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
$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
Prog. principal Subrutina 1 Subrutina 2
JSR $3C
RTS
JSR $29
RTS
CS2: UD. Pila. Subrutinas: subrutinas anidadas (3)
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
Prog. principal Subrutina 1 Subrutina 2
JSR $3C
RTS
JSR $29
RTS
CS2: UD. Pila. Subrutinas: subrutinas anidadas (4)
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
Prog. principal Subrutina 1 Subrutina 2
JSR $3C
RTS
JSR $29
RTS
CS2: UD. Pila. Subrutinas: subrutinas anidadas (5)
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
Prog. principal Subrutina 1 Subrutina 2
JSR $3C
RTS
JSR $29
RTS
CS2: UD. Pila. Subrutinas: subrutinas anidadas (6)
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
Prog. principal Subrutina 1 Subrutina 2
JSR $3C
RTS
JSR $29
RTS
CS2: UD. Pila. Subrutinas: subrutinas anidadas (7)
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
Prog. principal Subrutina 1 Subrutina 2
JSR $3C
RTS
JSR $29
RTS
CS2: UD. Pila. Subrutinas: subrutinas anidadas (8)
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)
Prog. principal Subrutina 1 Subrutina 2
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
CS2: Instrucciones. Modos de direccionamiento (3)
$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
CS2: Instrucciones. Modos de direccionamiento (4)
• 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
mult: laim $00sta RES
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
mult: laim $00sta RES
bucle: lda RES
This is a workstation.
File Edit View Insert Window About
This is a workstation.
File Edit View Insert Window AboutThis is a workstation.
File Edit View Insert Window About
This is a workstation.
File Edit View Insert Window AboutThis is a workstation.
File Edit View Insert Window About
This is a workstation.
File Edit View Insert Window About
This is a workstation.
File Edit View Insert Window About
This is a workstation.
File Edit View Insert Window About
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.
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
equ SUMA $BBequ CONT $AAequ PUNT $AB
laim 16sta CONTlaim $DFsta PUNTlaim 0
bucle:
addi PUNT
bcs terminardbz PUNTdbz CONTjmp bucle
terminar:sta SUMAstop