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
RT
WT, RT,
DT
AC[12]
WAC,
RR, RL
s
r
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-8
DB7-0
8 4
IR11-8
IR7-0
Cout
SC,
CC
Z
C
Z
C
TPC
TIR
TSP
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: instrucciones
ROR y ROL
AC[12]
WAC,
RR, RL
r
ALU
C
ZAC,
RAC,
CIM Cout
SC,
CC
C
AC[12]
WAC,
RR, RL
r
ALU
C
ZAC,
RAC,
CIM Cout
SC,
CC
C
Ejemplo:
C=1, AC11-0=011101110111
ROL ↓
C=0, AC11-0=111011101111
C=1, AC11-0=011101110111
ROR ↓
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
RT
WT, RT,
DT
12
R W
AB
DB
RAM
28x12
Z
RT
WT, RT,
DT
12
R W
AB
DB
RAM
28x12
Z
88

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 elemento
PUSH
SP SP – 1
RAM(SP) pN+1
Extraer un elemento
PULL
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 subrutina
RTS = instrucción de retorno de subrutina
Memoria
$2A
$29
$2B
$2C RTS
subrutina
SP $00
JSR $29
$01
1. Salto a subrutina en $29,
guardando la dirección de
retorno $03 en la pila
2. Ejecución de la subrutina
3. 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

En el CS2:
Memoria
$2A
$29
$2B
$2C
PC
RTS
subrutina
JSR $29
$00
$01
$02
$03
$003
$FE
SP $FF

En el CS2:
Memoria
$2A
$29
$2B
$2CPC RTS
subrutina
JSR $29
$00
$01
$02
$03
$003
$FE
SP $FF

CS2: UD. Pila. Subrutinas: llamada y retorno (fin)
En el CS2:
Memoria
$2A
$29
$2B
$2C RTS
subrutina
SP $00
JSR $29
$01
$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
subr1
$FD
$3C
RTS
subr2
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
subr1
JSR $3C$2A
$2B
$2C
JSR $29
SP $FF
$FE
$00
$02
$01
$03
$FD
$3C
RTS
subr2
$003
Prog.
JSR $3C
RTS
JSR $29
RTS

Memoria
$29
PC
RTS
subr1
JSR $3C$2A
$2B
$2C
JSR $29
SP $FF
$FE
$00
$02
$01
$03
$FD
$3C
RTS
subr2
$003
Prog.
JSR $3C
RTS
JSR $29
RTS

Memoria
JSR $29
SP
$FF
$FE
$00
$02
$01
$03
$29
PC
RTS
subr1
$FD
$3C
RTS
subr2
JSR $3C
$003
$2A
$2B
$2C
$02B
Prog.
JSR $3C
RTS
JSR $29
RTS

Memoria
$29
PC
RTS
subr1
JSR $3C$2A
$2B
$2C
JSR $29
SP $FF
$FE
$00
$02
$01
$03
$FD
$3C
RTS
subr2
$003
$02B
Prog.
JSR $3C
RTS
JSR $29
RTS

Memoria
$29
PC RTS
subr1
JSR $3C$2A
$2B
$2C
JSR $29
SP $FF
$FE
$00
$02
$01
$03
$FD
$3C
RTS
subr2
$003
$02B
Prog.
JSR $3C
RTS
JSR $29
RTS

JSR $29
SP
$FF
$FE
Memoria
$00
$02
$01
$03
$29
PC
RTS
subr1
$FD
$3C
RTS
subr2
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.

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
operando
M(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
$9F
direcció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úsqueda
Operación Nivel RT Señales de control
(cualquiera) 1. MAR ← PC
2. IR ← RAM;
PC ← PC + 1
TPC
R, 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ón
LAIM dato
AC ← dato
1. RT ← 011-8 IR7-0 ; AC ← 0
2. AC ← AC + RT
R8, CIM, WT, ZAC
RT, s, WAC
LDA dir
AC ← M(dir)
1. MAR ← IR
2. RT ← RAM; AC ← 0
3. AC ← AC + RT
TIR
ZAC, WT, R
RT, s, WAC
STA dir
M(dir) ← AC
1. MAR ← IR
2. RAM ← AC
TIR
RAC, W
ADD dir
AC ← AC + M(dir)
1. MAR ← IR
2. RT ← RAM
3. AC ← AC + RT
TIR
WT, R
RT, s, WAC
SUB dir
AC ← AC – M(dir)
1. MAR ← IR
2. RT ← RAM
3. AC ← AC – RT
TIR
WT, R
RT, r, WAC
ADDI punt
AC ← AC + M(M7-0(punt))
1. MAR ← IR
2. IR7-0 ← RAM7-0
3. MAR ← IR
4. RT ← RAM
5. AC ← AC + RT
TIR
R, W8
TIR
R, WT
RT, s, WAC
ROR
AC ← SHR(AC, C)
1. AC ← SHR(AC, C);
C ← AC0
RR
ROL
AC ← SHL(AC, C)
1. AC ← SHR(AC, C);
C ← AC11
RL

CS2: Instrucciones. Desarrollo en µops (3)
Fase de ejecución
JMP dir
PC ← dir
1. PC ← IR7-0 R8, WPC
BCS dir
C: PC ← dir
1. C: PC ← IR7-0 R8, WPC
DBZ dir
M(dir) ← M(dir) - 1
Z: PC ← PC+1
1. MAR ← IR7-0
2. RT ← RAM
3. RT ← RT – 1
4. RAM ← RT;
Z: PC ← PC + 1
TIR
R, WT
DT
RT, W, IPC
CLC
C ← 0
1. C ← 0 CC
SEC
C ← 1
1. C ← 1 SC
STOP NOP -
JSR dir
SP ← SP – 1
M(SP) ← PC
PC ← dir
1. SP ← SP – 1
2. MAR ← SP
3. RAM ← PC
4. PC ← IR7-0
DS
TSP
RPC, W
R8, WPC
RTS
PC ← M(SP)
SP ← SP + 1
1. MAR ← SP
2. PC ← RAM;
SP ← SP + 1
TSP
R, 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
RT
WT, 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 W
TPC,
TIR,
TSP
8
8 12
8
DB11-8
4
IR11-84
TPC
TIR
TSP
s
r
CIM
Xs
PC $05
Z
C
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
RT
WT, 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 W
TPC,
TIR,
TSP
8
8 12
8
DB11-8
4
IR11-84
TPC
TIR
TSP
s
r
CIM
Xs
Z
C
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
RT
WT, 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
TIR
TSP
s
r
CIM
Xs
Z
C
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
RT
WT, 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
TIR
TSP
s
r
CIM
Xs
Z
C
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
RT
WT, 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
TIR
TSP
s
r
CIM
Xs
Z
C
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
RT
WT, 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 W
TPC,
TIR,
TSP
8
8 12
8
DB11-8
Esta
instrucción
no es
ejecutada
4
IR11-84
TPC
TIR
TSP
s
r
CIM
Xs
Z
C
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
RT
WT, 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
TIR
TSP
s
r
CIM
Xs
Z
C
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
RT
WT, 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
TIR
TSP
s
r
CIM
Xs
Z
C
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
RT
WT, 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 W
TPC,
TIR,
TSP
8
8 12
8
DB11-8
4
IR11-84
TPC
TIR
TSP
s
r
CIM
Xs
Z
C
ZAC,
RAC,

CS2: Programación. Ensamblador
mi_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 $A0
equ MD $A1
equ MR $A2
laim 25
sta MD
laim 12
sta MR
jsr mult
stop
mult: laim $00
sta RES
bucle: lda RES
add MD
sta RES
dbz MR
jmp bucle
rts
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.txt
Etiquetas
de datos:
constantes
o
direcciones
de variables
en memoria
equ RES $A0
equ MD $A1
equ MR $A2
laim 25
sta MD
laim 12
sta MR
jsr mult
stop
mult: laim $00
sta RES
bucle: lda RES
add MD
sta RES
dbz MR
jmp bucle
rts
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 ← 0
hacer
R ← R + MD
MR ← MR - 1
mientras MR ≠ 0
fin mult
Código máquina Mnemónicos Ensamblador

CS2: Programación. Especificación de programas (2)
100010101
001010100
101010101
000011110
001010100
101010010
101010100
001111111
000101010
Código
máquina
Compilador Ensamblador
Pseudocódigo/
Lenguaje de
programación
MD ← 25
MR ← 12
R ← mult(MD,MR)
fin
subr mult(MD,MR) dev R
R ← 0
hacer
R ← R + MD
MR ← MR - 1
mientras MR ≠ 0
fin mult
Ensamblador
equ RES $A0
equ MD $A1
equ MR $A2
laim $19
sta MD
laim $0C
sta MR
jsr mult
stop
mult: laim $00
sta RES
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 entrada
R1, R2, ... = parámetros de salida
Nota: 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 ← 0
hacer
SUMA ← SUMA + PUNT[]
si (carry)
terminar
fsi
PUNT ← PUNT – 1
CONT ← CONT - 1
mientras CONT ≠ 0
fin
pseudocódigo
Solució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 fsi
PUNT ← PUNT – 1
CONT ← CONT - 1
mientras CONT ≠ 0
fin
equ SUMA $BB
equ CONT $AA
equ PUNT $AB
laim 16
sta CONT
laim $DF
sta PUNT
laim 0
sta SUMA
bucle:
lda SUMA
addi PUNT
sta SUMA
bcs terminar
dbz PUNT
dbz CONT
jmp 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 $BB
equ CONT $AA
equ PUNT $AB
laim 16
sta CONT
laim $DF
sta PUNT
laim 0
sta SUMA
bucle:
lda SUMA
addi PUNT
sta SUMA
bcs terminar
dbz PUNT
dbz CONT
jmp bucle
terminar:
stop
equ SUMA $BB
equ CONT $AA
equ PUNT $AB
laim 16
sta CONT
laim $DF
sta PUNT
laim 0
bucle:
addi PUNT
bcs terminar
dbz PUNT
dbz CONT
jmp bucle
terminar:
sta SUMA
stop

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

Más contenido relacionado

La actualidad más candente (20)

Destacado (20)

Similar a PDF ing. sumoso 15-5-2015 Etc2 0304 cs2 (20)

Más de Jose Bondia (13)

Último (20)

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