Architecture interne du microprocesseur 8086 Bus dadresse Le

Architecture interne du microprocesseur 8086. ü Bus d'adresse: Le 8086 utilise un bus d'adresse de 20 bits, ce qui lui permet d'atteindre 220 = 1 M cases mémoire de 1 octet chacune. Les 16 bits de poids faible du bus d'adresse sont multiplexés avec les 16 bits du bus de données, alors que les 4 bits de poids fort sont eux aussi multiplexés avec 4 bits de statut. ü Organisation de l'espace adressable. 1 Jelassi Khaled Microprocesseurs

Mode d’adressage ü Mode d’adressage • Les instructions peuvent avoir 0, 1, ou 2 opérandes. Exemples : Instructions sans opérande: NOP, STI, CLI, PUSHF, CBW. . . ; Instructions avec une seule opérande: INC, DEC, NEG, NOT. . ; Instructions avec deux opérandes: CMP, ADD, MOV, LEA, XCHG, AND. . . Ø Ø Une opérande peut se trouver dans un registre du 8086, dans un octet, dans un mot 16 bits ou dans un double mot 32 bits. Les opérations peuvent avoir lieu: § entre un registre et un autre registre, § entre un registre et un octet ou un mot en mémoire mais pas entre 2 octets ou 2 mots en mémoire (il faut passer dans ce cas par un registre). Toutefois les instructions de mouvement de chaînes d'octets effectuent "directement" le transfert de mémoire à mémoire (octet par octet ou mot par mot), l'adressage se faisant par les registres DS: SI et ES: DI. 2 Jelassi Khaled Microprocesseurs

Mode d’adressage Les instructions de transfert ü adressage registre à registre. Exemple: MOV AX, BX ADD CH, DL ; opérandes 16 bit ; opérandes 8 bits ü adressage immédiat. Exemples: MOV AX, 0 A 1 EBH ADD CL, 25 OR AH, 11000000 ü adressage direct. ; AX: = valeur hexa A 1 EB ; CL: = CL + 25 ; forcer les 2 bits de fort poids de AH à 1 Exemples: MOV BX, Total MOV DX, ES: Nom ü adressage indirect (ou basé). Exemples: MOV AX, [BX] MOV AX, [BP] ü adressage indexé. Exemple: ü MOV AX, Tab[SI] adressage indirect indexé (ou basé indexé). Exemples: MOV AX, [BX][SI] MOV AX, [BP][SI] ü ; relatif a DS ; Relatif a SS adressage basé indexé avec déplacement. Exemple: MOV AX, Compte[BX][SI] 3 Jelassi Khaled Microprocesseurs

Les Principales Instructions de l’assembleur ü L’instruction LEA Exemples: LEA BX, Tableau[SI] ü L'instruction XCHG. Exemple: XCHG AX, Somme ; chargement de l’adresse de Tableau ; échange des contenus de AX et de Somme ü Les instructions PUSH et POP Exemple: PUSH SI ; empile le contenu de SI Les instructions arithmétiques Les instructions d'addition ADD et ADC. Exemples: ADD AX, BX ADD AX, 0 F 00 H ADC DX, 0 ; AX reçoit AX + BX ; ces 2 instructions additionnent la ; valeur immédiate 0 F 00 H à la paire de ; registres DX: AX (32 bits). Les instructions de soustraction SUB et SBB. SUB AX, DX SBB SI, 100 ; AX reçoit AX-DX ; SI reçoit SI-100 - Carry 4 Jelassi Khaled Microprocesseurs

Les Principales Instructions de l’assembleur ü Les instructions de multiplication: MUL et IMUL Exemples: MUL CL ; AX: =AL * CL résultat sur 16 bits IMUL CX ; DX: AX: = AX * CX résultat sur 32 bits non signe ü Les instructions de division: DIV et IDIV Exemples: IDIV BX ; DX: AX est divisé par BX, le reste est dans DX et le quotient dans AX DIV BL ; AX est divisé par BL, le reste est dans AH, le quotient dans AL. Les instructions de décalage et de rotation ü Les instructions de décalage gauche : SHL Opérande, Nombre Opérande: Opérande = registre / case mémoire Nombre: Nombre = soit la valeur 1, soit la valeur contenue dans CL ü Les instructions de décalage droite : SHR Opérande, Nombre 5 Jelassi Khaled Microprocesseurs

Les principales instructions de l’assembleur ü Les instructions de rotation gauche : ROL Opérande, Nombre ü Les instructions de rotation gauche : ROR Opérande, Nombre ü Les instructions de rotation gauche avec retenu : RCL Opérande, Nombre ü Les instructions de rotation droite avec retenu : RCR Opérande, Nombre ü Les instructions logiques AND, OR et XOR Syntaxe: AND Destination, Source OR Destination, Source XOR Destination, Source Destination = registre/case mémoire Source = registre/valeur immédiate/case mémoire à condition que Destination ne soit pas une case mémoire. Jelassi Khaled Microprocesseurs 6

Les principales instructions de l’assembleur ü Les instructions logiques AND, OR et XOR Exemples: • AND AX, 0 FFF 0 H ; met à 0 les 4 bits de faible poids de AX • OR AL, 1 ; met à 1 le bit de faible poids de AL • AND AX, Masque ; fait un ET logique entre le contenu de AX ; et celui de Masque, le résultat est dans AX • XOR AX, -1 ; fait le complément à 1 de AX • TEST BX, 0 FFFE ; fait un ET logique entre le contenu de BX ; et 0 FFFE sans modifier BX. Permet de ; tester le bit 1 de BX 0 0 1 1 OR 0 1 AND 0 1 XOR 0 1 1 1 0 0 0 1 0 1 1 0 Les instructions de comparaison Syntaxe: CMP Destination, Source TEST Destination, Source Destination = registre / case mémoire Source = registre / case mémoire / valeur Exemples: • CMP AL, CL ; compare AL à CL • CMP AL, 0 ; compare AL à 0 • TEST AL, AH ; ET logique entre AL et AH Remarque: TEST laisse les opérandes du ET logique inchangées; les indicateurs sont positionnés en fonction du résultat du ET logique. 7 Jelassi Khaled Microprocesseurs

Les principales instructions de l’assembleur Les instructions de saut. ü Saut inconditionnel: Exemple: JMP Cas 1 ; saut direct JMP [BX] ; saut indirect à l'adresse contenue dans BX ü Saut conditionnel: Les instructions de saut testant un flag. JC / JNC JS / JNS JO / JNO JP / JNP JZ / JNZ Jump if Carry / not Carry Jump if Sign/ not Sign Jump if Overflow / not Overflow Jump if Parity / not Parity Jump if Zero / not Zero Les instructions de saut sur test arithmétique signé. JE JNE JG JGE JL JLE Jump if Equal Jump if Not Equal Jump if Greater or Equal Jump if Less or Equal Les instructions de saut sur test arithmétique non signé. JA JAE JB JBE Jump if Above or Equal Jump if Below or Equal 8 Jelassi Khaled Microprocesseurs

Les principales instructions de l’assembleur Les instructions de boucle: LOOP, LOOPE et LOOPNE. Syntaxe: LOOPE LOOPNE etiquette Exemple: Sommation des éléments de 0 à 100 Assembleur: _sommation proc near MOV Boucle: MOV ADD LOOP _sommation endp CX, 100 AX, CX Boucle langage ‘C’: int near sommation(void) { int x=0; _CX=100; do { x=x+_CX; _CX=_CX-1; } while (_CX!=0); return(x); 9 Jelassi Khaled Microprocesseurs

Les principales instructions de l’assembleur Les instructions sur chaînes de caractères MOVS (ou MOVSB, MOVSW), CMPS, SCAS, LODS et STOS Exemple: . model small. data table_1 db 5 dup(? ) table_2 dw 4 dup(? ) initial_1 db 1, 2, 5, 4, 9 initial_2 dw 1000, 1002, 1005, 1008. code programme proc near mov ax, @data ; initialisation segment de donnees mov ds, ax mov es, ax mov cx, 5 ; 5 élément à transferer cld ; transfert dans le sens croissant mov si, offset initial_1 ; adresse du tableau source dans SI mov di, offset table_1 ; adresse du tableau destination dans DI rep movsb ; transfert des éléments de initial_1 vers table_1 mov cx, 4 ; nombre d’éléments à transfere mov si, offset initial_2 ; adresse du tableau source dans SI mov di, offset table_2 ; adresse du tableau destination dans DI rep movsw ; transfert des éléments de initial_2 vers table_2 mov ax, 4 c 00 h int 21 h ; Fin du programme et retour au système d’exploitation programme endp end programme 10 Jelassi Khaled Microprocesseurs

Notion de procédure Instructions CALL et RET. L'instruction CALL effectue donc les opérations : - Empiler la valeur de IP. A ce moment, IP pointe sur l'instruction qui suit le CALL. - Placer dans IP l'adresse de la première instruction de la procédure (donnée en argument). Et l'instruction RET : - Dépiler une valeur et la ranger dans IP. Exemple: Calcul PROC near ……… RET Calcul ENDP ; procedure nommee Calcul ; instructions ; derniere instruction ; fin de la procedure CALL address PC (SP) – 1 SP PC (PC) + 3 (PC)H (PC)L (SP) - 2 address RET PCL PCH SP ; Retour de sous-prog ((SP) + 1) ((SP) + 2) (SP) + 2 11 Jelassi Khaled Microprocesseurs

Passage de paramètres aux procédures Passage de paramètres par pile /* Programme EXEMPLE_2. C */ int ma_fonction( int x, int y ) { return (x + y); } void main(void) { int X = 11; int Y = 22; int Res; Res = ma_fonction(X, Y); } _TEXT SEGMENT byte public 'CODE' ASSUME cs: _TEXT _main PROC near PUSH bp MOV bp, sp SUB sp, 6 ; int X = 11; MOV [bp-2], 11 ; int Y = 22; MOV [bp-4], 22 ; int Res ; Res = ma_fonction(X, Y) PUSH word ptr [bp-4] PUSH word ptr [bp-2] CALL _ma_fonction ADD sp, 4 MOV [bp-6], ax ; } MOV sp, bp POP bp RET _main ENDP 12 Jelassi Khaled Microprocesseurs

Passage de paramètres aux procédures Traduction de la procédure ma_fonction en assembleur ASSUME cs: _TEXT _ma_fonction PROC near PUSH bp MOV bp, sp ; return x + y; MOV ax, [bp+4] ADD ax, [bp+6] POP bp RET _ma_fonction ENDP ; En étudiant cet exemple, on constate que : 1. la fonction C ma_fonction() a été traduite par une procédure assembleur nommée _ma_fonction, qui lit ses arguments à partir de la pile (pointeur BP). 2. la fonction ne modifie pas l'état de la pile; 3. Avant l'appel de la fonction (CALL ), les arguments sont empilés (PUSH). Après le retour de la fonction, le pointeur SP est incrémenté pour remettre la pile dans son état précédent (ADD sp, 4 est équivalent à deux instructions POP 2 octets). 4. La valeur retournée par la fonction est passée dans AX (d'où l'instruction MOV [bp-6], ax). Le respect des conventions d'appel de procédures est bien entendu très important si l'on désire mélanger des fonctions C et des procédures en assembleur. 13 Jelassi Khaled Microprocesseurs

Interfaçage assembleur-langage ‘C’ Directives USES et arg near pascal addition PROC NEAR C USES di si, arg 1: WORD, arg 2: WORD, arg 3: WORD push bp ; sauvegarde de BP mov bp, sp ; faire pointer BP sur SP push di ; sauvegarde de di push si ; sauvegarde de si mov si, arg 1 mov di, arg 2 mov ax, arg 3 add ax, di add ax, si pop si ; récupération de si pop di ; récupération de di mov sp, bp ; remettre sp à sa valeur initiale pop bp ; récupération de bp ret 6 ; nettoyage de la pile addition endp ü Appel depuis l’assembleur: Invoke addition 1, 2, 3 ; en cas d’addition de 1, 2 et 3 Appel depuis le langage ‘C’: ü Addition(1, 2, 3); 14 Jelassi Khaled Microprocesseurs

Assembleur et langage ’C’ Appel de procédures ‘C’ depuis l’assembleur Cas de Printf: int Cdecl printf(const char *__format, . . . ); . MODEL small, c . printf PROTO NEAR, ; Model mémoire et conventions d’appel c ; prototype de la fonction printf (VARAG: ; arguments variables) pstring: NEAR PTR BYTE, num 1: WORD, num 2: VARARG. DATA format BYTE '%i %i', 13, 0. CODE _main PROC PUBLIC ; chaîne de caractères à afficher par printf ; Procédure assembleur qui fait appel à printf . INVOKE printf, OFFSET format, ax, bx. . . _main endp END _main ; Fin de la procédure 15 Jelassi Khaled Microprocesseurs

Le compilateur Assembleur ü Un petit programme réalisé avec DEBUG : C: DOS>debug -a 24 A 2 : 0100 ORG 200 24 A 2 : 0200 DB "Bien le bonjour de la part de DEBUG!$" 24 A 2 : 0225 ORG 100 24 A 2 : 0100 MOV AH, 09 24 A 2 : 0102 MOV DX, 200 24 A 2 : 0105 INT 21 24 A 2 : 0107 MOV AX, 4 C 00 24 A 2 : 010 A INT 21 24 A 2 : 010 C [Return] -g ü le même programme écrit pour MASM/TASM : DOSSEG. MODEL SMALL. STACK 50. DATA LIGNE DB "Bien le bonjour de la part de MASM/TASM!$". CODE MOV AX, @DATA MOV DS, AX MOV AH, 09 H MOV DX, OFFSET LIGNE INT 21 H MOV AX, 4 C 00 H INT 21 H END 16 Jelassi Khaled Microprocesseurs

Le compilateur Assembleur ü Déclaration de variables initialisées: . DATA octet db -2 octets db 8 dup(0) chaine db "Bonjour", 0 mot dw 7 FFFh double. Mots dd 2 dup(0 FFFFh) nombre_reel real 4 1. 0 ü Directives de programmation structurée: . DATA buf 1 BYTE "This is a string", '$‘ buf 2 BYTE 100 DUP (? ). CODE sub bx, bx . WHILE (buf 1[bx] != '$') mov al, buf 1[bx] mov buf 2[bx], al inc bx . ENDW ; mise à zero de bx ; Lire un caractère ; le placer dans buf 2 ; incrementation de bx 17 Jelassi Khaled Microprocesseurs

Thèmes de programmation variés Exemples de programmation: Transfert d’éléments d’un tableau vers un autre Calcul de la sommation des éléments d’un tableau et affichage du resultat. Recherche du maximum d’un tableau Recherche du minimum d’un tableau Tri par ordre croissant d’un tableau Remarque: Les procédures (2) et (5) doivent être écrites en langage ‘C’: extern near pascal int TAB 1[]; void pascal TRI (void){ int j, i=0; int aux; do { j=i+1; do { if (TAB 1[i]>=TAB 1[j]) {aux=TAB 1[i]; TAB 1[i]=TAB 1[j]; TAB 1[j]=aux; }; j++; } while(j<=4); i++; }while(i<=3); } extern near pascal int TAB 1[]; int near pascal SOMME (void){ int i=0; int somme =0; do { somme = somme+TAB 1[i]; i++; } while(i<=4) ; printf("%d", somme); return(somme); } Procédure (5) Procédure (2) 18 Jelassi Khaled Microprocesseurs

Thèmes de programmation variés. model small . stack 256 . data TAB 1 dw 3, 2, 1, 5, 4 tab 2 dw 5 dup(? ) message byte 0 ah, 0 dh, ' le resultat est: %d', 0 . code public TAB 1 extern SOMME: far ; procédure ‘C’ extern _printf: far ; procédure ‘C’ extern TRI: near ; procédure ‘C’ transfert proc near mov si, offset tab 1 mov di, offset tab 2 push ds pop es mov cx, 5 rep movsw ret transfert endp Procédure transfert minimum proc near mov si, offset tab 1 mov bx, [si] mov cx, 5 boucle: cmp bx, [si] jl suite mov bx, [si] suite: add si, 2 loop boucle mov ax, bx ret minimum endp Jelassi Khaled Initialisation Procédure minimum 19 Microprocesseurs

Thèmes de programmation variés maximum proc near mov si, offset tab 1 mov bx, [si] mov cx, 5 boucle: cmp bx, [si] jg suite mov bx, [si] suite: add si, 2 loop boucle mov ax, bx ret maximum endp Procédure maximum _main proc near mov ax, @data mov ds, ax call transfert call minimum call maximum call SOMME push ax push ds mov bx, offset message push bx call _printf call TRI mov ah, 4 ch int 21 h _main endp end _main Programme principal Appel de printf 20 Jelassi Khaled Microprocesseurs

Traduction en assembleur de procédures ‘C’ ü Procédure SOMME 48 E 3: 1 C 44 55 PUSH BP 48 E 3: 1 C 45 8 BEC MOV BP, SP 48 E 3: 1 C 47 83 EC 02 SUB SP, +02 48 E 3: 1 C 4 A 56 PUSH SI 48 E 3: 1 C 4 B 33 F 6 XOR SI, SI 48 E 3: 1 C 4 D C 746 FE 0000 MOV Word Ptr [BP-02], 0000 do {48 E 3: 1 C 52 8 BDE MOV BX, SI 48 E 3: 1 C 54 D 1 E 3 SHL BX, 1 48 E 3: 1 C 56 8 B 46 FE MOV AX, Word Ptr [BP-02] 48 E 3: 1 C 59 03870000 ADD AX, Word Ptr [BX+0000] 48 E 3: 1 C 5 D 8946 FE MOV Word Ptr [BP-02], AX 48 E 3: 1 C 63 46 INC SI 48 E 3: 1 C 64 83 FE 04 CMP SI, +04 48 E 3: 1 C 67 7 EE 9 JLE 1 C 52 48 E 3: 1 C 69 FF 76 FE PUSH Word Ptr [BP-02] 48 E 3: 1 C 6 C 1 E PUSH DS 48 E 3: 1 C 6 D B 8 C 400 MOV AX, 00 C 4 48 E 3: 1 C 70 50 PUSH AX 48 E 3: 1 C 71 90 NOP 48 E 3: 1 C 72 0 E PUSH CS 48 E 3: 1 C 73 E 875 E 8 CALL 04 EB 48 E 3: 1 C 76 83 C 406 ADD SP, +06 48 E 3: 1 C 79 8 B 46 FE MOV AX, Word Ptr [BP-02] 48 E 3: 1 C 7 C EB 00 JMP 1 C 7 E 48 E 3: 1 C 7 E 5 E POP SI 48 E 3: 1 C 7 F 8 BE 5 MOV SP, BP 48 E 3: 1 C 81 5 D POP BP 48 E 3: 1 C 82 CB RETF ; int i=0; ; int somme =0; ; somme+TAB 1[i]; ; i++ ; while(i<=4) ; Appel de printf ; return(somme); 21 Jelassi Khaled Microprocesseurs