__attribute__（（__aligned__））不能與靜態變量一起工作

Question

這讓我堅持了幾天。如果我聲明它爲static，我無法獲得一個數組來對齊到16。

任何幫助非常感謝。

修訂版：

#include <stdio.h> 
#include <assert.h> 

#define MAX_INPUTS 250 

int main() 
{ 
float input[MAX_INPUTS] __attribute__ ((__aligned__(16))); 
printf("Address of input: %p\n", input); 

printf("Assert1: %x\n", (((int) (input))  )  ); 
printf("Assert2: %x\n", (((int) (input)) % 16)  ); 
printf("Assert3: %x\n", (((int) (input)) % 16) == 0 ); 

assert ( (((int) (input))  )  ); 
assert ( (((int) (input)) % 16)  ); /* Fails */ 
assert ( (((int) (input)) % 16) == 0 ); /* Passes */ 

return 0; 
} 

的輸出是：

Address of input: 0022FB70 
Assert1: 22fb70 
Assert2: 0 
Assert3: 1 
Assertion failed: (((int) (input)) % 16), file aligntest.c, line 16 

正如人們所期望的，斷言2，因爲在地址0結束失敗然而，利用：

static float input[MAX_INPUTS] __attribute__ ((__aligned__(16))); 

的輸出是：

Address of input: 00404028 
Assert1: 404028 
Assert2: 8 
Assert3: 1 
Assertion failed: (((int) (input)) % 16), file aligntest.c, line 16 

斷言2仍然失敗，但結果不爲零。當Assert2被註釋掉時，Assert3通過（有或沒有靜態聲明）並且程序正常終止。

我在運行XP Pro的Intel Core 2 Duo上使用MinGw gcc 4.4.0。

Answer 1

在我工作的機器上（Windows Vista，MinGW gcc 4.3.2），您的代碼在任何優化級別都沒有生成任何assert的彙編器！

爲了得到要生成的斷言，我不得不想出volatile int變量並編譯-O0標誌。

int main(void) { 
    float input[MAX_INPUTS] __attribute__ ((__aligned__(16))); 
    static float input_static[MAX_INPUTS] __attribute__ ((__aligned__(16))); 
    volatile int addr_as_int; 

    printf("Address of input: %p\n", &input); 
    addr_as_int = (int)input; 
    print_pointer(input); 
    print_int(addr_as_int); 
    printf("normal int: %08x; int%%16: %02x\n", addr_as_int, addr_as_int%16); 
    printf("Assert: %d\n", (addr_as_int % 16) == 0); 
    assert((addr_as_int % 16) == 0); /* Passes */ 

    printf("Address of input_static: %p\n", &input_static); 
    addr_as_int = (int)input_static; 
    print_pointer(input_static); 
    print_int(addr_as_int); 
    printf("static int: %08x; int%%16: %02x\n", addr_as_int, (addr_as_int)%16); 
    printf("Assert: %d\n", (addr_as_int % 16) == 0); 
    assert((addr_as_int % 16) == 0); /* Does not Pass */ 

    return 0; 
} 

我不知道爲什麼編譯器選擇從對象文件中刪除斷言。我快速谷歌搜索沒有透露任何有趣的。

更新1（@Pax在@Falaina的建議添加 - 我們都建議你接受這一個，如果它原來是如此）：

其實我覺得@Falaina在已經釘它評論@帕克斯的回答：

只是一個建議。你是否在編譯優化？編譯器可能會嘗試變得聰明，並且「嘿，這個變量對齊到16個字節，顯然地址是％16」，並用1替換所有的檢查。只是一個想法。

下面是解釋。 GCC從源代碼中確定輸入確實（應該是）對齊到16個字節。它足夠聰明，完全可以刪除assert，只需打印1就可以得到printf。

然而，在鏈路級，所述接頭是不能保證對準到16個字節，而不是選擇爲8，因爲（來自@Pax）：

注意，對齊屬性的有效性可被限制通過鏈接器的固有限制。在很多系統上，鏈接器只能將變量排列成一定的最大對齊。 （對於某些連接器，支持的最大對齊可能非常小）。如果鏈接器只能對齊最多8個字節對齊的變量，則在__attribute__中指定對齊（16）仍然只能爲您提供8字節對齊。有關更多信息，請參閱鏈接器文檔。

到時候把assert和非優化的printf回到代碼中已經太遲了。所以實際的可執行文件不會斷言（因爲它們已被取出），它將打印優化的1而不是計算它的運行時間。

volatile修復它在我的答案是因爲GCC不會優化包含易失組件的表達式。它將離開assert並在運行時正確計算printf參數。

---

您可以手動調整您的數組，如果你不介意的聲明比stricly需要大一點：

#include <assert.h> 
#include <stdio.h> 

#define MAX_INPUTS 250 

void *force_align(void *base, size_t s, int align) { 
    size_t x; 
    int k = 0; 
    x = (size_t)base; 
    while ((k < align/(int)s) && (x % align)) { 
    k++; 
    x += s; 
    } 
    if (k == align) return NULL; 
#if 0 
    printf("%d elements 'discarded'\n", k); 
#endif 
    return (void*)((size_t)base + k*s); 
} 

int main(void) { 
    #define ALIGNMENT_REQ 16 
    #define EXTRA_ALIGN_REQ (ALIGNMENT_REQ/sizeof (float)) 
    static float misaligned_input[MAX_INPUTS + EXTRA_ALIGN_REQ] 
     __attribute__ ((__aligned__(ALIGNMENT_REQ))); 
    float *input; 

    /* manual alignment, check for NULL */ 
    assert((input = force_align(misaligned_input, sizeof *input, ALIGNMENT_REQ))); 

    printf("Address of misaligned input: %p\n", misaligned_input); 
    printf("Address of input: %p\n", input); 
    printf("Assert1: %x\n", (((int) (input))    )  ); 
    printf("Assert2: %x\n", (((int) (input)) % ALIGNMENT_REQ)  ); 
    printf("Assert3: %x\n", (((int) (input)) % ALIGNMENT_REQ) == 0); 
    assert ((((int) (input))    )  ); 
#if 0 
    assert ((((int) (input)) % ALIGNMENT_REQ)  ); /* Fails */ 
#endif 
    assert ((((int) (input)) % ALIGNMENT_REQ) == 0); /* Passes */ 

    return 0; 
} 

Answer 2

我想不出有什麼好的理由，但是在＆frac12;一個小時你沒有得到任何其他的答案要麼，所以我會用一種風格的投訴和一些猜測和懷疑去...

• 請把&出地址表達式的第一printf()。雖然(&array)和(array)在C中具有相同的值，但在兩行寫入時卻似乎有些錯誤。有一天，只要關心程序中的小東西就可以節省您的錯誤，或者有人會將操作數的類型更改爲額外的&生成雙重間接指針。無論如何，風格很重要。我無法證明這一點，但我確信它的確如此。

• 讓事情變得非常簡單。通過傳遞不可能斷言的static存儲類專注於故障情況。創建一個完全沒有任何內容的新目錄，僅複製失敗案例程序，然後根據CLI嘗試使用./whatever或.\whatever運行它。驗證沒有運行，直到你編譯它。確定你正在運行你認爲你自己的東西。

• 讓我們確切地知道你在XP上使用哪個GNU環境，有幾個。

Answer 3

從here：

注意，對齊屬性的有效性可以通過你的連接器固有的侷限性所限制。在很多系統上，鏈接器只能將變量排列成一定的最大對齊。 （對於某些連接器，支持的最大對齊可能非常小）。如果鏈接器只能對齊最多8個字節對齊的變量，則在__attribute__中指定對齊（16）仍然只能爲您提供8字節對齊。有關更多信息，請參閱鏈接器文檔。

我知道爲什麼斷言是不會發生，這是因爲表達的是真實的 - 不知道確切爲什麼表達是真實的，但你應該把它分解在這樣的情況下。將這些添加到您的調試聲明中：

printf("Assert1: %x\n", (((int) (input)))); 
printf("Assert2: %x\n", (((int) (input)) % 16)); 
printf("Assert3: %x\n", (((int) (input)) % 16) == 0); 

並向我們顯示結果。

此外，請檢查您正在運行的gcc版本 - 4.3.1和更早版本似乎有一個problem與對齊方式。 Cygwin似乎同時擁有gcc3和gcc4軟件包，假設您正在使用的是 - 如果不是，仍然檢查版本。

更新1：其實我認爲@Falaina已將它釘在下面的評論中。這是一個合理的解釋。

GCC從源代碼中確定輸入確實（應該是）對齊到16個字節。它足夠聰明，完全放棄斷言，併爲printf打印出1。

但是，在鏈接階段，鏈接器（不如GCC的能力）不能保證對齊到16個字節，而是選擇8（參見上面的我的報價）。到那時，將斷言和非優化的printf返回到代碼中爲時已晚。所以實際的可執行文件不會斷言（因爲它們已被取出），它將打印優化的1而不是計算它的運行時間。

揮發性修復它在@ pmg答案中的原因是因爲GCC將而不是優化包含易失組分的表達式。它將斷言保留並在運行時正確計算打印參數。

如果事實證明是這樣，這毫無疑問是我見過的更狡猾的問題之一。我毫不猶豫地把它稱爲​​一個bug，因爲gcc和ld都像廣告一樣行事 - 這是各種因素的結合。

Answer 4

從pointer to array of float到int的轉換不一定有意義。 如果pointer to array of floats大於int，則會丟失一些信息，這些信息可能是指針的「低位位」。

試試這個：

#include <stdio.h> 
#include <string.h> 

void print_pointer(void *ptr) { 
    unsigned char data[sizeof (void*)]; 
    size_t k; 

    memmove(data, &ptr, sizeof (void*)); 
    printf("ptr: "); 
    for (k=0; k<sizeof (void*); k++) { 
    printf(" %02x", data[k]); 
    } 
    puts(""); 
} 

做同樣的一個int

void print_int(int value) { /* ... */ } 

，並比較你的發現。