Remerciez-le!

Remerciez @Admin pour avoir partagé cet document gratuitement, de la manière la plus simple, en partageant sur les réseaux sociaux.

1 Programmation en Assembleur (1) Université Abdelhamid Ibn Badis de Mostaganem

1 Programmation en Assembleur (1) Université Abdelhamid Ibn Badis de Mostaganem Faculté des Sciences et Sciences de l’Ingénieur Microprocesseur Microprocesseur Cours ETL 427 – 4 Cours ETL 427 – 4ème ème ELT ELT 2  Définition C'est le seul langage qui soit directement compréhensible par un µp. Il est composé d'une suite d'octets localisés en mémoire et dont le contenu, binaire, constitue une suite de codes significatifs pour le microprocesseur. Il est nécessaire de bien comprendre que quel que soit le langage utilisé en programmation évoluée ( C , ADA, Programmation Structurée, Programmation Objets), les outils de programmation finiront toujours par fournir à notre microprocesseur des codes langage machine... Exemple Prenant l'instruction suivante comme exemple : MOVE.L $FC0024, $2400 Cette instruction est en langage assembleur, son équivalent binaire (hexadécimal) est : $ 21F9 00FC 0024 2400 C'est ce code là qui est stocké en mémoire et qui sera exécuté par le µp. donc le code opération de l'instruction MOVE.L est $ 21F9 == % 00 10 000 111 111 001. 00 = MOVE 10 = .L 000 111 = L'opérande destination est une adresse mémoire sur 16 bits... 111 001 = L'opérande Source est une adresse mémoire sur 32 bits... Langage machine 3  Définition Un programme en langage d'assembleur est stocké sous forme de texte . Chaque instruction assembleur représente exactement une instruction machine. Par exemple, une instruction d'addition est représentée en langage assembleur comme suit : ADD.B D1, $2200 Ici, la signification de l'instruction est beaucoup plus claire qu'en code machine. Le mot ADD est un mnémonique pour l'instruction d'addition. La forme générale d'une instruction assembleur est : Etiquette Mnémonique Opérandes commentaires Avantages : – minimise le code – meilleur contrôle sur le matériel. Langage assembleur 4  MOVE.(BWL) source, destination  MOVEA.(WL) src, An (si sur 16  extension sur 32 bits)  MOVEQ #data, Dn data sur 8bits et extension signé  L  Exp : MOVEQ#-128, D4  MOVE src, CCR (CCR sur 8 bits)  Exp : MOVE #$4E5A, CCR  EXG Rn, Rm (Rn  Rm)  SWAP Dn (Dn(31-16)  Dn(15-0)) FF FF FF 80 D4 XX 5A CCR Instructions de mouvement 5 Le code binaire pure et complément à 2 utilisent tous les deux ces instructions :  ADD.(B W L) src, Dn  ADDA.(W L) src, An (si sur 16  extension sur 32 bits)  ADDI.(B W L) #data, dest  ADDQ.(B W L) #data, dest il faudrait que data soit entre 1 et 8  ADDX.(B W L) Dn, Dm  ADDX.(B W L) -(An), -(Am) Même chose pour la soustraction : SUB Code BCD  ABCD -(An), -(Am)  ABCD Dn, Dm  SBCD -(An), -(Am)  SBCD Dn, Dm Remarque : quand l'addition est de plus de 8 bits, on procède par tranche  voir documentation. Instructions arithmétiques 6  MULU source, Dn  MULS source, Dn  source (W) x Dn (W)  résultat Dn (L) (16 x 16  32)  DIVU source, Dn  DIVS source, Dn  Dn(L) ÷ source (W)  résultat U : unsigned ; S : signed Exp : MULS D3, D5  NEG.(B,W,L) dest  complementation à 2  NEGX.(B,W,L) dest  complementation à 2  NBCD.B dest  si X=0 complément à 10; si X=1 complément à 9  EXT.(W,L) Dn extension signée rW qW Dn xxxx ------- D3 xxxx ------- D5 ------ ------- Résultat  D5 Instructions arithmétiques 7 Exp.1 : Calcul de la moyenne de 2 nombres de 32 bits : On suppose que aL+bL ne dépasse pas 32 bits  (a+b)L et m codés sur 32 bits. Remarque : a étant composé de plusieurs octets; alors l'octet de poids le plus fort se trouve à l'adresse spécifiée. ORG $2400 MOVE.L $2800, D0 ADD.L $2804, D0 DIVU #2, D0 MOVE.W D0, $2808 MOVE.B #9, D0 TRAP #15 END 2 a b m + = Calcul arithmétique 8 Exp.2 : Addition de 2 nombres a et b de 64 bits. s = a+b sur 64 bits. On suppose que (a+b) tient sur 64 bits. Ada = $2800 ; adb = $2808 ; ads = $2810 ORG $2500 MOVE.L $280C, D0 blowD0 ADD.L $2804, D0 blow+alowD0 (si retenue  X) MOVE.L D0, $28104 blow+alowslowads+4 MOVE.L adb, D0 bhighD0 MOVE.L $2800, D1 ahighD1 ADDX.L D0, D1 D0 + D1 +X  D1 MOVE.L D1, $2810 D1  shigh MOVE.B #9,D0 TRAPE #15 END Calcul arithmétique 9  ANDI.(B,W,L) #data, dest  De même pour OR et ORI  EOR.(B,W,L) Dn, dest  EORI.(B,W,L) #data, dest  NOT.(B,W,L) dest complément à 1  ASL.(B,W,L) Dn, Dm décalage de [Dn]0-5 bits  ASL.(B,W,L) #data, Dm data 1à 8  ASL.W dest toujours sur W décalage d'un bit  De même pour : ASR, LSL, LSR, ROL, ROR, ROXL et ROXR • AND.(B,W,L) Source, Dn Dn, Dest Instructions Logiques 10 Suppositions : [$2800]B = $00 [$2900]L = $A01704A2 X N Z V C Avant exécution x x x x x Après exécution de : MOVE.B $2800, $2820 x 0 1 0 0 Après : MOVE.L $2900, D4 x 1 0 0 0 Après : ADD.B #$11, D4 0 1 0 0 0 Après : ADD.B #$80, D4 1 0 0 1 1 Affectation des indicateurs 11 Une directive est une pseudo-instruction destinée à l'assembleur, c'est un ordre spécial que le programmeur donne à l'assembleur pour affecter de valeurs à des symboles (adr EQU $2801), introduire des données en mémoire, … etc.  Directive origine : ORG Elle indique à l'assembleur à quel emplacement en mémoire il faut mettre le code machine des instructions, une fois assemblées, ou bien à quel emplacement il faut mettre les données spécifiées par la directive DC.  Directive fin de fichier : END Elle indique la fin du texte source qui doit être assemblé. L'assembleur ignore tout texte placé après END.  Directive d'équivalence : EQU Elle est utilisée pour assigner une valeur à un symbole.  Directive d'initialisation mémoire : DC Elle permet de mettre une ou plusieurs constantes en mémoire à l'adresse courante Les directives en assembleur 12 Exp.1 : ORG $2400 MOVEQ #$43, D3 MOVE.L #’4ELT’, $2800 MOVE.B #9, D0 TRAP #15 END Exp.2 : ORG $2800 DC.B 12, $4A, '*', %11001000 DC.B -2, 'XY'  erreur car ça dépasse le format .B il faut mettre : DC.B 'XY', -2 ORG $2900 DC.W 12, 1, 'AB' DC.L '1993', $ABC ORG $2A00 DC.B 'Lundi Mostaganem Nov 2007' ORG $2400 … END Où d'une autre manière val1 EQU $43 val2 EQU ‘4ELT’ adr EQU $2800 ORG $2400 MOVEQ #val1, D3 MOVE.L #val2, adr MOVE.B #9, D0 TRAP #15 END Les directives en assembleur 13 Les directives en assembleur 14 On désigne par mode d'adressage, la manière d'accéder à un opérande.  Adressage Registre : L'opérande se trouve dans le registre spécifié dans l'instruction An, Dn, CCR, SR Exp : CLR.W D7 MOVE.L A3, D0 N.B : si la destination est un registre d'adresse An, si la taille est W  extension signée jusqu'à L.  Adressage immédiat : L'opérande est exprimé directement par sa valeur. Le symbole # (dièse) identifie le mode d'adressage immédiat. Exp. : MOVE.B #$E4, D2 MOVEQ #-6, D7 N.B : ce mode ne peut être utilisé qu'en source.  Adressage absolu : L'opérande est désigné par une adresse qui indique son emplacement en mémoire; le défaut de symbole exprime ce mode. Exp. : MOVE.W #$1E48, $2800 MOVE.L $2200, $803000 Modes d’adressage 15  Adressage indirect simple : L'opérande se trouve dans une position mémoire, dont l'adresse est contenue dans un registre d'adresse. Les parenthèses "( )" expriment ce mode. Exp. : CLR.W (A4) #$0000  [A4] Si [A4] = $2800 alors : les deux cases mémoire ($2800 et $2801) sont initialisées avec la valeur $00  Adressage indirecte et post-incrémenté : (An)+ − L'opération s'effectue sur l'opérande [[An]] − Puis incrémentation de An : le contenu de An va être incrémenté comme suit : [An] + 1  An si taille B [An] + 2  An si taille W [An] + 4  An si taille L Modes d’adressage 16 Exp. : CLR.W (An)+ Avant exécution A4 = $2800 Aprés execution A4 = $2802  Adressage indirecte et pré-décrémenté : - (An)  Décrémentation de An : [An] - 1  An si taille B [An] - 2  An si taille W [An] - 4  An si taille L  Puis l'opération s'effectue sur [[An]] Exp. : CLR.L -(A4) Avant exécution : [A4] = $2800 Après exécution : [A4] = $27FC N.B. : Pour (A7)+ et - (A7), quand la taille utilisée est B l'incrémentation ou la décrémentation s'effectue sur 2 unités (B == W). Modes d’adressage 17  Adressage indirect avec déplacement : d(An) d : déplacement est un nombre signé sur 16 bits. L'opérande se trouve en mémoire, et son adresse est : Adresse = [An] + d Exp. : MOVE.W #-2, -4(A6) On suppose A6 =$270A  Adressage indirect - indexé avec déplacement : d(An, uploads/S4/ coursmp-3-etl427.pdf