Yığın değişkenleri GCC __özniteliği __ ((hizalı (x))) ile hizalı mı?

Takip koduna sahibim:

#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]);
}

Ve şu çıktıya sahibim:

0x7fffbfcd2da0 0x7fffbfcd2da4 0x7fffbfcd2da8 0x7fffbfcd2dac

Adresi neden a[0]birden fazla değil 0x1000?

Tam olarak ne __attribute__((aligned(x)))yapar? Bu açıklamayı yanlış mı anladım ?

Gcc 4.1.2 kullanıyorum.

Sorunun, dizinizin yığında olması ve derleyicinizin aşırı hizalanmış yığın değişkenlerini destekleyemeyecek kadar eski olması olduğuna inanıyorum. GCC 4.6 ve sonrası bu hatayı düzeltti .

C11 / C ++ 11 alignas(64) float a[4];Herhangi bir 2 hizalamanın gücü için çalışır. Sizin kullandığınız
GNU C __attribute__((aligned(x)))de öyle.

(In C11, #include <stdalign.h>için #define alignas _Alignas: cppref ).

Ancak 4k sayfa sınırına göre çok büyük bir hizalama durumunda, bunu yığında istemeyebilirsiniz.

Yığın işaretçisi, işlev başladığında herhangi bir şey olabileceğinden, ihtiyacınız olandan çok daha fazlasını ayırmadan ve onu ayarlamadan diziyi hizalamanın bir yolu yoktur. (Derleyiciler, and rsp, -4096tahsis edilen 0 ila 4088 bayttan hiçbirini kullanmayacak veya eşdeğeri kullanmayacak; bu alanın yeterince büyük olup olmadığına göre dallanma mümkün olabilirdi, ancak yapılmaz çünkü büyük hizalamalar dizinin veya diğer yerellerin boyutundan çok daha büyüktür. normal durum değildir.)

Diziyi işlevin dışına ve global bir değişkene taşırsanız, çalışması gerekir. Yapabileceğiniz diğer şey, onu yerel bir değişken olarak tutmaktır (ki bu çok iyi bir şeydir), ama yapın static. Bu, yığında depolanmasını önleyecektir. Dizinin yalnızca bir kopyası olacağından, bu iki yolun da iş parçacığı veya özyineleme güvenli olmadığına dikkat edin.

Bu kodla:

#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]);
}

Bunu anlıyorum:

0x804c000 0x804c004 0x804c008 0x804c00c

beklenen de bu. Orijinal kodunuzla, sizin yaptığınız gibi rastgele değerler alıyorum.

Gcc'de özniteliğin yığın değişkenleriyle çalışmamasına neden olan bir hata vardı . Aşağıda bağlantılı yama ile düzeltilmiş görünüyor. Aşağıdaki bağlantı aynı zamanda sorun için oldukça fazla tartışma içermektedir.

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

Yukarıdaki kodunuzu RedHat 5.7 kutusundan iki farklı gcc sürümüyle denedim: 4.1.2 ve probleminize benzer şekilde başarısız oldu (yerel diziler hiçbir şekilde 0x1000 bayt boundaies ile hizalanmadı). Daha sonra kodunuzu RedHat 6.3 üzerinde gcc 4.4.6 ile denedim ve kusursuz çalıştı (yerel diziler hizalandı). Myth TV ekibinin benzer bir sorunu vardı (yukarıdaki gcc yamasının çözdüğü görülüyordu):

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

Her neyse, gcc'de sonraki sürümlerde düzeltilmiş gibi görünen bir hata bulmuşsunuz gibi görünüyor.

Son GCC (4.5.2-8ubuntu4 ile test edildi), dizi düzgün şekilde hizalanmış olarak beklendiği gibi çalışıyor gibi görünmektedir.

#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]);
}

Alırım:

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

Hizalama tüm türler için etkili değildir. Öznitelikleri çalışırken görmek için bir yapı kullanmayı düşünmelisiniz:

#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]);
}

Ve sonra okuyacaksınız:

0x603000 0x604000 0x605000 0x606000

Hangisini bekliyordun.

Düzenleme: @yzap tarafından gönderilen ve @Caleb Case yorumunun ardından, ilk sorun yalnızca GCC sürümünden kaynaklanmaktadır . İstekte bulunan kişinin kaynak koduyla GCC 3.4.6 ve GCC 4.4.1 karşılaştırmasını kontrol ettim:

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

Artık daha eski GCC sürümlerinin (4.4.1'den önceki bir yerde) hizalama patolojileri gösterdiği açıktır.

Not 1: Önerilen kodum, "dizinin her alanını hizalamak" olarak anladığım soruyu yanıtlamıyor.

Not 2: Statik olmayan a [] 'yi main () içerisine getirmek ve GCC 3.4.6 ile derlemek yapı dizisinin hizalama yönergesini bozar ancak yapılar arasındaki 0x1000 mesafesini korur ... yine de kötü! (geçici çözümler için @zifre yanıtına bakın)