Cours du jour de CCMP2

cmp/20120426-instructionselection.tex

@@ -0,0 +1,133 @@
+\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.