PureBasic

Forums PureBasic
Nous sommes le Jeu 22/Aoû/2019 2:06

Heures au format UTC + 1 heure




Poster un nouveau sujet Répondre au sujet  [ 7 messages ] 
Auteur Message
 Sujet du message: Tutoriel 6 - La pile et instructions asm pouvant la modifier
MessagePosté: Dim 05/Déc/2004 14:44 
Hors ligne
Avatar de l’utilisateur

Inscription: Jeu 22/Jan/2004 14:31
Messages: 3518
Localisation: Sourans
Code:
Tutorial 6 - Fonctionnement de la pile et les instructions asm pouvant la modifier.
-----------------------------------------------------------------------------------

Par Denis


Voici l'URL du site de FASM. Vous y trouverez la doc sur ce compilateur

http://flatassembler.net/


Chaque programme qui tourne utilise pour ses besoins une zone mémoire appelée la pile (stack en anglais).
La pile est pratique pour stocker des informations temporaires.
Lorsqu'un programme appelle un sous-programme ou comme en PB lorsque l'on appelle une procédure, les paramètres sont passés sur la pile.
La pile est aussi utilisée pour stocker des données de manière temporaire (résultat de calcul, sauvegarde temporaire d'une donnée etc.).
Les variables dites locales se situent sur la pile.


1) La PILE :
------------

La pile c'est comme une pile d'assiettes, on ne peut empiler qu'une assiette à la fois;
La pile a toujours la même taille, mais lorsque l'on y stocke des infos, on fait évoluer le registre ESP qui stocke l'adresse courante de la pile.
Le dernier élément empilé ("ajouté sur la pile") sera le premier élément dépilé ("retiré de la pile").
C'est ce que l'on appelle une pile LIFO (last in first out) par opposition aux FIFO (first in first out).
La pile a une taille maxi alloué dans notre cas par le système.
Chaque mouvement de pile est suivi par le pointeur de pile ESP qui est un pointeur 32 bits.
Plusieurs instructions peuvent modifier ce pointeur.

*********************************************************************************************
* La compréhension du fonctionnement de la pile est primordiale pour faire de l'assembleur. *
* Les erreurs de pile sont innombrables lorsque l'on débute la programmation en assembleur. *
* Perso, j'en fait encore de temps en temps.                                                *
*********************************************************************************************

La gestion de la pile se fait " à l'envers " c'est-à-dire que si on ajoute un élément, le pointeur est décrémenté.

En rappel :
  -Si on ajoute un élément sur la pile (on empile), le pointeur ESP sera décrémenté.
  -Si on supprime un élément sur la pile (on dépile), le pointeur ESP sera incrémenté.
 
  On ne peut empiler ou dépiler que des valeurs de 16 ou 32 bits soit 2 ou 4 octets.
  La valeur mise sur la pile s'appelle l'opérande.
 
  Pour revenir à ESP, si on empile une valeur :
    - ESP sera décrémenté de 2 dans le cas d'une opérande 16 bits
    - ESP sera décrémenté de 4 pour une opérande 32 bits.
 
  Si on dépile une valeur :
    - ESP sera incrémenté de 2 dans le cas d'une opérande 16 bits
    - ESP sera incrémenté de 4 pour une opérande 32 bits.
   
Un petit croquis permet de mieux se représenter la pile.
Pour l'exemple, on va dire que la pile commence à l'adresse $1000 et que l'on a mis une valeur, $F450.
Sur le dessin, ça fonctionne comme une pile d'assiettes.
Si on ajoute un élément, il sera mis au-dessus (sommet de la pile) et ESP sera décrémenté de 4.

Esp = $1000 et la valeur située à l'adresse $1000 vaut $F450
L'adresse pointée par ESP s'appelle aussi le sommet de la pile.


  Adresse de la pile          valeur
  contenu dans ESP         sur la pile (4 octets par Case dans cet exemple)
       


       $FFC              |             |  ESP - 4
                         |_____________|
                         |             |
       $1000             |    F450     |  <-- ESP pointe cette adresse
                         |_____________|       (mot de 32 bits stocké)
                         |             |      ESP = $ 1000
       $1004             |    xxxx     |  ESP + 4
                         |_____________|
                         |             |
       $1008             |    xxxx     |  ESP + 8
                         |_____________|
                         |             |
       $100C             |    xxxx     |  ESP + 12
                         |_____________|
                         |             |
       $1010             |    xxxx     |
                         |_____________|
                         |             |
       $1014             |    xxxx     |
                         |_____________|
                         |             |
       $1018             |    xxxx     |
                         |_____________|

                                       


2) Les instructions qui modifient la PILE et son pointeur :
-----------------------------------------------------------
Nous ne nous occuperons que du registre ESP et pas du registre SS (segment de pile).

  A) Instruction PUSH
  -------------------
    (page 415 du manuel d'Intel: jeu d'instructions volume 2B (N-Z))


//\\//\\//\\//\\//\\//\\//\\//\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//
//                                                                             \\
\\  L'instruction PUSH décrémente d'abord ESP.                                 //
//  Puis elle stocke sur la pile la valeur définie par l'opérande à l'adresse  \\
\\  contenue dans ESP (16 ou 32 bits).                                         //
//  Cela veut dire que ESP pointe toujours le dernier élément de la pile.      \\
\\                                                                             //
//\\//\\//\\//\\//\\//\\//\\//\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//


  L'opérande de cette instruction peut être :
    - Un registre (16 ou 32 bits)
    - Une valeur immédiate (un nombre sur 16 ou 32 bits)
    - Une mémoire (16 ou 32 bits)
    - Un registre de segment (16 bits)
   
   
Voici quelques exemples avec empilements 16 ou 32 bits :
-------------------------------------------------------
  FASM est le compilateur qui va transformer le code asm en code exécutable.
  Lorsque l'on manipule des valeurs, il faut lui indiquer le type, word ou dword.
  Word correspond à un mot de 16 bits et dword à un mot de 32 bits (j'y reviendrais dans le prochain tutoriel).
 
On Peut empiler :
----------------

    - Un registre 16 bits  (ESP est décrémenté de 2)
      PUSH  SI  ; il est inutile de préciser la taille car SI est un registre 16 bits
      Ici, c'est le contenu du registre SI qui est empilé.

    - Un registre 32 bits (ESP est décrémenté de 4)
      PUSH  EAX  ; il est inutile de préciser la taille car EAX est un registre 32 bits
      Ici, c'est le contenu du registre EAX qui est empilé.
 
    - Une mémoire 16 bits pointée par un registre 32 bits (ESP est décrémenté de 2)
      PUSH word [EDX]
      Les crochets indiquent que c'est la valeur située à l'adresse contenue dans EDX et pas le contenu de EDX.
      Par exemple, EDX vaut 87999 et à cette adresse il y a la valeur 17 (16 bits)
      c'est 17 qui sera mis sur la pile
   
    - Une mémoire 32 bits pointée par un registre 32 bits (ESP est décrémenté de 4)
      PUSH dword [EDI]
      Par exemple, EDI vaut 67742 et à cette adresse il y a la valeur 859789 (32 bits)
      c'est 859789 qui sera mis sur la pile

    - Une valeur immédiate sur 16 bits (ESP est décrémenté de 2)
      PUSH   word 25    ; empile la valeur décimale 25 sur la pile
     
    - Une valeur immédiate sur 32 bits
      PUSH   dword 1203    ; empile la valeur décimale 1203 sur la pile

    - Une valeur (16 bits) située en mémoire à l'adresse 1200
      PUSH   word [1200]

    - Une valeur (32 bits) située en mémoire à l'adresse 1200
      PUSH   dword [1200]

      Dans les 2 derniers cas, les crochets indiquent que c'est la valeur située à l'adresse 1200 et pas la valeur 1200 elle-même à empiler.

    - Un registre de segment (16 bits)
      PUSH   CS
     
   - - - - -   

  Reprenons le croquis de la pile ci-dessus.
  ESP vaut $1000
  A l'adresse pointée par ESP, il y a la valeur $F450
 
  Premier exemple, on empile le registre 16 bit SI et on considère que SI vaut $17
 
  L'instruction est la suivante
 
  PUSH  SI
 
  Voici l'état de pile après ce PUSH

     
  Adresse de la pile          valeur
  contenu dans ESP         sur la pile




                         |             | 
                         |_____________|
                         |             |
       $FFE              |      17     |  <-- ESP pointe cette adresse
                         |_____________|      ESP = $FFE
                         |             |
       $1000             |    F450     |  ESP + 4
                         |_____________| 
                         |             |
       $1004             |    xxxx     |  ESP + 8
                         |_____________|
                         |             |
       $1008             |    xxxx     |  ESP + 12
                         |_____________|
                         |             |
       $100C             |    xxxx     |  ESP + 16
                         |_____________|
                         |             |
       $1010             |    xxxx     |
                         |_____________|
                         |             |
       $1014             |    xxxx     |
                         |_____________|
                         |             |
       $1018             |    xxxx     |
                         |_____________|

     
     
      après ce PUSH, ESP vaut $1000 - 2 = $FFE
      Attention, le tableau représentait des mots de 32 bits.
      Mais $17 n'occupe pas les 32 bits situés à l'adresse $FFE mais bien 16 bits.
     
   - - - - -   
     
  Maintenant, reprenons le croquis de la pile d'origine sans avoir empilé le $17
  ESP vaut $1000
  A l'adresse pointée par ESP, il y a la valeur $F450
 
  On empile le nombre 32 bits $5630
 
  L'instruction est la suivante
 
  PUSH  dword $5630
 
  mais on pourrait aussi écrire
 
  PUSH  $5630
 
  car FASM considère en mode 32 bits que la valeur immédiate est un dword.
  Mais je déconseille car ça peut être source d'erreur.
   
 
  Voici l'état de pile après ce PUSH

     
  Adresse de la pile          valeur
  contenu dans ESP         sur la pile (4 octets par Case dans cet exemple)




                         |             |  ESP - 4
                         |_____________|
                         |             |
       $FFC              |    5630     |  <-- ESP pointe cette adresse
                         |_____________|      ESP = $FFC
                         |             |
       $1000             |    F450     |  ESP + 4
                         |_____________| 
                         |             |
       $1004             |    xxxx     |  ESP + 8
                         |_____________|
                         |             |
       $1008             |    xxxx     |  ESP + 12
                         |_____________|
                         |             |
       $100C             |    xxxx     |  ESP + 16
                         |_____________|
                         |             |
       $1010             |    xxxx     |
                         |_____________|
                         |             |
       $1014             |    xxxx     |
                         |_____________|
                         |             |
       $1018             |    xxxx     |
                         |_____________|

     
     
      après ce PUSH, ESP vaut $1000 - 4 = $FFC
      Attention, le tableau représente bien des mots de 32 bits.

   A noter que PUSH ne modifie aucun drapeau (registre EFLAGS).
   ------------------------------------------------------------     
     
     
  B) Instruction POP
  ------------------
    (page 87 du manuel d'Intel: jeu d'instructions volume 2B (N-Z))


//\\//\\//\\//\\//\\//\\//\\//\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\//\\
//                                                                                  //
\\  L'instruction POP charge la valeur située au sommet de la pile.                 \\
\\  et stocke cette valeur à l'emplacement spécifié par l'opérande de l'instruction //
\\  Puis elle incrémente ESP.                                                       \\
\\  Cela veut dire que ESP pointera après le POP, l'élément précédant sur la pile.  //
//                                                                                  \\
//\\//\\//\\//\\//\\//\\//\\//\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\


  POP ne supprime absolument pas la valeur sur la pile.
  Il fait une copie de la valeur et la stocke dans le registre ou la mémoire.
  Seul ESP est modifié (incrémenté)
 
 
  L'opérande de cette instruction peut être :
    - Un registre (16 ou 32 bits)
    - Une mémoire (16 ou 32 bits)
    - Un registre de segment (16 bits)
   
   
Voici quelques exemples avec dépilements 16 ou 32 bits :
-------------------------------------------------------

    - Un registre 16 bits  (ESP est incrémenté de 2)
      POP  SI  ; il est inutile de préciser la taille car SI est un registre 16 bits
      Ici, SI vaudra la valeur (16 bits) située au sommet de la pile.

    - Un registre 32 bits  (ESP est incrémenté de 4)
      POP  EDX  ; il est inutile de préciser la taille car EDX est un registre 32 bits
      Ici, EDX vaudra la valeur (32 bits) située au sommet de la pile.

    - Une mémoire 16 bits pointée par un registre 32 bits (ESP est incrémenté de 2)
      POP  word [EDX]
      Les crochets indiquent que c'est la valeur située à l'adresse contenue dans EDX et pas le contenu de EDX.
      La valeur 16 bits située au sommet de la pile va être copié à l'adresse contenu dans EDX.
      Par exemple, EDX vaut 87999 et au sommet de la pile il y a la valeur $56 (16 bits).
      Cette instruction copiera la valeur $56 à l'adresse 87999.
      La valeur précédente située à cette adresse est perdue (écrasée).
   
    - Une mémoire 32 bits pointée par un registre 32 bits (ESP est incrémenté de 4)
      POP  dword [EDI]
      La valeur 32 bits située au sommet de la pile va être copié à l'adresse contenue dans EDI.
      Par exemple, EDI vaut 67742 et au sommet de la pile il y a la valeur 859789 (32 bits).
      Cette instruction copiera la valeur 859789  à l'adresse 67742.
      La valeur précédente située à cette adresse est perdue (écrasée).

    - Une mémoire 16 bits pointée par une valeur immédiate (ESP est incrémenté de 2)
      POP  word [1546879]
      La valeur 16 bits située au sommet de la pile va être copiée à l'adresse 1546879.
      La valeur précédente située à cette adresse est perdue (écrasée).
   
    - Une mémoire 32 bits pointée par une valeur immédiate (ESP est incrémenté de 4)
      POP  dword [123365]
      La valeur 32 bits située au sommet de la pile va être copié à l'adresse 123365.
      La valeur précédante située à cette adresse est perdue (écrasée).

    - Un registre de segment 16 bits  (ESP est incrémenté de 2)
      POP  DS  ; il est inutile de préciser la taille car DS est un registre 16 bits
      Ici, DS vaudra la valeur (16 bits) située au sommet de la pile.

    A noter que pour l'instruction POP, il n'est pas possible d'utiliser le registre de segment CS.

      POP  CS  est une instruction invalide.
     
  Nous verrons dans un prochain tutoriel qu'il y a encore des variantes pour ces instructions (POP et PUSH).


  Reprenons notre dernier état de la pile
  ---------------------------------------
 
    Voici l'état de pile avant une instruction POP
    ESP vaut $FFC et la valeur du sommet de la pile est $5630
     
  Adresse de la pile          valeur
  contenu dans ESP         sur la pile (4 octets par Case dans cet exemple)




                         |             |  ESP - 4
                         |_____________|
                         |             |
       $FFC              |    5630     |  <-- ESP pointe cette adresse
                         |_____________|      ESP = $FFC
                         |             |
       $1000             |    F450     |  ESP + 4
                         |_____________| 
                         |             |
       $1004             |    xxxx     |  ESP + 8
                         |_____________|
                         |             |
       $1008             |    xxxx     |  ESP + 12
                         |_____________|
                         |             |
       $100C             |    xxxx     |  ESP + 16
                         |_____________|
                         |             |
       $1010             |    xxxx     |
                         |_____________|
                         |             |
       $1014             |    xxxx     |
                         |_____________|
                         |             |
       $1018             |    xxxx     |
                         |_____________|



   On dépile le registre EAX
   
   POP   EAX
   
   
   Voici l'état de la pile après ce POP



                         |             |  ESP - 8
                         |_____________|
                         |             |
       $FFC              |    5630     |  ESP - 4
                         |_____________|     
                         |             |
       $1000             |    F450     |  <-- ESP pointe cette adresse
                         |_____________|      ESP = $1000
                         |             |
       $1004             |    xxxx     |  ESP + 4
                         |_____________|
                         |             |
       $1008             |    xxxx     |  ESP + 8
                         |_____________|
                         |             |
       $100C             |    xxxx     |  ESP + 12
                         |_____________|
                         |             |
       $1010             |    xxxx     |
                         |_____________|
                         |             |
       $1014             |    xxxx     |
                         |_____________|
                         |             |
       $1018             |    xxxx     |
                         |_____________|



      EAX vaut $5630 qui était avant le POP le sommet de la pile
      ESP avant le POP valait $FFC
      ESP vaut après le POP  $1000  ($FFC +4)
     
      A noter que l'instruction POP ne modifie pas les valeurs de la pile.
      Seul ESP est modifié ainsi que l'opérande de destination.

   A noter que POP ne modifie aucun drapeau (registre EFLAGS).     
   ----------------------------------------------------------     

       
  C) Instructions PUSHFD et POPFD
  -------------------------------
    (PUSHFD page 150 du manuel d'Intel: jeu d'instructions volume 2B (N-Z))
    (POPFD page 94 du manuel d'Intel: jeu d'instructions volume 2B (N-Z))
     
    PUSHFD décrémente ESP de 4.
    Puis empile le registre de drapeaux EFLAGS
    Les bits b16 et b17 ne sont pas copiés mais mis à 0 dans la valeur empilée.
     
    POPFD dépile  la valeur 32 bits du sommet de la pile vers le registre de drapeaux EFLAGS
    incrémente ESP de 4.
   
   A noter que PUSHFD  ne modifie aucun drapeau (registre EFLAGS).
   --------------------------------------------------------------
   
   POPFD modifie Tous les drapeaux sauf les bits réservés et le bit VM.
   -------------------------------------------------------------------     
   

  D) Instructions PUSHAD, PUSHA, POPAD et POPA
  --------------------------------------------
    (PUSHAD et PUSHA page 148 du manuel d'Intel: jeu d'instructions volume 2B (N-Z))
    (POPAD et POPA page 92 du manuel d'Intel: jeu d'instructions volume 2B (N-Z))
     
    PUSHAD empile les registres 32 bits dans l'ordre suivant:
      EAX, ECX, EDX, EBX, ESP (valeur avant empilement), EBP, ESI et EDI
     
    PUSHA empile les registres 16 bits dans l'ordre suivant:
      AX, CX, DX, BX, SP (valeur avant empilement), BP, SI et DI
     
      Ces instructions modifient esp d'autant de fois 4 ou 2 octets qu'il y a de registres.
     
    POPAD et POPA dépilent respectivement les registres 32 bits et 16 bits dans l'ordre inverse pour les restaurer.
    POPAD et POPA restaurent ESP avec la valeur d'avant le PUSHAD ou PUSHA.

      Ces instructions modifient ESP d'autant de fois 4 ou 2 octets qu'il y a de registres.
     

   A noter que ces instructions ne modifient aucun drapeau (registre EFLAGS).     
   -------------------------------------------------------------------------     
     
     
  E) Instructions CALL et RET
  ---------------------------
    (CALL page 105 du manuel d'Intel: jeu d'instructions volume 2A (A-M))
    (RET page 171 du manuel d'Intel: jeu d'instructions volume 2B (N-Z))

    En PureBasic, lorsque l'on appelle une procédure, on utilise directement son nom.
   
    En assembleur, on utilise l'instruction CALL.
    Cette instruction permet de dire au µp que la prochaine instruction n'est pas celle qui suit mais est fonction de l'opérande qui suit le CALL.
   
    Tout comme il y a en Purebasic un EndProcedure, il y a une fin de sous-programme en assembleur.
    On utilise l'instruction RET qui permet de revenir à l'instruction qui suit le call.
   
    Je ne détaillerais pas l'opérante du CALL (calcul du déplacement car c'est fastidieux et inutile pour nous).
    Il existe des appels courts (Near CALL) et des appels longs (Far CALL).

    - L'appel court est celui que nous utiliserons pour nos libs.
      La procédure appelée se situe dans le même segment de code, segment pointé par CS.
      Ce CALL est aussi appelé CALL intra-segment
   
    - L'appel long : La procédure appelée se situe dans un segment de code différent du segment de code courant pointé par CS.
      Ce CALL est aussi appelé CALL inter-segment

    Pour nos librairies, nous utiliserons le CALL (appel court) associé à une étiquette représentant l'adresse.
   
    Imaginons que nous ayons une suite d'instructions qui se situent après un label (étiquette) que l'on nomme MaProcedure
   
    Nous allons écrire ceci (les xxx sont des instructions asm quelconques)
   
    CALL Maprocedure   ; <-- ici on va directement à l'instruction située après le label Maprocedure
   
    xxx     ; le RET ramène ici
    xxx
    xxx
    xxx
 
 
Maprocedure :

    xxx     ; le CALL Maprocedure arrive ici
    xxx
    xxx
    xxx
 
    RET     ; on a fini notre sous-programme, on retourne à la première instruction après le CALL
 
    CALL et RET modifient la pile comme ceci.
    ----------------------------------------
    CALL va mettre sur la pile l'adresse de retour. ESP est décrémenté de 4
    Ensuite CALL copie l'adresse ou se situe Maprocedure dans le registre EIP qui est le registre d'instructions.
    (EIP pointe toujours la prochaine instruction)
    Puis le programme Continue à Maprocedure
   
    Lorsque le pointeur d'instruction rencontre le RET, il se passe ceci.
    RET dépile l'adresse de retour qui est mise dans le registre d'instructions EIP (EIP pointe toujours la prochaine instruction).
    ESP est incrémenté de 4 et le programme Continue à l'instruction qui suit le CALL.

    L'instruction RET accepte aussi une opérande mais nous verrons cela lorsque nous aborderons le passage de paramètres.


   - - - - -   
     
   Ce qu'il faut absolument retenir c'est que ESP pointe le sommet de la pile.
   
   Le PUSH décrémente d'abord ESP puis écrit la valeur sur la pile.
   
   Le POP lit d'abord la valeur du sommet de pile puis incrémente ESP.
   

   Les PUSH et POP ne modifient pas les drapeaux, ce qui est parfois intéressant lors des tests.
       

   D'autres instructions peuvent modifier ESP comme les instructions d'addition, de soustractions etc.
   Nous verrons cela dans les prochains tuts.
   


Prochain tut : Le corps d'un programme FASM pour les librairies PureBasic et les instructions asm les plus courantes.


A+
Denis


Dernière édition par Anonyme2 le Lun 10/Jan/2005 19:16, édité 1 fois.

Haut
 Profil  
Répondre en citant le message  
 Sujet du message:
MessagePosté: Dim 05/Déc/2004 17:27 
Hors ligne

Inscription: Mer 21/Jan/2004 17:48
Messages: 5162
Citation:
Prochain tut : Le corps d'un programme FASM pour les librairies PureBasic et les instructions asm les plus courantes.


cool , j'attends celui là avec impatience :P

_________________
http://purebasic.developpez.com/
Je ne réponds à aucune question technique en PV, utilisez le forum, il est fait pour ça, et la réponse peut profiter à tous.


Haut
 Profil  
Répondre en citant le message  
 Sujet du message:
MessagePosté: Dim 05/Déc/2004 20:47 
Hors ligne
Avatar de l’utilisateur

Inscription: Jeu 22/Jan/2004 14:31
Messages: 3518
Localisation: Sourans
C'est FASM ou les instructions les plus courantes ?

Pour les instructions asm il y a les 996 pages de la doc Intel :mrgreen:

En parallèle j'ai travaillé un petit outil pour créer un corps de programme FASM pour les librairies avec les déclarations (paramètres, variables locales, globales y compris l'utilisation des structures.
Cet outil devrait faciliter la création de librairies (J'ai pas dit qu'il écrivait les librairies à votre place :mrgreen:)

Il est pas tout à fait terminé, tout du moins la version 1 car j'ai fait une liste de ce que je voudrais ajouter, y a encore du taf...


Haut
 Profil  
Répondre en citant le message  
 Sujet du message:
MessagePosté: Lun 06/Déc/2004 17:12 
Hors ligne

Inscription: Mer 21/Jan/2004 17:48
Messages: 5162
C'est le corps d'un programme pour créer une librairie qui m'intéresse, à la limite , un programme complet :)

Un truc tout simple , une fonction qui fait l'addition de deux paramètres par exemple.
ça me permettrait d'avoir un exemple complet à compiler.
et ensuite , je pourrai m'amuser à faire des bricoles en partant de ce modèle, mais bon , rien d'important, je n'ai pas envie de consacrer bcp de temps à l'apprentissage de l'assembleur , c'est surtout par curiosité.

j'avais fait quelques fonctions en C , à la rigueur je pourrai m'amuser à les recréer en assembleur pour apprendre.

_________________
http://purebasic.developpez.com/
Je ne réponds à aucune question technique en PV, utilisez le forum, il est fait pour ça, et la réponse peut profiter à tous.


Haut
 Profil  
Répondre en citant le message  
 Sujet du message: Re: Tutoriel 6 - La pile et instructions asm pouvant la modifier
MessagePosté: Mar 24/Nov/2009 15:18 
Hors ligne

Inscription: Mar 24/Nov/2009 15:13
Messages: 384
Bonjour,
Merci pour le cours sur l'assembleur mais comment pourrait-on avoir la documentation complète sur cet assembleur (nomenclature, jeu d'instructions du microprocesseur, mode d'adressage, pile, registres, etc.,), bref, une doc complète pour faire des programmes en assembleur ?


Haut
 Profil  
Répondre en citant le message  
 Sujet du message: Re: Tutoriel 6 - La pile et instructions asm pouvant la modifier
MessagePosté: Mar 24/Nov/2009 16:33 
Hors ligne
Avatar de l’utilisateur

Inscription: Jeu 22/Jan/2004 14:31
Messages: 3518
Localisation: Sourans
pat a écrit:
Bonjour,
Merci pour le cours sur l'assembleur mais comment pourrait-on avoir la documentation complète sur cet assembleur (nomenclature, jeu d'instructions du microprocesseur, mode d'adressage, pile, registres, etc.,), bref, une doc complète pour faire des programmes en assembleur ?



Des cours ... disons plutôt des infos :D

Pour le jeu d'instructions, l'architecture, l'optimisation etc. c'est ici pour Intel

http://www.intel.com/products/processor ... /index.htm

Pour AMD je ne sais pas et je n'ai pas envie de chercher :D

Pour le reste, les forums, les sites etc.


Dernière édition par Anonyme2 le Mar 24/Nov/2009 17:42, édité 1 fois.

Haut
 Profil  
Répondre en citant le message  
 Sujet du message: Re: Tutoriel 6 - La pile et instructions asm pouvant la modifier
MessagePosté: Mar 24/Nov/2009 16:42 
Hors ligne
Site Admin

Inscription: Mer 21/Jan/2004 11:03
Messages: 2564
tu peux aussi recuperer la doc de FASM: www.flatassembler.net


Haut
 Profil  
Répondre en citant le message  
Afficher les messages postés depuis:  Trier par  
Poster un nouveau sujet Répondre au sujet  [ 7 messages ] 

Heures au format UTC + 1 heure


Qui est en ligne

Utilisateurs parcourant ce forum: Aucun utilisateur enregistré et 1 invité


Vous ne pouvez pas poster de nouveaux sujets
Vous ne pouvez pas répondre aux sujets
Vous ne pouvez pas éditer vos messages
Vous ne pouvez pas supprimer vos messages

Rechercher:
Aller à:  
cron

 


Powered by phpBB © 2008 phpBB Group | Traduction par: phpBB-fr.com
subSilver+ theme by Canver Software, sponsor Sanal Modifiye