Assembler

ASSLM8LL8
unnC8A - ArqulLecLura de CompuLadoras

2011
Mar|ano kugg|ero
UNNC8A

Marlano 8ugglero - unnC8A ArqulLecLura de CompuLadoras - 2011

"##$%&'$( 2
!"#$%&'((!)"
SL1 DL INS1kUCCICNLS
Cada Cu Llene un con[unLo de lnsLrucclones que puede e[ecuLar. LsLas lnsLrucclones son parLe del mlcroprocesador y
es el fabrlcanLe (lnLel, AMu, l8M.) qulen deLermlna a que lnsLrucclones responde el mlsmo.
!"# %" &'(#)*++,-'"(. "# $% &'()*(+' ,$ +',-# %-# .(#+/*&&.'($# 0*$ *(- 123 '
4.&/'5/'&$#-,'/ 5*$,$ $)$&*+-/6
Ll seL de lnsLrucclones es proplo de una arqulLecLura de Cu en parLlcular. Cada arqulLecLura Llene su proplo seL y los
programas que corren sobre una Cu deben esLar dlsenados especlflcamenLe para ese seL de lnsLrucclones
1
.
Ll seL de lnsLrucclones de una Cu Lamblen se conoce como |engua[e de mqu|na. una lnsLruccln en lengua[e de
mqulna es una secuencla de blLs (ceros y unos) que la Cu sabe lnLerpreLar y le lndlca que operacln reallzar.
unA lnS18uCClCn
una lnsLruccln en lengua[e de mqulna Llene un aspecLo slmllar al slgulenLe:
101110000000010100000000
? un pequeno fragmenLo de un programa escrlLo en lengua[e de mqulna se varla asl:
101110000000010100000000
101110000000001000000000
101000110000111000000000
ClaramenLe, es lmposlble escrlblr cdlgo dlrecLamenLe en lengua[e de mqulna. LsLe lengua[e es LoLalmenLe lleglble
para un humano y Lener que memorlzar Lodas las comblnaclones de ceros y unos que forman cada lnsLruccln o, peor
aun, Lener que enconLrar un error enLre una llsLa de clenLos de lnsLrucclones escrlLas asl, es lmpensable.
LLNGUAILS DL AL1C NIVLL
ara evlLar Lener que escrlblr en lengua[e de mqulna, hablLualmenLe uLlllzamos los llamados |engua[es de a|to n|ve|.
LsLos lengua[es (como C++, ascal, 8uby, C#, vlsual 8aslc, !ava y oLros) poseen lnsLrucclones enLendlbles por los
humanos (programadores) que hacen mucho ms fcll escrlblr y leer el cdlgo fuenLe de un programa. ue hecho, esLos
lengua[es nos slmpllflcan la Larea aun ms, agrupando denLro de una |nstrucc|n de a|to n|ve| varlas lnsLrucclones del
lengua[e de mqulna (o |engua[e de ba[o n|ve|).

1
A parLlr de 2006, Apple, la companla fabrlcanLe de las compuLadoras MaclnLosh, decldl camblar la arqulLecLura owerC, uLlllzada
duranLe mucho Llempo en las Macs, por la arqulLecLura Inte| x86. Como resulLado, las apllcaclones creadas para la arqulLecLura
anLerlor deblan correr ba[o un emu|ador en las nuevas lnLel Macs que Lraducla las lnsLrucclones orlglnales a lnsLrucclones que la
arqulLecLura lnLel x86 pudlera comprender, de esLa forma se manLuvo la compaLlbllldad con las apllcaclones ms anLlguas.
CLro efecLo del camblo de arqulLecLuras fue que ahora los usuarlos de Mac podlan eleglr enLre usar el slsLema operaLlvo de Apple,
7-&89 :, o blen lnsLalar ;.(,'<#, que anLes slo esLaba dlsponlble para las Cs (que se basan en la arqulLecLura x86).

"##$%&'$( 3
Las Lres lnsLrucclones de ba[o nlvel mosLradas anLerlormenLe slrven para sumar 3 + 2 y almacenar el resulLado. Sl, Lodos
esos ceros y unos lo unlco que logran es sumar dos numeros. Cmo harlamos lo mlsmo en un lengua[e de alLo nlvel?
SenclllamenLe:
resultado = 5 + 2
or que se neceslLan +-(+-# lnsLrucclones de ba[o nlvel, enLonces? orque las lnsLrucclones de ba[o nlvel solo reallzan
Lareas sumamenLe senclllas. LsLo hace que los mlcroprocesadores sean mucho ms fclles y baraLos de consLrulr. La
gran poLencla de los mlcroprocesadores es consecuencla de su alLlslma velocldad que le permlLe e[ecuLar mlllones de
esas lnsLrucclones senclllas por segundo (y comblnando mlllones de lnsLrucclones senclllas se logran resulLados muy
comple[os, como puede ser cualqulera de los programas que usamos hablLualmenLe).
1-,- ,'(#)*++,/' %" 012- ',3"4 /$-%.=- *(- #'%- +-/$- >?#.&-6
CCMlLAuC8LS
ara converLlr el cdlgo fuenLe escrlLo en un lengua[e de alLo nlvel a cdlgo de mqulna se uLlllza una herramlenLa de
sofLware especlal llamada compllador.
3( +-56,41%-) &'(@.$/+$ &A,.B' C*$(+$ ,$ -%+' (.@$% $( .(#+/*&&.'($# ,$ 4?0*.(- ,$ >-)'
(.@$%6
Cada lengua[e de programacln posee un compllador proplo. Ll compllador acLua como un LraducLor. 1oma como
enLrada el llsLado de cdlgo de alLo nlvel y, por cada lnsLruccln, la Lransforma en una o ms lnsLrucclones de ba[o nlvel.
Ll problema" de los lengua[es de alLo nlvel es que, a camblo de facllldad de uso, esLamos reslgnando conLrol. Al
permlLlr que el compllador escrlba por nosoLros el cdlgo de mqulna, de[amos de Lener el conLrol absoluLo sobre cada
operacln que reallza la Cu al e[ecuLar nuesLro programa. LsLo es generalmenLe algo deseable, pero exlsLen casos
donde es lnLeresanLe poder Lener el conLrol dlrecLo de lo que sucede en nuesLro programa.
uado que no podemos conLrolar las lnsLrucclones de mqulna que genera el lengua[e de alLo nlvel y que escrlblr
dlrecLamenLe en cdlgo de ba[o nlvel es demaslado dlflcll, que alLernaLlva Lenemos?
ASSLM8LLk
ara cada lengua[e de mqulna (de cada arqulLecLura de Cu) exlsLe lo que se conoce como lengua[e ensamblador o
Assemb|er. Assembler no es realmenLe un %$(B*-)$, slno que es slmplemenLe una /$5/$#$(+-&.A( %$B.>%$ del lengua[e
de mqulna. LxlsLe una correspondencla uno a uno enLre cada lnsLruccln de ba[o nlvel y cada lnsLruccln de
Assembler.
7(("504") $# *( %$(B*-)$ 0*$ /$5/$#$(+- &-,- *(- ,$ %-# .(#+/*&&.'($# ,$ >-)' (.@$% ,$
C'/4- %$B.>%$ 5-/- %'# 5/'B/-4-,'/$#6
Sl Lraduclmos las Lres lnsLrucclones que hablamos vlsLo anLerlormenLe a su represenLacln en Assembler, obLendremos
lo slgulenLe:


"##$%&'$( 4
mov ax, 5
add ax, 2
mov resultado, ax
Ms all de que no nos quede claro en esLe momenLo que es exacLamenLe lo que hace cada lnsLruccln, es evldenLe
que esLa represenLacln del lengua[e de mqulna es mucho ms amlgable" para los humanos que la expresln orlglnal
en blnarlo. odemos lmaglnarnos que escrlblr en esLe lengua[e sl es facLlble y que enconLrar errores es una Larea ms
sencllla.
ara converLlr cdlgo Assembler en cdlgo de mqulna, en lugar de un compllador, se uLlllza un ensamb|ador. A pesar
de que Llene un ob[eLlvo slmllar al compllador, la gran dlferencla es que un ensamblador no B$($/- nuevo cdlgo slno
que slmplemenLe convlerLe cada lnsLruccln de Assembler en una unlca lnsLruccln de mqulna.
"% "'(15041%-) $# *( 5/'B/-4- 0*$ +/-,*&$ $% &A,.B' D##$4>%$/ - %- /$5/$#$(+-&.A(
>.(-/.- E&A,.B' ,$ 4?0*.(-F 0*$ $% 4.&/'5/'&$#-,'/ 5*$,$ &'45/$(,$/6
NULS1kC C8IL1IVC
Poy en dla el uso de Assembler como lengua[e de programacln para cualquler proyecLo de desarrollo es muy poco
comun. Los lengua[es, en realldad, LraLan de ale[arse cada vez ms del cdlgo de mqulna, generando cdlgo de ms
alLo nlvel, que nos evlLa Lener que lldlar con los deLalles. nosoLros podemos escrlblr cdlgo en un lengua[e que nos sea
cmodo, que nos brlnde mucha funclonalldad llsLa para usar y de[ar en manos del compllador la Larea de generar un
cdlgo de ba[o nlvel eflclenLe y veloz que haga lo que queremos.
2

LnLonces, para que aprender Assembler? La gran venLa[a de aprender Assembler es que nos permlLe enLender cmo
funclona un programa compllado a nlvel del mlcroprocesador. Al exlsLlr una correspondencla dlrecLa enLre las
lnsLrucclones de Assembler y las de cdlgo de mqulna, sabemos que cada lnsLruccln que escrlblmos es una que el
procesador va a e[ecuLar y esLo nos permlLe ver que es lo que realmenLe debe hacer nuesLro cdlgo de alLo nlvel para
lograr las funclonalldades comple[as a las que esLamos acosLumbrados.
lensen en el e[emplo anLerlor. Publeran pensado que para sumar dos numeros el procesador neceslLa Lres
lnsLrucclones? Lso es algo que en el lengua[e de alLo nlvel no se noLa, pero en Assembler sl.
LA A8Cul1LC1u8A ln1LL 8086
Ln nuesLro esLudlo de Assembler, nos basaremos en la arqulLecLura lnLel 8086. LsLa es la arqulLecLura del
mlcroprocesador uLlllzado en la l8M C orlglnal. A pesar de que la arqulLecLura ha evoluclonado mucho con el Llempo,
los prlnclplos generales se han manLenldo esLables
3
. LsLudlar la arqulLecLura orlglnal hace que nuesLro aprendlza[e de
los concepLos bslcos sea ms fcll.

2
CcaslonalmenLe Lal vez neceslLemos escrlblr una porcln de cdlgo en Assembler porque neceslLamos el conLrol absoluLo y no
podemos de[ar la generacln de cdlgo al compllador. ara ese caso, muchos lengua[es de alLo nlvel lncluyen lo que se conoce como
ensamblador en llnea (.(%.($ -##$4>%G), que nos permlLe escrlblr un bloque de cdlgo Assembler denLro de nuesLro cdlgo de alLo
nlvel.
1amblen exlsLen ramas de la programacln donde la codlflcacln en Assembler aun Llene su lugar, como por e[emplo, la
programacln de slsLemas de Llempo real, el desarrollo de slsLemas operaLlvos y la lmplemenLacln de sofLware embebldo.
3
La arqulLecLura se conoce en general como lnLel x86 y abarca Lodos los procesadores desde el 8086 orlglnal hasLa los ms reclenLes
procesadores de mulLlples nucleos. Ll hecho de que, a pesar de evoluclonar, la arqulLecLura se haya manLenldo esLable es lo que nos
permlLe Lener compaLlbllldad hacla aLrs y poder e[ecuLar hoy programas escrlLos hace ms de dlez anos.

"##$%&'$( 3
PL88AMlLn1AS
ara programar en Assembler neceslLamos Lres herramlenLas:
un edlLor donde escrlblr el cdlgo fuenLe.
un ensamblador que Lraduce el programa fuenLe a lengua[e de mqulna.
un vlnculador o %.(H$/ Lransforma el cdlgo en lengua[e de mqulna en un e[ecuLable (6$I$).
Como edlLor puede uLlllzarse cualquler edlLor de LexLo plano (sln formaLo), como el J%'& ,$ K'+-# que vlene con
Wlndows o el ",.+ de uCS. ara ensamblar el programa, usaremos el programa 7D97 de MlcrosofL. ? para generar el
e[ecuLable usaremos el programa LMKN.
C8LAClCn uL un L!LCu1A8LL A A81l8 uL CCulCC ASSLM8LL8
una vez escrlLo el cdlgo fuenLe del programa, lo guardamos con exLensln 6-#4. ara generar el cdlgo de mqulna,
desde la llnea de comandos
4
, usamos MASM asl
3
:
MASM Nombre;
uonde K'4>/$6-#4 es el nombre que le dlmos a nuesLro cdlgo fuenLe
6
. LsLo dar como resulLado un archlvo
K'4>/$6'>) (es declr, un archlvo con el mlsmo nombre que el orlglnal, pero con exLensln 6'>)), conLenlendo el cdlgo
de ob[eLo. Ll cdlgo de ob[eLo es cdlgo de mqulna, pero que Lodavla no Llene el formaLo de e[ecuLable requerldo por
el slsLema operaLlvo.
ara generar el e[ecuLable, usamos Llnk:
LINK Nombre;
nuevamenLe, K'4>/$6'>) es el nombre del archlvo de ob[eLo. Como resulLado de esLe paso, obLendremos K'4>/$6$I$.

4
ara acceder a la llnea de comandos de Wlndows: lr a M(.&.' O ")$&*+-/, escrlblr cmd y preslonar "(+$/. Luego navegar hasLa la
carpeLa que conLlene el archlvo Assembler. Con el comando cd "NombreCarpeta", se accede a una subcarpeLa de la acLual y con cd..
se vuelve a la carpeLa anLerlor (luego de cada comando hay que preslonar "(+$/).
3
ara poder escrlblr esLas lnsLrucclones, los programas MASM.exe y Llnk.exe deben enconLrarse en la 4.#4- carpeLa que el archlvo
de cdlgo Assembler.
6
uado que los programas MASM y Llnk no soporLan nombres largos, para que nuesLros programas ensamblen y enlacen
correcLamenLe, deberemos asegurarnos que el nombre que le pongamos al archlvo de cdlgo fuenLe Lenga 8 caracteres o menos
(-,$4?# del .ASM).

"##$%&'$( 6
!"#$%"&' !)'&'
kIMLk kCGkAMA LN ASSLM8LLk
rogramar en Assembler no es dlflcll, slo lleva un poco ms de Lraba[o que hacerlo en un lengua[e de alLo nlvel porque
las lnsLrucclones son mucho ms slmples, hacen menos cosas. ero esa es Lamblen una venLa[a: podemos saber
exacLamenLe que suceder cuando se e[ecuLe una lnsLruccln, asl que para hacer un programa slo Lenemos que
asegurarnos de darle las lnsLrucclones adecuadas al procesador.
Como prlmer programa, anallcemos el mlsmo e[emplo que hablamos presenLado en la seccln anLerlor:
mov ax, 5
add ax, 2
mov resultado, ax
?a dl[lmos que esLe fragmenLo de cdlgo Assembler lo que hace es sumar los numeros 3 y 2, y almacenar el resulLado.
Ahora veamos cmo funclona:
mov ax, 5
LsLa llnea aslgna el numero 3 al reglsLro Ax.
Los reg|stros son pequenas unldades de memorla que se encuenLran denLro del procesador y podemos pensar en ellos
como sl fueran @-/.->%$#. Lo que hacen, bslcamenLe, es almacenar un daLo. LxlsLen varlos reglsLros que se uLlllzan para
dlsLlnLas funclones y los veremos ms adelanLe. Ak es uno de los reglsLros dlsponlbles en la Cu.
La lnsLruccln MCV es una lnsLruccln de aslgnacln
7
. Ls equlvalenLe al slgno = de los lengua[es de alLo nlvel. Lo que
hace es coplar lo que esL del lado derecho de la coma sobre el reglsLro que esL del lado lzqulerdo.
89:; <"(#,'-= :14-)6 9$ *+.%.=- 5-/- /$-%.=-/ %- -#.B(-&.A( <"(#,'- > :14-)6
add ax, 2
LsLa lnsLruccln es un poco ms compllcada de enLender. La lnsLruccln ADD es una lnsLruccln de suma
8
. Lo que hace
es sumar los dos elemenLos que se escrlben a conLlnuacln (en esLe caso Ax y 2) y -%4-&$(- $% /$#*%+-,' #'>/$ $%
5/.4$/ $%$4$(+'.
Al prlnclplo el comporLamlenLo puede resulLar un poco exLrano, no? odemos enLenderlo me[or sl leemos add ax,
2" como sumarle a Ax el numero 2".
7<< <"(#,'-= &'+)"5"'#-6 9$ *+.%.=- 5-/- /$-%.=-/ %- #*4- <"(#,'- > <"(#,'- ?
&'+)"5"'#-6
Ln +',-# las lnsLrucclones de Assembler donde haya que almacenar un resulLado, esLe #.$45/$ se almacenar en el
pr|mer operando. ?a vlmos que esLo es asl para las lnsLrucclones MCv y Auu.

7
MCV vlene de la palabra en lngles 4'@$ que slgnlflca mover".
8
ADD en lngles slgnlflca sumar".

"##$%&'$( 7
8ecaplLulando, que Lenemos hasLa ahora?
mov ax, 5
add ax, 2
Con la prlmera lnsLruccln guardamos un 3 en Ax. Con la segunda, sumamos un 2 a Ax, con lo que Ax pasa a Lener un
valor de 7.
La ulLlma lnsLruccln es oLro MCv:
mov resultado, ax
La palabra 8LSuL1AuC represenLa en esLe cdlgo una ublcacln de memorla, una var|ab|e. A dlferencla de los reglsLros,
las varlables se almacenan en la memorla prlnclpal del slsLema, la 8AM
9
.
Con esLa llnea, aslgnamos a la varlable 8LSuL1AuC el valor de Ax, con lo cual 8LSuL1AuC pasar a Lener el valor 7.
Ahora que podemos enLender cada paso, repasemos el cdlgo orlglnal:
mov ax, 5 ; Cargar AX con 5
add ax, 2 ; Sumarle 2
mov resultado, ax ; Almacenar la suma en la variable RESULTADO
Ln el llsLado anLerlor lo que hlclmos fue agregar comentar|os. Los comenLarlos en Assembler se escrlben comenzando
por un punLo y coma. 1odo lo que slgue del punLo y coma se consldera un comenLarlo y es lgnorado por el
ensamblador.
Al programar en Assembler, el uso de comenLarlos es fundamenLal. uado que el Assembler es un lengua[e muy escueLo
y se neceslLan muchas lnsLrucclones para lograr comporLamlenLos senclllos, los comenLarlos ayudan muchlslmo a
enLender que es lo que el cdlgo hace.
LL 8lML8 8CC8AMA CCMLL1C
Lo que acabamos de ver es slo un C/-B4$(+' de cdlgo Assembler. ara poder reallzar un 5/'B/-4- en Assembler
debemos agregar algunas lnsLrucclones ms.
A conLlnuacln veremos nuevamenLe el cdlgo anLerlor, pero esLa vez en la forma de un programa compleLo. LsLe
programa puede escrlblrse en un edlLor de LexLo y luego ensamblarlo y enlazarlo para generar un e[ecuLable como se
expllc en la seccln anLerlor.

9
kAM vlene de P-(,'4 D&&$## 7$4'/G, que en lngles slgnlflca Memorla de Acceso AleaLorlo".

"##$%&'$( 8
.MODEL SMALL
.STACK
.DATA

resultado DW ? ; Declarar la variable RESULTADO de 16 bits

.CODE
inicio:

mov ax, @data ; Inicializar el segmento de datos
mov ds, ax ;

mov ax, 5 ; Cargar AX con 5
add ax, 2 ; Sumarle 2
mov resultado, ax ; Almacenar la suma en la variable RESULTADO

mov ax, 4C00h ; Terminar
int 21h ;

END inicio
Como podemos ver, es un poco ms comple[o que lo que Lenlamos hasLa ahora. ero hay mucho del cdlgo anLerlor
que, para slmpllflcar, podemos Lomar como una CA/4*%- $#+?(,-/. Ls declr, sl blen cada llnea Llene su slgnlflcado y
puede ser alLerada para lograr dlsLlnLos resulLados al ensamblar el programa, por ahora no nos preocuparemos por
ellas y slmplemenLe las usaremos asl.
LnLonces, el esqueleLo de &*-%0*.$/ programa en Assembler que hagamos ser el slgulenLe:
.MODEL SMALL
.STACK
.DATA

; --> Ac va la declaracin de variables <--

.CODE
inicio:

mov ds, ax ;

; --> Ac va nuestro cdigo <--

int 21h ;

END inicio
Ls declr, que ms all de Lodas las llneas que son esLndar, Lenemos slo dos secclones lmporLanLes en un programa
Assembler:
Ll segmento de datos (marcado por la dlrecLlva .DA1A) que es donde se declaran Lodas las varlables que uLlllza
el programa.
Ll segmento de cd|go (marcado por la dlrecLlva .CCDL) que slempre comlenza y Lermlna con las lnsLrucclones
que vemos en el modelo, enLre las cuales ublcaremos nuesLro cdlgo.

"##$%&'$( 9
!"#!$%&"' )*'+!"'
DA1CS
Ll cdlgo de mqulna Lraba[a excluslvamenLe con daLos blnarlos. Sl blen esLos daLos se pueden lnLerpreLar de dlsLlnLas
formas (como un numero enLero, como un real, como un carcLer), a nlvel de cdlgo de mqulna no hay nlnguna
dlsLlncln enLre, por e[emplo, un enLero y un carcLer.
La secuencla de blLs 01100001 puede ser .(+$/5/$+-,- como el numero 97 y como la leLra a", dependlendo de la
operacln que se reallce sobre el. Lo lmporLanLe es enLender que en el cdlgo de mqulna (y por lo LanLo en Assembler)
(' $I.#+$( %'# +.5'# ,$ ,-+'#.
"( D##$4>%$/ (' $I.#+$( %'# +.5'# ,$ ,-+'#6 "% #.B(.C.&-,' ,$ *(- #$&*$(&.- ,$ >.+#
,$5$(,$ ,$ %- '5$/-&.A( 0*$ #$ $)$&*+$ #'>/$ $%%-6
Lo que sl debemos Lener en cuenLa es el tamao de los daLos. Ln la arqulLecLura lnLel 8086 exlsLen dos Lamanos
poslbles para los daLos:
8 b|ts (Lamblen llamado 1 byte)
16 b|ts (Lamblen llamado 1 word o pa|abra)
Slempre debemos asegurarnos que el Lamano de los operandos en una lnsLruccln sea el correcLo. or e[emplo, sl
hacemos un MCv (como en el e[emplo anLerlor), ambos operandos deben ser de 8 blLs o blen deben ser ambos de 16
blLs, pero (' #$ 5*$,$( 4$=&%-/ byLes con words.
1odos los daLos Llenen un tamao f|[o. or eso, sl Lenemos el valor blnarlo 10010, esLe se escrlblr como 00010010 en
blnarlo de 8 blLs y como 0000000000010010 en blnarlo de 16 blLs. Slempre se escrlben los &$/'# - %- .=0*.$/,- para
lndlcar el Lamano exacLo del daLo.
ara slmpllflcar la expresln de numeros de 8 y 16 blLs es comun uLlllzar el slsLema de numeracln hexadeclmal (base
16). Cada dlglLo hexa represenLa 4 blLs. ue esa forma, por e[emplo, la palabra 1001111001011100 puede escrlblrse
como 9L3C. uLlllzaremos esLa forma abrevlada en esLe apunLe.
Sln1AxlS
uenLro del cdlgo Assembler, los daLos se pueden expresar en blnarlo, hexadeclmal y declmal. ara ldenLlflcar en que
slsLema de numeracln se esL expresando un valor se uLlllzan las slgulenLes reglas:
A los daLos blnarlos se les agrega una b al flnal. or e[emplo: 1001111001011100b es un daLo en blnarlo.
A los daLos hexadeclmales se les agregar una h al flnal. or e[emplo: 9E5Ch es un daLo en hexa.
10

Los daLos declmales se escrlben normalmenLe. or e[emplo: 40540 es un daLo en declmal.

10
Ln Assembler, cuando un numero hexa comlenza por un dlglLo enLre A y l (una leLra"), debe agregarse un cero delanLe del
numero. or e[emplo, A001 debe escrlblrse como 0A001h. Lse cero que se agrega no lncremenLa la canLldad de blLs del numero, es
slmplemenLe una forma de escrlblrlo para que el ensamblador no lo confunda con un nombre de varlable. Ln esLe apunLe, a menos
que sea denLro de un e[emplo de cdlgo, '4.+./$4'# $% &$/' .(.&.-% para evlLar confuslones.

"##$%&'$( 10
8l1S ? 8?1LS
ara un daLo cualqulera (una secuencla de 8 o 16 blLs), los blLs se numeran de derecha a lzqulerda comenzando por 0.
or e[emplo, para el byLe 00111001:
0 0 1 1 1 0 0 1
b|t 7 b|t 6 b|t S b|t 4 b|t 3 b|t 2 b|t 1 b|t 0
Ll b|t 0 se conoce como b|t menos s|gn|f|cat|vo o %$-#+ #.B(.C.&-+ >.+ (LS8).
Ll |t|mo b|t (blL 7 para los byLes y blL 13 para las palabras) se conoce como b|t ms s|gn|f|cat|vo o 4'#+ #.B(.C.&-(+ >.+
(MS8).
1amblen se habla de los blLs ms alLos" o ms ba[os". un blL es ms ba[o sl esL ms cerca del blL 0 y ms alLo sl esL
ms cerca del ulLlmo blL.
Ln el caso de las palabras, pueden dlvldlrse en dos byLes:
blLs 13 al 8 blLs 7 al 0
byte a|to byte ba[o
LsLos byLes se conocen como byte a|to (o parte a|ta) y byte ba[o (o parte ba[a). 1amblen se los suele llama byte ms
s|gn|f|cat|vo y byte menos s|gn|f|cat|vo, respecLlvamenLe.
kLGIS1kCS
Casl Lodas las lnsLrucclones de Assembler lnvolucran la uLlllzacln (lecLura o escrlLura) de un reglsLro. Los reglsLros,
como dl[lmos, son reas de memorla denLro de la Cu que pueden ser accedldas muy rpldamenLe, sln pasar por el bus
del slsLema. A los efecLos de la programacln, los reglsLros funclonan en forma slmllar a las varlables, slrvlendo para
almacenar daLos, pero se dlferenclan de ellas puesLo que las varlables se ublcan en la 8AM.
3( )"@,(#)- $# *( ?/$- ,$ 4$4'/.- ,$(+/' ,$ %- 123 0*$ #$ 5*$,$ -&&$,$/ /?5.,-4$(+$Q
#.( 5-#-/ 5'/ $% >*# ,$% #.#+$4-6
Ln el procesador lnLel 8086 exlsLen reglsLros de 8 y de 16 blLs para almacenar los dos Lamanos de daLos que
nombramos anLes (byLes y words).
A conLlnuacln presenLamos una Labla con Lodos los reglsLros del procesador lnLel 8086:


"##$%&'$( 11

Word (16 blLs)
8yLe alLo 8yLe ba[o
8lLs: 13 14 13 12 11 10 9 8 7 6 3 4 3 2 1 0
Ax AP AL Acumulador
8x 8P 8L 8ase
Cx CP CL ConLador
ux uP uL uaLos

CS Seg. de Cdlgo
uS Seg. de uaLos
LS SegmenLo LxLra
SS SegmenLo de lla

l . de lnsLruccln

Sl lndlce de luenLe
ul lndlce de uesLlno

S unLero de lla
8 unLero de 8ase

llags Cl ul ll 1l Sl Zl Al l Cl (llags)
or ahora, nos concenLraremos slo en los prlmeros cuaLro reglsLros, conocldos como reg|stros de props|to genera|.
ue[aremos los dems reglsLros para un ms adelanLe.
A"@,(#)-( %" 6)-6/(,#- @"'")14R #'( %'# /$B.#+/'# 7BQ CBQ DB G <B EG #*# C/-&&.'($# DSQ DLQ
JSQ JLQ $+&6F 0*$Q - ,.C$/$(&.- ,$ %'# ,$4?# /$B.#+/'# ,$ %- 123Q 5*$,$( *+.%.=-/#$ 5-/-
-%4-&$(-/ &*-%0*.$/ ,-+'Q +-(+' ,$ T &'4' ,$ UV >.+#6
Los reglsLros de propslLo general (Ax, 8x, Cx y ux) pueden almacenar un valor de 16 blLs cada uno. or e[emplo, para
aslgnar el valor 0037h a Cx lo hacemos asl:
mov cx, 0057h
Adems, esLos reglsLros se subdlvlden en dos, su parLe alLa y su parLe ba[a, que pueden ser accedldos
lndependlenLemenLe. or e[emplo, 8x se dlvlde en 8P y 8L
11
. ara aslgnar un valor de 8 blLs, por e[emplo 2lh, a la parLe
alLa de 8x lo hacemos asl:
mov bh, 2Fh
Los reglsLros de propslLo general son los n|cos que pueden subdlvldlrse en parLes de 8 blLs.

11
Las leLras L y n vlenen de %'< y W.BW, en lngles, que slgnlflcan ba[o" y alLo".

"##$%&'$( 12
!"#$%!& !"#$%&''!(")# !"#$%&#
INS1kUCCICNLS DL ASIGNACICN
MCv
?a la vlmos anLerlormenLe, vlene de 4'@$ y slrve para reallzar un aslgnacln. La forma general es:
MOV Destino, Fuente
Su funcln es aslgnar el valor de Fuente a Destino. Slo Fuente puede ser un numero, Destino (' porque no
serla un lugar vlldo donde aslgnar un daLo.
L[emplos:
mov ax, 000Fh ; Asignar el valor F en hexa a AX
mov cx, ax ; Copiar el valor de AX en CX (CX pasa a valer
000Fh)
mov dl, 01111101b ; Asignar el valor 1111101 en binario a DL
mov bh, 7 ; Asignar el valor 7 en decimal a BH
xCPC
xCPC nombre vlene de $I&W-(B$ y su funcln es lnLercamblar los valores de los dos operandos.
XCHG Operando1, Operando2
Luego de e[ecuLar esLa lnsLruccln, Operando1 Lendr el valor orlglnal de Operando2 y vlceversa. ClaramenLe, ('
5*$,$ uLlllzarse un numero como nlnguno de los operandos, ya que no habrla lugar donde almacenar uno de los daLos.
L[emplo:
mov ax, 1 ; AX = 1
mov bx, 2 ; BX = 2

xchg ax, bx ; Intercambiar AX y BX
; Ahora AX = 2 y BX = 1
INS1kUCCICNLS AkI1ML1ICAS 8SICAS
Auu
Lo vlmos anLerlormenLe. Suma los dos operandos y guarda el resulLado sobre el prlmero.
ADD Destino, Operando2
Ls declr, luego de e[ecuLar la operacln, Destino Lendr su valor orlglnal ms el Operando2. lgual que como con
MCv, slo el Operando2 puede ser un valor numerlco.
L[emplo:

"##$%&'$( 13
mov ah, 1 ; AH = 1
mov al, 2 ; AL = 2

add ah, al ; AH = AH + AL
; Ahora AH = 3
lnC
lnC vlene de .(&/$4$(+-/. Ls una lnsLruccln especlal que slrve para sumar 1.
INC Destino
lunclonalmenLe, es equlvalenLe a ADD Destino, 1 pero es 4?# /?5.,-. Ls muy comun que en los programas
queramos lncremenLar algun reglsLro en 1 (por e[emplo sl esLamos conLando algo), por eso es que exlsLe esLa
lnsLruccln especlal.
L[emplos:
mov dx, 6 ; DX = 6
inc dx ; DX = 7
inc dx ; DX = 8
inc dx ; DX = 9
Su8
Su8 vlene de #*>+/-&+ y slrve para reallzar una resLa.
SUB Destino, Operando2
Ll resulLado de la operacln serla equlvalenLe a la slgulenLe expresln en un lengua[e de alLo nlvel:
Destino = Destino - Operando2
La resLa es slempre en ese orden (Destino - Operando2) y no al reves.
L[emplo:
mov dh, 10 ; DH = 10
mov bl, 2 ; BL = 2

sub dh, bl ; DH = DH BL
; Ahora DH = 8
uLC
uLC, de ,$&/$4$(+-/, slrve para resLar 1.
DEC Destino
ue forma slmllar a lo que sucede con lnC, la lnsLruccln anLerlor es equlvalenLe a SUB Destino, 1 pero es ms
rplda. 1amblen es muy comun decremenLar un reglsLro en 1 en los programas Assembler, por eso es que exlsLe esLa
lnsLruccln especlal.

"##$%&'$( 14
UN LILMLC SIMLL
A conLlnuacln presenLamos un programa de e[emplo uLlllzando las lnsLrucclones bslcas que acabamos de ver.
P$-%.&$ *( 5/'B/-4- $( D##$4>%$/ 0*$ &-%&*%$ $% /$#*%+-,' ,$% #.B*.$(+$ &?%&*%' -/.+4X+.&' G %' -%4-&$($ $( $% /$B.#+/'
Y:6
EUZTT [ ZZZ\F ] E^_` ] Ua`F
.MODEL SMALL
.STACK
.DATA
.CODE
inicio:

mov ds, ax ;

; Resolver el primer parntesis (el resultado queda en DX)
mov dx, 1988
add dx, 9992

; Resolver el segundo parntesis (el resultado queda en AX)
mov ax, 530
sub ax, 170

; Resolver la resta entre los dos parntesis
; (el resultado queda en DX)
sub dx, ax

int 21h ;

END inicio
Los programas que haremos sern programas no lnLeracLlvos, sln sallda por panLalla. Sl blen esLos no represenLan
programas reales, son mucho ms slmples al momenLo de aprender Assembler.
Lo que nos lnLeresa no es crear programas uLlles con Assembler, slno enLender cmo funclonan los programas que
creamos. ara ver cmo Lraba[a el programa, paso a paso, podemos uLlllzar un debugger como el b/*>' Y$>*BB$/ de
8orland.


"##$%&'$( 13
!"!#$%& ( !"#$"%&'(
LACkGANI2ACICN DL LA MLMCkIA
La mlnlma unldad de memorla que se puede leer o escrlblr en un procesador lnLel 8086 son 8 b|ts (1 byLe). no se
pueden acceder a fracclones lnferlores.
8E',51 *',%1% %" 5"5-),1 %,)"++,-'104"R $# %- 4c(.4- 5'/&.A( ,$ 4$4'/.- - %- 0*$ #$
5*$,$ -&&$,$/ E%$$/ ' $#&/.>./F6
Ln camblo, como mxlmo se puede acceder a 16 b|ts (2 byLes o 1 palabra) slmulLneamenLe.
8FG,51 *',%1% %" 5"5-),1 %,)"++,-'104"R $# %- 4?I.4- &-(+.,-, ,$ >.+# 0*$ 5*$,$( #$/
-&&$,.,'# E%$c,'# ' $#&/.+'#F #.4*%+?($-4$(+$6
La memorla puede ser pensada como una secuencla de byLes, uno deLrs del oLro. CeneralmenLe se represenLa como
una Labla verLlcal:
0Ah
F6h
14h
44h
.
A cada celda de memorla de 1 byLe se le aslgna una d|recc|n. La dlreccln de memorla es un numero que ldenLlflca a la
celda en cuesLln y nos permlLe hacer referencla a ella para escrlblr o leer un valor. A cada celda de memorla
consecuLlva se le aslgna un valor lncremenLal.
D|recc|n Conten|do
00001h 0Ah
00002h F6h
00003h 14h
00004h 44h
. .
odemos pensar en las dlrecclones de memorla como sl fueran las dlrecclones de vlvlendas. Sl queremos enconLrar un
lugar en la cludad, debemos conocer su dlreccln. Sl queremos enconLrar un byLe en la memorla, Lamblen.
Las ce|das de memor|a del lnLel 8086 Llenen 8 b|ts cada una. Las d|recc|ones de memor|a son numeros de 20 b|ts que
ldenLlflcan a cada celda de memorla.
"( $% M(+$% T`TV %-# ,./$&&.'($# ,$ 4$4'/.- #'( (d4$/'# ,$ HI 0,#(6


"##$%&'$( 16
MLMC8lA SLCMLn1AuA
Al dlsenar la arqulLecLura 8086, lnLel decldl permlLlr dlrecclonar hasLa 1 M8 de memorla. or eso el bus de dlrecclones
se hlzo de 20 blLs (ya que 2
20
= 1048376 = 1M). Ll problema es que, como dl[lmos, el procesador 8086 slo puede
mane[ar daLos de 16 blLs como mxlmo.
ara resolver esLe problema y permlLlr un Lamano mayor de memorla (con 16 blL slo puede accederse a 2
16
= 63336 =
64k), lnLel lmplemenL un slsLema de memor|a segmentada.
Ln esLe slsLema, una memorla se expresa como dos numeros de 16 blLs. Ll prlmero (llamado numero de segmento),
permlLe selecclonar una porcln de memorla de hasLa 64 k8, y el segundo (llamado desp|azam|ento) permlLe
dlrecclonar 1 byLe denLro de ese segmenLo de memorla. La noLacln es la slgulenLe:
SEGMENTO : DESPLAZAMIENTO

LsLe esquema es slmllar al uso de meses y dlas en el calendarlo: cada fecha esL formada por un numero enLre 1 y 12, el
mes, y oLro enLre 1 y 31, el dla denLro del mes. LsLo es equlvalenLe al segmenLo (mes) y al desplazamlenLo (dla) de una
dlreccln segmenLada. La fecha se escrlbe dla/mes y la dlreccln segmenLo:desplazamlenLo.
La unlca dlferencla, es que en el esquema de memorla segmenLada los segmenLos se superponen. Cada segmenLo
comlenza 16 byLes despues del segmenLo anLerlor, pero el desplazamlenLo permlLe dlrecclonar 64 k8 a parLlr del
comlenzo del segmenLo. Ls claro que a parLlr del byLe 17 esLaremos plsando" el segmenLo slgulenLe. Ls como sl en las
fechas fuera vlldo poner 41/1 (que serla, en realldad, 10/2). LnLonces, en el esquema de memorla segmenLada un
mlsmo byLe puede nombrarse de varlas formas, camblando el segmenLo y el desplazamlenLo.
A menudo los daLos de un programa se ublcan denLro de un solo segmenLo, o blen el segmenLo se da por
sobreenLendldo. Ln esos casos, es comun referlrse a la ,./$&&.A( ,$ 4$4'/.- 1000h cuando, en realldad, deberlamos
declr formalmenLe el ,$#5%-=-4.$(+' 1000h denLro del segmenLo acLual.

SLCMLn1C 0
SLCMLn1C 1
SLCMLn1C 2
16 byLes
uLSLAZAMlLn1C
uLSuL LL lnlClC uLL
SLCMLn1C

"##$%&'$( 17
SLCMLn1CS Ln LCS 8CC8AMAS
un programa uLlllza dlsLlnLos segmenLos de memorla para almacenar sus daLos e lnsLrucclones. uos de los segmenLos
ms uLlllzados son el segmento de datos, donde se almacenan Lodos los daLos (por e[emplo, las varlables) que uLlllza el
programa, y el segmento de cd|go, donde se encuenLran las lnsLrucclones del programa. Ln nuesLro cdlgo, esLos
segmenLos esLn marcados por las dlrecLlvas .DA1A y .CCDL.
La Cu uLlllza reglsLros especlales, conocldos como reg|stros de segmentos, para almacenar los segmenLos
correspondlenLes a cada rea del programa. Ln parLlcular:
DS: almacena el segmenLo de datos.
CS: almacena el segmenLo de cd|go.
L'# 5/'B/-4-# *+.%.=-( ,'# #$B4$(+'# ,$ 4$4'/.- 5/.(&.5-%$#R $% ("@5"'#- %" +/%,@-
E0*$ #$ -%4-&$(- $( $% /$B.#+/' D!F G $% ("@5"'#- %" %1#-( E0*$ #$ -%4-&$(- $( $%
/$B.#+/' <!F6
Mlremos algunas de las prlmeras llneas de nuesLro esqueleLo bslco de cdlgo Assembler:
.DATA

; --> Ac va la declaracin de variables <--

.CODE
inicio:

mov ds, ax ;

; --> Ac va nuestro cdigo <--
vemos que la declaracln de varlables se hace deba[o de 6YDbD. 1odo lo que pongamos ahl lr a parar al segmenLo de
daLos del programa.
Ln 618Y" arranca nuesLro programa. Las dos prlmeras llneas lo que hacen es lnlclallzar el reglsLro uS con la dlreccln
del segmenLo de daLos. QDA1A represenLa la dlreccln correspondlenLe al segmenLo de daLos. LsLo se copla en Ax
(MCv Ax, [uA1A) y luego de Ax se pasa a uS.
12

Ln Assembler una dlreccln se escrlbe asl:
DS:[DESPLAZAMIENTO]
Ln lugar de uS puede ponerse oLro reglsLro de segmenLo, pero lo ms comun es dlrecclonar slo sobre el segmenLo de
daLos. or e[emplo, para coplar el conLenldo del byLe 22 denLro del segmenLo de daLos a AL harlamos lo slgulenLe:
mov al, ds:[22]
Lo ms comun es escrlblr las dlrecclones de memorla uLlllzando numeros hexadeclmales. ue esa manera, el e[emplo
anLerlor quedarla: mov al, ds:[16h].

12
LsLo se hace asl porque exlsLen resLrlcclones en cuanLo a cmo puede aslgnarse valores a un reglsLro de segmenLo. La unlca
operacln MCv permlLlda que Llene a uS como desLlno de la aslgnacln es MCv uS, Ax. or lo LanLo, hay que cargar el valor prlmero
en Ax y luego pasrselo a uS.

"##$%&'$( 18
ul8LCClCnAMlLn1C uL uA1CS uL 1AMARC WC8u
ul[lmos que la memorla esL dlvldlda en byLes. Cmo podemos, enLonces, almacenar daLos de 16 blLs? SlmplemenLe,
uLlllzando dos celdas de memorla.
La arqulLecLura lnLel 8086 almacena los daLos de Lamano word en un formaLo llamado ||tt|e end|an. Ln esLe formaLo se
guarda prlmero la parLe ba[a (los blLs 0 a 7) y luego la parLe alLa (los blLs 8 a 13). Ls declr, para almacenar el daLo
1011111000100000h (8L20h) a parLlr de la dlreccln 1000h:
D|recc|n Conten|do
1000h 20h
1001h BEh
Ll numero queda almacenado al reves". Sl lo leyeramos en orden quedarla 208Lh, en lugar de 8L20h.
D% -%4-&$(-/ (d4$/'# ,$ UV >.+#Q #$ -%4-&$(- 6),5")- 41 61)#" 0121 J 4*"@- 41 61)#" 14#1
EC'/4-+' 4,##4" "'%,1'F6
ara escrlblr o leer un daLo de 16 en memorla, debemos especlflcar slo la dlreccln del prlmero de los byLes (la parLe
ba[a). or e[emplo, sl queremos cargar en Ax el daLo del e[emplo anLerlor:
mov ax, ds:[1000h]
Ll ensamblador deLermlna que porcln de la memorla leer en base al oLro operando. Ln esLe caso, como puslmos Ax y
Ax es un reglsLro de 16 blLs, Lraeremos de memorla 16 blLs (los ublcados en 1000h y 1001h). Sl hubleramos puesLo, por
e[emplo, AL que es de 8 blLs, hubleramos leldo slo el byLe ublcado en 1000h.
ue lo anLerlor se desprende que slempre que uLlllcemos una dlreccln de memorla en una lnsLruccln, e| otro
operando debe ser un reg|stro, para que le lndlque al ensamblador sl esLamos Lraba[ando con 8 o 16 blLs.
CLra opcln es uLlllzar los descrlpLores de Lamano 81L 1k y WCkD 1k para lndlcar el Lamano de un daLo de
memorla. ue esa forma, no hay problema en uLlllzar una dlreccln y un numero:
mov word ptr ds:[1000h], 250
Sablendo que 230 es 00lAh en blnarlo de 16 blLs, la lnsLruccln anLerlor resulLa en:
D|recc|n Conten|do
1000h FAh
1001h 00h
CKL; MLA .(,.&- 0*$ %- ,./$&&.A( ,$ 4$4'/.- W-&$ /$C$/$(&.- - *( ,-+' ,$ T >.+# EU >G+$F6
N9A< MLA .(,.&- 0*$ %- ,./$&&.A( W-&$ /$C$/$(&.- - *( ,-+' ,$ UV >.+# EU <'/,F6
VAkIA8LLS LN ASSLM8LLk
una varlable en Assembler es slmplemenLe un nombre que se da a una dlreccln de memorla. 1raba[ar con los
desplazamlenLos de memorla dlrecLamenLe es poco prcLlco ya que sl agregamos daLos o movemos daLos de lugar, la
dlreccln de memorla camblar y deberemos correglr Lodos los punLos en el cdlgo que uLlllzan esa dlreccln. Al uLlllzar

"##$%&'$( 19
nombres slmbllcos (varlables) para las dlrecclones de memorla, nos olvldamos del verdadero valor de la dlreccln y
de[amos que el ensamblador se ocupe de reemplazar el nombre de la varlable por la dlreccln aproplada.
3(- 31),104" $( D##$4>%$/ $# *( ('4>/$ 0*$ #$ -#.B(- - *(- ,./$&&.A( ,$ 4$4'/.-6 "%
$(#-4>%-,'/ #$ $(&-/B- ,$ /$$45%-=-/ %-# @-/.->%$# ,$ (*$#+/' &A,.B' 5'/ %- ,./$&&.A( ,$
4$4'/.- -5/'5.-,-6
Las varlables se declarar en la seccln .DA1A del cdlgo uLlllzando el slgulenLe formaLo:
NOMBRE TAMAO VALOR_INICIAL
nCM88L es, claramenLe, el nombre que queremos darle a la varlable, lgual que en los lengua[es de alLo nlvel.
1AMARC lndlca sl el daLo a almacenar en esa varlable es un byLe (8 blLs) o una word (16 blLs). Ll Lamano se especlflca
uLlllzando u8 o uW, para byLes o words respecLlvamenLe.
13

<CR M(,.&- 0*$ %- @-/.->%$ -%4-&$(- @-%'/$# ,$ +-4-e' >G+$6 <NR M(,.&- 0*$ %- @-/.->%$
-%4-&$(- @-%'/$# ,$ +-4-e' <'/,6
L[emplos:
.DATA
NumeroPrimo DW 29
Mes DB 6
Resultado DW ?
NumeroPrimo, por e[emplo, reservar un espaclo de \ >G+$# y en el escrlblr el numero 29 (en blnarlo de 16 blLs). Ln
memorla quedar:
00011101
00000000
Mes reservar un espaclo de U >G+$, lnlclallzado con el valor 6:
00000110
or ulLlmo, Resultado reservar oLro espaclo de \ >G+$#, pero (' /$-%.=-/? *(- .(.&.-%.=-&.A(. LsLo slgnlflca que el
conLenldo de la memorla quedar con cualquler valor que hublera alll en el momenLo de reallzar la reserva de memorla
(Lal vez un valor uLlllzado por algun oLro programa que se e[ecuL anLerlormenLe). or e[emplo (aunque podrla ser
&*-%0*.$/ @-%'/):
01011001
11001100
1*-(,' *+.%.=-4'# $% #.B(' O &'4' @-%'/ .(.&.-% ,$ %- @-/.->%$Q #A%' $#+-4'# /$#$/@-(,' $%
$#5-&.'Q 5$/' #.( $#+->%$&$/ *( @-%'/ .(.&.-%6 L- 4$4'/.- 0*$,-/? &'( $% @-%'/ 0*$ +*@.$/-
W-#+- $#$ 4'4$(+'6
Uf

13
LxlsLen oLros descrlpLores de Lamano (uu, uC, eLc.) pero no los nombramos porque no sern uLlllzados en esLe apunLe.

"##$%&'$( 20
Las varlables quedan en memorla en forma consecut|va, Lal cual como se fueron declarando en el cdlgo:
00011101
00000000
00000110
01011001
11001100
vlmos que para uLlllzar una dlreccln de memorla en nuesLro cdlgo debemos uLlllzar la slnLaxls DS:[Direccin].
or e[emplo, sl la dlreccln de la varlable numerorlmo fuera 12AAh, para coplar su valor en ux uLlllzarlamos el
slgulenLe cdlgo:
mov ax, ds:[12AAh]
Cuando uLlllzamos varlables, la slnLaxls se slmpllflca muchlslmo:
mov ax, NumeroPrimo
lunclona exacLamenLe lgual que en los lengua[es de alLo nlvel.
C81LnL8 LA ul8LCClCn uL unA vA8lA8LL
Como dl[lmos, las varlables nos absLraen de la dlreccln real del daLo. SlmplemenLe uLlllzando el nombre de la varlable
accedemos al &'(+$(.,' de la dlreccln de memorla. Sln embargo, a veces puede lnLeresarnos conocer la ,./$&&.A( de
una varlable. Cmo hacemos? uLlllzamos el comando CllSL1:
mov bx, offset Resultado
uLlllzando el e[emplo anLerlor, esLamos almacenando en 8x la dlreccln de la varlable 8esulLado. Ms adelanLe
veremos cmo esLo puede sernos de uLllldad.
uLCLA8AClCn uL A88LCLCS
Sl queremos declarar un arreg|o de daLos (una secuencla ordenada de daLos del mlsmo Lamano), lo hacemos con la
mlsma slnLaxls anLerlor, slo que esLa vez ponemos varlos valores de lnlclallzacln separados por comas:
NOMBRE TAMAO_ELEMENTO ELEMENTO_0, ELEMENTO_1, ...
or e[emplo:
.DATA
Pares DB 2, 4, 6, 8
Ln memorla, obLendremos esLo:
00000010
00000100
00000110
00001000
Ln el caso de los arreglos, la varlable ldenLlflca la dlreccln del pr|mer e|emento. or e[emplo:

14
Ln general, de[ar varlables sln lnlclallzar no es una buena ldea y puede llevar a errores en el cdlgo sl uLlllzamos lnadverLldamenLe
la varlable sln aslgnarle un valor prevlamenLe.

"##$%&'$( 21
mov ah, Pares
Ll cdlgo anLerlor carga el prlmer elemenLo del arreglo ares en AP. Con lo que AP pasar a Lener el valor 2
(00000010b).
Sl queremos acceder a oLros elemenLos del arreglo, podemos uLlllzar una noLacln de sublndlce:
NOMBRE_ARREGLO[DESPLAZAMIENTO]
Ll valor uLSLAZAMlLn1C, enLre corcheLes, lndlca cunLos bytes debemos avanzar desde la dlreccln del prlmer
elemenLo. or e[emplo, Pares[1] equlvale al #$B*(,' elemenLo del arreglo ares (ya que nos corremos 1 byLe desde
el lnlclo).
CLros e[emplos:
mov al, Pares[0] ; Obtiene el primer elemento (00000010)
mov ah, Pares[1] ; Obtiene el segundo elemento (00000100)
mov bl, Pares[2] ; Obtiene el tercer elemento (00000110)
mov bh, Pares[3] ; Obtiene el cuarto elemento (00001000)
Cabe noLar que Pares y Pares[0] son equlvalenLes, ya que Pares[0] lndlca un desplazamlenLo de 0 byLes desde
el comlenzo del arreglo.
2-/- '>+$($/ *( $%$4$(+' ,$ *( -//$B%'Q *#-4'# $% ('4>/$ ,$% -//$B%' #$B*.,' ,$ *(
(d4$/' $(+/$ &'/&W$+$#6 "% (d4$/' .(,.&- &*?(+'# 0J#"( ,$>$4'# -@-(=-/ ,$#,$ $%
&'4.$(=' ,$% -//$B%' 5-/- '>+$($/ $% $%$4$(+'
A88LCLCS uL WC8uS
Los arreglos de words, se declaran lgual que los de byLes, pero usando uW:
.DATA
NumerosGrandes DW 1002h, 55A1h, 3037h, 000Fh
LsLe e[emplo, produce el slgulenLe resulLado en memorla (recordar que se almacenan con el ordenamlenLo %.++%$
$(,.-().
02h
10h
A1h
55h
37h
30h
0Fh
00h
La regla para acceder a cada elemenLo del arreglo slgue slendo la mlsma: poner enLre corcheLes el desplazamlenLo en
bytes desde el comlenzo del arreglo. ue modo que:
rlmer elemenLo: NumerosGrandes[0]
Segundo elemenLo: NumerosGrandes[2]

"##$%&'$( 22
1ercer elemenLo: NumerosGrandes[4]
CuarLo elemenLo: NumerosGrandes[6]
SlmplemenLe, hay que recordar que el desplazamlenLo es s|empre en bytes, ms all de que sea un arreglo de words.
A88LCLCS Sln lnlClALlZA8
Sl queremos declarar un arreglo pero no lnlclallzarlo (no darle un valor dlsLlnLo a &-,- elemenLo), podemos uLlllzar la
dlrecLlva uu. Ll slgulenLe e[emplo, declara un arreglo de 30 elemenLos de Llpo byLe, Lodos lnlclallzados en 0.
Arreglo DB 50 DUP (0)
Ls declr, se pone la canLldad de elemenLos (30), uu y, enLre parenLesls, el valor con que se lnlclallzan +','# los
elemenLos. Ll e[emplo anLerlor reserva 30 lugares de 1 byLe, Lodos con el valor 0.
Sl no queremos lnlclallzar el arreglo con (.(Bd( valor, podemos usar:
Arreglo DB 50 DUP (?)
CA8AC1L8LS
Ln Assembler, los caracLeres se represenLan uLlllzando el cdlgo ASCll
13
. Cada carcLer ASCll ocupa 8 blLs, de modo que
podemos declarar una varlable para almacenar un carcLer uLlllzando u8:
Caracter DB 41h
ara especlflcar el daLo, podemos uLlllzar LanLo el valor ASCll en declmal, hexadeclmal (como en el e[emplo) o blnarlo, o
blen escrlblr el carcLer enLre comlllas. 1odas las represenLaclones son equlvalenLes y, en el ulLlmo caso, es el
ensamblador qulen se encarga de hacer la Lraduccln al momenLo de generar el cdlgo de mqulna. Ll e[emplo anLerlor
es equlvalenLe a:
Caracter DB "A"
ue hecho, "A" puede uLlllzarse como reemplazo de 41h en cualquler lugar del cdlgo (no slo en la declaracln de
varlables). Lscrlblr MOV AL, "A" es LoLalmenLe vlldo. (Ax ser cargar con 41h = 01000001b).
S18lnCS
Ln Assembler, los sLrlngs no son ms que un arreg|o de caracteres. or lo LanLo, la declaracln de un sLrlng es la
slgulenLe:
Nombre DB "M", "a", "r", "i", "a", "n", "o"
ueclaramos un arreglo de bytes e lnlclallzamos cada elemenLo con el carcLer ASCll correspondlenLe. LsLo nos dar
como resulLado, en memorla, lo slgulenLe:

13
ASCll: D4$/.&-( 9+-(,-/, 1',$ C'/ M(C'/4-+.'( M(+$/&W-(B$, Cdlgo LsLadounldense LsLndar para el lnLercamblo de
lnformacln". Se pronuncla generalmenLe como askl". Ll cdlgo ASCll represenLa cada carcLer como un numero de 8 blLs. or
e[emplo, la A" es 01000001, la 8" es 01000010, eLc.

"##$%&'$( 23

4Dh
61h
72h
69h
61h
6Eh
6Fh
ara slmpllflcar la noLacln, Assembler provee una forma ms convenlenLe e lnLulLlva de lnlclallzar un sLrlng:
Nombre DB "Mariano"
Ll efecLo esLe cdlgo es $I-&+-4$(+$ el mlsmo que el del e[emplo anLerlor.

"##$%&'$( 24
!"#"$ #& #'(&))'"*+!!"#$%
LCS CLkANDCS
PasLa ahora hemos vlsLo varlas formas de expresar los operandos de una lnsLruccln en Assembler:
mov ax, bx ; Utilizando registros solamente
mov dh, 7 ; Utilizando valores numricos
mov dl, "x" ; Utilizando caracteres ASCII
mov ds:[150Ah], cx ; Utilizando una direccin de memoria explcita
mov bx, suma ; Utilizando variables
mov ah, lista[5] ; Utilizando variables de tipo arreglo
Los operandos de una lnsLruccln se pueden claslflcar bslcamenLe en Lres Llpos:
keg|stro: Ll operando esL conLenldo en uno de los reglsLros de la Cu. (Ln Lodos los e[emplos de arrlba
uLlllzamos reglsLros en alguno de los operandos).
D|recc|n de memor|a: ublcacln denLro de la memorla del programa donde se encuenLra el operando.
(odemos usar una dlreccln de memorla escrlblendola dlrecLamenLe o uLlllzando varlables).
Constante: un valor especlflcado dlrecLamenLe en el cdlgo. (or e[emplo un numero o un carcLer ASCll).
Ln general, para una operacln con dos operandos (como MCv) exlsLen las slgulenLes poslbllldades
16
:
MCv 8eglsLro, 8eglsLro
MCv 8eglsLro, ConsLanLe
MCv 8eglsLro, ulreccln de memorla
MCv ulreccln de memorla, 8eglsLro
MCv ulreccln de memorla, ConsLanLe
noLar que no ex|sten operac|ones entre d|recc|ones de memor|a. Sl, por e[emplo, se qulere coplar el conLenldo de una
dlreccln de memorla en oLra dlreccln, se debe llevar el daLo prlmero a un reglsLro y luego del reglsLro a la nueva
poslcln. ara llevar el conLenldo de la dlreccln 18C0h a la dlreccln 9lC3h:
mov ax, ds:[1BC0h] ; Copiar el contenido de la direccin 1BC0h en AX
mov ds:[9FC5h], ax ; Pasar lo copiado en AX a la direccin 9FC5h
P- "G,(#"' '5$/-&.'($# 0*$ *+.%.&$( #.4*%+?($-4$(+$ ,'# ,./$&&.'($# ,$ 4$4'/.-6
9.$45/$ 0*$ *( '5$/-(,' $# *(- ,./$&&.A(Q $% '+/' ,$>$ #$/ ' >.$( *( /$B.#+/' ' >.$( *(-
&'(#+-(+$6
noLar, adems, que |as constantes s|o pueden ut|||zarse como operando derecho, ya que el prlmer operando se
uLlllza para almacenar el resulLado de la operacln, con lo cual slo puede ser un reglsLro o una dlreccln de memorla.

16
Pay que Lener en cuenLa que las poslbllldades para cada operando dependen de cada lnsLruccln en parLlcular. ara conocer que
poslbllldades exlsLen para cada lnsLruccln hay que leer la especlflcacln de la arqulLecLura provlsLa por el fabrlcanLe, en esLe caso
lnLel. uede vlslLar hLLp://www.lnLel.com/deslgn/enLlum4/documenLaLlon.hLm para enconLrar los manuales de la arqulLecLura lnLel
x86 (formalmenLe conoclda como lA-32).

"##$%&'$( 23
MCuCS uL ul8LCClCnAMlLn1C
Los modos de d|recc|onam|ento son las dlsLlnLas formas que Lenemos de lndlcar en una lnsLruccln la ublcacln de uno
de los operandos. A conLlnuacln veremos los modos de dlrecclonamlenLo poslbles en la arqulLecLura lnLel 8086:
lnMLulA1C
un operando uLlllza d|recc|onam|ento |nmed|ato sl esL escrlLo como una constante denLro de la lnsLruccln. or
e[emplo, el operando derecho de esLa lnsLruccln uLlllza dlrecclonamlenLo lnmedlaLo:
add ax, 50
ara especlflcar un operando con dlrecclonamlenLo lnmedlaLo podemos uLlllzar numeros blnarlos, declmales y
hexadeclmales, y Lamblen caracLeres ASCll.
lnPL8Ln1L C uL 8LClS18C
un operando uLlllza dlrecclonamlenLo |nherente (o de reglsLro) sl esL ublcado denLro de un reg|stro de la Cu. Ln el
slgulenLe e[emplo, ambos operandos uLlllzan dlrecclonamlenLo lnherenLe:
mov ax, bx
ul8LC1C
un operando uLlllza d|recc|onam|ento d|recto sl esL ublcado en una memorla y |a d|recc|n de memor|a se espec|f|ca
exp||c|tamente en |a |nstrucc|n o blen uLlllzando una varlable. L[emplos:
mov ax, ds:[107Ah]
mov bx, numeroPrimo
sub ch, arreglo[7]
lnul8LC1C C8 8LClS18C
LsLa es una forma que no hablamos vlsLo anLes. un operando uLlllza d|recc|onam|ento |nd|recto sl esL ublcado en
memorla y |a d|recc|n de memor|a se espec|f|ca a travs de un reg|stro. ara lndlcarlo escrlblmos:
DS:[REGISTRO]
Los unlcos reglsLros admlLldos en esLe modo son: 8k, 8, DI y SI. or e[emplo:
mov ax, ds:[bx]
noLar la dlferencla con el e[emplo de dlrecclonamlenLo lnherenLe. Aqul 8x, al esLar enLre corcheLes, lndlca una
dlreccln de memorla. ara reallzar la operacln hay que leer el conLenldo del reglsLro y luego uLlllzar la dlreccln de
memorla obLenlda para enconLrar el daLo.


"##$%&'$( 26
Supongamos que 8x = 3A10h y que el conLenldo de la memorla es el slgulenLe:
D|recc|n Conten|do
5A10h 00001000
5A11h 11110101
Al e[ecuLar la lnsLruccln del e[emplo, Ax ser cargado con 1111010100001000b. odrlamos hacer las slgulenLes
equlvalenclas funclonales:
mov ax, ds:[bx] ! mov ax, ds:[5A10h] ! mov ax, 1111010100001000b

Las Lres lnsLrucclones Llenen el mlsmo resulLado: Ax es cargado con 1111010100001000b. ero la ublcacln del daLo es
dlsLlnLa en cada caso: la prlmera uLlllza dlrecclonamlenLo lndlrecLo, la segunda dlrecclonamlenLo dlrecLo y la Lercera
dlrecclonamlenLo lnmedlaLo.
9.$45/$ 0*$ $#&/.>.4'# <!.Q%,)"++,/'R $#+-4'# .(,.&-(,' 0*$ $% ,-+' #$ $(&*$(+/- $(
5"5-),16 L' 0*$ @- $(+/$ &'/&W$+$# $# %- %,)"++,/' ,$% ,-+'Q G- #$- 0*$ #$ $#&/.>-
$I5%c&.+-4$(+$ E,./$&&.'(-4.$(+' ,./$&+'F ' - +/-@X# ,$ *( /$B.#+/' E,./$&&.'(-4.$(+'
.(,./$&+'F6
9. /$&'/,-4'# %' -(+$/.'/Q $# C?&.% ,.#+.(B*./ $(+/$ 89: 7B= CB G 89: 7B= <!.QCBR6
MCuCS uL ul8LCClCnAMlLn1C 8LLA1lvC
un operando uLlllza d|recc|onam|ento re|at|vo cuando |a d|recc|n de memor|a se espec|f|ca ut|||zando sumas de
reg|stros y constantes. Ll formaLo es el slgulenLe:
DS:[REGISTRO_BASE + REGISTRO_NDICE + CONSTANTE]
Los reglsLros base son 8k y 8. Los reglsLros |nd|ce son SI y DI. uede omlLlrse cualqulera de los dos reglsLros (pero no
ambos, ya que en ese caso Lendrlamos dlrecclonamlenLo dlrecLo).
L[emplos:
mov ax, ds:[bx + si + 5]
mov ds:[si + 01Ah], bh
add al, ds:[di + 1011b]
Ls muy comun uLlllzar dlrecclonamlenLo relaLlvo con arreglos. Ln ese caso, se acosLumbra a uLlllzar la slgulenLe
noLacln:
mov ax, arreglo[bx]
Ln esLe e[emplo, esLamos uLlllzando un reglsLro base (8x) y el lugar de la consLanLe numerlca lo Loma el nombre de la
varlable. CLros e[emplo:
add bx, numeros[bx + di]
Ln esLe caso, Lenemos LanLo un reglsLro base como uno lndlce. 1amblen puede uLlllzarse la noLacln
numeros[bx][di].

"##$%&'$( 27
!"#$%&''!(")# !" $%&'(%)
LILCUCICN DL kCGkAMAS
ara e[ecuLar un programa, la Cu reallza un clclo de Lres fases:
1. Ietch - 8squeda de |a |nstrucc|n: La Cu busca la lnsLruccln a e[ecuLar en el segmenLo de cdlgo y la carga
en la unldad de conLrol.
2. Decode - Decod|f|cac|n de |a |nstrucc|n: La unldad de conLrol lnLerpreLa el cdlgo de lnsLruccln dando
orlgen a los comandos necesarlos para su e[ecucln.
3. Lxecute - L[ecuc|n de |a |nstrucc|n: Se ublcan los operandos y se reallza la operacln lndlcada por la
lnsLruccln sobre los mlsmos. llnalmenLe, se almacena el resulLado de la operacln.
ara conocer la ublcacln de la lnsLruccln a e[ecuLar, la Cu uLlllza el reglsLro I (M(#+/*&+.'( 2'.(+$/, unLero de
lnsLruccln"). Ll l conLlene el desplazamlenLo denLro del segmenLo de cdlgo de la lnsLruccln acLual. (La dlreccln
compleLa de la lnsLruccln es CS:I). Cada vez que se compleLa el C$+&W de una lnsLruccln, l es lncremenLado
auLomLlcamenLe para apunLar a la slgulenLe lnsLruccln.
"% /$B.#+/' &M -%4-&$(- %- ,./$&&.A( ,$ %- .(#+/*&&.A( - $)$&*+-/6
Como los programas raramenLe slguen una secuencla llneal de e[ecucln slno que neceslLan lLerar y blfurcar, Assembler
provee lnsLrucclones especlales que nos permlLen camblar el reglsLro l.
8IIUkCACICNLS
!M
La lnsLruccln !M (g*45) nos permlLe salLar a cualquler punLo del cdlgo. La slnLaxls es como slgue:
JMP nombre_etiqueta
ara poder lndlcar a que lugar del cdlgo queremos salLar, debemos deflnlr una et|queta. Las eLlqueLas son nombres
slmbllcos para dlrecclones denLro del segmenLo de cdlgo (slmllares a las varlables en el segmenLo de daLos). ara
deflnlr una eLlqueLa, slmplemenLe ponemos un nombre seguldo de dos punLos (por e[emplo lnlclo:") a la alLura del
cdlgo hacla donde queramos salLar.
inicio: . . . .
. . . .
. . . .
jmp inicio
Lo que hace !M es camblar el punLero de lnsLruccln (CS:l) de manera que apunLe a la dlreccln especlflcada por la
eLlqueLa.
!M Lamblen se conoce como sa|to |ncond|c|ona|, porque slempre Lransflere el conLrol del programa a la eLlqueLa
especlflcada. un sa|to cond|c|ona|, en camblo, Lransferlr el conLrol a la eLlqueLa s| se cump|e c|erta cond|c|n, esLo es
equlvalenLe a una senLencla |f de un lengua[e de alLo nlvel.

"##$%&'$( 28
CM ? SAL1CS CCnulCl CnALLS
una de las esLrucLuras de conLrol ms bslcas es la consLruccln |f.e|se. or e[emplo, en 8uby:
if a == b

Instrucciones a ejecutar si a == b

else

Instrucciones a ejecutar si a != b

end

Instrucciones posteriores al bloque ifelse
ara emular el comporLamlenLo de esLa consLruccln de alLo nlvel en Assembler debemos hacer uso de lnsLrucclones
de comparacln y de salLos condlclonales. un e[emplo anlogo al anLerlor en Assembler:
cmp ax, bx
jne else

Instrucciones a ejecutar si ax == bx

jmp end
else:

Instrucciones a ejecutar si ax != bx

end:

CM se uLlllza para comparar dos valores. A conLlnuacln de CM debemos uLlllzar una lnsLruccln de salLo condlclonal
que salLar o no, dependlendo del resulLado de la comparacln.
or ahora, uLlllzaremos los slgulenLes salLos condlclonales
17
:
IL: SalLar sl son lguales
INL: SalLar sl no son lguales
IA: SalLar sl es mayor (Lodas las comparaclones son del el operando de la lzqulerda respecLo del de la derecha)
IAL: SalLar sl es mayor o lgual
I8: SalLar sl es menor
I8L: SalLar sl es menor o lgual
Ln el e[emplo se uLlllza la lnsLruccln CM para comparar Ax y 8x. A conLlnuacln se uLlllza la lnsLruccln de salLo
condlclonal !nL. !nL (g*45 .C K'+ "0*-%) reallza la blfurcacln a la eLlqueLa lndlcada sl la comparacln anLerlor dlo que
los operandos son dlsLlnLos.
LnLonces, sl la comparacln da que son dlsLlnLos se salLar a la eLlqueLa LLSL. Sl son lguales, se slgue e[ecuLando
normalmenLe. Ln esLe caso, la ulLlma lnsLruccln anLes del bloque LLSL debe ser un salLo hacla la prlmera lnsLruccln
luego del LLSL, ya que hay que salLear esLe bloque. ue esLa forma, logramos un cdlgo con el mlsmo comporLamlenLo
que la consLruccln lf.else de un lengua[e de alLo nlvel.

17
Las leLras en esLos salLos slgnlflcan en lngles: ! = g*45, L = "0*-%, n = K'+, A = D>'@$, 8 = J$%'<.

"##$%&'$( 29
noLar que la condlcln de salLo es la opuesta a la condlcln expresada en el cdlgo de alLo nlvel. LsLo es asl porque el lf
Lraba[a al reves, hace que se #-%+$$ el cdlgo slgulenLe sl (' se cumple la condlcln. Ls medlo un Lrabalenguas, pero
pensndolo un poco se enLlende.
veamos el e[emplo, paso a paso con numeros concreLos:
Supongamos que Ax = 3 y 8x = 2.
cmp ax, bx
jne else
Comparamos Ax con 8x y debemos salLar sl no son lguales a la eLlqueLa LLSL. Como [usLamenLe no son lguales (3 != 2),
la condlcln de salLo se cumple. LnLonces, salLamos y llegamos al slgulenLe cdlgo:
else:

Instrucciones a ejecutar si ax != bx
L[ecuLamos Lodas las lnsLrucclones y llegamos a:
end:

Cuando el cdlgo llega a una eLlqueLa, slmplemenLe la lgnora
18
. Asl que segulmos e[ecuLando las lnsLrucclones que
slguen.
volvamos a comenzar, pero ahora supongamos que Ax = 8x = 4.
cmp ax, bx
jne else
Comparamos Ax con 8x y debemos salLar sl no son lguales a la eLlqueLa LLSL. Como sl son lguales (4 == 4), la condlcln
de salLo no se cumple. or lo LanLo, no salLamos y segulmos e[ecuLando las slgulenLes lnsLrucclones normalmenLe:
Instrucciones a ejecutar si ax == bx

jmp end
Al Lermlnar de e[ecuLar las lnsLrucclones nos enconLramos con un salLo lncondlclonal (!M). LsLo qulere declr que, sln
evaluar nlnguna condlcln, salLamos dlrecLamenLe a la eLlqueLa lndlcada (Lnu):
end:


18
ue hecho, las eLlqueLas en las lnsLrucclones de salLo se reemplazan por el va|or de |a d|recc|n denLro del segmenLo de cdlgo al
ensamblar el programa, asl que las eLlqueLas denLro del cuerpo del cdlgo realmenLe no ex|sten en la versln en lengua[e de
mqulna.

"##$%&'$( 30
l1L8AClCnLS
l1L8AClCn ll!A
Assembler brlnda la lnsLruccln LCC para reallzar lLeraclones del Llpo for. Ll formaLo es:
mov cx, N
etiqueta:

Instrucciones a repetir N veces

loop etiqueta
LCC uLlllza Ck como conLador. Cx debe lnlclallzarse en el numero de lLeraclones. Cada vez que se e[ecuLa la
lnsLruccln LCC, Cx se decremenLa en 1 y se reallza la blfurcacln a la eLlqueLa lndlcada slo sl Cx es dlsLlnLo de 0.
Ll slgulenLe e[emplo llena de ceros un arreglo de 30 elemenLos:
mov cx, 50 ; Vamos a iterar 50 veces
mov si, 0 ; Comenzar por el elemento 0

siguiente:

mov arreglo[si], 0 ; Copiar un 0 al elemento actual del arreglo

inc si ; Ir al prximo elemento

loop siguiente ; Iterar
l1L8AClCn CCnulClCnAL
1amblen podemos reallzar lLeraclones de Llpo wh||e (mlenLras se cumple una condlcln). ara ello debemos uLlllzar un
esquema slmllar al slgulenLe:
mov si, 0 ; Comenzar por el elemento 0

siguiente:

cmp arreglo[si], 0FFh ; Si el elemento actual es FFh
je salir ; Salir del bucle

mov arreglo[si], 0 ; Copiar un 0 al elemento actual del arreglo


jmp siguiente ; Iterar

salir:
Ll fragmenLo de cdlgo anLerlor llena de ceros un arreglo mlenLras que el elemenLo acLual sea dlsLlnLo de llh.
Slgulendo el cdlgo paso a paso con un arreglo de e[emplo, es fcll ver cmo funclona.


"##$%&'$( 31
UN LILMLC CCMLL1C CCN CCN1kCL DL ILUIC
9$ +.$($ *( -//$B%' ,$ $%$4$(+'# ,$ +-4-e' >G+$6 "% d%+.4' $%$4$(+' ,$% -//$B%' +.$($ $% @-%'/ ``W E$#+$ @-%'/ (' #$
/$5.+$ $( (.(Bd( '+/' $%$4$(+'Q #A%' $( $% d%+.4'F6 P$-%.&$ *( 5/'B/-4- $( D##$4>%$/ 0*$ ,$+$/4.($ %- %'(B.+*, ,$%
-//$B%'Q #.( &'(+-/ $% d%+.4' $%$4$(+'Q G %- -%4-&$($ $( $% /$B.#+/' Y:6
.MODEL SMALL
.STACK
.DATA

arreglo DB 15h, 07h, 22h, 9Ah, 4Dh, 00h ; Datos de prueba

.CODE
inicio:

mov ds, ax ;

mov dx, 0 ; DX arranca en 0 (lo incrementaremos en la
; iteracin)
mov si, 0 ; SI va a apuntando a cada elemento

iterar:

cmp arreglo[si], 00h ; Si llegamos al final (valor 00h)
je fin ; salir del bucle

inc dx ; Incrementar la longitud (al terminar el
; bucle DX tendr la longitud total del
; arreglo)

jmp iterar ; Iterar

fin:

int 21h ;

END inicio


"##$%&'$( 32
!"#!$%&"' )*' +,+#-+!"#
N0MLkCS NLGA1IVCS
Ln el procesador lnLel 8086 los numeros enLeros negaLlvos se almacenan uLlllzando la represenLacln de comp|emento
a 2.
nuevamenLe, a los efecLos del almacenamlenLo en memorla, LanLo numeros negaLlvos (Ca2) como poslLlvos (8SS) son
slmples secuenclas de blLs. uepende de las lnsLrucclones que uLlllcemos para operar sobre esos daLos que los mlsmos
sean conslderados numeros poslLlvos, numeros negaLlvos o cualquler oLra cosa.
lnlClALlZAClCn uL vA8lA8LLS
ara declarar una varlable e lnlclallzarla con un numero negaLlvo, se puede hacer slmplemenLe escrlblendo un numero
expresado en cualqulera de los slsLemas hablLuales (blnarlo, hexadeclmal o declmal) precedldo de un s|gno menos. C
blen, en el caso de los numeros blnarlos y hexa, puede ponerse dlrecLamenLe un valor que represenLe un numero
negaLlvo (MS8 = 1):
numeros_negativos DB -2, -00011110b, -2Fh
otro_negativo DB 11111010 ; Equivale a -6 en Ca2 y a 250 en BSS
Ll slgno menos lo unlco que hace es obLener el complemenLo a 2 de la represenLacln blnarla del numero lndlcado. or
e[emplo:
2 " 00000010b " 11111110b
LsLo no qulere declr que el numero deba ser necesarlamenLe lnLerpreLado como negaLlvo. Ln el e[emplo anLerlor, el
byLe resulLanLe se lnLerpreLa como -2 en Ca2, y como 234 en 8SS.
ue hecho, uLlllzar un slgno menos delanLe del numero no garant|za que e| va|or resu|tante sea un nmero negat|vo
v||do en Ca2. Supongamos la slgulenLe declaracln:
numero DB -195
CbLendrlamos el slgulenLe resulLado:
195 " 11000011b " 00111101b
Ll valor resulLanLe es el numero 61, LanLo en 8SS como en Ca2. LsLo sucede porque (' $I.#+$ una represenLacln del
numero -193 en blnarlo Ca2 de 8 blLs. or ello hay que Lener mucho culdado al uLlllzar el slgno menos para especlflcar
un valor negaLlvo.
D% 5'($/ *( (,@'- 5"'-( ,$%-(+$ ,$ *(- &'(#+-(+$Q .(,.&-4'# 0*$ 0*$/$4'# 164,+1) 41
)"@41 %" +-564"5"'#1+,/' 1 H #'>/$ $#$ @-%'/6 "% (d4$/' /$#*%+-(+$ 5*$,$ #$/ ' ('
($B-+.@'Q ,$5$(,.$(,' ,$% @-%'/ '/.B.(-% E5*$#+' 0*$ #$ 5*$,$ 5/',*&./ *( ,$#>'/,$F6


"##$%&'$( 33
luLn1lllCAClCn uL vALC8LS nLCA1lvCS
Al Lraba[ar con Assembler, a menudo neceslLaremos lnLerpreLar valores expresados en blnarlo o en hexadeclmal. Sl
blen lleva su Llempo hacer la conversln para obLener el numero en formaLo declmal, a veces no neceslLamos saber el
numero en sl, slno sl se LraLa de un numero poslLlvo o negaLlvo, y esLo puede lograrse fcllmenLe.
8ecordemos que en Ca2, Lodo numero negaLlvo comlenza por 1 y Lodo poslLlvo comlenza por 0. LnLonces, para
deLermlnar sl un numero expresado en blnarlo es poslLlvo o negaLlvo, basLa m|rar e| va|or de| MS8 (blL ms
slgnlflcaLlvo)
19
.
ara los numeros hexadeclmales, parLlmos de la mlsma premlsa: el MS8 debe ser 1 para los negaLlvos. Cada dlglLo hexa
represenLa 4 blLs. Ln que dlglLos hexa el blL de la lzqulerda es 1?
8h = 1000b
9h = 1001b
Ah = 1010b
.
lh = 1111b
LnLonces, para saber sl un numero expresado en hexa es negaLlvo, basLa fl[arse que comlence por un dlglLo enLre 8 y l.
L'# @-%'/$# $I5/$#-,'# $( S"G1%"+,514 0*$ &'4.$(=-( 5'/ *( ,cB.+' $(+/$ T G UQ #'(
(d4$/'# '"@1#,3-( "' D1H6
LL kLGIS1kC DL ILAGS
?a hemos vlsLo el funclonamlenLo de casl Lodos los reglsLros de la Cu lnLel 8086. nos queda por comenLar uno muy
lmporLanLe: el reglsLro de f|ags (o banderas).
LsLe reglsLro es alLerado por las operaclones lglcas y arlLmeLlcas que reallza la ALu para lndlcar al procesador algunas
condlclones especlales del resulLado obLenldo.
Ll reglsLro de flags es un reglsLro de 16 blLs, de los cuales slo 9 Llenen una funcln deflnlda. La organlzacln del reglsLro
es la slgulenLe:
C u l 1 S Z A C
13 14 13 12 11 10 9 8 7 6 3 4 3 2 1 0
A conLlnuacln, descrlblmos el funclonamlenLo de los blLs ms relevanLes para nuesLro esLudlo:
2: 8lL de cero (V$/', en lngles). Se acLlva (se pone en 1) sl el resulLado de una operacln es 0.
S: 8lL de s|gno. Se acLlva sl el resulLado de la operacln es negaLlvo (es declr, sl el MS8 es 1).
C: 8lL de carry. Se acLlva sl hay un acarreo del MS8 en una operacln arlLmeLlca en 8SS.
C: 8lL de desborde (-@$/C%'<, en lngles). Se acLlve para lndlcar desborde en una operacln arlLmeLlca en Ca2.
L[emplo:

19
Pay que Lener culdado de esLar observando la represenLacln comp|eta del numero. or e[emplo, el numero 1110b (' es un
numero negaLlvo. ?a que, sl compleLamos el numero para hacerlo de 8 blLs, Lenemos 00001110b, con lo cual vemos que le MS8 es 0.
(Lo mlsmo sucede sl el numero fuera de 16 blLs).

"##$%&'$( 34
mov ax, 5
mov bx, 7
sub ax, bx ; El resultado es 11111110b
; Z = 0 (no es cero)
; S = 1 (MSB = 1 - negativo en Ca2)
; C = 1 (hubo carry en realidad, borrow)
; O = 0 (no hubo desborde en Ca2)
Sl blen descrlblmos los flags en base a operaclones arlLmeLlcas, esLos se uLlllzan en general para lndlcar dlsLlnLos
esLados resulLanLes de las operaclones reallzadas, ya sean arlLmeLlcas o no. ara saber cmo afecLa cada lnsLruccln al
reglsLro de flags, hay que consulLar las especlflcaclones del fabrlcanLe
20
.
MS CLkACICNLS
CL8AClCnLS LCClCAS
Anu
AND Destino, Operando2
8eallza la con[unc|n |g|ca blL a blL y guarda el resulLado en uesLlno.
mov al, 01001110b
mov ah, 00111001b
and al, ah
; AL = 00001000
C8
OR Destino, Operando2
8eallza la d|syunc|n |nc|us|va blL a blL y guarda el resulLado en uesLlno.
mov al, 01001110b
mov ah, 00111001b
or al, ah
; AL = 01111111b
xC8
XOR Destino, Operando2
8eallza la d|syunc|n exc|us|va blL a blL y guarda el resulLado en uesLlno.
mov al, 01001110b
mov ah, 00111001b
xor al, ah
; AL = 01110111b

20
nuevamenLe, puede vlslLar hLLp://www.lnLel.com/deslgn/enLlum4/documenLaLlon.hLm para descargar las especlflcaclones
compleLas de Lodas las lnsLrucclones de la arqulLecLura lnLel x86.

"##$%&'$( 33
nLC
NEG Destino
Cenera el comp|emento a 2 del operando y lo almacena sobre sl mlsmo.
mov al, 01001110b
neg al
; AL = 10110010b
nC1
NOT Destino
8eallza la negac|n del operando blL a blL. Ls declr que |nv|erte cada b|t. (Ls equlvalenLe a generar el comp|emento a
1).
mov al, 01001110b
not al
; AL = 10110001b
1LS1
TEST Operando1, Operando2
8eallza la con[uncln lglca blL a blL (como Anu), pero a dlferencla de Anu, no guarda e| resu|tado. SlmplemenLe t|ene
efectos sobre e| reg|stro de f|ags (por e[emplo, Z = 1 sl Lodos los blLs del resulLado son ceros).
mov al, 01001110b
mov ah, 00111001b
test al, ah
; AL no se modifica
; El registro de flags es afectado (Z = 0, S = 0)
SAL1CS CCnulClCnALLS CCn SlCnC
PasLa ahora, uLlllzamos los slgulenLes salLos condlclonales para comparar dos operandos segun su relacln de orden:
IA: SalLar sl es mayor
IAL: SalLar sl es mayor o lgual
I8: SalLar sl es menor
I8L: SalLar sl es menor o lgual
1amblen son vlldas las lnsLrucclones que uLlllzan las condlclones negadas: INA, INAL, IN8 y IN8L.
LsLas lnsLrucclones conslderan a los operandos como valores expresados en 8SS (recordemos que la mlsma cadena de
blLs puede conslderarse en 8SS o Ca2).
Sl queremos conslderar los numeros en Ca2, debemos uLlllzar las slgulenLes
21
:

21
Las nuevas leLras slgnlflcan: C = h/$-+$/, L = L$##.

"##$%&'$( 36
IG: SalLar sl es mayor (Ca2)
IGL: SalLar sl es mayor o lgual (Ca2)
IL: SalLar sl es menor (Ca2)
ILL: SalLar sl es menor o lgual (Ca2)
1amblen son vlldas las lnsLrucclones que uLlllzan las condlclones negadas: ING, INGL, INL y INLL.
Los slgulenLes salLos condlclonales son vlldos LanLo para 8SS como para Ca2:
IL: SalLar sl son lguales
INL: SalLar sl no son lguales
MS CL8AClCnLS A8l1ML1lCAS
MuL / lMuL
LxlsLen dos lnsLrucclones de mulLlpllcacln: MUL, para valores sln slgno, e IMUL, para valores con slgno. MuL e lMuL
permlLen la mulLlpllcacln de dos valores de 8 blLs o de dos valores de 16 blLs.
MuL e lMuL slo uLlllzan *( '5$/-(,'. ara mulLlpllcar dos byLes, ponemos uno de los facLores en el reglsLro AL. Luego
usamos MuL o lMuL usando el oLro facLor como operando. ara el operando de MuL se puede usar cualquler modo de
dlrecclonamlenLo, excepto modo |nmed|ato. Ll resulLado de la mulLlpllcacln se devuelve en Ax. (noLar que el valor
ms grande que se obLlene al mulLlpllcar dos byLes es 233 * 233 = 63023, lo que no enLra en un byLe). or e[emplo:
mov al, 5
mov bl, 2
mul bl
; En este punto AX = 10
ara mulLlpllcar dos words, se pone una en Ax y se usa MuL o lMuL con el oLro facLor. Ll resulLado de mulLlpllcar dos
numeros de 16 blLs puede neceslLar hasLa 32 blLs. Como el procesador slo mane[a numeros de 16 blLs, dlvlde el
resulLado en dos: la palabra alLa y la ba[a. L- 5-%->/- >-)- #$ -%4-&$(- $( D: G %- -%+- $( Y:.
mov ax, -2000
mov bx, 30000
imul bx
; En este punto el resultado est DXAX
; AX = 0111100100000000
; DX = 1111110001101100
ulv / lulv
La dlvlsln Lraba[a en forma slmllar. 1enemos DIV e IDIV, para numeros sln y con slgno respecLlvamenLe. LsLas
lnsLrucclones permlLen dlvldlr un numero de 16 blLs por uno de 8, o un numero de 32 blLs por uno de 16.
ara dlvldlr un numero de 16 blL por un numero de 8, se pone el dlvldendo en Ax y se usa ulv o lulv pasando como
parmeLro el dlvlsor de 8 blLs. Ll coclenLe se almacena en AL. Ll resLo de la dlvlsln se almacena en AP.


"##$%&'$( 37
mov ax, 120
mov bl, 2
div bl
; AL = cociente, AH = resto.
ara dlvldlr un numero de 32 blL por uno de 16, se pone el dlvldendo separado en dos palabras: la ms ba[a en Ax y la
ms alLa en ux. Luego se usa ulv o lulv con el dlvlsor de 16 blLs. Ll coclenLe se almacena en Ax y el resLo en ux.
mov dx, 0001h
mov ax, 0ABC0h
mov cx, 0015h
idiv cx
; AX = cociente, DX = resto.
MS CL8AClCnLS LCCl CAS
CC88lMlLn1CS
8eallzar un corrlmlenLo (#W.C+) sobre un numero blnarlo slgnlflca Lrasladar cada blL del numero una canLldad fl[a de
poslclones hacla la derecha o hacla la lzqulerda (Lodos hacla el mlsmo lado). or e[emplo, sl apllcamos un corrlmlenLo
de 1 hacla la lzqulerda al numero 00001101, obLenemos el numero 00011010.
0 0 0 0 1 1 0 1

0 0 0 1 1 0 1 0
LsLe resulLado en Assembler se conslgue usando las lnsLrucclones SnL (9S.C+ L$C+) y Snk (9S.C+ P.BW+). Ambas
lnsLrucclones reclben como prlmer parmeLro la ublcacln del numero y como segundo parmeLro la canLldad de
lugares a correr. Los numeros en el exLremo lzqulerdo (en el caso de SPL) se descarLan, excepLo el ulLlmo que queda en
el carry. or el exLremo opuesLo se lnLroducen ceros:
C MS8 LS8 0
SP8 Lraba[a exacLamenLe en el senLldo opuesLo. Se lnLroducen ceros por la parLe lzqulerda y los numeros que salen por
la derecha van al flag de carry.
LsLa operacln se puede apllcar LanLo sobre operandos de 8 como de 16 blLs. Ll segundo operando debe ser o blen el
numero 1 o blen el reglsLro CL. SPL y SP8 no permlLe especlflcar la canLldad de corrlmlenLo medlanLe dlrecclonamlenLo
lnmedlaLo para oLro numero dlsLlnLo de 1.
shr ax, 1
mov cl, 2
shl bh, cl
uebemos recordar que esLe Llpo de corrlmlenLos slrven para mulLlpllcar (SPL) o dlvldlr (SP8) un numero por una
poLencla de dos. ero usar corrlmlenLos a derecha para dlvldlr numeros negaLlvos no funclona, ya que el blL de slgno es
qulLado de su poslcln. ara remedlar esLe lnconvenlenLe, Assembler provee oLra lnsLruccln que es SAk (corrlmlenLo
arlLmeLlco a derecha). SA8 opera asl:


"##$%&'$( 38

MS8 LS8

Cl
Ls declr, en lugar de lnserLar ceros, lnserLa una copla del MS8, con lo que el slgno se conserva.
SAL, la operacln de corrlmlenLo arlLmeLlco a lzqulerda, es equlvalenLe a SPL. Sln embargo, se uLlllza cuando se Lraba[a
con numeros con slgno, para hacer el cdlgo ms leglble.
8C1AClCnLS
Las roLaclones de blLs son slmllares a los corrlmlenLos, excepLo que cuando un valor es roLado, los blLs que salen por un
exLremo son coplados en el exLremo opuesLo.
veamos una roLacln a lzqulerda. LsLas se logran medlanLe la lnsLruccln kCL. Sl roLamos un byLe hacla la lzqulerda un
blL, movemos Lodos los blLs hacla la lzqulerda un lugar. Luego, el ulLlmo blL (el 7) se copla en el lugar 0:

Cl
MS8 LS8
Adems, los blLs que van sallendo Lamblen se coplan en el flag de carry.
Las roLaclones a derecha se hacen medlanLe kCk. lunclonan exacLamenLe al reves de las roLaclones a lzqulerda.
1amblen exlsLen oLras roLaclones kCL y kCk. LsLas Loman al blL de carry como un blL ms del numero (a la lzqulerda del
MS8 sl se usa 8CL y a la derecha del LS8 sl se usa 8C8). Asl, la roLacln hace que los numeros que se caen" de un
exLremo pasen al carry y cuando un numero se cae del carry vaya al LS8, para una roLacln a lzqulerda (o al LS8, para
una a derecha).
Cl
MS8 LS8

IUNCICNAMILN1C DL CM DL LCS SAL1CS CCNDICICNALLS
Consldere esLe fragmenLo de cdlgo:
cmp ax, bx
jne final
uado que CM y !nL son dos lnsLrucclones compleLamenLe alsladas, e[ecuLadas en su proplo clclo feLch-decode-
execuLe Cmo se conecLa la lnsLruccln CM con el salLo condlclonal para que esLe pueda decldlr sl debe o no reallzar
el salLo? La respuesLa es: - +/-@X# ,$% /$B.#+/' ,$ C%-B#.
La comparacln es en realldad una resta. Slmllar a Su8, CM resLa ambos operandos (op. lzqulerdo - op. derecho) y,
como cualquler operacln arlLmeLlca, afecta e| reg|stro de f|ags. La dlferencla es que no guarda e| resu|tado.
Luego, anallzando el reglsLro de flags, el salLo condlclonal deLermlna sl la condlcln se cumple o no. or e[emplo, para
deLermlnar sl los operandos eran lguales, !L puede mlrar el flag de Z. Sl Z = 1, slgnlflca que la resLa enLre los operandos
dlo 0, con lo cual los operandos deblan ser lguales. (Ln caso conLrarlo, sl Z = 0, slgnlflca que la resLa no dlo 0, con lo cual
los operandos eran dlsLlnLos).

"##$%&'$( 39
LxlsLen oLros dos salLos condlclonales equlvalenLes a !L y !nL que de[an claro que uLlllzan el flag Z:
I2: SalLar sl es 0 (Z = 1)
IN2: SalLar sl no es 0 (Z = 0)
Ls compleLamenLe vlldo uLlllzar cualqulera de las dos expreslones. ue hecho, al ensamblar el cdlgo LanLo !L como !Z
resulLan en la mlsma operacln en lengua[e de mqulna. (Lo mlsmo vale para !nL y !nZ).
22

1amblen exlsLen salLos condlclonales para pregunLar por oLros de los flags. or e[emplo:
Carry: IC / INC
Slgno: IS / INS
Cverflow: IC / INC
SAL1CS CCnulClCnALLS Sln CM
uado que los salLos condlclonales slmplemenLe uLlllzan el esLado del reglsLro de flags para deLermlnar sl deben o no
reallzar el salLo, en realldad no es necesarlo uLlllzar CM anLes de un salLo condlclonal. Cualquler operacln que afecLe
los flags Lamblen es vllda.
or e[emplo:
test al, 00001111b ; Realiza un "and" entre AL y 00001111
; Resultado --> 0000xxxx (los 4 bits ms bajos
; dependen del contenido de AL)

jz abajo ; Salta si es cero (Z = 1)
; Considerando el resultado (0000xxxx), saltar si
; los cuatro bits ms bajos de AL son 0
CLro e[emplo (muy comun cuando queremos hacer una lLeracln pero no podemos usar Cx para el LCC):
mov dx, 10 ; DX arranca en 10 (para iterar 10 veces)
mov si, 0

iterar: mov arreglo[si], 0
inc si

dec dx
jnz iterar ; Saltar si DX no lleg a 0

22
ue hecho, hay muchos salLos condlclonales que son equlvalenLes adems de esLos dos. or e[emplo, !8L y !nA son lguales.

Assembler

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Assembler

Uploaded by

Copyright:

Available Formats

ASSLM8LL8

unnC8A - ArqulLecLura de CompuLadoras

You might also like