Ensamblador

Programacin en Lenguaje Ensamblador bajo Linux
Amelia Ferreira
Vicente Robles
Caracas, 2007
Este documento es propiedad intelectual de los autores, Amelia Ferreira y Vicente Robles.
Su reproduccin total o parcial requiere la autorizacin previa de sus autores. Caracas 2007.
Introduccin................................................................................................................... 6
Captulo 1. La plataforma IA-32 .................................................................................... 8
Descripcin general de la mquina .............................................................................................. 8
Tipos de datos...............................................................................................................................................8
Registros .....................................................................................................................................................10
Registros de propsito general .............................................................................................................10
Registros de segmento ..........................................................................................................................12
Registro apuntador de instruccin........................................................................................................17
Registros de punto flotante ...................................................................................................................17
Banderas......................................................................................................................................................17
Captulo 2. El entorno de programacin ...................................................................... 19

El compilador gcc ......................................................................................................................... 19
Binutils........................................................................................................................................................24
El depurador gdb ........................................................................................................................................30
Ejecucin de programas con el depurador...........................................................................................30
Comandos bsicos de control ..........................................................................................................34
Comandos bsicos de inspeccin ....................................................................................................38
Alteracin de la ejecucin del programa ........................................................................................41
Uso de la opcin g de gcc ..............................................................................................................46
Conclusiones y detalles finales........................................................................................................48
Captulo 3. El programa en lenguaje ensamblador ...................................................... 50

Definiciones generales .................................................................................................................. 50
Secciones......................................................................................................................................... 50
Punto de inicio ............................................................................................................................... 51
Finalizacin del programa .......................................................................................................... 51
Estructura general........................................................................................................................ 52
Captulo 4. Definicin de datos .................................................................................... 53

Definicin de datos inicializados ................................................................................................ 53
Definicin de constantes .............................................................................................................. 54
Definicin de datos sin inicializar .............................................................................................. 55
Captulo 5. Instrucciones ............................................................................................. 56

Instrucciones de movimiento de datos....................................................................................... 57
La instruccin mov................................................................................................................................57
Movimiento de datos inmediatos a registro o a memoria..............................................................58
Movimiento de datos entre registros ...............................................................................................58
Movimiento de datos entre memoria y registros ............................................................................58
Movimiento de datos con extensin.....................................................................................................59
Carga direccin efectiva (instruccin leal) ..........................................................................................59
Uso de la pila ..............................................................................................................................................60
Instruccin push (apilar) .......................................................................................................................60
Instruccin pop (desapilar) ...................................................................................................................61
3
Instrucciones aritmticas y lgicas ............................................................................................ 62
add (suma) .............................................................................................................................................62
sub (resta)...............................................................................................................................................63
inc (incremento) ....................................................................................................................................63
dec (decremento) ...................................................................................................................................63
neg (negacin aritmtica) .....................................................................................................................64
not (negacin lgica).............................................................................................................................64
and (y lgico).........................................................................................................................................64
or (o lgico) ...........................................................................................................................................65
xor (or exclusivo) ..................................................................................................................................66
shl (desplazamiento lgico a la izquierda)...........................................................................................66
shr (desplazamiento lgico a la derecha) .............................................................................................67
sar (desplazamiento aritmtico a la derecha).......................................................................................67
mul (multiplicacin de enteros sin signo)............................................................................................68
imul (multiplicacin de enteros con signo) .........................................................................................68
imul con un operando.......................................................................................................................68
imul con dos operandos ...................................................................................................................68
imul con tres operandos ...................................................................................................................69
cwd (convierte palabra en palabra doble) ............................................................................................69
cltd (convierte palabra doble a palabra cudruple) .............................................................................69
div (divisin de enteros sin signo) .......................................................................................................69
idiv (divisin de enteros con signo) .....................................................................................................70
Instrucciones de comparacin .................................................................................................... 71

cmp (compara).......................................................................................................................................71
test (examina bits) .................................................................................................................................71
Instrucciones de salto ................................................................................................................... 72

Actualizacin de un registro con valor de una bandera ......................................................... 74
La instruccin loop ....................................................................................................................... 75
Ejercicios........................................................................................................................................ 77
Captulo 6. Entrada / Salida......................................................................................... 79

Funciones de alto nivel ................................................................................................................. 79
Funcin printf .............................................................................................................................................80
Funcin scanf..............................................................................................................................................81
Consideraciones adicionales......................................................................................................................83
Llamadas al sistema ..................................................................................................................... 87

Servicio read ...............................................................................................................................................88
Servicio write..............................................................................................................................................88
Instrucciones de bajo nivel .......................................................................................................... 93

El subsistema de E/S ..................................................................................................................................93
Interfaz de E/S: ......................................................................................................................................94
Funciones de una Interfaz de E/S:........................................................................................................94
Tcnicas de transferencia de E/S:.........................................................................................................95
Entrada/Salida programada: ............................................................................................................95
Entrada/Salida basada en interrupciones: .......................................................................................96
Acceso directo a memoria (DMA):.................................................................................................96
Direccionamiento de los dispositivos de E/S ......................................................................................97
E/S aislada y E/S mapeada a memoria.................................................................................................98
Instrucciones in y out..........................................................................................................................98
Dispositivos de E/S: El teclado ..........................................................................................................101
Ejemplos prcticos: .............................................................................................................................105
4
Ejercicios...................................................................................................................................... 116
Captulo 7. Control de flujo........................................................................................ 118

Traduccin de estructuras condicionales................................................................................ 118
Ciclos............................................................................................................................................. 120
Do while....................................................................................................................................................120
While.........................................................................................................................................................121
For .............................................................................................................................................................122
Ejercicios...................................................................................................................................... 124
Captulo 8. Arreglos ................................................................................................... 125

Declaracin de arreglos ...........................................................................................................................125
Lectura de datos en un arreglo.................................................................................................................126
Escritura de datos en un arreglo ..............................................................................................................128
Ejercicios...................................................................................................................................... 130
Captulo 9. Procedimientos ........................................................................................ 131

Instrucciones para llamadas a procedimientos .......................................................................................131
Convenciones para preservar los contenidos de los registros ...............................................................132
Estructura del programa con llamada a procedimientos ........................................................................132
Pase de parmetros ...................................................................................................................................134
Ejemplo de programa con pase de parmetro por valor ...................................................................134
Estado de la pila .............................................................................................................................135
Ejemplos de programas con pase de parmetro por referencia ........................................................136
Ejemplo de programa con una llamada a una funcin dentro de un ciclo .......................................140
Ejercicios...................................................................................................................................... 143
Captulo 10. Cadenas de caracteres............................................................................ 144

Instruccin movs .................................................................................................................................144
El prefijo rep ........................................................................................................................................146
La instruccin lods ..............................................................................................................................147
La instruccin stos...............................................................................................................................147
La instruccin cmps ............................................................................................................................148
La instruccin scas ..............................................................................................................................150
Ejercicios...................................................................................................................................... 153
Captulo 11. Operaciones de punto flotante ............................................................... 154

Instrucciones de movimiento de datos ....................................................................................................157
fld (apila un dato punto flotante en la pila FPU)...............................................................................157
fild (apila un entero)............................................................................................................................158
fst (movimiento de datos desde el tope de la pila) ............................................................................158
fst (copia el tope de la pila) ................................................................................................................158
fstp (lee el tope de la pila y desapila).................................................................................................158
fist (lee nmero entero del tope de la pila) ........................................................................................159
fxch (intercambio de valores entre el tope de la pila y otro registro) ..............................................159
Instrucciones de control ...........................................................................................................................159
finit (inicializacin) .............................................................................................................................159
fstcw (copia el contenido del registro de control) .............................................................................159
fstsw (copia el contenido del registro de estado) ..............................................................................159
Instrucciones aritmticas bsicas ............................................................................................................160
fadd (suma) ..........................................................................................................................................160
fsub (resta) ...........................................................................................................................................160
fmul (multiplicacin) ..........................................................................................................................161
5
fdiv (divisin) ......................................................................................................................................161
Instrucciones de comparacin .................................................................................................................163
Ejercicios...................................................................................................................................... 165
Captulo 12. Manejo de archivos................................................................................ 166

Tipos de archivo .......................................................................................................................... 167
Archivos de texto .....................................................................................................................................167
Archivos binarios .....................................................................................................................................168
Tipos de acceso ............................................................................................................................ 168

Acceso secuencial ....................................................................................................................................168
Acceso aleatorio .......................................................................................................................................168
Funciones de alto nivel ............................................................................................................... 169

fopen.....................................................................................................................................................170
fclose ....................................................................................................................................................171
fread .....................................................................................................................................................171
fwrite ....................................................................................................................................................171
fgets ......................................................................................................................................................172
fputs......................................................................................................................................................172
fscanf ....................................................................................................................................................172
fprintf ...................................................................................................................................................173
fseek .....................................................................................................................................................173
feof .......................................................................................................................................................173
ferror.....................................................................................................................................................174
fflush ....................................................................................................................................................174
remove..................................................................................................................................................174
Llamadas al sistema ................................................................................................................... 186

creat ......................................................................................................................................................187
open ......................................................................................................................................................187
close .....................................................................................................................................................188
read .......................................................................................................................................................189
write .....................................................................................................................................................189
lseek .....................................................................................................................................................189
unlink ...................................................................................................................................................190
mkdir ....................................................................................................................................................190
rmdir.....................................................................................................................................................190
rename..................................................................................................................................................191
chmod...................................................................................................................................................191
chdir .....................................................................................................................................................191
Ejercicios...................................................................................................................................... 196
Soluciones a los ejercicios .......................................................................................... 197
Introduccin
Este libro est destinado a aquellas personas que deseen aprender a programar
en lenguaje ensamblador para la plataforma IA-32 bajo ambiente Linux.
Los ejemplos se refieren al compilador gcc (GNU compiler collection). El
ensamblador de gcc se llama as y por formar parte de gcc comnmente se
conoce como gas. Este libro no pretende cubrir todas y cada una de las
instrucciones del lenguaje ensamblador sino las ms comunes y presenta una
serie de ejemplos y ejercicios para ayudar al lector en la programacin. Con el
conjunto de herramientas presentadas es posible desarrollar programas
complejos que solucionen una gran variedad de problemas.
La programacin en lenguaje ensamblador ofrece diferentes ventajas. Un
programa escrito en lenguaje ensamblador requiere considerablemente menos
memoria y tiempo de ejecucin que un programa escrito en un lenguaje de alto
nivel. La programacin en lenguaje ensamblador depende de la arquitectura del
computador sobre el cual se trabaja, sto es importante para entender el
funcionamiento interno de la mquina, por ello al programar en ensamblador se
llega a comprender cmo funciona el computador y cmo es su estructura
bsica. La capacidad de poder escribir programas en lenguaje ensamblador es
muy importante para los profesionales del rea de Sistemas Operativos debido a
que los programas residentes y rutinas de servicio de interrupcin casi siempre
son desarrollados en lenguaje ensamblador.
Adems, an cuando la mayora de los especialistas en programacin desarrolla
aplicaciones en lenguajes de alto nivel, que son ms fciles de escribir y de
mantener, una prctica comn es codificar en lenguaje ensamblador aquellas
rutinas que han causado cuellos de botella en el procesamiento.
La organizacin del libro corresponde al proceso de aprendizaje de la
programacin en lenguaje ensamblador, primero se describen las caractersticas
bsicas de la arquitectura de la mquina sobre la cual se va a trabajar, luego el
entorno de programacin es decir, los programas y herramientas necesarios
7
para realizar la programacin. Este captulo sirve de introduccin al uso de estas
herramientas y luego de consulta a medida que van aprendiendo nuevos
conceptos ya que provee la informacin necesaria para la deteccin y correccin
de errores del programa escrito en lenguaje ensamblador. Los siguientes
captulos describen la estructura del programa, cmo declarar datos y cmo
utilizar las instrucciones bsicas. Luego se explica cmo realizar operaciones de
lectura y escritura de informacin para posteriormente pasar a la explicacin de
la programacin de estrcuturas condicionales, ciclos y el uso de arreglos. Ms
adelante se describen las convenciones para el desarrollo de procedimientos.
Hasta este punto se cubren los conceptos bsicos de la programacin en
lenguaje ensamblador, los captulos siguientes proveen una visin un poco ms
detallada de ciertos aspectos como son el manejo de cadenas de caracteres lo
cual es posible realizar de manera ms eficiente con un conjunto de
instrucciones dedicadas. Estas instrucciones se presentan en el captulo 10.
Luego se describe cmo programar utilizando operaciones de punto flotante y
finalmente el ltimo captulo est dedicado al manejo de archivos.
Captulo 1. La plataforma IA-32

Escribir programas en lenguaje ensamblador requiere el conocimiento de la
estructura bsica de la mquina sobre la cual se va a trabajar. Este captulo
describe, por tanto, las caractersticas ms relevantes de la arquitectura IA-32
(Intel Architecture 32 bits), su repertorio de instrucciones y las consideraciones
de diseo que afectan directamente la programacin en lenguaje ensamblador,
esta descripcin se hace usando la nomenclatura de gas.
Descripcin general de la mquina

El computador se compone de varios bloques funcionales: el procesador, la
memoria, los dispositivos de entrada/salida y los buses. El procesador se
encarga del control y ejecucin de los programas; los programas y los datos que
los mismos utilizan se guardan en memoria; la comunicacin con el exterior se
logra a travs de los dispositivos de entrada/salida y los buses son los
encargados de transferir la informacin entre todos los componentes del
sistema antes mencionados.
Tipos de datos
Los datos se pueden accesar de diversas maneras. Se puede leer un slo byte (8
bits) o un conjunto de bytes. En esta mquina en particular se denomina palabra
a dos bytes y doble palabra a cuatro bytes. Los datos pueden representarse en
notacin binaria, octal, decimal o hexadecimal:
Binaria
0b1000
0b1100
0b1101011011
Octal
08
014
01533
Decimal
8
12
859
Hexadecimal
0x8
0xC
Ox35B
De esta forma, todo dato precedido por el prefijo 0b ser interpretado por la
mquina como un nmero binario. De forma similar, los prefijos 0 y 0x
denotarn datos octales o hexadecimales respectivamente. Por ltimo, todo
dato que no contenga uno de estos prefijos ser interpretado por defecto como
decimal.
9
Esta sintaxis es vlida tanto para el ensamblador gas como para el compilador
gcc, a excepcin del prefijo 0b el cual no est soportado por este ltimo al
momento de escribir estas lneas (se tiene previsto incluir soporte para el mismo
en el futuro).
Los tamaos de los diferentes tipos de datos del lenguaje de programacin C
son los siguientes:
Declaracin en C
char
short
int
unsigned
long int
unsigned long
char *
float
double
long double
Tipo de datos en IA-32

byte
palabra
doble palabra
doble palabra
doble palabra
doble palabra
doble palabra
precisin simple
precisin doble
precisin extendida
Sufijo de gas
b
w
l
l
l
l
l
s
l
t
Tamao (en bytes)

1
2
4
4
4
4
4
4
8
12
En gas las instrucciones utilizan un sufijo para indicar el tamao de los datos
sobre los cuales operan. El mismo puede ser omitido en aquellas instrucciones
en las cuales el tamao de al menos uno de los operandos pueda ser deducido
por gas de manera implcita. Sin embargo, debe ser incluido obligatoriamente
en casos en que los operandos no tengan un tamao implcito (por ejemplo una
operacin entre inmediato y memoria).
Los sufijos disponibles en gas son: b (byte), para denotar operandos de un
byte, w (word) para denotar operandos de dos bytes o una palabra, y l (long)
para denotar operandos de cuatro bytes o una palabra doble.
Por ltimo, es importante tener presente que el sistema guarda los datos en
memoria en secuencia inversa de bytes (little endian) lo cual trae como
consecuencia que el byte menos significativo se ubique en la posicin de menor
orden y el byte ms significativo en la posicin de memoria de mayor orden.
Por ejemplo si se transfiere el dato 0x457A a las posiciones consecutivas de
memoria 0x100 y 0x101 se ubica el byte 0x7A en la posicin 0x100 y el byte
0x45 en la posicin 0x101.
10
Registros
Tipo de registro
De propsito general
De segmento
Apuntador de instruccin
De punto flotante
Nmero y tamao
8 registros de 32 bits
1 registro de 32 bits
Descripcin
Almacenan datos. Para uso del programador
Permiten direccionar la memoria
Apunta a la siguiente instruccin a ejecutar
Se usan para aritmtica punto flotante
Registros de propsito general

Los
registros
de
propsito
general
se
utilizan
para
almacenar
datos
temporalmente. Debido a que estos registros han evolucionado desde una

mquina de 8 bits (el 8080) un grupo de registros an se puede utilizar con un
tamao de 8 bits para mantener compatibilidad con toda la lnea de
procesadores.
An cuando estos registros pueden mantener cualquier tipo de datos, algunos
tienen cierta funcionalidad especfica o son usados de manera especial por
algunas instrucciones.
La siguiente tabla muestra los nombres de los registros y sus usos ms
comunes:
Registro
eax
ebx
ecx
edx
edi
esi
esp
ebp
Descripcin
Acumulador para operaciones aritmetico lgicas
Registro base para acceder a memoria
Contador para algunas instrucciones
Registro de datos usado para algunas operaciones de entrada/salida
Apuntador a destino para operaciones con cadenas de caracteres
Apuntador a origen para operaciones con cadenas de caracteres
Apuntador de pila
Apuntador de marco de pila
En gas los registros se denotan anteponiendo el smbolo de % al nombre del

registro. Los registros %eax, %ebx, %ecx y %edx pueden ser direccionados como
registros con tamaos de 8, 16 o 32 bits cambiando su nomenclatura de
acuerdo al tamao. De forma similar, los registros %edi, %esi, %ebp y %esp se
pueden direccionar como registros de 16 o 32 bits.
11
Los tamaos de los registros %eax, %ebx, %ecx y %edx son los siguientes:
%ax (16 bits)

%ah (8 bits)
%al (8 bits)
%eax (32 bits)

%bx (16 bits)
%bh (8 bits)
%bl (8 bits)
%ebx (32 bits)

%cx (16 bits)
%ch (8 bits)
%cl (8 bits)
%ecx (32 bits)

%dx (16 bits)
%dh (8 bits)
%dl (8 bits)
%edx (32 bits)
12
Los tamaos de los registros %edi, %esi, %esp y %ebp son los siguientes:
%di (16 bits)
%edi (32 bits)

%si (16 bits)
%esi (32 bits)

%sp (16 bits)
%esp (32 bits)

bpi (16 bits)
%ebp (32 bits)
Registros de segmento
Los registros de segmento se utilizan para referenciar reas de memoria. La
plataforma IA-32 permite direccionar la memoria segn el modelo de memoria
lineal o el modelo de memoria segmentada.
El modelo de memoria lineal presenta todo el espacio de direcciones de la
memoria como un espacio contiguo. Todas las instrucciones, los datos y la pila
se encuentran en el mismo espacio de direcciones de memoria. Cada posicin
de memoria se referencia mediante una direccin especfica llamada "direccin
lineal".
El problema del enfoque anterior consiste en que todos los datos se encuentran
mezclados entre si y a la vez distribuidos a lo largo de todo el espacio de
direcciones memoria, lo cual hace que su manejo sea engorroso e ineficiente. El
13
modelo de memoria segmentada resuelve este problema dividendo el espacio
de direcciones en segmentos independientes entre si. Cada segmento contiene
un tipo especfico de informacin, es decir el cdigo (las instrucciones) se ubica
en un segmento, los datos en otro y la pila en un tercer segmento. Las
posiciones de memoria en los segmentos se definen por direcciones lgicas.
Una direccin lgica est compuesta por una direccin de segmento y un
desplazamiento. El procesador traduce una direccin lgica a una direccin
lineal.
Los procesadores de la familia Intel poseen un grupo de registros creados con el
fin de soportar el modelo de memoria segmentada, los cuales son conocidos
como registros de segmento:
Registro de segmento
cs
ds
ss
es
fs
gs
Descripcin
Segmento de cdigo
Segmento de datos
Segmento de pila
Apuntador de segmento extra
El contenido de los mismos es interpretado de diferente forma dependiendo si

el procesador se encuentra trabajando en modo real o en modo protegido .
Los procesadores ms antiguos de esta familia trabajaban en modo real, en el
cual un registro de segmento simplemente contena una direccin lineal que
sealaba el comienzo de un segmento. De esta forma, si un programa intentaba
acceder a un dato ubicado en el desplazamiento D del segmento apuntado por
el registro ds, la traduccin a una direccin lineal consista en tomar el
contenido de dicho registro, multiplicarlo por 0x10 (esto es la direccin de
inicio del segmento de datos en uso) y sumarle el desplazamiento D.
14
Por ejemplo:
Segmento: DS
Desplazamiento: 0x8A00
0x28A00
DATO
Desplazamiento
0x2000
0x20000
DS
0x00000
Sin embargo, con el paso de los aos este enfoque result ser insuficiente, ya
que por ejemplo, no haba forma de determinar si un desplazamiento causaba
que la direccin lineal cayera fuera del segmento. Para solventar ste y otros
problemas de seguridad, se implement a partir del procesador 80286 el modo
protegido.
En el modo protegido, el registro de segmento ya no contiene la direccin base
del segmento, sino un selector de segmento, el cual permite seleccionar un
descriptor de segmento. Este ltimo no es ms que una estructura de ocho

bytes, la cual posee un formato definido y contiene entre otras cosas la
direccin base del segmento en cuestin:
byte 7
Permisos de acceso
Direccin base (23-16)

Lmite (15-0)
byte 0
Descriptor de segmento del 80286

byte 7
Permisos de acceso
AV
Lmite (19-16)

Lmite (15-0)
byte 0
Descriptor de segmento del 80386 y posteriores

De esta manera, la direccin base del segmento pasa ahora a ocupar 24 32
bits (dependiendo del procesador), en contraposicin a los 16 bits que pueden
15
almacenarse en el registro de segmento en modo real. Adicionalmente se cuenta
con un campo de lmite de segmento que puede ocupar 16 20 bits, lo que
determina el tamao mximo de los segmentos en 64KB o 1MB. El descriptor de
segmento del 80386 incluye una bandera (G) que indica que el campo lmite
debe ser multiplicado por 4K, permitiendo entonces la existencia de segmentos
entre 4KB y 4 GB.
El descriptor de 80386 incluye dos banderas adicionales. La primera de ellas
(D/B), permite determinar si se est trabajando en modo de 16 32 bits. La
segunda (AVL) puede ser utilizada por los sistemas operativos para marcar el
segmento descrito como disponible o no (Available). El campo de permisos de
acceso posee los siguientes subcampos:
7
P
5
DPL
TIPO
En donde P ( present) es un bit que indica si el descriptor contiene informacin

vlida de un segmento o no. El bit DPL (Descriptor Privilege Level) indica el nivel
de privilegio mnimo para poder acceder al segmento. El bit S ( System) indica si
se trata de un descriptor de sistema o no (en cuyo caso es de cdigo o datos).
Por ltimo los cuatro bits correspondientes al campo tipo indican si se trata de
un segmento de cdigo o datos, el sentido de expansin del mismo (hacia
arriba para datos, hacia abajo para pila), si el segmento es de lectura y/o
escritura, y si el mismo ha sido accedido o no.
No todos los bits del registro de segmento estn destinados a seleccionar un
descriptor:
15
Selector
TI
RPL
El campo RPL ( Request Privilege Level) permite indicar el nivel de privilegio con
el cual se est accediendo al segmento, siendo 00 el nivel ms bajo y 11 el ms
alto. Este valor debe ser mayor o igual al del campo DPL del descriptor
correspondiente. Adicionalmente el campo TI (Table Indicador) es una bandera
que permite escoger la tabla en la cual ser seleccionado el descriptor de
segmento con los bits restantes (0 = tabla de descriptores globales, 1 = tabla
de descriptores locales). Los descriptores globales son utilizados por todos los
16
programas y a menudo se les conoce como descriptores de sistema, mientras
que los descriptores locales son exclusivos de un programa particular y a
menudo se les conoce como descriptores de aplicacin.
De esta forma, el mismo acceso a memoria que ejemplificamos anteriormente,
se llevara a cabo de la siguiente manera en modo protegido:
Segmento: DS
Desplazamiento: 0x8A00
Tabla de
descriptores
locales
Lmite del
segmento
0x2A000
DATO
0x28A00
Desplazamiento
0x0015
DS
00
93
00
A0
00
02
00
00
0x20000
Descriptor 1
Descriptor 0
0x00000
En primer lugar, el descriptor de segmento indica que debe seleccionarse el

descriptor nmero 2 (Selector = 0000000000010) de la tabla de descriptores
locales (TI = 1) con un nivel de privilegio de 1 (RPL = 01). De esta manera, se
procede a interpretar los ocho bytes correspondientes al mismo en la TDL.
Dicho descriptor indica que la direccin base del segmento en cuestin es la
0x00020000, y que el tamao del mismo es de 0x0A000, lo que quiere decir
que el lmite del mismo corresponde a la direccin 0x2A000. Dado que el RPL es
mayor que el DPL (00) se permite el acceso al segmento. De manera similar, se
verifica que la direccin lineal resultante (0x20000 + 0x8A00) se encuentra
dentro de los lmites del segmento.
El proceso de traduccin de direcciones es un poco ms complejo de lo que
puede intuirse a partir de esta breve explicacin, involucrando el uso de una
cach para agilizar el acceso a las tablas de descriptores. Es importante tener en
17
mente tambin que la memoria puede estar paginada, en cuyo caso ser
necesario transformar las direcciones lineales (virtuales) a direcciones fsicas o
reales. Por ltimo, cabe acotar que los registros ES, FS y GS apuntan a
segmentos de datos (o seleccionan descriptores de segmentos de datos).
Registro apuntador de instruccin
El registro apuntador de instruccin (eip) o contador de programa contiene la
direccin de la prxima instruccin a ejecutarse.
Registros de punto flotante

Son ocho registros los cuales son tratados como una pila. Se denominan %st(0),
%st(1), %st(2), etc. %st(0) se ubica en el tope de la pila.
Banderas
Las banderas proveen una manera de obtener informacin acerca de del estado
actual de la mquina y el resultado de procesamiento de una instruccin. La
plataforma IA-32 utiliza un registro de 32 bits llamado EFLAGS que contiene las
banderas. Las banderas ms comunmente usadas son las siguientes:
Bandera
CF
PF
AF
ZF
SF
DF
OF
Bit
0
2
4
6
7
10
11
Nombre
Bandera de acarreo (carry flag)
Bandera de paridad (parity flag)
Bandera de acarreo auxiliar (adjust flag)
Bandera de cero (zero flag)
Bandera de signo (sign flag)
Bandera de direccin (direction flag)
Bandera de desbordamiento (overflow flag)
La bandera de acarreo se activa cuando se produce acarreo en una suma o

multiplicacin, o un prstamo en una resta entre nmeros sin signo.
La bandera de paridad se usa para indicar si el resultado, en un registro, de una
operacin matemtica es vlido.
La bandera de acarreo auxiliar se utiliza en operaciones matemticas con
nmeros decimales codificados en binario (BCD). Se activa si hay acarreo
presente.
18
La bandera de cero se activa si el resultado de una operacin aritmtico lgica
es cero.
La bandera de signo muestra el bit ms significativo del resultado de una
operacin, el cual denota el signo del nmero.
La bandera de direccin controla la seleccin de autoincremento (D=0) o
autodecremento (D=1) de los registros %edi o %esi durante las operaciones con
cadenas de caracteres. La bandera de direccin slo se utiliza con las
instrucciones para el manejo de cadenas de caracteres.
La bandera de desbordamiento se utiliza en la aritmtica de enteros con signo
cuando un nmero sobrepasa la capacidad de representacin del registro.
19
Captulo 2. El entorno de programacin

El compilador gcc
El proceso de traduccin de un programa escrito en un lenguaje de alto nivel a
un archivo objeto ejecutable consta de varias etapas. A continuacin se
describen
las
etapas
correspondientes
al conjunto
de herramientas
de
compilacin gcc que permite traducir programas escritos en el lenguaje de

programacin C.
Programa
fuente
Pre-procesador
(cpp)
Compilador
(ccl)
Ensamblador
(as)
Enlazador
(ld)
Para ejemplificar los pasos usaremos un programa fuente denominado
Programa
objeto
ejemplo
escrito en lenguaje de programacin C, creado en un editor de texto y guardado

como
ejemplo.c:
#include <stdio.h>
int main()
{
printf(programa de ejemplo\n);
return 0;
}
Con gcc, la traduccin de este programa fuente a un archivo objeto ejecutable
se realiza de la siguiente manera:
linux>
gcc o ejemplo ejemplo.c
El compilador lee el archivo
ejemplo.c
y lo traduce al archivo objeto ejecutable
ejemplo. Esto se realiza a travs de las cuatro etapas mencionadas.

En la primera etapa el pre-procesador (cpp) modifica el programa original de
acuerdo a lo indicado por las directivas que comienzan con el caracter #. En este
caso la lnea
#include <stdio.h>
archivo de encabezado
stdio.h
le indica al pre-procesador que debe leer el
e insertar su contenido en el texto del programa.
20
La salida de esta etapa es el archivo intermedio
Pre-procesador
(cpp)
ejemplo.c
Luego,
ejemplo.i.
ejemplo.i
ejemplo.i entra en la siguiente etapa, el compilador (ccl) el cual traduce el
programa a lenguaje ensamblador. La salida de esta etapa es el archivo
ejemplo.s.
Compilador
(ccl)
ejemplo.i
ejemplo.s
En la siguiente etapa, el ensamblador (as) lee el archivo
ejemplo.s y lo traduce en
instrucciones de lenguaje de mquina generando un archivo objeto relocalizable

el cual se guarda como
ejemplo.o.
ejemplo.s
Ensamblador
(as)
ejemplo.o
Luego el enlazador (ld) enlaza ese archivo objeto con otros archivos asociados a
l, en este caso ya que el programa llama una biblioteca (la funcin printf forma
parte de la biblioteca estndar de entrada/salida) el enlazador se encarga de
enlazar el programa con esta biblioteca en particular. Su salida es un archivo
objeto ejecutable llamado
ejemplo.
Biblioteca
estndar
ejemplo.o
Enlazador
(ld)
ejemplo
Para ejecutar el programa se escribe:

linux>
./ejemplo
21
Lo cual producir como salida:
programa de ejemplo
linux>
El compilador gcc se puede ejecutar con varias opciones. Cabe destacar que
Linux diferencia entre maysculas y minsculas por lo cual un comando (u
opcin) en mayscula ser diferente a un comando (u opcin) con el mismo
nombre en minscula. Entre las opciones ms importantes tenemos:
-o
indica el nombre del archivo de salida, cuando no se usa, el compilador

genera un archivo llamado a.out por defecto.
-S
no ensambla, la salida es un archivo en lenguaje ensamblador con el sufijo
-c
no enlaza, la salida ser un archivo en cdigo objeto con el sufijo .o su

contenido se encuentra en binario. Se puede utilizar la herramienta objdump
para desensamblar este archivo y visualizar su contenido.
-O
opcin de optimizacin, se acompaa con un nmero que indica el nivel de

optimizacin deseado. Se puede escoger entre O0, O1, O2 u O3.
-g
produce informacin para la depuracin del programa.
.s.
Usando el programa
linux>
ejemplo anterior, el comando:
gcc -O2 -S -o ejemplo.s ejemplo.c
22
Produce como salida el programa en lenguaje ensamblador:
.file
"ejemplo.c"
.section
.rodata.str1.1,"aMS",@progbits,1
.LC0:
.string "programa de ejemplo"
.text
.p2align 2,,3
.globl main
.type
main,@function
main:
pushl
%ebp
movl
%esp, %ebp
subl
$8, %esp
andl
$-16, %esp
subl
$12, %esp
pushl
$.LC0
call
puts
xorl
%eax, %eax
leave
ret
.Lfe1:
.size
main,.Lfe1-main
.ident "GCC: (GNU) 3.2.2 20030222 (Red Hat Linux 3.2.2-5)"
Existe otra opcin de (-v, verbose), la cual nos permite observar la manera en la
que gcc invoca a cada una de las herramientas mencionadas (el compilador, el
ensamblador y el enlazador) para generar el archivo ejecutable. Por ejemplo, si
repetimos la compilacin del archivo ejemplo.s utilizando esta opcin, podemos
distinguir cada uno de los pasos descritos anteriormente:
linux>
gcc -o ejemplo.c ejemplo.c -v
23
En este caso, se pueden observar las siguientes lneas dentro de la salida
producida por gcc:
...
/usr/libexec/gcc/i386-redhat-linux/4.0.2/cc1 -quiet -v ej em pl o. c quiet -dumpbase ejemplo.c -auxbase ejemplo -version -o
/tm p/ cc VK 44 SE .s
...
as -V -Qy - o /t mp /c c4 zi Th v. o / tmp /c cV K44 SE .s
...
/usr/libexec/gcc/i386-redhat-linux/4.0.2/col le ct 2 --eh-frame-hdr -m
elf_i386 -dynamic-linker /lib/ld-linux.so.2 -o e je mp lo
/usr/lib/gcc/i386-redhat-linux/4.0.2/../../../crt1.o /usr/lib/gcc/i386redhat-linux/4.0.2/../../../crti.o /usr/lib/gcc/i386-redhatlinux/4.0.2/crtbegin.o -L/usr/lib/gcc/i386-redhat-linux/4.0.2 L/usr/lib/gcc/i386-redhat-linux/4.0.2 -L/usr/lib/gcc/i386-redhatlinux/4.0.2/../../.. /tmp /c c4 zi Th v. o -lgcc --as-needed -lgcc_s --noas-needed -lc -lgcc --as-needed -lgcc_s --no-as-needed
/usr/lib/gcc/i386-redhat-linux/4.0.2/crtend.o /usr/lib/gcc/i386-redhatlinux/4.0.2/../../../crtn.o
...
Se observa que el gcc llev a cabo tres pasos:

Llam al compilador (cc1) pasando el archivo ejemplo.c como entrada, y
generando el archivo ccVK44SE.s como salida.
Llam al ensamblador (as), pasando la salida del compilador como entrada, y
generando el archivo objeto relocalizable cc4ziThv.o como salida.
Llam al enlazador (collect2) pasando como entrada la salida del ensamblador y
un conjunto de bibliotecas estndar, y generando como salida el archivo objeto
ejecutable ejemplo
Luego de observar este resultado, es importante aclarar algunos puntos:
El archivo fuente original puede utilizarse directamente como entrada al
compilador. En caso de que la entrada haya sido preprocesada previamente,
debe utilizarse la opcin fpreprocessed para indicarle este hecho al cc1.
El enlazador real es ld pero gcc hace la llamada a collect2 debido al
funcionamiento interno de esta herramienta.
24
Cada una de las herramientas llamadas por gcc cuenta con su propio conjunto
de opciones que permiten un mayor control sobre todo el proceso de traduccin
en caso de ser necesario.
Finalmente, es posible realizar todos los pasos del proceso de traduccin de
manera manual, llamando a cada una de las herramientas con las opciones ms
adecuadas de acuerdo a lo que se quiere lograr. Por ejemplo, para generar el
archivo ejecutable ejemplo podemos realizar los siguientes pasos:
cpp -o ejemplo.i ejemplo.c

/usr/libexec/gcc/i386-redhat-linux/4.0.2/cc1 -o ejemplo.s ejemplo.i -quiet
fpreprocessed
linux> as -o ejemplo.o ejemplo.s
linux> ld --eh-frame-hdr -m elf_i386 -dynamic-linker /lib/ld-linux.so.2 -o ejemplo
/usr/lib/gcc/i386-redhat-linux/4.0.2/../../../crt1.o /usr/lib/gcc/i386-redhatlinux/4.0.2/../../../crti.o /usr/lib/gcc/i386-redhat-linux/4.0.2/crtbegin.o -L/usr/lib/gcc/i386redhat-linux/4.0.2 -L/usr/lib/gcc/i386-redhat-linux/4.0.2 -L/usr/lib/gcc/i386-redhatlinux/4.0.2/../../.. ejemp lo.o -lgcc --as-needed -lgcc_s --no-as-needed -lc -lgcc --asneeded -lgcc_s --no-as-needed /usr/lib/gcc/i386-redhat-linux/4.0.2/crtend.o
/usr/lib/gcc/i386-redhat-linux/4.0.2/../../../crtn.o
linux>
linux>
Binutils
Como mencionamos anteriormente, si utilizamos la opcin c se produce un
archivo en cdigo de mquina (binario). De igual forma podemos obtener este
archivo invocando manualmente a las herramientas correspondientes. Sin
embargo, existen casos en que necesitamos llevar a cabo el proceso inverso, es
decir, obtener la representacin en lenguaje ensamblador de un programa en
lenguaje de mquina.
En la vida real se dan situaciones en que se nos proporciona una biblioteca
previamente compilada (.o, .a, .so) sin ningn tipo de documentacin, y
debemos averiguar la forma correcta de utilizarla. (Por ejemplo, imagine que se
le proporciona la biblioteca para interactuar con un dispositivo de hardware,
pero no se le entrega el cdigo fuente ni una documentacin que permita
conocer las funciones disponibles para ello).
25
En este caso ser necesario identificarlas de alguna manera, bien sea
obteniendo una lista de los smbolos globales que identifican a dichas funciones
(entry points) o bien sea desensamblando el cdigo binario y analizando el
mismo.
Es posible llevar a cabo estas tareas utilizando un grupo de herramientas
provistas por GNU para el manejo de archivos binarios, conocidas como binutils,
entre las cuales se encuentran:
ld
El enlazador GNU
as
El ensamblador GNU
addr2line
Permite convertir direcciones a nombres de archivo y nmeros de

lnea
ar
Herramienta para el manejo de bibliotecas estticas
nm
Lista los smbolos contenidos en un archivo objeto
objcopy
Permite convertir entre formatos de archivo objeto
objdump
Muestra la informacin contenida en un archivo objeto
readelf
Extrae la informacin contenida en un archivo objeto en formato

ELF
size
Muestra el tamao de los segmentos de un archivo objeto o una

biblioteca esttica
strings
Lista todas las cadenas imprimibles de un archivo
strip
Elimina smbolos y secciones de un archivo objeto
De esta forma, podemos utilizar la herramienta objdump para desensamblar el

segmento de cdigo del archivo binario ejemplo.o y analizar su contenido:
gcc -O2 -c -o ejemplo.o ejemplo.c

linux> objdump -d ejemplo.o
linux>
26
Lo cual produce la salida:
00000000
0: 55
1: 89
3: 83
6: 83
9: 83
c: 68
11: e8
16: 31
18: c9
19: c3
<main>:
e5
ec
e4
ec
00
fc
c0
08
f0
0c
00 00 00
ff ff ff
push
mov
sub
and
sub
push
call
xor
leave
ret
%ebp
%esp,%ebp
$0x8,%esp
$0xfffffff0,%esp
$0xc,%esp
$0x0
12 <main+0x12>
%eax,%eax
En la cual se identifica claramente el procedimiento main y las instrucciones que

conforman el cuerpo del mismo.
La herramienta objdump tiene varias opciones entre las que vale la pena
destacar:
-d
desensambla el cdigo del segmento de texto.
-D
desensambla todo el programa incluyendo los datos (el programa trata

de traducir toda la informacin como instrucciones as que en la parte de
datos la traduccin no se corresponde con la informacin almacenada).
-G
muestra la informacin de depuracin de programas.
-l
muestra los nmeros de lnea.
-r
muestra las entradas de relocalizacin.
-R
muestra las entradas de relocalizacin dinmica.
-t
muestra la tabla de smbolos.
Si se incluye informacin de depuracin del archivo binario (utilizando la opcin

g), es posible relacionar cada direccin del programa desensamblado con las
lneas originales del programa en lenguaje de alto nivel, mediante la utilizacin
de addr2line:
27
linux>
gcc ejemplo.c -o ejemplo.o -c -g -O2
linux>
addr2line -e ejemplo.o -s
0
ejemplo.c:4
main()
{
11
printf(programa de ejemplo\n);
ejemplo.c:5
19
pushl %ebp
call <main+0x12>
ejemplo.c:7
ret
De esta forma, se observa que la primera instruccin en lenguaje ensamblador

(ubicada en la direccin 0x00) se corresponde con el inicio del procedimiento
main (lnea 4, la llave de apertura). De forma similar, la instruccin call
(direccin 0x11) corresponde a la llamada a printf en lenguaje C (lnea 5). Por
ltimo, la instruccin ret (direccin 0x19) , corresponde a la finalizacin del
procedimiento en lenguaje C (lnea 7, la llave de cierre). Es importante tener en
cuenta que una instruccin en lenguaje de alto nivel es traducida en una o ms
instrucciones de bajo nivel, por lo cual dos direcciones proporcionadas a
addr2line pueden arrojar como salida la misma lnea de cdigo fuente original.
En captulos posteriores se dar una explicacin ms detallada de este tema.
Algunas opciones importantes de esta herramienta son:
-e
permite especificar el archivo de entrada a analizar.
-s
evita que se imprima la ruta completa del archivo en lenguaje de alto nivel
al consultar una direccin.
-f
Imprime el nombre de la funcin a la cual corresponde la lnea del

programa.
Para archivos binarios que utilicen el formato ELF, podemos utilizar la

herramienta readelf. La misma permite analizar toda la informacin adicional
almacenada en el archivo, como por ejemplo la tabla de smbolos o la
informacin de relocalizacin:
linux>
readelf ejemplo.o -s
28
La tabla de smbolos '.symtab' contiene 10 entradas:
Num
0
1
2
3
4
5
6
7
8
9
linux>
Valor
Tam
Tipo
Union
Vis
00000000
0
NOTYPE LOCAL DEFAULT
00000000
0
FILE
LOCAL DEFAULT
00000000
0
SECTION LOCAL DEFAULT
00000000
0
00000000
0
00000000
0
00000000
0
00000000
0
00000000 26
FUNC
GLOBAL DEFAULT
00000000
0
NOTYPE GLOBAL DEFAULT
Ind
UND
ABS
1
3
4
5
7
6
1
UND
Nombre
ejemplo.c
main
puts
readelf ejemplo.o r
La seccin de reubicacin '.rel.text' en el desplazamiento 0x35c contiene 2

entradas:
Desplazamiento
0000000D
00000012
Info
00000501
00000902
Tipo
R_386_32
R_386_PC32
Val. Simbolo
00000000
00000000
Nom. Simbolo
.rodata.str1.1
puts
Esta herramienta tambin permite examinar el contenido de cualquier seccin o

encabezado del programa. Por ejemplo, podemos visualizar las caractersticas
de todas las secciones, y observar el contenido de la seccin de datos de solo
lectura, la cual contiene la cadena programa de ejemplo:
linux>
readelf ejemplo.o S
29
Hay 11 encabezados de seccin, comenzando en el desplazamiento: 0xec:
Encabezados de Seccin:
[Nr]
Nombre
Tipo
Direc
Desp
Tam
ES
[ 0]
.text
NULL
00000000
000000
000000
00
[ 1]
.text
PROGBITS
00000000
000034
00001a
00
[ 2]
.rel.text
REL
00000000
00035c
000010
08
[ 3]
.data
PROGBITS
00000000
000050
000000
00
[ 4]
.bss
NOBITS
00000000
000050
000000
[ 5]
.rodata.str1.1
PROGBITS
00000000
000050
[ 6]
.comment
PROGBITS
00000000
[ 7]
.note.GNU-stack
PROGBITS
[ 8]
.shstrtab
[ 9]
[10]
Opt
En
Inf
Al
WA
00
WA
000014
01
AMS
000064
00002d
00
00000000
000091
000000
00
STRTAB
00000000
000091
000058
00
.symtab
SYMTAB
00000000
0002a4
0002a4
10
10
.strtab
SYMTAB
00000000
000344
000015
00
AX
Clave para Opciones:

W (escribir), A (asignar), X (ejecutar), M (mezclar), S (cadenas)
I (info), L (orden enlazado), G (grupo), x (desconocido)
O (se requiere procesamiento extra del SO) o (especfico del SO)
p (especfico del procesador)
linux>
readelf ejemplo.o x 5
Volcado hexadecimal de la seccin '.rodata.str1.1':

Direccin
ASCII
programa
0x00000000 6D 65 6A 65 20 65 64 20 67 6F 72 70 67 6F 72 70 ejem
0x00000010
6F 6C 70 plo
de
30
Las principales opciones de readelf son las siguientes:
-a
muestra toda la informacin contenida en el archivo
-h
muestra la informacin de encabezado del archivo ELF
-S
muestra la informacin de los encabezados de seccin
-s
muestra la tabla de smbolos
-r
muestra la informacin de relocalizacin
-x
vaca el contenido de la seccin especificada
El depurador gdb
Un
depurador es una aplicacin
que permite correr otros
programas,
permitiendo al usuario ejercer cierto control sobre los mismos a medida que los
estos se ejecutan, y examinar el estado del sistema (variables, registros,
banderas, etc.) en el momento en que se presente algn problema. El propsito
final de un depurador consiste en permitir al usuario observar y comprender lo
que ocurre dentro de un programa mientras el mismo es ejecutado.
En los sistemas operativos UNIX/LINUX, el depurador ms comnmente utilizado
es gdb, es decir el depurador de GNU. ste ofrece una cantidad muy extensa y
especializada de opciones. Es muy importante entender el hecho de que un
depurador trabaja sobre archivos ejecutables. Esto quiere decir que el mismo
funciona de forma independiente al lenguaje en que se escribi el programa
original, sea ste lenguaje ensamblador o un lenguaje de medio o alto nivel
como C.
Ejecucin de programas con el depurador
Para iniciar el depurador, se utiliza el comando gdb. Esto ocasionar que
aparezca un nuevo prompt simbolizado por la cadena (gdb), lo que indica que
el depurador est listo para recibir una orden (de forma similar al smbolo $ o #
en una cnsola de Linux):
linux> gdb
GNU gdb Red Hat Linux (6.3.0.0-1.21rh)
Copyright 2004 Free Software Foundation, Inc.
GDB is free software, covered by the GNU General Public License, and you are
welcome to change it and/or distribute copies of it under certain conditions.
Type "show copying" to see the conditions.
There is absolutely no warranty for GDB. Type "show warranty" for details.
This GDB was configured as "i386-redhat-linux-gnu".
(gdb)
31
Una vez dentro del depurador, existen diferentes comandos para analizar el
comportamiento de un programa. Un hecho a resaltar es la gran semejanza que
existe entre la cnsola proporcionada por GDB y la consola que comnmente
utilizamos para llevar a cabo todas las tareas en Linux. En particular, es
importante mencionar que la utilizacin del tabulador para completar los
comandos automticamente tambin funciona dentro de gdb. Tambin es
posible utilizar las teclas Flecha Arriba y Flecha Abajo para navegar por los
ltimos comandos que se han utilizado.
El comando help permite obtener ayuda sobre cada uno de los comandos. Esta
ayuda funciona de una forma jerrquica. Por ejemplo, si se utiliza el comando
help sin argumentos, se desplegar una lista con las principales categoras
sobre las cuales es posible obtener ayuda:
(gdb) help
List of classes of commands:
aliases -- Aliases of other commands
breakpoints -- Making program stop at certain points
data -- Examining data
files -- Specifying and examining files
internals -- Maintenance commands
obscure -- Obscure features
running -- Running the program
stack -- Examining the stack
status -- Status inquiries
support -- Support facilities
tracepoints -- Tracing of program execution without stopping the program
user-defined -- User-defined commands
Type "help" followed by a class name for a list of commands in that class.
Type "help" followed by command name for full documentation.
Command name abbreviations are allowed if unambiguous.
Sin embargo, es posible proporcionar informacin ms detallada para obtener la

ayuda sobre el comando preciso que se necesite. Por ejemplo, utilizando el
comando help info, se obtiene una lista de todos los comandos que comienzan
con la palabra info, tales como info registers, info variables o info stack. Una
vez que se pide ayuda sobre un comando completo, gdb muestra informacin
ms detallada acerca del mismo:
(gdb) help info registers
List of integer registers and their contents, for selected stack frame.
Register name as argument means describe only that register.
32
Dentro del depurador, el primer paso es cargar el programa ejecutable que se
quiere depurar. Para ello se utiliza el comando file. Por ejemplo, supongamos
que se desea depurar el programa de ejemplo que utilizamos en secciones
anteriores:
(gdb) file ejemplo
Reading symbols from /root/ejemplo...(no debugging symbols found)...done.
Using host libthread_db library "/lib/libthread_db.so.1".
El comando file no suele utilizarse, ya que (como veremos ms adelante)

existe una forma ms directa para indicar el archivo de entrada. Para ejecutar el
programa se utiliza el comando run:
(gdb) run
Starting program: /root/ejemplo
Reading symbols from shared object read from target memory...(no debugging symbols
found)...done.
Loaded system supplied DSO at 0x531000
(no debugging symbols found)
programa de ejemplo
Program exited normally.
Observe que el depurador intercala mensajes de depuracin con la salida del

programa (en este caso programa de ejemplo). En especial note que el
depurador indica que el programa termin normalmente. En caso de un error
que ocasione una terminacin prematura, el depurador mostrar la informacin
apropiada. Finalmente, para salir del depurador se utiliza el commando quit.
Ahora bien, supongamos que se tiene un programa llamado suma.s, que toma
un arreglo de N posiciones, calcula la suma de los elementos que se encuentran
en las posiciones impares (A[1], A[3], etc.), e indica si el resultado fue positivo,
negativo o cero:
33
RES0:
RESP:
RESN:
A:
N:
.section .data
.asciz "El resultado de la suma es cero (%d)\n"
.asciz "El resultado de la suma es positivo (%d)\n"
.asciz "El resultado de la suma es negativo (%d)\n"
.long 1,10,-8,7,14,-3,23,-52
.long 8
.section .text
.globl _start
_start:
xorl %eax, %eax

xorl %ecx, %ecx
# suma = 0
#i=0
ciclo:
cmpl N, %ecx
jge fciclo
movl A(,%ecx,4), %edx
addl %edx, %eax
addl $1, %ecx
jmp ciclo
pushl %eax
cmpl $0, %eax
je R0
jl RN
# Mientras i<N
pushl $RESP
jmp fin
pushl $RESN
jmp fin
pushl $RES0
jmp fin
# Segundo argumento del printf
call printf
addl $8, %esp
movl $1, %eax
xorl %ebx, %ebx
int $0x80
# Muestra el resultado
fciclo:
RP:
RN:
R0:
fin:
# Carga A[i]
# suma += A[i]
# i++
# Repite el ciclo
# Primer argumento del printf
# Seleccionar el mensaje
# Termina el programa
En teora, el programa calcula la suma de los elementos en las posiciones

impares, esto es:
A[1] + A[3] + A[5] + A[7] = 10 + 7 + (-3) + (-52) = -38.
Sin embargo, al ensamblar y ejecutar el programa el resultado fue el siguiente:
linux> gcc suma.s -o suma -nostartfiles
linux>./suma
El resultado de la suma es negativo (-8)
Si se analiza el programa, es muy fcil descubrir los errores que llevaron a este
resultado, ya que los mismos son evidentes. Sin embargo, recomendamos no
examinar el cdigo fuente, sino proseguir con la lectura. En las siguientes
34
pginas se utilizar el depurador para determinar lo que est ocurriendo, tal y
como se hara en un caso real en el que no se tenga acceso al cdigo fuente, o
los errores no sean tan evidentes como para detectarse por simple inspeccin.
Comandos bsicos de control
Todo depurador permite al usuario controlar la ejecucin del programa
analizado, indicando bsicamente cuando detener dicha ejecucin, o que
fragmentos del programa ejecutar. A continuacin se muestra una breve
descripcin de los comandos ms comnmente utilizados en el depurador gdb
para controlar la ejecucin de un programa:
break
Permite insertar un punto de parada (breakpoint), para detener la

ejecucin del programa cuando se alcance una instruccin especfica. La
misma puede ser especificada mediante una etiqueta o una direccin (con
un * delante).
watch
Permite insertar un punto de parada, para detener la ejecucin del

programa cuando una variable o registro sean modificados. El argumento
puede ser una etiqueta, una direccin (con un *) o un registro (con un $).
delete
Permite eliminar un punto de parada indicando su nmero como

argumento. Utilizando el argumento breakpoints se pueden eliminar
todos los puntos de parada.
info breakpoints
Muestra los puntos de parada insertados en el programa, as como

informacin referente a los mismos (nmero, tipo, direccin, funcin, etc.).
En particular es importante resaltar que muestra las veces que el mismo
ha sido alcanzado.
step
Ejecuta el programa hasta alcanzar la siguiente lnea de cdigo fuente (si

el mismo se encuentra disponible). Bsicamente permite ejecutar la
prxima instruccin del programa original escrito en lenguaje de alto nivel.
Si se especifica un entero N como argumento se ejecutan N instrucciones.
stepi
Ejecuta la prxima instruccin de lenguaje ensamblador del programa. Si

se especifica un entero N como argumento se ejecutan N instrucciones.
next
Similar al comando step, pero en caso de encontrarse una llamada a un

procedimiento, el mismo es tratado como si fuera una instruccin atmica
(es decir, no se lleva a cabo el recorrido interno del procedimiento
invocado).
finish
Si el programa se encuentra ejecutando un procedimiento, se procesan

todas las instrucciones siguientes hasta que el mismo retorne el control a
su invocador.
continue
Permite continuar ejecutando todas las instrucciones restantes del

programa, hasta que el mismo finalice, se produzca una excepcin o se
encuentre un punto de parada.
35
Para ejemplificar el uso de estos comandos, se proceder a depurar el programa
ejecutado en la seccin anterior. Esta vez se invocar al depurador pasando
como argumento el nombre del archivo ejecutable que se desea depurar, en
lugar de utilizar el comando file:
linux> gdb suma
Copyright 2004 Free Software Foundation, Inc.
GDB is free software, covered by the GNU General Public License, and you are
welcome to change it and/or distribute copies of it under certain conditions.
Type "show copying" to see the conditions.
There is absolutely no warranty for GDB. Type "show warranty" for details.
This GDB was configured as "i386-redhat-linux-gnu"...(no debugging symbols found)
(gdb)
A continuacin se insertar un punto de parada justo antes de entrar en el ciclo,

con el fin de determinar cuantas veces se ejecuta el mismo. Esto se hace de la
siguiente forma:
(gdb) break ciclo
Breakpoint 1 at 0x8048188
El depurador indica la direccin de memoria en la que se encuentra la

instruccin en la que se coloc el punto de parada, as como el nmero asociado
a ste. Estos nmeros no son reutilizados. Es posible insertar un punto de
parada utilizando una direccin en lugar de una etiqueta (debe aadirse un *).
Por ejemplo, con los siguientes comandos se eliminar el punto de parada que
acabamos de crear, y se insertar otro en su lugar,esta vez indicando la
direccin de la instruccin en la que se desea detener la ejecucin y no una
etiqueta:
(gdb) delete 1
(gdb) break *0x8048188
Es posible comprobar que efectivamente se ha eliminado el primer punto de

parada e insertado el segundo utilizando el commando info breakpoints:
(gdb) info breakpoints
Num Type
Disp Enb Address What
2 breakpoint keep y 0x08048188 <ciclo>
36
Dado que se est recorriendo un arreglo de 8 elementos, y solo se van a sumar
aquellos almacenados en las posiciones impares, el ciclo debera ejecutarse tan
solo cuatro veces. A continuacin se proceder a comenzar la ejecucin del
programa con el comando run. Cada vez que se alcance la etiqueta ciclo, el
depurador detendr la ejecucin:
(gdb) run
Starting program: /root/suma
Reading symbols from shared object read from target memory...(no debugging symbols
found)...done.
Breakpoint 1, 0x08048188 in ciclo ()
(gdb)
Se utilizar el comando continue las veces que sea necesario para continuar
ejecutando el programa hasta alcanzar el final del mismo. Si se cuentan las
veces que se ejecut el ciclo, nos damos cuenta de que el mismo se est
ejecutando ocho veces (el punto de parada es alcanzado nueve veces, pero en
esta ltima la comparacin se evala como falsa y no se entra al ciclo), es decir,
que al parecer el programa est recorriendo todos los elementos del arreglo y
sumndolos.
Para verificar esto, se insertar un punto de parada del tipo watch, utilizando el
comando del mismo nombre, para verificar cuando (y como) es modificada la
variable suma (que se encuentra en el registro %eax. Tambin se eliminar el
breakpoint anterior ya que ha dejado de ser til. Note que antes de realizar
estas acciones reiniciaremos la ejecucin el programa (en este caso es posible
utilizar el comando run, pues sabemos que se detendr la primera vez que
alcance la etiqueta ciclo):
(gdb) run

(gdb) delete 2
(gdb) watch $eax
Watchpoint 3: $eax
37
A partir de este momento se proceder de forma similar a como se hizo con el
punto de parada anterior, es decir, se utilizar el comando continue para
avanzar en la ejecucin y dejar que el depurador indique cuando el registro es
modificado. Si observa el programa original, notar que esto solo ocurre al
momento de sumar cada elemento del arreglo con el acumulador. Si nuestra
suposicin es correcta, y el problema del programa consiste en que se estn
sumando todos los elementos, el programa debera detenerse ocho veces, pues
el registro %eax ser modificado la misma cantidad de veces (una por cada
elemento sumado). Efectivamente:
(gdb) continue
Continuing.
Watchpoint 3: $eax
Old value = 0
New value = 1
0x08048199 in ciclo ()
(gdb) continue
Continuing.
Watchpoint 3: $eax
Old value = 1
New value = 11
0x08048199 in ciclo ()
(gdb) continue
Continuing.
Watchpoint 3: $eax
Old value = 11
New value = 3
0x08048199 in ciclo ()
Despus de utilizar tres veces el comando continue, comprobamos que

efectivamente en las tres primeras iteraciones se han sumado los tres primeros
elementos del arreglo (0+1=1; 1+10=11; 11-8=3;). Si se utiliza el comando
continue seis veces ms se verifica que efectivamente en cada iteracin se suma

un elemento del arreglo, sin importar que el mismo se encuentre en una
posicin par o no. Esto comprueba la conclusin a la que habamos llegado en la
seccin anterior. Esto posiblemente se deba a que el ndice i no se est
actualizando como debera. En la siguiente seccin se buscar comprobar este
hecho. Si realiza esta experiencia por su cuenta, notar que el programa no
finaliza, ya que como el registro %eax se modifica en el procedimiento printf, la
38
ejecucin se detiene en este punto. En este caso deje el depurador tal cual, en la
prxima seccin continuaremos desde aqu.
Comandos bsicos de inspeccin
En la seccin anterior se ejecut dos veces el programa. En la primera se utiliz
un breakpoint, mientras que en la segunda se utiliz un watchpoint. Si algo
qued claro de esta pequea experiencia, es que el segundo mtodo fue mucho
ms til a la hora de sacar conclusiones y comprobar hechos, simplemente
porque proporcion ms informacin que el primero (en este caso, el valor del
registro %eax).
Una vez que la ejecucin del programa se encuentra detenida (sin importar el
tipo de punto de parada utilizado o el motivo por el que se detuvo la ejecucin)
es posible inspeccionar el estado del programa. Entre las cosas que pueden ser
inspeccionadas se encuentran los registros de la mquina (no solo los de
propsito general sino tambin los de propsito especfico como el eflags o el
eip), el contenido de la memoria, y la pila actual de llamadas.
A continuacin se muestra una breve descripcin de los comandos ms
comnmente utilizados en el depurador gdb para inspeccionar el estado de un
programa en ejecucin:
info registers
Muestra el contenido de todos los registros. La primera columna indica su

valor hexadecimal (binario), mientras que la segunda el contenido del mismo
en decimal interpretado como un entero con signo representado en
complemento autntico.
print
Permite mostrar el contenido de un registro o posicin de memoria

escribiendo como argumento una expresin vlida en lenguaje C. Se permite
el uso de los operadores * y & para trabajar con apuntadores.
display
Similar al comando print. La diferencia consiste en que el resultado de evaluar

la expresin proporcionada se mostrar cada vez que la ejecucin se
detenga.
disassemble
Desensambla la fraccin del segmento de cdigo correspondiente a la funcin

que se est ejecutando actualmente (note que el depurador considera una
funcin a las instrucciones que se encuentran entre una etiqueta y la
siguiente).
info variables
Muestra todas las variables globales definidas.
info locals
Muestra todas las variables locales definidas.
backtrace
Muestra la pila activa de llamadas a funcin.
39
A continuacin se utilizarn algunos de estos comandos para comprobar que
efectivamente el ndice utilizado para recorrer el arreglo no se est actualizando
debidamente. Eliminamos el watchpoint anterior e insertamos un breakpoint en
la misma instruccin de suma (cuya direccin obtuvimos cada vez que la
ejecucin se detuvo al modificarse el registro %eax). La razn de hacer este
cambio es evitar que la ejecucin se detenga en cualquier otra parte del
programa en que se modifique %eax, como sucedi con el printf en la ejecucin
anterior:
(gdb) delete 3
(gdb) break *0x08048199
Ahora se proceder a ejecutar de nuevo el programa desde el comienzo. Dado

que la
ejecucin
actual
no
ha
finalizado
el
depurador solicitar
una
confirmacin. Una vez dada, el programa se detendr la primera vez que se

alcance la instruccin de suma:
(gdb) run
The program being debugged has been started already.
Start it from the beginning? (y or n) y
warning: cannot close "shared object read from target memory": Fichero en formato errneo
..
(gdb)
Una vez alcanzado el punto de parada es posible verificar el estado de los

registros mediante el comando info registers. Preste especial atencin al ndice
utilizado para recorrer el arreglo durante el ciclo, el mismo se encuentra en el
registro %ecx:
(gdb) info registers
eax
0x1
ecx
0x0
edx
0x1
ebx
0x1a2fc4
esp
0xbfeaa1e0
ebp
0x0
esi
0xbfeaa1ec
edi
0x8048184
eip
0x8048199
eflags
0x202
..
1
0
1
1716164
0xbfeaa1e0
0x0
-1075142164
134513028
0x8048199
514
40
Aqu se hace evidente el primer error: El ndice debera comenzar en uno, ya que
ste corresponde al primer elemento impar del arreglo. Sin embargo se observa
que el primer elemento que se carga es el que se encuentra en la posicin cero.
En este caso es el contenido del registro %edx (1), que es en donde se carg
previamente. Es posible utilizar el comando print para comprobar efectivamente
quienes son los elementos A[0], A[1] y A[%ecx] (este ltimo cargado en %edx)
(gdb) print *(&A+0)
$1 = 1
(gdb) print *(&A+1)
$2 = 10
(gdb) print *(&A+$ecx)
$3 = 1
Ahora bien, suponga que se desea visualizar exactamente la misma informacin

(el valor de i, y el valor de A[i]) cada vez que la ejecucin se detenga en la
instruccin de suma. Es posible automatizar este proceso mediante el uso del
comando display :
(gdb) display $ecx
10: $ecx = 0
(gdb) display *(&A+$ecx)
11: *(&{<data variable, no debug info>} 134517372 + $ecx) = 1
Utilizando el comando continue tres o cuatro veces, se observa la forma en la

que vara el ndice en cada iteracin del ciclo, y el elemento que es sumado a
acumulador en cada caso:
10: $ecx = 1
(gdb) continue
Continuing.
11: *(&{<data variable, no debug info>} 134517372 + $ecx) = -8
10: $ecx = 2
(gdb) continue
Continuing.
10: $ecx = 3
(gdb) continue
Continuing.
41
10: $ecx = 4
Esta pequea experiencia permite determinar el segundo error del programa: el

ndice se est actualizando de uno en uno, mientras que en cada iteracin
debera moverse dos posiciones (ya que se quiere sumar solo los elementos
impares). De esta forma, se puede concluir que las instrucciones a corregir en el
programa original son las siguientes:
xorl %ecx, %ecx
addl $1, %ecx
movl $1, %ecx

addl $2, %ecx
# El ndice se inicializa en uno.

# Obviar los elementos pares.
Sin embargo, no es necesario corregir las instrucciones y volver a compilar el

programa original. En la siguiente seccin se mostrar como probar las
correcciones sugeridas desde el depurador.
Alteracin de la ejecucin del programa

Mientras se est depurando un programa, es posible modificar el estado del
mismo (cambiando el valor de los registros o la memoria), y alternado en
consecuencia de forma indirecta la ejecucin del mismo. Esto es muy til
cuando se ha determinado un problema y se quiere probar la solucin de forma
rpida. En otras palabras, es un mecanismo que permite contestar preguntas del
tipo Qu pasara si este registro tuviera el valor 0? o Qu pasara si el
apuntador de la pila se encontrara una posicin ms arriba?.
A continuacin se muestra una breve descripcin de los comandos ms
comnmente utilizados para alterar el estado de un programa en ejecucin:
set
print
El comando set permite evaluar una expresin y asignar su resultado a un registro

o una posicin de memoria mediante el operador de asignacin. Se diferencia de
print en que el comando set no imprime el resultado en la cnsola.
Dado que el comando print evalua la expresin que se pasa como argumento (la
cual puede contener el operador de asignacin =) el mismo puede ser utilizado
para alterar el contenido de un registro o posicin de memoria.
display
Similar al comando print. La diferencia consiste en que la asignacin ser llevada a

cabo cada vez que la ejecucin se detenga.
jump
Este comando permite continuar la ejecucin en un punto del programa distinto a la

instruccin en que se detuvo. La instruccin a la que se saltar puede ser indicada
mediante una etiqueta o mediante una direccin (utilizando *).
42
Para ejemplificar el uso de estos comandos, se proceder a modificar los valores

del ndice en el programa anterior, con el fin de comprobar si efectivamente el
resultado ser correcto al cambiar las dos instrucciones determinadas en la
seccin anterior. El primer cambio (inicializar el ndice en uno y no en cero) se
realizar de forma manual mediante el uso del comando set. Para ello se debe
insertar un nuevo punto de parada en la primera instruccin del programa,
ubicada en la etiqueta _start:
(gdb) break _start
La segunda modificacin (incrementar el ndice de dos en dos), se simular

mediante el uso del comando display . Dado que existe un punto de parada
dentro del ciclo (en la instruccin de suma), y sabemos que en la versin actual
el ndice se incrementa en uno con cada iteracin, se proceder a asignarle al
ndice su valor ms uno (%ecx = %ecx + 1) cada vez que la ejecucin
se
detenga en dicho punto de parada:

(gdb) display $ecx=$ecx+1
12: $ecx = $ecx + 1 = 5
Finalmente se debe reiniciar la ejecucin del programa. Como en el caso

anterior, ser necesario confirmar. Observe que la ejecucin se detiene en la
primera instruccin:
(gdb) run
Breakpoint 5, 0x08048184 in _start ()

12: $ecx = $ecx + 1 = -1080108287
11: *(&{<data variable, no debug info>} 134517372 + $ecx) = Cannot access memory at
address 0x67ffe80
Disabling display 11 to avoid infinite recursion.
Note que el display que se haba insertado anteriormente (A[%ecx]) no pudo ser
procesado debido a que el valor original de %ecx ocasiona que la referencia a
memoria no sea vlida. El depurador automticamente deshabilitar este display
para los sucesivos puntos de parada que sean alcanzados. Es posible utilizar el
comando info display para comprobar cuales estn habilitados y cuales no
(observe la letra y o n que refleja este hecho):
43
(gdb) info display

Auto-display expressions now in effect:
Num Enb Expression
12: y $ecx = $ecx + 1
11: n *(&{<data variable, no debug info>} 134517372 + $ecx)
10: y $ecx
Hasta que la ejecucin no alcance el ciclo, no tiene sentido habilitar ningn
display. En consecuencia, conviene deshabilitarlos todos mediante el comando

disable display:
(gdb) disable display
(gdb) info display
Num Enb Expression
12: n $ecx = $ecx + 1
11: n *(&{<data variable, no debug info>} 134517372 + $ecx)
10: n $ecx
Ahora bien, sabemos que la ejecucin se encuentra detenida en la primera

instruccin del programa. Puede utilizarse el comando disassemble para
comprobar este hecho:
(gdb) disassemble
Dump of assembler code for function _start:
0x08048184 <_start+0>: xor %eax,%eax
0x08048186 <_start+2>: xor %ecx,%ecx
End of assembler dump.
Este comando desensambla por defecto la funcin en la que se encuentra la

prxima instruccin a ejecutar. Sin embargo, es posible especificar un rango de
direcciones a desensamblar, por ejemplo:
(gdb) disassemble 0x08048184 0x080481A0
Dump of assembler code from 0x8048184 to 0x80481a0:
0x08048184 <_start+0>: xor %eax,%eax
0x08048186 <_start+2>: xor %ecx,%ecx
0x08048188 <ciclo+0>: cmp 0x804929c,%ecx
0x0804818e <ciclo+6>: jge 0x804819e <fciclo>
0x08048190 <ciclo+8>: mov 0x804927c(,%ecx,4),%edx
0x08048197 <ciclo+15>: add %edx,%eax
0x08048199 <ciclo+17>: add $0x1,%ecx
0x0804819c <ciclo+20>: jmp 0x8048188 <ciclo>
0x0804819e <fciclo+0>: push %eax
0x0804819f <fciclo+1>: cmp $0x0,%eax
End of assembler dump.
44
En cualquier caso, lo importante es que luego de ejecutar las prximas dos
instrucciones el registro %ecx quedar inicializado en cero. En ese momento
corregiremos esto manualmente utilizando el comando set para inicializarlo en
uno:
(gdb) stepi 2
0x08048188 in ciclo ()
Note que la ejecucin se detuvo en la primera instruccin del ciclo (direccin

0x08048188). En este momento es posible modificar manualmente el ndice
(usando set), habilitar de nuevo los display (usando enable display), y proseguir
la ejecucin del programa (usando continue):
(gdb) set $ecx=1
(gdb) enable display
(gdb) continue
Continuing.
12: $ecx = $ecx + 1 = 2
11: *(&{<data variable, no debug info>} 134517372 + $ecx) = -8
10: $ecx = 2
Observe que el registro %ecx comenz el ciclo con un valor de uno. Ahora vale
dos, despus de efectuarse la suma ocasionada por el primer display .
Posteriormente se ejecutar la instruccin que lo incrementaba en uno en el
programa original, con lo cual en la prxima iteracin del ciclo el registro
contendr el valor tres, luego cinco y as sucesivamente. Es decir, que los
cambios han funcionado.
Sin embargo, note que el display 11 (este nmero puede variar) indica que el
elemento cargado fue -8, que en realidad no es el elemento A[1] sino A[2]. No
se deje engaar, esto simplemente es consecuencia de que la expresin del
display 11 es evaluada luego de que el display 12 ha actualizado %ecx

incrementndolo en uno. El valor que realmente se carg se encuentra en el
registro %edx:
(gdb) print $edx
$5 = 10
45
Efectivamente, el elemento A[1] es 10. Es posible dejar el display tal y como
est, y el resultado ser correcto ya que el mismo no afecta a la ejecucin del
programa. Sin embargo, conviene modificarlo para poder observar de forma
correcta el elemento cargado y el ndice utilizado en las iteraciones restantes:
(gdb) display $edx
13: $edx = 10
(gdb) display $ecx
14: $ecx = 2
(gdb) delete display 10
(gdb) delete display 11
(gdb) info display
Num Enb Expression
14: y $ecx
13: y $edx
12: y $ecx = $ecx + 1
(gdb)
Utilizando cuatro veces ms el comando continue, se completarn las tres

iteraciones restantes, mostrando en cada una de ellas los valores correctos de i
(%ecx) y A[i] (%edx). De igual forma compruebe que el resultado es correcto (38), y coincide con lo que habamos pronosticado al analizar el comportamiento
del programa original:
(gdb) continue
Continuing.
16: $ecx = 3
15: $edx = 7
14: $ecx = $ecx + 1 = 4
(gdb) continue
Continuing.
16: $ecx = 5
15: $edx = -3
14: $ecx = $ecx + 1 = 6
(gdb) continue
Continuing.
16: $ecx = 7
15: $edx = -52
14: $ecx = $ecx + 1 = 8
(gdb) continue
Continuing.
El resultado de la suma es negativo (-38)
Program exited normally.
46
Una vez que estamos seguros de los errores y de la efectividad de las soluciones
propuestas, podemos modificar las instrucciones adecuadas en el programa
original, no solo con la certeza de que al compilarlo de nuevo el programa
funcionar de forma adecuada, sino con el conocimiento de cual era el problema
y con una justificacin clara de porqu las modificaciones hechas han sido
exitosas.
Uso de la opcin g de gcc

En caso de que contar con el cdigo fuente del programa que se desea depurar,
es posible compilarlo de una forma especial en la que se agregan nuevas
secciones (.debug, .line) que contienen informacin para facilitar el proceso de
depuracin, tales como la correspondencia entre las lneas del programa
original en lenguaje C y las instrucciones en lenguaje ensamblador.
Para incluir estas secciones en un archivo ejecutable, el mismo debe ser
compilarlo utilizando la opcin g. Por ejemplo vamos a compilar el archivo
ejemplo.c utilizando la opcin (ejemplo1) y sin utilizarla (ejemplo2). Compare
la diferencia de tamao entre los archivos:
linux> gcc ejemplo.c -o ejemplo1 -g
linux> gcc ejemplo.c -o ejemplo2
linux> ll example?
-rwxr-xr-x 1 root root 5805 jul 26 11:28 ejemplo1
-rwxr-xr-x 1 root root 4693 jul 26 11:29 ejemplo2
Esta diferencia de tamao (aproximadamente un 25%) se debe a que el primer

archivo contiene una cantidad de informacin adicional con fines de depuracin.
En general es recomendable utilizar esta opcin mientras se estn realizando
pruebas con el programa, pero una vez que se vaya a compilar la versin final,
nunca utilice esta opcin. Esto en primer lugar para generar un archivo ms
compacto, pero la razn de mayor peso es proporcionar la menor cantidad de
informacin posible que pueda ser utilizada para llevar a cabo procesos de
ingeniera reversa con su programa.
47
Veamos algunos ejemplos de la informacin adicional incluida mediante el uso
del comando g. En primer lugar, observe lo que ocurre al intentar utilizar los
comandos mostrados a continuacin con el programa que no contiene
informacin adicional:
[root@localhost ~]# gdb ejemplo2
..
This GDB was configured as "i386-redhat-linux-gnu"...(no debugging symbols found)
(gdb) list 4,7
No symbol table is loaded. Use the "file" command.
(gdb) info line 5
No symbol table is loaded. Use the "file" command.
(gdb) break main
(gdb) run
Starting program: /root//ejemplo2
Reading symbols from shared object read from target memory...
(no debugging symbols found)...done.
Breakpoint 1, 0x08048382 in main ()
Note las secciones resaltadas en negrita. Al cargar el programa, gdb no

encontr informacin de depuracin, y en consecuencia ninguno de los
comandos especializados que se probaron funcionaron. En el caso del archivo
compilado con la informacin de depuracin si tienen efecto:
[root@localhost ~]# gdb ejemplo1
This GDB was configured as "i386-redhat-linux-gnu"...
(gdb) list 4,7
4
{
5
printf("programa de ejemplo\n");
6
return 0;
7
}
(gdb) info line 5
Line 5 of "ejemplo.c" starts at address 0x8048398 <main+28> and ends at 0x80483a8
<main+44>.
(gdb) break main
Breakpoint 1 at 0x8048398: file ejemplo.c, line 5.
48
(gdb) run
Starting program: /root/ejemplo1
Reading symbols from shared object read from target memory...done.
Breakpoint 1, main () at ejemplo.c:5
5
printf("programa de ejemplo\n");
Note lo fcil que resulta relacionar las instrucciones de alto nivel con sus
correspondientes instrucciones en lenguaje de mquina utilizando el depurador.
Adems cada vez que el programa alcance un punto de parada, mostrar
informacin adicional referida al cdigo fuente original. Se deja al lector la tarea
de investigar que otros comandos adicionales provee gdb para ser utilizados
con aquellos archivos que contienen informacin de depuracin.
Conclusiones y detalles finales

El depurador es una herramienta extremadamente til para todo programador,
no importa el nivel en que escriba el cdigo, el lenguaje que utilice o el rea a la
que se dedique. En el mundo real se presenta una gran cantidad de situaciones
en las que tenemos que depurar programas hechos por otras personas, bien sea
compaeros de trabajo o empresas de desarrollo de software. En la mayor parte
de estos casos no contamos con el cdigo fuente o la documentacin adecuada.
An cuando se trata de cdigo propio, el uso de un depurador no slo permite
corregir los errores en menos tiempo sino que a la hora de reportar cual era la
falla o la forma en la que se solucion se tiene informacin slida que respalda
los cambios.
Por todo esto y mucho ms es importante el aprender a utilizar un depurador.
Obviamente es necesario tener una idea lo suficientemente clara del lenguaje
ensamblador y sus principios bsicos de funcionamiento de un computador
moderno. No es necesario ser un experto en determinado lenguaje ensamblador
o en depurador especfico, ya que cualquiera de estos puede cambiar. Lo que es
realmente importante es comprender el funcionamiento general del depurador,
con
el
fin
de
poder aprender a
utilizar
de forma
efectiva
implementacin del mismo.
cualquier
49
Para finalizar, se enumeran algunos detalles del depurador gdb que son muy
tiles y permiten agilizar mucho el proceso de depuracin una vez que se ha
adquirido la prctica necesaria:
Es posible presionar simplemente la tecla ENTER sin escribir nada en la

consola del depurador para repetir el ltimo comando. Esto es
sumamente til para realizar una ejecucin paso a paso (se ejecuta una
instruccin
con
el
comando
stepi
luego
se
presiona
ENTER
sucesivamente para avanzar de una instruccin a otra).
Es posible escribir un comando de forma incompleta si el mismo puede

ser interpretado sin ambigedad por el depurador. Por ejemplo, se
pueden utilizar los comandos del 1 o dele 1 para eliminar el punto de
parada nmero 1 (en lugar de escribir delete 1). Sin embargo no es vlido
utilizar el comando de 1, ya que existen otros dos comandos que
comienzan con esas dos letras (define y detach).
Si se desea depurar un programa que recibe argumentos desde la lnea

de comandos, es posible hacerlo, especificando los mismos como
parmetros del comando run. Por ejemplo, suponga que se tiene un
programa llamado cuadrado, el cual toma como argumento un entero e
imprime el cuadrado del mismo. En condiciones normales se podra
ejecutar como ./cuadrado 2. Para depurar esta ejecucin, primero se
carga el programa en el depurador (gdb cuadrado), y a continuacin se
ejecuta pasando el argumento como parmetro al comando run ( run 2).
50
Captulo 3. El programa en lenguaje ensamblador

Definiciones generales
Todo programa en lenguaje ensamblador tiene una estructura similar y utiliza
elementos comunes. Los conceptos ms importantes que se deben manejar son
los siguientes:
Directiva- una directiva es una lnea de programa que provee informacin para
el ensamblador. Las directivas comienzan con un punto (.).
Identificador: Es una letra seguida de cualquier cantidad de letras o dgitos (y en
algunos casos caracteres especiales).
Etiqueta- Es un smbolo (identificador) que identifica una lnea de programa, va
seguida de dos puntos (:).
Instruccin- Las instrucciones son los enunciados que el ensamblador traduce a
un programa objeto.
Comentario- Texto que aparece despus de un caracter de inicio de comentario
(#), el ensamblador ignora los comentarios. Son muy importantes para
desarrollar programas legibles.
Secciones
Un programa escrito en lenguaje ensamblador se compone de varias secciones.
Las secciones ms comunes son: la seccin de texto, la seccin de datos y la
seccin bss.
En la seccin de texto se escriben las instrucciones, en la seccin de datos los
datos inicializados y en la seccin bss las variables sin inicializar.
Cada una de las secciones se declara por medio de una directiva. Para declarar
las secciones mencionadas se usan las siguientes directivas:
.section .text para la seccin de texto (instrucciones)
.section .data para la seccin de datos (datos inicializados)
.section .bss
para la seccin bss (datos sin inicializar)
Comnmente las secciones se colocan en la siguiente secuencia:

.section .data
.section .bss
.section .text
51
Las siglas bss corresponden a "block storage start", que significa inicio de
bloque de almacenamiento.
La ventaja de declarar variables en la seccin .bss es que esos datos no se
incluyen en el programa ejecutable y por lo tanto el tamao total del programa
es menor al tamao generado por la declaracin equivalente en la seccin .data.
A diferencia de las secciones de datos y bss, la seccin de texto es de solo
lectura. Esto quiere decir que la misma no puede ser modificada en tiempo de
ejecucin. El propsito de esto consiste en que si existen mltiples instancias
del programa ejecutndose, todas comparten la misma seccin de texto (se
carga una sola vez en memoria), mientras que cada una tiene su propia seccin
de datos y/o bss.
Sin embargo, existen datos dentro de un programa que nunca son modificados,
tales como las constantes, o los literales no asociados a una variable (como la
cadena Hola Mundo utilizada en la llamada a printf en el captulo anterior).
Con el fin de compartir estos datos de la misma forma que ocurre con las
instrucciones, los mismos pueden ser almacenados dentro de una seccin
especial llamada rodata (Read Only Data, Datos de solo lectura). La misma se
comporta de la misma forma que la seccin de datos, pero no permite
operaciones de escritura sobre los datos declarados dentro de la misma.
Punto de inicio
Cuando se realiza la traduccin del programa en lenguaje ensamblador a un
archivo ejecutable, el enlazador necesita saber el punto de inicio en el cdigo.
Para ello se declara una etiqueta: _start la cual indica a partir de qu instruccin
se comienza a ejecutar el cdigo.
Esta etiqueta debe ser declarada como global, es decir, que est disponible para
aplicaciones externas; esto se logra utilizando la directiva .globl.
Finalizacin del programa

El lenguaje ensamblador gas no provee una instruccin de fin de ejecucin, esto
se logra mediante una llamada al sistema. Para realizar esta llamada se pasan
dos parmetros: el valor 1 en el registro %eax indica el cdigo de llamada a exit
(salida); el valor 0 en el registro %ebx indica la salida normal del programa.
52
La finalizacin se realiza de la siguiente manera:
movl $1, %eax
movl $0, %ebx
int $0x80
# cdigo de llamada a exit

# salida normal
# llamada al sistema
Otra manera de finalizar el programa es llamando a la funcin "exit", para ello

se debe pasar el valor cero como parmetro y luego invocar la funcin de la
siguiente manera:
pushl $0
call exit
# pasa 0 como parmetro (salida normal)

# llamada a la funcin de salida
Estructura general
En general la estructura de un programa en lenguaje ensamblador tiene la
siguiente forma:
.section .data
# aqui se declaran variables inicializadas
.section .bss
# aqui van las variables declaradas pero sin inicializar
.section .text
.globl _start
_start:
# esta etiqueta indica el inicio del programa principal
# aqui van las instrucciones
movl $1, %eax

movl $0, %ebx
int $0x80
# estas tres instrucciones corresponden a

# la finalizacin del programa
53
Captulo 4. Definicin de datos

En las secciones de datos se definen diferentes tipos de datos tales como
variables inicializadas o no, formatos de lectura y escritura, mensajes a mostrar
por pantalla, etc.
Definicin de datos inicializados

En la seccin .data se definen los datos inicializados, para ello se pueden utilizar
las siguientes directivas:
Directiva
.ascii
.asciz
.string
.byte
.double
.float
.long
.int
.octa
.quad
.short
Tipo de dato
cadena de caracteres
cadena de caracteres con caracter de culminacin (null)
equivalente a .asciz
valor de un byte (8 bits)
nmero de punto flotante precisin doble (64 bits)
nmero de punto flotante precisin simple (32 bits)
nmero entero de 4 bytes (32 bits)
equivalente a .long
nmero entero de 16 bytes
El formato para estas directivas es el siguiente:
etiqueta: directiva valor

Ejemplo: declaracin de variables inicializadas
.section .data
cadena:
.ascii abcdefghijk
var1:
.long 0
var2:
.float 3.14
var3:
.double 2345.7865
En este ejemplo se declara una cadena de caracteres llamada cadena cuyo

contenido es: abcdefghijk; una variable entera de 32 bits llamada var1 que
se inicializa en cero, una variable punto flotante de 32 bits llamada var2 que
se inicializa con el valor 3.14 y una variable punto flotante de 64 bits llamada
var3 que se inicializa con el valor 2345.7865, ntese que el lenguaje utiliza el
punto para los decimales.
54
Se pueden definir mltiples valores en la misma lnea. Cada uno de ellos ser
guardado en memoria en el orden en el cual fueron declarados.
Ejemplo: declaracin de mltiples valores con una misma etiqueta
.section .data
var: .long 10, 20, 30, 40, 50
En este caso cuando se lee la variable var arroja el valor 10, para poder leer el
siguiente valor se debe incrementar la direccin de var en 4 bytes (debido a que
la variable est declarada como long, es decir de 32 bits) de esta manera se usa
la etiqueta var como la direccin inicial de estos valores y su tratamiento es el
de un arreglo donde cada acceso se realiza tomando var como posicin inicial
lo cual sera equivalente a decir var[0] y las posiciones siguientes como un
desplazamiento de 4 bytes cada uno. Para leer por ejemplo el valor 30 se accede
como var+8.
Cuando se definen las variables el sistema las guarda en forma consecutiva en
memoria. Por ejemplo si se definen variables de 16 bits y luego se leen usando
instrucciones de 32 bits el sistema no produce un mensaje de error y accede los
bytes consecutivos leyendo datos no vlidos.
Estas directivas tambin se pueden utilizar en la seccin .rodata la cual es de
solo lectura tomando en consideracin que los valores de las variables no
podrn ser modificados.
Definicin de constantes
Las constantes se pueden definir en cualquier parte del programa, sin embargo
se recomienda hacerlo en la seccin de definicin de datos (.data o .rodata) por
claridad del programa. La definicin de constantes se hace usando la directiva
.equ, el formato para esta directiva es:
directiva smbolo, valor

Ejemplo: definicin de constantes
.section .data
.equ escala, 32
55
Cuando se declara una constante su valor no puede ser modificado por el
programa. Esta declaracin "nombra" el valor 32 como escala. La constante se
puede utilizar como un inmediato, como desplazamiento o como direccin de
memoria. Cuando se usa como un inmediato se debe anteponer un smbolo de
dlar, en este caso para usar escala como inmediato se coloca: $escala.
Definicin de datos sin inicializar

En la seccin .bss se definen variables sin inicializar, es decir se reserva espacio
en memoria y se nombra con una etiqueta. Para definir datos en la seccin .bss
se usan las directivas:
Directiva
.comm
.space
.lcomm
Descripcin
declara un rea de memoria para datos sin inicializar
equivalente a .comm
declara un rea local de memoria para datos sin inicializar
La directiva .lcomm se usa para datos locales, que no sern usados fuera del
cdigo local.
El formato, para estas directivas es el siguiente:
etiqueta directiva, tamao en bytes

Ejemplo: declaracin de un rea de memoria sin inicializar
.section .bss
area: .space, 100
Se declara una variable llamada area de 100 bytes de tamao.

La ventaja de declarar variables en la seccin .bss es que esos datos no se
incluyen en el programa ejecutable y por lo tanto el tamao total del programa
es menor al tamao generado por la declaracin equivalente en la seccin .data.
56
Captulo 5. Instrucciones
Las instrucciones en gas tienen un sufijo que indica el tamao del dato sobre el
cual acta la instruccin.
Sufijo
b
w
l
Tamao
byte
word (2 bytes)
long (4 bytes)
El nmero de operandos de una instruccin vara dependiendo de la instruccin

en particular. En general las instrucciones tienen la forma:
instruccin operando fuente, operando destino

Los operandos se pueden clasificar en tres tipos:
Inmediato: para valores constantes.
Registro: denota el contenido de uno de los registros.
Referencia a memoria: denota el contenido de una posicin de memoria

direccionada por la referencia.
Hay varias maneras de obtener la informacin las cuales se pueden resumir en

la siguiente tabla:
Tipo de direcionamiento
Inmediato
Por registro
Absoluto
Indirecto
Base+desplazamiento
Indexado
Indexado
Escalado
Escalado
Escalado
Escalado
Expresin
$inm
reg
Inm
(reg)
Inm(reg)
(regb, regi)
Inm(regb, regi)
(, regi, e)
Inm(, regi, e)
(regb, regi, e)
Inm(regb, regi, e)
Valor del operando

Inm
R[reg]
M[inm]
M[R[reg]]
M[Inm+R[reg]]
M[R[regb]+R[regi]]
M[Inm+R[regb]+R[regi]]
M[R[regi]*e]
M[Inm+R[regi]*e]
M[R[regb]+R[regi]*e]
M[Inm+R[regb]+R[regi]*e]
inm denota un inmediato.

reg denota un registro, regb un registro base y regi un registro ndice.
e es la escala la cual puede ser 1, 2, 4 8.
R[reg] significa el contenido del registro reg.
M[x] significa el contenido de la posicin de memoria con direccin x.
57
Ejemplo: valores
para
cada
contenidos de: %eax= 0x100

Expresin
$inm
reg
Inm
(reg)
Inm(reg)
(regb, regi)
Inm(regb, regi)
(, regi, e)
Inm(, regi, e)
(regb, regi, e)
Inm(regb, regi, e)
modo
de
direccionamiento, asumiendo
los
y %ecx= 0x10
Ejemplo
$0x65
%eax
0x120
(%eax)
8(%eax)
(%eax, %ecx)
8(%eax, %ecx)
(, %eax, 4)
8(, %eax, 4)
(%eax, %ecx, 2)
12(%eax, %ecx, 2)
Valor del operando

Inm
R[reg]
M[inm]
M[R[reg]]
M[Inm+R[reg]]
M[R[regb]+R[regi]]
M[Inm+R[regb]+R[regi]]
M[R[regi]*e]
M[Inm+R[regi]*e]
M[R[regb]+R[regi]*e]
M[Inm+R[regb]+R[regi]*e]
Valor
0x65
0x100
M[0x120]
M[0x100]
M[0x108]
M[0x110]
M[0x118]
M[0x400]
M[0x408]
M[0x120]
M[0x12C]
El valor inmediato se puede expresar en decimal o en hexadecimal como se

puede observar en el siguiente ejemplo:
Asumiendo el contenido de %eax=0x100
Operando
12(%eax)
0xC(%eax)
Expresin
M[12+contenido de %eax]
M[0xC+contenido de %eax]
Valor
M[0x10C]
M[0x10C]
Instrucciones de movimiento de datos

La instruccin mov
La instruccin mov permite el movimiento de datos, ya que gas utiliza un prefijo
para sealar el tamao de los datos podemos tener tres opciones al momento
de realizar una transferencia de datos:
El formato de la instruccin es:
Instruccin
movb Fuente, Destino
Efecto
DestinoFuente
Descripcin
mueve 1 byte
movw Fuente, Destino
DestinoFuente
mueve 2 bytes
movl Fuente, Destino
DestinoFuente
mueve 4 bytes
inmediato
inmediato
registro
registro
memoria
Operandos Vlidos
registro
memoria
registro
memoria
registro
Ejemplo
movl $25, %eax
movb $10, etiqueta
movw %bx, %ax
movl %eax, etiqueta
movl etiqueta, %eax
58
Movimiento de datos inmediatos a registro o a memoria
Los datos inmediatos se especifican directamente en la instruccin. Deben estar
precedidos por el smbolo dlar para indicar que son datos inmediatos. Pueden
estar expresados en decimal o hexadecimal.
Ejemplos:
movb
movw
movl
movl
movl
$45, %ah
$123, %ax
$85, %eax
$5678, %eax
$0x100, %ebx
#
#
#
#
#
movl
movl
$12, 0x100
$12, a
#
#
#
#
#
#
movl $27, (%ecx)
mueve 45 al registro de 8 bits %ah

mueve el valor 123 al registro %ax
mueve el valor 85 al registro %eax
mueve el valor 5678 al registro %eax
mueve el valor 0x100 en hexadecimal al
registro %ebx
mueve 12 a la posicin de memoria 0x100
mueve 12 a la posicin de memoria etiquetada
a, esta variable debe estar previamente
definida
mueve 27 a la posicin de memoria cuya
direccin est en %ecx
Movimiento de datos entre registros

Esta es la transferencia de datos que toma menor tiempo dentro del sistema, es
buena prctica de programacin utilizar este tipo de transferencia en vez de
accesos a memoria ya que ello redunda en una mayor eficiencia.
Ejemplos:
movb
movw
movl
%ah, %bl
%ax, %bx
%eax, %ebx
# mueve el contenido de %ah a %bl (1 byte)

# mueve el contenido de %ax a %bx (2 bytes)
# mueve el contenido de %eax a %ebx (4 bytes)
Movimiento de datos entre memoria y registros

Las direcciones de memoria usualmente se expresan con etiquetas, cuando por
ejemplo se escribe:
movl
%eax, a
# mueve el contenido de %eax a memoria

comenzando en la direccin a
Como se estn transfiriendo 4 bytes stos sern guardados en memoria de

manera consecutiva a partir de la posicin a.
Para mover la informacin de memoria a un registro se escribe:
movl
a, %eax
# mueve el contenido de la memoria desde la

posicin a, transfiere 4 bytes a %eax
59
Movimiento de datos con extensin
Hay dos instrucciones adicionales que permiten mover datos extendindolos.
Instruccin
movsbl Fuente, Destino
Efecto
Destino Fuente (signo extendido)
Descripcin
mueve un byte signo extendido
movzbl Fuente, Destino
Destino Fuente (cero extendido)
mueve un byte cero extendido
registro
registro
memoria
Operandos Vlidos
registro
memoria
registro
Ejemplo
movsbl %bx, %eax
movzbl %eax, etiqueta
movsbl etiqueta, %eax
La instruccin movsbl toma un operando fuente de 1 o 2 bytes, ejecuta una

extensin de signo a 4 bytes y lo copia al destino de 4 bytes.
La instruccin movzbl hace un procedimiento similar pero extiende con ceros.
Ejemplo de movsbl:
movsbl %bl, %eax
# extiende el valor de 8 bits en %bl a 32 bits

usando el bit de signo
Ejemplo de movzbl:
movzbl %bl, %eax
# extiende el valor de 8 bits en %bl a 32 bits

rellenando con ceros
Carga direccin efectiva (instruccin leal)

La instruccin leal (load effective address) permite obtener la direccin de un
operando en vez de su valor.
Instruccin
leal Fuente, Destino
memoria
Efecto
Destino<- direccin de Fuente
Operandos Vlidos
registro
Descripcin
Carga la direccin efectiva
Ejemplo
leal etiqueta, %eax
Ejemplo:
leal a, %eax
# actualiza el registro %eax con la direccin de a
Existe otra manera de realizar esta operacin utilizando la instruccin movl y

anteponiendo el smbolo de dlar a la etiqueta que representa la posicin de
memoria, esta solucin se basa en el uso de direccionamiento indirecto. Para
cargar %eax con la direccin de a se puede, entonces, escribir:
movl $a, %eax
Lo cual tendr un resultado equivalente a la instruccin leal anterior.
60
Programa de ejemplo con varios movimientos de datos.
.section
a: .long
b: .long
c: .long
.data
25
42
5
# a=25
# b=42
# c=5
.section .text
.globl _start
_start:
movl a, %eax
movl b, %ebx
movl c, %ecx
movl %ecx, %eax
movl %eax, a
leal a, %ecx
movl %ebx, (%ecx)
movl $a, %ecx
movl $1, %eax
movl $0, %ebx
int $0x80
#
#
#
#
#
#
#
#
#
%eax=a=25
%ebx=b=42
%ecx=c=5
%eax=%ecx=5
a=%eax=5
%ecx=direccin de a
a=%ebx=42
%ecx=direccin de a
finalizacin del programa
Uso de la pila
La pila es un rea de memoria que crece desde una direccin inicial hacia
direcciones menores. El ltimo elemento colocado en la pila es el que est
disponible para ser retirado.
Las instrucciones para el manejo de la pila son dos, una para apilar un operando
fuente y una para desapilar el valor que est en el tope de la pila y colocarlo en
un operando destino.
Instruccin push (apilar)
Instruccin
pushw Fuente
Efecto
R[%esp] R[%esp]-2
M[R[%esp]] Fuente
pushl Fuente
R[%esp] R[%esp]-4
M[R[%esp]] Fuente
Operandos Vlidos
inmediato
registro
memoria
Descripcin
Actualiza el apuntador %esp y luego
coloca Fuente en el tope de la pila (2 bytes)
Actualiza el apuntador %esp y luego
coloca Fuente en el tope de la pila (4 bytes)
Ejemplo
pushw $7
pushl %eax
pushl etiqueta
61
Instruccin pop (desapilar)
Instruccin
popw Destino
Efecto
Descripcin
lee el valor del tope de la pila, lo guarda en Destino y
luego actualiza %esp (dato de 2 bytes)
Destino M[R[%esp]]
R[%esp] R[%esp]+2
popl Destino
lee el valor del tope de la pila, lo guarda en Destino y

luego actualiza %esp (dato de 4 bytes)
Destino M[R[%esp]]
R[%esp] R[%esp]+4
Operandos Vlidos
registro
memoria
Ejemplo
popw %ax
popl etiqueta
Ejemplo de uso de las instrucciones pushl y popl:

Dados los valores iniciales:
%esp=0x108
%eax=15
%ebx=43
%ecx=28
La direccin se encuentra expresada en hexadecimal y los contenidos de los

registros en decimal.
Al ejecutarse las instrucciones:
1
2
3
4
5
6
pushl %eax
pushl %ebx
popl %eax
pushl %ecx
popl %ebx
popl %ecx
Ocurre lo siguiente:
1
2
3
4
5
6
pushl %eax
pushl %ebx
popl %eax
pushl %ecx
popl %ebx
popl %ecx
%esp=%esp-4
%esp=%esp-4
%eax= M[%esp]
%esp=%esp-4
%ebx= M[%esp]
%ecx= M[%esp]
%esp=0x104
%esp=0x100
%eax=M[0x100]
%esp=0x100
%ebx=M[0x100]
%ecx=M[0x104]
M[%esp]=%eax
M[%esp]=%ebx
%eax=43
M[%esp]=%ecx
%ebx=28
%ecx=15
M[0x104]=15
M[0x100]=43
%esp=%esp+4
M[0x100]=28
%esp=%esp+4
%esp=%esp+4
%esp=104
%esp=104
%esp=108
Y en la pila las direcciones y los contenidos sern:

1: pushl %eax
2:pushl %ebx
%esp
%esp
0x104
0x108
15
4:pushl %ecx
%esp
0x100
0x104
0x108
28
15
0x100
0x104
0x108
43
15
3: popl %eax
%esp
0x100
0x104
0x108
5:popl %ebx
%esp
0x100
0x104
0x108
43
15
6: popl %ecx
28
15
%esp
0x100
0x104
0x108
28
15
62
1: Al apilar el contenido de %eax se decrementa %esp en 4 bytes y se coloca el

valor contenido en %eax en la pila, en este caso 15.
2: Al apilar %ebx, se decrementa %esp otros 4 bytes y se coloca el valor, 43 en la
pila.
3: Cuando se lee el contenido de la pila y se coloca el valor en %eax, la mquina
lee el valor en el tope de la pila, en este caso 43 y lo actualiza en el registro
%eax, por lo tanto %eax ahora tendr 43 como contenido. Luego se suman 4
bytes al apuntador %esp.
4: Al ejecutar de nuevo una instruccin de apilar, como en este caso apilar %ecx,
se vuelve a decrementar %esp y se coloca el nuevo valor en el tope de la pila el
cual es el nmero 28.
5: Con la nueva instruccin de desapilar se lee el tope de la pila, que contiene
28 y se actualiza el registro operando de la instruccin, en este caso %ebx; a
partir de este momento %ebx tendr el nuevo valor 28. Luego se incrementa
%esp.
6: Con esta instruccin ocurre algo similar a la anterior, se lee el tope de la pila,
el valor 15 y se actualiza en el registro operando, es decir %ecx, luego se suman
4 bytes a %esp y ste vuelve a la direccin inicial.
Instrucciones aritmticas y lgicas

Cuando
se
ejecutan
estas
instrucciones
las
banderas
son
actualizadas
automticamente.
add (suma)
Instruccin
addb Fuente, Destino
Efecto
DestinoDestino + Fuente
Descripcin
suma operandos de 1 byte
addw Fuente, Destino
suma operandos de 2 bytes
addl Fuente, Destino
suma operandos de 4 bytes
inmediato
inmediato
registro
registro
memoria
Operandos Vlidos
registro
memoria
registro
memoria
registro
Ejemplo
addl $15, %eax
addb $10, etiqueta
addw %bx, %ax
addl %eax, etiqueta
addl etiqueta, %eax
63
sub (resta)
Instruccin
subb Fuente, Destino
Efecto
DestinoDestino - Fuente
Descripcin
resta operandos de 1 byte
subw Fuente, Destino
resta operandos de 2 bytes
subl Fuente, Destino
resta operandos de 4 bytes
inmediato
inmediato
registro
registro
memoria
Operandos Vlidos
registro
memoria
registro
memoria
registro
Ejemplo
subl $15, %eax
subb $10, etiqueta
subw %bx, %ax
subl %eax, etiqueta
subl etiqueta, %eax
inc (incremento)
Instruccin
incb Destino
Efecto
DestinoDestino + 1
Descripcin
incrementa operando de 1 byte
incw Destino
DestinoDestino + 1
incrementa operando de 2 bytes
incl Destino
DestinoDestino + 1
incrementa operando de 4 bytes
Operandos Vlidos
registro
memoria
Ejemplo
incw %ax
incl etiqueta
dec (decremento)
Instruccin
decb Destino
Efecto
DestinoDestino - 1
Descripcin
decrementa operando de 1 byte
decw Destino
DestinoDestino - 1
decrementa operando de 2 bytes
decl Destino
DestinoDestino - 1
decrementa operando de 4 bytes
Operandos Vlidos
registro
memoria
Ejemplo
decw %ax
decl etiqueta
64
neg (negacin aritmtica)
Esta instruccin cambia el signo del operando para ello realiza el complemento
a 2 del nmero.
Instruccin
negb Operando
Efecto
Operando - Operando
Descripcin
niega operando de 1 byte
negw Operando
Operando - Operando
niega operando de 2 bytes
negl Operando
Operando - Operando
Operandos Vlidos
registro
memoria
Ejemplo
negl %eax
negl etiqueta
not (negacin lgica)

Esta instruccin ejecuta la operacin lgica NOT sobre el operando, es decir
invierte los bits. Cambia los unos por ceros y los ceros por unos.
Instruccin
notb Operando
Efecto
Operando ~ Operando
Descripcin
niega operando de 1 byte
notw Operando
Operando ~ Operando
notl Operando
Operando ~ Operando
Operandos Vlidos
registro
memoria
Ejemplo
notl %eax
notl etiqueta
and (y lgico)
Esta instruccin ejecuta un and bit a bit entre los operandos. La operacin lgica
and se define como:
Operando 1
Operando 2
AND
65
Instruccin
andb Fuente, Destino
Efecto
DestinoDestino AND Fuente
Descripcin
and entre operandos de 1 byte
andw Fuente, Destino
and entre operandos de 2 bytes
andl Fuente, Destino
and entre operandos de 4 bytes
inmediato
inmediato
registro
registro
memoria
Operandos Vlidos
registro
memoria
registro
memoria
registro
Ejemplo
andl $15, %eax
andb $10, etiqueta
andw %bx, %ax
andl %eax, etiqueta
andl etiqueta, %eax
or (o lgico)
Esta instruccin realiza un or bit a bit entre los operandos. La operacin lgica
or se define como:
Operando 1
Operando 2
OR
Instruccin
orb Fuente, Destino
Efecto
DestinoDestino OR Fuente
Descripcin
or entre operandos de 1 byte
orw Fuente, Destino
or entre operandos de 2 bytes
orl Fuente, Destino
or entre operandos de 4 bytes
inmediato
inmediato
registro
registro
memoria
Operandos Vlidos
registro
memoria
registro
memoria
registro
Ejemplo
orl $15, %eax
orb $10, etiqueta
orw %bx, %ax
orl %eax, etiqueta
orl etiqueta, %eax
66
xor (or exclusivo)
Esta instruccin realiza un or exclusivo bit a bit entre los operandos. La
operacin lgica xor se define como:
Operando 1
Operando 2
XOR
Instruccin
xorb Fuente, Destino
Efecto
DestinoDestino XOR Fuente
Descripcin
xor entre operandos de 1 byte
xorw Fuente, Destino
xor entre operandos de 2 bytes
xorl Fuente, Destino
xor entre operandos de 4 bytes
inmediato
inmediato
registro
registro
memoria
Operandos Vlidos
registro
memoria
registro
memoria
registro
Ejemplo
xorl $15, %eax
xorb $10, etiqueta
xorw %bx, %ax
xorl %eax, etiqueta
xorl etiqueta, %eax
La instruccin xor se utiliza a menudo para inicializar registros en cero

colocando el mismo registro como ambos operandos, de la siguiente manera:
xorl %eax, %eax
# %eax=0
Ya que el xor produce un cero cuando los bits son iguales, esta operacin
siempre producir un registro con contenido cero.
shl (desplazamiento lgico a la izquierda)

La instruccin sal (desplazamiento aritmtico a la izquierda) funciona de manera
idntica a shll. Ambas desplazan el contenido del operando a la izquierda y
llenan con ceros. Esta operacin produce la multiplicacin por potencias de dos,
el desplazamiento de una posicin corresponde a la multiplicacin por 21, dos
posiciones por 22 y as sucesivamente. Esta instruccin tarda menos que el uso
de la instruccin de multiplicacin.
67
Instruccin
shlb Posiciones, Destino
Efecto
DestinoDestino << posiciones
Descripcin
desplazamiento a la izquierda, operando de 1 byte
shlw Posiciones, Destino
desplazamiento a la izquierda, operando de 2 bytes
shll Posiciones, Destino
desplazamiento a la izquierda, operando de 4 bytes
inmediato
inmediato
%cl
%cl
Operandos Vlidos
registro
memoria
registro
memoria
Ejemplo
shll $4, %eax
shlb $4, etiqueta
shll %cl, %eax
shll %cl, etiqueta
shr (desplazamiento lgico a la derecha)

La instruccin shr desplaza el contenido del operando a la derecha y llena con
ceros. Permite dividir el nmero entre potencias de 2, para nmeros sin signo.
Instruccin
shrb Posiciones, Destino
Efecto
DestinoDestino >> posiciones
Descripcin
desplazamiento lgico a la derecha, operando de 1 byte
shrw Posiciones, Destino
desplazamiento lgico a la derecha, operando de 2 bytes
shrl Posiciones, Destino
desplazamiento lgico a la derecha, operando de 4 bytes
inmediato
inmediato
%cl
%cl
Operandos Vlidos
registro
memoria
registro
memoria
Ejemplo
shrl $4, %eax
shrb $4, etiqueta
shrl %cl, %eax
shrl %cl, etiqueta
sar (desplazamiento aritmtico a la derecha)

La instruccin sar desplaza el contenido del operando a la derecha y llena con el
bit de signo. Permite dividir el nmero entre potencias de 2, para nmeros con
signo.
Instruccin
sarb Posiciones, Destino
Efecto
Descripcin
desplazamiento aritmtico a la derecha, operando de 1 byte
sarw Posiciones, Destino
desplazamiento aritmtico a la derecha, operando de 2 bytes
sarl Posiciones, Destino
desplazamiento aritmtico a la derecha, operando de 4 bytes
inmediato
inmediato
%cl
%cl
Operandos Vlidos
registro
memoria
registro
memoria
Ejemplo
sarl $4, %eax
sarb $4, etiqueta
sarl %cl, %eax
sarl %cl, etiqueta
68
mul (multiplicacin de enteros sin signo)
Esta instruccin opera sobre nmeros sin signo.
Instruccin
mulb Fuente
Efecto
%ax Fuente * %al
Descripcin
multiplicacin sin signo, %al implcito
mulw Fuente
%dx:%ax Fuente * %ax
multiplicacin sin signo, %ax implcito
mull Fuente
%edx:%eax Fuente * %eax
multiplicacin sin signo, %eax implcito
Operandos Vlidos
registro
memoria
Ejemplo
mulw %cx
En este caso el resultado queda en %dx:%ax
mull etiqueta En este caso el resultado queda en %edx:%eax
imul (multiplicacin de enteros con signo)

Hay tres versiones de la instruccin de multiplicacin para operandos con signo,
una con un operando, una con dos operandos, y otra con tres operandos.
imul con un operando
Instruccin
imulb Fuente
Efecto
%ax Fuente * %al
Descripcin
multiplicacin con signo, 1 byte. %al implcito
imulw Fuente
%dx:%ax Fuente * %ax
multiplicacin con signo, un operando. %ax implcito
imull Fuente
%edx:%eax Fuente * %eax
multiplicacin con signo, un operando. %eax implcito
Operandos Vlidos
registro
memoria
Ejemplo
imulw %cx
En este caso el resultado queda en %dx:%ax
imull etiqueta En este caso el resultado queda en %edx:%eax
imul con dos operandos

Instruccin
imulw Fuente, Destino
Efecto
Destino Destino * Fuente
Descripcin
multiplicacin con signo, dos operandos de 2 bytes
imull Fuente, Destino
Destino Destino * Fuente
multiplicacin con signo, dos operandos de 4 bytes
registro
inmediato
memoria
Operandos Vlidos
registro
registro
registro
Ejemplo
imulw %cx, %bx
imull $4, %eax
imull etiqueta, %ebx
69
imul con tres operandos
En esta instruccin el primer operando es un inmediato y el destino debe ser un
registro.
Instruccin
imulw Multiplicador, Fuente, Destino
Efecto
Destino Fuente * Multiplicador
Descripcin
multiplicacin con un inmediato, 2 bytes
imull Multiplicador, Fuente, Destino
Destino Fuente * Multiplicador
multiplicacin con un inmediato, 4 bytes
inmediato
inmediato
Operandos Vlidos
registro
registro
memoria
registro
Ejemplo
imulw $12, %ax, %bx
imull $12, etiqueta, %ecx
cwd (convierte palabra en palabra doble)

Esta instruccin no tiene operandos, convierte un nmero con signo de una
palabra a una palabra doble en el %dx:%ax duplicando el signo para generar un
dividendo de 32 bits.
Instruccin
cwd
Efecto
%dx:%ax %ax con signo extendido
Descripcin
extiende palabra a doble palabra
cltd (convierte palabra doble a palabra cudruple)

Esta instruccin extiende un nmero con signo de 32 bits a uno de 64 bits
duplicando el signo. Genera el dividendo %edx:%eax.
Instruccin
cltd
Efecto
%edx:%eax %eax con signo extendido
Descripcin
extiende palabra doble a palabra cudruple
Estas instrucciones se utilizan antes de la divisin para asegurar que el

dividendo, el cual es implcito en la divisin, sea del tamao adecuado.
div (divisin de enteros sin signo)
Instruccin
divb Fuente
Efecto
%al %ax Fuente
Descripcin
divisin sin signo, 1 byte , %ax implcito
%ah resto
divw Fuente
%ax %dx:%ax Fuente
divisin sin signo, 2 bytes, %dx:%ax implcito
%dx resto
divl Fuente
%eax %edx:eax Fuente
divisin sin signo, 4 bytes, %edx:%eax implcito
%edx resto
70
Operandos Vlidos
registro
memoria
Ejemplo
divw %cx
En este caso el resultado queda en %ax
divl etiqueta En este caso el resultado queda en %eax
%dx:%ax implcito
%edx:%eax implcito
idiv (divisin de enteros con signo)

Instruccin
idivb Fuente
Efecto
Descripcin
divisin con signo, 1 byte, %ax implcito
%al %ax Fuente

%ah resto
idivw Fuente
divisin con signo, 2 bytes, %dx:%ax implcito
%ax %dx:%ax Fuente

%dx resto
idivl Fuente
divisin con signo, 4 bytes, %edx:%eax implcito
%eax %edx:eax Fuente

%edx resto
Operandos Vlidos
registro
memoria
Ejemplo
idivw %cx
En este caso el resultado queda en %ax
idivl etiqueta En este caso el resultado queda en %eax
%dx:%ax implcito
%edx:%eax implcito
Ejemplo de un programa que realiza algunas operaciones aritmticas:

.section
a: .long
b: .long
c: .long
.data
5
45
6
.section .text
.globl _start
_start:
movl a, %eax
movl b, %ebx
addl %ebx, %eax
decl %eax
movl c, %ecx
cltd
idivl %ecx
subl %edx, %ebx
imull $5, %ebx
imull %ebx
imull $3,%eax,%ecx
decl %eax
subl $1755, %eax
shll $2, %eax
movl $32, %ebx
#
#
#
#
#
#
#
#
#
#
#
#
#
#
#
%eax=a=5
%ebx=b=45
%eax=%eax+%ebx=5+45=50
%eax=%eax-1=49
%ecx=c=6
extiende %eax a %edx:%eax
%eax=%eax/%ecx=49/6=8 %edx=resto=1
%ebx=%ebx-%edx=45-1=44
%ebx=%ebx*5=44*5=220
%edx:%eax=%eax*%ebx %eax=8*220=1760
%ecx=%eax*3=1760*3=5280
%eax=%eax-1=1759
%eax=%eax-1755=4
%eax=%eax<<2 = %eax*22 %eax=16
%ebx=32
71
sarl $4, %ebx
# %ebx=%ebx>>4 = %ebx/24 %ebx=2
movl $1, %eax

xorl %ebx, %ebx
int $0x80
# finalizacion del programa
Instrucciones de comparacin
cmp (compara)
Compara el contenido de dos operandos. Resta los operandos pero no actualiza
el resultado, solo actualiza las banderas.
Instruccin
cmpb Operando2, Operando1
cmpw Operando2, Operando1
cmpl Operando2, Operando1
inmediato
inmediato
registro
registro
memoria
Efecto
Operando1 - Operando2
Operandos Vlidos
registro
memoria
registro
memoria
registro
Descripcin
Compara los operandos de 1 byte
Compara los operandos de 2 bytes
Compara los operandos de 4 bytes
Ejemplo
cmpl $5, %eax
cmpb $4, etiqueta
cmpw %bx, %ax
cmpl %eax, etiqueta
cmpl etiqueta, %eax
Esta instruccin compara el operando 1 con el operando 2, por ejemplo:

cmpl %ebx, %eax
# compara el contenido de %eax con el contenido

# de %ebx
test (examina bits)

Realiza la operacin AND entre los operandos pero sin actualizar el resultado.
Solo actualiza las banderas.
Instruccin
testb Operando2, Operando1
testw Operando2, Operando1
testl Operando2, Operando1
inmediato
inmediato
registro
registro
memoria
Operandos Vlidos
registro
memoria
registro
memoria
registro
Efecto
Operando1 AND Operando2
Descripcin
Examina los operandos de 1 byte
Examina los operandos de 2 bytes
Examina los operandos de 4 bytes
Ejemplo
testl $5, %eax
testb $4, etiqueta
testw %bx, %ax
testl %eax, etiqueta
testl etiqueta, %eax
72
Es comn usar la instruccin test repitiendo el operando para saber si este es
cero, positivo o negativo.
Ejemplo:
testl
%eax, %eax
# %eax & %eax
Instrucciones de salto
Una instruccin de salto produce un cambio en la ejecucin del programa
pasando a una nueva posicin, no secuencial. La direccin del salto se
representa con una etiqueta.
Instruccin
jmp etiqueta
jmp *etiqueta
ja etiqueta
jna etiqueta
jae etiqueta
jnae etiqueta
jb etiqueta
jnb etiqueta
jbe etiqueta
jnbe etiqueta
jc etiqueta
jnc etiqueta
jcxz etiqueta
jecxz etiqueta
je etiqueta
jne etiqueta
jg etiqueta
jng etiqueta
jge etiqueta
jnge etiqueta
jl
etiqueta
jnl etiqueta
jle etiqueta
jnle etiqueta
js etiqueta
jns etiqueta
jo etiqueta
jno etiqueta
jp etiqueta
jnp etiqueta
jpe etiqueta
jpo etiqueta
Descripcin
Salto incondicional directo
Salto incondicional indirecto
Salto por superior (nmeros sin signo)
Salto por no superior (nmeros sin signo)
Salto por superior o igual (nmeros sin signo)
Salto por no superior o igual (nmeros sin signo)
Salto por inferior (nmeros sin signo)
Salto por no inferior (nmeros sin signo)
Salto por inferior o igual (nmeros sin signo)
Salto por no inferior o igual (nmeros sin signo)
Salto por acarreo (nmeros sin signo)
Salto por no acarreo (nmeros sin signo)
Salto por %cx=0
Salto por %ecx=0
Salto por igual
Salto por no igual
Salto por mayor (>)
Salto por no mayor
Salto por mayor o igual (>=)
Salto por no mayor o igual
Salto por menor (<)
Salto por no menor
Salto por menor o igual (<=)
Salto por no menor o igual
Salto por negativo
Salto por no negativo
Salto por desbordamiento
Salto por no desbordamiento
Salto por paridad
Salto por no paridad
Salto por paridad par
Salto por paridad impar
La instruccin jmp salta de manera incondicional, es decir, no chequea ningn

cdigo de condicin. El salto puede ser directo a la direccin representada por
73
la etiqueta o indirecto donde la direccin de destino se lee de un registro o de
una posicin de memoria.
Ejemplo de salto incondicional directo:
1
2
3
4
etiq1:
addl
jmp
subl
addl
%eax, %ebx
etiq1
%edx, %ebx
%edx, %ebx
# salto incondicional a etiq1
En este caso la tercera instruccin no se ejecuta ya que al ejecutarse el salto el

programa pasa a ejecutar la instruccin 4.
Ejemplo de salto incondicional indirecto: dados los valores %eax = 0x120 y el
contenido de la posicin de memoria 0x120 = 0x180
jmp
*%eax
# salta a la direccin 0x120 (contenido de %eax)
jmp
*(%eax)
# salta a la direccin 0x180 (contenido de la

posicin de memoria 0x120 direccionada por %eax)
Las otras instrucciones de salto son condicionales lo cual significa que la

mquina revisa los cdigos de condicin antes de realizar el salto, si la
condicin se cumple realiza el salto a la etiqueta especificada, si la condicin no
se cumple contina la ejecucin de manera secuencial.
Ejemplo de salto condicional:
1
2
3
4
5
6
7
8
menor:
fin:
movl
movl
cmpl
jl
subl
jmp
addl
valor1, %eax
valor2, %ebx
%ebx, %eax
menor
$5,%eax
fin
$5,%eax
#
#
#
#
#
#
#
%eax=valor1
%ebx=valor2
compara valor1 con valor2
si valor1<valor2 salta a etiq1
si valor1>=valor2 resta 5 a %eax
salta a fin
si valor1<valor2 suma 5 a %eax
En el ejemplo anterior que si se cumple la condicin de comparacin

valor1<valor2 el programa salta a la instruccin 7 sin pasar por las
instrucciones 5 y 6. En caso de no cumplirse la condicin, es decir
valor1>=valor2, entonces contina la ejecucin en la instruccin siguiente, en
este caso, la instruccin 5. Es importante destacar la necesidad de introducir la
instruccin 6, un salto incondicional a la etiqueta fin ya que de no estar
presente la mquina seguira el orden secuencial y luego de realizar la resta
74
ejecutara la suma lo cual arrojara un resultado errneo. En este programa slo
se ejecuta una de las dos operaciones aritmticas, la resta en caso de cumplirse
la condicin o la suma en caso de que no se cumpla.
Actualizacin de un registro con valor de una bandera

Es posible transferir el contenido de una bandera o una condicin que dependa
de la combinacin de varias banderas a un registro. Esto es til para poder usar
la misma condicin en varias partes del programa.
Las instrucciones que realizan esta actualizacin se denominan set y hay una
por cada
condicin
(tal
como
estn
expresadas
en
los
saltos).
Estas
instrucciones slo mueven un byte y el destino debe ser un registro.

Ejemplo:
cmpl
setg
%ebx, %edx
%cl
test %eax,%eax
setz %bl
#
#
#
#
#
#
compara el contenido de %edx con %ebx

si %edx>%ebx entonces %cl se actualiza con 1,
en caso contrario en 0
examina los bits de %eax
si %eax=0 entonces actualiza %bl en 1,
en caso contrario lo coloca en 0
Ejemplo de uso de varias instrucciones

Dado el siguiente programa:
.section .text
.globl _start
_start:
l1:
movl $14, %eax
l2:
movl $4, %ecx
l3:
xorl %ebx, %ebx
l4:
incl %ebx
l5:
addl %ecx, %ebx
l6:
imull %ebx, %eax
l7:
decl %ebx
l8:
addl %ebx, %ecx
l9:
cltd
l10: idivl %ebx
l11: movl $1, %eax
l12: movl $0, %ebx
l13: int $0x80
Se pueden observar los cambios en los registros:
75
l1
l2
l3
l4
l5
l6
l7
l8
l9
l10
l11
l12
%eax
14
%ebx
%ecx
%edx
4
0
1
5
70
4
8
0
2
17
1
0
La instruccin loop
La instruccin loop permite programar ciclos de manera eficiente.
Instruccin
loop etiqueta
loope etiqueta
loopz etiqueta
loopne etiqueta
loopnz etiqueta
Descripcin
Ciclo hasta que %ecx=0
Ciclo hasta que %ecx=0 o la bandera de cero (ZF)=0
Equivalente a loope
Ciclo hasta que %ecx=0 o la bandera de cero (ZF)=1
Equivalente a a loopne
La instruccin loop utiliza el registro %ecx como contador y decrementa su valor

automticamente cada vez que la instruccin se ejecuta. Slo permite un
desplazamiento de 8 bits, por lo tanto, slo se puede usar para ciclos pequeos.
Antes de usar la instruccin hay que actualizar el registro %ecx con el nmero
de iteraciones que se necesitan en el ciclo, la instruccin lo utiliza de manera
implcita, es importante recordar que este registro no se puede utilizar,
entonces, dentro del ciclo ya que ello afectara la operacin del mismo. Cuando
se usa esta instruccin y el registro contador %ecx llega a cero, sto no afecta la
bandera de cero (ZF).
Ejemplo del uso de la instruccin loop, programa que suma 10 veces 5.
.section .data
resultado: .long 0
.section .text
.globl _start
_start:
movl $0, %ebx
movl $5, %eax
movl $10, %ecx
# %ebx=0, donde se va a sumar

# %eax=5, el valor a sumar
# %ecx=10, nmero de iteraciones
76
ciclo1:
addl %eax, %ebx

loop ciclo1
# suma 5
# regresa al inicio del ciclo
movl %ebx, resultado
# actualiza resultado con el valor

# final de la suma
movl $1, %eax

xorl %ebx, %ebx
int $0x80
# fin del programa
77
Ejercicios
5.1- Muestre los cambios ocurridos en los contenidos de los registros para el
siguiente programa:
.section .text
.globl _start
_start:
movl $5, %eax
xorl %ecx, %ecx
addl $6, %ecx
addl %ecx, %eax
movl %ecx, %ebx
movl $2, %edx
incl %ebx
imull %edx, %ebx
shll $2,%edx
sarl $1,%ecx
addl %ebx, %eax
cltd
idivl %ecx
movl $1, %eax
movl $0, %ebx
int $0x80
5.2- Para los valores a=6, b=8, c=12, d=4 declarados en la seccin de datos,
escriba un programa que calcule x=a-3b+25(c-d).
5.3- Escriba un fragmento de cdigo que calcule x=16*y sin utilizar la
instruccin de multiplicacin.
5.4- Escriba un fragmento de cdigo que calcule x=y/32 sin usar la instruccin
de divisin.
5.5- Dados los valores a=4, b=5, c=2, d=7 declarados en la seccin de datos;
escriba un programa que calcule la expresin x=(a+(b-c))/(c*d).
5.6- Escriba un programa que dados tres valores enteros declarados en la
seccin de datos, determine el mayor y lo guarde en una variable denominada
mayor.
78
5.7- Escriba un programa que dados dos valores enteros a y b declarados en la
seccin de datos produzca como salida la actualizacin de la variable resultado
segn las siguientes condiciones:
Si a=b: resultado=a
Si a>b: resultado=a-b
Si a<b: resultado=b-a
5.8- Suponiendo que el contenido inicial de %ebp=%esp=0x100 y dadas las

siguientes instrucciones, muestre los cambios ocurridos en la pila y en los
registros involucrados.
movl $25, %eax
addl $5, %eax
pushl %eax
incl %eax
pushl %eax
movl %eax, %ebx
subl $15, %ebx
cltd
idivl %ebx
pushl %edx
popl %eax
popl %ecx
popl %ebx
79
Captulo 6. Entrada / Salida

Un ser humano puede tener las ideas ms innovadoras o los mejores
sentimientos, sin embargo esto de nada vale si los mismos no pueden ser
comunicados a los dems. De la misma forma, un programa de computadora no
tiene ninguna utilidad si el mismo no puede de una u otra forma comunicarse
con el usuario.
El conjunto de actividades que permiten a un programa interactuar con los
usuarios (y el resto de su entorno, como por ejemplo otras computadoras), as
como los mecanismos de hardware y software que soportan estas actividades
son comnmente conocidos como sistema de entrada/salida, frecuentemente
abreviado E/S.
Aunque en los inicios de la computacin moderna el llevar a cabo este tipo de
actividades era una tarea bastante compleja y limitada, con la aparicin y
evolucin de los lenguajes de alto nivel esto ha cambiado drsticamente, al
punto en que hoy en da basta una simple lnea de cdigo para comunicarle un
mensaje al usuario o recibir una indicacin por parte de este.
A lo largo de este captulo sern descritas diferentes formas de realizar las
actividades de E/S. Se comenzar con el enfoque ms sencillo, provisto por un
lenguaje de alto nivel como C, para luego abordar enfoques ms avanzados
como las llamadas al sistema o la utilizacin de instrucciones bajo nivel
diseadas para este propsito.
Funciones de alto nivel

Actualmente todos los lenguajes de alto nivel proporcionan alguna instruccin
que de una u otra forma permite interactuar con los usuarios. En el caso del
lenguaje C, las instrucciones bsicas de entrada salida son printf y scanf, las
cuales permiten respectivamente enviar (print, imprimir) o recibir (scan, leer)
informacin. La f con que finalizan ambas instrucciones hace referencia a que
las mismas proporcionan E/S formateada. Ms adelante se explicar en que
consiste esto.
El sistema de E/S del lenguaje C define los conceptos de flujo y archivo. Un
archivo representa a cualquier dispositivo de E/S como puede ser la pantalla o el
teclado, y permite que el programador realice operaciones de E/S sobre los
mismos sin necesidad de conocer los detalles especificos de un determinado
dispositivo.
Sin embargo considere que el lenguaje C permite la utilizacin de una ampla
variedad de dispositivos diferentes. Esto quiere decir que no todos los archivos
soportan las mismas operaciones. Para solucionar esto, y facilitar las tareas del
programador se define un mecanismo que permite tratar a todos los
dispositivos de una manera estndar. Para ello, el sistema de E/S de C trata cada
dispositivo fsico como un flujo, lo cual no es ms que una abstraccin lgica de
dicho dispositivo.
80
Los conceptos de archivo y flujo estn relacionados de la siguiente manera: Un
archivo es asociado a un flujo determinado mediante una operacin denominada
apertura. A partir de este momento, el programador enva o recibe datos hacia o
desde el flujo (que puede ser binario o de texto), y es el subsistema de E/S
quien realiza la correspondencia necesaria entre dicho flujo y su archivo
asociado, de forma que los datos sean efectivamente intercambiados con el
dispositivo fsico que dicho archivo representa. Finalmente es posible desasociar
el flujo del archivo mediante una operacin de cierre.
En un programa que no involucre operaciones avanzadas de E/S, (como la
mayor parte de los presentados en esta obra) el programador no necesita
realizar operaciones de apertura o cierre, ya que al momento de comenzar la
ejecucin del programa existen ciertos flujos asociados automticamente a los
dispositivos de E/S utilizados con mayor frecuencia. El estndar ANSI de C
define tres flujos predefinidos:
Flujo
Descripcin
Dispositivo asociado por defecto
stdin
Entrada estndar
Teclado
stdout
Salida estndar
Monitor
stderr
Flujo de errores
Monitor
A continuacin se describirn formalmente las funciones printf y scanf, para

luego pasar a ilustrar su utilizacin mediante algunos ejemplos.
Funcin printf
La funcin printf permite escribir en la salida estndar, proporcionando un
formato especfico para los datos a escribir. De all que las escrituras realizadas
por esta funcin y las lecturas realizadas por scanf sean conocidas como e/s
formateada. Esto implica que ambas funciones pueden trabajar con los tipos de
datos especificados por el estandar ANSI de C tales como nmeros, caracteres y
cadenas.
Esta funcin recibe una cantidad variable de argumentos, en los que solo uno de
ellos es obligatorio: la cadena de formato. Este parmetro es una cadena que
permite indicar el formato que tendr la impresin que se quiere realizar, y en
base a la cual se determina la cantidad y tipo de los parmetros restantes.
Dicha cadena puede contenter caracteres comunes y corrientes, los cuales se
mostrarn en pantalla exactamente como se encuentran en la cadena, y un
segundo tipo de caracteres conocidos como especificadores de formato , los
cuales estn formados por un smbolo de porcentaje (%) y un cdigo de formato
(c para caracteres, d para nmeros decimales, etc). Los especificadores de
formato compatibles con la funcin printf son los siguientes:
81
Especificador
Formato
%c
Caracter simple
%d
Entero con signo en base decimal
%i
Entero con signo en base decimal (integer)
%e
Notacin cientfica (letra e minscula)
%E
Real en notacin cientfica (letra E mayscula)
%f
Real (punto flotante)
%g
Equivalente a la representacin real ms corta (%e o %f)
%G
Equivalente a la representacin real ms corta (%E o %f)
%o
Entero con signo en base octal
%p
Apuntador o direccin de memoria
%s
Cadena de caracteres
%u
Entero sin signo en base decimal
%x
Entero con signo en base hexadecimal (letras minsculas)
%X
Entero con signo en base hexadecimal (letras maysculas)
Adems de la cadena de formato, deben existir tantos parmetros adicionales

como especificadores de formato contenga la cadena, ya que cada uno de los
mismos proporciona el valor por el cual ser sustituido cada especificador al
momento de mostrar la cadena por la pantalla. Dicho de otra manera, la cadena
de formato puede ser vista como una plantilla, mientras que el resto de los
parmetros son los valores que completan los campos vacos de dicha plantilla.
De esta forma, las siguientes llamadas a printf son vlidas (asumiendo que las
variables sexo y edad han sido declaradas previamente y son de tipo caracter y
entero respectivamente):
printf("Hola mundo");
printf("Su edad es %d", edad);
printf(Sexo:%c - Edad:%d, sexo, edad);
Por ejemplo, si la variable edad (de tipo entero) tiene un valor decimal de
veinte, la ejecucin de la segunda llamada a printf ocasionar que se muestre el
mensaje Su edad es 20 a travs de la pantalla.
Funcin scanf
La funcin scanf permite leer desde la entrada estndar, proporcionando un
formato especfico para los datos a recibir. De forma anloga a la funcin printf,
esta funcin permite reconocer los tipos de datos especificados por el estndar
ANSI de C tales como nmeros, caracteres y cadenas.
82
Los argumentos recibidos por la funcin scanf son similares a los de la funcin
printf , siendo de nuevo el primero de ellos la cadena de formato. Sin embargo
en este caso la cadena de formato es utilizada para especificar una plantilla
que deber ser completada con la entrada proporcionada por el usuario.
En este caso, por cada especificador de formato que se encuentre en la cadena
ser necesario proporcionar un apuntador a la direccin de memoria en la que
ser almacenado el elemento reconocido. Los especificadores de formato
compatibles con la funcin scanf son los siguientes:
Especificador
Formato
%c
Caracter simple
%d
Entero con signo en base decimal
%i
Entero con signo en base decimal (integer)
%e
Notacin cientfica (letra e minscula)
%E
Real en notacin cientfica (letra E mayscula)
%f
Real (punto flotante)
%g
Equivalente a la representacin real que coincida (%e o %f)
%G
Equivalente a la representacin real que coincida (%E o %f)
%o
Entero con signo en base octal
%p
Apuntador o direccin de memoria
%s
Cadena de caracteres
%u
Entero sin signo en base decimal
%x
Entero con signo en base hexadecimal (letras minsculas)
%X
Entero con signo en base hexadecimal (letras maysculas)
De esta forma, las siguientes llamadas a scanf son vlidas (asumiendo que la
variable edad ha sido declarada como entero, y las variables nombre y apellido
como arreglo de caracteres):
scanf("%d", &edad);
scanf(%s,%s, nombre, apellido);
Por ejemplo, la ejecucin de la primera llamada a scanf ocasionar que se
detenga la ejecucin del programa hasta que el usuario proporcione un nmero
entero decimal mediante la utilizacin del teclado. Si el usuario introduce,
digamos, el valor 20, el mismo ser asignado a la variable edad, o en otras
palabras, dicho valor ser almacenado en la direccin de memoria ocupada por
dicha variable (&edad).
Es vlido preguntarse que ocurre si la entrada del usuario no coincide al 100%
con la especificada por la cadena de formato al hacer una llamada a la funcin
scanf. De suceder esto, solo se reconoce la entrada hasta el primer caracter que
83
no coincida con la cadena de formato, y solo se le asigna un valor a las variables
correspondientes a los especificadotes de formato que preceden a dicho
carcter. En cualquier caso la funcin retorna la cantidad de elementos de la
entrada que fueron asignados a las variables. Por ejemplo, si se hace la
siguiente llamada a scanf:
scanf("%s, %s. V-%d", apellido, nombre, &cedula);
Y el usuario introduce la cadena Perez, Pedro. 16247521, la funcin scanf
devolver el valor 2, ya que la cadena coincide con la plantilla solo hasta el
espacio que se encuentra despus del punto. Al no encontrar la letra V, la
funcin no contina examinando la cadena de entrada, y retorna el valor dos ya
que solo las variables apellido y nombre recibieron un valor (Perez y Pedro,
respectivamente). La variable cdula no es modificada.
Consideraciones adicionales
Una diferencia importante entre las funciones printf y scanf consiste en la
manera en que se les pasan los argumentos. Todos los argumentos de una
llamada a la funcin scanf (a excepcin de la cadena de formato) son pasados
por referencia, es decir, se proporciona la direccin de la variable y no su valor.
Esto se debe a que la funcin utiliza estas variables para almacenar un valor
leido de la entrada estndar y en consecuencia necesita saber la posicin de
memoria en la que el mismo ser almacenado.
En contraparte, la funcin printf no necesita conocer la direccin de las
variables, sino el valor que contienen para poder escribirlo en la salida estndar.
Por esta razn, todos los tipos de dato simple (enteros, caracteres, etc.) son
pasados por valor. Algunas otras variables como los arreglos y las estructuras
(esto incluye las cadenas ya que son arreglos de caracteres) son pasados por
referencia, pero esto se debe a limitaciones del pase de parmetros por valor (ya
que los parmetros se almacenan en la pila, vase el captulo de
procedimientos) y no a que la funcin printf necesite conocer la direccin de
dichos argumentos per se.
Para ilustrar la utilizacin de ambas funciones desde un programa en lenguaje
ensamblador, se presentan dos ejemplos sencillos. Sin embargo es importante
hacer una acotacin en este punto. Cuando se hace una llamada a las funciones
printf y scanf (o a cualquier otro procedimiento), el contenido de los registros
%eax, %ecx y %edx corre el riesgo de ser modificado. El motivo de esto ser
explicado en profundidad en el capitulo relativo a la llamada a procedimientos,
sin embargo, es importante tener en cuenta este hecho al momento de
programar, tomando las precauciones necesarias para no perder informacin
importante al llevar a cabo las operaciones de lectura o escritura.
84
El primer ejemplo consiste en un programa que pide al usuario una cadena de
caracteres mediante la utilizacin de scanf, y luego la muestra de nuevo
mediante la utilizacin de printf.
Programa en C:
#include <stdio.h>
char cadena[80];
main()
{
printf("Por favor introduzca una cadena: ");
scanf("%s", cadena);
printf("La cadena introducida es: %s\n", cadena);
}
Programa en ensamblador:
.section .rodata
cad1:
.asciz "Por favor introduzca una cadena: "
cad2:
.asciz "%s"
cad3:
.asciz "La cadena introducida es: %s\n"
.section .bss
cadena: .space 50
# Reserva espacio para la cadena introducida
.section .text
.globl _start
_start:
# Muestra un mensaje solicitando que se escriba una cadena
leal cad1, %eax
# Carga la direccin de la cadena de formato
pushl %eax
# Pasa el primer argumento (cad1)
call printf
# Hace la llamada a printf
addl $4, %esp
# Libera el espacio de la pila ocupado por
el nico argumento
# Lee la cadena introducida por el usuario
leal cadena, %eax
# Carga la direccin donde se almacenar
la cadena
pushl %eax
# Pasa el segundo argumento (cadena)
leal cad2, %eax
pushl %eax
call scanf
# Hace la llamada a scanf
addl $8, %esp
# Libera los 8 bytes de pila ocupados por
los argumentos
85
leal cadena, %eax
# Carga la direccin de la cadena leida
pushl %eax
# Pasa el segundo argumento (cadena)
leal cad3, %eax
pushl %eax
call printf
addl $8, %esp
# Libera los 8 bytes de pila ocupados por
los argumentos
movl $1, %eax
movl $0, %ebx
int $0x80
En este segundo ejemplo se pedirn al usuario dos nmeros enteros en notacin

decimal, y se mostrar la suma de ambos. Si bien el programa puede parecer
extremadamente sencillo, ms adelante observaremos que esto se debe a las
facilidades provistas por las funciones printf y scanf.
Programa en C:
#include <stdio.h>
int A,B,C;
main()
{
printf("Valor de A: ");
scanf("%d", &A);
printf("Valor de B: ");
scanf("%d", &B);
C = A+B;
printf("El valor de A+B es: %d\n", C);
}
.section .rodata
cad1:
.asciz "Valor de A: "
cad2:
.asciz "Valor de B: "
86
cad3:
cad4:
.asciz "El valor de A+B es: %d\n"

.asciz "%d"
.section .bss
A: .space 4
B: .space 4
C: .space 4
# Reserva espacio para un entero

.section .text
.globl _start
_start:
# Muestra un mensaje solicitando el valor de A
leal cad1, %eax
pushl %eax
# Pasamel primer argumento (cad1)
call printf
addl $4, %esp
# Libera los 4 bytes de pila ocupados por el
nico argumento
# Lee el valor de A
leal A, %eax
# Carga la direccin donde se almacenar el
entero
pushl %eax
# Pasa el segundo argumento (&A)
leal cad4, %eax
pushl %eax
call scanf
addl $8, %esp
# Libera los 8 bytes de pila ocupados los
argumentos
# Muestra un mensaje solicitando el valor de B
leal cad2, %eax
pushl %eax
call printf
addl $4, %esp
# Libera los 4 bytes de pila ocupados por el
nico argumento
# Lee el valor de B
leal B, %eax
# Carga la direccin donde se almacenar el
entero
pushl %eax
# Pasam el segundo argumento (&B)
leal cad4, %eax
pushl %eax
call scanf
addl $8, %esp
# Libera los 8 bytes de pila ocupados los
argumentos
87
# Suma los nmeros y deja el resultado en C
movl A, %eax
addl B, %eax
movl %eax, C
pushl C
# Pasamos el segundo argumento (C)
leal cad3, %eax
# Cargamos la direccin de la cadena de formato
pushl %eax
# Pasamos el primer argumento (cad3)
call printf
# Hacemos la llamada a printf
addl $8, %esp
# Liberamos los 8 bytes de pila ocupados los
argumentos
movl $1, %eax
movl $0, %ebx
int $0x80.rodata
Llamadas al sistema
Las llamadas al sistema son servicios que provee el sistema operativo a los
programas de usuario para llevar a cabo diversas tareas de manera controlada y
coordinada. En Linux, la lista de las distintas llamadas al sistema se puede
encontrar en el archivo unistd.h, generalmente ubicado en el directorio
/usr/include/asm/. De esta forma, es posible conocer el nmero que identifica
a cada servicio mediante el siguiente comando:
linux>
more /usr/include/asm/unistd.h
....
#define __NR_restart_syscall
#define __NR_exit
#define __NR_fork
#define __NR_read
#define __NR_write
#define __NR_open
#define __NR_close
....
0
1
2
3
4
5
6
Para obtener informacin referente a un servicio especfico, es posible consultar

la segunda seccin del manual ( man), la cual contiene la informacin referente a
las llamadas al sistema. Por ejemplo, para conocer ms acerca del servicio de
escritura (write, servicio #4), es necesario utilizar el siguiente comando:
88
linux>
man 2 write
Son de particular inters los servicios read (lectura) y write (escritura), los cuales
permiten realizar las mismas operaciones bsicas que las instrucciones de alto
nivel printf y scanf , pero a un nivel ms elemental. Si bien las llamadas al
sistema no son invocadas como funciones de C, a menudo la descripcin de las
mismas se da en la notacin de dicho lenguaje.
Servicio read
El prototipo del servicio read es el siguiente:
ssize_t read(int fd, void *buf, size_t count);
fd:
Descriptor de archivo desde el que se lee (stdin, stdout, sterr)
buf:
Apuntador al rea de memoria donde se almacenarn los datos.
count: Nmero mximo de bytes a leer.
Servicio write
De forma similar, el prototipo del servicio write es el siguiente:
ssize_t write(int fd, const void *buf, size_t num);
fd:
buf:
num:
Descriptor de archivo en el que se escribe (stdin, stdout, sterr)

Apuntador al rea de memoria que contiene los datos a escribir.
Nmero mximo de bytes a escribir.
Ambas llamadas al sistema sern tratadas con un mayor grado de detalle en el

capitulo 12, junto con otras llamadas que permiten el manejo de archivos.
Ahora bien, una vez identificados los servicios de inters, y haber consultado el
manual para identificar los parmetros que reciben o los resultados que
devuelven, surge la pregunta de cmo hacer uso de los mismos desde un
programa en lenguaje ensamblador.
La peticin de un servicio al sistema operativo se hace a travs de la
interrupcin 0x80 (esta interrupcin es similar a la 23H de DOS). Simplemente
se coloca el nmero que identifica al servicio en el registro %eax, y se levanta la
interrupcin mediante la instruccin int $0x80.
Sin embargo, an cabe preguntarse Cmo se pasan los argumentos de la
llamada al sistema para que la misma se ejecute de manera exitosa? La
respuesta es sencilla. Si la llamada a un servicio recibe menos de seis
argumentos, los mismos deben ser depositados en los registros %ebx, %ecx,
%edx, %esi y %edi, en este mismo orden. Por ejemplo, para el caso de los
89
servicios read y write, es necesario colocar el descriptor de archivo desde el cual
se va a leer o al cual se va a escribir (fd) en el registro %ebx.
En caso de existir seis o ms argumentos, todos deben ser almacenados en un
rea de memoria contigua, y debe colocarse en %ebx un apuntador al primero
de los mismos.
Para ilustrar la utilizacin de las llamadas al sistema read y write, se presentan
de nuevo los mismos dos ejemplos que fueron implementados con las funciones
printf y scanf en la seccin anterior. El primero de ellos es bastante similar a su
contraparte con funciones de alto nivel, y esto se debe a que el mismo solo lee e
imprime cadenas y no otro tipo de datos. Sin embargo, note que debido a la
ausencia de un mecanismo como el proporcionado por el especificador de
formato %s, es necesario mostrar el resultado final con dos llamadas al
sistema independientes.
.section .rodata
cad1:
cad2:
.asciz "La cadena introducida es: "
fcad2:
.section .bss
cadena: .space 50
.section .text
.globl _start
_start:
movl $4, %eax
# Servicio #4 (write)
movl $1, %ebx
# File Descriptor = 1 (stdout)
leal cad1, %ecx
# Apuntador a la cadena a imprimir
movl $cad2-cad1, %edx
# Nmero mximo de caracteres a imprimir
int $0x80
# Llamada al SO
movl $3, %eax
# Servicio #3, (servicio de lectura)
movl $0, %ebx
# File Descriptor = 0 (stdin)
leal cadena, %ecx
# Direccin donde se almacenar la cadena
movl $49, %edx
# Nmero mximo de caracteres a leer
int $0x80
# Llamada al SO
# Muestra el resultado (parte 1)
movl $4, %eax
movl $1, %ebx
90
leal cad2, %ecx
movl $fcad2-cad2, %edx
int $0x80

# Llamada al SO

movl $4, %eax
movl $1, %ebx
leal cadena, %ecx
movl $49, %edx
int $0x80
# Llamada al SO
movl $1, %eax
movl $0, %ebx
int $0x80
En el ejemplo anterior se observa que a excepcin de la llamada adicional, el

programa es bastante similar a la versin que utiliza las funciones printf y scanf.
Sin embargo, repetir el segundo ejemplo utilizando llamadas al sistema no es
una tarea tan sencilla, ya que los servicios utilizados permiten la lectura y
escritura de cadenas de caracteres, mientras que en este ejemplo se necesita
leer y escribir otro tipo de dato, como lo son enteros en base decimal.
Para hacer una versin del mismo programa que utilice llamadas al sistema ser
necesario llevar a cabo la conversin entre un entero decimal y la cadena de
caracteres que lo representa de manera manual, es decir, escribiendo cdigo
adicional que realice dicha tarea. A continuacin se presenta la solucin:
.section .rodata
cad1:
cad2:
cad3:
.asciz "El valor de A+B es: "
fcad3:
.section .bss
A: .space 4
B: .space 4
C: .space 4
cadena: .space 11
#
#
#
#
Reserva
Reserva
Reserva
Reserva
espacio
espacio
espacio
espacio
para
para
para
para
un
un
un
la
entero
entero
entero
cadena introducida
.section .text
.globl _start
_start:
91
# Muestra un mensaje solicitando que proporcione el valor de A
movl $4, %eax
# Servicio #4, (write)
movl $1, %ebx
leal cad1, %ecx
int $0x80
# Llamada al SO
movl $3, %eax
# Servicio #3, (read)
movl $0, %ebx
leal cadena, %ecx
movl $49, %edx
int $0x80
# Llamada al SO
# Obtiene el valor entero representado por la cadena
xorl %ecx, %ecx
# i=0
xorl %eax, %eax
# A=0
movl $10, %esi
# base decimal
for1:
movb cadena(%ecx), %bl # Carga un caracter. (cadena[i])
cmpb $0, %bl
# Si llega al final de la cadena
je ffor1
# Sale del ciclo
cmpb $10, %bl
je ffor1
# Sale del ciclo
subb $'0', %bl
# Obtiene el dgito entero que representa
movzx %bl, %ebx
# Expande el entero a 32 bits (D)
mull %esi
# A=A*10
addl %ebx, %eax
# A=A+D
incl %ecx
# Se repite para el siguiente caracter
jmp for1
ffor1:
movl %eax, A
# Guarda el valor de A
# Muestra un mensaje solicitando que proporcione el valor de B
movl $4, %eax
movl $1, %ebx
leal cad2, %ecx
int $0x80
# Llamada al SO
movl $3, %eax
movl $0, %ebx
leal cadena, %ecx
movl $49, %edx
int $0x80
# Llamada al SO
92
xorl %ecx, %ecx
# i=0
xorl %eax, %eax
# B=0
movl $10, %esi
# base decimal
for2:
movb cadena(%ecx), %bl
cmpb $0, %bl
je ffor2
cmpb $10, %bl
je ffor2
subb $'0', %bl
movzx %bl, %ebx
mull %esi
addl %ebx, %eax
incl %ecx
jmp for2
ffor2:
movl %eax, B
#
#
#
#
#
#
#
#
#
#
Carga un caracter. (cadena[i])

Si llega al final de la cadena
Sale del ciclo
Sale del ciclo
Obtiene el dgito entero que representa
Expande el entero a 32 bits (D)
B=B*10
B=B+D
Se repite para el siguiente caracter
# Guarda el valor de B
# Calcula el valor de A+B

movl A, %eax
addl B, %eax
movl %eax, C
# Obtiene la cadena que representa al entero C
movb $0, cadena+10
# Termina la cadena (\0)
movl $9, %ecx
# i=9
movl $10, %esi
# base decimal
for3:
cltd
# Expande C a 64 bits (edx:eax)
idivl %esi
# Lo divide entre la base
addb $'0', %dl
# Obtiene la representacin del dgito
decimal
movb %dl, cadena(%ecx) # Lo inserta en la cadena
decl %ecx
cmpl $0, %eax
# Se repite mientras queden dgitos
jne for3
movl %ecx, %esi
# Guarda el desplazamiento
movl $4, %eax
movl $1, %ebx
leal cad3, %ecx
movl $fcad3-cad3, %edx # Nmero mximo de caracteres a imprimir
int $0x80
# Llamada al SO
93
movl $4, %eax
movl $1, %ebx
leal cadena, %ecx
addl %esi, %ecx
# Ajustamos la direccin de la cadena
movl $10, %edx
int $0x80
# Llamada al SO
movl $1, %eax
movl $0, %ebx
int $0x80
Observe que la cantidad de lneas de cdigo se increment de manera

importante. Si consideramos adems que este programa no contempla la
utilizacin de nmeros negativos, o la posibilidad de que el usuario se
equivoque e introduzca un carcter distinto a uno de los diez dgitos decimales,
se hace evidente lo til que resulta el contar con funciones como printf y scanf.
Sin embargo, es importante tener siempre en cuenta que dichas funciones de
una u otra forma llevan a cabo un procedimiento similar al que hemos realizado
aqu manualmente: una funcin de alto nivel no realiza ninguna tarea que no
pueda ser llevada a cabo mediante un conjunto de instrucciones de bajo nivel,
ya que en el fondo son estas ltimas las nicas que el procesador de una
computadora es capaz de ejecutar.
Instrucciones de bajo nivel

La implementacin de las funciones de alto nivel y las llamadas al sistema que
han sido descritas anteriormente es posible, gracias a la existencia de funciones
de bajo nivel (instrucciones de mquina) que permiten interactuar con los
diferentes dispositivos de E/S.
En la arquitectura IA-32 stas son la instruccin in, que permite recibir datos
desde el dispositivo, y la instruccin out, que permite enviar datos hacia el
mismo. Antes de describir en mayor profundidad el funcionamiento de ambas,
es necesario conocer el funcionamiento bsico de un subsistema de E/S
moderno.
El subsistema de E/S
El subsistema de E/S de una computadora proporciona un modo de
comunicacin entre el sistema central y el ambiente externo. Los dispositivos de
E/S conectados a la computadora tambin se llaman perifricos. Un subsistema
de E/S consiste en interfases de E/S y dispositivos perifricos. La estructura
general de un susbsistema de E/S es la siguiente:
94
CPU
MEMORIA
Bus de datos
Bus de direcciones
Bus de control
Interfaz de E/S
Subsistema de E/S
Dispositivo de E/S
Interfaz de E/S:
La interfaz de E/S proporciona un mtodo para transferir informacin entre
dispositivos de almacenamiento interno y dispositivos externos. El propsito del
enlace de comunicacin provisto por la interfaz es resolver las diferencias que
existen entre la computadora central y cada perifrico. Estas diferencias son:
Los perifricos son dispositivos electromecnicos y electromagnticos,

por lo tanto se necesita una conversin de valores de seales.
La velocidad de transferencia de datos es diferente para cada dispositivo

y a su vez es diferente con respecto a la velocidad de transferencia de la
CPU. Por ello se necesita un mecanismo de sincronizacin.
Los cdigos de datos y los formatos en los perifricos son diferentes del
formato de palabra del sistema central.
Los modos de operacin de cada dispositivo son diferentes entre s.
Funciones de una Interfaz de E/S:
Control y Temporizacin: para coordinar el trfico entre los recursos

internos y los dispositivos externos. Adems se realiza arbitraje de buses
comunes.
Comunicacin con la CPU: Decodificacin de rdenes (ejemplo READ

SECTOR), Intercambio de Datos, Informacin de estado (ejemplo BUSY,
READY), reconocimiento de direccin.
Comunicacin con los dispositivos:

informacin de estado y datos.
Almacenamiento temporal de los datos.
Deteccin de errores: por defectos mecnicos y elctricos, por ejemplo
implica
intercambiar
rdenes,
95
papel atascado en una impresora. Tambin errores en la informacin
almacenada o transmitida, lo cual se logra por ejemplo mediante el uso
de un bit de paridad.
Tcnicas de transferencia de E/S:

Los subsistemas de E/S suelen clasificarse en base a qu tanto se involucra la
CPU en la transaccin de E/S. Se entiende por transaccin el transferir un nico
bit, byte, palabra, o bloque de bytes de informacin entre el dispositivo de E/S y
la CPU, o entre el dispositivo de E/S y la memoria principal.
Existen diversas tcnicas para el manejo de esta transferencia de datos entre el
computador (CPU o memoria) y los dispositivos externos. Algunas usan la CPU
como una trayectoria intermedia; otras transfieren los datos directamente desde
o hacia la unidad de memoria. Desde este punto de vista, la transferencia de
datos puede ser:
Programada
Basada en interrupciones
Por acceso directo a memoria (DMA, Direct Memory Access)
Con un procesador de E/S (IOP, Input/Output Processor)
A continuacin se describe brevemente cada una de estas tcnicas.
Entrada/Salida programada:
En este caso los datos se intercambian entre la CPU y la interfaz de E/S. La CPU
ejecuta un programa que le da el control directo de la operacin de entrada o
salida, donde se incluye la deteccin del estado del dispositivo, el envo de un
comando de lectura o escritura y la transferencia de datos.
Transferir datos bajo el control del programa requiere que la CPU realice un
monitoreo constante de perifricos. Cuando la CPU enva una orden a la interfaz
de E/S, debe esperar hasta que la operacin concluya. Una vez que se inicia una
transferencia de datos, es necesario que la CPU monitoree la interfaz para
detectar cuando puede volverse a realizar una transferencia, ya que la interfaz
no realiza ninguna accin para notificar a la CPU.
Este proceso toma mucho tiempo y mantiene ocupado el procesador mientras
espera por la disponibilidad del dispositivo. Adems, si la CPU es ms rpida
que la interfaz de E/S ste es un tiempo que la CPU desperdicia. Si bien es un
mtodo sumamente ineficiente, tiene la ventaja de ser el que requiriere la menor
cantidad de hardware para ser implementado.
96
Entrada/Salida basada en interrupciones:
Esta tcnica permite que la CPU emita un comando de E/S hacia una interfaz y
luego ejecute otro trabajo. La interfaz se encargar de producir una interrupcin
para solicitar atencin de la CPU cuando est lista para intercambiar datos.
Cuando la CPU detecta la seal de interrupcin detiene la tarea que est
procesando, transfiere el control a una rutina de servicio (conocido como
manejador de interrupcin) para procesar la transferencia de entrada o salida y
luego regresa a la tarea que ejecutaba originalmente.
Tanto en la E/S programada como en la de interrupciones, la CPU es la
responsable de extraer los datos de la memoria principal en una salida y de
almacenar los datos en la memoria principal en una entrada. Si bien esta tcnica
es ms eficiente que la E/S programada, ya que permite que el CPU atienda
otras tareas mientras se espera por el dispositivo perifrico, la misma requiere
de la existencia de un mecanismo de interrupciones lo que incrementa los
requerimientos de hardware.
Acceso directo a memoria (DMA):

La tcnica de acceso directo a memoria permite mover grandes volmenes de
datos sin involucrar directamente la CPU. Necesita un componente adicional: un
controlador de DMA, el cual es capaz de controlar la transferencia de datos.
Cuando la CPU desea leer o escribir un bloque de datos, emite un comando
hacia el controlador de DMA y le enva la siguiente informacin:
1.
Si se trata de una lectura o una escritura.
2.
La direccin del dispositivo de E/S implicado.
3.
La localidad inicial de memoria desde la cual se leer o en la cual se

escribir.
4.
El nmero de palabras a leer o escribir.
La CPU continuar entonces con otras tareas delegando la operacin de

transferencia de informacin al controlador de DMA. Dicho controlador
transfiere la informacin directamente desde o hacia la memoria sin atravesar la
CPU, cuando la transferencia se completa enva una seal de interrupcin a la
CPU para indicar el final de la transferencia.
El controlador de DMA transfiere la informacin a travs del bus de datos, por
ello es necesario que la CPU le ceda el bus para que se pueda llevar a cabo la
transferencia. Cuando el controlador de DMA toma el control del bus puede
hacer la transferencia por rfagas lo cual consiste en transferir varias palabras
en una rfaga continua mientras el controlador de DMA domina los canales de
memoria; o por robo de ciclo donde se transfiere una palabra a la vez, despus
de lo cual la CPU retoma el control de los canales.
97
Esta tcnica es sumamente efectiva cuando se transmiten bloques de datos.
Aunque a simple vista pueda no parecerlo, el mecanismo de robo de ciclos es
sumamente efectivo, ya quelos dispositivos son muy lentos en comparacin a la
CPU. Por esta razn, cuando se produce un conflicto entre el dispositivo y la
CPU se le da prioridad al dispositivo.
Direccionamiento de los dispositivos de E/S

Debido a que los buses no son ms que lneas de comunicacin compartidas
por los diferentes dispositivos, es necesario definir un mecanismo por medio del
cual uno de ellos pueda determinar si los datos transmitidos en un momento
dado a travs del bus van dirigidos a l o a otro dispositivo.
Esto se resuelve de la siguiente manera: un dispositivo conectado al bus de
datos opera de tal forma, que aunque pueda recibir todos los datos que circulan
por l, solo reaccionan cuando la direccin existente en ese momento en el bus
de direcciones tiene un valor concreto, especficamente, la direccin que
identifica a dicho dispositivo. Por ejemplo, la interfaz de E/S del teclado ignora
cualquier dato o comando presente en los diferentes buses, si la direccin
presente en el bus de direcciones no se encuentra en el rango 0x60-0x6F.
Estas direcciones son conocidas como puertos de E/S, y deben identificar de
manera unvoca a los distintos dispositivos (es decir, un puerto solo debe estar
asociado a un nico dispositivo). Sin embargo es posible que varios puertos
estn asociados al mismo dispositivo. Cuando esto sucede (como en el caso del
teclado), cada puerto tiene un uso distinto dentro del mismo dispositivo.
Bajo este esquema, los puertos identifican a los diferentes dispositivos de forma
anloga a como una direccin identifica a las diferentes localidades de memoria.
El procedimiento para intercambiar entre el procesador y un dispositivo de E/S
es entonces similar al utilizado para intercambiar informacin entre el
procesador y la memoria. La principal diferencia radica en que en lugar de
utilizar la instruccin mov con direcciones de memoria, se utilizan las
instrucciones in y out con nmeros de puerto, tal y como ser descrito en la
siguiente seccin. A continuacin se presentan algunos ejemplos de los puertos
ms comunes en la arquitectura IA-32:
Dispositivo
Rango de puertos
Teclado
0x60 0x6F
Controlador de disco duro
0x1F0 0x1F7
Puerto de juegos
0x200 0x207
Puerto paralelo (LPT1)
0x378 0x37F
Puerto serial (COM1)
0x3F8 0x3FF
En Linux, es posible visualizar los puertos de E/S en uso, de la siguiente forma:
98
linux> more /proc/ioports

E/S aislada y E/S mapeada a memoria
Actualmente existen dos tcnicas diferentes para permitir la interaccin entre el
CPU y un dispositivo perifrico: La E/S aislada y la E/S mapeada a memoria. La
diferencia entre ambas tcnicas radica en la forma en la que los dispositivos de
E/S son direccionados y las instrucciones utilizadas para intercambiar con los
mismos:
E/S aislada
En la tcnica de E/S aislada, las direcciones de los dispositivos de E/S estn
aisladas del espacio de direcciones de memoria principal, es decir, que una
misma direccin puede ser utilizada para identificar un dispositivo y una
localidad de memoria a la vez. No existe ambigedad alguna, ya que las
instrucciones utilizadas para acceder a los dispositivos y la memoria son
distintas. Por ejemplo, la direccin 0x64 utilizada en una instruccin mov hac
e referencia a la localidad de memoria 0x64, mientras que la misma direccin
utilizada en una instruccin in hace referencia a uno de los puertos asociados
al teclado. Este es el esquema descrito en la seccin anterior.
E/S mapeada a memoria
En la tcnica de E/S mapeada a memoria, una parte del rango de direcciones del
subsistema de memoria es destinado para mapear los diferentes dispositivos
de E/S. La ventaja de esta tcnica consiste en que el acceso a los dispositivos ya
no se hace con las instrucciones especiales in y out, sino con cualquier
instruccin que acceda a memoria como mov. La desventaja consiste en que
se reduce la cantidad de memoria que puede ser direccionada por las
aplicaciones.
Instrucciones in y out
La arquitectura IA-32 proporciona dos instrucciones que permiten enviar o
recibir datos hacia o desde un dispositivo perifrico utilizando E/S aislada.
Ambas instrucciones permiten la utilizacin de sufijos para indicar la longitud
de los datos a transferir. Cuando se utiliza la instruccin in, el destino debe ser
siempre el registro al, ax, o eax, dependiendo del tamao de los datos a recibir
desde el dispositivo. De forma similar, en el caso de la instruccin out, el origen
debe ser el registro al, ax o eax, dependiendo del tamao de los datos a enviar
al dispositivo.
El nmero de puerto (el origen en caso de una instruccin in, o el destino en el
caso de una instruccin out) puede especificarse como un inmediato si el mismo
puede ser representado en ocho bits. Por ejemplo, las siguientes instrucciones
permiten leer o escribir un byte desde o hacia el puerto 0x60:
99
inb $0x60, %al

outb %al, %0x60
Sin embargo, existen casos en los que el nmero de puerto no puede ser
representado en ocho bits. En estos casos, el mismo debe ser especificado
obligatoriamente mediante el contenido del registro dx. Por ejemplo, las
siguientes instrucciones permiten leer o escribir un byte desde o hacia el puerto
0x3F8:
movx $0x3F8, %dx
inb %bx, %al
outb %al, %bx
Existe una variacin de ambas instrucciones que permite transferir datos
directamente desde la memoria hacia el dispositivo de E/S, en lugar de hacerlo
desde el registro al, ax o eax. Los mnemnicos de dichas instrucciones son ins y
outs. En estas instrucciones, no es necesario especificar ningn operando ya
que ambos estn implcitos: El nmero de puerto se encuentra en el registro dx,
mientras que la direccin de memoria se encuentra especificada por el par de
registros [es:edi] (para la instruccin ins) o [ds:esi] (para la instruccion outs), a
partir del segmento de datos.
Adicionalmente, una vez ejecutadas estas instrucciones, el registro que contiene
el desplazamiento a partir del cual se estn almacenando (edi) o desde el cual se
estn tomando (esi) los datos transmitidos es incrementado en 1, 2 o 4
unidades, de acuerdo al tamao del dato transferido (byte, palabra o doble
palabra). Esto permite intercambiar bloques de datos entre la memoria y el
dispositivo de una forma sumamente sencilla.
Por ejemplo, supongamos que se desea recibir un arreglo de diez enteros desde
un dispositivo direccionado con el puerto 0x60, y almacenar el mismo en el
segmento bss identificado con la etiqueta A. Esto es posible utilizando la
instruccin ins:
leal A, %edi
movx $0x60, %edx
ciclo:
cmpl %edi, $A + 40
jge fciclo
insl
jmp ciclo
fciclo:
100
A continuacin se muestran todos los formatos vlidos para las instrucciones de
E/S aislada de la arquitectura IA-32:
Instruccin
inb Puerto, %al
inw Puerto, %ax
inl Puerto, %eax
Inmediato (8 bits)
registro dx
Efecto
%al Puerto
%axl Puerto
%eax Puerto
Operandos vlidos
registro al
registro al
Descripcin
mueve 1 byte
mueve 2 bytes
mueve 4 bytes
Ejemplo
inb $0x60, %al
inl %bx, %eax
Instruccin
outb %al, Puerto
Puerto%al
mueve 1 byte
outw %ax, Puerto
Puerto%ax
mueve 2 bytes
outl %eax, Puerto
Puerto%eax
mueve 4 bytes
registro al
registro al
Instruccin
insb
Efecto
edi edi 1
MEM[es:edi] Puerto
edi edi 2
MEM[es:edi] Puerto
edi edi 4
insl
Instruccin
outsb
outsl
Operandos vlidos
Inmediato (8 bits)
registro dx
MEM[es:edi] Puerto
insw
outsw
Efecto
Efecto
Puerto MEM[ds:esi]
esi esi 1
Puerto MEM[ds:esi]
esi esi 2
Puerto MEM[ds:esi]
esi esi 4
Descripcin
Ejemplo
outb %al, $0x60
outw %ax, %bx
Descripcin
mueve 1 byte desde el puerto indicado por el registro
bx
mueve 2 bytes desde el puerto indicado por el registro
bx
mueve 4 bytes desde el puerto indicado por el registro
bx
Descripcin
mueve 1 byte al puerto indicado por el registro bx
mueve 2 bytes al puerto indicado por el registro bx
mueve 4 bytes al puerto indicado por el registro bx
Antes de comenzar con algunos ejemplos prcticos, se presenta una breve

introduccin a las caractersticas generales de un dispositivo de E/S, y el caso
particular del teclado, el cual ser utilizado en dichos ejemplos.
101
Dispositivos de E/S: El teclado
Anteriormente en este captulo introdujo el concepto de interfaz de E/S. El
propsito de la misma es permitir que la CPU controle una amplia variedad de
dispositivos con caractersticas distintas, de una forma relativamente
estandarizada. A continuacin se explota el diagrama de conexin de la interfaz
de E/S presentado anteriormente, con el fin de describir el diagrama de bloques
bsico de una interfaz de E/S:
El registro de datos acta como buffer para los datos intercambiados entre el
dispositivo y la CPU. Dicho registro puede ser escrito o ledo por la misma, de
acuerdo al tipo de operacin que se est realizando. Por ejemplo, en el caso de
un teclado, cada vez que se presiona una tecla, el cdigo que identifica a la
misma es colocado en este registro, para ser ledo posteriormente por la CPU.
En el caso de un puerto serial, este registro puede ser escrito por la CPU para
enviar datos al dispositivo conectado a dicho puerto.
El registro de estado refleja el estado actual del dispositivo manejado a tras de
la interfaz. Por ejemplo, en el caso de un mdem, dicho registro permite
determinar cuando el dispositivo est listo para transmitir datos, o cuando se ha
recibido uno desde el otro extremo de la lnea.
Por ltimo, el registro de control permite configurar la diferentes caractersticas
de funcionamiento del dispositivo controlado. Por ejemplo, al conectarse a un
router a travs de un puerto serial, es necesario configurar la interfaz para que
funcione a una velocidad de transmisin determinada. Dado que sobre el
registro de control solo se realizan operaciones de escritura, y sobre el registro
de estado solo se realizan operaciones de lectura, los mismos comparten el
mismo nmero de puerto sin que se exista ningn tipo de ambigedad.
102
El teclado es el dispositivo de entrada ms utilizado en una computadora
moderna. Su registro de datos est identificado por el puerto 0x60, mientras
que el puerto 0x64 se utiliza para identificar al registro de estado (en una
lectura) o al registro de control (en una escritura).
Los datos proporcionados por el mismo son transmitidos a la computadora en
forma de cdigos de rastreo (scancodes). Los mismos no son otra cosa que un
nmero que identifica cada una de las diferentes teclas y sus estados. Los
mismos son producidos cuando el usuario presiona (o levanta) una (o varias)
teclas.
Cada modelo de teclado utiliza un cdigo interno (definido en el firmware), el
cual es traducido a la forma de un cdigo de rastreo al ser transmitido a la
computadora, con la intencin de estandarizar el uso de estos dispositivos. An
as, existen diferentes conjuntos de cdigos de rastreo. La mayora de los
teclados permiten seleccionar cual de dichos conjuntos se desea utilizar.
Para efectos de los ejemplos que sern presentados en la siguiente seccin, tan
solo es necesario comprender que el dispositivo identifica las diferentes teclas
mediante cdigos de rastreo, los cuales deben ser convertidos de alguna forma,
generalmente utilizando una tabla de conversin (conocida como keymap) para
obtener el caracter ASCII correspondiente.
Por lo general los cdigos de rastreo son asignados en base a la posicin que
ocupa cada tecla, comenzando de arriba a abajo y de izquierda a derecha.
Algunas excepciones a esta regla se hacen para mantener la compatibilidad con
modelos ms antiguos, en los que algunas teclas han sido aadidas y/o
eliminadas.
A continuacin se presentan los cdigos de rastreo que sern utilizados en los
ejemplos de la siguiente seccin. Los mismos pertenecen al conjunto de cdigos
#1. Si bien el conjunto de cdigos #2 es el ms utilizado actualmente, el mismo
es convertido al conjunto de cdigos #1 por un microprocesador en la tarjeta
madre de la computadora (esto es debido a razones histricas). Se recomienda
consultar bibliografa especializada para obtener informacin ms detallada al
respecto.
103
Tecla
Cdigo de rastreo (al presionarla)
Cdigo de rastreo (al levantarla)
1
2
3
4
5
6
7
8
9
0
Q
W
E
R
T
Y
U
I
O
P
A
S
D
F
G
H
J
K
L
Z
X
C
V
B
N
M
ENTER
0x02
0x03
0x04
0x05
0x06
0x07
0x08
0x09
0x0A
0x0B
0x10
0x11
0x12
0x13
0x14
0x15
0x16
0x17
0x18
0x19
0x1E
0x1F
0x20
0x21
0x22
0x23
0x24
0x25
0x26
0x2C
0x2D
0x2E
0x2F
0x30
0x31
0x32
0x1C
0x82
0x83
0x84
0x85
0x86
0x87
0x88
0x89
0x8A
0x8B
0x90
0x91
0x92
0x93
0x94
0x95
0x96
0x97
0x98
0x99
0x9E
0x9F
0xA0
0xA1
0xA2
0xA3
0xA4
0xA5
0xA6
0xAC
0xAD
0xAE
0xAF
0xB0
0xB1
0xB2
0x9C
Observe que la diferencia entre el cdigo generado al presionar una tecla, y el

generado al levantarla, consiste nicamente en el sptimo bit, que en el primer
caso se encuentra apagado y en el segundo encendido. Es posible visualizar la
104
tabla de traduccin utilizada actualmente por su computadora, utilizando el
comando dumpkeys en la consola de comandos de Linux.
Ahora bien, cuando el usuario presiona (o levanta) una tecla, el cdigo de
rastreo correspondiente es colocado en el registro de datos del teclado.
Adicionalmente se enciende el bit 0 del registro de estado, para indicar que un
cdigo de rastreo vlido se encuentra en el registro de datos.
Un programa que utilice la tcnica de transferencia de E/S programada, deber
monitorear continuamente el estado de dicho bit para detectar que una tecla ha
sido presionada o levantada (en las otras tcnicas el teclado activa una
interrupcin con el fin de notificar este hecho).
De esta forma, el esqueleto bsico de un programa que desea recibir el cdigo
de rastreo de una tecla que ha sido presionada o levantada es el siguiente:
espera: inb $0x64, %al
andb $1, %al
cmpb $0, %al
je espera
inb $0x60,%al
# Lee el registro de estado

# Enmascara el bit 0
# Si est apagado espera
# Lee el scancode del registro de datos
Adicionalmente, es posible enviar comandos al teclado (para lo cual existe un

protocolo definido). De manera similar a lo que ocurre en el caso de la lectura
de un cdigo de rastreo, es necesario esperar a que el teclado este listo para
recibir un comando antes de enviarlo. Esto se determina examinando el bit 1 del
registro de estado. Si el mismo se encuentra encendido, indica que el
dispositivo se encuentra ocupado. En consecuencia el programa debe esperar a
que dicho bit se encuentre apagado para enviar un comando.
Los comandos (y sus parmetros, en caso de necesitarlos) se envan a travs del
registro de datos. Solo en casos muy especficos se escribe directamente el
registro de control del teclado. Por ejemplo, para enviar el comando CMD con
parametro DATA al teclado, debe seguirse el siguiente esquema:
andb $2, %al
jne espera
movb
outb
movb
outb
CMD, %al
%al,$0x60
DATA, %al
%al,$0x60

# Si no est listo para recibir espera
#
#
#
#
CMD: Byte que identifica el comando

Enva el comando
DATA: Parmetro del comando
Enva el parmetro
En la siguiente seccin se har un uso exhaustivo de los dos fragmentos de

cdigo aqu expuestos, con el fin de demostrar los principios de la tcnica de
transferencia de E/S programada en el caso especfico de un teclado.
105
Ejemplos prcticos:
En esta seccin se presentan algunos ejemplos prcticos de utilizacin de las
instrucciones in y out. Al estudiar los mismos, debe tener en cuenta que al
interactuar en lenguaje de mquina con un dispositivo de E/S se estn rozando
los lmites que separan el software del hardware, por lo cual todo comienza a
ser mucho ms dependiente de este ltimo. En otras palabras: en este nivel, el
programa es 100% dependiente del hardware con el cual se est interactuando.
En este caso se utilizar un dispositivo sencillo y al alcance de todos: el teclado.
Se utilizar direccionamiento mediante E/S aislada utilizando las instrucciones
iny out. Adems en todos los ejemplos se utilizar la tcnica de E/S
programada, ya que el uso de cualquier otra tcnica involucrara modificar el
Sistema Operativo (por ejemplo para reemplazar el manejador de interrupciones
del teclado), tarea que se encuentra fuera del alcance de este libro.
Antes de ejecutar cualquiera de estos ejemplos es necesario tener en cuenta los
siguientes puntos:
An cuando el programa est interactuando con el teclado mediante E/S
programada, el manejador de interrupciones del teclado del Sistema
Operativo se mantiene activo, por lo cual el mismo captura y enva a la
consola de comandos cada una de las teclas presionadas.
Los puertos del teclado aqu utilizados son compartidos tambin por el
ratn. El ejecutar estos programas con el mismo conectado a la PC puede
causar conflictos y derivar en un comportamiento inesperado, en especial
en el ltimo ejemplo en el que se envan comandos al teclado.
Al estar utilizando E/S programada es posible que se pierdan algunas de
las teclas presionadas. La utilizacin de una computadora con un CPU
sumamente rpido ayuda a mejorar este aspecto, ms nunca puede
corregirlo del todo. Esto se nota en especial en el ltimo ejemplo, en el
que se debe esperar por un el teclado no solo para recibir datos sino
tambin para enviar comandos.
Dado que el programa solicita permiso para acceder directamente a los
puertos del teclado, el mismo no puede ser ejecutado sin permisos de
superusuario.
Con la intencin de minimizar los efectos causados por los problemas
anteriormente mencionados, se proponen las siguientes acciones:
Las cadenas de salida de los programas comienzan con un caracter '\b',

esto con el fin de borrar el caracter escrito por el Sistema Operativo en la
consola cuando el manejador de interrupciones del teclado detecta una
tecla presionada. La solucin ptima sera deshabilitar dicho manejador
de interrupciones, sin embargo el realizar una accin como esta escapa
del alcance de este libro.
Desconecte el ratn antes de ejecutar el programa o preferiblemente
106
antes de encender la computadora para evitar cualquier tipo de conflicto
con dicho dispositivo.
Ejecute los programas en modo texto. Si no sabe o no puede iniciar su

computadora en modo texto, ejectelos desde un terminal virtual.
Inicie sesin como superusuario, o bien ejecute los programas con

permisos de superusuario utilizando el comando sudo.
Reduzca la frecuencia con la que el teclado detecta que una tecla es

presionada mediante el uso del comando kbdrate. Esto con el fin de
poder visualizar con mayor detenimiento el funcionamiento de cada uno
de los programas.
Dicho todo esto, se recomienda seguir los siguientes pasos a la hora de ejecutar
los programas de ejemplo. En caso de no seguir dichos pasos el
comportamiento de los programas puede no ser el esperado:
Desconecte el ratn de la computadora antes de encender la misma.
Inicie la computadora.
Si la misma se inicia en modo grfico, presione las teclas CTRL+ALT+F1
para cambiar al primer terminal virtual.
Inicie sesin como superusuario en dicho terminal.
Cambie la frecuencia de reconocimiento y el retardo de repeticin del
teclado mediante el comando: kbdrate -r 2.0 -d 1000.
Compile y ejecute los programas de ejemplo.
Termine la sesin en el terminal virtual mediante el comando exit.
De ser necesario, regrese al entorno grfico presionando las teclas
CTRL+ALT+F7.
Apague la computadora.
Conecte de nuevo el ratn.
En este primer ejemplo, simplemente se muestra al usuario el scancode recibido
(en formato hexadecimal) cada vez que se presiona (o se levanta) una tecla. El
programa finaliza cuando se detecta el scancode 0x1C, correspondiente a la
tecla ENTER presionada:
.section .data
CAD:
.asciz "\bScancode leido: 0x%2x\n"
ERROR: .asciz "Se ha denegado el permiso sobre los puertos del
teclado\n"
SC:
.bss
.space 1
# Espacio para almacenar el scancode
107
.section .text
.globl _start
_start:
# Solicita permiso sobre los puertos del teclado
movl $101, %eax
# Servicio 101 (ioperm)
movl $0x60, %ebx
# Desde 0x60 (Registro de datos)
movl $5, %ecx
# Hasta 0x64 (Registro de estado)
movl $1, %edx
# Obtener permiso
int $0x80
# Llamada al SO
testl
%eax,%eax
jne err

andb $1, %al
cmpb $0, %al
je espera
# No se obtuvo el permiso

xorl %eax, %eax

inb $0x60,%al
movb %al, SC
# Limpia eax
# Salvaguarda el scancode leido
pushl %eax
pushl $CAD
call printf
addl $8, %esp
# Imprime el scancode (hex)
cmpb $0x1C,SC
je fin
jmp espera
# Si es ENTER (presionada) terminar
err:
pushl $ERROR
call printf
addl $4, %esp
# Informa al usuario sobre el error
fin:
movl $101, %eax

movl $0x60, %ebx
movl $5, %ecx
movl $0, %edx
int $0x80
#
#
#
#
#
movl $1, %eax

movl $0, %ebx
int $0x80
Servicio 101 (ioperm)

Desde 0x60 (Registro de datos)
Hasta 0x64 (Registro de estado)
Liberar permiso
Llamada al SO
108
Observe que el corazn del programa est compuesto de dos ciclos anidados:
en el ms interno se lee el registro de estado del teclado (puerto 0x64), y si
verifica si el bit 0 se encuentra encendido. Mientras esto no sea as, el programa
se mantiene esperando. Una vez que el usuario presiona una tecla, y el bit 0 del
registro de estado se enciende, el programa lee el cdigo de rastreo
almacenado en el registro de datos del teclado (puerto 0x60) e imprime el
mismo en formato hexadecimal mediante una llamada a printf.
Si dicho cdigo de rastreo coincide con el generado al presionar la tecla ENTER
(0x1C), el programa sale del ciclo externo y finaliza su ejecucin. Observe
adems que para poder acceder a los puertos mencionados, el programa solicita
permiso al sistema operativo mediante una llamada al servicio ioperm. De
manera similar los permisos son liberados al finalizar la ejecucin del programa.
Si se observa con detenimiento la salida de este programa, se verifica que tal y
como se describi anteriormente, el presionar y levantar una tecla genera dos
cdigos de rastreo exactamente iguales, con la diferencia de que el primero de
ellos tiene el bit 7 apagado, mientras que el segundo lo tiene encendido.
El siguiente programa es una versin modificada del anterior, en el cual en lugar
de mostrar el cdigo de rastreo recibido, se indica al usuario si la tecla
(cualquiera que esta sea) ha sido presionada o levantada. Nuevamente, el
programa finaliza una vez que el usuario presiona la tecla ENTER:
.section .data
CAD1:
.asciz "\bTecla presionada\n"
CAD2:
.asciz "\bTecla levantada\n"
teclado\n"
SC:
.bss
.space 1
.section .text
.globl _start
_start:
movl $101, %eax
movl $0x60, %ebx
movl $5, %ecx
movl $1, %edx
# Obtener permiso
int $0x80
# Llamada al SO
testl
%eax,%eax
jne err
109
andb $1, %al
cmpb $0, %al
je espera

xorl %eax, %eax

inb $0x60,%al
movb %al, SC
# Limpia eax
# Salvaguarda el scancode leido
andb $0x80, %al

jne sino
# Verifica el estado del bit 7

# Si est encendido fue levantada
si:
pushl SC
pushl $CAD1
call printf
addl $8, %esp
jmp fsi
# La tecla fue presionada
sino:
pushl SC
pushl $CAD2
call printf
addl $8, %esp
# La tecla fue levantada
fsi:
cmpb $0x1C,SC
je fin
jmp espera
# Si es ENTER (presionado) terminar
err:
pushl $ERROR
call printf
addl $4, %esp
fin:
movl $101, %eax

movl $0x60, %ebx
movl $5, %ecx
movl $0, %edx
int $0x80
#
#
#
#
#
movl $1, %eax

movl $0, %ebx
int $0x80

Liberar permiso
Llamada al SO
El funcionamiento de este programa es bsicamente idntico al anterior, con la

diferencia de que ahora se aplica una mscara (0x80) para comprobar el estado
del bit 7 en el cdigo de rastreo recibido, y en base a esto se imprime el
mensaje correspondiente.
Ahora bien, suponga que desea detallar an ms este programa, indicando al
usuario la tecla que presion (no su cdigo de rastreo). Dado que los cdigo de
110
rastreo no tienen una correspondencia directa con el cdigo ASCII, no existe una
forma sencilla de convertir el cdigo de rastreo al ASCII que le corresponde para
poder imprimirlo mediante la funcin printf.
Una instruccin sumamente poderosa que se utiliza generalmente en este tipo
de programas es la instruccin xlat. Como su nombre lo indica, la misma sirve
para llevar a cabo una traduccin. En realidad lo que la misma realiza es una
bsqueda dentro de una tabla. La instruccin no recibe parmetros de forma
explcita, sino que asigna al registro %al, el byte ubicado en la posicin N de la
tabla, donde N es el valor que contena dicho registro antes de la ejecucin de la
instruccin xlat. La tabla se ubica en memoria, y su direccin de inicio debe
estar contenida en el registro ebx.
Por ejemplo, suponga que se desea traducir un dgito decimal a su cdigo ASCII
correspondiente. Esto es posible mediante el uso de una tabla de traduccin:
TABLA:
.ascii 0123456789
y la instruccin xlat:
movb NUM, %al
leal TABLA, %ebx
xlat
# %al = MEM[%ebx+%al]
En el tercer ejemplo, el programa indica al usuario que tecla ha presionado, si la

misma es una letra. En caso de ser cualquier otra tecla, se muestra un asterisco.
Las teclas levantadas son ignoradas. Como en los casos anteriores, el programa
finaliza una vez que el usuario presiona la tecla ENTER:
.section .data
CAD:
.asciz "\b%c\n"
teclado\n"
table:
.asciz "QWERTYUIOP****ASDFGHJKL*****ZXCVBNM"
SC:
.bss
.space 1
.section .text
.globl _start
111
_start:
movl $101, %eax
movl $0x60, %ebx
movl $5, %ecx
movl $1, %edx
# Obtener permiso
int $0x80
# Llamada al SO
testl
%eax,%eax
jne err
andb $1, %al
cmpb $0, %al
je espera
xorl %eax, %eax
inb $0x60,%al
cmpb $0x1C,%al
je fin

# Limpia eax
movb %al, SC
andb $0x80, %al
jne espera
# Ignora las teclas levantadas
cmpb $0x10, SC
jl noletra
cmpb $0x32, SC
jg noletra
#
#
#
#
leal table, %ebx

movb SC, %al
subb $0x10,%al
xlat
jmp mostrar
# Traduce el scancode a la letra
movb $'*', %al
# Si no es una letra imprime *
pushl %eax
pushl $CAD
call printf
addl $8, %esp
jmp espera
# Muestra la tecla presionada
Si
No
Si
No
el
es
el
es
scancode es menor al de la Q
una letra
scancode es mayor al de la M
una letra
noletra:
mostrar:
112
err:
pushl $ERROR
call printf
addl $4, %esp
fin:
movl $101, %eax

movl $0x60, %ebx
movl $5, %ecx
movl $0, %edx
int $0x80
#
#
#
#
#
movl $1, %eax

movl $0, %ebx
int $0x80

Liberar permiso
Llamada al SO
El funcionamiento de este programa es prcticamente idntico al del primer

ejemplo, con la salvedad de que el cdigo de rastreo recibido es traducido a
su correspondiente ASCII (en el caso de ser una letra) o a un asterisco (en caso
de ser otra tecla). Para ello se define en el segmento de datos la tabla de
traduccin adecuada. Observe que como los cdigos de rastreo de las teclas
correspondientes a las letras no ocupan un rango continuo, sino que existen
algunos cdigos de rastreo correspondientes a otras teclas intercalados entre
estas, se han incluido algunos asteriscos dentro de la tabla.
En el caso de que se quisiera traducir el cdigos de rastreo a una cadena en
lugar de un caracter (por ejemplo para identificar las teclas ENTER o ESC), la
tabla debera contener apuntadores a dichas cadenas. Sin embargo, dado que
los elementos de la tabla son de 1 byte de longitud, tendra ms sentido que la
tabla reflejara la posicin que ocupa el apuntador a la cadena en cuestin
dentro de un arreglo cuyos elementos ocupen 4 bytes. La solucin ms
apropiada depende del problema especfico que se quiera resolver, pero en
cualquier caso la instruccin xlat es una herramienta poderosa que siempre
debe ser considerada.
Todos los ejemplos anteriores han hecho uso de la instruccin in, lo cual es
natural debido a que estamos interactuando con un dispositivo de entrada como
lo es el teclado. Sin embargo, es posible utilizar dicho dispositivo como
elemento de salida, valindonos de los LEDs indicadores del mismo (NUM, CAPS
y SCROLL).
Para ello se enva un comando de control que permite especificar cuales LEDs
deben estar encendidos y cuales no. El programa detecta cuando el usuario
presiona cualquiera de las teclas correspondientes a los nmeros del 0 al 7 (del
teclado bsico, no el numrico), y muestra su representacin binaria utilizando
los LEDs anteriormente mencionados. En otras palabras, el programa transforma
el teclado en un convertidor octal a binario de un dgito:
.section .data
teclado\n"
table: .byte 0b000, 0b001, 0b100, 0b101, 0b010,0b011,0b110,0b111
113
SC:
.section .bss
.space 1
.section .text
.globl _start
_start:
movl $101, %eax
movl $0x60, %ebx
movl $5, %ecx
movl $1, %edx
# Obtener permiso
int $0x80
# Llamada al SO
testl
%eax,%eax
jne err

andb $1, %al
je espera
xorl %eax, %eax
inb $0x60,%al
cmpb $0x1C,%al
je fin
cero:

# Limpia eax
movb %al, SC
andb $0x80, %al
jne espera
cmpb $0x0B, SC
je cero
# Si el scancode es el del 0
# Salta a cero
cmpb $0x02, SC
jl espera
cmpb $0x08, SC
jg espera
#
#
#
#
decb SC
jmp mostrar
# Resta 1 al scancode
movb $0, SC
# El dgito es 0
Si
No
Si
No
el
es
el
es
scancode es menor al del 1

un dgito octal
scancode es mayor al del 7
un dgito octal
114
mostrar:
inb $0x64, %al
andb $2, %al
jne mostrar
# Lee el registro de control

movb $0xED, %al

outb %al,$0x60
movb SC, %al
leal table, %ebx
xlat
outb %al,$0x60
jmp espera
#
#
#
#
#
#
err:
pushl $ERROR
call printf
addl $4, %esp
fin:
movl $101, %eax

movl $0x60, %ebx
movl $5, %ecx
movl $0, %edx
int $0x80
#
#
#
#
#
movl $1, %eax

movl $0, %ebx
int $0x80
Comando 0xED: Luces del teclado

Enva el comando
Carga el digito octal
Direccin de la tabla de traduccin
Traduce al patrn de las luces
Enva el patrn

Liberar permiso
Llamada al SO
En este ejemplo se utilizan las mismas tcnicas que en el ejemplo anterior para
esperar que una tecla sea presionada y asegurarse que sea uno de los dgitos
del 0 al 7 en el teclado bsico. Luego el mismo es traducido a un patrn de
bits que representa los estados de los tres LEDs del teclado (1 encendido, 0
apagado). La idea de dicho patrn consiste en que los LEDs representen el
equivalente binario del dgito octal presionado por el usuario. La tabla fue
construida de la siguiente forma:
Octal
Binario
0
1
2
3
4
5
6
7
000
001
010
011
100
101
110
111
CAPS
0
0
1
1
0
0
1
1
Patrn de bits a enviar

NUM
0
0
0
0
1
1
1
1
SCROLL
0
1
0
1
0
1
0
1
115
El patrn que se enva al teclado debe indicar el estado de cada uno de los tres
LED's en el orden CAPS-NUM-SCROLL. Sin embargo, la disposicin fsica de los
mismos en el teclado es NUM-CAPS-SCROLL. De all que en la tabla los bits 1 y
2 se encuentren invertidos con respecto al nmero binario.
Una vez obtenido el patrn a enviar, el programa debe esperar nuevamente por
el teclado, sin embargo en este caso no se espera a que se presione o levante
una tecla, sino a que el dispositivo est listo para recibir un comando. En este
caso, el bit del registro de estado utilizado para reflejar esta condicin es el bit
2 (en lugar del 0). Una vez que el teclado est dispuesto a recibir un comando,
se enva el mismo (0xED, utilizado para modificar el estado de los LEDs) seguido
del patrn anteriormente obtenido utilizando la instruccin outb dos veces.
Si bien los protocolos, registros y puertos varan de un dispositivo a otro, los
principios de funcionamiento ilustrados en estos cuatro ejemplos son los
mismos para cualquiera de ellos. Vale la pena comentar que en el lenguaje de
programacin C existen macros equivalentes a las instrucciones in y out, as
como una funcin equivalente a la llamada al sistema ioperm. Los manejadores
de interrupciones, por ejemplo, suelen ser escritos en lenguaje C y utilizar las
macros y funciones anteriormente mencionadas.
116
Ejercicios
6.1- Escriba un programa que lea seis valores y los muestre por pantalla segn
el formato escogido por el usuario. Los formatos disponibles son:
[1] En una lnea horizontal en el orden de entrada
[2] En una lnea horizontal en orden inverso a la entrada
[3] De manera vertical en el orden de entrada
[4] De manera vertical en orden inverso a la entrada
Utilice las funciones printf y scanf.
6.2- Escriba un programa que lea cuatro valores enteros y calcule su suma.
Debe mostrar el resultado por pantalla. Utilice las funciones printf y scanf.
6.3- Escriba un programa que lea cuatro valores enteros y calcule su promedio.
Debe mostrar el resultado por pantalla. Utilice las funciones printf y scanf.
6.4- Escriba un programa que lea dos valores enteros a y b y produzca como
salida un resultado segn las siguientes condiciones:
Si a=b: resultado=a
Si a>b: resultado=a-b
Si a<b: resultado=b-a
6.5- Escriba un programa que lea la cantidad de minutos de duracin de una
llamada telefnica y que calcule el monto a pagar por dicha llamada de acuerdo
a la siguiente tarifa:
Si la llamada dura hasta 3 minutos el monto a pagar ser Bs. 200

Cada minuto adicional cuesta Bs. 100

6.6- Escriba un programa que solicite al usuario introducir una cadena y dos
caracteres. El programa debe reemplazar las apariciones del primer caracter con
el segundo caracter. Utilice llamadas al sistema.
6.7- Modifique el primer ejemplo de la seccin Llamadas al sistema de forma
que el resultado pueda ser presentado al usuario mediante una nica llamada al
sistema en lugar de dos. Ayuda: Piense en la utilidad del carcter nulo al final de
una cadena.
6.8- Qu cambios es necesario realizar al segundo ejemplo de la seccin
Llamadas al sistema de forma que trabaje en base binaria en lugar decimal?
Para que rango de bases es esto vlido? Por qu?.
6.9- Escriba un programa que pida al usuario un entero decimal con signo. Si el
nmero es negativo, el mismo estar precedido por el smbolo -, mientras que
si el nmero es positivo el mismo puede o no estar precedido por el smbolo
+. La lectura debe ser hecha mediante una llamada al sistema, mientras que el
resultado se mostrar al usuario mediante una llamada a la funcin printf.
117
6.10- Escriba un programa que permita emular el concepto de la cadena de
formato de la funcin scanf utilizando nicamente llamadas al sistema. Asuma
que la cadena de formato se encuentra en el segmento de datos en una etiqueta
llamada format. De igual forma asuma que la direccin de cada uno de los
argumentos adicionales se encuentran en un arreglo llamado params, en el
que cada elemento es una direccin de memoria de 4 bytes. Los especificadores
de formato vlido son nicamente %c y %s.
6.11- Escriba un programa que notifique al usuario cuando una de las teclas de
funcin (F1-F12) sea presionada o levantada. Utilice E/S programada.
6.12- Modifique el programa anterior, de manera que omita las repeticiones
generadas al mantener presionada durante cierto tiempo la tecla en cuestin.
6.13- Escriba un programa que notifique al usuario cuando se detecte que se ha
presionado la combinacin de teclas CTRL+ALT+Q. Utilice E/S programada
6.14- Escriba un programa que convierta el teclado en una calculadora binaria
de 3 bits. Para ello deber reconocer comandos de la forma [+*][XXX], donde OP
es una de las teclas '+' o '-', y X es una de las teclas '0' o '1'. El mismo deber
calcular la operacin especificada (+: OR a nivel de bit, *: AND a nivel de bit)
entre el acumulador (inicializado en cero) y el nmero binario introducido. El
resultado debe ser mostrado utilizando los LEDs del teclado. El programa
finaliza al presionar la tecla ENTER.
118
Captulo 7. Control de flujo

Estas estructuras son las que dirigen el flujo de ejecucin de un programa. An
cuando
es
posible
programar
directamente
en
lenguaje
ensamblador,
presentamos las estructuras de control de flujo ms comunes en los lenguajes

de alto nivel y su traduccin a ensamblador. Para los programas de alto nivel
utilizamos el lenguaje de programacin C. Para la programacin tanto de las
estructuras condicionales como de los ciclos, en lenguaje ensamblador se
utilizan las instrucciones de comparacin y los saltos condicionales.
Traduccin de estructuras condicionales

Por ejemplo para realizar un extracto de programa que haga lo siguiente:
if (x>y)
result=x-y;
else
result=y-x;
Se puede traducir como:
1
2
3
4
5
6
7
8 mayor:
9
10 fin:
movl x, %ebx
movl y, %eax
cmpl %eax, %ebx
jg mayor
subl %ebx, %eax
movl %eax, result
jmp fin
subl %eax, %ebx
movl %ebx, result
#
#
#
#
#
#
#
#
#
%ebx = x
%eax = y
compara %ebx con %eax
si x>y salta a mayor
sino %eax=y-x
guarda el resultado
salta a fin
%ebx=x-y
guarda el resultado
Es importante destacar que al culminar la ejecucin de las instrucciones 5 y 6,

que corresponden a las acciones en caso que no se cumpla la condicin, hay
que incluir un salto incondicional que salte al final del programa para evitar que
se ejecuten las instrucciones 8 y 9 seguidamente lo cual provocara un error ya
que se ejecutaran ambos clculos del resultado y no slo uno de ellos
dependiendo de la condicin.
119
El siguiente ejemplo es equivalente al anterior:
1
movl x, %ebx
2
movl y, %eax
3
cmpl %eax, %ebx
4
jle menorig
5
subl %eax, %ebx
6
movl %ebx, result
7
jmp fin
8 menorig: subl %ebx, %eax
9
movl %ebx, result
10 fin:
#
#
#
#
#
#
#
#
#
%ebx = x
%eax = y
compara %ebx con %eax
si x<=y salta a menorig
sino %ebx=x-y
guarda el resultado
salta a fin
%eax=y-x
guarda el resultado
El siguiente programa revisa un nmero declarado en la seccin de datos y

verifica si es mayor, menor o igual a 5. Produce un mensaje de texto.
Programa en C:
#include <stdio.h>
int x=2;
main()
{
if(x>5)
printf("El nmero es mayor que 5\n");
else
if (x==5)
printf("El nmero es igual a 5\n");
else
printf("El nmero es menor que 5\n");
}
.section .data
x:
.long 9
mensaje1:
.asciz"El numero es igual a 5\n"
mensaje2:
.asciz"El numero es mayor que 5\n"
mensaje3:
.asciz"El numero es menor que 5\n"
.section .text
.globl _start
_start:
movl x, %eax
cmpl $5, %eax
jg mayor
jl menor
pushl $mensaje1
call printf
jmp fin
#
#
#
#
#
carga %eax con el

compara x con 5
si x>5 salta a la
si x<5 salta a la
si x=5 imprime el
valor de x
etiqueta "mayor"
etiqueta "menor"
mensaje 1
# salta a fin de programa
120
mayor:
pushl $mensaje2
call printf
jmp fin
pushl $mensaje3
call printf
movl $1, %eax
xorl %ebx, %ebx
int $0x80
menor:
fin:
# imprime el mensaje 2 cuando x>5

# imprime el mensaje 3 cuando x<5
# fin de programa
Cabe destacar que la instruccin pushl $mensaje1 es equivalente a las

instrucciones:
leal mensaje1, %eax
pushl %eax
Las cuales fueron presentadas en el captulo 6.
Ciclos
Los ciclos permiten ejecutar un conjunto de instrucciones varias veces hasta que
se cumpla una condicin. El chequeo de la condicin puede estar al inicio o al
final del ciclo, en caso de estar al final hay que tener en cuenta que la ejecucin
se va a efectuar al menos una vez.
A modo de ejemplo se presentan cuatro versiones de un programa que imprime
los nmeros del 1 al 10.
Do while
Este ciclo revisa la condicin al final.
#include <stdio.h>
int x=0;
main()
{
do
{
x++;
printf("%d ",x);
}
while(x<10);
printf("\n");
}
121
# Programa que muestra por pantalla los numeros del 1 al 10
# Traduccion del do while
.section .data
formato:
.asciz"%d "
salto:
.asciz"\n"
.section .text
.globl _start
_start:
movl $0, %ebx
do:
incl %ebx
pushl %ebx
pushl $formato
call printf
addl $8, %esp
cmpl $10, %ebx
jl do
pushl $salto
call printf
movl $1, %eax
movl $0, %ebx
int $0x80
#
#
#
#
#
#
#
#
#
%ebx=0, contador
incrementa %ebx
pasa el valor como parametro
pasa el formato como parametro
muestra el valor por pantalla
limpia la pila de parametros
compara %ebx con 10
salta al inicio del ciclo si %ebx < 10
imprime salto de linea
# termina el programa
While
En este caso la condicin se revisa al inicio del ciclo.
#include <stdio.h>
int x=1;
main()
{
while(x<=10)
{
printf("%d ",x);
x++;
}
printf("\n");
}
# Traduccion del while
.section .data
formato:
.asciz"%d "
salto:
.asciz"\n"
.section .text
.globl _start
122
_start:
while:
finwhile:
movl $1, %ebx

cmpl $10,%ebx
jg finwhile
pushl %ebx
pushl $formato
call printf
addl $8, %esp
incl %ebx
jmp while
pushl $salto
call printf
movl $1, %eax
movl $0, %ebx
int $0x80
#
#
#
#
#
#
#
#
#
#
%ebx=1, contador
compara %ebx con 10
salta a finwhile si %ebx > 10
incrementa %ebx
salta al inicio del ciclo
imprime salto de linea
For
Esta estructura permite expresar en una sola lnea el estado inicial del contador,
la condicin y cmo se realiza la cuenta.
#include <stdio.h>
int x;
main()
{
for(x=1;x<=10;x++) printf("%d ",x);
printf("\n");
}
# Traduccion del for
.section .data
formato:
.asciz"%d "
salto:
.asciz"\n"
.section .text
.globl _start
_start:
movl $1, %ebx
for:
cmpl $10, %ebx
jg finfor
pushl %ebx
pushl $formato
call printf
addl $8, %esp
incl %ebx
jmp for
#
#
#
#
#
#
#
#
#
%ebx=1, contador
compara %ebx con 10
si %ebx>10 salta a fin de ciclo
incrementa %ebx
salta al inicio del ciclo
123
finfor:
pushl $salto
call printf
movl $1, %eax
movl $0, %ebx
int $0x80
Como se puede observar, este programa, en lenguaje ensamblador, es idntico

a la implementacin del while.
Los ciclos tambin se pueden programar utilizando la instruccin loop. A
continuacin se muestra una solucin al programa anterior usando loop.
# Uso de la instruccion loop
.section .data
formato:
.asciz"%d "
salto:
.asciz"\n"
.section .text
.globl _start
_start:
movl $10, %ecx
movl $1, %edi
muestra:
# %ecx es el contador de iteraciones

# %edi tiene el numero a mostrar
pushl %ecx
pushl %edi
pushl $formato
call printf
addl $8, %esp
popl %ecx
incl %edi
loop muestra
#
#
#
#
#
#
#
#
#
guarda valor de %ecx

apila valor a mostrar
apila formato de salida
muestra numero por pantalla
restaura valor de %ecx
calcula nuevo valor a mostrar
salta al ciclo para mostrar el
siguiente valor
pushl $salto
call printf
# apila formato de salto de linea

# realiza el salto de linea
movl $1, %eax

xorl %ebx, %ebx
int $0x80
# fin del programa
En este caso hay que salvaguardar el valor de %ecx en la pila antes de la llamada
a la funcin printf y luego restaurar ese registro debido a que las llamadas a
funciones o procedimientos pueden modificar algunos registros, entre ellos
%ecx. Esto se explica en detalle en el captulo 9.
124
Ejercicios
7.1- Escriba un programa que lea un entero y que imprima el mensaje "Hola"
tantas veces como el nmero de entrada. El mensaje debe aparecer en pantalla
llenando lneas horizontales.
7.2- Escriba un programa que lea un entero y que imprima el mensaje "Hola"
tantas veces como el nmero de entrada. El mensaje debe aparecer en pantalla
una sla vez por cada lnea horizontal.
7.3- Escriba un programa que calcule xy.
7.4- Escriba un programa que determine el monto a pagar a un trabajador
semanal segn la siguiente estructura de pagos:
El pago por hora de trabajo (sueldo bsico) puede ser:
Bs. 3.250,oo para un trabajador no calificado

Bs. 4.500,oo para un trabajador calificado
Bs. 4.850,oo para un trabajador calificado con experiencia
El monto a pagar se calcula de la siguiente manera:
Hasta 40 horas de trabajo se pagan con sueldo bsico

De 40 a 60 horas se pagan con sueldo bsico y medio
Ms de 60 horas se pagan con doble sueldo bsico
125
Captulo 8. Arreglos
Cuando se declara un arreglo en C se escribe una expresin con la siguiente
estructura: T A[N]
esta declaracin designa el nombre del arreglo como A de N
posiciones del tipo de dato T. Esto produce la asignacin de un espacio de

memoria de N*T, es decir el nmero de elementos del arreglo por el nmero de
bytes del tipo de dato. Los elementos del arreglo se acceden con un ndice cuyo
rango es { 0, N-1}.
Ejemplo de declaracin y parmetros de arreglos en C:
char A[12];
int B[8];
double C[6];
Sus parmetros son los siguientes:
Arreglo
A
B
C
Tamao de un dato
1 byte
4 bytes
8 bytes
Tamao total del arreglo

12 bytes
32 bytes
48 bytes
Direccin inicial
XA
XB
XC
Elemento i
XA + i
XB + 4i
XC + 8i
En lenguaje ensamblador se utiliza el tipo de direccionamiento escalado para

acceder a las posiciones de un arreglo. Hay que tomar en cuenta la direccin
inicial del arreglo y utilizar un ndice para ir recorriendo cada uno de sus
elementos. El tamao de los datos representa el desplazamiento entre dos
posiciones del arreglo.
Declaracin de arreglos
En lenguaje ensamblador los arreglos se declaran como una variable con varios
valores, por ejemplo si se declara el arreglo a como:
.section .data
a: .long 25,48,32,87
Los elementos del arreglo se guardan en memoria en posiciones consecutivas y

el identificador a apunta a la primera posicin del arreglo, es decir la posicin
cuyo ndice es cero. Cada elemento del arreglo tiene el tamao del tipo de dato
asociado, en este caso cada elemento ocupa 4 bytes debido a que el arreglo
est declarado como tipo long y el tamao total del arreglo es de 16 bytes.
126
En este otro ejemplo:
.section .data
arr: .byte 5,4,3,7
Cada elemento del arreglo ocupa 1 byte. El tamao total de este arreglo es de 4
bytes.
Lectura de datos en un arreglo

La forma general de accesar un arreglo se puede expresar como:
desplazamiento (base, ndice, escala)
La direccin se calcula como:
desplazamiento + direccin base + ndice *escala
Donde escala refleja el tamao del tipo de dato del arreglo.
Para leer un elemento del arreglo a se puede utilizar la siguiente instruccin:
movl a(,%ecx,4), %eax
donde a es la direccin inicial del arreglo y se utiliza un registro, en este caso

%ecx como ndice. La escala (4) viene dada por el tamao del tipo de dato del
arreglo.
Hay varias maneras de leer informacin de un arreglo. A continuacin se
presentan dos soluciones para leer los valores de la primera y tercera posiciones
de un arreglo de enteros:
.section .data
arr: long 10,20,30,40,50,60,70,80
#arreglo arr de enteros
.section .text
.globl _start
_start:
# En ambas soluciones se coloca el valor de la primera posicin
# del arreglo (10) en %eax y el valor de la tercera posicin del
# arreglo (30) en %ecx; arr denota la direccin inicial del
# arreglo. La escala es 4 porque el tipo de dato (entero) ocupa
# 4 bytes de memoria.
# solucin 1
movl $0, %ebx
movl arr(, %ebx, 4), %eax
movl $2, %ebx
movl arr(, %ebx, 4),%ecx
#
#
#
#
#
#
actualiza %ebx en 0 (ndice=0)

direccin= arr+(0*4),transfiere
el valor 10 a %eax
el valor 30 a %ecx
127
# solucin 2
leal arr, %edx
movl $0, %ebx
movl (%edx, %ebx, 4), %eax
movl $2, %ebx
movl (%edx, %ebx, 4), %ecx
#
#
#
#
#
#
#
#
%edx contiene la direccin

inicial del arreglo arr
direccin=arr+(0*4),transfiere
el valor 10 a %eax
el valor 30 a %ecx
Ejemplo: programa que dado un arreglo de enteros de 10 posiciones,

inicializado, suma los valores del arreglo y guarda el resultado en la variable
"result"
.section .data
arr: .long 34, 5, 8, 12, 43, 21, 9, 6, 92, 10
result: .long 0
.section .text
.globl _start
_start:
movl $0, %eax
movl $0, %ecx
suma:
addl arr(,%ecx,4), %eax
incl %ecx
cmpl $10, %ecx
jl suma
movl %eax, result
movl $1, %eax
xorl %ebx, %ebx
int $0x80
#
#
#
#
#
#
#
#
inicializa %eax en 0
inicializa el ndice
suma un nuevo valor
incrementa el ndice
compara i con 10
si i<10 salta a suma
actualiza result
fin del programa
Ejemplo: programa que dado un arreglo de 10 caracteres, indica la cantidad de

ocurrencias de la letra "a".
section .data
mensaje:
.asciz"Programa que dado un arreglo de 10 caracteres\n"
mensaj2:
.asciz"indica la cantidad de ocurrencias de la letra a\n"
salida:
.asciz"En el arreglo hay %d veces la letra a\n"
salto:
.asciz"\n\n"
arr:
.byte 'a','b','c','d','a','s','a','w','f','a'
.section .text
.globl _start
128
_start:
verif:
noa:
finverif:
pushl $mensaje
call printf
pushl $mensaj2
call printf
addl $8, %esp
# mensaje inicial
xorl %eax, %eax

xorl %edx, %edx
cmpl $10, %edx
je finverif
movb arr(%edx), %bl
cmpb $'a', %bl
jne noa
incl %edx
incl %eax
jmp verif
incl %edx
jmp verif
# acumulador de ocurrencias
# indice para el arreglo
pushl %eax
pushl $salida
call printf
# muestra resultado por pantalla
movl $1, %eax

xorl %ebx, %ebx
int $0x80
# fin del programa
# lee caracter
# compara con a
#
#
#
#
si = a incrementa el indice
y el acumulador
lee siguiente caracter
si dif a solo incrementa indice
Escritura de datos en un arreglo

La escritura de datos en un arreglo se hace de manera similar, por ejemplo el
siguiente programa escribe los nmeros del 1 al 10 en un arreglo de 10
posiciones:
.section .bss
arr: .space 40
# se declara el espacio de 40 bytes para generar

# el arreglo de 10 posiciones de enteros
.section .text
.globl _start
_start:
leal arr, %ebx
# %ebx=dir inicial del arreglo
xorl %ecx, %ecx
# %ecx=0 indice
movl $1, %eax
# valor a guardar en el arreglo
genera:
cmpl $9, %ecx
# compara el indice con 9
jg fin
# salta a fin cuando indice=10
movl %eax, (%ebx, %ecx, 4)
# escribe valor en arr
incl %eax
# incrementa el valor
129
fin:
incl %ecx
movl $1, %eax
movl $0, %ebx
int $0x80
# incrementa el indice
# fin del programa
130
Ejercicios
8.1- Escriba un programa que lea un arreglo de n enteros y sume los elementos
del arreglo.
8.2- Escriba un programa que lea un arreglo de 20 enteros y calcule el
promedio de los nmeros del arreglo.
8.3- Escriba un programa que lea un arreglo de n enteros y calcule la cantidad
de nmeros pares.
8.4- Escriba un programa que lea un arreglo de n enteros y calcule la sumatoria
de los nmeros pares.
8.5- Escriba un programa que lea un arreglo de 12 enteros determine el mayor
e indique en que posicin se encuentra.
131
Captulo 9. Procedimientos
Los procedimeintos son segmentos de programa sumamente tiles para evitar
la repeticin de cdigo, un programa con procedimientos es adems mucho
ms legible.
Una llamada a un procedimiento involucra el pase de informacin tanto hacia el
procedimiento como de retorno y el pase del control de flujo de ejecucin de
una parte del cdigo hacia otra. El pase de informacin desde y hacia el
procedimiento se realiza a travs de la pila. La porcin de la pila asignada a una
llamada a un procedimiento se conoce como marco de pila. Para utilizar la pila
se usan dos registros que sirven de apuntadores: %ebp es el apuntador de
marco de pila y %esp es el apuntador de pila, ste es el registro cuyo contenido
cambia mientras se ejecuta el procedimiento.
Instrucciones para llamadas a procedimientos

Las instrucciones que se utilizan para transferir el control en los procedimientos
son las siguientes:
Instruccin
Descripcin
call etiqueta
llamada a procedimiento
leave
preparacin para el retorno
ret
retorno de procedimiento
Cuando se ejecuta una llamada a procedimiento (call) el sistema apila la

direccin de retorno y transfiere el control al procedimiento. La direccin de
retorno es la direccin de la instruccin siguiente a la llamada. La instruccin de
retorno (ret) retira la direccin de retorno de la pila y pasa el control a esta
direccin. Dentro del procedimiento hay que preparar la pila para su uso, esto
se hace al inicio del procedimiento con las instrucciones:
pushl %ebp
movl %esp, %ebp
# preserva marco de pila anterior

# actualiza marco de pila
Y luego se prepara la pila para el retorno al programa invocador, lo cual se

realiza con la instruccin leave que se ejecuta antes de ret. La instruccin leave
reemplaza las siguientes dos instrucciones:
movl %ebp, %esp
# mueve el apuntador de pila al marco de

# pila anterior
132
popl %ebp
# restaura el marco de pila anterior
Hay procedimientos que retornan un valor como resultado, a este tipo de

procedimiento se les conocen como funcin, en este caso se usa el registro
%eax para retornar el resultado.
Convenciones para preservar los contenidos de los registros

Slo hay un conjunto de registros de usuario y stos pueden ser usados tanto
por el programa principal como por el procedimiento invocado. Para evitar que
se pierda informacin de los registros la arquitectura IA-32 adopta una serie de
convenciones las cuales deben ser respectadas al momento de escribir cdigo
que incluya procedimientos. Los registros %eax, %edx y %ecx son preservados
por el programa invocador. Los registros %ebx, %esi y %edi son preservados por
el procedimiento invocado. El procedimiento debe guardar estos valores en la
pila antes de utilizarlos y restaurar sus valores antes de regresar al programa
invocador.
Estructura del programa con llamada a procedimientos

Cuando se escribe un programa con llamada a procedimiento se realizan los
siguientes pasos:
Programa invocador:
Preservar los registros %eax, %edx y %ecx
Apilar los parmetros en orden inverso
Realizar la llamada al procedimiento
Procedimiento:
Prlogo:
Preservar el marco de pila anterior
Actualizar el marco de pila
Preservar los registros %ebx, %esi, %edi
Cuerpo del procedimiento:
Cdigo del procedimiento
Eplogo:
Mover el valor de retorno a %eax (si es el caso)
Restaurar los registros %ebx, %esi, %edi
133
Actualizar el apuntador de pila al marco de pila
Restaurar el marco de pila anterior
Retornar al programa invocador
Programa invocador:
Limpiar la pila (liberar el espacio ocupado por los prmetros de la

llamada)
El resultado (de existir) est en %eax y debe ser movido a otra localidad
Restaurar los registros %ecx, %edx y %eax
Los pasos listados anteriormente se realizan con las siguientes instrucciones:

# programa invocador:
pushl %eax
#
pushl %ecx
pushl %edx
pushl arg2
#
pushl arg1
call procedimiento
addl $x,%esp
#
#
#
movl %eax, valor #
#
popl %edx
#
popl %ecx
popl %eax
se preservan los registros del invocador
se apilan los parmetros
el valor x depende del nmero de bytes que

ocupen los parmetros, esta instruccin
limpia la pila eliminando los parmetros
si el procedimiento retorna un valor este
estar en %eax
se restauran los registros
# procedimiento:
# prlogo:
pushl %ebp
# se preserva marco de pila anterior
movl %esp, %ebp
# se actualiza marco de pila
pushl %ebx
# se preservan los registros del invocado
pushl %esi
pushl %edi
# cuerpo del programa
# aqui van las instrucciones del procedimiento
# eplogo:
movl resul, %eax # si hay un valor de retorno se guarda en %eax
popl %edi
# se restauran los registros
popl %esi
popl %ebx
leave
# se prepara la pila para el retorno
ret
# regresa el control al programa invocador
En algunos casos no es necesario preservar todos los registros.
134
Pase de parmetros
Los parmetros a pasar hacia el procedimiento pueden ser de dos tipos: por
valor o por referencia. Cuando se pasa un parmetro por valor se genera una
copia del valor del parmetro y ese dato es el que est disponible en el
procedimiento, el procedimiento o funcin no puede cambiar el parmetro.
Cuando se pasa un parmetro por referencia realmente se pasa la direccin del
parmetro, no su valor, y al estar la direccin disponible durante la ejecucin
del procedimiento, el valor all guardado puede ser modificado.
Para pasar informacin acerca de un arreglo, se pasa la direccin inicial del
arreglo.
Ejemplo de programa con pase de parmetro por valor
El siguiente es un programa con una funcin que calcula el cuadrado de un
nmero entero. Paso de un parmetro por valor. Retorna el resultado como un
entero.
Programa en C:
#include <stdio.h>
int cuadrado(int x);
int t=10;
int s;
main()
{
s=cuadrado(t);
printf("cuadrado: %d\n", s);
}
int cuadrado(int x)
{
x=x*x;
return x;
}
.section .data
t: .long 10
formato: .asciz "cuadrado: %d\n"
135
.section .text
.globl _start
_start:
pushl t
call cuadrado
addl $4, %esp
pushl %eax
pushl $formato
call printf
movl $1, %eax
movl $0, %ebx
int $0x80
cuadrado:
#
#
#
#
se apila el parmetro t
llamada al procedimiento
limpieza de la pila (4 bytes)
mostrar el resultado por pantalla
pushl %ebp
movl %esp, %ebp
movl 8(%ebp), %eax
imull %eax, %eax
leave
ret
#
#
#
#
preserva marco de pila anterior

actualiza marco de pila
obtiene el parmetro
calcula x2. Resultado en %eax
# retorno al programa principal
Estado de la pila
Se denotan los cambios en las direcciones slo con un desplazamiento a partir
de la direccin inicial de %ebp.
Cuando se apila el parmetro y se realiza la llamada al procedimiento:
pushl t
call cuadrado
%esp
%esp
%ebp
-4
0
t
%ebp
-8
-4
0
dir retorno
t
En el procedimiento:
%esp -12
-8
-4
%ebp
0
pushl %ebp
%ebp = 0
dir retorno
t
%ebp=%esp -12
-8
-4
0
movl %esp,%ebp
%ebp = 0
dir retorno
t
leave es equivalente a las instrucciones movl %ebp, %esp
popl %ebp
movl 8(%ebp),%eax
movl %ebp,%esp
%ebp=%esp -12
%ebp = 0
%esp=%ebp -12
%ebp = 0
-8 dir retorno
-8
dir retorno
-4
t
-4
t
0
0
popl %ebp
ret
136
-12
%esp -8
-4
%ebp 0
%ebp = 0
dir retorno
t
-12
-8
%esp -4
%ebp 0
%ebp = 0
dir retorno
t
La instruccin ret produce la lectura de la pila la cual tiene la direccin de

retorno. Luego en el programa principal se limpia la pila incrementando %esp
para eliminar el parmetro:
addl $4, %esp
-12
-8
-4
%ebp=%esp
0
%ebp +0
dir retorno
t
Ejemplos de programas con pase de parmetro por referencia

El siguiente programa contiene un procedimiento que duplica el valor de los
nmeros de un arreglo de 4 posiciones. Paso de parmetro por referencia (la
direccin inicial del arreglo) y por valor (el nmero de posiciones del arreglo).
Programa en lenguaje C:
#include <stdio.h>
main()
{
int a[4];
int n=4;
int i;
a[0]=10;
a[1]=20;
a[2]=30;
a[3]=40;
duplica(a,n);
for(i=0;i<n;i++)
printf("%d\t",a[i]);
printf("\n");
}
137
void duplica(int arr[4],int y)
{
int i;
int temp;
for(i=0;i<y;i++)
{
temp=arr[i]*2;
arr[i]=temp;
}
}
.section
a: .long
n: .long
formato:
.data
10, 20, 30, 40
4
.asciz "%d\n"
.section .text
.globl _start
_start:
leal a, %eax
pushl %eax
pushl n
call duplica
addl $8, %esp
xorl %ebx, %ebx
xorl %edi, %edi
ciclo: movl a(,%ecx,4), %ebx
pushl %ebx
pushl $formato
call printf
incl %edi
cmpl n, %edi
jl ciclo
movl $1, %eax
movl $0, %ebx
int $0x80
#
#
#
#
#
#
#
#
#
obtiene direccin del arreglo a

apila la dir de a
apila el valor de n=4
llamada al procedimiento duplica
limpieza de la pila (2 parmetros)
%ebx=0
%edi=0, ndice para el arreglo
lee un nmero del arreglo
apila el nmero
# imprime el nmero
# imprime mientras el indice<n

# culmina el programa
duplica:
for:
pushl %ebp
#
movl %esp, %ebp
#
movl 8(%ebp), %esi
#
movl 12(%ebp), %edx
#
xorl %ecx, %ecx
#
movl (%edx,%ecx,4), %eax
addl %eax, %eax
#
movl %eax, (%edx,%ecx,4)
incl %ecx
#
preserva marco de pila anterior

actualiza marco de pila
%esi=nmero de elementos de a
%edx= la direccin de a
%ecx se usa como ndice
# lee nmero del arreglo
duplica el valor ledo
# reeemplaza el valor
incrementa el ndice
138
cmpl %esi, %ecx
jl for
leave
ret
#
#
#
#
compara el ndice con n

salta por menor al ciclo del for
prepara la pila para el retorno
retorno al programa principal
El siguiente programa tiene una funcin que calcula la suma de los elementos
de un arreglo de enteros de 10 posiciones. Se leen los datos del arreglo y se
muestra por pantalla el resultado. Paso de parmetro por referencia. La funcin
suma retorna un valor entero.
#include <stdio.h>
int suma(int arreglo[10]);
void leer(int arreglo[10]);
main()
{
int a[10];
int resultado;
leer(a);
resultado=suma(a);
printf("El resultado de sumar los elementos del arreglo es: %d\n", resultado);
}
void leer(int arreglo[10])
{
int x,i;
printf("Introduzca 10 enteros:\n");
for(i=0;i<10;i++)
{
scanf("%d",&x);
arreglo[i]=x;
}
}
int suma(int arreglo[10])
{
int i;
int res=0;
for(i=0;i<10;i++)
res=res+arreglo[i];
return res;
}
# Programa que lee un arreglo de enteros de 10 posiciones
# y suma los elementos del arreglo
139
.section .data
leearr:
.asciz"Introduzca los 10 numeros del arreglo:\n"
dato:
.asciz"%d"
salida:
.asciz"La suma de los elementos del arreglo es: %d\n"
.section .bss
a:
.space 40
.section .text
.globl _start
_start:
pushl $leearr
call printf
leal dato, %edx
pushl %edx
leal a, %eax
pushl %eax
call leer
addl $8, %esp
leal a, %eax
pushl %eax
call suma
addl $4, %esp
pushl %eax
pushl $salida
call printf
movl $1, %eax
movl $0, %ebx
int $0x80
leer:
leenum:
suma:
# imprime mensaje inicial
# invoca el proc para leer el arreglo
# invoca la funcion para sumar contenidos
# imprime el resultado
pushl %ebp
movl %esp, %ebp
movl 8(%ebp), %ebx
movl 12(%ebp), %esi
xorl %edi, %edi
pushl %ebx
pushl %esi
call scanf
addl $4,%ebx
incl %edi
cmpl $10,%edi
jl leenum
leave
ret
pushl %ebp
movl %esp, %ebp
movl 8(%ebp), %ebx

# %esi=dir formato de lectura
# %edi-contador de elementos
#
#
#
#
#
lee un nuevo elemento del arreglo

actualiza dir para siguiente num.
incrementa contador
compara contador con 10
mientras contador<10 lee numero
140
sumar:
xorl %eax, %eax

# %eax se usa para acumular la suma
xorl %ecx, %ecx
# %ecx indice para el arreglo
addl (%ebx,%ecx,4), %eax
# suma nuevo elemento
incl %ecx
cmpl $10,%ecx
# compara el indice con 10
jl sumar
# mientras indice<10 vuelve a sumar
leave
ret
Ejemplo de programa con una llamada a una funcin dentro de un ciclo

Es importante destacar que en el caso de llamadas a procedimiento dentro de
un ciclo hay que recordar que el programa invocador es responsable de
salvaguardar los registros %eax, %ecx y %edx si alguno de ellos controla el
funcionamiento del ciclo o su contenido debe permanecer inalterado luego de la
ejecucin del procedimiento ya que estos registros pueden ser modificados por
el procedimiento. Por ejemplo el siguiente programa multiplica dos nmeros
usando el mtodo de sumas sucesivas y mostrando por pantalla el nmero de
cada iteracin:
# Programa que calcula x multiplicado por y por sumas sucesivas
# Muestra el numero de iteracion cada vez que se realiza una suma
# y el subtotal de la suma
.section .data
x:
.long 25
y:
.long 4
iterac:
.asciz"Iteracion numero: %d, subtotal: %d\n"
salida:
.asciz"%d multiplicado por %d es: %d\n"
.section .text
.globl _start
_start:
movl x, %ebx
movl $1, %edi
movl $0, %esi
suma:
cmpl y, %edi
jg finsum
addl %ebx, %esi
pushl %esi
pushl %edi
pushl $iterac
call printf
incl %edi
jmp suma
141
finsum:
pushl %esi
pushl y
pushl x
pushl $salida
call printf
movl $1, %eax
movl $0, %ebx
int $0x80
Este programa funciona bien, pero si cambiamos el registro %edi por %edx,
entonces el programa arroja un resultado invlido.
# Programa que calcula x multiplicado por y por sumas sucesivas
# Muestra el numero de iteracion cada vez que se realiza una suma
# y el subtotal de la suma
.section .data
x:
.long 25
y:
.long 4
iterac:
.asciz"Iteracion numero: %d, subtotal: %d\n"
salida:
.asciz"%d multiplicado por %d es: %d\n"
.section .text
.globl _start
_start:
movl x, %ebx
movl $1, %edx
movl $0, %esi
suma:
cmpl y, %edx
jg finsum
addl %ebx, %esi
pushl %esi
pushl %edx
pushl $iterac
call printf
incl %edx
jmp suma
finsum:
pushl %esi
pushl y
pushl x
pushl $salida
call printf
movl $1, %eax
movl $0, %ebx
int $0x80
142
Esto se debe a que el contenido de %edx es modificado durante la ejecucin de
la funcin printf y ello afecta el funcionamiento del ciclo.
143
Ejercicios
9.1- Escriba un programa que lea un arreglo de 20 enteros y calcule el
promedio de los nmeros pares del arreglo. Debe invocar un procedimiento que
indique cuntos nmeros son pares y calcule su suma.
9.2- Escriba un programa que lea un arreglo de n enteros y calcule la sumatoria
de los nmeros mayores que 10 y menores que 100 presentes en el arreglo.
9.3- Escriba un programa que dado un nmero de entrada "n", muestre por
pantalla el factorial de n (n!).
9.4- Escriba un programa que dado un nmero de entrada "n", siendo n mayor
que 2, muestre por pantalla la serie de Fibonacci de los primeros n nmeros. La
serie de Fibonacci se genera con la siguiente expresin:
Fn=Fn-1+Fn-2 con F1=F2=1
144
Captulo 10. Cadenas de caracteres

El uso de las cadenas de caracteres es imprescindible para el programador
debido a que es el lenguaje natural de comunicacin entre las personas. An
cuando se pueden desarrollar programas que manejen cadenas de caracteres
utilizando las instrucciones bsicas presentadas en el Captulo 5 existen una
serie de instrucciones dedicadas al manejo de este tipo de datos que tienen
como objetivo el desarrollo de programas ms eficientes. Esta seccin introduce
estas instrucciones.
Instruccin movs
Esta instruccin permite el movimiento de datos entre dos localidades de
memoria. Los operandos son implcitos, el operando fuente es el registro %esi el
cual apunta a la cadena a mover y el operando destino es el registro %edi el cual
apunta al rea de memoria destino.
Instruccin
movsb
movsw
movsl
Descripcin
Mueve un byte
Mueve 2 bytes
Mueve 4 bytes
Para poder realizar el movimiento de una cadena es necesario primero actualizar

los registros %esi y %edi con las direcciones de la fuente y del destino,
respectivamente.
Esto
se
puede
hacer
utilizando
la
instruccin
leal
direccionamiento indirecto (ver captulo 4):

leal cadena1, %esi
movl $cadena1, %esi
# primera opcin, usando leal

# segunda opcin usando direccionamiento
# indirecto
Cada vez que se invoca la instruccin movs los registros %esi y %edi se
actualizan automticamente incrementndose o decrementndose el nmero de
bytes de la instruccin ejecutada. El incremento o decremento depende del valor
de la bandera DF ubicada en el registro EFLAGS. Si la bandera est en cero, los
registros sern incrementados, si est en uno, sern decrementados. Se puede
actualizar la bandera usando las instrucciones cld para colocar la bandera en 0
y std para colocarla en 1.
145
El siguiente es un programa que mueve una cadena declarada en la seccin de
datos. El primer programa mueve una cadena de un caracter, el siguiente mueve
una cadena de cuatro caracteres.
# Programa que mueve una cadena de una posicion de memoria a otra
# Cadena de un caracter
.section .data
fuente:
.asciz"a"
salida:
.asciz"%s\n"
.section .bss
destino: .space 2
.section .text
.globl _start
_start:
leal fuente, %esi
leal destino, %edi
movsb
pushl $destino
pushl $salida
call printf
# %esi=dir de inicio de la cadena fuente

# %edi=dir de inicio de la cadena destino
# mueve un byte, es decir, un caracter
# muestra la cadena por pantalla
movl $1, %eax

movl $0, %ebx
int $0x80
# Cadena de 4 caracteres
.section .data
fuente:
.asciz"abcd"
salida:
.asciz"%s\n"
.section .bss
destino: .space 5
.section .text
.globl _start
_start:
leal fuente, %esi
leal destino, %edi
movsl
pushl $destino
pushl $salida
call printf
# %esi=dire de inicio de la cadena fuente

# mueve 4 bytes, es decir, 4 caracteres
146
movl $1, %eax
movl $0, %ebx
int $0x80
El prefijo rep
Este prefijo se puede utilizar para repetir la ejecucin de una instruccin de
manejo de cadena de caracteres. Es controlado implcitamente por el registro
%ecx, repite la instruccin hasta que %ecx sea igual a 0.
Hay que actualizar el registro %ecx con la cantidad de movimientos de datos
que se van a realizar, por ejemplo si queremos mover una cadena de 8 bytes y
usamos la instruccin movsb entonces hay que colocar %ecx en 8, si usamos
movsw, %ecx debe estar en 4 y si usamos movsl entoces %ecx debe ser
actualizado en 2.
Ejemplo de un programa que usa el prefijo rep para mover una cadena un byte
a la vez, es decir, un caracter a la vez.
.section .data
fuente:
.asciz"abcdefghijklmnopqrstuvwxyz"
salida:
.asciz"%s\n"
tamano:
.long 26
# numero de caracteres de la cadena
.section .bss
destino: .space 27
.section .text
.globl _start
_start:
leal fuente, %esi
leal destino, %edi
movl tamano, %ecx
rep movsb
pushl $destino
pushl $salida
call printf
#
#
#
#
%esi=dir de inicio
%edi=dir de inicio
%ecx se inicializa
mueve un byte a la
de la cadena fuente
de la cadena destino
en 26
vez durante 26 veces
movl $1, %eax

movl $0, %ebx
int $0x80
147
Existen cuatro prefijos adicionales que adems de monitoriar el estado del
registro %ecx dependen del valor de la bandera de cero (ZF), estos son:
repe
repne
repnz
repz
repite
repite
repite
repite
mientras
mientras
mientras
mientras
igual
no igual
no cero
cero
(equivalente a repne)
(equivalente a repe)
La instruccin lods
La instruccin lods se utiliza para mover una cadena de caracteres desde
memoria hacia el registro %eax, usa el registro implcito %esi para indicar la
direccin de la cadena.
Instruccin
lodsb
lodsw
lodsl
Descripcin
Carga un byte en %al
Carga 2 bytes en %ax
Carga 4 bytes en %eax
La instruccin stos
La instruccin stos se usa para transferir una cadena que est en el registro
%eax a una posicin de memoria. Usa como operando destino implcito el
registro %edi.
Instruccin
stosb
stosw
stosl
Descripcin
Transfiere un byte de %al a memoria
Transfiere dos bytes de %ax a memoria
Transfiere cuato bytes de %eax a memoria
Programa que modifica una cadena de caracteres cambiando su representacin

en minsculas a maysculas.
# Programa que cambia una cadena de caracteres en minusculas
# a la misma cadena en mayusculas
.section .data
fuente:
.asciz"abcdefghijklmnopqrstuvwxyz"
salida:
.asciz"%s\n"
tamano:
.long 26
# numero de caracteres de la cadena
.section .bss
destino: .space 27
.section .text
.globl _start
_start:
leal fuente, %esi
# %esi=dir de inicio de la cadena fuente
148
leal destino, %edi
movl tamano, %ecx

# inicia %ecx con tamano de la cadena
codif:
lodsb
subb $32, %al
stosb
loop codif
#
#
#
#
carga caracter en %al

resta 32 a la representacion del caracter
guarda el caracter en la cadena destino
vuelve a entrar en el ciclo mientras %ecx>0
pushl $destino
pushl $salida
call printf
movl $1, %eax

movl $0, %ebx
int $0x80
# fin del programa
La instruccin cmps
La instruccin cmps se usa para comparar cadenas de caracteres, los operandos
estn implcitos en los registros %esi y %edi como en los casos anteriores. Esta
instruccin resta el valor de la cadena de destino del valor de la cadena fuente y
esta operacin modifica las banderas en EFLAGS.
Instruccin
cmpsb
cmpsw
cmpsl
Descripcin
Compara el valor de un byte
Compara el valor de 2 bytes
Compara el valor de 4 bytes
El siguiente programa compara dos cadenas de caracteres.

# Programa que solicita dos cadenas por teclado, las compara
si son iguales
.section .data
solicita1: .asciz"Introduzca la primera cadena: "
solicita2: .asciz"Introduzca la segunda cadena: "
salto:
.asciz"\n"
formato:
.asciz"%s"
iguales:
.asciz"Las cadenas son iguales\n"
diferent:
.asciz"Las cadenas son diferentes\n"
.section .bss
cad1: .space 100
cad2: .space 100
.section .text
e indica
149
.globl _start
_start:
pushl $solicita1
call printf
pushl $cad1
pushl $formato
call scanf
pushl $salto
call printf
pushl $solicita2
call printf
pushl $cad2
pushl $formato
call scanf
leal cad1, %esi
# %esi=direccion de inicio de la cadena
leal cad2, %edi
# %edi=direccion de inicio de la cadena
cad1
cad2
movl $100, %ecx
rep cmpsb
jne noigual
pushl $iguales
call printf
jmp fin
pushl $diferent
call printf
noigual:
fin:
Luego
# compara las cadenas cad1 y cad2
movl $1, %eax

movl $0, %ebx
int $0x80
de
comparar
dos
cadenas
tambin
se
pueden
realizar
saltos
condicionales por mayor o menor. La reglas para determinar si una cadena de

caracteres es mayor o menor que otra son las siguientes:
El peso depende del orden alfabtico. Las primeras letras del alfabeto
tienen mayor peso, es decir la "a" es mayor que la "b" que a su vez es
mayor que la "c" y as sucesivamente.
Las minsculas tienen mayor peso que las maysculas.
Por ejemplo la cadena "cola" es mayor que la cadena "hola" que a su vez es
mayor que "Hola".
Estas reglas siguen los valores de codificacin de caracteres del cdigo ASCII.
150
Cuando se comparan cadenas de diferente tamao la situacin es ms
complicada, las reglas son las siguientes:
La comparacin se basa en el nmeros de caracteres de la cadena ms

corta.
Si la cadena corta es mayor que el mismo nmero de caracteres en la

cadena larga, entonces la cadena corta es mayor.
Si la cadena corta es menor que el mismo nmero de caracteres en la

cadena larga, entonces la cadena corta es menor.
Si la cadena corta es igual que el mismo nmero de caracteres en la

cadena larga, entonces la cadena larga es mayor.
La instruccin scas
La instruccin scas permite buscar caracteres dentro de una cadena.
Instruccin
scasb
scasw
scasl
Descripcin
Compara un byte en memoria con el valor en %al
Compara dos bytes en memoria con el valorde %ax
Compara cuatro bytes en memoria con el valor de %eax
El registro %edi debe tener la direccin de la cadena de caracteres sobre la cual

va a actuar la instruccin scas. Cuando se ejecuta la instruccin el valor de %edi
es incrementado o decrementado (dependiendo del valor de la bandera DF) la
cantidad de bytes correspondientes a la instruccin. Esta instruccin modifica
las banderas en EFLAGS por lo tanto se pueden usar los saltos condicionales
para determinar el resultado de la comparacin. Usualmente se utiliza con el
prefijo repe para detectar un caracter diferente al ubicado en el registro o con
repne para detectar un caracter igual.
Esta instruccin tambin es til para determinar el tamao de una cadena de
caracteres.
El siguiente programa muestra un ejemplo de bsqueda de un caracter dentro
de una cadena, puesto que la cadena es solicitada al usuario es necesario
determinar su tamao.
151
# Programa que busca un caracter en una cadena de caracteres
.section .data
mensaje1:
.asciz"Este programa solicita una cadena de caracteres y un
caracter\n"
mensaje2:
.asciz"a buscar dentro de la cadena, indica si el caracter
fue encontrado\n"
solict1:
.asciz"Introduzca la cadena de caracteres (maximo 100
caracteres): "
solict2:
.asciz"Introduzca el caracter a buscar: "
format1:
.asciz"%s"
format2:
.asciz"La cadena tiene %d caracteres\n"
noesta:
.asciz"El caracter %s no se encuentra en la cadena\n"
siesta:
.asciz"El caracter %s se encuentra en la cadena\n"
tam:
.long 0
.section .bss
cadena:
.space 100
caracter:
.space 1
# tamano maximo de la cadena de entrada

# tamano de un caracter
.section .text
.globl _start
_start:
pushl $mensaje1
#
call printf
pushl $mensaje2
call printf
addl $8, %esp
pushl $solict1
#
call printf
addl $4, %esp
leal cadena, %edx
pushl %edx
pushl $format1
call scanf
#
addl $8, %esp
pushl $solict2
#
call printf
addl $4, %esp
leal caracter, %edx
pushl %edx
pushl $format1
call scanf
#
cld
leal cadena, %edi
movl $100, %ecx
movb $0, %al
repne scasb
mensaje inicial
mensaje que solicita la cadena
lectura de la cadena
mensaje que solicita el caracter a buscar
lectura del caracter
# limpia la bandera CF, asi %ecx se decrementa

# %edi=dir de inicio de la cadena
# tamano maximo de la cadena
# caracter de fin de cadena
# busca el fin de la cadena
152
jne fin
subl$100, %ecx
neg %ecx
decl %ecx
movl %ecx, tam
pushl %ecx
pushl $format2
call printf
addl $8, %esp
# calcula el numero de caracteres

# %ecx tiene el largo de la cadena
# el largo de la cadena se guarda en tam
# muestra el numero de caracteres
movl tam, %ecx

leal cadena, %edi
leal caracter, %esi
lodsb
repne scasb
jne nohay
#
#
#
#
#
#
vuelve a cargar %ecx con el largo

de la cadena
%edi= inicio de la cadena
%esi=direccion del caracter
carga el caracter en %al
realiza la busqueda
pushl $caracter
pushl $siesta
call printf
jmp fin
# si el caracter esta en la cadena,

# muestra el mensaje respectivo
pushl $caracter
pushl $noesta
call printf
# si el caracter no esta en la cadena,

# muestra el mensaje que lo indica
movl $1, %eax

movl $0, %ebx
int $0x80
# fin del programa
nohay:
fin:
153
Ejercicios
10.1.- Escriba un programa que realice la revisin de una contrasea, debe
inidicar si la contrasea introducida es correcta.
10.2.- Escriba un programa que detecte la presencia del caracter "-" en una
cadena de caracteres, el programa debe leer la cadena e indicar la posicin de la
primera aparicin del caracter.
10.3.- Escriba un programa que cuente el nmero de ocurrencias del caracter
"y" en una cadena.
154
Captulo 11. Operaciones de punto flotante

La manera de representar fracciones se realiza usando nmeros de punto
flotante. Esta representacin es similar a la notacin cientfica, slo que en las
computadoras
cada
parte de la
notacin, coeficiente y
exponente, se
representan en binario. Debido a que existen infinitos nmeros reales y que la

mquina slo puede representar un subconjunto de los mismos, se han
establecido estndares para la representacin de nmeros fraccionarios los
cuales son utilizados de manera universal para representar nmeros de punto
flotante. El estndar adoptado se denomina Estndar IEEE 754. IEEE son las
siglas del Instituto de Ingeniera Elctrica y Electrnica, por sus siglas en ingls.
El estndar 754 define dos tamaos para nmeros de punto flotante: 32 bits
para precisin simple y 64 bits para precisin doble. El formato de precisin
simple permite almacenar valores dentro del rango: 1.18x10-38 a 3.40x1038. El
formato de precisin doble tiene un rango de : 2.23x10-308 a 1.79x10308.
La plataforma IA-32 provee ambos formatos y un formato de 80 bits llamado
formato de punto flotante de precisin doble extendida. Este ltimo es usado en
los registros de la Unidad de Punto Flotante y tiene un rango de 3.37x10-4932 a
1.18x104932.
Para definir valores de punto flotante se utilizan las directivas .float para definir
un valor de precisin simple (32 bits) y .double para definir un valor de
precisin doble (64 bits). Hasta el momento, el ensamblador gas no provee una
directiva para definir valores de precisin doble extendida.
Las operaciones de punto flotante se ejecutan en la unidad de punto flotante
(FPU- Floating Point Unit), la cual contiene registros adicionales para el manejo
de la informacin en punto flotante. La FPU permite el procesamiento de
funciones matemticas complejas de manera rpida y eficiente.
Los registros de datos de la FPU se denominan %st(0), %st(1), ..., %st(7) y estn
relacionados entre si como una pila circular. El tope de la pila es %st(0). Cuando
se cargan datos en la FPU, realmente se cargan en la pila comenzando en la
posicin %st(0), luego cada vez que se apila un nuevo valor se corren los valores
presentes en la pila hacia los registros siguientes. Slo hay ocho espacios
155
disponibles, si se apila un noveno valor ste reemplaza el contenido de %st(0),
por ello se dice que la pila es circular.
La FPU tiene su propio registro de estado el cual indica las condiciones de
operacin de la unidad. Es un registro de 16 bits que contiene las banderas
siguientes:
Bit de estado
Descripcin
Bandera de excepcin de operacin invlida
Bandera de excepcin de operando denormalizado
Bandera de excepcin de divisin entre cero
Bandera de excepcin de desbordamiento (valores muy grandes)
Bandera de excepcin de desbordamiento (valores muy pequeos)
Bandera de excepcin de precisin
Falla de pila
Resumen de estado de errores
Cdigo de condicin (bit 0)
10
11-13
Apuntador al tope de la pila
14
15
Bandera de PFU ocupada
Los seis primeros bits son banderas de excepcin se activan cuando ocurre una
excepcin durante el procesamiento de instrucciones en la FPU, se mantienen
activas hasta que un programa las desactive.
Este registro puede ser ledo transfiriendo su contenido a una doble palabra de
memoria o hacia el registro %ax. Esto se logra mediante el uso de la instruccin
fstsw.
156
Asimismo la FPU provee un registro de control el cual controla su operacin. Sus
bits se especifican como:
Bit de control
Descripcin
Mscara de excepcin de operacin invlida
Mscara de excepcin de operando denormalizado
Mscara de excepcin de divisin entre cero
Mscara de excepcin de desbordamiento (valores muy grandes)
Mscara de excepcin de desbordamiento (valores muy pequeos)
Mscara de excepcin de precisin
6-7
Reservado
8-9
Control de precisin
10-11
Control de redondeo
12
Control de infinito
13-15
Reservado
Los primeros seis bits se usan para controlar qu banderas del registro de
estado son usadas, cuando uno de estos bits est activo impide que la bandera
correspondiente en el registro de estado pueda ser activada. Estos bits se
encuentran activos por defecto, enmascarando as todas las excepciones. Los
bits siguientes proveen la capacidad de escoger ciertas condiciones de
funcionamiento de la FPU.
Los bits 8 y 9 definen la precisin con la cual se trabaja, las opciones son las
siguientes:
00011011-
precisin simple
no se usa
precisin doble
precisin doble extendida
Los bits 10 y 11 definen las opciones de redondeo, las cuales son:
00011011-
redondeo hacia el ms cercano

redondeo hacia abajo
redondeo hacia arriba
redondeo hacia cero
Por defecto la FPU trabaja con precisin doble extendida y con redondeo hacia
el valor ms cercano. El valor del registro de control, por defecto, es: 0x037F.
157
Redondeo
Precisin
bit
15
bit
14
bit
13
bit
12
bit
11
bit
10
bit
9
bit
8
bit
7
bit
6
bit
5
bit
4
bit
3
bit
2
bit
1
bit
0
Para modificar las condiciones hay que modificar el contenido del registro de
control. Esto se hace con la instruccin fldcw la cual carga una doble palabra en
el registro de control.
Ejemplo de un programa que cambia la precisin a simple, notse que es
necesario cambiar los bits 8 y 9 a la combinacin 00, por lo cual el nuevo valor
del registro de control debe ser: 0x007F.
.section .data
simple:
.byte 0x7F, 0x00
.section .text
.globl _start
_start:
fldcw simple
movl $1, %eax
movl $0, %ebx
int $0x80
# el orden se debe a que es little endian
# modifica contenido del registro de control

# fin del programa
Instrucciones de movimiento de datos

fld (apila un dato punto flotante en la pila FPU)
Instruccin
flds etiqueta
fldl etiqueta
Descripcin
Apila un valor de precisin simple (32 bits)
Apila un valor de precisin doble (64 bits)
flds valor1
fldl valor2
Ejemplo
valor1 declarado como .float
valor2 declarado como .double
Esta instruccin tiene varios formatos con valores predeterminados, ellos son
los siguientes:
158
Instruccin
fld1
fldl2t
fldl2e
fldpi
fldlg2
fldln2
fldz
Descripcin
Apila +1.0
Apila log(base 2) 10
Apila log(base 2) e
Apila el valor de pi ()
Apila log(base10) 2
Apila log(base e) 2
Apila +0.0
fild (apila un entero)

Instruccin
filds etiqueta
fildl etiqueta
Descripcin
Apila un valor entero de 32 bits
Apila un valor entero de 64 bits
Ejemplo
flds entero1
fldl entero2
entero1 declarado como .long

entero2 declarado como .quad
Cuando se realizan las instrucciones de apilar valores, cada valor adicional se va

apilando en el tope st(0) y los dems valores se van corriendo hacia los registros
restantes.
fst (movimiento de datos desde el tope de la pila)
Esta instruccin tiene dos variantes:
fst- lee el tope de la pila y mantiene su valor intacto
fstp- lee el tope de la pila y luego desapila ese valor, moviendo los contenidos
de los dems registros hacia el tope.
fst (copia el tope de la pila)
Instruccin
fst %st(x)
Descripcin
Copia el dato del tope de la pila a otro registro FPU
fsts etiqueta
Copia el dato del tope de la pila a memoria (32 bits)
fstl etiqueta
Copia el dato del tope de la pila a memoria (64 bits)
Ejemplo
fst %st(4) copia el contenido de %st(0) y lo
guarda en %st(4)
fsts variable1 copia el contenido de %st(0) y lo
guarda en variable1 (32 bits)
fstl variable2 copia el contenido de %st(0) y lo
guarda en variable2 (64 bits)
fstp (lee el tope de la pila y desapila)

Instruccin
fstp %st(x)
fstps etiqueta
fstpl etiqueta
Descripcin
Desapila el dato del tope de la pila y lo mueve a
otro registro FPU
memoria (32 bits)
memoria (64 bits)
Ejemplo
fstp %st(4) desapila contenido de %st(0) y
lo mueve a %st(4)
fstps variable1 desapila el contenido de
%st(0) y lo mueve a variable1 (32 bits)
fstpl variable2 desapila el contenido de
%st(0) y lo mueve a variable2 (64 bits)
159
fist (lee nmero entero del tope de la pila)
Instruccin
fists etiqueta
fistl etiqueta
Descripcin
Desapila el valor presente en el tope de la pila y lo
guarda en memoria (32 bits)
Desapila el valor presente en el tope de la pila y lo
guarda en memoria (64 bits)
Ejemplo
fists valor1
valor1 entero (32 bits)
fistl valor2
valor2 entero (64 bits)
fxch (intercambio de valores entre el tope de la pila y otro registro)

Instruccin
fxch %st(x)
Descripcin
Intercambia el dato del tope de la pila
y otro registro de la pila
Ejemplo
fxch %st(1)
intercambia el contenido de %st(0) y %st(1)
Instrucciones de control
finit (inicializacin)
Esta instruccin inicializa la FPU. No modifica los contenidos de los registros de
datos, coloca el registro de control en sus valores por defecto.
fstcw (copia el contenido del registro de control)
Con esta instruccin se crea una copia del contenido del registro de control en
fstsw (copia el contenido del registro de estado)
Con esta instruccin se crea una copia del contenido del registro de estado en
160
Instrucciones aritmticas bsicas

fadd (suma)
Instruccin
fadds etiqueta
faddl etiqueta
fadd %st(x), %st(0)
fadd %st(0), %st(x)
faddp %st(0), %st(x)
faddp
fiadds etiqueta
fiaddl etiqueta
Descripcin
Suma valor de 32 bits al tope de la pila
Suma valor de 64 bits al tope de la pila
Suma contenido de %st(x) con %st(0), guarda el
resultado en %st(0)
Suma %st(0) con %st(x), guarda el resultado en %st(x)
Suma %st(0) con %st(x), guarda el resultado en %st(x)
y desapila %st(0)
Suma %st(0) con %st(1), guarda el resultado en
%st(1), desapila %st(0)
Suma valor entero de 32 bits a %st(0), guarda el
resultado en %st(0)
Suma valor entero de 64 bits a %st(0), guarda el
resultado en %st(0)
Ejemplo
fadds valor1
faddl valor2
fadd %st(4), %st(0)
Descripcin
Resta tope de la pila menos valor de 32 bits
Resta tope de la pila menos valor de 64 bits
Resta el contenido de %st(x) menos %st(0), guarda el
resultado en %st(0)
Resta %st(0) menos %st(x), guarda el resultado en
%st(x)
Resta %st(0) menos %st(x), guarda el resultado en
%st(x) y desapila %st(0)
Resta %st(0) menos %st(1), guarda el resultado en
Resta %st(0) menos valor entero de 32 bits, guarda el
resultado en %st(0)
Resta %st(0) menos valor entero de 64 bits, guarda el
resultado en %st(0)
Ejemplo
fsubs valor1
fsubl valor2
fsub %st(4), %st(0)
fadd %st(0), %st(3)

faddp %st(0), %st(4)
faddp
fiadds valor1
fiaddl valor2
fsub (resta)
Instruccin
fsubs etiqueta
fsubl etiqueta
fadd %st(x), %st(0)
fsub %st(0), %st(x)
fsubp %st(0), %st(x)
fsubp
fisubs etiqueta
fisubl etiqueta
fsub %st(0), %st(3)

fsubp %st(0), %st(4)
fsubp
fisubs valor1
fisubl valor2
La instruccin fsubr realiza la resta inversa, es decir toma en cuenta los

operandos de manera inversa a la tabla presentada para fsub. Resta el segundo
operando del primero y guarda el resultado en el segundo lo cual coincide con
fsub.
161
fmul (multiplicacin)
Instruccin
fmuls etiqueta
fmull etiqueta
fmul %st(x), %st(0)
fmul %st(0), %st(x)
fmulp %st(0), %st(x)
fmulp
fimuls etiqueta
fimull etiqueta
Descripcin
Multiplica tope de la pila por valor de 32 bits
Multiplica tope de la pila por valor de 64 bits
Multiplica el contenido de %st(x) por %st(0), guarda el
resultado en %st(0)
Multiplica %st(0) por %st(x), guarda el resultado en
%st(x)
Multiplica %st(0) por %st(x), guarda el resultado en
Multiplica %st(0) por %st(1), guarda el resultado en
Multiplica %st(0) por valor entero de 32 bits, guarda el
resultado en %st(0)
Multiplica %st(0) por valor entero de 64 bits, guarda el
resultado en %st(0)
Ejemplo
fmuls valor1
fmull valor2
fmul %st(4), %st(0)
Descripcin
Divide el tope de la pila entre valor de 32 bits
Divide el tope de la pila entre valor de 64 bits
Divide el contenido de %st(x) entre %st(0), guarda el
resultado en %st(0)
Divide %st(0) entre %st(x), guarda el resultado en
%st(x)
Divide %st(0) entre %st(x), guarda el resultado en
Divide %st(0) entre %st(1), guarda el resultado en
Divide %st(0) entre valor entero de 32 bits, guarda el
resultado en %st(0)
Divide %st(0) entre valor entero de 64 bits, guarda el
resultado en %st(0)
Ejemplo
fdivs valor1
fdivl valor2
fdiv %st(4), %st(0)
fmul %st(0), %st(3)

fmulp %st(0), %st(4)
fmulp
fimuls valor1
fimull valor2
fdiv (divisin)
Instruccin
fdivs etiqueta
fdivl etiqueta
divl %st(x), %st(0)
fdiv %st(0), %st(x)
fdivp %st(0), %st(x)
fdivp
fidivs etiqueta
fidivl etiqueta
fdiv %st(0), %st(3)

fdivp %st(0), %st(4)
fdivp
fidivs valor1
fidivl valor2
La instruccin fdivr realiza la divisin inversa, es decir toma en cuenta los

operandos de manera inversa a la tabla presentada para fdiv. Resta el segundo
operando del primero y guarda el resultado en el segundo.
Algunas funciones matemticas avanzadas
Instruccin
f2xm1
fabs
fchs
fcos
fprem1
frndint
fscale
fsin
fsqrt
Descripcin
calcula 2 elevado al contenido de %st(0) menos 1
calcula el valor absoluto de %st(0)
cambia el signo del valor en %st(0)
calcula el coseno del valor en %st(0) en radianes, guarda el resultado en %st(0)
calcula el resto de dividir el valor en %st(0) entre el valor en %st(1)
redondea el valor en %st(0) al entero ms cercano
calcula %st(0) elevado al valor en %st(1)
calcula el seno del valor en %st(0) en radianes, guarda el resultado en %st(0)
calcula la raiz cuadrada del valor en %st(0)
162
La instruccin frndint redondea el valor en %st(0) al entero ms cercano usando
el mtodo de redondeo que se encuentre en el registro de control.
La instruccin fprem1 calcula el resto de la divisin de manera iterativa. Se
puede saber cuando la operacin culmina revisando el bit 2 del registro de
estado, cuando ese bit se encuentra en cero, las iteraciones estn completas.
Este proceso se debe realizar dentro de un ciclo, tal como se ejemplifica en el
siguiente programa:
.section .data
valor1:
.float 25.45
valor2:
.float 2.24
.section .bss
.space resultado, 4
.section .text
.globl _start
_start:
finit
flds valor2
flds valor1
ciclo:
fprem1
fstsw %ax
testb $4, %ah
jnz ciclo
fsts resultado
movl $1, %eax
movl $0, %ebx
int $0x80
#
#
#
#
#
#
#
#
#
inicializacion de FPU
carga valor2
carga valor1
calcula resto de div valor1/valor2
copia registro de estado en %ax
chequea bit 2 del registro de estado
mientras diferente de 0 vuelva a ciclo
actualiza resultado con el resto
fin del programa
Las operaciones fcos y fsin calculan el coseno y el seno respectivamente.

Asumen que el valor en %st(0) est expresado en radianes. La frmula para
convertir grados en radianes es la siguiente:
radianes= (grados*pi)/180
Esto se puede realizar con la siguiente secuencia de instrucciones:
fsts grados
fidivs val180
fldpi
fmul %st(1), %st(0)
#
#
#
#
#
carga la cantidad de grados

divide entre 180 (valor guardado en memoria)
carga pi en %st(0), ahora %st(1)=180
multiplica grados/180 por pi
el resultado queda en %st(0)
163
Instrucciones de comparacin
En los primeros modelos de mquinas Intel era necesario leer el registro de
estado y actualizar, por medio de un programa, el contenido del registro de
banderas (EFLAGS) para poder realizar saltos de acuerdo a las comparaciones
realizadas. A partir del procesador Pentium Pro se introduce un conjunto de
instrucciones que actualizan automticamente el registro de banderas. Estas son
las instrucciones presentadas a continuacin:
Instruccin
fcomi %st(x)
fcomip %st(x)
fucomi %st(0), %st(x)
fucomip %st(0), %st(x)
Descripcin
compara %st(0) con %st(x)
compara %st(0) con %st(x) y desapila
revisa si los valores en %st(0) y en %st(x) son vlidos
revisa si los valores en %st(0) y en %st(x) son vlidos y desapila
Ejemplo
fcomi %st(4)
fcomip %st(3)
fucomi %st(0), %st(2)
fucomip %st(0), %st(3)
La comparacin actualiza las banderas segn la siguiente tabla:

Condicin
ZF (Bandera de cero)
PF (Bandera de paridad)
CF (Bandera de acarreo)
%st(0)> %st(x)
%st(0)< %st(x)
%st(0) = %st(x)
Ejemplo de un programa que calcula una expresin aritmtica con cuatro

valores fraccionarios declarados en la seccin de datos.
# Programa que calcula (a+b)*(c-d)
.section .data
mensaje:
.asciz"Programa que calcula la expresion (a+b)*(c-d)\n"
salto:
.asciz"\n"
a:
.float 2.65
b:
.float 4.85
c:
.float 25.234
d:
.float 12.82
formato:
.asciz"resultado: %f\n"
.section .text
.globl _start
_start:
pushl $mensaje
call printf
pushl $salto
call printf
addl $8, %esp
finit
flds c
# mensaje inicial
# inicializacion de FPU
# carga c en %st(0)
164
fsubs d
flds a
fadds b
fmul %st(1), %st(0)
#
#
#
#
%st(0)=%st(0)-d
(c-d)
carga a en %st(0), %st(1)=c-d
%st(0)=%st(0)+b
(a+b)
%st(0)=%st(0)*%st(1)
subl $8, %esp

fstpl (%esp)
pushl $formato
call printf
#
#
#
#
reserva 8 bytes en la pila

coloca resultado en la pila
apila el formato de salida
muestra resultado por pantalla
movl $1, %eax

xorl %ebx, %ebx
int $0x80
# fin del programa
Para mostrar el resultado por pantalla se puede usar la funcin printf pero hay
que tener en cuenta que el formato de salida debe ser %f para mostrar un
nmero fraccionario. Asimismo cuando se desapila el resultado se debe usar la
instruccin fstpl la cual desapila el valor de 8 bytes y lo coloca en memoria.
Para hacer esto primero se resta 8 al apuntador %esp (para reservar 8 bytes) y
luego con la instruccin fstpl (%esp) se "apila" el valor como parmetro para la
llamada a la funcin printf.
165
Ejercicios
11.1- Escriba un programa que calcule la nota definitiva tomando en cuenta 6
notas con los siguientes porcentajes:
Nota 1: 20%
Nota 2: 15%
Nota 3: 25%
Nota 4: 10%
Nota 5: 25%
Nota 6: 5%
El programa debe mostrar la nota final con dos decimales y la nota definitiva
redondeada, el redondeo debe ser hacia arriba.
11.2.- Escriba un programa que permita convertir grados Centgrados a
Fahrenheit.
11.3.- Escriba un programa que acepte como entradas 10 valores de
temperatura en grados Centgrados y muestre su promedio.
11.4.- Escriba un programa que solicite el valor del dimetro de un crculo y
calcule su rea.
11.5.- Escriba un programa que permita realizar la conversin de kilmetros a
millas y de millas a kilmetros.
166
Captulo 12. Manejo de archivos

En los capitulos anteriores se han descrito mecanismos que permiten recibir
datos del usuario mediante los dispositivos de E/S, procesarlos de manera
sofisticada mediante el uso de las diferentes estructuras de control, realizar
clculos complejos sobre dichos datos utilizando bien sea registros enteros o de
punto flotante, y mostrar los resultados obtenidos haciendo uso de diferentes
funciones e instrucciones.
Sin embargo, qu ocurre una vez que el programa finaliza su ejecucin, o
cuando es retirada la energa elctrica que hace funcionar al computador?. La
respuesta es simple: los datos proporcionados por el usuario, los resultados
calculados y cualquier otra informacin importante se pierde. Esto se debe a
que tanto el cdigo como los datos de un programa en ejecucin se mantienen
en un tipo de memoria voltil (la RAM), la cual pierde cualquier requiere energa
elctrica para mantener la informacin almacenada en ella.
Existen innumerables ocasiones en que es necesario que la informacin
almacenada se mantenga intacta an cuando el computador se encuentre
apagado. El ejemplo ms claro de esto es una base de datos de cualquier tipo.
Otros ejemplos de la vida cotidiana son el correo electrnico, imgenes y msica
digitalizada, archivos de texto, documentos, hojas de clculo, presentaciones,
archivos de configuracin de los programas, e inclusive los programas en si
mismos.
Un archivo no es ms que un conjunto de datos que son almacenados en un
dispositivo de almacenamiento permanente, tal como el disco duro, un diskette
o una memoria porttil USB. El manejo de archivos involucra bsicamente tres
acciones por parte del usuario: apertura, manipulacin y cierre. La manipulacin
del archivo consiste en realizar operaciones de lectura y/o escritura sobre el
mismo.
Por ejemplo, imagine que posee un archivo de texto en el cual escribe
regularmente las actividades que tiene que realizar. Cuando utiliza un editor de
texto
dentro
de
un
entorno
grfico
para
modificar
este
archivo,
insconscientemente est realizando las tres acciones anteriormente descritas:
167
Apertura:
Al hacer doble clic en el archivo.
Lectura:
Al ejecutarse el editor se cargan el contenido del archivo: las

actividades anotadas previamente.
Escritura:
Al seleccionar la opcin que permite guardar las modificaciones

realizadas al archivo.
Cierre:
Al finalizar la ejecucin del editor.
Si bien esta explicacin puede parecer trivial, a lo largo de este captulo se

mostrar que el manejo de archivos desde el punto de vista del programador
siempre est compuesto por estas tres acciones bsicas, sin importar que el
lenguaje utilizado sea de alto o bajo nivel.
Para realizar una operacin de lectura o escritura sobre un archivo, es necesario
haber abierto el mismo previamente. Adicionalmente existen otras operaciones
bsicas
que
pueden
ser
realizadas
sobre
un
archivo,
las
cuales
no
necesariamente involucran la apertura del mismo. Entre ellas se encuentran la

creacin de un nuevo archivo, el cambio de atributos (nombre, visibilidad,
permisos de acceso, etc.) de uno existente, as como la eliminacin del mismo.
Tipos de archivo
Un archivo puede ser clasificado de acuerdo a la forma en la que es almacenada
la informacin dentro del mismo. En este sentido, existen dos tipos de archivo:
archivos de texto y archivos binarios. Esta distincin es sumamente importante,
ya que es necesario conocer el tipo de archivo que se est manejando para
manipularlo adecuadamente.
Archivos de texto
Un archivo de texto es una secuencia de caracteres (generalmente imprimibles),
en el cual la informacin es almacenada de forma que pueda ser comprendida a
simple vista por el usuario. Por esta razn, tambin son llamados archivos de
texto plano. Ejemplos de este tipo de archivo son un documentos HTML, cdigo
fuente de programas en lenguajes de alto y bajo nivel, documentos de texto sin
formato (txt) y los archivos de configuracin de algunas aplicaciones.
168
Archivos binarios
Un archivo binario es una secuencia de bytes, en el cual la informacin es
almacenada en la forma ms elemental que puede manejar un computador:
ceros y unos. Esto ocasiona que la misma no pueda ser comprendida a simple
vista por el usuario. Ejemplos de este tipo de archivo son imgenes y msica
digitalizada, programas en lenguaje de mquina, documentos con formato (doc,
pdf) y los archivos de configuracin de algunas aplicaciones.
Observe que los archivos de configuracin de las aplicaciones han sido
mencionados como ejemplo para ambos tipos de archivo. Esto lo que nos indica
es que en el fondo cualquier archivo puede ser almacenado en una u otra forma,
la decisin la toma el programador que disea la aplicacin que har uso del
archivo en cuestin, evalando previamente que tipo de archivo se adapta mejor
a sus necesidades. Por ejemplo, si el archivo de configuracin es binario ser
necesario crear una herramienta que permita al usuario final modificarlo,
mientras que si es un archivo de texto plano, el mismo podr ser modificado
mediante la utilizacin de un editor de texto convencional.
Tipos de acceso
Otro criterio utilizado para clasificar los diferentes tipos de archivo, se refiere a
la forma en la que se accesa a la informacin almacenada en los mismos. Desde
este punto de vista, un archivo puede ser de acceso secuencial o de acceso
aleatorio.
Acceso secuencial
En un archivo de acceso secuencial, para tener acceso al dato almacenado en la
posicin N, se deben haber accesado los datos almacenados en las N-1
posiciones previas, en un orden secuencial.
Acceso aleatorio
Un archivo de acceso aleatorio permite acceder a cualquier parte del mismo en
cualquier momento, como si se tratara de un arreglo almacenado en la
memoria. Por esta razn este tipo de acceso es conocido tambin como acceso
169
directo, ya que permite ir directamente a los datos de inters sin tener que
recorrer los que lo preceden dentro del archivo.
Como siempre, la decisin de utilizar un determinado tipo de acceso recae en el
programador. El criterio de mayor peso a la hora de elegir uno u otro es el
tiempo de acceso. Si existen pocos datos almacenados en un archivo, la
diferencia entre los tiempos de acceso de forma secuencial y directa puede ser
imperceptible para el usuario. Sin embargo, la diferencia comienza a apreciarse
a medida que se manejan archivos con grandes cantidades de informacin.
Sin embargo existen casos en los que el acceso secuencial de un archivo es
recomendable. El caso ms representativo es el manejo de una nmina de
empleados, clientes o estudiantes, en la cual se se deben procesar todos (o la
mayora) de los registros.
Funciones de alto nivel

En la actualidad la mayor parte de los lenguajes de alto nivel proporcionan un
conjunto de funciones para permitir al programador realizar el manejo de
archivos de una forma simple y poderosa a la vez. En particular el lenguaje C es
bastante rico en este sentido, ya que pose una gran variedad de funciones
orientadas a la manipulacin de archivos. La siguiente es una lista de las ms
relevantes, junto con una breve descripcin de la tarea que realiza cada una de
ellas:
Func i n
De scr ipc i n
fopen
Abre un archivo
fclose
Cierra un archivo
fread
Lee bloques de bytes desde un archivo
fwrite
Escribe bloques de bytes a un archivo
fgets
Lee una cadena de caracteres desde un archivo
fputs
Escribe una cadena de caracters a un archivo
fscanf
Realiza lectura formateada desde un archivo
fprintf
Realiza escritura formateada a un archivo
fseek
Cambia la posicin del apuntador de lectura y escritura
feof
Determina si se alcanz el final del archivo
ferror
Determina si ocurri un error en la ltima operacin sobre el archivo
fflush
Vaca el contenido del buffer al archivo
remove
Elimina un archivo o directorio
170
A continuacin se presenta una descripcin ms detallada de cada una de estas
llamadas al sistema:
fopen
La funcin fopen, permite abrir un archivo existente. El prototipo de la misma es
el siguiente:
FILE *fopen(const char *camino, const char *modo);

En donde camino es una cadena que contiene la ruta (absoluta o relativa) del
archivo que se desea abrir y modo es una cadena que describe la forma en la
que se desea abrir el archivo. La llamada a fopen devuelve el descriptor asociado
al archivo abierto. En caso de no poderse abrir el archivo, la llamada devuelve
NULL.
La cadena modo debe comenzar por una de las siguientes opciones:
Opc i n
De scr ipc i n
Abre el archivo solo para lectura. El apuntador se posiciona al comienzo.
r+
Abre el archivo para lectura y escritura. El apuntador se posiciona al comienzo.
Trunca el fichero a una longitud de cero bytes o crea uno nuevo si no existe, y lo abre
para para escritura. El apuntador se posiciona al principio.
w+
Trunca el fichero a una longitud de cero bytes o crea uno nuevo si no existe, y lo abre
para para lectura y escritura. El apuntador se posiciona al principio.
Abre el archivo para escritura o crea uno nuevo si no existe. El apuntador se

posiciona al final.
a+
Abre el archivo para lectura y escritura o crea uno nuevo si no existe. El apuntador se
posiciona al final
Adicionalmente la cadena modo puede incluir el carcter b al final de

cualquiera de las opciones mencionadas (rb, r+b, etc.) o entre los caracteres de
aquellas que ocupan ms de un carcter (rb+, ab+, etc.) para indicar que el
archivo que se desea abrir es binario (la ausencia de la b indica que el archivo
es de texto plano). Sin embargo esta opcin es ignorada en Linux (y todos los
sistemas que siguen el estandar POSIX) ya que el mismo trata de la misma forma
ambos tipos de archivo. Sin embargo es comn colocar dicha opcin para
mantener la compatibilidad con otros sistemas.
171
fclose
La funcin fclose, permite cerrar un archivo, es decir, elimina la relacin
existente entre el descriptor y el archivo, de forma que el primero deje de hacer
referencia al ltimo (note por lo tanto que el cerrar el descriptor no
necesariamente implica la liberacin de los recursos asociados al archivo, ya que
puede existir otro descriptor haciendo referencia al mismo). El prototipo de la
misma es el siguiente:
int fclose(FILE *flujo);

En donde flujo es el descriptor de archivo que se desea cerrar. La llamada a
fclose devuelve 0 en caso de xito y la constante EOF en caso de ocurrir un

error.
fread
La funcin fread, permite leer un flujo de datos binarios desde un archivo. El
prototipo de la misma es el siguiente:
size_t fread(void *ptr, size_t tam, size_t nmiemb, FILE *flujo);

En donde prt es un apuntador a la zona de memoria en la que se almacenarn
los datos ledos, tam es la cantidad de elementos a leer, nmiemb es el tamao
en bytes de cada uno de dichos elementos y flujo es el descriptor de archivo
desde el cual se desea leer. La llamada a fread devuelve el nmero de elementos
ledos correctamente.
fwrite
La funcin fwrite, permite escribir un flujo de datos binarios en un archivo. El
size_t fwrite(const void *ptr, size_t tam, size_t nmiemb, FILE *flujo);
En donde prt es un apuntador a la zona de memoria en la que se encuentran los

datos a escribir, tam es la cantidad de elementos a escribir, nmiemb es el
tamao en bytes de cada uno de dichos elementos y flujo es el descriptor de
archivo desde el cual se desea escribir. La llamada a fwrite devuelve el nmero
de elementos escritos correctamente.
172
fgets
La funcin fgets, permite leer una cadena de caracteres desde un archivo. El
char *fgets(char *s, int tam, FILE *flujo);
En donde s es un apuntador a la zona de memoria en la que se almacenarn los

datos ledos, tam es la cantidad de caracteres a leer, y flujo es el descriptor de
archivo desde el cual se desea leer. La llamada a fgets devuelve s en caso de
xito y NULL en caso de error.
fputs
La funcin fputs, permite escribir una cadena de caracteres en un archivo. El
int fputs(const char *s, FILE *flujo);
En donde s es un apuntador a la zona de memoria en la que se encuentran los

datos a escribir, tam es la cantidad de caracteres a escribir, y flujo es el
descriptor de archivo en el cual se desea escribir. La llamada a fputs devuelve un
nmero no negativo en caso de xito y la constante EOF en caso de error.
fscanf
La funcin fscanf, permite realizar lectura formateda desde un archivo. El
int fscanf(FILE *flujo, const char *formato, ...);
En donde flujo es el descriptor de archivo desde el cual se desea leer, formato

es la cadena que define el formato de los datos a
leer y los parmetros
adicionales son apuntadores a las zonas de memoria en las que sern

almacenados los datos reconocidos. Esta funcin se comporta de la misma
manera que la funcin scanf pero toma la entrada desde el archivo especificado
en lugar de hacerlo desde la entrada estndar (el teclado). La llamada a fscanf
devuelve
la
cantidad
de
elementos
reconocidos
asignados
correspondientes variables.
las
173
fprintf
La funcin fprintf, permite realizar escritura formateda en un archivo. El
int fprintf(FILE *flujo, const char *formato, ...);
En donde flujo es el descriptor de archivo en el cual se desea escribir, formato

es la cadena que define el formato de los datos a escribir y los parmetros
adicionales son las variables con las cuales se rellenar la cadena de formato.
Esta funcin se comporta de la misma manera que la funcin printf pero escribe
la salida en el archivo especificado en lugar de hacerlo en la salida estndar (la
pantalla). La llamada a fprintf devuelve la cantidad de caracteres escritos.
fseek
La
funcin
fseek,
permite
cambiar
la
ubicacin
del
apuntador
de
lectura/escritura de un descriptor de archivo. El prototipo de la misma es el

siguiente:
int fseek(FILE *flujo, long desplto, int origen);

En donde flujo es el descriptor del archivo al cual se desea cambiar la posicin
del apuntador, desplto es la cantidad de bytes que se quiere desplazar el mismo
y origen es la posicin a partir de la cual se har efectivo dicho desplazamiento.
La llamada a fseek devuelve 0 en caso de tener xito y -1 en caso de ocurrir un
error.
feof
La funcin feof , permite determinar si se ha alcanzado el final de un archivo
abierto. El prototipo de la misma es el siguiente:
int feof(FILE *flujo);

En donde flujo es el descriptor del archivo en cuestin. La llamada a feof
devuelve un valor distinto de cero (verdadero) en caso que el apuntador de
lectura y escritura se encuentre al final del archivo y 0 en caso contrario.
174
ferror
La funcin ferror, permite determinar si ha ocurrido un error en al realizar
alguna operacin sobre un descriptor de archivo. El prototipo de la misma es el
siguiente:
int ferror(FILE *flujo);

En donde flujo es el descriptor del archivo en cuestin. La llamada a ferror
devuelve un valor distinto de cero si ha ocurrido un error y 0 en caso contrario.
fflush
La funcin fflush, fuerza a que se vace el contenido del buffer asociado a un
descriptor de archivo. El prototipo de la misma es el siguiente:
int fflush(FILE *flujo);

En donde flujo es el descriptor del archivo en cuestin. La llamada a fflush
devuelve cero en caso de concluir con xito. En caso de ocurrir un error retorna
la constante EOF.
remove
La funcin remove, permite eliminar una entrada del sistema de archivos, y de
ser la nica referencia al archivo en cuestin, eliminarlo. El prototipo de la
misma es el siguiente:
int remove(const char *pathname);

En donde pathname es una cadena que contiene la ruta (absoluta o relativa) del
archivo que se desea eliminar. La llamada a remove devuelve 0 en caso de tener
xito y -1 en caso de ocurrir un error.
Para ilustrar la utilizacin de las funciones anteriormente descritas, se presenta
un programa que sirve como agenda telefnica con una cantidad de opciones
bastante limitada (solo permite insertar y buscar un contacto en base a la
posicin).
Programa en C:
175
#include <stdio.h>
int main()
{
int opcion = 0;
FILE* archivo;
printf("1 Insertar contacto\n");
printf("2 Buscar contacto\n");
while(opcion!=1 && opcion !=2)
{
printf("Su opcin: ");
scanf("%d", &opcion);
}
char nombre[80];
int telefono;
int posicion;
if(opcion==1)
{
// Abrir el archivo de texto para escritura al final
archivo = fopen("agenda.txt","a");
// Si no se pudo abrir el archivo
if(archivo==NULL)
{
printf("Error al abrir el archivo\n");
return -1;
}
else
{
printf("Nombre del contacto: ");
scanf("%s", nombre);
printf("Telfono del contacto: ");
scanf("%d", &telefono);
fprintf(archivo, "%s | %d\n", nombre, telefono);
}
}
if(opcion==2)
{
// Abrir el archivo de texto para lectura desde el comienzo
archivo = fopen("agenda.txt","r");
if(archivo==NULL)
{
176
return -1;
}
else
{
printf("Posicin: ");
scanf("%d", &posicion);
int i=0;
while(i!=posicion && i!=-1)
{
if(feof(archivo)) i=-1;
else
{
fscanf(archivo, "%s | %d\n", nombre, &telefono);
i++;
}
}
if(i==-1)
{
printf("La posicin indicada est vaca\n");
}
else
{
printf("Nombre: %s\n", nombre);
printf("Telefono: %d\n", telefono);
}
}
// Cerrar el archivo
fclose(archivo);
return 0;
}
}
.section .rodata
cad1:
.asciz "1 Insertar contacto\n2 Buscar contacto\n"
cad2:
.asciz "Su opcin: "
cad3:
.asciz "Ocurri un error al intentar abrir el archivo\n"
cad4:
.asciz "Nombre del contacto: "
cad5:
.asciz "Telfono del contacto: "
cad6:
.asciz "Posicin: "
cad7:
.asciz "Nombre: %s\nTelefono: %d\n"
cad8:
.asciz "La posicin indicada est vaca\n"
file:
.asciz "agenda.txt"
format1:.asciz "%d"
format2:.asciz "%s"
177
format3:.asciz "%s | %d\n"
modo1: .asciz "a"
modo2: .asciz "r"
.section .bss
nombre: .space
tlf:
.space
opcion: .space
pos:
.space
desp:
.space
fd: .space 4
80
4
4
4
4
.section .text
.globl _start
_start:
pushl $cad1
call printf
addl $4, %esp
while: pushl $cad2
call printf
addl $4, %esp
# Muestra las opciones
# Pide una opcin
pushl $opcion
pushl $format1
call scanf
addl $8, %esp
# Lee la respuesta del usuario
cmpl $1, opcion

je insertar
cmpl $2, opcion
je buscar
jmp while
# Si es 1 salta a insertar
# Si es 2 salta a buscar
# En otro caso pregunta de nuevo
# Abre el archivo para escritura al final

insertar:
pushl $modo1
pushl $file
call fopen
addl $8, %esp
# Modo: ab
# Archivo: agenda2.dat
# Llama a fopen
mov %eax, fd
# Apuntador al archivo abierto
cmpl $0, fd
# Si fd==NULL (0) ocurri un error
178
je error
pushl $cad4
call printf
addl $4, %esp
# Pregunta por el nombre del contacto
pushl $nombre
pushl $format2
call scanf
addl $8, %esp
pushl $cad5
call printf
addl $4, %esp
# Pregunta por el telefono del contacto
pushl $tlf
pushl $format1
call scanf
addl $8, %esp
# Inserta el contacto en el archivo

pushl tlf
pushl $nombre
pushl $format3
pushl fd
call fprintf
addl $16, %esp
#
#
#
#
#
Telefono
&Nombre
Cadena de formato
Apuntador al archivo abierto
Llama a fprintf
jmp fin
# Salta al final del programa
# Abre el archivo para lectura desde el comienzo

buscar:
pushl $modo2
# Modo: rb
pushl $file
call fopen
# Llama a fopen
addl $8, %esp
mov %eax, fd
cmpl $0, fd
je error
pushl $cad6
call printf
addl $4, %esp
# Pide la posicin del contacto
179
pushl $pos
pushl $format1
call scanf
addl $8, %esp
xorl %esi, %esi
# i=0
cmpl %esi, pos

je mostrar
# Si i=pos
# Salta a mostrar
rep:
# Si se alcanz el final del archivo la posicin no existe

pushl fd
call feof
# Llama a feof
addl $4, %esp
cmpl $0, %eax
jne nopos
# Lee el contacto desde el archivo
pushl $tlf
# &Telefono
pushl $nombre
# &Nombre
pushl $format3
# Cadena de formato
pushl fd
call fscanf
# Llama a fscanf
addl $16, %esp
incl %esi
jmp rep
mostrar:
pushl tlf
pushl $nombre
pushl $cad7
call printf
addl $12, %esp
jmp fin
# i++
# Repite la bsqueda
# Muestra la informacin del contacto
# La posicin solicitada no existe

nopos:
pushl $cad8
# Informa al usuario del problema
call printf
addl $4, %esp
jmp fin
# Ocurri un error al abrir el archivo

error:
180
pushl $cad3
call printf
addl $4, %esp
jmp fin2
# Informa al usuario del error
fin:
# Cierra el archivo si estaba abierto
pushl fd
# Descriptor del archivo a cerrar
call fclose
# Llama a fclose
addl $4, %esp
fin2:
movl $1, %eax
movl $0, %ebx
int $0x80
Observe que esta versin de la agenda realiza un acceso secuencial sobre un

archivo de texto plano para almacenar y recuperar la informacin de los
contactos. Si examina el contenido del archivo agenda.txt en un editor de texto
encontr que la informacin contenida en el mismo puede ser leida por un ser
humano. Observe tambin que para ubicar un contacto es necesario recorrer
todos los que lo preceden dentro del archivo.
A continuacin se presenta una segunda versin de la agenda, que contempla
exactamente las mismas opciones, pero utiliza el acceso directo para almacenar
y recuperar la informacin de los contactos en un archivo binario.
Programa en C:
#include <stdio.h>
int main()
{
int opcion = 0;
FILE* archivo;
printf("1 Insertar contacto\n");
printf("2 Buscar contacto\n");
while(opcion!=1 && opcion !=2)
{
printf("Su opcin: ");
181
scanf("%d", &opcion);
}
char nombre[80];
int telefono;
int posicion;
if(opcion==1)
{
// Abrir el archivo binario para escritura al final
archivo = fopen("agenda2.dat","ab");
if(archivo==NULL)
{
return -1;
}
else
{
printf("Nombre del contacto: ");
scanf("%s", nombre);
printf("Telfono del contacto: ");
scanf("%d", &telefono);
fwrite(nombre, 80, 1, archivo);
fwrite(&telefono, 4, 1, archivo);
}
}
if(opcion==2)
{
// Abrir el archivo binario para lectura desde el comienzo
archivo = fopen("agenda2.dat","rb");
if(archivo==NULL)
{
return -1;
}
else
{
printf("Posicin: ");
scanf("%d", &posicion);
fseek(archivo,84*(posicion-1),SEEK_SET);
fread(nombre, 80, 1, archivo);
fread(&telefono, 4, 1, archivo);
if(feof(archivo))
{
182
printf("La posicin indicada est vaca\n");
}
else
{
printf("Nombre: %s\n", nombre);
printf("Telefono: %d\n", telefono);
}
}
// Cerrar el archivo
fclose(archivo);
return 0;
}
}
.section .rodata
cad1:
cad2:
.asciz "Su opcin: "
cad3:
cad4:
cad5:
cad6:
.asciz "Posicin: "
cad7:
cad8:
file:
.asciz "agenda2.dat"
format1:.asciz "%d"
format2:.asciz "%s"
modo1: .asciz "ab"
modo2: .asciz "rb"
.section .bss
nombre: .space
tlf:
.space
opcion: .space
pos:
.space
desp:
.space
fd: .space 4
80
4
4
4
4
.section .text
.globl _start
_start:
pushl $cad1
call printf
addl $4, %esp
183
while: pushl $cad2
call printf
addl $4, %esp
# Pide una opcin
pushl $opcion
pushl $format1
call scanf
addl $8, %esp
cmpl $1, opcion

je insertar
cmpl $2, opcion
je buscar
jmp while

insertar:
pushl $modo1
pushl $file
call fopen
addl $8, %esp
# Modo: ab
# Llama a fopen
mov %eax, fd
cmpl $0, fd
je error
pushl $cad4
call printf
addl $4, %esp
pushl $nombre
pushl $format2
call scanf
addl $8, %esp
pushl $cad5
call printf
addl $4, %esp
pushl $tlf
pushl $format1
call scanf
addl $8, %esp
184
pushl fd
pushl $1
pushl $80
pushl $nombre
call fwrite
addl $16, %esp
#
#
#
#
#

Cantidad de elementos a escribir
Tamao del elemento
Direccin fuente de los datos
Llama a fwrite
pushl fd
pushl $1
pushl $4
pushl $tlf
call fwrite
addl $16, %esp
#
#
#
#
#

Cantidad de elementos a escribir
Tamao del elemento
Direccin fuente de los datos
Llama a fwrite
jmp fin

buscar:
pushl $modo2
# Modo: rb
pushl $file
call fopen
# Llama a fopen
addl $8, %esp
mov %eax, fd
cmpl $0, fd
je error
pushl $cad6
call printf
addl $4, %esp
pushl $pos
pushl $format1
call scanf
addl $8, %esp
decl pos
movl $84, %eax
imull pos
movl %eax, desp
# desplazamiento = (posicin-1)*84
# Localiza el contacto dentro del archivo

pushl $0
# A partir del comienzo (SEEK_SET : 0)
pushl %eax
# Se desplaza "desplazamiento" bytes
185
pushl fd
call fseek
addl $12, %esp

# Llama a fseek

pushl fd
pushl $1
# Cantidad de elementos a leer
pushl $80
# Tamao del elemento
pushl $nombre
# Direccin destino de los datos
call fread
# Llama a fread
addl $16, %esp
pushl fd
pushl $1
pushl $4
pushl $tlf
call fread
addl $16, %esp
#
#
#
#
#

Cantidad de elementos a leer
Tamao del elemento
Direccin destino de los datos
Llama a fread

pushl fd
call feof
addl $4, %esp
cmpl $0, %eax
jne nopos

# Llama a feof
pushl tlf
pushl $nombre
pushl $cad7
call printf
addl $12, %esp
jmp fin

nopos:
pushl $cad8
call printf
addl $4, %esp
jmp fin

error:
pushl $cad3
call printf
186
addl $4, %esp
jmp fin2
fin:
pushl fd
call fclose
# Llama a fclose
addl $4, %esp
fin2:
movl $1, %eax
movl $0, %ebx
int $0x80
Observe que en esta nueva versin no es necesario recorrer todo el archivo para
recuperar la informacin de un contacto, ya que al conocer a priori el tamao en
bytes que ocupa cada registro dentro del archivo (84 bytes) es posible
posicionar el apuntador de lectura en el desplazamiento adecuado para leer
nicamente la informacin de inters. Note tambin que si intenta examinar el
contenido del archivo agenda.dat en un editor de texto, encontrar imposible
determinar el nmero telefnico de los contactos. Esto se debe a que los
mismos estn almacenados en formato binario como enteros de 4 bytes.
Llamadas al sistema
Todas las funciones de alto nivel descritas en la seccin anterior se apoyan en
las llamadas al sistema operativo para llevar a cabo cada una de las operaciones
involucradas con el manejo de archivos. Las mismas pueden ser utilizadas
directamente por un programa en lenguaje ensamblador, siguiendo los pasos
descritos en el capitulo 6.
El sistema operativo Linux presenta una gran variedad de llamadas relacionadas
con el manejo de archivos. La siguiente es una lista de las ms relevantes, junto
con una breve descripcin de la tarea que realiza cada una de ellas:
187
Llam ad a
Nmer o
De scr ipc i n
creat
Crea un nuevo archivo
open
Abre un archivo
close
Cierra un archivo
read
Lee datos desde un archivo abierto
write
Escribe datos en un archivo abierto
lseek
19
Cambia la posicin dentro del archivo desde la que se lee o escribe
10
Elimina una entrada del sistema de archivos (si es la nica

referencia al archivo, borra el archivo)
mkdir
39
Crea un directorio
rmdir
40
Elimina un directorio (debe estar vaco)
rename
38
Cambia el nombre de un archivo o directorio
chmod
15
Cambia los permisos de acceso a un archivo o directorio
chdir
12
Cambia el directorio de trabajo
unlink
A continuacin se presenta una descripcin ms detallada de cada una de estas

llamadas al sistema:
creat
La llamada al sistema creat (8), permite crear un nuevo archivo. El prototipo de
la misma es el siguiente:
int creat(const char *camino, mode_t modo);

archivo que se desea crear, mientras que modo es un nmero octal que
representa los permisos de acceso que sern asignados a archivo creado. La
llamada devuelve el descriptor de archivo asociado al mismo. En caso de no
poderse crear el archivo, la llamada devuelve un valor negativo que identifica al
error ocurrido.
open
La llamada al sistema open (5), permite abrir un archivo existente. Los
prototipos de la misma son los siguientes:
int open(const char *camino, int flags);

int open(const char *camino, int flags, mode_t modo);
188
archivo que se desea abrir y flags es un entero que representa las caractersticas
con las que se desea operar el archivo a abrir (por ejemplo solo lectura, solo
escritura, etc.) En este caso el atributo modo es opcional, y tiene la misma
utilidad que en el caso de la llamada creat en caso de que el archivo a abrir no
exista y la bandera O_CREAT est encendida. La llamada devuelve el descriptor
asociado al archivo abierto. En caso de no poderse abrir el archivo, la llamada
devuelve un valor negativo que identifica al error ocurrido.
Las diferentes banderas que componen el atributo flags se encuentran definidas
en
el
archivo
fcntl.h,
generalmente
ubicado
en
el
directorio
/usr/include/bits/. A continuacin se presentan las ms relevantes:
Ba nd era
Valor (oc ta l)
De scr ipc i n
O_RDONLY
00
Solo lectura
O_WRONLY
01
Solo escritura
O_RDWR
02
Lectura y escritura
O_CREAT
0100
Crea el archivo si no existe
O_TRUNK
01000
Trunca el archivo si existe
O_APPEND
02000
Comienza a escribir al final del archivo
close
La llamada al sistema close (6), permite cerrar un archivo, es decir, elimina la
relacin existente entre el descriptor y el archivo, de forma que el primero deje
de hacer referencia al ltimo (note por lo tanto que el cerrar el descriptor no
necesariamente implica la liberacin de los recursos asociados al archivo, ya que
puede existir otro descriptor haciendo referencia al mismo). El prototipo de la
llamada close es el siguiente:
int close(int fd);

En donde fd es el descriptor del archivo que se desea cerrar. La llamada
devuelve 0 en caso de tener xito y -1 en caso de ocurrir un error.
189
read
La llamada al sistema read (4), permite leer datos desde un archivo. El prototipo
de la llamada read es el siguiente:
ssize_t read(int fd, void *buf, size_t nbytes);

En donde fd es el descriptor del archivo desde el cual se desea leer, buf es un
apuntador a la zona de memoria en la que se almacenarn los datos leidos y
nbytes es la cantidad mxima de bytes que se leern. La llamada devuelve el

nmero de bytes ledos en caso de tener xito (puede ser menor a nbytes) y -1
en caso de ocurrir un error.
write
La llamada al sistema write (5), permite escribir datos en un archivo. El prototipo
de la llamada write es el siguiente:
ssize_t write(int fd, const void *buf, size_t num);

En donde fd es el descriptor del archivo en el cual se desea escribir, buf es un
apuntador a la zona de memoria que contiene los datos a escribir y num es la
cantidad de bytes que se escribirn. La llamada devuelve el nmero de bytes
escritos en caso de tener xito y -1 en caso de ocurrir un error.
lseek
La llamada al sistema lseek (19), permite cambiar la ubicacin del apuntador de
lectura/escritura de un descriptor de archivo. El prototipo de la llamada lseek es
el siguiente:
off_t lseek(int fildes, off_t offset, int whence);

En donde fildes es el descriptor del archivo al cual se desea cambiar la posicin
del apuntador, offset es la cantidad de bytes que se quiere desplazar el mismo y
whence es la posicin a partir de la cual se har efectivo dicho desplazamiento.

La llamada devuelve la posicin final del apuntar medida en bytes a partir del
comienzo del archivo en caso de tener xito y -1 en caso de ocurrir un error. Es
importante tener en cuenta que esta llamada permite desplazarse ms all del
final del archivo sin que esto produzca un error. Si una vez hecho esto se realiza
190
una operacin de escritura, los bytes ubicados entre el antiguo final del archivo
y la posicin actual son rellenados con cero.
unlink
La llamada al sistema unlink (10), permite eliminar una entrada del sistema de
archivos, y de ser la nica referencia al archivo en cuestin, eliminarlo. El
prototipo de la llamada unlink es el siguiente:
int unlink(const char *pathname);

archivo que se desea eliminar. La llamada devuelve 0 en caso de tener xito y -1
en caso de ocurrir un error.
mkdir
La llamada al sistema mkdir (39), permite crear un nuevo directorio. El prototipo
de la llamada mkdir es el siguiente:
int mkdir(const char *pathname, mode_t mode);

directorio que se desea crear, mientras que modo es un nmero octal que
representa los permisos de acceso que sern asignados al directorio creado. La
llamada devuelve 0 en caso de tener xito y -1 en caso de ocurrir un error.
rmdir
La llamada al sistema rmdir (40), permite eliminar un directorio existente. El
prototipo de la llamada rmdir es el siguiente:
int rmdir(const char *pathname);

directorio que se desea eliminar. La llamada devuelve 0 en caso de tener xito y
-1 en caso de ocurrir un error.
191
rename
La llamada al sistema rename (38), permite cambiar el nombre (y en
consecuencia mover) un archivo o directorio existente. El prototipo de la
llamada rename es el siguiente:
int rename(const char *oldpath, const char *newpath);

En donde oldpath es una cadena que contiene la ruta (absoluta o relativa) del
directorio que se desea eliminar, y newpath es una cadena que contiene la
nueva ruta (absoluta o relativa) que se desea asignar al archivo. La llamada
devuelve 0 en caso de tener xito y -1 en caso de ocurrir un error.
chmod
La llamada al sistema chmod (15), permite cambiar los permisos de acceso de
archivo o directorio existente. El prototipo de la llamada chmod es el siguiente:
int chmod(const char *path, mode_t mode);

En donde path es una cadena que contiene la ruta (absoluta o relativa) del
directorio en cuestin, y mode es un nmero octal que representa los nuevos
permisos de acceso que sern asignados al mismo. La llamada devuelve 0 en
caso de tener xito y -1 en caso de ocurrir un error.
chdir
La llamada al sistema chdir (12), permite cambiar el directorio de trabajo actual.
El prototipo de la llamada chdir es el siguiente:
int chdir(const char *path);

En donde path es una cadena que contiene la ruta (absoluta o relativa) del nuevo
directorio de trabajo. La llamada devuelve 0 en caso de tener xito y -1 en caso
de ocurrir un error.
Para ilustrar la utilizacin de las llamadas al sistema operativo anteriormente

descritas, se presenta una nueva versin de la agenda telefnica, utilizando
nuevamente un archivo binario para almacenar la informacin de los contactos y
acceso directo para manipular su contenido.
192
.section .rodata
cad1:
cad2:
.asciz "Su opcin: "
cad3:
cad4:
cad5:
cad6:
.asciz "Posicin: "
cad7:
cad8:
file:
format1:.asciz "%d"
format2:.asciz "%s"
.section .bss
nombre: .space
tlf:
.space
opcion: .space
pos:
.space
desp:
.space
fd:
.space
80
4
4
4
4
4
.section .text
.globl _start
_start:
pushl $cad1
call printf
addl $4, %esp
while:
pushl $cad2
call printf
addl $4, %esp
# Pide una opcin
pushl $opcion
pushl $format1
call scanf
addl $8, %esp
cmpl $1, opcion

je insertar
cmpl $2, opcion
je buscar
193
jmp while

insertar:
movl $5, %eax
# Servicio #5 (open)
movl $file, %ebx
# Ruta del archivo a abrir
movl $02101, %ecx
# O_CREAT | O_APPEND | O_WRONLY
# 0100|02000|01:02101
int $0x80
# Llamada al SO
mov %eax, fd
cmpl $0, fd
jl error
# Si fd<0 ocurri un error
pushl $cad4
call printf
addl $4, %esp
pushl $nombre
pushl $format2
call scanf
addl $8, %esp
pushl $cad5
call printf
addl $4, %esp
pushl $tlf
pushl $format1
call scanf
addl $8, %esp
# Inserta el contacto
movl $4, %eax
#
movl fd, %ebx
#
movl $nombre, %ecx #
movl $84, %edx
#
int $0x80
#
jmp fin
en el archivo
Servicio #4, (write)
File Descriptor del archivo abierto
Apuntador a los datos a escribir
Nmero de bytes a escribir
Llamada al SO

buscar:
movl $5, %eax
movl $file, %ebx
movl $0, %ecx
# ORDONLY : 0
194
int $0x80
mov %eax, fd
# Llamada al SO
cmpl $0, fd
jl error
pushl $cad6
call printf
addl $4, %esp
pushl $pos
pushl $format1
call scanf
addl $8, %esp
decl pos
movl $84, %eax
imull pos
movl %eax, desp

movl $19, %eax
# Servicio #19, (lseek)
movl fd, %ebx
# File Descriptor del archivo abierto
movl desp, %ecx
# Desplazamiento en bytes
movl $0, %edx
int $0x80
# Llamada al SO
movl $3, %eax
movl fd, %ebx
movl $nombre, %ecx # Direccin donde se almacenarn los datos
movl $84, %edx
# Nmero de bytes a leer
int $0x80
# Llamada al SO
cmpl $0, %eax
je nopos
# Si se leyeron cero bytes

# la posicin no existe
pushl tlf
pushl $nombre
pushl $cad7
call printf
addl $12, %esp
jmp fin

nopos:
195
pushl $cad8
call printf
addl $4, %esp
jmp fin

error:
pushl $cad3
call printf
addl $4, %esp
fin:
# Cierra el archivo
movl $6, %eax
movl fd, %ebx
int $0x80
si estaba abierto
# Servicio #5 (close)
# Llamada al SO
movl $1, %eax
movl $0, %ebx
int $0x80
Note que el formato de archivo es idntico al utilizado por la segunda versin

del programa, y en consecuencia los archivos generados por una versin pueden
ser ledos por la otra y viceversa, es decir, son compatibles. Observe tambin
que las banderas pasadas como argumento a la llamada open deben ser
combinadas mediante un OR a nivel de bit.
Si bien este programa puede parecer a simple vista ms largo y complejo que la
versin que utiliza funciones de alto nivel, tambin es cierto que el mismo no
necesita de bibliotecas externas lo que se traduce en una ejecucin ms rpida.
Adicionalmente considere que utilizando llamadas al sistema el programador
tiene un mayor control y libertad sobre las acciones que puede llevar a cabo, y
no se encuentra limitado por las restricciones impuestas por los autores de las
funciones de alto nivel.
196
Ejercicios
12.1 El comando more muestra el contenido de un archivo de texto,
permitiendo al usuario avanzar una lnea presionando la tecla ENTER o a la
siguiente pgina presionando la barra espaciadora. Escriba un programa que
simule este comportamiento. Utilice las funciones de alto nivel provistas por el
lenguaje C.
12.2- Repita el ejercicio anterior utilizando nicamente llamadas al sistema
operativo.
12.3 Modifique la primera versin de la agenda telefnica (acceso secuencial,
texto plano, funciones de C), de forma que incluya una opcin para eliminar un
contacto.
12.4 Repita el ejercicio anterior para la tercera versin de la agenda (acceso
directo, archivo binario, llamadas al sistema).
12.5 Escriba un programa que dados dos archivos de texto, produzca como
salida un tercer archivo que sea la concatenacin de los contenidos de ambos.
Utilice las funciones de alto nivel provistas por el lenguaje C.
12.6 Escriba un programa que dados dos archivos binarios con el formato
utilizado por la agenda telefnica desarrollada en este captulo, produzca como
salida un nuevo archivo binario que contenga la mezcla de los contactos
contenidos en ambos. Asuma que dentro de un mismo archivo no existen
contactos repetidos. Utilice nicamente llamadas al sistema operativo. Ayuda:
Al comparar los nombres de los contactos solo tenga en cuenta la parte de la
cadena que precede al carcter nulo (/0).
197
Soluciones a los ejercicios

Captulo 5
5.1- Cambios ocurridos en los registros para el programa:
.section .text
.globl _start
_start:
1
movl $5, %eax
2
xorl %ecx, %ecx
3
addl $6, %ecx
4
addl %ecx, %eax
5
movl %ecx, %ebx
6
movl $2, %edx
7
incl %ebx
8
imull %edx, %ebx
9
shll $2,%edx
10
sarl $1,%ecx
11
addl %ebx, %eax
12
cltd
13
idivl %ecx
14
movl $1, %eax
15
movl $0, %ebx
int $0x80
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
%ea x
5
%eb x
%ecx
%ed x
0
6
11
6
2
7
14
8
3
25
25
8
1
0
1
0
5.2# Programa que calcula x=a-3b+25(c-d)

.section .data
a:
.long 6
198
b:
c:
d:
x:
.long
.long
.long
.long
8
12
4
0
.section .text
.globl _start
_start:
movl b, %ebx
imull $3, %ebx
movl a, %eax
subl %ebx, %eax
movl c, %ecx
subl d, %ecx
imull $25,%ecx
addl %ecx, %eax
movl %eax, x
movl $1, %eax
movl $0, %ebx
int $0x80
#
#
#
#
#
#
#
#
#
%ebx=b
%ebx=3b
%eax=a
%eax=a-3b
%ecx=c
%ecx=c-d
%ecx=(c-d)*25
%eax= (a-3b)+((c-d)*25)
guarda el resultado en x
# fin del programa
5.3# Calculo de x=16*y

shll $4, y
# desplaza 4 posiciones a la izquierda lo cual es
# equivalente a multiplicar por 24
5.4# Calculo de x=y/32

sarl $5,y
# desplazamiento aritmtico de 5 posiciones a la
# derecha, equivalente a dividir entre 25
5.5# Programa que calcula x=(a+(b-c))/(c*d)

.section .data
a:
.long 4
b:
.long 5
c:
.long 2
d:
.long 7
x:
.long 0
.section .text
.globl _start
_start:
movl b, %eax
subl c, %eax
addl a, %eax
movl c, %ecx
imull d, %ecx
cltd
idivl %ecx
# %eax=b
# %eax=b-c
%eax=(b-c)+a
# %ecx=c
# %ecx=c*d
# %edx=0
# %eax=((b-c)+a)/(c*d)
%edx=resto
199
movl %eax, x
# guarda el resultado en x
movl $1, %eax

movl $0, %ebx
int $0x80
5.6# Programa que revisa tres numeros y escoge el mayor

.section .data
a:
.long 4
b:
.long 2
c:
.long 3
mayor: .long 0
.section .text
.globl _start
_start:
movl a, %eax
movl b, %ebx
movl c, %ecx
cmpl %ebx, %eax
jg amayorb
cmpl %ecx, %ebx
jl bmenorc
movl %ebx, mayor
jmp fin
#
#
#
#
#
#
compara a con b
si a>b salata a amayorb
compara b con c
si b<c salta a mnenorc
cuando b es el mayor
salta a fin
bmenorc:
movl %ecx, mayor

jmp fin
# cuando c es el mayor
# salta a fin
amayorb:
cmpl %ecx, %eax

jl amenorc
movl %eax,mayor
jmp fin
#
#
#
#
amenorc:
movl %ecx, mayor
# cuando c es el mayor
fin:
movl $1, %eax

movl $0, %ebx
int $0x80
# fin del programa
compara a con c
si a<c salta a amenorc
cuando a es el mayor
salta a fin
5.7# Programa que produce como salida a si a =b; a-b si a>b o b-a si a<b
.section .data
a:
.long 6
# declaracin de las variables a y b
b:
.long 8
resultado:
.long 0
# variable resultado para guardar la salida
.section .text
.globl _start
_start:
movl a, %eax
# %eax= a
200
movl b, %ebx
# %ebx= b
cmpl %ebx, %eax
# compara a con b
je igual
# si a=b salta a igual
jg mayor
# si a>b salta a mayor
subl %eax, %ebx
# cuando a<b, resta b-a
movl %ebx, resultado
# actualiza el resultado
jmp fin
movl %eax, resultado
# cuando a=b resultado=a
jmp fin
subl %ebx, %eax
# cuando a>b, resta a-b
movl %eax, resultado
# actualiza el resultado
movl $1, %eax
# culmina el programa
movl $0, %ebx
int $0x80
igual:
mayor:
fin:
5.81
2
3
4
5
6
7
8
9
10
11
12
13
movl $25, %eax

addl $5, %eax
pushl %eax
incl %eax
pushl %eax
movl %eax, %ebx
subl $16, %ebx
cltd
idivl %ebx
pushl %edx
popl %eax
popl %ecx
popl %ebx
1
2
3
4
5
6
7
8
9
10
11
12
13
%ea x
25
30
%eb x
%ecx
%ed x
%es p
0x0FC
31
0xF08
31
15
0
1
2
1
31
30
0xF04
0xF08
0xF0C
0x100
Pila:
Direccin
Contenido
0xF04
201
0xF08
31
0x0FC
30
0x100
Captulo 6
6.1.# Programa que muestra valores enteros en diferentes formatos
.section .data
mensaje:
.asciz"Programa que lee 6 valores y los muestra en uno de cuatro
formatos\n"
mensaj2:
.asciz"Los formatos disponibles para mostrar los numeros son:\n"
f1:
.asciz"Horizontal en el mismo orden de entrada [1]\n"
f2:
.asciz"Horizontal en orden inverso
[2]\n"
f3:
.asciz"Vertical en el mismo orden de entrada
[3]\n"
f4:
.asciz"Vertical en orden inverso
[4]\n"
escoge:
.asciz"Escoja un formato, introduzca el numero correspondiente:\t"
leer:
.asciz"Introduzca los 6 valores:\n"
v1:
.asciz"valor 1:\t"
v2:
.asciz"valor 2:\t"
v3:
.asciz"valor 3:\t"
v4:
.asciz"valor 4:\t"
v5:
.asciz"valor 5:\t"
v6:
.asciz"valor 6:\t"
salta:
.asciz"\n\n"
valor:
.asciz"%d"
salf12:
.asciz"Los valores leidos son: \n %d\t %d\t %d\t %d\t %d\t %d\n"
salf34:
.asciz"Los valores leidos son: \n %d\n %d\n %d\n %d\n %d\n %d\n"
forma:
.long 0
val1:
.long 0
val2:
.long 0
val3:
.long 0
val4:
.long 0
val5:
.long 0
val6:
.long 0
.section .text
.globl _start
_start:
pushl $mensaje
call printf
pushl $mensaj2
call printf
pushl $f1
call printf
pushl $f2
call printf
pushl $f3
call printf
pushl $f4
# mensaje inicial
#
formatos disponibles
202
call printf
addl $24, %esp
pushl $escoge
call printf
pushl $forma
pushl $valor
call scanf
# lee formato escogido, lo guarda en

# forma
pushl $leer
call printf
addl $16, %esp
pushl $v1
call printf
pushl $val1
pushl $valor
call scanf
addl $12, %esp
# lee valor 1
pushl $v2
call printf
pushl $val2
pushl $valor
call scanf
addl $12, %esp
# lee valor 2
pushl $v3
call printf
pushl $val3
pushl $valor
call scanf
addl $12, %esp
# lee valor 3
pushl $v4
call printf
pushl $val4
pushl $valor
call scanf
addl $12, %esp
# lee valor 4
pushl $v5
call printf
pushl $val5
pushl $valor
call scanf
addl $12, %esp
# lee valor 5
pushl $v6
call printf
pushl $val6
pushl $valor
call scanf
# lee valor 6
203
addl $12, %esp
pushl $salta # salto de lnea
call printf
addl $4, %esp
cmpl $1, forma
je uno
cmpl $2, forma
je dos
cmpl $3, forma
je tres
pushl val1
pushl val2
pushl val3
pushl val4
pushl val5
pushl val6
pushl $salf34
call printf
jmp fin
# muestra valores segun formato 4
uno:
pushl val6
pushl val5
pushl val4
pushl val3
pushl val2
pushl val1
pushl $salf12
call printf
jmp fin
dos:
pushl val1
pushl val2
pushl val3
pushl val4
pushl val5
pushl val6
pushl $salf12
call printf
jmp fin
tres:
pushl val6
pushl val5
pushl val4
pushl val3
pushl val2
pushl val1
pushl $salf34
call printf
fin:
movl $1, %eax
# fin del programa
204
xorl %ebx, %ebx
int $0x80
6.2.# Programa que suma 4 valores

.section .data
mensaje:
.asciz"Programa que lee 4 valores y los suma\n"
leer:
v1:
.asciz"valor 1:\t"
v2:
.asciz"valor 2:\t"
v3:
.asciz"valor 3:\t"
v4:
.asciz"valor 4:\t"
salta:
.asciz"\n"
valor:
.asciz"%d"
salida:
.asciz"La suma de: %d + %d + %d + %d = %d\n"
val1:
val2:
val3:
val4:
.long
.long
.long
.long
0
0
0
0
.section .text
.globl _start
_start:
pushl $mensaje
call printf
pushl $leer
call printf
addl $8, %esp
# mensaje inicial
pushl $v1
call printf
pushl $val1
pushl $valor
call scanf
addl $12, %esp
# lee valor 1
pushl $v2
call printf
pushl $val2
pushl $valor
call scanf
addl $12, %esp
# lee valor 2
pushl $v3
call printf
pushl $val3
pushl $valor
call scanf
addl $12, %esp
# lee valor 3
pushl $v4
call printf
pushl $val4
# lee valor 4
205
pushl $valor
call scanf
addl $12, %esp
call printf
addl $4, %esp
movl
addl
addl
addl
val1,
val2,
val3,
val4,
%eax
%eax
%eax
%eax
pushl %eax
pushl val4
pushl val3
pushl val2
pushl val1
pushl $salida
call printf
# suma los 4 valores
# muestra los valores y su suma
movl $1, %eax # fin del programa

xorl %ebx, %ebx
int $0x80
6.3..section .data
mensaje:
.asciz"Programa que lee 4 valores y calcula el promedio\n"
leer:
v1:
.asciz"valor 1:\t"
v2:
.asciz"valor 2:\t"
v3:
.asciz"valor 3:\t"
v4:
.asciz"valor 4:\t"
salta: .asciz"\n"
valor: .asciz"%d"
salida:
.asciz"El promedio de: %d , %d , %d , %d es: %d\n"
val1:
val2:
val3:
val4:
.long
.long
.long
.long
0
0
0
0
.section .text
.globl _start
_start:
pushl $mensaje
call printf
pushl $leer
call printf
addl $8, %esp
pushl $v1
call printf
pushl $val1
# mensaje inicial
# lee valor 1
206
pushl $valor
call scanf
addl $12, %esp
pushl $v2
call printf
pushl $val2
pushl $valor
call scanf
addl $12, %esp
# lee valor 2
pushl $v3
call printf
pushl $val3
pushl $valor
call scanf
addl $12, %esp
# lee valor 3
pushl $v4
call printf
pushl $val4
pushl $valor
call scanf
addl $12, %esp
# lee valor 4

call printf
addl $4, %esp
movl val1, %eax
addl val2, %eax
addl val3, %eax
addl val4, %eax
movl $4, %ecx
cltd
idivl %ecx
# suma los 4 valores
pushl %eax
pushl val4
pushl val3
pushl val2
pushl val1
pushl $salida
call printf
# muestra los valores y el promedio
# divide la suma entre 4

xorl %ebx, %ebx
int $0x80
6.4# Programa que lee dos valores a y b y produce como salida, por
# pantalla a si a =b; a-b si a>b o b-a si a<b
.section .data
207
leea:
.asciz"Introduzca el dato a:
leeb:
.asciz"Introduzca el dato b:
valor: .asciz"%d"
a:
.long 0
b:
.long 0
salida:
.asciz"resultado:
%d\n"
.section .text
.globl _start
_start:
leal a, %eax
pushl %eax
pushl $valor
call scanf
leal b, %eax
pushl %eax
pushl $valor
call scanf
movl a, %eax
movl b, %ebx
xorl %ecx, %ecx
cmpl %ebx, %eax
je igual
jg mayor
subl %eax, %ebx
movl %ebx, %ecx
jmp fin
igual: movl %eax, %ecx
jmp fin
mayor: subl %ebx, %eax
movl %eax, %ecx
fin:
pushl %ecx
pushl $salida
call printf
movl $1, %eax
movl $0, %ebx
int $0x80
#
#
#
#
#
#
#
#
#
#
#
#
#
#
#
#
#
#
#
#
#
#
#
#
#
\n"
\n"
%eax=dir inicial de a
pasa la dir de a como parametro
pasa el formato valor como parametro
llamada a la funcin de lectura (lee a)
%eax=dir inicial de b
pasa la dir de b como parametro
pasa el formato valor como parametro
llamada a la funcin de lectura (lee b)
%eax=a
%ebx=b
%ecx=0 temporal para el resultado
compara a con b
si a=b salta a igual
si a>b salta a mayor
resta b-a
guarda resultado en %ecx
salta a fin de programa
cuando a=b, %ecx=a
salta a fin de programa
cuando a>b, resta a-b
guarda resultado en %ecx
pasa %ecx como parametro
apila formato de salida
muestra resultado por pantalla
fin del programa
6.5# Programa que calcula el monto a pagar para una llamada telefonica
.section .data
leea:
.asciz"Introduzca los minutos de la llamada:
\n"
valor:
.asciz"%d"
min:
.long 0
monto:
.asciz"Monto a pagar:
%d\n"
.section .text
.globl _start
_start:
leal min, %eax
pushl %eax
pushl $valor
call scanf
xorl %ebx, %ebx
#
#
#
#
#
%eax= dir de min (indica los minutos)

se apila dir de min
se apila el formato de lectura
lee min
%ebx=0
208
basico:
fin:
movl min, %eax

# %eax=min (minutos de la llamada)
cmpl $3, min
# compara min con 3
jle basico
# si min<=3 entonces tarifa=basica
subl $3, %eax
# si min>3 %eax=min-3 (min adicionales)
imull $100, %eax, %ebx
# %ebx=min adicionales por 100
addl $200, %ebx
# %ebx=monto a pagar (si la tarifa es basica
# %ebx=0+200, si hay min adicionales
# %ebx=monto adicional+200)
pushl %ebx
# apila %ebx=monto a pagar
pushl $monto # apila formato de salida
call printf
# muestra por pantalla el monto
movl $0, %ebx
int $0x80
6.6..section .rodata
cadinic:
.asciz
caracter1:
.asciz
caracter2:
.asciz
cadmod:
.asciz
fcadmod:
.section
cadena:
car1:
car2:
trash:
.bss
.space
.space
.space
.space
20
1
1
10
"Introduzca la cadena (max. 20 caracteres): "

"Introduzca el caracter a reemplazar: "
"Introduzca el caracter a utilizar como reeemplazo: "
"La cadena modificada es: "
#
#
#
#
#
espacio
espacio
espacio
espacio
nuestro
para la cadena
para el caracter a reemplazar
para el nuevo caracter
para volcar los caracteres que no son de
inters
.section .text
.globl _start
_start:
# Mensaje solicitando que se escriba la cadena
movl $4, %eax
movl $1, %ebx
leal cadinic, %ecx
movl $caracter1-cadinic, %edx # Nmero de caracteres a imprimir
int $0x80
# Llamada al SO
# Lectura de la cadena introducida por el usuario
movl $3, %eax
movl $0, %ebx
leal cadena, %ecx
# Dir donde se almacenar la cadena
movl $20, %edx
int $0x80
# Llamada al SO
# Mensaje que solicita caracter a reemplazar
movl $4, %eax
209
movl $1, %ebx
leal caracter1, %ecx
movl $caracter2-caracter1,%edx
int $0x80
#
#
#
#
File Descriptor = 1 (stdout)

Apuntador a la cadena a imprimir
Nmero de caracteres a imprimir
Llamada al SO
# Lectura del caracter a reemplazar

movl $3, %eax
movl $0, %ebx
leal car1, %ecx
# Dir donde se almacenar el caracter
movl $1, %edx
int $0x80
# Llamada al SO
# Vaciado del buffer de entrada
movl $3, %eax
movl $0, %ebx
leal trash, %ecx
movl $10, %edx
int $0x80
# Llamada al SO
# Mensaje que solicita caracter a utilizar como reemplazo
movl $4, %eax
movl $1, %ebx
leal caracter2, %ecx
movl $cadmod-caracter2, %edx
# Nmero de caracteres a imprimir
int $0x80
# Llamada al SO
# Lectura del caracter a utilizar como reemplazo
movl $3, %eax
movl $0, %ebx
leal car2, %ecx
movl $1, %edx
int $0x80
# Llamada al SO
# Vaciado del buffer de entrada
movl $3, %eax
movl $0, %ebx
leal trash, %ecx
movl $10, %edx
int $0x80
# Llamada al SO
# Reemplazo del caracter
movb car2, %bh
leal cadena, %ecx
leecar:
movb (%ecx), %ah
cmpb $0, %ah
je fincomp
cmpb car1, %ah
jne noc
movb %bh, (%ecx)
noc: incl %ecx
jmp leecar
# Lee el caracter de reemplazo

# Direccin de inicio de la cadena
#
#
#
#
#
#
#
#
Carga un caracter de la cadena

Si es un caracter nulo
La cadena se termin
Si no es el caracter a reemplazar
Lo ignora
De lo contario lo reemplaza
Contnua con el siguiente caracter
de la cadena
210
fincomp:
# Imprimir resultado (Mensaje)
movl $4, %eax
movl $1, %ebx
leal cadmod, %ecx
movl $fcadmod-cadmod, %edx
int $0x80
#
#
#
#
#
Servicio #4 (write)
Nmero de caracteres a imprimir
Llamada al SO
# Imprimir resultado (Cadena modificada)

movl $4, %eax
movl $1, %ebx
leal cadena, %ecx
movl $20, %edx
# Nmero de caracteres a imprimir
int $0x80
# Llamada al SO
# Fin del programa
movl $1, %eax
movl $0, %ebx
int $0x80
6.7..section
cad1:
cad2:
cadena:
fcadena:
.data
.asciz "La cadena introducida es: "
.space 50
.section .text
.globl _start
_start:
movl $4, %eax
movl $1, %ebx
leal cad1, %ecx
int $0x80
# Llamada al SO
movl $3, %eax
movl $0, %ebx
leal cadena, %ecx
movl $49, %edx
int $0x80
# Llamada al SO
# Muestra el resultado (una sola llamada)
movl $4, %eax
movl $1, %ebx
leal cad2, %ecx
211
movl $fcadena-cad2, %edx
int $0x80

# Llamada al SO
movl $1, %eax
movl $0, %ebx
int $0x80
6.8.Es necesario reservar espacio para representar 32 bits en lugar de 10 dgitos

decimales. Esto es:
cadena:
.space 10
debe cambiarse por

cadena:
.space 32
En segundo lugar, es necesario realizar divisiones sucesivas entre 2 en lugar de

10 para convertir las cadenas de entrada a enteros, y realizar multiplicaciones
sucesivas por 2 en lugar de 10 para convertir el entero resultante en una cadena
que lo represente. Para ello, deben sustituirse las tres apariciones de:
movl $10, %esi
# base decimal
movl $2, %esi
# base binaria
Por:
Para facilitar este ltimo cambio, y permitir que el programa funcione de forma
genrica para otras bases, es posible definir una constante simblica:
.equ BASE, 2
# Se utiliza base 2
Y reemplazar las instrucciones anteriores por:

movl $BASE, %esi
# base binaria
Esta solucin es vlida para cualquier base comprendida entre 2 y 10. Para
bases superiores a 10 es necesario introducir lgica adicional que contemple el
hecho de que los dgitos superiores al 9 son representados mediante las letras
del alfabeto. A continuacin se presenta el programa con las modificaciones
sugeridas anteriormente:
.equ BASE, 2
# Se utiliza base 2
.section .rodata
cad1:
212
cad2:
cad3:
salto:

.asciz "El valor de A+B es: "
.asciz "\n"
.section
A:
B:
C:
cadena:
.bss
.space
.space
.space
.space
4
4
4
32
#
#
#
#
Reserva
Reserva
Reserva
Reserva
espacio
espacio
espacio
espacio
para
para
para
para
un
un
un
la
entero
entero
entero
cadena introducida
.section .text
.globl _start
_start:
movl $4, %eax
movl $1, %ebx
leal cad1, %ecx
int $0x80
# Llamada al SO
movl $3, %eax
movl $0, %ebx
leal cadena, %ecx
movl $49, %edx
int $0x80
# Llamada al SO
xorl %ecx, %ecx
# i=0
xorl %eax, %eax
# A=0
movl $BASE, %esi
# base
for1:
cmpb $0, %bl
je ffor1
# Sale del ciclo
cmpb $10, %bl
je ffor1
# Sale del ciclo
subb $'0', %bl
movzx %bl, %ebx
mull %esi
# A=A*10
addl %ebx, %eax
# A=A+D
incl %ecx
jmp for1
ffor1:
movl %eax, A
# Guarda el valor de A
movl $4, %eax
movl $1, %ebx
leal cad2, %ecx
int $0x80
# Llamada al SO
213

movl $3, %eax
movl $0, %ebx
leal cadena, %ecx
movl $49, %edx
int $0x80
# Llamada al SO
xorl %ecx, %ecx
# i=0
xorl %eax, %eax
# A=0
movl $BASE, %esi
# base
for2:
cmpb $0, %bl
je ffor2
# Sale del ciclo
cmpb $10, %bl
je ffor2
# Sale del ciclo
subb $'0', %bl
movzx %bl, %ebx
mull %esi
# A=A*10
addl %ebx, %eax
# A=A+D
incl %ecx
jmp for2
ffor2:
movl %eax, B
# Guarda el valor de B
# Calcula el valor de A+B
movl A, %eax
addl B, %eax
movl %eax, C
# Obtiene la cadena que representa al entero C
movb $0, cadena+10
# Termina la cadena (\0)
movl $9, %ecx
# i=9
movl $BASE, %esi
# base
for3:
cltd
# Expande C a 64 bits (edx:eax)
idivl %esi
# Lo divide entre la base
addb $'0', %dl
# Obtiene la representacin del dgito
movb %dl, cadena(%ecx)
# Lo inserta en la cadena
decl %ecx
cmpl $0, %eax
# Se repite mientras queden dgitos
jne for3
movl %ecx, %esi
# Guarda el desplazamiento
incl %esi
movl $4, %eax
movl $1, %ebx
leal cad3, %ecx
movl $salto-cad3, %edx
decimal
214
int $0x80
# Llamada al SO

movl $4, %eax
movl $1, %ebx
leal cadena, %ecx
addl %esi, %ecx
# Ajustamos la direccin de la cadena
movl $10, %edx
int $0x80
# Llamada al SO
# Imprime un salto de lnea
movl $4, %eax
#
movl $1, %ebx
#
leal salto, %ecx
#
movl $1, %edx
#
int $0x80
#

Nmero mximo de caracteres a imprimir
Llamada al SO
movl $1, %eax
movl $0, %ebx
int $0x80
6.9..section .rodata
cad1:
.asciz "Por favor introduzca un entero decimal con signo: "
cad2:
.asciz "El valor del entero introducido es: %d\n"
.section
NUM:
SIGNO:
cadena:
.bss
.space 4
.space 4
.space 12
# Reserva espacio para almacena el entero

# Reserva espacio para almacena el signo
.section .text
.globl _start
_start:
# Muestra un mensaje solicitando que proporcione el valor del entero
movl $4, %eax
movl $1, %ebx
leal cad1, %ecx
int $0x80
# Llamada al SO
movl $3, %eax
movl $0, %ebx
leal cadena, %ecx
movl $49, %edx
int $0x80
# Llamada al SO
215
xorl %ecx, %ecx
xorl %eax, %eax
movl $10, %esi
# i=0
# A=0
# base decimal

cmpb $'-', %bl
je negativo
movl $1, SIGNO
cmpb $'+', %bl
jne for1
incl %ecx
jmp for1
# Lee el primer caracter de la cadena

# Si es '-' el nmero es negativo
negativo:
movl $-1, SIGNO
incl %ecx
for1:
cmpb $0, %bl
je ffor1
cmpb $10, %bl
je ffor1
subb $'0', %bl
movzx %bl, %ebx
mull %esi
addl %ebx, %eax
incl %ecx
jmp for1
ffor1:
imull SIGNO
movl %eax, NUM
#
#
#
#
El nmero se debe multiplicar por 1

Si no tiene el smbolo '+'
Comienza desde i=0
Si lo tiene, omite el primer caracter
# El nmero se debe multiplicar por -1

# Omitir el primer caracter
#
#
#
#
#
#
#
#
#
#
Carga un caracter. (cadena[i])

Sale del ciclo
Sale del ciclo
Obtiene el dgito entero que representa
Expande el entero a 32 bits (D)
A=A*10
A=A+D
Se repite para el siguiente caracter
# Multiplica por el signo

# Guarda el valor del entero
# Muestra el entero obtenido al usuario

pushl NUM
pushl $cad2
call printf
addl $8, %esp
movl $1, %eax
movl $0, %ebx
int $0x80
6.10.# Datos de prueba definidos en el segmento de datos equivalentes a

# scanf("Soy %s y me gusta la letra %c, &string, &char)
# A diferencia de scanf, toma en cuenta los espacios
216
.section
params:
format:
msj:
msj2:
.rodata
.long string, char
.asciz "Soy %s y me gusta la letra %c"
.asciz "Cadena de entrada: "
.asciz "Eres %s y te gusta la letra %c\n"
.section
char:
string:
cadena:
.bss
.space 10
.space 20
.space 100
# Variable char
# Variable string
.section .text
.globl _start
_start:
# Muestra un mensaje solicitando la cadena de entrada
movl $4, %eax
movl $1, %ebx
leal msj, %ecx
movl $msj2-msj, %edx
int $0x80
# Llamada al SO
movl $3, %eax
movl $0, %ebx
leal cadena, %ecx
movl $49, %edx
int $0x80
# Llamada al SO
# Ciclo para buscar especificadores de formato
xorl %esi, %esi
# i=0
xorl %edi, %edi
# j=0
xorl %ecx, %ecx
# reconocidos=0
buscar:
movb format(%esi), %al
# Carga un caracter de la cadena de formato
cmpb $'\0', %al
# Si es un caracter nulo
je fbuscar
# Alcanz el final de la cadena de formato
cmpb $'%', %al
# Si es un smbolo de porcentaje
je reconocer
# Debe reconocer una variable
cmpb cadena(%edi), %al
# De lo contrario, debe coincidir con
jne fbuscar
# la cadena proporcionada por el usuario
incl %esi
incl %edi
jmp buscar
reconocer:
incl %esi
movb format(%esi), %al
cmpb $'c', %al
je recon_c
cmpb $'s', %al
je recon_s
# Contina procesando la cadena de formato
# Carga el caracter que especifica

# el tipo de variable a reconocer
# Reconoce un caracter
# Reconoce una cadena
217
jmp error
recon_c:
movb
movl
movb
incl
cadena(%edi), %al
params(,%ecx,4),%edx
%al, (%edx)
%edx
incl %ecx
incl %esi
incl %edi
jmp buscar
recon_s:
incl %esi
movb format(%esi), %bl
movl params(,%ecx,4),%edx
ciclo:
movb cadena(%edi), %al
cmpb %al, %bl
je fciclo
movb %al, (%edx)
incl %edi
incl %edx
jmp ciclo
fciclo:
movb $0, (%edx)
incl %ecx
incl %esi
incl %edi
jmp buscar
# Especificador invlido
# Caracter reconocido
# Direccin destino
# Almacena el caracter
# reconocidos++
# Siguiente caracter de la cadena de formato

# Direccin destino
# Caracter reconocido
# Si coincide con la cadena de formato
# Almacena el caracter
# Siguiente caracter
# Cierra la cadena
# reconocidos++
fbuscar:
# Muestra las variables reconocidas por el 'scanf'
pushl char
pushl $string
pushl $msj2
call printf
addl $12, %esp
movl $1, %eax
movl $0, %ebx
int $0x80
6.11..section
fkeys:
CADP:
CADL:
ERROR:
.data
.byte 59,60,61,62,63,0,1,2,3,4,23,24
.asciz "\rSe ha presionado la tecla F%d\n"
.asciz "\rSe ha levantado la tecla F%d\n"
.asciz "Se ha denegado el permiso sobre los puertos del teclado\n"
218
.section .bss
SC:
.space 1
.section .text
.globl _start
_start:
movl $101, %eax
movl $0x60, %ebx
movl $5, %ecx
movl $1, %edx
# Obtener permiso
int $0x80
# Llamada al SO
testl
jne err
%eax,%eax
espera:
inb $0x64, %al
andb $1, %al
cmpb $0, %al
je espera

xorl %eax, %eax

inb $0x60,%al
cmpb $0x1C,%al
je fin
# Limpia eax
movb %al, SC
andb $0x80, %al
je pres
# Determina si la tecla fue

# presionada o levantada
lev:
# Carga la direccin de la cadena apropiada
leal CADL, %ebx

jmp continua
pres:
leal CADP, %ebx
continua:
andl $0x3F, SC
movb SC, %al
xorl %ecx, %ecx
ciclo:
cmpl $12, %ecx
jge espera
# Limpia el bit 7 del scancode
# Si no es una tecla de funcin

# la ignora
cmpb fkeys(%ecx), %al # De lo contario la muestra

je mostrar
incl %ecx
jmp ciclo
# Contina la bsqueda
219
mostrar:
incl %ecx
pushl %ecx
pushl %ebx
call printf
addl $8, %esp
jmp espera
# Muestra la tecla
err: pushl $ERROR

call printf
addl $4, %esp
# Libera los permisos

fin: movl $101, %eax
movl $0x60, %ebx
movl $5, %ecx
movl $0, %edx
int $0x80
sobre los puertos del teclado

# Liberar permiso
# Llamada al SO
movl $1, %eax

movl $0, %ebx
int $0x80
6.12..section
fkeys:
CAD:
CADP:
CADL:
ERROR:
.data
.byte 59,60,61,62,63,0,1,2,3,4,23,24
.asciz "\r
"
.asciz "\rSe ha presionado la tecla F%d\n"
.asciz "\rSe ha levantado la tecla F%d\n"
.section .bss
SC:
.space 1
LASTSC: .space 1

# Espacio para almacenar el scancode anterior
.section .text
.globl _start
_start:
movl $101, %eax
movl $0x60, %ebx
movl $5, %ecx
movl $1, %edx
# Obtener permiso
int $0x80
# Llamada al SO
testl
jne err
%eax,%eax
espera:
inb $0x64, %al
220
andb $1, %al
cmpb $0, %al
je espera
xorl %eax, %eax

inb $0x60,%al
cmpb $0x1C,%al
je fin
# Limpia eax
cmpb %al, LASTSC

je limpia
# Si el scancode es igual al anterior

# ignorar la tecla
movb %al, LASTSC

movb %al, SC
andb $0x80, %al
je pres
# Salvaguarda el scancode recibido

# Determina si la tecla fue
# presionada o levantada
# Carga la direccin de la cadena apropiada

lev:
leal CADL, %ebx
jmp continua
pres:
leal CADP, %ebx
continua:
andb $0x3F, SC
movb SC, %al
xorl %ecx, %ecx
ciclo:
cmpl $12, %ecx
jge espera
# Limpia el bit 7 del scancode
# Si no es una tecla de funcin

# ignorarla
cmpb fkeys(%ecx), %al # De lo contrario la muestra

je mostrar
incl %ecx
jmp ciclo
mostrar:
incl %ecx
pushl %ecx
pushl %ebx
call printf
addl $8, %esp
jmp espera
limpia:
pushl $CAD
call printf
addl $4, %esp
jmp espera
# Contina la bsqueda
# Muestra la tecla
# Limpia la pantalla (la lnea actual)
221
err: pushl $ERROR
call printf
addl $4, %esp
# Libera los permisos

movl $0x60, %ebx
movl $5, %ecx
movl $0, %edx
int $0x80
sobre los puertos del teclado

# Liberar permiso
# Llamada al SO
movl $1, %eax

movl $0, %ebx
int $0x80
6.13..section
ALT:
CTRL:
Q:
.data
.long 0
.long 0
.long 0
BLANCO:
MSJ:
ERROR:
.asciz "\r
\r"
.asciz "\rSe ha presionado la combinacin ALT+CTRL+Q\n"
.section .bss
SC:
.space 1
.section .text
.globl _start
_start:
movl $101, %eax
movl $0x60, %ebx
movl $5, %ecx
movl $1, %edx
# Obtener permiso
int $0x80
# Llamada al SO
testl
jne err
%eax,%eax
espera:
inb $0x64, %al
andb $1, %al
cmpb $0, %al
je espera
xorl %eax, %eax
inb $0x60,%al
cmpb $0x1C,%al

# Limpia eax
222
je fin
cmpb $0x1D,%al
je presiono_alt
cmpb $0x38,%al
je presiono_ctrl
cmpb $0x10,%al
je presiono_q
# Si se presion la tecla ALT
cmpb $0x9D,%al
je levanto_alt
cmpb $0xb8,%al
je levanto_ctrl
cmpb $0x90,%al
je levanto_q
# Si se levant la tecla ALT
# Si se presion la tecla CTRL

# Si se presion la tecla Q
# Si se levant la tecla CTRL

# Si se levant la tecla Q
# Si es cualquier otra tecla la misma es ignorada

jmp limpiar
presiono_alt:
movl $1, ALT
jmp comprueba
presiono_ctrl:
movl $1, CTRL
jmp comprueba
presiono_q:
movl $1, Q
comprueba:
movl ALT, %eax
andl CTRL, %eax
andl Q, %eax
cmpl $0, %eax
je limpiar
# Enciende la bandera ALT

# Comprueba el estado de las banderas
# Enciende la bandera CTRL
# Enciende la bandera Q
# Hace un AND entre las tres banderas
# Si no se cumple la combinacin
# Espera por otra tecla
# Si se cumple la combinacin, notifica al usuario

pushl $MSJ
call printf
addl $4, %esp
jmp espera
levanto_alt:
movl $0, ALT
jmp espera
levanto_ctrl:
movl $0, CTRL
jmp espera
levanto_q:
movl $0, Q
jmp espera
limpiar:
movl $4, %eax
# Apaga la bandera ALT

# Apaga la bandera CTRL
# Apaga la bandera Q
223
movl $1, %ebx
leal BLANCO, %ecx
movl $MSJ-BLANCO, %edx
int $0x80
jmp espera
err: pushl $ERROR
call printf
addl $4, %esp
#
#
#
#

Llamada al SO
# Libera los permisos sobre los puertos del teclado

movl $0x60, %ebx
movl $5, %ecx
movl $0, %edx
# Liberar permiso
int $0x80
# Llamada al SO
movl $1, %eax
movl $0, %ebx
int $0x80
6.14..section
TABLE:
ACUM:
AUX:
MSJ:
OPER:
SALTO:
ERROR:
.data
.byte 0b000, 0b001, 0b100, 0b101, 0b010,0b011,0b110,0b111
.byte 0, '\n'
# Acumulador de la calculadora binaria
.byte 0, '\n'
# Operando proporcionado por el usuario
.asciz "\r
\r"
.ascii "
\r"
.byte '\n'
.bss
SC: .space 1
.section .text
.globl _start
_start:
movl $101, %eax
movl $0x60, %ebx
movl $5, %ecx
movl $1, %edx
# Obtener permiso
int $0x80
# Llamada al SO
testl
jne err
%eax,%eax
xorl %esi, %esi
# Caracteres reconocidos
jmp mostrar
# Coloca las luces del teclado en 000
224
espera:
inb $0x64, %al
andb $1, %al
cmpb $0, %al
je espera
xorl %eax, %eax
inb $0x60,%al
cmpb $0x1C,%al
je fin
movb %al, SC
andb $0x80, SC
jne espera
cmpl $0, %esi
jne bit
operacion:
cmpb $78,%al
je presiono_or
cmpb $55,%al
je presiono_and

# Limpia eax
# Las posiciones 1, 2 y 3 son bits
# Si se presion la tecla +
# Si se presion la tecla *

jmp imprime
bit:
cmpb $82,%al
je presiono_0
cmpb $79,%al
je presiono_1
# Si se presion la tecla 0
# Si se presion la tecla 1

jmp imprime
presiono_0:
movb $'0', OPER(%esi)
shlb $1, AUX
incl %esi
jmp comprueba
presiono_1:
movb $'1', OPER(%esi)
shlb $1, AUX
incb AUX
incl %esi
jmp comprueba
presiono_or:
movb $'+', OPER
incl %esi
jmp comprueba
presiono_and:
# AUX = AUX << 1

# AUX = AUX << 1

# AUX = AUX + 1
225
movb $'*', OPER
incl %esi
comprueba:
cmpl $4, %esi
je opera
imprime:
movl $4, %eax
movl $1, %ebx
leal MSJ, %ecx
movl $SALTO-MSJ, %edx
int $0x80
jmp espera
opera:
movb AUX, %al
cmpb $'+', OPER
je ejecuta_or
ejecuta_and:
andb %al, ACUM
jmp seguir
# Si se leyeron los 3 bits

# Efecta la operacin
#
#
#
#
#

Llamada al SO
# Carga el operador (+ o *)
# Si es +
# Se ejecuta un OR
# ACUM = ACUM and AUX
ejecuta_or:
orb %al, ACUM
# ACUM = ACUM or AUX
seguir:
movl $4, %eax
movl $1, %ebx
leal MSJ, %ecx
movl $ERROR-MSJ, %edx
int $0x80
#
#
#
#
#
mostrar:
inb $0x64, %al
andb $2, %al
jne mostrar
# Lee el registro de control

movb
outb
movb
leal
xlat
outb
$0xED, %al
%al,$0x60
ACUM, %al
TABLE, %ebx
%al,$0x60
#
#
#
#
#
#

Llamada al SO
Comando 0xED: Luces del teclado

Enva el comando
Carga el digito octal
Direccin de la tabla de traduccin
Traduce al patrn de las luces
Enva el patrn
# Limpia el mensaje mostrado al usuario y reinicia las variables

xorl %esi, %esi
movb $0, AUX
movb $' ', OPER
movb $' ', OPER+1
movb $' ', OPER+2
movb $' ', OPER+3
226
jmp espera
err: pushl $ERROR
call printf
addl $4, %esp
# Libera los permisos sobre los puertos del teclado

movl $0x60, %ebx
movl $5, %ecx
movl $0, %edx
# Liberar permiso
int $0x80
# Llamada al SO
movl $1, %eax
movl $0, %ebx
int $0x80
Captulo 7
7.1# Programa que imprime Hola horizontal
.section .data
salida:
.asciz"Hola\t"
leenum:
.asciz"%d"
salta: .asciz"\n"
numero:
.long 0
.section .text
.globl _start
_start:
leal numero, %eax
pushl %eax
pushl $leenum
call scanf
ciclo:
cmpl $0, numero
je fin
pushl $salida
call printf
decl numero
jmp ciclo
fin:
pushl $salta
call printf
movl $1, %eax
movl $0, %ebx
int $0x80
# lee numero
7.2# Programa que imprime Hola vertical

.section .data
salida:
.asciz"Hola\n"
leenum:
.asciz"%d"
227
numero:
.long 0
.section .text
.globl _start
_start:
leal numero, %eax
pushl %eax
pushl $leenum
call scanf
ciclo:
cmpl $0, numero
je fin
pushl $salida
call printf
decl numero
jmp ciclo
fin:
movl $1, %eax
movl $0, %ebx
int $0x80
7.3# Programa que calcula x elevado a la y

.section .data
mensaje0:
.asciz"Programa que calcula x (base) elevado a la y (potencia)\n"
leedato:
.asciz"%d"
mensaje1:
.asciz"introduzca la base: \t"
mensaje2:
.asciz"introduzca la potencia: \t"
base:
.asciz"%d\t"
result:
.asciz"%d\t elevado a la %d\t es: %d\n"
x:
.long 0
y:
.long 0
.section .text
.globl _start
_start:
pushl $mensaje0
call printf
pushl $mensaje1
call printf
leal x, %eax
pushl %eax
pushl $leedato
call scanf
pushl $mensaje2
call printf
leal y, %eax
pushl %eax
pushl $leedato
call scanf
# Mensaje inicial
# Introducir dato de la base
# Leer base
# Introducir la potencia
# Leer potencia
# %eax se usa para calcular el

resultado
xorl %eax, %eax
cmpl $0, x
jz fin
movl $1, %eax
# %eax = 0
# compara %eax con 0
# si x=0 resultado=0
# %eax=1
228
mult:
fin:
movl y, %ecx
# %ecx=y tiene la potencia
cmpl $0, %ecx
# compara y con 0
je fin
# si y=0 termina
imull x, %eax
# multiplica la base y veces
decl %ecx
# decrementa potencia
jmp mult
# regresa al inicio del ciclo
pushl %eax
pushl y
pushl x
pushl $result
call printf
movl $1, %eax
movl $0, %ebx
int $0x80
7.4# Programa que calcula el monto a pagar a un trabajador semanal

.section .data
mensaje:
.asciz"Programa que calcula el monto a pagar a un trabajador\n"
mensaj2:
.asciz"Los trabajadores se clasifican como:\n"
clas1:
.asciz"Trabajador no calificado
[1]\n"
clas2:
.asciz"Trabajador calificado
[2]\n"
clas3:
.asciz"Trabajador calificado con experiencia
[3]\n\n"
trabaj:
.asciz"Introduzca la clasificacion del trabajador:\t"
ttrab:
.long 0
leer:
.asciz"Introduzca la cantidad de horas trabajadas en la semana:\t"
salta:
.asciz"\n"
entrada:
.asciz"%d"
salida:
.asciz"El monto a pagar es: %d\n"
horas:
.long 0
basico:
.long 0
medio:
.long 0
doble:
.long 0
.equ
sueldo1, 3250
.equ
sueldo2, 4500
.equ
sueldo3, 4850
.section .text
.globl _start
_start:
pushl $mensaje
call printf
pushl $mensaj2
call printf
pushl $clas1
call printf
pushl $clas2
call printf
pushl $clas3
call printf
pushl $trabaj
call printf
pushl $ttrab
# muestra mensajes iniciales
229
pushl $entrada
call scanf
addl $28, %esp
pushl $leer
call printf
pushl $horas
pushl $entrada
call scanf
addl $16, %esp
# lee tipo de trabajador
# lee cantidad de horas trabajadas
pushl $salta
call printf
addl $4, %esp
movl horas, %eax
cmpl $40, %eax
jle hasta40
movl $40, basico
subl $40, %eax
cmpl $20, %eax
jle hasta60
movl $20, medio
subl $20, %eax
movl %eax, doble
jmp seguir
movl %eax, basico
jmp seguir
movl %eax, medio
hasta40:
hasta60:
#
#
#
#
#
#
#
#
#
compara horas con 40

si <= salta a hasta 40
si > basico=40
y resta 40 de horas
compara resto con 20
si <= salta a hasta60
si > medio=20
resta las 20 horas
doble=resto de las horas (mas de 60)
# cuando <40 horas, basico=cant.horas

#
#
#
#
#
cuando horas esta entre 40 y 60

medio=cant horas>40
revisa si es trabajador no calificado
si no, salta a califica
trab no calificado %edx=3250
seguir:
cmpl $1, ttrab

jne califica
movl $sueldo1, %edx
jmp calcula
califica:
cmpl $2, ttrab

jne califica2
califica2:
movl $sueldo3, %edx # trab. calificado con exp. %edx=4850
calcula:
movl %edx, %edi

movl %edx, %esi
sarl $1, %edi
addl %edx, %edi
shll $1, %esi
imull basico, %edx
imull medio, %edi
imull doble, %esi
addl %edi, %edx
addl %esi, %edx
# revisa si es trab. calificado

# si es trabajador calificado con
# experiencia salta a califica2
movl $sueldo2, %edx # trab. calificado %edx=4500
jmp calcula
#
#
#
#
#
#
#
#
#
%edi para calcular sueldo y medio

%esi para calcular doble sueldo
sueldo/2
%edi=sueldo*1.5
sueldo *2
horas a sueldo basico por sueldo
horas a sueldo medio por sueldo y 1/2
horas a doble sueldo por doble sueldo
suma de las tres partes del calculo
230
pushl %edx
pushl $salida
call printf
# muestra el monto por pantalla
movl $1, %eax

xorl %ebx, %ebx
int $0x80
Captulo 8
8.1# Programa que suma los elementos de un arreglo de n enteros
.section .data
lee:
.asciz"Introduzca el numero de elementos del arreglo: \n"
n:
.long 0
leenum:
.asciz"Introduzca a[ %d ]: \t"
leen:
.asciz"%d"
x:
.long 0
resul:
.asciz"La suma de los elementos del arreglo es:
%d\n"
.section .bss
arreglo:
.space 400
.section .text
.globl _start
_start:
pushl $lee
call printf
leal n, %eax
pushl %eax
pushl $leen
call scanf
xorl %esi, %esi
xorl %edi, %edi
leesum:
cmpl n, %esi
je fin
pushl %esi
pushl $leenum
call printf
leal x, %ebx
pushl %ebx
pushl $leen
call scanf
addl x, %edi
incl %esi
jmp leesum
fin:
pushl %edi
pushl $resul
call printf
movl $1, %eax
movl $0, %ebx
int $0x80
# Imprime mensaje inicial
#
#
#
#
#
lee n (numero de elementos del arreglo)

%esi es el indice del arreglo (i)
%edi es el acumulador
compara i con n
cuando i=n salta a fin
# imprime mensaje para lectura de a[i]
#
#
#
#
lee a[i]
suma a[i] a %edi
incrementa %esi (i)
vuelve a leer siguiente elemento
# muestra por pantalla la suma

# fin del programa
231
8.2# Programa que calcula el promedio de los numeros de un arreglo de
# 20 enteros
.section .data
leenum:
leen:
.asciz"%d"
x:
.long 0
resul:
.asciz"El promedio de los elementos del arreglo es: %d\n"
.section .bss
arreglo:
.space 400
.section .text
.globl _start
_start:
leearr:
fin:
xorl %esi, %esi

xorl %edi, %edi
cmpl $20, %esi
je fin
pushl %esi
pushl $leenum
call printf
leal x, %ebx
pushl %ebx
pushl $leen
call scanf
addl x, %edi
incl %esi
jmp leearr
movl $20, %ebx
movl %edi, %eax
cltd
idivl %ebx
pushl %eax
pushl $resul
call printf
movl $1, %eax
movl $0, %ebx
int $0x80
#
#
#
#
%esi es el indice (i)

%edi suma elementos del arreglo
compara indice con 20
si indice=20 salta a fin
# imprime mensaje para leer a[i]
#
#
#
#
#
#
#
#
lee a[i]
suma a[i] en %edi
incrementa el indice (i)
vuelve a leer siguiente a[i]
%ebx=20 (tamano del arreglo)
%eax=suma de los elementos del arreglo
expande %eax
divide %eax/20
# muestra el promedio por pantalla

# fin del programa
8.3# Programa que calcula la cantidad de numeros pares en un arreglo de n enteros

.section .data
lee:
n:
.long 0
leenum:
leen:
.asciz"%d"
x:
.long 0
resul:
.asciz"La cantidad de pares en el arreglo es: %d\n"
.section .bss
arreglo:
.space 400
232
.section .text
.globl _start
_start:
pushl $lee
call printf
leal n, %eax
pushl %eax
pushl $leen
call scanf
xorl %esi, %esi
xorl %edi, %edi
leearr:
cmpl n, %esi
je fin
pushl %esi
pushl $leenum
call printf
leal x, %ebx
pushl %ebx
pushl $leen
call scanf
movl x, %eax
cltd
movl $2, %ecx
idivl %ecx
cmpl $0, %edx
jne nopar
incl %edi
nopar:
incl %esi
jmp leearr
fin:
pushl %edi
pushl $resul
call printf
movl $1, %eax
movl $0, %ebx
int $0x80
#
#
#
#
#
lee n (numeros de elementos del arreglo)

%edi acumula cantidad de pares
compara i con n
# lee a[i]
#
#
#
#
#
#
#
verifica si el numero es par

divide a[i]/2
compara el resto con 0
si resto es diferente de 0 salta a nopar
si el resto es 0 incrementa %edi
incrementa i
# muestra el resultado por pantalla

# fin del programa
8.4# Programa que calcula la suma de los pares de un arreglo de n enteros

.section .data
lee:
n:
.long 0
leenum:
leen:
.asciz"%d"
x:
.long 0
resul: .asciz"La suma de los numeros pares del arreglo es: %d\n"
.section .bss
arreglo:
.space 400
.section .text
.globl _start
_start:
pushl $lee
233
leearr:
nopar:
fin:
call printf
leal n, %eax
pushl %eax
pushl $leen
call scanf
xorl %esi, %esi
xorl %edi, %edi
cmpl n, %esi
je fin
pushl %esi
pushl $leenum
call printf
leal x, %ebx
pushl %ebx
pushl $leen
call scanf
movl x, %eax
cltd
movl $2, %ecx
idivl %ecx
cmpl $0, %edx
jne nopar
addl x,%edi
incl %esi
jmp leearr
pushl %edi
pushl $resul
call printf
movl $1, %eax
movl $0, %ebx
int $0x80
#
#
#
#
#
lee n (numeros de elementos del arreglo)

%edi suma los pares
compara i con n
# lee a[i]
#
#
#
#
#
#
#
verifica si el numero es par

divide a[i]/2
compara el resto con 0
si resto es diferente de 0 salta a nopar
si el resto es 0 suma a[i] a %edi
incrementa i

# fin del programa
8.5# Programa que lee un arreglo de 12 enteros, determina cul es el mayor e

indica en qu posicin se encuentra
.section .data
encab:
.asciz"Este programa lee un arreglo de enteros, determina el mayor
e indica en que posicion se encuentra\n"
pidenum:
leenum:
.asciz"%d"
num:
.long 0
impmayor:
.asciz"El numero mayor presente en el arreglo es:
%d\n"
impposic:
.asciz"Y se encuentra en la posicion:
%d\n"
tamano:
.long 12
.section .bss
arreglo:
.space 48
.section .text
.globl _start
_start:
pushl $encab
call printf
addl $4, %esp
# imprime el ancabezado
234
# Leemos el arreglo
xorl %esi, %esi
# %esi es el indice (i)
leearr:
cmpl tamano, %esi
# compara indice con tamano (12)
je finlee
# si indice=12 salta a fin de lectura
pushl %esi
pushl $pidenum
call printf
# imprime mensaje para leer arreglo[i]
leal num, %ebx
pushl %ebx
pushl $leenum
call scanf
# lee arreglo[i]
movl num, %eax
# transfiere num a %eax temporalmente
movl %eax, arreglo(,%esi,4)
# guarda num en arreglo
incl %esi
# incrementa el indice (i)
jmp leearr
# vuelve a leer siguiente a[i]
# Ahora determinamos el mayor y su posicion, %eax va a contener el mayor y %ebx
la posicion
finlee:
xorl %esi, %esi
# Inicia el indice
movl arreglo(,%esi,4), %ecx
# lee primer num
movl %ecx, %eax
# lo guarda como mayor
movl %esi, %ebx
# guarda su posicion
incl %esi
# incrementa indice
leesig:
movl arreglo(,%esi,4), %ecx
# lee siguiente numero
cmpl %eax, %ecx
# compara nuevo num con mayor anterior
jle noreemplz
# si no es mayor va a noreemplz
movl %ecx, %eax
# si es mayor reemplaza num
movl %esi, %ebx
# y la posicion
noreemplz:
incl %esi
cmpl tamano,%esi
# verifica fin del arreglo
je fincomp
# si indice igual a 12 termina
jmp leesig
# si indice menor que 12 lee siguiente
fincomp:
pushl %eax
# imprime el mayor
pushl $impmayor
call printf
pushl %ebx
# imprime la posicion
pushl $impposic
call printf
movl $1, %eax
# fin del programa
movl $0, %ebx
int $0x80
Captulo 9
9.1# Programa que calcula el promedio de los pares
.section .data
mensaje:
.asciz"Programa que lee un arreglo a de 20 enteros y calcula\n"
mensaj2:
.asciz"el promedio de los numeros pares presentes en el arreglo\n"
leernum:
.asciz"Introduzca a[%d]:\t"
entrada:
.asciz"%d"
salida:
.asciz"Hay %d numeros pares y su promedio es: %d\n"
salto:
.asciz"\n\n"
235
num:
pares:
.long 0
.long 0, 0
.section .bss
a:
.space 80
# guarda numeros de pares y su sumatoria

# en parea[0]=cantidad de pares y en
# pares[1]=suma de los pares
# arreglo a de 20 numeros enteros
.section .text
.globl _start
_start:
pushl $mensaje
# muestra mensaje inicial
call printf
pushl $mensaj2
call printf
xorl %esi, %esi
leearr:
cmpl $20, %esi
# ciclo que lee los elementos del arreglo
je finlee
pushl %esi
pushl $leernum
call printf
pushl $num
pushl $entrada
call scanf
movl num, %eax
movl %eax, a(,%esi,4)
incl %esi
jmp leearr
finlee:
pushl $a
pushl $pares
call par
#
#
#
#
dir inicial del arreglo

dir pares
retorna cantidad de pares y la
sumatoria de los pares
addl $8, %esp

imprime:
pushl pares
leal pares, %eax
addl $4, %eax
movl (%eax), %ecx
pushl %ecx
pushl $salida
call printf
# muestra por pantalla cantidad de pares

# y su sumatoria

xorl %ebx, %ebx
int $0x80
# procedimiento que verifica cuantos numeros son pares y calcula su suma
par:
pushl %ebp
movl %esp, %ebp
movl 8(%ebp), %ebx # dir pares
movl 12(%ebp),%esi # dir a
xorl %ecx, %ecx
movl $2, %edi
236
verifica:
finverif:
cmpl $20, %ecx

# compara el indice con tamano de a
je finverif
movl (%esi, %ecx, 4), %eax
incl %ecx
pushl %eax
# guarda valor leido
cltd
idivl %edi
# divide valor entre 2
cmpl $0, %edx
# compara el resto con 0
jne verifica
# si resto no es 0 no es par
incl (%ebx)
# si es par incrementa pares[0]
popl %eax
# recupera valor ledo
addl %eax, 4(%ebx)
# lo suma a pares[1]
jmp verifica
leave
ret
9.2# Programa que calcula la suma de los numeros mayores que 10 y menores que 100
presentes en un arreglo de enteros
.section .data
mensaje:
.asciz"Programa que lee un arreglo de n enteros y calcula\n"
mensaj2:
.asciz"la suma de los numeros entre 10 y 100\n"
leertam:
.asciz"Introduzca el numero de elementos del arreglo:\t"
entrada:
.asciz"%d"
leenum:
.asciz"Introduzca los valores del arreglo\n"
salida:
.asciz"La suma de los numeros entre 10 y 100 es: %d\n"
salto: .asciz"\n\n"
n:
num:
.long 0
.long 0
.section .bss
a:
.space 400
.section .text
.globl _start
_start:
pushl $mensaje
call printf
pushl $mensaj2
call printf
pushl $leertam
call printf
pushl $n
pushl $entrada
call scanf
pushl $salto
call printf
pushl $leenum
call printf
addl $24, %esp
# tamano del arreglo
# arreglo a
# mensaje inicial
# solicita tamano del arreglo
# lee n (tamano del arreglo)
# solicita al usuario que introduzca los

# valores del arreglo
xorl %esi, %esi
237
leearr:
cmpl n, %esi
# ciclo que lee los valores del arreglo
je finlee
pushl $num
pushl $entrada
call scanf
addl $8, %esp
movl num, %eax
movl %eax, a(,%esi,4)
incl %esi
jmp leearr
finlee:
pushl $a
# dir inicial del arreglo
pushl n
# tamano del arreglo
call suma
# la funcion suma retorna la suma de
addl $8, %esp # los numeros entre 10 y 100
imprime:
pushl %eax
pushl $salida
call printf
movl $1, %eax

xorl %ebx, %ebx
int $0x80
# fin del programa
# funcion que retorna la sumatoria de los

# menores que 100
suma:
pushl %ebp
movl %esp, %ebp
movl 8(%ebp), %ebx
#
movl 12(%ebp),%esi
#
xorl %eax, %eax
#
xorl %ecx, %ecx
#
acumul:
cmpl %ebx, %ecx
#
je finacum
#
movl (%esi, %ecx, 4), %edx #
incl %ecx
#
cmpl $10, %edx
#
jl acumul
#
cmpl $100, %edx
#
jg acumul
#
addl %edx, %eax
#
jmp acumul
#
finacum:
leave
ret
numeros mayores que 10 y
tamano del arreglo

dir arreglo
acumulador para la suma
indice para arreglo
compara indice con tamano
al leer todos termina
lee valor
incrementa indice
compara valor leido con 10
si <10 lee siguiente
si >=10 compara con 100
si >100 lee siguiente
si >=10 y <=100 lo suma
lee siguiente
9.3# Solucin 1:
# Programa que calcula el factorial de un nmero de manera iterativa
.section .rodata
CAD:
.asciz "Por favor indique un nmero: "
CADF: .asciz "%d"
CADR: .asciz "El factorial del nmero es: %d\n"
238
.section .bss
NUM:
.space 4
.section .text
.globl _start
_start:
pushl $CAD
call printf
addl $4, %esp
# Pedimos el nmero
pushl $NUM
pushl $CADF
call scanf
addl $8, %esp
# Lo almacenamos en NUM
pushl NUM
call fact
addl $4, %esp
# Calculamos el factorial
pushl %eax
pushl $CADR
call printf
addl $8, %esp
# Mostramos el resultado
movl $1, %eax

movl $0, %ebx
int $0x80
# Terminamos el programa
# Procedimiento iterativo para calcular el factorial de un nmero

.globl fact
fact:
pushl %ebp
movl %esp, %ebp
pushl %ebx
pushl %esi
pushl %edi
for:
# Salvaguardamos el marco de pila anterior

# Actualizamos el marco de pila
# Salvaguardar los registros responsabilidad del invocado
movl $1, %eax
# El factorial de 0 es 1
cmpl $1, 8(%ebp)

jle epilogo
imull 8(%ebp)
decl 8(%ebp)
jmp for
# Si N<=1 terminamos el ciclo
epilogo:
popl %edi
popl %esi
popl %ebx
leave
# Sino, FACT = FACT * N

# N-# Repetimos el ciclo
# Restauramos los registros salvaguardados
239
ret
# Devolver el control al invocador
# Solucin 2:
# Programa que calcula el factorial de un nmero de manera recursiva
.section .rodata
CAD:
.asciz "Por favor indique un nmero: "
CADF: .asciz "%d"
CADR: .asciz "El factorial del nmero es: %d\n"
.section .bss
NUM:
.space 4
.section .text
.globl _start
_start:
pushl $CAD
call printf
addl $4, %esp
# Pedimos el nmero
pushl $NUM
pushl $CADF
call scanf
addl $8, %esp
# Lo almacenamos en NUM
pushl NUM
call fact
addl $4, %esp
# Calculamos el factorial
pushl %eax
pushl $CADR
call printf
addl $8, %esp
# Mostramos el resultado
movl $1, %eax

movl $0, %ebx
int $0x80
# Terminamos el programa
# Procedimiento recursivo para calcular el factorial de un nmero

.globl fact
fact:
pushl %ebp
movl %esp, %ebp
pushl %ebx
pushl %esi
pushl %edi
# Salvaguardamos el marco de pila anterior

# Actualizamos el marco de pila
# Salvaguardar los registros responsabilidad del invocado
cmpl $1, 8(%ebp)

jle base
# Si N<=1 caso base, FACT = 1
240
movl 8(%ebp), %edx
decl %edx
pushl %edx
call fact
addl $4, %esp
imull 8(%ebp)
jmp epilogo
base:
# Sino, FACT = N * FACT(N-1)
movl $1, %eax
epilogo:
popl %edi
popl %esi
popl %ebx
leave
ret
# Restauramos los registros salvaguardados

# Devolver el control al invocador
9.4.# Programa que genera la serie de Fibonacci

.section .data
mensaje:
.asciz"Programa que muestra por pantalla la serie de Fibonacci
hasta n numeros\n"
leern:
.asciz"Introduzca n:\t"
error:
.asciz"El n es cero, por lo tanto no se muestra la serie\n"
entrada:
.asciz"%d"
salida:
.asciz"La serie de Fibonacci para los %d primeros numeros es:\n"
salid2:
.asciz"%d\t"
salto:
.asciz"\n\n"
n:
.long 0
.section .bss
arrfib:
.space 400
.section .text
.globl _start
_start:
pushl $mensaje
call printf
pushl $leern
call printf
pushl $n
pushl $entrada
call scanf
mayor0:
# arrfib arreglo para guardar la serie
# muestra mensaje inicial
# lee n, cantidad de elementos de la

# serie a mostrar
addl $16, %esp

cmpl $0, n
# compara n con 0
jg mayor0
pushl $error # si n=0 se muestra el mensaje de error
call printf
jmp fin
pushl n
# pasa el numero n por parametro
pushl $arrfib
# pasa dir del arreglo arrfib por parametro
241
call fib
# llama a fib para generar la serie
addl $8, %esp
pushl n
pushl $salida
call printf
# muestra mensaje de salida
addl $8, %esp
xorl %edi, %edi
movl n, %esi
cmpl %esi, %edi
# compara indice con n
je fin
movl arrfib(,%edi,4), %eax
incl %edi
pushl %eax
# muestra la serie por pantalla
pushl $salid2
call printf
addl $8, %esp
jmp serie
pushl $salto
# imprime un salto de linea
call printf
movl $1, %eax
# fin del programa
xorl %ebx, %ebx
int $0x80
serie:
fin:
# Procedimiento que genera la serie de Fibonacci

fib:
pushl %ebp
movl %esp, %ebp
movl 8(%ebp), %edx
movl 12(%ebp), %ebx
xorl %ecx, %ecx
movl $1, (%edx, %ecx, 4)
cmpl $1, %ebx
je finfib
incl %ecx
movl $1, (%edx, %ecx, 4)
incl %ecx
movl $1, %edi
movl $1, %esi
cmpl %ebx, %ecx
je finfib
movl %edi, %eax
addl %esi, %eax
movl %eax, (%edx, %ecx, 4)
incl %ecx
movl %esi, %edi
movl %eax, %esi
jmp ciclo
leave
ret
ciclo:
finfib:
#
#
#
#
%edx=dir arreglo
%ebx=n (n>0)
%ecx=0 indice del arreglo
arrfib[0]=1
# si n=1 salta a finfib

# arrfib[1]=1
# %edi=1 (arrfib[0])
# %esi=1 (arrfib[1])
# compara indice con n
#
#
#
#
#
suma dos valores anteriores

agrega siguiente elemento
incrementa indice
actualiza registro temporal
actualiza registro temporal
Capitulo 10
10.1.# Este programa solicita al usuario una contrasena y la compara
242
# con la cadena de caracteres declarada en la seccion de datos,
# indica si la contrasena es valida o no
.section .data
contras:
.asciz"clave1234"
largo:
.long 9
escriba:
.asciz"Por favor introduzca la contrasena: "
format1:
.asciz"%s"
resultig:
.asciz"La contrasena es correcta\n"
resultno:
.asciz"La contrasena es incorrecta\n"
.section .bss
clave:
.space 9
.section .text
.globl _start
_start:
pushl $escriba
call printf
addl $8, %esp
leal clave, %edx
pushl %edx
pushl $format1
call scanf
cld
leal contras, %edi
leal clave, %esi
movl largo, %ecx
repe cmpsb
jne error
pushl $resultig
call printf
jmp fin
error: pushl $resultno
call printf
fin:
movl $1, %eax
movl $0, %ebx
int $0x80
# limpia la bandera DF
# actualiza %edi con inicio de la contrasena
# actualiza %esi con inicio de la clave leida
# actualiza %ecx con el numero de caracteres
# compara 1 caracter a la vez
# si es incorrecta va a error
# si es correcta imprime el mensaje correspondiente
# imprime mensaje de error

# fin del programa
10.2.# Este programa solicita una cadena de caracteres y revisa la

# existencia del caracter "-" . Si esta presenta indica la ,
# posicion de la primera aparicion del caracter
.section .data
mensaj1:
.asciz"Este programa revisa la existencia del caracter '-' en
una cadena\n"
caracter:
.asciz"-"
escriba:
.asciz"Por favor introduzca la cadena: "
format1:
.asciz"%s"
salida1:
.asciz"El caracter '-' no esta presente en la cadena\n"
salida2:
.asciz"El caracter '-' se encuentra en la posicion %d de
la cadena\n"
largo:
.long 0
.section .bss
243
cadena:
.space 100
.section .text
.globl _start
_start:
pushl $mensaj1
call printf
pushl $escriba
call printf
addl $8, %esp
leal cadena, %edx
pushl %edx
pushl $format1
call scanf
# lee la cadena
cld
# limpia la bandera DF
leal cadena, %edi
# actualiza %edi con inicio de la cadena leida
# determinar el tamano de la cadena leida
movl $100, %ecx
movb $0, %al
repne scasb
jne fin
# caso de excepcion
subl $100, %ecx
neg %ecx
decl %ecx
movl %ecx, largo
# comparar la cadena leida con el caracter
leal cadena, %edi
leal caracter, %esi
# actualiza %esi con el inicio del caracter
lodsb
repne scasb
jne noesta
subl largo, %ecx
neg %ecx
pushl %ecx
pushl $salida2
call printf
jmp fin
noesta:
pushl $salida1
call printf
fin:
movl $1, %eax

movl $0, %ebx
int $0x80
# fin del programa
10.3.# Este programa cuenta el numero de ocurrencias del caracter 'y'

# dentro de una cadena de caracteres
.section .data
mensaj1:
.asciz"Este programa cuenta el numero de ocurrencias del caracter
'y'\n"
leecad:
.asciz"Por favor introduzca la cadena: "
y:
.asciz"y"
format1:
.asciz"%s"
244
salida:
cadena\n"
.asciz"El caracter
.section .bss
cadena:
esta presente %d veces en la
.space 100
.section .text
.globl _start
_start:
pushl $mensaj1
call printf
pushl $leecad
call printf
addl $8, %esp
leal cadena, %edx
pushl %edx
pushl $format1
call scanf
addl $8, %esp
cld
# calcula largo de la cadena
leal cadena, %edi
movl $100, %ecx
movb $0, %al
repne scasb
jne fin
subl $100, %ecx
neg %ecx
decl %ecx
xorl %ebx, %ebx
leal cadena, %edi
leal y, %esi
lodsb
revisa:
repne scasb
jne termina
incl %ebx
jmp revisa
termina:
pushl %ebx
pushl $salida
call printf
fin:
'y'
movl $1, %eax

movl $0, %ebx
int $0x80
# lee la cadena
# caso de excepcion
# %ecx tiene el largo de la cadena
# carga y en %al
# fin del programa
Capitulo 11
11.1.# Programa que calcula la nota
.section .data
mensaje: .asciz"Programa que calcula la nota definitiva, teniendo como entrada 6
notas parciales.\n"
245
mensaje2:
.asciz"Muestra la nota final con decimales y la definitiva
redondeada\n"
entrada1:
.asciz"Introduzca las notas:\n"
nota1:
.asciz"Nota 1 (valor: 20%): "
nota2:
nota3:
nota4:
nota5:
nota6:
leenota: .asciz"%d"
salto:
.asciz"\n"
n1:
.long 0
n2:
.long 0
n3:
.long 0
n4:
.long 0
n5:
.long 0
n6:
.long 0
porc20:
.float .20
porc15:
.float .15
porc25:
.float .25
porc10:
.float .10
porc5:
.float .05
result2: .quad 0
forma1:
.asciz"Nota final: %.2f\n"
# formato de salida con dos
# decimales
forma2:
.asciz"Nota definitiva: %d\n" # formato de salida entero
redondeo:
.byte 0x7f, 0x0b
# para actualizar el
# redondeo hacia arriba
.section .text
.globl _start
_start:
pushl $mensaje
call printf
pushl $mensaje2
call printf
pushl $salto
call printf
pushl $entrada1
call printf
addl $16, %esp
# mensaje inicial
pushl $nota1
call printf
pushl $n1
pushl $leenota
call scanf
pushl $salto
call printf
addl $16, %esp
# lee nota 1
pushl $nota2
call printf
# lee nota 2
246
pushl $n2
pushl $leenota
call scanf
pushl $salto
call printf
addl $16, %esp
pushl $nota3
call printf
pushl $n3
pushl $leenota
call scanf
pushl $salto
call printf
addl $16, %esp
# lee nota 3
pushl $nota4
call printf
pushl $n4
pushl $leenota
call scanf
pushl $salto
call printf
addl $16, %esp
lee nota 4
pushl $nota5
call printf
pushl $n5
pushl $leenota
call scanf
pushl $salto
call printf
addl $16, %esp
lee nota 5
pushl $nota6
call printf
pushl $n6
pushl $leenota
call scanf
pushl $salto
call printf
addl $16, %esp
# lee nota 6
finit
fldcw
filds
fmuls
filds
fmuls
filds
fmuls
filds
fmuls
redondeo
n1
porc20
n2
porc15
n3
porc25
n4
porc10
#
#
#
#
#
#
#
#
# inicializa FPU
# cambia a redondeo hacia arriba
carga nota 1
multiplica nota 1 * 20%
carga nota 2
carga nota 3
carga nota 4
247
filds
fmuls
filds
fmuls
faddp
faddp
faddp
faddp
faddp
n5
porc25
n6
porc5
# carga nota 5
# multiplica nota 5 * 25%
# carga nota 6
# multiplica nota 6 * 5%
# suma los valores de las notas
fistl result2
# guarda el resultado
subl $8, %esp

fstpl (%esp)
pushl $forma1
call printf
addl $12, %esp
# muestra el resultado con 2 decimales
pushl result2
pushl $forma2
call printf
addl $8, %esp
# muestra el resultado redondeado
movl $1, %eax

xorl %ebx, %ebx
int $0x80
# fin del programa
11.2..section .data
mensaje: .asciz"Programa que convierte grados Centigrados a Fahrenheit\n"
introd:
.asciz"Introduzca los grados Centigrados: "
leegrado:
.asciz"%f"
salto:
.asciz"\n"
grados:
.float 0.0
nueve:
.float 9.0
cinco:
.float 5.0
treinta2:
.float 32.0
salida:
.asciz"Grados Fahrenheit= %.2f\n"
.section .text
.globl _start
_start:
pushl $mensaje
call printf
pushl $introd
call printf
addl $8, %esp
pushl $grados
pushl $leegrado
call scanf
248
pushl $salto
call printf
finit
flds grados
fdivs cinco
fmuls nueve
fadds treinta2
subl $8, %esp
fstpl (%esp)
pushl $salida
call printf
movl $1, %eax
xorl %ebx, %ebx
int $0x80
11.3..section .data
mensaje: .asciz"Programa que calcula el promedio de temperatura\n"
mensaje2:
.asciz"dados 10 valores en grados Centigrados\n"
pidevalor:
.asciz"Introduzca el valor %d: "
leegrado:
salto:
grado:
cero:
diez:
salida:
.asciz"%f"
.asciz"\n"
.float 0.0
.float 0.0
.float 10.0
.asciz"El promedio de temperatura es: %.4f\n"
.section .text
.globl _start
_start:
pushl $mensaje
call printf
pushl $mensaje2
call printf
addl $8, %esp
leeysuma:
finit
flds cero
xorl %edi, %edi
incl %edi
cmpl $10, %edi
jg termina
pushl %edi
pushl $pidevalor
call printf
addl $8, %esp
incl %edi
pushl $grado
249
pushl $leegrado
call scanf
addl $8, %esp
fadds grado
jmp leeysuma
termina: fdivs diez
subl $8, %esp
fstpl (%esp)
pushl $salida
call printf
movl $1, %eax
xorl %ebx, %ebx
int $0x80
11.4..section
mensaje:
introd:
leediam:
salto:
diam:
dos:
salida:
.data
.asciz"Programa que calcula el area de un circulo dado su diametro\n"
.asciz"Introduzca el diametro: "
.asciz"%f"
.asciz"\n"
.float 0.0
.float 2.0
.asciz"Area del circulo= %.4f\n"
.section .text
.globl _start
_start:
pushl $mensaje
call printf
pushl $introd
call printf
addl $8, %esp
pushl $diam
pushl $leediam
call scanf
pushl $salto
call printf
finit
flds diam
fdivs dos
fst %st(1)
fmul %st(1), %st(0)
fldpi
fmul %st(1), %st(0)
# apila diametro
# divide diam/2
# apila pi
250
subl $8, %esp
fstpl (%esp)
pushl $salida
call printf
movl $1, %eax
xorl %ebx, %ebx
int $0x80
11.5..section .data
mensaje: .asciz"Programa que convierte kilometros en millas o millas en
kilometros\n"
tipoconv:
.asciz"Indique el tipo de conversion que desea realizar:\n"
tipo1:
.asciz"Convertir de kilometros a millas [k] o de millas a
kilometros [m]: "
leetipo: .asciz"%c"
salto:
.asciz"\n"
kiloms:
.asciz"Introduzca la cantidad de kilometros: "
millas:
.asciz"Introduzca la cantidad de millas: "
formatof:
.asciz"%f"
km:
.float 0.0
milla:
.float 0.0
convers: .float 0.62
kmmilla: .asciz"Son %.2f millas\n"
millakm: .asciz"Son %.2f kilometros\n"
.section .bss
tipo:
.space 1
.section .text
.globl _start
_start:
pushl $mensaje
call printf
pushl $tipoconv
call printf
pidetipo:
pushl $tipo1
call printf
addl $12, %esp
pushl $tipo
pushl $leetipo
call scanf
addl $8, %esp
cmpl $'k', tipo
je kilo
cmpl $'K', tipo
je kilo
cmpl $'m', tipo
je mill
251
cmpl $'M', tipo
je mill
jmp pidetipo
pushl $salto
call printf
addl $4, %esp
finit
kilo:
pushl $kiloms
call printf
addl $4, %esp
pushl $km
pushl $formatof
call scanf
addl $8, %esp
flds km
fmuls convers
subl $8, %esp
fstpl (%esp)
pushl $kmmilla
call printf
jmp fin
mill:
pushl $millas
call printf
addl $4, %esp
pushl $milla
pushl $formatof
call scanf
addl $8, %esp
flds milla
fdivs convers
subl $8, %esp
fstpl (%esp)
pushl $millakm
call printf
fin:
movl $1, %eax

xorl %ebx, %ebx
int $0x80
Capitulo 12
12.1.# Utilice el siguiente script para desactivar el buffering y echo del terminal
# more.sh:
# stty -icanon -echo
252
# ./12-1 $1
# stty icanon echo
.section
cad:
formato:
modor:
.rodata
.asciz "Ocurri un error al intentar abrir el archivo especificado\n"
.asciz "%s"
.asciz "r"
.section
fd:
buffer:
char:
.bss
.space 4
.space 80
.space 1
.section .text
.globl _start
_start:
movl 8(%esp), %eax
# Argumento del programa: Nombre del archivo
# Abre el archivo en modo lectura

pushl $modor
# Modo: r
pushl %eax
# Archivo fuente
call fopen
# Llama a fopen
addl $8, %esp
mov %eax, fd
cmpl $0, fd
je error
xorl %edi, %edi
# lineas = 0
rep:
# Lee una linea del archivo
pushl fd
pushl $80
# Cantidad de caracteres a leer (mximo)
pushl $buffer
# Apuntador al buffer
call fgets
# Llama a fscanf
addl $12, %esp
# Se muestra por la pantalla
pushl $buffer
pushl $formato
# Cadena de formato
call printf
addl $8, %esp
# Si se alcanz el final del archivo sale del ciclo
pushl fd
call feof
# Llama a feof
addl $4, %esp
cmpl $0, %eax
# Si se alcanz el final del archivo
jne fin
incl %edi
cmpl $25,%edi
# lineas = lineas + 1
# Si se han mostrado 25 lineas
253
je espera
jmp rep
espera:
call getchar
movb %al, char
cmpb $'\n', char
je avanzar1
cmpb $' ', char
je avanzar25
jmp espera
# Espera por el usuario

# Siguiente lnea del archivo
# Obtiene la entrada del usuario
#
#
#
#
Si pis ENTER
Avanza una lnea
Si pis la barra espaciadora
Avanza una pgina (25 lneas)
avanzar1:
decl %edi
jmp rep
# lineas = lineas - 1
avanzar25:
xorl %edi, %edi
jmp rep
# lineas = 0
error:
pushl $cad
call printf
addl $4, %esp
jmp fin2
fin: # Cierra el archivo si est abierto

cmpl $0, fd
je fin2
pushl fd
call fclose
addl $4, %esp

# Llama a fclose
fin2:
movl $1, %eax
movl $0, %ebx
int $0x80
12.2.#
#
#
#
#
Utilice el siguiente script para desactivar el buffering y echo del terminal

more.sh:
stty -icanon -echo
./12-2 $1
stty icanon echo
254
.section
cad:
formato:
modor:
.rodata
.asciz "Ocurri un error al intentar abrir el archivo especificado\n"
.asciz "%s"
.asciz "r"
.section
fd:
buffer:
char:
.bss
.space 4
.space 80
.space 1
.section .text
.globl _start
_start:
# Abre el archivo en modo lectura
movl $5, %eax
movl 8(%esp), %ebx
movl $0, %ecx
# ORDONLY : 0
int $0x80
# Llamada al SO
mov %eax, fd
cmpl $0, fd
jl error
xorl %edi, %edi
# lineas = 0
rep:
# Lee una linea del archivo
xorl %esi, %esi
leer:
movl $3, %eax
#
movl fd, %ebx
#
leal buffer(%esi), %ecx
#
movl $1, %edx
#
int $0x80
#
Servicio #3, (read)

Direccin donde se almacenarn los datos
Nmero de bytes a leer
Llamada al SO
cmpl $0, %eax

je fin
cmpb $'\n',buffer(%esi)
je mostrar
#
#
#
#
incl %esi
jmp leer
mostrar:
movb $0,buffer+1(%esi)
Si se leyeron cero bytes

Se alcanz el final del archivo
Si se ley un salto de linea
Muestra la lnea almacenada
# Cerrar la cadena leda
# Se muestra por la pantalla

pushl $buffer
pushl $formato
# Cadena de formato
call printf
# Llama a printf
addl $8, %esp
incl %edi
255
cmpl $25,%edi
je espera
jmp rep
espera:
call getchar
movb %al, char
cmpb $'\n', char
je avanzar1
cmpb $' ', char
je avanzar25
jmp espera
# Si se han mostrado 25 lineas

# Espera por el usuario
# Obtiene la entrada del usuario
#
#
#
#
Si pis ENTER
Avanza una linea
Si pis la barra espaciadora
Avanza una pgina (25 lneas)
avanzar1:
decl %edi
jmp rep
# lineas = lineas - 1
avanzar25:
xorl %edi, %edi
jmp rep
# lineas = 0
error:
pushl $cad
call printf
addl $4, %esp
jmp fin2
fin: # Cierra el archivo si est abierto

cmpl $0, fd
je fin2
movl $6, %eax
movl fd, %ebx
int $0x80
# Llamada al SO
fin2:
movl $1, %eax
movl $0, %ebx
int $0x80
12.3..section
cad1:
cad2:
cad3:
cad4:
cad5:
.rodata
.asciz "1 Insertar contacto\n2 Buscar contacto\n3 Eliminar contacto\n"
.asciz "Su opcin: "
256
cad6:
cad7:
cad8:
cad9:
file:
file2:
format1:
format2:
format3:
modo1:
modo2:
modo3:
.asciz
.asciz
.asciz
.asciz
.asciz
.asciz
.asciz
.asciz
.asciz
.asciz
.asciz
.asciz
"Posicin: "
"Nombre: %s\nTelefono: %d\n"
"La posicin indicada est vaca\n"
"Ocurri un error al intentar abrir el archivo temporal\n"
"agenda.txt"
"agenda.tmp"
"%d"
"%s"
"%s | %d\n"
"a"
"r"
"w"
.section
nombre:
tlf:
opcion:
pos:
desp:
fd:
fd2:
.bss
.space
.space
.space
.space
.space
.space
.space
80
4
4
4
4
4
4
.section .text
.globl _start
_start:
pushl $cad1
call printf
addl $4, %esp
while:
pushl $cad2
call printf
addl $4, %esp
# Pide una opcin
pushl $opcion
pushl $format1
call scanf
addl $8, %esp
cmpl $1, opcion

je insertar
cmpl $2, opcion
je buscar
cmpl $3, opcion
je eliminar
jmp while
# Si es 3 salta a eliminar

insertar:
pushl $modo1
# Modo: a
257
pushl $file
call fopen
addl $8, %esp
# Archivo: agenda.txt
# Llama a fopen
mov %eax, fd
cmpl $0, fd
je error
pushl $cad4
call printf
addl $4, %esp
pushl $nombre
pushl $format2
call scanf
addl $8, %esp
pushl $cad5
call printf
addl $4, %esp
pushl $tlf
pushl $format1
call scanf
addl $8, %esp

pushl tlf
pushl $nombre
pushl $format3
pushl fd
call fprintf
addl $16, %esp
#
#
#
#
#
Telefono
&Nombre
Cadena de formato
Llama a fprintf
jmp fin

buscar:
pushl $modo2
# Modo: r
pushl $file
call fopen
# Llama a fopen
addl $8, %esp
mov %eax, fd
cmpl $0, fd
je error
pushl $cad6
call printf
258
addl $4, %esp
pushl $pos
pushl $format1
call scanf
addl $8, %esp
xorl %esi, %esi
# i=0
cmpl %esi, pos

je mostrar
# Si i=pos
# Salta a mostrar
rep:

pushl fd
call feof
# Llama a feof
addl $4, %esp
cmpl $0, %eax
jne nopos
pushl $tlf
# &Telefono
pushl $nombre
# &Nombre
pushl $format3
# Cadena de formato
pushl fd
call fscanf
# Llama a fscanf
addl $16, %esp
incl %esi
jmp rep
mostrar:
pushl tlf
pushl $nombre
pushl $cad7
call printf
addl $12, %esp
jmp fin
# i++
# Repite la bsqueda

# Y un archivo secundario para escritura de los contactos
eliminar:
pushl $modo2
# Modo: r
pushl $file
call fopen
# Llama a fopen
addl $8, %esp
mov %eax, fd
# Apuntador al archivo original
cmpl $0, fd
je error
pushl $modo3
pushl $file2
# Modo: w
# Archivo: agenda.tmp
259
call fopen
addl $8, %esp
mov %eax, fd2
cmpl $0, fd2
je error2
# Llama a fopen
pushl $cad6
call printf
addl $4, %esp
pushl $pos
pushl $format1
call scanf
addl $8, %esp
# Apuntador al archivo temporal

# Si fd2==NULL (0) ocurri un error
movl $1, %esi

# i=1
copiar:
# Si se alcanz el final del archivo finaliz la copia
pushl fd
call feof
# Llama a feof
addl $4, %esp
cmpl $0, %eax
jne fcopiar
# Lee un contacto desde el archivo original
pushl $tlf
# &Telefono
pushl $nombre
# &Nombre
pushl $format3
# Cadena de formato
pushl fd
# Apuntador al archivo original
call fscanf
# Llama a fscanf
addl $16, %esp
cmpl %esi, pos
je saltar
# Si i=pos
# No copia el contacto
# Se inserta en el archivo temporal

pushl tlf
# Telefono
pushl $nombre
# &Nombre
pushl $format3
# Cadena de formato
pushl fd2
# Apuntador al archivo temporal
call fprintf
# Llama a fprintf
addl $16, %esp
saltar:
incl %esi
jmp copiar
# i++
fcopiar:
# Cierra ambos archivos
pushl fd
call fclose
addl $4, %esp
pushl fd2

# Llama a fclose
260
call fclose
addl $4, %esp
# Llama a fclose
# Elimina el archivo original

pushl $file
# Ruta del archivo a eliminar
call remove
# Llama a remove
addl $4, %esp
# Lo sustituye por el archivo temporal
pushl $file
# Ruta nueva
pushl $file2
# Ruta antiga
call rename
# Llama a rename
addl $8, %esp
jmp fin2

nopos:
pushl $cad8
call printf
addl $4, %esp
jmp fin

error:
pushl $cad3
call printf
addl $4, %esp
jmp fin2
error2:
pushl $cad9
call printf
addl $4, %esp
fin:
pushl fd
call fclose
# Llama a fclose
addl $4, %esp
fin2:
movl $1, %eax
movl $0, %ebx
int $0x80
12.4.-
261
.section .rodata
cad1:
.asciz "1 Insertar contacto\n2 Buscar contacto\n3 Eliminar contacto\n"
cad2:
.asciz "Su opcin: "
cad3:
cad4:
cad5:
cad6:
.asciz "Posicin: "
cad7:
cad8:
cad9:
.asciz "Ocurri un error al intentar abrir el archivo temporal\n"
file:
file2:
.asciz "agenda3.tmp"
format1:.asciz "%d"
format2:.asciz "%s"
.section .bss
nombre: .space 80
tlf: .space 4
opcion: .space 4
pos: .space 4
desp:
.space 4
fd: .space 4
fd2: .space 4
.section .text
.globl _start
_start:
pushl $cad1
call printf
addl $4, %esp
while:
pushl $cad2
call printf
addl $4, %esp
# Pide una opcin
pushl $opcion
pushl $format1
call scanf
addl $8, %esp
cmpl $1, opcion

je insertar
cmpl $2, opcion
je buscar
cmpl $3, opcion
je eliminar
jmp while
# Si es 3 salta a eliminar
262
insertar:
movl $5, %eax
movl $file, %ebx
movl $02101, %ecx
movl $0644, %edx
int $0x80
mov %eax, fd
#
#
#
#
#
#
Servicio #5 (open)
Ruta del archivo a abrir
O_CREAT | O_APPEND | O_WRONLY
Permisos del archivo
Llamada al SO
cmpl $0, fd
jl error
pushl $cad4
call printf
addl $4, %esp
pushl $nombre
pushl $format2
call scanf
addl $8, %esp
pushl $cad5
call printf
addl $4, %esp
pushl $tlf
pushl $format1
call scanf
addl $8, %esp

movl $4, %eax
movl fd, %ebx
movl $nombre, %ecx
# Apuntador a los datos a escribir
movl $84, %edx
# Nmero de bytes a escribir
int $0x80
# Llamada al SO
jmp fin

buscar:
movl $5, %eax
movl $file, %ebx
movl $0, %ecx
# ORDONLY : 0
int $0x80
# Llamada al SO
mov %eax, fd
cmpl $0, fd
jl error
pushl $cad6
call printf
addl $4, %esp
263
pushl $pos
pushl $format1
call scanf
addl $8, %esp
decl pos
movl $84, %eax
imull pos
movl %eax, desp

movl $19, %eax
# Servicio #19, (lseek)
movl fd, %ebx
movl desp, %ecx
# Desplazamiento en bytes
movl $0, %edx
int $0x80
# Llamada al SO
movl $3, %eax
movl fd, %ebx
movl $nombre, %ecx
# Direccin donde se almacenarn los datos
movl $84, %edx
int $0x80
# Llamada al SO
cmpl $0, %eax
je nopos

# la posicin no existe
pushl tlf
pushl $nombre
pushl $cad7
call printf
addl $12, %esp
jmp fin

# Y un archivo secundario para escritura de los contactos
eliminar:
movl $5, %eax
movl $file, %ebx
movl $0, %ecx
# ORDONLY : 0
int $0x80
# Llamada al SO
mov %eax, fd
cmpl $0, fd
jl error
movl $5, %eax
movl $file2, %ebx
movl $02101, %ecx
movl $0644, %edx
int $0x80
mov %eax, fd2
#
#
#
#
#
#
Servicio #5 (open)
O_CREAT | O_APPEND | O_WRONLY
Llamada al SO
264
cmpl $0, fd2
jl error2
# Si fd2<0 ocurri un error
pushl $cad6
call printf
addl $4, %esp
pushl $pos
pushl $format1
call scanf
addl $8, %esp
movl $1, %esi

# i=1
copiar:
# Lee un contacto desde el archivo original
movl $3, %eax
movl fd, %ebx
movl $nombre, %ecx
movl $84, %edx
int $0x80
# Llamada al SO
# Si se alcanz el final del archivo finaliz la copia
cmpl $0, %eax
je fcopiar
cmpl %esi, pos
je saltar
# Si i=pos
# No copia el contacto
# Se inserta en el archivo temporal

movl $4, %eax
movl fd2, %ebx
movl $nombre, %ecx
# Apuntador a los datos a escribir
movl $84, %edx
# Nmero de bytes a escribir
int $0x80
# Llamada al SO
saltar:
incl %esi
jmp copiar
fcopiar:
# Cierra ambos archivos
movl $6, %eax
movl fd, %ebx
int $0x80
movl $6, %eax
movl fd2, %ebx
int $0x80
# i++
# Llamada al SO
# Llamada al SO
# Elimina el archivo original

movl $10, %eax
# Servicio #10 (unlink)
movl $file, %ebx
# Ruta del archivo a eliminar
int $0x80
# Llamada al SO
265
# Lo sustituye por el archivo temporal

movl $38, %eax
# Servicio #38 (rename)
movl $file2, %ebx
# Ruta antiga
movl $file, %ecx
# Ruta nueva
int $0x80
# Llamada al SO
jmp fin2

nopos:
pushl $cad8
call printf
addl $4, %esp
jmp fin

error:
pushl $cad3
call printf
addl $4, %esp
jmp fin2
error2:
pushl $cad9
call printf
addl $4, %esp
fin:
movl $6, %eax
movl fd, %ebx
int $0x80
# Llamada al SO
fin2:
movl $1, %eax
movl $0, %ebx
int $0x80
12.5..section
cad1:
cad2:
cad3:
cad4:
cad5:
cad6:
.rodata
.asciz "Archivo
.asciz "Archivo
.asciz "Archivo
.asciz "Ocurri
.asciz "Ocurri
.asciz "Ocurri
fuente #1: "

fuente #2: "
destino: "
un error al intentar abrir el archivo fuente #1\n"
un error al intentar abrir el archivo destino\n"
266
formato:.asciz "%s"
char:
.asciz "%c"
modor:
.asciz "r"
modow:
.asciz "w"
.section .bss
fuente1:.space 80
fuente2:.space 80
destino:.space 80
fd1: .space 4
fd2: .space 4
fd3: .space 4
buffer: .space 1
.section .text
.globl _start
_start:
pushl $cad1
call printf
addl $4, %esp
# Solicita la ruta del primer archivo fuente
pushl $fuente1
pushl $formato
call scanf
addl $8, %esp
pushl $cad2
call printf
addl $4, %esp
# Solicita la ruta del segundo archivo fuente
pushl $fuente2
pushl $formato
call scanf
addl $8, %esp
pushl $cad3
call printf
addl $4, %esp
# Solicita la ruta del archivo destino
pushl $destino
pushl $formato
call scanf
addl $8, %esp
# Abre los dos archivos fuentes para lectura y el destino para escritura
pushl $modor
pushl $fuente1
call fopen
addl $8, %esp
# Modo: r
# Archivo fuente 1
# Llama a fopen
267
mov %eax, fd1
cmpl $0, fd1

je error1
pushl $modor
pushl $fuente2
call fopen
addl $8, %esp
mov %eax, fd2
# Modo: r
# Archivo fuente 2
# Llama a fopen
cmpl $0, fd2

je error2
pushl $modow
pushl $destino
call fopen
addl $8, %esp
mov %eax, fd3
# Modo: w
# Archivo destino
# Llama a fopen
cmpl $0, fd3

je error3
# Copia el contenido del archivo fuente1 a al archivo destino

rep1:
# Lee un caracter del primer archivo fuente
pushl $buffer
pushl $char
# Cadena de formato
pushl fd1
call fscanf
# Llama a fscanf
addl $8, %esp
pushl fd1
call feof
# Llama a feof
addl $4, %esp
cmpl $0, %eax
jne rep2
# Lo guarda en el archivo destino
pushl buffer
# Contenido del buffer
pushl $char
# Cadena de formato
pushl fd3
call fprintf
# Llama a fprintf
addl $8, %esp
jmp rep1
rep2:
# Lee
pushl
pushl
pushl
un caracter del segundo archivo fuente

$buffer
$char
# Cadena de formato
fd2
268
call fscanf
addl $8, %esp
# Llama a fscanf

pushl fd2
call feof
# Llama a feof
addl $4, %esp
cmpl $0, %eax
jne fin
# Lo guarda en el archivo destino
pushl buffer
# Contenido del buffer
pushl $char
# Cadena de formato
pushl fd3
call fprintf
# Llama a fprintf
addl $8, %esp
jmp rep2
error3: pushl $cad5

call printf
addl $4, %esp
jmp fin
error2: pushl $cad5

call printf
addl $4, %esp
jmp fin
error1: pushl $cad4

call printf
addl $4, %esp
jmp fin
fin: # Cierra cualquier archivo abierto previamente

cierra1:cmpl $0, fd1
je cierra2
pushl fd1
call fclose
addl $4, %esp
je cierra3
pushl fd2
call fclose
addl $4, %esp
je fin2
pushl fd3
call fclose

# Llama a fclose

# Llama a fclose

# Llama a fclose
269
addl $4, %esp
fin2:
movl $1, %eax
movl $0, %ebx
int $0x80
12.6..section
cad1:
cad2:
cad3:
cad4:
cad5:
cad6:
formato:
char:
modor:
modow:
.rodata
.asciz "Archivo
.asciz "Archivo
.asciz "Archivo
.asciz "Ocurri
.asciz "Ocurri
.asciz "Ocurri
.asciz "%s"
.asciz "%c"
.asciz "r"
.asciz "w"
fuente #1: "

fuente #2: "
destino: "
un error al intentar abrir el archivo destino\n"
.section .bss
fuente1: .space 80
fuente2: .space 80
destino: .space 80
fd1:
.space 4
fd2:
.space 4
fd3:
.space 4
buffer: .space 84*500
contactos:.space 4
.section .text
.globl _start
_start:
pushl $cad1
call printf
addl $4, %esp
# Solicita la ruta del primer archivo fuente
pushl $fuente1
pushl $formato
call scanf
addl $8, %esp
pushl $cad2
call printf
addl $4, %esp
# Solicita la ruta del segundo archivo fuente
270
pushl $fuente2
pushl $formato
call scanf
addl $8, %esp
pushl $cad3
call printf
addl $4, %esp
# Solicita la ruta del archivo destino
pushl $destino
pushl $formato
call scanf
addl $8, %esp
# Abre los dos archivos fuentes para lectura y el destino para escritura
movl $5, %eax
movl $fuente1, %ebx
movl $0, %ecx
int $0x80
mov %eax, fd1
cmpl $0, fd1
jl error1
#
#
#
#
#
#
Servicio #5 (open)
ORDONLY : 0
Llamada al SO
Si fd<0 ocurri un error
movl $5, %eax

movl $fuente2, %ebx
movl $0, %ecx
int $0x80
mov %eax, fd2
cmpl $0, fd2
jl error2
#
#
#
#
#
#
Servicio #5 (open)
ORDONLY : 0
Llamada al SO
movl $5, %eax

movl $destino, %ebx
movl $01101, %ecx
movl $0644, %edx
int $0x80
mov %eax, fd3
cmpl $0, fd3
jl error3
#
#
#
#
#
#
#
Servicio #5 (open)
O_CREAT | O_TRUNC | O_WRONLY
Llamada al SO
movl $0, contactos

copiar1:
movl $3, %eax
movl fd1, %ebx
leal buffer, %ecx
addl contactos,%ecx
movl $84, %edx
int $0x80
cmpl $0, %eax
je copiar2
addl $84,contactos
# contactos = 0
# Llamada al SO
# Termin con este archivo
271
jmp copiar1
copiar2:
movl $3, %eax
movl fd2, %ebx
leal buffer, %ecx
addl contactos,%ecx
movl $84, %edx
int $0x80
cmpl $0, %eax
je seguir
xorl %ebx, %ebx
revisar:cmpl contactos,%ebx
jge noesta
leal buffer(%ebx), %esi
leal buffer, %edi
addl contactos, %edi
movl $80, %ecx
rep cmpsb
je copiar2
addl $84, %ebx
jmp revisar
noesta:
addl $84,contactos
jmp copiar2
seguir:
xorl %edi, %edi
vaciar: cmpl contactos, %edi
jge fin
movl $4, %eax
movl fd3, %ebx
leal buffer(%edi), %ecx
movl $84, %edx
int $0x80
addl $84, %edi
jmp vaciar

# Llamada al SO
# Termin con este archivo
# i=0
# mientras i<contactos
# Nombre del contacto en la posicin i

# Nombre del contacto ledo
#
#
#
#
Comparar hasta 80 caracteres

Compara el nombre de los contactos
Si el contacto ya existe se ignora
i++
# Si el contacto no est en la lista

# Se agrega
# i=0
# mientras i<contactos
#
#
#
#
#

Apuntador a los datos a escribir
Nmero de bytes a escribir
Llamada al SO
error3: pushl $cad5

call printf
addl $4, %esp
jmp fin
error2: pushl $cad5

call printf
addl $4, %esp
jmp fin
error1:
pushl $cad4
272
call printf
addl $4, %esp
jmp fin
fin: # Cierra cualquier archivo abierto previamente
jl cierra2
movl $6, %eax
movl fd1, %ebx
int $0x80
# Llamada al SO

jl cierra3
movl $6, %eax
movl fd2, %ebx
int $0x80
# Llamada al SO

jl fin2
movl $6, %eax
movl fd3, %ebx
int $0x80
# Llamada al SO
fin2:
movl $1, %eax
movl $0, %ebx
int $0x80

Ensamblador

Cargado por

Copyright:

Formatos disponibles

Ensamblador

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Ensamblador

Cargado por

Copyright:

Formatos disponibles

Programacin en Lenguaje Ensamblador bajo Linux

Captulo 2. El entorno de programacin ...................................................................... 19

Captulo 3. El programa en lenguaje ensamblador ...................................................... 50

Captulo 4. Definicin de datos .................................................................................... 53

Captulo 5. Instrucciones ............................................................................................. 56

Instrucciones de comparacin .................................................................................................... 71

Instrucciones de salto ................................................................................................................... 72

Captulo 6. Entrada / Salida......................................................................................... 79

Llamadas al sistema ..................................................................................................................... 87

Instrucciones de bajo nivel .......................................................................................................... 93

Captulo 7. Control de flujo........................................................................................ 118

Captulo 8. Arreglos ................................................................................................... 125

Captulo 9. Procedimientos ........................................................................................ 131

Captulo 10. Cadenas de caracteres............................................................................ 144

Captulo 11. Operaciones de punto flotante ............................................................... 154

Captulo 12. Manejo de archivos................................................................................ 166

Tipos de acceso ............................................................................................................................ 168

Funciones de alto nivel ............................................................................................................... 169

Llamadas al sistema ................................................................................................................... 186

Soluciones a los ejercicios .......................................................................................... 197

Captulo 1. La plataforma IA-32

Descripcin general de la mquina

Tipo de datos en IA-32

Tamao (en bytes)

Registros de propsito general

temporalmente. Debido a que estos registros han evolucionado desde una

En gas los registros se denotan anteponiendo el smbolo de % al nombre del

%ax (16 bits)

%eax (32 bits)

%ebx (32 bits)

%ecx (32 bits)

%edx (32 bits)

%edi (32 bits)

%esi (32 bits)

%esp (32 bits)

%ebp (32 bits)

El contenido de los mismos es interpretado de diferente forma dependiendo si

descriptor de segmento. Este ltimo no es ms que una estructura de ocho

Direccin base (23-16)

Descriptor de segmento del 80286

Direccin base (31-24)

Direccin base (23-16)

Descriptor de segmento del 80386 y posteriores

En donde P ( present) es un bit que indica si el descriptor contiene informacin

En primer lugar, el descriptor de segmento indica que debe seleccionarse el

Registros de punto flotante

La bandera de acarreo se activa cuando se produce acarreo en una suma o

Captulo 2. El entorno de programacin

compilacin gcc que permite traducir programas escritos en el lenguaje de

Para ejemplificar los pasos usaremos un programa fuente denominado

escrito en lenguaje de programacin C, creado en un editor de texto y guardado

gcc o ejemplo ejemplo.c

El compilador lee el archivo

y lo traduce al archivo objeto ejecutable

ejemplo. Esto se realiza a travs de las cuatro etapas mencionadas.

le indica al pre-procesador que debe leer el

e insertar su contenido en el texto del programa.

La salida de esta etapa es el archivo intermedio

ejemplo.i entra en la siguiente etapa, el compilador (ccl) el cual traduce el