GCC 4
GCC 4
  1. 1. Programming Languages Supported by GCC
    1. Using the GNU Compiler Collection (GCC)
  2. 10. gcov
    1. Brief description of gcov data files
    2. Data file relocation to support cross-profiling
    3. gcov
    4. Introduction to gcov
    5. Invoking gcov
    6. Using gcov with GCC Optimization
  3. 11. Known Causes of Trouble
    1. Actual Bugs We Haven't Fixed Yet
    2. Certain Changes We Don't Want to Make
    3. Common Misunderstandings with GNU C++
    4. Declare and Define Static Members
    5. Disappointments and Misunderstandings
    6. Fixed Header Files
    7. Implicit Copy-Assignment for Virtual Bases
    8. Incompatibilities of GCC
    9. Interoperation
    10. Known Causes of Trouble with GCC
    11. Name lookup, templates, and accessing members of base classes
    12. Standard Libraries
    13. Temporaries May Vanish Before You Expect
    14. Warning Messages and Error Messages
  4. 2. Language Standards Supported by GCC
    1. Language Standards Supported by GCC
  5. 3. GCC Command Options
    1. AArch64 Options
    2. Adapteva Epiphany Options
    3. ARC Options
    4. ARM Options
    5. AVR Options
    6. Blackfin Options
    7. C6X Options
    8. Compiling C++ Programs
    9. CR16 Options
    10. CRIS Options
    11. Darwin Options
    12. DEC Alpha Options
    13. Environment Variables Affecting GCC
    14. FR30 Options
    15. FRV Options
    16. GCC Command Options
    17. GNU/Linux Options
    18. H8/300 Options
    19. Hardware Models and Configurations
    20. HPPA Options
    21. i386 and x86-64 Windows Options
    22. IA-64 Options
    23. IBM RS/6000 and PowerPC Options
    24. Intel 386 and AMD x86-64 Options
    25. LM32 Options
    26. M32C Options
    27. M32R/D Options
    28. M680x0 Options
    29. MCore Options
    30. MeP Options
    31. MicroBlaze Options
    32. MIPS Options
    33. MMIX Options
    34. MN10300 Options
    35. Moxie Options
    36. MSP430 Options
    37. NDS32 Options
    38. Nios II Options
    39. Option Summary
    40. Options Controlling C Dialect
    41. Options Controlling C++ Dialect
    42. Options Controlling Objective-C and Objective-C++ Dialects
    43. Options Controlling the Kind of Output
    44. Options Controlling the Preprocessor
    45. Options for Code Generation Conventions
    46. Options for Debugging Your Program or GCC
    47. Options for Directory Search
    48. Options for Linking
    49. Options for System V
    50. Options That Control Optimization
    51. Options to Control Diagnostic Messages Formatting
    52. Options to Request or Suppress Warnings
    53. Passing Options to the Assembler
    54. PDP-11 Options
    55. picoChip Options
    56. PowerPC Options
    57. RL78 Options
    58. RX Options
    59. S/390 and zSeries Options
    60. Score Options
    61. SH Options
    62. Solaris 2 Options
    63. SPARC Options
    64. Specifying subprocesses and the switches to pass to them
    65. Specifying Target Machine and Compiler Version
    66. SPU Options
    67. TILE-Gx Options
    68. TILEPro Options
    69. Using Precompiled Headers
    70. V850 Options
    71. VAX Options
    72. VMS Options
    73. VxWorks Options
    74. x86-64 Options
    75. Xstormy16 Options
    76. Xtensa Options
    77. zSeries Options
  6. 4. C Implementation-defined behavior
    1. Architecture
    2. Arrays and pointers
    3. C Implementation-defined behavior
    4. Characters
    5. Declarators
    6. Environment
    7. Floating point
    8. Hints
    9. Identifiers
    10. Integers
    11. Library functions
    12. Locale-specific behavior
    13. Preprocessing directives
    14. Qualifiers
    15. Statements
    16. Structures, unions, enumerations, and bit-fields
    17. Translation
  7. 5. C++ Implementation-defined behavior
    1. C++ Implementation-defined behavior
    2. Conditionally-supported behavior
    3. Exception handling
  8. 6. Extensions to the C Language Family
    1. 128-bit integers
    2. Additional Floating Types
    3. Alpha Built-in Functions
    4. Altera Nios II Built-in Functions
    5. Alternate Keywords
    6. An Inline Function is As Fast As a Macro
    7. ARC Built-in Functions
    8. ARC SIMD Built-in Functions
    9. Argument Types
    10. Arithmetic on void- and Function-Pointers
    11. ARM ACLE Intrinsics
    12. ARM iWMMXt Built-in Functions
    13. ARM NEON Intrinsics
    14. ARM Pragmas
    15. Arrays of Length Zero
    16. Arrays of Variable Length
    17. Assembler Instructions with C Expression Operands
    18. Attribute Syntax
    19. AVR Built-in Functions
    20. Binary constants using the ‘0b’ prefix
    21. Blackfin Built-in Functions
    22. Built-in functions for memory model aware atomic operations
    23. Built-in Functions Specific to Particular Target Machines
    24. C++ Style Comments
    25. Case Ranges
    26. Cast to a Union Type
    27. Cilk Plus C/C++ language extension Built-in Functions.
    28. Complex Numbers
    29. Compound Literals
    30. Conditionals with Omitted Operands
    31. Constraint Modifier Characters
    32. Constraints for asm Operands
    33. Constraints for Particular Machines
    34. Constructing Function Calls
    35. Controlling Names Used in Assembler Code
    36. Darwin Format Checks
    37. Darwin Pragmas
    38. Decimal Floating Types
    39. Declaring Attributes of Functions
    40. Defining Global Register Variables
    41. Designated Initializers
    42. Diagnostic Pragmas
    43. Directly-mapped Integer Functions
    44. Directly-mapped Media Functions
    45. Dollar Signs in Identifier Names
    46. Double-Word Integers
    47. Extensions to the C Language Family
    48. Fixed-Point Types
    49. Format Checks Specific to Particular Target Machines
    50. FR-V Built-in Functions
    51. Function Names as Strings
    52. Function Specific Option Pragmas
    53. Getting the Return or Frame Address of a Function
    54. Half-Precision Floating Point
    55. Hex Floats
    56. Incomplete enum Types
    57. Inquiring on Alignment of Types or Variables
    58. ISO/IEC 14882:1998 Edits for Thread-Local Storage
    59. ISO/IEC 9899:1999 Edits for Thread-Local Storage
    60. Labels as Values
    61. Legacy __sync Built-in Functions for Atomic Memory Access
    62. Locally Declared Labels
    63. Loop-Specific Pragmas
    64. M32C Pragmas
    65. Macros with a Variable Number of Arguments.
    66. MeP Pragmas
    67. MIPS DSP Built-in Functions
    68. MIPS Loongson Built-in Functions
    69. MIPS Paired-Single Support
    70. MIPS-3D Built-in Functions
    71. Mixed Declarations and Code
    72. MSP430 Built-in Functions
    73. Multiple Alternative Constraints
    74. Named Address Spaces
    75. NDS32 Built-in Functions
    76. Nested Functions
    77. Non-Constant Initializers
    78. Non-Lvalue Arrays May Have Subscripts
    79. Object Size Checking Built-in Functions
    80. Offsetof
    81. Other Built-in Functions
    82. Other Built-in Functions Provided by GCC
    83. Other MIPS Built-in Functions
    84. Paired-Single Arithmetic
    85. Paired-Single Built-in Functions
    86. picoChip Built-in Functions
    87. PowerPC AltiVec Built-in Functions
    88. PowerPC Built-in Functions
    89. PowerPC Hardware Transactional Memory Built-in Functions
    90. Pragmas Accepted by GCC
    91. Prototypes and Old-Style Function Definitions
    92. Push/Pop Macro Pragmas
    93. Raw read/write Functions
    94. Referring to a Type with typeof
    95. RS/6000 and PowerPC Pragmas
    96. RX Built-in Functions
    97. S/390 System z Built-in Functions
    98. SH Built-in Functions
    99. Simple Constraints
    100. Slightly Looser Rules for Escaped Newlines
    101. Solaris Format Checks
    102. Solaris Pragmas
    103. SPARC VIS Built-in Functions
    104. Specifying Attributes of Types
    105. Specifying Attributes of Variables
    106. Specifying Registers for Local Variables
    107. SPU Built-in Functions
    108. Statements and Declarations in Expressions
    109. Structure-Packing Pragmas
    110. Structures With No Members
    111. Symbol-Renaming Pragmas
    112. The Character <ESC> in Constants
    113. Thread-Local Storage
    114. TI C6X Built-in Functions
    115. TILE-Gx Built-in Functions
    116. TILEPro Built-in Functions
    117. Unnamed struct/union fields within structs/unions
    118. Using Vector Instructions through Built-in Functions
    119. Variables in Specified Registers
    120. Visibility Pragmas
    121. Weak Pragmas
    122. When is a Volatile Object Accessed?
    123. X86 Built-in Functions
    124. x86 specific memory model extensions for transactional memory
    125. X86 transaction memory intrinsics
  9. 7. Extensions to the C++ Language
    1. #pragma interface and implementation
    2. Backwards Compatibility
    3. C++-Specific Variable, Function, and Type Attributes
    4. Deprecated Features
    5. Extensions to the C++ Language
    6. Extracting the function pointer from a bound pointer to member function
    7. Function Multiversioning
    8. Java Exceptions
    9. Namespace Association
    10. Restricting Pointer Aliasing
    11. Type Traits
    12. Vague Linkage
    13. When is a Volatile C++ Object Accessed?
    14. Where's the Template?
  10. 8. GNU Objective-C features
    1. @encode
    2. +load: Executing code before main
    3. c99-like fast enumeration syntax
    4. compatibility_alias
    5. Constant string objects
    6. Dynamically registering methods
    7. Exceptions
    8. Fast enumeration
    9. Fast enumeration details
    10. Fast enumeration protocol
    11. Forwarding hook
    12. Garbage Collection
    13. GNU Objective-C features
    14. GNU Objective-C runtime API
    15. Legacy type encoding
    16. Messaging with the GNU Objective-C runtime
    17. Method signatures
    18. Modern GNU Objective-C runtime API
    19. Synchronization
    20. Traditional GNU Objective-C runtime API
    21. Type encoding
    22. Using fast enumeration
    23. What you can and what you cannot do in +load
  11. 9. Binary Compatibility
    1. Binary Compatibility
  12. Index
    1. index
  • 请登录查看
字典 我要纠错

Specifying Attributes of Variables

6.36 Specifying Attributes of Variables

The keyword __attribute__ allows you to specify special attributes of variables or structure fields. This keyword is followed by an attribute specification inside double parentheses. Some attributes are currently defined generically for variables. Other attributes are defined for variables on particular target systems. Other attributes are available for functions (see Function Attributes) and for types (see Type Attributes). Other front ends might define more attributes (see Extensions to the C++ Language).

You may also specify attributes with ‘__’ preceding and following each keyword. This allows you to use them in header files without being concerned about a possi