web-dev-qa-db-fra.com

Les variables de pile sont-elles alignées par l'attribut GCC __ ((aligné (x)))?

j'ai le code suivant:

#include <stdio.h>

int
main(void)
{
        float a[4] __attribute__((aligned(0x1000))) = {1.0, 2.0, 3.0, 4.0};
        printf("%p %p %p %p\n", &a[0], &a[1], &a[2], &a[3]);
}

Et j'ai la sortie suivante:

0x7fffbfcd2da0 0x7fffbfcd2da4 0x7fffbfcd2da8 0x7fffbfcd2dac

Pourquoi l'adresse de a[0] N'est pas un multiple de 0x1000?

Que fait exactement __attribute__((aligned(x)))? J'ai mal compris cette explication?

J'utilise gcc 4.1.2.

cmemorygccalignment
86
cojocar

Je crois que le problème est que votre tableau est sur la pile. Étant donné que le pointeur de pile peut être n'importe quoi au démarrage de la fonction, il n'y a aucun moyen d'aligner le tableau sans allouer beaucoup plus que ce dont vous avez besoin et l'ajuster. Si vous déplacez le tableau hors de la fonction et dans une variable globale, cela devrait fonctionner. L'autre chose que vous pourriez faire est de la conserver en tant que variable locale (ce qui est une très bonne chose), mais faites-la static. Cela l'empêchera d'être stocké sur la pile. Sachez que ces deux méthodes ne sont pas adaptées aux threads ou aux récursions, car il n'y aura qu'une seule copie du tableau.

Avec ce code:

#include <stdio.h>

float a[4] __attribute__((aligned(0x1000))) = {1.0, 2.0, 3.0, 4.0};

int
main(void)
{
        printf("%p %p %p %p\n", &a[0], &a[1], &a[2], &a[3]);
}

J'ai compris:

0x804c000 0x804c004 0x804c008 0x804c00c

c'est ce qui est attendu. Avec votre code d'origine, j'obtiens juste des valeurs aléatoires comme vous l'avez fait.

94
Zifre

Il y avait un bogue dans gcc qui faisait que l'attribut était aligné pour ne pas fonctionner avec les variables de pile. Il semble être corrigé avec le patch lié ci-dessous. Le lien ci-dessous contient également un peu de discussion sur le problème.

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=1666

J'ai essayé votre code ci-dessus avec deux versions différentes de gcc: 4.1.2 à partir d'une boîte RedHat 5.7, et il a échoué de la même manière que votre problème (les tableaux locaux n'étaient en aucun cas alignés sur les limites de 0x1000 octets). J'ai ensuite essayé votre code avec gcc 4.4.6 sur RedHat 6.3, et cela a fonctionné parfaitement (les tableaux locaux étaient alignés). Les gens de Myth TV ont eu un problème similaire (que le correctif gcc ci-dessus semblait résoudre):

http://code.mythtv.org/trac/ticket/6535

Quoi qu'il en soit, il semble que vous ayez trouvé un bogue dans gcc, qui semble avoir été corrigé dans les versions ultérieures.

40
rts1

GCC récent (testé avec 4.5.2-8ubuntu4) semble fonctionner comme prévu avec le tableau correctement aligné.

#include <stdio.h>

int main(void)
{
    float a[4] = { 1.0, 2.0, 3.0, 4.0 };
    float b[4] __attribute__((aligned(0x1000))) = { 1.0, 2.0, 3.0, 4.0 };
    float c[4] __attribute__((aligned(0x10000))) = { 1.0, 2.0, 3.0, 4.0 };

    printf("%p %p %p %p\n", &a[0], &a[1], &a[2], &a[3]);
    printf("%p %p %p %p\n", &b[0], &b[1], &b[2], &b[3]);
    printf("%p %p %p %p\n", &c[0], &c[1], &c[2], &c[3]);
}

Je reçois:

0x7ffffffefff0 0x7ffffffefff4 0x7ffffffefff8 0x7ffffffefffc
0x7ffffffef000 0x7ffffffef004 0x7ffffffef008 0x7ffffffef00c
0x7ffffffe0000 0x7ffffffe0004 0x7ffffffe0008 0x7ffffffe000c
13
Caleb Case

L'alignement n'est pas efficace pour tous les types. Vous devriez envisager d'utiliser une structure pour voir les attributs en action:

#include <stdio.h>

struct my_float {
        float number;
}  __attribute__((aligned(0x1000)));

struct my_float a[4] = { {1.0}, {2.0}, {3.0}, {4.0} };

int
main(void)
{
        printf("%p %p %p %p\n", &a[0], &a[1], &a[2], &a[3]);
}

Et puis, vous lirez:

0x603000 0x604000 0x605000 0x606000

C'est ce que vous attendiez.

Edit: Poussé par @yzap et suite au commentaire de cas @Caleb, le problème initial est dû à la version GCC seulement. J'ai vérifié sur GCC 3.4.6 vs GCC 4.4.1 avec le code source du demandeur:

$ ./test_orig-3.4.6
0x7fffe217d200 0x7fffe217d204 0x7fffe217d208 0x7fffe217d20c
$ ./test_orig-4.4.1
0x7fff81db9000 0x7fff81db9004 0x7fff81db9008 0x7fff81db900c

Il est maintenant évident que les anciennes versions de GCC (quelque part avant 4.4.1) montrent des pathologies d'alignement.

Note 1: Mon code proposé ne répond pas à la question que j'ai comprise comme "aligner chaque champ du tableau".

Note 2: Apporter un [] non statique à l'intérieur de main () et compiler avec GCC 3.4.6 rompt la directive d'alignement du tableau de struct mais garde une distance de 0x1000 entre les structs ... toujours mauvais! (voir la réponse @zifre pour les solutions de contournement)

9
levif