[ASM] Neku a besoin de votre aide

Discussion dans 'Web, design' créé par neku, 30 Janvier 2007.

Statut de la discussion:
Fermée.
  1. Offline
    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 ;)
    neku, 30 Janvier 2007
    #1
  2. Offline
    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;
    }
    
    neku, 31 Janvier 2007
    #2
  3. Offline
    guslinux Gamerz'ien
    C'est quoi pour du code ca ???
    Tu exécutes des instructions ASM via une fonction C ??
    guslinux, 31 Janvier 2007
    #3
  4. Offline
    neku Codeur roumain
    Oui rien ne t'interdit d'écrire directement des morceaux de code directement en Assembleur dans ton code source C.
    neku, 31 Janvier 2007
    #4
  5. Offline
    kawash Touriste
    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?
    kawash, 1 Février 2007
    #5
  6. Offline
    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 ;)
    neku, 1 Février 2007
    #6
Statut de la discussion:
Fermée.