_attribute_很有意思！

阿新 • • 發佈：2019-01-04

GNU C 的一大特色就是__attribute__ 機制。__attribute__ 可以設定函式屬性（Function Attribute ）、變數屬性（Variable Attribute ）和型別屬性（Type Attribute ）。

__attribute__ 書寫特徵是：__attribute__ 前後都有兩個下劃線，並切後面會緊跟一對原括弧，括弧裡面是相應的__attribute__ 引數。

__attribute__ 語法格式為：__attribute__ ((attribute-list))

其位置約束為：放於宣告的尾部“ ；” 之前。

關鍵字__attribute__ 也可以對結構體（struct ）或共用體（union ）進行屬性設定。大致有六個引數值可以被設定，即：aligned, packed, transparent_union, unused, deprecated 和 may_alias 。

在使用__attribute__ 引數時，你也可以在引數的前後都加上“__” （兩個下劃線），例如，使用__aligned__而不是aligned ，這樣，你就可以在相應的標頭檔案裡使用它而不用關心標頭檔案裡是否有重名的巨集定義。

aligned (alignment)

該屬性設定一個指定大小的對齊格式（以位元組為單位），例如：

struct S {

short b[3];

} __attribute__ ((aligned (8)));

typedef int int32_t __attribute__ ((aligned (8)));

該宣告將強制編譯器確保（盡它所能）變數類型為struct S 或者int32_t 的變數在分配空間時採用8 位元組對齊方式。

如上所述，你可以手動指定對齊的格式，同樣，你也可以使用預設的對齊方式。如果aligned 後面不緊跟一個指定的數字值，那麼編譯器將依據你的目標機器情況使用最大最有益的對齊方式。例如：

struct S {

short b[3];

} __attribute__ ((aligned));

這裡，如果sizeof （short ）的大小為2 （byte ），那麼，S 的大小就為6 。取一個2 的次方值，使得該值大於等於6 ，則該值為8 ，所以編譯器將設定S 型別的對齊方式為8 位元組。

aligned 屬性使被設定的物件佔用更多的空間，相反的，使用packed 可以減小物件佔用的空間。

需要注意的是，attribute 屬性的效力與你的聯結器也有關，如果你的聯結器最大隻支援16 位元組對齊，那麼你此時定義32 位元組對齊也是無濟於事的。

packed

使用該屬性對struct 或者union 型別進行定義，設定其型別的每一個變數的記憶體約束。當用在enum 型別定義時，暗示了應該使用最小完整的型別（it indicates that the smallest integral type should be used）。

下面的例子中，packed_struct 型別的變數陣列中的值將會緊緊的靠在一起，但內部的成員變數s 不會被“pack” ，如果希望內部的成員變數也被packed 的話，unpacked-struct 也需要使用packed 進行相應的約束。

struct unpacked_struct

{

char c;

int i;

};

struct packed_struct

{

char c;

int i;

struct unpacked_struct s;

}__attribute__ ((__packed__));

下面的例子中使用__attribute__ 屬性定義了一些結構體及其變數，並給出了輸出結果和對結果的分析。

程式代碼為：

 1 struct p
 2 
 3 {
 4 
 5 int a;
 6 
 7 char b;
 8 
 9 short c;
10 
11 }__attribute__((aligned(4))) pp;
12 
13 struct m
14 
15 {
16 
17 char a;
18 
19 int b;
20 
21 short c;
22 
23 }__attribute__((aligned(4))) mm;
24 
25 struct o
26 
27 {
28 
29 int a;
30 
31 char b;
32 
33 short c;
34 
35 }oo;
36 
37 struct x
38 
39 {
40 
41 int a;
42 
43 char b;
44 
45 struct p px;
46 
47 short c;
48 
49 }__attribute__((aligned(8))) xx;
50 
51 int main()
52 
53 {
54 
55 printf("sizeof(int)=%d,sizeof(short)=%d.sizeof(char)=%d\n",sizeof(int),sizeof(short),sizeof(char));
56 
57 printf("pp=%d,mm=%d \n", sizeof(pp),sizeof(mm));
58 
59 printf("oo=%d,xx=%d \n", sizeof(oo),sizeof(xx));
60 
61 return 0;
62 
63 }

輸出結果：

sizeof(int)=4,sizeof(short)=2.sizeof(char)=1

pp=8,mm=12

oo=8,xx=24

分析：

sizeof(pp):

sizeof(a)+sizeof(b)+sizeof(c)=4+1+1=6<8 所以sizeof(pp)=8

sizeof(mm):

sizeof(a)+sizeof(b)+sizeof(c)=1+4+2=7

但是 a 後面需要用 3 個位元組填充，但是 b 是 4 個位元組，所以 a 佔用 4 位元組， b 佔用 4 個位元組，而 c 又要佔用 4 個位元組。所以 sizeof(mm)=12

sizeof(oo):

sizeof(a)+sizeof(b)+sizeof(c)=4+1+2=7

因為默認是以4 位元組對齊，所以sizeof(oo)=8

sizeof(xx):

sizeof(a)+ sizeof(b)=4+1=5

sizeof(pp)=8; 即xx 是採用8 位元組對齊的，所以要在a ，b 後面添3 個空餘位元組，然後才能儲存px ，

4+1+ （3 ）+8+1=17

因為xx 採用的對齊是8 位元組對齊，所以xx 的大小必定是8 的整數倍，即xx 的大小是一個比17 大又是8 的倍數的一個最小值，由此得到

17<24 ，所以sizeof(xx)=24

函式屬性（Function Attribute）
函式屬性可以幫助開發者把一些特性新增到函式宣告中，從而可以使編譯器在錯誤檢查方面的功能更強大。__attribute__機制也很容易同非GNU應用程式做到相容之功效。
GNU CC需要使用 –Wall編譯器來擊活該功能，這是控制警告資訊的一個很好的方式。下面介紹幾個常見的屬性引數。
__attribute__ format
該__attribute__屬性可以給被宣告的函式加上類似printf或者scanf的特徵，它可以使編譯器檢查函式宣告和函式實際呼叫引數之間的格式化字串是否匹配。該功能十分有用，尤其是處理一些很難發現的bug。
format的語法格式為：
format (archetype, string-index, first-to-check)
format屬性告訴編譯器，按照printf, scanf,
strftime或strfmon的引數表格式規則對該函式的引數進行檢查。“archetype”指定是哪種風格；“string-index”指定傳入函式的第幾個引數是格式化字串；“first-to-check”指定從函式的第幾個引數開始按上述規則進行檢查。
具體使用格式如下：
__attribute__((format(printf,m,n)))
__attribute__((format(scanf,m,n)))
其中引數m與n的含義為：
m：第幾個引數為格式化字串（format string）；
n：引數集合中的第一個，即引數“…”裡的第一個引數在函式引數總數排在第幾，注意，有時函式引數裡還有“隱身”的呢，後面會提到；
在使用上，__attribute__((format(printf,m,n)))是常用的，而另一種卻很少見到。下面舉例說明，其中myprint為自己定義的一個帶有可變引數的函式，其功能類似於printf：

//m=1；n=2
extern void myprint(const char *format,...) __attribute__((format(printf,1,2)));
//m=2；n=3
extern void myprint(int l，const char *format,...)
__attribute__((format(printf,2,3)));
需要特別注意的是，如果myprint是一個函式的成員函式，那麼m和n的值可有點“懸乎”了，例如：
//m=3；n=4
extern void myprint(int l，const char *format,...)
__attribute__((format(printf,3,4)));
其原因是，類成員函式的第一個引數實際上一個“隱身”的“this”指標。（有點C++基礎的都知道點this指標，不知道你在這裡還知道嗎？）
這裡給出測試用例：attribute.c，程式碼如下：

1：
2：extern void myprint(const char *format,...) 
__attribute__((format(printf,1,2)));
3：
4：void test()
5：{
6：     myprint("i=%d\n",6);
7：     myprint("i=%s\n",6);
8：     myprint("i=%s\n","abc");
9：     myprint("%s,%d,%d\n",1,2);
10：}

執行$gcc –Wall –c attribute.c attribute後，輸出結果為：

attribute.c: In function `test':
attribute.c:7: warning: format argument is not a pointer (arg 2)
attribute.c:9: warning: format argument is not a pointer (arg 2)
attribute.c:9: warning: too few arguments for format

如果在attribute.c中的函式宣告去掉__attribute__((format(printf,1,2)))，再重新編譯，既執行$gcc –Wall –c attribute.c attribute後，則並不會輸出任何警告資訊。
注意，預設情況下，編譯器是能識別類似printf的“標準”庫函式。
__attribute__ noreturn
該屬性通知編譯器函式從不返回值，當遇到類似函式需要返回值而卻不可能執行到返回值處就已經退出來的情況，該屬性可以避免出現錯誤資訊。C庫函式中的abort（）和exit（）的宣告格式就採用了這種格式，如下所示：

extern void exit(int) __attribute__((noreturn));extern void abort(void) __attribute__((noreturn)); 為了方便理解，大家可以參考如下的例子：

 1 //name: noreturn.c     ；測試__attribute__((noreturn))
 2 extern void myexit();
 3 
 4 int test(int n)
 5 {
 6            if ( n > 0 )
 7           {
 8                    myexit();
 9                  /* 程式不可能到達這裡*/
10           }
11            else
12                    return 0;
13 }

編譯顯示的輸出資訊為：

$gcc –Wall –c noreturn.c
noreturn.c: In function `test':
noreturn.c:12: warning: control reaches end of non-void function

警告資訊也很好理解，因為你定義了一個有返回值的函式test卻有可能沒有返回值，程式當然不知道怎麼辦了！
加上__attribute__((noreturn))則可以很好的處理類似這種問題。把
extern void myexit();修改為：
extern void myexit() __attribute__((noreturn));之後，編譯不會再出現警告資訊。
__attribute__ const
該屬性只能用於帶有數值型別引數的函式上。當重複呼叫帶有數值引數的函式時，由於返回值是相同的，所以此時編譯器可以進行優化處理，除第一次需要運算外，其它只需要返回第一次的結果就可以了，進而可以提高效率。該屬性主要適用於沒有靜態狀態（static state）和副作用的一些函式，並且返回值僅僅依賴輸入的引數。
為了說明問題，下面舉個非常“糟糕”的例子，該例子將重複呼叫一個帶有相同引數值的函式，具體如下：

extern int square(int n) __attribute__     ((const));...                  for (i = 0; i < 100; i++ )                  {       total += square (5) + i;             }
通過新增__attribute__((const))宣告，編譯器只調用了函式一次，以後只是直接得到了相同的一個返回值。
事實上，const引數不能用在帶有指標型別引數的函式中，因為該屬性不但影響函式的引數值，同樣也影響到了引數指向的資料，它可能會對程式碼本身產生嚴重甚至是不可恢復的嚴重後果。
並且，帶有該屬性的函式不能有任何副作用或者是靜態的狀態，所以，類似getchar（）或time（）的函式是不適合使用該屬性的。
-finstrument-functions
該引數可以使程式在編譯時，在函式的入口和出口處生成instrumentation呼叫。恰好在函式入口之後並恰好在函數出口之前，將使用當前函式的地址和呼叫地址來呼叫下面的
profiling
函式。（在一些平臺上，__builtin_return_address不能在超過當前函式範圍之外正常工作，所以呼叫地址資訊可能對profiling函式是無效的。）

void __cyg_profile_func_enter(void *this_fn, void *call_site);
void __cyg_profile_func_exit(void *this_fn, void *call_site);

其中，第一個引數this_fn是當前函式的起始地址，可在符號表中找到；第二個引數call_site是指呼叫處地址。
instrumentation
也可用於在其它函式中展開的行內函數。從概念上來說，profiling呼叫將指出在哪裡進入和退出行內函數。這就意味著這種函式必須具有可定址形式。如果函式包含內聯，而所有使用到該函式的程式都要把該內聯展開，這會額外地增加程式碼長度。如果要在C 程式碼中使用extern inline宣告，必須提供這種函式的可定址形式。
可對函式指定no_instrument_function屬性，在這種情況下不會進行 Instrumentation操作。例如，可以在以下情況下使用no_instrument_function屬性：上面列出的profiling函數、高優先順序的中斷例程以及任何不能保證profiling正常呼叫的函式。
no_instrument_function
如果使用了-finstrument-functions
，將在絕大多數使用者編譯的函式的入口和出口點呼叫profiling函式。使用該屬性，將不進行instrument操作。
constructor/destructor
若函式被設定為constructor屬性，則該函式會在main（）函式執行之前被自動的執行。類似的，若函式被設定為destructor屬性，則該函式會在main（）函式執行之後或者exit（）被呼叫後被自動的執行。擁有此類屬性的函式經常隱式的用在程式的初始化資料方面。
這兩個屬性還沒有在面向物件C中實現。
同時使用多個屬性
可以在同一個函式聲明裡使用多個__attribute__，並且實際應用中這種情況是十分常見的。使用方式上，你可以選擇兩個單獨的__attribute__，或者把它們寫在一起，可以參考下面的例子：

/* 把類似printf的訊息傳遞給stderr 並退出 */extern void die(const char *format, ...)                  __attribute__((noreturn))                  __attribute__((format(printf, 1, 2))); 或者寫成 extern void die(const char *format, ...)                  __attribute__((noreturn, format(printf, 1, 2))); 如果帶有該屬性的自定義函式追加到庫的標頭檔案裡，那麼所以呼叫該函式的程式都要做相應的檢查。

和非GNU編譯器的相容性
慶幸的是，__attribute__設計的非常巧妙，很容易作到和其它編譯器保持相容，也就是說，如果工作在其它的非GNU編譯器上，可以很容易的忽略該屬性。即使__attribute__使用了多個引數，也可以很容易的使用一對圓括弧進行處理，例如：

/* 如果使用的是非GNU C, 那麼就忽略__attribute__ */#ifndef __GNUC__#     define     __attribute__(x)     /*NOTHING*/#endif
需要說明的是，__attribute__適用於函式的宣告而不是函式的定義。所以，當需要使用該屬性的函式時，必須在同一個檔案裡進行宣告，例如：

/* 函式宣告 */void die(const char *format, ...) __attribute__((noreturn))                                     __attribute__((format(printf,1,2))); void die(const char *format, ...){                  /* 函式定義 */}

Specifying Attributes of Variables

aligned (alignment)This attribute specifies a minimum alignment for the variable or structure field, measured in bytes. For example, the declaration:

          int x __attribute__ ((aligned (16))) = 0;

causes the compiler to allocate the global variable x on a 16-byte boundary. On a 68040, this could be used in conjunction with an asm expression to access themove16 instruction which requires 16-byte aligned operands.

You can also specify the alignment of structure fields. For example, to create a double-word aligned int pair, you could write:

          struct foo { int x[2] __attribute__ ((aligned (8))); };

This is an alternative to creating a union with a double member that forces the union to be double-word aligned.

As in the preceding examples, you can explicitly specify the alignment (in bytes) that you wish the compiler to use for a given variable or structure field. Alternatively, you can leave out the alignment factor and just ask the compiler to align a variable or field to the maximum useful alignment for the target machine you are compiling for. For example, you could write:

          short array[3] __attribute__ ((aligned));

for more: http://gcc.gnu.org/onlinedocs/gcc-4.0.0/gcc/Variable-Attributes.html#Variable-Attributes

下面來看一個不一樣的HelloWorld程式:

#include <stdio.h>

#include <stdlib.h>

static __attribute__((constructor)) void before()

{

printf("Hello");

}

static __attribute__((destructor)) void after()

{

printf(" World!\n");

}

int main(int args,char ** argv)

{

return EXIT_SUCCESS;

}

我們知道這是一個HelloWorld程式，所以輸出的結果就是"Hello World!"，很簡單，不需要對這點過多關心.

下面我們來關心關心別的:

__attribute__((constructor))

__attribute__((destructor))

解釋一下：__attribute__((constructor)) 在main() 之前執行,__attribute__((destructor)) 在main()執行結束之後執行.

上面的例子中我沒有在main函式中新增任何的輸出，所以看不到具體的資訊.這點可以自己嘗試～

如果要在main()之前或者是執行完成之後，需要執行很多的前處理動作或者是後處理動作，我們應該怎麼處理?

也許，你需要下面這些東西:

__attribute__((constructor(PRIORITY)))

__attribute__((destructor(PRIORITY)))

PRIORITY: 優先順序.

好吧，下面就來試試：

執行的輸出如下:

從輸出的資訊看，前處理都是按照優先順序先後執行的，而後處理則是相反的，好吧，我們使用GDB除錯驗證一下:

從除錯的資訊也是驗證了上面的結果.

另外一個問題，優先順序有沒有範圍的？

其實剛開始我寫的程式中的優先順序是1,我們將上面的程式改一下，然後編譯看一下會有什麼樣的結果:

0-100(包括100),是內部保留的，所以在編碼的時候需要注意.

關於__attribute__的用法，可以有另外一種寫法，先宣告函式，然後再定義.

glibc多采用第一種寫法.

關於linux核心中的"__attribute__ ((packed))"

引用:
__attrubte__ ((packed)) 的作用就是告訴編譯器取消結構在編譯過程中的優化對齊,按照實際佔用位元組數進行對齊。

#define __u8 unsigned char
#define __u16 unsigned short

/* __attribute__ ((packed)) 的位置約束是放於宣告的尾部“；”之前 */
struct str_struct{
        __u8    a;
        __u8    b;
        __u8    c;
        __u16   d;
} __attribute__ ((packed));

/* 當用到typedef時，要特別注意__attribute__ ((packed))放置的位置，相當於：
* typedef struct str_stuct str;
* 而struct str_struct 就是上面的那個結構。
*/
typedef struct {
        __u8    a;
        __u8    b;
        __u8    c;
        __u16   d;
} __attribute__ ((packed)) str;

/* 在下面這個typedef結構中，__attribute__ ((packed))放在結構名str_temp之後，其作用是被忽略的，注意與結構str的區別。*/
typedef struct {
        __u8    a;
        __u8    b;
        __u8    c;
        __u16   d;
}str_temp __attribute__ ((packed));

typedef struct {
        __u8    a;
        __u8    b;
        __u8    c;
        __u16   d;
}str_nopacked;

int main(void)
{
        printf("sizeof str = %d\n", sizeof(str));
        printf("sizeof str_struct = %d\n", sizeof(struct str_struct));
        printf("sizeof str_temp = %d\n", sizeof(str_temp));
        printf("sizeof str_nopacked = %d\n", sizeof(str_nopacked));
        return 0;
}
編譯執行:
引用:
[[email protected] root]# ./packedtest
sizeof str = 5
sizeof str_struct = 5
sizeof str_temp = 6
sizeof str_nopacked = 6
GNU C的一大特色就是__attribute__機制。__attribute__可以設定函式屬性（Function Attribute）、變數屬性（Variable Attribute）和型別屬性（Type Attribute）。

__attribute__書寫特徵是：__attribute__前後都有兩個下劃線，並且後面會緊跟一對括弧，括弧裡面是相應的__attribute__引數。

__attribute__語法格式為：

__attribute__ ((attribute-list))

其位置約束：放於宣告的尾部“；”之前。

函式屬性（Function Attribute）：函式屬性可以幫助開發者把一些特性新增到函式宣告中，從而可以使編譯器在錯誤檢查方面的功能更強大。__attribute__機制也很容易同非GNU應用程式做到相容之功效。

GNU CC需要使用 –Wall編譯器來擊活該功能，這是控制警告資訊的一個很好的方式。

packed屬性：使用該屬性可以使得變數或者結構體成員使用最小的對齊方式，即對變數是一位元組對齊，對域（field）是位對齊。

網路通訊通常分為基於資料結構的和基於流的。HTTP協議就是後者的一個例子。
    有時為了提高程式的處理速度和資料處理的方便，會使用基於資料結構的通訊（不需要對流進行解析）。但是，當需要在多平臺間進行通訊時，基於資料結構的通訊，往往要十分注意以下幾個方面：
[1] 位元組序
[2] 變數長度
[3] 記憶體對齊
    在常見的系統架構中（Linux X86，Windows），非單位元組長度的變數型別，都是低位元組在前，而在某些特定系統中，如Soalris Sparc平臺，高位元組在前。如果在傳送資料前不進行處理，那麼由Linux X86發向Soalris Sparc平臺的資料值，勢必會有極大的偏差，進而程式執行過程中無法出現預計的正常結果，更嚴重時，會導致段錯誤。
    對於此種情況，我們往往使用同一的位元組序。在系統中，有ntohXXX(), htonXXX()等函式，負責將資料在網路位元組序和本地位元組序之間轉換。雖然每種系統的本地位元組序不同，但是對於所有系統來說，網路位元組序是固定的 -----高位元組在前。所以，可以以網路位元組序為通訊的標準，傳送前，資料都轉換為網路位元組序。
    轉換的過程，也建議使用ntohXXX(), htonXXX()等標準函式，這樣程式碼可以輕鬆地在各平臺間進行移植（像通訊這種很少依賴系統API的程式碼，做成通用版本是不錯的選擇）。

    變數的長度，在不同的系統之間會有差別，如同是Linux2.6.18的平臺，在64位系統中，指標的長度為8個位元組，而在32位系統中，指標又是4個字節的長度---此處只是舉個例子，很少有人會將指標作為資料傳送出去。下面是我整理的在64位Linux系統和32位Linux系統中，幾種常見C語言變量的長度：
                short    int    long    long long    ptr    time_t
32位           2         4       4             8               4        4
64位           2         4       8             8               8        8
    在定義通訊用的結構體時，應該考慮使用定常的資料型別，如uint32_t，4位元組的固定長度，並且這屬於標準C庫(C99)，在各系統中都可使用。

    記憶體對齊的問題，也與系統是64位還是32位有關。如果你手頭有32位和64位系統，不妨寫個簡單的程式測試一下，你就會看到同一個結構體，即便使用了定常的資料型別，在不同系統中的大小是不同的。對齊往往是以4位元組或8位元組為準的，只要你寫的測試程式，變數所佔空間沒有對齊到4或8的倍數即可，舉個簡單的測試用的結構體的例子吧：
struct student
{
    char name[7];
    uint32_t id;
    char subject[5];
};
    在每個系統上看下這個結構體的長度吧。
    記憶體對齊，往往是由編譯器來做的，如果你使用的是gcc，可以在定義變數時，新增__attribute__，來決定是否使用記憶體對齊，或是記憶體對齊到幾個位元組，以上面的結構體為例：
1)到4位元組，同樣可指定對齊到8位元組。
struct student
{
    char name[7];
    uint32_t id;
    char subject[5];
} __attribute__ ((aligned(4)));

2)不對齊，結構體的長度，就是各個變數長度的和
struct student
{
    char name[7];
    uint32_t id;
    char subject[5];
} __attribute__ ((packed));

One of the best (but little known) features of GNU C is the __attribute__ mechanism, which allows a developer to attach characteristics to function declarations to allow the compiler to perform more error checking. It was designed in a way to be compatible with non-GNU implementations, and we've been using this for years in highly portable code with very good results.

Table of Contents

Note that __attribute__ spelled with two underscores before and two after, and there are always two sets of parentheses surrounding the contents. There is a good reason for this - see below. Gnu CC needs to use the -Wall compiler directive to enable this (yes, there is a finer degree of warnings control available, but we are very big fans of max warnings anyway).

attribute format

This __attribute__ allows assigning printf-like or scanf-like characteristics to the declared function, and this enables the compiler to check the format string against the parameters provided throughout the code. This is exceptionally helpful in tracking down hard-to-find bugs.

There are two flavors:

__attribute__((format(printf,m,n)))
__attribute__((format(scanf,m,n)))

but in practice we use the first one much more often.

The (m) is the number of the "format string" parameter, and (n) is the number of the first variadic parameter. To see some examples:

/* like printf() but to standard error only */
extern void eprintf(const char *format, ...)
	__attribute__((format(printf, 1, 2)));  /* 1=format 2=params */

/* printf only if debugging is at the desired level */
extern void dprintf(int dlevel, const char *format, ...)
	__attribute__((format(printf, 2, 3)));  /* 2=format 3=params */

With the functions so declared, the compiler will examine the argument lists

$ cat test.c
1  extern void eprintf(const char *format, ...)
2               __attribute__((format(printf, 1, 2)));
3
4  void foo()
5  {
6      eprintf("s=%s\n", 5);             /* error on this line */
7
8      eprintf("n=%d,%d,%d\n", 1, 2);    /* error on this line */
9  }

$ cc -Wall -c test.c
test.c: In function `foo':
test.c:6: warning: format argument is not a pointer (arg 2)
test.c:8: warning: too few arguments for format

Note that the "standard" library functions - printf and the like - are already understood by the compiler by default.

attribute noreturn

This attribute tells the compiler that the function won't ever return, and this can be used to suppress errors about code paths not being reached. The C library functions abort() and exit() are both declared with this attribute:

extern void exit(int)   __attribute__((noreturn));
extern void abort(void) __attribute__((noreturn));

Once tagged this way, the compiler can keep track of paths through the code and suppress errors that won't ever happen due to the flow of control never returning after the function call.

In this example, two nearly-identical C source files refer to an "exitnow()" function that never returns, but without the __attribute__tag, the compiler issues a warning. The compiler is correct here, because it has no way of knowing that control doesn't return.

$ cat test1.c
extern void exitnow();

int foo(int n)
{
        if ( n > 0 )
	{
                exitnow();
		/* control never reaches this point */
	}
        else
                return 0;
}

$ cc -c -Wall test1.c
test1.c: In function `foo':
test1.c:9: warning: this function may return with or without a value

But when we add __attribute__, the compiler suppresses the spurious warning:

$ cat test2.c
extern void exitnow() __attribute__((noreturn));

int foo(int n)
{
        if ( n > 0 )
                exitnow();
        else
                return 0;
}

$ cc -c -Wall test2.c
no warnings!

attribute const

This attribute marks the function as considering only its numeric parameters. This is mainly intended for the compiler to optimize away repeated calls to a function that the compiler knows will return the same value repeatedly. It applies mostly to math functions that have no static state or side effects, and whose return is solely determined by the inputs.

In this highly-contrived example, the compiler normally must call the square() function in every loop even though we know that it's going to return the same value each time:

extern int square(int n) __attribute__((const));

...
	for (i = 0; i < 100; i++ )
	{
		total += square(5) + i;
	}

By adding __attribute__((const)), the compiler can choose to call the function just once and cache the return value.

In virtually every case, const can't be used on functions that take pointers, because the function is not considering just the function parameters but also the data the parameters point to, and it will almost certainly break the code very badly in ways that will be nearly impossible to track down.

Furthermore, the functions so tagged cannot have any side effects or static state, so things like getchar() or time() would behave very poorly under these circumstances.

Putting them together

Multiple __attributes__ can be strung together on a single declaration, and this is not uncommon in practice. You can either use two separate __attribute__s, or use one with a comma-separated list:

/* send printf-like message to stderr and exit */
extern void die(const char *format, ...)
	__attribute__((noreturn))
	__attribute__((format(printf, 1, 2)));

/*or*/

extern void die(const char *format, ...)
	__attribute__((noreturn, format(printf, 1, 2)));

If this is tucked away safely in a library header file, all programs that call this function receive this checking.

Compatibility with non-GNU compilers

Fortunately, the __attribute__ mechanism was cleverly designed in a way to make it easy to quietly eliminate them if used on platforms other than GNU C. Superficially, __attribute__ appears to have multiple parameters (which would typically rule out using a macro), but the two sets of parentheses effectively make it a single parameter, and in practice this works very nicely.

/* If we're not using GNU C, elide __attribute__ */
#ifndef __GNUC__
#  define  __attribute__(x)  /*NOTHING*/
#endif

Note that __attribute__ applies to function declarations, not definitions, and we're not sure why this is. So when defining a function that merits this treatment, an extra declaration must be used (in the same file):

/* function declaration */
void die(const char *format, ...) __attribute__((noreturn))
                                  __attribute__((format(printf,1,2)));

void die(const char *format, ...)
{
	/* function definition */
}

Other References

We'll note that there are many more attributes available, including those for variables and types, and they are not covered here: we have chosen to just touch on the high points. Those wishing more information can find it in the GNU online documentation athttp://gcc.gnu.org:

GCC 4.0

GCC 4.0 Function Attributes
GCC 4.0 Variable Attributes
GCC 4.0 Type Attributes

GCC 3.2

GCC 3.2 Function Attributes
GCC 3.2 Variable Attributes
GCC 3.2 Type Attributes

GCC 3.1

GCC 3.1 Function Attributes
GCC 3.1 Variable Attributes
GCC 3.1 Type Attributes

GCC 3.0.4

Function Attributes
Variable Attributes
Type Attributes

GCC 2.95.3

Function Attributes
Variable Attributes
Type Attributes

參考：

http://blog.sina.com.cn/s/blog_644c3be70100i8ii.html