1 / 21

Architecture interne du microprocesseur 8086.

Architecture interne du microprocesseur 8086. Bus d'adresse:

ruby-tyler
Download Presentation

Architecture interne du microprocesseur 8086.

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. 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: MOVAX, BX ; opérandes 16 bit ADDCH, DL ; opérandes 8 bits • adressage immédiat. Exemples: MOVAX, 0A1EBH ; AX:= valeur hexa A1EB ADDCL, 25 ; CL:= CL + 25 ORAH,11000000 ; forcer les 2 bits de fort poids de AH à 1 • adressage direct. Exemples: MOVBX,Total MOVDX,ES:Nom • adressage indirect (ou basé). Exemples: MOVAX,[BX] MOVAX,[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 LEABX,Tableau[SI] • L'instruction XCHG. Exemple: XCHGAX,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,100 ;SI reçoit SI-100 - Carry Microprocesseurs

  5. Les Principales Instructions de l’assembleur • Les instructions de multiplication: MUL et IMUL Exemples: MULCL ; AX:=AL * CL résultat sur 16 bits IMULCX ; DX:AX:= AX * CX résultat sur 32 bits non signe • Les instructions de division: DIV et IDIV Exemples: IDIVBX ;DX:AX est divisé par BX, le reste est dans DX et le quotient dans AX DIVBL ;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 :SHLOpé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 :SHROpé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: ANDDestination,Source ORDestination,Source XORDestination,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. 0 1 1 1 0 0 0 1 0 1 1 0 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 • ORAL,1 ;met à 1 le bit de faible poids de AL • ANDAX,Masque ;fait un ET logique entre le contenu de AX ;et celui de Masque, le résultat est dans AX • XORAX,-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 0 0 1 1 0 0 1 1 0 0 1 1 OR 0 1 0 1 AND 0 1 0 1 XOR 0 1 0 1 • Les instructions de comparaison Syntaxe: CMPDestination,Source TESTDestination,Source Destination = registre / case mémoire Source = registre / case mémoire / valeur • Exemples: • CMPAL,CL ; compare AL à CL • CMPAL,0 ; compare AL à 0 • TESTAL,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: JMPCas1 ;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 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,4c00h int 21h ; Fin du programme et retour au système d’exploitation programme endp end programme Microprocesseurs

  11. Calcul PROC near ; procedure nommee Calcul ……… ; instructions RET ; derniere instruction Calcul ENDP ; fin de la procedure 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: 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 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 ; • Traduction de la procédure ma_fonction en assembleur En étudiant cet exemple, on constate que : 1. la fonction Cma_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’ Cas de Printf: int Cdecl printf(const char *__format, ...); • Appel de procédures ‘C’ depuis l’assembleur .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 .DATAformat 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 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 • Un petit programme réalisé avec DEBUG : • 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,09H MOV DX,OFFSET LIGNE INT 21H MOV AX,4C00H INT 21H 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); } extern near pascal int TAB1[]; 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 Initialisation .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 si,offset tab1 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 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 mov bx,[si] suite: add si,2 loop boucle mov ax,bx ret maximum endp _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,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:1C44 55 PUSH BP 48E3:1C45 8BEC MOV BP,SP 48E3:1C47 83EC02 SUB SP,+02 48E3:1C4A 56 PUSH SI 48E3:1C4B 33F6 XOR SI,SI ; int i=0; 48E3:1C4D C746FE0000 MOV Word Ptr [BP-02],0000 ; int somme =0; do {48E3:1C52 8BDE MOV BX,SI 48E3:1C54 D1E3 SHL BX,1 48E3:1C56 8B46FE MOV AX,Word Ptr [BP-02] 48E3:1C59 03870000 ADD AX,Word Ptr [BX+0000] ; somme+TAB1[i]; 48E3:1C5D 8946FE MOV Word Ptr [BP-02],AX 48E3:1C63 46 INC SI ; i++ 48E3:1C64 83FE04 CMP SI,+04 ; while(i<=4) ; 48E3:1C67 7EE9 JLE 1C52 48E3:1C69 FF76FE PUSH Word Ptr [BP-02] 48E3:1C6C 1E PUSH DS 48E3:1C6D B8C400 MOV AX,00C4 48E3:1C70 50 PUSH AX 48E3:1C71 90 NOP 48E3:1C72 0E PUSH CS 48E3:1C73 E875E8 CALL 04EB 48E3:1C76 83C406 ADD SP,+06 48E3:1C79 8B46FE MOV AX,Word Ptr [BP-02] ; return(somme); 48E3:1C7C EB00 JMP 1C7E 48E3:1C7E 5E POP SI 48E3:1C7F 8BE5 MOV SP,BP 48E3:1C81 5D POP BP 48E3:1C82 CB RETF Appel de printf Microprocesseurs

More Related