Le but de ce TP est d’introduire des premières bases qui serviront à la programmation en assembleur sur des processeurs 32 bits d’architecture x86, sous Linux, et en mode protégé.

Exercice 1. (Nombre de données)

Dessiner un tableau à deux lignes dont la ligne du haut est indexée par les entiers allants de \(0\) jusqu’à \(16\) et la ligne du bas contient les valeurs \(2^0\) jusqu’à \(2^{16}\). Apprendre ce tableau par cœur.
Combien de données différentes peut-on coder sur \(n\) bits ?
Combien de données différentes peut-on coder sur \(n\) octets ?
Combien de données différentes peut-on coder sur \(n\) \(\mathrm{Kio}\) ?
Combien de données différentes peut-on coder sur \(n\) \(\mathrm{Mio}\) ?
Combien de données différentes peut-on coder sur \(n\) \(\mathrm{Gio}\) ?

1 Représentation des entiers

Exercice 2. (Changements de base)

Représenter la valeur \((999)_{\mathrm{dix}}\) en base deux, en base quatre et enfin en base seize. L’exécution de l’algorithme de changement de base doit être illustrée pas à pas.

Note : en base 16, on utilise les lettre abcdef pour compléter les 10 chiffres usuels.
Représenter la valeur \((1002)_{\mathrm{trois}}\) en base dix.

Exercice 3. (Binaire et hexadécimal)

Représenter la valeur \((\texttt{10101011111000000000001})_{\mathrm{deux}}\) en hexadécimal en utilisant la méthode de conversion rapide traduisant chaque suite de quatre bits en une lettre hexadécimale.
Représenter la valeur \((\texttt{2BABA101F9})_{\mathrm{seize}}\) en binaire en utilisant la méthode de conversion rapide traduisant chaque lettre hexadécimale en une suite de quatre bits.

Exercice 4. (Représentation avec biais)

Représenter sur \(n := 8\) bits avec un biais de \(k := 1000\) la valeur \((-950)_{\mathrm{dix}}\) en représentation avec biais.
Représenter sur \(n = 16\) bits avec un biais de \(k := 256\) la valeur \((0)_{\mathrm{dix}}\) en représentation avec biais.
Donner la valeur décimale représentée par la suite de bits \((\texttt{00000000})_{\mathrm{biais}=21}\).
Donner la valeur décimale représentée par la suite de bits \((\texttt{0000000000010001})_{\mathrm{biais}=17}\).
Donner la valeur décimale représentée par la suite de bits \((\texttt{00010001})_{\mathrm{biais}=1777}\).

Exercice 5. (Représentation en complément à deux)

Représenter sur \(n := 8\) bits la valeur \((17)_{\mathrm{dix}}\) selon la représentation en complément à deux.
Représenter sur \(n := 8\) bits la valeur \((-1)_{\mathrm{dix}}\) selon la représentation en complément à deux.
Représenter sur \(n := 16\) bits la valeur \((-1021)_{\mathrm{dix}}\) selon la représentation en complément à deux.
Expliquer s’il est possible de représenter la valeur \((-1000)_{\mathrm{dix}}\) en complément à deux sur \(n := 8\).
Donner la valeur décimale représentée par la suite de bits \((\texttt{00001001})_{\mathrm{c2}}\) sur \(n := 8\) bits.
Donner la valeur décimale représentée par la suite de bits \((\texttt{10001001})_{\mathrm{c2}}\) sur \(n := 8\) bits.
Donner la valeur décimale représentée par la suite de bits \((\texttt{11001011})_{\mathrm{c2}}\) sur \(n := 8\) bits.

1.1 Opérations en complément à deux

On rappelle que la représentation des entiers signés se fait sur un nombre de bits fixé. Dans ce cas, l’addition de deux entiers peut produire une retenue dite de sortie qui ne fait pas partie de la représentation du résultat.

Par exemple, pour \(n := 4 bits\), 1110 + 0101 = (1)0011 on obtient une retenue de sortie.

Aussi, le résultat de l’addition peut ne pas être représentable sur le même nombre de bits, dans ce cas il y a dépassement de capacité.

Par exemple pour \(n := 4 bits\), la valeur \(-5\) peut être représenté en \((\texttt{1011})_{\mathrm{c2}}\) mais la somme \(-5 + -5 = -10\) ne rentre pas dans la plage de valeur possible sur \(4\) bits.

Exercice 6. (Critère de dépassement de capacité)

Proposer une méthode pour détecter sur le calcul en binaire les cas de dépassement de capacité.

Exercice 7. (Dépassement de capacité et retenue de sortie)

Considérons les valeurs suivantes sur \(n := 8\) bits :

\(v_1 := (\texttt{10011100})_{\mathrm{c2}}\)
\(v_2 := (\texttt{00000101})_{\mathrm{c2}}\)
\(v_3 := (\texttt{10001000})_{\mathrm{c2}}\)
\(v_4 := (\texttt{11111001})_{\mathrm{c2}}\)
\(v_5 := (\texttt{00110101})_{\mathrm{c2}}\)
\(v_6 := (\texttt{11100000})_{\mathrm{c2}}\)
\(v_7 := (\texttt{01001111})_{\mathrm{c2}}\)
\(v_8 := (\texttt{01011001})_{\mathrm{c2}}\)
\(v_9 := (\texttt{10000000})_{\mathrm{c2}}\)
\(v_{10} := (\texttt{11000000})_{\mathrm{c2}}\)

Réaliser, en les posant, les additions suivantes et pour chacune d’elle, dire s’il y a une retenue sortante et/ou un dépassement de capacité.

\(v_1 + v_2\) ;
\(v_3 + v_4\) ;
\(v_5 + v_6\) ;
\(v_7 + v_8\) ;
\(v_9 + v_{10}\) ;
\(v_1 + v_{10}\).

Les additions posées font partie de la réponse et doivent être utilisées pour justifier les résultats fournis.

2 Boutisme et mémoire

La mémoire est organisée par octet plutôt que par bit. Pour stocker un double word il faut 4 octets donc 4 cases dans la mémoire. L’ordre de ces octets dans la mémoire dépend de l’architecture de la machine utilisée, de l’octet de poids fort à l’octet de poids faible (grand boutisme) ou de l’octet de poids faible à l’octet de poids fort (petit boutisme).

Les architectures qui nous intéressent sont en petit boutisme.

Exercice 8. Aux adresses \(8\) à \(11\) de la mémoire, on trouve les octets \((\texttt{49})_{\mathrm{seize}}\), \((\texttt{31})_{\mathrm{seize}}\), \((\texttt{61})_{\mathrm{seize}}\) et \((\texttt{4f})_{\mathrm{seize}}\).

Donner la représentation hexadécimale du double word à l’adresse \(8\).

3 Codage du texte

Pour représenter du texte, chaque lettre/symbole est représenté par un nombre entier lui même représenté en octets (suivant différents encodages). Une suite de lettre devient donc une suite de nombre (puis d’octets).

Les tables de correspondance entre symboles et nombres sont dictés par des normes dont une des plus utilisés est la norme ASCII datant des années 1960.

Chaque lettre est représentée par un entier lui même représentatble sur \(7\) bits (cf figure suivante) (d’un même octet).

Exercice 9. (Un peu d’ASCII)

Représenter le texte \((\texttt{Bien})_{\mathrm{ASCII}}\) en représentation héxadécimale sur \(4\) octets.
Représenter les lettres 'd', 'D', 't' et 'T' en représentation binaire sur \(n := 8\) bits. Qu’observe-t-on ?
En observant la représentation hexadécimal des chiffres de la table ASCII, donner une astuce pour retrouver rapidement l’un à partir de l’autre.
On trouve dans la mémoire l’entier \(695160616\) codé sur un double word en petit boutisme. Donner le texte correspondant.
Donner la représentation ASCII des octets de l’exercice précédent.

Après dénombrement, on s’aperçoit rapidement qu’il n’est pas possible de représenter tous les symboles possible (à commencer par nos lettres accentuées).

D’autres normes ont vu le jour, en restant rétro-compatible avec la norme ASCII. Une des plus utilisées est la norme Unicode. Par exemple, les lettres “à” et “œ” sont représentées par les nombre \((\texttt{e0})_\mathrm{seize}\) et \((\texttt{153})_\mathrm{seize}\). La valeur maximale permise par la norme est \((\texttt{10ffff})_\mathrm{seize}\).

Pour représenter chacune de ses valeurs, il faut de \(1\) à \(3\) octets. Cela introduit une difficulté quant à l’encodage en octets que l’on va illustrer par l’exercice suivant.

Exercice 10. (Suite d’entier)

Proposer différentes méthodes pour représenter la suite d’entier 14 0 35 1545 1 1 0 avec uniquement les chiffres (sans espaces donc). Elles doivent fonctionner pour toutes suites de nombres de moins de 9 chiffres.
Les comparer.
La norme Unicode définit plusieurs encodages UTF. Sont-ils comparables aux méthodes précédentes ?