[ASM] Neku a besoin de votre aide

Statut
N'est pas ouverte pour d'autres réponses.

neku

Codeur roumain
je vais en premier vous copier le morceau de code incriminé ^

Code:
// ==========================
// = Composantes Couleur ASM =
// ==========================

// #define GetR(Color) Color >> 16
unsigned int GetR_asm(int Color) {
	int Red = 0;

	asm ("pushl %eax");
	asm ("movl %0, %%eax" :: "r" (Color));
	asm ("shr $16, %eax");
	asm ("movl %%eax, %0" : "=r" (Red));
	asm ("popl %eax");
	
	return (unsigned int)Red;
}

// #define GetV(Color) (Color >> 8) - (GetR(Color) << 8)
unsigned int GetV_asm(int Color) {
	int Red = (int)GetR_asm(Color);
	int Vert = 0;
	
	asm ("pushl %eax");
	asm ("pushl %ebx");
	asm ("movl %0, %%eax" :: "r" (Color));
	asm ("shr $8, %eax");
	asm ("movl %0, %%ebx" :: "r" (Red));
	asm ("shl $8, %ebx");
	asm ("subl %ebx, %eax");
	asm ("movl %%eax, %0" : "=r" (Vert));
	asm ("popl %ebx");
	asm ("popl %eax");
	
	return (unsigned int)Vert;
}
Alors le problème est dans la fonction GetV
lorsque je fais :
asm ("movl %0, %%ecx" :: "r" (Red));
il écrase la valeur de eax précédement modifiée.
pourquoi ?
merci de votre aide ;)
 
1er
OP
neku

neku

Codeur roumain
Mon problème étant résolu voici comment récupérer chaque composante d'une couleur en Assemble inline compilé avec g++

Code:
// ==========================
// = Composantes Couleur ASM =
// ==========================

// #define GetR(Color) Color >> 16
unsigned int GetR_asm(int Color) {
	unsigned int Red = 0;

	asm ("pushl %eax");							//On sauvegarde la pile
	asm ("movl %0, %%eax" :: "r" (Color));		//On place la couleur dans le registre EAX
	asm ("shr $16, %eax");						//On décale de 16 rangs vers la droite la valeur binaire de la couleur (Division par 2^16)
	asm ("movl %%eax, %0" : "=r" (Red));		//On place le résultat dans la variable Red
	asm ("popl %eax");							//On restore la pile
	
	return Red;
}

// #define GetV(Color) (Color >> 8) - (GetR(Color) << 8)
unsigned int GetV_asm(int Color) {
	unsigned int Red = GetR_asm(Color);
	unsigned int Green = 0;
	
	asm ("pushl %eax");							//On Sauvegarde la pile
	asm ("pushl %ebx");
	asm ("movl %0, %%ebx" :: "r" (Red));		//Place la valeur de la composante rouge dans EBX
	asm ("shl $8, %ebx");						//On décale de 8 Rangs vers la gauche la valeur binaire de la composante rouge (Multiplication par 2^8)
	asm ("movl %0, %%eax" :: "r" (Color));		//On place la couleur dans le registre EAX
	asm ("shr $8, %eax");						//On décale de 8 Rangs vers la droite la valeur binaire de la couleur (Division par 2^8)
	asm ("subl %ebx, %eax");					//On soustraire EBX à EAX (Soit le résultat de l'opération précédente à celui encore avant)
	asm ("movl %%eax, %0" : "=r" (Green));		//On place le résultat dans la variable Green
	asm ("popl %ebx");							//On restore la pile
	asm ("popl %eax");
	
	return Green;
}

// #define GetB(Color) Color - (GetV(Color) << 8) - (GetR(Color) << 16)
unsigned int GetB_asm(int Color) {
	unsigned int Red = GetR_asm(Color);
	unsigned int Green = GetV_asm(Color);
	unsigned int Blue = 0;
	
	asm ("pushl %eax");							//On sauvegarde la pile
	asm ("pushl %ebx");
	asm ("pushl %ecx");
	asm ("movl %0, %%ecx" :: "r" (Green));		//On place la composante verte dans ECX
	asm ("shl $8, %ecx");						//Décalage de 8 Rangs vers la droite (Mul 2^8)
	asm ("movl %0, %%ebx" :: "r" (Red));		//composante Rouge dans EBX
	asm ("shl $16, %ebx");						//Décalage de 16 Rangs vers la droite (Mul 2^16)
	asm ("movl %0, %%eax" :: "r" (Color));		//On place la couleur dans EAX
	asm ("subl %ebx, %eax");					//On soustrait EBX à EAX
	asm ("subl %ecx, %eax");					//On soustrait ECX à EAX
	asm ("movl %%eax, %0" : "=r" (Blue));		//On place le résultat dans la variable Blue
	asm ("popl %ecx");							//On restore la pile
	asm ("popl %ebx");
	asm ("popl %eax");
	
	return Blue;
}
 

guslinux

Gamerz'ien
C'est quoi pour du code ca ???
Tu exécutes des instructions ASM via une fonction C ??
 
1er
OP
neku

neku

Codeur roumain
Oui rien ne t'interdit d'écrire directement des morceaux de code directement en Assembleur dans ton code source C.
 

kawash

Elite
j
e connais la syntaxe du genre :

asm {
mov ax, bx
}

mais pas cette syntaxe avec la fct asm("..") c avec quelles librairies, quel compilo?
 
1er
OP
neku

neku

Codeur roumain
Je l'ai dis plus haut g++
c'est la syntax at&t pas intel.

gcc, g++ n'accepte que la syntax at&t

puis pour les différence entre

asm {}
_asm {}
__asm {}
asm("")
....

google est ton amis ;)
 
Statut
N'est pas ouverte pour d'autres réponses.
Haut