Architecture externe d’un processeur (Exemple de MIPS)

1 IntroductionL'architecture externe d’un processeur représente ce que doit connaître un

programmeur souhaitant programmer directement avec le langage du processeur. Ce langage, dit lagunage machine, est représenté par des chaînes binaires propres à chaque processeur. Pour manipuler facilement ce langage, les programmeurs utilisent une forme plus conviviale dite langage d’assemblage. Le langage d’assemblage est équivalent au langage machine sauf qu’il utilise des représentations mnémoniques des opérations telles que Add, Mouv, Jump, …etc, au lieu de manipuler des chaînes binaires. La programmation d’un processeur en assembleur est, en générale, plus complexe mais elle permet d’écrire des programmes plus rapides exploitant les performances maximales du processeur. Elle permet, entre autres, de réaliser des compilateurs permettant de traduire un programme écrit en langage évolué (Pascal, C, etc) en un programme en langage machine. L’architecture externe d’un processeur concerne les éléments suivants :- Les registres visibles.- L'adressage de la mémoire.- Le jeu d'instructions.- Les mécanismes de traitement des interruptions et des exceptions

2 Présentation du processeur MIPS R3000Dans le but d’illustrer les différents concepts, nous prendrons comme exemple le

processeur MIPS R3000 qui est un processeur 32 bits. Son jeu d'instructions est de type RISC (Reduced Instruction Set Computer). Il existe plusieurs réalisations industrielles de cette architecture (SIEMENS, NEC, LSI LOGIC, SILICON GRAPHICS, etc...). Ce processeur est suffisamment simple pour présenter les principes de base, et suffisamment puissante pour supporter un système d'exploitation multi-tâches tel que UNIX.

2-1 Registres visibles du MIPS-R3000MIPS-R3000 est un microprocesseur moderne possédant des mécanismes de

protection et de multi-tâches (permettant d’exécuter plusieurs tâches à la fois). Le processeur possède deux modes de fonctionnement : utilisateur/superviseur. Le mode superviseur est le mode protégé dans lequel les programmes du système d’exploitation s’exécutent. Le mode utilisateur est le mode dans lequel les programmes des utilisateurs s’exécutent. Chacun des modes dispose de ses propres registres visibles.

a) Registres non protégésLe processeur possède 35 registres manipulés par les instructions standard (c'est-à-dire

les instructions qui peuvent s’exécuter aussi bien en mode utilisateur qu’en mode superviseur).

Les 32 registres à usage général ($R0 à $R31)Ce sont des registres de 32 bits utilisés par les instructions pour stocker les opérandes en vue de réaliser les opérations arithmétiques et logiques. Le registre $R0 en particulier retourne toujours un zéro quel que soit ce qu’on y enregistre. Le registre $R31 est utilisé pour sauvegarder l’adresse de retour dans le cas d’appel de procédure.

Le compteur programme $PC (compteur ordinal)Ce registre contient l'adresse de l'instruction en cours d'exécution. Sa valeur est modifiée par toutes les instructions.

Les registres HI et LO Ces registres à 32 bits sont utilisés pour la multiplication ou la division pour stocker le résultat de l’opération

b) Registres protégésL'architecture MIPS définit 32 registres (numérotés de 0 à 31), qui ne sont accessibles,

en lecture comme en écriture, que par les instructions privilégiées (c'est à dire les instructions qui ne peuvent être exécutées qu'en mode superviseur). On dit qu'ils appartiennent au "coprocesseur système". En particuliers nous avons :

Le registre d'état SR (Status Register)Il contient en particulier le bit qui définit le mode : superviseur ou utilisateur, ainsi que les bits de masquage des interruptions

Registre de cause CR (Cause Register)En cas d'interruption ou d'exception, son contenu définit la cause pour laquelle on fait appel au programme de traitement des interruptions et des exceptions.

Registre d'exception EPC (Exception Program Counter).Il contient l'adresse de retour (PC + 4) en cas d'interruption. Il contient l'adresse de l'instruction fautive (PC) en cas d'exception.

Registre d'adresse illégale BAR (Bad Address Register).En cas d'exception de type "adresse illégale", il contient la valeur de l'adresse mal formée.

3 Organisation de la mémoireL’organisation de la mémoire diffère d’un processeur à un autre. La différence réside

dans la taille affectée aux bus de données et d’adresses. La taille du bus de données est d’une importance capitale. Elle détermine la taille du mot mémoire. En générale, la taille est de 4, 8, 16, 32, 64 ou 128 bits.

Les processeurs actuels permettent d’adresser des mots de tailles variables. Un processeur 32 bits peut, par exemple, charger des mots de 32 bits mais peut aussi charger des mots de tailles plus petites. En générale, le plus petit objet que le processeur peut charger est l’octet. Le processeur est dit, dans ce cas, adressable par octet. Les mots de tailles plus grandes sont stockés comme une séquence d’octets. L’adresse du mot correspond à l’adresse du premier octet de la séquence. Il existe deux choix pour l’ordre dans lequel les octets d’un objet sont stockés en mémoire (un entier sur 32 bits par exemple) ; le poids fort d’abord (Big-Endian) ou le plus faible d’abord (Little-Endian). Dans le Big-Endian, l’adresse du mot correspond à l’adresse de l’octet des poids forts. Les octets de poids faibles suivent ceux de poids forts. Dans le Little-Endian, l’adresse du mot correspond à l’adresse de l’octet de poids faibles et les octets de poids forts suivent ceux de poids faibles. La figure III-1 illustre les deux principes :

L’adresse du mot est X dans les deux cas

Figure 1 organisation Big-Endian et Little-Endian

3-1 Organisation mémoire de MIPS-R3000MIPS-R3000, est un processeur ayant un bus de données de 32 bits et un bus d’adresse

de 32 bits également. Il est adressable par octet selon le mode Little-Endian. Les instructions sont toutes codées sur 32 bits. Les données sont codées sur un mot (4 octets consécutifs), demi-mot (2 octets consécutifs), ou sur un octet. Une instruction ou un mot doit toujours être alignée sur une adresse qui est un multiple de 4 car elle est formée de 4 octets. Un demi-mot doit être aligné sur une adresse qui est multiple de 2. Le processeur passe en exception si on tente d’accéder à un objet non aligné.

L’espace mémoire est découpé en 2 segments identifiés par le bit de poids fort de l’adresse (31eme bit). Un 0 sur ce bit correspond au segment utilisateur et un 1 correspond au segment système. Quand le processeur est en mode superviseur, les 2 segments sont accessibles. Quand le processeur est en mode utilisateur, seul le segment utilisateur est accessible. Le processeur part en exception si une instruction essaye d'accéder à la mémoire avec une adresse correspondant au segment système alors que le processeur est en mode utilisateur.

En général, un programme est composé d’une section instruction, d’une section données, et d’une pile utilisée pour réaliser des appels de procédures et de fonctions. Par convention, l’espace mémoire du MIPS R3000 est décomposé selon cette structure comme indiquée dans la figure III-2. (Les adresses sont indiquées en hexadécimal).

La section .text contient le code exécutable en mode utilisateur. Elle est implantée conventionnellement à l’adresse 0x00400000. La section .data contient les données globales manipulées par le programme utilisateur. Elle est implantée conventionnellement à l’adresse 0x10000000. Sa taille peut déborder sur la section de pile utilisateurs .stack, implantée à l’adresse 0x7FFFFFFF et qui s’étend vers les adresses décroissantes. Le mode superviseur dispose aussi de trois sections contenant les programmes, les données et la pile du système d’exploitation.

Octet

0LSB31 MSB

x x +1 x +2 x +3

Big-Endian

Octet

0LSB31 MSB

x x +1 x +2 x +3

Little-Endian

Bus de données(32 bits)

0x000000000x00000004

.

.

.0x003FFFFC

.

.

.

0x00400000

.

.

.

0x0FFFFFFC0x10000000

.

.

.0x7FFFFFFC

.

.

.

0x80000000

0xBFFFFFFC

.

.

.

0xC0000000

.

.

.0xFFFFEFFC

.

.

.

0xFFFFF000

0xFFFFFFFC

Octet 0

Segment utilisateur31eme bit = 0

Segment système31eme bit = 1

Octet 1 Octet 2 Octet 3

Réservé

Section programme utilisateurs(.TEXT)

Section données utilisateurs(.DATA)

Section pile utilisateurs(.STACK)

Section programme système(.KTEXT)

Section données système(.DATA)

Section pile système(.KSTACK)

Réservé

Figure 2 Organisation mémoire du MIPS-R3000

4 Modes d’adressageL’accès à la mémoire se fait par une adresse spécifiée dans un champ (une partie) de

l’instruction. Il arrive que l’espace mémoire adressé par le processeur soit plus grand que la capacité d’adressage du champ de l’instruction. Il est aussi fréquent de manipuler des structures complexes tels que les tableaux et les enregistrements nécessitant des techniques d’adressage particulières. Il existe en effet plusieurs modes d’adressages. Les plus connus sont les suivants1) Adressage immédiat

Ce mode est utilisé pour manipuler des constantes connues sans passer par la mémoire pour les chercher. L’opérande est une valeur immédiate se trouvant directement dans l’instructionExemple Load RA, #10 ; mettre la valeur immédiate 10 dans le registre A

2) Adressage direct

L’adresse de l’information à chercher se trouve directement dans l’instruction. Ce mode est le plus simple mais l’espace mémoire accessible dépend de la taille du champs adresse de l’instruction

Exemple

10RA

Load RA, 10 ; charger le registre A avec la donnée se trouvant en ; mémoire à l’adresse 10

3) Adressage indirectL’instruction contient une adresse qui contient l’adresse de l’information à chercher.

Ce mode nécessite deux accès à la mémoire. Il tend à être abandonné et ne plus être utilisé sur les processeurs modernes.Exemple

Load RA, (10) ; charger le registre A par l’information se trouvant en mémoire à ; l’adresse se trouvant dans la location d’adresse 10 de la mémoire

4) Adressage registreL’information ne se trouve pas en mémoire mais dans un autre registre interne du

processeur.Exemple

Load RA, RB

5) Adressage indirect par registreL’information à chercher se trouve en mémoire à l’adresse indiqué par un registre

interne

ExempleLoad RA, (RB)

.

.

.10...

25

25RA

Mémoire

.

.

.10..25

2530RA

Mémoire

30

10RA10RB

10RB

.

.

.10...

25

Mémoire

25RA

5) Adressage Basé (ou par déplacement)L’adresse de l’information à chercher est donnée en deux parties. Une partie dite base

se trouvant dans un registre et une partie, dite déplacement, donnée dans l’instruction. Cette forme d’adressage est souvent utilisée pour manipuler des structures complexes. Un tableau, par exemple peut être adressé par un registre qui indique la base du tableau, et un déplacement qui fait référence à un élément à l’intérieur du tableau.Exemple

6) Adressage IndexéL’adresse de l’information est la somme des contenus de deux registres

ExempleLoad A, (B)(C)

7) Adressage basé indexéC’est une combinaison des deux modes d’adressage précédents

Exemple

15RB +

.

.

.25...

30

Mémoire

Load RA, 10 (RB)

30RA

15B +

.

.

.35...

10

Mémoire

10A

20C

15B +

.

.

.45...

30

Load A, 10 (B)(C)

30A

20

Mémoire

8) Adressage relatifCe mode est souvent utilisé dans les instructions de branchement. L’adresse de

l’information est la combinaison du contenu du compteur ordinal (PC) et d’un déplacementExemple

Brel 10 ; branchement relatif vers la 10eme instruction après  ; l’instruction courante

4-1 Modes d’adressage du MIPS-R3000Le processeur MIPS-R3000 possède les modes d’adressage suivants :

Adressage immédiat Adressage par registre Adressage basé Adressage relatif

5 Formats d’instructionsIl existe en général trois types de formats d’instruction en fonction du nombre

d’opérandes figurant dans une instruction ; le format d’instruction à une adresse, le format à deux adresses et le format à trois adresses.

a) Instruction à une adresseCe format d’instruction a été utilisé dans les anciens processeurs qui disposaient d’un

nombre limité de registres. Un registre particulier, dit accumulateur, retient les résultats temporaires pendant que les opérandes sont chargés un à un de la mémoire. Une instruction est de la forme : Code_Operation, Opérande. L’instruction évoluée suivante A = B*C + D est traduite en langage machine à une adresse comme suite :

Load BMul CAdd DStore A

b) Instruction à deux adressesDans ce mode, une instruction est de la forme Code_Operation Destination, Source.

Par exemple, l’instruction Add A, B additionne le contenu de A et de B avec le résultat sauvegardé dans A. l’instruction A = B*C + D sera traduite comme suit :

Load A, BMul A, CAdd A, D

c) Instruction à trois adressesUne instruction à trois adresses est de la forme :

Code_Operation Résultat, Operande1, Operande2

15PC +

.

.

.25...

30 30A

Brel 1014

Mémoire

6 Bits 5 Bits 5 Bits 5 Bits 5 Bits 6 Bits

0561011151620212552631

6 Bits 5 Bits 5 Bits 16 Bits

0151620212552631

L’instruction A = B*C + D sera traduite de la manière suivante :Mul A, B, C Add A, D, A

5-1 Format d’instruction de MIPS-R3000Toutes les instructions du processeur MIPS-R3000 ont une taille de 32 bits. Il existe

trois formats d’instructions :

a) Instruction de format RLe format R est utilisé par les instructions nécessitant 2 registres sources et un registre

destination. Le format est donné par la figure III-3-(a) :

OP RS RT RD SHAMT FUNCT

OP RS RT Valeur immédiate

OP Valeur immédiate

Figure III-3 formats d’instructions de MIPS-R3000Avec :

OP : est le code de l’opération. Il détermine quelle est l’opération effectuée par l’instruction (addition, soustraction, …etc.). Plusieurs instructions peuvent avoir le même code OP. Dans ce cas, le champ FUNCT permet de distinguer entre ces opérations

RS : indique le premier registre source (contenant le premier opérande) RT : indique le deuxième registre source (contenant le deuxième opérande) RD : indique le registre destination (qui recevra le résultat de l’opération) SHAMT : utilisé dans les instructions de décalage pour indiquer le nombre de

décalages à effectuer. FUNCT : utilisé pour distinguer entre les instructions ayant le même code OP.

b) Instruction de format ILe format I (figure III-3-(b) est utilisé par les instructions de lecture/écriture

mémoire, par les instructions utilisant un opérande immédiat, ainsi que par les branchements conditionnels. Dans tous les cas, la taille de la valeur immédiate ne peut excéder 16 bits

c) Instruction de format JCe format (figure III-3-c) est utilisé uniquement pour les branchements à longue

distance (inconditionnels). La taille de l’adresse de branchement est de 26 bits

5-2 Jeu d’instruction du processeur MIPS-R3000Le processeur MIPS est de type Load/Store. Cela veut dire qu’il existe uniquement

deux instructions pour accéder à la mémoire. L’instruction Load pour charger un objet de la mémoire et l’instruction Store pour enregistrer un objet dans la mémoire. Toutes les autres instructions sont orientées registres. Cela signifie que les instructions arithmétiques et

0255

2631

6 Bits 26 Bits

(a) Format R

(b) Format I

(a) Format J

logiques, par exemple, prennent leurs opérandes dans des registres et rangent le résultat dans un registre. Cette technique est utilisée dans la majorité des processeurs modernes de type RISC, car l’accès à la mémoire est très lent et les opérations effectuées sur les registres sont plus rapides.

La table III-1 résume une partie du jeu d’instruction du processeur MIPS-R3000 indiquant le code assembleur, l’opération effectuée ainsi que le format associé. La figure III-4 donne le code machine associé à chacune des instructions.

ExempleTraduire l’instruction LW R5, 126(R8)  en code machine

Signification : charge le registre R5 du contenu d’adresse 126+(R8) ;Format I : Op (6bits) | RS (5bits) | RT (5bits) | Valeur immédiate (16 bits)OP = 100011RT = Registre à charger (R5) = 00101RS = Registre base (R8) = 01000Valeur immédiate = 0000000001111110

Le code machine associé est : 10001101000001010000000001111110=0x8D05007EExercice ;

Donner l’instruction assembleur correspondant à l’instruction machine suivante :0x00642820

5-3 Etude de quelques instructions

a) Instructions d’accès à la mémoire

LB RT, I(RS) : Charger l’octet de poids faible du registre RT par la donnée (sur un octet) se trouvant en mémoire à l’adresse (RS)+I. Le signe de la donnée est étendu sur les octets de poids forts de RT

Exemple : (RS)= 0x00000100, I= 0x00AB

LBU RT, I(RS) : Charger l’octet de poids faible du registre RT par la donnée (sur un octet) se trouvant en mémoire à l’adresse (RS)+I. Le signe est ignoré et les octets de poids fors sont mis à zéroLe résultat de l’exemple précèdent sera : RT =0x000000FE

+

FE

Mémoire

0x000001AB FBF17C

32 bits

FERT FFFFFF

LH RT, I(RS) :charger les deux octets de poids faibles de RT par les deux octets mémoires commençant à partir de l’adresse (RS) +I. Le signe est étendu sur les deux octets de poids forts

Le résultat de l’exemple précèdent sera RT =0xFFFFFBFELHU RT, I(RS) : charger les deux octets de poids faibles de RT par les deux octets mémoires

commençant à partir de l’adresse (RS) +I. Le signe est ignoré et les octets de poids forts sont mis à zéro

Le résultat de l’exemple précèdent sera RT = 0x0000FBFELW RT, I(RS) : charger le registre RT par le mot d’adresse (RS) + I.Le résultat de l’exemple précèdent sera RT = 0x7CF1FBFE

Les instruction SB, SH, SW ont un format équivalent à LB, LH, et LW. Elles permettent d’enregistrer les données en mémoire.

b) Instructions arithmétiques et logiques

ADD RD, RS, RT : le registre RD reçoit le résultat d’addition des deux registres RS + RT. S’il y a débordement, une exception est générée et le programme est interrompu.

ADDU RD, RS, RT : le registre RD reçoit le résultat d’addition des deux registres RS + RT. Un débordement éventuel est ignoré

Les instructions SUB et SUBU ont un format équivalent à ADD et ADDU. Elles effectuent des soustractions avec ou sans débordement.

MULT RS, RT : le contenu du registre RS est multiplié par le contenu du registre RD. Le poids faible du résultat est sauvegardé dans le registre LO et le poids fort dans le registre HI. S’il y a débordement, une exception est générée et le programme est interrompu

MULTU RS, RT : effectue la même opération que MULT sans générer d’exception en cas de débordement (non signée)

DIV RS, RT : divise le contenu de RD sur RT, le registre LO reçoit le quotient et le registre HI reçoit le reste

DIVU RS, RT : division non signéeOR RD, RS, RT : chaque bit de RD reçoit le OU logique entre les bits correspondant de RS

et RTAND RD, RS, RT : chaque bit de RD reçoit le ET logique entre les bits correspondant de RS

et RTc) Instructions manipulant des valeurs immédiates

Compte tenu du format de codage I des instruction Immédiates (figure III-3-b), une adresse ou une constante immédiate ne peut avoir q’une taille au plus de 16 bits. Une constante de 32 bits ne peut donc être chargée avec une seule instruction. L’instruction LUI combinée avec ADD ou OR permet de charger une constante ou une adresse de 32 bits.LUI RT, I : Enregistrer la valeur immédiate I dans les 16 bits de poids fort du registre RT, les

16 bits de poids faibles sont mis à zéro (0x0000).ORI RT, RS, I : effectuer un OU logique entre le contenu de RS et la valeur immédiate I, le

résultat est dans RT.Exemple : enregistrer le mot 0x12FE2C3B dans le registre R5Comme il n y a aucune instruction qui manipule une constante de 32 bits, on utilise deux instructions LUI $R5, 0x12FE #R5 = 0x12FE0000ORI $R5, $R5, 0x2C3B #R5 = 0x12FE2C3B

Instructions Arithmétiques/Logiques

Assembleur Opération FormatAdd Rd, Rs, Rt Add (overflow detection) Rd <-Rs + Rt R Sub Rd, Rs, Rt Subtract (overflow detection) Rd <-Rs - Rt R Addu Rd, Rs, Rt Add (no overflow ) Rd <-Rs + Rt R Subu Rd, Rs, Rt Subtract (no overflow ) Rd <-Rs - Rt R Addi Rt, Rs,I Add Immediate (overflow detection) Rt <-Rs + I I Addiu Rt, Rs,I Add Immediate (no overflow) Rt <-Rs + I I Or Rd, Rs, Rt Logical Or Rd <-Rs or Rt R And Rd, Rs, Rt Logical And Rd <-Rs and Rt R Xor Rd, Rs Rt Logical Exclusive-Or Rd <-Rs xor Rt R Nor Rd, Rs, Rt Logical Not Or Rd <-Rs nor Rt R Ori Rt, Rs, I Or Immediate (unsigned) Rt <-Rs or I I Andi Rt, Rs, I And Immediate (unsigned) Rt <-Rs and I I Xori Rt, Rs, I Exclusive-Or Immediate (unsigned) Rt <-Rs xor I I Sllv Rd, Rt, Rs Shift Left Logical Variable (5 lsb of Rs is significant) Rd <-Rt << Rs R Srlv Rd, Rt, Rs Shift Right Logical Variable (5 lsb of Rs is significant) Rd <-Rt >> Rs R

Srav Rd, Rt, Rs Shift Right Arithmetical Variable (5 lsb of Rs is significant) (with sign extension) Rd <-Rt >> Rs R

Sll Rd, Rt, sh Shift Left Logical Rd <-Rt << sh R Srl Rd, Rt, sh Shift Right Logical Rd <-Rt >> sh R Sra Rd, Rt, sh Shift Right Arithmetical (with sign extension) Rd <-Rt >> sh R Lui Rt, I Load Upper Immediate,16 lower bits of Rt are set to zero Rt <-I || "0000" IS l t Rd, Rs, Rt Set if Less Than Rd <- 1 if Rs<Rt else 0 R Sltu Rd, Rs, Rt Set if Less Than Unsigned Rd <- 1 if Rs<Rt else 0 R Slti Rt, Rs, I Set if Less Than Immediate Rt <- 1 if Rs < I else 0 (sign extended Immediate) I Sltiu Rt, Rs, I Set if Less Than Immediate Rt <- 1 if Rs < I else 0 (unsigned immediate) I Mult Rs, Rt Multiply Rs * Rt R

LO <-32 low significant bits HI <-32 high significant bits

Multu Rs, Rt Multiply Unsigned Rs * Rt R LO <-32 low significant bits HI <-32 high significant bits

Div Rs, Rt Divide Rs / Rt R LO <-Quotient HI <-Remainder

Divu Rs, Rt Divide Unsigned Rs / Rt R LO <-Quotient HI <-Remainder

Mfhi Rd Move From HI Rd <- HI R Mflo Rd Move From LO Rd <- LO R Mthi Rs Move To HI HI <-Rs R Mtlo Rs Move To LO LO <-Rs R

Instructions de branchementAssembleur Opération Format

Beq Rs, Rt, I Branch if Equal PC <-PC+ (I*4) if Rs = RPC <-PC+4 if Rs Rt I

Bne Rs, Rt, I Branch if Not Equal PC <-PC+ (I*4) if Rs RPC <-PC+4 if Rs =Rt I

Bgez Rs, I Branch if Greater or Equal Zero PC <-PC+ (I*4) if Rs 0 PC <-PC+4 if Rs < 0 I

Bgtz Rs, i Branch if Greater Than Zero PC <-PC+ (I*4) if Rs > 0 PC <-PC+4 if Rs 0 I

Blez Rs, I Branch if Less or Equal Zero PC <-PC+ (I*4) if Rs 0 PC <-PC + 4 if Rs > 0 I

Bltz Rs, I Branch if Less Than Zero PC <-PC+ (I*4) if Rs < 0PC <-PC+4 if Rs 0 I

Bgezal Rs, I Branch if Greater or Equal Zero and linkPC <-PC+ (I*4) if Rs 0 PC <-PC+4 if Rs < 0R31 <-PC+4 in both cases

I

Bltzal Rs, IBranch if Less Than Zero and link

PC <-PC+ (I*4) if Rs < 0PC <-PC+4 if Rs 0

I

J I Jump PC <-PC 31:28 || I*4 J

Jal I Jump and LinkR31 <-PC+4PC <-PC 31:28 || I*4

J

Jr Rs Jump Register PC <-Rs R

Jalr Rs Jump and Link Register R31 <-PC+4 PC <-Rs

R

Jalr Rd, Rs Jump and Link Register Rd <-PC+4 PC <-Rs

R

Instructions de Lecture/Ecriture mémoireAssembleur Opération Format

Lw Rt, I (Rs) Load Word (sign extended Immediate) Rt <- M (Rs + I) I Sw Rt, I (Rs) Store Word M (Rs + I) <- Rt I

Lh Rt, I (Rs)

Load Half Word sign extended Immediate. Two bytes from storage are loaded into the the 2 less significant bytes of Rt, the sign of these 2 bytes is extended on the 2 most signficant bytes.

Rt <-M (Rs + I) I

Lhu Rt, I (Rs)

Load Half Word Unsignedsign extended Immediate. Two bytes from storage are loaded into the the 2 less significant bytes of Rt, other bytes are set to zero

Rt <-M (Rs + I) I

Sh Rt, I (Rs)Store Half Wordsign not extended Immediate. The Two less significant bytes of Rt are stored into storage

M (Rs + I) <-Rt I

Lb Rt, I (Rs)

Load Bytesign extended Immediate. One byte from storage is oaded into the less significant byte of Rt. The sign of this byte is extended on the 3 most signficant bytes.

Rt <-M (Rs + I) I

Lbu Rt, I (Rs)

Load Byte Unsignedsign extended Immediate. One byte from storage is loaded into the less significant byte of Rt, other bytes are set to zero

Rt <-M (Rs + I) I

Sb Rt, I (Rs) Store Bytesign extended Immediate. The less significant byte of Rt is stored into storage

M (Rs + I) <-Rt I

Instructions système (en mode protégé)Assembleur Opération Format

Rfe Restore From ExceptionPrivileged instruction. Restore the prevous IT mask and mode

SR <- SR 31:4 || SR 5:2 R

Break nBreakpoint TrapBranch to exception handler, n defines the breakpoint number

SR <- SR 31:6 || SR 3:0 || "00" PC <- "8000 0080"CR <- cause

R

Syscall

System Call TrapBranch to exception handler

SR <- SR 31:6 || SR 3:0 || "00" PC <- "8000 0080"CR <- cause

R

Mfc0 Rt, Rd

Move From Control CoprocessorPrivileged Instruction . The register Rd of the Control Coprocessor is moved into the integer register Rt

Rt <-Rd R

Mtc0 Rt, Rd

Move To Control CoprocessorPrivileged Instruction . The integer register Rt is moved into the register Rd of the Control Coprocessor

Rd <-Rt R

Table 1 jeu d’instruction du processeur MIPS-R3000

OP (Bits 28:26)

OP (Bits 31:29)

000 001 010 011 100 101 110 111

000001010011100101110111

OP = COPRO (010000) RS (Bit 23)

OP =COPRO RS (Bit 25)

01

0 1

OP = BCOND (000001) RT (Bit 16)

OP = BCOND RT (Bit 20)

01

0 1

Figure 4 Code machine associé au jeu d’instruction du processeur MIPS-R3000

Table 2 convention d’usage des registres MIPS

OP = SPECIAL (000000)Function (Bits 2:0)

OP = SPECIAL Function (Bits 5:3)

000 001 010 011 100 101 110 111

000001010011100101110111

SLL SRL SRA SLLV SRLV SRAVJR JALR SYSCALL BREAK

MFHI MTHI MFLO MTLOMULT MULTU DIV DIVUADD ADDU SUB SUBU AND OR XOR NOR

SLT SLTU

d) Instruction de branchementLes instructions de branchement permettent de réaliser des séquences conditionnelles

(if-then-else) ainsi que des boucles. Le branchement peut être soit relatif (par rapport à l’instruction courante) ou absolu (à une adresse bien déterminée)BEQ RS, RT, I : si RS = RT alors aller à la Ieme instruction après l’instruction courante, si

non, aller à la prochaine instruction (si I<0, le branchement est en arrière) BGTZ RS, I : si RS > 0 alors aller à la Ieme instruction se trouvant après l’instruction

courante, si non, aller à l’instruction courante (saut en arrière si I<0)J I : aller à l’instruction d’adresse I (branchement absolu)JAL I : aller à l’instruction d’adresse I, sauvegarder l’adresse de la prochaine instruction dans

le registre R31. Cette instruction est utilisée pour réaliser des appels de sous programmes

JR RS : aller à l’instruction d’adresse se trouvant dans le registre RS. Cette instruction est utilisée pour réaliser des retours de procédures

ExerciceEcrire un programme assembleur MIPS qui récupère dans le registre R10, la plus

grande valeur se trouvant dans les registres R11 et R12

Programme C

If (R11>= R12){ R10 = R11}else { R10 = R12}

Programme assembleurSub $R13, $R11, $R12 # On utilise le registre R13 comme registre temporaire de

# travail qui reçoit la différence entre R11 et R12BGEZ $R13, suite # si R11 >= R12, aller à suiteADD $R10, $R0, $R12 # Si non R10 R12J fin

Suite : ADD $R10, $R0, $R11 # R10 R11Fin : …

6 Types de données manipulées par le processeur MIPS1) Entiers et caractères

Les entiers sous MIPS adoptent une représentation en complément à 2 et peuvent avoir des tailles différentes. Les caractères sont représentés en code ASCII est tiennent sur un octet. Ils peuvent donc être considérés comme des entiers non signés sur 8 bits. La table III-3 résume les types utilisés dans les langages évolués (C par exemple) ainsi que leurs correspondance en MIPS.

Type C Type MIPS Nombre d’octets

Long long Dword (64 bits) 8 (deux accès mémoire)

Long (ou int) Word (32 bits) 4 (un accès mémoire)

Short Halfword (16 bits) 2 (un accès mémoire)

Char Byte 1 (un accès mémoire

Table III-3 représentation des données entières sous MIPS

2) Nombre réels (float en C)Les processeurs MIPS disposent d’un coprocesseur spécialisé dans les calculs flottants

(dit coprocesseur 1). Ce coprocesseur dispose de 32 registres propres de 32 bits, numérotés f0 à f31. La représentation adoptée est la norme IEEE-754, simple et double précision. La double précision (sur 64 bits) utilise une concaténation de deux registres consécutifs (f0 :f1 par exemple). Il existe aussi des instructions propres au coprocesseur pour effectuer des opérations flottantes.

3) chaînes de caractèresLes caractères sont combinés pour produire un « String » qui est une chaîne de

caractères de taille variable. Il existe trois façons représenter les strings La première position (le premier octet) de la chaîne est réservée pour indiquer la taille

de la chaîne de caractères. C’est la représentation adoptée par le langage Pascal La dernière position de la chaîne contient un caractère spécial de fin de chaîne (le

caractère 0). C’est la représentation adoptée par le langage C et Java. Une variable indépendante accompagne le String indiquant le nombre de caractères de

la chaîne. Cette représentation n’est pas utilisée en pratique.

En assembleur, il est plus pratique d’adopter une représentation de type C car elle ne nécessite aucun calcul pour la taille de la chaîne. Ainsi, la chaîne « Bonjour» sera représentée par le code  (ASCII): 42, 6F, 6E, 7E, 7A, 7F, 75, 72, 0

7 Ecriture de programmes en langage d’assemblage MIPSL’assembleur MIPS permet d’écrire des programmes fonctionnant sur le processeur

MIPS-R3000. Les systèmes MIPS adoptent un certain nombre de règles concernant l’utilisation des registres. La table III-2 donne les noms et les fonctions conventionnelles des registres MIPS. Ces recommandations ne sont pas obligatoires. Elles sont des conventions entre les programmeurs pour adopter les mêmes règles de programmation, de façon à ce que les programmes écrits par des personnes différentes puissent fonctionner ensemble correctement. Parmi les règles nous citons :

Les registres $at (1), $k0 (26), et $k1 (27) sont réservés pour le système d’exploitation et l’assembleur. Ils ne doivent pas être utilisés par d’autres programmes

Les registres $a0–$a3 (4–7) sont utilisés pour passer les 4 premiers arguments aux routines (procédure ou fonction). S’il y a plus d’arguments, il faut utiliser la pile. Les registres $V0 et $V1 sont utilisés pour renvoyer des valeurs de retour.

Les registres $t0–$t9 (8–15, 24, 25) peuvent être utilisées par les routines sans les préserver. Ils sont utilisés pour retenir des valeurs temporaires. Le programmer doit savoir que le contenu initial de ces registres risque d’être altéré lors d’un appel de procédure

Les registres $s0–$s7 (16–23) sont des registres dont les valeurs sont préservées lors de l’appel de procédure. La procédure appelée doit garantir que le contenu initial de ses registres soit sauvegardé (dans la pile) et restitué après le retour le la procédure.

Le registre $gp (28) qui pointe vers le segment de données globales permettant de facilité l’accès aux données

Le registre $sp (29) qui pointe vers la prochaine location vide de la pile, le registre $fp (30) utilisé pour pointer vers les données locales contenues dans la pile et, en fin, le registre $ra (31) qui sauvegarde l’adresse de retour dans un appel de procédure

7-1 Directives d’assemblage et pseudo-instructions Pour faciliter l’écriture d’un programme, l’assembleur dispose en générale de

directives d’assemblage et de pseudo-instructions. Une directive d’assemblage est une commande adressée à l’assembleur lui-même. Son but est d’aider l’assembleur à générer le code objet du programme. Une pseudo-instruction est, en générale, une forme de macro remplaçant un ensemble d’instructions réelles. Cela permet au programmeur de faciliter certaines tâches tel que le chargement d’une donnée en mémoire qui nécessite deux instructions.

1) Directives.data : les éléments qui suivent cette directive seront enregistrés dans la section donnée de la

mémoire utilisateur (entre 0x10000000 et 0x7FFFFFFF).text : les éléments qui suivent seront enregistrés dans la section programme de la mémoire

utilisateur..byte  b1, b2, …bn : Enregistrer les n octets en mémoire.half  h1, h2, …hn : Enregistrer les n demi-mot en mémoire.word w1, w2, …wn : Enregistrer les n mots en mémoire.ascii  chaîne : Enregistre la chaîne de caractère en mémoire.asciiz  chaîne  : Enregistrer la chaîne de caractère en mémoire et lui ajouter le caractère 0

à la fin.float f1, f2, …f3 : Enregistrer les nombres flottants en mémoire.double d1, d2, …dn : Enregistrer les double-mots en mémoire (flottants sur 64 bits)

2) Pseudo-instructionsLA RT, Etiquette : Charger RT de l’adresse correspondant à l’étiquette (peut être sur 32 bits)Equivalent à :LUI RT, Adresse31-16 de l’étiquette

ORI RT, Adresse15-0 de l’étiquetteLI RT, I : charger RT de la valeur immédiate I (peut être sur 32 bits)MOVE RD, RS : RD RSEquivalent à OR RD, RS, $R0MUL RD, RS, RT : RD RS*RTEquivalente à MULT RS, RT

MFLO RD

7-2 Simulateur de processeurs MIPS (SPIM)SPIM (MIPS inversé) est un logiciel de simulation de processeurs MIPS. Il permet de

lire un programme source assembleur et de simuler son exécution. Plusieurs versions s’exécutant sur des plateformes multiples (Unix, Linux, Mac-OS-X et Windows) sont disponibles sur le net1. L’utilisation de SPIM permet de vérifier la justesse des programmes écrits en assembleur MIPS et de voir le résultat de l’exécution de ces derniers. SIMP simule également un système d’exploitation rudimentaire permettant de gérer un terminal virtuel d’entrées sorties.

Sous SPIM, Un programme assembleur doit avoir le format suivant :

.data # section données, déclarer toutes les données dans cette section.Byte …..Word ….

.text # Section programme. Ecrire le programme dans cette section

1 Pour télécharger SPIM, visitez le site : http://pages.cs.wisc.edu/~larus/spim.html

.globl main # cette étiquette doit toujours être déclarée au début du programmemain : ……..

…….. # Ecrire les instructions du programme dans cette section

7-3 Exemples de programmes assembleur

1) Addition de deux entiersSoit à écrire un programme assembleur qui additionne deux valeurs 14 et 15. Ces

valeurs son contenues dans deux variables d’adresses A et B sur 32 bits chacune. Le résultat sera sauvegardé en mémoire à l’adresse C. Le programme effectuant l’addition est le suivant :

.data # Déclaration des donnéesA : .word 14 # Déclaration d’un entier sur 32 bits en mémoire B : .word 15 # Deuxième entierC : .word 0 # Entier recevant le résultat

.text # Section programme

.globl main # Point d’entrée du programmemain : la $t0, A # Charger l’adresse de la variable A dans T0

lw $t1, 0($t0) # Charger le contenu de A dans le registre T1lw $t2, 4($t0) # Charger le contenu de B dans T2add $t3, $t1, $t2 # Effectuer l’addition, le résultat est dans T3sw $t3, 8($t0) # sauvegarder le résultat dans Cjr $ra # fin du programme

La déclaration des variables se fait dans la section de données (.data). L’étiquette A : correspond à l’adresse mémoire du premier octet du mot contenant la valeur 14. Le mot sera réservé grâce à la directive .word 14 qui réserve un mot et met la valeur 14 à l’intérieur. L’étiquette B : contient l’adresse du mot contenant la valeur 15. (B = A + 4 car A est sur 4 octets). Le résultat sera sauvegardé dans le mot d’adresse C (A +8). La directive .word 0 réserve un mot et l’initialise à 0 car il est destiné à recevoir le résultat de l’addition de A et B.

Le programme est écrit dans la section .text. il commence par la définition de l’étiquette globale main. Cette étiquette indiquera au simulateur SPIM où commence le programme pour effectuer un saut à ce dernier.

Pour effectuer une opération arithmétique sur le processeur MIPS, il faut charger tous les opérandes dans les registres. L’instruction « la $t0, A » est, en fait, une pseudo instruction qui permet de charger l’adresse du premier opérande dans le registre T0. L’assembleur remplacera cette pseudo instruction par les vraies instructions MIPS effectuant cette opération. (lui $a, poids_forts_de_A et ori $t0, poids_faibles_de_A) Il suffit ensuite d’utiliser cette adresse comme base pour charger les deux opérandes et enregistrer le résultat. Le premier opérande correspond à l’adresse de base, le deuxième opérande correspond à un déplacement de 4 par rapport à l’adresse de base et le résultat correspond à un déplacement de 8. Il n’est donc, pas nécessaire de charger l’adresse de chaque opérande.

Le système d’exploitation simulé par SPIM exécute les programmes utilisateurs en appelant la procédure main (exécution de l’instruction « jal main »). Le programme doit donc toujours commencer par la définition de l’étiquette globale main. Il est fréquemment terminé par l’instruction de retour (jr $ra) pour rendre la main au système d’exploitation de SPIM.

2) Addition d’éléments d’un tableau d’entiers

Soit à écrire un programme assembleur MIPS qui calcule la somme des éléments d’un tableau à 10 mots et à sauvegarder le résultat en mémoire. Le programme est :

.datatab: .word 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 # Eléments du tableaures: .word 0 # Variable recevant la somme des éléments

.text

.globl mainmain: and $t4, $t4, $zero # T4 est destiné à contenir la somme, il est initialisé à 0

li $t1, 10 # T1 contient la taille du tableau en mots (10 éléments)la $t2, tab # T2 contient l’adresse début du tableau

boucle:lw $t3, 0($t2) # charger un élément du tableau dans T3add $t4, $t3, $t4 # ajouter l’élément à la sommeaddi $t1,$t1, -1 # nombre d’éléments restant à sommerbeq $t1, $zero, fin # s’il ne reste plus d’éléments à sommer, aller à finaddi $t2, $t2, 4 # T2 va pointer vers l’élément suivant du tableauj boucle # Continuer à sommer

fin: la $t2, res # T2 contient maintenant l’adresse du résultatsw $t4, 0($t2) # enregistrer le résultat en mémoirejr $ra # fin du programmeLe tableau et son contenu, ainsi que le mot recevant le résultat, sont déclarés à l’aide

de la directive « .word ». Le programme commence par mettre à zéro le registre $t4 destiné à recevoir la somme. La mise à zéro de $t4 est effectuée en réalisant un « and » avec le registre $zero. Le registre $t1 contient la taille en mots du tableau (10 dans ce cas) et le registre $t2 contient l’adresse de base du tableau. Au niveau de l’étiquette « boucle : » commence une boucle qui additionne un éléments du tableau à la somme partielle ($t4) à chaque itération. La boucle commence par charger l’élément dans le registre $t3 et l’additionner à la somme partielle. Le nombre d’éléments est, ensuite décrémenté de 1 et la base du tableau est incrémenté de 4 pour pointer vers l’élément suivant. Le programme sort de la boucle quand tous les éléments auront été traités ($t1 = 0) et le résultat est enregistré en mémoire.

8- Les interruptions et les exceptionsDans son fonctionnement normal, le processeur exécute les instructions l’une après

l’autre. Le compteur ordinal (PC) s’incrémente régulièrement pour pointer vers l’instruction prochaine sauf dans le cas d’une instruction de branchement. Dans ce cas, le compteur ordinal pointe vers l’adresse de branchement indiquée dans l’instruction.

Toutefois, il existe des situations dans lesquelles le processeur interrompt l’exécution normale du programme et se branche vers un autre programme. Quatre types d'évènements peuvent interrompre l'exécution "normale" d'un programme:

La réinitialisation (le signal RESET) Les interruptions Les exceptions Les appels système

8-1) Les interruptionsLes interruptions sont des évènements asynchrones provenant généralement de

périphériques externes, détectés sur des lignes spéciales du processeur. Ces lignes sont dites sources d’interruption. Une fois l’interruption déclenchée, le processeur interrompt l’exécution du programme est se branche vers une routine qui exécute un programme particulier dit routine d’interruption (ou gestionnaire d’interruption). En général ce

programme consiste à répondre au périphérique ayant déclenché cette interruption. Une fois terminé, le processeur revient au programme interrompu et reprend sont exécution normale.

Plusieurs sources d’interruption peuvent exister. Dans ce cas on peut définir un niveau de priorité entre elle, de façon à ce qu’une routine d’irruption puisse être privilégiée ou être elle-même interrompu. On peut également empêcher momentanément une interruption d’agir. Dans ce cas, on dit qu’elle est masquée.

MIPS-R3000 dispose de 6 sources d’interruption matérielles qui peuvent être masquée globalement ou individuellement. L’activation d’une ligne d’interruption non masquée fait passer le processeur en mode superviseur et se branche à l’adresse : 0x80000180. L’adresse de retour est sauvegardée dans le registre EPC pour pouvoir reprendre le programme interrompu.

Plus précisément, le processeur MIPS effectue les tâches suivantes à chaque interruption :

sauvegarder l'adresse de retour (PC + 4) dans le registre EPC sauvegarder l’ancienne valeur du registre d’état SR passer en mode superviseur et masquer momentanément les interruptions mettre à jour le registre CR pour indiquer à la routine d’interruption, de quelle source

il s’agit se brancher à l’adresse 0x80000180 pour exécuter la routine d’interruption.

En plus des 6 lignes d'interruption matérielles, le processeur R3000 possède un mécanisme d'interruption logicielle. Le programme en exécution peut déclencher ces interruptions en mettant à 1 les bits appropriés du registre CR. L’adresse de branchement est toujours (0x80000180). Toutes les interruptions auront donc le même gestionnaire d’interruption qui doit localiser la source d’interruption en examinant le registre CR.

8-2) les exceptionsLes exceptions sont des évènements "anormaux", le plus souvent liés à une erreur de

programmation, qui empêchent l'exécution correcte de l'instruction en cours. La détection d'une exception entraîne l'arrêt immédiat de l'exécution de l'instruction fautive. Ainsi, on assure que l'instruction fautive ne modifie pas la valeur d'un registre visible ou de la mémoire. Les exceptions ne sont pas masquables.

Le processeur R3000 dispose de 7 exceptions suivantes :1. ADEL  (Adresse illégale en lecture) : adresse non alignée ou se trouvant dans le segment

système alors que le processeur est en mode utilisateur.2. ADES  (Adresse illégale en écriture) : adresse non alignée ou accès à une donnée dans le

segment système alors que le processeur est en mode utilisateur.3. DBE (Data bus erreur) : le système mémoire signale une erreur en activant le signal

BERR à la suite d'un accès de donnée.4. IBE (Instruction bus erreur) : le système mémoire signale une erreur en activant le signal

BERR à l'occasion d'une lecture instruction.5. OVF (Dépassement de capacité) : lors de l'exécution d'une instruction arithmétique (ADD,

ADDI ou SUB), le résultat ne peut être représenté sur 32 bits.6. RI (Codop illégal) : le codop ne correspond à aucune instruction connue (il s'agit

probablement d'un branchement dans une zone mémoire ne contenant pas du code exécutable.

7. CPU (Coprocesseur 0 inaccessible) : tentative d'exécution d'une instruction privilégiée (MTC0, MFC0, RFE) alors que le processeur est en mode utilisateur.

Quand une exception se produit, le processeur passe en mode superviseur et se branche au à l’adresse 0x80000180. Le processeur doit transmettre au gestionnaire d'exceptions l'adresse de l'instruction fautive et indiquer dans le registre de cause le type d'exception détectée.

Lorsqu'une exception est détectée, le processeur : sauvegarde l'adresse de l'instruction fautive dans le registre EPC sauvegarde l'ancienne valeur du registre d'état SR passe en mode superviseur et masque les interruptions dans SR écrit le type de l'exception dans le registre CR se branche à l'adresse "0x80000180".

8-3) les appels systèmeUn appel système est un mécanisme permettant aux tâches utilisateurs (ou système) de

demander un service au système d’exploitation, comme par exemple une entrée sortie. L’appel se comporte comme une interruption logicielle et le programme appelant est repris à la fin de la routine associée.

MIPS-R3000 possède deux instructions permettant d’effectuer des appels système. L’instruction SYSCALL et l’instruction BREAK. SYSCALL est associée aux services du système d’exploitation. En général, le numéro du service et des paramètres éventuels sont transmis via les registres généraux du processeur. BREAK est utilisé généralement pour débuguer un programme. Elle permet d’arrêter son exécution à des points déterminés.

Appels système sous SPIMLe simulateur SPIM simule une console d’entrée/sortie permettant au programmeur de

lire les données et d’écrire les résultats. Cette console est accessible aux utilisateurs en utilisant les appels système grâce à l’instruction Syscall. Pour demander un service, le programme appelant doit charger le code du service dans le registre $v0 et éventuellement d’autres arguments dans les registres $a0-$a3 (f12 dans pour les flottant). Si le service renvoie un résultat, il est retourné dans le registre $v0. La table III-4 donne les codes de services implémentés sous SPIM ainsi que les arguments correspondants.

Service Code Argument Résultat CommentairePrint_int 1 $a0 = int Imprime sur la console l’entier transmis

dans $a0Print_float 2 $f12 =float Imprime le réel transmis dans $f12Print_double 3 $f12 =double Imprime le réel (sur 64 bits) transmis dans

$f12Print_string 4 $a0 = string Imprime la chaîne de caractère (terminée

par 0) d’adresse transmise dans $a0Read_int 5 Entier (dans $v0) Lit un entier de la console et le met dans

$v0Read_float 6 Réel (dans $f12) Lit un réel et le met dans $f12Read_double 7 Double(dans

$f12)Lit un réel (sur 64 bits) et le met dans $f12

Read_string 8 $a0= buffer, $a1=lenth

Lit un ensemble de caractères de longueur contenue dans $a1 et met l’adresse dans $a0

sbrk 9 $a0=quantité Adresse dans $v0

Renvoie un pointer vers un bloc de données de quantité donnée

Exit 10 Arrête le fonctionnement du programme

Table III-3 Services implémentés dans SPIM

Exemple

Ecrire un programme permettant de lire deux entiers depuis la console SPIM et afficher le résultat de leur addition

.datam1: .asciiz "Donnez le premier opérande"m2: .asciiz "Donnez le deuxième opérande"m3: .asciiz "Le résultat est:"

.text

.globl mainmain: li $v0, 4 # Code du service print_string

la $a0, m1 # Adresse de la chaîne à affichersyscall # appel système pour afficher la chaîneli $v0, 5 # Code du service read_intsyscall # appel système pour lire un entieradd $t0, $v0, $zero # mettre l'entier lu dans $t0li $v0, 4 # code de service print_stringla $a0, m2 # adresse du deuxième message a affichersyscall # appel système pour afficher message2li $v0, 5 # lecture du deuxième opérandesyscalladd $t0, $t0, $v0 # effectuer l'additionli $v0, 4 # affichage du message 3la $a0, m3syscallli $v0, 1 # code du service print_intadd $a0, $t0, $zerosyscall # Affichage du résultat

8-4) Le signal RESETLe processeur dispose également d’une ligne dont l’activation entraîne l’exécution

d’un programme spécial de réinitialisation. Cette ligne se comporte comme une ligne d’interruption sauf qu’elle n’est pas masquable, elle possède une adresse propre et qu’elle ne sauvegarde pas l’adresse de retour.

La ligne RESET du processeur MIPS-R3000 doit être activée pendant, au moins, un cycle d’horloge. Une fois activé, le processeur passe en mode superviseur, masque toutes les interruptions et se branche à l’adresse 0xBFC00000

9) le mode superviseurLe mode superviseur (ou protégé) offre les mécanismes nécessaires pour mettre en

place un système d’exploitation permettant de gérer les processus, la mémoire et les périphériques. Certains registres du processeur ne sont accessibles qu’en mode protégé et ne peuvent être manipulés que par des instructions spécifiques à ce mode (typiquement les instruction mfc0 et mtc0). Tous les gestionnaires d’exception, toutes les routine d’interruptions et les routines système (accessibles par les appels système) sont en fait des modules du système d’exploitation.

MIPS-R3000 offre particulièrement 4 registres accessibles en mode protégé ; SR, CR, EPC et BAR. Nous allons étudier en détail les deux registres SR et CR.

9-1) Le registre SR (Status Register)

01

IECKUC

23

IEPKUP

5

IEOKUO

467

MSWI 00

89

MIRQ

1012 11131415

01012345

1631

0 ……………………….0

Le registre SR décrit l’état du processeur. Seules les 16 bits de poids faible sont utilisées. Les autres bits de poids fort ainsi que les bits 6 et 7 du poids faible sont toujours à zéro. La figure III-5 montre le format du registre.

Figure III-5 format du registre SR IEC : est le masque global des interruptions de l’état courant. Un 0 désactive toutes les

interruptions et un 1 active toutes les interruptions non masquées individuellement KUC : est le mode de fonctionnement actuel du processeur

0=superviseur, 1= utilisateur. IEP et KUP représentent le masque global et le mode de fonctionnement de l’état

précédant une interruption ou une exception. Le processeur les met à jour à chaque interruption ou exception en faisant un décalage à gauche de deux positions

KUO et IEO représente le masque global et le mode de fonctionnement de l’état antérieur (l’état avant l’état précèdent). Cela permet de garder trace de trois états distincts, comme dans le cas d’une interruption prioritaire qui arrive pendant le traitement d’une autre interruption.

MSWI (0 et 1) : ces deux bits représentent les masques individuels des deux interruptions logicielles SWI0 et SWI1. Un zéro sur le bit masque l’interruption correspondante et un 1 active l’interruption correspondante

MIRQ (0 à 5) : ces 6 bits représentent les masques individuels des 6 lignes d’interruption externes du processeur MIPS. Un 0 sur un bit désactive l’interruption correspondante et un 1 active l’interruption correspondanteQuand une interruption (ou une exception) est déclenchée, le registre SR est mis à jour

par le processeur. Cela permet de sauvegarder l’état actuel, le passage au mode superviseur et de désactiver momentanément les interruptions. Ceci est réalisé en une seule opération en faisant un décalage à gauche des 6 bits de poids faibles du registre SR comme le montre la figure III-5 (a). La restauration de l’ancien état est réalisée grâce à l’instruction de retour ERET (ou RFE) qui effectue un décalage à droite des 6 bits du registre SR comme le montre la figure III-5-b. Les autres bits du registre SR ne sont pas modifiés.

(a) Arrivée d’une interruption (b) Retour d’interruption (Sauvegarde de l’état actuel) (restauration de l’état actuel)

Figure III-6 sauvegarde et restauration de l’état du processeur

01

IECKUC

23

IEPKUP

5

IEO

4

KUO

00IEPKUPIEOKUO

01

IECKUC

23

IEPKUP

5

IEO

4

KUO

IECKUCIEPKUPIEOKUO

9-2 le registre CR (Cause Register)Le registre CR est géré par le processeur pour permettre au superviseur de signalé aux

programmes la cause d’une interruption ou exception. A chaque arrivée d’un tel événement, le processeur met à jour ce registre. Son format est le suivant :

Figure III-7 format dur registre SR XCODE : indique le code correspondant à l’interruption ou à l’exception. Les codes sont

les suivants :

Code Des Cause Code Des Cause0000 INT Interruption 1000 SYS Syscall (appel système)0001 Inutilisé 1001 BP BREAK (Point d’arrêt)0010 Inutilisé 1010 RI Codop illégal0011 Inutilisé 1011 CPU Coprocesseur inaccessible0100 ADEL Adresse illégale en lecture 1100 OVF Ovrflow arithmétique0101 ADES Adresse illégale en écriture 1101 Inutilisé0110 IBL Bus erreur sur accès

instruction1110 Inutilisé

0111 DBE Bus erreur sur accès données

1111 Inutilisé

SWI : indique la présence d’interruption logicielle. Un 1 su un bit du champ indique que l’interruption logicielle correspondante est déclenchée.

IRQ : indique la présence d’une interruption matérielle. Un 1 sur un bit de ce champ indique qu l’interruption correspondante s’est déclenchée.

Exemple d’implémentation d’un gestionnaire d’exceptionEcrire le code superviseur permettant de protéger en écriture la zone mémoire réservée

au système d’exploitation. Quand un utilisateur tente d’écrire dans cette zone, le système doit prendre la main, afficher un message d’erreur puis rendre la main au programme utilisateur en sautant l’instruction fautive.

.kdata # utilisation de l’espace mémoire du superviseurerr: .asciiz "Erreur de protection mémoire :Cette zone est protégée en écriture"

.ktext 0x80000180 # Adresse du gestionnaire d’exceptionmfc0 $k0, $13 # Charger le registre Cause dans $k0mfc0 $k1, $14 # Charger le registre EPC dans $K1andi $k0, $K0, 0x003C # extraire le code de l'exceptionsrl $K0, 2 # ignorer les deux bits de poids faibles (décalage à droite

# de deux positionsli $t0, 0x5 # code d’erreur ADES (0101)bne $k0, $t0, suite1 # aller vers un autre type d’exceptionla $a0, err # adresse du message dans $a0li $v0, 5 # service système print_string syscall # Afficher le message d'erreuraddiu $k1, $k1, 4 # sauter l'instruction fautivemtc0 $k1, $14 # remettre à jour l'adresse de retoureret # retour d'interruption

01

0 0

23

XCODE

5 467

SWI 00

89

IRQ

1012 11131415

01012345

1631

0 ……………………….0

suite1: ................. # Traitement d'autres interruptions ou exceptions

# Programme utilisateur qui essaye de lire dans une zone protégée.data

m : .asciiz " message quelconque "

.text

.globl mainmain: li $t0, 0xFFFFFFFF # charger $T0 par une adresse de l’espace # superviseur

sw $t1, 0($t0) # tentative d’écriture dans cette zonela $a0, m # suite du programme, affichage d’unli $v0, 1 # message quelconquesyscall

suite2 ............... # suite du programme utilisateurQuand le processeur tentera d’exécuter l’instruction sw $t1, 0(t0) il s’apercevra qu’il

est en mode utilisateur. Il déclenchera alors l’exception de code ADES qui sera prise en charge par notre gestionnaire.