Hola, muy buenas. Estoy aprendiendo ensamblador y para ello lo estoy enlazando con las librerías estandar de C++. No sé mucho sobre la sintaxis de intel (estoy aprendiendo NASM), pero he conseguido el siguiente código (el cual está guardado en el archivo intercambiar.s)
.file "intercambiar.cpp"
.text
.globl __Z12intercambiarPiS_
.def __Z12intercambiarPiS_; .scl 2; .type 32; .endef
__Z12intercambiarPiS_:
LFB0:
.cfi_startproc
pushl %ebp
.cfi_def_cfa_offset 8
.cfi_offset 5, -8
movl %esp, %ebp
.cfi_def_cfa_register 5
movl 8(%ebp), %eax
movl 12(%ebp), %ebx
movl %eax, 12(%ebp)
movl %ebx, 8(%ebp)
popl %ebp
.cfi_restore 5
.cfi_def_cfa 4, 4
ret
.cfi_endproc
LFE0:
.ident "GCC: (GNU) 4.8.1"
Lo que he hecho es conseguir el código base gracias al compilador g++ de MinGW y añadir el intercambiador de variables.
Lo que sería el intercambiador es el siguiente:
pushl %ebp
movl %esp, %ebp
movl 8(%ebp), %eax
movl 12(%ebp), %ebx
movl %eax, 12(%ebp)
movl %ebx, 8(%ebp)
popl %ebp
ret
Lo que he hecho después es ejecutar el siguiente comando:
g++ -Wall -c intercambiador.s
Con el, he obtenido un fichero objeto
Ahora bien, cuando ejecuto el programa principal, no me intercambia las variables.
Aquí tenéis el programa principal en C++:
#include <iostream>
void intercambiar(int* lpnValorA, int* lpnValorB);
int main() {
int nValorA, nValorB;
std::cout << "Introduzca el valor A: ";
std::cin >> nValorA;
std::cout << "Introduzca el valor B: ";
std::cin >> nValorB;
intercambiar(&nValorA, &nValorB);
std::cout << "\nnValorA = " << nValorA << std::endl;
std::cout << "nValorB = " << nValorB;
std::cin.get();
std::cin.get();
return 0;
}
Pues eso, el intercambiador no hace nada
Soy novato en ASM, por lo que no seáis duros :D Gracias
Eso es sintaxis AT&T.
¿Porqué no usar ASM Inline?
#include <stdio.h>
#include <stdlib.h>
int var1 = 1;
int var2 = 2;
int main()
{
asm(".intel_syntax noprefix");
asm("mov eax, [_var1]");
asm("mov ecx, [_var2]");
asm("mov [_var1] , ecx");
asm("mov [_var2], eax");
asm(".att_syntax noprefix");
printf("Valor de var1: %i\n", var1);
printf("Valor de var2: %i\n", var2);
return 0;
}
¿Por qué usas el registro ecx? ¿Podrías usar el ebx? Por cierto, no usé inline porque quería acostumbrarme a los ficheros objeto y a enlazar. En cualquier caso, ¿no debería mi código funcionar?
No entiendo esa sintaxis pero vamos quiero pensar que lo que tu estas haciendo es mover los datos a eax y no a la direccion a la que apunta :xD
osea estas haciendo esto:
mov eax, 1
mov ebx, 2
En lugar de esto:
mov [eax], 1
mov [ebx] , 2
Prueba así:
pushl %ebp
movl %esp, %ebp
movl 8(%ebp), %eax
movl 12(%ebp), %ebx
movl %ecx, 12(%ebp)
movl (%eax), %ecx
movl %ecx, 8(%ebp)
movl (%ebx), %ecx
popl %ebp
ret
Repito, no se esa sintaxis, puede que hasta sea erronea.
Lo de usar ECX en lugar de EBX es por que me apetecia :P
saludos.
Si, es que es alrevés xD
No entiendo por qué tiene que ser tan largo. En teoría, muevo las dos variables a los registros de propósito general y después les doy a las variables los valores intercambiados.
Muevo la primera a eax, muevo la seguda a ebx, le doy a la primera ebx y le doy a la segunda eax... No veo por qué no funciona en mi código. He conseguido que funcione con NASM con un código similar
Has probado mi código arreglando mi error? :rolleyes:
Es extraño. Tampoco funciona xD
Esta es la salida obtenida:
Introduzca el valor A: 10
Introduzca el valor B: 20
nValorA = 10
nValorB = 20
Debuggea el código a ver en que falla. :rolleyes:
CREO QUE POR FIN SÉ LO QUE FALLA, pero el problema es que no sé como solucionarlo... xD
Bueno, el problema es que estoy intercambiando las DIRECCIONES de las variables. Es decir, lo que recibimos con el puntero ebp es la dirección de la dirección, y cuando añadimos corchetes (nasm), a lo que accedemos es a la dirección de la variable.
mov eax, [ebp+0x8] ; [ebp+0x8] es la dirección del primer parámetro
mov ecx, [ebp+0xC] ; [ebp+0xC] es la dirección del segundo parámetro
mov [ebp+0xC], eax ; ¡Hemos intercambiado la dirección de ambas variables, no sus valores!
mov [ebp+0x8], ecx
Lo que se me había ocurrido (aunque no ha funcionado), es añadir doble corchete (debería ser super intuitivo XD):
...
mov eax, [[ebp+0x8]] ;No funciona :(
...
El error que me lanza el ensamblador NASM es:
intercambiar.asm:13: error: expression syntax error
intercambiar.asm:14: error: expression syntax error
intercambiar.asm:15: error: expression syntax error
intercambiar.asm:16: error: expression syntax error
Si alguien sabe como acceder a los valores, por favor, compartidlo :D
Normal te tira el error de sintaxis por el doble corchete. Si en ebp hay una direccion y la pasas a eax, y luego la copias sin mas, no estas copiando el valor.
movl 8(%ebp), %eax
Copio la direccion de ebp + 8, pero si es una direccion tienes que hacer esto de nuevo.
movl (%eax), %ebx
Y ya tienes el valor en ebx, y ya puedes pasarlo. Escribe una funcion en ASM con ASMinline y ahorrate todos esos problemas.
La funcion tiene dos variables, que esas son dos offsets, copia los valores de los offset a un registro de calculo general e intercambia.
;intercambiar variables eax y ebx
movl (%eax), %ecx
movl (%ebx), %edx
movl %ecx, (%ebx)
movl %edx, (%eax)
Cualquier cosa comenta.
Un saludo.
He conseguido solucionar el problema!! La solución (en NASM) es esta:
segment .text
global _change_values
_change_values:
enter 0,0
push ebx
mov edx, dword [ebp+8]
mov ebx, dword [edx] ; ebx = primer parámetro
mov edx, dword [ebp+12]
mov ecx, dword [edx] ; ecx = segundo parámetro
; mov dword [ebp+8], ecx >> Intercambiador v1 NO FUNCIONA
; mov dword [ebp+12], ebx
mov edx, dword [ebp+8] ; Intercambiador v2
mov [edx], ecx
mov edx, dword [ebp+12]
mov [edx], ebx
pop ebx
leave
ret
Esto me plantea otra duda. ¿Por qué el intercambiador v1 no funciona? Sé que le intercambiador v2 si que debe funcionar perfectamente (de hecho, funciona :D), pero no entiendo porque en la primera versión que hice no puede funcionar...
Gracias por toda su ayuda!!
PD.: Sé que he puesto dword de sobra, pero aun quitándolos del intercambiador no funciona...
Aquí está la versión reducida (sinceramente, no sé si se puede optimizar más xD)
segment .text
global _change_values
_change_values:
enter 0,0
push ebx
; void intercambiar(int* valor_a, int* valor_b);
mov eax, dword [ebp+8] ; eax = value_a
mov ebx, dword [ebp+12] ; ebx = value_b
mov ecx, [eax] ; ecx = *value_a
mov edx, [ebx] ; edx = *value_b
mov [eax], edx ; *valor_a = edx >> *valor_a = *valor_b
mov [ebx], ecx ; *valor_b = ecx >> *valor_b = *valor_a
pop ebx
leave
ret
Porque tu lo que le pasas a la función es un puntero. :P
¡¡He caído dos veces en la misma trampa!! No me lo puedo creer... ¡QUE DURO ES APRENDER ASM! Pero es satisfactorio y útil :P
Creo que no se puede resumir más...