1 / 169

Assembleur

Assembleur. Niveaux de programmation. Niveaux de programmation circuit logiques 0/1 --------------------------------------------------------------------------------- unité de traitement micro-instructions

tanith
Download Presentation

Assembleur

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Assembleur

  2. Niveaux de programmation • Niveaux de programmation circuit logiques 0/1 --------------------------------------------------------------------------------- unité de traitement micro-instructions (UAL, chemins de données) = suite de 0/1 (Unité de commande) micro-pgme = suite de micro-instructions ------------------------------------------------------------------------------------ Codop 111111 000011101010101 langage machine = suite de 0/1 ------------------------------------------------------------------------------------ ADD A,20 assembleur = remplacer les codop JZ 13 par des mnémoniques Djamal Rebaïne

  3. Structure d’un programme assembleur 8086 TITLE nom ; donner un nom au programme PILE SEGMENTSTACK ; déclaration d’un segment de pile ; dont le nom est pile .......... .......... PILE ENDS ; fin de la déclaration de la pile DONNEE SEGMENT ; déclaration d’un segment de données qui va ; contenir les variables ........... DONNEE ENDS ; fin de la déclaration de données LECODE SEGMENT ; déclaration du segment de code qui va contenir ; le code Debut: ; étiquette d’indication du point d’entrée du code ................................. LECODE ENDS ; fin de la déclaration du code END Debut ; fin du point d’entrée du code Djamal Rebaïne

  4. Exemple • TITLE prog2.asm: Exemple sur ROL, • ; pour mettre un commentaire, on écrit ; • Pile segment stack ; segemnt de pile • dw 100 dup(?) • Pile ends • DATA segment ; segement de donnée • DATA1 DW 5F97H • COMPTE DB ? • DATA ends • CODE segment ; segment de code • MAIN: • ASSUME CS:CODE, DS:DATA • MOV AX,DATA • MOV DS, AX • XOR BL, BL ; Mettre BL à 0 (ou bien SUB) • MOV DL, 16 ; rotation 16 fois • MOV AX, DATA1 • ENCORE: ROL AX, 1 ; Rotation a gauche (a droite aussi si on préfère) • JNC PROCHAIN ; Test si CF=0 • INC BL ; Si CF = 1, incrémenter le compteur du nombre de ‘1’ • PROCHAIN: DEC DL ; répéter 16 fois • JNZ ENCORE ; encore une fois si ce n’est pas fini • MOV COMPTE, BL ; sauvegarder le résultat dans la case mémoire COMPTE • MOV AH, 4Ch • INT 21h • MAIN ENDS • END MAIN Djamal Rebaïne

  5. Pourquoi les segments? À l'origine - Pour pouvoir adresser plus de 64 Ko de mémoire dans un programme car les registres sont sur 16 bits En pratique aujourd'hui - Permet de séparer clairement des zones mémoires selon leur rôle Exemple : la pile ne peut pas être écrasée par des données ou déborder sur des données / code Mais cela est contraignant ... Djamal Rebaïne

  6. Suite Adressage sur 20 bits avec 2 registres 2 registres 16 bits : peut coder adresses sur 32 bits Pour uniquement 20 bits (car les bus d’adresse sur les processeurs 8086 sont sur 20 bits): - Décale le premier registre de 4 bits et l'additionne au second - Adresse notée A:B - Adresse réelle : A * 16 + B Exemple (les nombres sont en hexa) • 3100:27EE correspond à l'adresse 31000 + 27EE = 337EE • Décaler de 4 bits en binaire revient à décaler d'un chiffre en hexa Djamal Rebaïne

  7. Suite 2 Nous avons 4 segments d'adresses : CS, DS, SS, ES • utiliser 2 registres pour adresser des mots mémoires - Le premier est le registre de segment - Le second un registre général On l'appelle l'offset (décalage) Addresse : segment:offset • Exemples - CS:IP : adresse de la prochaine instruction à exécuter - DS:SI : adresse d'une donnée - SS:SP : adresse du haut de la pile Djamal Rebaïne

  8. Vos programme sources, écrits en assembleur, doivent avoir l’extension .asm pour ASseMbler Djamal Rebaïne

  9. Déclaration de variables Les variables se déclarent de la manière suivante: datas1 db ? ; datas1 est un byte non initialisédatas2 db 0FFh ; datas2 est un byte initialisé à FF (255 en hexadécimal)datas3 dw ? ; datas3 est un word (16 bits) non initialisédatas4 db 5 dup (?) ; datas4 est un tableau de 5 bytes non initialisésdatas5 dw 10 dup (15) ; datas5 est un tableau de 10 byte initialisés chacun à 15 De manière générale: DB : 1 byte (8 bits) (Declare Byte) DW : 1 word (16 bits) (Declare Word) DD : 2 words (32 bits) (Declare Double) DF,DP : 6 bytesDQ : 8 bytes (64 bits)DT : 10 bytes Les constantes peuvent être écrites en: - décimal: 1, 2, 3, 123, 45 - hexadécimal : 1h,2h,3h,12h,0Fh,0AD4h (noter la présence du 0 quand le premier chiffre du nombre en hexadécimal commence par une lettre) - binaire : 1b,0b,1010b,111101b Djamal Rebaïne

  10. Les entrées Sorties en assembleur • Pour réaliser les opérations standards (affichage, saisie), le système d’exploitation (ici DOS) fournit les fonctions pré-écrites suivantes: • Affichage d’un caratère: mov DL, “A”; caractère A est transfére dans DL mov AH, 2; fonction no. 2 int 21h ; appel au DOS • Affichage d’une chaine de caractères: mov DX, offset chaine; pointe vers l’adresse du premier caractère de la chaîne de caractères chaine mov AH, 09h; fonction no. 9 int 21h ; donne la main au DOS • Saisie d’un caratère: mov AH, 1; fonction no. 1 (avec écho) int 21h ; résultat est mis dans AL Djamal Rebaïne

  11. Saisie d’un caractère mov AH, 7; fonction no. 7 (sans écho) int 21h ; résultat dans AL • Arrêt de programme: mov AX, 4C00h; int 21h; À mettre à la fin de chaque fin programme; c’est l’équivalent du return (0) en C. Ces instructions ont pour effet de retourner au DOS Djamal Rebaïne

  12. L’équivalent de quelques instructions du langage C en assembleur • if then else Assembleur If ax =1 if: CMP AX, 1 bx = 10; JNZ Else else { bx = 0; Then: MOV BX,10 cx = 10; JMP endif } Else: MOV BX,0 MOV CX,10 endif: .............. Djamal Rebaïne

  13. Instruction i VRAI FAUX Condition ? Instructions m Instructions j Instructions k … Instruction i Siconditionalors Instructions j Sinon Instruction m Fin si Instructions k Djamal Rebaïne

  14. La boucle FOR Assembleur • For (k=0; k<=10; k++) MOV BX,0 • bx = bx + k; MOV CX,0 For: CMP CX,10 JA Endfor ADD BX,CX INC CX JMP For Endfor: Djamal Rebaïne

  15. WHILE Assembleur • bx = 5 MOV BX,5 • while (bx >0) while: CMP BX,0 bx = bx -1; JLE Endwhile DEC BX JMP while Endwhile: Djamal Rebaïne

  16. En règle générale • while (a > b) while: cmp a,b • { jle endwhile … … } jmp while … endwhile: … Djamal Rebaïne

  17. SWITCH Assembleur • switch (n) { CMP n,1 case 1: ....; break; JNE case2 case 2: .....; break; ............ default: .....; JMP endswitch } case2: CMP n,2 JNE default .......... JMP endswitch default: ........... endswitch: ........... Djamal Rebaïne

  18. Écrire le code de l’instructionEn assembleur if (a>b) && (c <= d) if: cmp a, b { jng endif ................ } cmp c, d jnle endif .............. endif: Exercice: coder en assembleur les instructions suivantes: 1. if (a >b) || (c > d)) 2. for (i=1; i < 10; i++) { { } } Djamal Rebaïne

  19. Liste des registres les plus utilisés A. Registres généraux • AX (A pour accumulateur): joue le rôle d’opérande implicite dans plusieurs opérations: MUL, DIV, INC, etc. • CX (C pour compteur): est utilisé pour les boucles (instruction LOOP). • DX: utilisé dans les multiplications et divisions comme registre d’extension. • SI (Source Index): souvent utilisé comme pointeur sur une adresse mémoire (exemple: MOV AL, [SI]). Il est très utilisée avec les instructions de traitement de chaînes de caractères (LODS). • DI (Destination Index): pareil que SI (instruction STOS) • BP (base pointeur): sert de pointeur sur la base de la pile, et permet d’atteindre n’importe quel élément de la pile (exemple: MOV AX,[BP+2]). • SP (Stack pointer): pointe sur le sommet de la pile; son contenu est automatiquement changé par les instructions PUSH et POP. Djamal Rebaïne

  20. B. Registres spéciaux • IP (Instruction pointeur): contient l’adresse de l’instruction qui suit celle qui est en cours d’exécution. • DS (Data Segment): Pointe sur le début du segment qui contient les données • CS (Code Segment): Pointe sur le segment qui contient le code du programme. • ES (Extended Segment) : permet de pointer sur un segment supplémentaire défini par le programmeur. Il se charge par l’intermédiaire de AX, comme pour DS. • SS (Stack Segment): segment contenant la pile. C. Registre indicateur : utilisé pour sauvegarder des états particuliers du microprocesseur en référence à la dernière instruction exécutée. Quelques bits seulement de ce registre ont une signification sont nommés: CF (retenue), OF (débordement), etc. Djamal Rebaïne

  21. La plupart des opérations de calculs donnent des informations sur le résultat dans le registre spécial flags. Les informations possibles sont : CF : 1 si le résultat a donné lieu à une retenue PF : 1 si l'octet de poids faible du résultat à un nombre pair de 1 AF : 1 si le résultat a donné lieu à une retenue sur le 3eme bit ZF : 1 si le résultat est zéro SF : 1 si le résultat est négatif IF : 1 si les interruptions peuvent arriver DF : 0 si la direction est incrémentée, 1 si elle est décrémentée OF : 1 si le résultat ne tient pas dans la destination Djamal Rebaïne

  22. Format standard d’une instruction Label: Mnémonique Opérandes ;commentaire Label: est unidentificateur permettant de désigner un endroit dans le code source, soit une instruction, soit une donnée. Si le label est placé avant une instruction, on fait référence à l’adresse de cette instruction. Si c’est avant une donnée, on fait référence à l’adresse de cette instruction. Le label de code doit se terminer par deux points (:). Il sert général comme destinations des instructions ou des retour de début des boucles de répétition. Le label de donnée ne contient pas les deux points(:) à la fin. Il sert dans ce cas là comme identificateur. Djamal Rebaïne

  23. Mnémonique (des instructions): il sert à identifier une instruction donnée. Quelques instructions de base sont résumées dans la prochaine section. • Opérandes: une instruction assembleur peut avoir de 0 à 3 opérandes. Chaque opérande peut être le nom d’un registre, un opérande mémoire, une expression constante ou le nom d’un périphérique entrée/sortie. • Commentaire: précédé du point-virgule (;). Il sert à à ajouter des informations explicatives au sujet du fonctionnement du programme ou de l’instruction correspondante. Djamal Rebaïne

  24. Quelques instructions de base-1 • Affectations ; Registres <-- Valeurs MOV AX, 65535 ; (décimal) MOV Cl, 01101b ; (binaire) MOV DH, 0FAh ; (hexa) ; Entre registres MOV AX, BX MOV CL, DH ; Entre Registres et Variables MOV CX, variable_de_deux_octets MOV variable_de_un_octet, DL ;Registres <-- Adresses Mémoire Mov AX, Offset variable ; AX <- adresse de variable Mov CX, [ 5Ah ] ; CX <- valeur à l'adresse 5A en hexa Djamal Rebaïne

  25. Quelques instructions de base- 2 • Arithmétique ; Incrémentation INC AX ; AX <- AX + 1 Inc ma_variable ; Décrémentation DEC AX Dec ma_variable ; Addition ADD AX, 5 ; AX <- AX + 5 ADD BH, toto ; BH <- BH + toto Add toto, Cx ; toto <- toto + Cx ; Soustraction SUB AX, 5 ; AX <- AX – 5 SUB BH, toto ; BH <- BH – toto SUB toto, CX ; toto <- toto - CX Djamal Rebaïne

  26. Quelques instructions de base-3 • Logique ; AND bit à bit MOV AH, 0101b ; AH <- 5 MOV BH, 1001b ; BH <- 9 AND AH, BH ; AH <- AH AND BH; AH vaut 0001b, soit 1 ; OR bit à bit MOV AH, 0101b ; AH <- 5 MOV BH, 1001b ; BH <- 9 Or AH, BH ; AH <- AH OR BH; AH vaut 1101b, soit 13 (8+4+1) ; XOR bit à bit MOV AH, 0101b ; AH <- 5 MOV BH, 1001b ; BH <- 9 XOR Ah, BH ; AH <- AH XOR BH; AH vaut 1100b, soit 12 (8+4) ; NOT bit à bit MOV AH, 0101b ; AH <- 5 Not AH ; AH <- NOT AH; AH vaut 1010b, soit 10 (8+2) Djamal Rebaïne

  27. Quelques instructions de base-4 • Comparaisons : Toutes les comparaisons se font à l'aide de l'instruction CMP. On utilise ensuite les instructions de saut conditionnel: Jump if Equal, JMP if Greater, ... Il faut définir des labels (étiquettes): les endroits dans le programme où va sauter si le test est vérifié (comme les GOTO en Fortran). ; Egalité (Jump if Equal) CMP AX, 5 JE label_1 ; Différence (Jump if Not Equal) CMP AX, ma_variable JNE label_2 ;Inférieur, Supérieur, Inf. ou égal, Sup. ou égal ; (Jump if Lower, Greater, Lower or Equal, Greater or Equal) CMP CH, 0 JL label_1 CMP DH, Ah JG label_2 CMP AL, 01001b JLE label_3 Djamal Rebaïne

  28. CMP variable, 65 JGE label_4 Label_1: instructions... Label_2: instructions... Label_3: instructions... Label_4: instructions... ; Saut non conditionnel : JMP label_1 Remarque: CMP est identique à l’instruction SUB, mais ne produit pas de résultat. Il positionne cependant les flags. Il permet de sauter à un label qui est à une adresse de 16 bits. Les sauts à un label sont toujours courts (à peu prés de 127octets). Il faut donc prendre garde que ce label puisse être atteint. Djamal Rebaïne

  29. Djamal Rebaïne

  30. Djamal Rebaïne

  31. Un Warm-up Quelques exemples de programmes en assembleur

  32. Impression d’une chaine de caractères TITLE Mon_premier_programme_assembleur PILE SEGMENT STACK; DW 100 DUP (?) PILE ENDS; DATA SEGMENT; chaine db 'Bienvenue au monde de l',39,'assembleur!','$‘ ; remarquez le $ pour marquer la fin de la chaîne de caractères DATA ENDS Djamal Rebaïne

  33. MAIN SEGMENT ASSUME DS:DATA, CS:MAIN; pour l’instant on fait comme ça sans ; trop se poser de question. DEBUT: MOV AX, DATA ; Initialiser le registre DS pour récupérer ; l’adresse du segment de donnée MOV DS, AX MOV DX, offset chaine ; Afficher une chaine de caractères MOV AH, 09h ; fonction 9 pour imprimer sur écran une ;chaine de caratères à partir d’une adresse; un $ doit terminer cette ;chaine pour marquer l,arrêt de l’impression. INT 21h MOV AX, 4C00h ; l’équivalent de return(0) en C-C++ INT 21h; MAIN ENDS END debut Djamal Rebaïne

  34. Quelques notes utiles • La déclaration d’une chaîne de caractères est mise en • '''' ou ' ' . • Le caractère '$' indique la fin d’une chaîne de caractères. Son omission implique que les octets en mémoire qui viennent après cette chaîne sont aussi affichés comme des caractères. • L’assembleur ne fait pas de différence entre une majuscule et une minuscule dans l’écriture de ses instructions et la notation des registres. • La directive ASSUME permet d'indiquer à l'assembleur où se situe le segment de données et le segment de code. Puis il s'agit d'initialiser le segment de données à l’intérieur du segment de code: MOV AX, nom_du_segment_de_donneesMOV DS, AX Djamal Rebaïne

  35. Les données sont regroupées dans une zone de la mémoire appelée segment de données, tandis que les instructions se situent dans un autre segment qui est le segment d'instructions. • Le registre DS (Data Segment) contient le segment de données, tandis que • le registre CS (Code Segment) contient le segment d'instructions. • C'est la directive ASSUME qui permet d'indiquer à l'assembleur où se situe • le segment de données et le segment de code. Puis il s'agit d'initialiser le segment de données: • MOV AX, nom_du_segment_de_donnees • MOV DS, AX • La même procédure est faite quand viendra le moment d’utiliser • le segment de pile Djamal Rebaïne

  36. Maximum entre deux nombres TITLE Exercice 3 ; Écrire un programme en assembleur 8086 qui calcule le maximum ; de deux nombres A et B.   PILE SEGMENT STACK; DW 100 DUP (?) PILE ENDS;  DATA SEGMENT;  n1 db (?) n2 db (?)  DATA ENDS  MAIN SEGMENT  ASSUME DS:DATA, CS:MAIN DEBUT: MOV AX, DATA ; Initialise le registre DS pour récupérer l’adresse du segment de MOV DS,AX ; donnée MOV AH, 1h ; Lire un nombre à partir du clavier INT 21h MOV n1, AL MOV AH, 1h ; Lire un deuxième nombre à partir du clavier INT 21h MOV n2, AL   Djamal Rebaïne

  37. CMP AL, n1 JG AFFICHER_N2 JL AFFICHER_N1 JMP AFFICHER_EGAL  AFFICHER_N1 :   MOV DL, N1 ; afficher n1 mov AH, 02h int 21h JMP RETURN  AFFICHER_N2 :   MOV DL, N2 ; afficher n2 mov AH, 02h int 21h JMP RETURN  Djamal Rebaïne

  38. AFFICHER_EGAL :   MOV DL, '=' ; afficher "=" mov AH, 02h int 21h JMP RETURN   RETURN:  MOV AX, 4C00h ; return 0 INT 21h;   MAIN ENDS  END debut Djamal Rebaïne

  39. Modes d’adressage pour accéder aux données Un mode d'adressage est un moyen qui permet au microprocesseur d'avoir accès à une donnée. Cette donnée peut être un nombre quelconque dont on aura besoin dans le programme, un nombre qui se trouve déjà dans un registre, ou encore un nombre qui se trouve écrit quelque part en mémoire. • La connaissance des principaux modes d'adressage est nécessaire car elle permet d'écrire les programmes de la façon la plus courte, la plus simple et la plus lisible possible. Djamal Rebaïne

  40. Modes d’adressage pour accéder aux données 1. Adressage immédiat : l'opérande est une constante mov ah,10h ; 2. Adressage direct : l'opérande est une case mémoire (registre ds est par défaut) mov al,[10h] ; [ds:10h] mov ax,[es:10h] ; [ici le segment est ES 3. Adressage basé : l'opérande est une case mémoire dont l'adresse est donnée par BX (Si ou Di, avec ds par défaut) ou bp (avec ss par défaut) mov AH,[BX] ; <=> mov AH,[DS:BX] mov AL,[bp] ; <=> mov AL,[ss:bp] BX,BP,SI,DI peuvent servir de registre pointeur Djamal Rebaïne

  41. 4. Adressage indexé : l'opérande est une case mémoire dont l'adresse est donnée par si ou di (avec ds par défaut, sauf mnemonic spécique) mov ah,[si] ; <=> mov ah,[ds:si] 5. Adressage basé et indexé mov ah,[bx+di] ; <=> mov ah,[ds:bx+di] mov [bp+si],ah ; <=> mov [ss:bp+si],ah Les couples possibles sont BP-DI,BP-SI, BX-DI, BX-SI 6. Adressage basé avec déplacement mov ah,[bx+123h] ; <=> mov ah,[ds:bx+123h] Djamal Rebaïne

  42. 7. Adressage indexé avec déplacement mov ah,[di+123h] ; <=> mov ah,[ds:di+123h] 8. Adressage basé et indexé avec déplacement mov ah,[bx+si+123h] ; <=> mov ah,[ds:bx+si+123h] Djamal Rebaïne

  43. Remarques • Si aucun registre de segment n'est précisé, c'est le segment par défaut qui est utilisé : CS pour IP; DS pour BX et SI; ES pour DI, SS pour BP et SP. 2. Ce n’est pas toutes les combinaisons registres de segment/registres d'index qui sont possibles; les combinaisons les plus communément utilisées sont: DS:BX, DS:SI, ES:DI, SS:BP, CS:BX Djamal Rebaïne

  44. Un petit mot sur l’instruction de transfert MOV reg, reg (registre à registre) reg, mem (registre à mémoire) mem, reg (mémoire à registre) reg, imed (registre à valeur) mem, imed (mémoire à valeur) NOTE: Pas de transfert de mémoire à mémoire Djamal Rebaïne

  45. Applications de quelques instructions sur des exemples Djamal Rebaïne

  46. Instruction CMP(Comparer) CMP destination, source L’instruction CMP affecte les indicateurs AF, OF, SF, PF, CF et ZF mais seuls CF et ZF sont utilisés. L’opérande destination peut être dans un registre ou dans une mémoire. L’opérande source peut être dans un registre, dans une mémoire, ou en mode immédiat. Les opérandes (destination et source) ne changent pas. DATA1 DW 235FH … MOV BX, 7888H ; 7888Hh  BX MOV CX, 9FFFH CMP BX, CX ; BX < CX  CF=1  JNC est exécutée  PASSE JNCPASSE ; Note: les contenus de (BX, et CX) ne changent pas après CMP ADD BX, 4000H PASSE: ADD CX, DATA1 ; mais CF est toujours vérifié pour (< ou >). Pour (=) on utilise ZF. TEMP DB ? … MOV AL, TEMP ; TEMP  AL CMP AL, 99 ; TEMP = 99?. Avec (SUB AL, 99), la même chose mais 0  AL JZPROCHAIN ; Si ZF=1 (TEMP=99), Saute a PROCHAIN: INC BX ; Sinon incrémente BX PROCHAIN: MOV AH, 4Ch INT 21h ; Arrêt du programme Djamal Rebaïne

  47. TITLE prog1.asm: Exemple sur CMP,Trouver l’octet le plus grand parmi 5 notes d’élèves • PILE segment stack • dw 100 dup(?) • PILE ends • ;------------------------------------------------------------------------------------------------------------------------------------------------------------- • DATA segment • NOTES DB 18, 06, 19, 11, 08 • PLUS_G DB ? • DATA ends • ;------------------------------------------------------------------------------------------------------------------------------------------------------------ • CODE segment • main: • assume CS:CODE, DS:data ; génération de l’adresse du segment de code et de données • MOV AX, DATA ; Initialiser le registre DS pour récupérer l’adresse du segment de donnée • MOV DS, AX • MOV CX, 5 ; compteur de boucle • MOV BX, OFFSET NOTES ; BX pointe vers les données NOTES • XOR AL, AL ; Initialise AL à 0; va héberger la plus grande note • ENCORE: CMP AL, [BX] ; compare la note prochaine à la note la plus élevée • JA PROCHAIN ; Sauter si AL est encore la note la plus élevée • MOV AL, [BX] ; sinon AL retient la plus élevée • PROCHAIN: INC BX ; pointe vers la prochaine note • LOOPENCORE ; CX décrémente jusqu’à 0 pour sortir de la LOOP • MOV PLUS_G, AL ; sauvegarde de la note la plus élevée dans PLUS_G • ;------------------------------------------------------------------------------------------------------------------------------------------------------------- • MOV AH, 4Ch • INT 21h • MAIN ENDS • END MAIN Djamal Rebaïne

  48. Operateur offset: renvoie l’adresse à laquelle est située un label de donnée Exemple: …… Bval db ? Wval1 dw ? Wval2 dd ? … … Si Bval se trouve à l’adresse offset 00404000 (hexa), l’opérateur offset renvoie les valeurs suivantes: MOV AX, offset bval ; AX = 00404000 MOV AX, offset Wval1 ; AX = 00404001 MOV AX, offset Wval2 ; AX = 00404002 Noter que l’opérateur offset utilise un registre de 16 bits. Djamal Rebaïne

  49. TITLE prog2.asm: Exemple sur ROL,Trouver le nombre de ‘1’ dans un mot • Pile segment stack ; déclaration d’un segment de pile – pas nécessaire dans notre cas • dw 100 dup(?) • Pile ends • ;------------------------------------------------------------------------------------------------------------------------------------------------------------ • DATA segment • DATA1 DW 5F97H • COMPTE DB ? • DATA ends • ;------------------------------------------------------------------------------------------------------------------------------------------------------------- • CODE segment • MAIN: • ASSUME CS:CODE, DS:DATA • MOV AX,DATA • MOV DS, AX • XOR BL, BL ; Mettre BL à 0 (ou bien SUB) • MOV DL, 16 ; rotation 16 fois • MOV AX, DATA1 • ENCORE: ROL AX, 1 ; Rotation a gauche (a droite aussi si on préfère) • JNC PROCHAIN ; Test si CF=0 • INC BL ; Si CF = 1, incrémenter le compteur du nombre de ‘1’ • PROCHAIN: DEC DL ; répéter 16 fois • JNZ ENCORE ; encore une fois si ce n’est pas fini • MOV COMPTE, BL ; sauvegarder le résultat dans la case mémoire COMPTE • ;------------------------------------------------------------------------------------------------------------------------------------------------------------ • MOV AH, 4Ch • INT 21h • MAIN ENDS • END MAIN Djamal Rebaïne

  50. ; Segment de données data SEGMENT chaine DB 'Hello world*' data ENDS ; Segment de code code SEGMENT ASSUME DS:data, CS:code main: ; Initialisation du registre de segment de données MOV AX,data MOV DS,AX ; Chargement de l'adresse de la chaîne dans BX ; Il s'agit de l'adresse relative au début du segment MOV BX,offset chaine ; Initialisation compteur MOV CX,0 Repeter: MOV AL,[BX] CMP AL,’*’ ; Test de fin de chaîne JZ finito INC BX ; va de l’avant dans la chaine INC CX ; Incrémentation compteur JMP repeter finito: ; Retour au DOS MOV AH,4CH INT 21H code ENDS END main ; Adresse de lancement Djamal Rebaïne

More Related