Discussion :

[Snark]

Bonjour à tous !

Je suis à l'origine développeur C, mais suite à des besoins récent dans l'optimisation de traitement d'image, j'ai décidé de me mettre sérieusement à l'assembleur, afin de pouvoir utiliser les optimisations processeur spécifiques, et notamment le MMX (si vous en avez d'autre à proposer, je suis preneur).

Malheureusement mes connaissances en assembleur remontais à la fac, et n'était pas du tout orienté x86. Donc après plusieurs jours de documentation, je me suis enfin senti prêt à faire mes premiers essais. Et là, *paf*. J'utilise GCC qui utilise la norme AT&T, alors que toutes mes documentations était en norme Intel.... donc après une demi journée de plus pour comprendre les différences et l'intégration avec GCC, je m'y suis mis.

Pour m'entrainer, j'ai décidé de commencer doucement avec le MMX et de faire une fusion de deux images avec un niveau d'alpha.

Mais là, *repaf* après quelques essais très simple, j'obtient quelque chose qui ne ressemble pas du tout à ce que je souhaite. Voici mon début de code avec, en commentaire, ce que j'attendais dans les registres (sur archi 64bits):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
void test_mmx()
{
	unsigned int color = 0x00000020;
	unsigned char data[8] = {255,255,255,255,255,255,255,255};
 
	__asm__ (
		"movl %%edx,%%eax\n\t"   // eax = 0x00000020
		"shl $16,%%eax\n\t"      // eax = 0x00200000
		"addl %%edx,%%eax\n\t"   // eax = 0x00200020
 
		"movd %%eax, %%mm0\n\t"  // mm0 = 0x00000000 00200020
		"movd %%eax, %%mm1\n\t"  // mm1 = 0x00000000 00200020
		"psllq $32,%%mm0\n\t"    // mm0 = 0x00200020 00000000
		"paddq %%mm1, %%mm0\n\t" // mm0 = 0x00200020 00200020
 
		"movq %%mm0,(%%rdi)\n\t" // rdi = 0x00200020 00200020
		: 
		: "d"(color),"D"(data)
    );
 
    printf("> %02x%02x%02x%02x %02x%02x%02x%02x\n",data[0],data[1],data[2],data[3],data[5],data[6],data[7],data[8]);
}

Et voici le résultat de l'execution:

> 20002000 00200000

Comme on le vois, le résultat n'est pas que j'escomptais dans le commentaire . Mais je n'arrive pas à comprendre où je me suis trompé. Ce doit être un truc tout bête, mais ça m'échappe.

----

Question subsidiaire d'ultra débutant:
J'ai vu dans plusieurs documentation la syntaxe qui revient régulièrement:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
sub     eax, [ebx + ecx * 4h - 20h]    ; syntaxe Intel
subl    -0x20(%ebx, %ecx, 0x4), %eax    ; syntaxe AT&T

Sauf que je n'arrive pas a trouver d'explication claire sur ce que calcul -0x20(%ebx, %ecx, 0x4). J'ai bien vu que c'était disp(base, index, scale).
En testant, -4(%ebx), je comprend bien qu'il me fait un offset d'adresse de -4. Mais pour les autres paramètres, le compilateur m'insulte dès que j'essai de mettre quelque chose. Par conséquent, je n'ai pas vraiment saisi comment ça s'utilise et dans quel cas.

J'ai pensé un moment que -1(%ebx, 4) allais me faire juste me faire un décalage de -1*4... Mais le compilateur n'en veut pas. Donc si quelqu'un peut m'éclairer là dessus, j'en resortirai un peu moins bête

Merci beaucoup pour votre aide !

[Snark]

Mes déboires, jour 2:

Edit: Oubliez ce message.... J'ai compris. Je suis trop con, je suis en little endian. Besoin de sommeil moi !

J'ai décidé de faire des essais en très petite section, pour mieux saisir les particularités. Donc j'ai fait ça:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
	unsigned char data[8] = {0,0,0,0,0,0,0,0};
	__asm__ (
		"movl $0x04030201,%%eax\n\t"
		"movl %%eax,(%%rdi)\n\t"
		: "=a"(ret2)
		: "D"(data)
	);
 
    printf("> %08x\n",ret2);
    printf("> %02x%02x%02x%02x %02x%02x%02x%02x\n",data[0],data[1],data[2],data[3],data[4],data[5],data[6],data[7]);

Ce qui me donne:

> 04030201
> 01020304 00000000

Pourquoi l'ordre des octets sont inversé dans mon tableau !?


----
Pour ma question subsidiaire sur le -0x20(%ebx, %ecx, 0x4) j'ai compris tout seul. Le second paramètre dois forcement être un registre, tout simplement. C'était bien le fonctionnement que je pensais, sinon.

[n5Rzn1D9dC]

Salut,

Pour ton problème de AT&T, pour lequel je suis d'accord sur le faite que ça craint, je sais qu'il existe au moins un code pour faire la conversion.
Donc tu peux coder en intel, et le binaire te changera tout ton code en syntax AT&T.

Il me semble que j'étais tombé dessus par hasard en faisant une recherche apt-get, mais là je viens d'en lancer une et il m'a renvoyé une liste de résultat prodigieusement grande ^

edit:
Je viens de le retrouver en rajoutant "nasm" comme je pensais me rappeler.

J'ai trouvé un descriptif:

intel2gas

intel2gas is a converter between the source format of the NASM and GAS (GNU Assembler) assemblers. It was originally written for use with the Hermes project but with extensibility in mind. Syntax files can be written to allow conversion between any other assembly languages. Conversion between MASM and C inline assembly and GNU syntax is now available.

Bon par contre toi ce serait pour de l'asm inline vers de l'asm inline, donc je ne sais pas si il pourrait fonctionner.

Pour ton histoire de -20, je pige quedal à la syntax at&t, mais si ça donne ce que tu as donné en intel, c'est à dire:
"sub eax, [ebx + ecx * 4h - 20h]"

Ca veut dire:
Soustraire à eax le dword pointeur de [ebx+ecx*0x4-0x20]
Donc ce qu'il y a entre crochet est un pointeur mémoire, qui doit être soustrait à eax.

L'idéal c'est quand même de regarder tout ça au debugger (genre Immunity debugger pour win32 / edb ou gdb ou fdbg pour Linux) afin de bien comprendre ce qu'il se passe.
Après tout, ça sert justement à ce genre de chose ^
Au moins tu pourras voir en live à quoi correspond le pointeur, à quoi sert cette opération et les conséquences sur celle qui suivra etc..

[Obsidian]

Hello,

C'est une bonne chose d'avoir vu un poil la syntaxe AT&T pour principe mais, personnellement, une fois que je l'ai vue ça me suffit. :-)

Tu peux donc ajouter :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

    ".intel_syntax noprefix"

… en début de code assembleur inline dans un programme C géré par GCC. Il faudra peut-être ajouter également :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

    ".att_syntax"

… à la fin, sinon l'assembleur qui suit l'étape de compilation C risque de ne pas être capable de retomber lui-même sur ses pieds.