4. C Implementation-defined behavior

A conforming implementation of ISO C is required to document its choice of behavior in each of the areas that are designated "implementation defined." The following lists all such areas, along with the section number from the ISO/IEC 9899:1999 standard.

4.1 Translation
4.2 Environment
4.3 Identifiers
4.4 Characters
4.5 Integers
4.6 Floating point
4.7 Arrays and pointers
4.8 Hints
4.9 Structures, unions, enumerations, and bit-fields
4.10 Qualifiers
4.11 Preprocessing directives
4.12 Library functions
4.13 Architecture
4.14 Locale-specific behavior

4.1 Translation

• How a diagnostic is identified (3.10, 5.1.1.3).

  Diagnostics consist of all the output sent to stderr by GCC.

• Whether each nonempty sequence of white-space characters other than new-line is retained or replaced by one space character in translation phase 3 (5.1.1.2).

4.2 Environment

The behavior of these points are dependent on the implementation of the C library, and are not defined by GCC itself.

4.3 Identifiers

• Which additional multibyte characters may appear in identifiers and their correspondence to universal character names (6.4.2).

• The number of significant initial characters in an identifier (5.2.4.1, 6.4.2).

  For internal names, all characters are significant. For external names, the number of significant characters are defined by the linker; for almost all targets, all characters are significant.

4.4 Characters

• The number of bits in a byte (3.6).

• The values of the members of the execution character set (5.2.1).

• The unique value of the member of the execution character set produced for each of the standard alphabetic escape sequences (5.2.2).

• The value of a char object into which has been stored any character other than a member of the basic execution character set (6.2.5).

• Which of signed char or unsigned char has the same range, representation, and behavior as "plain" char (6.2.5, 6.3.1.1).

• The mapping of members of the source character set (in character constants and string literals) to members of the execution character set (6.4.4.4, 5.1.1.2).

• The value of an integer character constant containing more than one character or containing a character or escape sequence that does not map to a single-byte execution character (6.4.4.4).

• The value of a wide character constant containing more than one multibyte character, or containing a multibyte character or escape sequence not represented in the extended execution character set (6.4.4.4).

• The current locale used to convert a wide character constant consisting of a single multibyte character that maps to a member of the extended execution character set into a corresponding wide character code (6.4.4.4).

• The current locale used to convert a wide string literal into corresponding wide character codes (6.4.5).

• The value of a string literal containing a multibyte character or escape sequence not represented in the execution character set (6.4.5).

4.5 Integers

• Any extended integer types that exist in the implementation (6.2.5).

• Whether signed integer types are represented using sign and magnitude, two's complement, or one's complement, and whether the extraordinary value is a trap representation or an ordinary value (6.2.6.2).

  GCC supports only two's complement integer types, and all bit patterns are ordinary values.

• The rank of any extended integer type relative to another extended integer type with the same precision (6.3.1.1).

• The result of, or the signal raised by, converting an integer to a signed integer type when the value cannot be represented in an object of that type (6.3.1.3).

• The results of some bitwise operations on signed integers (6.5).

4.6 Floating point

• The accuracy of the floating-point operations and of the library functions in <math.h> and <complex.h> that return floating-point results (5.2.4.2.2).

• The rounding behaviors characterized by non-standard values of FLT_ROUNDS (5.2.4.2.2).

• The evaluation methods characterized by non-standard negative values of FLT_EVAL_METHOD (5.2.4.2.2).

• The direction of rounding when an integer is converted to a floating-point number that cannot exactly represent the original value (6.3.1.4).

• The direction of rounding when a floating-point number is converted to a narrower floating-point number (6.3.1.5).

• How the nearest representable value or the larger or smaller representable value immediately adjacent to the nearest representable value is chosen for certain floating constants (6.4.4.2).

• Whether and how floating expressions are contracted when not disallowed by the FP_CONTRACT pragma (6.5).

• The default state for the FENV_ACCESS pragma (7.6.1).

• Additional floating-point exceptions, rounding modes, environments, and classifications, and their macro names (7.6, 7.12).

• The default state for the FP_CONTRACT pragma (7.12.2).

• Whether the "inexact" floating-point exception can be raised when the rounded result actually does equal the mathematical result in an IEC 60559 conformant implementation (F.9).

• Whether the "underflow" (and "inexact") floating-point exception can be raised when a result is tiny but not inexact in an IEC 60559 conformant implementation (F.9).

4.7 Arrays and pointers

• The result of converting a pointer to an integer or vice versa (6.3.2.3).

  A cast from pointer to integer discards most-significant bits if the pointer representation is larger than the integer type, sign-extends(2) if the pointer representation is smaller than the integer type, otherwise the bits are unchanged.

  A cast from integer to pointer discards most-significant bits if the pointer representation is smaller than the integer type, extends according to the signedness of the integer type if the pointer representation is larger than the integer type, otherwise the bits are unchanged.

  When casting from pointer to integer and back again, the resulting pointer must reference the same object as the original pointer, otherwise the behavior is undefined. That is, one may not use integer arithmetic to avoid the undefined behavior of pointer arithmetic as proscribed in 6.5.6/8.

• The size of the result of subtracting two pointers to elements of the same array (6.5.6).

4.8 Hints

• The extent to which suggestions made by using the register storage-class specifier are effective (6.7.1).

  The register specifier affects code generation only in these ways:

  • When used as part of the register variable extension, see 5.38 Variables in Specified Registers.

  • When `-O0' is in use, the compiler allocates distinct stack memory for all variables that do not have the register storage-class specifier; if register is specified, the variable may have a shorter lifespan than the code would indicate and may never be placed in memory.

  • On some rare x86 targets, setjmp doesn't save the registers in all circumstances. In those cases, GCC doesn't allocate any variables in registers unless they are marked register.

• The extent to which suggestions made by using the inline function specifier are effective (6.7.4).

  GCC will not inline any functions if the `-fno-inline' option is used or if `-O0' is used. Otherwise, GCC may still be unable to inline a function for many reasons; the `-Winline' option may be used to determine if a function has not been inlined and why not.

4.9 Structures, unions, enumerations, and bit-fields

• Whether a "plain" int bit-field is treated as a signed int bit-field or as an unsigned int bit-field (6.7.2, 6.7.2.1).

• Allowable bit-field types other than _Bool, signed int, and unsigned int (6.7.2.1).

• Whether a bit-field can straddle a storage-unit boundary (6.7.2.1).

• The order of allocation of bit-fields within a unit (6.7.2.1).

• The alignment of non-bit-field members of structures (6.7.2.1).

• The integer type compatible with each enumerated type (6.7.2.2).

4.10 Qualifiers

• What constitutes an access to an object that has volatile-qualified type (6.7.3).

4.11 Preprocessing directives

• How sequences in both forms of header names are mapped to headers or external source file names (6.4.7).

• Whether the value of a character constant in a constant expression that controls conditional inclusion matches the value of the same character constant in the execution character set (6.10.1).

• Whether the value of a single-character character constant in a constant expression that controls conditional inclusion may have a negative value (6.10.1).

• The places that are searched for an included `<>' delimited header, and how the places are specified or the header is identified (6.10.2).

• How the named source file is searched for in an included `""' delimited header (6.10.2).

• The method by which preprocessing tokens (possibly resulting from macro expansion) in a #include directive are combined into a header name (6.10.2).

• The nesting limit for #include processing (6.10.2).

  GCC imposes a limit of 200 nested #includes.

• Whether the `#' operator inserts a `\' character before the `\' character that begins a universal character name in a character constant or string literal (6.10.3.2).

• The behavior on each recognized non-STDC #pragma directive (6.10.6).

• The definitions for __DATE__ and __TIME__ when respectively, the date and time of translation are not available (6.10.8).

  If the date and time are not available, __DATE__ expands to "??? ?? ????" and __TIME__ expands to "??:??:??".

4.12 Library functions

The behavior of these points are dependent on the implementation of the C library, and are not defined by GCC itself.

4.13 Architecture

• The values or expressions assigned to the macros specified in the headers <float.h>, <limits.h>, and <stdint.h> (5.2.4.2, 7.18.2, 7.18.3).

• The number, order, and encoding of bytes in any object (when not explicitly specified in this International Standard) (6.2.6.1).

• The value of the result of the sizeof operator (6.5.3.4).

4.14 Locale-specific behavior

The behavior of these points are dependent on the implementation of the C library, and are not defined by GCC itself.