TD3

Exercice 1 (Basic--). On considère le langage Basic-- dont les programmes sont des suites d’ins-
tructions “basiques” inst1 , . . . , instl (chaque instruction a donc un numéro). On ne dispose que de deux
variables entières x et y. Une instruction basique inst est au choix :
— une affectation de la forme x ← e, ou y ← e, où e est une expression arithmétique,
— un test ?x = 0, ou ?y = 0, qui a pour effet d’ignorer l’instruction suivante si la variable ne contient
pas 0
— l’instruction push v qui met le contenu de la variable v (x, y, ou pc) sur la pile. Si v est pc, la
valeur mise sur la pile est le numéro de l’instruction.
— l’instruction pop v (x ou y) qui enlève de la pile l’entier n et le range dans v (si la pile est vide, v
reçoit une valeur aléatoire)
— l’instruction goto e qui passe à l’instruction instk si l’expression arithmétique e s’évalue en k.
Un programme qui comporte l instructions termine lorsque l’on cherche à exécuter l’instruction l + 1.
On note A(m, n) la fonction d’Ackermann, définie comme :

 n+1 si m = 0
A(m, n) = A(m − 1, 1) si m > 0 et n = 0
A(m − 1, A(m, n − 1))) si m > 0 et n > 0.


Écrire un programme en Basic-- qui se termine avec la variable x qui contient A(m, n) lorsque
initialement la variable x contenait m et la variable y contenait n.
Exercice 2 (Instructions Pentium). On rappelle que l’instruction “movl e1 , e2 ” a pour effet d’écrire la
valeur dénotée par e1 dans le conteneur (registre ou emplacement mémoire) dénoté par e2 . Les expressions
e1 , e2 ont différent format, notamment :
— le format “immédiat” : $0x12,$0xcafe,. . .
— le format “registre” : %eax, %ebx,. . .
— le format “absolu” : 0x12, 0xcafe,. . .
— le format “indirect” : (%eax), %ebx,. . .
— le format “indirect avec décalage” : 0xcafe(%eax), (%eax,%ebx, 4), . . .
— le format “adresse d’un indirect avec décalage” : %0xcafe(%eax),. . .
1. L’instruction “leal e1 , e2 ” a pour effet d’écrire l’adresse du conteneur e1 dans le conteneur e2 .
Quels sont les formats autorisés pour e1 et e2 ?
2. Lorsque e1 et e2 le permettent, réécrivez l’instruction “leal e1 , e2 ” à l’aide de movl
Exercice 3 (Switch C). On considère la fonction C et sa traduction assembleur données à la page
suivante.
1. On rappelle que le drapeau ZF (zero flag) est modifié par les instructions arithmétiques et lu par
les instructions de branchement. Suivez dans le code assembleur le déroulement pas à pas de la
fonction lorsque i=3 (Indication : on saute en LBB0 2).
2. Comment est renvoyé le résultat de la fonction ? Comment est passée la valeur initiale de la
variable i ? Où la variable i est-elle stockée par la suite ?
3. Pour i = 0, quels sont les labels visités, et quelle est la valeur renvoyée ?
4. Même question pour i = 2.
5. Même question pour i = 1.

1
 int f ( int i ){
switch ( i ) {
case 1 : i ++;
case 3 : return 3 ;
default : { i −−; break ; }
case 2 : return 2 ;
}
return 0 ;
}

1 f: 23 LBB0 1 :
2 pushq %rbp 24 movl −8(%rbp ) , %eax
3 movq %rsp , %rbp 25 addl $1 , %eax
4 movl %edi , −8(%rbp ) 26 movl %eax , −8(%rbp )
5 movl %edi , %eax 27 LBB0 2 :
6 subl $3 , %edi 28 movl $3 , −4(%rbp )
7 movl %eax , −12(%rbp ) 29 jmp LBB0 6
8 movl %edi , −16(%rbp ) 30 LBB0 3 :
9 je LBB0 2 31 movl −8(%rbp ) , %eax
10 jmp LBB0 7 32 addl $0xFFFFFFFF , %eax
11 LBB0 7 : 33 movl %eax , −8(%rbp )
12 movl −12(%rbp ) , %eax 34 jmp LBB0 5
13 subl $2 , %eax 35 LBB0 4 :
14 movl %eax , −20(%rbp ) 36 movl $2 , −4(%rbp )
15 je LBB0 4 37 jmp LBB0 6
16 jmp LBB0 8 38 LBB0 5 :
17 LBB0 8 : 39 movl $0 , −4(%rbp )
18 movl −12(%rbp ) , %eax 40 LBB0 6 :
19 subl $1 , %eax 41 movl −4(%rbp ) , %eax
20 movl %eax , −24(%rbp ) 42 popq %rbp
21 jne LBB0 3 43 retq
22 jmp LBB0 1

Exercice 4 (Fonctions). On considère la fonction C et sa traduction assembleur ci-dessous.

i n t f ( i n t i , i n t j ) { return ( i ==0)? j : f ( i −1 , i ∗ j ) ; }

1 f: 14 subl $1 , %eax
2 pushq %rbp 15 movl −4(%rbp ) , %ecx
3 movq %rsp , %rbp 16 imull −8(%rbp ) , %ecx
4 subq $16 , %rsp 17 movl %eax , %edi
5 movl %edi , −4(%rbp ) 18 movl %ecx , %e s i
6 movl %e s i , −8(%rbp ) 19 callq f
7 cmpl $0 , −4(%rbp ) 20 movl %eax , −12(%rbp )
8 jne LBB0 2 21 LBB0 3 :
9 movl −8(%rbp ) , %eax 22 movl −12(%rbp ) , %eax
10 movl %eax , −12(%rbp ) 23 addq $16 , %rsp
11 jmp LBB0 3 24 popq %rbp
12 LBB0 2 : 25 retq
13 movl −4(%rbp ) , %eax

1. Expliquez la différence entre cette fonction et la précédente quant au registre %rsp.

2. En vous inspirant des codes assembleurs ci-dessus, écrivez le code assembleur d’une fonction à un
seul argument calculant la factorielle.