code assembleur en c

Version imprimable

Voir 40 message(s) de cette discussion en une page

19/07/2006, 19h41
rare1

code assembleur en c
salut
comment faire le entrer le code assmebleur en c
sachant que je connait l'instuction qui est asm
en faite
on fait
Code:

1 2 3 4 5 asm{ mov ah,0x1 int 0x21 }
mais la pb que jmp ne fonctionne pas cad
je ne peut pas faire
Code:

1 2 3 4 5 6 asm{ etikette:mov ah,0x01 jmp etikette }
19/07/2006, 19h46
Gruik

Tu veux vraiment faire de l'assembleur? :)

Sinon, à une epoque je faisais des modules en assembleur utilisables dans du c apres avoir crée le header .h correspondant
Mais je sais plus comment ça marche...
19/07/2006, 19h48
millie

C'est vrai que tu peux faire un fichier assembleur à part, le compiler en objet, faire le .h et le lier ensuite (j'ai déjà fait cette méthode sur un M68k). Mais si c'est juste pour deux instructions, je ne sais pas, je me demande si il ne fallait pas en plus ajouter une option pour le compilateur.

Tu as une raison particulière d'en mettre, ou c'est juste pour savoir ?
19/07/2006, 19h57
Pragmateek
Pour le faire de manière standard:
Code:

1 2 3 asm("..."); asm("..."); ...
Mais l'insertion d'assembleur n'est pas portable.
19/07/2006, 20h05
rare1

non il est portable

telecharger turbo c cersion 3.0
et ecrivez asm{
mov ah,1
int 0x21
}
il marche
mais le jmp non:roll: :roll: :roll: :roll:
19/07/2006, 20h49
bouazza92

Je conseille de faire une compilation séparée avec NASM et GCC .
Va voir http://inferno.cs.univ-paris8.fr/~am.../os/nasmC.html
19/07/2006, 20h59
millie

Citation:

Envoyé par rare1

non il est portable

telecharger turbo c cersion 3.0
et ecrivez asm{
mov ah,1
int 0x21
}
il marche
mais le jmp non:roll: :roll: :roll: :roll:

Non, ça ne peut pas être portable sur toutes les machines. Sur d'autres processeurs, il n'y a pas les mêmes instructions que sur les x86 (pentium, celeron) et les mêmes registres (par exemple, les instructions machines sur des processeurs motorola 68000 sont complétements différentes, ou encore sur une station SUN).

Mais la plupart des PC en commerce ont le même jeu d'instruction (à peu près, il y a des ajouts supplémentaires sur certaines types de processeurs pour permettre des optimisations).
19/07/2006, 21h06
millie
Code:

1 2 3 4 asm{ mov ah,1 int 0x21 }
Je ne sais pas si tu utilises que cette instruction, mais il faut faire attention à ne pas dégager des valeurs dans les registres, ça pourrait faire planter le reste du programme ! (tu ne donnais peut être qu'un exemple)
20/07/2006, 10h21
bouazza92

Ah beh si tu veux vraiment faire un jmp sans compilation séparée , alors ça va devenir un peu compliqué...
Tu initialises une variable , tu y entres le code machine c'est à dire binaire ( et pas le code asm ) , et tu vas essayer d'obtenir son adresse .
Et dans ton prog en asm , tu fais un jmp vers cette adresse , ça devrait marcher normalement .
20/07/2006, 10h36
rare1

Citation:

Envoyé par bouazza92

Ah beh si tu veux vraiment faire un jmp sans compilation séparée , alors ça va devenir un peu compliqué...
Tu initialises une variable , tu y entres le code machine c'est à dire binaire ( et pas le code asm ) , et tu vas essayer d'obtenir son adresse .
Et dans ton prog en asm , tu fais un jmp vers cette adresse , ça devrait marcher normalement .

voila voila ce que je veut
explique toi en un petit exemple
c'est bien cette astuce
tres interrsant explique
20/07/2006, 10h37
bouazza92
Il y a aussi une autre solution plus simple .
Elle consiste à faire une fonction qui contiendra le code assembleur que doit contenir ton etiquette .
Puis tu essaies d'avoir l'adresse de cette fonction , et voilà , tu fais un jmp vers celle-ci .
Pour avoir l'adresse de ta fonction , il faut d'abord initialiser un pointeur vers celle-ci , le code pour initialiser un tel pointeur pourra être du genre :
Code:

1 2 void(*ptr_fonc)(); ptr_fonc = ta_fonc;// ta_fonc est ta fonction qui doit être seule , c'est à dire sans donner un paramétre suppélementaire ou paranthéses ...
20/07/2006, 10h47
bouazza92
Citation:

Envoyé par rare1

voila voila ce que je veut
explique toi en un petit exemple
c'est bien cette astuce
tres interrsant explique

Et beh ma premiére solution consiste à produire le code binaire du code que doit contenir ton etiquette puis de le stocker dans une variable dans ton code C , et il faut initaliser un pointeur vers celle-ci pour pouvoir accéder à son adresse mémoire , donc tu fais simplement un jmp vers cette adresse mémoire .

C'est un peu la même chose qu'on fait sur un secteur de boot .

Voilà je vais expliquer , tu entres le code de ton etiquette dans un fichier etiquette.asm , en ajoutant
Code:

1 2 [BITS 16] [ORG 0x0]
avant ton code , celà a pour objectif de ne produire que du code 16 bits ( compatible avec DOS ) .
Puis tu utilises NASM ( si tu ne l'as pas , télécharges-le sur le net ) .
Tu compiles ton fichier avec

Code:

nasm -f bin -o etiquette.bin etiquette.asm

Et le reste va être très facile , tu ouvres le fichiers avec un éditeur héxadécimal qui devra respecter les caractéres ASCII complexes , et tu copies ce code .
Tu ouvres ton fichier C avec ce même éditeur ( et pas Turbo C ) et tu initialises une variable char , par exemple :
Code:

1 2 char etiquette;
aprés celui ci , tu assignes le code binaire copié à la variable etiquette .
Et tu concaténes "jmp " avec &etiquette ( elle retourne l'adresse mémoire de etiquette ) ;
Enfin , tu executeras le résultats de la concaténation avec asm .

La compilation séparée aurai été plus simple .
20/07/2006, 10h54
gege2061
Bonjour,

Citation:

Envoyé par rare1

non il est portable

Il y a plusieurs choses à prendre en compte pour dire que c'est portable :
- Le mot clés asm est bien définie par la norme C99 (C90 je ne suis pas sûr) donc portable
- Les instructions doivent être fournies sous forme de chaîne de caractères, la syntaxe est propre à chaque compilateur, portable si tu compile toujours avec le même compilateur
- On parle d'assembleur donc portable sur les machines possédant les instructions/registres que tu souhaite exécuter
Donc en partant de quelque chose de standard, on arrive à un programme qui fonctionnera sur un nombre réduit de machines.
20/07/2006, 10h54
bouazza92

Ah beh je conseille toujours de faire une compilation séparée avec NASM et GCC , donc il faudra oublier Turbo C ( 16 bits , donc ton code ne sera pas très rapide ) , et adopter DJGPP ( si tu n'as pas windows ) ou Dev-C++ ( Pour Windows ) , ceux-ci intégrent ld qui est nécessaire pour la compilation séparée ( ou gcc si on ne veut pas faire un binaire plat mais plutot un EXE ) .
Ils permettent aussi de travailler en mode 32 bits , donc tes codes exploiteront les plus hautes performances du microprocesseur et seront donc très rapides !
Et puis , l'utilisation d'un compilateur comme GCC te permettra de te concentrer plus sur la portabilité de tes codes !
20/07/2006, 20h00
mat.M

Citation:

Envoyé par rare1

il marche
mais le jmp non

Peux-tu être précis : jmp ne fonctionne pas c'est à dire ?
Le code donné , on boucle indéfiniment ce qui fait que le flag Overflow du CPU doit être activé ou il y a dépassement de pile et la section en assembleur rend la main à la suite du programme.

Les interruptions ne fonctionnent pas sous Windows seulement sous Dos et sans doute pas sous Unix
20/07/2006, 23h55
David.Schris
Citation:

Envoyé par bouazza92

Et beh ma premiére solution consiste à produire le code binaire du code que doit contenir ton etiquette puis de le stocker dans une variable dans ton code C , et il faut initaliser un pointeur vers celle-ci pour pouvoir accéder à son adresse mémoire , donc tu fais simplement un jmp vers cette adresse mémoire .

Pas bête. Cela fonctionera sous DOS. Par contre, sous d'autres systèmes (en mode protégé), tu pourrais avoir un problème dans le cas où ta variable est dans une zone non exécutable de la mémoire.
Citation:
Envoyé par bouazza92

Il y a aussi une autre solution plus simple .
Elle consiste à faire une fonction qui contiendra le code assembleur que doit contenir ton etiquette .
Puis tu essaies d'avoir l'adresse de cette fonction , et voilà , tu fais un jmp vers celle-ci , le code pour initialiser un tel pointeur pourra être du genre :

Code:

1 2 void(*ptr_fonc)(); ptr_fonc = ta_fonc;// ta_fonc est ta fonction qui doit être seule , c'est à dire sans donner un paramétre suppélementaire ou paranthéses ...
Mais pour être sûr d'être tranquille, il faudra peut-être penser à dire au compilateur de ne pas générer le prologue de la fonction en question, non ?

Citation:

Envoyé par mat.M

Les interruptions ne fonctionnent pas sous Windows seulement sous Dos et sans doute pas sous Unix

Sous Unix, je ne sais pas. Sous linux, par contre, il y a au moins une interruption qui DOIT fonctionner, même sans être root...

Au cas où cela aiderait quelqu'un : avec gcc on peut fair un JMP vers un label.

Enfin, une autre idée : si votre compilateur ne supporte pas l'utilisation des labels, peut-être pouvez-vous vous en sortir avec des sauts relatifs ?
21/07/2006, 20h43
rare1

ces solution vraiment malgre que je suis un eleve ingenieur informatique

sont tres difficile surtout celle de bouazza.
mais vous m'avez dit de faire la compilation separe avec c et nasm(malgre que je prefere tasm)
bon ya qq qui peut m'expliqer cette compilation separe sachant que mes outils sont nasm et turbo c
@mat.m
ma probleme est la suivante.

si j'ecrit ce programme dans le trubro c

#include<stdio.h>

main()
{
asm{

mov ah,0x1
int 0x21
mov ah,0x4
int 0x21
}
printf("developpez.com est le meilleur site web en informatique");
}

------->il marche 5/5

alors que si j'ecrit ce programme

#include<stdio.h>

main()
{
asm{

etikette:mov ah,0x1
int 0x21
jmp etikette

mov ah,0x4
int 0x21
}
printf("developpez.com est le meilleur site web en informatique");
}

----------------->ca ne marche pas
22/07/2006, 10h54
rare1

:cry: bouazza plz aide moi sur ce pb

Perso j'utilise GCC qui apelle l'assembleur gas des binutils pour mes codes assembleurs.

Tout comme cela a été dit plus haut je te conseille de séparer tes codes assembleur et C le plus possible, ca fait très vite brouillon.
Tu peux créer ton .h en C et son implémentation en .S, c'est la solution la plus propre je trouve.

.h
Code:

1 2 3 4 5 6 7 8 9 10 #ifdef HAVE_ASM_USCORE # define EXT_C(sym) _ ## sym #else # define EXT_C(sym) sym #endif #ifndef ASM //tes définitions #endif
.S
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 #define ASM 1 #include "ton.h" // Tu créés une stack et tes flags movl $(stack + TAILLE_STACK), %ebp movl %ebp, %esp pushl $0 popf // Tu empiles les paramètres de ta fonction pushl %ebx pushl %eax // Tu apelles la fonction call EXT_C( ta_fonction ) // Tu fais une boucle si tu veux loop: NOP jmp loop
Pour ceux a qui le code parait bizarre, gas inverse les opérandes par rapport à l'assembleur intel.

22/07/2006, 23h55
David.Schris

Citation:

Envoyé par rare1

[...]

etikette:mov ah,0x1
int 0x21
jmp etikette

mov ah,0x4
int 0x21
}
printf("developpez.com est le meilleur site web en informatique");
}

----------------->ca ne marche pas

Si tu commençais par répondre à mat.M (son message est là), cela serait un bon début.
Ecrire "ca ne marche pas" ne suffit pas.

Aussi, comme il l'a très justement fait remarquer, tu as une boucle "infinie" (?) dans ton code. Le fait de constamment lire ce qui vient du clavier sans jamais s'arrêter me paraît à moi aussi comme étant d'un intérêt relativement limité (et rend le code qui suit inutile).

Pour résumer :
1) décris correctement ton problème.
2) réfléchis bien à ce que tu veux faire avant d'écrire du code.

Voir 40 message(s) de cette discussion en une page