CM4 Assembleur MIPS (suite)marchett/CM4.pdfRemarques programmation Passer du C a l’assembleur MIPS...

CM4Assembleur MIPS (suite)

Olivier Marchetti (CM-TD-TP) 1

1Laboratoire d’informatique de Paris 6 – Pôle SoC – UPMC

Année 2020-2021

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 précisément où écrire, où lire.

=⇒ orchestrer un va-et-vient entre CPU et RAM.Pour cela, il faut :

I effectuer des calculs d’adresses mémoire,

I charger/décharger certains registres depuis/vers la RAM.

Syntaxe MIPS

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

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

Déchargement 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 CM4 – Assembleur MIPS (suite) Année 2020-2021 2 / 32




Savoir organiser les données dans le code assembleur.

=⇒ préciser la localisation en RAM, la nature et la visibilité.

Syntaxe MIPS

Utilisation de directives assembleur dans le code :

I Segment mémoire : .data, .text...

I Description des données : .asciiz, .word...

I Visibilité : .globl, .extern.

Etiquettes Dir{Seg. mém, visib., données} – Instr. Commentaires↓ ↓ ↓

.data

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

... ... ...

.text

.globl main # main → global... ... ...

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





Réinventer les structures de contrôle en jouant avec desétiquettes 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 décisionsStructure de contrôle switch - case

2 Programmation en assembleur MIPS : fonctionGénéralités sur les fonctions en MIPSImplémentation 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 POU

R

@ 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 encodée en binaire en RAM sur 4 octets.

I Programme assembleur = une instruction MIPS par ligne.

I Programme en mémoire ≈ suite des instructions encodées sur 4 octets =⇒ toutes adressées !




Peut-on réaliser un switch avec des instructions beq, bne et des j Etq ?

=⇒ Oui !

Structure de contrôle � 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 contrôle � Selon cas� en MIPS (essai)

1| SELON : beq $t0, $t1, ETQ0 # $pc ← ETQ02| addi $t1, $t1, 1 # $t1 ← $t1 + 13| beq $t0, $t1, ETQ1 # $pc ← ETQ14| addi $t1, $t1, 1 # $t1 ← $t1 + 15| ... #

6| beq $t0, $t1, ETQN # $pc ← DEFAUT7| 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 effectués sera

borné par le nombre d’étiquettes.

=⇒ Impossible à réaliseravec beq, bne et j.

Structure de contrôle � Selon cas� en MIPS (essai)

1| SELON : beq $t0, $t1, ETQ0 # $pc ← ETQ02| addi $t1, $t1, 1 # $t1 ← $t1 + 13| beq $t0, $t1, ETQ1 # $pc ← ETQ14| addi $t1, $t1, 1 # $t1 ← $t1 + 15| ... #

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


9| j SUITE #

10| ... #


12| j SUITE #


14| j SUITE #

15| SUITE : #




Comment réaliser convenablement un switch en assembleur ?

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

I Calculer l’adresse mémoire de T SAUT[k] (1).

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

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




Méthodologie pour réaliser un switch en assembleur

1 Faire un tableau d’étiquettes T SAUTdans le segment des données.

2 Former l’entier k dans un registre.

3 Former l’adresse mémoire 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 contrôle � Selon cas� en MIPS

1| SELON : sll $t0, $t0, 2 # $t0 ← $t0 × 42| la $t1, T SAUT # $t1 ← T SAUT3| add $t2, $t0, $t1 # $t2 ← @T SAUT[k]4| lw $t2, 0($t2) # $t2 ← ETQK5| jr $t2 # $PC ← ETQK6| ETQ0 : instructions etq 0 #

7| j SUITE #


9| j SUITE #

10| ... #


12| j SUITE #


14| j SUITE #

15| SUITE : #

Remarques – Niveau logiciel

X Bien réaliser le tableau d’étiquettes.

X Structure peu pratique au niveau lan-gage assembleur.

Remarques – Niveau matériel

√Temps constant & très efficace.

X Mal exploitée par les architectures modernes (à causede l’instruction jr).


Instructions de saut ? Fonction ? Remarques programmation Fonctions en MIPS ? Implémentation MIPS






Programmation vs. Programmation MIPS

Pour bien programmer, de quoi avons-nous besoin ?

1 Réaliser des calculs(arithmétiques ou logiques).

2 Effectuer des transferts dedonnées.

3 Manipuler des constantes.

...

7 Effectuer des entrées/sortiesélémentaires.

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 entréesspécifiques (i.e. typées),

I produisant une unique valeur deretour.

Ces deux caractéristiques définissentune interface pour l’extérieur (laréalisation 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 réel analogueen architecture.

2 Possibilité de créer de toute pièce en langage assembleur le concept de fonction :

• conserver cette notion de bôıte noire,• conserver cette notion d’interface,• définir un mécanisme logiciel/matériel effectif respectant ces deux notions.



Assembleur MIPS : réaliser une fonction (1/8)

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

=⇒ Etiquettes & sauts !

Petit problème...

Notre fonction assembleur a connaissance de qui l’aappelée...

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




Que doit faire le processeur pour réaliser un appel de fonction ?

1 Sauvegarderl’adresse consécutiveà celle du sited’appel (i.e.l’adresse de retour).

2 Effectuer lebranchement enajustant PC.

3 Exécuter le code dela fonction appelée.

4 Effectuer lebranchement enajustant PC versl’adresse mémoriséeprécédemment.




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

(concaténation des premiers bits $PC et ceux de l’étiquette)

Saut sur registre – jr $r (jump register)

jr $r


jr $r ⇐⇒ PC ← $r

Utilisée avec $ra, cela permet de retournerau point d’appel.




Que doit faire le logiciel pour réaliser l’exécution d’une telle fonction ?

Juste avant l’appel de la fonction

1 Positionner les arguments àun endroit standard pourl’appelée (usuellement$a0...$a3).

A l’appel

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

A l’exécution de la fct. appelée

3 Créer en RAM un espacepour ses variables locales.

4 Exécuter le code.

5 Charger le résultat 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 appelée en appelle à son tour une autre ?

A l’exécution

I Premier appel :

jal somme ⇐⇒ 1) $ra ← µ√

2) PC ← Σ√

I Deuxième appel :

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

√

L’adresse de retour du premier appel a étéécrasée ! ! !

=⇒ un saut avec liaison est insuffisant.

Comment garder la trace des appelsprécédents ?

=⇒ définir et sauvegarder uncontexte d’exécution.




Comment organiser en mémoire ces contextes d’exécution ?

Une fonction se termine lorsque les appels internes de cette fonction sont touscomplétés. 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)

Exécuter une fonction sur le CPU :

1 Sauvegarder le contexte (i.e. tous les registres nécessaires). EMPILER

2 Exécuter les instructions du corps de la fonction.

3 Restituer le contexte d’exécution, et reprendre le flot d’instructions. DEPILER




Où mettre/récupérer un contexte d’exécution 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 définit l’adresse du bloc mémoire pilede la fonction courante.

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

Définir un bloc de pile

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

où TailleBloc est un multiplede 8 octets (alignement mémoire).




Comment gérer 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’appelée.

Registres à sauvegarder lors d’un appel

Nom Numéro Usage Appelante Appelée

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

] –

et Rés. 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’appelée

I Celle qui sauvegarde une donnée se charge également de la restituer.

I Limiter les accès à la pile grâce à une analyse de l’usage des registres.

I Répartir (et limiter) le code d’appel entre le bloc appelant et le bloc appelé.



Assembleur MIPS : implémentation d’une pile (1/4)

Comment le logiciel décrit-il un appel standard de fonction ?

=⇒ Cinq étapes : ouverture, prologue, exécution, épilogue, final.

1 OUVerture : l’appelante prépare la réalisation effective de l’appelée (sauvegardeéventuelle de registres).

2 PROlogue : l’appelée prépare son bloc de données sur la pile.

3 EXECUTION : l’appelée exécute ses instructions propres.

4 EPIlogue : l’appelée rend la main en restituant le contexte de l’appelant et endépilant son bloc mémoire de la pile.

5 FINal : l’appelante restaure éventuellement des registres et reprend le code de lafonction implémentée.



Assembleur MIPS : implémentation 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 nécessaire) les registres temporaires $t0-$t9.2 Passage des arguments à l’appelée par les registres $a0-$a3.3 Empiler les arguments supplémentaires.

4 Sauvegarder (si nécessaire) les registres arguments $a0-$a3.5 L’appelante invoque l’appelée par un jal.



Assembleur MIPS : implémentation 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’appelée comporte unappel (i.e. l’appeléedevient appelante),prévoir un bloc de pileconséquent.

Prologue - fonction appelée

1 Agrandir la pile en ajoutant un bloc mémoire (multiple de 8 octets).

$sp ← $sp − TailleBloc2 Empilement du registre $ra (si l’appelée comporte un appel) et $fp.3 Ajustement de $fp.4 Sauvegarde (si nécessaire) des registres $s0-$s7.5 Empilement des variables locales de l’appelée.



Assembleur MIPS : implémentation d’une pile – EPILOGUE & FINAL (4/4)

Epilogue – fonction appelée

1 Si l’appelée retourne une valeur, celle-ciest placée dans $v0.

2 Restituer tous les registres sauvegardéspar l’appelée lors du prologue (rétablir$ra et $fp).

3 Dépiler le bloc mémoire de l’appelée :

$sp ← $sp + TailleBloc4 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 de l’ouverture.



Assembleur MIPS : Exemple complet

Le programme suivant effectue un appel à une fonction qui réalise la somme desn = 10 premiers entiers.

Remarques

1 Un code assembleur dépend du matériel, du SE utilisé (alignement mémoire).

=⇒ contraintes décrites 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 étrange de $fp & $sp) XI très efficace !

registre 6= variable

sauvegarder 6= empiler

restituer 6= dépiler

La sauvegarde/restitution des données dans la convention

La convention spécifie ce processus au niveau code de sorte à garantir :

I l’intégrité des données du programme,

I le fonctionnement cohérent de la pile.

I l’interopérabilité de modules issus de programmes écrits dans différents 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 différences 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 mémoire.Variable tableau : c’est un pointeur constant valant l’adresse du 1er élément.

Hypothèses : $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 copiés sur la pile dans le contexte d’exécution !

Remarques sur le C et l’assembleur

I En C, les arguments d’une fonction sont copiés sur la pile.

I Ces recopies ont un coup (accès mémoire).

I Utiliser des pointeurs élimine ces recopies =⇒ utile pour les structures !I Le concept de pointeur est un concept bas-niveau !



Rendre à César ce qui est à César

Références bibliographiques utilisées

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

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

Images utilisées

I Image du transparent 14 :

Sujet : homme réfléchissant assis.Source : openclipart.org.

Licence : domaine public.

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


Sujet : icône CPU.Auteur : Oliver Scholtz.Licence : GNU/GPU


Sujet : pouce.Source : openclipart.org.

Licence : domaine public.

I Images du transparent 16 :

Sujet : icônes bôıtes.Auteur : openclipart.org.Licence : domaine public.


en.wikipedia.org

Programmation en assembleur MIPS : saut sur instructionsAssembleur MIPS : prendre des décisionsStructure de contrôle switch - case

Programmation en assembleur MIPS : fonctionGénéralités sur les fonctions en MIPSImplémentation MIPS de la pile

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

CM4 Assembleur MIPS (suite)marchett/CM4.pdfRemarques programmation Passer du C a l’assembleur MIPS...

Documents

Transcript of CM4 Assembleur MIPS (suite)marchett/CM4.pdfRemarques programmation Passer du C a l’assembleur MIPS...