Principes de Fonctionnement
des Ordinateurs
- Coder pour un microprocesseur -

Frédéric Boulanger
frederic.boulanger@centralesupelec.fr

CentraleSupélec
3e année mention Science du logiciel

Traduction des langages de programmation

Fossé sémantique

Les langages de programmation proposent des concepts abstraits qui sont absents de ce que propose un microprocesseur :
  • types de données
  • structures de contrôle :
    • if … then … else
    • while
    • fonctions
Cette différence de niveaux d'abstraction est appelée fossé sémantique
La tendance actuelle est de privilégier les performances, et de laisser les compilateurs et interpréteurs combler le fossé sémantique.

Représentation des données

Pour le microprocesseur

  • mots de 8, 16, 32 ou 64 bits
  • trois interprétations :
    • code d'une instruction
    • adresse
    • donnée

Langages de programmation

  • booléens, entiers, flottants, caractères, types structurés (tableaux, …)
  • Représentation :
    • booléens : faux = 0, vrai = 1
    • entiers : complément à 2
    • flottants : norme IEEE 754
    • caractères : Unicode, UTF-8
    • tableaux et structures : mots consécutifs en mémoire

Structures de contrôle

Pour le microprocesseur

  • cmp
  • b, beq, blt

Langages de programmation

  • comparaisons variées : <=, <, ==, >, >=
  • boucles for et while
  • définition et appel de fonction, récursion
Comment coder ces structures de contrôle ?

Conditions

  • a < b : cmp a, b; blt vrai
  • a <= b : idem que not b < a, d'où : cmp b, a; blt faux
  • a == b : cmp a, b; beq vrai
  • a != b : cmp a, b; beq faux
  • a > b : cmp b, a; beq vrai
  • a >= b : cmp a, b; blt faux

Conditions - Exemple 1

Code Python


if r0 < r1 :
  r0 = r1 - r0
else :
  r1 = r0 - r1

Code machine


        cmp r0, r1
        blt vrai
        sub r1, r0, r1
        b   fin
@vrai   sub r0, r1, r0
@fin

Conditions - Exemple 2

Code Python


if r0 <= r1 :
  r0 = r1 - r0
else :
  r1 = r0 - r1

Code machine


        cmp r1, r0
        blt faux
@vrai   sub r0, r1, r0
        b   fin
@faux   sub r1, r0, r1
@fin

Boucles

Se codent comme un if avec un branchement à la fin
pour revenir au début de la boucle

Code Python


r2 = 0
while r0 >= r1 :
  r0 = r0 - r1
  r2 = r2 + 1

Code machine


        mov r2, #0
@boucle cmp r0, r1
        blt fin
        sub r0, r0, r1
        add r2, r2, #1
        b   boucle
@fin

Boucles - autre exemple

Code Python


while r0 < r1 :
  r1 = r1 - 1

Code machine


@boucle cmp r0, r1
        blt ok
        b   fin
@ok     sub r1, r1, #1
        b   boucle
@fin

Fonctions

Définition

  • une fonction peut être identifiée à l'adresse de sa première instruction
  • … mais que fait-on à la fin ?
  • les arguments peuvent être passés dans des registres
  • … mais s'il y en a plus de 8 ?

Appel

  • on place les arguments dans des registres
  • et on saute à l'adresse de la fonction (b func)
  • les arguments peuvent être passés dans des registres
  • … mais comment revient-on après l'appel ?

Fonctions

Solution

  • on place les arguments dans des registres
  • on mémorise dans un registre (r7)
    l'adresse de l'instruction qui suit l'appel
  • et on saute à l'adresse de la fonction (b func)
  • la fonction place son résultat dans un registre (r0)
  • et saute à l'adresse contenue dans (r7)

Fonctions

Exemple


% r0 <- r0 * r1
@mult   mov r2, #0
@loop   cmp r0, #0
        beq fin
        add r2, r2, r1
        sub r0, r0, #1
        b   loop
@fin    mov r0, r2
        b   r7
				

% programme principal
@main   mov r0, #3
        mov r1, #4
        mov r7, #next
        b   mult
@next   mov r1, #2
        mov r7, #nexxt
        b   mult
@nexxt  mov r2, r0
        …

Fonctions

Problèmes

  • la fonction mult modifie r2
  • que se passe-t-il si mult appelle une autre fonction ?
  • comment préserver la valeur de r7 ?
  • comment traiter les fonctions récursives ?

Solution

  • on utilise une zone de mémoire pour sauvegarder les registres
  • structure LIFO (Last In First Out) = pile

La pile

Principe

  • zone de mémoire de taille variable
  • les données sont ajoutées au sommet (push)
  • les données sont enlevées au sommet (pop)
  • le sommet est indiqué par le pointeur de pile (SP = Stack Pointer)

La pile

Opérations

  • Push (empiler)
    • on incrémente le pointeur de pile
    • on écrit la nouvelle donnée au sommet
  • Pop (déplier)
    • on lit la donnée située au sommet de la pile
    • on décrémente le pointeur de pile

La pile

Push r0

Pop r0

Fonctions

Avec pile


% r0 <- r0 * r1
@mult   push r2
        mov  r2, #0
@loop   cmp  r0, #0
        beq  fin
        add  r2, r2, r1
        sub  r0, r0, #1
        b    loop
@fin    mov  r0, r2
        pop  r2
        b    r7
				

% programme principal
@main   mov  sp, #stack
        mov  r0, #3
        mov  r1, #4
        mov  r7, #next
        b    mult
@next   mov  r1, #2
        mov  r7, #nexxt
        b    mult
@nexxt  mov  r2, r0
        …
@stack  rmw  1

Fonctions récursives


% mult(r0, r1) =
%   0 si r0 = 0
%   r1 + mult(r0-1, r1) sinon
@mult  push r2
       mov  r2, #0
@loop  cmp  r0, #0
       beq  fin
       sub  r0, r0, #1
       push r7
       mov  r7, #mlnxt
       b    mult
@mlnxt pop  r7
       add  r2, r0, r1
@fin   mov  r0, r2
       pop  r2
       b    r7
				

% programme principal
@main  mov sp, #stack
       mov r0, #3
       mov r1, #4
       mov r7, #next
       b   mult
@next  mov r1, #2
       mov r7, #nexxt
       b   mult
@nexxt mov r2, r0
       ...
@stack rmw  1

Fonctions

Instruction bl

bl rx, adresse
  • copie le PC dans rx
  • saute à adresse
  • bl = Branch and Link

Utilisation

Au lieu de : 

        mov  r7, #next
        b    func
@next   …
On écrit simplement : 
bl r7, func

Pile et Tas

Pile

La pile contient :

  • les paramètres des fonctions
  • les adresses de retour
  • les valeurs des registres sauvegardés
  • les variables locales

Tas

Le tas contient les données allouées dynamiquement :

  • tableaux
  • chaînes de caractères
  • objets

Pile et Tas

Si la pile rencontre le tas $\Rightarrow$ stack overflow !

Suite…

Mémoires