Language assembleur

[hepta7]

Bonjour,
Pourriez-vous m'aider svp, je n'arrive pas à résoudre ce problème?

Ex. 1
Soit un fichier dont le nom est stocké dans une variable. Ecrivez
un
programme qui :
— tente d’ouvrir le fichier en écriture seule ;
— si l’ouverture échoue :
— affiche à l’écran le message :
échec lors de l’ouverture du fichier

— passe a la ligne ;
— retourne le code d’erreur 1 ;
— si l’ouverture réussit :
— affiche a l’écran le message :
fichier ouvert avec succès
— passe a la ligne ;
— ferme le fichier ;
— retourne la valeur 0 pour indiquer un dénouement correct.
-----

[JPL]

Explique d'abord ce que tu as tenté, sur quoi tu butes .

[hepta7]

Tout d'abord merci prêter attention à mon problème,
Je viens débuter dans le langage assembleur.
Voici le bout de code avec le quel j'ai commencé qui permettait de savoir comment comment ouvrir un fichier en écriture seul. (je ne sais toujours pas )
D'après mes note de cours quand on met "eax, 5" cela permet d'ouvrir ou créer un fichier.
Donc voici ma question: comment savoir si le fichier a été ouvert ou créé (est-ce avec ecx que je pourrais déterminer cela*?)
Et dans quel cas l'ouverture échoue?

global main
section .rodata
	nomFichier	DD	'brol', 0
section .text
main:
	mov eax, 5
	mov ebx, nomFichier
	mov ecx, 1q | 2000q
	int 0x80

J'utilise kdbg, donc comment voir si cela a fonctionné avec ce logiciel?

[hepta7]

En faite je viens de comprendre comment fonctionne l'ouverture d'un fichier.
Le paramètre a introduire se trouve dans "ecx" et s'il y en a plusieurs ils sont séparés par l’opération logique ou: |

Puis pour voir si les paramètre entrés se sont bien exécuter, il faut vérifier la valeur de "eax" après l'interruption:
Si les paramètre d'ouverture ont fonctionné alors eax sera positif (nombre quelconque).
Si les paramètre d'ouverture n'ont pas fonctionné alors eax sera négatif.

[A voir en vidéo sur Futura]

[hepta7]

Pourriez vous m'expliquer comment utiliser eflags comme registre " bt eflags, 7 "?

global main
section .rodata
  nomFichier	DB	'test', 0
  msg1		DB	'fichier ouvert avec succès\n'
  msg2		DB	'échec lors de l\’ouverture du fichier\n'
  lgrMsg1	DD	lgrMsg1 - msg1
  lgrMsg2	DD	lgrMsg2 - msg2
section .text
main:
  mov eax, 5
  mov ebx, nomFichier
  mov ecx, 2000q | 1q
  int 0x80
  
  or eax, eax
  
  bt eflags, 7
  jc _echec
  
  mov eax, 4
  mov ebx, 1
  mov ecx, msg1
  mov edx, [lgrMsg1]
  int 0x80
  jmp _fin

_echec:
  mov eax, 4
  mov ebx, 1
  mov ecx, msg2
  mov edx, [lgrMsg2]
  int 0x80

_fin:
  mov eax, 1
  mov ebx, 0
  int 0x80

[satinas]

Bonjour,
Tu as ouvert un fichier, et l'appel système retourne dans eax le handle du fichier ouvert
Si il y a eu un problème, le handle retourné est -1, c'est à dire une valeur négative.

Plutôt que de tester par si eax == -1, on va lire dans le mot d'état du processeur eflags le flag SF indiquant si le dernière instruction a produit un résultat négatif (la dernière opération étant "or eax,eax", SF contient le signe de eax).

Pour lire le flag SF, on utilise l'instruction bt qui copie le bit 7 du mot d'état, qui se trouve être SF, dans le bit carry C. Ensuite on teste le contenu de C.

[satinas]

Bon, je suis pas sur d'avoir compris la question. je pense pas que l'instruction "bt eflags,7" soit autorisée. Si tu veux tester le bit de signe de eflags, tu as l'instruction JS qui fonctionne suivant le même principe que JC.

[hepta7]

Merci tu me sauve la vie, JS ne se trouvais pas dans mes note de cours.

Voici le code après modification, mais j'ai un autre problème, je ne sais pas "— retourne le code d’erreur 1 ; " et "— retourne la valeur 0 pour indiquer un dénouement correct."

Tu serais pas comment t'y prendre par hasard?

global main
section .rodata
  nomFichier   DB   'test', 0
  msg1      DB   `fichier ouvert avec succès\n`
  lgrMsg1   DD   lgrMsg1 - msg1  
  msg2      DB   `échec lors de l’ouverture du fichier\n`
  lgrMsg2   DD   lgrMsg2 - msg2
section .text
main:
  mov eax, 5
  mov ebx, nomFichier
  mov ecx, 2000q | 1q
  int 0x80
  
  or eax, eax
  js _echec
  
  mov eax, 4
  mov ebx, 1
  mov ecx, msg1
  mov edx, [lgrMsg1]   ;affiche a l’ ́ecran msg1 & passe a la ligne
  int 0x80
  mov eax, 6      ;ferme le fichier
  int 0x80
  jmp _fin

_echec:
  mov eax, 4
  mov ebx, 1
  mov ecx, msg2
  mov edx, [lgrMsg2]
  int 0x80      ;affiche a l’ ́ecran msg2 & passe a la ligne

_fin:
  mov eax, 1
  mov ebx, 0
  int 0x80

[whoami]

Bonjour,

Merci tu me sauve la vie, JS ne se trouvais pas dans mes note de cours.

Quand on veut programmer en assembleur, une des démarches nécessaires est de récupérer la doc du processeur visé, elle est systématiquement disponible sur le site du fabricant.

[satinas]

On peut passer à côté d'une instruction dont on imagine pas l'existence, par contre la réponse à ta 2ème question est largement documentée sur Internet, alors ...

[hepta7]

J'utilise kdbg pour voir mon code à l'oeuvre, apparement il faut que j'utilise echo $? afin de savoir quel code va être retourner, mais quand je l'esseai apres la fermeture de kdbg j'obtient 130, apparemment je suis censé avoir 1 quand il s'agit d'erreur et 0 si tout est ok.

Si vous pouvez me donner des indication concernant kdbg et ou il faut que j'utilise echo $? je vous en saurais gré

[satinas]

détaille nous tous les appels système appelés par ton programme, notamment le dernier.

[hepta7]

J'ai détaillé les appels système en commentaire

global main
section .rodata
  nomFichier   DB   'test', 0
  msg1      DB   `fichier ouvert avec succès\n`
  lgrMsg1   DD   lgrMsg1 - msg1  
  msg2      DB   `échec lors de l’ouverture du fichier\n`
  lgrMsg2   DD   lgrMsg2 - msg2
section .text

main:
  mov eax, 5   ; ouvrir fichier
  mov ebx, nomFichier   ; chemin du fichier en question
  mov ecx, 2000q | 1q   ; indicateur WRONLY | APPEND
  int 0x800   ; intteruption et voir consulter valeur eax: si nbr négatif alor echec, si positif alors succé
  
  or eax, eax   ; operation afin d'obtenir information du eflags sur eax
  js _echec   ; si eax negatif alors SF=1 alors jump au label _echec, si eax positif alors SF=0
  
  mov eax, 4   ; ecriture
  mov ebx, 1   ; stdout pour afficher à l'écran
  mov ecx, msg1   ; chemin du texte à afficher
  mov edx, [lgrMsg1]   ; information sur le nbr de caractere du texte
  int 0x80   ; interruption et consulter valeur eax: si eax= -1 en cas d'erreur
  mov eax, 6      ; fermeture du fichier: 
  int 0x80   ; interruption et consulter valeur eax: si eax=0 alors c'est ok, si eax=1 alors il y a une erreur
  jmp _fin   ; jump au label _fin

_echec:
  mov eax, 4   ; ecriture
  mov ebx, 1   ; stdout pour afficher à l'écran
  mov ecx, msg2   ; chemin du texte à afficher
  mov edx, [lgrMsg2]   ; information sur le nbr de caractere du texte
  int 0x80   ; interruption et consulter valeur eax: si eax=0 alors c'est ok, si eax=1 alors il y a une erreur

_fin:
  mov eax, 1   ; exit
  mov ebx, 0   ; (?)
  int 0x80   ; interruption et utilisation de echo $? (si vous trouvez?)

[satinas]

Bravo, une programme avec des commentaires c'est déjà plus parlant.
T'a mis un point d'interrogation (?) juste au point sensible
Le code retour, il faut le mettre bien sur dans le dernier appel système qui clos le programme et rend la main au programme en amont. On place le code retour dans ebx, je l'invente pas, c'est marqué ici http://syscalls.kernelgrok.com/
Donc dans ton cas, il faut remplir ebx avec 0 ou 1 selon s'il y a erreur ou pas, puis faire le jmp vers le label _fin:
c'est tout

Après effectivement la commande "echo $?" affiche le code retour du dernier programme exécuté, et donc affichera la valeur que tu a mis dans ebx juste avant l'appel système sys_exit.
Par contre je ne connais pas kdbg et je ne peux t'aider dans ce domaine.

Tu as juste à assembler le programme, l'exécuter, et taper echo $?

[hepta7]

Merci infiniment Satinas, je vais essayé ce que tu viens de dire.

[hepta7]

Voila le code final, ca pourrait servire à d'autre personne dans le besoin.

Je tiens encore à te remercier Satinas pour l'aide dont tu m'a apportée.

global main
section .rodata
  nomFichier   DB   'test', 0
  msg1      DB   `fichier ouvert avec succès\n`
  lgrMsg1   DD   lgrMsg1 - msg1  
  msg2      DB   `échec lors de l’ouverture du fichier\n`
  lgrMsg2   DD   lgrMsg2 - msg2
section .text

main:
  mov eax, 5   ; ouvrir fichier
  mov ebx, nomFichier   ; chemin du fichier en question
  mov ecx, 2000q | 1q   ; indicateur WRONLY | APPEND
  int 0x80   ; intteruption et voir consulter valeur eax: si nbr négatif alor echec, si positif alors succé
  
  or eax, eax   ; operation afin d'obtenir information du eflags sur eax
  js _echec   ; si eax negatif alors SF=1 alors jump au label _echec, si eax positif alors SF=0
  
  mov eax, 4   ; ecriture
  mov ebx, 1   ; stdout pour afficher à l'écran
  mov ecx, msg1   ; chemin du texte à afficher
  mov edx, [lgrMsg1]   ; information sur le nbr de caractere du texte
  int 0x80   ; interruption et consulter valeur eax: si eax= -1 en cas d'erreur
  mov eax, 6      ; fermeture du fichier: 
  int 0x80   ; interruption et consulter valeur eax: si eax=0 alors c'est ok, si eax=1 alors il y a une erreur
  mov eax, 1   ; exit
  mov ebx, 0   ; retourne la valeur 0 pour indiquer un d ́enouement correct
  jmp _fin   ; jump au label _fin

_echec:
  mov eax, 4   ; ecriture
  mov ebx, 1   ; stdout pour afficher à l'écran
  mov ecx, msg2   ; chemin du texte à afficher
  mov edx, [lgrMsg2]   ; information sur le nbr de caractere du texte
  int 0x80   ; interruption et consulter valeur eax: si eax=0 alors c'est ok, si eax=1 alors il y a une erreur
  mov eax, 1   ; exit
  mov ebx, 1   ; retourne le code d’erreur 1
  
_fin:
  int 0x80   ; interruption utilisation de echo $? afin d'afficher la valeur retourner qui est celle de ebx

[satinas]

ok, mais le "mov eax,1" peut rester après le label _fin

[hepta7]

Je devais respecter les instruction de mes notes de cours en voici un extrait:

Sous GNU/Linux, un appel systeme se fait en quatre etapes :
1. mettre le numero du service desire dans eax ;
2. mettre les parametres, s'il y en a, dans ebx, ecx et edx, dans cet ordre-la ;
3. appeler le systeme par l'instruction int 0x80 ;
4. consulter la valeur de retour dans eax, s'il y en a une et si necessaire.

[satinas]

La seule exigence pour le processeur, est de mettre "int 0x80" en dernier, après il y a l'esthétique des sources. Et si tu tiens à respecter les règles, ce que je comprends, pas de 'u' dans langage en français, mais c'est juste pour avoir le dernier mot, hein

[hepta7]

Je ne savais pas, mais merci tout de même tu viens de m'apprendre encore quelque chose

[acx01b]

hepta7, pourquoi tu fais de l'assembleur ?
c'est un cours de compilation ? après les deux autres principales applications de l'assembleur c'est l'électronique numérique, et le reverse engineering.

et je suis le seul à être parfaitement contre faire de l'assembleur comme ça ? il faut faire de l'assembleur inline dans du C/C++ c'est beaucoup plus intéressant.

c'est intéressant aussi de faire du bytecode (Java ou encore mieux .NET).

et sinon tu as déjà vu la récursivité en assembleur ?

[hepta7]

Il faut dire ça à mon prof
Et je tien à préciser que je suis débutant

On fait aussi du java et Cobol (ce cours, je le laisse pour l'année prochaine faute de temps) et bien évidement la base de tout: de l'algorithme.

Je ne suis pas arriver à la "récursivité en assembleur", ca touche à ma curiosité tout ça

[acx01b]

pour moi ça avait été une grande révélation de savoir écrire par exemple la fonction factorielle en récursif en assembleur. je te laisse te creuser les méninges pour traduire ça en assembleur :

int factoriel(int N) {
   if (N <= 1) return 1;
   return N * factoriel(N-1);
}

c'est de la récursivité non terminale

[acx01b]

Il faut dire ça à mon prof

tu n'as jamais fait de C/C++ ?

si tu en as déjà fait tu devrais lui parler d'assembleur inline (c'est à dire écrire quelques fonctions ou quelques lignes en assembleur au milieu du code C ou C++, plutôt avec le compilateur visual studio pour l'assembleur intel x86. ce qui est cool c'est aussi de regarder dans le débuggeur le code assmbleur, de "stepper" dans l'assembleur quand on débug)

[hepta7]

Donc par récursivité cela veut dire sans binaire
Etant donné que je ne connait pas le c/c++, je prefere m'abstenir de donner des lecon à mon prof

[acx01b]

???
récursivité ça veut dire une fonction qui se rappelle elle même.

je ne vois pas ce que tu veux dire par "sans binaire"

et désolé mais faire de l'assembleur avant du C ... ha c'est parce que tu fais du Cobol... au secours. ça sert à rien le cobol il faut faire du C pas du cobol!!!!

tu fais quoi comme filière, comme études ?

[hepta7]

Je suis en informatique de gestion et je trouve aussi que Cobol ne sert à rien, mise à part les banque qui apparemment utilise ce language.

[acx01b]

on fait de l'assembleur du java et du cobol en informatique de gestion ? sérieux ? étrange. pourquoi tu ne vas pas en fac d'info normale ?

[hepta7]

Je suis dans une école supérieur. Que ça soit dans une école ou a l'université les cours ne change pas vraiment en fin de parcourt on a la même formation, je suppose. De plus l’école dans laquelle je suis est apparemment réputée.
PS: J'habite en Belgique.

[acx01b]

ben si en fac d'informatique ou plutôt math/informatique tu as pas mal d'étudiants qui ont eu un bac scientifique avec plutôt des bonnes notes, ce n'est pas le cas en informatique de gestion, je ne sais pas si tu as des maths mais si oui le niveau est moins bon, et puis tu n'auras pas de cours de programmation 3D, intelligence artificielle, traitement du signal, etc. Enfin je ne pense pas que tu pourras aller en master 2 recherche ou en doctorat.