\chapter{Instruction selection}

\section{Microprocesseur}

\subsection{CISC -- Complex Instruction Set Chip}

6, 8, 16 registres, certain pour des pointeurs, d'autres pour des entiers, etc.

Les opérations mathématiques peuvent être faites en mémoire.

Il peut y avoir des effets de bords (auto-incrémentation, \ldots)

\subsection{RISC -- Reduced Instruciton Set Chip}

Généralement un plus grand nombre de registres. Sur certaines machines, une
partie est cachée (ou utilisé pour le passage d'arguments avec les fenêtres).

On ne peut faire de l'arithmétique que sur des registres (pas directement en
mémoire).

Les fonctions \verb+load+ et \verb+store+ sont relatives à un registres.

Il y a peu d'instructions et elles ne font qu'une seule action à la fois, sans
effet de bord.

\subsection{MIPS}

\subsubsection{Registres}

Tous les 32 registres sont équivalents, ceci dit, il y a des conventions.

Le premier registre contient toujours la constante 0. Le registre 1 est réservé
à l'assembleur et les registres 26 et 27 sont quant à eux réservés au système
d'exploitation.\\

Les derniers registres gérent le stack pointer (29), le frame pointer (30) et
l'adresse de retour (31).\\

Comme en Sparc et dans la norme Épita, il n'est possible de passer que 4
arguments via les registres 4 à 7.

Le résultat de la fonctions est retourné via les registres 2 et 3.

\subsubsection{Instructions RISC typiques}

L'assembleur est capable de sélectionner intelligemment les instructions (par
exemple, si l'on fait un \verb+add+ avec une constante et un registre, il
sélectionnera \verb+addi+).\\

À ce stade, on n'a plus d'information sur les types des données. C'est pourquoi
on utilise les instructions pour sauvegarder ces informations (par exemple pour
\verb+add+, on a \verb+addu+ pour faire une addition sans overflow).

La multiplication et la division se font sans passer de registre de destination
afin d'avoir une plus grande précision.\\

Les opérations logiques (\verb+and+, \verb+andi+, \verb+not+, \verb+rol+,
\verb+sll+, \ldots) font les mêmes choses qu'en C, mais sur les mots binaires.

On a des instruction de comparaison~: \verb+seq+, \verb+sge+, \verb+sgt+,
\ldots\\

On a deux types de branchement inconditionnel (vers une étiquette ou une
adresse donnée)~: \verb+b+, \verb+j+, \verb+jal+ (très pratique pour les appels
de fonctions, il fait tout~!). Entre \verb+b+ et \verb+j+, il y a un problème
de taille.

Traduire un CJUMP, c'est avec \verb+bczt+ et \verb+bczf+ ça utilise le
coprocesseur pour faire un branchement en fonction de la valeur de \verb+z+.\\

On a aussi des instructions de branchement conditionnel (\verb+bge+, \ldots).

Il y a aussi des instructions qui permettent de contrôler le processeur
(\verb+syscall+ qui permet de déclencher des appels système, \verb+rfe+ qui
restaure le registre de statut, \verb+break+ qui déclenche une exception
particulière et bien sur \verb+nop+).\\

On a plein d'instruction de chargement \verb+ld+, \verb+lw+, \verb+ulw+, \ldots
mais bon, il y en a tellement qu'il y en a forcément une qui charge ce qu'on
veut où l'on veut. Et puis c'est exactement la même merde pour les
\verb+store+. Et idem pour les \verb+move+ (il y a des instructions pour
utiliser les registres flottant).\\

Pour les opérations flottantes, on a un coprocesseur qui est appelé par
certaines instructions. Il utilise des registres particuliers qu'il faut penser
à définir. Pareil pour les flags, il en utilise d'autres. Les instructions
flottantes sont sur 32 ou 64 bits (\verb+.s+ single (32 bits) ou \verb+.d+
double (64 bits) à la fin des instructions et puis il y a \verb+.w+ quand on
utilise un mot utilisé pour les convertions (un mot c'est un entier par
définition)).\\

On remarque qu'il n'y a donc pas beaucoup d'instructions :p

\section{Le compilateur Tiger}

On utilise Mips parce que c'est simple et facile. C'est assez moderne
d'ailleurs apparemment.

Il existe un émulateur \textsc{mips}~: \textsc{spim} qui est fourni avec une superbe
interface graphique \textsc{xspim} qui permet de visualiser l'état courrant du
processeur (registres, boutons de contrôle, data, texte, \ldots).

\subsection{Factorielle}

Voir l'exemple d'assembleur tout bête sur les slides.

\subsection{Nolimips}

Un nouvel émulateur \textsc{mips}, il fait un peu plus de chose comme
l'exécution d'instruction pas-à-pas. Son principal avantage est de supporter un
nombre de registre infini~!\\

Il a été fait par un étudiant de la promo 2004.

\section{Sélection d'instruction}

L'idée c'est de traduire une instruction comme \verb+a[i] := x+ avec \verb+x+
une valeur en mémoire et \verb+a[i]+ est dans un registre.\\

Le schéma des slides se lit plutôt de bas en haut.
Le \verb+a[i]+ se décompose en deux parties~: on fait \verb-a+i- pour obtenir
l'adresse de la case du tableau. La première partie détermine \verb+a+ puis
ensuite on calcul le décalage à appliquer pour avoir la case \verb+i+.

Au final, on \verb+load+, \verb+addi+ (pour avoir la constante 4 dans un
registre, 4 pour la taille d'un mot), \verb+mul+ (multiplication de i par la
taille précédemment calculée), \verb+add+ (calcul de la position de la case),
\verb+load+ (on charge \verb+x+) puis \verb+store+ (on stocke \verb+x+ dans la
case donnée).

D'autres traductions sont possibles (avec plus d'opérations ou avec des
instructions plus complexes). Le mieux étant d'avoir le moins d'instructions
couteuses.
