Conception et exploitation des processeurs

Dimension: px

Commencer à balayer dès la page:

Download "Conception et exploitation des processeurs"

Jérôme Larouche
il y a 8 ans
Total affichages :

1 Chargés de cours : Frédéric Pétrot et Sébastien Viardot Année universitaire Structure du cours C1 C2 C3 au VHDL aux langages d'assemblage pour les ISA x86 et MIPS Conventions pour les appels de fonctions en assembleur x86 et MIPS 2 / à l'assembleur x86 3 à l'assembleur MIPS 4 3 / 32

d'assemblage pour les ISA x86 et MIPS Conventions pour les appels de

2 Étude du langage d'assemblage de 2 processeurs Intel x86 (pentium) ISA hégémonique, desktops, laptops et serveurs Constructeur Intel a, compatibilité ascendante depuis 1979 Machine CISC : Complex Instruction Set Computer a wwwintelcom MIPS R3000 ISA symbolique RISC : Reduced Instruction Set Computer Constructeur MIPS a, 1988 Importante part de marché dans l'embarqué (networking en particulier), mais nettement moins que ARM b, favori des smartphones et autres tablettes a wwwmipscom b wwwarmcom 4 / 32 CISC Intel x86 jeu d'instruction prolique, 425 en 2004 sans les extensions multimédia et 64 bits destiné à être programmé par un humain vise un code compréhensible et dense nombreux modes d'adressage opérandes peuvent être des cases mémoire registres spécialisés par le matériel cherche à optimiser la taille du programme par l'utilisation d'instructions complexes 5 / 32 RISC MIPS R3000 jeu d'instruction minimaliste, 65 dans le R3000, moins de 80 dans ses évolutions destiné à être la cible d'un compilateur instruction de taille xe menant à une occupation mémoire du programme plus grande registres à usage général, utilisation logicielle conventionnelle un mode d'adressage unique, architecture load/store opérande = registre 6 / 32

particulier), mais nettement moins que ARM b, favori des smartphones et autres tablettes a wwwmipscom b wwwarmcom 4 / 32 CISC Intel x86 jeu d'instruction prolique, 425 en 2004 sans les extensions

3 Programmation assembleur Langage traduit en binaire compréhensible par la machine Transformation fondamentalement syntaxique caractéristiques diérentes important de connaître les deux types Attention! Ne pas confondre les 2 assembleurs!!! 7 / 32 à l'assembleur x à l'assembleur x86 3 à l'assembleur MIPS 4 8 / 32 à l'assembleur x86 ISA x86 : Registres Registre bits bits Remarque 32 bits 15 à 8 7 à 0 %eax %ax parfois spécialisé %ah %al %ebx %bx parfois spécialisé %bh %bl %ecx %cx parfois spécialisé %ch %cl %edx %dx parfois spécialisé %dh %dl %esi %si parfois spécialisé %edi %di parfois spécialisé %esp %sp pointeur de pile %ebp %bp pointeur de contexte %eip %ip pointeur d'instruction %eflags %flags registre des indicateurs Considérés comme registres à usage général durant ce cours Attention, ils peuvent être utilisés implicitement par certaines instructions que nous n'étudierons pas 9 / 32

!! 7 / 32 à l'assembleur x86 1 2 à l'assembleur x86 3 à l'assembleur MIPS 4 8 / 32 à l'assembleur x86 ISA x86 : Registres Registre bits bits Remarque 32 bits 15 à 8 7 à 0 %eax %ax parfois spécialisé

4 à l'assembleur x86 ISA x86 Adresses Sur 32 bits, de 0x0000_0000 à 0xFFFF_FFFF Données Sur 32, 16 ou 8 bits Instruction contient information de taille Organisation mémoire little endian Valeur 0x stockée en 0xDEAD_BEEC Adresse 0xDEADBEEC 0xDEADBEED 0xDEADBEEE 0xDEADBEEF Valeur 0x78 0x56 0x34 0x12 10 / 32 à l'assembleur x86 Sous-ensemble pour commencer, Suxes Précisent la taille de la valeur manipulée par l'instruction l (long) : 32 bits w (word) : 16 bits b (byte) : 8 bits Copies entre éléments mémorisants mov suxe source, destination entre registres : movl %eax, %ebx registre vers mémoire : movb %al, v ebx eax mem[v] 70 al mémoire vers registre : movw u, %bx bx 150 mem[u] 150 constante vers registre : movb $45, %dh dh const vers mém : movl $0x1234, t mem[t] 310 0x mémoire vers mémoire : impossible 11 / 32 à l'assembleur x86 Les plus courantes, Arithmétiques addw %ax, %bx bx bx + ax subb $20, %al al al 20 negl %eax eax eax shll $1, %eax eax eax shrl $4, %ebx ebx 0 4 ebx 314 sarl $12, %ebx ebx ebx Logiques andw $0xD0D0, %cx orb $0xFA, %al xorl %eax, %eax notl %ecx cx cx and 0xD0D0 al al or 0xFA eax eax xor eax ecx ecx 12 / 32

la valeur manipulée par l'instruction l (long) : 32 bits w (word) : 16 bits b (byte) : 8 bits Copies entre éléments mémorisants mov suxe source, destination entre registres : movl %eax, %ebx registre

5 à l'assembleur x86 Les plus courantes, Comparaisons cmpl $5, %eax eags ags(eax 5) testb $0x01, %bl eags ags(1 and bl) Branchements Décision prise en fonction du contenu des ags jmp label jxx label ip label adresse instruction suivante ip label si xx est vraie, si non xx 13 / 32 à l'assembleur x86 Les plus courantes, Branchements Comparaison Entiers naturels Entiers signés > ja, jnbe jg, jnle jae, jnb jge, jnl < jb, jnae jl, jnge jbe, jna jle, jng = je, jz jne, jnz n not, a above, b below, g greater, l less, e equal, z zero 14 / 32 à l'assembleur MIPS 1 2 à l'assembleur x86 3 à l'assembleur MIPS 4 15 / 32

plus courantes, Branchements Comparaison Entiers naturels Entiers signés > ja, jnbe jg, jnle jae, jnb jge, jnl < jb, jnae jl, jnge jbe, jna jle, jng =

6 à l'assembleur MIPS ISA MIPS Registre Remarque 32 bits $0 registre trash (peut être écrit, zéro en lecture) $1-$30 non spécialisés $31 contient l'adresse de retour de fonction Adresses Sur 32 bits, de 0x0000_0000 à 0xFFFF_FFFF Données Sur 32, 16 ou 8 bits Seules les instructions de chargement ou de stockage mémoire contiennent information de taille Organisation mémoire little endian 16 / 32 à l'assembleur MIPS ISA MIPS Sous-ensemble pour commencer, Suxes pour les chargements/stockages mémoire Précisent la taille de la valeur manipulée par l'instruction w (word) : 32 bits h (half) : 16 bits b (byte) : 8 bits Copies entre éléments mémorisants entre registres : add $3, $2, $0 $3 $2 reg vers mém : sw $12, 96($5) mem[$5 + 96] 310 $12 mém vers reg : lb $2, -15($1) $ mem[$1 15] 70 const vers reg : ori $3, $0, 0xBEEF $ xBEEF const vers demi-mot poids fort reg : lui $4, 0xDEAD $4 0xDEAD 0 16 const vers mém : impossible mém vers mém : impossible 17 / 32 à l'assembleur MIPS Les plus courantes, Arithmétiques add $4, $12, $23 $4 $12 + $23 sub $14, $9, $30 $14 $9 $30 addi $2, $17, -1 $2 $17 1 sllv $1, $12, $7 $1 $12 31 $ $740 sra $4, $3, 9 $4 $ $3 319 Logiques and $14, $9, $30 $14 $9 and $30 ori $4, $3, 0xFF $4 $3 or x00FF xori $1, $12, 0xAAAA $1 $12 xor xAAAA nor $4, $12, $23 $4 $12 or $23 18 / 32

l'assembleur MIPS ISA MIPS Sous-ensemble pour commencer, Suxes pour les chargements/stockages mémoire Précisent la taille de la valeur manipulée par l'instruction w (word) : 32 bits h (half) : 16

7 à l'assembleur MIPS Les plus courantes, Comparaisons sltu $4, $12, $23 slti $2, $17, -1 $ si 0 $12 < 0 $23, 0 32 sinon $ si $17 < xFFFF, 0 32 sinon Branchements inconditionnels (sauts) j label pc label jr $31 pc $31 19 / 32 à l'assembleur MIPS Les plus courantes, Branchements conditionnels beq $2, $3, label pc label si $2 = $3, adresse instruction suivante sinon bne $2, $3, label pc label si $2 $3, adresse instruction suivante sinon blez $2, label pc label si $2 0, adresse instruction suivante sinon bgtz $2, label pc label si $2 > 0, adresse instruction suivante sinon 20 / à l'assembleur x86 3 à l'assembleur MIPS 4 21 / 32

label pc label si $2 = $3, adresse instruction suivante sinon bne $2, $3, label pc label si $2 $3, adresse instruction suivante sinon blez $2, label pc label si $2

8 if C : int x = ; if (x == 5) x += 2; else x -= 4; x86 : ; x est dans %eax if: cmpl $5, %eax jne else addl $2, %eax jmp endif else: subl $4, %eax endif: MIPS : ; x est dans $4 if: li $1, 5 bne $4, $1, else addi $4, $4, 2 j endif else: addi $4, $4, -4 endif: 22 / 32 while C : int x = ; while (x > 5) x -= 1; x86 : while: cmpl $5, %eax jle endwhile subl $1, %eax jmp while endwhile: MIPS : while: slti $1, $4, 6 bne $1, $0, endwhile addi $4, $4, -1 j while endwhile: 23 / 32 for, équivalent structuré du while x86 : C : int x = ; unsigned int i; for (i = 0; i < 5; i++) x = x + 4; movl $0, %ecx for: cmpl $5, %ecx jae endfor addl $4, %eax addl $1, %ecx jmp for endfor: MIPS : li $2, $0 for: slti $1, $2, 5 beq $1, $0, endfor addi $4, $4, 4 addi $2, $2, 1 j for endfor: 24 / 32

: while: slti $1, $4, 6 bne $1, $0, endwhile addi $4, $4, -1 j while endwhile: 23 / 32 for, équivalent structuré du while x86 : C : int x = ; unsigned int i; for (i = 0; i < 5; i++) x = x + 4;

9 Premier programme : pgcd C : int main(void) unsigned a, b; a = 15; b = 10; while (a!= b) if (a < b) b = b - a; else a = a - b; return 0; x86 : globl main main: enter $0, $0 movl $15, %ecx movl $10, %edx while: cmpl %ecx, %edx je endwhile if: jb else subl %ecx, %edx jmp endif else: subl %edx, %ecx endif: jmp while endwhile: leave movl $0, %eax ret MIPS : globl main main: addi $4, $0, 15 addi $5, $0, 10 while: beq $4, $5, endwhile if: slt $1, $4, $5 beq $1, $0, else sub $5, $5, $4 j endif else: sub $4, $4, $5 endif: j while endwhile: addi $2, $0, 0 jr $31 25 / 32 Éclaircissements globl main étent la visibilité de l'étiquette main aux autres chiers prologue et épilogue de fonction minimaux : x86 enter $0,$0 leave ; retourne zéro movl $0, %eax ret MIPS ; retourne zéro addi $2, $0, 0 ; $31 contient l'adresse ; de retour de la fonction jr $31 Permet de faire tourner vos premiers programmes Clarication complète au Cours 3! 26 / 32 Vue mémoire 1 2 à l'assembleur x86 3 à l'assembleur MIPS 4 27 / 32

subl %edx, %ecx endif: jmp while endwhile: leave movl $0, %eax ret MIPS : globl main main: addi $4, $0, 15 addi $5, $0, 10 while: beq $4, $5, endwhile if: slt $1, $4, $5 beq $1, $0, else sub $5, $5,

10 Vue mémoire Exécutable en mémoire Exécutable constitué de 4 parties Code Directive text En lecture seulement Commence en bas de la mémoire Données connues statiquement Directive data Variables globales initialisées au lancement En lecture/écriture Directive lcomm Variables globales non explicitement initialisées, initialisées à zéro au lancement En lecture/écriture 28 / 32 Vue mémoire Exécutable en mémoire Données connues statiquement Directive rodata Constantes initialisées au lancement En lecture seulement Placées à la suite du code Données allouées dynamiquement Pile Variables globales dont les adresses sont dénies à l'exécution Placées à la suite des données initialisées Gérée par le matériel et/ou le logiciel lors des appels de fonctions Commence à la n de la mémoire 29 / 32 Vue mémoire Résumé 0xFFFFFFFF 0x 0x pile tas bss 0x data 0x données rodata 0x 0x code text 0x 0x x x 0x code text 0x rodata 0x données data bss tas 0x 0x pile 0x 0xFFFFFFFF 30 / 32

Exécutable en mémoire Données connues statiquement Directive rodata Constantes initialisées au lancement En lecture seulement Placées à la suite du code Données allouées dynamiquement Pile Variables

11 Informations techniques 1 2 à l'assembleur x86 3 à l'assembleur MIPS 4 31 / 32 Informations techniques Informations techniques Nom de chier Historiquement xs : assembleur xs : préprocesseur C avant assembleur Maintenant comportement identique : cpp+asm Génération du binaire gcc -gstabs -o x xs -gstabs : ajoute les information permettant de déverminer -o file : donne le nom file au chier produit 32 / 32

avant assembleur Maintenant comportement identique : cpp+asm Génération du binaire gcc -gstabs -o x

Documents pareils

Rappels d architecture

Assembleur Rappels d architecture Un ordinateur se compose principalement d un processeur, de mémoire. On y attache ensuite des périphériques, mais ils sont optionnels. données : disque dur, etc entrée