Code Machine

Code Assembleur
Processeurs RISC
(Byte code).
Didier Remy
Octobre 2000

http://cristal.inria.fr/remy/poly/compil/1/
http://w3.edu.polytechnique.fr/profs/informatique//Didier.Remy/compil/1/

Informations utiles
La pico-machine decrite dans le livre Le langage Caml de
Pierre Weis et Xavier Leroy.
Le simulateur SPIM du processeur MIPS R2000 est pr esente
succinctement ci-dessous. Voir aussi son manuel de ref
erence
en ligne et en Postscript.

Slide 1
 Les processeurs

Les processeurs se ressemblent tous du point de vue de

lutilisateur (i.e. de la partie visible de leur architecture). Ils
comportent principalement une m emoire, un ensemble de
registres, et un jeu dinstructions.
Les diff
erences proviennent surtout du jeu dinstructions :
Les (vieux) processeurs CISC (Complex Instruction Set)
Slide 2 Leurs instructions sont de taille variable et beaucoup r
ealisent des
transferts avec la m
emoire ; ils poss`edent en g
en
eral peu de registres (et
pas uniformes)
Concus avant 1985. Typiquement : Intel 8086 et Motorola 68000.
Les (nouveaux) processeurs RISC (Reduced Instruction Set)
Instructions de taille fixe, r
eguli`
eres (trois adresses) dont peu font des
transfert avec la memoire. Ils poss` edent en gen
eral beaucoup de registres
(uniformes).
Concus apr`es 1985. Typiquement : Alpha, Sparc et Mips. G4.

La m
emoire

Tous les processeurs modernes comportent une unit e memoire

(MMU) qui permet de manipuler des adresses virtuelles, i.e. de
faire un renommage, transparent pour lutilisateur, entre les
adresses virtuelles du programme et les adresses r
eelles en
memoire.
Cela permet ` a chaque programme de choisir ses adresses
Slide 3
ind
ependemment des autres programmes (qui peuvent etre
ex
ecut
es en m eme temps sur la m eme machine avec les m emes
adresses virtuelles mais des adresses r
eelles diff
erentes).
Du point de vue de lutilisateur, la m
emoire est un (grand)
tableau dont les indices sont les adresses.

2
 Les zones m
emoire

Adresses hautes Stack

y

Slide 4 Donn
ees dynamiques
Allou
ee dynamiquement
Donn
ees statiques
Modifiable
Texte (programme)
Non
ecrivable
Adresses basses R
eserv
e au syst`
eme

Les registres du MIPS

Le MIPS comporte 32 registres g en

eraux interchangeables, sauf
le registre zero qui vaut toujours 0, m eme apr` es une ecriture.
Le registre ra, utilis
e implicitement par certaines instructions
pour sauver ladresse de retour avant un saut.
Les autres registres ont des utilisations pref
erentielles, mais cela
nest strict que pour communiquer avec dautres programmes
Slide 5 (par exemple fournir ou utiliser des programmes en librairies) :
passage (a0, ... a3) et retour (v0, v1) des arguments ;
registres temporaires sauvegard es (s0, .. s7) ou non (t0, ... t9)
par les appels de fonction.
pointeurs de pile sp, fp ou de donn ee gp ;
reserv
es par lassembleur at et le syst`
eme k0, k1.

3
 Le jeu dinstructions

r nom de registre
n une constante enti`
ere
a absolu (n ou `)
` une
etiquette (adresse)
o erande (r ou a)
op

La plupart des instructions suivent le mod` ele

add r1 , r2 , o qui place dans r1 la valeur r2 + o.
Slide 6
Les instructions qui interagissent avec la m emoire sont
uniquement les instructions load et store.
lw r1 , n(r2 ) place dans r1 le mot contenu ` a ladresse r2 + n.
sw r1 , n(r2 ) place r1 dans le mot contenu ` a ladresse r2 + n.
Les instructions de contr ole conditionnel ou inconditionnel :
bne r, a, ` saute ` a ladresse ` si r et a sont differents,
jal o qui sauve pc + 1 dans ra et saute ` etiquette o.
a l

Syntaxe Effet Syntaxe Effet

move r1 , r2 r1 r2 lw r1 , o(r2 ) r1 tas.(r2 + o)

add r1 , r2 , o r1 o + r2 sw r1 , o(r2 ) r1 tas.(r2 + o)
sub r1 , r2 , o r1 r2 o slt r1 , r2 , o r1 r2 < o
mul r1 , r2 , o r1 r2 o sle r1 , r2 , o r1 r2 o
div r1 , r2 , o r1 r2 o seq r1 , r2 , o r1 r2 = o
Slide 7 and r1 , r2 , o r1 r2 land o sne r1 , r2 , o r1 r2 6= o
or r1 , r2 , o r1 r2 lor o j o pc o
xor r1 , r2 , o r1 r2 lxor o jal o ra pc + 1 pc o
sll r1 , r2 , o r1 r2 lsl o beq r, o, a pc a si r = o
srl r1 , r2 , o r1 r2 lsr o bne r, o, a pc a si r 6= o
li r1 , n r1 n syscall appel syst`
eme
la r1 , a r1 a nop ne fait rien

4
 Les appels syst`
emes

Ils permettent linteraction avec le syst`eme dexploitation, et en

dependent. Le num ero de lappel syst`
eme est lu dans v0
(attention, ce nest pas la convention standard). Selon lappel,
un argument suppl ementaire peut etre pass
e dans a0.
Le simulateur SPIM impl
emente les appels suivants :

Slide 8 Nom No Effet

print int 1 imprime lentier contenu dans a0

print string 4 imprime la chane en a0 jusqu`
a \000
read int 5 lit un entier et le place dans v0
sbrk 9 alloue a0 bytes dans le tas,
retourne ladresse du d
ebut dans v0.
exit 10 arr
et du programme en cours dex
ecution
Le jeu dappel syst`
eme d
epend du syst`
eme dexploitation.

Langage dassembleur et langage machine

Le langage dassembleur est un langage symbolique qui donne

des noms aux instructions (plus lisibles que des suites de bits). Il
permet aussi lutilisation d
etiquettes symboliques et de
pseudo-instructions et de modes dadressage surcharg es.
Le langage machine est une suite dinstructions cod ees sur des
mots (de 32 bits pour le MIPS). Les instructions de lassembleur
Slide 9
sont expansees en instructions de la machine `a l
edition de lien.
Les
etiquettes sont donc resolues et les pseudo-instructions
remplacees par une ou plusieurs instructions machine.
Lassemblage est la traduction du langage dassembleur en
langage machine. Le r esultat est un fichier object qui contient,
en plus du code, des informations de relocation qui permettent
de lier (linker) le code de plusieurs programmes ensemble.

5
 Pseudo-instructions

La decompilation du langage machine en langage assembleur est

facile. Elle permet de pr
esenter les instructions machine (mots de
32 bits) sous une forme plus lisible.
Exemple dexpansion (pr
esent
ee sous une forme d
ecompil
ee).

Assembleur Langage machine Commentaire

Slide 10
blt r, o, a slt $1, r, o Justifie le registre at ($1)

bne $1, $0, a r

eserv
e par lassembleur.

li $t0, 400020 lui $1, 6 charge les 16 bits de poids fort

ori $8, $1, 6804 puis les 16 bits de poids faible

add $t0, $t1, 1 addi $8, $9, 1 addition avec une constante

move $t0, $t1 addu $8, $0, $9 addition unsigned avec z

ero

La pico-machine

Cest une machine invent

ee (Pierre Weis et Xavier Leroy) pour
des raisons p
edagogiques.
Cest un mod`
ele simplifi
e de machine RISC, tr`
es proche du MIPS.
Son jeu dinstructions est (pas tout `
a fait) un sous-ensemble du
MIPS.
Slide 11 Une grosse diff
erence de syntaxe... Dans le code 3 adresses,
source et destination sont invers
es :

Code MIPS Pico code signification

nom r1 , o, r2 nom r2 , o, r1 r1 o nom r2

6
 Exemple de programme assembleur

hello.spi
. data
hello : . asciiz hello \n # hello pointe vers hello \n\0
. text
. globl start
start :
Slide 12
li $v0, 4 # la primitive print string
la $a0, hello # a0 l adresse de hello
syscall

Le programme est assembl

e, charg
e puis ex
ecut
e par :
spim notrap file hello . spi

Par convention le programme commence `

a l
etiquette start.
Si on retire loption notrap, le chargeur ajoute un pr
elude qui se
branche `a l
etiquette main (remplacer alors start par main).

if-then-else

On utilise des sauts conditionnels et inconditionnels :

Pascal la fonction minimun

if t1 < t2 then t3 := t1 else t3 := t2

Assembleur Mips
Slide 13
blt $t1, $t2, Then # si t1 >= t2 saut `
a Then
move $t3, $t2 # t3 := t1
j End # saut `a Fi
Then: move $t3, $t1 # t3 := t2
End: # suite du programme

7
 Boucles

Pascal : calcule dans t2 = 0 la somme des entiers de 1 `

a t1
while t1 > 0 do begin t2 := t2 + t1; t1 := t1 1 end

Programme
equivalent Code Mips
While: While:
Slide 14 if t1 <= 0 then goto End ble $t1, $0, End
else
begin
t2 := t2 + t1; add $t2, $t2, $t1
t1 := t1 1; sub $t1, $t1, 1
goto While j While
end;
End: End:

Appel de proc
edure

Pour appeler une proc edure, il faut sauver ladresse de retour `

a
lappel, en g
en
eral dans $ra, pour revenir apr` es lappel.
` la fin dune proc
A edure, on retourne `
a lappelant en sautant `
a
ladresse contenu dans $ra.
Par exemple on d efinit une procedure writeln qui imprime un
Slide 15 entier puis un retour `
a la ligne.
writeln : # largument est dans a0
li $v0, 1 # le num ero de print int
syscall # appel syst`eme
li $v0, 4 # la primitive print string
la $a0, nl # la chane \n
syscall
j $ra # saut `
a l adresse ra

8
 Le programme complet

. data # le tas
nl : . asciiz \n # la chane \n
. text # la z
one code
. globl start
start :
li $a0, 1 # a0 < 1
Slide 16
jal writeln # ra < pc+1; saut `
a writeln
li $a0, 2 # on recommence avec 2
jal writeln
j Exit # saut `
a la fin du programme
writeln :
...
Exit: # fin du programme

Noter la diff
erence entre les instructions j et jal.

Proc
edures r
ecursives

Lorsquune procedure est recursive plusieurs appels imbriqu

es
peuvent
etre actifs simultanement :

a0 v0 1




a0 v0 1




fn fn1 ...
Slide 17


v0 v0 a0






v v a
0 0 0

Cest bien s
ur le m
eme code qui est utilise pour fn et fn1 . Il faut
donc sauver avant lappel recursif la valeur des registres qui
seront (ou risque d
etre) modifies par lappel r
ecursif et dont les
valeurs seront encore necessaires (lues) au retour de lappel.
On utilise la pile.

9
 La pile

Par convention, la pile grossit vers les adresses d

ecroissantes. Le
registre sp pointe vers le dernier mot utilis
e.
Pour sauver un registre r sur la pile
sub $sp, $sp, 4 # alloue un mot sur la pile
sw r , 0( $sp) #ecrit r sur le sommet de la pile
Slide 18 Pour restaurer un mot de la pile dans un registre r
lw r , 0( $sp) # lit le sommet de la pile dans r
add $sp, $sp, 4 # desalloue un mot sur la pile

En gen
eral, on alloue et desalloue lespace en pile par blocs pour
plusieurs temporaires `a la fois.
On peut aussi utiliser la pile pour allouer des tableaux si leur
dur
ee de vie le permet.

Conventions dappel

En general :
les arguments sont pass es dans les registres a0 `
a a3 puis dans
la pile.
la ou les valeurs de retour dans v0 et v1.
De m eme :
les registres ti sont sauv es par lappelant (lappel
e peut les
Slide 19
ecraser)
les registres si sont sauv es par lappel
e (qui doit les remettre
dans letat o`
u il les a pris)
Mais ce nest quune convention ! (celle propos e par le fabriquant)
La respecter permet de comminiquer avec dautres programmes
(qui la respectent
egalement).
Choisir une autre convention est possible tant que lon nint
eragit
pas avec le monde exterieur.

10
 Exemple : calcul de la factorielle

Largument est dans a0, le r

esultat dans v0.
fact : blez $a0, fact 0 # si a0 <= 0 saut ` a fact 0
sub $sp, $sp, 8 # r
eserve deux mots en pile
sw $ra, 0( $sp) # sauve ladresse de retour
sw $a0, 4($sp) # et la valeur de a0
sub $a0, $a0, 1 # decr
ement a0
Slide 20 jal fact # v0 < appel r ecursif (a01)
lw $a0, 4($sp) # r
ecup ere a0
mul $v0, $v0, $a0 # v0 < a0 v0
lw $ra, 0( $sp) # r
ecup ere l adresse de retour
add $sp, $sp, 8 # lib`
ere la pile
j $ra # retour `a l appelant

fact 0 : li $v0, 1 # v0 < 1

j $ra # retour `
a l appelant

Allocation dans le tas

Allocation statique Un espace est r

eserv
e au chargement.
Tableau: # adresse symbolique sur le d
ebut
. align 2 # aligner sur un mot (22 bytes)
. space 4000 # taille en bytes

Slide 21 Allocation dynamique En cours de calcul on peut demander au

syst`
eme dagrandir le tas.
En SPIM, lappel syst`eme num ero 9 prend la taille dans v0 et
retourne le pointeur vers le d
ebut de bloc dans a0.
malloc: # procedure dallocation dynamique
li $v0, 9 # appel syst`
eme n. 9
syscall # alloue une taille a0 et
j $ra # retourne le pointeur dans v0

11
 Gestion de lallocation

En pratique, on alloue un gros tableau Tas (statiquement ou

dynamiquement) dans lequel on salloue des petits blocs.
Par exemple on r
eserve un registre pour pointer sur le premier
emplacement libre du tas.
start :
Slide 22 la $t8, Tas # on r
eserve le registre t8
...
array :
sw $a0, ( $t8) #ecrit la taille dans l ent
ete
add $v0, $t8, 4 # v0 < adresse de la case 0
add $t8, $v0, $a0 # augmente t8 de la taille +1
j $ra

(On ignore ici les probl`

emes de d
ebordement quil conviendrait
de traiter.)

Le byte-code

Cest un jeu dintructions invente pour une machine virtuelle (ou

abstraite) qui est alors interpr
et
e par un programme, lui m
eme
compile dans lassembleur de la machine r eelle.

Avantages : le byte-code est ind ependant de larchitecture, il est

portable (fonctionne sur diff
erentes machines).
Slide 23 Le jeu dinstructions peut
etre mieux adpapt
e au langage
compil
e.

Inconvenient : linterpr
etation du byte-code ajoute au moins un
facteur 5 en temps dex ecution (pour de tr`
es bons byte-codes).

Exemples : Java, Ocaml.

Micro-code : Dans une machine r eelle, les instructions sont en

fait interpr
et
ees par du micro-code (qui lui est vraiment cabl
e).

12
 Exercices

Utilisation de SPIM en td Spim est install e sur les machines de

la salle 33. Dans les autres salles, il faut
eventuellement se loger
`
a distance sur des machines de cette salle linux. (Voir les d etails
dans le version HTML.)

La fonction de Fibonnaci
Slide 24
crire la fonction fib en assembleur MIPS. On pourra commencer
E
par une version simple, inefficace.
crire
E egalement une version optimis ee qui m
emorise les deux
appels precedents dans des registres. On pourra lire lentier au
clavier et limprimer `
a l
ecran.

Compilation des expressions arithm

etiques
On se propose de compiler les expressions arithm etiques en
langage MIPS. On se limitera ` a des expressions avec les 4
operations de bases, les constantes enti`
eres et une seule variable
(qui sera lue au d
ebut du programme dans le flux dentr ee).
Pour simplifier, une expression arithm
etique sera donn ee par sa
syntaxe abstraite, et on prendra la d
efinition de type suivante
Slide 25 (imposee) :
expression. mli
type expression =
| Binexp of binop expression expression
| Int of int
| X ( variable )
and binop = Plus | Minus | Times | Div;;

Pour
eviter les probl`
emes dentr
ee sortie, on
ecrira le programme
`
a compiler sous la forme dun fichier source. Par exemple, pour

13
 compiler lexpression ((x * x) + (1 - x * 2)), on
ecrira le source
dans un fichier
arith. ml
open Expression;;
open Arithmetique;;
let e =
Binexp (Plus,
Binexp (Times, X, X),
Slide 26 Binexp (Minus,
Int 1,
Binexp (Times, X, Int 2)))
in compile e;;

On fabriquera un ex
ecutable arith.out par la commande :
ocamlc o arith.out expression . mli arithmetique. ml arith . ml
puis le fichier de code Spim compil
e en lan
cant cette commande
./ arith . out > arith . spi

Le programme compil e arith.spi devra

etre ex
ecutable sur la
machine SPIM par la commande :
spim notrap file arith . spi
standard,
evalue lexpression, et ainsi de suite tant que lentier lu
est non nul.
Lexercice consiste donc a ecire un fichier source arithmetique.ml
qui implemente la fonction compile : epxressions > unit qui
Slide 27 imprime dans la sortie standard le code spim correspondant ` a
l
evaluattion de lexpression recue en argument.
Dans un premier temps, on ne recherchera pas lefficacit e, mais
la simplicit
e. Par exemple :
on effectue toutes les op erations dans les registres a1 et a2 .
on utilise le registre a3 pour la valeur de la variable, et
on sauve les arguments dans la pile lors dun calcul auxiliaire.
Commencer par une version de la fonction compile qui ne traire
que les cas simples, i.e. o`u lexpression arithm
etique et une

14
 constante, une variable, ou ne contient quune seule op
eration.

Extensions
Cummuler les r esultats auxilliaires, et afficher la somme `
a la
fin.
utiliser les registres au mieux et la pile seulement si n ecessaire.

Slide 28

15