Discussion :

[Altess]

Bonjour,

Je souhaite compiler un code qui contient de l'assembleur.
J'utilise g++ pour compiler le tout, et la notation AT&T nescessaire à g++ pour coder de l'assembleur est plus que bordelique. J'ai donc utilisé la commande ".intel_syntax", qui me permet de coder l'assembleur de maniere classique, sous g++. Pour plus de clareté, je vous exposes le code :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
void MaFonction(char *param1, char *param2)
{
          asm
          (
                    ".intel_syntax noprefix\n"
                    "mov eax, param1\n"
                    "mov ecx, param2\n"
                    [...]
                    ".att_syntax\n"
          );
}

Mon probléme est que l'utilisation de param1 et param2 n'est pas autorisé.
Je n'arrive pas a utiliser ces parametres dans mon code assembleur.
J'ai observer une methode qui consiste a ajouter des information en fin de code :

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
 
void MaFonction(char *param1, char *param2)
{
          asm
          (
                    ".intel_syntax noprefix\n"
                    "mov eax, a\n"
                    "mov ecx, b\n"
                    [...]
                    ".att_syntax\n"
                    :
                    :"b" (param2), "a" (param1)
                    :
          );
}

Mais ca ne fonctionne pas non plus.
J'ai l'erreur : impossible constraint in 'asm'

Pour information, je travail sous windows XP. J'utilise Qt.
Mon code assembleur fonctionne parfaitement sous VC++ si je l'adapte.

Avez vous une idée de la provenance de ce problème ? Et de quelle manière le résoudre ?

Cordialement,
PKO

[screetch]

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
void MaFonction(char *param1, char *param2)
{
asm
(
".intel_syntax noprefix\n"
"mov eax, a\n"
"mov ecx, b\n"
[...]
".att_syntax\n"
:
:"b" (param2), "a" (param1)
:
);
}

le "b" et le "a" dit au compilo de placer ces variables dans "eax" et "ebx" respectivement
je crois que ca marcherait (je suis pas certain...)

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
void MaFonction(char *param1, char *param2)
{
asm
(
".intel_syntax noprefix\n"
[...]
".att_syntax\n"
:
:"c" (param2), "a" (param1)
:
);
}

[screetch]

et vérifie bien que ca donne le bon résultat a la compil =)

[Altess]

Bonsoir.

Effectivement, le soucis vient bien de là. Ca compile bien maintenant.
Malgré la bonne compilation, mon application plante quand même. J'ai réussi à localiser l'endroit, mais, étant sous Qt, je ne sait pas exploiter le mode debug, et je regrette grandement le mode pas à pas de VC++

Si je vire tous les appels des fonction asm ca fonctionne, si je les laisse, ca fonctionne pas. Le problème est ciblé, c'est déjà ça.

Correction : J'ai 3 fonction en asm. Seulement 2 font planter l'application.

[screetch]

tu as vérifié le code généré, que les variables etaient bien placées dans les bons registres ? tu peux le poster la ?
il y a une option g++ pour avoir le listing du code assembleur

[koala01]

Salut,

Je vais surement te paraitre buté, mais, pourquoi passer par des instructions en assembleur

De manière générale, l'assembleur que tu pourrais générer a de fortes chances d'être moins efficace que celui que le compilateur est susceptible de générer en utilisant les bons paramètres et en fournissant un algorithme correct.

De plus, il ne faut pas oublier que tu as, pour ainsi dire, autant d'assembleur que de systèmes, plateformes et autres processeurs, ce qui me fait dire que c'est vraiment courir un risque très important au niveau de la portabilité (si celle-ci t'intéresse un tant soit peu, selon ton point de vue )

[Altess]

Koala01 > Bonsoir. Le code n'est pas de moi, je souhaite simplement l'adapter à Qt. Je n'est pas estimé nécessaire la conversion asm -> C++, simplement parce qu'en général, si ça marche, faut pas toucher

Voila le code :

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
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
__declspec(naked) BOOL __fastcall SameSector(LPBYTE lpSect1, LPBYTE lpSect2)
{ // ECX = lpSect1, EDX = lpSect2
	asm 
	(
		".intel_syntax noprefix\n"
		"push  ebx\n"
		"mov   eax, edx\n"
		"mov   ebx, 32\n"

	"Next:\n"
		"mov   edx, [ecx]\n"
		"cmp   edx, [eax]\n"
		"jne   short Diff\n"

		"mov   edx, [ecx+4]\n"
		"cmp   edx, [eax+4]\n"
		"jne   short Diff\n"

		"mov   edx, [ecx+8]\n"
		"cmp   edx, [eax+8]\n"
		"jnz   short Diff\n"

		"mov   edx, [ecx+12]\n"
		"cmp   edx, [eax+12]\n"
		"jne   short Diff\n"
		"dec   ebx\n"
		"jz    short samExit\n"
		"add   ecx, 16\n"
		"add   eax, 16\n"
		"jmp   short Next\n"
	"Diff:\n"
		"xor   eax, eax\n"
	"samExit:\n"
		"pop   ebx\n"
		"ret   0\n"
		".att_syntax \n"
		:
		:"d" (lpSect2), "c" (lpSect1)// ECX = lpSect1, EDX = lpSect2
		:
		);

Cette méthode compare deux zones mémoires de 512 octets et retourne vrai si elles sont identiques, faux sinon.

Après étude, j'ai observé que le code plantait au niveau de la ligne en gras. Malheureusement, je n'arrive pas visualiser la valeur des registres. Pas évident pour debuger.

Cordialement,
PKO

[Altess]

Re Bonsoir.

Koala01 > C'est en lisant ton poste, et en rédigeant le miens que je me suis senti ridicule. Tu me fais logiquement observer :

"pourquoi passer par des instructions en assembleur

Plus bas, je te répond que ce petit bout de code en assembleur sert à :

Cette méthode compare deux zones mémoires de 512 octets et retourne vrai si elles sont identiques, faux sinon.

Et là, c'est l'illumination. Ce code assembleur sert a rien, il me suffit de comparer le tout via des méthodes disponibles dans la bibliothèque standard C++. Je me lance sur mon code, et en 3 coups de cuillère à pot c'est plié.

Cette aventure aura le mérite de m'avoir fait re-découvrir l'assembleur, le AT&T, et surtout, surtout, il m'aura permis de prendre conscience. ¨Prendre du recul sur un code, ça peut éviter de passer pour un c** en postant sur le forum.

Mille fois désolé de vous avoir fait perdre votre temps.
Je vous souhaites une bonne soirée, je crois que j'ai besoins de repos

Cordialement,
PKO

[koala01]

(HS: normalement, il faudrait écrire "en trois coups de cul, hier, à Pô... c'est une longue histoire, mais la cuillère à pot n'existe pas )

A vrai dire, à la lecture du début de ton message, je m'apprêtais à répondre "mais encore faut il voir comment ca marche"... J'aurais presque tendance à préférer un code "qui ne fonctionne pas bien" mais facile à comprendre, qu'un code "qui marche" mais qui est incompréhensible.

Le fait est que, au moins, quand tu as un code facilement compréhensible (qui évite les effets de bords, qui place une variable, une instruction ou un appel de fonction par ligne, et qui est correctement indenté), tu as beacoups plus facile à le retravailler "pour qu'il marche", d'abord, mais aussi pour l'adapter aux changements s'il doit prendre en compte des nouvelles restrictions parce que "oublié dans un coin" pendant 10 ans (ou écrit avec un langage décidément trop proche de la machine)

Ensuite, j'ai remarqué que tu te contredisais car, justement, tu avais un problème avec ton code assembleur...

J'ai donc eu la réaction de te dire "mais si ca marchait, tu n'aurait pas de problème", et cela renforçait - par la preuve - ce que j'essayais de te faire comprendre

Entendons nous, je n'ai rien contre l'assembleur, et il y a effectivement des cas où il est nécessaire d'y recourir (peut être simplement parce que c'est la seule chose dont on dispose ) mais, dans l'ensemble, je suis généralement réticent lorsqu'il s'agit d'envisager le mix de deux choses aussi dissemblables que l'assembleur et un langage de troisième génération orienté objet

Pour le reste, je peux te rassurer: le ridicule ne tue pas depuis de nombreuses années (sinon, je n'aurais pas atteint mon age "canonique ) mais ce qui est vrai, c'est qu'en prenant un peu de recul sur un code, on peut s'éviter des heures de pertes de temps finalement inutiles