(Consulta) Intercambiador de variables en ensamblador (sintaxis de AT&T)

[class_OpenGL]

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)

Código (asm) [Seleccionar] Expandir

.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:

Código (asm) [Seleccionar] Expandir

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:

Código [Seleccionar] Expandir

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++:

Código (c++) [Seleccionar] Expandir

#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

[fary]

Eso es sintaxis AT&T.

¿Porqué no usar ASM Inline?

Código (c) [Seleccionar] Expandir

#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;
}

[class_OpenGL]

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

[fary]

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  

osea estas haciendo esto:

mov eax, 1
mov ebx, 2

En lugar de esto:

mov [eax],  1
mov [ebx] , 2

Prueba así:

Código (asm) [Seleccionar] Expandir

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  

saludos.

[class_OpenGL]

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

[fary]

Has probado mi código arreglando mi error?  

[class_OpenGL]

Es extraño. Tampoco funciona xD

Esta es la salida obtenida:

Código [Seleccionar] Expandir

Introduzca el valor A: 10
Introduzca el valor B: 20

nValorA = 10
nValorB = 20

[fary]

Debuggea el código a ver en que falla. 

[class_OpenGL]

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.

Código (asm) [Seleccionar] Expandir

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):

Código (asm) [Seleccionar] Expandir

...
mov eax, [[ebp+0x8]] ;No funciona :(
...

El error que me lanza el ensamblador NASM es:

Código [Seleccionar] Expandir

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

[cpu2]

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.

Código (asm) [Seleccionar] Expandir

movl 8(%ebp), %eax

Copio la direccion de ebp + 8, pero si es una direccion tienes que hacer esto de nuevo.

Código (asm) [Seleccionar] Expandir

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.

Código (asm) [Seleccionar] Expandir

;intercambiar     variables eax y ebx

movl (%eax), %ecx
movl (%ebx), %edx

movl %ecx, (%ebx)
movl %edx, (%eax)

Cualquier cosa comenta.

Un saludo.