(C) Mario Medina C. 1 Estructura de una CPU 8088

Procesadores Intel x86
Š Familia de microprocesadores desarrollados
por Intel que son la base de los PCs
Arquitectura Intel x86
Sistemas Computacionales
Mario Medina C.
mariomedina@udec.cl
z
Š Procesadores de la familia x86
z
z
z
z
z
z
Leer instrucción de memoria y colocarla en la
CPU (Fetch)
Decodificar la instrucción (Decode) y actualizar el
contador de programa
Ejecutar la instrucción (Execute), devolviendo los
resultados a los registros o a memoria
tienen conjunto básico común de registros
tienen conjunto básico común de instrucciones
mantienen la arquitectura del conjunto de
instrucciones (Instruction Set Architecture)
Estructura de una CPU 8088
Operación básica de un 8088
Š Tres pasos básicos:
Intel 8088 (1980) a Intel Quad Core (2009)
Š EU ejecuta las instrucciones
Š BIU realiza operaciones de bus bajo control de
la EU
z
Lee instrucciones y operandos, escribe resultados
Š Dos unidades internas
z
z
Unidad de ejecución (Execution Unit)
Unidad de interfaz de bus (Bus Interface Unit)
Estructura de una CPU 8088
Estructura de una CPU 8088
Š EU y BIU operan en paralelo
Š Mientras EU procesa una instrucción, la BIU
está leyendo las instrucciones siguientes
z
Almacenadas en una cola de instrucciones de 4
bytes
Š Segmentación del trabajo (pipelining)
z
z
z
Minimiza tiempos de inactividad
Aumenta instrucciones procesadas por unidad de
tiempo
Desacopla la EU del acceso a memoria
(C) Mario Medina C.
1
Bus Interface Unit (BIU)
Š Realiza los accesos a memoria
Š Implementa el modelo de memoria
Š Contiene
z
z
z
z
z
Memoria segmentada de 8088
Š Intel 8088 direcciona memoria física de 1 MiB
z
genera direcciones físicas de 20 bits usando 2
registros de 16 bits
Los registros de segmento CS, DS, SS y ES
Puntero a instrucción IP
Bloque de suma de direcciones ∑
Cola de instrucciones de 4 bytes
Buses de datos internos de 16 bits
Segmentos
Š Decodifica las instrucciones leídas por la BIU
Š Ejecuta las instrucciones
Š Contiene
Š Segmento: bloque de
memoria de 64 KiB
Š 8088 puede direccionar 4
segmentos en un instante
dado
z
z
z
z
Unidad Aritmético-Lógica (ALU)
z
4 registros de datos
z
4 registros punteros e índices
œOperandos de 8 ó 16 bits
œEstos segmentos pueden ser
disjuntos, traslapados o iguales
z
Execution Unit (EU)
œAccesibles como registros de 8 ó 16 bits
CS: Code segment
DS: Data segment
SS: Stack segment
ES: Extra segment
œUsados en operaciones de transferencias de datos
œUsados con registros de segmentos
z
Registros 8088
(C) Mario Medina C.
9 flags o bits de estado y de control
Bits de condición 8088
2
Registros 80386 y posteriores
Tipos de datos Intel x86
Š Palabras (words): 16 bits
Š Registros de
propósito general
extendidos a 32 bits
Š 2 registros de
segmento extras
Š Cola de instrucciones
de 6 instrucciones
Š Más flags de
condición
z
Herencia del 8086
Š Palabras dobles (doublewords): 32 bits
Š Palabras cuádruples (quadwords): 64 bits
Š Instrucción mov: movimiento de datos
z
z
z
movb (move byte)
movw (move word)
movl (move doubleword)
Š Punteros: 32 bits
Registros de 32 bits Intel x86
Š Registros enteros
z
Almacenan datos y
direcciones
Š 8 registros de 32 bits
z
Registro %eax
Š Accesibles como 8
registros de 16 bits
z
Registro %ax
%ax
%ah
%al
%ebx
%bx
%bh
%bl
%ecx
%cx
%ch
%cl
%edx
%dx
%dh
%dl
%esi
%si
%edi
%di
%esp
%sp
%ebp
%bp
Š Ejemplo: addl S, D
z
z
Registros %ah y %al
Formato ensamblador GNU Assembler (GAS)
Partes de una instrucción
œOperación: qué hacer (addl)
œOperandos fuente (S) y destino (D)
Š Suma S + D y almacena resultado en D
z
Š Los 4 primeros son
accesibles como bytes
z
%eax
Instrucciones
Qué son S y D?
œDatos en registros
œConstantes
œDatos en memoria
Modos de Direccionamiento
Š Modo Inmediato
Š Usado para definir constantes
z
z
Formato: $Imm
Valor: Imm
Š Modo Registro
z
z
z
Especifica el registro de 8, 16 ó 32 bits a usar
Formato: Ea
Valor: R[Ea]
Modos de Direccionamiento
Š Modos de direccionamiento a memoria
z
Š Modo Absoluto
z
z
z
Especifica una dirección absoluta de memoria
Formato: Imm
Valor: M[Imm]
Š Modo Indirecto
z
z
z
(C) Mario Medina C.
Indican cómo calcular la dirección efectiva del
operando
Dirección dada por el contenido de un registro
Formato: (Ea)
Valor: M[R[Ea]]
3
Modos de Direccionamiento
Š Modo Indexado
Š Modo Base + Desplazamiento
z
z
z
Modos de Direccionamiento
Útil para acceso a vectores
Formato: Imm(Eb)
Valor: M[Imm + R[Eb]]
z
z
Š Modo Indexado escalado
Š Modo Indexado
z
z
z
Formato: Imm(Eb, Ei)
Valor: M[Imm + R[Eb] + R[Ei]]
z
Dirección se calcula como registro base + índice
Formato: (Eb, Ei)
Valor: M[R[Eb] + R[Ei]]
z
z
s: factor de escala 1, 2, 4 ó 8
Formato: (, Ei, s)
Valor: M[R[Ei]*s]
Š Modo Indexado escalado
z
z
Formato: Imm(, Ei, s)
Valor: M[Imm + R[Ei]*s]
Modos de Direccionamiento
Š Modo Indexado escalado
z
z
Tipo
Formato: (Eb, Ei, s)
Valor: M[R[Eb] + R[Ei]*s]
Š Modo Indexado escalado
z
z
z
Resumen Modos
Modo más complejo
Formato: Imm(Eb, Ei, s)
Valor: M[Imm + R[Eb] + R[Ei]*s]
Formato
Valor operando
Imm
Inmediato
Registro
Ea
R[Ea]
Registro
Memoria
Imm
M[Imm]
Absoluto
Memoria
(Ea)
M[R[Ea]]
Indirecto
Memoria
Imm(Eb)
M[Imm +R[Eb]]
Base + Desp.
Memoria
(Eb, Ei)
M[R[Eb] +R[Ei]]
Indexado
Memoria
Imm(Eb, Ei)
M[Imm +R[Eb] +R[Ei]]
Indexado
Memoria
(, Ei, s)
M[R[Ei]*s]
Indexado escalado
Memoria
Imm(, Ei, s)
M[Imm +R[Ei]*s]
Indexado escalado
Memoria
(Eb, Ei, s)
M[R[Eb] +R[Ei]*s]
Indexado escalado
Memoria
Imm(Eb, Ei, s)
M[Imm+R[Eb]+R[Ei]*s]
Indexado escalado
Ejemplo
Š Dados
Š Evalúe
Dirección
0x100
0x104
0x108
0x10C
Valor
0xFF
0xAB
0x13
0x11
Registro
%eax
%ecx
%edx
Valor
0x100
0x1
0x3
(C) Mario Medina C.
z
z
z
z
z
z
z
z
z
z
%eax
0x104
$0x108
(%eax)
4(%eax)
9(%eax, %edx)
260(%ecx, %edx)
0xFC(,%ecx, 4)
(%eax, %ecx, 4)
2(%eax, %ecx, 2)
Nombre
Inmediato $Imm
Movimiento de datos
Š Operando fuente S
z
z
z
Inmediato
Registro
Memoria
Š Operando destino D
z
z
Registro
Memoria
Š No se pueden mover
datos entre posiciones
de memoria
z
z
Memoria a registro
Registro a memoria
Š movl S, D
z
z
Mueve doubleword
D ←S
Š movw S, D
z
z
Mueve word
D ←S
Š movb S, D
z
z
Mueve byte
D ←S
Š Instrucciones no
modifican otros bits
4
Movimiento de datos
Š Instrucciones de manejo
Š movsbl S, D
de pila
Mueve byte extendido en
signo
Š pushl S
œCopia bit 7 en bits 31-8
z Almacena S en la pila
z D ←SignExtend(S)
z R[%esp] ← R[%esp]-4
Š movzbl S, D
z M[R[%esp]] ←S
z Mueve byte extendido a
Š
popl
D
cero
z Retira D de la pila
œBits 31-8 son 0
z D← M[R[%esp]]
z D ←ZeroExtend(S)
z R[%esp] ← R[%esp]+4
z
Pila del procesador
Š Área de memoria utilizada para almacenar y
recuperar rápidamente datos
Š Vital para manejo de funciones
Š Acceso via instrucciones especiales popl y
pushl
Š Indexada por registro dedicado %esp
Š Crece hacia direcciones bajas de memoria
Pila y registro “Stack Pointer”
Ejemplo: exchange()
Š Código C
Inicialmente
Direcciones
de Memoria
%eax
0x123
%edx
0
%esp
0x108
pushl %eax
%eax
%edx
%esp
popl %edx
0x123
0
0x104
%eax
%edx
%esp
0x123
0x123
0x108
Comienzo de pila
Comienzo de pila
Comienzo de pila
•
•
•
•
•
•
•
•
•
0x108
0x108
Tope de pila
0x104
0x108
0x123
Tope de pila
0x123
int exchange(int *xp, int y){
int x = *xp;
*xp = y;
return x;
}
Š Código intercambia dato apuntado por xp y dato
contenido por y
Š Código utiliza variable intermedia x
Tope de pila
Ejemplo: exchange()
Š Código Assembly
Š Parámetros de funciones se
movl 8(%ebp), %eax
pasan a través de memoria,
movl 12(%ebp), %edx indexados por el puntero
movl (%eax), %ecx
base (base pointer) %ebp
movl %edx, (%eax)
movl %ecx, %eax
Š Convención: parámetros xp e y de la función están a 8
y 12 bytes de (%ebp), respectivamente
Š Convención: funciones retornan resultados en %eax
(C) Mario Medina C.
Operaciones aritmético-lógicas
Instrucción
Efecto
Descripción
leal S, D
D ← &S
Carga dirección
incl D
D←D+1
Incrementa D
decl D
D←D-1
Decrementa D
negl D
D ← -D
Niega D
notl D
D ← ~D
Complementa D
addl S, D
D←D+S
Suma S y D
subl S, D
D←D-S
Resta S a D
imull S, D
D←D*S
Multiplica S y D
xorl S, D
D←D^S
XOR S y D
orl S, D
D←D|S
OR S y D
andl S, D
D←D&S
AND S y D
5
Instrucción leal S, D
Š Variante de movl
z
z
z
Calcula la dirección en memoria de S (&S)
Almacena la dirección calculada en D
Usada para generar punteros y cálculos aritméticos
z
1.
3.
movl 10(%ecx), %eax
œ%eax ← M[%ecx + 10]
4.
leal 10(%ecx), %eax
5.
œ%eax ← %ecx + 10
Š Ejemplo: %edx contiene variable x
z
Š Suponga que %eax contiene x, y %ecx
contiene y. Qué calculan:
2.
Š Ejemplo de puntero
z
Ejemplos de leal
6.
leal
leal
leal
leal
leal
leal
6(%eax), %edx
(%eax, %ecx), %edx
(%eax, %ecx, 4), %edx
7(%eax, %eax, 8), %edx
0xa(, %ecx, 4), %edx
9(%eax, %ecx, 2), %edx
Qué hace leal 7(%edx, %edx, 4), %eax?
%eax almacena 5x+7
Operaciones aritméticas
Š Dados
Š Evalúe
Dirección
0x100
0x104
0x108
0x10C
Valor
0xFF
0xAB
0x13
0x11
1.
Registro
%eax
%ecx
%edx
Valor
0x100
0x1
0x3
6.
2.
3.
4.
5.
addl %ecx, (%eax)
subl %edx, 4(%eax)
imull $16, (%eax,
%edx, 4)
incl 8(%eax)
decl %ecx
subl %edx, %eax
Operaciones de desplazamiento
Instrucción
Efecto
Descripción
sall k, D
D ← D << k
Desp. izquierda
shll k, D
D ← D << k
Desp. izquierda
sarl k, D
D ← D >> k
Desp. derecha aritmético
shrl k, D
D ← D >> k
Desp. derecha lógico
Desplazamientos
Š Desplazamiento va de 0 a 31
z
Generalmente operando inmediato o %cl
Š Operaciones sall y shll son iguales
Š Operaciones sarl y shrl son diferentes
z
sarl hace desplazamiento aritmético a la derecha
z
shrl hace desplazamiento lógico a la derecha
Ejemplo: código C
int arith(int x, int y, int z){
int t1 = x + y;
int t2 = z*48;
int t3 = t1&0xFFFF;
int t4 = t2*t3;
œExtensión de signo mantiene el signo del resultado
œRellena con 0s
(C) Mario Medina C.
return t4;
}
6
Ejemplo: código ensamblador
Š Suponga que x, y y z están a 8, 12 y 16 bytes de
(%ebp), respectivamente
movl 12(%ebp), %eax
//
movl 16(%ebp), %edx
//
addl 8(%ebp), %eax
//
leal (%edx, %edx, 2), %edx
sall $4, %edx
//
andl $65535, %eax
//
imull %eax, %edx
//
movl %edx, %eax
//
Lee y
Lee z
Calcula t1
Calcula
Calcula
Calcula
Retorna
Multiplicación de enteros
Š imull S, D: Multiplica 2 operandos
z
z
Cada operando tiene 32 bits
Resultado truncado a 32 bits
Š imull S: Multiplicación de 1 operando
z
Operando S tiene 32 bits
z
Resultado tiene 64 bits
œSe multiplica con contenido de %eax
t2
t3
t4
t4
œ32 bits más significativos en %edx
œ32 bits menos significativos en %eax
Š mull S: multiplica enteros sin signo
División
Š idivl realiza división de 64 bits con signo
z
z
z
z
Dividendo: concatenación de %edx:%eax
Divisor: operando de la instrucción
Cuociente de la división queda en %eax
Resto de la división queda en %edx
Š divl realiza división de 64 bits sin signo
Š cltd convierte contenido de %eax a 64 bits
con signo
z
Ejemplos
Š Suponga x en 8(%ebp) e Š Suponga x en 8(%ebp)
y en 12(%ebp)
e y en 12(%ebp)
Š Multiplica x e y, retorna Š Divide x por y, retorna
resultados en la pila
resultados en la pila
movl 8(%ebp), %eax
imull 12(%ebp)
pushl %edx
pushl %eax
movl 8(%ebp), %eax
cltd
idivl 12(%ebp)
pushl %eax
pushl %edx
Extiende signo de %eax en %edx
Operaciones aritméticas
Bits de condición
Š CPUs Intel mantienen flags o bits de condición
Instrucción
Efecto
Descripción
imull S
R[%edx]:R[%eax]←S×R[%eax]
Multiplica con signo
mull S
R[%edx]:R[%eax]←S×R[%eax]
Multiplica sin signo
z
cltd
R[%edx]:R[%eax]←
SignExtend(R[%eax])
Convierte a quad
word
z
idivl S
R[%edx]←R[%edx]:R[%eax] mod S
División con signo
z
z
z
R[%eax]←R[%edx]:R[%eax]÷S;
divl S
R[%edx]←R[%edx]:R[%eax] mod S
División sin signo
Describen resultados de últimas operaciones de ALU
Carry Flag (CF): Última operación generó un rebalse
Zero Flag (ZF): Última operación generó un cero
Sign Flag (SF): Última operación generó un número
negativo
Overflow Flag (OF): ÚItima operación generó un
rebalse de complemento a 2
R[%eax]←R[%edx]:R[%eax]÷S;
(C) Mario Medina C.
7
Ejemplo: resta
Š Calcular 0xE4534980 – 0x94533443
z
Equivalente a 0xE4534980+[0x94533443]
œRestar B es sumar el complemento a 2 de B
z
z
z
Equivalente a 0xE4534980+0x6BACCBBD
Resultado es 0x15000153D
Cómo quedan los bits de condición?
œZF = 0
œCF = 1
œSF = 0
œOF = 1
Ejemplo: t = a + b
Š Implementado con instrucción addl
z
z
z
z
CF: (unsigned t) < (unsigned a)
ZF: (t == 0)
SF: (t < 0)
OF: (a < 0 == b < 0) && (t < 0 != a < 0)
Š Instrucción leal no modifica bits de condición
Š Operaciones lógicas hacen CF y OF igual a 0
Š Desplazamientos hacen OF 0 y modifican CF
Instr. Comparación
•Modifican los códigos de condición
•No modifican operandos
Acceso a códigos de condición
Instrucción Sinónimo
Efecto
Condición
sete D
setz
D←ZF
cero
setne D
setnz
D←~ZF
No cero
sets D
D←SF
Negativo
D←~SF
No negativo
Instrucción
Basado en
Descripción
setns D
cmpb S2, S1
S1 - S 2
Compara bytes
setg D
setnle
D←~(SF^OF)&~ZF
Mayor (signed)
testb S2, S1
S1 & S 2
Test bytes
setge D
setnl
D←~(SF^OF)
Mayor o igual
cmpw S2, S1
S1 - S 2
Compara palabras
setl D
setnge
D←SF^OF
Menor
setle D
setng
D←(SF^OF)|ZF
Menor o igual
testw S2, S1
S1 & S 2
Test palabras
seta D
setnbe
D←~CF &~ZF
Superior (unsigned)
cmpl S2, S1
S1 - S 2
Compara palabras dobles
setae D
setnb
D←~CF
Superior o igual
testl S2, S1
S1 & S 2
Test palabras dobles
setb D
setnae
D←CF
Inferior
setbe D
setna
D←CF|ZF
Inferior o igual
Instrucciones setX
Š Resultado de instrucciones setX es 1 byte de
valor 0 ó 1
z
Destino de instrucción es un registro de 8 bits ó un
byte en memoria
œUsar movzbl para convertir resultado a 32 bits
z
Ejemplo: si a está en %eax y b en %edx
cmpl %eax, %edx
setl %al
movzbl %al, %eax
(C) Mario Medina C.
a < b?
Bits 0-7 %eax son 0 ó 1
Extiende valor a 32 bits
Ahora %eax es 0 ó 1
Instrucciones de salto
•Cambio en secuencia de ejecución de instrucciones
•Saltos condicionales e incondicionales
Instrucción
Sinónimo Condición Descripción
jmp Rótulo
1
Salto directo
jmp *Operando
1
Salto indirecto
je Rótulo
jz
ZF
Cero
jne Rótulo
jnz
~ZF
No cero
js Rótulo
SF
Negativo
jns Rótulo
~SF
No negativo
8
Instrucciones de salto
Instrucción
Sinónimo
Condición
Descripción
jg Rótulo
jnle
~(SF^OF)&~ZF
Mayor (signed)
jge Rótulo
jnl
~(SF^OF)
Mayor o igual
jl Rótulo
jnge
SF^OF
Menor
jle Rótulo
jng
(SF^OF)|ZF
Menor o igual
ja Rótulo
jnbe
~CF &~ZF
Superior (unsigned)
jae Rótulo
jnb
~CF
Superior o igual
jb Rótulo
jnae
CF
Inferior
jbe Rótulo
jna
CF|ZF
Inferior o igual
•Rótulo es una referencia en el código fuente
jmp L1
.L1: pop %edx
(C) Mario Medina C.
9