Désassemblage IA32 32 bits AT & T code d'assemblage d'une fonction dans C

Question

[Modifié] Est-ce que quelqu'un pourrait m'expliquer comment on obtient les valeurs de M et N dans ce problème, en passant par chaque ligne du code d'assemblage correspondant?

Je suis toujours coincé à la partie movl array2.

M et N sont des constantes définies à l'aide #define

#define M <some value> 
#define N <some value> 

int array1[M][N]; 
int array2[N][M]; 
int copy(int i, int j) 
{ 
array1[i][j] = array2[j][i]; 
} 

Si le code ci-dessus génère le code assembleur suivant: Comment pouvons-nous en déduire les valeurs des constantes M et N?

copy: 
    pushl %ebp 
    movl %esp, %ebp 
    pushl %ebx 
    movl 8(%ebp), %ecx 
    movl 12(%ebp), %ebx 
    leal (%ecx, %ecx, 8), %edx 
    sall $2, %edx 
    movl %ebx, %eax 
    sall $4, %eax 
    subl %ebx, %eax 
    sall $2, %eax 
    movl array2(%eax, %ecx, 4), %eax 
    movl %eax, array1(%edx, %ebx, 4) 
    popl %ebx 
    movl %ebp,%esp 
    popl %ebp 
    ret 

Answer 1

Très bien les gars, après beaucoup de recherches, j'ai été capable de trouver une solution. Corrigez-moi si je me trompe.

donc passer par l'étape d'assemblage suivant par l'étape: (les numéros de ligne supplémentaires pour la facilité)

M et N sont des constantes déterminées à l'aide de #define

int array1[M][N]; 
int array2[N][M]; 
int copy(int i, int j) 
{ 
array1[i][j] = array2[j][i]; 
} 

copy: 
    1 pushl %ebp 
    2 movl %esp, %ebp 
    3 pushl %ebx 
    4 movl 8(%ebp), %ecx 
    5 movl 12(%ebp), %ebx 
    6 leal (%ecx, %ecx, 8), %edx 
    7 sall $2, %edx 
    8 movl %ebx, %eax 
    9 sall $4, %eax 
    10 subl %ebx, %eax 
    11 sall $2, %eax 
    12 movl array2(%eax, %ecx, 4), %eax 
    13 movl %eax, array1(%edx, %ebx, 4) 
    14 popl %ebx 
    15 movl %ebp,%esp 
    16 popl %ebp 
     ret 

1. poussoir %ebp en pile

2. %ebp points à %esp

3. poussoir %ebx en pile

4. %ecx est égal à int i (index pour l'accès au réseau)

5. %ebx est égal à int j (index pour l'accès au réseau)

6. %edx est égal à 8 * %ecx + %ecx ou 9i

7. %edx est égal à 36i après un décalage binaire gauche de 2

8. %eax égal% ebx ou j

9. %eax est égal à 16j après un décalage binaire gauche de 4

10. %eax est égal à %eax - %ebx = 16j - j = 15j

11. %eax est égal à 60j après un décalage binaire gauche de 2

12. %eax est égal élément array2 avec index [4%ecx + %ebx] or [4i + 60j]

13. élément d'index [ 4%ebx + %edx ] or [ 4j + 36i ] de array1 est égal à %eax ou [4i + 60j]

Un échange des deux éléments de réseau fait en 12 et 13 en utilisant% eax comme registre intermédiaire.

14. %ebx sauté

15. %esp 'ancienne valeur s restaurée

16. %ebp sauté

Maintenant, nous supposons array1[i][j]' élément s accès à être égal à 4Ni + 4jL'accès à l'élément array2[j][i] est égal à 4Mj + 4i. (Le 4 dans chaque terme d'index en tant que int est de 4 octets et i, j sont des décalages individuels à partir de l'emplacement du tableau de départ) Cela est vrai car C stocke des tableaux dans une forme majeure de ligne.

Ainsi nous obtenons assimilant, M = 15 et N = 9.

Answer 2

Vous devez vérifier les autres parties de l'assemblage. Par exemple, si vous définissez M et N comme 8 fois, vous trouverez les éléments suivants dans l'assemblée

array1: 
    .zero 256 
array2: 
    .zero 256 

parce que sur ma machine, int est de 4 octets et 8 fois 8 est 64. Et 64 * 4 = 256 L'échantillon peut être trouvé here.