visus
/
toolchain-gcc-arm-embedded
Tarkkaile 1
Äänestä 0
Fork 0
Koodi Ongelmat 0 Pull-pyynnöt 0 Julkaisut 0 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2 Commitit
1 Haara
Haara: main
Branchit Tagit
${ item.name }
Create branch ${ searchTerm }
from 'main'
${ noResults }
toolchain-gcc-arm-embedded/share/doc/gcc-arm-none-eabi/html/cpp/Common-Predefined-Macros.html

662 lines
30KB
Raaka Pysyvä linkki Blame Historia 

  1. <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

  2. <html>

  3. <!-- Copyright (C) 1987-2020 Free Software Foundation, Inc.

  4. 

  5. Permission is granted to copy, distribute and/or modify this document

  6. under the terms of the GNU Free Documentation License, Version 1.3 or

  7. any later version published by the Free Software Foundation.  A copy of

  8. the license is included in the

  9. section entitled "GNU Free Documentation License".

  10. 

  11. This manual contains no Invariant Sections.  The Front-Cover Texts are

  12. (a) (see below), and the Back-Cover Texts are (b) (see below).

  13. 

  14. (a) The FSF's Front-Cover Text is:

  15. 

  16. A GNU Manual

  17. 

  18. (b) The FSF's Back-Cover Text is:

  19. 

  20. You have freedom to copy and modify this GNU Manual, like GNU

  21.      software.  Copies published by the Free Software Foundation raise

  22.      funds for GNU development. -->

  23. <!-- Created by GNU Texinfo 6.5, http://www.gnu.org/software/texinfo/ -->

  24. <head>

  25. <meta http-equiv="Content-Type" content="text/html; charset=utf-8">

  26. <title>Common Predefined Macros (The C Preprocessor)</title>

  27. 

  28. <meta name="description" content="Common Predefined Macros (The C Preprocessor)">

  29. <meta name="keywords" content="Common Predefined Macros (The C Preprocessor)">

  30. <meta name="resource-type" content="document">

  31. <meta name="distribution" content="global">

  32. <meta name="Generator" content="makeinfo">

  33. <link href="index.html#Top" rel="start" title="Top">

  34. <link href="Index-of-Directives.html#Index-of-Directives" rel="index" title="Index of Directives">

  35. <link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">

  36. <link href="Predefined-Macros.html#Predefined-Macros" rel="up" title="Predefined Macros">

  37. <link href="System_002dspecific-Predefined-Macros.html#System_002dspecific-Predefined-Macros" rel="next" title="System-specific Predefined Macros">

  38. <link href="Standard-Predefined-Macros.html#Standard-Predefined-Macros" rel="prev" title="Standard Predefined Macros">

  39. <style type="text/css">

  40. <!--

  41. a.summary-letter {text-decoration: none}

  42. blockquote.indentedblock {margin-right: 0em}

  43. blockquote.smallindentedblock {margin-right: 0em; font-size: smaller}

  44. blockquote.smallquotation {font-size: smaller}

  45. div.display {margin-left: 3.2em}

  46. div.example {margin-left: 3.2em}

  47. div.lisp {margin-left: 3.2em}

  48. div.smalldisplay {margin-left: 3.2em}

  49. div.smallexample {margin-left: 3.2em}

  50. div.smalllisp {margin-left: 3.2em}

  51. kbd {font-style: oblique}

  52. pre.display {font-family: inherit}

  53. pre.format {font-family: inherit}

  54. pre.menu-comment {font-family: serif}

  55. pre.menu-preformatted {font-family: serif}

  56. pre.smalldisplay {font-family: inherit; font-size: smaller}

  57. pre.smallexample {font-size: smaller}

  58. pre.smallformat {font-family: inherit; font-size: smaller}

  59. pre.smalllisp {font-size: smaller}

  60. span.nolinebreak {white-space: nowrap}

  61. span.roman {font-family: initial; font-weight: normal}

  62. span.sansserif {font-family: sans-serif; font-weight: normal}

  63. ul.no-bullet {list-style: none}

  64. -->

  65. </style>

  66. 

  67. 

  68. </head>

  69. 

  70. <body lang="en">

  71. <a name="Common-Predefined-Macros"></a>

  72. <div class="header">

  73. <p>

  74. Next: <a href="System_002dspecific-Predefined-Macros.html#System_002dspecific-Predefined-Macros" accesskey="n" rel="next">System-specific Predefined Macros</a>, Previous: <a href="Standard-Predefined-Macros.html#Standard-Predefined-Macros" accesskey="p" rel="prev">Standard Predefined Macros</a>, Up: <a href="Predefined-Macros.html#Predefined-Macros" accesskey="u" rel="up">Predefined Macros</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Index-of-Directives.html#Index-of-Directives" title="Index" rel="index">Index</a>]</p>

  75. </div>

  76. <hr>

  77. <a name="Common-Predefined-Macros-1"></a>

  78. <h4 class="subsection">3.7.2 Common Predefined Macros</h4>

  79. <a name="index-common-predefined-macros"></a>

  80. 

  81. <p>The common predefined macros are GNU C extensions.  They are available

  82. with the same meanings regardless of the machine or operating system on

  83. which you are using GNU C or GNU Fortran.  Their names all start with

  84. double underscores.

  85. </p>

  86. <dl compact="compact">

  87. <dt><code>__COUNTER__</code></dt>

  88. <dd><p>This macro expands to sequential integral values starting from 0.  In

  89. conjunction with the <code>##</code> operator, this provides a convenient means to

  90. generate unique identifiers.  Care must be taken to ensure that

  91. <code>__COUNTER__</code> is not expanded prior to inclusion of precompiled headers

  92. which use it.  Otherwise, the precompiled headers will not be used.

  93. </p>

  94. </dd>

  95. <dt><code>__GFORTRAN__</code></dt>

  96. <dd><p>The GNU Fortran compiler defines this.

  97. </p>

  98. </dd>

  99. <dt><code>__GNUC__</code></dt>

  100. <dt><code>__GNUC_MINOR__</code></dt>

  101. <dt><code>__GNUC_PATCHLEVEL__</code></dt>

  102. <dd><p>These macros are defined by all GNU compilers that use the C

  103. preprocessor: C, C++, Objective-C and Fortran.  Their values are the major

  104. version, minor version, and patch level of the compiler, as integer

  105. constants.  For example, GCC version <var>x</var>.<var>y</var>.<var>z</var>

  106. defines <code>__GNUC__</code> to <var>x</var>, <code>__GNUC_MINOR__</code> to <var>y</var>,

  107. and <code>__GNUC_PATCHLEVEL__</code> to <var>z</var>.  These

  108. macros are also defined if you invoke the preprocessor directly.

  109. </p>

  110. <p>If all you need to know is whether or not your program is being compiled

  111. by GCC, or a non-GCC compiler that claims to accept the GNU C dialects,

  112. you can simply test <code>__GNUC__</code>.  If you need to write code

  113. which depends on a specific version, you must be more careful.  Each

  114. time the minor version is increased, the patch level is reset to zero;

  115. each time the major version is increased, the

  116. minor version and patch level are reset.  If you wish to use the

  117. predefined macros directly in the conditional, you will need to write it

  118. like this:

  119. </p>

  120. <div class="smallexample">

  121. <pre class="smallexample">/* <span class="roman">Test for GCC &gt; 3.2.0</span> */

  122. #if __GNUC__ &gt; 3 || \

  123.     (__GNUC__ == 3 &amp;&amp; (__GNUC_MINOR__ &gt; 2 || \

  124.                        (__GNUC_MINOR__ == 2 &amp;&amp; \

  125.                         __GNUC_PATCHLEVEL__ &gt; 0))

  126. </pre></div>

  127. 

  128. <p>Another approach is to use the predefined macros to

  129. calculate a single number, then compare that against a threshold:

  130. </p>

  131. <div class="smallexample">

  132. <pre class="smallexample">#define GCC_VERSION (__GNUC__ * 10000 \

  133.                      + __GNUC_MINOR__ * 100 \

  134.                      + __GNUC_PATCHLEVEL__)

  135. &hellip;

  136. /* <span class="roman">Test for GCC &gt; 3.2.0</span> */

  137. #if GCC_VERSION &gt; 30200

  138. </pre></div>

  139. 

  140. <p>Many people find this form easier to understand.

  141. </p>

  142. </dd>

  143. <dt><code>__GNUG__</code></dt>

  144. <dd><p>The GNU C++ compiler defines this.  Testing it is equivalent to

  145. testing <code><span class="nolinebreak">(__GNUC__</span>&nbsp;&amp;&amp;&nbsp;<span class="nolinebreak">__cplusplus)</span><!-- /@w --></code>.

  146. </p>

  147. </dd>

  148. <dt><code>__STRICT_ANSI__</code></dt>

  149. <dd><p>GCC defines this macro if and only if the <samp>-ansi</samp> switch, or a

  150. <samp>-std</samp> switch specifying strict conformance to some version of ISO C

  151. or ISO C++, was specified when GCC was invoked.  It is defined to &lsquo;<samp>1</samp>&rsquo;.

  152. This macro exists primarily to direct GNU libc&rsquo;s header files to use only

  153. definitions found in standard C.

  154. </p>

  155. </dd>

  156. <dt><code>__BASE_FILE__</code></dt>

  157. <dd><p>This macro expands to the name of the main input file, in the form

  158. of a C string constant.  This is the source file that was specified

  159. on the command line of the preprocessor or C compiler.

  160. </p>

  161. </dd>

  162. <dt><code>__INCLUDE_LEVEL__</code></dt>

  163. <dd><p>This macro expands to a decimal integer constant that represents the

  164. depth of nesting in include files.  The value of this macro is

  165. incremented on every &lsquo;<samp>#include</samp>&rsquo; directive and decremented at the

  166. end of every included file.  It starts out at 0, its value within the

  167. base file specified on the command line.

  168. </p>

  169. </dd>

  170. <dt><code>__ELF__</code></dt>

  171. <dd><p>This macro is defined if the target uses the ELF object format.

  172. </p>

  173. </dd>

  174. <dt><code>__VERSION__</code></dt>

  175. <dd><p>This macro expands to a string constant which describes the version of

  176. the compiler in use.  You should not rely on its contents having any

  177. particular form, but it can be counted on to contain at least the

  178. release number.

  179. </p>

  180. </dd>

  181. <dt><code>__OPTIMIZE__</code></dt>

  182. <dt><code>__OPTIMIZE_SIZE__</code></dt>

  183. <dt><code>__NO_INLINE__</code></dt>

  184. <dd><p>These macros describe the compilation mode.  <code>__OPTIMIZE__</code> is

  185. defined in all optimizing compilations.  <code>__OPTIMIZE_SIZE__</code> is

  186. defined if the compiler is optimizing for size, not speed.

  187. <code>__NO_INLINE__</code> is defined if no functions will be inlined into

  188. their callers (when not optimizing, or when inlining has been

  189. specifically disabled by <samp>-fno-inline</samp>).

  190. </p>

  191. <p>These macros cause certain GNU header files to provide optimized

  192. definitions, using macros or inline functions, of system library

  193. functions.  You should not use these macros in any way unless you make

  194. sure that programs will execute with the same effect whether or not they

  195. are defined.  If they are defined, their value is 1.

  196. </p>

  197. </dd>

  198. <dt><code>__GNUC_GNU_INLINE__</code></dt>

  199. <dd><p>GCC defines this macro if functions declared <code>inline</code> will be

  200. handled in GCC&rsquo;s traditional gnu90 mode.  Object files will contain

  201. externally visible definitions of all functions declared <code>inline</code>

  202. without <code>extern</code> or <code>static</code>.  They will not contain any

  203. definitions of any functions declared <code>extern inline</code>.

  204. </p>

  205. </dd>

  206. <dt><code>__GNUC_STDC_INLINE__</code></dt>

  207. <dd><p>GCC defines this macro if functions declared <code>inline</code> will be

  208. handled according to the ISO C99 or later standards.  Object files will contain

  209. externally visible definitions of all functions declared <code>extern

  210. inline</code>.  They will not contain definitions of any functions declared

  211. <code>inline</code> without <code>extern</code>.

  212. </p>

  213. <p>If this macro is defined, GCC supports the <code>gnu_inline</code> function

  214. attribute as a way to always get the gnu90 behavior.

  215. </p>

  216. </dd>

  217. <dt><code>__CHAR_UNSIGNED__</code></dt>

  218. <dd><p>GCC defines this macro if and only if the data type <code>char</code> is

  219. unsigned on the target machine.  It exists to cause the standard header

  220. file <samp>limits.h</samp> to work correctly.  You should not use this macro

  221. yourself; instead, refer to the standard macros defined in <samp>limits.h</samp>.

  222. </p>

  223. </dd>

  224. <dt><code>__WCHAR_UNSIGNED__</code></dt>

  225. <dd><p>Like <code>__CHAR_UNSIGNED__</code>, this macro is defined if and only if the

  226. data type <code>wchar_t</code> is unsigned and the front-end is in C++ mode.

  227. </p>

  228. </dd>

  229. <dt><code>__REGISTER_PREFIX__</code></dt>

  230. <dd><p>This macro expands to a single token (not a string constant) which is

  231. the prefix applied to CPU register names in assembly language for this

  232. target.  You can use it to write assembly that is usable in multiple

  233. environments.  For example, in the <code>m68k-aout</code> environment it

  234. expands to nothing, but in the <code>m68k-coff</code> environment it expands

  235. to a single &lsquo;<samp>%</samp>&rsquo;.

  236. </p>

  237. </dd>

  238. <dt><code>__USER_LABEL_PREFIX__</code></dt>

  239. <dd><p>This macro expands to a single token which is the prefix applied to

  240. user labels (symbols visible to C code) in assembly.  For example, in

  241. the <code>m68k-aout</code> environment it expands to an &lsquo;<samp>_</samp>&rsquo;, but in the

  242. <code>m68k-coff</code> environment it expands to nothing.

  243. </p>

  244. <p>This macro will have the correct definition even if

  245. <samp>-f(no-)underscores</samp> is in use, but it will not be correct if

  246. target-specific options that adjust this prefix are used (e.g. the

  247. OSF/rose <samp>-mno-underscores</samp> option).

  248. </p>

  249. </dd>

  250. <dt><code>__SIZE_TYPE__</code></dt>

  251. <dt><code>__PTRDIFF_TYPE__</code></dt>

  252. <dt><code>__WCHAR_TYPE__</code></dt>

  253. <dt><code>__WINT_TYPE__</code></dt>

  254. <dt><code>__INTMAX_TYPE__</code></dt>

  255. <dt><code>__UINTMAX_TYPE__</code></dt>

  256. <dt><code>__SIG_ATOMIC_TYPE__</code></dt>

  257. <dt><code>__INT8_TYPE__</code></dt>

  258. <dt><code>__INT16_TYPE__</code></dt>

  259. <dt><code>__INT32_TYPE__</code></dt>

  260. <dt><code>__INT64_TYPE__</code></dt>

  261. <dt><code>__UINT8_TYPE__</code></dt>

  262. <dt><code>__UINT16_TYPE__</code></dt>

  263. <dt><code>__UINT32_TYPE__</code></dt>

  264. <dt><code>__UINT64_TYPE__</code></dt>

  265. <dt><code>__INT_LEAST8_TYPE__</code></dt>

  266. <dt><code>__INT_LEAST16_TYPE__</code></dt>

  267. <dt><code>__INT_LEAST32_TYPE__</code></dt>

  268. <dt><code>__INT_LEAST64_TYPE__</code></dt>

  269. <dt><code>__UINT_LEAST8_TYPE__</code></dt>

  270. <dt><code>__UINT_LEAST16_TYPE__</code></dt>

  271. <dt><code>__UINT_LEAST32_TYPE__</code></dt>

  272. <dt><code>__UINT_LEAST64_TYPE__</code></dt>

  273. <dt><code>__INT_FAST8_TYPE__</code></dt>

  274. <dt><code>__INT_FAST16_TYPE__</code></dt>

  275. <dt><code>__INT_FAST32_TYPE__</code></dt>

  276. <dt><code>__INT_FAST64_TYPE__</code></dt>

  277. <dt><code>__UINT_FAST8_TYPE__</code></dt>

  278. <dt><code>__UINT_FAST16_TYPE__</code></dt>

  279. <dt><code>__UINT_FAST32_TYPE__</code></dt>

  280. <dt><code>__UINT_FAST64_TYPE__</code></dt>

  281. <dt><code>__INTPTR_TYPE__</code></dt>

  282. <dt><code>__UINTPTR_TYPE__</code></dt>

  283. <dd><p>These macros are defined to the correct underlying types for the

  284. <code>size_t</code>, <code>ptrdiff_t</code>, <code>wchar_t</code>, <code>wint_t</code>,

  285. <code>intmax_t</code>, <code>uintmax_t</code>, <code>sig_atomic_t</code>, <code>int8_t</code>,

  286. <code>int16_t</code>, <code>int32_t</code>, <code>int64_t</code>, <code>uint8_t</code>,

  287. <code>uint16_t</code>, <code>uint32_t</code>, <code>uint64_t</code>,

  288. <code>int_least8_t</code>, <code>int_least16_t</code>, <code>int_least32_t</code>,

  289. <code>int_least64_t</code>, <code>uint_least8_t</code>, <code>uint_least16_t</code>,

  290. <code>uint_least32_t</code>, <code>uint_least64_t</code>, <code>int_fast8_t</code>,

  291. <code>int_fast16_t</code>, <code>int_fast32_t</code>, <code>int_fast64_t</code>,

  292. <code>uint_fast8_t</code>, <code>uint_fast16_t</code>, <code>uint_fast32_t</code>,

  293. <code>uint_fast64_t</code>, <code>intptr_t</code>, and <code>uintptr_t</code> typedefs,

  294. respectively.  They exist to make the standard header files

  295. <samp>stddef.h</samp>, <samp>stdint.h</samp>, and <samp>wchar.h</samp> work correctly.

  296. You should not use these macros directly; instead, include the

  297. appropriate headers and use the typedefs.  Some of these macros may

  298. not be defined on particular systems if GCC does not provide a

  299. <samp>stdint.h</samp> header on those systems.

  300. </p>

  301. </dd>

  302. <dt><code>__CHAR_BIT__</code></dt>

  303. <dd><p>Defined to the number of bits used in the representation of the

  304. <code>char</code> data type.  It exists to make the standard header given

  305. numerical limits work correctly.  You should not use

  306. this macro directly; instead, include the appropriate headers.

  307. </p>

  308. </dd>

  309. <dt><code>__SCHAR_MAX__</code></dt>

  310. <dt><code>__WCHAR_MAX__</code></dt>

  311. <dt><code>__SHRT_MAX__</code></dt>

  312. <dt><code>__INT_MAX__</code></dt>

  313. <dt><code>__LONG_MAX__</code></dt>

  314. <dt><code>__LONG_LONG_MAX__</code></dt>

  315. <dt><code>__WINT_MAX__</code></dt>

  316. <dt><code>__SIZE_MAX__</code></dt>

  317. <dt><code>__PTRDIFF_MAX__</code></dt>

  318. <dt><code>__INTMAX_MAX__</code></dt>

  319. <dt><code>__UINTMAX_MAX__</code></dt>

  320. <dt><code>__SIG_ATOMIC_MAX__</code></dt>

  321. <dt><code>__INT8_MAX__</code></dt>

  322. <dt><code>__INT16_MAX__</code></dt>

  323. <dt><code>__INT32_MAX__</code></dt>

  324. <dt><code>__INT64_MAX__</code></dt>

  325. <dt><code>__UINT8_MAX__</code></dt>

  326. <dt><code>__UINT16_MAX__</code></dt>

  327. <dt><code>__UINT32_MAX__</code></dt>

  328. <dt><code>__UINT64_MAX__</code></dt>

  329. <dt><code>__INT_LEAST8_MAX__</code></dt>

  330. <dt><code>__INT_LEAST16_MAX__</code></dt>

  331. <dt><code>__INT_LEAST32_MAX__</code></dt>

  332. <dt><code>__INT_LEAST64_MAX__</code></dt>

  333. <dt><code>__UINT_LEAST8_MAX__</code></dt>

  334. <dt><code>__UINT_LEAST16_MAX__</code></dt>

  335. <dt><code>__UINT_LEAST32_MAX__</code></dt>

  336. <dt><code>__UINT_LEAST64_MAX__</code></dt>

  337. <dt><code>__INT_FAST8_MAX__</code></dt>

  338. <dt><code>__INT_FAST16_MAX__</code></dt>

  339. <dt><code>__INT_FAST32_MAX__</code></dt>

  340. <dt><code>__INT_FAST64_MAX__</code></dt>

  341. <dt><code>__UINT_FAST8_MAX__</code></dt>

  342. <dt><code>__UINT_FAST16_MAX__</code></dt>

  343. <dt><code>__UINT_FAST32_MAX__</code></dt>

  344. <dt><code>__UINT_FAST64_MAX__</code></dt>

  345. <dt><code>__INTPTR_MAX__</code></dt>

  346. <dt><code>__UINTPTR_MAX__</code></dt>

  347. <dt><code>__WCHAR_MIN__</code></dt>

  348. <dt><code>__WINT_MIN__</code></dt>

  349. <dt><code>__SIG_ATOMIC_MIN__</code></dt>

  350. <dd><p>Defined to the maximum value of the <code>signed char</code>, <code>wchar_t</code>,

  351. <code>signed short</code>,

  352. <code>signed int</code>, <code>signed long</code>, <code>signed long long</code>,

  353. <code>wint_t</code>, <code>size_t</code>, <code>ptrdiff_t</code>,

  354. <code>intmax_t</code>, <code>uintmax_t</code>, <code>sig_atomic_t</code>, <code>int8_t</code>,

  355. <code>int16_t</code>, <code>int32_t</code>, <code>int64_t</code>, <code>uint8_t</code>,

  356. <code>uint16_t</code>, <code>uint32_t</code>, <code>uint64_t</code>,

  357. <code>int_least8_t</code>, <code>int_least16_t</code>, <code>int_least32_t</code>,

  358. <code>int_least64_t</code>, <code>uint_least8_t</code>, <code>uint_least16_t</code>,

  359. <code>uint_least32_t</code>, <code>uint_least64_t</code>, <code>int_fast8_t</code>,

  360. <code>int_fast16_t</code>, <code>int_fast32_t</code>, <code>int_fast64_t</code>,

  361. <code>uint_fast8_t</code>, <code>uint_fast16_t</code>, <code>uint_fast32_t</code>,

  362. <code>uint_fast64_t</code>, <code>intptr_t</code>, and <code>uintptr_t</code> types and

  363. to the minimum value of the <code>wchar_t</code>, <code>wint_t</code>, and

  364. <code>sig_atomic_t</code> types respectively.  They exist to make the

  365. standard header given numerical limits work correctly.  You should not

  366. use these macros directly; instead, include the appropriate headers.

  367. Some of these macros may not be defined on particular systems if GCC

  368. does not provide a <samp>stdint.h</samp> header on those systems.

  369. </p>

  370. </dd>

  371. <dt><code>__INT8_C</code></dt>

  372. <dt><code>__INT16_C</code></dt>

  373. <dt><code>__INT32_C</code></dt>

  374. <dt><code>__INT64_C</code></dt>

  375. <dt><code>__UINT8_C</code></dt>

  376. <dt><code>__UINT16_C</code></dt>

  377. <dt><code>__UINT32_C</code></dt>

  378. <dt><code>__UINT64_C</code></dt>

  379. <dt><code>__INTMAX_C</code></dt>

  380. <dt><code>__UINTMAX_C</code></dt>

  381. <dd><p>Defined to implementations of the standard <samp>stdint.h</samp> macros with

  382. the same names without the leading <code>__</code>.  They exist the make the

  383. implementation of that header work correctly.  You should not use

  384. these macros directly; instead, include the appropriate headers.  Some

  385. of these macros may not be defined on particular systems if GCC does

  386. not provide a <samp>stdint.h</samp> header on those systems.

  387. </p>

  388. </dd>

  389. <dt><code>__SCHAR_WIDTH__</code></dt>

  390. <dt><code>__SHRT_WIDTH__</code></dt>

  391. <dt><code>__INT_WIDTH__</code></dt>

  392. <dt><code>__LONG_WIDTH__</code></dt>

  393. <dt><code>__LONG_LONG_WIDTH__</code></dt>

  394. <dt><code>__PTRDIFF_WIDTH__</code></dt>

  395. <dt><code>__SIG_ATOMIC_WIDTH__</code></dt>

  396. <dt><code>__SIZE_WIDTH__</code></dt>

  397. <dt><code>__WCHAR_WIDTH__</code></dt>

  398. <dt><code>__WINT_WIDTH__</code></dt>

  399. <dt><code>__INT_LEAST8_WIDTH__</code></dt>

  400. <dt><code>__INT_LEAST16_WIDTH__</code></dt>

  401. <dt><code>__INT_LEAST32_WIDTH__</code></dt>

  402. <dt><code>__INT_LEAST64_WIDTH__</code></dt>

  403. <dt><code>__INT_FAST8_WIDTH__</code></dt>

  404. <dt><code>__INT_FAST16_WIDTH__</code></dt>

  405. <dt><code>__INT_FAST32_WIDTH__</code></dt>

  406. <dt><code>__INT_FAST64_WIDTH__</code></dt>

  407. <dt><code>__INTPTR_WIDTH__</code></dt>

  408. <dt><code>__INTMAX_WIDTH__</code></dt>

  409. <dd><p>Defined to the bit widths of the corresponding types.  They exist to

  410. make the implementations of <samp>limits.h</samp> and <samp>stdint.h</samp> behave

  411. correctly.  You should not use these macros directly; instead, include

  412. the appropriate headers.  Some of these macros may not be defined on

  413. particular systems if GCC does not provide a <samp>stdint.h</samp> header on

  414. those systems.

  415. </p>

  416. </dd>

  417. <dt><code>__SIZEOF_INT__</code></dt>

  418. <dt><code>__SIZEOF_LONG__</code></dt>

  419. <dt><code>__SIZEOF_LONG_LONG__</code></dt>

  420. <dt><code>__SIZEOF_SHORT__</code></dt>

  421. <dt><code>__SIZEOF_POINTER__</code></dt>

  422. <dt><code>__SIZEOF_FLOAT__</code></dt>

  423. <dt><code>__SIZEOF_DOUBLE__</code></dt>

  424. <dt><code>__SIZEOF_LONG_DOUBLE__</code></dt>

  425. <dt><code>__SIZEOF_SIZE_T__</code></dt>

  426. <dt><code>__SIZEOF_WCHAR_T__</code></dt>

  427. <dt><code>__SIZEOF_WINT_T__</code></dt>

  428. <dt><code>__SIZEOF_PTRDIFF_T__</code></dt>

  429. <dd><p>Defined to the number of bytes of the C standard data types: <code>int</code>,

  430. <code>long</code>, <code>long long</code>, <code>short</code>, <code>void *</code>, <code>float</code>,

  431. <code>double</code>, <code>long double</code>, <code>size_t</code>, <code>wchar_t</code>, <code>wint_t</code>

  432. and <code>ptrdiff_t</code>.

  433. </p>

  434. </dd>

  435. <dt><code>__BYTE_ORDER__</code></dt>

  436. <dt><code>__ORDER_LITTLE_ENDIAN__</code></dt>

  437. <dt><code>__ORDER_BIG_ENDIAN__</code></dt>

  438. <dt><code>__ORDER_PDP_ENDIAN__</code></dt>

  439. <dd><p><code>__BYTE_ORDER__</code> is defined to one of the values

  440. <code>__ORDER_LITTLE_ENDIAN__</code>, <code>__ORDER_BIG_ENDIAN__</code>, or

  441. <code>__ORDER_PDP_ENDIAN__</code> to reflect the layout of multi-byte and

  442. multi-word quantities in memory.  If <code>__BYTE_ORDER__</code> is equal to

  443. <code>__ORDER_LITTLE_ENDIAN__</code> or <code>__ORDER_BIG_ENDIAN__</code>, then

  444. multi-byte and multi-word quantities are laid out identically: the

  445. byte (word) at the lowest address is the least significant or most

  446. significant byte (word) of the quantity, respectively.  If

  447. <code>__BYTE_ORDER__</code> is equal to <code>__ORDER_PDP_ENDIAN__</code>, then

  448. bytes in 16-bit words are laid out in a little-endian fashion, whereas

  449. the 16-bit subwords of a 32-bit quantity are laid out in big-endian

  450. fashion.

  451. </p>

  452. <p>You should use these macros for testing like this:

  453. </p>

  454. <div class="smallexample">

  455. <pre class="smallexample">/* <span class="roman">Test for a little-endian machine</span> */

  456. #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__

  457. </pre></div>

  458. 

  459. </dd>

  460. <dt><code>__FLOAT_WORD_ORDER__</code></dt>

  461. <dd><p><code>__FLOAT_WORD_ORDER__</code> is defined to one of the values

  462. <code>__ORDER_LITTLE_ENDIAN__</code> or <code>__ORDER_BIG_ENDIAN__</code> to reflect

  463. the layout of the words of multi-word floating-point quantities.

  464. </p>

  465. </dd>

  466. <dt><code>__DEPRECATED</code></dt>

  467. <dd><p>This macro is defined, with value 1, when compiling a C++ source file

  468. with warnings about deprecated constructs enabled.  These warnings are

  469. enabled by default, but can be disabled with <samp>-Wno-deprecated</samp>.

  470. </p>

  471. </dd>

  472. <dt><code>__EXCEPTIONS</code></dt>

  473. <dd><p>This macro is defined, with value 1, when compiling a C++ source file

  474. with exceptions enabled.  If <samp>-fno-exceptions</samp> is used when

  475. compiling the file, then this macro is not defined.

  476. </p>

  477. </dd>

  478. <dt><code>__GXX_RTTI</code></dt>

  479. <dd><p>This macro is defined, with value 1, when compiling a C++ source file

  480. with runtime type identification enabled.  If <samp>-fno-rtti</samp> is

  481. used when compiling the file, then this macro is not defined.

  482. </p>

  483. </dd>

  484. <dt><code>__USING_SJLJ_EXCEPTIONS__</code></dt>

  485. <dd><p>This macro is defined, with value 1, if the compiler uses the old

  486. mechanism based on <code>setjmp</code> and <code>longjmp</code> for exception

  487. handling.

  488. </p>

  489. </dd>

  490. <dt><code>__GXX_EXPERIMENTAL_CXX0X__</code></dt>

  491. <dd><p>This macro is defined when compiling a C++ source file with the option

  492. <samp>-std=c++0x</samp> or <samp>-std=gnu++0x</samp>. It indicates that some

  493. features likely to be included in C++0x are available. Note that these

  494. features are experimental, and may change or be removed in future

  495. versions of GCC.

  496. </p>

  497. </dd>

  498. <dt><code>__GXX_WEAK__</code></dt>

  499. <dd><p>This macro is defined when compiling a C++ source file.  It has the

  500. value 1 if the compiler will use weak symbols, COMDAT sections, or

  501. other similar techniques to collapse symbols with &ldquo;vague linkage&rdquo;

  502. that are defined in multiple translation units.  If the compiler will

  503. not collapse such symbols, this macro is defined with value 0.  In

  504. general, user code should not need to make use of this macro; the

  505. purpose of this macro is to ease implementation of the C++ runtime

  506. library provided with G++.

  507. </p>

  508. </dd>

  509. <dt><code>__NEXT_RUNTIME__</code></dt>

  510. <dd><p>This macro is defined, with value 1, if (and only if) the NeXT runtime

  511. (as in <samp>-fnext-runtime</samp>) is in use for Objective-C.  If the GNU

  512. runtime is used, this macro is not defined, so that you can use this

  513. macro to determine which runtime (NeXT or GNU) is being used.

  514. </p>

  515. </dd>

  516. <dt><code>__LP64__</code></dt>

  517. <dt><code>_LP64</code></dt>

  518. <dd><p>These macros are defined, with value 1, if (and only if) the compilation

  519. is for a target where <code>long int</code> and pointer both use 64-bits and

  520. <code>int</code> uses 32-bit.

  521. </p>

  522. </dd>

  523. <dt><code>__SSP__</code></dt>

  524. <dd><p>This macro is defined, with value 1, when <samp>-fstack-protector</samp> is in

  525. use.

  526. </p>

  527. </dd>

  528. <dt><code>__SSP_ALL__</code></dt>

  529. <dd><p>This macro is defined, with value 2, when <samp>-fstack-protector-all</samp> is

  530. in use.

  531. </p>

  532. </dd>

  533. <dt><code>__SSP_STRONG__</code></dt>

  534. <dd><p>This macro is defined, with value 3, when <samp>-fstack-protector-strong</samp> is

  535. in use.

  536. </p>

  537. </dd>

  538. <dt><code>__SSP_EXPLICIT__</code></dt>

  539. <dd><p>This macro is defined, with value 4, when <samp>-fstack-protector-explicit</samp> is

  540. in use.

  541. </p>

  542. </dd>

  543. <dt><code>__SANITIZE_ADDRESS__</code></dt>

  544. <dd><p>This macro is defined, with value 1, when <samp>-fsanitize=address</samp>

  545. or <samp>-fsanitize=kernel-address</samp> are in use.

  546. </p>

  547. </dd>

  548. <dt><code>__SANITIZE_THREAD__</code></dt>

  549. <dd><p>This macro is defined, with value 1, when <samp>-fsanitize=thread</samp> is in use.

  550. </p>

  551. </dd>

  552. <dt><code>__TIMESTAMP__</code></dt>

  553. <dd><p>This macro expands to a string constant that describes the date and time

  554. of the last modification of the current source file. The string constant

  555. contains abbreviated day of the week, month, day of the month, time in

  556. hh:mm:ss form, year and looks like <code>&quot;Sun&nbsp;Sep&nbsp;16&nbsp;01:03:52&nbsp;1973&quot;<!-- /@w --></code>.

  557. If the day of the month is less than 10, it is padded with a space on the left.

  558. </p>

  559. <p>If GCC cannot determine the current date, it will emit a warning message

  560. (once per compilation) and <code>__TIMESTAMP__</code> will expand to

  561. <code>&quot;???&nbsp;???&nbsp;??&nbsp;??:??:??&nbsp;????&quot;<!-- /@w --></code>.

  562. </p>

  563. </dd>

  564. <dt><code>__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1</code></dt>

  565. <dt><code>__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2</code></dt>

  566. <dt><code>__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4</code></dt>

  567. <dt><code>__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8</code></dt>

  568. <dt><code>__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16</code></dt>

  569. <dd><p>These macros are defined when the target processor supports atomic compare

  570. and swap operations on operands 1, 2, 4, 8 or 16 bytes in length, respectively.

  571. </p>

  572. </dd>

  573. <dt><code>__HAVE_SPECULATION_SAFE_VALUE</code></dt>

  574. <dd><p>This macro is defined with the value 1 to show that this version of GCC

  575. supports <code>__builtin_speculation_safe_value</code>.

  576. </p>

  577. </dd>

  578. <dt><code>__GCC_HAVE_DWARF2_CFI_ASM</code></dt>

  579. <dd><p>This macro is defined when the compiler is emitting DWARF CFI directives

  580. to the assembler.  When this is defined, it is possible to emit those same

  581. directives in inline assembly.

  582. </p>

  583. </dd>

  584. <dt><code>__FP_FAST_FMA</code></dt>

  585. <dt><code>__FP_FAST_FMAF</code></dt>

  586. <dt><code>__FP_FAST_FMAL</code></dt>

  587. <dd><p>These macros are defined with value 1 if the backend supports the

  588. <code>fma</code>, <code>fmaf</code>, and <code>fmal</code> builtin functions, so that

  589. the include file <samp>math.h</samp> can define the macros

  590. <code>FP_FAST_FMA</code>, <code>FP_FAST_FMAF</code>, and <code>FP_FAST_FMAL</code>

  591. for compatibility with the 1999 C standard.

  592. </p>

  593. </dd>

  594. <dt><code>__FP_FAST_FMAF16</code></dt>

  595. <dt><code>__FP_FAST_FMAF32</code></dt>

  596. <dt><code>__FP_FAST_FMAF64</code></dt>

  597. <dt><code>__FP_FAST_FMAF128</code></dt>

  598. <dt><code>__FP_FAST_FMAF32X</code></dt>

  599. <dt><code>__FP_FAST_FMAF64X</code></dt>

  600. <dt><code>__FP_FAST_FMAF128X</code></dt>

  601. <dd><p>These macros are defined with the value 1 if the backend supports the

  602. <code>fma</code> functions using the additional <code>_Float<var>n</var></code> and

  603. <code>_Float<var>n</var>x</code> types that are defined in ISO/IEC TS

  604. 18661-3:2015.  The include file <samp>math.h</samp> can define the

  605. <code>FP_FAST_FMAF<var>n</var></code> and <code>FP_FAST_FMAF<var>n</var>x</code> macros if

  606. the user defined <code>__STDC_WANT_IEC_60559_TYPES_EXT__</code> before

  607. including <samp>math.h</samp>.

  608. </p>

  609. </dd>

  610. <dt><code>__GCC_IEC_559</code></dt>

  611. <dd><p>This macro is defined to indicate the intended level of support for

  612. IEEE 754 (IEC 60559) floating-point arithmetic.  It expands to a

  613. nonnegative integer value.  If 0, it indicates that the combination of

  614. the compiler configuration and the command-line options is not

  615. intended to support IEEE 754 arithmetic for <code>float</code> and

  616. <code>double</code> as defined in C99 and C11 Annex F (for example, that the

  617. standard rounding modes and exceptions are not supported, or that

  618. optimizations are enabled that conflict with IEEE 754 semantics).  If

  619. 1, it indicates that IEEE 754 arithmetic is intended to be supported;

  620. this does not mean that all relevant language features are supported

  621. by GCC.  If 2 or more, it additionally indicates support for IEEE

  622. 754-2008 (in particular, that the binary encodings for quiet and

  623. signaling NaNs are as specified in IEEE 754-2008).

  624. </p>

  625. <p>This macro does not indicate the default state of command-line options

  626. that control optimizations that C99 and C11 permit to be controlled by

  627. standard pragmas, where those standards do not require a particular

  628. default state.  It does not indicate whether optimizations respect

  629. signaling NaN semantics (the macro for that is

  630. <code>__SUPPORT_SNAN__</code>).  It does not indicate support for decimal

  631. floating point or the IEEE 754 binary16 and binary128 types.

  632. </p>

  633. </dd>

  634. <dt><code>__GCC_IEC_559_COMPLEX</code></dt>

  635. <dd><p>This macro is defined to indicate the intended level of support for

  636. IEEE 754 (IEC 60559) floating-point arithmetic for complex numbers, as

  637. defined in C99 and C11 Annex G.  It expands to a nonnegative integer

  638. value.  If 0, it indicates that the combination of the compiler

  639. configuration and the command-line options is not intended to support

  640. Annex G requirements (for example, because <samp>-fcx-limited-range</samp>

  641. was used).  If 1 or more, it indicates that it is intended to support

  642. those requirements; this does not mean that all relevant language

  643. features are supported by GCC.

  644. </p>

  645. </dd>

  646. <dt><code>__NO_MATH_ERRNO__</code></dt>

  647. <dd><p>This macro is defined if <samp>-fno-math-errno</samp> is used, or enabled

  648. by another option such as <samp>-ffast-math</samp> or by default.

  649. </p></dd>

  650. </dl>

  651. 

  652. <hr>

  653. <div class="header">

  654. <p>

  655. Next: <a href="System_002dspecific-Predefined-Macros.html#System_002dspecific-Predefined-Macros" accesskey="n" rel="next">System-specific Predefined Macros</a>, Previous: <a href="Standard-Predefined-Macros.html#Standard-Predefined-Macros" accesskey="p" rel="prev">Standard Predefined Macros</a>, Up: <a href="Predefined-Macros.html#Predefined-Macros" accesskey="u" rel="up">Predefined Macros</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Index-of-Directives.html#Index-of-Directives" title="Index" rel="index">Index</a>]</p>

  656. </div>

  657. 

  658. 

  659. 

  660. </body>

  661. </html>