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 d
ecrite dans le livre Le langage Caml de
Pierre Weis et Xavier Leroy.
Le simulateur SPIM du processeur MIPS R2000 est pr
esent
e
succinctement ci-dessous. Voir aussi son manuel de r
ef
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)
Con
cus 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 m
emoire. Ils poss`
edent en g
en
eral beaucoup de registres
(uniformes).
Con
cus apr`
es 1985. Typiquement : Alpha, Sparc et Mips. G4.

La m
emoire
Tous les processeurs modernes comportent une unit
e m
emoire
(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
m
emoire.
Slide 3

Cela permet `
a chaque programme de choisir ses adresses
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.

Les zones m
emoire
Adresses hautes

Stack

Donn
ees dynamiques

Slide 4

Allou
ee dynamiquement
Donn
ees statiques
Modifiable
Texte (programme)
Non
ecrivable
Adresses basses

R
eserv
e au syst`
eme

Les registres du MIPS

Slide 5

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 pr
ef
erentielles, mais cela
nest strict que pour communiquer avec dautres programmes
(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 ;
r
eserv
es par lassembleur at et le syst`
eme k0, k1.

Le jeu dinstructions

Slide 6

Slide 7

une constante enti`

ere

une
etiquette (adresse)

nom de registre

absolu (n ou `)

op
erande (r ou a)

La plupart des instructions suivent le mod`

ele
add r1 , r2 , o qui place dans r1 la valeur r2 + o.
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 diff
erents,
jal o qui sauve pc + 1 dans ra et saute `
a l
etiquette o.

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

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

Les appels syst`

emes
Ils permettent linteraction avec le syst`
eme dexploitation, et en
d
ependent. 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

imprime lentier contenu dans a0

print string

imprime la chane en a0 jusqu`

a \000

read int

lit un entier et le place dans v0

sbrk

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.

Slide 9

Le langage machine est une suite dinstructions cod

ees sur des
mots (de 32 bits pour le MIPS). Les instructions de lassembleur
sont expans
ees en instructions de la machine `
a l
edition de lien.
Les
etiquettes sont donc r
esolues et les pseudo-instructions
remplac
ees 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.

Pseudo-instructions
La d
ecompilation 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).

Slide 10

Assembleur

Langage machine

Commentaire

blt r, o, a

slt $1, r, o

Justifie le registre at ($1)

bne $1, $0, a

r
eserv
e par lassembleur.

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

li

$t0, 400020

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

Exemple de programme assembleur

hello.spi
hello :

. data
. asciiz
. text
. globl

hello \n

# hello pointe vers hello \n\0

start

start :
Slide 12

li
$v0, 4
la
$a0, hello
syscall

# la primitive print string

# a0 l adresse de hello

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

Then:
End:

blt
$t1, $t2, Then
move $t3, $t2
j
End
move $t3, $t1

#
#
#
#
#

si t1 >= t2 saut `
a Then
t3 := t1
saut `
a Fi
t3 := t2
suite du programme

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
Code Mips

Programme
equivalent

Slide 14

While:
if t1 <= 0 then goto End
else
begin
t2 := t2 + t1;
t1 := t1 1;
goto While
end;
End:

While:
ble

$t1, $0, End

add $t2, $t2, $t1

sub $t1, $t1, 1
j
While
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.

Slide 15

Par exemple on d
efinit une proc
edure writeln qui imprime un
entier puis un retour `
a la ligne.
writeln :
li
$v0, 1
syscall
li
$v0, 4
la $a0, nl
syscall
j
$ra

#
#
#
#
#

largument est dans a0

le num
ero de print int
appel syst`
eme
la primitive print string
la chane \n

# saut `
a l adresse ra

Le programme complet

nl :

. data
. asciiz
. text
. globl

\n

# le tas
# la chane \n
# la z
one code

start

start :
li
jal
li
jal
j

Slide 16

$a0, 1
writeln
$a0, 2
writeln
Exit

# a0 < 1
# ra < pc+1; saut `
a writeln
# on recommence avec 2
# 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

Slide 17

Lorsquune proc
edure est r
ecursive plusieurs appels imbriqu
es
peuvent
etre actifs simultan
ement :

a0 v0 1

a0 v0 1
fn
fn1
...

v0 v0 a0

v v a
0
0
0
Cest bien s
ur le m
eme code qui est utilis
e pour fn et fn1 . Il faut
donc sauver avant lappel r
ecursif la valeur des registres qui
seront (ou risque d
etre) modifi
es par lappel r
ecursif et dont les
valeurs seront encore n
ecessaires (lues) au retour de lappel.
On utilise la pile.

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
sw r , 0( $sp)
Slide 18

# alloue un mot sur la pile

#
ecrit r sur le sommet de la pile

Pour restaurer un mot de la pile dans un registre r

lw r , 0( $sp)
add $sp, $sp, 4

# lit le sommet de la pile dans r

# d
esalloue un mot sur la pile

En g
en
eral, on alloue et d
esalloue 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

Slide 19

En g
en
eral :
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

ecraser)
les registres si sont sauv
es par lappel
e (qui doit les remettre
dans l
etat 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 ext
erieur.

10

Exemple : calcul de la factorielle

Largument est dans a0, le r
esultat dans v0.
fact :

Slide 20

blez
sub
sw
sw
sub
jal
lw
mul
lw
add
j

fact 0 : li
j

si a0 <= 0 saut `
a fact 0
r
eserve deux mots en pile
sauve ladresse de retour
et la valeur de a0
d
ecr
ement a0
v0 < appel r
ecursif (a01)
r
ecup
ere a0
v0 < a0 v0
r
ecup
ere l adresse de retour
lib`
ere la pile
retour `
a l appelant

$a0, fact 0
$sp, $sp, 8
$ra, 0( $sp)
$a0, 4($sp)
$a0, $a0, 1
fact
$a0, 4($sp)
$v0, $v0, $a0
$ra, 0( $sp)
$sp, $sp, 8
$ra

#
#
#
#
#
#
#
#
#
#
#

$v0, 1
$ra

# v0 < 1
# retour `
a l appelant

Allocation dans le tas

Allocation statique Un espace est r
eserv
e au chargement.
Tableau:
. align 2
. space 4000
Slide 21

# adresse symbolique sur le d

ebut
# aligner sur un mot (22 bytes)
# taille en bytes

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:
li $v0, 9
syscall
j $ra

#
#
#
#

proc
edure dallocation dynamique
appel syst`
eme n. 9
alloue une taille a0 et
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

sw
add
add
j

$a0, ( $t8)
#
ecrit la taille dans l ent
ete
$v0, $t8, 4
# v0 < adresse de la case 0
$t8, $v0, $a0 # augmente t8 de la taille +1
$ra

array :

(On ignore ici les probl`

emes de d
ebordement quil conviendrait
de traiter.)

Le byte-code
Cest un jeu dintructions invent
e pour une machine virtuelle (ou
abstraite) qui est alors interpr
et
e par un programme, lui m
eme
compil
e 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.
Inconv
enient : 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 c
abl
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 pr
ec
edents 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
op
erations de bases, les constantes enti`
eres et une seule variable
(qui sera lue au d
ebut du programme dans le flux dentr
ee).

Slide 25

Pour simplifier, une expression arithm

etique sera donn
ee par sa
syntaxe abstraite, et on prendra la d
efinition de type suivante
(impos
ee) :

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

Slide 26

open Expression;;
open Arithmetique;;
let e =
Binexp (Plus,
Binexp (Times, X, X),
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.

Slide 27

Lexercice consiste donc a

ecire un fichier source arithmetique.ml
qui impl
emente la fonction compile : epxressions > unit qui
imprime dans la sortie standard le code spim correspondant `
a
l
evaluattion de lexpression re
cue 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