Gnu Asm

[sés]

 ¿Alguien sabe de alguna página dónde venga BIEN explicado cómo insertar ensamblador "inline" en GCC (MingW concretamente)?

Solo veo los típicos ejemplos tontos tipo "movl $0,%eax"...
Cómo hacer un "memset" (y no me funciona ninguno) <_<

Esto está "copiado" (solo he cambiado el nombre de las variables por la mías) de los tutoriales que he encontrado:

Código [Seleccionar] Expand

   asm (
       "cld\n"
       "rep\n"
       "stosl\n"
       :
       : "c" (size), "a" (value), "D" (ptr)
       : "%ecx", "%edi"
   );
size, value y ptr son variables locales.

Me da este error: error: can't find a register in class `CREG' while reloading `asm'


Tampoco soy capaz de hacer los "mov" a mano:

Código [Seleccionar] Expand

   asm (
       "cld\n"
       "movl $ptr,edi\n"
       "movl $value,eax\n"
       "movl $size,ecx\n"
       "rep\n"
       "stosl\n"
   );
Al enlazar me dice que no encuentra las variables ptr, value y size

¿Alguien sabe qué está mal o alguna página donde explique bien cómo hacerlo?

[jelorol]

 A lo mejor esto te sirve de ayuda:

http://howtos.linux.com/howtos/Assembly-HO...HOWTO/gcc.shtml

[fiero]

 Vaya coñazo ¿no?, en realidad eso de asm("..."); es una función con el código ensamblador pasado como una cadena de texto... ¿No hay una instrucción asm{} al igual que el borlandC de dos o el visualC++ de windows ?

Igual debes especificar los saltos de linea con \n\t

[sés]

 La final lo he resuelto así:

Código [Seleccionar] Expand

   asm (
       "cld\n\t"
       "movl %0,%%edi\n\t"
       "movl %1,%%eax\n\t"
       "movl %2,%%ecx\n\t"
       "rep; stosl"
       :
       : "m" (ptr), "m" (value), "m" (size)
       : "%ecx", "%edi"
   );

Aunque sigo sin saber cómo hacerlo funcionar de la forma que puse antes y que he visto en un montón de páginas <_<. Seguiré probando.


Lo que no entiendo es porqué narices hay que poner los dichosos saltos de línea. ¿No hay alguna forma de hacerlo como en otros compiladores? O.o

[_Grey]

 Mirando un programilla antiguo e encontrado que las declaraciones de codigo asm las hago de otra forma, normalmente con esto:

Código [Seleccionar] Expand


__asm__ __volatile__("
... CODIGO ...
                       "
                       :
                       :"g"(compointer),"g"(comdestino),"g"(compointerendY)
                       );

salvo cuando es solo una instruccion donde sale asi:

Código [Seleccionar] Expand


__asm__("cli"); // cli es la instruccion asm

no me preguntes para que era el __volatile__, igual era para que el compilador pudiera tomarse libertad de optimizar esa parte o todo lo contrario.....

Por cierto ese asm es horrible un muy buen motivo para no tocarlo, de hecho seria mejor que te mirases NASM que parece que hacia buena pareja con GCC, y tiene una sintaxis "humana".
De todas formas puede que este anticuado y esto sea haora distinto hace muchisimo que no toco este compilata, y a dios pongo por testigo que no volvere a usar asm inline en el!!!

Saludos y suerte.

[EDIT]

Lo que no entiendo es porqué narices hay que poner los dichosos saltos de línea. ¿No hay alguna forma de hacerlo como en otros compiladores? O.o

Los saltos de linea (\n) no pero el \t y las comillas en cada linea deberias poder.

[sés]

Los saltos de linea (\n) no pero el \t y las comillas en cada linea deberias poder.

Los "\t" sí se pueden quitar, solo los puse para ver mejor el ASM que se generaba. Incluso se pueden quitar los "\n" y poner ";", lo que no sé es si darái problemas al generar líneas muuuuuuuuuuy largas.
Y las comillas... ¿cómo las quito? Todo tiene que ir en una cadena, ¿no?


Bueno, uso este (asqueroso) ASM porque quiero que sea "inline" y no sé hacerlo con otro (ni siquiera sé si se puede).
De todas formas solo estaba probando para hacer algunas funciones pequeñas. Aun me quedan bastantes cosas que hacer antes de ponerme a pasar el código a ASM. Espero que me dé tiempo antes del "concurso" ^_^

[samsaga2]

 Recuerdo a la gente que las GCC si soportan ensamblador con la sintaxis de Intel:

asm (
  ".intel_syntax\n\t"
  "mov eax,0\n\t"
  "mov ebx,eax\n\t"
  "mov eax,ebx\n\t"
)

Que bonito codigo en assembler me ha quedao lo dono a la posperidad O_O acordaos de mi cuando seas ricos y famosos.

[TheAzazel]

Recuerdo a la gente que las GCC si soportan ensamblador con la sintaxis de Intel:

asm (
  ".intel_syntax\n\t"
  "mov eax,0\n\t"
  "mov ebx,eax\n\t"
  "mov eax,ebx\n\t"
)

Que bonito codigo en assembler me ha quedao lo dono a la posperidad O_O acordaos de mi cuando seas ricos y famosos.

Seguro q eso tira? dios, me akabas de arreglar el dia! en el puerto a linux habia eliminado todas las optimizaciones MMX-SSE por no ponerme con ese engorro...pero si acepta esa sintaxis es mucho mas friendly.

Ses, si el metodo anterior no funciona... lo mejor es usar nasm, pq lo otro es un LIO!!!

saludos

[TheAzazel]

 Ses, tengo un conversor de codigo ASM entre AT&T e Intel, si aun lo necesitas, dimelo y te lo paso.
Saludos

[sés]

 Pues no me vendría nada mal para cuando me ponga a pasar cosas a ASM ^_^

Si no ocupa demasiado manda pacá: sesses[arrobita]wanadoo[puntito].es

[TheAzazel]

 ya lo tienes