TD6 --- L3 Langage et Compilation --

Le retour de la MVàP

Fort de notre expériennce de la semaine passée, nous continuons à programmer en MVàP. Pour ceux qui regrettent le python et ces fonctions : pas de problème la MVàP permet d'en écrire, et à la fin de ce TD en salle machine, les fonctions n'auront plus de secrets pour vous.

Préliminaire

Sortez un papier, un crayon et une gomme. Imaginez pour l'instant que le pc devant vous sert seulement à visionner cette feuille d'exercice.

Code MVàP 1

Soit le programme suivant en MVàP :
  JUMP 0
LABEL 1   
  PUSHL -3
  PUSHI 2
  MUL
  STOREL -4
  RETURN
RETURN
LABEL 0   
  PUSHI 0
  PUSHI 2
  CALL  1
  POP
  WRITE
  POP
  HALT
Une fois assemblé, ce code devient :
 Adr |  Instruction
-----+---------------
   0 | JUMP       11 
   2 | PUSHL      -3 
   4 | PUSHI       2 
   6 | MUL           
   7 | STOREL     -4 
   9 | RETURN        
  10 | RETURN        
  11 | PUSHI       0 
  13 | PUSHI       2 
  15 | CALL        2 
  17 | POP           
  18 | WRITE         
  19 | POP           
  20 | HALT          
Commenter et compléter le début de trace suivant. Commenter le code original. Que réalise-t-il?
Le début de l'exécution donnant la trace suivante :
  pc |               |    fp   pile
====================================================
   0 | JUMP       11 |     0 [ ] 0
  11 | PUSHI       0 |     0 [ ] 0
  13 | PUSHI       2 |     0 [ 0 ] 1
  15 | CALL        2 |     0 [ 0 2 ] 2
   2 | PUSHL      -3 |     4 [ 0 2 17 0 ] 4
     |               |
     |               |
     |               |
     |               |

Code MVàP 2

Soit le programme suivant en MVàP :
  JUMP 0
LABEL 1
  PUSHL -3
  PUSHI 2
  MUL
  STOREL -4
  RETURN
RETURN
LABEL 2
LABEL 3
  PUSHL -4
  PUSHL -3
  PUSHI 1
  ADD
  INF
  JUMPF 4
  PUSHI 0
  PUSHL -3
  CALL 1
  POP
  STOREL -4
  JUMP 3
LABEL 4
  PUSHL -4
  STOREL -5
  RETURN
RETURN
LABEL 0
  PUSHI 0
  PUSHI 3
  PUSHI 5
  CALL 2
  POP
  POP
  WRITE
  POP
  HALT
Une fois assemblé, ce code devient :
 Adr |  Instruction
-----+---------------
   0 | JUMP       38 
   2 | PUSHL      -3 
   4 | PUSHI       2 
   6 | MUL           
   7 | STOREL     -4 
   9 | RETURN        
  10 | RETURN        
  11 | PUSHL      -4 
  13 | PUSHL      -3 
  15 | PUSHI       1 
  17 | ADD           
  18 | INF           
  19 | JUMPF      32 
  21 | PUSHI       0 
  23 | PUSHL      -3 
  25 | CALL        2 
  27 | POP           
  28 | STOREL     -4 
  30 | JUMP       11 
  32 | PUSHL      -4 
  34 | STOREL     -5 
  36 | RETURN        
  37 | RETURN        
  38 | PUSHI       0 
  40 | PUSHI       3 
  42 | PUSHI       5 
  44 | CALL       11 
  46 | POP           
  47 | POP           
  48 | WRITE         
  49 | POP           
  50 | HALT 
Compléter les traces d'exécution suivantes. Identifier les appels de fonctions. Repérer les blocs d'activation. Que réalise le code?
Trace partielle :
  pc |               |    fp   pile
====================================================
   0 | JUMP       38 |     0 [ ] 0                  
  38 | PUSHI       0 |     0 [ ] 0		    
  40 | PUSHI       3 |     0 [ 0 ] 1		    
  42 | PUSHI       5 |     0 [ 0 3 ] 2		                 
  44 | CALL       11 |     0 [ 0 3 5 ] 3                         
  11 | PUSHL      -4 |      
     |               |
     |               |
     |               |
  18 | INF           |     5 [ 0 3 5 46 0 3 6 ] 7	        
  19 | JUMPF      32 |     5 [ 0 3 5 46 0 1 ] 6		
  21 | PUSHI       0 |     5 [ 0 3 5 46 0 ] 5		
  23 | PUSHL      -3 |     5 [ 0 3 5 46 0 0 ] 6		
  25 | CALL        2 |     5 [ 0 3 5 46 0 0 5 ] 7                    
   2 | PUSHL      -3 |     9 [ 0 3 5 46 0 0 5 27 5 ] 9      
   4 | PUSHI       2 |     9 [ 0 3 5 46 0 0 5 27 5 5 ] 10   
   6 | MUL           |     9 [ 0 3 5 46 0 0 5 27 5 5 2 ] 11 
   7 | STOREL     -4 |     9 [ 0 3 5 46 0 0 5 27 5 10 ] 10  
   9 | RETURN        | 
     |               |
     |               |
     |               |
  11 | PUSHL      -4 |     5 [ 0 10 5 46 0 ] 5		
  13 | PUSHL      -3 |     5 [ 0 10 5 46 0 10 ] 6	
  15 | PUSHI       1 |     5 [ 0 10 5 46 0 10 5 ] 7	
  17 | ADD           |     5 [ 0 10 5 46 0 10 5 1 ] 8	      
  18 | INF           |     5 [ 0 10 5 46 0 10 6 ] 7	
  19 | JUMPF      32 |     5 [ 0 10 5 46 0 0 ] 6	             
  32 | PUSHL      -4 |     5 [ 0 10 5 46 0 ] 5		
  34 | STOREL     -5 |     5 [ 0 10 5 46 0 10 ] 6	
  36 | RETURN        |     5 [ 10 10 5 46 0 ] 5         
  46 | POP           |     0 [ 10 10 5 ] 3          
  47 | POP           |     0 [ 10 10 ] 2	    
  48 | WRITE         |     0 [ 10 ] 1		    
10						                  
  49 | POP           |     0 [ 10 ] 1		   
  50 | HALT          |     0 [ ] 0                 

autocorrection

Vous pouvez éteindre votre papier, votre gomme et votre crayon et reprendre une activité normale. Si ce n'est pas déjà fait la semaine dernière, téléchargez les sources de la MVaP et suivez les instructions avec les tests.
Utilisez la MVàP pour vérifier que celle ci ne se trompe pas et donne la même réponse que votre crayon.

Production de code

Pour chaque programme décrit informellement ci-dessous, écrire un programme MVàP et testez le. Le fichier texte .mvap doit contenir une instruction par ligne et un saut de ligne après chaque instruction. Vous pouvez commenter votre code en préfixant chaque ligne par un dièse (hash). Attention à bien prendre soin de sauter une ligne y compris après la dernière instruction (HALT).
Fonction f(x)=1-x. Fonction g(x)=1+x. Main : appel de f(a)*g(a) pour un entier a lu auprès de l'utilisateur.
Fonction valeur absolue et son appel pour un entier entré par l'utilisateur.
Fonction 2^n (2 chapeau n c'est bien ça) et son appel pour un entier entré par l'utilisateur. Évidemment on fera une fonction récursive sinon ce n'est pas drôle.
Fonction de Fibonnacci et appel d'ycelle dans le main pour 2 valeurs lues auprès de l'utilisateur.
Et parce qu'il faut bien une question un peu plus difficile.
Reprendre la fonction chapeau. Codez là en récursion terminale.