code assembleur en c

**rare1** · 19/07/2006, 19h41

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

Code :

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

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 :

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

1
2
3
4
5
6
 
asm{
 
etikette:mov ah,0x01
jmp etikette
}

**Gruik** · 19/07/2006, 19h46

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...

**millie** · 19/07/2006, 19h48

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 ?

**Pragmateek** · 19/07/2006, 19h57

Pour le faire de manière standard:

Code :

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

1
2
3
asm("...");
asm("...");
...

Mais l'insertion d'assembleur n'est pas portable.

**rare1** · 19/07/2006, 20h05

non il est portable

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

**bouazza92** · 19/07/2006, 20h49

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

**millie** · 19/07/2006, 20h59

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

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).

**millie** · 19/07/2006, 21h06

Code :

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

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)

**bouazza92** · 20/07/2006, 10h21

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 .

**rare1** · 20/07/2006, 10h36

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

**bouazza92** · 20/07/2006, 10h37

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 :

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

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 ...

**bouazza92** · 20/07/2006, 10h47

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 :

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

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 :

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

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 :

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

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 .

**gege2061** · 20/07/2006, 10h54

Bonjour,

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.

**bouazza92** · 20/07/2006, 10h54

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 !

mat.M · 20/07/2006, 20h00

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

**David.Schris** · 20/07/2006, 23h55

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.

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 :

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

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 ?

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 ?

**rare1** · 21/07/2006, 20h43

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

**rare1** · 22/07/2006, 10h54

bouazza plz aide moi sur ce pb

**NewbiZ** · 22/07/2006, 16h59

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 :

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

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 :

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
 
#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.

**David.Schris** · 22/07/2006, 23h55

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.

code assembleur en c

C

Discussions similaires

Partager

Partager