Ce site est en cours de reconstruction certains liens peuvent ne pas fonctionner ou certaines images peuvent ne pas s'afficher.

3. TP 3
Boucle for

Dans ce TP, nous nous intéressons à la traduction de la boucle for.

3.1. for i

Traduire le programme suivant en assembleur 32 bits :

Afficher le code assembly/programs/for_loop_sum.c

// ===================================================================
// Program: for_loop_sum.c
// Date: July 2020
// Author: Jean-Michel Richer
// Email: jean-michel.richer@univ-angers.fr
// ===================================================================
// Description:
//   This program shows how to code a for loop in C.
//   It is intended to be translated in 32 bits x86 assembly
//   language.
// ===================================================================
#include <stdio.h>
#include <stdlib.h>
 
/**
 * main function
 *
 * we compute the sum of i=1 to 10 = (11*10)/2 = 55
 */
int main(int argc, char *argv[]) {
 
  int sum = 0;
  
  for (int i = 1; i < 11; ++i) {
    sum += i;
  }
  
  printf("sum=%d\n", sum);
  
  return EXIT_SUCCESS;
}
 

Voici sa traduction :

Afficher le code assembly/programs/for_loop_sum_nasm.asm

; ===================================================================
; Program: for_loop_sum_nasm.asm
; Date: July 2020
; Author: Jean-Michel Richer
; Email: jean-michel.richer@univ-angers.fr
; ===================================================================
; Description:
;   This program computes and prints the sum of integers from
;   1 to 10
; ===================================================================
global main
extern printf
 
; ===================================================================
; #####     ##     #####    ##
; #    #   #  #      #     #  #
; #    #  #    #     #    #    #
; #    #  ######     #    ######
; #    #  #    #     #    #    #
; #####   #    #     #    #    #
; ===================================================================
section .data
 
  msg_sum:  db "sum=%d", 10, 0
 
 
; ===================================================================
;  ####    ####   #####   ######
; #    #  #    #  #    #  #
; #       #    #  #    #  #####
; #       #    #  #    #  #
; #    #  #    #  #    #  #
;  ####    ####   #####   ######
; ===================================================================
section .text
 
; -------------------------------------------------------------------
; SUBPROGRAM
;
; int main(int argc, char *argv[])
;
; DESCRIPTION
; 
; Main subprogram that computes sum of 1 to 10 and prints result
;
; PARAMETERS
;
; argc    int     number of arguments of the program
; argv    char *[]  array of arguments as strings
;
; RETURN VALUE
;
; 0   if everything is ok, 
; >0  if error
;
; VARIABLES / REGISTERS
;
;   i   int   loop variable ecx
;   sum   int   sum of values eax
;
; -------------------------------------------------------------------
main:
  push  ebp
  mov   ebp, esp
  
  ;
  ; Code of subprogram
  ;
  xor   eax, eax    ; sum = 0
  
  mov   ecx, 1      ; i = 1
.for_i:
  cmp   ecx, 11
  jge   .endfor_i
  
    add   eax, ecx  ; sum += i
    
  inc   ecx       ; ++i
  jmp   .for_i
.endfor_i:  
  
  push  eax
  push  dword msg_sum
  call  printf
  add   esp, 8
    
  xor   eax, eax    ; 0 of return 0
  
  mov   esp, ebp
  pop   ebp
  ret
 
 

3.2. for avec tableau

On itère sur un tableau :

dans un premier temps le tableau est initialisé avec des valeurs aléatoires
on affiche les valeurs
puis on en fait la somme que l'on affiche

Afficher le code assembly/programs/for_loop_array.c

// ===================================================================
// Program: for_loop_sum.c
// Date: July 2020
// Author: Jean-Michel Richer
// Email: jean-michel.richer@univ-angers.fr
// ===================================================================
// Description:
//   This program shows how to code a for loop in C and iterate
//   through an array.
//   It is intended to be translated in 32 bits x86 assembly
//   language.
// ===================================================================
 
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
 
// Size of the array
const int MAX_ELEMENTS = 8;
// Array of integers that needs to be allocated
int *array;
 
/**
 * Initialization with random numbers from 1 to 10
 * @param a array of integer
 * @param size size of the array
 */
void random_init(int *a, int size) {
  for (int i = 0; i < size; ++i) {
    a[i] = (rand() % 10) + 1;
  }
}
 
/**
 * Print contents of the array
 * @param a array of integer
 * @param size size of the array
 */
void print_values(int *a, int size) {
  for (int i = 0; i < size; ++i) {
    printf("%d ", a[i]);
  }
  printf("\n");
}
 
/**
 * Sum of the values of the array
 * @param a array of integer
 * @param size size of the array
 */
int array_sum(int *a, int size) {
  int sum = 0;
  for (int i = 0; i < size; ++i) {
    sum += a[i];
  }
  return sum;
}
 
/**
 * main method
 */
int main(int argc, char *argv[]) {
  // initialize random number generator
  srand( time(nullptr) );
 
  //  allocate array
  array = new int [ MAX_ELEMENTS ];
  
  // initialize araray with random values
  random_init( array, MAX_ELEMENTS );
  // print contents of array
  print_values( array, MAX_ELEMENTS );
  
  // compute and print sum of values of array
  printf( "sum=%d\n", array_sum( array, MAX_ELEMENTS ) );
  
  // free resources
  delete [] array;
  
  return EXIT_SUCCESS;
}
 

Dont la traduction en assembleur en 32 bits est :

Afficher le code assembly/programs/for_loop_array_nasm.asm

; ===================================================================
; Program: for_loop_sum_nasm.asm
; Date: July 2020
; Author: Jean-Michel Richer
; Email: jean-michel.richer@univ-angers.fr
; ===================================================================
; Description:
;   This program creates an array of random values and computes 
;   and prints the sum of the values
; ===================================================================
global main
extern printf, rand, srand, time, malloc, free
 
; ===================================================================
; #####     ##     #####    ##
; #    #   #  #      #     #  #
; #    #  #    #     #    #    #
; #    #  ######     #    ######
; #    #  #    #     #    #    #
; #####   #    #     #    #    #
; ===================================================================
section .data
 
  MAX_ELEMENTS  equ 8
  
  array:      dd 0  ; int *array
  
  msg_print_a_i:  db "%d ", 0
  msg_sum:    db "sum=%d", 10, 0
  new_line:   db 10, 0
 
; ===================================================================
;  ####    ####   #####   ######
; #    #  #    #  #    #  #
; #       #    #  #    #  #####
; #       #    #  #    #  #
; #    #  #    #  #    #  #
;  ####    ####   #####   ######
; ===================================================================
section .text
 
; -------------------------------------------------------------------
; SUBPROGRAM
;
; void random_init(int *a, int size)
;
; DESCRIPTION
; 
; initialize integer array 'a' of size 'size' with random values
; between 1 and 10
;
; PARAMETERS
;
; a   int * array of integers
; size  int   size of the array
;
; RETURN VALUE
;   
; none
;
; VARIABLES / REGISTERS
; 
; a   int *   array of integers   [ebp +8]  ebx
; size  int     size of the array   [ebp+12]    
; i   int   for loop variable         esi
;   eax   int   return value of rand()
; ecx   int   constant = 10
;
; -------------------------------------------------------------------
random_init:
  push  ebp
  mov   ebp, esp
 
  push  ebx
  push  esi
  
  mov   ebx, [ebp + 8]
  
  ; for (int i = 0; i < size; ++i)
  xor   esi, esi
.for_i:
  cmp   esi, [ebp + 12]
  jge   .endfor_i
  
    ; a[i] = (rand() % 10) + 1;
    call  rand
    xor   edx, edx
    mov   ecx, 10
    div   ecx
    add   edx, 1
    mov   [ebx + esi * 4], edx
  
  inc   esi
  jmp   .for_i
.endfor_i:  
  
  pop   esi
  pop   ebx
  
  mov   esp, ebp
  pop   ebp
  ret
 
; -------------------------------------------------------------------
; SUBPROGRAM
;
; void print_values(int *a, int size)
;
; DESCRIPTION
; 
; print values of array 'a' of size 'size' 
;
; PARAMETERS
;
; a   int * array of integers   
; size  int   size of the array   
;
; RETURN VALUE
;   
; none
;
; VARIABLES / REGISTERS
; 
; a   int *   array of integers   [ebp +8]  ebx
; size  int     size of the array   [ebp+12]    
; i   int   for loop variable         esi
;
; -------------------------------------------------------------------
print_values:
  push  ebp
  mov   ebp, esp
 
  push  ebx
  push  esi
  
  mov   ebx, [ebp + 8]
  
  ; for (int i = 0; i < size; ++i)
  xor   esi, esi
.for_i:
  cmp   esi, [ebp + 12]
  jge   .endfor_i
  
    ; printf("%d ", a[i]);
    push  dword [ebx + esi * 4]
    push  dword msg_print_a_i
    call  printf
    add   esp, 8
      
  inc   esi
  jmp   .for_i
.endfor_i:  
  
  ; printf("\n");
  push  dword new_line
  call  printf
  add   esp, 4
  
  pop   esi
  pop   ebx
  
  mov   esp, ebp
  pop   ebp
  ret
 
 
; -------------------------------------------------------------------
; SUBPROGRAM
;
; int array_sum(int *a, int size)
;
; DESCRIPTION
; 
; compute sum of value of the array 'a' of size 'size' 
;
; PARAMETERS
;
; a   int * array of integers   [ebp+8]   ebx
; size  int   size of the array   [ebp+12]  esi
;
; RETURN VALUE
;   
; the sum of a[0] + ... + a[size-1]
;
; VARIABLES / REGISTERS
; 
; a   int *   array of integers   [ebp +8]  ebx
; size  int     size of the array   [ebp+12]    
; i   int   for loop variable         esi
;   sum   int   sum of a[i]'s           eax
;
; -------------------------------------------------------------------
array_sum:
  push  ebp
  mov   ebp, esp
 
  push  ebx
  push  esi
  
  mov   ebx, [ebp + 8]
  
  ; sum = 0
  xor   eax, eax
  
  ; for (int i = 0; i < size; ++i)
  xor   esi, esi
.for_i:
  cmp   esi, [ebp + 12]
  jge   .endfor_i
  
    ; sum += a[i]
    add   eax, [ebx + esi * 4]
      
  inc   esi
  jmp   .for_i
.endfor_i:  
  
  pop   esi
  pop   ebx
  
  mov   esp, ebp
  pop   ebp
  ret
 
; -------------------------------------------------------------------
; SUBPROGRAM
;
; int main(int argc, char *argv[])
;
; DESCRIPTION
; 
; Main subprogram that computes sum of 1 to 10 and prints result
;
; PARAMETERS
;
; argc    int     number of arguments of the program
; argv    char *[]  array of arguments as strings
;
; RETURN VALUE
;
; 0   if everything is ok, 
; >0  if error
;
; VARIABLES / REGISTERS
;   
; argc  int     number of commandl line   [ebp + 8] 
;           arguments
; argv  char *[]  command line arguments    [ebp + 12]  
;
; -------------------------------------------------------------------
main:
  push  ebp
  mov   ebp, esp
  
  ; srand( time(nullptr) );
  xor   eax, eax
  push  eax
  call  time
  add   esp, 4
  push  eax
  call  srand
  add   esp, 4
  
  ; array = new int [ MAX_ELEMENTS ];
  ; array = (int *) malloc( MAX_ELEMENTS * sizeof(int) );
  mov   eax, MAX_ELEMENTS
  shl   eax, 2
  push  eax
  call  malloc
  add   esp, 4
  mov   [array], eax
  
  ; random_init( array, MAX_ELEMENTS );
  push  dword MAX_ELEMENTS
  push  dword [array]
  call  random_init
  add   esp, 8
    
  ; print_values( array, MAX_ELEMENTS );
  push  dword MAX_ELEMENTS
  push  dword [array]
  call  print_values
  add   esp, 8
  
  ; printf( "sum=%d\n", array_sum( array, MAX_ELEMENTS ) );
  push  dword MAX_ELEMENTS
  push  dword [array]
  call  array_sum
  add   esp, 8
  
  push  eax
  push  dword msg_sum
  call  printf
  add   esp, 8
  
  ; delete [] array
  push  dword [array]
  call  free
  add   esp, 4
 
  ; return 0
  xor   eax, eax    ; 0 of return 0
  
  mov   esp, ebp
  pop   ebp
  ret
 
 

3.3. Que retenir

3.3.1. Manipulation des tableaux

Pour manipuler les éléments d'un tableau d'octets, d'entiers, de flottants a[i], on peut procéder en utilisant deux registres :

un registre pour stocker l'adresse du tableau
un registre pour stocker l'indice du tableau

Il faudra alors multiplier l'indice par un facteur qui dépend du type du tableau :

pour un tableau char : 1
pour un tableau int ou float : 4
pour un tableau double : 8

Afficher le code

int tab[ 200 ];
t[ 10 ];

Afficher le code

mov   esi, tab
mov   ecx, 10
mov   eax, [ esi + ecx * 4 ]

3.3.2. Registres préservés

Si on utilise le registre ecx en tant qu'indicie de boucle et qu'à l'intérieur de la boucle on appelle une fonction standard de la bibliothèque C, ecx risque d'être modifié ce qui peut avoir deux conséquences : soit terminer la boucle, soit la rendre infinie.