LMI 1ère TD4 printw

pour ceux que ça interesse, voici mon code du td4. comme le code de printd mais avec un word

Code:


; Même chose que printd, mais avec un word.
; LAMBERT Nicolas g1222
;===========================
   section .data
;==========================
nb    DB 'sxxxxx '
LF    DB 10
carhex    DB '0123456789ABCDEF'
;===========================
      section .bss
;===========================
tmp   RESW   1
;===========================
global printw
;===========================
   section .code
;===========================
printw:
   push ebp         ;spécifique à tous les appels de procédures
   mov ebp,esp
   pusha               ; instruction incorrecte
   MOV   AX,[ebp+8]
   MOV   [tmp],AX
;===========================
; Impression hexad�imale
;===========================
   mov eax,[tmp]         ; récupère l'élément qui viens de la pile,
               ;mais de 2*push en arrière.
               ;car le dernier push c'est le précédent ebp
               ;donc il faut prendre l'avant dernier pour pointer
               ;vers le nombre à afficher
   mov edi,16            ; base 16 (car en hexa)
   mov esi,nb+5         ; met dans ESI position la position dans la variable nb
   mov ecx,4            ; 8 caractères à afficher (sera utiliser pour la premiere loop)

digith:   mov edx,0
   div edi               ; on divise le nombre par 16
   add edx,carhex         ; on ajoute la référence vers le premier caractère de la
               ;variable carhex (qui contient les caractères exadécimaux) au reste.
   mov bl,[edx]         ; copie la caractère correcpondant dans bl
   mov [esi],bl         ; copie le contenu de bl dans l'adresse que pointe ESI
   dec esi               ; décrémence ESI afin de pointer vers l'emplacement suivant
               ;que doit contenir le prochain caractère.
   loop digith            ; TQ ECX n'est pas nulle, on boucle

   mov eax,4            ;  appel système write
   mov ebx,1            ;
   mov ecx,nb+2         ;
   mov edx,5            ; nbr de caractères à afficher
   int   0x80

;===========================
; Impression décimale positive
;===========================
   mov ax,[tmp]         ; on récupère encore une foisl'avant dernier élément
               ;car c'est lui le nombre à afficher
   mov ebx,10            ; mais cette fois ci, en base 10
   mov esi,nb+5         ; met dans ESI la position dans la variable nb
   mov ecx,1            ; on met 1 car début du cpt de caractères
digit:   mov edx,0
   div ebx               ; on divise le nombre par 10
   add dl,30h            ; on ajoute 30 au reste en hexa pour avoir son équivalent
               ;en caractère dans la table ansi
   mov [esi],dl         ; ajoute le caractère à l'endroit pointé par ESI
               ;(dans la variable nb ET au bon endroit)
   dec esi               ; on pointe l'élément suivant dans la variable nb;
   inc ecx               ; le nbr de caractères à afficher
   cmp eax,0            ; si le dernier quotient (du nombre actuel, dans EAX donc)
   jne digit      ;est égal à 0, on continue, sinon, on boucle

   mov byte [esi],'+'      ; on ajoute la caractère + à l'endroit pointé par ESI
   inc ecx               ; le nbr de caractères à afficher

   mov edx,ecx            ; on met dans edx le  nbr de caractères à afficher
   mov ecx,nb            ; on met ddans ecx l'adresse qui contient la chaine de caractère
   add ecx,7   ;;;;; POURQUOI 12 ??????????????
   sub ecx,edx            ; ???
   mov eax,4            ; appel système write
   mov ebx,1
        int 0x80
;===========================
; Impression décimale négative
;===========================
   mov ax,[tmp]         ; si le nbr à afficher = 0, on n'affiche pas le nbr en format neg
   cmp ax,0            ; ===
   jge fin               ; ===
   neg ax               ; on fait le complément à 2 du nombre
   mov ebx,10            ; on travail en base 10
   mov esi,nb+5         ; on met dans ESI la position dans la variable nb (10 car 10e caractère)
   mov ecx,1            ; on met 1 car c'est le début du compteur de caractères
digitn:   
   mov edx,0            ; on et met 0 car DIV prends (edx et eax) comme dividente
   div ebx               ; on divise ça par EBX
   add dl,30h            ; on ajoute 30 en hexa au reste obtenu (30h car cf table ansi)
   mov [esi],dl         ; déplace le caractère à l'endroit ou pointe ESI
   dec esi               ; on pointe le caractère suivant dans la variable nb;
   inc ecx               ; cpt de caractères
   cmp ax,0            ; si le quotient de la derniere division n'est
   jne digitn      ; pas nulle, on continue

   mov byte [esi],'-'      ; on place le caractère '-' à l'endroit pointé par ESI
   inc ecx               ; incrémente la cpt de caractères

   mov edx,ecx            ; appel système write
   mov ecx,nb
   add ecx,7
   sub ecx,edx
   mov eax,4
   mov ebx,1
        int 0x80
;===========================
; Impression saut de ligne
;===========================
fin:   
   mov eax,4            ; appel système write
   mov ebx,1            ; écriture a l'écran
   mov ecx,LF            ; le caractère
   mov edx,1            ; le nombre de caractère à écrire
   int 0x80

   popa               ; restauration des registres
   pop ebp               ; restauration du pointeur de la pile
   ret 4               ; nettoye les 4 derniers bytes de la pile


ca s'appelle notepad++

Sans vouloir faire le rabat-joie (ou whatever), il ne faut pas utiliser de variables globales

Il faut faire un “trou” dans la pile et l'utiliser pour y stocker des “variables locales” (je peux fournir mes notes une fois que je les aurai informatisées, s'il faut )

C'est quoi le but du projet (j'ai pas envie d'analyser le code)

Afficher un nombre de 16 bits en hexa / décimal (positif et négatif)

Aaahhh facil !

sans variable local ... arf, et comment tu fais ton 'trou' dans la pile?

(le code affiche un nombre (en l'occurence codé sur 16 bits) en hexa, en décimal positif et éventuellement en décimal négatif

Pour le trou, faut ajouter un nombre de bytes à ESP (si je me souviens bien), pour que les éléments viennent se mettre après (faut que je reprenne mes notes, mais c'est grosso-modo ça)

pfff, trop facile !

c'était pas un soucis enfaite, falais juste remetre le [ebp+8] du printd dans un registre de 16 bits (AX) (au lieu d'utiliser une variable) ^^

Bug a écrit:c'était pas un soucis enfaite, falais juste remetre le [ebp+8] du printd dans un registre de 16 bits (AX) (au lieu d'utiliser une variable) ^^

mais ouais, c'est ce que je lui disais depuis une heure !
il m'écoute jamais !

TG Kara, c'est la seule partie sérieuse du forum, alors laisse les travailler.

Dis sardine, qu'est qu'il faut que je change à mon code pour qu'il ne me foute pas une segmentation fault? :s
(fin je dis sardine, parce que il a déjà toutes les réponses lui, je sais pas comment xD)

Code:

; M√me chose que printd, mais avec un word.
; LAMBERT Nicolas g1222
;===========================
;   section .data
;==========================
;nb       DB 'sxxxxx '
;LF       DB 10
;carhex    DB '0123456789ABCDEF'
;===========================
global printw
;===========================
   section .code
;===========================
printw:   push ebp         ;sp√cifique √† tous les appels de proc√dures
   mov ebp,esp
   SUB   ESP,96         ;on rÈserve 7+1+16 byte donc x4 pour la taille en double
   pusha               ;
;===========================
; variables locales
;===========================

   MOV   dword [EBP-4],'s'
   MOV   dword [EBP-8],'x'
   MOV   dword [EBP-12],'x'
   MOV   dword [EBP-16],'x'
   MOV   dword [EBP-20],'x'
   MOV   dword [EBP-24],'x'
   MOV   dword [EBP-28],' '
   MOV   dword [EBP-32],10
   MOV   dword [EBP-36],'0'
   MOV   dword [EBP-40],'1'
   MOV   dword [EBP-44],'2'
   MOV   dword [EBP-48],'3'
   MOV   dword [EBP-52],'4'
   MOV   dword [EBP-56],'5'
   MOV   dword [EBP-60],'6'
   MOV   dword [EBP-64],'7'
   MOV   dword [EBP-68],'8'
   MOV   dword [EBP-72],'9'
   MOV   dword [EBP-76],'A'
   MOV   dword [EBP-80],'B'
   MOV   dword [EBP-84],'C'
   MOV   dword [EBP-88],'D'
   MOV   dword [EBP-92],'E'
   MOV   dword [EBP-96],'F'

;===========================
; Impression hexadÈcimale
;===========================
   mov ax,[ebp+8]         ; r√cup√re l'√l√ment qui viens de la pile,
               ;mais de 2*push en arri√re.
               ;car le dernier push c'est le pr√c√dent ebp
               ;donc il faut prendre l'avant dernier pour pointer
               ;vers le nombre √† afficher
   mov edi,16            ; base 16 (car en hexa)
   mov esi,[EBP-24]         ; met dans ESI position la position dans la variable nb
   mov ecx,4            ; 4 caract√res √† afficher (sera utiliser pour la premiere loop)

digith:   mov edx,0
   div edi               ; on divise le nombre par 16
   add edx,[EBP-40]         ; on ajoute la r√f√rence vers le premier caract√re de la
               ;variable carhex (qui contient les caract√res exad√cimaux) au reste.
   mov bl,[edx]         ; copie la caract√re correcpondant dans bl
   mov [esi],bl         ; copie le contenu de bl dans l'adresse que pointe ESI
   dec esi               ; d√cr√mence ESI afin de pointer vers l'emplacement suivant
               ;que doit contenir le prochain caract√re.
   loop digith            ; TQ ECX n'est pas nulle, on boucle

   mov eax,4            ;  appel syst√me write
   mov ebx,1            ;
   mov ecx,[EBP-8]         ;
   mov edx,5            ; nbr de caract√res √† afficher
   int   0x80

;===========================
; Impression d√cimale positive
;===========================
   mov ax,[ebp+8]         ; on r√cup√re encore une foisl'avant dernier √l√ment
               ;car c'est lui le nombre √† afficher
   mov ebx,10            ; mais cette fois ci, en base 10
   mov esi,[EBP-24]         ; met dans ESI la position dans la variable nb
   mov ecx,1            ; on met 1 car d√but du cpt de caract√res
digit:   mov edx,0
   div ebx               ; on divise le nombre par 10
   add dl,30h            ; on ajoute 30 au reste en hexa pour avoir son √quivalent
               ;en caract√re dans la table ansi
   mov [esi],dl         ; ajoute le caract√re √† l'endroit point√ par ESI
               ;(dans la variable nb ET au bon endroit)
   dec esi               ; on pointe l'√l√ment suivant dans la variable nb;
   inc ecx               ; le nbr de caract√res √† afficher
   cmp eax,0            ; si le dernier quotient (du nombre actuel, dans EAX donc)
   jne digit      ;est √gal √† 0, on continue, sinon, on boucle

   mov byte [esi],'+'      ; on ajoute la caract√re + √† l'endroit point√ par ESI
   inc ecx               ; le nbr de caract√res √† afficher

   mov edx,ecx            ; on met dans edx le  nbr de caract√res √† afficher
   mov ecx,[EBP]            ; on met ddans ecx l'adresse qui contient la chaine de caract√re
   add ecx,7            ; ??? 7 chiffres significatifs?
   sub ecx,edx            ; ???
   mov eax,4            ; appel syst√me write
   mov ebx,1
        int 0x80
;===========================
; Impression d√cimale n√gative
;===========================
   mov ax,[ebp+8]         ; si le nbr √† afficher = 0, on n'affiche pas le nbr en format neg
   cmp ax,0            ; ===
   jge fin               ; ===
   neg ax               ; on fait le compl√ment √† 2 du nombre
   mov ebx,10            ; on travail en base 10
   MOV ESI,EBP         ;2 lignes pour mettre l'adresse de ebp-7
   SUB EBP,20         ;sinon erreur
   ;mov esi,EBP-5         ; on met dans ESI la position dans la variable nb (10 car 10e caract√re)
   mov ecx,1            ; on met 1 car c'est le d√but du compteur de caract√res
digitn:   
   mov edx,0            ; on et met 0 car DIV prends (edx et eax) comme dividente
   div ebx               ; on divise √ßa par EBX
   add dl,30h            ; on ajoute 30 en hexa au reste obtenu (30h car cf table ansi)
   mov [esi],dl         ; d√place le caract√re √† l'endroit ou pointe ESI
   dec esi               ; on pointe le caract√re suivant dans la variable nb;
   inc ecx               ; cpt de caract√res
   cmp ax,0            ; si le quotient de la derniere division n'est
   jne digitn      ; pas nulle, on continue

   mov byte [esi],'-'      ; on place le caract√re '-' √† l'endroit point√ par ESI
   inc ecx               ; incr√mente la cpt de chiffres significatif

   mov edx,ecx            ; edx= nbr de chiffres significatifs
   MOV ecx,EBP
   SUB ecx,7            ; l'adresse
   add ecx,28            ; max 7 chiffres significatifs
   sub ecx,edx
   mov eax,4            ; appel systeme write
   mov ebx,1
        int 0x80
;===========================
; Impression saut de ligne
;===========================
fin:   
   mov eax,4            ; appel syst√me write
   mov ebx,4            ; √criture a l'√cran
   MOV ecx,EBP
   SUB ecx,7
   mov edx,1            ; le nombre de caract√re √† √crire
   int 0x80

   popa               ; restauration des registres
   pop ebp               ; restauration du pointeur de la pile
   ret 4               ; nettoye les 4 derniers bytes de la pile





Il faut “reboucher” (via un add esp) le trou créé par le sub esp, vers la fin du code

c'est pas logique vu qu'après tu restore ESP.
j'ai qd même tester mais j'ai la même erreur.
autre idée? ^^

Il segfault en l'appelant directement as it ou quand tu le call depuis un autre fichier ?

Car dans le 1er cas c'est normal, il n'y a pas d'appel au syscall exit :P

non non je l'appel bien depuis un autre fichier. enfaite ça merde depuis que j'ai fait une version qui utilise des variables locales :/ (mais j'ai tjrs l'autre version, qui se trouve en première page d'ailleur)

Faudrait déjà remplacer tous les E*X par des *X, vu que c'est en 16 bits, et ça foire au niveau du MOV BL,[EDX]
Première vue, edx est trop grand pour rentrer dans BL

le problème n'est tjrs pas résolu

tu dois remplacer le moV 4Segement par
$ gcc truc.S -c -o truc.o
$ ld truc.o -o truc
$ ./truc

puis tu fais un petit

.global _start
BONJ: .ascii "Bonjour\n" ; Definition en mémoire de la chaîne à afficher. \n correspond au saut de ligne
_start: mov $4 , %eax ; Mettre 4 dans le registre eax (appel système '''Write'')
mov $1 , %ebx ; Mettre 1 dans le registre ebx (descripteur de fichier ''STDOUT'')
mov $BONJ , %ecx ; Mettre l'adresse mémoire de notre chaîne de caractère dans le registre ecx
mov $8 , %edx ; Mettre la taille de la chaîne dans edx
int $0x80 ; Interruption 0x80, éxécutant un appel système sous Linux)

mov $1 , %eax ; Mettre 1 dans eax (appel système ''Exit'')
mov $0 , %ebx ; Mettre 0 dans ebx (valeur de retour du programme)
int $0x80

je vois pas le rapport avec les variables locales lol

XD si j'ai pigé le code qui t'a filé sa veux dire bonjour mais ya plusieurs trucs qui foire
1 - on a pas vu ces notations là avec le % etc...
2 - les commentaires sont trop important
3 - tu peux me reexpliquer ligne par ligne pour voir si tu l'a pas chipé de asmFR

personne n'as utilisé de variable local dans son code?

perso j ai utiliser une variable local dans mon test de code, ou j ai mis le carhex etc...

je les push, et la j suis entrin de essayé de les recuperrer avec des [ebp-***] ( mais je patauge un peu faudrai que je fasse un dessin )
mais la j'ai aussi un segmentation fault dans la partie hexa, au meme endroit que toi.

et si je remplace EDX par DX a cette endroit ca compile meme plus.
mais sinon, dans la procédure printw, aucune local

merci nvs

Code:

varLoc:
  push  ebp
  mov  ebp,esp

  sub  esp,10        ; réservation de 10 octets sur la pile
 
  push  eax
  push  ecx

  mov      dword [ebp-4],'0123'    ; 4 en une fois
          ; tests
  mov      al,[ebp-1]  ; '3'
  mov      al,[ebp-2]  ; '2'
  mov      al,[ebp-3]  ; '1'
  mov      al,[ebp-4]  ; '0'


        ; 10 fois une
    mov      ecx,ebp
  mov      al,'0'
 .remplissage:
    dec      ecx
    mov      byte [ecx],al
  inc      al
  cmp      al,'9'
  jle      .remplissage
          ; tests
  mov      al,[ebp-1]  ; '0'
  mov      al,[ebp-3]  ; '2'
  mov      al,[ebp-7]  ; '6'
  mov      al,[ebp-10]  ; '9'

  pop      ecx
  pop      eax

  add      esp,10      ; libération de 10 octets sur la pile

  pop      ebp
  ret