Discussion :

[lynzpl]

Bonjour,

J'ai besoin d'aide, je dois faire une fonction en assembleur qui va trouver la médiane entre 3 chiffres donc par exemple si j'ai 2 7 5 il va me renvoyer 5. Voilà la fonction que j'ai faite pour l'instant cependant je n'ai que des erreurs de segmentation (erreur de segmentation (core dumped)).

Code asm :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
     .text
    .globl median3
median3:
    pushl %ebp
    movl %esp, %ebp
    pushl %ebx
    pushl %ecx
    pushl %edx
 
    movl 8(%ebp), %eax     # eax = a
    movl 12(%ebp), %ebx    # ebx = b
    movl 16(%ebp), %ecx    # ecx = c
 
    # Test 1 : a >= b ?
    cmpl %ebx, %eax
    jge a_ge_b             # si a >= b, aller à a_ge_b
a_lt_b:
    # ici a < b
    cmpl %ecx, %eax
    jge median_is_a        # si a >= c alors médiane = a
    cmpl %ecx, %ebx
    jge median_is_b        # si b >= c alors médiane = c sinon médiane = b
    movl %ebx, %eax        # médiane = b
    jmp end_median
 
a_ge_b:
    # ici a >= b
    cmpl %ecx, %eax
    jle median_is_a        # si a <= c alors médiane = a
    cmpl %ecx, %ebx
    jge median_is_b        # si b >= c alors médiane = b
    movl %ecx, %eax        # sinon médiane = c
    jmp end_median
 
median_is_a:
    movl 8(%ebp), %eax
    jmp end_median
 
median_is_b:
    movl 12(%ebp), %eax
    jmp end_median
 
end_median:
    popl %edx
    popl %ecx
    popl %ebx
    movl %ebp, %esp
    popl %ebp
    ret

et voilà le programme c appelant :

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
#include <stdio.h>
 
// Déclaration de la fonction assembleur
int median3(int a, int b, int c);
 
int main() {
    int a, b, c, m;
 
    // Exemple 1
    a = 10; b = 20; c = 15;
    m = median3(a, b, c);
    printf("median3(%d, %d, %d) = %d\n", a, b, c, m);
 
    // Exemple 2
    a = -5; b = 0; c = -10;
    m = median3(a, b, c);
    printf("median3(%d, %d, %d) = %d\n", a, b, c, m);
 
    // Exemple 3
    a = 8; b = 8; c = 10;
    m = median3(a, b, c);
    printf("median3(%d, %d, %d) = %d\n", a, b, c, m);
 
    return 0;}

Si vous pouviez m'aider à trouver le/les problèmes, merci.

[fred1599]

Hello,

L'erreur est due à une incompatibilité d'ABI (convention d'appel). Votre code C compile en 64-bits (passant les arguments par registres) tandis que votre assembleur 32-bits les attend sur la pile.

Vous pouvez résoudre le "segfault" en forçant la compilation 32-bits avec gcc -m32 ... (après avoir installé gcc-multilib).

P.S : Il est toujours préférable de donner la commande de compilation...

[lynzpl]

Hello,

L'erreur est due à une incompatibilité d'ABI (convention d'appel). Votre code C compile en 64-bits (passant les arguments par registres) tandis que votre assembleur 32-bits les attend sur la pile.

Vous pouvez résoudre le "segfault" en forçant la compilation 32-bits avec gcc -m32 ... (après avoir installé gcc-multilib).

P.S : Il est toujours préférable de donner la commande de compilation...

Je complie bien avec gcc -m32 mais j'ai quand même cette erreur.

Je compile comme ça : gcc -m32 -o prog main.c median3.s
puis ./prog

[Obsidian]

Ça compile chez moi avec la commande donnée et ça semble fonctionner :

Code Shell :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
$ gcc -m32 --std=c99 -o prog main.c median3.s
$ ./prog 
median3(10, 20, 15) = 20
median3(-5, 0, -10) = -5
median3(8, 8, 10) = 8

En précisant que je compile cela sur un ancien Code 2 Quad Q9550 de 2008 mais que cela reste une machine Linux nativement 64 bits et à jour (Fedora 41), avec libs 32 et 64 bits installées.

Peux-tu compiler avec l'option « -g » puis utiliser gdb pour savoir à quel endroit ça plante chez toi en particulier ? Car les seuls accès mémoire par pointeur effectués par ton programme sont ceux qui justement chargent les trois paramètres depuis la pile. Hormis cet endroit, tu n'utilises que des variables locales dans ton programmes C et n'effectues que des échanges de registres dans ton programme assembleur. Ça ne laisse pas beaucoup de place pour une segfault, en effet…