Architecture interne du microprocesseur 8086.

Présentation au sujet: "Architecture interne du microprocesseur 8086."— Transcription de la présentation:

1 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 = 1M 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. Microprocesseurs

2 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. Microprocesseurs

3 Mode d’adressage Les instructions de transfert
adressage registre à registre. Exemple: MOV AX, BX ; opérandes 16 bit ADD CH, DL ; opérandes 8 bits adressage immédiat. Exemples: MOV AX, 0A1EBH ; AX:= valeur hexa A1EB ADD CL, 25 ; CL:= CL + 25 OR AH, ; forcer les 2 bits de fort poids de AH à 1 adressage direct. 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] ; relatif a DS MOV AX,[BP][SI] ;Relatif a SS adressage basé indexé avec déplacement. Exemple: MOV AX,Compte[BX][SI] Microprocesseurs

4 Les Principales Instructions de l’assembleur
L’instruction LEA Exemples: LEA BX,Tableau   ;chargement de l’adresse de Tableau LEA BX,Tableau[SI] L'instruction XCHG. Exemple: XCHG AX,Somme ;é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 ;AX reçoit AX + BX ADD AX,0F00H ;ces 2 instructions additionnent la ADC DX,0 ;valeur immédiate 0F00H à la paire de ;registres DX:AX (32 bits). Les instructions de soustraction SUB et SBB. SUB AX,DX ;AX reçoit AX-DX SBB SI, ;SI reçoit SI Carry Microprocesseurs

5 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 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 Microprocesseurs

6 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. Microprocesseurs

7 Les principales instructions de l’assembleur
Les instructions logiques AND, OR et XOR Exemples: AND AX,0FFF0H ;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,0FFFE ; fait un ET logique entre le contenu de BX ;et 0FFFE sans modifier BX. Permet de ;tester le bit 1 de BX OR AND XOR 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. Microprocesseurs

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

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

10 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 ,1002,1005,1008 .code programme proc near mov ; 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,4c00h int 21h ; Fin du programme et retour au système d’exploitation programme endp end programme Microprocesseurs

11 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 ; procedure nommee Calcul ……… ; instructions RET ; derniere instruction Calcul ENDP ; fin de la procedure CALL address PC (PC) + 3 (SP) (PC)H (SP) – 1 (PC)L SP (SP) - 2 PC address RET ;Retour de sous-prog PCL ((SP) + 1) PCH ((SP) + 2) SP (SP) + 2 Microprocesseurs

12 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 Microprocesseurs

13 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. Microprocesseurs

14 Interfaçage assembleur-langage ‘C’
Directives USES et arg near pascal addition PROC NEAR C USES di si, arg1:WORD, arg2:WORD, arg3: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,arg1 mov di,arg2 mov ax,arg3 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); Microprocesseurs

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

16 Le compilateur Assembleur
Un petit programme réalisé avec DEBUG : C:\DOS>debug -a 24A2 : 0100 ORG 200 24A2 : 0200 DB "Bien le bonjour de la part de DEBUG!$" 24A2 : 0225 ORG 100 24A2 : 0100 MOV AH,09 24A2 : 0102 MOV DX,200 24A2 : 0105 INT 21 24A2 : 0107 MOV AX,4C00 24A2 : 010A INT 21 24A2 : 010C [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 MOV DS,AX MOV AH,09H MOV DX,OFFSET LIGNE INT 21H MOV AX,4C00H END Microprocesseurs

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

18 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 TAB1[]; void pascal TRI (void){ int j,i=0; int aux; do { j=i+1; do { if (TAB1[i]>=TAB1[j]) {aux=TAB1[i]; TAB1[i]=TAB1[j]; TAB1[j]=aux;}; j++; } while(j<=4); i++; }while(i<=3); } int near pascal SOMME (void){ int i=0; int somme =0; do { somme = somme+TAB1[i]; i++; } while(i<=4) ; printf("%d",somme); return(somme); Procédure (5) Procédure (2) Microprocesseurs

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

20 Thèmes de programmation variés
maximum proc near mov si,offset tab1 mov bx,[si] mov cx,5 boucle:cmp bx,[si] jg suite suite: add si,2 loop boucle mov ax,bx ret maximum endp _main proc near mov 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,4ch int 21h _main endp end _main Procédure maximum Programme principal push ax push ds mov bx, offset message push bx call _printf Appel de printf Microprocesseurs

21 Traduction en assembleur de procédures ‘C’
Procédure SOMME 48E3:1C PUSH BP 48E3:1C45 8BEC MOV BP,SP 48E3:1C47 83EC SUB SP,+02 48E3:1C4A PUSH SI 48E3:1C4B 33F XOR SI,SI ; int i=0; 48E3:1C4D C746FE MOV Word Ptr [BP-02],0000 ; int somme =0; do {48E3:1C52 8BDE MOV BX,SI 48E3:1C54 D1E SHL BX,1 48E3:1C56 8B46FE MOV AX,Word Ptr [BP-02] 48E3:1C ADD AX,Word Ptr [BX+0000] ; somme+TAB1[i]; 48E3:1C5D 8946FE MOV Word Ptr [BP-02],AX 48E3:1C INC SI ; i++ 48E3:1C64 83FE CMP SI,+04 ; while(i<=4) ; 48E3:1C67 7EE JLE C52 48E3:1C69 FF76FE PUSH Word Ptr [BP-02] 48E3:1C6C 1E PUSH DS 48E3:1C6D B8C MOV AX,00C4 48E3:1C PUSH AX 48E3:1C NOP 48E3:1C72 0E PUSH CS 48E3:1C73 E875E CALL EB 48E3:1C76 83C ADD SP,+06 48E3:1C79 8B46FE MOV AX,Word Ptr [BP-02] ; return(somme); 48E3:1C7C EB JMP C7E 48E3:1C7E 5E POP SI 48E3:1C7F 8BE MOV SP,BP 48E3:1C81 5D POP BP 48E3:1C82 CB RETF Appel de printf Microprocesseurs