0% encontró este documento útil (0 votos)
218 vistas17 páginas

Parcial 2

Descargar como docx, pdf o txt
Descargar como docx, pdf o txt
Descargar como docx, pdf o txt
Está en la página 1/ 17

Caracteristicas Ambos operandos deben de ser del mismo tamao (n de bits) No ueden accesar estos registros efp,cs,ds Ambos

no puedes hacer valores de memoria Mov eax, bx 32 16 bx 16 bits eax 32 bits No se puesde hacer cs,xxx Que contiene el registro cs,ds,ss,ts? r/ los registros del segmento contienen la direccin inicial en donde comienza el segmento no se puede hacer mov a,b no se puede hacer mov a(8),cax(32)no son del mismo tamao movimiento ,registro si se puede hacer b(32),cax(32) .data A byte 10 no B dword 10 si Inc i++ Dec i Inc ax o add ax,4 dec ax ax=ax-1 mov eax ,offset m1 mov edx, eax call writesminc ptr =pointer to mov ah, byte ptr* forma correcta mov ah, * forma incorrecta mov eax, a mov eax, dword ptr a offset: desplazamiento con respecto al origen de un identificador de datos (todo dentro del data)cuando defino .data Ms s1 byte mensaje 1,0 A dword 23 Com1 word 10 Msj2 byte final,0 .Data m e n s a j e 1 Mss1 A 0 0 0 2 3 0 10 f Com1 i n a l 0 Dump men Msj2 mov esi, offset com1 mov edi, offset msj2 di: vamos a usar offset .data B1 byte hola 0

Tienen que ser iguales

B2 byte 4dup(20h) B3 byte ,0 B4 dword? .code Mov esi, offset b1 Mov edi, offset b2 h Mov al, (esi)-al =h Mov (edi),al Add esi, 1 Inc edi Loop a .data Sb byte 1,2,3 Sw word 1,23 Sumb byte 0 Sumw word 0 Sumdw dword 0 Code X sum proc

sb=1,2,3 1b 00000001 8 bits 1 byte

1b 00000010 8 bits 1 byte

1b 00000011 8 bits 1 byte

mov esi, offset sb mov ecx, 3 xb: mov dx,(esi) eax add sumb, db Ab add esi, 1 0000 00 06 loop xb,2 mov eax, 0 mov al, sumb call writedec 28=256(0-255) .data S1 byte maana sera 5,0 .code R proc Mov esi, offset, s1 Mov ecx, lengthof s1;longitud de cadena Comment * Barrer cadena s1 e ir comparando cada elemento con carcter 5 A:mov al, byte ptr (esi) .if (al ==byte ptr 5) Mov (esi),byte ptr 6 .end if Inc esi Loop a .data S1 byte maana sera 5, 0 S2 byte lengthof si dup (2011) Mov esi, offset s1 Mov ecx, lengthof s1 Mov edi, offset s2 L=($-m1) nombre de la variable donde se encuentra la cadena Ptr=redifinir un operado Mov reg reg = r,r Mem,reg = mr

al

Reg,mem Mem,inm Reg,inm

= r,m = m,i = r,i memoria de 8 bits

Movzx r32,r/m8 R32,r/m16 R16,r/m8 . code proc Mov eax, 0 Mov edx, 0 Mov ecx, 0 Mov ebx,0

Mov ah, b 0 Reg, mem Data bit

Title copiarcadena2 Include Irvine 32.inc .data Letras byte l u c k, 0 Palabra byte? .code Nestor proc Mov esi, offset leras Mov edi, offset palabra Mov ecx, 5 Mov edx,0 A: Mov dh(esi) Mov (edi)dh Inc esi Inc edi Loop a Mov edx, offset palabra Call writestring Exit Nestor endp End nestor Raiz de un numero h El bit de un signo es el bit ms a la izquierda MOV, una instruccin de transferencia de datos, copia un operando de origen a un operando de destino. La instruccin MOVZX extiende con ceros un operando ms pequeo en uno ms grande. La instruccin MOVSX extiende con signo un operando ms pequeo en un registro ms grande. La instruccin XCHG intercambia el contenido de dos operandos. Cuando menos un operando debe ser un registro. Tipos de operandos En este captulo presentamos los siguientes tipos de operandos: Un operando directo es el nombre de una variable, y representa su direccin. Un operando de desplazamiento directo suma un desplazamiento al nombre de una variable, con lo que genera un nuevo desplazamiento, que puede usarse para acceder a los datos en la memoria. Un operando indirecto es un registro que contiene la direccin de los datos . Al encerrar el registro entre corchetes (como en [esi]), un programa hace referencia a la direccin y obtiene los datos de la memoria.

Un operando indexado combina una constante con un operando indirecto. La constante y el valor del registro se suman, y el desplazamiento resultante se emplea para hacer referencia a la direccin. Por ejemplo, [arreglo_ esi] y arreglo[esi] son operandos indexados.Las siguientes operaciones aritmticas son importantes: La instruccin INC suma 1 a un operando. La instruccin DEC resta 1 a un operando. La instruccin ADD suma un operando de origen a un operando de destino. La instruccin SUB resta un operando de origen de un operando de destino. La instruccin NEG invierte el signo de un operando. Cuando convierta expresiones aritmticas simples en lenguaje ensamblador, use las reglas de precedencia de los operadores estndar para seleccionar qu expresin se debe evaluar primero.Banderas de estado Las siguientes banderas de estado de la CPU se ven afectadas por las operaciones aritmticas: La bandera Signo se activa cuando el resultado de una opera cin aritmtica es negativo. La bandera Acarreo se activa cuando el resultado de una operacin aritmtica sin signo es demasiado grande para el operando de destino. La bandera Acarreo auxiliar se activa cuando ocurre un acarreo o un prsta mo en la posicin del bit 3 del operando de destino. La bandera Cero se activa cuando el resultado de una operacin aritmtica es cero. La bandera Desbordamiento se activa cuando el resultado de una operacin aritmtica con signo es demasiado grande para el operando de destino. Por ejemplo, en una operacin con bytes, la CPU detecta el desbordamiento aplicando un OR exclusivo al acarreo que sale del bit 6 con el acarreo que sale del bit 7. Los siguientes operadores son de uso comn en el lenguaje ensamblador: El operador OFFSET devuelve la distancia de una variable, a partir del inicio de su segmento circundante. El operador PTR redefi ne el tamao declarado de una variable. El operador TYPE devuelve el tamao (en bytes) de una sola variable, o de un elemento individual de un arreglo. El operador LENGTHOF devuelve el nmero de elementos en un arreglo. El operador SIZEOF devuelve el nmero de bytes utilizados por un inicializador de arreglos. El operador TYPEDEF crea un tipo defi nido por el usuario. Ciclos La instruccin JMP se bifurca en forma incondicional hacia otra ubicacin. La instruccin LOOP se utiliza en los ciclos con conteo. En el modo de 32 bits, LOOP utiliza a ECX como contador; en el modo de 16 bits, CX es el contador. En ambos modos de 16 y 32 bits, LOOPD (ciclo doble) utiliza a ECX como contador. 4.1.2 Tipos de operandos En este captulo presentamos tres tipos de operandos de instrucciones : inmediatos, de registro y de memoria. De los tres, slo el tercero es un poco complicado. La tabla 4-1 presenta una notacin simple para los operandos, adaptada de los manuales de la familia IA-32 de Intel. Utilizaremos esta notacin a partir de este captulo para describir la sintaxis de las instrucciones Intel individuales. Tabla 4-1 Notacin de operandos de instrucciones. Operando Descripcin r8 Registro de propsito general de 8 bits: AH, AL, BH, BL, CH, CL, DH, DL r16 Registro de propsito general de 16 bits: AX, BX, CX, DX, SI, DI, SP, BP r32 Registro de propsito general de 32 bits: EAX, EBX, ECX, EDX, ESI, EDI, ESP, EBP reg Cualquier registro de propsito general sreg Registro de segmento de 16 bits: CS, DS, SS, ES, FS, GS

imm Valor inmediato de 8, 16 o 32 bits imm8 Valor tipo byte inmediato de 8 bits imm16 Valor tipo palabra inmediato de 16 bits imm32 Valor tipo doble palabra inmediato de 32 bits r/m8 Operando de 8 bits, que puede ser un registro general de 8 bits o un byte de memoria r/m16 Operando de 16 bits, que puede ser un registro general de 16 bits o una palabra de memoria r/m32 Operando de 32 bits, que puede ser un registro general de 32 bits o una doble palabra de memoria mem Cualquier operando de memoria de 8, 16 o 32 bits 4.1.3 Operandos directos de memoria En la seccin 3.4 explicamos que los nombres de las variables son referencias a desplazamientos dentro del segmento de datos. Por ejemplo, la siguiente declaracin indica que se ha asignado al segmento de datos un byte que contiene el nmero 10h: .data var1 BYTE 10h El cdigo del programa contiene instrucciones que emplean (buscan) operandos que hacen referencia a direcciones de memoria. Suponga que var1 se ubic en el desplazamiento 10400h. Una instruccin en lenguaje ensamblador para mover esta variable al registro AL podra ser: mov AL,var1 MASM ensamblara esta instruccin como el siguiente cdigo de mquina: A0 00010400 El siguiente programa demuestra la mayor parte de los ejemplos de transferencias de datos de la seccin 4.1: TITLE Ejemplos de transferencias de datos (Moves.asm) ; Ejemplo del captulo 4. Demostracin de MOV y ; XCHG con operando directos y de desplazamiento directo. ; ltima actualizacin: 06/01/2006 INCLUDE Irvine32.inc .data val1 WORD 1000h val2 WORD 2000h arregloB BYTE 10h,20h,30h,40h,50h arregloW WORD 100h,200h,300h arregloD DWORD 10000h,20000h .code main PROC ; MOVZX mov bx,0A69Bh movzx eax,bx ; EAX = 0000A69Bh movzx edx,bl ; EDX = 0000009Bh movzx cx,bl ; CX = 009Bh ; MOVSX mov bx,0A69Bh movsx eax,bx ; EAX = FFFFA69Bh movsx edx,bl ; EDX = FFFFFF9Bh mov bl,7Bh movsx cx,bl ; CX = 007Bh ; Intercambio de memoria a memoria: mov ax,val1 ; AX = 1000h xchg ax,val2 ; AX = 2000h, val2 = 1000h mov val1,ax ; val1 = 2000h ; Direccionamiento con desplazamiento directo (arreglo de bytes):

mov al,arregloB ; AL = 10h mov al,[arregloB+1] ; AL = 20h mov al,[arregloB+2] ; AL = 30h ; Direccionamiento con desplazamiento directo (arreglo de palabras): mov ax,arregloW ; AX = 100h mov ax,[arregloW+2] ; AX = 200h ; Direccionamiento con desplazamiento directo (arreglo de dobles palabras): mov eax,arregloD ; EAX = 10000h mov eax,[arregloD+4] ; EAX = 20000h mov eax,[arregloD+TYPE arregloD] ; EAX = 20000h exit main ENDP END main Este programa no genera resultados en la pantalla, pero puede (y debe) ejecutarlo mediante un depurador. Consulte los tutoriales en el sitio Web del libro para ; Ejemplo del captulo 4. Demostracin de las instrucciones ; ADD, SUB, INC, DEC y NEG, y la manera en ; que afectan a las banderas de estado de la CPU. ; ltima actualizacin: 06/01/2006 INCLUDE Irvine32.inc .data valR SDWORD ? valX SDWORD 26 valY SDWORD 30 valZ SDWORD 40 .code main PROC ; INC y DEC mov ax,1000h inc ax ; 1001h dec ax ; 1000h ; Expresin: valR = -valX + (valY - valZ) mov eax,valX neg eax ; -26 mov ebx,valY sub ebx,valZ ; -10 add eax,ebx mov valR,eax ; -36 ; Ejemplo de la bandera Cero: mov cx,1 sub cx,1 ; ZF = 1 mov ax,0FFFFh inc ax ; ZF = 1 ; Ejemplo de la bandera Signo: mov cx,0 sub cx,1 ; SF = 1 mov ax,7FFFh add ax,2 ; SF = 1 ; Ejemplo de la bandera Acarreo: mov al,0FFh add al,1 ; CF = 1, AL = 00 ; Ejemplo de la bandera Desbordamiento: mov al,+127 add al,1 ; OF = 1 mov al,-128

sub al,1 ; OF = 1 exit main ENDP END main EJEMPLOS include irvine32.Inc .data producto byte 'el producto es',0 m1 byte 'entre el multiplicando',0 m2 byte 'entre el multipilicador',0 .code Jal proc mov EDX, offset m1 call writestring call readdec call crlf mov EBX , EAX; multiplicand en EBX mov EDX, offset m2 call writestring; multiplicador en EAX call readdec call crlf mov ECX, 1 mov EDX, 0 .while (ECX <= EBX) add EDX, EAX .endw mov EAX, EDX mov EDX. offset producto call writestring call writedec call crlf exit Jal endp end Jal title arr include irvine32.inc .data arr word 12,145,457,17 suma word 0 msg1 byte "la suma es",0 .code nestor proc mov ecx, lengthof arr mov eax,0 mov esi, offset arr sumar: mov ax,[esi]

add suma, ax add esi,2 loop sumar cambiar:

mov ax, suma call writestring call crlf exit nestor endp end nestor tittle lab 6-3-14 include irvine32.inc proc mov eax, 12345678h call dumpregs call crlf ; mov ax,0 call dumpregs call crlf ; mov eax,0 call dumpregs call crlf ; mov al, 175 call dumpregs call crlf ; mov ah, 235 call dumpregs call crlf ; call writedec call crlf ; mov ebx,9876543h mov ecx, ebx call dumpregs call crlf ; movzx ebx,ah call dumpregs call crlf ; mov ah, 8ah call dumpregs call crlf exit lab endp end lab

title arr include irvine32.inc .data arr dword 12,145,457,17 suma dword 0 msg1 byte "la suma es",0 .code j proc mov ecx,lengthof arr mov eax,0 mov esi,offset arr sumar: mov eax,[esi] add suma,eax add esi,4 loop sumar mov eax,suma call crlf call writedec exit j endp end j title 6 de marzo de 2014 include irvine32.Inc .data .code NES proc mov EAX, 12345678H call DUMPREGS call crlf ; mov AX ,0 call DUMPREGS call crlf ; mov EAX, 0 call DUMPREGS call crlf ; mov AL, 175 call DUMPREGS call crlf ; mov AH, 235 call DUMPREGS call crlf ; call WRITEDEC call crlf ; mov EBX, 9876543H MOV ECX,EBX call DUMPREGS

call crlf ; COMMENT * MOVZX R32,R/M8 MOVZX R32,R/M16 MOVZX R16,R/M8 * mov EAX, 0 MOV AH,10 MOV EBX,12345678H call DUMPREGS call crlf ; MOVZX EBX,AH call DUMPREGS call crlf ; mov AH,8AH call DUMPREGS call crlf ; movSX EAX, AH MOV ECX,EBX call DUMPREGS call crlf ; exit NES endp end NES TITLE POINTERS INCLUDE IRVINE32.inc .DATA ARRB BYTE 1,2,3 ARRW WORD 1000,2000,3000 AB DWORD OFFSET ARRB AW DWORD OFFSET ARRW .CODE P PROC ; MOV EAX, 0 MOV ESI,AB MOV AL,[ESI] CALL WRITEDEC CALL CRLF ; MOV ESI,AW MOV AX,[ESI] CALL WRITEDEC CALL CRLF ;

EXIT P ENDP END P TITLE POINTERS INCLUDE IRVINE32.inc .DATA ARRB BYTE 1,2,3 ARRW WORD 1000,2000,3000 AB DWORD OFFSET ARRB AW DWORD OFFSET ARRW .CODE P PROC ; MOV EAX, 0 MOV ESI,AB MOV AL,[ESI] CALL WRITEDEC CALL CRLF ; MOV ESI,AW MOV AX,[ESI] CALL WRITEDEC CALL CRLF ;

EXIT P ENDP END P TITLE UsoMov INCLUDE Irvine32.inc .Data .Code mr proc MOV EAX,12345678h ;Se mueve un valor hexadecimal a EAX call dumpregs ;Mostramos los registros en consola call crlf MOV AX,0 ; Se da el valor de cero a AX CALL Dumpregs ;Mostramos los registros en consola CALL CRLF MOV EAX,0 ; SE da el valor de Cero a EAX CALL Dumpregs ;Mostramos los registros en consola CALL CRLF MOV AH,175 ;Se mueve el valor de 175 a AH Call Dumpregs ;Mostramos los registros en consola Call crlf

MOV AL,235 ; Se mueve el valor de 235 a AL Call Dumpregs ;Mostramos los registros en consola Call crlf Call Writedec ; Se muestra el contenido de EAX en consola Call crlf MOV EBX,9876543h ; Se mueve el valor hexadecimal a EBX MOV ECX,EBX ; El contenido de EBX se copia ECX Call Dumpregs ;Mostramos los registros en consola call crlf COMMENT * MOVZX r32,r/m8 MOVZX r32,r/m16 MOVZX r16,r/m8 * MOV EAX,0 ; Se dale valor de cero a EAX MOV AH,10 ; se mueve 10 a AH MOV EBX,12345678h ; Se mueve el valor hexadecimal a EBX call Dumpregs ;Mostramos los registros en consola call crlf MOVZX EBX,AH ; El registro AH se copia a EBX Call Dumpregs ;Mostramos los registros en consola Call crlf MOV AH,8ah ; Se mueve un valor hexadecimal a AH Call Dumpregs ;Mostramos los registros en consola Call crlf MOVSX EAX,AH ; El registro AH se copia a EAX Call Dumpregs ;Mostramos los registros en consola call Crlf exit mr endp end mr TITLE CopiarCadena2 INCLUDE IRVINE32.INC .DATA LETRAS BYTE "L","U","C","K",0 ; arreglo de caracteres PALABRA BYTE ? ; variable de tipo BYTE sin un tamao definido .CODE mr PROC MOV ESI,offset LETRAS ; desplzamos la direccin de memoria de LETRAS a ESI MOV EDI,offset PALABR; desplazamos la direccin de memoria de PALABRA a EDI MOV ECX,5 ; asignamos el valor de 5 a ECX MOV EDX,0 ; El registro de EDX ser cero A: MOV DH,[ESI] ; Movemos un elemento del arreglo a DH en cada repeticin MOV [EDI],DH ; Luego El valor guardado en DH se transfiere a una posicin en EDI INC ESI ; Incrementamos ESI INC EDI ; Incrementamos EDI

LOOP A mov EDX, offset PALABRA ; Se muestra nuestro mensaje concatenado Call WriteString EXIT mr ENDP END mr TITLE BuscarCaracter INCLUDE IRVINE32.INC .DATA ; declaramos los respectivos mensajes a mostrar en nuestro programa PALABRA BYTE "miercoles 12 de marzo de 2014",0 ; Cadena que se recorrera con el loop msj byte "que letra busco?? ",0 msj2 byte "lo encontre",0 msj3 byte "no lo encontre",0 .CODE mr PROC mov EAX,0 ; Damos el valor de cero a EAX mov ESI, offset PALABRA ; desplazamos la direccin de memoria a ESI de PALABRA mov ECX, LENGThOF PALABRA; asignamos el tamao de la cadena a ECX mov EDX, offset msj call writeString ; Indicamos que letra ser la que buscaremos call readChar call writeChar call crlf ; ingresamos el carcter a buscar, el carcter se almacena en AL ; mostramos el carcter ingresado

recorrer: .if([ESI]==al) ; se compar el carcter de AL con la posicin del arreglo jmp a ; si la condicin es verdadero se utiliza JMP para saltar a una nueva etiqueta .endif INC ESI ; mientras la condicin sea falso, se incrementar ESI loop recorrer jmp no ; si se realiza todo el recorrido del arreglo y no encuentra el carcter a: ; etiqueta de cdigo cuando la condicin es verdadera mov EDX, offset msj2 ; se muestra el mensaje que se ha encontrado el carcter call writeString call crlf jmp fin ; da un salto a la etiqueta fin no: ; etiqueta de cdigo si la condicin fue falsa mov EDX, offset msj3 ; ; se muestra un mensaje que no se ha encontrado el carcter call writeString call crlf ; se finalzia el programa

fin:

exit mr endp end mr ;sume cada elemento del arreglo y muestrelo en pantalla title sumaarreglo include irvine32.inc

.data ; se declara un arreglo de tipo dword, una variable que almacenara la suma y un mensaje arr dword 30,45,450,25 suma dword 0 msg1 byte "la suma es: ",0 .code mr proc mov ecx, lengthof arr ; obtenemos el nmero de elementos que contiene la cadena mov eax,0 ; damos el valor de cero a eax mov esi,offset arr ; colocamos el desplazamiento en memoria de la cadena a esi sumar: mov eax,[esi] ; con lo corchetes hacemos referencia que nos colocamos en la primera ; posicin del arreglo, luego se asigna al registro eax add suma,eax ; se suma el valor de eax a la variable sumar. ; en esi se encuentra el desplazamiento del arreglo, como es de tipo dword o 4 bytes ; por ser de ste tipo de datos se sumaran cuatro a esi en cada repeticin. add esi,4 loop sumar mov eax,suma call crlf call writedec exit mr endp end mr ;de una cadena tome un caracter cualquiera y cambiela por otro caracter de su conveniencia title cambiocadena include irvine32.inc .data ;declaramos tres mensajes en nuestro segmento de cdigo. cad1 byte "laboratorio 2 del fm",0 msg1 byte "cambio realizado",0 msg2 byte "camiar el numero 2 por el 3",0 .code mr proc ;mostramos dos mensajes mov edx,offset cad1 call writestring call crlf mov edx,offset msg2 call writestring call crlf call crlf mov ebx,offset cad1 ; colocamos el desplazamiento de memoria de la varible cad1 mov al,byte ptr "3" ; con ptr redefinimos el tipo de dato del operando en ste caso ser byte mov dl,byte ptr "2" ; con ptr redefinimos el tipo de dato del operando en ste caso ser byte mov ecx,lengthof cad1 ;colocamos la cantidad de elementos que existen en el arreglo cad1 en ecx ; la suma total es asigna a eax para ser mostrados en consola

cambiar: mov ah, byte ptr [ebx] ;redefinimos la posicin a la que hacemos referencia, y asginamos a ah .if (ah==dl) ;se comparan los valore de ah y dl mov [ebx], byte ptr al ;si la condicin es verdadera, se realiza el cambio de caracter mov edx,offset msg1 call writestring ;se muestra en pantalla que se a realizado el cambio call crlf .endif inc ebx ;se incrementa en uno a ebx loop cambiar call crlf mov edx,offset cad1 call writestring exit mr endp end mr

; se imprime el nuevo mensaje

comment & disee un programa que copie una cadena a otra cadena & title copiarcadena include irvine32.inc .data m1 byte "lenguaje de maquina seccion 01",0 ; cadena a copiar m2 byte 30 dup(0) ; se reserva 30 bytes de memoria, donde se copiara la cadena .code mr proc mov esi, offset m1 ; se mueve el desplazamiento de m1 a esi mov edi, offset m2 ; se mueve el desplazamiento de m2 a edi mov edx, offset m1 call writestring call crlf mov ecx, lengthof m1; se obtiene el tamao de la cadena m1 cambio: mov al, [esi] ; se hace referencia al primer elemento del arreglo m1 y se copia a al mov [edi],al ; el valor de al se copia a un byte del arreglo m2 inc esi ; se incrementa esi en uno inc edi ; se incrementa edi en uno loop cambio mov edx, offset m2 ; se muestra el mensaje copiado call writestring exit mr endp end mr comment & disee un programa en assembler que cuente la cantidad de elementos de un arreglo utilizando los tres mtodos conocido y explique si existe alguna diferencia. muestre los resultados en pantalla

& title contadorcadena include irvine32.inc .data m1 byte "assembler",0 ; una cadena es un arreglo de caracteres l=($-m1) ; obtenemos la longitud de la cadena y se almacena en l(primer mtodo) cont dword 0 ; declaramos un contador dword .code mr proc mov ecx, lengthof m1; obtenemos el tamao del arreglo y lo almacenamos en ecx (segundo mtodo) mov eax,ecx ; guardamos el valor de ecx en eax call writedec ; mostramos en consola el resultado call crlf mov eax,l call writedec mov esi,offset m1 ; movemos el valor de l a eax ; mostramos en consola el resultado ; movemos el desplazamiento de m1 a esi

.while([esi] != byte ptr 0) ; realizamos el recorrido del arreglo y cada elemento se commpar con cero inc esi ; se incremente esi en cada repeticin inc cont ; se incrementa el contador en uno .endw call crlf mov eax,cont call writedec exit mr endp end mr

; se muestra el resultado

También podría gustarte