CM3 Assembleur MIPS (suite) - marchett/CM3.pdf · 2 Possibilit e de cr eer de toute pi ece en...

CM3Assembleur MIPS (suite)

Olivier Marchetti (CM-TD-TP) 1 Guillaume Matheron (TD-TP) 2

1Laboratoire d’informatique de Paris 6 – Pole SoC – UPMC

2Institut des Systemes Intelligents et de Robotique – Equipe SYROCO – UPMC

Annee 2017-2018

Instructions de saut ? Fonction ? Remarques programmation

Passer du C a l’assembleur MIPS : rappels (1/3)

Programmer en ensembleur... ou se substituer au compilateur

Savoir precisement ou ecrire, ou lire.

=⇒ orchestrer un va-et-vient entre CPU et RAM.

Pour cela, il faut :

I effectuer des calculs d’adresses memoire,

I charger/decharger certains registres depuis/vers la RAM.

Syntaxe MIPS

Chargement d’un registre (lw : load word) :

lw $t, C($s) ⇐⇒ $t ← RAM[$s + C]

Dechargement d’un registre (sw : store word) :

sw $t, C($s) ⇐⇒ RAM[$s + C] ← $t

1

0

2

@

2 −2| mot |

2 −1| mot |

00101101

01001100

11100000

11000101

00011110

RAM

$Reg

CPU

C

valeur de $svaleur de $s

Olivier Marchetti CM3 – Assembleur MIPS (suite) Annee 2017-2018 2 / 32




Savoir organiser les donnees dans le code assembleur.

=⇒ preciser la localisation en RAM, la nature et la visibilite.

Syntaxe MIPS

Utilisation de directives assembleur dans le code :

I Segment memoire : .data, .text...

I Description des donnees : .asciiz, .word...

I Visibilite : .globl, .extern.

Etiquettes Dir{Seg. mem, visib., donnees} – Instr. Commentaires

↓ ↓ ↓.data

tab ent : .word 1,2,3,4

... ... ...

.text

.globl main # main → global

... ... ...

main : la $r, tab ent # $r ← tab ent

... ... ...





Reinventer les structures de controle en jouant avec desetiquettes assembleurs.

=⇒ organiser des sauts d’instructions avec PC

Syntaxe MIPS

Utilisation d’instructions MIPS dans le code :

I Branchements conditionnels : beq, bne, slt...

I Branchements inconditionnels : j.



Plan

1 Programmation en assembleur MIPS : saut sur instructionsAssembleur MIPS : prendre des decisionsStructure de controle switch - case

2 Programmation en assembleur MIPS : fonctionGeneralites sur les fonctions en MIPSImplementation MIPS de la pile

3 Quelques remarques sur le langage assembleur MIPSProgrammation et conventionsLangage de haut-niveau & langage assembleur


Instructions de saut ? Fonction ? Remarques programmation Branchement ? Switch






Le guidage du flot d’instructions et le langage assembleur (1/5)

Comment orienter le flot d’instructions avec le langage assembleur ?

=⇒ Programmation assembleur = programmation avec goto !

Mem.

dispo.

Tas

données stat.

Programme$pc

$gp.data

.text

Mém

oir

e d

u p

rogra

mm

e

01110 0111000 10

111

j POUR

@ NumLigne

Cycle CDE, langage machine et langage assembleur MIPS

I A chaque passage dans ce cycle, une instruction est lue et PC est ajuste.

I Cette instruction est encodee en binaire en RAM sur 4 octets.

I Programme assembleur = une instruction MIPS par ligne.

I Programme en memoire ≈ suite des instructions encodees sur 4 octets =⇒ toutes adressees !




Peut-on realiser un switch avec des instructions beq, bne et des j Etq ?

=⇒ Oui !

Structure de controle � Selon cas� en C

switch(k) { // avec k de type int.

case 0 : instructions etq 0

break;

case 1 : instructions etq 1

break;

...

case n : instructions etq n

break;

default : instructions etq n

break;

}

Avec dans ce code assembleur :

I $t0 stocke la valeur de k,

I $t1 stocke la valeur 0.

Structure de controle � Selon cas� en MIPS (essai)

1| SELON : beq $t0, $t1, ETQ0 # $pc ← ETQ0

2| addi $t1, $t1, 1 # $t1 ← $t1 + 1

3| beq $t0, $t1, ETQ1 # $pc ← ETQ1

4| addi $t1, $t1, 1 # $t1 ← $t1 + 1

5| ... #

6| beq $t0, $t1, ETQN # $pc ← DEFAUT

7| j DEFAUT #

8| ETQ0 : instructions etq 0 #

9| j SUITE #

10| ... #

11| ETQN : instructions etq n #

12| j SUITE #

13| DEFAUT : instructions defaut #

14| j SUITE #

15| SUITE : #




Est-ce bien un switch ?

=⇒ Non, ce n’est pas un switch !

I Structure switch : branchement entemps constant.

6=I Ici, le nombre de tests effectues sera

borne par le nombre d’etiquettes.

=⇒ Impossible a realiser

avec beq, bne et j.

Structure de controle � Selon cas� en MIPS (essai)

1| SELON : beq $t0, $t1, ETQ0 # $pc ← ETQ0

2| addi $t1, $t1, 1 # $t1 ← $t1 + 1

3| beq $t0, $t1, ETQ1 # $pc ← ETQ1

4| addi $t1, $t1, 1 # $t1 ← $t1 + 1

5| ... #

6| beq $t0, $t1, ETQN # $pc ← DEFAUT

7| j DEFAUT #


9| j SUITE #

10| ... #


12| j SUITE #


14| j SUITE #

15| SUITE : #




Comment realiser convenablement un switch en assembleur ?

=⇒ En s’appuyant sur une table de saut dans le segment des donnees.

I Calculer l’adresse memoire de T SAUT[k] (1).

I Demander le mot memoire d’adresse T SAUT[k] (2 & 3).

I Ajuster PC de sorte a designer l’instruction d’adresse T SAUT[k] (4).




Methodologie pour realiser un switch en assembleur

1 Faire un tableau d’etiquettes T SAUT

dans le segment des donnees.

2 Former l’entier k dans un registre.

3 Former l’adresse memoire deT SAUT[k] (avec la : load address).

4 Charger T SAUT[k] dans un registre.

5 Charger $pc par ce registre.

Saut sur registre – jr $r (jump register)

jr $r

Au niveau registre :

jr $r ⇐⇒ PC ← $r

Structure de controle � Selon cas� en MIPS

1| SELON : sll $t0, $t0, 2 # $t0 ← $t0 × 4

2| la $t1, T SAUT # $t1 ← T SAUT

3| add $t2, $t0, $t1 # $t2 ← @T SAUT[k]

4| lw $t2, 0($t2) # $t2 ← ETQK

5| jr $t2 # $PC ← ETQK


7| j SUITE #


9| j SUITE #

10| ... #


12| j SUITE #


14| j SUITE #

15| SUITE : #

Remarques – Niveau logiciel

X Bien realiser le tableau d’etiquettes.

X Structure peu pratique au niveau lan-gage assembleur.

Remarques – Niveau materiel

√Temps constant & tres efficace.

X Mal exploitee par les architectures modernes (a causede l’instruction jr).


Instructions de saut ? Fonction ? Remarques programmation Fonctions en MIPS ? Implementation MIPS






Programmation vs. Programmation MIPS

Pour bien programmer, de quoi avons-nous besoin ?

1 Realiser des calculs(arithmetiques ou logiques).

2 Effectuer des transferts dedonnees.

3 Manipuler des constantes.

...

7 Effectuer des entrees/sortieselementaires.

8 Disposer de l’abstractionfonction.



Assembleur MIPS : retour sur le concept de fonction

Qu’est-ce qu’une fonction ?

C’est une boıte noire :

I travaillant sur des entreesspecifiques (i.e. typees),

I produisant une unique valeur deretour.

Ces deux caracteristiques definissentune interface pour l’exterieur (larealisation interne importe peu).

. . . .

Sortie

type Sortie f(type Entrée_1,..., type Entrée_k)

Entrée_1

Entrée_k

Concepts et architecture

1 Type, variable, fonction sont des concepts de programmation sans reel analogueen architecture.

2 Possibilite de creer de toute piece en langage assembleur le concept de fonction :

• conserver cette notion de boıte noire,• conserver cette notion d’interface,• definir un mecanisme logiciel/materiel effectif respectant ces deux notions.



Assembleur MIPS : realiser une fonction (1/8)

Comment disposer de l’abstraction de programmation � fonction � en MIPS ?

=⇒ Etiquettes & sauts !

Petit probleme...

Notre fonction assembleur a connaissance de qui l’aappelee...

6= boıte noire.=⇒ ce n’est pas le concept d’une fonction !




Que doit faire le processeur pour realiser un appel de fonction ?

1 Sauvegarderl’adresse consecutivea celle du sited’appel (i.e.l’adresse de retour).

2 Effectuer lebranchement enajustant PC.

3 Executer le code dela fonction appelee.

4 Effectuer lebranchement enajustant PC versl’adresse memoriseeprecedemment.




Comment disposer de l’abstraction de programmation � fonction � en MIPS ?

=⇒ Etiquettes, sauts et liaison & saut sur registre !

Comment l’ordinateur retourne-t-il au point d’appel de la fonction appelante ?

=⇒ sauvegarder dans un registre l’adresse contenue dans $PC lors de l’appel !

Saut et liaison – jal EtqFct (jump and link)

jal EtqFct


jal EtqFct⇐⇒ 1) Sauvegarde de l’adr. de l’instr. suiv.,

$ra ← PC + 4

2) Mise a jour de PC,

PC ← PC + 4[31...28].4×EtqFct

(concatenation des premiers bits $PC et ceux de l’etiquette)

Saut sur registre – jr $r (jump register)

jr $r


jr $r ⇐⇒ PC ← $r

Utilisee avec $ra, cela permet de retournerau point d’appel.




Que doit faire le logiciel pour realiser l’execution d’une telle fonction ?

Juste avant l’appel de la fonction

1 Positionner les arguments aun endroit standard pourl’appelee (usuellement$a0...$a3).

A l’appel

2 Effectuer un branchementde code (i.e. copier leregistre $PC dans $ra eteffectuer un saut).

A l’execution de la fct. appelee

3 Creer en RAM un espacepour ses variables locales.

4 Executer le code.

5 Charger le resultat de lafonction dans un registrepour l’appelant(usuellement $v0, $v1).

6 Recouvrer le flotd’instructions de lafonction appelante.




Qu’arrive-t-il si la fonction appelee en appelle a son tour une autre ?

A l’execution

I Premier appel :

jal somme ⇐⇒ 1) $ra ← µ√

2) PC ← Σ√

I Deuxieme appel :

jal somme⇐⇒ 1) $ra ← χ X2) PC ← Σ X

L’adresse de retour du premier appel a eteecrasee ! ! !

=⇒ un saut avec liaison est insuffisant.

Comment garder la trace des appelsprecedents ?

=⇒ definir et sauvegarder uncontexte d’execution.




Comment organiser en memoire ces contextes d’execution ?

Une fonction se termine lorsque les appels internes de cette fonction sont touscompletes. C’est une politique :

� dernier entre, premier servi �⇐⇒ c’est la pile !

jr $ra

jr $ra

jr $ra

jalmain()

somme(2)

somme(1)

somme(0)

jal

jal

t

+

Début somme(2),

Fin somme(2)

Executer une fonction sur le CPU :

1 Sauvegarder le contexte (i.e. tous les registres necessaires). EMPILER

2 Executer les instructions du corps de la fonction.

3 Restituer le contexte d’execution, et reprendre le flot d’instructions. DEPILER




Ou mettre/recuperer un contexte d’execution de fonction ?

=⇒ En RAM !

$fp

$sp

$sp

$gp

somme(2)d’exécution

Contexte

Pile@ @

Seg. texte

Tas

données stat.

Programme

.text

.data

$pc

RAM

Seg. pile

Mem.

dispo.

Pile

Mém

oir

e d

u p

rogra

mm

e

Seg. données

Cro

issa

nce

de

la p

ile

Contexte

main()d’exécution

somme(1)

Contexted’exécution

$fp

d’exécutionContexte

somme(0)

Pile : registres $fp/$sp (frame/stack pointer)

I $fp definit l’adresse du bloc memoire pilede la fonction courante.

I $sp designe l’adresse du sommet de la pile.

Definir un bloc de pile

1 $fp ← $sp2 $sp ← $sp - TailleBloc

ou TailleBloc est un multiplede 8 octets (alignement memoire).




Comment gerer la sauvegarde/restitution de registres, la pile, le passage des arguments,la valeur de retour ?

=⇒ Selon une convention logicielle entre la fonction appelante et l’appelee.

Registres a sauvegarder lors d’un appel

Nom Numero Usage Appelante Appelee

$v0–$v1 $2–$3 Val. retour [√

] –

et Res. fonction

$a0–$a3 $4–$7 Arg. fonct. [√

] –

$t0–$t7 $8–$15 Temp. [√

] –

$s0–$s7 $16–$23 Temp. sauv. – [√

]

$t8–$t9 $24–$25 Temp. [√

] –

$sp $29 Pointeur pile – [√

]

$fp $30 Pointeur bloc – [√

]

$ra $31 Adr. retour – [√

]

Compilateurs et programmeursrespectent des conventions.

Deux conventions standard : sauvegarde par l’appelante/l’appelee

I Celle qui sauvegarde une donnee se charge egalement de la restituer.

I Limiter les acces a la pile grace a une analyse de l’usage des registres.

I Repartir (et limiter) le code d’appel entre le bloc appelant et le bloc appele.



Assembleur MIPS : implementation d’une pile (1/4)

Comment le logiciel decrit-il un appel standard de fonction ?

=⇒ Cinq etapes : ouverture, prologue, execution, epilogue, final.

1 OUVerture : l’appelante prepare la realisation effective de l’appelee (sauvegardeeventuelle de registres).

2 PROlogue : l’appelee prepare son bloc de donnees sur la pile.

3 EXECUTION : l’appelee execute ses instructions propres.

4 EPIlogue : l’appelee rend la main en restituant le contexte de l’appelant et endepilant son bloc memoire de la pile.

5 FINal : l’appelante restaure eventuellement des registres et reprend le code de lafonction implementee.



Assembleur MIPS : implementation d’une pile – OUVERTURE (2/4)

$fp

$sp

$fp

$sp

Contexte

d’exécution

appelante

$t0...

$t9

@ Etat fin 2

$fp

$sp

Contexte

d’exécution

appelante

(sup. 4 mots)

Libre

@ Etat initial

Contexte

d’exécution

appelante

@ Etat fin 4

$t0...

$t9

...$a0

$a3

Zone

argum

ents

...argSup_k

argSup_1

Ouverture - fonction appelante

1 Sauvegarder (si necessaire) les registres temporaires $t0-$t9.

2 Passage des arguments a l’appelee par les registres $a0-$a3.

3 Empiler les arguments supplementaires.

4 Sauvegarder (si necessaire) les registres arguments $a0-$a3.

5 L’appelante invoque l’appelee par un jal.



Assembleur MIPS : implementation d’une pile – PROLOGUE (3/4)

$fp

$sp

Contexte

appelante

...$a3

$a0

...

d’exécution

Etat initial@

$sp

$fp

Contexte

appelante

...$a3

$a0

...

d’exécution

Etat fin 3@

$sp

$fp

Contexte

appelante

...$a3

$a0

...

d’exécution

@ Etat fin 5

...argSup_k

argSup_1...

argSup_k

argSup_1

[$ra]$fp

...argSup_k

argSup_1

[$ra]$fp

...

...varLoc_1

$s7

$s0

varLoc_k

Si l’appelee comporte unappel (i.e. l’appeleedevient appelante),prevoir un bloc de pileconsequent.

Prologue - fonction appelee

1 Agrandir la pile en ajoutant un bloc memoire (multiple de 8 octets).

$sp ← $sp − TailleBloc

2 Empilement du registre $ra (si l’appelee comporte un appel) et $fp.

3 Ajustement de $fp.

4 Sauvegarde (si necessaire) des registres $s0-$s7.

5 Empilement des variables locales de l’appelee.



Assembleur MIPS : implementation d’une pile – EPILOGUE & FINAL (4/4)

Epilogue – fonction appelee

1 Si l’appelee retourne une valeur, celle-ciest placee dans $v0.

2 Restituer tous les registres sauvegardespar l’appelee lors du prologue (retablir$ra et $fp).

3 Depiler le bloc memoire de l’appelee :

$sp ← $sp + TailleBloc

4 Retourner a l’appelant avec un jr $ra.

$sp

$fp

$fp

$sp

Contexte

appelante

...$a3

$a0

...

d’exécution

@

Contexte

appelante

...$a3

$a0

...

d’exécution

@

Etat initial

Etat final

...argSup_k

argSup_1

[$ra]$fp

...

...varLoc_1

$s7

$s0

varLoc_k

...argSup_k

argSup_1

Final – fonction appelante

1 Restituer tout ce que l’appelante avait sauvegarde lors du prologue.



Assembleur MIPS : Exemple complet

Le programme suivant effectue un appel a une fonction qui realise la somme desn = 10 premiers entiers.

Remarques

1 Un code assembleur depend du materiel, du SE utilise (alignement memoire).

=⇒ contraintes decrites par l’Application Binary Interface.

2 Aucune contrainte d’utilisation des registres usagers (sauf $zero).


Instructions de saut ? Fonction ? Remarques programmation Convention ? C & ASM






Quelques mots sur la convention d’appel

� The nice thing about standards is that you have so many to choose from. �

[Andrew Tanenbaum, Computer Networks, 2nd ed., p. 254]

Code GCC :

I conforme a la convention√

I peu intuitif (usage etrange de $fp & $sp) X

I tres efficace !

registre 6= variable

sauvegarder 6= empiler

restituer 6= depiler

La sauvegarde/restitution des donnees dans la convention

La convention specifie ce processus au niveau code de sorte a garantir :

I l’integrite des donnees du programme,

I le fonctionnement coherent de la pile.

I l’interoperabilite de modules issus de programmes ecrits dans differents langages.

Programmeurs/compilateurs disposent d’une grande liberte pour mettre en oeuvrecette convention.

optimisation en vue√

... certification X



Langage haut-niveau : qu’est-ce qu’un pointeur ?

Quelles differences y-a-t-il entre un pointeur et une variable de type tableau ?

Rappels sur le langage C

Variable pointeur : c’est une variable pouvant contenir une adresse memoire.Variable tableau : c’est un pointeur constant valant l’adresse du 1er element.

Hypotheses : $a0 ← tab et $a1 ← n

Les compilateurs effectuent de puissantes optimisations du code produit.



Langage de haut-niveau : retour sur le passage par valeur/addresse en C

Que se passe-t-il avec les arguments d’une fonction lors de son appel ?

=⇒ Ils sont copies sur la pile dans le contexte d’execution !

Remarques sur le C et l’assembleur

I En C, les arguments d’une fonction sont copies sur la pile.

I Ces recopies ont un coup (acces memoire).

I Utiliser des pointeurs elimine ces recopies =⇒ utile pour les structures !

I Le concept de pointeur est un concept bas-niveau !



Rendre a Cesar ce qui est a Cesar

References bibliographiques utilisees

I � Organisation et conception des ordinateurs �, J. Hennessy & D. Patter-son, Dunod.

I en.wikipedia.org et diverses ressources...

Images utilisees

I Image du transparent 14 :

Sujet : homme reflechissant assis.Source : openclipart.org.

Licence : domaine public.

I Image du transparent 20 : echangeur autorou-tier Los Angeles-Pasadena-Santa-Monica (au-teur : inconnu).


Sujet : icone CPU.Auteur : Oliver Scholtz.Licence : GNU/GPU


Sujet : pouce.Source : openclipart.org.

Licence : domaine public.

I Images du transparent 16 :

Sujet : icones boıtes.Auteur : openclipart.org.Licence : domaine public.


en.wikipedia.org

CM3 Assembleur MIPS (suite) - marchett/CM3.pdf · 2 Possibilit e de cr eer de toute pi ece en...

Documents

Transcript of CM3 Assembleur MIPS (suite) - marchett/CM3.pdf · 2 Possibilit e de cr eer de toute pi ece en...