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:

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 Gracias

¿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?

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

Es extraño. Tampoco funciona xD

Esta es la salida obtenida:

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:

Si alguien sabe como acceder a los valores, por favor, compartidlo