SOLUTION MATERIEL #2

2.1 Pour l'instruction C suivante, écrivez le code assembleur LEGv8 correspondant. Supposons
que les variables C f, g et h aient déjà été placées respectivement dans les registres X0, X1 et X2.
Utilisez un nombre minimal d'instructions d'assemblage LEGv8.
f = g + (h - 5) ;
Répondre:

SUBI X2, X2, #5 // (h-5) stocké dans le registre temporaire X3

AJOUTER X0, X1, X2 // g + X3

2.2 Écrivez une seule instruction C qui correspond aux deux instructions d'assemblage LEGv8
ci-dessous.
AJOUTER f, g, h
AJOUTER f, je, f
Répondre:

F = h + h + je
2.3 [5] < §§2.2, 2.3 > Pour l'instruction C suivante, écrivez le code assembleur LEGv8
correspondant. Supposons que les variables f , g , h , i et j sont affectées à des registres
X0, X1, X2, X3 et X4 , respectivement. Supposons que l'adresse de base des tableaux A et B se
trouve respectivement dans les registres X6 et X7 .
B[8] = A[ij];
Répondre:
SOUS-X9, X3, X4 // calcule ij
LSL X9, X9, #3 // multx8 en conversion du décalage de
AJOUTER X11, X6, X9 mot en décalage d'octet
LDUR X10, [X11, #0] // calcule &A[ij]
STUR X10, [X7, #64] ou // charge A[ij]
// stocker dans B[8]
SOUS-X9, X2, X4
LSL X9, X9, #3
AJOUTER X1, X6, X9
LDURX10, [X11, #0]
STURX10, [X7, #64]
2.4 [10] < §§2.2, 2.3 > Pour les instructions d'assemblage LEGv8 ci-dessous, quel est le
instruction C correspondante ? Supposons que les variables f , g , h , I et j soient affectées
respectivement aux registres X0, X1, X2, X3 et X4 . Supposons que l'adresse de base des
tableaux A et B se trouve respectivement dans les registres X6 et X7 .
 LSL X9, X0, #3
AJOUTER X9, X6, X9
// X9 = f*8
LSL X10, X1, #3 // X9 = &A[f]
AJOUTER X10, X7, // X10 = g*8
X10 // X10 = &B[g]
LDUR X0, [X9, #0] // f = A[f]

ADDI X11, X9, #8

LDUR X9, [X11, #0]
AJOUTER X9, X9, X0
STURX9, [X10, #0]
Répondre:
f = UNE[f];
f = UNE[f+1] + UNE[f]
B[g] = f;
ou
B[g] = A[f] + A[f + 1]
2.5 [5] < §§2.2, 2.3, 2.6 > Pour les instructions d'assemblage LEGv8 de l'exercice 2.4,
réécrivez le
code assembleur pour minimiser le nombre d’instructions LEGv8 nécessaires pour exécuter la
même fonction.
Répondre:
LSL X9, X0, #3 // X9 = f*8
AJOUTER X9, X6, X9 // X9 = &A[f]
LSL X10, X1, #3 // X10 = g*8
AJOUTER X10, X7,
// X10 = &B[g]
X10
LDUR X0, [X9, #0] // f = A[f]

ADDI X11, X9, #8

LDUR X9, [X11, #8]
AJOUTER X9, X9, X0
STURX9, [X10, #0]

2.6 [5] < §2.3 > Montrer comment la valeur 0xabcdef12 serait disposée dans la mémoire
d'une machine small-endian et big-endian. Supposons que les données soient stockées à
partir de l'adresse 0 et que la taille du mot soit de 4 octets.
Répondre:
gros-boutiste
(mémoire)
faible ----------------------> élevé
ab | cd | ef | 12 petit-boutiste
(mémoire)
faible ----------------------> élevé
12 | ef | cd | un B

ou
1 . .
Gros boutien

Dans un format big endian , l'octet de poids fort est stocké à l' adresse la plus
basse. Par conséquent, les données fournies seraient stockées comme suit :
Octet d’adresse
() un B
je CD
2 ef
.3 12 .

2
Petit endian

Dans un format Little Endian , l' octet de poids fort est stocké à l' adresse la plus élevée (donc l'
octet de poids faible est stocké à l' adresse la plus basse). Ainsi, le tlnln donné serait stocké
comme suit :

Octet d’adresse
() 12
1 ef
2 CD
3 un B

2.7 [5] < §2.4 > Traduisez 0xabcdef12 en décimal.

10*16E7 + 11*16E6 + 12*16E5 + 13*16E4 + 14*16E3 + 15*16E2 + 1*16E1 + 2*16E0
= 2882400018
Ou
0x167 + 11x166 + … + 2x160 = 2882400018
2.8 [5] < §§2.2, 2.3 > Traduisez le code C suivant en LEGv8. Supposons que les variables
2.9 g , h , i et j sont affectés respectivement aux registres X0, X1, X2, X3 et X4 . Supposons
que l'adresse de base des tableaux A et B se trouve respectivement dans les registres X6 et
X7 . Supposons que les éléments des tableaux A et B soient des mots de 8 octets :
B[8] = A[i] + A[j];
Répondre:

SHL X9, X3, 3

AJOUTE X9, X9, X6
R
 LDUR X9, [X9,#0] //X9 = A[I]
SHL X10, X4, 2
AJOUTE X10, X10, X6
R
LDUR X10, [X10,#0] //X10 = A[J]
AJOUTE X11, X9, X10
R
STUR X11, [X7,64] // B[8] = A[I] + A[J]
2.9 [10] < §§2.2, 2.3 > Traduisez le code LEGv8 suivant en C. Supposons que les variables f , g ,
h , i et j sont affectées aux registres X0,X1,X2,X3 et X4 , respectivement. Supposons que
l'adresse de base des tableaux A et B se trouve respectivement dans les registres X6 et X7 .
ADDI X9, X6, #8

AJOUTER X10, X6, XZR

STURX10, [X9, #0]

LDUR X9, [X9, #0]
AJOUTER X0, X9, X10

solution:
1. La première ligne calcule l'adresse du 2ème mot dans A (car X6 est l'adresse de base du
tableau A), c'est-à-dire A[1]. En effet, chaque mot fait 8 octets et l'adresse est stockée dans le
registre temporaire X9.

2. La deuxième ligne copie l'adresse de A dans le registre X10.

3. La troisième ligne stocke ce qui était dans X10 dans X9 (l'adresse du 2ème mot dans A. Ainsi,
le code c jusqu'à présent est A[1]= A. (où A est l'adresse mémoire du premier élément du tableau
A)
4. La quatrième ligne charge la valeur A dans le registre X9.

5. La cinquième ligne ajoute X9 et 10. Qui ont maintenant la même valeur et stockent le résultat
dans X0= F. Donc F = 2A.

6. Maintenant, le code C global devient

7. A[1]= A, (A[1] = A[0];)
8. F = 2A, (f = A[0] + A[1];)

2.10 [20] < §§2.2, 2.5 > Pour chaque instruction LEGv8 de l'exercice 2.9, affichez la
valeur des champs opcode (Op), registre source (Rn) et registre cible (Rd ou Rt). Pour les
instructions de type I, affichez la valeur du champ immédiat et pour les instructions de type R,
affichez la valeur du deuxième registre source (Rm).
Répondre:
Instruction Taper code opérationrm m rd/rt
imm /
ADDIx9, 16, #8 J'écris 580/0x244 - 6 9 adresse
8
AJOUTER X10, 16, XZR Type R 1112/0x458 31 6 10
-
STURx10 , [X9, #0] Type D 1984/0x7c0 - 9 10 0
LDUR X9, [x9, #0] Type D 1986/027c2 - 9 9 0
AJOUTER XO, X9, X1O Type R 1112/030458 10 9 0
-
ADDI X9, X6, #8 [1001000100 000000001000 00110 01010] [10001011000 11111
AJOUTER X10,X6, 000000 00110 01010] [11111000000 000000000 00 01001 01010]
XZR [11111000010 000000000 00 01001 01001] [10001011000 01010
STURX10, [X9, #0] 000000 000000 01001]
LDURX9, PX9,#0]
AJOUTER X0, X9,
2.11 Supposons que les registres X0 et X1 contiennent les valeurs 0 ×
8000000000000000 et
0 × D000000000000000 , respectivement.
2.11.1 [5] < §2.4 > Quelle est la valeur de X9 pour le code assembleur suivant ?
AJOUTER X9, X0, X1
RÉPONDRE:
X9 = X0 + X1 = 0x8000000000000000 + 0xD000000000000000 = 0x150000000000000000
2.11.2 [5] < §2.4 > Le résultat dans X9 est-il le résultat souhaité ou y a-t-il eu un
débordement ?
RÉPONDRE:
Il y a eu un débordement
2.11.3 [5] < §2.4 > Pour le contenu des registres X0 et X1 comme précisé ci-dessus,
quelle est la valeur de X9 pour le code assembleur suivant ?
SOUS-X9, X0, X1
RÉPONDRE:

X9 = X0 - X1 = 0x8000000000000000 - 0xD000000000000000 = - 0x50000000000000000

(complément à 2 : 1011 0000 0000 0000 0000 … 0000 0000 0000)

2.11.4 [5] < §2.4 > Le résultat dans X9 est-il le résultat souhaité ou y a-t-il eu un
débordement ?

RÉPONDRE:

Oui, c'est le résultat souhaité.

2.11.5 [5] < §2.4 > Pour le contenu des registres X0 et X1 tel que précisé ci-dessus,
que signifie
la valeur de X9 pour le code assembleur suivant ?

AJOUTER X9, X0, X1

AJOUTER X9, X9, X0

RÉPONDRE:

X9 = X0 + X1 = 0x8000000000000000 + 0xD000000000000000 = 0x150000000000000000

X9 = X9 + X0 = 0x15000000000000000 + 0x8000000000000000 = 0x1D0000000000000000

2.11.6 [5] < §2.4 > Le résultat dans X9 est-il le résultat souhaité ou y a-t-il eu un
débordement ?

RÉPONDRE:

Il y a eu un débordement
2.12 Supposons que X0 ait la valeur 128dix.

2.12.1 [5] < §2.4 > Pour l'instruction ADD X9, X0, X1 , quelle(s) plage(s) de

des valeurs pour X1 qui entraîneraient un débordement ?

RÉPONDRE:
128 dix = 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 1000 0000 deux
La plage de valeurs pour X1 va de 9223372036854775680 à 9223372036854775807. (binaire : de
10000000000000000000000000000000000000000000000000000000000000000.00000 000000 À
111111111111111111111111111111111111111111111111111111111111111)
2.12.2 [5] < § 2.4> Pour l'instruction SUB X9, X0, X1, quelle(s) plage(s) de valeurs pour
X1 entraînerait un débordement ?
RÉPONDRE:

2.12.3 [5] < §2.4 > Pour l'instruction SUB X9, X1, X0 , quelle(s) plage(s) de
des valeurs pour X1 qui entraîneraient un débordement ?
RÉPONDRE:

2.13 [5] < §§2.2, 2.5 > Fournir le type d'instruction et le langage assembleur
instruction pour la valeur binaire suivante :
1000 1011 0000 0000 0000 0000 0000 0000 deux
Indice : la figure 2.20 peut être utile.
Répondre:
AJOUTER X0, X0, X0
2.14 [5] < §§2.2, 2.5 > Fournir le type d'instruction et la représentation
hexadécimale
de la consigne suivante :
STURX9, [X10, #32]
Répondre:
Sol. STUR - 1984-11111000000
X9 - 10000
Shamt - 00
Rn - 01010
Chemin - 01001
La série est donc (1111 1000 0001 0000 00010100 1001}
Qui en hexadécimal est F810149

2.15 [5] < §2.5 > Fournir le type d'instruction, l'instruction en langage assembleur et
représentation binaire de l'instruction décrite par les champs LEGv8 suivants : op=0x658,
Rm=13, Rn=15, Rd=17, shamt=0
Répondre:
Format R

code opération Chambre honte Rn Chemin

11 bits 5 bits 6 bits 5 bits 5 bits
METTRE les valeurs comme opcode 1624(0x658)
2.16 [5] < §2.5 > Fournir le type d'instruction, l'instruction en langage assembleur et
représentation binaire de l'instruction décrite par les champs LEGv8 suivants :
Répondre:
op=0 × 7c2, Rn=12, Rt=3, const=0 × 4
- immédiat Chem
1 code opération Rn Format immédiat
format 1 in
METTRE les valeurs comme opcode 1986(0x7c2)
2.17 Supposons que nous souhaitons étendre le fichier de registre LEGv8 à 128
registres
et étendez le jeu d’instructions pour qu’il contienne quatre fois plus d’instructions.
2.17.1 [5] < §2.5 > Comment cela affecterait-il la taille de chacun des champs de
bits dans le
Des instructions de type R ?
Répondre:
Ne pas inclure dans le cours
2.17.2 [5] < §2.5 > Comment cela affecterait-il la taille de chacun des champs de
bits dans le
Je tape des instructions ?
Répondre:
Ne pas inclure dans le cours

2.17.3 [5] < §§2.5, 2.8, 2.10 > Comment chacun des deux changements proposés
pourrait-il diminuer
la taille d'un programme d'assemblage LEGv8 ? D’un autre cô té, comment le changement
proposé pourrait-il augmenter la taille d’un programme d’assemblage LEGv8 ?
Répondre:
Ne pas inclure dans le cours

2.18 Supposons le contenu du registre suivant :

X10 = 0x00000000AAAAAAAA,
X11 = 0x1234567812345678
2.18.1 [5] < §2.6 > Pour les valeurs de registre indiquées ci-dessus, quelle est la valeur
de X12 pour
la séquence d’instructions suivante ?
LSL X12, X10, #4
ORR X12, X12, X11
Répondre:
X12 = 0X1234567ABABEFEF8
2.18.2 [5] < §2.6 > Pour les valeurs de registre indiquées ci-dessus, quelle est la valeur
de X12 pour
la séquence d’instructions suivante ?
LSL X12, X11, #4
Répondre:
X12 = 00100011 01000101 01100111 10000001 00100011 01000101 01100111 10000000
X12 = 0x2345678123456780
2.18.3 [5] < §2.6 > Pour les valeurs de registre indiquées ci-dessus, quelle est la valeur
de X12 pour
la séquence d’instructions suivante ?
LSR X12, X10, #3

ANDI X12, X12, 0xFEF

Répondre:
X12 = 00000000 00000000 00000000 00000000 00000000 00000000 00000101 01000101 X12 =
0x0000000000000545
2.19 [10] < §2.6 > Trouver la séquence la plus courte d'instructions LEGv8 qui
extrait

les bits 16 à 11 du registre X10 et utilise la valeur de ce champ pour remplacer les bits 31 à 26
du registre X11 sans changer les autres bits des registres X10 ou X11 . (Assurez-vous de
tester votre code en utilisant X10 = 0 et X11 = 0xffffffffffffffff . Cela pourrait révéler une
erreur commune.)
RÉPONDRE:

AJOUTER X12> XZR, X10

LSLX12, X12, #15
ORRX11, X12, XL

2.20 [5] < §2.6 > Fournir un ensemble minimal d'instructions LEGv8 pouvant être
utilisées pour
implémentez la pseudo-instruction suivante :
PAS X10, X11 // inversion bit par bit

Répondre:

X9=111111111111 … . … . … 11111111

RAP X10, X9, X11