begin process at 2012 02 09 09:05:03
  Trouver un code source :
 
dans
 
Accueil > 

Code

 > 

Astuces

 > ASM INLINE AVEC GCC EN SYNTAXE INTEL

ASM INLINE AVEC GCC EN SYNTAXE INTEL


 Information sur la source

Note :
Aucune note
Catégorie :Astuces Classé sous :asm, inline, gcc, att, syntaxe Niveau :Débutant Date de création :27/07/2006 Vu / téléchargé :15 527 / 280

Auteur : vinc1008881

Ecrire un message privé
Site perso
Commentaire sur cette source (3)
Ajouter un commentaire et/ou une note

 Description

Il est parfois indispensable d'utiliser de l'asm quand oN programme en C, par exemple pour optimiser un programme, ou lorsque que l'on utilise des instructions que on n'a pas en C (exemple : int)
Seulement avec gcc (compilateur de dev-cpp) ce n'est pas chose facile, car la syntaxe est de type at&t, une sorte de mandarin (chinoi) pour ceux qui connaissent déjà la syntaxe intel (celle de nasm, masm...)
Mon code propose 2 méthodes pour palier à ce problème : la premiere est une astuce pour utiliser la syntaxe INTEL sous gcc, la seconde est un mini-dictionnaire qui regroupe quelques traductions de la syntaxe intel vers la syntaxe gcc.
Ce code s'adresse aux débutant qui ont dev-cpp, ou au personne sous LINUX !

Source

  • /*
  • * This program is free software; you can redistribute it and/or modify
  • * it under the terms of the GNU General Public License as published by
  • * the Free Software Foundation; either version 2 of the License, or
  • * (at your option) any later version.
  • *
  • * This program is distributed in the hope that it will be useful,
  • * but WITHOUT ANY WARRANTY; without even the implied warranty of
  • * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  • * GNU General Public License for more details.
  • *
  • * You should have received a copy of the GNU General Public License
  • * along with this program; if not, write to the Free Software
  • * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  • */
  • /*
  • * Conversion de la syntaxe at&t vers celle de intel (idem que nasm par exemple)
  • * Sous liscence GNU/GPL...blablabla...(par vinc1008881, vinc(pnt)calo~one( arob )wan~adoo.france)
  • * !!!!!!!!!!!POUR QUE GCC RESPECTE STRICTEMENT LA COMMANDE ASM ORDONNE, IL FAUT
  • * METTRE asm volatile ("instruction"); et non asm ("instruction");
  • */
  • //1)syntaxe intel avec gcc : ATTENTION NE MARCHE QU'AVEC DES VARIABLES GLOBALES !!!
  • void un (void) //ne PAS compiler ce programme
  • {
  • int var = 13;
  • asm (".intel_syntax noprefix");//passage en syntaxe intel
  • asm ("mov ax, 0x3");//instruction en syntaxe intel
  • asm ("mov eax, [var]");//l'edition des liens sera mauvaise car var est une variable LOCALE
  • asm (".att_syntax noprefix");//passage en syntaxe at&t
  • }
  • //2)syntaxe at&t avec gcc : possibilité d'inclure des variables locales
  • //comme cette syntaxe est imcompréhensible, voilà un dico de intel vers gcc :-)
  • //entre ( ) dans les lignes asm suivantes se trouve le nom de la variable locale --> ne pas enlever les parentheses
  • //bien sur je ne traite pas tous les cas : a vous d'adapter pour vos besoin (ex : charger eax en ebx...)
  • void deux (void)
  • {
  • char ca, cb, cc;//variables locales pour les exemples
  • short sa, sb, sc;
  • int ia, ib, ic;
  • asm("cli" ::); //cli
  • asm("hlt" ::); //hlt
  • asm("inb %w1, %b0" : "=a"(ca) : "d"(sa)); //mov dx, [sa] in al, dx mov [ca]
  • asm("int $0x10");//int 0x10
  • asm("jmp label");//jmp label --> idem pour tous les jxx
  • asm("label:");//label:
  • asm("lgdt %0" : : "m" (ia));//lgdt [ptr] /!\ ici ia est une structure de 6 octets
  • asm("lidt %0" : : "m" (ia));//lidt [ptr] /!\ ici ia est une structure de 6 octets
  • asm("mov %0, %%eax" :: "r" (ia));//mov eax, [ia]
  • asm("mov %%eax, %0" : "=r" (ia));//mov [ia], eax
  • asm("mov %ax, %ds");//mov ds, ax
  • asm("mov %eax, %ebx");//mov ebx, eax
  • asm("mov $next, %eax");//mov eax, next
  • asm("next:");
  • asm ("nop" ::); //nop
  • asm("outb %%al, %%dx" : : "d" (sa), "a" (ca));//mov al, [ca] mov dx, [sa] out al, dx
  • asm("outw %%ax, %%dx" : : "d" (sa), "a" (sb));//mov ax, [sb] mov dx, [sa] out ax, dx
  • asm("popf"); //popf
  • asm("popfl"); //popfd
  • asm("popl %ebp"); //pop ebp
  • asm("popw %ax"); //pop ax
  • asm("pushf"); //pushf
  • asm("pushf"); //pushfd
  • asm("pushl %ebp"); //push ebp
  • asm("pushw %ax"); //push ax
  • asm("rdtsc" : "=A" (ia));//rdtsc puis place le contenue de eax et ebx dans ia ICI unsigned long long de 64 bits
  • asm("sgdt %0" : "=m" (ia));//sgdt [ia] attention ia structure de 6 octets
  • asm("sidt %0" : "=m" (ia));//sidt [ia] attention ia structure de 6 octets
  • asm("sti" ::); //sti
  • }
/*
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */
 
/*
 *  Conversion de la syntaxe at&t vers celle de intel (idem que nasm par exemple)
 *  Sous liscence GNU/GPL...blablabla...(par vinc1008881, vinc(pnt)calo~one( arob )wan~adoo.france)
 *  !!!!!!!!!!!POUR QUE GCC RESPECTE STRICTEMENT LA COMMANDE ASM ORDONNE, IL FAUT
 *  METTRE asm volatile ("instruction"); et non asm ("instruction");
 */

//1)syntaxe intel avec gcc : ATTENTION NE MARCHE QU'AVEC DES VARIABLES GLOBALES !!!

void un (void)		//ne PAS compiler ce programme
{
int var = 13;
asm (".intel_syntax noprefix");//passage en syntaxe intel
asm ("mov ax, 0x3");//instruction en syntaxe intel
asm ("mov eax, [var]");//l'edition des liens sera mauvaise car var est une variable LOCALE
asm (".att_syntax noprefix");//passage en syntaxe at&t
}
	
//2)syntaxe at&t avec gcc : possibilité d'inclure des variables locales
//comme cette syntaxe est imcompréhensible, voilà un dico de intel vers gcc :-)
//entre ( ) dans les lignes asm suivantes se trouve le nom de la variable locale --> ne pas enlever les parentheses
//bien sur je ne traite pas tous les cas : a vous d'adapter pour vos besoin (ex : charger eax en ebx...)

void deux (void)
{
char ca, cb, cc;//variables locales pour les exemples
short sa, sb, sc;
int ia, ib, ic;
	
asm("cli" ::); //cli
	
asm("hlt" ::); //hlt
	
asm("inb %w1, %b0" : "=a"(ca) : "d"(sa)); //mov dx, [sa]		in al, dx	mov [ca]
asm("int $0x10");//int 0x10
	
asm("jmp label");//jmp label --> idem pour tous les jxx
asm("label:");//label:
	
asm("lgdt %0" : : "m" (ia));//lgdt [ptr]		/!\ ici ia est une structure de 6 octets
	
asm("lidt %0" : : "m" (ia));//lidt [ptr]		/!\ ici ia est une structure de 6 octets

asm("mov %0, %%eax" :: "r" (ia));//mov eax, [ia]
asm("mov %%eax, %0" : "=r" (ia));//mov [ia], eax
asm("mov %ax, %ds");//mov ds, ax
asm("mov %eax, %ebx");//mov ebx, eax
asm("mov $next, %eax");//mov eax, next
asm("next:");

asm ("nop" ::); //nop
	
asm("outb %%al, %%dx" : : "d" (sa), "a" (ca));//mov al, [ca]		mov dx, [sa]	out al, dx
asm("outw %%ax, %%dx" : : "d" (sa), "a" (sb));//mov ax, [sb]		mov dx, [sa]	out ax, dx

asm("popf");	//popf
asm("popfl");	//popfd
asm("popl %ebp");	//pop ebp
asm("popw %ax");	//pop ax

asm("pushf");	//pushf
asm("pushf");	//pushfd
asm("pushl %ebp");	//push ebp
asm("pushw %ax");	//push ax

asm("rdtsc" : "=A" (ia));//rdtsc	puis place le contenue de eax et ebx dans ia ICI unsigned long long de 64 bits

asm("sgdt %0" : "=m" (ia));//sgdt [ia] attention ia structure de 6 octets
asm("sidt %0" : "=m" (ia));//sidt [ia] attention ia structure de 6 octets
asm("sti" ::); //sti

}

 Conclusion

Il y a seulement les instructions fondamentales (mov, push, int) et ceux systeme (lgdt, cli...), les autres viendrons au fil du temps.

 Fichier Zip

Les Membres Club peuvent télécharger directement un fichier contenu dans le zip sans télécharger le zip en entier !

Télécharger le zip


 Sources du même auteur

ALGORITHME DE CALCUL DE PROBABILITÉ DU JEU RISK
Source avec Zip COMMENT PROGRAMMER UN OS SIMPLE EN C ET SOUS WINDOWS

 Sources de la même categorie

Source avec Zip SCHEDULER RR FIFO par yvesB87
Source avec Zip ALGORITHMES RÉCURSIFS VS ALGORITHMES ITÉRATIFS par yvesB87
Source avec Zip Source avec une capture C++ FORMAT D'IMAGE AVEC QT par pop70
Source avec une capture EXEMPLE DE POINTEURS DE FONCTION par pop70
Source avec Zip Source avec une capture [C++] CLASS REGISTER par Miwik

 Sources en rapport avec celle ci

Source avec Zip Source avec une capture FIND TEXT (WIN64) par BruNews
Source avec Zip ANALYSEUR DE TEXTE (MAJ V2) par sholvaC
Source avec Zip Source avec une capture OPTIMISATION DE CALCULS (WIN64) par BruNews
Source avec Zip Source avec une capture CALENDRIER (WIN64) par BruNews
Source avec Zip COMMENTER CODE C <=> ASM (WIN64) par BruNews

Commentaires et avis

Commentaire de Nebula le 03/08/2006 13:49:39

Dans le même genre et pour avoir de l'asm x86 dans gdb, çà peut servir : set disassembly-flavor intel

Commentaire de jb_gfx le 16/10/2006 08:20:30

Je sais toujours pas comment récupérer le contenu d'un registre dans une variable C. Si tu peux m'expliquer... merci

Par exemple:
eax=0x02B et j'ai ma variable C: int eaxRes;
Comment je place 0x02B dans eaxRes à la fin de ma routine asm?

Commentaire de acx01b le 02/09/2007 18:36:57

salut

moi l'asm inline at&t je l'utilises uniquement comme ça
pour utiliser un nom déclaré en C dans de l'asm les noms sont précédés par un _
mais comme l'asm est assemblé après la compilation, et qu'à la compilation les variables locales sont dans la pile ou les registres (et leur nom disparait), on ne peut utiliser que les variables globales (c'est logique et ça n'a pas spécialement de raison d'être autrement)
de la même manière on ne peut pas utiliser des noms en C qui ont été déclarés en asm sauf si en C on les déclare externe avant ou si on déclare le prototype pour une fonction

#include <stdio.h>
#include <stdio.h>
int eaxRes;

void mafonction2();
void mafonction() {
    printf("ma fonction\n");
}

asm("_mafonction2:");
asm("ret");

int main() {
    asm("movl $0x123, %eax");
    asm("movl %eax, _eaxRes");

    printf("%x\n",eaxRes); // affiche 123 (hexa)

    asm("movl $123, %eax");
    asm("movl %eax, _eaxRes");

    printf("%d\n",eaxRes); // affiche 123

    eaxRes = 122;
    asm("movl _eaxRes, %eax");
    asm("addl $1, %eax");
    asm("movl %eax, _eaxRes");
    printf("%d\n",eaxRes); // affiche 123

    asm("call _mafonction"); // affiche ma fonction

    mafonction2();
    return 0;
}

 Ajouter un commentaire


Discussions en rapport avec ce code source dans le forum

asm inline [ par tintin72 ] Bonjour,Je programme un petit jeu en OpenGL et j'aimerai savoir comment faire pour que les commandes clavier soit fluides et pas saccadées comme c'est DevCPP inline asm error [ par belette321 ] Bon, je suis en plein creation d'un petit dll qui utilisele ASM inline, j'ai plusieur fonction qui on touts les memeerreur. Cependant je ne trouve pas Inline asm + classe = erreur! [ par Darkneon ] Salut a tous.Lorsque je mets du codes assembleur dans ma classe le compilateur me renvoit l'erreur suivante."Inline assembly not allowed in inline and Naked function, asm inline, et chaînes de caractères [ par stagiairecpp ] Bonjour, Voilà je rencontre un soucis très particulier sous VS pour une situation très particulière. J'en appelle donc directement aux pro-codeurs ad Visual Studio 2008 x64 et procedure __asm [ par ld121962 ] Bonjour, Je voudrais passer un code de win32 en x64. A la compilation j'ai un message me disant que le mot clef "__asm, mov, etc.." sont inconnus. Q Problème avec GCC [ par messier79 ] BonjourJ'ai installé Mingw32 et j'ai configuré mes variables comme il fautA l'exécution de gcc -v, j'obtiens le message sans pb.Mais à la compil du fi VC++ fait chier [ par GoldenEye ] Qui peut me dire comment on place le curseur où on veut et ce sans Borland ( conio.h et gotoxy aux chiottes donc ) sous DOS et avec VC++ 6.0 ( ça fait Gtk avec gcc [ par GoldenEye ] Bonjour à tous.Je suis en trian de passer de VC++ à gccSi qqun pouvait m'indiquer un site de documentation sur la librairie graphique gtk, ce serait t Nix petit probleme de syntaxe avec les sources [ par Nic.C ] Salut,En faite le probleme c'est que tu fait mettre certain mot clés avec le 1er caractere en majuscule ce qui pose probleme quand on fait copier/coll gcc et les couleurs !! [ par UncleShu ] Salut je voudrais savoir les autres couleurs en C avec gcc, exemple :printf("\033[1;34m Ecrit en bleu !! \033[0m\n");Merci d'avance !


Nos sponsors


Sondage...

Comparez les prix

CalendriCode

Février 2012
LMMJVSD
  12345
6789101112
13141516171819
20212223242526
272829    

Consulter la suite du CalendriCode

 
Développement réalisé par Nicolas SOREL (Nix) avec l'aide de : Cyril DURAND et Emmanuel (EBArtSoft), Merci à Vincent pour ses précieux conseils.
CodeS-SourceS.com© Toute reproduction même partielle est interdite sauf accord écrit du Webmaster
CodeS-SourceS.com© est une marque déposée tous droits réservés

Google Coop CodeS-SourceS Google Coop CodeS-SourceS
Temps d'éxécution de la page : 1,685 sec (3)

Nous contacter | Annoncer sur CodeS-SourceS | Mentions légales