1 @c Copyright (C) 1988-2015 Free Software Foundation, Inc.
3 @c This is part of the GCC manual.
4 @c For copying conditions, see the file gcc.texi.
7 @chapter Extensions to the C Language Family
8 @cindex extensions, C language
9 @cindex C language extensions
12 GNU C provides several language features not found in ISO standard C@.
13 (The @option{-pedantic} option directs GCC to print a warning message if
14 any of these features is used.) To test for the availability of these
15 features in conditional compilation, check for a predefined macro
16 @code{__GNUC__}, which is always defined under GCC@.
18 These extensions are available in C and Objective-C@. Most of them are
19 also available in C++. @xref{C++ Extensions,,Extensions to the
20 C++ Language}, for extensions that apply @emph{only} to C++.
22 Some features that are in ISO C99 but not C90 or C++ are also, as
23 extensions, accepted by GCC in C90 mode and in C++.
26 * Statement Exprs:: Putting statements and declarations inside expressions.
27 * Local Labels:: Labels local to a block.
28 * Labels as Values:: Getting pointers to labels, and computed gotos.
29 * Nested Functions:: As in Algol and Pascal, lexical scoping of functions.
30 * Constructing Calls:: Dispatching a call to another function.
31 * Typeof:: @code{typeof}: referring to the type of an expression.
32 * Conditionals:: Omitting the middle operand of a @samp{?:} expression.
33 * __int128:: 128-bit integers---@code{__int128}.
34 * Long Long:: Double-word integers---@code{long long int}.
35 * Complex:: Data types for complex numbers.
36 * Floating Types:: Additional Floating Types.
37 * Half-Precision:: Half-Precision Floating Point.
38 * Decimal Float:: Decimal Floating Types.
39 * Hex Floats:: Hexadecimal floating-point constants.
40 * Fixed-Point:: Fixed-Point Types.
41 * Named Address Spaces::Named address spaces.
42 * Zero Length:: Zero-length arrays.
43 * Empty Structures:: Structures with no members.
44 * Variable Length:: Arrays whose length is computed at run time.
45 * Variadic Macros:: Macros with a variable number of arguments.
46 * Escaped Newlines:: Slightly looser rules for escaped newlines.
47 * Subscripting:: Any array can be subscripted, even if not an lvalue.
48 * Pointer Arith:: Arithmetic on @code{void}-pointers and function pointers.
49 * Pointers to Arrays:: Pointers to arrays with qualifiers work as expected.
50 * Initializers:: Non-constant initializers.
51 * Compound Literals:: Compound literals give structures, unions
53 * Designated Inits:: Labeling elements of initializers.
54 * Case Ranges:: `case 1 ... 9' and such.
55 * Cast to Union:: Casting to union type from any member of the union.
56 * Mixed Declarations:: Mixing declarations and code.
57 * Function Attributes:: Declaring that functions have no side effects,
58 or that they can never return.
59 * Label Attributes:: Specifying attributes on labels.
60 * Attribute Syntax:: Formal syntax for attributes.
61 * Function Prototypes:: Prototype declarations and old-style definitions.
62 * C++ Comments:: C++ comments are recognized.
63 * Dollar Signs:: Dollar sign is allowed in identifiers.
64 * Character Escapes:: @samp{\e} stands for the character @key{ESC}.
65 * Variable Attributes:: Specifying attributes of variables.
66 * Type Attributes:: Specifying attributes of types.
67 * Alignment:: Inquiring about the alignment of a type or variable.
68 * Inline:: Defining inline functions (as fast as macros).
69 * Volatiles:: What constitutes an access to a volatile object.
70 * Using Assembly Language with C:: Instructions and extensions for interfacing C with assembler.
71 * Alternate Keywords:: @code{__const__}, @code{__asm__}, etc., for header files.
72 * Incomplete Enums:: @code{enum foo;}, with details to follow.
73 * Function Names:: Printable strings which are the name of the current
75 * Return Address:: Getting the return or frame address of a function.
76 * Vector Extensions:: Using vector instructions through built-in functions.
77 * Offsetof:: Special syntax for implementing @code{offsetof}.
78 * __sync Builtins:: Legacy built-in functions for atomic memory access.
79 * __atomic Builtins:: Atomic built-in functions with memory model.
80 * Integer Overflow Builtins:: Built-in functions to perform arithmetics and
81 arithmetic overflow checking.
82 * x86 specific memory model extensions for transactional memory:: x86 memory models.
83 * Object Size Checking:: Built-in functions for limited buffer overflow
85 * Pointer Bounds Checker builtins:: Built-in functions for Pointer Bounds Checker.
86 * Cilk Plus Builtins:: Built-in functions for the Cilk Plus language extension.
87 * Other Builtins:: Other built-in functions.
88 * Target Builtins:: Built-in functions specific to particular targets.
89 * Target Format Checks:: Format checks specific to particular targets.
90 * Pragmas:: Pragmas accepted by GCC.
91 * Unnamed Fields:: Unnamed struct/union fields within structs/unions.
92 * Thread-Local:: Per-thread variables.
93 * Binary constants:: Binary constants using the @samp{0b} prefix.
97 @section Statements and Declarations in Expressions
98 @cindex statements inside expressions
99 @cindex declarations inside expressions
100 @cindex expressions containing statements
101 @cindex macros, statements in expressions
103 @c the above section title wrapped and causes an underfull hbox.. i
104 @c changed it from "within" to "in". --mew 4feb93
105 A compound statement enclosed in parentheses may appear as an expression
106 in GNU C@. This allows you to use loops, switches, and local variables
107 within an expression.
109 Recall that a compound statement is a sequence of statements surrounded
110 by braces; in this construct, parentheses go around the braces. For
114 (@{ int y = foo (); int z;
121 is a valid (though slightly more complex than necessary) expression
122 for the absolute value of @code{foo ()}.
124 The last thing in the compound statement should be an expression
125 followed by a semicolon; the value of this subexpression serves as the
126 value of the entire construct. (If you use some other kind of statement
127 last within the braces, the construct has type @code{void}, and thus
128 effectively no value.)
130 This feature is especially useful in making macro definitions ``safe'' (so
131 that they evaluate each operand exactly once). For example, the
132 ``maximum'' function is commonly defined as a macro in standard C as
136 #define max(a,b) ((a) > (b) ? (a) : (b))
140 @cindex side effects, macro argument
141 But this definition computes either @var{a} or @var{b} twice, with bad
142 results if the operand has side effects. In GNU C, if you know the
143 type of the operands (here taken as @code{int}), you can define
144 the macro safely as follows:
147 #define maxint(a,b) \
148 (@{int _a = (a), _b = (b); _a > _b ? _a : _b; @})
151 Embedded statements are not allowed in constant expressions, such as
152 the value of an enumeration constant, the width of a bit-field, or
153 the initial value of a static variable.
155 If you don't know the type of the operand, you can still do this, but you
156 must use @code{typeof} or @code{__auto_type} (@pxref{Typeof}).
158 In G++, the result value of a statement expression undergoes array and
159 function pointer decay, and is returned by value to the enclosing
160 expression. For instance, if @code{A} is a class, then
169 constructs a temporary @code{A} object to hold the result of the
170 statement expression, and that is used to invoke @code{Foo}.
171 Therefore the @code{this} pointer observed by @code{Foo} is not the
174 In a statement expression, any temporaries created within a statement
175 are destroyed at that statement's end. This makes statement
176 expressions inside macros slightly different from function calls. In
177 the latter case temporaries introduced during argument evaluation are
178 destroyed at the end of the statement that includes the function
179 call. In the statement expression case they are destroyed during
180 the statement expression. For instance,
183 #define macro(a) (@{__typeof__(a) b = (a); b + 3; @})
184 template<typename T> T function(T a) @{ T b = a; return b + 3; @}
194 has different places where temporaries are destroyed. For the
195 @code{macro} case, the temporary @code{X} is destroyed just after
196 the initialization of @code{b}. In the @code{function} case that
197 temporary is destroyed when the function returns.
199 These considerations mean that it is probably a bad idea to use
200 statement expressions of this form in header files that are designed to
201 work with C++. (Note that some versions of the GNU C Library contained
202 header files using statement expressions that lead to precisely this
205 Jumping into a statement expression with @code{goto} or using a
206 @code{switch} statement outside the statement expression with a
207 @code{case} or @code{default} label inside the statement expression is
208 not permitted. Jumping into a statement expression with a computed
209 @code{goto} (@pxref{Labels as Values}) has undefined behavior.
210 Jumping out of a statement expression is permitted, but if the
211 statement expression is part of a larger expression then it is
212 unspecified which other subexpressions of that expression have been
213 evaluated except where the language definition requires certain
214 subexpressions to be evaluated before or after the statement
215 expression. In any case, as with a function call, the evaluation of a
216 statement expression is not interleaved with the evaluation of other
217 parts of the containing expression. For example,
220 foo (), ((@{ bar1 (); goto a; 0; @}) + bar2 ()), baz();
224 calls @code{foo} and @code{bar1} and does not call @code{baz} but
225 may or may not call @code{bar2}. If @code{bar2} is called, it is
226 called after @code{foo} and before @code{bar1}.
229 @section Locally Declared Labels
231 @cindex macros, local labels
233 GCC allows you to declare @dfn{local labels} in any nested block
234 scope. A local label is just like an ordinary label, but you can
235 only reference it (with a @code{goto} statement, or by taking its
236 address) within the block in which it is declared.
238 A local label declaration looks like this:
241 __label__ @var{label};
248 __label__ @var{label1}, @var{label2}, /* @r{@dots{}} */;
251 Local label declarations must come at the beginning of the block,
252 before any ordinary declarations or statements.
254 The label declaration defines the label @emph{name}, but does not define
255 the label itself. You must do this in the usual way, with
256 @code{@var{label}:}, within the statements of the statement expression.
258 The local label feature is useful for complex macros. If a macro
259 contains nested loops, a @code{goto} can be useful for breaking out of
260 them. However, an ordinary label whose scope is the whole function
261 cannot be used: if the macro can be expanded several times in one
262 function, the label is multiply defined in that function. A
263 local label avoids this problem. For example:
266 #define SEARCH(value, array, target) \
269 typeof (target) _SEARCH_target = (target); \
270 typeof (*(array)) *_SEARCH_array = (array); \
273 for (i = 0; i < max; i++) \
274 for (j = 0; j < max; j++) \
275 if (_SEARCH_array[i][j] == _SEARCH_target) \
276 @{ (value) = i; goto found; @} \
282 This could also be written using a statement expression:
285 #define SEARCH(array, target) \
288 typeof (target) _SEARCH_target = (target); \
289 typeof (*(array)) *_SEARCH_array = (array); \
292 for (i = 0; i < max; i++) \
293 for (j = 0; j < max; j++) \
294 if (_SEARCH_array[i][j] == _SEARCH_target) \
295 @{ value = i; goto found; @} \
302 Local label declarations also make the labels they declare visible to
303 nested functions, if there are any. @xref{Nested Functions}, for details.
305 @node Labels as Values
306 @section Labels as Values
307 @cindex labels as values
308 @cindex computed gotos
309 @cindex goto with computed label
310 @cindex address of a label
312 You can get the address of a label defined in the current function
313 (or a containing function) with the unary operator @samp{&&}. The
314 value has type @code{void *}. This value is a constant and can be used
315 wherever a constant of that type is valid. For example:
323 To use these values, you need to be able to jump to one. This is done
324 with the computed goto statement@footnote{The analogous feature in
325 Fortran is called an assigned goto, but that name seems inappropriate in
326 C, where one can do more than simply store label addresses in label
327 variables.}, @code{goto *@var{exp};}. For example,
334 Any expression of type @code{void *} is allowed.
336 One way of using these constants is in initializing a static array that
337 serves as a jump table:
340 static void *array[] = @{ &&foo, &&bar, &&hack @};
344 Then you can select a label with indexing, like this:
351 Note that this does not check whether the subscript is in bounds---array
352 indexing in C never does that.
354 Such an array of label values serves a purpose much like that of the
355 @code{switch} statement. The @code{switch} statement is cleaner, so
356 use that rather than an array unless the problem does not fit a
357 @code{switch} statement very well.
359 Another use of label values is in an interpreter for threaded code.
360 The labels within the interpreter function can be stored in the
361 threaded code for super-fast dispatching.
363 You may not use this mechanism to jump to code in a different function.
364 If you do that, totally unpredictable things happen. The best way to
365 avoid this is to store the label address only in automatic variables and
366 never pass it as an argument.
368 An alternate way to write the above example is
371 static const int array[] = @{ &&foo - &&foo, &&bar - &&foo,
373 goto *(&&foo + array[i]);
377 This is more friendly to code living in shared libraries, as it reduces
378 the number of dynamic relocations that are needed, and by consequence,
379 allows the data to be read-only.
380 This alternative with label differences is not supported for the AVR target,
381 please use the first approach for AVR programs.
383 The @code{&&foo} expressions for the same label might have different
384 values if the containing function is inlined or cloned. If a program
385 relies on them being always the same,
386 @code{__attribute__((__noinline__,__noclone__))} should be used to
387 prevent inlining and cloning. If @code{&&foo} is used in a static
388 variable initializer, inlining and cloning is forbidden.
390 @node Nested Functions
391 @section Nested Functions
392 @cindex nested functions
393 @cindex downward funargs
396 A @dfn{nested function} is a function defined inside another function.
397 Nested functions are supported as an extension in GNU C, but are not
398 supported by GNU C++.
400 The nested function's name is local to the block where it is defined.
401 For example, here we define a nested function named @code{square}, and
406 foo (double a, double b)
408 double square (double z) @{ return z * z; @}
410 return square (a) + square (b);
415 The nested function can access all the variables of the containing
416 function that are visible at the point of its definition. This is
417 called @dfn{lexical scoping}. For example, here we show a nested
418 function which uses an inherited variable named @code{offset}:
422 bar (int *array, int offset, int size)
424 int access (int *array, int index)
425 @{ return array[index + offset]; @}
428 for (i = 0; i < size; i++)
429 /* @r{@dots{}} */ access (array, i) /* @r{@dots{}} */
434 Nested function definitions are permitted within functions in the places
435 where variable definitions are allowed; that is, in any block, mixed
436 with the other declarations and statements in the block.
438 It is possible to call the nested function from outside the scope of its
439 name by storing its address or passing the address to another function:
442 hack (int *array, int size)
444 void store (int index, int value)
445 @{ array[index] = value; @}
447 intermediate (store, size);
451 Here, the function @code{intermediate} receives the address of
452 @code{store} as an argument. If @code{intermediate} calls @code{store},
453 the arguments given to @code{store} are used to store into @code{array}.
454 But this technique works only so long as the containing function
455 (@code{hack}, in this example) does not exit.
457 If you try to call the nested function through its address after the
458 containing function exits, all hell breaks loose. If you try
459 to call it after a containing scope level exits, and if it refers
460 to some of the variables that are no longer in scope, you may be lucky,
461 but it's not wise to take the risk. If, however, the nested function
462 does not refer to anything that has gone out of scope, you should be
465 GCC implements taking the address of a nested function using a technique
466 called @dfn{trampolines}. This technique was described in
467 @cite{Lexical Closures for C++} (Thomas M. Breuel, USENIX
468 C++ Conference Proceedings, October 17-21, 1988).
470 A nested function can jump to a label inherited from a containing
471 function, provided the label is explicitly declared in the containing
472 function (@pxref{Local Labels}). Such a jump returns instantly to the
473 containing function, exiting the nested function that did the
474 @code{goto} and any intermediate functions as well. Here is an example:
478 bar (int *array, int offset, int size)
481 int access (int *array, int index)
485 return array[index + offset];
489 for (i = 0; i < size; i++)
490 /* @r{@dots{}} */ access (array, i) /* @r{@dots{}} */
494 /* @r{Control comes here from @code{access}
495 if it detects an error.} */
502 A nested function always has no linkage. Declaring one with
503 @code{extern} or @code{static} is erroneous. If you need to declare the nested function
504 before its definition, use @code{auto} (which is otherwise meaningless
505 for function declarations).
508 bar (int *array, int offset, int size)
511 auto int access (int *, int);
513 int access (int *array, int index)
517 return array[index + offset];
523 @node Constructing Calls
524 @section Constructing Function Calls
525 @cindex constructing calls
526 @cindex forwarding calls
528 Using the built-in functions described below, you can record
529 the arguments a function received, and call another function
530 with the same arguments, without knowing the number or types
533 You can also record the return value of that function call,
534 and later return that value, without knowing what data type
535 the function tried to return (as long as your caller expects
538 However, these built-in functions may interact badly with some
539 sophisticated features or other extensions of the language. It
540 is, therefore, not recommended to use them outside very simple
541 functions acting as mere forwarders for their arguments.
543 @deftypefn {Built-in Function} {void *} __builtin_apply_args ()
544 This built-in function returns a pointer to data
545 describing how to perform a call with the same arguments as are passed
546 to the current function.
548 The function saves the arg pointer register, structure value address,
549 and all registers that might be used to pass arguments to a function
550 into a block of memory allocated on the stack. Then it returns the
551 address of that block.
554 @deftypefn {Built-in Function} {void *} __builtin_apply (void (*@var{function})(), void *@var{arguments}, size_t @var{size})
555 This built-in function invokes @var{function}
556 with a copy of the parameters described by @var{arguments}
559 The value of @var{arguments} should be the value returned by
560 @code{__builtin_apply_args}. The argument @var{size} specifies the size
561 of the stack argument data, in bytes.
563 This function returns a pointer to data describing
564 how to return whatever value is returned by @var{function}. The data
565 is saved in a block of memory allocated on the stack.
567 It is not always simple to compute the proper value for @var{size}. The
568 value is used by @code{__builtin_apply} to compute the amount of data
569 that should be pushed on the stack and copied from the incoming argument
573 @deftypefn {Built-in Function} {void} __builtin_return (void *@var{result})
574 This built-in function returns the value described by @var{result} from
575 the containing function. You should specify, for @var{result}, a value
576 returned by @code{__builtin_apply}.
579 @deftypefn {Built-in Function} {} __builtin_va_arg_pack ()
580 This built-in function represents all anonymous arguments of an inline
581 function. It can be used only in inline functions that are always
582 inlined, never compiled as a separate function, such as those using
583 @code{__attribute__ ((__always_inline__))} or
584 @code{__attribute__ ((__gnu_inline__))} extern inline functions.
585 It must be only passed as last argument to some other function
586 with variable arguments. This is useful for writing small wrapper
587 inlines for variable argument functions, when using preprocessor
588 macros is undesirable. For example:
590 extern int myprintf (FILE *f, const char *format, ...);
591 extern inline __attribute__ ((__gnu_inline__)) int
592 myprintf (FILE *f, const char *format, ...)
594 int r = fprintf (f, "myprintf: ");
597 int s = fprintf (f, format, __builtin_va_arg_pack ());
605 @deftypefn {Built-in Function} {size_t} __builtin_va_arg_pack_len ()
606 This built-in function returns the number of anonymous arguments of
607 an inline function. It can be used only in inline functions that
608 are always inlined, never compiled as a separate function, such
609 as those using @code{__attribute__ ((__always_inline__))} or
610 @code{__attribute__ ((__gnu_inline__))} extern inline functions.
611 For example following does link- or run-time checking of open
612 arguments for optimized code:
615 extern inline __attribute__((__gnu_inline__)) int
616 myopen (const char *path, int oflag, ...)
618 if (__builtin_va_arg_pack_len () > 1)
619 warn_open_too_many_arguments ();
621 if (__builtin_constant_p (oflag))
623 if ((oflag & O_CREAT) != 0 && __builtin_va_arg_pack_len () < 1)
625 warn_open_missing_mode ();
626 return __open_2 (path, oflag);
628 return open (path, oflag, __builtin_va_arg_pack ());
631 if (__builtin_va_arg_pack_len () < 1)
632 return __open_2 (path, oflag);
634 return open (path, oflag, __builtin_va_arg_pack ());
641 @section Referring to a Type with @code{typeof}
644 @cindex macros, types of arguments
646 Another way to refer to the type of an expression is with @code{typeof}.
647 The syntax of using of this keyword looks like @code{sizeof}, but the
648 construct acts semantically like a type name defined with @code{typedef}.
650 There are two ways of writing the argument to @code{typeof}: with an
651 expression or with a type. Here is an example with an expression:
658 This assumes that @code{x} is an array of pointers to functions;
659 the type described is that of the values of the functions.
661 Here is an example with a typename as the argument:
668 Here the type described is that of pointers to @code{int}.
670 If you are writing a header file that must work when included in ISO C
671 programs, write @code{__typeof__} instead of @code{typeof}.
672 @xref{Alternate Keywords}.
674 A @code{typeof} construct can be used anywhere a typedef name can be
675 used. For example, you can use it in a declaration, in a cast, or inside
676 of @code{sizeof} or @code{typeof}.
678 The operand of @code{typeof} is evaluated for its side effects if and
679 only if it is an expression of variably modified type or the name of
682 @code{typeof} is often useful in conjunction with
683 statement expressions (@pxref{Statement Exprs}).
684 Here is how the two together can
685 be used to define a safe ``maximum'' macro which operates on any
686 arithmetic type and evaluates each of its arguments exactly once:
690 (@{ typeof (a) _a = (a); \
691 typeof (b) _b = (b); \
692 _a > _b ? _a : _b; @})
695 @cindex underscores in variables in macros
696 @cindex @samp{_} in variables in macros
697 @cindex local variables in macros
698 @cindex variables, local, in macros
699 @cindex macros, local variables in
701 The reason for using names that start with underscores for the local
702 variables is to avoid conflicts with variable names that occur within the
703 expressions that are substituted for @code{a} and @code{b}. Eventually we
704 hope to design a new form of declaration syntax that allows you to declare
705 variables whose scopes start only after their initializers; this will be a
706 more reliable way to prevent such conflicts.
709 Some more examples of the use of @code{typeof}:
713 This declares @code{y} with the type of what @code{x} points to.
720 This declares @code{y} as an array of such values.
727 This declares @code{y} as an array of pointers to characters:
730 typeof (typeof (char *)[4]) y;
734 It is equivalent to the following traditional C declaration:
740 To see the meaning of the declaration using @code{typeof}, and why it
741 might be a useful way to write, rewrite it with these macros:
744 #define pointer(T) typeof(T *)
745 #define array(T, N) typeof(T [N])
749 Now the declaration can be rewritten this way:
752 array (pointer (char), 4) y;
756 Thus, @code{array (pointer (char), 4)} is the type of arrays of 4
757 pointers to @code{char}.
760 In GNU C, but not GNU C++, you may also declare the type of a variable
761 as @code{__auto_type}. In that case, the declaration must declare
762 only one variable, whose declarator must just be an identifier, the
763 declaration must be initialized, and the type of the variable is
764 determined by the initializer; the name of the variable is not in
765 scope until after the initializer. (In C++, you should use C++11
766 @code{auto} for this purpose.) Using @code{__auto_type}, the
767 ``maximum'' macro above could be written as:
771 (@{ __auto_type _a = (a); \
772 __auto_type _b = (b); \
773 _a > _b ? _a : _b; @})
776 Using @code{__auto_type} instead of @code{typeof} has two advantages:
779 @item Each argument to the macro appears only once in the expansion of
780 the macro. This prevents the size of the macro expansion growing
781 exponentially when calls to such macros are nested inside arguments of
784 @item If the argument to the macro has variably modified type, it is
785 evaluated only once when using @code{__auto_type}, but twice if
786 @code{typeof} is used.
790 @section Conditionals with Omitted Operands
791 @cindex conditional expressions, extensions
792 @cindex omitted middle-operands
793 @cindex middle-operands, omitted
794 @cindex extensions, @code{?:}
795 @cindex @code{?:} extensions
797 The middle operand in a conditional expression may be omitted. Then
798 if the first operand is nonzero, its value is the value of the conditional
801 Therefore, the expression
808 has the value of @code{x} if that is nonzero; otherwise, the value of
811 This example is perfectly equivalent to
817 @cindex side effect in @code{?:}
818 @cindex @code{?:} side effect
820 In this simple case, the ability to omit the middle operand is not
821 especially useful. When it becomes useful is when the first operand does,
822 or may (if it is a macro argument), contain a side effect. Then repeating
823 the operand in the middle would perform the side effect twice. Omitting
824 the middle operand uses the value already computed without the undesirable
825 effects of recomputing it.
828 @section 128-bit Integers
829 @cindex @code{__int128} data types
831 As an extension the integer scalar type @code{__int128} is supported for
832 targets which have an integer mode wide enough to hold 128 bits.
833 Simply write @code{__int128} for a signed 128-bit integer, or
834 @code{unsigned __int128} for an unsigned 128-bit integer. There is no
835 support in GCC for expressing an integer constant of type @code{__int128}
836 for targets with @code{long long} integer less than 128 bits wide.
839 @section Double-Word Integers
840 @cindex @code{long long} data types
841 @cindex double-word arithmetic
842 @cindex multiprecision arithmetic
843 @cindex @code{LL} integer suffix
844 @cindex @code{ULL} integer suffix
846 ISO C99 supports data types for integers that are at least 64 bits wide,
847 and as an extension GCC supports them in C90 mode and in C++.
848 Simply write @code{long long int} for a signed integer, or
849 @code{unsigned long long int} for an unsigned integer. To make an
850 integer constant of type @code{long long int}, add the suffix @samp{LL}
851 to the integer. To make an integer constant of type @code{unsigned long
852 long int}, add the suffix @samp{ULL} to the integer.
854 You can use these types in arithmetic like any other integer types.
855 Addition, subtraction, and bitwise boolean operations on these types
856 are open-coded on all types of machines. Multiplication is open-coded
857 if the machine supports a fullword-to-doubleword widening multiply
858 instruction. Division and shifts are open-coded only on machines that
859 provide special support. The operations that are not open-coded use
860 special library routines that come with GCC@.
862 There may be pitfalls when you use @code{long long} types for function
863 arguments without function prototypes. If a function
864 expects type @code{int} for its argument, and you pass a value of type
865 @code{long long int}, confusion results because the caller and the
866 subroutine disagree about the number of bytes for the argument.
867 Likewise, if the function expects @code{long long int} and you pass
868 @code{int}. The best way to avoid such problems is to use prototypes.
871 @section Complex Numbers
872 @cindex complex numbers
873 @cindex @code{_Complex} keyword
874 @cindex @code{__complex__} keyword
876 ISO C99 supports complex floating data types, and as an extension GCC
877 supports them in C90 mode and in C++. GCC also supports complex integer data
878 types which are not part of ISO C99. You can declare complex types
879 using the keyword @code{_Complex}. As an extension, the older GNU
880 keyword @code{__complex__} is also supported.
882 For example, @samp{_Complex double x;} declares @code{x} as a
883 variable whose real part and imaginary part are both of type
884 @code{double}. @samp{_Complex short int y;} declares @code{y} to
885 have real and imaginary parts of type @code{short int}; this is not
886 likely to be useful, but it shows that the set of complex types is
889 To write a constant with a complex data type, use the suffix @samp{i} or
890 @samp{j} (either one; they are equivalent). For example, @code{2.5fi}
891 has type @code{_Complex float} and @code{3i} has type
892 @code{_Complex int}. Such a constant always has a pure imaginary
893 value, but you can form any complex value you like by adding one to a
894 real constant. This is a GNU extension; if you have an ISO C99
895 conforming C library (such as the GNU C Library), and want to construct complex
896 constants of floating type, you should include @code{<complex.h>} and
897 use the macros @code{I} or @code{_Complex_I} instead.
899 @cindex @code{__real__} keyword
900 @cindex @code{__imag__} keyword
901 To extract the real part of a complex-valued expression @var{exp}, write
902 @code{__real__ @var{exp}}. Likewise, use @code{__imag__} to
903 extract the imaginary part. This is a GNU extension; for values of
904 floating type, you should use the ISO C99 functions @code{crealf},
905 @code{creal}, @code{creall}, @code{cimagf}, @code{cimag} and
906 @code{cimagl}, declared in @code{<complex.h>} and also provided as
907 built-in functions by GCC@.
909 @cindex complex conjugation
910 The operator @samp{~} performs complex conjugation when used on a value
911 with a complex type. This is a GNU extension; for values of
912 floating type, you should use the ISO C99 functions @code{conjf},
913 @code{conj} and @code{conjl}, declared in @code{<complex.h>} and also
914 provided as built-in functions by GCC@.
916 GCC can allocate complex automatic variables in a noncontiguous
917 fashion; it's even possible for the real part to be in a register while
918 the imaginary part is on the stack (or vice versa). Only the DWARF 2
919 debug info format can represent this, so use of DWARF 2 is recommended.
920 If you are using the stabs debug info format, GCC describes a noncontiguous
921 complex variable as if it were two separate variables of noncomplex type.
922 If the variable's actual name is @code{foo}, the two fictitious
923 variables are named @code{foo$real} and @code{foo$imag}. You can
924 examine and set these two fictitious variables with your debugger.
927 @section Additional Floating Types
928 @cindex additional floating types
929 @cindex @code{__float80} data type
930 @cindex @code{__float128} data type
931 @cindex @code{w} floating point suffix
932 @cindex @code{q} floating point suffix
933 @cindex @code{W} floating point suffix
934 @cindex @code{Q} floating point suffix
936 As an extension, GNU C supports additional floating
937 types, @code{__float80} and @code{__float128} to support 80-bit
938 (@code{XFmode}) and 128-bit (@code{TFmode}) floating types.
939 Support for additional types includes the arithmetic operators:
940 add, subtract, multiply, divide; unary arithmetic operators;
941 relational operators; equality operators; and conversions to and from
942 integer and other floating types. Use a suffix @samp{w} or @samp{W}
943 in a literal constant of type @code{__float80} and @samp{q} or @samp{Q}
944 for @code{_float128}. You can declare complex types using the
945 corresponding internal complex type, @code{XCmode} for @code{__float80}
946 type and @code{TCmode} for @code{__float128} type:
949 typedef _Complex float __attribute__((mode(TC))) _Complex128;
950 typedef _Complex float __attribute__((mode(XC))) _Complex80;
953 Not all targets support additional floating-point types. @code{__float80}
954 and @code{__float128} types are supported on x86 and IA-64 targets.
955 The @code{__float128} type is supported on hppa HP-UX targets.
958 @section Half-Precision Floating Point
959 @cindex half-precision floating point
960 @cindex @code{__fp16} data type
962 On ARM targets, GCC supports half-precision (16-bit) floating point via
963 the @code{__fp16} type. You must enable this type explicitly
964 with the @option{-mfp16-format} command-line option in order to use it.
966 ARM supports two incompatible representations for half-precision
967 floating-point values. You must choose one of the representations and
968 use it consistently in your program.
970 Specifying @option{-mfp16-format=ieee} selects the IEEE 754-2008 format.
971 This format can represent normalized values in the range of @math{2^{-14}} to 65504.
972 There are 11 bits of significand precision, approximately 3
975 Specifying @option{-mfp16-format=alternative} selects the ARM
976 alternative format. This representation is similar to the IEEE
977 format, but does not support infinities or NaNs. Instead, the range
978 of exponents is extended, so that this format can represent normalized
979 values in the range of @math{2^{-14}} to 131008.
981 The @code{__fp16} type is a storage format only. For purposes
982 of arithmetic and other operations, @code{__fp16} values in C or C++
983 expressions are automatically promoted to @code{float}. In addition,
984 you cannot declare a function with a return value or parameters
985 of type @code{__fp16}.
987 Note that conversions from @code{double} to @code{__fp16}
988 involve an intermediate conversion to @code{float}. Because
989 of rounding, this can sometimes produce a different result than a
992 ARM provides hardware support for conversions between
993 @code{__fp16} and @code{float} values
994 as an extension to VFP and NEON (Advanced SIMD). GCC generates
995 code using these hardware instructions if you compile with
996 options to select an FPU that provides them;
997 for example, @option{-mfpu=neon-fp16 -mfloat-abi=softfp},
998 in addition to the @option{-mfp16-format} option to select
999 a half-precision format.
1001 Language-level support for the @code{__fp16} data type is
1002 independent of whether GCC generates code using hardware floating-point
1003 instructions. In cases where hardware support is not specified, GCC
1004 implements conversions between @code{__fp16} and @code{float} values
1008 @section Decimal Floating Types
1009 @cindex decimal floating types
1010 @cindex @code{_Decimal32} data type
1011 @cindex @code{_Decimal64} data type
1012 @cindex @code{_Decimal128} data type
1013 @cindex @code{df} integer suffix
1014 @cindex @code{dd} integer suffix
1015 @cindex @code{dl} integer suffix
1016 @cindex @code{DF} integer suffix
1017 @cindex @code{DD} integer suffix
1018 @cindex @code{DL} integer suffix
1020 As an extension, GNU C supports decimal floating types as
1021 defined in the N1312 draft of ISO/IEC WDTR24732. Support for decimal
1022 floating types in GCC will evolve as the draft technical report changes.
1023 Calling conventions for any target might also change. Not all targets
1024 support decimal floating types.
1026 The decimal floating types are @code{_Decimal32}, @code{_Decimal64}, and
1027 @code{_Decimal128}. They use a radix of ten, unlike the floating types
1028 @code{float}, @code{double}, and @code{long double} whose radix is not
1029 specified by the C standard but is usually two.
1031 Support for decimal floating types includes the arithmetic operators
1032 add, subtract, multiply, divide; unary arithmetic operators;
1033 relational operators; equality operators; and conversions to and from
1034 integer and other floating types. Use a suffix @samp{df} or
1035 @samp{DF} in a literal constant of type @code{_Decimal32}, @samp{dd}
1036 or @samp{DD} for @code{_Decimal64}, and @samp{dl} or @samp{DL} for
1039 GCC support of decimal float as specified by the draft technical report
1044 When the value of a decimal floating type cannot be represented in the
1045 integer type to which it is being converted, the result is undefined
1046 rather than the result value specified by the draft technical report.
1049 GCC does not provide the C library functionality associated with
1050 @file{math.h}, @file{fenv.h}, @file{stdio.h}, @file{stdlib.h}, and
1051 @file{wchar.h}, which must come from a separate C library implementation.
1052 Because of this the GNU C compiler does not define macro
1053 @code{__STDC_DEC_FP__} to indicate that the implementation conforms to
1054 the technical report.
1057 Types @code{_Decimal32}, @code{_Decimal64}, and @code{_Decimal128}
1058 are supported by the DWARF 2 debug information format.
1064 ISO C99 supports floating-point numbers written not only in the usual
1065 decimal notation, such as @code{1.55e1}, but also numbers such as
1066 @code{0x1.fp3} written in hexadecimal format. As a GNU extension, GCC
1067 supports this in C90 mode (except in some cases when strictly
1068 conforming) and in C++. In that format the
1069 @samp{0x} hex introducer and the @samp{p} or @samp{P} exponent field are
1070 mandatory. The exponent is a decimal number that indicates the power of
1071 2 by which the significant part is multiplied. Thus @samp{0x1.f} is
1078 @samp{p3} multiplies it by 8, and the value of @code{0x1.fp3}
1079 is the same as @code{1.55e1}.
1081 Unlike for floating-point numbers in the decimal notation the exponent
1082 is always required in the hexadecimal notation. Otherwise the compiler
1083 would not be able to resolve the ambiguity of, e.g., @code{0x1.f}. This
1084 could mean @code{1.0f} or @code{1.9375} since @samp{f} is also the
1085 extension for floating-point constants of type @code{float}.
1088 @section Fixed-Point Types
1089 @cindex fixed-point types
1090 @cindex @code{_Fract} data type
1091 @cindex @code{_Accum} data type
1092 @cindex @code{_Sat} data type
1093 @cindex @code{hr} fixed-suffix
1094 @cindex @code{r} fixed-suffix
1095 @cindex @code{lr} fixed-suffix
1096 @cindex @code{llr} fixed-suffix
1097 @cindex @code{uhr} fixed-suffix
1098 @cindex @code{ur} fixed-suffix
1099 @cindex @code{ulr} fixed-suffix
1100 @cindex @code{ullr} fixed-suffix
1101 @cindex @code{hk} fixed-suffix
1102 @cindex @code{k} fixed-suffix
1103 @cindex @code{lk} fixed-suffix
1104 @cindex @code{llk} fixed-suffix
1105 @cindex @code{uhk} fixed-suffix
1106 @cindex @code{uk} fixed-suffix
1107 @cindex @code{ulk} fixed-suffix
1108 @cindex @code{ullk} fixed-suffix
1109 @cindex @code{HR} fixed-suffix
1110 @cindex @code{R} fixed-suffix
1111 @cindex @code{LR} fixed-suffix
1112 @cindex @code{LLR} fixed-suffix
1113 @cindex @code{UHR} fixed-suffix
1114 @cindex @code{UR} fixed-suffix
1115 @cindex @code{ULR} fixed-suffix
1116 @cindex @code{ULLR} fixed-suffix
1117 @cindex @code{HK} fixed-suffix
1118 @cindex @code{K} fixed-suffix
1119 @cindex @code{LK} fixed-suffix
1120 @cindex @code{LLK} fixed-suffix
1121 @cindex @code{UHK} fixed-suffix
1122 @cindex @code{UK} fixed-suffix
1123 @cindex @code{ULK} fixed-suffix
1124 @cindex @code{ULLK} fixed-suffix
1126 As an extension, GNU C supports fixed-point types as
1127 defined in the N1169 draft of ISO/IEC DTR 18037. Support for fixed-point
1128 types in GCC will evolve as the draft technical report changes.
1129 Calling conventions for any target might also change. Not all targets
1130 support fixed-point types.
1132 The fixed-point types are
1133 @code{short _Fract},
1136 @code{long long _Fract},
1137 @code{unsigned short _Fract},
1138 @code{unsigned _Fract},
1139 @code{unsigned long _Fract},
1140 @code{unsigned long long _Fract},
1141 @code{_Sat short _Fract},
1143 @code{_Sat long _Fract},
1144 @code{_Sat long long _Fract},
1145 @code{_Sat unsigned short _Fract},
1146 @code{_Sat unsigned _Fract},
1147 @code{_Sat unsigned long _Fract},
1148 @code{_Sat unsigned long long _Fract},
1149 @code{short _Accum},
1152 @code{long long _Accum},
1153 @code{unsigned short _Accum},
1154 @code{unsigned _Accum},
1155 @code{unsigned long _Accum},
1156 @code{unsigned long long _Accum},
1157 @code{_Sat short _Accum},
1159 @code{_Sat long _Accum},
1160 @code{_Sat long long _Accum},
1161 @code{_Sat unsigned short _Accum},
1162 @code{_Sat unsigned _Accum},
1163 @code{_Sat unsigned long _Accum},
1164 @code{_Sat unsigned long long _Accum}.
1166 Fixed-point data values contain fractional and optional integral parts.
1167 The format of fixed-point data varies and depends on the target machine.
1169 Support for fixed-point types includes:
1172 prefix and postfix increment and decrement operators (@code{++}, @code{--})
1174 unary arithmetic operators (@code{+}, @code{-}, @code{!})
1176 binary arithmetic operators (@code{+}, @code{-}, @code{*}, @code{/})
1178 binary shift operators (@code{<<}, @code{>>})
1180 relational operators (@code{<}, @code{<=}, @code{>=}, @code{>})
1182 equality operators (@code{==}, @code{!=})
1184 assignment operators (@code{+=}, @code{-=}, @code{*=}, @code{/=},
1185 @code{<<=}, @code{>>=})
1187 conversions to and from integer, floating-point, or fixed-point types
1190 Use a suffix in a fixed-point literal constant:
1192 @item @samp{hr} or @samp{HR} for @code{short _Fract} and
1193 @code{_Sat short _Fract}
1194 @item @samp{r} or @samp{R} for @code{_Fract} and @code{_Sat _Fract}
1195 @item @samp{lr} or @samp{LR} for @code{long _Fract} and
1196 @code{_Sat long _Fract}
1197 @item @samp{llr} or @samp{LLR} for @code{long long _Fract} and
1198 @code{_Sat long long _Fract}
1199 @item @samp{uhr} or @samp{UHR} for @code{unsigned short _Fract} and
1200 @code{_Sat unsigned short _Fract}
1201 @item @samp{ur} or @samp{UR} for @code{unsigned _Fract} and
1202 @code{_Sat unsigned _Fract}
1203 @item @samp{ulr} or @samp{ULR} for @code{unsigned long _Fract} and
1204 @code{_Sat unsigned long _Fract}
1205 @item @samp{ullr} or @samp{ULLR} for @code{unsigned long long _Fract}
1206 and @code{_Sat unsigned long long _Fract}
1207 @item @samp{hk} or @samp{HK} for @code{short _Accum} and
1208 @code{_Sat short _Accum}
1209 @item @samp{k} or @samp{K} for @code{_Accum} and @code{_Sat _Accum}
1210 @item @samp{lk} or @samp{LK} for @code{long _Accum} and
1211 @code{_Sat long _Accum}
1212 @item @samp{llk} or @samp{LLK} for @code{long long _Accum} and
1213 @code{_Sat long long _Accum}
1214 @item @samp{uhk} or @samp{UHK} for @code{unsigned short _Accum} and
1215 @code{_Sat unsigned short _Accum}
1216 @item @samp{uk} or @samp{UK} for @code{unsigned _Accum} and
1217 @code{_Sat unsigned _Accum}
1218 @item @samp{ulk} or @samp{ULK} for @code{unsigned long _Accum} and
1219 @code{_Sat unsigned long _Accum}
1220 @item @samp{ullk} or @samp{ULLK} for @code{unsigned long long _Accum}
1221 and @code{_Sat unsigned long long _Accum}
1224 GCC support of fixed-point types as specified by the draft technical report
1229 Pragmas to control overflow and rounding behaviors are not implemented.
1232 Fixed-point types are supported by the DWARF 2 debug information format.
1234 @node Named Address Spaces
1235 @section Named Address Spaces
1236 @cindex Named Address Spaces
1238 As an extension, GNU C supports named address spaces as
1239 defined in the N1275 draft of ISO/IEC DTR 18037. Support for named
1240 address spaces in GCC will evolve as the draft technical report
1241 changes. Calling conventions for any target might also change. At
1242 present, only the AVR, SPU, M32C, and RL78 targets support address
1243 spaces other than the generic address space.
1245 Address space identifiers may be used exactly like any other C type
1246 qualifier (e.g., @code{const} or @code{volatile}). See the N1275
1247 document for more details.
1249 @anchor{AVR Named Address Spaces}
1250 @subsection AVR Named Address Spaces
1252 On the AVR target, there are several address spaces that can be used
1253 in order to put read-only data into the flash memory and access that
1254 data by means of the special instructions @code{LPM} or @code{ELPM}
1255 needed to read from flash.
1257 Per default, any data including read-only data is located in RAM
1258 (the generic address space) so that non-generic address spaces are
1259 needed to locate read-only data in flash memory
1260 @emph{and} to generate the right instructions to access this data
1261 without using (inline) assembler code.
1265 @cindex @code{__flash} AVR Named Address Spaces
1266 The @code{__flash} qualifier locates data in the
1267 @code{.progmem.data} section. Data is read using the @code{LPM}
1268 instruction. Pointers to this address space are 16 bits wide.
1275 @cindex @code{__flash1} AVR Named Address Spaces
1276 @cindex @code{__flash2} AVR Named Address Spaces
1277 @cindex @code{__flash3} AVR Named Address Spaces
1278 @cindex @code{__flash4} AVR Named Address Spaces
1279 @cindex @code{__flash5} AVR Named Address Spaces
1280 These are 16-bit address spaces locating data in section
1281 @code{.progmem@var{N}.data} where @var{N} refers to
1282 address space @code{__flash@var{N}}.
1283 The compiler sets the @code{RAMPZ} segment register appropriately
1284 before reading data by means of the @code{ELPM} instruction.
1287 @cindex @code{__memx} AVR Named Address Spaces
1288 This is a 24-bit address space that linearizes flash and RAM:
1289 If the high bit of the address is set, data is read from
1290 RAM using the lower two bytes as RAM address.
1291 If the high bit of the address is clear, data is read from flash
1292 with @code{RAMPZ} set according to the high byte of the address.
1293 @xref{AVR Built-in Functions,,@code{__builtin_avr_flash_segment}}.
1295 Objects in this address space are located in @code{.progmemx.data}.
1301 char my_read (const __flash char ** p)
1303 /* p is a pointer to RAM that points to a pointer to flash.
1304 The first indirection of p reads that flash pointer
1305 from RAM and the second indirection reads a char from this
1311 /* Locate array[] in flash memory */
1312 const __flash int array[] = @{ 3, 5, 7, 11, 13, 17, 19 @};
1318 /* Return 17 by reading from flash memory */
1319 return array[array[i]];
1324 For each named address space supported by avr-gcc there is an equally
1325 named but uppercase built-in macro defined.
1326 The purpose is to facilitate testing if respective address space
1327 support is available or not:
1331 const __flash int var = 1;
1338 #include <avr/pgmspace.h> /* From AVR-LibC */
1340 const int var PROGMEM = 1;
1344 return (int) pgm_read_word (&var);
1346 #endif /* __FLASH */
1350 Notice that attribute @ref{AVR Variable Attributes,,@code{progmem}}
1351 locates data in flash but
1352 accesses to these data read from generic address space, i.e.@:
1354 so that you need special accessors like @code{pgm_read_byte}
1355 from @w{@uref{http://nongnu.org/avr-libc/user-manual/,AVR-LibC}}
1356 together with attribute @code{progmem}.
1359 @b{Limitations and caveats}
1363 Reading across the 64@tie{}KiB section boundary of
1364 the @code{__flash} or @code{__flash@var{N}} address spaces
1365 shows undefined behavior. The only address space that
1366 supports reading across the 64@tie{}KiB flash segment boundaries is
1370 If you use one of the @code{__flash@var{N}} address spaces
1371 you must arrange your linker script to locate the
1372 @code{.progmem@var{N}.data} sections according to your needs.
1375 Any data or pointers to the non-generic address spaces must
1376 be qualified as @code{const}, i.e.@: as read-only data.
1377 This still applies if the data in one of these address
1378 spaces like software version number or calibration lookup table are intended to
1379 be changed after load time by, say, a boot loader. In this case
1380 the right qualification is @code{const} @code{volatile} so that the compiler
1381 must not optimize away known values or insert them
1382 as immediates into operands of instructions.
1385 The following code initializes a variable @code{pfoo}
1386 located in static storage with a 24-bit address:
1388 extern const __memx char foo;
1389 const __memx void *pfoo = &foo;
1393 Such code requires at least binutils 2.23, see
1394 @w{@uref{http://sourceware.org/PR13503,PR13503}}.
1398 @subsection M32C Named Address Spaces
1399 @cindex @code{__far} M32C Named Address Spaces
1401 On the M32C target, with the R8C and M16C CPU variants, variables
1402 qualified with @code{__far} are accessed using 32-bit addresses in
1403 order to access memory beyond the first 64@tie{}Ki bytes. If
1404 @code{__far} is used with the M32CM or M32C CPU variants, it has no
1407 @subsection RL78 Named Address Spaces
1408 @cindex @code{__far} RL78 Named Address Spaces
1410 On the RL78 target, variables qualified with @code{__far} are accessed
1411 with 32-bit pointers (20-bit addresses) rather than the default 16-bit
1412 addresses. Non-far variables are assumed to appear in the topmost
1413 64@tie{}KiB of the address space.
1415 @subsection SPU Named Address Spaces
1416 @cindex @code{__ea} SPU Named Address Spaces
1418 On the SPU target variables may be declared as
1419 belonging to another address space by qualifying the type with the
1420 @code{__ea} address space identifier:
1427 The compiler generates special code to access the variable @code{i}.
1428 It may use runtime library
1429 support, or generate special machine instructions to access that address
1433 @section Arrays of Length Zero
1434 @cindex arrays of length zero
1435 @cindex zero-length arrays
1436 @cindex length-zero arrays
1437 @cindex flexible array members
1439 Zero-length arrays are allowed in GNU C@. They are very useful as the
1440 last element of a structure that is really a header for a variable-length
1449 struct line *thisline = (struct line *)
1450 malloc (sizeof (struct line) + this_length);
1451 thisline->length = this_length;
1454 In ISO C90, you would have to give @code{contents} a length of 1, which
1455 means either you waste space or complicate the argument to @code{malloc}.
1457 In ISO C99, you would use a @dfn{flexible array member}, which is
1458 slightly different in syntax and semantics:
1462 Flexible array members are written as @code{contents[]} without
1466 Flexible array members have incomplete type, and so the @code{sizeof}
1467 operator may not be applied. As a quirk of the original implementation
1468 of zero-length arrays, @code{sizeof} evaluates to zero.
1471 Flexible array members may only appear as the last member of a
1472 @code{struct} that is otherwise non-empty.
1475 A structure containing a flexible array member, or a union containing
1476 such a structure (possibly recursively), may not be a member of a
1477 structure or an element of an array. (However, these uses are
1478 permitted by GCC as extensions.)
1481 Non-empty initialization of zero-length
1482 arrays is treated like any case where there are more initializer
1483 elements than the array holds, in that a suitable warning about ``excess
1484 elements in array'' is given, and the excess elements (all of them, in
1485 this case) are ignored.
1487 GCC allows static initialization of flexible array members.
1488 This is equivalent to defining a new structure containing the original
1489 structure followed by an array of sufficient size to contain the data.
1490 E.g.@: in the following, @code{f1} is constructed as if it were declared
1496 @} f1 = @{ 1, @{ 2, 3, 4 @} @};
1499 struct f1 f1; int data[3];
1500 @} f2 = @{ @{ 1 @}, @{ 2, 3, 4 @} @};
1504 The convenience of this extension is that @code{f1} has the desired
1505 type, eliminating the need to consistently refer to @code{f2.f1}.
1507 This has symmetry with normal static arrays, in that an array of
1508 unknown size is also written with @code{[]}.
1510 Of course, this extension only makes sense if the extra data comes at
1511 the end of a top-level object, as otherwise we would be overwriting
1512 data at subsequent offsets. To avoid undue complication and confusion
1513 with initialization of deeply nested arrays, we simply disallow any
1514 non-empty initialization except when the structure is the top-level
1515 object. For example:
1518 struct foo @{ int x; int y[]; @};
1519 struct bar @{ struct foo z; @};
1521 struct foo a = @{ 1, @{ 2, 3, 4 @} @}; // @r{Valid.}
1522 struct bar b = @{ @{ 1, @{ 2, 3, 4 @} @} @}; // @r{Invalid.}
1523 struct bar c = @{ @{ 1, @{ @} @} @}; // @r{Valid.}
1524 struct foo d[1] = @{ @{ 1, @{ 2, 3, 4 @} @} @}; // @r{Invalid.}
1527 @node Empty Structures
1528 @section Structures with No Members
1529 @cindex empty structures
1530 @cindex zero-size structures
1532 GCC permits a C structure to have no members:
1539 The structure has size zero. In C++, empty structures are part
1540 of the language. G++ treats empty structures as if they had a single
1541 member of type @code{char}.
1543 @node Variable Length
1544 @section Arrays of Variable Length
1545 @cindex variable-length arrays
1546 @cindex arrays of variable length
1549 Variable-length automatic arrays are allowed in ISO C99, and as an
1550 extension GCC accepts them in C90 mode and in C++. These arrays are
1551 declared like any other automatic arrays, but with a length that is not
1552 a constant expression. The storage is allocated at the point of
1553 declaration and deallocated when the block scope containing the declaration
1559 concat_fopen (char *s1, char *s2, char *mode)
1561 char str[strlen (s1) + strlen (s2) + 1];
1564 return fopen (str, mode);
1568 @cindex scope of a variable length array
1569 @cindex variable-length array scope
1570 @cindex deallocating variable length arrays
1571 Jumping or breaking out of the scope of the array name deallocates the
1572 storage. Jumping into the scope is not allowed; you get an error
1575 @cindex variable-length array in a structure
1576 As an extension, GCC accepts variable-length arrays as a member of
1577 a structure or a union. For example:
1583 struct S @{ int x[n]; @};
1587 @cindex @code{alloca} vs variable-length arrays
1588 You can use the function @code{alloca} to get an effect much like
1589 variable-length arrays. The function @code{alloca} is available in
1590 many other C implementations (but not in all). On the other hand,
1591 variable-length arrays are more elegant.
1593 There are other differences between these two methods. Space allocated
1594 with @code{alloca} exists until the containing @emph{function} returns.
1595 The space for a variable-length array is deallocated as soon as the array
1596 name's scope ends. (If you use both variable-length arrays and
1597 @code{alloca} in the same function, deallocation of a variable-length array
1598 also deallocates anything more recently allocated with @code{alloca}.)
1600 You can also use variable-length arrays as arguments to functions:
1604 tester (int len, char data[len][len])
1610 The length of an array is computed once when the storage is allocated
1611 and is remembered for the scope of the array in case you access it with
1614 If you want to pass the array first and the length afterward, you can
1615 use a forward declaration in the parameter list---another GNU extension.
1619 tester (int len; char data[len][len], int len)
1625 @cindex parameter forward declaration
1626 The @samp{int len} before the semicolon is a @dfn{parameter forward
1627 declaration}, and it serves the purpose of making the name @code{len}
1628 known when the declaration of @code{data} is parsed.
1630 You can write any number of such parameter forward declarations in the
1631 parameter list. They can be separated by commas or semicolons, but the
1632 last one must end with a semicolon, which is followed by the ``real''
1633 parameter declarations. Each forward declaration must match a ``real''
1634 declaration in parameter name and data type. ISO C99 does not support
1635 parameter forward declarations.
1637 @node Variadic Macros
1638 @section Macros with a Variable Number of Arguments.
1639 @cindex variable number of arguments
1640 @cindex macro with variable arguments
1641 @cindex rest argument (in macro)
1642 @cindex variadic macros
1644 In the ISO C standard of 1999, a macro can be declared to accept a
1645 variable number of arguments much as a function can. The syntax for
1646 defining the macro is similar to that of a function. Here is an
1650 #define debug(format, ...) fprintf (stderr, format, __VA_ARGS__)
1654 Here @samp{@dots{}} is a @dfn{variable argument}. In the invocation of
1655 such a macro, it represents the zero or more tokens until the closing
1656 parenthesis that ends the invocation, including any commas. This set of
1657 tokens replaces the identifier @code{__VA_ARGS__} in the macro body
1658 wherever it appears. See the CPP manual for more information.
1660 GCC has long supported variadic macros, and used a different syntax that
1661 allowed you to give a name to the variable arguments just like any other
1662 argument. Here is an example:
1665 #define debug(format, args...) fprintf (stderr, format, args)
1669 This is in all ways equivalent to the ISO C example above, but arguably
1670 more readable and descriptive.
1672 GNU CPP has two further variadic macro extensions, and permits them to
1673 be used with either of the above forms of macro definition.
1675 In standard C, you are not allowed to leave the variable argument out
1676 entirely; but you are allowed to pass an empty argument. For example,
1677 this invocation is invalid in ISO C, because there is no comma after
1684 GNU CPP permits you to completely omit the variable arguments in this
1685 way. In the above examples, the compiler would complain, though since
1686 the expansion of the macro still has the extra comma after the format
1689 To help solve this problem, CPP behaves specially for variable arguments
1690 used with the token paste operator, @samp{##}. If instead you write
1693 #define debug(format, ...) fprintf (stderr, format, ## __VA_ARGS__)
1697 and if the variable arguments are omitted or empty, the @samp{##}
1698 operator causes the preprocessor to remove the comma before it. If you
1699 do provide some variable arguments in your macro invocation, GNU CPP
1700 does not complain about the paste operation and instead places the
1701 variable arguments after the comma. Just like any other pasted macro
1702 argument, these arguments are not macro expanded.
1704 @node Escaped Newlines
1705 @section Slightly Looser Rules for Escaped Newlines
1706 @cindex escaped newlines
1707 @cindex newlines (escaped)
1709 The preprocessor treatment of escaped newlines is more relaxed
1710 than that specified by the C90 standard, which requires the newline
1711 to immediately follow a backslash.
1712 GCC's implementation allows whitespace in the form
1713 of spaces, horizontal and vertical tabs, and form feeds between the
1714 backslash and the subsequent newline. The preprocessor issues a
1715 warning, but treats it as a valid escaped newline and combines the two
1716 lines to form a single logical line. This works within comments and
1717 tokens, as well as between tokens. Comments are @emph{not} treated as
1718 whitespace for the purposes of this relaxation, since they have not
1719 yet been replaced with spaces.
1722 @section Non-Lvalue Arrays May Have Subscripts
1723 @cindex subscripting
1724 @cindex arrays, non-lvalue
1726 @cindex subscripting and function values
1727 In ISO C99, arrays that are not lvalues still decay to pointers, and
1728 may be subscripted, although they may not be modified or used after
1729 the next sequence point and the unary @samp{&} operator may not be
1730 applied to them. As an extension, GNU C allows such arrays to be
1731 subscripted in C90 mode, though otherwise they do not decay to
1732 pointers outside C99 mode. For example,
1733 this is valid in GNU C though not valid in C90:
1737 struct foo @{int a[4];@};
1743 return f().a[index];
1749 @section Arithmetic on @code{void}- and Function-Pointers
1750 @cindex void pointers, arithmetic
1751 @cindex void, size of pointer to
1752 @cindex function pointers, arithmetic
1753 @cindex function, size of pointer to
1755 In GNU C, addition and subtraction operations are supported on pointers to
1756 @code{void} and on pointers to functions. This is done by treating the
1757 size of a @code{void} or of a function as 1.
1759 A consequence of this is that @code{sizeof} is also allowed on @code{void}
1760 and on function types, and returns 1.
1762 @opindex Wpointer-arith
1763 The option @option{-Wpointer-arith} requests a warning if these extensions
1766 @node Pointers to Arrays
1767 @section Pointers to Arrays with Qualifiers Work as Expected
1768 @cindex pointers to arrays
1769 @cindex const qualifier
1771 In GNU C, pointers to arrays with qualifiers work similar to pointers
1772 to other qualified types. For example, a value of type @code{int (*)[5]}
1773 can be used to initialize a variable of type @code{const int (*)[5]}.
1774 These types are incompatible in ISO C because the @code{const} qualifier
1775 is formally attached to the element type of the array and not the
1780 transpose (int N, int M, double out[M][N], const double in[N][M]);
1784 transpose(3, 2, y, x);
1788 @section Non-Constant Initializers
1789 @cindex initializers, non-constant
1790 @cindex non-constant initializers
1792 As in standard C++ and ISO C99, the elements of an aggregate initializer for an
1793 automatic variable are not required to be constant expressions in GNU C@.
1794 Here is an example of an initializer with run-time varying elements:
1797 foo (float f, float g)
1799 float beat_freqs[2] = @{ f-g, f+g @};
1804 @node Compound Literals
1805 @section Compound Literals
1806 @cindex constructor expressions
1807 @cindex initializations in expressions
1808 @cindex structures, constructor expression
1809 @cindex expressions, constructor
1810 @cindex compound literals
1811 @c The GNU C name for what C99 calls compound literals was "constructor expressions".
1813 ISO C99 supports compound literals. A compound literal looks like
1814 a cast containing an initializer. Its value is an object of the
1815 type specified in the cast, containing the elements specified in
1816 the initializer; it is an lvalue. As an extension, GCC supports
1817 compound literals in C90 mode and in C++, though the semantics are
1818 somewhat different in C++.
1820 Usually, the specified type is a structure. Assume that
1821 @code{struct foo} and @code{structure} are declared as shown:
1824 struct foo @{int a; char b[2];@} structure;
1828 Here is an example of constructing a @code{struct foo} with a compound literal:
1831 structure = ((struct foo) @{x + y, 'a', 0@});
1835 This is equivalent to writing the following:
1839 struct foo temp = @{x + y, 'a', 0@};
1844 You can also construct an array, though this is dangerous in C++, as
1845 explained below. If all the elements of the compound literal are
1846 (made up of) simple constant expressions, suitable for use in
1847 initializers of objects of static storage duration, then the compound
1848 literal can be coerced to a pointer to its first element and used in
1849 such an initializer, as shown here:
1852 char **foo = (char *[]) @{ "x", "y", "z" @};
1855 Compound literals for scalar types and union types are
1856 also allowed, but then the compound literal is equivalent
1859 As a GNU extension, GCC allows initialization of objects with static storage
1860 duration by compound literals (which is not possible in ISO C99, because
1861 the initializer is not a constant).
1862 It is handled as if the object is initialized only with the bracket
1863 enclosed list if the types of the compound literal and the object match.
1864 The initializer list of the compound literal must be constant.
1865 If the object being initialized has array type of unknown size, the size is
1866 determined by compound literal size.
1869 static struct foo x = (struct foo) @{1, 'a', 'b'@};
1870 static int y[] = (int []) @{1, 2, 3@};
1871 static int z[] = (int [3]) @{1@};
1875 The above lines are equivalent to the following:
1877 static struct foo x = @{1, 'a', 'b'@};
1878 static int y[] = @{1, 2, 3@};
1879 static int z[] = @{1, 0, 0@};
1882 In C, a compound literal designates an unnamed object with static or
1883 automatic storage duration. In C++, a compound literal designates a
1884 temporary object, which only lives until the end of its
1885 full-expression. As a result, well-defined C code that takes the
1886 address of a subobject of a compound literal can be undefined in C++,
1887 so the C++ compiler rejects the conversion of a temporary array to a pointer.
1888 For instance, if the array compound literal example above appeared
1889 inside a function, any subsequent use of @samp{foo} in C++ has
1890 undefined behavior because the lifetime of the array ends after the
1891 declaration of @samp{foo}.
1893 As an optimization, the C++ compiler sometimes gives array compound
1894 literals longer lifetimes: when the array either appears outside a
1895 function or has const-qualified type. If @samp{foo} and its
1896 initializer had elements of @samp{char *const} type rather than
1897 @samp{char *}, or if @samp{foo} were a global variable, the array
1898 would have static storage duration. But it is probably safest just to
1899 avoid the use of array compound literals in code compiled as C++.
1901 @node Designated Inits
1902 @section Designated Initializers
1903 @cindex initializers with labeled elements
1904 @cindex labeled elements in initializers
1905 @cindex case labels in initializers
1906 @cindex designated initializers
1908 Standard C90 requires the elements of an initializer to appear in a fixed
1909 order, the same as the order of the elements in the array or structure
1912 In ISO C99 you can give the elements in any order, specifying the array
1913 indices or structure field names they apply to, and GNU C allows this as
1914 an extension in C90 mode as well. This extension is not
1915 implemented in GNU C++.
1917 To specify an array index, write
1918 @samp{[@var{index}] =} before the element value. For example,
1921 int a[6] = @{ [4] = 29, [2] = 15 @};
1928 int a[6] = @{ 0, 0, 15, 0, 29, 0 @};
1932 The index values must be constant expressions, even if the array being
1933 initialized is automatic.
1935 An alternative syntax for this that has been obsolete since GCC 2.5 but
1936 GCC still accepts is to write @samp{[@var{index}]} before the element
1937 value, with no @samp{=}.
1939 To initialize a range of elements to the same value, write
1940 @samp{[@var{first} ... @var{last}] = @var{value}}. This is a GNU
1941 extension. For example,
1944 int widths[] = @{ [0 ... 9] = 1, [10 ... 99] = 2, [100] = 3 @};
1948 If the value in it has side-effects, the side-effects happen only once,
1949 not for each initialized field by the range initializer.
1952 Note that the length of the array is the highest value specified
1955 In a structure initializer, specify the name of a field to initialize
1956 with @samp{.@var{fieldname} =} before the element value. For example,
1957 given the following structure,
1960 struct point @{ int x, y; @};
1964 the following initialization
1967 struct point p = @{ .y = yvalue, .x = xvalue @};
1974 struct point p = @{ xvalue, yvalue @};
1977 Another syntax that has the same meaning, obsolete since GCC 2.5, is
1978 @samp{@var{fieldname}:}, as shown here:
1981 struct point p = @{ y: yvalue, x: xvalue @};
1984 Omitted field members are implicitly initialized the same as objects
1985 that have static storage duration.
1988 The @samp{[@var{index}]} or @samp{.@var{fieldname}} is known as a
1989 @dfn{designator}. You can also use a designator (or the obsolete colon
1990 syntax) when initializing a union, to specify which element of the union
1991 should be used. For example,
1994 union foo @{ int i; double d; @};
1996 union foo f = @{ .d = 4 @};
2000 converts 4 to a @code{double} to store it in the union using
2001 the second element. By contrast, casting 4 to type @code{union foo}
2002 stores it into the union as the integer @code{i}, since it is
2003 an integer. (@xref{Cast to Union}.)
2005 You can combine this technique of naming elements with ordinary C
2006 initialization of successive elements. Each initializer element that
2007 does not have a designator applies to the next consecutive element of the
2008 array or structure. For example,
2011 int a[6] = @{ [1] = v1, v2, [4] = v4 @};
2018 int a[6] = @{ 0, v1, v2, 0, v4, 0 @};
2021 Labeling the elements of an array initializer is especially useful
2022 when the indices are characters or belong to an @code{enum} type.
2027 = @{ [' '] = 1, ['\t'] = 1, ['\h'] = 1,
2028 ['\f'] = 1, ['\n'] = 1, ['\r'] = 1 @};
2031 @cindex designator lists
2032 You can also write a series of @samp{.@var{fieldname}} and
2033 @samp{[@var{index}]} designators before an @samp{=} to specify a
2034 nested subobject to initialize; the list is taken relative to the
2035 subobject corresponding to the closest surrounding brace pair. For
2036 example, with the @samp{struct point} declaration above:
2039 struct point ptarray[10] = @{ [2].y = yv2, [2].x = xv2, [0].x = xv0 @};
2043 If the same field is initialized multiple times, it has the value from
2044 the last initialization. If any such overridden initialization has
2045 side-effect, it is unspecified whether the side-effect happens or not.
2046 Currently, GCC discards them and issues a warning.
2049 @section Case Ranges
2051 @cindex ranges in case statements
2053 You can specify a range of consecutive values in a single @code{case} label,
2057 case @var{low} ... @var{high}:
2061 This has the same effect as the proper number of individual @code{case}
2062 labels, one for each integer value from @var{low} to @var{high}, inclusive.
2064 This feature is especially useful for ranges of ASCII character codes:
2070 @strong{Be careful:} Write spaces around the @code{...}, for otherwise
2071 it may be parsed wrong when you use it with integer values. For example,
2086 @section Cast to a Union Type
2087 @cindex cast to a union
2088 @cindex union, casting to a
2090 A cast to union type is similar to other casts, except that the type
2091 specified is a union type. You can specify the type either with
2092 @code{union @var{tag}} or with a typedef name. A cast to union is actually
2093 a constructor, not a cast, and hence does not yield an lvalue like
2094 normal casts. (@xref{Compound Literals}.)
2096 The types that may be cast to the union type are those of the members
2097 of the union. Thus, given the following union and variables:
2100 union foo @{ int i; double d; @};
2106 both @code{x} and @code{y} can be cast to type @code{union foo}.
2108 Using the cast as the right-hand side of an assignment to a variable of
2109 union type is equivalent to storing in a member of the union:
2114 u = (union foo) x @equiv{} u.i = x
2115 u = (union foo) y @equiv{} u.d = y
2118 You can also use the union cast as a function argument:
2121 void hack (union foo);
2123 hack ((union foo) x);
2126 @node Mixed Declarations
2127 @section Mixed Declarations and Code
2128 @cindex mixed declarations and code
2129 @cindex declarations, mixed with code
2130 @cindex code, mixed with declarations
2132 ISO C99 and ISO C++ allow declarations and code to be freely mixed
2133 within compound statements. As an extension, GNU C also allows this in
2134 C90 mode. For example, you could do:
2143 Each identifier is visible from where it is declared until the end of
2144 the enclosing block.
2146 @node Function Attributes
2147 @section Declaring Attributes of Functions
2148 @cindex function attributes
2149 @cindex declaring attributes of functions
2150 @cindex functions that never return
2151 @cindex functions that return more than once
2152 @cindex functions that have no side effects
2153 @cindex functions in arbitrary sections
2154 @cindex functions that behave like malloc
2155 @cindex @code{volatile} applied to function
2156 @cindex @code{const} applied to function
2157 @cindex functions with @code{printf}, @code{scanf}, @code{strftime} or @code{strfmon} style arguments
2158 @cindex functions with non-null pointer arguments
2159 @cindex functions that are passed arguments in registers on x86-32
2160 @cindex functions that pop the argument stack on x86-32
2161 @cindex functions that do not pop the argument stack on x86-32
2162 @cindex functions that have different compilation options on x86-32
2163 @cindex functions that have different optimization options
2164 @cindex functions that are dynamically resolved
2166 In GNU C, you declare certain things about functions called in your program
2167 which help the compiler optimize function calls and check your code more
2170 The keyword @code{__attribute__} allows you to specify special
2171 attributes when making a declaration. This keyword is followed by an
2172 attribute specification inside double parentheses. The following
2173 attributes are currently defined for functions on all targets:
2174 @code{aligned}, @code{alloc_size}, @code{alloc_align}, @code{assume_aligned},
2175 @code{noreturn}, @code{returns_twice}, @code{noinline}, @code{noclone},
2177 @code{always_inline}, @code{flatten}, @code{pure}, @code{const},
2178 @code{nothrow}, @code{sentinel}, @code{format}, @code{format_arg},
2179 @code{no_instrument_function}, @code{no_split_stack},
2180 @code{section}, @code{constructor},
2181 @code{destructor}, @code{used}, @code{unused}, @code{deprecated},
2182 @code{weak}, @code{malloc}, @code{alias}, @code{ifunc},
2183 @code{warn_unused_result}, @code{nonnull},
2184 @code{returns_nonnull}, @code{gnu_inline},
2185 @code{externally_visible}, @code{hot}, @code{cold}, @code{artificial},
2186 @code{no_sanitize_address}, @code{no_address_safety_analysis},
2187 @code{no_sanitize_thread},
2188 @code{no_sanitize_undefined}, @code{no_reorder}, @code{bnd_legacy},
2189 @code{bnd_instrument}, @code{stack_protect},
2190 @code{error} and @code{warning}.
2191 Several other attributes are defined for functions on particular
2192 target systems. Other attributes, including @code{section} are
2193 supported for variables declarations (@pxref{Variable Attributes}),
2194 labels (@pxref{Label Attributes})
2195 and for types (@pxref{Type Attributes}).
2197 GCC plugins may provide their own attributes.
2199 You may also specify attributes with @samp{__} preceding and following
2200 each keyword. This allows you to use them in header files without
2201 being concerned about a possible macro of the same name. For example,
2202 you may use @code{__noreturn__} instead of @code{noreturn}.
2204 @xref{Attribute Syntax}, for details of the exact syntax for using
2208 @c Keep this table alphabetized by attribute name. Treat _ as space.
2210 @item alias ("@var{target}")
2211 @cindex @code{alias} attribute
2212 The @code{alias} attribute causes the declaration to be emitted as an
2213 alias for another symbol, which must be specified. For instance,
2216 void __f () @{ /* @r{Do something.} */; @}
2217 void f () __attribute__ ((weak, alias ("__f")));
2221 defines @samp{f} to be a weak alias for @samp{__f}. In C++, the
2222 mangled name for the target must be used. It is an error if @samp{__f}
2223 is not defined in the same translation unit.
2225 Not all target machines support this attribute.
2227 @item aligned (@var{alignment})
2228 @cindex @code{aligned} attribute
2229 This attribute specifies a minimum alignment for the function,
2232 You cannot use this attribute to decrease the alignment of a function,
2233 only to increase it. However, when you explicitly specify a function
2234 alignment this overrides the effect of the
2235 @option{-falign-functions} (@pxref{Optimize Options}) option for this
2238 Note that the effectiveness of @code{aligned} attributes may be
2239 limited by inherent limitations in your linker. On many systems, the
2240 linker is only able to arrange for functions to be aligned up to a
2241 certain maximum alignment. (For some linkers, the maximum supported
2242 alignment may be very very small.) See your linker documentation for
2243 further information.
2245 The @code{aligned} attribute can also be used for variables and fields
2246 (@pxref{Variable Attributes}.)
2249 @cindex @code{alloc_size} attribute
2250 The @code{alloc_size} attribute is used to tell the compiler that the
2251 function return value points to memory, where the size is given by
2252 one or two of the functions parameters. GCC uses this
2253 information to improve the correctness of @code{__builtin_object_size}.
2255 The function parameter(s) denoting the allocated size are specified by
2256 one or two integer arguments supplied to the attribute. The allocated size
2257 is either the value of the single function argument specified or the product
2258 of the two function arguments specified. Argument numbering starts at
2264 void* my_calloc(size_t, size_t) __attribute__((alloc_size(1,2)))
2265 void* my_realloc(void*, size_t) __attribute__((alloc_size(2)))
2269 declares that @code{my_calloc} returns memory of the size given by
2270 the product of parameter 1 and 2 and that @code{my_realloc} returns memory
2271 of the size given by parameter 2.
2274 @cindex @code{alloc_align} attribute
2275 The @code{alloc_align} attribute is used to tell the compiler that the
2276 function return value points to memory, where the returned pointer minimum
2277 alignment is given by one of the functions parameters. GCC uses this
2278 information to improve pointer alignment analysis.
2280 The function parameter denoting the allocated alignment is specified by
2281 one integer argument, whose number is the argument of the attribute.
2282 Argument numbering starts at one.
2287 void* my_memalign(size_t, size_t) __attribute__((alloc_align(1)))
2291 declares that @code{my_memalign} returns memory with minimum alignment
2292 given by parameter 1.
2294 @item assume_aligned
2295 @cindex @code{assume_aligned} attribute
2296 The @code{assume_aligned} attribute is used to tell the compiler that the
2297 function return value points to memory, where the returned pointer minimum
2298 alignment is given by the first argument.
2299 If the attribute has two arguments, the second argument is misalignment offset.
2304 void* my_alloc1(size_t) __attribute__((assume_aligned(16)))
2305 void* my_alloc2(size_t) __attribute__((assume_aligned(32, 8)))
2309 declares that @code{my_alloc1} returns 16-byte aligned pointer and
2310 that @code{my_alloc2} returns a pointer whose value modulo 32 is equal
2314 @cindex @code{always_inline} function attribute
2315 Generally, functions are not inlined unless optimization is specified.
2316 For functions declared inline, this attribute inlines the function
2317 independent of any restrictions that otherwise apply to inlining.
2318 Failure to inline such a function is diagnosed as an error.
2319 Note that if such a function is called indirectly the compiler may
2320 or may not inline it depending on optimization level and a failure
2321 to inline an indirect call may or may not be diagnosed.
2324 @cindex @code{gnu_inline} function attribute
2325 This attribute should be used with a function that is also declared
2326 with the @code{inline} keyword. It directs GCC to treat the function
2327 as if it were defined in gnu90 mode even when compiling in C99 or
2330 If the function is declared @code{extern}, then this definition of the
2331 function is used only for inlining. In no case is the function
2332 compiled as a standalone function, not even if you take its address
2333 explicitly. Such an address becomes an external reference, as if you
2334 had only declared the function, and had not defined it. This has
2335 almost the effect of a macro. The way to use this is to put a
2336 function definition in a header file with this attribute, and put
2337 another copy of the function, without @code{extern}, in a library
2338 file. The definition in the header file causes most calls to the
2339 function to be inlined. If any uses of the function remain, they
2340 refer to the single copy in the library. Note that the two
2341 definitions of the functions need not be precisely the same, although
2342 if they do not have the same effect your program may behave oddly.
2344 In C, if the function is neither @code{extern} nor @code{static}, then
2345 the function is compiled as a standalone function, as well as being
2346 inlined where possible.
2348 This is how GCC traditionally handled functions declared
2349 @code{inline}. Since ISO C99 specifies a different semantics for
2350 @code{inline}, this function attribute is provided as a transition
2351 measure and as a useful feature in its own right. This attribute is
2352 available in GCC 4.1.3 and later. It is available if either of the
2353 preprocessor macros @code{__GNUC_GNU_INLINE__} or
2354 @code{__GNUC_STDC_INLINE__} are defined. @xref{Inline,,An Inline
2355 Function is As Fast As a Macro}.
2357 In C++, this attribute does not depend on @code{extern} in any way,
2358 but it still requires the @code{inline} keyword to enable its special
2362 @cindex @code{artificial} function attribute
2363 This attribute is useful for small inline wrappers that if possible
2364 should appear during debugging as a unit. Depending on the debug
2365 info format it either means marking the function as artificial
2366 or using the caller location for all instructions within the inlined
2370 @cindex interrupt handler functions
2371 When added to an interrupt handler with the M32C port, causes the
2372 prologue and epilogue to use bank switching to preserve the registers
2373 rather than saving them on the stack.
2376 @cindex @code{flatten} function attribute
2377 Generally, inlining into a function is limited. For a function marked with
2378 this attribute, every call inside this function is inlined, if possible.
2379 Whether the function itself is considered for inlining depends on its size and
2380 the current inlining parameters.
2382 @item error ("@var{message}")
2383 @cindex @code{error} function attribute
2384 If this attribute is used on a function declaration and a call to such a function
2385 is not eliminated through dead code elimination or other optimizations, an error
2386 that includes @var{message} is diagnosed. This is useful
2387 for compile-time checking, especially together with @code{__builtin_constant_p}
2388 and inline functions where checking the inline function arguments is not
2389 possible through @code{extern char [(condition) ? 1 : -1];} tricks.
2390 While it is possible to leave the function undefined and thus invoke
2391 a link failure, when using this attribute the problem is diagnosed
2392 earlier and with exact location of the call even in presence of inline
2393 functions or when not emitting debugging information.
2395 @item warning ("@var{message}")
2396 @cindex @code{warning} function attribute
2397 If this attribute is used on a function declaration and a call to such a function
2398 is not eliminated through dead code elimination or other optimizations, a warning
2399 that includes @var{message} is diagnosed. This is useful
2400 for compile-time checking, especially together with @code{__builtin_constant_p}
2401 and inline functions. While it is possible to define the function with
2402 a message in @code{.gnu.warning*} section, when using this attribute the problem
2403 is diagnosed earlier and with exact location of the call even in presence
2404 of inline functions or when not emitting debugging information.
2407 @cindex functions that do pop the argument stack on x86-32
2409 On the x86-32 targets, the @code{cdecl} attribute causes the compiler to
2410 assume that the calling function pops off the stack space used to
2411 pass arguments. This is
2412 useful to override the effects of the @option{-mrtd} switch.
2415 @cindex @code{const} function attribute
2416 Many functions do not examine any values except their arguments, and
2417 have no effects except the return value. Basically this is just slightly
2418 more strict class than the @code{pure} attribute below, since function is not
2419 allowed to read global memory.
2421 @cindex pointer arguments
2422 Note that a function that has pointer arguments and examines the data
2423 pointed to must @emph{not} be declared @code{const}. Likewise, a
2424 function that calls a non-@code{const} function usually must not be
2425 @code{const}. It does not make sense for a @code{const} function to
2430 @itemx constructor (@var{priority})
2431 @itemx destructor (@var{priority})
2432 @cindex @code{constructor} function attribute
2433 @cindex @code{destructor} function attribute
2434 The @code{constructor} attribute causes the function to be called
2435 automatically before execution enters @code{main ()}. Similarly, the
2436 @code{destructor} attribute causes the function to be called
2437 automatically after @code{main ()} completes or @code{exit ()} is
2438 called. Functions with these attributes are useful for
2439 initializing data that is used implicitly during the execution of
2442 You may provide an optional integer priority to control the order in
2443 which constructor and destructor functions are run. A constructor
2444 with a smaller priority number runs before a constructor with a larger
2445 priority number; the opposite relationship holds for destructors. So,
2446 if you have a constructor that allocates a resource and a destructor
2447 that deallocates the same resource, both functions typically have the
2448 same priority. The priorities for constructor and destructor
2449 functions are the same as those specified for namespace-scope C++
2450 objects (@pxref{C++ Attributes}).
2452 These attributes are not currently implemented for Objective-C@.
2455 @itemx deprecated (@var{msg})
2456 @cindex @code{deprecated} attribute.
2457 The @code{deprecated} attribute results in a warning if the function
2458 is used anywhere in the source file. This is useful when identifying
2459 functions that are expected to be removed in a future version of a
2460 program. The warning also includes the location of the declaration
2461 of the deprecated function, to enable users to easily find further
2462 information about why the function is deprecated, or what they should
2463 do instead. Note that the warnings only occurs for uses:
2466 int old_fn () __attribute__ ((deprecated));
2468 int (*fn_ptr)() = old_fn;
2472 results in a warning on line 3 but not line 2. The optional @var{msg}
2473 argument, which must be a string, is printed in the warning if
2476 The @code{deprecated} attribute can also be used for variables and
2477 types (@pxref{Variable Attributes}, @pxref{Type Attributes}.)
2480 @cindex @code{disinterrupt} attribute
2481 On Epiphany and MeP targets, this attribute causes the compiler to emit
2482 instructions to disable interrupts for the duration of the given
2486 @cindex @code{__declspec(dllexport)}
2487 On Microsoft Windows targets and Symbian OS targets the
2488 @code{dllexport} attribute causes the compiler to provide a global
2489 pointer to a pointer in a DLL, so that it can be referenced with the
2490 @code{dllimport} attribute. On Microsoft Windows targets, the pointer
2491 name is formed by combining @code{_imp__} and the function or variable
2494 You can use @code{__declspec(dllexport)} as a synonym for
2495 @code{__attribute__ ((dllexport))} for compatibility with other
2498 On systems that support the @code{visibility} attribute, this
2499 attribute also implies ``default'' visibility. It is an error to
2500 explicitly specify any other visibility.
2502 GCC's default behavior is to emit all inline functions with the
2503 @code{dllexport} attribute. Since this can cause object file-size bloat,
2504 you can use @option{-fno-keep-inline-dllexport}, which tells GCC to
2505 ignore the attribute for inlined functions unless the
2506 @option{-fkeep-inline-functions} flag is used instead.
2508 The attribute is ignored for undefined symbols.
2510 When applied to C++ classes, the attribute marks defined non-inlined
2511 member functions and static data members as exports. Static consts
2512 initialized in-class are not marked unless they are also defined
2515 For Microsoft Windows targets there are alternative methods for
2516 including the symbol in the DLL's export table such as using a
2517 @file{.def} file with an @code{EXPORTS} section or, with GNU ld, using
2518 the @option{--export-all} linker flag.
2521 @cindex @code{__declspec(dllimport)}
2522 On Microsoft Windows and Symbian OS targets, the @code{dllimport}
2523 attribute causes the compiler to reference a function or variable via
2524 a global pointer to a pointer that is set up by the DLL exporting the
2525 symbol. The attribute implies @code{extern}. On Microsoft Windows
2526 targets, the pointer name is formed by combining @code{_imp__} and the
2527 function or variable name.
2529 You can use @code{__declspec(dllimport)} as a synonym for
2530 @code{__attribute__ ((dllimport))} for compatibility with other
2533 On systems that support the @code{visibility} attribute, this
2534 attribute also implies ``default'' visibility. It is an error to
2535 explicitly specify any other visibility.
2537 Currently, the attribute is ignored for inlined functions. If the
2538 attribute is applied to a symbol @emph{definition}, an error is reported.
2539 If a symbol previously declared @code{dllimport} is later defined, the
2540 attribute is ignored in subsequent references, and a warning is emitted.
2541 The attribute is also overridden by a subsequent declaration as
2544 When applied to C++ classes, the attribute marks non-inlined
2545 member functions and static data members as imports. However, the
2546 attribute is ignored for virtual methods to allow creation of vtables
2549 On the SH Symbian OS target the @code{dllimport} attribute also has
2550 another affect---it can cause the vtable and run-time type information
2551 for a class to be exported. This happens when the class has a
2552 dllimported constructor or a non-inline, non-pure virtual function
2553 and, for either of those two conditions, the class also has an inline
2554 constructor or destructor and has a key function that is defined in
2555 the current translation unit.
2557 For Microsoft Windows targets the use of the @code{dllimport}
2558 attribute on functions is not necessary, but provides a small
2559 performance benefit by eliminating a thunk in the DLL@. The use of the
2560 @code{dllimport} attribute on imported variables can be avoided by passing the
2561 @option{--enable-auto-import} switch to the GNU linker. As with
2562 functions, using the attribute for a variable eliminates a thunk in
2565 One drawback to using this attribute is that a pointer to a
2566 @emph{variable} marked as @code{dllimport} cannot be used as a constant
2567 address. However, a pointer to a @emph{function} with the
2568 @code{dllimport} attribute can be used as a constant initializer; in
2569 this case, the address of a stub function in the import lib is
2570 referenced. On Microsoft Windows targets, the attribute can be disabled
2571 for functions by setting the @option{-mnop-fun-dllimport} flag.
2574 @cindex eight-bit data on the H8/300, H8/300H, and H8S
2575 Use this attribute on the H8/300, H8/300H, and H8S to indicate that the specified
2576 variable should be placed into the eight-bit data section.
2577 The compiler generates more efficient code for certain operations
2578 on data in the eight-bit data area. Note the eight-bit data area is limited to
2581 You must use GAS and GLD from GNU binutils version 2.7 or later for
2582 this attribute to work correctly.
2585 @cindex exception handler functions
2586 Use this attribute on the NDS32 target to indicate that the specified function
2587 is an exception handler. The compiler will generate corresponding sections
2588 for use in an exception handler.
2590 @item exception_handler
2591 @cindex exception handler functions on the Blackfin processor
2592 Use this attribute on the Blackfin to indicate that the specified function
2593 is an exception handler. The compiler generates function entry and
2594 exit sequences suitable for use in an exception handler when this
2595 attribute is present.
2597 @item externally_visible
2598 @cindex @code{externally_visible} attribute.
2599 This attribute, attached to a global variable or function, nullifies
2600 the effect of the @option{-fwhole-program} command-line option, so the
2601 object remains visible outside the current compilation unit.
2603 If @option{-fwhole-program} is used together with @option{-flto} and
2604 @command{gold} is used as the linker plugin,
2605 @code{externally_visible} attributes are automatically added to functions
2606 (not variable yet due to a current @command{gold} issue)
2607 that are accessed outside of LTO objects according to resolution file
2608 produced by @command{gold}.
2609 For other linkers that cannot generate resolution file,
2610 explicit @code{externally_visible} attributes are still necessary.
2613 @cindex functions that handle memory bank switching
2614 On 68HC11 and 68HC12 the @code{far} attribute causes the compiler to
2615 use a calling convention that takes care of switching memory banks when
2616 entering and leaving a function. This calling convention is also the
2617 default when using the @option{-mlong-calls} option.
2619 On 68HC12 the compiler uses the @code{call} and @code{rtc} instructions
2620 to call and return from a function.
2622 On 68HC11 the compiler generates a sequence of instructions
2623 to invoke a board-specific routine to switch the memory bank and call the
2624 real function. The board-specific routine simulates a @code{call}.
2625 At the end of a function, it jumps to a board-specific routine
2626 instead of using @code{rts}. The board-specific return routine simulates
2629 On MeP targets this causes the compiler to use a calling convention
2630 that assumes the called function is too far away for the built-in
2633 @item fast_interrupt
2634 @cindex interrupt handler functions
2635 Use this attribute on the M32C and RX ports to indicate that the specified
2636 function is a fast interrupt handler. This is just like the
2637 @code{interrupt} attribute, except that @code{freit} is used to return
2638 instead of @code{reit}.
2641 @cindex functions that pop the argument stack on x86-32
2642 On x86-32 targets, the @code{fastcall} attribute causes the compiler to
2643 pass the first argument (if of integral type) in the register ECX and
2644 the second argument (if of integral type) in the register EDX@. Subsequent
2645 and other typed arguments are passed on the stack. The called function
2646 pops the arguments off the stack. If the number of arguments is variable all
2647 arguments are pushed on the stack.
2650 @cindex functions that pop the argument stack on x86-32
2651 On x86-32 targets, the @code{thiscall} attribute causes the compiler to
2652 pass the first argument (if of integral type) in the register ECX.
2653 Subsequent and other typed arguments are passed on the stack. The called
2654 function pops the arguments off the stack.
2655 If the number of arguments is variable all arguments are pushed on the
2657 The @code{thiscall} attribute is intended for C++ non-static member functions.
2658 As a GCC extension, this calling convention can be used for C functions
2659 and for static member methods.
2661 @item format (@var{archetype}, @var{string-index}, @var{first-to-check})
2662 @cindex @code{format} function attribute
2664 The @code{format} attribute specifies that a function takes @code{printf},
2665 @code{scanf}, @code{strftime} or @code{strfmon} style arguments that
2666 should be type-checked against a format string. For example, the
2671 my_printf (void *my_object, const char *my_format, ...)
2672 __attribute__ ((format (printf, 2, 3)));
2676 causes the compiler to check the arguments in calls to @code{my_printf}
2677 for consistency with the @code{printf} style format string argument
2680 The parameter @var{archetype} determines how the format string is
2681 interpreted, and should be @code{printf}, @code{scanf}, @code{strftime},
2682 @code{gnu_printf}, @code{gnu_scanf}, @code{gnu_strftime} or
2683 @code{strfmon}. (You can also use @code{__printf__},
2684 @code{__scanf__}, @code{__strftime__} or @code{__strfmon__}.) On
2685 MinGW targets, @code{ms_printf}, @code{ms_scanf}, and
2686 @code{ms_strftime} are also present.
2687 @var{archetype} values such as @code{printf} refer to the formats accepted
2688 by the system's C runtime library,
2689 while values prefixed with @samp{gnu_} always refer
2690 to the formats accepted by the GNU C Library. On Microsoft Windows
2691 targets, values prefixed with @samp{ms_} refer to the formats accepted by the
2692 @file{msvcrt.dll} library.
2693 The parameter @var{string-index}
2694 specifies which argument is the format string argument (starting
2695 from 1), while @var{first-to-check} is the number of the first
2696 argument to check against the format string. For functions
2697 where the arguments are not available to be checked (such as
2698 @code{vprintf}), specify the third parameter as zero. In this case the
2699 compiler only checks the format string for consistency. For
2700 @code{strftime} formats, the third parameter is required to be zero.
2701 Since non-static C++ methods have an implicit @code{this} argument, the
2702 arguments of such methods should be counted from two, not one, when
2703 giving values for @var{string-index} and @var{first-to-check}.
2705 In the example above, the format string (@code{my_format}) is the second
2706 argument of the function @code{my_print}, and the arguments to check
2707 start with the third argument, so the correct parameters for the format
2708 attribute are 2 and 3.
2710 @opindex ffreestanding
2711 @opindex fno-builtin
2712 The @code{format} attribute allows you to identify your own functions
2713 that take format strings as arguments, so that GCC can check the
2714 calls to these functions for errors. The compiler always (unless
2715 @option{-ffreestanding} or @option{-fno-builtin} is used) checks formats
2716 for the standard library functions @code{printf}, @code{fprintf},
2717 @code{sprintf}, @code{scanf}, @code{fscanf}, @code{sscanf}, @code{strftime},
2718 @code{vprintf}, @code{vfprintf} and @code{vsprintf} whenever such
2719 warnings are requested (using @option{-Wformat}), so there is no need to
2720 modify the header file @file{stdio.h}. In C99 mode, the functions
2721 @code{snprintf}, @code{vsnprintf}, @code{vscanf}, @code{vfscanf} and
2722 @code{vsscanf} are also checked. Except in strictly conforming C
2723 standard modes, the X/Open function @code{strfmon} is also checked as
2724 are @code{printf_unlocked} and @code{fprintf_unlocked}.
2725 @xref{C Dialect Options,,Options Controlling C Dialect}.
2727 For Objective-C dialects, @code{NSString} (or @code{__NSString__}) is
2728 recognized in the same context. Declarations including these format attributes
2729 are parsed for correct syntax, however the result of checking of such format
2730 strings is not yet defined, and is not carried out by this version of the
2733 The target may also provide additional types of format checks.
2734 @xref{Target Format Checks,,Format Checks Specific to Particular
2737 @item format_arg (@var{string-index})
2738 @cindex @code{format_arg} function attribute
2739 @opindex Wformat-nonliteral
2740 The @code{format_arg} attribute specifies that a function takes a format
2741 string for a @code{printf}, @code{scanf}, @code{strftime} or
2742 @code{strfmon} style function and modifies it (for example, to translate
2743 it into another language), so the result can be passed to a
2744 @code{printf}, @code{scanf}, @code{strftime} or @code{strfmon} style
2745 function (with the remaining arguments to the format function the same
2746 as they would have been for the unmodified string). For example, the
2751 my_dgettext (char *my_domain, const char *my_format)
2752 __attribute__ ((format_arg (2)));
2756 causes the compiler to check the arguments in calls to a @code{printf},
2757 @code{scanf}, @code{strftime} or @code{strfmon} type function, whose
2758 format string argument is a call to the @code{my_dgettext} function, for
2759 consistency with the format string argument @code{my_format}. If the
2760 @code{format_arg} attribute had not been specified, all the compiler
2761 could tell in such calls to format functions would be that the format
2762 string argument is not constant; this would generate a warning when
2763 @option{-Wformat-nonliteral} is used, but the calls could not be checked
2764 without the attribute.
2766 The parameter @var{string-index} specifies which argument is the format
2767 string argument (starting from one). Since non-static C++ methods have
2768 an implicit @code{this} argument, the arguments of such methods should
2769 be counted from two.
2771 The @code{format_arg} attribute allows you to identify your own
2772 functions that modify format strings, so that GCC can check the
2773 calls to @code{printf}, @code{scanf}, @code{strftime} or @code{strfmon}
2774 type function whose operands are a call to one of your own function.
2775 The compiler always treats @code{gettext}, @code{dgettext}, and
2776 @code{dcgettext} in this manner except when strict ISO C support is
2777 requested by @option{-ansi} or an appropriate @option{-std} option, or
2778 @option{-ffreestanding} or @option{-fno-builtin}
2779 is used. @xref{C Dialect Options,,Options
2780 Controlling C Dialect}.
2782 For Objective-C dialects, the @code{format-arg} attribute may refer to an
2783 @code{NSString} reference for compatibility with the @code{format} attribute
2786 The target may also allow additional types in @code{format-arg} attributes.
2787 @xref{Target Format Checks,,Format Checks Specific to Particular
2790 @item function_vector
2791 @cindex calling functions through the function vector on H8/300, M16C, M32C and SH2A processors
2792 Use this attribute on the H8/300, H8/300H, and H8S to indicate that the specified
2793 function should be called through the function vector. Calling a
2794 function through the function vector reduces code size, however;
2795 the function vector has a limited size (maximum 128 entries on the H8/300
2796 and 64 entries on the H8/300H and H8S) and shares space with the interrupt vector.
2798 On SH2A targets, this attribute declares a function to be called using the
2799 TBR relative addressing mode. The argument to this attribute is the entry
2800 number of the same function in a vector table containing all the TBR
2801 relative addressable functions. For correct operation the TBR must be setup
2802 accordingly to point to the start of the vector table before any functions with
2803 this attribute are invoked. Usually a good place to do the initialization is
2804 the startup routine. The TBR relative vector table can have at max 256 function
2805 entries. The jumps to these functions are generated using a SH2A specific,
2806 non delayed branch instruction JSR/N @@(disp8,TBR). You must use GAS and GLD
2807 from GNU binutils version 2.7 or later for this attribute to work correctly.
2809 Please refer the example of M16C target, to see the use of this
2810 attribute while declaring a function,
2812 In an application, for a function being called once, this attribute
2813 saves at least 8 bytes of code; and if other successive calls are being
2814 made to the same function, it saves 2 bytes of code per each of these
2817 On M16C/M32C targets, the @code{function_vector} attribute declares a
2818 special page subroutine call function. Use of this attribute reduces
2819 the code size by 2 bytes for each call generated to the
2820 subroutine. The argument to the attribute is the vector number entry
2821 from the special page vector table which contains the 16 low-order
2822 bits of the subroutine's entry address. Each vector table has special
2823 page number (18 to 255) that is used in @code{jsrs} instructions.
2824 Jump addresses of the routines are generated by adding 0x0F0000 (in
2825 case of M16C targets) or 0xFF0000 (in case of M32C targets), to the
2826 2-byte addresses set in the vector table. Therefore you need to ensure
2827 that all the special page vector routines should get mapped within the
2828 address range 0x0F0000 to 0x0FFFFF (for M16C) and 0xFF0000 to 0xFFFFFF
2831 In the following example 2 bytes are saved for each call to
2832 function @code{foo}.
2835 void foo (void) __attribute__((function_vector(0x18)));
2846 If functions are defined in one file and are called in another file,
2847 then be sure to write this declaration in both files.
2849 This attribute is ignored for R8C target.
2851 @item ifunc ("@var{resolver}")
2852 @cindex @code{ifunc} attribute
2853 The @code{ifunc} attribute is used to mark a function as an indirect
2854 function using the STT_GNU_IFUNC symbol type extension to the ELF
2855 standard. This allows the resolution of the symbol value to be
2856 determined dynamically at load time, and an optimized version of the
2857 routine can be selected for the particular processor or other system
2858 characteristics determined then. To use this attribute, first define
2859 the implementation functions available, and a resolver function that
2860 returns a pointer to the selected implementation function. The
2861 implementation functions' declarations must match the API of the
2862 function being implemented, the resolver's declaration is be a
2863 function returning pointer to void function returning void:
2866 void *my_memcpy (void *dst, const void *src, size_t len)
2871 static void (*resolve_memcpy (void)) (void)
2873 return my_memcpy; // we'll just always select this routine
2878 The exported header file declaring the function the user calls would
2882 extern void *memcpy (void *, const void *, size_t);
2886 allowing the user to call this as a regular function, unaware of the
2887 implementation. Finally, the indirect function needs to be defined in
2888 the same translation unit as the resolver function:
2891 void *memcpy (void *, const void *, size_t)
2892 __attribute__ ((ifunc ("resolve_memcpy")));
2895 Indirect functions cannot be weak. Binutils version 2.20.1 or higher
2896 and GNU C Library version 2.11.1 are required to use this feature.
2899 @cindex interrupt handler functions
2900 Use this attribute on the ARC, ARM, AVR, CR16, Epiphany, M32C, M32R/D,
2901 m68k, MeP, MIPS, MSP430, RL78, RX, Visium and Xstormy16 ports to indicate
2902 that the specified function is an interrupt handler. The compiler generates
2903 function entry and exit sequences suitable for use in an interrupt handler
2904 when this attribute is present. With Epiphany targets it may also generate
2905 a special section with code to initialize the interrupt vector table.
2907 Note, interrupt handlers for the Blackfin, H8/300, H8/300H, H8S, MicroBlaze,
2908 and SH processors can be specified via the @code{interrupt_handler} attribute.
2910 Note, on the ARC, you must specify the kind of interrupt to be handled
2911 in a parameter to the interrupt attribute like this:
2914 void f () __attribute__ ((interrupt ("ilink1")));
2917 Permissible values for this parameter are: @w{@code{ilink1}} and
2920 Note, on the AVR, the hardware globally disables interrupts when an
2921 interrupt is executed. The first instruction of an interrupt handler
2922 declared with this attribute is a @code{SEI} instruction to
2923 re-enable interrupts. See also the @code{signal} function attribute
2924 that does not insert a @code{SEI} instruction. If both @code{signal} and
2925 @code{interrupt} are specified for the same function, @code{signal}
2926 is silently ignored.
2928 Note, for the ARM, you can specify the kind of interrupt to be handled by
2929 adding an optional parameter to the interrupt attribute like this:
2932 void f () __attribute__ ((interrupt ("IRQ")));
2936 Permissible values for this parameter are: @code{IRQ}, @code{FIQ},
2937 @code{SWI}, @code{ABORT} and @code{UNDEF}.
2939 On ARMv7-M the interrupt type is ignored, and the attribute means the function
2940 may be called with a word-aligned stack pointer.
2942 Note, for the MSP430 you can provide an argument to the interrupt
2943 attribute which specifies a name or number. If the argument is a
2944 number it indicates the slot in the interrupt vector table (0 - 31) to
2945 which this handler should be assigned. If the argument is a name it
2946 is treated as a symbolic name for the vector slot. These names should
2947 match up with appropriate entries in the linker script. By default
2948 the names @code{watchdog} for vector 26, @code{nmi} for vector 30 and
2949 @code{reset} for vector 31 are recognized.
2951 You can also use the following function attributes to modify how
2952 normal functions interact with interrupt functions:
2956 @cindex @code{critical} attribute
2957 Critical functions disable interrupts upon entry and restore the
2958 previous interrupt state upon exit. Critical functions cannot also
2959 have the @code{naked} or @code{reentrant} attributes. They can have
2960 the @code{interrupt} attribute.
2963 @cindex @code{reentrant} attribute
2964 Reentrant functions disable interrupts upon entry and enable them
2965 upon exit. Reentrant functions cannot also have the @code{naked}
2966 or @code{critical} attributes. They can have the @code{interrupt}
2970 @cindex @code{wakeup} attribute
2971 This attribute only applies to interrupt functions. It is silently
2972 ignored if applied to a non-interrupt function. A wakeup interrupt
2973 function will rouse the processor from any low-power state that it
2974 might be in when the function exits.
2978 On Epiphany targets one or more optional parameters can be added like this:
2981 void __attribute__ ((interrupt ("dma0, dma1"))) universal_dma_handler ();
2984 Permissible values for these parameters are: @w{@code{reset}},
2985 @w{@code{software_exception}}, @w{@code{page_miss}},
2986 @w{@code{timer0}}, @w{@code{timer1}}, @w{@code{message}},
2987 @w{@code{dma0}}, @w{@code{dma1}}, @w{@code{wand}} and @w{@code{swi}}.
2988 Multiple parameters indicate that multiple entries in the interrupt
2989 vector table should be initialized for this function, i.e.@: for each
2990 parameter @w{@var{name}}, a jump to the function is emitted in
2991 the section @w{ivt_entry_@var{name}}. The parameter(s) may be omitted
2992 entirely, in which case no interrupt vector table entry is provided.
2994 Note, on Epiphany targets, interrupts are enabled inside the function
2995 unless the @code{disinterrupt} attribute is also specified.
2997 On Epiphany targets, you can also use the following attribute to
2998 modify the behavior of an interrupt handler:
3000 @item forwarder_section
3001 @cindex @code{forwarder_section} attribute
3002 The interrupt handler may be in external memory which cannot be
3003 reached by a branch instruction, so generate a local memory trampoline
3004 to transfer control. The single parameter identifies the section where
3005 the trampoline is placed.
3008 The following examples are all valid uses of these attributes on
3011 void __attribute__ ((interrupt)) universal_handler ();
3012 void __attribute__ ((interrupt ("dma1"))) dma1_handler ();
3013 void __attribute__ ((interrupt ("dma0, dma1"))) universal_dma_handler ();
3014 void __attribute__ ((interrupt ("timer0"), disinterrupt))
3015 fast_timer_handler ();
3016 void __attribute__ ((interrupt ("dma0, dma1"), forwarder_section ("tramp")))
3017 external_dma_handler ();
3020 On MIPS targets, you can use the following attributes to modify the behavior
3021 of an interrupt handler:
3023 @item use_shadow_register_set
3024 @cindex @code{use_shadow_register_set} attribute
3025 Assume that the handler uses a shadow register set, instead of
3026 the main general-purpose registers.
3028 @item keep_interrupts_masked
3029 @cindex @code{keep_interrupts_masked} attribute
3030 Keep interrupts masked for the whole function. Without this attribute,
3031 GCC tries to reenable interrupts for as much of the function as it can.
3033 @item use_debug_exception_return
3034 @cindex @code{use_debug_exception_return} attribute
3035 Return using the @code{deret} instruction. Interrupt handlers that don't
3036 have this attribute return using @code{eret} instead.
3039 You can use any combination of these attributes, as shown below:
3041 void __attribute__ ((interrupt)) v0 ();
3042 void __attribute__ ((interrupt, use_shadow_register_set)) v1 ();
3043 void __attribute__ ((interrupt, keep_interrupts_masked)) v2 ();
3044 void __attribute__ ((interrupt, use_debug_exception_return)) v3 ();
3045 void __attribute__ ((interrupt, use_shadow_register_set,
3046 keep_interrupts_masked)) v4 ();
3047 void __attribute__ ((interrupt, use_shadow_register_set,
3048 use_debug_exception_return)) v5 ();
3049 void __attribute__ ((interrupt, keep_interrupts_masked,
3050 use_debug_exception_return)) v6 ();
3051 void __attribute__ ((interrupt, use_shadow_register_set,
3052 keep_interrupts_masked,
3053 use_debug_exception_return)) v7 ();
3056 On NDS32 target, this attribute is to indicate that the specified function
3057 is an interrupt handler. The compiler will generate corresponding sections
3058 for use in an interrupt handler. You can use the following attributes
3059 to modify the behavior:
3062 @cindex @code{nested} attribute
3063 This interrupt service routine is interruptible.
3065 @cindex @code{not_nested} attribute
3066 This interrupt service routine is not interruptible.
3068 @cindex @code{nested_ready} attribute
3069 This interrupt service routine is interruptible after @code{PSW.GIE}
3070 (global interrupt enable) is set. This allows interrupt service routine to
3071 finish some short critical code before enabling interrupts.
3073 @cindex @code{save_all} attribute
3074 The system will help save all registers into stack before entering
3077 @cindex @code{partial_save} attribute
3078 The system will help save caller registers into stack before entering
3082 On RL78, use @code{brk_interrupt} instead of @code{interrupt} for
3083 handlers intended to be used with the @code{BRK} opcode (i.e.@: those
3084 that must end with @code{RETB} instead of @code{RETI}).
3086 On RX targets, you may specify one or more vector numbers as arguments
3087 to the attribute, as well as naming an alternate table name.
3088 Parameters are handled sequentially, so one handler can be assigned to
3089 multiple entries in multiple tables. One may also pass the magic
3090 string @code{"$default"} which causes the function to be used for any
3091 unfilled slots in the current table.
3093 This example shows a simple assignment of a function to one vector in
3094 the default table (note that preprocessor macros may be used for
3095 chip-specific symbolic vector names):
3097 void __attribute__ ((interrupt (5))) txd1_handler ();
3100 This example assigns a function to two slots in the default table
3101 (using preprocessor macros defined elsewhere) and makes it the default
3102 for the @code{dct} table:
3104 void __attribute__ ((interrupt (RXD1_VECT,RXD2_VECT,"dct","$default")))
3108 @item interrupt_handler
3109 @cindex interrupt handler functions on the Blackfin, m68k, H8/300 and SH processors
3110 Use this attribute on the Blackfin, m68k, H8/300, H8/300H, H8S, and SH to
3111 indicate that the specified function is an interrupt handler. The compiler
3112 generates function entry and exit sequences suitable for use in an
3113 interrupt handler when this attribute is present.
3115 @item interrupt_thread
3116 @cindex interrupt thread functions on fido
3117 Use this attribute on fido, a subarchitecture of the m68k, to indicate
3118 that the specified function is an interrupt handler that is designed
3119 to run as a thread. The compiler omits generate prologue/epilogue
3120 sequences and replaces the return instruction with a @code{sleep}
3121 instruction. This attribute is available only on fido.
3124 @cindex interrupt service routines on ARM
3125 Use this attribute on ARM to write Interrupt Service Routines. This is an
3126 alias to the @code{interrupt} attribute above.
3129 @cindex User stack pointer in interrupts on the Blackfin
3130 When used together with @code{interrupt_handler}, @code{exception_handler}
3131 or @code{nmi_handler}, code is generated to load the stack pointer
3132 from the USP register in the function prologue.
3135 @cindex @code{l1_text} function attribute
3136 This attribute specifies a function to be placed into L1 Instruction
3137 SRAM@. The function is put into a specific section named @code{.l1.text}.
3138 With @option{-mfdpic}, function calls with a such function as the callee
3139 or caller uses inlined PLT.
3142 @cindex @code{l2} function attribute
3143 On the Blackfin, this attribute specifies a function to be placed into L2
3144 SRAM. The function is put into a specific section named
3145 @code{.l1.text}. With @option{-mfdpic}, callers of such functions use
3149 @cindex @code{leaf} function attribute
3150 Calls to external functions with this attribute must return to the current
3151 compilation unit only by return or by exception handling. In particular, leaf
3152 functions are not allowed to call callback function passed to it from the current
3153 compilation unit or directly call functions exported by the unit or longjmp
3154 into the unit. Leaf function might still call functions from other compilation
3155 units and thus they are not necessarily leaf in the sense that they contain no
3156 function calls at all.
3158 The attribute is intended for library functions to improve dataflow analysis.
3159 The compiler takes the hint that any data not escaping the current compilation unit can
3160 not be used or modified by the leaf function. For example, the @code{sin} function
3161 is a leaf function, but @code{qsort} is not.
3163 Note that leaf functions might invoke signals and signal handlers might be
3164 defined in the current compilation unit and use static variables. The only
3165 compliant way to write such a signal handler is to declare such variables
3168 The attribute has no effect on functions defined within the current compilation
3169 unit. This is to allow easy merging of multiple compilation units into one,
3170 for example, by using the link-time optimization. For this reason the
3171 attribute is not allowed on types to annotate indirect calls.
3173 @item long_call/medium_call/short_call
3174 @cindex indirect calls on ARC
3175 @cindex indirect calls on ARM
3176 @cindex indirect calls on Epiphany
3177 These attributes specify how a particular function is called on
3178 ARC, ARM and Epiphany - with @code{medium_call} being specific to ARC.
3179 These attributes override the
3180 @option{-mlong-calls} (@pxref{ARM Options} and @ref{ARC Options})
3181 and @option{-mmedium-calls} (@pxref{ARC Options})
3182 command-line switches and @code{#pragma long_calls} settings. For ARM, the
3183 @code{long_call} attribute indicates that the function might be far
3184 away from the call site and require a different (more expensive)
3185 calling sequence. The @code{short_call} attribute always places
3186 the offset to the function from the call site into the @samp{BL}
3187 instruction directly.
3189 For ARC, a function marked with the @code{long_call} attribute is
3190 always called using register-indirect jump-and-link instructions,
3191 thereby enabling the called function to be placed anywhere within the
3192 32-bit address space. A function marked with the @code{medium_call}
3193 attribute will always be close enough to be called with an unconditional
3194 branch-and-link instruction, which has a 25-bit offset from
3195 the call site. A function marked with the @code{short_call}
3196 attribute will always be close enough to be called with a conditional
3197 branch-and-link instruction, which has a 21-bit offset from
3200 @item longcall/shortcall
3201 @cindex functions called via pointer on the RS/6000 and PowerPC
3202 On the Blackfin, RS/6000 and PowerPC, the @code{longcall} attribute
3203 indicates that the function might be far away from the call site and
3204 require a different (more expensive) calling sequence. The
3205 @code{shortcall} attribute indicates that the function is always close
3206 enough for the shorter calling sequence to be used. These attributes
3207 override both the @option{-mlongcall} switch and, on the RS/6000 and
3208 PowerPC, the @code{#pragma longcall} setting.
3210 @xref{RS/6000 and PowerPC Options}, for more information on whether long
3211 calls are necessary.
3213 @item long_call/near/far
3214 @cindex indirect calls on MIPS
3215 These attributes specify how a particular function is called on MIPS@.
3216 The attributes override the @option{-mlong-calls} (@pxref{MIPS Options})
3217 command-line switch. The @code{long_call} and @code{far} attributes are
3218 synonyms, and cause the compiler to always call
3219 the function by first loading its address into a register, and then using
3220 the contents of that register. The @code{near} attribute has the opposite
3221 effect; it specifies that non-PIC calls should be made using the more
3222 efficient @code{jal} instruction.
3225 @cindex @code{malloc} attribute
3226 This tells the compiler that a function is @code{malloc}-like, i.e.,
3227 that the pointer @var{P} returned by the function cannot alias any
3228 other pointer valid when the function returns, and moreover no
3229 pointers to valid objects occur in any storage addressed by @var{P}.
3231 Using this attribute can improve optimization. Functions like
3232 @code{malloc} and @code{calloc} have this property because they return
3233 a pointer to uninitialized or zeroed-out storage. However, functions
3234 like @code{realloc} do not have this property, as they can return a
3235 pointer to storage containing pointers.
3237 @item mips16/nomips16
3238 @cindex @code{mips16} attribute
3239 @cindex @code{nomips16} attribute
3241 On MIPS targets, you can use the @code{mips16} and @code{nomips16}
3242 function attributes to locally select or turn off MIPS16 code generation.
3243 A function with the @code{mips16} attribute is emitted as MIPS16 code,
3244 while MIPS16 code generation is disabled for functions with the
3245 @code{nomips16} attribute. These attributes override the
3246 @option{-mips16} and @option{-mno-mips16} options on the command line
3247 (@pxref{MIPS Options}).
3249 When compiling files containing mixed MIPS16 and non-MIPS16 code, the
3250 preprocessor symbol @code{__mips16} reflects the setting on the command line,
3251 not that within individual functions. Mixed MIPS16 and non-MIPS16 code
3252 may interact badly with some GCC extensions such as @code{__builtin_apply}
3253 (@pxref{Constructing Calls}).
3255 @item micromips/nomicromips
3256 @cindex @code{micromips} attribute
3257 @cindex @code{nomicromips} attribute
3259 On MIPS targets, you can use the @code{micromips} and @code{nomicromips}
3260 function attributes to locally select or turn off microMIPS code generation.
3261 A function with the @code{micromips} attribute is emitted as microMIPS code,
3262 while microMIPS code generation is disabled for functions with the
3263 @code{nomicromips} attribute. These attributes override the
3264 @option{-mmicromips} and @option{-mno-micromips} options on the command line
3265 (@pxref{MIPS Options}).
3267 When compiling files containing mixed microMIPS and non-microMIPS code, the
3268 preprocessor symbol @code{__mips_micromips} reflects the setting on the
3270 not that within individual functions. Mixed microMIPS and non-microMIPS code
3271 may interact badly with some GCC extensions such as @code{__builtin_apply}
3272 (@pxref{Constructing Calls}).
3274 @item model (@var{model-name})
3275 @cindex function addressability on the M32R/D
3276 @cindex variable addressability on the IA-64
3278 On the M32R/D, use this attribute to set the addressability of an
3279 object, and of the code generated for a function. The identifier
3280 @var{model-name} is one of @code{small}, @code{medium}, or
3281 @code{large}, representing each of the code models.
3283 Small model objects live in the lower 16MB of memory (so that their
3284 addresses can be loaded with the @code{ld24} instruction), and are
3285 callable with the @code{bl} instruction.
3287 Medium model objects may live anywhere in the 32-bit address space (the
3288 compiler generates @code{seth/add3} instructions to load their addresses),
3289 and are callable with the @code{bl} instruction.
3291 Large model objects may live anywhere in the 32-bit address space (the
3292 compiler generates @code{seth/add3} instructions to load their addresses),
3293 and may not be reachable with the @code{bl} instruction (the compiler
3294 generates the much slower @code{seth/add3/jl} instruction sequence).
3296 On IA-64, use this attribute to set the addressability of an object.
3297 At present, the only supported identifier for @var{model-name} is
3298 @code{small}, indicating addressability via ``small'' (22-bit)
3299 addresses (so that their addresses can be loaded with the @code{addl}
3300 instruction). Caveat: such addressing is by definition not position
3301 independent and hence this attribute must not be used for objects
3302 defined by shared libraries.
3304 @item ms_abi/sysv_abi
3305 @cindex @code{ms_abi} attribute
3306 @cindex @code{sysv_abi} attribute
3308 On 32-bit and 64-bit x86 targets, you can use an ABI attribute
3309 to indicate which calling convention should be used for a function. The
3310 @code{ms_abi} attribute tells the compiler to use the Microsoft ABI,
3311 while the @code{sysv_abi} attribute tells the compiler to use the ABI
3312 used on GNU/Linux and other systems. The default is to use the Microsoft ABI
3313 when targeting Windows. On all other systems, the default is the x86/AMD ABI.
3315 Note, the @code{ms_abi} attribute for Microsoft Windows 64-bit targets currently
3316 requires the @option{-maccumulate-outgoing-args} option.
3318 @item callee_pop_aggregate_return (@var{number})
3319 @cindex @code{callee_pop_aggregate_return} attribute
3321 On x86-32 targets, you can use this attribute to control how
3322 aggregates are returned in memory. If the caller is responsible for
3323 popping the hidden pointer together with the rest of the arguments, specify
3324 @var{number} equal to zero. If callee is responsible for popping the
3325 hidden pointer, specify @var{number} equal to one.
3327 The default x86-32 ABI assumes that the callee pops the
3328 stack for hidden pointer. However, on x86-32 Microsoft Windows targets,
3329 the compiler assumes that the
3330 caller pops the stack for hidden pointer.
3332 @item ms_hook_prologue
3333 @cindex @code{ms_hook_prologue} attribute
3335 On 32-bit and 64-bit x86 targets, you can use
3336 this function attribute to make GCC generate the ``hot-patching'' function
3337 prologue used in Win32 API functions in Microsoft Windows XP Service Pack 2
3340 @item hotpatch (@var{halfwords-before-function-label},@var{halfwords-after-function-label})
3341 @cindex @code{hotpatch} attribute
3343 On S/390 System z targets, you can use this function attribute to
3344 make GCC generate a ``hot-patching'' function prologue. If the
3345 @option{-mhotpatch=} command-line option is used at the same time,
3346 the @code{hotpatch} attribute takes precedence. The first of the
3347 two arguments specifies the number of halfwords to be added before
3348 the function label. A second argument can be used to specify the
3349 number of halfwords to be added after the function label. For
3350 both arguments the maximum allowed value is 1000000.
3352 If both arguments are zero, hotpatching is disabled.
3355 @cindex function without a prologue/epilogue code
3356 This attribute is available on the ARM, AVR, MCORE, MSP430, NDS32,
3357 RL78, RX and SPU ports. It allows the compiler to construct the
3358 requisite function declaration, while allowing the body of the
3359 function to be assembly code. The specified function will not have
3360 prologue/epilogue sequences generated by the compiler. Only basic
3361 @code{asm} statements can safely be included in naked functions
3362 (@pxref{Basic Asm}). While using extended @code{asm} or a mixture of
3363 basic @code{asm} and C code may appear to work, they cannot be
3364 depended upon to work reliably and are not supported.
3367 @cindex functions that do not handle memory bank switching on 68HC11/68HC12
3368 On 68HC11 and 68HC12 the @code{near} attribute causes the compiler to
3369 use the normal calling convention based on @code{jsr} and @code{rts}.
3370 This attribute can be used to cancel the effect of the @option{-mlong-calls}
3373 On MeP targets this attribute causes the compiler to assume the called
3374 function is close enough to use the normal calling convention,
3375 overriding the @option{-mtf} command-line option.
3378 @cindex Allow nesting in an interrupt handler on the Blackfin processor.
3379 Use this attribute together with @code{interrupt_handler},
3380 @code{exception_handler} or @code{nmi_handler} to indicate that the function
3381 entry code should enable nested interrupts or exceptions.
3384 @cindex NMI handler functions on the Blackfin processor
3385 Use this attribute on the Blackfin to indicate that the specified function
3386 is an NMI handler. The compiler generates function entry and
3387 exit sequences suitable for use in an NMI handler when this
3388 attribute is present.
3391 @cindex @code{nocompression} attribute
3392 On MIPS targets, you can use the @code{nocompression} function attribute
3393 to locally turn off MIPS16 and microMIPS code generation. This attribute
3394 overrides the @option{-mips16} and @option{-mmicromips} options on the
3395 command line (@pxref{MIPS Options}).
3397 @item no_instrument_function
3398 @cindex @code{no_instrument_function} function attribute
3399 @opindex finstrument-functions
3400 If @option{-finstrument-functions} is given, profiling function calls are
3401 generated at entry and exit of most user-compiled functions.
3402 Functions with this attribute are not so instrumented.
3404 @item no_split_stack
3405 @cindex @code{no_split_stack} function attribute
3406 @opindex fsplit-stack
3407 If @option{-fsplit-stack} is given, functions have a small
3408 prologue which decides whether to split the stack. Functions with the
3409 @code{no_split_stack} attribute do not have that prologue, and thus
3410 may run with only a small amount of stack space available.
3413 @cindex @code{stack_protect} function attribute
3414 This function attribute make a stack protection of the function if
3415 flags @option{fstack-protector} or @option{fstack-protector-strong}
3416 or @option{fstack-protector-explicit} are set.
3419 @cindex @code{noinline} function attribute
3420 This function attribute prevents a function from being considered for
3422 @c Don't enumerate the optimizations by name here; we try to be
3423 @c future-compatible with this mechanism.
3424 If the function does not have side-effects, there are optimizations
3425 other than inlining that cause function calls to be optimized away,
3426 although the function call is live. To keep such calls from being
3433 (@pxref{Extended Asm}) in the called function, to serve as a special
3437 @cindex @code{noclone} function attribute
3438 This function attribute prevents a function from being considered for
3439 cloning---a mechanism that produces specialized copies of functions
3440 and which is (currently) performed by interprocedural constant
3444 @cindex @code{no_icf} function attribute
3445 This function attribute prevents a functions from being merged with another
3446 semantically equivalent function.
3448 @item nonnull (@var{arg-index}, @dots{})
3449 @cindex @code{nonnull} function attribute
3450 The @code{nonnull} attribute specifies that some function parameters should
3451 be non-null pointers. For instance, the declaration:
3455 my_memcpy (void *dest, const void *src, size_t len)
3456 __attribute__((nonnull (1, 2)));
3460 causes the compiler to check that, in calls to @code{my_memcpy},
3461 arguments @var{dest} and @var{src} are non-null. If the compiler
3462 determines that a null pointer is passed in an argument slot marked
3463 as non-null, and the @option{-Wnonnull} option is enabled, a warning
3464 is issued. The compiler may also choose to make optimizations based
3465 on the knowledge that certain function arguments will never be null.
3467 If no argument index list is given to the @code{nonnull} attribute,
3468 all pointer arguments are marked as non-null. To illustrate, the
3469 following declaration is equivalent to the previous example:
3473 my_memcpy (void *dest, const void *src, size_t len)
3474 __attribute__((nonnull));
3478 @cindex @code{no_reorder} function or variable attribute
3479 Do not reorder functions or variables marked @code{no_reorder}
3480 against each other or top level assembler statements the executable.
3481 The actual order in the program will depend on the linker command
3482 line. Static variables marked like this are also not removed.
3483 This has a similar effect
3484 as the @option{-fno-toplevel-reorder} option, but only applies to the
3487 @item returns_nonnull
3488 @cindex @code{returns_nonnull} function attribute
3489 The @code{returns_nonnull} attribute specifies that the function
3490 return value should be a non-null pointer. For instance, the declaration:
3494 mymalloc (size_t len) __attribute__((returns_nonnull));
3498 lets the compiler optimize callers based on the knowledge
3499 that the return value will never be null.
3502 @cindex @code{noreturn} function attribute
3503 A few standard library functions, such as @code{abort} and @code{exit},
3504 cannot return. GCC knows this automatically. Some programs define
3505 their own functions that never return. You can declare them
3506 @code{noreturn} to tell the compiler this fact. For example,
3510 void fatal () __attribute__ ((noreturn));
3513 fatal (/* @r{@dots{}} */)
3515 /* @r{@dots{}} */ /* @r{Print error message.} */ /* @r{@dots{}} */
3521 The @code{noreturn} keyword tells the compiler to assume that
3522 @code{fatal} cannot return. It can then optimize without regard to what
3523 would happen if @code{fatal} ever did return. This makes slightly
3524 better code. More importantly, it helps avoid spurious warnings of
3525 uninitialized variables.
3527 The @code{noreturn} keyword does not affect the exceptional path when that
3528 applies: a @code{noreturn}-marked function may still return to the caller
3529 by throwing an exception or calling @code{longjmp}.
3531 Do not assume that registers saved by the calling function are
3532 restored before calling the @code{noreturn} function.
3534 It does not make sense for a @code{noreturn} function to have a return
3535 type other than @code{void}.
3538 @cindex @code{nothrow} function attribute
3539 The @code{nothrow} attribute is used to inform the compiler that a
3540 function cannot throw an exception. For example, most functions in
3541 the standard C library can be guaranteed not to throw an exception
3542 with the notable exceptions of @code{qsort} and @code{bsearch} that
3543 take function pointer arguments.
3545 @item nosave_low_regs
3546 @cindex @code{nosave_low_regs} attribute
3547 Use this attribute on SH targets to indicate that an @code{interrupt_handler}
3548 function should not save and restore registers R0..R7. This can be used on SH3*
3549 and SH4* targets that have a second R0..R7 register bank for non-reentrant
3553 @cindex @code{optimize} function attribute
3554 The @code{optimize} attribute is used to specify that a function is to
3555 be compiled with different optimization options than specified on the
3556 command line. Arguments can either be numbers or strings. Numbers
3557 are assumed to be an optimization level. Strings that begin with
3558 @code{O} are assumed to be an optimization option, while other options
3559 are assumed to be used with a @code{-f} prefix. You can also use the
3560 @samp{#pragma GCC optimize} pragma to set the optimization options
3561 that affect more than one function.
3562 @xref{Function Specific Option Pragmas}, for details about the
3563 @samp{#pragma GCC optimize} pragma.
3565 This can be used for instance to have frequently-executed functions
3566 compiled with more aggressive optimization options that produce faster
3567 and larger code, while other functions can be compiled with less
3570 @item OS_main/OS_task
3571 @cindex @code{OS_main} AVR function attribute
3572 @cindex @code{OS_task} AVR function attribute
3573 On AVR, functions with the @code{OS_main} or @code{OS_task} attribute
3574 do not save/restore any call-saved register in their prologue/epilogue.
3576 The @code{OS_main} attribute can be used when there @emph{is
3577 guarantee} that interrupts are disabled at the time when the function
3578 is entered. This saves resources when the stack pointer has to be
3579 changed to set up a frame for local variables.
3581 The @code{OS_task} attribute can be used when there is @emph{no
3582 guarantee} that interrupts are disabled at that time when the function
3583 is entered like for, e@.g@. task functions in a multi-threading operating
3584 system. In that case, changing the stack pointer register is
3585 guarded by save/clear/restore of the global interrupt enable flag.
3587 The differences to the @code{naked} function attribute are:
3589 @item @code{naked} functions do not have a return instruction whereas
3590 @code{OS_main} and @code{OS_task} functions have a @code{RET} or
3591 @code{RETI} return instruction.
3592 @item @code{naked} functions do not set up a frame for local variables
3593 or a frame pointer whereas @code{OS_main} and @code{OS_task} do this
3598 @cindex @code{pcs} function attribute
3600 The @code{pcs} attribute can be used to control the calling convention
3601 used for a function on ARM. The attribute takes an argument that specifies
3602 the calling convention to use.
3604 When compiling using the AAPCS ABI (or a variant of it) then valid
3605 values for the argument are @code{"aapcs"} and @code{"aapcs-vfp"}. In
3606 order to use a variant other than @code{"aapcs"} then the compiler must
3607 be permitted to use the appropriate co-processor registers (i.e., the
3608 VFP registers must be available in order to use @code{"aapcs-vfp"}).
3612 /* Argument passed in r0, and result returned in r0+r1. */
3613 double f2d (float) __attribute__((pcs("aapcs")));
3616 Variadic functions always use the @code{"aapcs"} calling convention and
3617 the compiler rejects attempts to specify an alternative.
3620 @cindex @code{pure} function attribute
3621 Many functions have no effects except the return value and their
3622 return value depends only on the parameters and/or global variables.
3623 Such a function can be subject
3624 to common subexpression elimination and loop optimization just as an
3625 arithmetic operator would be. These functions should be declared
3626 with the attribute @code{pure}. For example,
3629 int square (int) __attribute__ ((pure));
3633 says that the hypothetical function @code{square} is safe to call
3634 fewer times than the program says.
3636 Some of common examples of pure functions are @code{strlen} or @code{memcmp}.
3637 Interesting non-pure functions are functions with infinite loops or those
3638 depending on volatile memory or other system resource, that may change between
3639 two consecutive calls (such as @code{feof} in a multithreading environment).
3642 @cindex @code{hot} function attribute
3643 The @code{hot} attribute on a function is used to inform the compiler that
3644 the function is a hot spot of the compiled program. The function is
3645 optimized more aggressively and on many targets it is placed into a special
3646 subsection of the text section so all hot functions appear close together,
3649 When profile feedback is available, via @option{-fprofile-use}, hot functions
3650 are automatically detected and this attribute is ignored.
3653 @cindex @code{cold} function attribute
3654 The @code{cold} attribute on functions is used to inform the compiler that
3655 the function is unlikely to be executed. The function is optimized for
3656 size rather than speed and on many targets it is placed into a special
3657 subsection of the text section so all cold functions appear close together,
3658 improving code locality of non-cold parts of program. The paths leading
3659 to calls of cold functions within code are marked as unlikely by the branch
3660 prediction mechanism. It is thus useful to mark functions used to handle
3661 unlikely conditions, such as @code{perror}, as cold to improve optimization
3662 of hot functions that do call marked functions in rare occasions.
3664 When profile feedback is available, via @option{-fprofile-use}, cold functions
3665 are automatically detected and this attribute is ignored.
3667 @item no_sanitize_address
3668 @itemx no_address_safety_analysis
3669 @cindex @code{no_sanitize_address} function attribute
3670 The @code{no_sanitize_address} attribute on functions is used
3671 to inform the compiler that it should not instrument memory accesses
3672 in the function when compiling with the @option{-fsanitize=address} option.
3673 The @code{no_address_safety_analysis} is a deprecated alias of the
3674 @code{no_sanitize_address} attribute, new code should use
3675 @code{no_sanitize_address}.
3677 @item no_sanitize_thread
3678 @cindex @code{no_sanitize_thread} function attribute
3679 The @code{no_sanitize_thread} attribute on functions is used
3680 to inform the compiler that it should not instrument memory accesses
3681 in the function when compiling with the @option{-fsanitize=thread} option.
3683 @item no_sanitize_undefined
3684 @cindex @code{no_sanitize_undefined} function attribute
3685 The @code{no_sanitize_undefined} attribute on functions is used
3686 to inform the compiler that it should not check for undefined behavior
3687 in the function when compiling with the @option{-fsanitize=undefined} option.
3690 @cindex @code{bnd_legacy} function attribute
3691 The @code{bnd_legacy} attribute on functions is used to inform
3692 compiler that function should not be instrumented when compiled
3693 with @option{-fcheck-pointer-bounds} option.
3695 @item bnd_instrument
3696 @cindex @code{bnd_instrument} function attribute
3697 The @code{bnd_instrument} attribute on functions is used to inform
3698 compiler that function should be instrumented when compiled
3699 with @option{-fchkp-instrument-marked-only} option.
3701 @item regparm (@var{number})
3702 @cindex @code{regparm} attribute
3703 @cindex functions that are passed arguments in registers on x86-32
3704 On x86-32 targets, the @code{regparm} attribute causes the compiler to
3705 pass arguments number one to @var{number} if they are of integral type
3706 in registers EAX, EDX, and ECX instead of on the stack. Functions that
3707 take a variable number of arguments continue to be passed all of their
3708 arguments on the stack.
3710 Beware that on some ELF systems this attribute is unsuitable for
3711 global functions in shared libraries with lazy binding (which is the
3712 default). Lazy binding sends the first call via resolving code in
3713 the loader, which might assume EAX, EDX and ECX can be clobbered, as
3714 per the standard calling conventions. Solaris 8 is affected by this.
3715 Systems with the GNU C Library version 2.1 or higher
3716 and FreeBSD are believed to be
3717 safe since the loaders there save EAX, EDX and ECX. (Lazy binding can be
3718 disabled with the linker or the loader if desired, to avoid the
3722 @cindex reset handler functions
3723 Use this attribute on the NDS32 target to indicate that the specified function
3724 is a reset handler. The compiler will generate corresponding sections
3725 for use in a reset handler. You can use the following attributes
3726 to provide extra exception handling:
3729 @cindex @code{nmi} attribute
3730 Provide a user-defined function to handle NMI exception.
3732 @cindex @code{warm} attribute
3733 Provide a user-defined function to handle warm reset exception.
3737 @cindex @code{sseregparm} attribute
3738 On x86-32 targets with SSE support, the @code{sseregparm} attribute
3739 causes the compiler to pass up to 3 floating-point arguments in
3740 SSE registers instead of on the stack. Functions that take a
3741 variable number of arguments continue to pass all of their
3742 floating-point arguments on the stack.
3744 @item force_align_arg_pointer
3745 @cindex @code{force_align_arg_pointer} attribute
3746 On x86 targets, the @code{force_align_arg_pointer} attribute may be
3747 applied to individual function definitions, generating an alternate
3748 prologue and epilogue that realigns the run-time stack if necessary.
3749 This supports mixing legacy codes that run with a 4-byte aligned stack
3750 with modern codes that keep a 16-byte stack for SSE compatibility.
3753 @cindex @code{renesas} attribute
3754 On SH targets this attribute specifies that the function or struct follows the
3758 @cindex @code{resbank} attribute
3759 On the SH2A target, this attribute enables the high-speed register
3760 saving and restoration using a register bank for @code{interrupt_handler}
3761 routines. Saving to the bank is performed automatically after the CPU
3762 accepts an interrupt that uses a register bank.
3764 The nineteen 32-bit registers comprising general register R0 to R14,
3765 control register GBR, and system registers MACH, MACL, and PR and the
3766 vector table address offset are saved into a register bank. Register
3767 banks are stacked in first-in last-out (FILO) sequence. Restoration
3768 from the bank is executed by issuing a RESBANK instruction.
3771 @cindex @code{returns_twice} attribute
3772 The @code{returns_twice} attribute tells the compiler that a function may
3773 return more than one time. The compiler ensures that all registers
3774 are dead before calling such a function and emits a warning about
3775 the variables that may be clobbered after the second return from the
3776 function. Examples of such functions are @code{setjmp} and @code{vfork}.
3777 The @code{longjmp}-like counterpart of such function, if any, might need
3778 to be marked with the @code{noreturn} attribute.
3781 @cindex save all registers on the Blackfin, H8/300, H8/300H, and H8S
3782 Use this attribute on the Blackfin, H8/300, H8/300H, and H8S to indicate that
3783 all registers except the stack pointer should be saved in the prologue
3784 regardless of whether they are used or not.
3786 @item save_volatiles
3787 @cindex save volatile registers on the MicroBlaze
3788 Use this attribute on the MicroBlaze to indicate that the function is
3789 an interrupt handler. All volatile registers (in addition to non-volatile
3790 registers) are saved in the function prologue. If the function is a leaf
3791 function, only volatiles used by the function are saved. A normal function
3792 return is generated instead of a return from interrupt.
3795 @cindex break handler functions
3796 Use this attribute on the MicroBlaze ports to indicate that
3797 the specified function is an break handler. The compiler generates function
3798 entry and exit sequences suitable for use in an break handler when this
3799 attribute is present. The return from @code{break_handler} is done through
3800 the @code{rtbd} instead of @code{rtsd}.
3803 void f () __attribute__ ((break_handler));
3806 @item section ("@var{section-name}")
3807 @cindex @code{section} function attribute
3808 Normally, the compiler places the code it generates in the @code{text} section.
3809 Sometimes, however, you need additional sections, or you need certain
3810 particular functions to appear in special sections. The @code{section}
3811 attribute specifies that a function lives in a particular section.
3812 For example, the declaration:
3815 extern void foobar (void) __attribute__ ((section ("bar")));
3819 puts the function @code{foobar} in the @code{bar} section.
3821 Some file formats do not support arbitrary sections so the @code{section}
3822 attribute is not available on all platforms.
3823 If you need to map the entire contents of a module to a particular
3824 section, consider using the facilities of the linker instead.
3827 @cindex @code{sentinel} function attribute
3828 This function attribute ensures that a parameter in a function call is
3829 an explicit @code{NULL}. The attribute is only valid on variadic
3830 functions. By default, the sentinel is located at position zero, the
3831 last parameter of the function call. If an optional integer position
3832 argument P is supplied to the attribute, the sentinel must be located at
3833 position P counting backwards from the end of the argument list.
3836 __attribute__ ((sentinel))
3838 __attribute__ ((sentinel(0)))
3841 The attribute is automatically set with a position of 0 for the built-in
3842 functions @code{execl} and @code{execlp}. The built-in function
3843 @code{execle} has the attribute set with a position of 1.
3845 A valid @code{NULL} in this context is defined as zero with any pointer
3846 type. If your system defines the @code{NULL} macro with an integer type
3847 then you need to add an explicit cast. GCC replaces @code{stddef.h}
3848 with a copy that redefines NULL appropriately.
3850 The warnings for missing or incorrect sentinels are enabled with
3854 See @code{long_call/short_call}.
3857 See @code{longcall/shortcall}.
3860 @cindex interrupt handler functions on the AVR processors
3861 Use this attribute on the AVR to indicate that the specified
3862 function is an interrupt handler. The compiler generates function
3863 entry and exit sequences suitable for use in an interrupt handler when this
3864 attribute is present.
3866 See also the @code{interrupt} function attribute.
3868 The AVR hardware globally disables interrupts when an interrupt is executed.
3869 Interrupt handler functions defined with the @code{signal} attribute
3870 do not re-enable interrupts. It is save to enable interrupts in a
3871 @code{signal} handler. This ``save'' only applies to the code
3872 generated by the compiler and not to the IRQ layout of the
3873 application which is responsibility of the application.
3875 If both @code{signal} and @code{interrupt} are specified for the same
3876 function, @code{signal} is silently ignored.
3879 @cindex @code{sp_switch} attribute
3880 Use this attribute on the SH to indicate an @code{interrupt_handler}
3881 function should switch to an alternate stack. It expects a string
3882 argument that names a global variable holding the address of the
3887 void f () __attribute__ ((interrupt_handler,
3888 sp_switch ("alt_stack")));
3892 @cindex functions that pop the argument stack on x86-32
3893 On x86-32 targets, the @code{stdcall} attribute causes the compiler to
3894 assume that the called function pops off the stack space used to
3895 pass arguments, unless it takes a variable number of arguments.
3897 @item syscall_linkage
3898 @cindex @code{syscall_linkage} attribute
3899 This attribute is used to modify the IA-64 calling convention by marking
3900 all input registers as live at all function exits. This makes it possible
3901 to restart a system call after an interrupt without having to save/restore
3902 the input registers. This also prevents kernel data from leaking into
3906 @cindex @code{target} function attribute
3907 The @code{target} attribute is used to specify that a function is to
3908 be compiled with different target options than specified on the
3909 command line. This can be used for instance to have functions
3910 compiled with a different ISA (instruction set architecture) than the
3911 default. You can also use the @samp{#pragma GCC target} pragma to set
3912 more than one function to be compiled with specific target options.
3913 @xref{Function Specific Option Pragmas}, for details about the
3914 @samp{#pragma GCC target} pragma.
3916 For instance on an x86, you could compile one function with
3917 @code{target("sse4.1,arch=core2")} and another with
3918 @code{target("sse4a,arch=amdfam10")}. This is equivalent to
3919 compiling the first function with @option{-msse4.1} and
3920 @option{-march=core2} options, and the second function with
3921 @option{-msse4a} and @option{-march=amdfam10} options. It is up to the
3922 user to make sure that a function is only invoked on a machine that
3923 supports the particular ISA it is compiled for (for example by using
3924 @code{cpuid} on x86 to determine what feature bits and architecture
3928 int core2_func (void) __attribute__ ((__target__ ("arch=core2")));
3929 int sse3_func (void) __attribute__ ((__target__ ("sse3")));
3932 You can either use multiple
3933 strings to specify multiple options, or separate the options
3934 with a comma (@samp{,}).
3936 The @code{target} attribute is presently implemented for
3937 x86, PowerPC, and Nios II targets only.
3938 The options supported are specific to each target.
3940 On the x86, the following options are allowed:
3945 @cindex @code{target("abm")} attribute
3946 Enable/disable the generation of the advanced bit instructions.
3950 @cindex @code{target("aes")} attribute
3951 Enable/disable the generation of the AES instructions.
3954 @cindex @code{target("default")} attribute
3955 @xref{Function Multiversioning}, where it is used to specify the
3956 default function version.
3960 @cindex @code{target("mmx")} attribute
3961 Enable/disable the generation of the MMX instructions.
3965 @cindex @code{target("pclmul")} attribute
3966 Enable/disable the generation of the PCLMUL instructions.
3970 @cindex @code{target("popcnt")} attribute
3971 Enable/disable the generation of the POPCNT instruction.
3975 @cindex @code{target("sse")} attribute
3976 Enable/disable the generation of the SSE instructions.
3980 @cindex @code{target("sse2")} attribute
3981 Enable/disable the generation of the SSE2 instructions.
3985 @cindex @code{target("sse3")} attribute
3986 Enable/disable the generation of the SSE3 instructions.
3990 @cindex @code{target("sse4")} attribute
3991 Enable/disable the generation of the SSE4 instructions (both SSE4.1
3996 @cindex @code{target("sse4.1")} attribute
3997 Enable/disable the generation of the sse4.1 instructions.
4001 @cindex @code{target("sse4.2")} attribute
4002 Enable/disable the generation of the sse4.2 instructions.
4006 @cindex @code{target("sse4a")} attribute
4007 Enable/disable the generation of the SSE4A instructions.
4011 @cindex @code{target("fma4")} attribute
4012 Enable/disable the generation of the FMA4 instructions.
4016 @cindex @code{target("xop")} attribute
4017 Enable/disable the generation of the XOP instructions.
4021 @cindex @code{target("lwp")} attribute
4022 Enable/disable the generation of the LWP instructions.
4026 @cindex @code{target("ssse3")} attribute
4027 Enable/disable the generation of the SSSE3 instructions.
4031 @cindex @code{target("cld")} attribute
4032 Enable/disable the generation of the CLD before string moves.
4034 @item fancy-math-387
4035 @itemx no-fancy-math-387
4036 @cindex @code{target("fancy-math-387")} attribute
4037 Enable/disable the generation of the @code{sin}, @code{cos}, and
4038 @code{sqrt} instructions on the 387 floating-point unit.
4041 @itemx no-fused-madd
4042 @cindex @code{target("fused-madd")} attribute
4043 Enable/disable the generation of the fused multiply/add instructions.
4047 @cindex @code{target("ieee-fp")} attribute
4048 Enable/disable the generation of floating point that depends on IEEE arithmetic.
4050 @item inline-all-stringops
4051 @itemx no-inline-all-stringops
4052 @cindex @code{target("inline-all-stringops")} attribute
4053 Enable/disable inlining of string operations.
4055 @item inline-stringops-dynamically
4056 @itemx no-inline-stringops-dynamically
4057 @cindex @code{target("inline-stringops-dynamically")} attribute
4058 Enable/disable the generation of the inline code to do small string
4059 operations and calling the library routines for large operations.
4061 @item align-stringops
4062 @itemx no-align-stringops
4063 @cindex @code{target("align-stringops")} attribute
4064 Do/do not align destination of inlined string operations.
4068 @cindex @code{target("recip")} attribute
4069 Enable/disable the generation of RCPSS, RCPPS, RSQRTSS and RSQRTPS
4070 instructions followed an additional Newton-Raphson step instead of
4071 doing a floating-point division.
4073 @item arch=@var{ARCH}
4074 @cindex @code{target("arch=@var{ARCH}")} attribute
4075 Specify the architecture to generate code for in compiling the function.
4077 @item tune=@var{TUNE}
4078 @cindex @code{target("tune=@var{TUNE}")} attribute
4079 Specify the architecture to tune for in compiling the function.
4081 @item fpmath=@var{FPMATH}
4082 @cindex @code{target("fpmath=@var{FPMATH}")} attribute
4083 Specify which floating-point unit to use. The
4084 @code{target("fpmath=sse,387")} option must be specified as
4085 @code{target("fpmath=sse+387")} because the comma would separate
4089 On the PowerPC, the following options are allowed:
4094 @cindex @code{target("altivec")} attribute
4095 Generate code that uses (does not use) AltiVec instructions. In
4096 32-bit code, you cannot enable AltiVec instructions unless
4097 @option{-mabi=altivec} is used on the command line.
4101 @cindex @code{target("cmpb")} attribute
4102 Generate code that uses (does not use) the compare bytes instruction
4103 implemented on the POWER6 processor and other processors that support
4104 the PowerPC V2.05 architecture.
4108 @cindex @code{target("dlmzb")} attribute
4109 Generate code that uses (does not use) the string-search @samp{dlmzb}
4110 instruction on the IBM 405, 440, 464 and 476 processors. This instruction is
4111 generated by default when targeting those processors.
4115 @cindex @code{target("fprnd")} attribute
4116 Generate code that uses (does not use) the FP round to integer
4117 instructions implemented on the POWER5+ processor and other processors
4118 that support the PowerPC V2.03 architecture.
4122 @cindex @code{target("hard-dfp")} attribute
4123 Generate code that uses (does not use) the decimal floating-point
4124 instructions implemented on some POWER processors.
4128 @cindex @code{target("isel")} attribute
4129 Generate code that uses (does not use) ISEL instruction.
4133 @cindex @code{target("mfcrf")} attribute
4134 Generate code that uses (does not use) the move from condition
4135 register field instruction implemented on the POWER4 processor and
4136 other processors that support the PowerPC V2.01 architecture.
4140 @cindex @code{target("mfpgpr")} attribute
4141 Generate code that uses (does not use) the FP move to/from general
4142 purpose register instructions implemented on the POWER6X processor and
4143 other processors that support the extended PowerPC V2.05 architecture.
4147 @cindex @code{target("mulhw")} attribute
4148 Generate code that uses (does not use) the half-word multiply and
4149 multiply-accumulate instructions on the IBM 405, 440, 464 and 476 processors.
4150 These instructions are generated by default when targeting those
4155 @cindex @code{target("multiple")} attribute
4156 Generate code that uses (does not use) the load multiple word
4157 instructions and the store multiple word instructions.
4161 @cindex @code{target("update")} attribute
4162 Generate code that uses (does not use) the load or store instructions
4163 that update the base register to the address of the calculated memory
4168 @cindex @code{target("popcntb")} attribute
4169 Generate code that uses (does not use) the popcount and double-precision
4170 FP reciprocal estimate instruction implemented on the POWER5
4171 processor and other processors that support the PowerPC V2.02
4176 @cindex @code{target("popcntd")} attribute
4177 Generate code that uses (does not use) the popcount instruction
4178 implemented on the POWER7 processor and other processors that support
4179 the PowerPC V2.06 architecture.
4181 @item powerpc-gfxopt
4182 @itemx no-powerpc-gfxopt
4183 @cindex @code{target("powerpc-gfxopt")} attribute
4184 Generate code that uses (does not use) the optional PowerPC
4185 architecture instructions in the Graphics group, including
4186 floating-point select.
4189 @itemx no-powerpc-gpopt
4190 @cindex @code{target("powerpc-gpopt")} attribute
4191 Generate code that uses (does not use) the optional PowerPC
4192 architecture instructions in the General Purpose group, including
4193 floating-point square root.
4195 @item recip-precision
4196 @itemx no-recip-precision
4197 @cindex @code{target("recip-precision")} attribute
4198 Assume (do not assume) that the reciprocal estimate instructions
4199 provide higher-precision estimates than is mandated by the powerpc
4204 @cindex @code{target("string")} attribute
4205 Generate code that uses (does not use) the load string instructions
4206 and the store string word instructions to save multiple registers and
4207 do small block moves.
4211 @cindex @code{target("vsx")} attribute
4212 Generate code that uses (does not use) vector/scalar (VSX)
4213 instructions, and also enable the use of built-in functions that allow
4214 more direct access to the VSX instruction set. In 32-bit code, you
4215 cannot enable VSX or AltiVec instructions unless
4216 @option{-mabi=altivec} is used on the command line.
4220 @cindex @code{target("friz")} attribute
4221 Generate (do not generate) the @code{friz} instruction when the
4222 @option{-funsafe-math-optimizations} option is used to optimize
4223 rounding a floating-point value to 64-bit integer and back to floating
4224 point. The @code{friz} instruction does not return the same value if
4225 the floating-point number is too large to fit in an integer.
4227 @item avoid-indexed-addresses
4228 @itemx no-avoid-indexed-addresses
4229 @cindex @code{target("avoid-indexed-addresses")} attribute
4230 Generate code that tries to avoid (not avoid) the use of indexed load
4231 or store instructions.
4235 @cindex @code{target("paired")} attribute
4236 Generate code that uses (does not use) the generation of PAIRED simd
4241 @cindex @code{target("longcall")} attribute
4242 Generate code that assumes (does not assume) that all calls are far
4243 away so that a longer more expensive calling sequence is required.
4246 @cindex @code{target("cpu=@var{CPU}")} attribute
4247 Specify the architecture to generate code for when compiling the
4248 function. If you select the @code{target("cpu=power7")} attribute when
4249 generating 32-bit code, VSX and AltiVec instructions are not generated
4250 unless you use the @option{-mabi=altivec} option on the command line.
4252 @item tune=@var{TUNE}
4253 @cindex @code{target("tune=@var{TUNE}")} attribute
4254 Specify the architecture to tune for when compiling the function. If
4255 you do not specify the @code{target("tune=@var{TUNE}")} attribute and
4256 you do specify the @code{target("cpu=@var{CPU}")} attribute,
4257 compilation tunes for the @var{CPU} architecture, and not the
4258 default tuning specified on the command line.
4261 When compiling for Nios II, the following options are allowed:
4264 @item custom-@var{insn}=@var{N}
4265 @itemx no-custom-@var{insn}
4266 @cindex @code{target("custom-@var{insn}=@var{N}")} attribute
4267 @cindex @code{target("no-custom-@var{insn}")} attribute
4268 Each @samp{custom-@var{insn}=@var{N}} attribute locally enables use of a
4269 custom instruction with encoding @var{N} when generating code that uses
4270 @var{insn}. Similarly, @samp{no-custom-@var{insn}} locally inhibits use of
4271 the custom instruction @var{insn}.
4272 These target attributes correspond to the
4273 @option{-mcustom-@var{insn}=@var{N}} and @option{-mno-custom-@var{insn}}
4274 command-line options, and support the same set of @var{insn} keywords.
4275 @xref{Nios II Options}, for more information.
4277 @item custom-fpu-cfg=@var{name}
4278 @cindex @code{target("custom-fpu-cfg=@var{name}")} attribute
4279 This attribute corresponds to the @option{-mcustom-fpu-cfg=@var{name}}
4280 command-line option, to select a predefined set of custom instructions
4282 @xref{Nios II Options}, for more information.
4285 On the x86 and PowerPC back ends, the inliner does not inline a
4286 function that has different target options than the caller, unless the
4287 callee has a subset of the target options of the caller. For example
4288 a function declared with @code{target("sse3")} can inline a function
4289 with @code{target("sse2")}, since @code{-msse3} implies @code{-msse2}.
4292 @cindex tiny data section on the H8/300H and H8S
4293 Use this attribute on the H8/300H and H8S to indicate that the specified
4294 variable should be placed into the tiny data section.
4295 The compiler generates more efficient code for loads and stores
4296 on data in the tiny data section. Note the tiny data area is limited to
4297 slightly under 32KB of data.
4300 @cindex @code{trap_exit} attribute
4301 Use this attribute on the SH for an @code{interrupt_handler} to return using
4302 @code{trapa} instead of @code{rte}. This attribute expects an integer
4303 argument specifying the trap number to be used.
4306 @cindex @code{trapa_handler} attribute
4307 On SH targets this function attribute is similar to @code{interrupt_handler}
4308 but it does not save and restore all registers.
4311 @cindex @code{unused} attribute.
4312 This attribute, attached to a function, means that the function is meant
4313 to be possibly unused. GCC does not produce a warning for this
4317 @cindex @code{used} attribute.
4318 This attribute, attached to a function, means that code must be emitted
4319 for the function even if it appears that the function is not referenced.
4320 This is useful, for example, when the function is referenced only in
4323 When applied to a member function of a C++ class template, the
4324 attribute also means that the function is instantiated if the
4325 class itself is instantiated.
4328 @cindex @code{vector} attribute
4329 This RX attribute is similar to the @code{interrupt} attribute, including its
4330 parameters, but does not make the function an interrupt-handler type
4331 function (i.e. it retains the normal C function calling ABI). See the
4332 @code{interrupt} attribute for a description of its arguments.
4335 @cindex @code{version_id} attribute
4336 This IA-64 HP-UX attribute, attached to a global variable or function, renames a
4337 symbol to contain a version string, thus allowing for function level
4338 versioning. HP-UX system header files may use function level versioning
4339 for some system calls.
4342 extern int foo () __attribute__((version_id ("20040821")));
4346 Calls to @var{foo} are mapped to calls to @var{foo@{20040821@}}.
4348 @item visibility ("@var{visibility_type}")
4349 @cindex @code{visibility} attribute
4350 This attribute affects the linkage of the declaration to which it is attached.
4351 There are four supported @var{visibility_type} values: default,
4352 hidden, protected or internal visibility.
4355 void __attribute__ ((visibility ("protected")))
4356 f () @{ /* @r{Do something.} */; @}
4357 int i __attribute__ ((visibility ("hidden")));
4360 The possible values of @var{visibility_type} correspond to the
4361 visibility settings in the ELF gABI.
4364 @c keep this list of visibilities in alphabetical order.
4367 Default visibility is the normal case for the object file format.
4368 This value is available for the visibility attribute to override other
4369 options that may change the assumed visibility of entities.
4371 On ELF, default visibility means that the declaration is visible to other
4372 modules and, in shared libraries, means that the declared entity may be
4375 On Darwin, default visibility means that the declaration is visible to
4378 Default visibility corresponds to ``external linkage'' in the language.
4381 Hidden visibility indicates that the entity declared has a new
4382 form of linkage, which we call ``hidden linkage''. Two
4383 declarations of an object with hidden linkage refer to the same object
4384 if they are in the same shared object.
4387 Internal visibility is like hidden visibility, but with additional
4388 processor specific semantics. Unless otherwise specified by the
4389 psABI, GCC defines internal visibility to mean that a function is
4390 @emph{never} called from another module. Compare this with hidden
4391 functions which, while they cannot be referenced directly by other
4392 modules, can be referenced indirectly via function pointers. By
4393 indicating that a function cannot be called from outside the module,
4394 GCC may for instance omit the load of a PIC register since it is known
4395 that the calling function loaded the correct value.
4398 Protected visibility is like default visibility except that it
4399 indicates that references within the defining module bind to the
4400 definition in that module. That is, the declared entity cannot be
4401 overridden by another module.
4405 All visibilities are supported on many, but not all, ELF targets
4406 (supported when the assembler supports the @samp{.visibility}
4407 pseudo-op). Default visibility is supported everywhere. Hidden
4408 visibility is supported on Darwin targets.
4410 The visibility attribute should be applied only to declarations that
4411 would otherwise have external linkage. The attribute should be applied
4412 consistently, so that the same entity should not be declared with
4413 different settings of the attribute.
4415 In C++, the visibility attribute applies to types as well as functions
4416 and objects, because in C++ types have linkage. A class must not have
4417 greater visibility than its non-static data member types and bases,
4418 and class members default to the visibility of their class. Also, a
4419 declaration without explicit visibility is limited to the visibility
4422 In C++, you can mark member functions and static member variables of a
4423 class with the visibility attribute. This is useful if you know a
4424 particular method or static member variable should only be used from
4425 one shared object; then you can mark it hidden while the rest of the
4426 class has default visibility. Care must be taken to avoid breaking
4427 the One Definition Rule; for example, it is usually not useful to mark
4428 an inline method as hidden without marking the whole class as hidden.
4430 A C++ namespace declaration can also have the visibility attribute.
4433 namespace nspace1 __attribute__ ((visibility ("protected")))
4434 @{ /* @r{Do something.} */; @}
4437 This attribute applies only to the particular namespace body, not to
4438 other definitions of the same namespace; it is equivalent to using
4439 @samp{#pragma GCC visibility} before and after the namespace
4440 definition (@pxref{Visibility Pragmas}).
4442 In C++, if a template argument has limited visibility, this
4443 restriction is implicitly propagated to the template instantiation.
4444 Otherwise, template instantiations and specializations default to the
4445 visibility of their template.
4447 If both the template and enclosing class have explicit visibility, the
4448 visibility from the template is used.
4451 @cindex @code{vliw} attribute
4452 On MeP, the @code{vliw} attribute tells the compiler to emit
4453 instructions in VLIW mode instead of core mode. Note that this
4454 attribute is not allowed unless a VLIW coprocessor has been configured
4455 and enabled through command-line options.
4457 @item warn_unused_result
4458 @cindex @code{warn_unused_result} attribute
4459 The @code{warn_unused_result} attribute causes a warning to be emitted
4460 if a caller of the function with this attribute does not use its
4461 return value. This is useful for functions where not checking
4462 the result is either a security problem or always a bug, such as
4466 int fn () __attribute__ ((warn_unused_result));
4469 if (fn () < 0) return -1;
4476 results in warning on line 5.
4479 @cindex @code{weak} attribute
4480 The @code{weak} attribute causes the declaration to be emitted as a weak
4481 symbol rather than a global. This is primarily useful in defining
4482 library functions that can be overridden in user code, though it can
4483 also be used with non-function declarations. Weak symbols are supported
4484 for ELF targets, and also for a.out targets when using the GNU assembler
4488 @itemx weakref ("@var{target}")
4489 @cindex @code{weakref} attribute
4490 The @code{weakref} attribute marks a declaration as a weak reference.
4491 Without arguments, it should be accompanied by an @code{alias} attribute
4492 naming the target symbol. Optionally, the @var{target} may be given as
4493 an argument to @code{weakref} itself. In either case, @code{weakref}
4494 implicitly marks the declaration as @code{weak}. Without a
4495 @var{target}, given as an argument to @code{weakref} or to @code{alias},
4496 @code{weakref} is equivalent to @code{weak}.
4499 static int x() __attribute__ ((weakref ("y")));
4500 /* is equivalent to... */
4501 static int x() __attribute__ ((weak, weakref, alias ("y")));
4503 static int x() __attribute__ ((weakref));
4504 static int x() __attribute__ ((alias ("y")));
4507 A weak reference is an alias that does not by itself require a
4508 definition to be given for the target symbol. If the target symbol is
4509 only referenced through weak references, then it becomes a @code{weak}
4510 undefined symbol. If it is directly referenced, however, then such
4511 strong references prevail, and a definition is required for the
4512 symbol, not necessarily in the same translation unit.
4514 The effect is equivalent to moving all references to the alias to a
4515 separate translation unit, renaming the alias to the aliased symbol,
4516 declaring it as weak, compiling the two separate translation units and
4517 performing a reloadable link on them.
4519 At present, a declaration to which @code{weakref} is attached can
4520 only be @code{static}.
4524 You can specify multiple attributes in a declaration by separating them
4525 by commas within the double parentheses or by immediately following an
4526 attribute declaration with another attribute declaration.
4528 @cindex @code{#pragma}, reason for not using
4529 @cindex pragma, reason for not using
4530 Some people object to the @code{__attribute__} feature, suggesting that
4531 ISO C's @code{#pragma} should be used instead. At the time
4532 @code{__attribute__} was designed, there were two reasons for not doing
4537 It is impossible to generate @code{#pragma} commands from a macro.
4540 There is no telling what the same @code{#pragma} might mean in another
4544 These two reasons applied to almost any application that might have been
4545 proposed for @code{#pragma}. It was basically a mistake to use
4546 @code{#pragma} for @emph{anything}.
4548 The ISO C99 standard includes @code{_Pragma}, which now allows pragmas
4549 to be generated from macros. In addition, a @code{#pragma GCC}
4550 namespace is now in use for GCC-specific pragmas. However, it has been
4551 found convenient to use @code{__attribute__} to achieve a natural
4552 attachment of attributes to their corresponding declarations, whereas
4553 @code{#pragma GCC} is of use for constructs that do not naturally form
4554 part of the grammar. @xref{Pragmas,,Pragmas Accepted by GCC}.
4556 @node Label Attributes
4557 @section Label Attributes
4558 @cindex Label Attributes
4560 GCC allows attributes to be set on C labels. @xref{Attribute Syntax}, for
4561 details of the exact syntax for using attributes. Other attributes are
4562 available for functions (@pxref{Function Attributes}), variables
4563 (@pxref{Variable Attributes}) and for types (@pxref{Type Attributes}).
4565 This example uses the @code{cold} label attribute to indicate the
4566 @code{ErrorHandling} branch is unlikely to be taken and that the
4567 @code{ErrorHandling} label is unused:
4571 asm goto ("some asm" : : : : NoError);
4573 /* This branch (the fall-through from the asm) is less commonly used */
4575 __attribute__((cold, unused)); /* Semi-colon is required here */
4580 printf("no error\n");
4586 @cindex @code{unused} label attribute
4587 This feature is intended for program-generated code that may contain
4588 unused labels, but which is compiled with @option{-Wall}. It is
4589 not normally appropriate to use in it human-written code, though it
4590 could be useful in cases where the code that jumps to the label is
4591 contained within an @code{#ifdef} conditional.
4594 @cindex @code{hot} label attribute
4595 The @code{hot} attribute on a label is used to inform the compiler that
4596 the path following the label is more likely than paths that are not so
4597 annotated. This attribute is used in cases where @code{__builtin_expect}
4598 cannot be used, for instance with computed goto or @code{asm goto}.
4601 @cindex @code{cold} label attribute
4602 The @code{cold} attribute on labels is used to inform the compiler that
4603 the path following the label is unlikely to be executed. This attribute
4604 is used in cases where @code{__builtin_expect} cannot be used, for instance
4605 with computed goto or @code{asm goto}.
4609 @node Attribute Syntax
4610 @section Attribute Syntax
4611 @cindex attribute syntax
4613 This section describes the syntax with which @code{__attribute__} may be
4614 used, and the constructs to which attribute specifiers bind, for the C
4615 language. Some details may vary for C++ and Objective-C@. Because of
4616 infelicities in the grammar for attributes, some forms described here
4617 may not be successfully parsed in all cases.
4619 There are some problems with the semantics of attributes in C++. For
4620 example, there are no manglings for attributes, although they may affect
4621 code generation, so problems may arise when attributed types are used in
4622 conjunction with templates or overloading. Similarly, @code{typeid}
4623 does not distinguish between types with different attributes. Support
4624 for attributes in C++ may be restricted in future to attributes on
4625 declarations only, but not on nested declarators.
4627 @xref{Function Attributes}, for details of the semantics of attributes
4628 applying to functions. @xref{Variable Attributes}, for details of the
4629 semantics of attributes applying to variables. @xref{Type Attributes},
4630 for details of the semantics of attributes applying to structure, union
4631 and enumerated types.
4632 @xref{Label Attributes}, for details of the semantics of attributes
4635 An @dfn{attribute specifier} is of the form
4636 @code{__attribute__ ((@var{attribute-list}))}. An @dfn{attribute list}
4637 is a possibly empty comma-separated sequence of @dfn{attributes}, where
4638 each attribute is one of the following:
4642 Empty. Empty attributes are ignored.
4645 A word (which may be an identifier such as @code{unused}, or a reserved
4646 word such as @code{const}).
4649 A word, followed by, in parentheses, parameters for the attribute.
4650 These parameters take one of the following forms:
4654 An identifier. For example, @code{mode} attributes use this form.
4657 An identifier followed by a comma and a non-empty comma-separated list
4658 of expressions. For example, @code{format} attributes use this form.
4661 A possibly empty comma-separated list of expressions. For example,
4662 @code{format_arg} attributes use this form with the list being a single
4663 integer constant expression, and @code{alias} attributes use this form
4664 with the list being a single string constant.
4668 An @dfn{attribute specifier list} is a sequence of one or more attribute
4669 specifiers, not separated by any other tokens.
4671 @subsubheading Label Attributes
4673 In GNU C, an attribute specifier list may appear after the colon following a
4674 label, other than a @code{case} or @code{default} label. GNU C++ only permits
4675 attributes on labels if the attribute specifier is immediately
4676 followed by a semicolon (i.e., the label applies to an empty
4677 statement). If the semicolon is missing, C++ label attributes are
4678 ambiguous, as it is permissible for a declaration, which could begin
4679 with an attribute list, to be labelled in C++. Declarations cannot be
4680 labelled in C90 or C99, so the ambiguity does not arise there.
4682 @subsubheading Type Attributes
4684 An attribute specifier list may appear as part of a @code{struct},
4685 @code{union} or @code{enum} specifier. It may go either immediately
4686 after the @code{struct}, @code{union} or @code{enum} keyword, or after
4687 the closing brace. The former syntax is preferred.
4688 Where attribute specifiers follow the closing brace, they are considered
4689 to relate to the structure, union or enumerated type defined, not to any
4690 enclosing declaration the type specifier appears in, and the type
4691 defined is not complete until after the attribute specifiers.
4692 @c Otherwise, there would be the following problems: a shift/reduce
4693 @c conflict between attributes binding the struct/union/enum and
4694 @c binding to the list of specifiers/qualifiers; and "aligned"
4695 @c attributes could use sizeof for the structure, but the size could be
4696 @c changed later by "packed" attributes.
4699 @subsubheading All other attributes
4701 Otherwise, an attribute specifier appears as part of a declaration,
4702 counting declarations of unnamed parameters and type names, and relates
4703 to that declaration (which may be nested in another declaration, for
4704 example in the case of a parameter declaration), or to a particular declarator
4705 within a declaration. Where an
4706 attribute specifier is applied to a parameter declared as a function or
4707 an array, it should apply to the function or array rather than the
4708 pointer to which the parameter is implicitly converted, but this is not
4709 yet correctly implemented.
4711 Any list of specifiers and qualifiers at the start of a declaration may
4712 contain attribute specifiers, whether or not such a list may in that
4713 context contain storage class specifiers. (Some attributes, however,
4714 are essentially in the nature of storage class specifiers, and only make
4715 sense where storage class specifiers may be used; for example,
4716 @code{section}.) There is one necessary limitation to this syntax: the
4717 first old-style parameter declaration in a function definition cannot
4718 begin with an attribute specifier, because such an attribute applies to
4719 the function instead by syntax described below (which, however, is not
4720 yet implemented in this case). In some other cases, attribute
4721 specifiers are permitted by this grammar but not yet supported by the
4722 compiler. All attribute specifiers in this place relate to the
4723 declaration as a whole. In the obsolescent usage where a type of
4724 @code{int} is implied by the absence of type specifiers, such a list of
4725 specifiers and qualifiers may be an attribute specifier list with no
4726 other specifiers or qualifiers.
4728 At present, the first parameter in a function prototype must have some
4729 type specifier that is not an attribute specifier; this resolves an
4730 ambiguity in the interpretation of @code{void f(int
4731 (__attribute__((foo)) x))}, but is subject to change. At present, if
4732 the parentheses of a function declarator contain only attributes then
4733 those attributes are ignored, rather than yielding an error or warning
4734 or implying a single parameter of type int, but this is subject to
4737 An attribute specifier list may appear immediately before a declarator
4738 (other than the first) in a comma-separated list of declarators in a
4739 declaration of more than one identifier using a single list of
4740 specifiers and qualifiers. Such attribute specifiers apply
4741 only to the identifier before whose declarator they appear. For
4745 __attribute__((noreturn)) void d0 (void),
4746 __attribute__((format(printf, 1, 2))) d1 (const char *, ...),
4751 the @code{noreturn} attribute applies to all the functions
4752 declared; the @code{format} attribute only applies to @code{d1}.
4754 An attribute specifier list may appear immediately before the comma,
4755 @code{=} or semicolon terminating the declaration of an identifier other
4756 than a function definition. Such attribute specifiers apply
4757 to the declared object or function. Where an
4758 assembler name for an object or function is specified (@pxref{Asm
4759 Labels}), the attribute must follow the @code{asm}
4762 An attribute specifier list may, in future, be permitted to appear after
4763 the declarator in a function definition (before any old-style parameter
4764 declarations or the function body).
4766 Attribute specifiers may be mixed with type qualifiers appearing inside
4767 the @code{[]} of a parameter array declarator, in the C99 construct by
4768 which such qualifiers are applied to the pointer to which the array is
4769 implicitly converted. Such attribute specifiers apply to the pointer,
4770 not to the array, but at present this is not implemented and they are
4773 An attribute specifier list may appear at the start of a nested
4774 declarator. At present, there are some limitations in this usage: the
4775 attributes correctly apply to the declarator, but for most individual
4776 attributes the semantics this implies are not implemented.
4777 When attribute specifiers follow the @code{*} of a pointer
4778 declarator, they may be mixed with any type qualifiers present.
4779 The following describes the formal semantics of this syntax. It makes the
4780 most sense if you are familiar with the formal specification of
4781 declarators in the ISO C standard.
4783 Consider (as in C99 subclause 6.7.5 paragraph 4) a declaration @code{T
4784 D1}, where @code{T} contains declaration specifiers that specify a type
4785 @var{Type} (such as @code{int}) and @code{D1} is a declarator that
4786 contains an identifier @var{ident}. The type specified for @var{ident}
4787 for derived declarators whose type does not include an attribute
4788 specifier is as in the ISO C standard.
4790 If @code{D1} has the form @code{( @var{attribute-specifier-list} D )},
4791 and the declaration @code{T D} specifies the type
4792 ``@var{derived-declarator-type-list} @var{Type}'' for @var{ident}, then
4793 @code{T D1} specifies the type ``@var{derived-declarator-type-list}
4794 @var{attribute-specifier-list} @var{Type}'' for @var{ident}.
4796 If @code{D1} has the form @code{*
4797 @var{type-qualifier-and-attribute-specifier-list} D}, and the
4798 declaration @code{T D} specifies the type
4799 ``@var{derived-declarator-type-list} @var{Type}'' for @var{ident}, then
4800 @code{T D1} specifies the type ``@var{derived-declarator-type-list}
4801 @var{type-qualifier-and-attribute-specifier-list} pointer to @var{Type}'' for
4807 void (__attribute__((noreturn)) ****f) (void);
4811 specifies the type ``pointer to pointer to pointer to pointer to
4812 non-returning function returning @code{void}''. As another example,
4815 char *__attribute__((aligned(8))) *f;
4819 specifies the type ``pointer to 8-byte-aligned pointer to @code{char}''.
4820 Note again that this does not work with most attributes; for example,
4821 the usage of @samp{aligned} and @samp{noreturn} attributes given above
4822 is not yet supported.
4824 For compatibility with existing code written for compiler versions that
4825 did not implement attributes on nested declarators, some laxity is
4826 allowed in the placing of attributes. If an attribute that only applies
4827 to types is applied to a declaration, it is treated as applying to
4828 the type of that declaration. If an attribute that only applies to
4829 declarations is applied to the type of a declaration, it is treated
4830 as applying to that declaration; and, for compatibility with code
4831 placing the attributes immediately before the identifier declared, such
4832 an attribute applied to a function return type is treated as
4833 applying to the function type, and such an attribute applied to an array
4834 element type is treated as applying to the array type. If an
4835 attribute that only applies to function types is applied to a
4836 pointer-to-function type, it is treated as applying to the pointer
4837 target type; if such an attribute is applied to a function return type
4838 that is not a pointer-to-function type, it is treated as applying
4839 to the function type.
4841 @node Function Prototypes
4842 @section Prototypes and Old-Style Function Definitions
4843 @cindex function prototype declarations
4844 @cindex old-style function definitions
4845 @cindex promotion of formal parameters
4847 GNU C extends ISO C to allow a function prototype to override a later
4848 old-style non-prototype definition. Consider the following example:
4851 /* @r{Use prototypes unless the compiler is old-fashioned.} */
4858 /* @r{Prototype function declaration.} */
4859 int isroot P((uid_t));
4861 /* @r{Old-style function definition.} */
4863 isroot (x) /* @r{??? lossage here ???} */
4870 Suppose the type @code{uid_t} happens to be @code{short}. ISO C does
4871 not allow this example, because subword arguments in old-style
4872 non-prototype definitions are promoted. Therefore in this example the
4873 function definition's argument is really an @code{int}, which does not
4874 match the prototype argument type of @code{short}.
4876 This restriction of ISO C makes it hard to write code that is portable
4877 to traditional C compilers, because the programmer does not know
4878 whether the @code{uid_t} type is @code{short}, @code{int}, or
4879 @code{long}. Therefore, in cases like these GNU C allows a prototype
4880 to override a later old-style definition. More precisely, in GNU C, a
4881 function prototype argument type overrides the argument type specified
4882 by a later old-style definition if the former type is the same as the
4883 latter type before promotion. Thus in GNU C the above example is
4884 equivalent to the following:
4897 GNU C++ does not support old-style function definitions, so this
4898 extension is irrelevant.
4901 @section C++ Style Comments
4903 @cindex C++ comments
4904 @cindex comments, C++ style
4906 In GNU C, you may use C++ style comments, which start with @samp{//} and
4907 continue until the end of the line. Many other C implementations allow
4908 such comments, and they are included in the 1999 C standard. However,
4909 C++ style comments are not recognized if you specify an @option{-std}
4910 option specifying a version of ISO C before C99, or @option{-ansi}
4911 (equivalent to @option{-std=c90}).
4914 @section Dollar Signs in Identifier Names
4916 @cindex dollar signs in identifier names
4917 @cindex identifier names, dollar signs in
4919 In GNU C, you may normally use dollar signs in identifier names.
4920 This is because many traditional C implementations allow such identifiers.
4921 However, dollar signs in identifiers are not supported on a few target
4922 machines, typically because the target assembler does not allow them.
4924 @node Character Escapes
4925 @section The Character @key{ESC} in Constants
4927 You can use the sequence @samp{\e} in a string or character constant to
4928 stand for the ASCII character @key{ESC}.
4930 @node Variable Attributes
4931 @section Specifying Attributes of Variables
4932 @cindex attribute of variables
4933 @cindex variable attributes
4935 The keyword @code{__attribute__} allows you to specify special
4936 attributes of variables or structure fields. This keyword is followed
4937 by an attribute specification inside double parentheses. Some
4938 attributes are currently defined generically for variables.
4939 Other attributes are defined for variables on particular target
4940 systems. Other attributes are available for functions
4941 (@pxref{Function Attributes}), labels (@pxref{Label Attributes}) and for
4942 types (@pxref{Type Attributes}).
4943 Other front ends might define more attributes
4944 (@pxref{C++ Extensions,,Extensions to the C++ Language}).
4946 You may also specify attributes with @samp{__} preceding and following
4947 each keyword. This allows you to use them in header files without
4948 being concerned about a possible macro of the same name. For example,
4949 you may use @code{__aligned__} instead of @code{aligned}.
4951 @xref{Attribute Syntax}, for details of the exact syntax for using
4955 @cindex @code{aligned} attribute
4956 @item aligned (@var{alignment})
4957 This attribute specifies a minimum alignment for the variable or
4958 structure field, measured in bytes. For example, the declaration:
4961 int x __attribute__ ((aligned (16))) = 0;
4965 causes the compiler to allocate the global variable @code{x} on a
4966 16-byte boundary. On a 68040, this could be used in conjunction with
4967 an @code{asm} expression to access the @code{move16} instruction which
4968 requires 16-byte aligned operands.
4970 You can also specify the alignment of structure fields. For example, to
4971 create a double-word aligned @code{int} pair, you could write:
4974 struct foo @{ int x[2] __attribute__ ((aligned (8))); @};
4978 This is an alternative to creating a union with a @code{double} member,
4979 which forces the union to be double-word aligned.
4981 As in the preceding examples, you can explicitly specify the alignment
4982 (in bytes) that you wish the compiler to use for a given variable or
4983 structure field. Alternatively, you can leave out the alignment factor
4984 and just ask the compiler to align a variable or field to the
4985 default alignment for the target architecture you are compiling for.
4986 The default alignment is sufficient for all scalar types, but may not be
4987 enough for all vector types on a target that supports vector operations.
4988 The default alignment is fixed for a particular target ABI.
4990 GCC also provides a target specific macro @code{__BIGGEST_ALIGNMENT__},
4991 which is the largest alignment ever used for any data type on the
4992 target machine you are compiling for. For example, you could write:
4995 short array[3] __attribute__ ((aligned (__BIGGEST_ALIGNMENT__)));
4998 The compiler automatically sets the alignment for the declared
4999 variable or field to @code{__BIGGEST_ALIGNMENT__}. Doing this can
5000 often make copy operations more efficient, because the compiler can
5001 use whatever instructions copy the biggest chunks of memory when
5002 performing copies to or from the variables or fields that you have
5003 aligned this way. Note that the value of @code{__BIGGEST_ALIGNMENT__}
5004 may change depending on command-line options.
5006 When used on a struct, or struct member, the @code{aligned} attribute can
5007 only increase the alignment; in order to decrease it, the @code{packed}
5008 attribute must be specified as well. When used as part of a typedef, the
5009 @code{aligned} attribute can both increase and decrease alignment, and
5010 specifying the @code{packed} attribute generates a warning.
5012 Note that the effectiveness of @code{aligned} attributes may be limited
5013 by inherent limitations in your linker. On many systems, the linker is
5014 only able to arrange for variables to be aligned up to a certain maximum
5015 alignment. (For some linkers, the maximum supported alignment may
5016 be very very small.) If your linker is only able to align variables
5017 up to a maximum of 8-byte alignment, then specifying @code{aligned(16)}
5018 in an @code{__attribute__} still only provides you with 8-byte
5019 alignment. See your linker documentation for further information.
5021 The @code{aligned} attribute can also be used for functions
5022 (@pxref{Function Attributes}.)
5024 @item cleanup (@var{cleanup_function})
5025 @cindex @code{cleanup} attribute
5026 The @code{cleanup} attribute runs a function when the variable goes
5027 out of scope. This attribute can only be applied to auto function
5028 scope variables; it may not be applied to parameters or variables
5029 with static storage duration. The function must take one parameter,
5030 a pointer to a type compatible with the variable. The return value
5031 of the function (if any) is ignored.
5033 If @option{-fexceptions} is enabled, then @var{cleanup_function}
5034 is run during the stack unwinding that happens during the
5035 processing of the exception. Note that the @code{cleanup} attribute
5036 does not allow the exception to be caught, only to perform an action.
5037 It is undefined what happens if @var{cleanup_function} does not
5042 @cindex @code{common} attribute
5043 @cindex @code{nocommon} attribute
5046 The @code{common} attribute requests GCC to place a variable in
5047 ``common'' storage. The @code{nocommon} attribute requests the
5048 opposite---to allocate space for it directly.
5050 These attributes override the default chosen by the
5051 @option{-fno-common} and @option{-fcommon} flags respectively.
5054 @itemx deprecated (@var{msg})
5055 @cindex @code{deprecated} attribute
5056 The @code{deprecated} attribute results in a warning if the variable
5057 is used anywhere in the source file. This is useful when identifying
5058 variables that are expected to be removed in a future version of a
5059 program. The warning also includes the location of the declaration
5060 of the deprecated variable, to enable users to easily find further
5061 information about why the variable is deprecated, or what they should
5062 do instead. Note that the warning only occurs for uses:
5065 extern int old_var __attribute__ ((deprecated));
5067 int new_fn () @{ return old_var; @}
5071 results in a warning on line 3 but not line 2. The optional @var{msg}
5072 argument, which must be a string, is printed in the warning if
5075 The @code{deprecated} attribute can also be used for functions and
5076 types (@pxref{Function Attributes}, @pxref{Type Attributes}.)
5078 @item mode (@var{mode})
5079 @cindex @code{mode} attribute
5080 This attribute specifies the data type for the declaration---whichever
5081 type corresponds to the mode @var{mode}. This in effect lets you
5082 request an integer or floating-point type according to its width.
5084 You may also specify a mode of @code{byte} or @code{__byte__} to
5085 indicate the mode corresponding to a one-byte integer, @code{word} or
5086 @code{__word__} for the mode of a one-word integer, and @code{pointer}
5087 or @code{__pointer__} for the mode used to represent pointers.
5090 @cindex @code{packed} attribute
5091 The @code{packed} attribute specifies that a variable or structure field
5092 should have the smallest possible alignment---one byte for a variable,
5093 and one bit for a field, unless you specify a larger value with the
5094 @code{aligned} attribute.
5096 Here is a structure in which the field @code{x} is packed, so that it
5097 immediately follows @code{a}:
5103 int x[2] __attribute__ ((packed));
5107 @emph{Note:} The 4.1, 4.2 and 4.3 series of GCC ignore the
5108 @code{packed} attribute on bit-fields of type @code{char}. This has
5109 been fixed in GCC 4.4 but the change can lead to differences in the
5110 structure layout. See the documentation of
5111 @option{-Wpacked-bitfield-compat} for more information.
5113 @item section ("@var{section-name}")
5114 @cindex @code{section} variable attribute
5115 Normally, the compiler places the objects it generates in sections like
5116 @code{data} and @code{bss}. Sometimes, however, you need additional sections,
5117 or you need certain particular variables to appear in special sections,
5118 for example to map to special hardware. The @code{section}
5119 attribute specifies that a variable (or function) lives in a particular
5120 section. For example, this small program uses several specific section names:
5123 struct duart a __attribute__ ((section ("DUART_A"))) = @{ 0 @};
5124 struct duart b __attribute__ ((section ("DUART_B"))) = @{ 0 @};
5125 char stack[10000] __attribute__ ((section ("STACK"))) = @{ 0 @};
5126 int init_data __attribute__ ((section ("INITDATA")));
5130 /* @r{Initialize stack pointer} */
5131 init_sp (stack + sizeof (stack));
5133 /* @r{Initialize initialized data} */
5134 memcpy (&init_data, &data, &edata - &data);
5136 /* @r{Turn on the serial ports} */
5143 Use the @code{section} attribute with
5144 @emph{global} variables and not @emph{local} variables,
5145 as shown in the example.
5147 You may use the @code{section} attribute with initialized or
5148 uninitialized global variables but the linker requires
5149 each object be defined once, with the exception that uninitialized
5150 variables tentatively go in the @code{common} (or @code{bss}) section
5151 and can be multiply ``defined''. Using the @code{section} attribute
5152 changes what section the variable goes into and may cause the
5153 linker to issue an error if an uninitialized variable has multiple
5154 definitions. You can force a variable to be initialized with the
5155 @option{-fno-common} flag or the @code{nocommon} attribute.
5157 Some file formats do not support arbitrary sections so the @code{section}
5158 attribute is not available on all platforms.
5159 If you need to map the entire contents of a module to a particular
5160 section, consider using the facilities of the linker instead.
5163 @cindex @code{shared} variable attribute
5164 On Microsoft Windows, in addition to putting variable definitions in a named
5165 section, the section can also be shared among all running copies of an
5166 executable or DLL@. For example, this small program defines shared data
5167 by putting it in a named section @code{shared} and marking the section
5171 int foo __attribute__((section ("shared"), shared)) = 0;
5176 /* @r{Read and write foo. All running
5177 copies see the same value.} */
5183 You may only use the @code{shared} attribute along with @code{section}
5184 attribute with a fully-initialized global definition because of the way
5185 linkers work. See @code{section} attribute for more information.
5187 The @code{shared} attribute is only available on Microsoft Windows@.
5189 @item tls_model ("@var{tls_model}")
5190 @cindex @code{tls_model} attribute
5191 The @code{tls_model} attribute sets thread-local storage model
5192 (@pxref{Thread-Local}) of a particular @code{__thread} variable,
5193 overriding @option{-ftls-model=} command-line switch on a per-variable
5195 The @var{tls_model} argument should be one of @code{global-dynamic},
5196 @code{local-dynamic}, @code{initial-exec} or @code{local-exec}.
5198 Not all targets support this attribute.
5201 This attribute, attached to a variable, means that the variable is meant
5202 to be possibly unused. GCC does not produce a warning for this
5206 This attribute, attached to a variable with the static storage, means that
5207 the variable must be emitted even if it appears that the variable is not
5210 When applied to a static data member of a C++ class template, the
5211 attribute also means that the member is instantiated if the
5212 class itself is instantiated.
5214 @item vector_size (@var{bytes})
5215 This attribute specifies the vector size for the variable, measured in
5216 bytes. For example, the declaration:
5219 int foo __attribute__ ((vector_size (16)));
5223 causes the compiler to set the mode for @code{foo}, to be 16 bytes,
5224 divided into @code{int} sized units. Assuming a 32-bit int (a vector of
5225 4 units of 4 bytes), the corresponding mode of @code{foo} is V4SI@.
5227 This attribute is only applicable to integral and float scalars,
5228 although arrays, pointers, and function return values are allowed in
5229 conjunction with this construct.
5231 Aggregates with this attribute are invalid, even if they are of the same
5232 size as a corresponding scalar. For example, the declaration:
5235 struct S @{ int a; @};
5236 struct S __attribute__ ((vector_size (16))) foo;
5240 is invalid even if the size of the structure is the same as the size of
5244 The @code{selectany} attribute causes an initialized global variable to
5245 have link-once semantics. When multiple definitions of the variable are
5246 encountered by the linker, the first is selected and the remainder are
5247 discarded. Following usage by the Microsoft compiler, the linker is told
5248 @emph{not} to warn about size or content differences of the multiple
5251 Although the primary usage of this attribute is for POD types, the
5252 attribute can also be applied to global C++ objects that are initialized
5253 by a constructor. In this case, the static initialization and destruction
5254 code for the object is emitted in each translation defining the object,
5255 but the calls to the constructor and destructor are protected by a
5256 link-once guard variable.
5258 The @code{selectany} attribute is only available on Microsoft Windows
5259 targets. You can use @code{__declspec (selectany)} as a synonym for
5260 @code{__attribute__ ((selectany))} for compatibility with other
5264 The @code{weak} attribute is described in @ref{Function Attributes}.
5267 The @code{dllimport} attribute is described in @ref{Function Attributes}.
5270 The @code{dllexport} attribute is described in @ref{Function Attributes}.
5274 @anchor{AVR Variable Attributes}
5275 @subsection AVR Variable Attributes
5279 @cindex @code{progmem} AVR variable attribute
5280 The @code{progmem} attribute is used on the AVR to place read-only
5281 data in the non-volatile program memory (flash). The @code{progmem}
5282 attribute accomplishes this by putting respective variables into a
5283 section whose name starts with @code{.progmem}.
5285 This attribute works similar to the @code{section} attribute
5286 but adds additional checking. Notice that just like the
5287 @code{section} attribute, @code{progmem} affects the location
5288 of the data but not how this data is accessed.
5290 In order to read data located with the @code{progmem} attribute
5291 (inline) assembler must be used.
5293 /* Use custom macros from @w{@uref{http://nongnu.org/avr-libc/user-manual/,AVR-LibC}} */
5294 #include <avr/pgmspace.h>
5296 /* Locate var in flash memory */
5297 const int var[2] PROGMEM = @{ 1, 2 @};
5299 int read_var (int i)
5301 /* Access var[] by accessor macro from avr/pgmspace.h */
5302 return (int) pgm_read_word (& var[i]);
5306 AVR is a Harvard architecture processor and data and read-only data
5307 normally resides in the data memory (RAM).
5309 See also the @ref{AVR Named Address Spaces} section for
5310 an alternate way to locate and access data in flash memory.
5313 @itemx io (@var{addr})
5314 Variables with the @code{io} attribute are used to address
5315 memory-mapped peripherals in the io address range.
5316 If an address is specified, the variable
5317 is assigned that address, and the value is interpreted as an
5318 address in the data address space.
5322 volatile int porta __attribute__((io (0x22)));
5325 The address specified in the address in the data address range.
5327 Otherwise, the variable it is not assigned an address, but the
5328 compiler will still use in/out instructions where applicable,
5329 assuming some other module assigns an address in the io address range.
5333 extern volatile int porta __attribute__((io));
5337 @itemx io_low (@var{addr})
5338 This is like the @code{io} attribute, but additionally it informs the
5339 compiler that the object lies in the lower half of the I/O area,
5340 allowing the use of @code{cbi}, @code{sbi}, @code{sbic} and @code{sbis}
5344 @itemx address (@var{addr})
5345 Variables with the @code{address} attribute are used to address
5346 memory-mapped peripherals that may lie outside the io address range.
5349 volatile int porta __attribute__((address (0x600)));
5354 @subsection Blackfin Variable Attributes
5356 Three attributes are currently defined for the Blackfin.
5362 @cindex @code{l1_data} variable attribute
5363 @cindex @code{l1_data_A} variable attribute
5364 @cindex @code{l1_data_B} variable attribute
5365 Use these attributes on the Blackfin to place the variable into L1 Data SRAM.
5366 Variables with @code{l1_data} attribute are put into the specific section
5367 named @code{.l1.data}. Those with @code{l1_data_A} attribute are put into
5368 the specific section named @code{.l1.data.A}. Those with @code{l1_data_B}
5369 attribute are put into the specific section named @code{.l1.data.B}.
5372 @cindex @code{l2} variable attribute
5373 Use this attribute on the Blackfin to place the variable into L2 SRAM.
5374 Variables with @code{l2} attribute are put into the specific section
5375 named @code{.l2.data}.
5378 @subsection M32R/D Variable Attributes
5380 One attribute is currently defined for the M32R/D@.
5383 @item model (@var{model-name})
5384 @cindex variable addressability on the M32R/D
5385 Use this attribute on the M32R/D to set the addressability of an object.
5386 The identifier @var{model-name} is one of @code{small}, @code{medium},
5387 or @code{large}, representing each of the code models.
5389 Small model objects live in the lower 16MB of memory (so that their
5390 addresses can be loaded with the @code{ld24} instruction).
5392 Medium and large model objects may live anywhere in the 32-bit address space
5393 (the compiler generates @code{seth/add3} instructions to load their
5397 @anchor{MeP Variable Attributes}
5398 @subsection MeP Variable Attributes
5400 The MeP target has a number of addressing modes and busses. The
5401 @code{near} space spans the standard memory space's first 16 megabytes
5402 (24 bits). The @code{far} space spans the entire 32-bit memory space.
5403 The @code{based} space is a 128-byte region in the memory space that
5404 is addressed relative to the @code{$tp} register. The @code{tiny}
5405 space is a 65536-byte region relative to the @code{$gp} register. In
5406 addition to these memory regions, the MeP target has a separate 16-bit
5407 control bus which is specified with @code{cb} attributes.
5412 Any variable with the @code{based} attribute is assigned to the
5413 @code{.based} section, and is accessed with relative to the
5414 @code{$tp} register.
5417 Likewise, the @code{tiny} attribute assigned variables to the
5418 @code{.tiny} section, relative to the @code{$gp} register.
5421 Variables with the @code{near} attribute are assumed to have addresses
5422 that fit in a 24-bit addressing mode. This is the default for large
5423 variables (@code{-mtiny=4} is the default) but this attribute can
5424 override @code{-mtiny=} for small variables, or override @code{-ml}.
5427 Variables with the @code{far} attribute are addressed using a full
5428 32-bit address. Since this covers the entire memory space, this
5429 allows modules to make no assumptions about where variables might be
5433 @itemx io (@var{addr})
5434 Variables with the @code{io} attribute are used to address
5435 memory-mapped peripherals. If an address is specified, the variable
5436 is assigned that address, else it is not assigned an address (it is
5437 assumed some other module assigns an address). Example:
5440 int timer_count __attribute__((io(0x123)));
5444 @itemx cb (@var{addr})
5445 Variables with the @code{cb} attribute are used to access the control
5446 bus, using special instructions. @code{addr} indicates the control bus
5450 int cpu_clock __attribute__((cb(0x123)));
5455 @subsection PowerPC Variable Attributes
5457 Three attributes currently are defined for PowerPC configurations:
5458 @code{altivec}, @code{ms_struct} and @code{gcc_struct}.
5460 For full documentation of the struct attributes please see the
5461 documentation in @ref{x86 Variable Attributes}.
5463 For documentation of @code{altivec} attribute please see the
5464 documentation in @ref{PowerPC Type Attributes}.
5466 @subsection SPU Variable Attributes
5468 The SPU supports the @code{spu_vector} attribute for variables. For
5469 documentation of this attribute please see the documentation in
5470 @ref{SPU Type Attributes}.
5472 @anchor{x86 Variable Attributes}
5473 @subsection x86 Variable Attributes
5475 Two attributes are currently defined for x86 configurations:
5476 @code{ms_struct} and @code{gcc_struct}.
5481 @cindex @code{ms_struct} attribute
5482 @cindex @code{gcc_struct} attribute
5484 If @code{packed} is used on a structure, or if bit-fields are used,
5485 it may be that the Microsoft ABI lays out the structure differently
5486 than the way GCC normally does. Particularly when moving packed
5487 data between functions compiled with GCC and the native Microsoft compiler
5488 (either via function call or as data in a file), it may be necessary to access
5491 Currently @option{-m[no-]ms-bitfields} is provided for the Microsoft Windows x86
5492 compilers to match the native Microsoft compiler.
5494 The Microsoft structure layout algorithm is fairly simple with the exception
5495 of the bit-field packing.
5496 The padding and alignment of members of structures and whether a bit-field
5497 can straddle a storage-unit boundary are determine by these rules:
5500 @item Structure members are stored sequentially in the order in which they are
5501 declared: the first member has the lowest memory address and the last member
5504 @item Every data object has an alignment requirement. The alignment requirement
5505 for all data except structures, unions, and arrays is either the size of the
5506 object or the current packing size (specified with either the
5507 @code{aligned} attribute or the @code{pack} pragma),
5508 whichever is less. For structures, unions, and arrays,
5509 the alignment requirement is the largest alignment requirement of its members.
5510 Every object is allocated an offset so that:
5513 offset % alignment_requirement == 0
5516 @item Adjacent bit-fields are packed into the same 1-, 2-, or 4-byte allocation
5517 unit if the integral types are the same size and if the next bit-field fits
5518 into the current allocation unit without crossing the boundary imposed by the
5519 common alignment requirements of the bit-fields.
5522 MSVC interprets zero-length bit-fields in the following ways:
5525 @item If a zero-length bit-field is inserted between two bit-fields that
5526 are normally coalesced, the bit-fields are not coalesced.
5533 unsigned long bf_1 : 12;
5535 unsigned long bf_2 : 12;
5540 The size of @code{t1} is 8 bytes with the zero-length bit-field. If the
5541 zero-length bit-field were removed, @code{t1}'s size would be 4 bytes.
5543 @item If a zero-length bit-field is inserted after a bit-field, @code{foo}, and the
5544 alignment of the zero-length bit-field is greater than the member that follows it,
5545 @code{bar}, @code{bar} is aligned as the type of the zero-length bit-field.
5566 For @code{t2}, @code{bar} is placed at offset 2, rather than offset 1.
5567 Accordingly, the size of @code{t2} is 4. For @code{t3}, the zero-length
5568 bit-field does not affect the alignment of @code{bar} or, as a result, the size
5571 Taking this into account, it is important to note the following:
5574 @item If a zero-length bit-field follows a normal bit-field, the type of the
5575 zero-length bit-field may affect the alignment of the structure as whole. For
5576 example, @code{t2} has a size of 4 bytes, since the zero-length bit-field follows a
5577 normal bit-field, and is of type short.
5579 @item Even if a zero-length bit-field is not followed by a normal bit-field, it may
5580 still affect the alignment of the structure:
5591 Here, @code{t4} takes up 4 bytes.
5594 @item Zero-length bit-fields following non-bit-field members are ignored:
5606 Here, @code{t5} takes up 2 bytes.
5610 @subsection Xstormy16 Variable Attributes
5612 One attribute is currently defined for xstormy16 configurations:
5617 @cindex @code{below100} attribute
5619 If a variable has the @code{below100} attribute (@code{BELOW100} is
5620 allowed also), GCC places the variable in the first 0x100 bytes of
5621 memory and use special opcodes to access it. Such variables are
5622 placed in either the @code{.bss_below100} section or the
5623 @code{.data_below100} section.
5627 @node Type Attributes
5628 @section Specifying Attributes of Types
5629 @cindex attribute of types
5630 @cindex type attributes
5632 The keyword @code{__attribute__} allows you to specify special
5633 attributes of @code{struct} and @code{union} types when you define
5634 such types. This keyword is followed by an attribute specification
5635 inside double parentheses. Eight attributes are currently defined for
5636 types: @code{aligned}, @code{packed}, @code{transparent_union},
5637 @code{unused}, @code{deprecated}, @code{visibility}, @code{may_alias}
5638 and @code{bnd_variable_size}. Other attributes are defined for
5639 functions (@pxref{Function Attributes}), labels (@pxref{Label
5640 Attributes}) and for variables (@pxref{Variable Attributes}).
5642 You may also specify any one of these attributes with @samp{__}
5643 preceding and following its keyword. This allows you to use these
5644 attributes in header files without being concerned about a possible
5645 macro of the same name. For example, you may use @code{__aligned__}
5646 instead of @code{aligned}.
5648 You may specify type attributes in an enum, struct or union type
5649 declaration or definition, or for other types in a @code{typedef}
5652 For an enum, struct or union type, you may specify attributes either
5653 between the enum, struct or union tag and the name of the type, or
5654 just past the closing curly brace of the @emph{definition}. The
5655 former syntax is preferred.
5657 @xref{Attribute Syntax}, for details of the exact syntax for using
5661 @cindex @code{aligned} attribute
5662 @item aligned (@var{alignment})
5663 This attribute specifies a minimum alignment (in bytes) for variables
5664 of the specified type. For example, the declarations:
5667 struct S @{ short f[3]; @} __attribute__ ((aligned (8)));
5668 typedef int more_aligned_int __attribute__ ((aligned (8)));
5672 force the compiler to ensure (as far as it can) that each variable whose
5673 type is @code{struct S} or @code{more_aligned_int} is allocated and
5674 aligned @emph{at least} on a 8-byte boundary. On a SPARC, having all
5675 variables of type @code{struct S} aligned to 8-byte boundaries allows
5676 the compiler to use the @code{ldd} and @code{std} (doubleword load and
5677 store) instructions when copying one variable of type @code{struct S} to
5678 another, thus improving run-time efficiency.
5680 Note that the alignment of any given @code{struct} or @code{union} type
5681 is required by the ISO C standard to be at least a perfect multiple of
5682 the lowest common multiple of the alignments of all of the members of
5683 the @code{struct} or @code{union} in question. This means that you @emph{can}
5684 effectively adjust the alignment of a @code{struct} or @code{union}
5685 type by attaching an @code{aligned} attribute to any one of the members
5686 of such a type, but the notation illustrated in the example above is a
5687 more obvious, intuitive, and readable way to request the compiler to
5688 adjust the alignment of an entire @code{struct} or @code{union} type.
5690 As in the preceding example, you can explicitly specify the alignment
5691 (in bytes) that you wish the compiler to use for a given @code{struct}
5692 or @code{union} type. Alternatively, you can leave out the alignment factor
5693 and just ask the compiler to align a type to the maximum
5694 useful alignment for the target machine you are compiling for. For
5695 example, you could write:
5698 struct S @{ short f[3]; @} __attribute__ ((aligned));
5701 Whenever you leave out the alignment factor in an @code{aligned}
5702 attribute specification, the compiler automatically sets the alignment
5703 for the type to the largest alignment that is ever used for any data
5704 type on the target machine you are compiling for. Doing this can often
5705 make copy operations more efficient, because the compiler can use
5706 whatever instructions copy the biggest chunks of memory when performing
5707 copies to or from the variables that have types that you have aligned
5710 In the example above, if the size of each @code{short} is 2 bytes, then
5711 the size of the entire @code{struct S} type is 6 bytes. The smallest
5712 power of two that is greater than or equal to that is 8, so the
5713 compiler sets the alignment for the entire @code{struct S} type to 8
5716 Note that although you can ask the compiler to select a time-efficient
5717 alignment for a given type and then declare only individual stand-alone
5718 objects of that type, the compiler's ability to select a time-efficient
5719 alignment is primarily useful only when you plan to create arrays of
5720 variables having the relevant (efficiently aligned) type. If you
5721 declare or use arrays of variables of an efficiently-aligned type, then
5722 it is likely that your program also does pointer arithmetic (or
5723 subscripting, which amounts to the same thing) on pointers to the
5724 relevant type, and the code that the compiler generates for these
5725 pointer arithmetic operations is often more efficient for
5726 efficiently-aligned types than for other types.
5728 The @code{aligned} attribute can only increase the alignment; but you
5729 can decrease it by specifying @code{packed} as well. See below.
5731 Note that the effectiveness of @code{aligned} attributes may be limited
5732 by inherent limitations in your linker. On many systems, the linker is
5733 only able to arrange for variables to be aligned up to a certain maximum
5734 alignment. (For some linkers, the maximum supported alignment may
5735 be very very small.) If your linker is only able to align variables
5736 up to a maximum of 8-byte alignment, then specifying @code{aligned(16)}
5737 in an @code{__attribute__} still only provides you with 8-byte
5738 alignment. See your linker documentation for further information.
5741 This attribute, attached to @code{struct} or @code{union} type
5742 definition, specifies that each member (other than zero-width bit-fields)
5743 of the structure or union is placed to minimize the memory required. When
5744 attached to an @code{enum} definition, it indicates that the smallest
5745 integral type should be used.
5747 @opindex fshort-enums
5748 Specifying this attribute for @code{struct} and @code{union} types is
5749 equivalent to specifying the @code{packed} attribute on each of the
5750 structure or union members. Specifying the @option{-fshort-enums}
5751 flag on the line is equivalent to specifying the @code{packed}
5752 attribute on all @code{enum} definitions.
5754 In the following example @code{struct my_packed_struct}'s members are
5755 packed closely together, but the internal layout of its @code{s} member
5756 is not packed---to do that, @code{struct my_unpacked_struct} needs to
5760 struct my_unpacked_struct
5766 struct __attribute__ ((__packed__)) my_packed_struct
5770 struct my_unpacked_struct s;
5774 You may only specify this attribute on the definition of an @code{enum},
5775 @code{struct} or @code{union}, not on a @code{typedef} that does not
5776 also define the enumerated type, structure or union.
5778 @item transparent_union
5779 @cindex @code{transparent_union} attribute
5781 This attribute, attached to a @code{union} type definition, indicates
5782 that any function parameter having that union type causes calls to that
5783 function to be treated in a special way.
5785 First, the argument corresponding to a transparent union type can be of
5786 any type in the union; no cast is required. Also, if the union contains
5787 a pointer type, the corresponding argument can be a null pointer
5788 constant or a void pointer expression; and if the union contains a void
5789 pointer type, the corresponding argument can be any pointer expression.
5790 If the union member type is a pointer, qualifiers like @code{const} on
5791 the referenced type must be respected, just as with normal pointer
5794 Second, the argument is passed to the function using the calling
5795 conventions of the first member of the transparent union, not the calling
5796 conventions of the union itself. All members of the union must have the
5797 same machine representation; this is necessary for this argument passing
5800 Transparent unions are designed for library functions that have multiple
5801 interfaces for compatibility reasons. For example, suppose the
5802 @code{wait} function must accept either a value of type @code{int *} to
5803 comply with POSIX, or a value of type @code{union wait *} to comply with
5804 the 4.1BSD interface. If @code{wait}'s parameter were @code{void *},
5805 @code{wait} would accept both kinds of arguments, but it would also
5806 accept any other pointer type and this would make argument type checking
5807 less useful. Instead, @code{<sys/wait.h>} might define the interface
5811 typedef union __attribute__ ((__transparent_union__))
5815 @} wait_status_ptr_t;
5817 pid_t wait (wait_status_ptr_t);
5821 This interface allows either @code{int *} or @code{union wait *}
5822 arguments to be passed, using the @code{int *} calling convention.
5823 The program can call @code{wait} with arguments of either type:
5826 int w1 () @{ int w; return wait (&w); @}
5827 int w2 () @{ union wait w; return wait (&w); @}
5831 With this interface, @code{wait}'s implementation might look like this:
5834 pid_t wait (wait_status_ptr_t p)
5836 return waitpid (-1, p.__ip, 0);
5841 When attached to a type (including a @code{union} or a @code{struct}),
5842 this attribute means that variables of that type are meant to appear
5843 possibly unused. GCC does not produce a warning for any variables of
5844 that type, even if the variable appears to do nothing. This is often
5845 the case with lock or thread classes, which are usually defined and then
5846 not referenced, but contain constructors and destructors that have
5847 nontrivial bookkeeping functions.
5850 @itemx deprecated (@var{msg})
5851 The @code{deprecated} attribute results in a warning if the type
5852 is used anywhere in the source file. This is useful when identifying
5853 types that are expected to be removed in a future version of a program.
5854 If possible, the warning also includes the location of the declaration
5855 of the deprecated type, to enable users to easily find further
5856 information about why the type is deprecated, or what they should do
5857 instead. Note that the warnings only occur for uses and then only
5858 if the type is being applied to an identifier that itself is not being
5859 declared as deprecated.
5862 typedef int T1 __attribute__ ((deprecated));
5866 typedef T1 T3 __attribute__ ((deprecated));
5867 T3 z __attribute__ ((deprecated));
5871 results in a warning on line 2 and 3 but not lines 4, 5, or 6. No
5872 warning is issued for line 4 because T2 is not explicitly
5873 deprecated. Line 5 has no warning because T3 is explicitly
5874 deprecated. Similarly for line 6. The optional @var{msg}
5875 argument, which must be a string, is printed in the warning if
5878 The @code{deprecated} attribute can also be used for functions and
5879 variables (@pxref{Function Attributes}, @pxref{Variable Attributes}.)
5882 Accesses through pointers to types with this attribute are not subject
5883 to type-based alias analysis, but are instead assumed to be able to alias
5884 any other type of objects.
5885 In the context of section 6.5 paragraph 7 of the C99 standard,
5886 an lvalue expression
5887 dereferencing such a pointer is treated like having a character type.
5888 See @option{-fstrict-aliasing} for more information on aliasing issues.
5889 This extension exists to support some vector APIs, in which pointers to
5890 one vector type are permitted to alias pointers to a different vector type.
5892 Note that an object of a type with this attribute does not have any
5898 typedef short __attribute__((__may_alias__)) short_a;
5904 short_a *b = (short_a *) &a;
5908 if (a == 0x12345678)
5916 If you replaced @code{short_a} with @code{short} in the variable
5917 declaration, the above program would abort when compiled with
5918 @option{-fstrict-aliasing}, which is on by default at @option{-O2} or
5922 In C++, attribute visibility (@pxref{Function Attributes}) can also be
5923 applied to class, struct, union and enum types. Unlike other type
5924 attributes, the attribute must appear between the initial keyword and
5925 the name of the type; it cannot appear after the body of the type.
5927 Note that the type visibility is applied to vague linkage entities
5928 associated with the class (vtable, typeinfo node, etc.). In
5929 particular, if a class is thrown as an exception in one shared object
5930 and caught in another, the class must have default visibility.
5931 Otherwise the two shared objects are unable to use the same
5932 typeinfo node and exception handling will break.
5934 @item designated_init
5935 This attribute may only be applied to structure types. It indicates
5936 that any initialization of an object of this type must use designated
5937 initializers rather than positional initializers. The intent of this
5938 attribute is to allow the programmer to indicate that a structure's
5939 layout may change, and that therefore relying on positional
5940 initialization will result in future breakage.
5942 GCC emits warnings based on this attribute by default; use
5943 @option{-Wno-designated-init} to suppress them.
5945 @item bnd_variable_size
5946 When applied to a structure field, this attribute tells Pointer
5947 Bounds Checker that the size of this field should not be computed
5948 using static type information. It may be used to mark variable
5949 sized static array fields placed at the end of a structure.
5957 S *p = (S *)malloc (sizeof(S) + 100);
5958 p->data[10] = 0; //Bounds violation
5961 By using an attribute for a field we may avoid bound violation
5962 we most probably do not want to see:
5968 char data[1] __attribute__((bnd_variable_size));
5970 S *p = (S *)malloc (sizeof(S) + 100);
5971 p->data[10] = 0; //OK
5976 To specify multiple attributes, separate them by commas within the
5977 double parentheses: for example, @samp{__attribute__ ((aligned (16),
5980 @subsection ARM Type Attributes
5982 On those ARM targets that support @code{dllimport} (such as Symbian
5983 OS), you can use the @code{notshared} attribute to indicate that the
5984 virtual table and other similar data for a class should not be
5985 exported from a DLL@. For example:
5988 class __declspec(notshared) C @{
5990 __declspec(dllimport) C();
5994 __declspec(dllexport)
5999 In this code, @code{C::C} is exported from the current DLL, but the
6000 virtual table for @code{C} is not exported. (You can use
6001 @code{__attribute__} instead of @code{__declspec} if you prefer, but
6002 most Symbian OS code uses @code{__declspec}.)
6004 @anchor{MeP Type Attributes}
6005 @subsection MeP Type Attributes
6007 Many of the MeP variable attributes may be applied to types as well.
6008 Specifically, the @code{based}, @code{tiny}, @code{near}, and
6009 @code{far} attributes may be applied to either. The @code{io} and
6010 @code{cb} attributes may not be applied to types.
6012 @anchor{PowerPC Type Attributes}
6013 @subsection PowerPC Type Attributes
6015 Three attributes currently are defined for PowerPC configurations:
6016 @code{altivec}, @code{ms_struct} and @code{gcc_struct}.
6018 For full documentation of the @code{ms_struct} and @code{gcc_struct}
6019 attributes please see the documentation in @ref{x86 Type Attributes}.
6021 The @code{altivec} attribute allows one to declare AltiVec vector data
6022 types supported by the AltiVec Programming Interface Manual. The
6023 attribute requires an argument to specify one of three vector types:
6024 @code{vector__}, @code{pixel__} (always followed by unsigned short),
6025 and @code{bool__} (always followed by unsigned).
6028 __attribute__((altivec(vector__)))
6029 __attribute__((altivec(pixel__))) unsigned short
6030 __attribute__((altivec(bool__))) unsigned
6033 These attributes mainly are intended to support the @code{__vector},
6034 @code{__pixel}, and @code{__bool} AltiVec keywords.
6036 @anchor{SPU Type Attributes}
6037 @subsection SPU Type Attributes
6039 The SPU supports the @code{spu_vector} attribute for types. This attribute
6040 allows one to declare vector data types supported by the Sony/Toshiba/IBM SPU
6041 Language Extensions Specification. It is intended to support the
6042 @code{__vector} keyword.
6044 @anchor{x86 Type Attributes}
6045 @subsection x86 Type Attributes
6047 Two attributes are currently defined for x86 configurations:
6048 @code{ms_struct} and @code{gcc_struct}.
6054 @cindex @code{ms_struct}
6055 @cindex @code{gcc_struct}
6057 If @code{packed} is used on a structure, or if bit-fields are used
6058 it may be that the Microsoft ABI packs them differently
6059 than GCC normally packs them. Particularly when moving packed
6060 data between functions compiled with GCC and the native Microsoft compiler
6061 (either via function call or as data in a file), it may be necessary to access
6064 Currently @option{-m[no-]ms-bitfields} is provided for the Microsoft Windows x86
6065 compilers to match the native Microsoft compiler.
6069 @section Inquiring on Alignment of Types or Variables
6071 @cindex type alignment
6072 @cindex variable alignment
6074 The keyword @code{__alignof__} allows you to inquire about how an object
6075 is aligned, or the minimum alignment usually required by a type. Its
6076 syntax is just like @code{sizeof}.
6078 For example, if the target machine requires a @code{double} value to be
6079 aligned on an 8-byte boundary, then @code{__alignof__ (double)} is 8.
6080 This is true on many RISC machines. On more traditional machine
6081 designs, @code{__alignof__ (double)} is 4 or even 2.
6083 Some machines never actually require alignment; they allow reference to any
6084 data type even at an odd address. For these machines, @code{__alignof__}
6085 reports the smallest alignment that GCC gives the data type, usually as
6086 mandated by the target ABI.
6088 If the operand of @code{__alignof__} is an lvalue rather than a type,
6089 its value is the required alignment for its type, taking into account
6090 any minimum alignment specified with GCC's @code{__attribute__}
6091 extension (@pxref{Variable Attributes}). For example, after this
6095 struct foo @{ int x; char y; @} foo1;
6099 the value of @code{__alignof__ (foo1.y)} is 1, even though its actual
6100 alignment is probably 2 or 4, the same as @code{__alignof__ (int)}.
6102 It is an error to ask for the alignment of an incomplete type.
6106 @section An Inline Function is As Fast As a Macro
6107 @cindex inline functions
6108 @cindex integrating function code
6110 @cindex macros, inline alternative
6112 By declaring a function inline, you can direct GCC to make
6113 calls to that function faster. One way GCC can achieve this is to
6114 integrate that function's code into the code for its callers. This
6115 makes execution faster by eliminating the function-call overhead; in
6116 addition, if any of the actual argument values are constant, their
6117 known values may permit simplifications at compile time so that not
6118 all of the inline function's code needs to be included. The effect on
6119 code size is less predictable; object code may be larger or smaller
6120 with function inlining, depending on the particular case. You can
6121 also direct GCC to try to integrate all ``simple enough'' functions
6122 into their callers with the option @option{-finline-functions}.
6124 GCC implements three different semantics of declaring a function
6125 inline. One is available with @option{-std=gnu89} or
6126 @option{-fgnu89-inline} or when @code{gnu_inline} attribute is present
6127 on all inline declarations, another when
6128 @option{-std=c99}, @option{-std=c11},
6129 @option{-std=gnu99} or @option{-std=gnu11}
6130 (without @option{-fgnu89-inline}), and the third
6131 is used when compiling C++.
6133 To declare a function inline, use the @code{inline} keyword in its
6134 declaration, like this:
6144 If you are writing a header file to be included in ISO C90 programs, write
6145 @code{__inline__} instead of @code{inline}. @xref{Alternate Keywords}.
6147 The three types of inlining behave similarly in two important cases:
6148 when the @code{inline} keyword is used on a @code{static} function,
6149 like the example above, and when a function is first declared without
6150 using the @code{inline} keyword and then is defined with
6151 @code{inline}, like this:
6154 extern int inc (int *a);
6162 In both of these common cases, the program behaves the same as if you
6163 had not used the @code{inline} keyword, except for its speed.
6165 @cindex inline functions, omission of
6166 @opindex fkeep-inline-functions
6167 When a function is both inline and @code{static}, if all calls to the
6168 function are integrated into the caller, and the function's address is
6169 never used, then the function's own assembler code is never referenced.
6170 In this case, GCC does not actually output assembler code for the
6171 function, unless you specify the option @option{-fkeep-inline-functions}.
6172 Some calls cannot be integrated for various reasons (in particular,
6173 calls that precede the function's definition cannot be integrated, and
6174 neither can recursive calls within the definition). If there is a
6175 nonintegrated call, then the function is compiled to assembler code as
6176 usual. The function must also be compiled as usual if the program
6177 refers to its address, because that can't be inlined.
6180 Note that certain usages in a function definition can make it unsuitable
6181 for inline substitution. Among these usages are: variadic functions, use of
6182 @code{alloca}, use of variable-length data types (@pxref{Variable Length}),
6183 use of computed goto (@pxref{Labels as Values}), use of nonlocal goto,
6184 and nested functions (@pxref{Nested Functions}). Using @option{-Winline}
6185 warns when a function marked @code{inline} could not be substituted,
6186 and gives the reason for the failure.
6188 @cindex automatic @code{inline} for C++ member fns
6189 @cindex @code{inline} automatic for C++ member fns
6190 @cindex member fns, automatically @code{inline}
6191 @cindex C++ member fns, automatically @code{inline}
6192 @opindex fno-default-inline
6193 As required by ISO C++, GCC considers member functions defined within
6194 the body of a class to be marked inline even if they are
6195 not explicitly declared with the @code{inline} keyword. You can
6196 override this with @option{-fno-default-inline}; @pxref{C++ Dialect
6197 Options,,Options Controlling C++ Dialect}.
6199 GCC does not inline any functions when not optimizing unless you specify
6200 the @samp{always_inline} attribute for the function, like this:
6203 /* @r{Prototype.} */
6204 inline void foo (const char) __attribute__((always_inline));
6207 The remainder of this section is specific to GNU C90 inlining.
6209 @cindex non-static inline function
6210 When an inline function is not @code{static}, then the compiler must assume
6211 that there may be calls from other source files; since a global symbol can
6212 be defined only once in any program, the function must not be defined in
6213 the other source files, so the calls therein cannot be integrated.
6214 Therefore, a non-@code{static} inline function is always compiled on its
6215 own in the usual fashion.
6217 If you specify both @code{inline} and @code{extern} in the function
6218 definition, then the definition is used only for inlining. In no case
6219 is the function compiled on its own, not even if you refer to its
6220 address explicitly. Such an address becomes an external reference, as
6221 if you had only declared the function, and had not defined it.
6223 This combination of @code{inline} and @code{extern} has almost the
6224 effect of a macro. The way to use it is to put a function definition in
6225 a header file with these keywords, and put another copy of the
6226 definition (lacking @code{inline} and @code{extern}) in a library file.
6227 The definition in the header file causes most calls to the function
6228 to be inlined. If any uses of the function remain, they refer to
6229 the single copy in the library.
6232 @section When is a Volatile Object Accessed?
6233 @cindex accessing volatiles
6234 @cindex volatile read
6235 @cindex volatile write
6236 @cindex volatile access
6238 C has the concept of volatile objects. These are normally accessed by
6239 pointers and used for accessing hardware or inter-thread
6240 communication. The standard encourages compilers to refrain from
6241 optimizations concerning accesses to volatile objects, but leaves it
6242 implementation defined as to what constitutes a volatile access. The
6243 minimum requirement is that at a sequence point all previous accesses
6244 to volatile objects have stabilized and no subsequent accesses have
6245 occurred. Thus an implementation is free to reorder and combine
6246 volatile accesses that occur between sequence points, but cannot do
6247 so for accesses across a sequence point. The use of volatile does
6248 not allow you to violate the restriction on updating objects multiple
6249 times between two sequence points.
6251 Accesses to non-volatile objects are not ordered with respect to
6252 volatile accesses. You cannot use a volatile object as a memory
6253 barrier to order a sequence of writes to non-volatile memory. For
6257 int *ptr = @var{something};
6259 *ptr = @var{something};
6264 Unless @var{*ptr} and @var{vobj} can be aliased, it is not guaranteed
6265 that the write to @var{*ptr} occurs by the time the update
6266 of @var{vobj} happens. If you need this guarantee, you must use
6267 a stronger memory barrier such as:
6270 int *ptr = @var{something};
6272 *ptr = @var{something};
6273 asm volatile ("" : : : "memory");
6277 A scalar volatile object is read when it is accessed in a void context:
6280 volatile int *src = @var{somevalue};
6284 Such expressions are rvalues, and GCC implements this as a
6285 read of the volatile object being pointed to.
6287 Assignments are also expressions and have an rvalue. However when
6288 assigning to a scalar volatile, the volatile object is not reread,
6289 regardless of whether the assignment expression's rvalue is used or
6290 not. If the assignment's rvalue is used, the value is that assigned
6291 to the volatile object. For instance, there is no read of @var{vobj}
6292 in all the following cases:
6297 vobj = @var{something};
6298 obj = vobj = @var{something};
6299 obj ? vobj = @var{onething} : vobj = @var{anotherthing};
6300 obj = (@var{something}, vobj = @var{anotherthing});
6303 If you need to read the volatile object after an assignment has
6304 occurred, you must use a separate expression with an intervening
6307 As bit-fields are not individually addressable, volatile bit-fields may
6308 be implicitly read when written to, or when adjacent bit-fields are
6309 accessed. Bit-field operations may be optimized such that adjacent
6310 bit-fields are only partially accessed, if they straddle a storage unit
6311 boundary. For these reasons it is unwise to use volatile bit-fields to
6314 @node Using Assembly Language with C
6315 @section How to Use Inline Assembly Language in C Code
6316 @cindex @code{asm} keyword
6317 @cindex assembly language in C
6318 @cindex inline assembly language
6319 @cindex mixing assembly language and C
6321 The @code{asm} keyword allows you to embed assembler instructions
6322 within C code. GCC provides two forms of inline @code{asm}
6323 statements. A @dfn{basic @code{asm}} statement is one with no
6324 operands (@pxref{Basic Asm}), while an @dfn{extended @code{asm}}
6325 statement (@pxref{Extended Asm}) includes one or more operands.
6326 The extended form is preferred for mixing C and assembly language
6327 within a function, but to include assembly language at
6328 top level you must use basic @code{asm}.
6330 You can also use the @code{asm} keyword to override the assembler name
6331 for a C symbol, or to place a C variable in a specific register.
6334 * Basic Asm:: Inline assembler without operands.
6335 * Extended Asm:: Inline assembler with operands.
6336 * Constraints:: Constraints for @code{asm} operands
6337 * Asm Labels:: Specifying the assembler name to use for a C symbol.
6338 * Explicit Reg Vars:: Defining variables residing in specified registers.
6339 * Size of an asm:: How GCC calculates the size of an @code{asm} block.
6343 @subsection Basic Asm --- Assembler Instructions Without Operands
6344 @cindex basic @code{asm}
6345 @cindex assembly language in C, basic
6347 A basic @code{asm} statement has the following syntax:
6350 asm @r{[} volatile @r{]} ( @var{AssemblerInstructions} )
6353 The @code{asm} keyword is a GNU extension.
6354 When writing code that can be compiled with @option{-ansi} and the
6355 various @option{-std} options, use @code{__asm__} instead of
6356 @code{asm} (@pxref{Alternate Keywords}).
6358 @subsubheading Qualifiers
6361 The optional @code{volatile} qualifier has no effect.
6362 All basic @code{asm} blocks are implicitly volatile.
6365 @subsubheading Parameters
6368 @item AssemblerInstructions
6369 This is a literal string that specifies the assembler code. The string can
6370 contain any instructions recognized by the assembler, including directives.
6371 GCC does not parse the assembler instructions themselves and
6372 does not know what they mean or even whether they are valid assembler input.
6374 You may place multiple assembler instructions together in a single @code{asm}
6375 string, separated by the characters normally used in assembly code for the
6376 system. A combination that works in most places is a newline to break the
6377 line, plus a tab character (written as @samp{\n\t}).
6378 Some assemblers allow semicolons as a line separator. However,
6379 note that some assembler dialects use semicolons to start a comment.
6382 @subsubheading Remarks
6383 Using extended @code{asm} typically produces smaller, safer, and more
6384 efficient code, and in most cases it is a better solution than basic
6385 @code{asm}. However, there are two situations where only basic @code{asm}
6390 Extended @code{asm} statements have to be inside a C
6391 function, so to write inline assembly language at file scope (``top-level''),
6392 outside of C functions, you must use basic @code{asm}.
6393 You can use this technique to emit assembler directives,
6394 define assembly language macros that can be invoked elsewhere in the file,
6395 or write entire functions in assembly language.
6399 with the @code{naked} attribute also require basic @code{asm}
6400 (@pxref{Function Attributes}).
6403 Safely accessing C data and calling functions from basic @code{asm} is more
6404 complex than it may appear. To access C data, it is better to use extended
6407 Do not expect a sequence of @code{asm} statements to remain perfectly
6408 consecutive after compilation. If certain instructions need to remain
6409 consecutive in the output, put them in a single multi-instruction @code{asm}
6410 statement. Note that GCC's optimizers can move @code{asm} statements
6411 relative to other code, including across jumps.
6413 @code{asm} statements may not perform jumps into other @code{asm} statements.
6414 GCC does not know about these jumps, and therefore cannot take
6415 account of them when deciding how to optimize. Jumps from @code{asm} to C
6416 labels are only supported in extended @code{asm}.
6418 Under certain circumstances, GCC may duplicate (or remove duplicates of) your
6419 assembly code when optimizing. This can lead to unexpected duplicate
6420 symbol errors during compilation if your assembly code defines symbols or
6423 Since GCC does not parse the @var{AssemblerInstructions}, it has no
6424 visibility of any symbols it references. This may result in GCC discarding
6425 those symbols as unreferenced.
6427 The compiler copies the assembler instructions in a basic @code{asm}
6428 verbatim to the assembly language output file, without
6429 processing dialects or any of the @samp{%} operators that are available with
6430 extended @code{asm}. This results in minor differences between basic
6431 @code{asm} strings and extended @code{asm} templates. For example, to refer to
6432 registers you might use @samp{%eax} in basic @code{asm} and
6433 @samp{%%eax} in extended @code{asm}.
6435 On targets such as x86 that support multiple assembler dialects,
6436 all basic @code{asm} blocks use the assembler dialect specified by the
6437 @option{-masm} command-line option (@pxref{x86 Options}).
6438 Basic @code{asm} provides no
6439 mechanism to provide different assembler strings for different dialects.
6441 Here is an example of basic @code{asm} for i386:
6444 /* Note that this code will not compile with -masm=intel */
6445 #define DebugBreak() asm("int $3")
6449 @subsection Extended Asm - Assembler Instructions with C Expression Operands
6450 @cindex extended @code{asm}
6451 @cindex assembly language in C, extended
6453 With extended @code{asm} you can read and write C variables from
6454 assembler and perform jumps from assembler code to C labels.
6455 Extended @code{asm} syntax uses colons (@samp{:}) to delimit
6456 the operand parameters after the assembler template:
6459 asm @r{[}volatile@r{]} ( @var{AssemblerTemplate}
6460 : @var{OutputOperands}
6461 @r{[} : @var{InputOperands}
6462 @r{[} : @var{Clobbers} @r{]} @r{]})
6464 asm @r{[}volatile@r{]} goto ( @var{AssemblerTemplate}
6466 : @var{InputOperands}
6471 The @code{asm} keyword is a GNU extension.
6472 When writing code that can be compiled with @option{-ansi} and the
6473 various @option{-std} options, use @code{__asm__} instead of
6474 @code{asm} (@pxref{Alternate Keywords}).
6476 @subsubheading Qualifiers
6480 The typical use of extended @code{asm} statements is to manipulate input
6481 values to produce output values. However, your @code{asm} statements may
6482 also produce side effects. If so, you may need to use the @code{volatile}
6483 qualifier to disable certain optimizations. @xref{Volatile}.
6486 This qualifier informs the compiler that the @code{asm} statement may
6487 perform a jump to one of the labels listed in the @var{GotoLabels}.
6491 @subsubheading Parameters
6493 @item AssemblerTemplate
6494 This is a literal string that is the template for the assembler code. It is a
6495 combination of fixed text and tokens that refer to the input, output,
6496 and goto parameters. @xref{AssemblerTemplate}.
6498 @item OutputOperands
6499 A comma-separated list of the C variables modified by the instructions in the
6500 @var{AssemblerTemplate}. An empty list is permitted. @xref{OutputOperands}.
6503 A comma-separated list of C expressions read by the instructions in the
6504 @var{AssemblerTemplate}. An empty list is permitted. @xref{InputOperands}.
6507 A comma-separated list of registers or other values changed by the
6508 @var{AssemblerTemplate}, beyond those listed as outputs.
6509 An empty list is permitted. @xref{Clobbers}.
6512 When you are using the @code{goto} form of @code{asm}, this section contains
6513 the list of all C labels to which the code in the
6514 @var{AssemblerTemplate} may jump.
6517 @code{asm} statements may not perform jumps into other @code{asm} statements,
6518 only to the listed @var{GotoLabels}.
6519 GCC's optimizers do not know about other jumps; therefore they cannot take
6520 account of them when deciding how to optimize.
6523 The total number of input + output + goto operands is limited to 30.
6525 @subsubheading Remarks
6526 The @code{asm} statement allows you to include assembly instructions directly
6527 within C code. This may help you to maximize performance in time-sensitive
6528 code or to access assembly instructions that are not readily available to C
6531 Note that extended @code{asm} statements must be inside a function. Only
6532 basic @code{asm} may be outside functions (@pxref{Basic Asm}).
6533 Functions declared with the @code{naked} attribute also require basic
6534 @code{asm} (@pxref{Function Attributes}).
6536 While the uses of @code{asm} are many and varied, it may help to think of an
6537 @code{asm} statement as a series of low-level instructions that convert input
6538 parameters to output parameters. So a simple (if not particularly useful)
6539 example for i386 using @code{asm} might look like this:
6545 asm ("mov %1, %0\n\t"
6550 printf("%d\n", dst);
6553 This code copies @code{src} to @code{dst} and add 1 to @code{dst}.
6556 @subsubsection Volatile
6557 @cindex volatile @code{asm}
6558 @cindex @code{asm} volatile
6560 GCC's optimizers sometimes discard @code{asm} statements if they determine
6561 there is no need for the output variables. Also, the optimizers may move
6562 code out of loops if they believe that the code will always return the same
6563 result (i.e. none of its input values change between calls). Using the
6564 @code{volatile} qualifier disables these optimizations. @code{asm} statements
6565 that have no output operands, including @code{asm goto} statements,
6566 are implicitly volatile.
6568 This i386 code demonstrates a case that does not use (or require) the
6569 @code{volatile} qualifier. If it is performing assertion checking, this code
6570 uses @code{asm} to perform the validation. Otherwise, @code{dwRes} is
6571 unreferenced by any code. As a result, the optimizers can discard the
6572 @code{asm} statement, which in turn removes the need for the entire
6573 @code{DoCheck} routine. By omitting the @code{volatile} qualifier when it
6574 isn't needed you allow the optimizers to produce the most efficient code
6578 void DoCheck(uint32_t dwSomeValue)
6582 // Assumes dwSomeValue is not zero.
6592 The next example shows a case where the optimizers can recognize that the input
6593 (@code{dwSomeValue}) never changes during the execution of the function and can
6594 therefore move the @code{asm} outside the loop to produce more efficient code.
6595 Again, using @code{volatile} disables this type of optimization.
6598 void do_print(uint32_t dwSomeValue)
6602 for (uint32_t x=0; x < 5; x++)
6604 // Assumes dwSomeValue is not zero.
6610 printf("%u: %u %u\n", x, dwSomeValue, dwRes);
6615 The following example demonstrates a case where you need to use the
6616 @code{volatile} qualifier.
6617 It uses the x86 @code{rdtsc} instruction, which reads
6618 the computer's time-stamp counter. Without the @code{volatile} qualifier,
6619 the optimizers might assume that the @code{asm} block will always return the
6620 same value and therefore optimize away the second call.
6625 asm volatile ( "rdtsc\n\t" // Returns the time in EDX:EAX.
6626 "shl $32, %%rdx\n\t" // Shift the upper bits left.
6627 "or %%rdx, %0" // 'Or' in the lower bits.
6632 printf("msr: %llx\n", msr);
6636 // Reprint the timestamp
6637 asm volatile ( "rdtsc\n\t" // Returns the time in EDX:EAX.
6638 "shl $32, %%rdx\n\t" // Shift the upper bits left.
6639 "or %%rdx, %0" // 'Or' in the lower bits.
6644 printf("msr: %llx\n", msr);
6647 GCC's optimizers do not treat this code like the non-volatile code in the
6648 earlier examples. They do not move it out of loops or omit it on the
6649 assumption that the result from a previous call is still valid.
6651 Note that the compiler can move even volatile @code{asm} instructions relative
6652 to other code, including across jump instructions. For example, on many
6653 targets there is a system register that controls the rounding mode of
6654 floating-point operations. Setting it with a volatile @code{asm}, as in the
6655 following PowerPC example, does not work reliably.
6658 asm volatile("mtfsf 255, %0" : : "f" (fpenv));
6662 The compiler may move the addition back before the volatile @code{asm}. To
6663 make it work as expected, add an artificial dependency to the @code{asm} by
6664 referencing a variable in the subsequent code, for example:
6667 asm volatile ("mtfsf 255,%1" : "=X" (sum) : "f" (fpenv));
6671 Under certain circumstances, GCC may duplicate (or remove duplicates of) your
6672 assembly code when optimizing. This can lead to unexpected duplicate symbol
6673 errors during compilation if your asm code defines symbols or labels.
6675 (@pxref{AssemblerTemplate}) may help resolve this problem.
6677 @anchor{AssemblerTemplate}
6678 @subsubsection Assembler Template
6679 @cindex @code{asm} assembler template
6681 An assembler template is a literal string containing assembler instructions.
6682 The compiler replaces tokens in the template that refer
6683 to inputs, outputs, and goto labels,
6684 and then outputs the resulting string to the assembler. The
6685 string can contain any instructions recognized by the assembler, including
6686 directives. GCC does not parse the assembler instructions
6687 themselves and does not know what they mean or even whether they are valid
6688 assembler input. However, it does count the statements
6689 (@pxref{Size of an asm}).
6691 You may place multiple assembler instructions together in a single @code{asm}
6692 string, separated by the characters normally used in assembly code for the
6693 system. A combination that works in most places is a newline to break the
6694 line, plus a tab character to move to the instruction field (written as
6696 Some assemblers allow semicolons as a line separator. However, note
6697 that some assembler dialects use semicolons to start a comment.
6699 Do not expect a sequence of @code{asm} statements to remain perfectly
6700 consecutive after compilation, even when you are using the @code{volatile}
6701 qualifier. If certain instructions need to remain consecutive in the output,
6702 put them in a single multi-instruction asm statement.
6704 Accessing data from C programs without using input/output operands (such as
6705 by using global symbols directly from the assembler template) may not work as
6706 expected. Similarly, calling functions directly from an assembler template
6707 requires a detailed understanding of the target assembler and ABI.
6709 Since GCC does not parse the assembler template,
6710 it has no visibility of any
6711 symbols it references. This may result in GCC discarding those symbols as
6712 unreferenced unless they are also listed as input, output, or goto operands.
6714 @subsubheading Special format strings
6716 In addition to the tokens described by the input, output, and goto operands,
6717 these tokens have special meanings in the assembler template:
6721 Outputs a single @samp{%} into the assembler code.
6724 Outputs a number that is unique to each instance of the @code{asm}
6725 statement in the entire compilation. This option is useful when creating local
6726 labels and referring to them multiple times in a single template that
6727 generates multiple assembler instructions.
6732 Outputs @samp{@{}, @samp{|}, and @samp{@}} characters (respectively)
6733 into the assembler code. When unescaped, these characters have special
6734 meaning to indicate multiple assembler dialects, as described below.
6737 @subsubheading Multiple assembler dialects in @code{asm} templates
6739 On targets such as x86, GCC supports multiple assembler dialects.
6740 The @option{-masm} option controls which dialect GCC uses as its
6741 default for inline assembler. The target-specific documentation for the
6742 @option{-masm} option contains the list of supported dialects, as well as the
6743 default dialect if the option is not specified. This information may be
6744 important to understand, since assembler code that works correctly when
6745 compiled using one dialect will likely fail if compiled using another.
6748 If your code needs to support multiple assembler dialects (for example, if
6749 you are writing public headers that need to support a variety of compilation
6750 options), use constructs of this form:
6753 @{ dialect0 | dialect1 | dialect2... @}
6756 This construct outputs @code{dialect0}
6757 when using dialect #0 to compile the code,
6758 @code{dialect1} for dialect #1, etc. If there are fewer alternatives within the
6759 braces than the number of dialects the compiler supports, the construct
6762 For example, if an x86 compiler supports two dialects
6763 (@samp{att}, @samp{intel}), an
6764 assembler template such as this:
6767 "bt@{l %[Offset],%[Base] | %[Base],%[Offset]@}; jc %l2"
6771 is equivalent to one of
6774 "btl %[Offset],%[Base] ; jc %l2" @r{/* att dialect */}
6775 "bt %[Base],%[Offset]; jc %l2" @r{/* intel dialect */}
6778 Using that same compiler, this code:
6781 "xchg@{l@}\t@{%%@}ebx, %1"
6785 corresponds to either
6788 "xchgl\t%%ebx, %1" @r{/* att dialect */}
6789 "xchg\tebx, %1" @r{/* intel dialect */}
6792 There is no support for nesting dialect alternatives.
6794 @anchor{OutputOperands}
6795 @subsubsection Output Operands
6796 @cindex @code{asm} output operands
6798 An @code{asm} statement has zero or more output operands indicating the names
6799 of C variables modified by the assembler code.
6801 In this i386 example, @code{old} (referred to in the template string as
6802 @code{%0}) and @code{*Base} (as @code{%1}) are outputs and @code{Offset}
6803 (@code{%2}) is an input:
6808 __asm__ ("btsl %2,%1\n\t" // Turn on zero-based bit #Offset in Base.
6809 "sbb %0,%0" // Use the CF to calculate old.
6810 : "=r" (old), "+rm" (*Base)
6817 Operands are separated by commas. Each operand has this format:
6820 @r{[} [@var{asmSymbolicName}] @r{]} @var{constraint} (@var{cvariablename})
6824 @item asmSymbolicName
6825 Specifies a symbolic name for the operand.
6826 Reference the name in the assembler template
6827 by enclosing it in square brackets
6828 (i.e. @samp{%[Value]}). The scope of the name is the @code{asm} statement
6829 that contains the definition. Any valid C variable name is acceptable,
6830 including names already defined in the surrounding code. No two operands
6831 within the same @code{asm} statement can use the same symbolic name.
6833 When not using an @var{asmSymbolicName}, use the (zero-based) position
6835 in the list of operands in the assembler template. For example if there are
6836 three output operands, use @samp{%0} in the template to refer to the first,
6837 @samp{%1} for the second, and @samp{%2} for the third.
6840 A string constant specifying constraints on the placement of the operand;
6841 @xref{Constraints}, for details.
6843 Output constraints must begin with either @samp{=} (a variable overwriting an
6844 existing value) or @samp{+} (when reading and writing). When using
6845 @samp{=}, do not assume the location contains the existing value
6846 on entry to the @code{asm}, except
6847 when the operand is tied to an input; @pxref{InputOperands,,Input Operands}.
6849 After the prefix, there must be one or more additional constraints
6850 (@pxref{Constraints}) that describe where the value resides. Common
6851 constraints include @samp{r} for register and @samp{m} for memory.
6852 When you list more than one possible location (for example, @code{"=rm"}),
6853 the compiler chooses the most efficient one based on the current context.
6854 If you list as many alternates as the @code{asm} statement allows, you permit
6855 the optimizers to produce the best possible code.
6856 If you must use a specific register, but your Machine Constraints do not
6857 provide sufficient control to select the specific register you want,
6858 local register variables may provide a solution (@pxref{Local Reg Vars}).
6861 Specifies a C lvalue expression to hold the output, typically a variable name.
6862 The enclosing parentheses are a required part of the syntax.
6866 When the compiler selects the registers to use to
6867 represent the output operands, it does not use any of the clobbered registers
6870 Output operand expressions must be lvalues. The compiler cannot check whether
6871 the operands have data types that are reasonable for the instruction being
6872 executed. For output expressions that are not directly addressable (for
6873 example a bit-field), the constraint must allow a register. In that case, GCC
6874 uses the register as the output of the @code{asm}, and then stores that
6875 register into the output.
6877 Operands using the @samp{+} constraint modifier count as two operands
6878 (that is, both as input and output) towards the total maximum of 30 operands
6879 per @code{asm} statement.
6881 Use the @samp{&} constraint modifier (@pxref{Modifiers}) on all output
6882 operands that must not overlap an input. Otherwise,
6883 GCC may allocate the output operand in the same register as an unrelated
6884 input operand, on the assumption that the assembler code consumes its
6885 inputs before producing outputs. This assumption may be false if the assembler
6886 code actually consists of more than one instruction.
6888 The same problem can occur if one output parameter (@var{a}) allows a register
6889 constraint and another output parameter (@var{b}) allows a memory constraint.
6890 The code generated by GCC to access the memory address in @var{b} can contain
6891 registers which @emph{might} be shared by @var{a}, and GCC considers those
6892 registers to be inputs to the asm. As above, GCC assumes that such input
6893 registers are consumed before any outputs are written. This assumption may
6894 result in incorrect behavior if the asm writes to @var{a} before using
6895 @var{b}. Combining the @samp{&} modifier with the register constraint on @var{a}
6896 ensures that modifying @var{a} does not affect the address referenced by
6897 @var{b}. Otherwise, the location of @var{b}
6898 is undefined if @var{a} is modified before using @var{b}.
6900 @code{asm} supports operand modifiers on operands (for example @samp{%k2}
6901 instead of simply @samp{%2}). Typically these qualifiers are hardware
6902 dependent. The list of supported modifiers for x86 is found at
6903 @ref{x86Operandmodifiers,x86 Operand modifiers}.
6905 If the C code that follows the @code{asm} makes no use of any of the output
6906 operands, use @code{volatile} for the @code{asm} statement to prevent the
6907 optimizers from discarding the @code{asm} statement as unneeded
6908 (see @ref{Volatile}).
6910 This code makes no use of the optional @var{asmSymbolicName}. Therefore it
6911 references the first output operand as @code{%0} (were there a second, it
6912 would be @code{%1}, etc). The number of the first input operand is one greater
6913 than that of the last output operand. In this i386 example, that makes
6914 @code{Mask} referenced as @code{%1}:
6917 uint32_t Mask = 1234;
6926 That code overwrites the variable @code{Index} (@samp{=}),
6927 placing the value in a register (@samp{r}).
6928 Using the generic @samp{r} constraint instead of a constraint for a specific
6929 register allows the compiler to pick the register to use, which can result
6930 in more efficient code. This may not be possible if an assembler instruction
6931 requires a specific register.
6933 The following i386 example uses the @var{asmSymbolicName} syntax.
6935 same result as the code above, but some may consider it more readable or more
6936 maintainable since reordering index numbers is not necessary when adding or
6937 removing operands. The names @code{aIndex} and @code{aMask}
6938 are only used in this example to emphasize which
6939 names get used where.
6940 It is acceptable to reuse the names @code{Index} and @code{Mask}.
6943 uint32_t Mask = 1234;
6946 asm ("bsfl %[aMask], %[aIndex]"
6947 : [aIndex] "=r" (Index)
6948 : [aMask] "r" (Mask)
6952 Here are some more examples of output operands.
6959 asm ("mov %[e], %[d]"
6964 Here, @code{d} may either be in a register or in memory. Since the compiler
6965 might already have the current value of the @code{uint32_t} location
6966 pointed to by @code{e}
6967 in a register, you can enable it to choose the best location
6968 for @code{d} by specifying both constraints.
6970 @anchor{InputOperands}
6971 @subsubsection Input Operands
6972 @cindex @code{asm} input operands
6973 @cindex @code{asm} expressions
6975 Input operands make values from C variables and expressions available to the
6978 Operands are separated by commas. Each operand has this format:
6981 @r{[} [@var{asmSymbolicName}] @r{]} @var{constraint} (@var{cexpression})
6985 @item asmSymbolicName
6986 Specifies a symbolic name for the operand.
6987 Reference the name in the assembler template
6988 by enclosing it in square brackets
6989 (i.e. @samp{%[Value]}). The scope of the name is the @code{asm} statement
6990 that contains the definition. Any valid C variable name is acceptable,
6991 including names already defined in the surrounding code. No two operands
6992 within the same @code{asm} statement can use the same symbolic name.
6994 When not using an @var{asmSymbolicName}, use the (zero-based) position
6996 in the list of operands in the assembler template. For example if there are
6997 two output operands and three inputs,
6998 use @samp{%2} in the template to refer to the first input operand,
6999 @samp{%3} for the second, and @samp{%4} for the third.
7002 A string constant specifying constraints on the placement of the operand;
7003 @xref{Constraints}, for details.
7005 Input constraint strings may not begin with either @samp{=} or @samp{+}.
7006 When you list more than one possible location (for example, @samp{"irm"}),
7007 the compiler chooses the most efficient one based on the current context.
7008 If you must use a specific register, but your Machine Constraints do not
7009 provide sufficient control to select the specific register you want,
7010 local register variables may provide a solution (@pxref{Local Reg Vars}).
7012 Input constraints can also be digits (for example, @code{"0"}). This indicates
7013 that the specified input must be in the same place as the output constraint
7014 at the (zero-based) index in the output constraint list.
7015 When using @var{asmSymbolicName} syntax for the output operands,
7016 you may use these names (enclosed in brackets @samp{[]}) instead of digits.
7019 This is the C variable or expression being passed to the @code{asm} statement
7020 as input. The enclosing parentheses are a required part of the syntax.
7024 When the compiler selects the registers to use to represent the input
7025 operands, it does not use any of the clobbered registers (@pxref{Clobbers}).
7027 If there are no output operands but there are input operands, place two
7028 consecutive colons where the output operands would go:
7031 __asm__ ("some instructions"
7033 : "r" (Offset / 8));
7036 @strong{Warning:} Do @emph{not} modify the contents of input-only operands
7037 (except for inputs tied to outputs). The compiler assumes that on exit from
7038 the @code{asm} statement these operands contain the same values as they
7039 had before executing the statement.
7040 It is @emph{not} possible to use clobbers
7041 to inform the compiler that the values in these inputs are changing. One
7042 common work-around is to tie the changing input variable to an output variable
7043 that never gets used. Note, however, that if the code that follows the
7044 @code{asm} statement makes no use of any of the output operands, the GCC
7045 optimizers may discard the @code{asm} statement as unneeded
7046 (see @ref{Volatile}).
7048 @code{asm} supports operand modifiers on operands (for example @samp{%k2}
7049 instead of simply @samp{%2}). Typically these qualifiers are hardware
7050 dependent. The list of supported modifiers for x86 is found at
7051 @ref{x86Operandmodifiers,x86 Operand modifiers}.
7053 In this example using the fictitious @code{combine} instruction, the
7054 constraint @code{"0"} for input operand 1 says that it must occupy the same
7055 location as output operand 0. Only input operands may use numbers in
7056 constraints, and they must each refer to an output operand. Only a number (or
7057 the symbolic assembler name) in the constraint can guarantee that one operand
7058 is in the same place as another. The mere fact that @code{foo} is the value of
7059 both operands is not enough to guarantee that they are in the same place in
7060 the generated assembler code.
7063 asm ("combine %2, %0"
7065 : "0" (foo), "g" (bar));
7068 Here is an example using symbolic names.
7071 asm ("cmoveq %1, %2, %[result]"
7072 : [result] "=r"(result)
7073 : "r" (test), "r" (new), "[result]" (old));
7077 @subsubsection Clobbers
7078 @cindex @code{asm} clobbers
7080 While the compiler is aware of changes to entries listed in the output
7081 operands, the inline @code{asm} code may modify more than just the outputs. For
7082 example, calculations may require additional registers, or the processor may
7083 overwrite a register as a side effect of a particular assembler instruction.
7084 In order to inform the compiler of these changes, list them in the clobber
7085 list. Clobber list items are either register names or the special clobbers
7086 (listed below). Each clobber list item is a string constant
7087 enclosed in double quotes and separated by commas.
7089 Clobber descriptions may not in any way overlap with an input or output
7090 operand. For example, you may not have an operand describing a register class
7091 with one member when listing that register in the clobber list. Variables
7092 declared to live in specific registers (@pxref{Explicit Reg Vars}) and used
7093 as @code{asm} input or output operands must have no part mentioned in the
7094 clobber description. In particular, there is no way to specify that input
7095 operands get modified without also specifying them as output operands.
7097 When the compiler selects which registers to use to represent input and output
7098 operands, it does not use any of the clobbered registers. As a result,
7099 clobbered registers are available for any use in the assembler code.
7101 Here is a realistic example for the VAX showing the use of clobbered
7105 asm volatile ("movc3 %0, %1, %2"
7107 : "g" (from), "g" (to), "g" (count)
7108 : "r0", "r1", "r2", "r3", "r4", "r5");
7111 Also, there are two special clobber arguments:
7115 The @code{"cc"} clobber indicates that the assembler code modifies the flags
7116 register. On some machines, GCC represents the condition codes as a specific
7117 hardware register; @code{"cc"} serves to name this register.
7118 On other machines, condition code handling is different,
7119 and specifying @code{"cc"} has no effect. But
7120 it is valid no matter what the target.
7123 The @code{"memory"} clobber tells the compiler that the assembly code
7125 reads or writes to items other than those listed in the input and output
7126 operands (for example, accessing the memory pointed to by one of the input
7127 parameters). To ensure memory contains correct values, GCC may need to flush
7128 specific register values to memory before executing the @code{asm}. Further,
7129 the compiler does not assume that any values read from memory before an
7130 @code{asm} remain unchanged after that @code{asm}; it reloads them as
7132 Using the @code{"memory"} clobber effectively forms a read/write
7133 memory barrier for the compiler.
7135 Note that this clobber does not prevent the @emph{processor} from doing
7136 speculative reads past the @code{asm} statement. To prevent that, you need
7137 processor-specific fence instructions.
7139 Flushing registers to memory has performance implications and may be an issue
7140 for time-sensitive code. You can use a trick to avoid this if the size of
7141 the memory being accessed is known at compile time. For example, if accessing
7142 ten bytes of a string, use a memory input like:
7144 @code{@{"m"( (@{ struct @{ char x[10]; @} *p = (void *)ptr ; *p; @}) )@}}.
7149 @subsubsection Goto Labels
7150 @cindex @code{asm} goto labels
7152 @code{asm goto} allows assembly code to jump to one or more C labels. The
7153 @var{GotoLabels} section in an @code{asm goto} statement contains
7155 list of all C labels to which the assembler code may jump. GCC assumes that
7156 @code{asm} execution falls through to the next statement (if this is not the
7157 case, consider using the @code{__builtin_unreachable} intrinsic after the
7158 @code{asm} statement). Optimization of @code{asm goto} may be improved by
7159 using the @code{hot} and @code{cold} label attributes (@pxref{Label
7162 An @code{asm goto} statement cannot have outputs.
7163 This is due to an internal restriction of
7164 the compiler: control transfer instructions cannot have outputs.
7165 If the assembler code does modify anything, use the @code{"memory"} clobber
7167 optimizers to flush all register values to memory and reload them if
7168 necessary after the @code{asm} statement.
7170 Also note that an @code{asm goto} statement is always implicitly
7171 considered volatile.
7173 To reference a label in the assembler template,
7174 prefix it with @samp{%l} (lowercase @samp{L}) followed
7175 by its (zero-based) position in @var{GotoLabels} plus the number of input
7176 operands. For example, if the @code{asm} has three inputs and references two
7177 labels, refer to the first label as @samp{%l3} and the second as @samp{%l4}).
7179 Alternately, you can reference labels using the actual C label name enclosed
7180 in brackets. For example, to reference a label named @code{carry}, you can
7181 use @samp{%l[carry]}. The label must still be listed in the @var{GotoLabels}
7182 section when using this approach.
7184 Here is an example of @code{asm goto} for i386:
7191 : "r" (p1), "r" (p2)
7201 The following example shows an @code{asm goto} that uses a memory clobber.
7207 asm goto ("frob %%r5, %1; jc %l[error]; mov (%2), %%r5"
7218 @anchor{x86Operandmodifiers}
7219 @subsubsection x86 Operand Modifiers
7221 References to input, output, and goto operands in the assembler template
7222 of extended @code{asm} statements can use
7223 modifiers to affect the way the operands are formatted in
7224 the code output to the assembler. For example, the
7225 following code uses the @samp{h} and @samp{b} modifiers for x86:
7229 asm volatile ("xchg %h0, %b0" : "+a" (num) );
7233 These modifiers generate this assembler code:
7239 The rest of this discussion uses the following code for illustrative purposes.
7248 asm volatile goto ("some assembler instructions here"
7250 : "q" (iInt), "X" (sizeof(unsigned char) + 1)
7251 : /* No clobbers. */
7256 With no modifiers, this is what the output from the operands would be for the
7257 @samp{att} and @samp{intel} dialects of assembler:
7259 @multitable {Operand} {masm=att} {OFFSET FLAT:.L2}
7260 @headitem Operand @tab masm=att @tab masm=intel
7269 @tab @code{OFFSET FLAT:.L2}
7272 The table below shows the list of supported modifiers and their effects.
7274 @multitable {Modifier} {Print the opcode suffix for the size of th} {Operand} {masm=att} {masm=intel}
7275 @headitem Modifier @tab Description @tab Operand @tab @option{masm=att} @tab @option{masm=intel}
7277 @tab Print the opcode suffix for the size of the current integer operand (one of @code{b}/@code{w}/@code{l}/@code{q}).
7282 @tab Print the QImode name of the register.
7287 @tab Print the QImode name for a ``high'' register.
7292 @tab Print the HImode name of the register.
7297 @tab Print the SImode name of the register.
7302 @tab Print the DImode name of the register.
7307 @tab Print the label name with no punctuation.
7312 @tab Require a constant operand and print the constant expression with no punctuation.
7318 @anchor{x86floatingpointasmoperands}
7319 @subsubsection x86 Floating-Point @code{asm} Operands
7321 On x86 targets, there are several rules on the usage of stack-like registers
7322 in the operands of an @code{asm}. These rules apply only to the operands
7323 that are stack-like registers:
7327 Given a set of input registers that die in an @code{asm}, it is
7328 necessary to know which are implicitly popped by the @code{asm}, and
7329 which must be explicitly popped by GCC@.
7331 An input register that is implicitly popped by the @code{asm} must be
7332 explicitly clobbered, unless it is constrained to match an
7336 For any input register that is implicitly popped by an @code{asm}, it is
7337 necessary to know how to adjust the stack to compensate for the pop.
7338 If any non-popped input is closer to the top of the reg-stack than
7339 the implicitly popped register, it would not be possible to know what the
7340 stack looked like---it's not clear how the rest of the stack ``slides
7343 All implicitly popped input registers must be closer to the top of
7344 the reg-stack than any input that is not implicitly popped.
7346 It is possible that if an input dies in an @code{asm}, the compiler might
7347 use the input register for an output reload. Consider this example:
7350 asm ("foo" : "=t" (a) : "f" (b));
7354 This code says that input @code{b} is not popped by the @code{asm}, and that
7355 the @code{asm} pushes a result onto the reg-stack, i.e., the stack is one
7356 deeper after the @code{asm} than it was before. But, it is possible that
7357 reload may think that it can use the same register for both the input and
7360 To prevent this from happening,
7361 if any input operand uses the @samp{f} constraint, all output register
7362 constraints must use the @samp{&} early-clobber modifier.
7364 The example above is correctly written as:
7367 asm ("foo" : "=&t" (a) : "f" (b));
7371 Some operands need to be in particular places on the stack. All
7372 output operands fall in this category---GCC has no other way to
7373 know which registers the outputs appear in unless you indicate
7374 this in the constraints.
7376 Output operands must specifically indicate which register an output
7377 appears in after an @code{asm}. @samp{=f} is not allowed: the operand
7378 constraints must select a class with a single register.
7381 Output operands may not be ``inserted'' between existing stack registers.
7382 Since no 387 opcode uses a read/write operand, all output operands
7383 are dead before the @code{asm}, and are pushed by the @code{asm}.
7384 It makes no sense to push anywhere but the top of the reg-stack.
7386 Output operands must start at the top of the reg-stack: output
7387 operands may not ``skip'' a register.
7390 Some @code{asm} statements may need extra stack space for internal
7391 calculations. This can be guaranteed by clobbering stack registers
7392 unrelated to the inputs and outputs.
7397 takes one input, which is internally popped, and produces two outputs.
7400 asm ("fsincos" : "=t" (cos), "=u" (sin) : "0" (inp));
7404 This @code{asm} takes two inputs, which are popped by the @code{fyl2xp1} opcode,
7405 and replaces them with one output. The @code{st(1)} clobber is necessary
7406 for the compiler to know that @code{fyl2xp1} pops both inputs.
7409 asm ("fyl2xp1" : "=t" (result) : "0" (x), "u" (y) : "st(1)");
7417 @subsection Controlling Names Used in Assembler Code
7418 @cindex assembler names for identifiers
7419 @cindex names used in assembler code
7420 @cindex identifiers, names in assembler code
7422 You can specify the name to be used in the assembler code for a C
7423 function or variable by writing the @code{asm} (or @code{__asm__})
7424 keyword after the declarator as follows:
7427 int foo asm ("myfoo") = 2;
7431 This specifies that the name to be used for the variable @code{foo} in
7432 the assembler code should be @samp{myfoo} rather than the usual
7435 On systems where an underscore is normally prepended to the name of a C
7436 function or variable, this feature allows you to define names for the
7437 linker that do not start with an underscore.
7439 It does not make sense to use this feature with a non-static local
7440 variable since such variables do not have assembler names. If you are
7441 trying to put the variable in a particular register, see @ref{Explicit
7442 Reg Vars}. GCC presently accepts such code with a warning, but will
7443 probably be changed to issue an error, rather than a warning, in the
7446 You cannot use @code{asm} in this way in a function @emph{definition}; but
7447 you can get the same effect by writing a declaration for the function
7448 before its definition and putting @code{asm} there, like this:
7451 extern func () asm ("FUNC");
7458 It is up to you to make sure that the assembler names you choose do not
7459 conflict with any other assembler symbols. Also, you must not use a
7460 register name; that would produce completely invalid assembler code. GCC
7461 does not as yet have the ability to store static variables in registers.
7462 Perhaps that will be added.
7464 @node Explicit Reg Vars
7465 @subsection Variables in Specified Registers
7466 @cindex explicit register variables
7467 @cindex variables in specified registers
7468 @cindex specified registers
7469 @cindex registers, global allocation
7471 GNU C allows you to put a few global variables into specified hardware
7472 registers. You can also specify the register in which an ordinary
7473 register variable should be allocated.
7477 Global register variables reserve registers throughout the program.
7478 This may be useful in programs such as programming language
7479 interpreters that have a couple of global variables that are accessed
7483 Local register variables in specific registers do not reserve the
7484 registers, except at the point where they are used as input or output
7485 operands in an @code{asm} statement and the @code{asm} statement itself is
7486 not deleted. The compiler's data flow analysis is capable of determining
7487 where the specified registers contain live values, and where they are
7488 available for other uses. Stores into local register variables may be deleted
7489 when they appear to be dead according to dataflow analysis. References
7490 to local register variables may be deleted or moved or simplified.
7492 These local variables are sometimes convenient for use with the extended
7493 @code{asm} feature (@pxref{Extended Asm}), if you want to write one
7494 output of the assembler instruction directly into a particular register.
7495 (This works provided the register you specify fits the constraints
7496 specified for that operand in the @code{asm}.)
7504 @node Global Reg Vars
7505 @subsubsection Defining Global Register Variables
7506 @cindex global register variables
7507 @cindex registers, global variables in
7509 You can define a global register variable in GNU C like this:
7512 register int *foo asm ("a5");
7516 Here @code{a5} is the name of the register that should be used. Choose a
7517 register that is normally saved and restored by function calls on your
7518 machine, so that library routines will not clobber it.
7520 Naturally the register name is CPU-dependent, so you need to
7521 conditionalize your program according to CPU type. The register
7522 @code{a5} is a good choice on a 68000 for a variable of pointer
7523 type. On machines with register windows, be sure to choose a ``global''
7524 register that is not affected magically by the function call mechanism.
7526 In addition, different operating systems on the same CPU may differ in how they
7527 name the registers; then you need additional conditionals. For
7528 example, some 68000 operating systems call this register @code{%a5}.
7530 Eventually there may be a way of asking the compiler to choose a register
7531 automatically, but first we need to figure out how it should choose and
7532 how to enable you to guide the choice. No solution is evident.
7534 Defining a global register variable in a certain register reserves that
7535 register entirely for this use, at least within the current compilation.
7536 The register is not allocated for any other purpose in the functions
7537 in the current compilation, and is not saved and restored by
7538 these functions. Stores into this register are never deleted even if they
7539 appear to be dead, but references may be deleted or moved or
7542 It is not safe to access the global register variables from signal
7543 handlers, or from more than one thread of control, because the system
7544 library routines may temporarily use the register for other things (unless
7545 you recompile them specially for the task at hand).
7547 @cindex @code{qsort}, and global register variables
7548 It is not safe for one function that uses a global register variable to
7549 call another such function @code{foo} by way of a third function
7550 @code{lose} that is compiled without knowledge of this variable (i.e.@: in a
7551 different source file in which the variable isn't declared). This is
7552 because @code{lose} might save the register and put some other value there.
7553 For example, you can't expect a global register variable to be available in
7554 the comparison-function that you pass to @code{qsort}, since @code{qsort}
7555 might have put something else in that register. (If you are prepared to
7556 recompile @code{qsort} with the same global register variable, you can
7557 solve this problem.)
7559 If you want to recompile @code{qsort} or other source files that do not
7560 actually use your global register variable, so that they do not use that
7561 register for any other purpose, then it suffices to specify the compiler
7562 option @option{-ffixed-@var{reg}}. You need not actually add a global
7563 register declaration to their source code.
7565 A function that can alter the value of a global register variable cannot
7566 safely be called from a function compiled without this variable, because it
7567 could clobber the value the caller expects to find there on return.
7568 Therefore, the function that is the entry point into the part of the
7569 program that uses the global register variable must explicitly save and
7570 restore the value that belongs to its caller.
7572 @cindex register variable after @code{longjmp}
7573 @cindex global register after @code{longjmp}
7574 @cindex value after @code{longjmp}
7577 On most machines, @code{longjmp} restores to each global register
7578 variable the value it had at the time of the @code{setjmp}. On some
7579 machines, however, @code{longjmp} does not change the value of global
7580 register variables. To be portable, the function that called @code{setjmp}
7581 should make other arrangements to save the values of the global register
7582 variables, and to restore them in a @code{longjmp}. This way, the same
7583 thing happens regardless of what @code{longjmp} does.
7585 All global register variable declarations must precede all function
7586 definitions. If such a declaration could appear after function
7587 definitions, the declaration would be too late to prevent the register from
7588 being used for other purposes in the preceding functions.
7590 Global register variables may not have initial values, because an
7591 executable file has no means to supply initial contents for a register.
7593 On the SPARC, there are reports that g3 @dots{} g7 are suitable
7594 registers, but certain library functions, such as @code{getwd}, as well
7595 as the subroutines for division and remainder, modify g3 and g4. g1 and
7596 g2 are local temporaries.
7598 On the 68000, a2 @dots{} a5 should be suitable, as should d2 @dots{} d7.
7599 Of course, it does not do to use more than a few of those.
7601 @node Local Reg Vars
7602 @subsubsection Specifying Registers for Local Variables
7603 @cindex local variables, specifying registers
7604 @cindex specifying registers for local variables
7605 @cindex registers for local variables
7607 You can define a local register variable with a specified register
7611 register int *foo asm ("a5");
7615 Here @code{a5} is the name of the register that should be used. Note
7616 that this is the same syntax used for defining global register
7617 variables, but for a local variable it appears within a function.
7619 Naturally the register name is CPU-dependent, but this is not a
7620 problem, since specific registers are most often useful with explicit
7621 assembler instructions (@pxref{Extended Asm}). Both of these things
7622 generally require that you conditionalize your program according to
7625 In addition, operating systems on one type of CPU may differ in how they
7626 name the registers; then you need additional conditionals. For
7627 example, some 68000 operating systems call this register @code{%a5}.
7629 Defining such a register variable does not reserve the register; it
7630 remains available for other uses in places where flow control determines
7631 the variable's value is not live.
7633 This option does not guarantee that GCC generates code that has
7634 this variable in the register you specify at all times. You may not
7635 code an explicit reference to this register in the assembler
7636 instruction template part of an @code{asm} statement and assume it
7637 always refers to this variable.
7638 However, using the variable as an input or output operand to the @code{asm}
7639 guarantees that the specified register is used for that operand.
7640 @xref{Extended Asm}, for more information.
7642 Stores into local register variables may be deleted when they appear to be dead
7643 according to dataflow analysis. References to local register variables may
7644 be deleted or moved or simplified.
7646 As with global register variables, it is recommended that you choose a
7647 register that is normally saved and restored by function calls on
7648 your machine, so that library routines will not clobber it.
7650 Sometimes when writing inline @code{asm} code, you need to make an operand be a
7651 specific register, but there's no matching constraint letter for that
7652 register. To force the operand into that register, create a local variable
7653 and specify the register in the variable's declaration. Then use the local
7654 variable for the asm operand and specify any constraint letter that matches
7658 register int *p1 asm ("r0") = @dots{};
7659 register int *p2 asm ("r1") = @dots{};
7660 register int *result asm ("r0");
7661 asm ("sysint" : "=r" (result) : "0" (p1), "r" (p2));
7664 @emph{Warning:} In the above example, be aware that a register (for example r0) can be
7665 call-clobbered by subsequent code, including function calls and library calls
7666 for arithmetic operators on other variables (for example the initialization
7667 of p2). In this case, use temporary variables for expressions between the
7668 register assignments:
7672 register int *p1 asm ("r0") = @dots{};
7673 register int *p2 asm ("r1") = t1;
7674 register int *result asm ("r0");
7675 asm ("sysint" : "=r" (result) : "0" (p1), "r" (p2));
7678 @node Size of an asm
7679 @subsection Size of an @code{asm}
7681 Some targets require that GCC track the size of each instruction used
7682 in order to generate correct code. Because the final length of the
7683 code produced by an @code{asm} statement is only known by the
7684 assembler, GCC must make an estimate as to how big it will be. It
7685 does this by counting the number of instructions in the pattern of the
7686 @code{asm} and multiplying that by the length of the longest
7687 instruction supported by that processor. (When working out the number
7688 of instructions, it assumes that any occurrence of a newline or of
7689 whatever statement separator character is supported by the assembler --
7690 typically @samp{;} --- indicates the end of an instruction.)
7692 Normally, GCC's estimate is adequate to ensure that correct
7693 code is generated, but it is possible to confuse the compiler if you use
7694 pseudo instructions or assembler macros that expand into multiple real
7695 instructions, or if you use assembler directives that expand to more
7696 space in the object file than is needed for a single instruction.
7697 If this happens then the assembler may produce a diagnostic saying that
7698 a label is unreachable.
7700 @node Alternate Keywords
7701 @section Alternate Keywords
7702 @cindex alternate keywords
7703 @cindex keywords, alternate
7705 @option{-ansi} and the various @option{-std} options disable certain
7706 keywords. This causes trouble when you want to use GNU C extensions, or
7707 a general-purpose header file that should be usable by all programs,
7708 including ISO C programs. The keywords @code{asm}, @code{typeof} and
7709 @code{inline} are not available in programs compiled with
7710 @option{-ansi} or @option{-std} (although @code{inline} can be used in a
7711 program compiled with @option{-std=c99} or @option{-std=c11}). The
7713 @code{restrict} is only available when @option{-std=gnu99} (which will
7714 eventually be the default) or @option{-std=c99} (or the equivalent
7715 @option{-std=iso9899:1999}), or an option for a later standard
7718 The way to solve these problems is to put @samp{__} at the beginning and
7719 end of each problematical keyword. For example, use @code{__asm__}
7720 instead of @code{asm}, and @code{__inline__} instead of @code{inline}.
7722 Other C compilers won't accept these alternative keywords; if you want to
7723 compile with another compiler, you can define the alternate keywords as
7724 macros to replace them with the customary keywords. It looks like this:
7732 @findex __extension__
7734 @option{-pedantic} and other options cause warnings for many GNU C extensions.
7736 prevent such warnings within one expression by writing
7737 @code{__extension__} before the expression. @code{__extension__} has no
7738 effect aside from this.
7740 @node Incomplete Enums
7741 @section Incomplete @code{enum} Types
7743 You can define an @code{enum} tag without specifying its possible values.
7744 This results in an incomplete type, much like what you get if you write
7745 @code{struct foo} without describing the elements. A later declaration
7746 that does specify the possible values completes the type.
7748 You can't allocate variables or storage using the type while it is
7749 incomplete. However, you can work with pointers to that type.
7751 This extension may not be very useful, but it makes the handling of
7752 @code{enum} more consistent with the way @code{struct} and @code{union}
7755 This extension is not supported by GNU C++.
7757 @node Function Names
7758 @section Function Names as Strings
7759 @cindex @code{__func__} identifier
7760 @cindex @code{__FUNCTION__} identifier
7761 @cindex @code{__PRETTY_FUNCTION__} identifier
7763 GCC provides three magic variables that hold the name of the current
7764 function, as a string. The first of these is @code{__func__}, which
7765 is part of the C99 standard:
7767 The identifier @code{__func__} is implicitly declared by the translator
7768 as if, immediately following the opening brace of each function
7769 definition, the declaration
7772 static const char __func__[] = "function-name";
7776 appeared, where function-name is the name of the lexically-enclosing
7777 function. This name is the unadorned name of the function.
7779 @code{__FUNCTION__} is another name for @code{__func__}, provided for
7780 backward compatibility with old versions of GCC.
7782 In C, @code{__PRETTY_FUNCTION__} is yet another name for
7783 @code{__func__}. However, in C++, @code{__PRETTY_FUNCTION__} contains
7784 the type signature of the function as well as its bare name. For
7785 example, this program:
7789 extern int printf (char *, ...);
7796 printf ("__FUNCTION__ = %s\n", __FUNCTION__);
7797 printf ("__PRETTY_FUNCTION__ = %s\n", __PRETTY_FUNCTION__);
7815 __PRETTY_FUNCTION__ = void a::sub(int)
7818 These identifiers are variables, not preprocessor macros, and may not
7819 be used to initialize @code{char} arrays or be concatenated with other string
7822 @node Return Address
7823 @section Getting the Return or Frame Address of a Function
7825 These functions may be used to get information about the callers of a
7828 @deftypefn {Built-in Function} {void *} __builtin_return_address (unsigned int @var{level})
7829 This function returns the return address of the current function, or of
7830 one of its callers. The @var{level} argument is number of frames to
7831 scan up the call stack. A value of @code{0} yields the return address
7832 of the current function, a value of @code{1} yields the return address
7833 of the caller of the current function, and so forth. When inlining
7834 the expected behavior is that the function returns the address of
7835 the function that is returned to. To work around this behavior use
7836 the @code{noinline} function attribute.
7838 The @var{level} argument must be a constant integer.
7840 On some machines it may be impossible to determine the return address of
7841 any function other than the current one; in such cases, or when the top
7842 of the stack has been reached, this function returns @code{0} or a
7843 random value. In addition, @code{__builtin_frame_address} may be used
7844 to determine if the top of the stack has been reached.
7846 Additional post-processing of the returned value may be needed, see
7847 @code{__builtin_extract_return_addr}.
7849 This function should only be used with a nonzero argument for debugging
7853 @deftypefn {Built-in Function} {void *} __builtin_extract_return_addr (void *@var{addr})
7854 The address as returned by @code{__builtin_return_address} may have to be fed
7855 through this function to get the actual encoded address. For example, on the
7856 31-bit S/390 platform the highest bit has to be masked out, or on SPARC
7857 platforms an offset has to be added for the true next instruction to be
7860 If no fixup is needed, this function simply passes through @var{addr}.
7863 @deftypefn {Built-in Function} {void *} __builtin_frob_return_address (void *@var{addr})
7864 This function does the reverse of @code{__builtin_extract_return_addr}.
7867 @deftypefn {Built-in Function} {void *} __builtin_frame_address (unsigned int @var{level})
7868 This function is similar to @code{__builtin_return_address}, but it
7869 returns the address of the function frame rather than the return address
7870 of the function. Calling @code{__builtin_frame_address} with a value of
7871 @code{0} yields the frame address of the current function, a value of
7872 @code{1} yields the frame address of the caller of the current function,
7875 The frame is the area on the stack that holds local variables and saved
7876 registers. The frame address is normally the address of the first word
7877 pushed on to the stack by the function. However, the exact definition
7878 depends upon the processor and the calling convention. If the processor
7879 has a dedicated frame pointer register, and the function has a frame,
7880 then @code{__builtin_frame_address} returns the value of the frame
7883 On some machines it may be impossible to determine the frame address of
7884 any function other than the current one; in such cases, or when the top
7885 of the stack has been reached, this function returns @code{0} if
7886 the first frame pointer is properly initialized by the startup code.
7888 This function should only be used with a nonzero argument for debugging
7892 @node Vector Extensions
7893 @section Using Vector Instructions through Built-in Functions
7895 On some targets, the instruction set contains SIMD vector instructions which
7896 operate on multiple values contained in one large register at the same time.
7897 For example, on the x86 the MMX, 3DNow!@: and SSE extensions can be used
7900 The first step in using these extensions is to provide the necessary data
7901 types. This should be done using an appropriate @code{typedef}:
7904 typedef int v4si __attribute__ ((vector_size (16)));
7908 The @code{int} type specifies the base type, while the attribute specifies
7909 the vector size for the variable, measured in bytes. For example, the
7910 declaration above causes the compiler to set the mode for the @code{v4si}
7911 type to be 16 bytes wide and divided into @code{int} sized units. For
7912 a 32-bit @code{int} this means a vector of 4 units of 4 bytes, and the
7913 corresponding mode of @code{foo} is @acronym{V4SI}.
7915 The @code{vector_size} attribute is only applicable to integral and
7916 float scalars, although arrays, pointers, and function return values
7917 are allowed in conjunction with this construct. Only sizes that are
7918 a power of two are currently allowed.
7920 All the basic integer types can be used as base types, both as signed
7921 and as unsigned: @code{char}, @code{short}, @code{int}, @code{long},
7922 @code{long long}. In addition, @code{float} and @code{double} can be
7923 used to build floating-point vector types.
7925 Specifying a combination that is not valid for the current architecture
7926 causes GCC to synthesize the instructions using a narrower mode.
7927 For example, if you specify a variable of type @code{V4SI} and your
7928 architecture does not allow for this specific SIMD type, GCC
7929 produces code that uses 4 @code{SIs}.
7931 The types defined in this manner can be used with a subset of normal C
7932 operations. Currently, GCC allows using the following operators
7933 on these types: @code{+, -, *, /, unary minus, ^, |, &, ~, %}@.
7935 The operations behave like C++ @code{valarrays}. Addition is defined as
7936 the addition of the corresponding elements of the operands. For
7937 example, in the code below, each of the 4 elements in @var{a} is
7938 added to the corresponding 4 elements in @var{b} and the resulting
7939 vector is stored in @var{c}.
7942 typedef int v4si __attribute__ ((vector_size (16)));
7949 Subtraction, multiplication, division, and the logical operations
7950 operate in a similar manner. Likewise, the result of using the unary
7951 minus or complement operators on a vector type is a vector whose
7952 elements are the negative or complemented values of the corresponding
7953 elements in the operand.
7955 It is possible to use shifting operators @code{<<}, @code{>>} on
7956 integer-type vectors. The operation is defined as following: @code{@{a0,
7957 a1, @dots{}, an@} >> @{b0, b1, @dots{}, bn@} == @{a0 >> b0, a1 >> b1,
7958 @dots{}, an >> bn@}}@. Vector operands must have the same number of
7961 For convenience, it is allowed to use a binary vector operation
7962 where one operand is a scalar. In that case the compiler transforms
7963 the scalar operand into a vector where each element is the scalar from
7964 the operation. The transformation happens only if the scalar could be
7965 safely converted to the vector-element type.
7966 Consider the following code.
7969 typedef int v4si __attribute__ ((vector_size (16)));
7974 a = b + 1; /* a = b + @{1,1,1,1@}; */
7975 a = 2 * b; /* a = @{2,2,2,2@} * b; */
7977 a = l + a; /* Error, cannot convert long to int. */
7980 Vectors can be subscripted as if the vector were an array with
7981 the same number of elements and base type. Out of bound accesses
7982 invoke undefined behavior at run time. Warnings for out of bound
7983 accesses for vector subscription can be enabled with
7984 @option{-Warray-bounds}.
7986 Vector comparison is supported with standard comparison
7987 operators: @code{==, !=, <, <=, >, >=}. Comparison operands can be
7988 vector expressions of integer-type or real-type. Comparison between
7989 integer-type vectors and real-type vectors are not supported. The
7990 result of the comparison is a vector of the same width and number of
7991 elements as the comparison operands with a signed integral element
7994 Vectors are compared element-wise producing 0 when comparison is false
7995 and -1 (constant of the appropriate type where all bits are set)
7996 otherwise. Consider the following example.
7999 typedef int v4si __attribute__ ((vector_size (16)));
8001 v4si a = @{1,2,3,4@};
8002 v4si b = @{3,2,1,4@};
8005 c = a > b; /* The result would be @{0, 0,-1, 0@} */
8006 c = a == b; /* The result would be @{0,-1, 0,-1@} */
8009 In C++, the ternary operator @code{?:} is available. @code{a?b:c}, where
8010 @code{b} and @code{c} are vectors of the same type and @code{a} is an
8011 integer vector with the same number of elements of the same size as @code{b}
8012 and @code{c}, computes all three arguments and creates a vector
8013 @code{@{a[0]?b[0]:c[0], a[1]?b[1]:c[1], @dots{}@}}. Note that unlike in
8014 OpenCL, @code{a} is thus interpreted as @code{a != 0} and not @code{a < 0}.
8015 As in the case of binary operations, this syntax is also accepted when
8016 one of @code{b} or @code{c} is a scalar that is then transformed into a
8017 vector. If both @code{b} and @code{c} are scalars and the type of
8018 @code{true?b:c} has the same size as the element type of @code{a}, then
8019 @code{b} and @code{c} are converted to a vector type whose elements have
8020 this type and with the same number of elements as @code{a}.
8022 In C++, the logic operators @code{!, &&, ||} are available for vectors.
8023 @code{!v} is equivalent to @code{v == 0}, @code{a && b} is equivalent to
8024 @code{a!=0 & b!=0} and @code{a || b} is equivalent to @code{a!=0 | b!=0}.
8025 For mixed operations between a scalar @code{s} and a vector @code{v},
8026 @code{s && v} is equivalent to @code{s?v!=0:0} (the evaluation is
8027 short-circuit) and @code{v && s} is equivalent to @code{v!=0 & (s?-1:0)}.
8029 Vector shuffling is available using functions
8030 @code{__builtin_shuffle (vec, mask)} and
8031 @code{__builtin_shuffle (vec0, vec1, mask)}.
8032 Both functions construct a permutation of elements from one or two
8033 vectors and return a vector of the same type as the input vector(s).
8034 The @var{mask} is an integral vector with the same width (@var{W})
8035 and element count (@var{N}) as the output vector.
8037 The elements of the input vectors are numbered in memory ordering of
8038 @var{vec0} beginning at 0 and @var{vec1} beginning at @var{N}. The
8039 elements of @var{mask} are considered modulo @var{N} in the single-operand
8040 case and modulo @math{2*@var{N}} in the two-operand case.
8042 Consider the following example,
8045 typedef int v4si __attribute__ ((vector_size (16)));
8047 v4si a = @{1,2,3,4@};
8048 v4si b = @{5,6,7,8@};
8049 v4si mask1 = @{0,1,1,3@};
8050 v4si mask2 = @{0,4,2,5@};
8053 res = __builtin_shuffle (a, mask1); /* res is @{1,2,2,4@} */
8054 res = __builtin_shuffle (a, b, mask2); /* res is @{1,5,3,6@} */
8057 Note that @code{__builtin_shuffle} is intentionally semantically
8058 compatible with the OpenCL @code{shuffle} and @code{shuffle2} functions.
8060 You can declare variables and use them in function calls and returns, as
8061 well as in assignments and some casts. You can specify a vector type as
8062 a return type for a function. Vector types can also be used as function
8063 arguments. It is possible to cast from one vector type to another,
8064 provided they are of the same size (in fact, you can also cast vectors
8065 to and from other datatypes of the same size).
8067 You cannot operate between vectors of different lengths or different
8068 signedness without a cast.
8071 @section Support for @code{offsetof}
8072 @findex __builtin_offsetof
8074 GCC implements for both C and C++ a syntactic extension to implement
8075 the @code{offsetof} macro.
8079 "__builtin_offsetof" "(" @code{typename} "," offsetof_member_designator ")"
8081 offsetof_member_designator:
8083 | offsetof_member_designator "." @code{identifier}
8084 | offsetof_member_designator "[" @code{expr} "]"
8087 This extension is sufficient such that
8090 #define offsetof(@var{type}, @var{member}) __builtin_offsetof (@var{type}, @var{member})
8094 is a suitable definition of the @code{offsetof} macro. In C++, @var{type}
8095 may be dependent. In either case, @var{member} may consist of a single
8096 identifier, or a sequence of member accesses and array references.
8098 @node __sync Builtins
8099 @section Legacy @code{__sync} Built-in Functions for Atomic Memory Access
8101 The following built-in functions
8102 are intended to be compatible with those described
8103 in the @cite{Intel Itanium Processor-specific Application Binary Interface},
8104 section 7.4. As such, they depart from the normal GCC practice of using
8105 the @samp{__builtin_} prefix, and further that they are overloaded such that
8106 they work on multiple types.
8108 The definition given in the Intel documentation allows only for the use of
8109 the types @code{int}, @code{long}, @code{long long} as well as their unsigned
8110 counterparts. GCC allows any integral scalar or pointer type that is
8111 1, 2, 4 or 8 bytes in length.
8113 Not all operations are supported by all target processors. If a particular
8114 operation cannot be implemented on the target processor, a warning is
8115 generated and a call an external function is generated. The external
8116 function carries the same name as the built-in version,
8117 with an additional suffix
8118 @samp{_@var{n}} where @var{n} is the size of the data type.
8120 @c ??? Should we have a mechanism to suppress this warning? This is almost
8121 @c useful for implementing the operation under the control of an external
8124 In most cases, these built-in functions are considered a @dfn{full barrier}.
8126 no memory operand is moved across the operation, either forward or
8127 backward. Further, instructions are issued as necessary to prevent the
8128 processor from speculating loads across the operation and from queuing stores
8129 after the operation.
8131 All of the routines are described in the Intel documentation to take
8132 ``an optional list of variables protected by the memory barrier''. It's
8133 not clear what is meant by that; it could mean that @emph{only} the
8134 following variables are protected, or it could mean that these variables
8135 should in addition be protected. At present GCC ignores this list and
8136 protects all variables that are globally accessible. If in the future
8137 we make some use of this list, an empty list will continue to mean all
8138 globally accessible variables.
8141 @item @var{type} __sync_fetch_and_add (@var{type} *ptr, @var{type} value, ...)
8142 @itemx @var{type} __sync_fetch_and_sub (@var{type} *ptr, @var{type} value, ...)
8143 @itemx @var{type} __sync_fetch_and_or (@var{type} *ptr, @var{type} value, ...)
8144 @itemx @var{type} __sync_fetch_and_and (@var{type} *ptr, @var{type} value, ...)
8145 @itemx @var{type} __sync_fetch_and_xor (@var{type} *ptr, @var{type} value, ...)
8146 @itemx @var{type} __sync_fetch_and_nand (@var{type} *ptr, @var{type} value, ...)
8147 @findex __sync_fetch_and_add
8148 @findex __sync_fetch_and_sub
8149 @findex __sync_fetch_and_or
8150 @findex __sync_fetch_and_and
8151 @findex __sync_fetch_and_xor
8152 @findex __sync_fetch_and_nand
8153 These built-in functions perform the operation suggested by the name, and
8154 returns the value that had previously been in memory. That is,
8157 @{ tmp = *ptr; *ptr @var{op}= value; return tmp; @}
8158 @{ tmp = *ptr; *ptr = ~(tmp & value); return tmp; @} // nand
8161 @emph{Note:} GCC 4.4 and later implement @code{__sync_fetch_and_nand}
8162 as @code{*ptr = ~(tmp & value)} instead of @code{*ptr = ~tmp & value}.
8164 @item @var{type} __sync_add_and_fetch (@var{type} *ptr, @var{type} value, ...)
8165 @itemx @var{type} __sync_sub_and_fetch (@var{type} *ptr, @var{type} value, ...)
8166 @itemx @var{type} __sync_or_and_fetch (@var{type} *ptr, @var{type} value, ...)
8167 @itemx @var{type} __sync_and_and_fetch (@var{type} *ptr, @var{type} value, ...)
8168 @itemx @var{type} __sync_xor_and_fetch (@var{type} *ptr, @var{type} value, ...)
8169 @itemx @var{type} __sync_nand_and_fetch (@var{type} *ptr, @var{type} value, ...)
8170 @findex __sync_add_and_fetch
8171 @findex __sync_sub_and_fetch
8172 @findex __sync_or_and_fetch
8173 @findex __sync_and_and_fetch
8174 @findex __sync_xor_and_fetch
8175 @findex __sync_nand_and_fetch
8176 These built-in functions perform the operation suggested by the name, and
8177 return the new value. That is,
8180 @{ *ptr @var{op}= value; return *ptr; @}
8181 @{ *ptr = ~(*ptr & value); return *ptr; @} // nand
8184 @emph{Note:} GCC 4.4 and later implement @code{__sync_nand_and_fetch}
8185 as @code{*ptr = ~(*ptr & value)} instead of
8186 @code{*ptr = ~*ptr & value}.
8188 @item bool __sync_bool_compare_and_swap (@var{type} *ptr, @var{type} oldval, @var{type} newval, ...)
8189 @itemx @var{type} __sync_val_compare_and_swap (@var{type} *ptr, @var{type} oldval, @var{type} newval, ...)
8190 @findex __sync_bool_compare_and_swap
8191 @findex __sync_val_compare_and_swap
8192 These built-in functions perform an atomic compare and swap.
8193 That is, if the current
8194 value of @code{*@var{ptr}} is @var{oldval}, then write @var{newval} into
8197 The ``bool'' version returns true if the comparison is successful and
8198 @var{newval} is written. The ``val'' version returns the contents
8199 of @code{*@var{ptr}} before the operation.
8201 @item __sync_synchronize (...)
8202 @findex __sync_synchronize
8203 This built-in function issues a full memory barrier.
8205 @item @var{type} __sync_lock_test_and_set (@var{type} *ptr, @var{type} value, ...)
8206 @findex __sync_lock_test_and_set
8207 This built-in function, as described by Intel, is not a traditional test-and-set
8208 operation, but rather an atomic exchange operation. It writes @var{value}
8209 into @code{*@var{ptr}}, and returns the previous contents of
8212 Many targets have only minimal support for such locks, and do not support
8213 a full exchange operation. In this case, a target may support reduced
8214 functionality here by which the @emph{only} valid value to store is the
8215 immediate constant 1. The exact value actually stored in @code{*@var{ptr}}
8216 is implementation defined.
8218 This built-in function is not a full barrier,
8219 but rather an @dfn{acquire barrier}.
8220 This means that references after the operation cannot move to (or be
8221 speculated to) before the operation, but previous memory stores may not
8222 be globally visible yet, and previous memory loads may not yet be
8225 @item void __sync_lock_release (@var{type} *ptr, ...)
8226 @findex __sync_lock_release
8227 This built-in function releases the lock acquired by
8228 @code{__sync_lock_test_and_set}.
8229 Normally this means writing the constant 0 to @code{*@var{ptr}}.
8231 This built-in function is not a full barrier,
8232 but rather a @dfn{release barrier}.
8233 This means that all previous memory stores are globally visible, and all
8234 previous memory loads have been satisfied, but following memory reads
8235 are not prevented from being speculated to before the barrier.
8238 @node __atomic Builtins
8239 @section Built-in Functions for Memory Model Aware Atomic Operations
8241 The following built-in functions approximately match the requirements for
8242 C++11 memory model. Many are similar to the @samp{__sync} prefixed built-in
8243 functions, but all also have a memory model parameter. These are all
8244 identified by being prefixed with @samp{__atomic}, and most are overloaded
8245 such that they work with multiple types.
8247 GCC allows any integral scalar or pointer type that is 1, 2, 4, or 8
8248 bytes in length. 16-byte integral types are also allowed if
8249 @samp{__int128} (@pxref{__int128}) is supported by the architecture.
8251 Target architectures are encouraged to provide their own patterns for
8252 each of these built-in functions. If no target is provided, the original
8253 non-memory model set of @samp{__sync} atomic built-in functions are
8254 utilized, along with any required synchronization fences surrounding it in
8255 order to achieve the proper behavior. Execution in this case is subject
8256 to the same restrictions as those built-in functions.
8258 If there is no pattern or mechanism to provide a lock free instruction
8259 sequence, a call is made to an external routine with the same parameters
8260 to be resolved at run time.
8262 The four non-arithmetic functions (load, store, exchange, and
8263 compare_exchange) all have a generic version as well. This generic
8264 version works on any data type. If the data type size maps to one
8265 of the integral sizes that may have lock free support, the generic
8266 version utilizes the lock free built-in function. Otherwise an
8267 external call is left to be resolved at run time. This external call is
8268 the same format with the addition of a @samp{size_t} parameter inserted
8269 as the first parameter indicating the size of the object being pointed to.
8270 All objects must be the same size.
8272 There are 6 different memory models that can be specified. These map
8273 to the same names in the C++11 standard. Refer there or to the
8274 @uref{http://gcc.gnu.org/wiki/Atomic/GCCMM/AtomicSync,GCC wiki on
8275 atomic synchronization} for more detailed definitions. These memory
8276 models integrate both barriers to code motion as well as synchronization
8277 requirements with other threads. These are listed in approximately
8278 ascending order of strength. It is also possible to use target specific
8279 flags for memory model flags, like Hardware Lock Elision.
8282 @item __ATOMIC_RELAXED
8283 No barriers or synchronization.
8284 @item __ATOMIC_CONSUME
8285 Data dependency only for both barrier and synchronization with another
8287 @item __ATOMIC_ACQUIRE
8288 Barrier to hoisting of code and synchronizes with release (or stronger)
8289 semantic stores from another thread.
8290 @item __ATOMIC_RELEASE
8291 Barrier to sinking of code and synchronizes with acquire (or stronger)
8292 semantic loads from another thread.
8293 @item __ATOMIC_ACQ_REL
8294 Full barrier in both directions and synchronizes with acquire loads and
8295 release stores in another thread.
8296 @item __ATOMIC_SEQ_CST
8297 Full barrier in both directions and synchronizes with acquire loads and
8298 release stores in all threads.
8301 When implementing patterns for these built-in functions, the memory model
8302 parameter can be ignored as long as the pattern implements the most
8303 restrictive @code{__ATOMIC_SEQ_CST} model. Any of the other memory models
8304 execute correctly with this memory model but they may not execute as
8305 efficiently as they could with a more appropriate implementation of the
8306 relaxed requirements.
8308 Note that the C++11 standard allows for the memory model parameter to be
8309 determined at run time rather than at compile time. These built-in
8310 functions map any run-time value to @code{__ATOMIC_SEQ_CST} rather
8311 than invoke a runtime library call or inline a switch statement. This is
8312 standard compliant, safe, and the simplest approach for now.
8314 The memory model parameter is a signed int, but only the lower 8 bits are
8315 reserved for the memory model. The remainder of the signed int is reserved
8316 for future use and should be 0. Use of the predefined atomic values
8317 ensures proper usage.
8319 @deftypefn {Built-in Function} @var{type} __atomic_load_n (@var{type} *ptr, int memmodel)
8320 This built-in function implements an atomic load operation. It returns the
8321 contents of @code{*@var{ptr}}.
8323 The valid memory model variants are
8324 @code{__ATOMIC_RELAXED}, @code{__ATOMIC_SEQ_CST}, @code{__ATOMIC_ACQUIRE},
8325 and @code{__ATOMIC_CONSUME}.
8329 @deftypefn {Built-in Function} void __atomic_load (@var{type} *ptr, @var{type} *ret, int memmodel)
8330 This is the generic version of an atomic load. It returns the
8331 contents of @code{*@var{ptr}} in @code{*@var{ret}}.
8335 @deftypefn {Built-in Function} void __atomic_store_n (@var{type} *ptr, @var{type} val, int memmodel)
8336 This built-in function implements an atomic store operation. It writes
8337 @code{@var{val}} into @code{*@var{ptr}}.
8339 The valid memory model variants are
8340 @code{__ATOMIC_RELAXED}, @code{__ATOMIC_SEQ_CST}, and @code{__ATOMIC_RELEASE}.
8344 @deftypefn {Built-in Function} void __atomic_store (@var{type} *ptr, @var{type} *val, int memmodel)
8345 This is the generic version of an atomic store. It stores the value
8346 of @code{*@var{val}} into @code{*@var{ptr}}.
8350 @deftypefn {Built-in Function} @var{type} __atomic_exchange_n (@var{type} *ptr, @var{type} val, int memmodel)
8351 This built-in function implements an atomic exchange operation. It writes
8352 @var{val} into @code{*@var{ptr}}, and returns the previous contents of
8355 The valid memory model variants are
8356 @code{__ATOMIC_RELAXED}, @code{__ATOMIC_SEQ_CST}, @code{__ATOMIC_ACQUIRE},
8357 @code{__ATOMIC_RELEASE}, and @code{__ATOMIC_ACQ_REL}.
8361 @deftypefn {Built-in Function} void __atomic_exchange (@var{type} *ptr, @var{type} *val, @var{type} *ret, int memmodel)
8362 This is the generic version of an atomic exchange. It stores the
8363 contents of @code{*@var{val}} into @code{*@var{ptr}}. The original value
8364 of @code{*@var{ptr}} is copied into @code{*@var{ret}}.
8368 @deftypefn {Built-in Function} bool __atomic_compare_exchange_n (@var{type} *ptr, @var{type} *expected, @var{type} desired, bool weak, int success_memmodel, int failure_memmodel)
8369 This built-in function implements an atomic compare and exchange operation.
8370 This compares the contents of @code{*@var{ptr}} with the contents of
8371 @code{*@var{expected}} and if equal, writes @var{desired} into
8372 @code{*@var{ptr}}. If they are not equal, the current contents of
8373 @code{*@var{ptr}} is written into @code{*@var{expected}}. @var{weak} is true
8374 for weak compare_exchange, and false for the strong variation. Many targets
8375 only offer the strong variation and ignore the parameter. When in doubt, use
8376 the strong variation.
8378 True is returned if @var{desired} is written into
8379 @code{*@var{ptr}} and the execution is considered to conform to the
8380 memory model specified by @var{success_memmodel}. There are no
8381 restrictions on what memory model can be used here.
8383 False is returned otherwise, and the execution is considered to conform
8384 to @var{failure_memmodel}. This memory model cannot be
8385 @code{__ATOMIC_RELEASE} nor @code{__ATOMIC_ACQ_REL}. It also cannot be a
8386 stronger model than that specified by @var{success_memmodel}.
8390 @deftypefn {Built-in Function} bool __atomic_compare_exchange (@var{type} *ptr, @var{type} *expected, @var{type} *desired, bool weak, int success_memmodel, int failure_memmodel)
8391 This built-in function implements the generic version of
8392 @code{__atomic_compare_exchange}. The function is virtually identical to
8393 @code{__atomic_compare_exchange_n}, except the desired value is also a
8398 @deftypefn {Built-in Function} @var{type} __atomic_add_fetch (@var{type} *ptr, @var{type} val, int memmodel)
8399 @deftypefnx {Built-in Function} @var{type} __atomic_sub_fetch (@var{type} *ptr, @var{type} val, int memmodel)
8400 @deftypefnx {Built-in Function} @var{type} __atomic_and_fetch (@var{type} *ptr, @var{type} val, int memmodel)
8401 @deftypefnx {Built-in Function} @var{type} __atomic_xor_fetch (@var{type} *ptr, @var{type} val, int memmodel)
8402 @deftypefnx {Built-in Function} @var{type} __atomic_or_fetch (@var{type} *ptr, @var{type} val, int memmodel)
8403 @deftypefnx {Built-in Function} @var{type} __atomic_nand_fetch (@var{type} *ptr, @var{type} val, int memmodel)
8404 These built-in functions perform the operation suggested by the name, and
8405 return the result of the operation. That is,
8408 @{ *ptr @var{op}= val; return *ptr; @}
8411 All memory models are valid.
8415 @deftypefn {Built-in Function} @var{type} __atomic_fetch_add (@var{type} *ptr, @var{type} val, int memmodel)
8416 @deftypefnx {Built-in Function} @var{type} __atomic_fetch_sub (@var{type} *ptr, @var{type} val, int memmodel)
8417 @deftypefnx {Built-in Function} @var{type} __atomic_fetch_and (@var{type} *ptr, @var{type} val, int memmodel)
8418 @deftypefnx {Built-in Function} @var{type} __atomic_fetch_xor (@var{type} *ptr, @var{type} val, int memmodel)
8419 @deftypefnx {Built-in Function} @var{type} __atomic_fetch_or (@var{type} *ptr, @var{type} val, int memmodel)
8420 @deftypefnx {Built-in Function} @var{type} __atomic_fetch_nand (@var{type} *ptr, @var{type} val, int memmodel)
8421 These built-in functions perform the operation suggested by the name, and
8422 return the value that had previously been in @code{*@var{ptr}}. That is,
8425 @{ tmp = *ptr; *ptr @var{op}= val; return tmp; @}
8428 All memory models are valid.
8432 @deftypefn {Built-in Function} bool __atomic_test_and_set (void *ptr, int memmodel)
8434 This built-in function performs an atomic test-and-set operation on
8435 the byte at @code{*@var{ptr}}. The byte is set to some implementation
8436 defined nonzero ``set'' value and the return value is @code{true} if and only
8437 if the previous contents were ``set''.
8438 It should be only used for operands of type @code{bool} or @code{char}. For
8439 other types only part of the value may be set.
8441 All memory models are valid.
8445 @deftypefn {Built-in Function} void __atomic_clear (bool *ptr, int memmodel)
8447 This built-in function performs an atomic clear operation on
8448 @code{*@var{ptr}}. After the operation, @code{*@var{ptr}} contains 0.
8449 It should be only used for operands of type @code{bool} or @code{char} and
8450 in conjunction with @code{__atomic_test_and_set}.
8451 For other types it may only clear partially. If the type is not @code{bool}
8452 prefer using @code{__atomic_store}.
8454 The valid memory model variants are
8455 @code{__ATOMIC_RELAXED}, @code{__ATOMIC_SEQ_CST}, and
8456 @code{__ATOMIC_RELEASE}.
8460 @deftypefn {Built-in Function} void __atomic_thread_fence (int memmodel)
8462 This built-in function acts as a synchronization fence between threads
8463 based on the specified memory model.
8465 All memory orders are valid.
8469 @deftypefn {Built-in Function} void __atomic_signal_fence (int memmodel)
8471 This built-in function acts as a synchronization fence between a thread
8472 and signal handlers based in the same thread.
8474 All memory orders are valid.
8478 @deftypefn {Built-in Function} bool __atomic_always_lock_free (size_t size, void *ptr)
8480 This built-in function returns true if objects of @var{size} bytes always
8481 generate lock free atomic instructions for the target architecture.
8482 @var{size} must resolve to a compile-time constant and the result also
8483 resolves to a compile-time constant.
8485 @var{ptr} is an optional pointer to the object that may be used to determine
8486 alignment. A value of 0 indicates typical alignment should be used. The
8487 compiler may also ignore this parameter.
8490 if (_atomic_always_lock_free (sizeof (long long), 0))
8495 @deftypefn {Built-in Function} bool __atomic_is_lock_free (size_t size, void *ptr)
8497 This built-in function returns true if objects of @var{size} bytes always
8498 generate lock free atomic instructions for the target architecture. If
8499 it is not known to be lock free a call is made to a runtime routine named
8500 @code{__atomic_is_lock_free}.
8502 @var{ptr} is an optional pointer to the object that may be used to determine
8503 alignment. A value of 0 indicates typical alignment should be used. The
8504 compiler may also ignore this parameter.
8507 @node Integer Overflow Builtins
8508 @section Built-in Functions to Perform Arithmetic with Overflow Checking
8510 The following built-in functions allow performing simple arithmetic operations
8511 together with checking whether the operations overflowed.
8513 @deftypefn {Built-in Function} bool __builtin_add_overflow (@var{type1} a, @var{type2} b, @var{type3} *res)
8514 @deftypefnx {Built-in Function} bool __builtin_sadd_overflow (int a, int b, int *res)
8515 @deftypefnx {Built-in Function} bool __builtin_saddl_overflow (long int a, long int b, long int *res)
8516 @deftypefnx {Built-in Function} bool __builtin_saddll_overflow (long long int a, long long int b, long int *res)
8517 @deftypefnx {Built-in Function} bool __builtin_uadd_overflow (unsigned int a, unsigned int b, unsigned int *res)
8518 @deftypefnx {Built-in Function} bool __builtin_uaddl_overflow (unsigned long int a, unsigned long int b, unsigned long int *res)
8519 @deftypefnx {Built-in Function} bool __builtin_uaddll_overflow (unsigned long long int a, unsigned long long int b, unsigned long int *res)
8521 These built-in functions promote the first two operands into infinite precision signed
8522 type and perform addition on those promoted operands. The result is then
8523 cast to the type the third pointer argument points to and stored there.
8524 If the stored result is equal to the infinite precision result, the built-in
8525 functions return false, otherwise they return true. As the addition is
8526 performed in infinite signed precision, these built-in functions have fully defined
8527 behavior for all argument values.
8529 The first built-in function allows arbitrary integral types for operands and
8530 the result type must be pointer to some integer type, the rest of the built-in
8531 functions have explicit integer types.
8533 The compiler will attempt to use hardware instructions to implement
8534 these built-in functions where possible, like conditional jump on overflow
8535 after addition, conditional jump on carry etc.
8539 @deftypefn {Built-in Function} bool __builtin_sub_overflow (@var{type1} a, @var{type2} b, @var{type3} *res)
8540 @deftypefnx {Built-in Function} bool __builtin_ssub_overflow (int a, int b, int *res)
8541 @deftypefnx {Built-in Function} bool __builtin_ssubl_overflow (long int a, long int b, long int *res)
8542 @deftypefnx {Built-in Function} bool __builtin_ssubll_overflow (long long int a, long long int b, long int *res)
8543 @deftypefnx {Built-in Function} bool __builtin_usub_overflow (unsigned int a, unsigned int b, unsigned int *res)
8544 @deftypefnx {Built-in Function} bool __builtin_usubl_overflow (unsigned long int a, unsigned long int b, unsigned long int *res)
8545 @deftypefnx {Built-in Function} bool __builtin_usubll_overflow (unsigned long long int a, unsigned long long int b, unsigned long int *res)
8547 These built-in functions are similar to the add overflow checking built-in
8548 functions above, except they perform subtraction, subtract the second argument
8549 from the first one, instead of addition.
8553 @deftypefn {Built-in Function} bool __builtin_mul_overflow (@var{type1} a, @var{type2} b, @var{type3} *res)
8554 @deftypefnx {Built-in Function} bool __builtin_smul_overflow (int a, int b, int *res)
8555 @deftypefnx {Built-in Function} bool __builtin_smull_overflow (long int a, long int b, long int *res)
8556 @deftypefnx {Built-in Function} bool __builtin_smulll_overflow (long long int a, long long int b, long int *res)
8557 @deftypefnx {Built-in Function} bool __builtin_umul_overflow (unsigned int a, unsigned int b, unsigned int *res)
8558 @deftypefnx {Built-in Function} bool __builtin_umull_overflow (unsigned long int a, unsigned long int b, unsigned long int *res)
8559 @deftypefnx {Built-in Function} bool __builtin_umulll_overflow (unsigned long long int a, unsigned long long int b, unsigned long int *res)
8561 These built-in functions are similar to the add overflow checking built-in
8562 functions above, except they perform multiplication, instead of addition.
8566 @node x86 specific memory model extensions for transactional memory
8567 @section x86-Specific Memory Model Extensions for Transactional Memory
8569 The x86 architecture supports additional memory ordering flags
8570 to mark lock critical sections for hardware lock elision.
8571 These must be specified in addition to an existing memory model to
8575 @item __ATOMIC_HLE_ACQUIRE
8576 Start lock elision on a lock variable.
8577 Memory model must be @code{__ATOMIC_ACQUIRE} or stronger.
8578 @item __ATOMIC_HLE_RELEASE
8579 End lock elision on a lock variable.
8580 Memory model must be @code{__ATOMIC_RELEASE} or stronger.
8583 When a lock acquire fails it is required for good performance to abort
8584 the transaction quickly. This can be done with a @code{_mm_pause}
8587 #include <immintrin.h> // For _mm_pause
8591 /* Acquire lock with lock elision */
8592 while (__atomic_exchange_n(&lockvar, 1, __ATOMIC_ACQUIRE|__ATOMIC_HLE_ACQUIRE))
8593 _mm_pause(); /* Abort failed transaction */
8595 /* Free lock with lock elision */
8596 __atomic_store_n(&lockvar, 0, __ATOMIC_RELEASE|__ATOMIC_HLE_RELEASE);
8599 @node Object Size Checking
8600 @section Object Size Checking Built-in Functions
8601 @findex __builtin_object_size
8602 @findex __builtin___memcpy_chk
8603 @findex __builtin___mempcpy_chk
8604 @findex __builtin___memmove_chk
8605 @findex __builtin___memset_chk
8606 @findex __builtin___strcpy_chk
8607 @findex __builtin___stpcpy_chk
8608 @findex __builtin___strncpy_chk
8609 @findex __builtin___strcat_chk
8610 @findex __builtin___strncat_chk
8611 @findex __builtin___sprintf_chk
8612 @findex __builtin___snprintf_chk
8613 @findex __builtin___vsprintf_chk
8614 @findex __builtin___vsnprintf_chk
8615 @findex __builtin___printf_chk
8616 @findex __builtin___vprintf_chk
8617 @findex __builtin___fprintf_chk
8618 @findex __builtin___vfprintf_chk
8620 GCC implements a limited buffer overflow protection mechanism
8621 that can prevent some buffer overflow attacks.
8623 @deftypefn {Built-in Function} {size_t} __builtin_object_size (void * @var{ptr}, int @var{type})
8624 is a built-in construct that returns a constant number of bytes from
8625 @var{ptr} to the end of the object @var{ptr} pointer points to
8626 (if known at compile time). @code{__builtin_object_size} never evaluates
8627 its arguments for side-effects. If there are any side-effects in them, it
8628 returns @code{(size_t) -1} for @var{type} 0 or 1 and @code{(size_t) 0}
8629 for @var{type} 2 or 3. If there are multiple objects @var{ptr} can
8630 point to and all of them are known at compile time, the returned number
8631 is the maximum of remaining byte counts in those objects if @var{type} & 2 is
8632 0 and minimum if nonzero. If it is not possible to determine which objects
8633 @var{ptr} points to at compile time, @code{__builtin_object_size} should
8634 return @code{(size_t) -1} for @var{type} 0 or 1 and @code{(size_t) 0}
8635 for @var{type} 2 or 3.
8637 @var{type} is an integer constant from 0 to 3. If the least significant
8638 bit is clear, objects are whole variables, if it is set, a closest
8639 surrounding subobject is considered the object a pointer points to.
8640 The second bit determines if maximum or minimum of remaining bytes
8644 struct V @{ char buf1[10]; int b; char buf2[10]; @} var;
8645 char *p = &var.buf1[1], *q = &var.b;
8647 /* Here the object p points to is var. */
8648 assert (__builtin_object_size (p, 0) == sizeof (var) - 1);
8649 /* The subobject p points to is var.buf1. */
8650 assert (__builtin_object_size (p, 1) == sizeof (var.buf1) - 1);
8651 /* The object q points to is var. */
8652 assert (__builtin_object_size (q, 0)
8653 == (char *) (&var + 1) - (char *) &var.b);
8654 /* The subobject q points to is var.b. */
8655 assert (__builtin_object_size (q, 1) == sizeof (var.b));
8659 There are built-in functions added for many common string operation
8660 functions, e.g., for @code{memcpy} @code{__builtin___memcpy_chk}
8661 built-in is provided. This built-in has an additional last argument,
8662 which is the number of bytes remaining in object the @var{dest}
8663 argument points to or @code{(size_t) -1} if the size is not known.
8665 The built-in functions are optimized into the normal string functions
8666 like @code{memcpy} if the last argument is @code{(size_t) -1} or if
8667 it is known at compile time that the destination object will not
8668 be overflown. If the compiler can determine at compile time the
8669 object will be always overflown, it issues a warning.
8671 The intended use can be e.g.@:
8675 #define bos0(dest) __builtin_object_size (dest, 0)
8676 #define memcpy(dest, src, n) \
8677 __builtin___memcpy_chk (dest, src, n, bos0 (dest))
8681 /* It is unknown what object p points to, so this is optimized
8682 into plain memcpy - no checking is possible. */
8683 memcpy (p, "abcde", n);
8684 /* Destination is known and length too. It is known at compile
8685 time there will be no overflow. */
8686 memcpy (&buf[5], "abcde", 5);
8687 /* Destination is known, but the length is not known at compile time.
8688 This will result in __memcpy_chk call that can check for overflow
8690 memcpy (&buf[5], "abcde", n);
8691 /* Destination is known and it is known at compile time there will
8692 be overflow. There will be a warning and __memcpy_chk call that
8693 will abort the program at run time. */
8694 memcpy (&buf[6], "abcde", 5);
8697 Such built-in functions are provided for @code{memcpy}, @code{mempcpy},
8698 @code{memmove}, @code{memset}, @code{strcpy}, @code{stpcpy}, @code{strncpy},
8699 @code{strcat} and @code{strncat}.
8701 There are also checking built-in functions for formatted output functions.
8703 int __builtin___sprintf_chk (char *s, int flag, size_t os, const char *fmt, ...);
8704 int __builtin___snprintf_chk (char *s, size_t maxlen, int flag, size_t os,
8705 const char *fmt, ...);
8706 int __builtin___vsprintf_chk (char *s, int flag, size_t os, const char *fmt,
8708 int __builtin___vsnprintf_chk (char *s, size_t maxlen, int flag, size_t os,
8709 const char *fmt, va_list ap);
8712 The added @var{flag} argument is passed unchanged to @code{__sprintf_chk}
8713 etc.@: functions and can contain implementation specific flags on what
8714 additional security measures the checking function might take, such as
8715 handling @code{%n} differently.
8717 The @var{os} argument is the object size @var{s} points to, like in the
8718 other built-in functions. There is a small difference in the behavior
8719 though, if @var{os} is @code{(size_t) -1}, the built-in functions are
8720 optimized into the non-checking functions only if @var{flag} is 0, otherwise
8721 the checking function is called with @var{os} argument set to
8724 In addition to this, there are checking built-in functions
8725 @code{__builtin___printf_chk}, @code{__builtin___vprintf_chk},
8726 @code{__builtin___fprintf_chk} and @code{__builtin___vfprintf_chk}.
8727 These have just one additional argument, @var{flag}, right before
8728 format string @var{fmt}. If the compiler is able to optimize them to
8729 @code{fputc} etc.@: functions, it does, otherwise the checking function
8730 is called and the @var{flag} argument passed to it.
8732 @node Pointer Bounds Checker builtins
8733 @section Pointer Bounds Checker Built-in Functions
8734 @findex __builtin___bnd_set_ptr_bounds
8735 @findex __builtin___bnd_narrow_ptr_bounds
8736 @findex __builtin___bnd_copy_ptr_bounds
8737 @findex __builtin___bnd_init_ptr_bounds
8738 @findex __builtin___bnd_null_ptr_bounds
8739 @findex __builtin___bnd_store_ptr_bounds
8740 @findex __builtin___bnd_chk_ptr_lbounds
8741 @findex __builtin___bnd_chk_ptr_ubounds
8742 @findex __builtin___bnd_chk_ptr_bounds
8743 @findex __builtin___bnd_get_ptr_lbound
8744 @findex __builtin___bnd_get_ptr_ubound
8746 GCC provides a set of built-in functions to control Pointer Bounds Checker
8747 instrumentation. Note that all Pointer Bounds Checker builtins are allowed
8748 to use even if you compile with Pointer Bounds Checker off. The builtins
8749 behavior may differ in such case as documented below.
8751 @deftypefn {Built-in Function} void * __builtin___bnd_set_ptr_bounds (const void * @var{q}, size_t @var{size})
8753 This built-in function returns a new pointer with the value of @var{q}, and
8754 associate it with the bounds [@var{q}, @var{q}+@var{size}-1]. With Pointer
8755 Bounds Checker off built-in function just returns the first argument.
8758 extern void *__wrap_malloc (size_t n)
8760 void *p = (void *)__real_malloc (n);
8761 if (!p) return __builtin___bnd_null_ptr_bounds (p);
8762 return __builtin___bnd_set_ptr_bounds (p, n);
8768 @deftypefn {Built-in Function} void * __builtin___bnd_narrow_ptr_bounds (const void * @var{p}, const void * @var{q}, size_t @var{size})
8770 This built-in function returns a new pointer with the value of @var{p}
8771 and associate it with the narrowed bounds formed by the intersection
8772 of bounds associated with @var{q} and the [@var{p}, @var{p} + @var{size} - 1].
8773 With Pointer Bounds Checker off built-in function just returns the first
8777 void init_objects (object *objs, size_t size)
8780 /* Initialize objects one-by-one passing pointers with bounds of an object,
8781 not the full array of objects. */
8782 for (i = 0; i < size; i++)
8783 init_object (__builtin___bnd_narrow_ptr_bounds (objs + i, objs, sizeof(object)));
8789 @deftypefn {Built-in Function} void * __builtin___bnd_copy_ptr_bounds (const void * @var{q}, const void * @var{r})
8791 This built-in function returns a new pointer with the value of @var{q},
8792 and associate it with the bounds already associated with pointer @var{r}.
8793 With Pointer Bounds Checker off built-in function just returns the first
8797 /* Here is a way to get pointer to object's field but
8798 still with the full object's bounds. */
8799 int *field_ptr = __builtin___bnd_copy_ptr_bounds (&objptr->int_filed, objptr);
8804 @deftypefn {Built-in Function} void * __builtin___bnd_init_ptr_bounds (const void * @var{q})
8806 This built-in function returns a new pointer with the value of @var{q}, and
8807 associate it with INIT (allowing full memory access) bounds. With Pointer
8808 Bounds Checker off built-in function just returns the first argument.
8812 @deftypefn {Built-in Function} void * __builtin___bnd_null_ptr_bounds (const void * @var{q})
8814 This built-in function returns a new pointer with the value of @var{q}, and
8815 associate it with NULL (allowing no memory access) bounds. With Pointer
8816 Bounds Checker off built-in function just returns the first argument.
8820 @deftypefn {Built-in Function} void __builtin___bnd_store_ptr_bounds (const void ** @var{ptr_addr}, const void * @var{ptr_val})
8822 This built-in function stores the bounds associated with pointer @var{ptr_val}
8823 and location @var{ptr_addr} into Bounds Table. This can be useful to propagate
8824 bounds from legacy code without touching the associated pointer's memory when
8825 pointers were copied as integers. With Pointer Bounds Checker off built-in
8826 function call is ignored.
8830 @deftypefn {Built-in Function} void __builtin___bnd_chk_ptr_lbounds (const void * @var{q})
8832 This built-in function checks if the pointer @var{q} is within the lower
8833 bound of its associated bounds. With Pointer Bounds Checker off built-in
8834 function call is ignored.
8837 extern void *__wrap_memset (void *dst, int c, size_t len)
8841 __builtin___bnd_chk_ptr_lbounds (dst);
8842 __builtin___bnd_chk_ptr_ubounds ((char *)dst + len - 1);
8843 __real_memset (dst, c, len);
8851 @deftypefn {Built-in Function} void __builtin___bnd_chk_ptr_ubounds (const void * @var{q})
8853 This built-in function checks if the pointer @var{q} is within the upper
8854 bound of its associated bounds. With Pointer Bounds Checker off built-in
8855 function call is ignored.
8859 @deftypefn {Built-in Function} void __builtin___bnd_chk_ptr_bounds (const void * @var{q}, size_t @var{size})
8861 This built-in function checks if [@var{q}, @var{q} + @var{size} - 1] is within
8862 the lower and upper bounds associated with @var{q}. With Pointer Bounds Checker
8863 off built-in function call is ignored.
8866 extern void *__wrap_memcpy (void *dst, const void *src, size_t n)
8870 __bnd_chk_ptr_bounds (dst, n);
8871 __bnd_chk_ptr_bounds (src, n);
8872 __real_memcpy (dst, src, n);
8880 @deftypefn {Built-in Function} const void * __builtin___bnd_get_ptr_lbound (const void * @var{q})
8882 This built-in function returns the lower bound (which is a pointer) associated
8883 with the pointer @var{q}. This is at least useful for debugging using printf.
8884 With Pointer Bounds Checker off built-in function returns 0.
8887 void *lb = __builtin___bnd_get_ptr_lbound (q);
8888 void *ub = __builtin___bnd_get_ptr_ubound (q);
8889 printf ("q = %p lb(q) = %p ub(q) = %p", q, lb, ub);
8894 @deftypefn {Built-in Function} const void * __builtin___bnd_get_ptr_ubound (const void * @var{q})
8896 This built-in function returns the upper bound (which is a pointer) associated
8897 with the pointer @var{q}. With Pointer Bounds Checker off built-in function
8902 @node Cilk Plus Builtins
8903 @section Cilk Plus C/C++ Language Extension Built-in Functions
8905 GCC provides support for the following built-in reduction functions if Cilk Plus
8906 is enabled. Cilk Plus can be enabled using the @option{-fcilkplus} flag.
8909 @item __sec_implicit_index
8911 @item __sec_reduce_add
8912 @item __sec_reduce_all_nonzero
8913 @item __sec_reduce_all_zero
8914 @item __sec_reduce_any_nonzero
8915 @item __sec_reduce_any_zero
8916 @item __sec_reduce_max
8917 @item __sec_reduce_min
8918 @item __sec_reduce_max_ind
8919 @item __sec_reduce_min_ind
8920 @item __sec_reduce_mul
8921 @item __sec_reduce_mutating
8924 Further details and examples about these built-in functions are described
8925 in the Cilk Plus language manual which can be found at
8926 @uref{http://www.cilkplus.org}.
8928 @node Other Builtins
8929 @section Other Built-in Functions Provided by GCC
8930 @cindex built-in functions
8931 @findex __builtin_call_with_static_chain
8932 @findex __builtin_fpclassify
8933 @findex __builtin_isfinite
8934 @findex __builtin_isnormal
8935 @findex __builtin_isgreater
8936 @findex __builtin_isgreaterequal
8937 @findex __builtin_isinf_sign
8938 @findex __builtin_isless
8939 @findex __builtin_islessequal
8940 @findex __builtin_islessgreater
8941 @findex __builtin_isunordered
8942 @findex __builtin_powi
8943 @findex __builtin_powif
8944 @findex __builtin_powil
9102 @findex fprintf_unlocked
9104 @findex fputs_unlocked
9221 @findex printf_unlocked
9253 @findex significandf
9254 @findex significandl
9325 GCC provides a large number of built-in functions other than the ones
9326 mentioned above. Some of these are for internal use in the processing
9327 of exceptions or variable-length argument lists and are not
9328 documented here because they may change from time to time; we do not
9329 recommend general use of these functions.
9331 The remaining functions are provided for optimization purposes.
9333 @opindex fno-builtin
9334 GCC includes built-in versions of many of the functions in the standard
9335 C library. The versions prefixed with @code{__builtin_} are always
9336 treated as having the same meaning as the C library function even if you
9337 specify the @option{-fno-builtin} option. (@pxref{C Dialect Options})
9338 Many of these functions are only optimized in certain cases; if they are
9339 not optimized in a particular case, a call to the library function is
9344 Outside strict ISO C mode (@option{-ansi}, @option{-std=c90},
9345 @option{-std=c99} or @option{-std=c11}), the functions
9346 @code{_exit}, @code{alloca}, @code{bcmp}, @code{bzero},
9347 @code{dcgettext}, @code{dgettext}, @code{dremf}, @code{dreml},
9348 @code{drem}, @code{exp10f}, @code{exp10l}, @code{exp10}, @code{ffsll},
9349 @code{ffsl}, @code{ffs}, @code{fprintf_unlocked},
9350 @code{fputs_unlocked}, @code{gammaf}, @code{gammal}, @code{gamma},
9351 @code{gammaf_r}, @code{gammal_r}, @code{gamma_r}, @code{gettext},
9352 @code{index}, @code{isascii}, @code{j0f}, @code{j0l}, @code{j0},
9353 @code{j1f}, @code{j1l}, @code{j1}, @code{jnf}, @code{jnl}, @code{jn},
9354 @code{lgammaf_r}, @code{lgammal_r}, @code{lgamma_r}, @code{mempcpy},
9355 @code{pow10f}, @code{pow10l}, @code{pow10}, @code{printf_unlocked},
9356 @code{rindex}, @code{scalbf}, @code{scalbl}, @code{scalb},
9357 @code{signbit}, @code{signbitf}, @code{signbitl}, @code{signbitd32},
9358 @code{signbitd64}, @code{signbitd128}, @code{significandf},
9359 @code{significandl}, @code{significand}, @code{sincosf},
9360 @code{sincosl}, @code{sincos}, @code{stpcpy}, @code{stpncpy},
9361 @code{strcasecmp}, @code{strdup}, @code{strfmon}, @code{strncasecmp},
9362 @code{strndup}, @code{toascii}, @code{y0f}, @code{y0l}, @code{y0},
9363 @code{y1f}, @code{y1l}, @code{y1}, @code{ynf}, @code{ynl} and
9365 may be handled as built-in functions.
9366 All these functions have corresponding versions
9367 prefixed with @code{__builtin_}, which may be used even in strict C90
9370 The ISO C99 functions
9371 @code{_Exit}, @code{acoshf}, @code{acoshl}, @code{acosh}, @code{asinhf},
9372 @code{asinhl}, @code{asinh}, @code{atanhf}, @code{atanhl}, @code{atanh},
9373 @code{cabsf}, @code{cabsl}, @code{cabs}, @code{cacosf}, @code{cacoshf},
9374 @code{cacoshl}, @code{cacosh}, @code{cacosl}, @code{cacos},
9375 @code{cargf}, @code{cargl}, @code{carg}, @code{casinf}, @code{casinhf},
9376 @code{casinhl}, @code{casinh}, @code{casinl}, @code{casin},
9377 @code{catanf}, @code{catanhf}, @code{catanhl}, @code{catanh},
9378 @code{catanl}, @code{catan}, @code{cbrtf}, @code{cbrtl}, @code{cbrt},
9379 @code{ccosf}, @code{ccoshf}, @code{ccoshl}, @code{ccosh}, @code{ccosl},
9380 @code{ccos}, @code{cexpf}, @code{cexpl}, @code{cexp}, @code{cimagf},
9381 @code{cimagl}, @code{cimag}, @code{clogf}, @code{clogl}, @code{clog},
9382 @code{conjf}, @code{conjl}, @code{conj}, @code{copysignf}, @code{copysignl},
9383 @code{copysign}, @code{cpowf}, @code{cpowl}, @code{cpow}, @code{cprojf},
9384 @code{cprojl}, @code{cproj}, @code{crealf}, @code{creall}, @code{creal},
9385 @code{csinf}, @code{csinhf}, @code{csinhl}, @code{csinh}, @code{csinl},
9386 @code{csin}, @code{csqrtf}, @code{csqrtl}, @code{csqrt}, @code{ctanf},
9387 @code{ctanhf}, @code{ctanhl}, @code{ctanh}, @code{ctanl}, @code{ctan},
9388 @code{erfcf}, @code{erfcl}, @code{erfc}, @code{erff}, @code{erfl},
9389 @code{erf}, @code{exp2f}, @code{exp2l}, @code{exp2}, @code{expm1f},
9390 @code{expm1l}, @code{expm1}, @code{fdimf}, @code{fdiml}, @code{fdim},
9391 @code{fmaf}, @code{fmal}, @code{fmaxf}, @code{fmaxl}, @code{fmax},
9392 @code{fma}, @code{fminf}, @code{fminl}, @code{fmin}, @code{hypotf},
9393 @code{hypotl}, @code{hypot}, @code{ilogbf}, @code{ilogbl}, @code{ilogb},
9394 @code{imaxabs}, @code{isblank}, @code{iswblank}, @code{lgammaf},
9395 @code{lgammal}, @code{lgamma}, @code{llabs}, @code{llrintf}, @code{llrintl},
9396 @code{llrint}, @code{llroundf}, @code{llroundl}, @code{llround},
9397 @code{log1pf}, @code{log1pl}, @code{log1p}, @code{log2f}, @code{log2l},
9398 @code{log2}, @code{logbf}, @code{logbl}, @code{logb}, @code{lrintf},
9399 @code{lrintl}, @code{lrint}, @code{lroundf}, @code{lroundl},
9400 @code{lround}, @code{nearbyintf}, @code{nearbyintl}, @code{nearbyint},
9401 @code{nextafterf}, @code{nextafterl}, @code{nextafter},
9402 @code{nexttowardf}, @code{nexttowardl}, @code{nexttoward},
9403 @code{remainderf}, @code{remainderl}, @code{remainder}, @code{remquof},
9404 @code{remquol}, @code{remquo}, @code{rintf}, @code{rintl}, @code{rint},
9405 @code{roundf}, @code{roundl}, @code{round}, @code{scalblnf},
9406 @code{scalblnl}, @code{scalbln}, @code{scalbnf}, @code{scalbnl},
9407 @code{scalbn}, @code{snprintf}, @code{tgammaf}, @code{tgammal},
9408 @code{tgamma}, @code{truncf}, @code{truncl}, @code{trunc},
9409 @code{vfscanf}, @code{vscanf}, @code{vsnprintf} and @code{vsscanf}
9410 are handled as built-in functions
9411 except in strict ISO C90 mode (@option{-ansi} or @option{-std=c90}).
9413 There are also built-in versions of the ISO C99 functions
9414 @code{acosf}, @code{acosl}, @code{asinf}, @code{asinl}, @code{atan2f},
9415 @code{atan2l}, @code{atanf}, @code{atanl}, @code{ceilf}, @code{ceill},
9416 @code{cosf}, @code{coshf}, @code{coshl}, @code{cosl}, @code{expf},
9417 @code{expl}, @code{fabsf}, @code{fabsl}, @code{floorf}, @code{floorl},
9418 @code{fmodf}, @code{fmodl}, @code{frexpf}, @code{frexpl}, @code{ldexpf},
9419 @code{ldexpl}, @code{log10f}, @code{log10l}, @code{logf}, @code{logl},
9420 @code{modfl}, @code{modf}, @code{powf}, @code{powl}, @code{sinf},
9421 @code{sinhf}, @code{sinhl}, @code{sinl}, @code{sqrtf}, @code{sqrtl},
9422 @code{tanf}, @code{tanhf}, @code{tanhl} and @code{tanl}
9423 that are recognized in any mode since ISO C90 reserves these names for
9424 the purpose to which ISO C99 puts them. All these functions have
9425 corresponding versions prefixed with @code{__builtin_}.
9427 The ISO C94 functions
9428 @code{iswalnum}, @code{iswalpha}, @code{iswcntrl}, @code{iswdigit},
9429 @code{iswgraph}, @code{iswlower}, @code{iswprint}, @code{iswpunct},
9430 @code{iswspace}, @code{iswupper}, @code{iswxdigit}, @code{towlower} and
9432 are handled as built-in functions
9433 except in strict ISO C90 mode (@option{-ansi} or @option{-std=c90}).
9435 The ISO C90 functions
9436 @code{abort}, @code{abs}, @code{acos}, @code{asin}, @code{atan2},
9437 @code{atan}, @code{calloc}, @code{ceil}, @code{cosh}, @code{cos},
9438 @code{exit}, @code{exp}, @code{fabs}, @code{floor}, @code{fmod},
9439 @code{fprintf}, @code{fputs}, @code{frexp}, @code{fscanf},
9440 @code{isalnum}, @code{isalpha}, @code{iscntrl}, @code{isdigit},
9441 @code{isgraph}, @code{islower}, @code{isprint}, @code{ispunct},
9442 @code{isspace}, @code{isupper}, @code{isxdigit}, @code{tolower},
9443 @code{toupper}, @code{labs}, @code{ldexp}, @code{log10}, @code{log},
9444 @code{malloc}, @code{memchr}, @code{memcmp}, @code{memcpy},
9445 @code{memset}, @code{modf}, @code{pow}, @code{printf}, @code{putchar},
9446 @code{puts}, @code{scanf}, @code{sinh}, @code{sin}, @code{snprintf},
9447 @code{sprintf}, @code{sqrt}, @code{sscanf}, @code{strcat},
9448 @code{strchr}, @code{strcmp}, @code{strcpy}, @code{strcspn},
9449 @code{strlen}, @code{strncat}, @code{strncmp}, @code{strncpy},
9450 @code{strpbrk}, @code{strrchr}, @code{strspn}, @code{strstr},
9451 @code{tanh}, @code{tan}, @code{vfprintf}, @code{vprintf} and @code{vsprintf}
9452 are all recognized as built-in functions unless
9453 @option{-fno-builtin} is specified (or @option{-fno-builtin-@var{function}}
9454 is specified for an individual function). All of these functions have
9455 corresponding versions prefixed with @code{__builtin_}.
9457 GCC provides built-in versions of the ISO C99 floating-point comparison
9458 macros that avoid raising exceptions for unordered operands. They have
9459 the same names as the standard macros ( @code{isgreater},
9460 @code{isgreaterequal}, @code{isless}, @code{islessequal},
9461 @code{islessgreater}, and @code{isunordered}) , with @code{__builtin_}
9462 prefixed. We intend for a library implementor to be able to simply
9463 @code{#define} each standard macro to its built-in equivalent.
9464 In the same fashion, GCC provides @code{fpclassify}, @code{isfinite},
9465 @code{isinf_sign} and @code{isnormal} built-ins used with
9466 @code{__builtin_} prefixed. The @code{isinf} and @code{isnan}
9467 built-in functions appear both with and without the @code{__builtin_} prefix.
9469 @deftypefn {Built-in Function} int __builtin_types_compatible_p (@var{type1}, @var{type2})
9471 You can use the built-in function @code{__builtin_types_compatible_p} to
9472 determine whether two types are the same.
9474 This built-in function returns 1 if the unqualified versions of the
9475 types @var{type1} and @var{type2} (which are types, not expressions) are
9476 compatible, 0 otherwise. The result of this built-in function can be
9477 used in integer constant expressions.
9479 This built-in function ignores top level qualifiers (e.g., @code{const},
9480 @code{volatile}). For example, @code{int} is equivalent to @code{const
9483 The type @code{int[]} and @code{int[5]} are compatible. On the other
9484 hand, @code{int} and @code{char *} are not compatible, even if the size
9485 of their types, on the particular architecture are the same. Also, the
9486 amount of pointer indirection is taken into account when determining
9487 similarity. Consequently, @code{short *} is not similar to
9488 @code{short **}. Furthermore, two types that are typedefed are
9489 considered compatible if their underlying types are compatible.
9491 An @code{enum} type is not considered to be compatible with another
9492 @code{enum} type even if both are compatible with the same integer
9493 type; this is what the C standard specifies.
9494 For example, @code{enum @{foo, bar@}} is not similar to
9495 @code{enum @{hot, dog@}}.
9497 You typically use this function in code whose execution varies
9498 depending on the arguments' types. For example:
9503 typeof (x) tmp = (x); \
9504 if (__builtin_types_compatible_p (typeof (x), long double)) \
9505 tmp = foo_long_double (tmp); \
9506 else if (__builtin_types_compatible_p (typeof (x), double)) \
9507 tmp = foo_double (tmp); \
9508 else if (__builtin_types_compatible_p (typeof (x), float)) \
9509 tmp = foo_float (tmp); \
9516 @emph{Note:} This construct is only available for C@.
9520 @deftypefn {Built-in Function} @var{type} __builtin_call_with_static_chain (@var{call_exp}, @var{pointer_exp})
9522 The @var{call_exp} expression must be a function call, and the
9523 @var{pointer_exp} expression must be a pointer. The @var{pointer_exp}
9524 is passed to the function call in the target's static chain location.
9525 The result of builtin is the result of the function call.
9527 @emph{Note:} This builtin is only available for C@.
9528 This builtin can be used to call Go closures from C.
9532 @deftypefn {Built-in Function} @var{type} __builtin_choose_expr (@var{const_exp}, @var{exp1}, @var{exp2})
9534 You can use the built-in function @code{__builtin_choose_expr} to
9535 evaluate code depending on the value of a constant expression. This
9536 built-in function returns @var{exp1} if @var{const_exp}, which is an
9537 integer constant expression, is nonzero. Otherwise it returns @var{exp2}.
9539 This built-in function is analogous to the @samp{? :} operator in C,
9540 except that the expression returned has its type unaltered by promotion
9541 rules. Also, the built-in function does not evaluate the expression
9542 that is not chosen. For example, if @var{const_exp} evaluates to true,
9543 @var{exp2} is not evaluated even if it has side-effects.
9545 This built-in function can return an lvalue if the chosen argument is an
9548 If @var{exp1} is returned, the return type is the same as @var{exp1}'s
9549 type. Similarly, if @var{exp2} is returned, its return type is the same
9556 __builtin_choose_expr ( \
9557 __builtin_types_compatible_p (typeof (x), double), \
9559 __builtin_choose_expr ( \
9560 __builtin_types_compatible_p (typeof (x), float), \
9562 /* @r{The void expression results in a compile-time error} \
9563 @r{when assigning the result to something.} */ \
9567 @emph{Note:} This construct is only available for C@. Furthermore, the
9568 unused expression (@var{exp1} or @var{exp2} depending on the value of
9569 @var{const_exp}) may still generate syntax errors. This may change in
9574 @deftypefn {Built-in Function} @var{type} __builtin_complex (@var{real}, @var{imag})
9576 The built-in function @code{__builtin_complex} is provided for use in
9577 implementing the ISO C11 macros @code{CMPLXF}, @code{CMPLX} and
9578 @code{CMPLXL}. @var{real} and @var{imag} must have the same type, a
9579 real binary floating-point type, and the result has the corresponding
9580 complex type with real and imaginary parts @var{real} and @var{imag}.
9581 Unlike @samp{@var{real} + I * @var{imag}}, this works even when
9582 infinities, NaNs and negative zeros are involved.
9586 @deftypefn {Built-in Function} int __builtin_constant_p (@var{exp})
9587 You can use the built-in function @code{__builtin_constant_p} to
9588 determine if a value is known to be constant at compile time and hence
9589 that GCC can perform constant-folding on expressions involving that
9590 value. The argument of the function is the value to test. The function
9591 returns the integer 1 if the argument is known to be a compile-time
9592 constant and 0 if it is not known to be a compile-time constant. A
9593 return of 0 does not indicate that the value is @emph{not} a constant,
9594 but merely that GCC cannot prove it is a constant with the specified
9595 value of the @option{-O} option.
9597 You typically use this function in an embedded application where
9598 memory is a critical resource. If you have some complex calculation,
9599 you may want it to be folded if it involves constants, but need to call
9600 a function if it does not. For example:
9603 #define Scale_Value(X) \
9604 (__builtin_constant_p (X) \
9605 ? ((X) * SCALE + OFFSET) : Scale (X))
9608 You may use this built-in function in either a macro or an inline
9609 function. However, if you use it in an inlined function and pass an
9610 argument of the function as the argument to the built-in, GCC
9611 never returns 1 when you call the inline function with a string constant
9612 or compound literal (@pxref{Compound Literals}) and does not return 1
9613 when you pass a constant numeric value to the inline function unless you
9614 specify the @option{-O} option.
9616 You may also use @code{__builtin_constant_p} in initializers for static
9617 data. For instance, you can write
9620 static const int table[] = @{
9621 __builtin_constant_p (EXPRESSION) ? (EXPRESSION) : -1,
9627 This is an acceptable initializer even if @var{EXPRESSION} is not a
9628 constant expression, including the case where
9629 @code{__builtin_constant_p} returns 1 because @var{EXPRESSION} can be
9630 folded to a constant but @var{EXPRESSION} contains operands that are
9631 not otherwise permitted in a static initializer (for example,
9632 @code{0 && foo ()}). GCC must be more conservative about evaluating the
9633 built-in in this case, because it has no opportunity to perform
9637 @deftypefn {Built-in Function} long __builtin_expect (long @var{exp}, long @var{c})
9638 @opindex fprofile-arcs
9639 You may use @code{__builtin_expect} to provide the compiler with
9640 branch prediction information. In general, you should prefer to
9641 use actual profile feedback for this (@option{-fprofile-arcs}), as
9642 programmers are notoriously bad at predicting how their programs
9643 actually perform. However, there are applications in which this
9644 data is hard to collect.
9646 The return value is the value of @var{exp}, which should be an integral
9647 expression. The semantics of the built-in are that it is expected that
9648 @var{exp} == @var{c}. For example:
9651 if (__builtin_expect (x, 0))
9656 indicates that we do not expect to call @code{foo}, since
9657 we expect @code{x} to be zero. Since you are limited to integral
9658 expressions for @var{exp}, you should use constructions such as
9661 if (__builtin_expect (ptr != NULL, 1))
9666 when testing pointer or floating-point values.
9669 @deftypefn {Built-in Function} void __builtin_trap (void)
9670 This function causes the program to exit abnormally. GCC implements
9671 this function by using a target-dependent mechanism (such as
9672 intentionally executing an illegal instruction) or by calling
9673 @code{abort}. The mechanism used may vary from release to release so
9674 you should not rely on any particular implementation.
9677 @deftypefn {Built-in Function} void __builtin_unreachable (void)
9678 If control flow reaches the point of the @code{__builtin_unreachable},
9679 the program is undefined. It is useful in situations where the
9680 compiler cannot deduce the unreachability of the code.
9682 One such case is immediately following an @code{asm} statement that
9683 either never terminates, or one that transfers control elsewhere
9684 and never returns. In this example, without the
9685 @code{__builtin_unreachable}, GCC issues a warning that control
9686 reaches the end of a non-void function. It also generates code
9687 to return after the @code{asm}.
9690 int f (int c, int v)
9698 asm("jmp error_handler");
9699 __builtin_unreachable ();
9705 Because the @code{asm} statement unconditionally transfers control out
9706 of the function, control never reaches the end of the function
9707 body. The @code{__builtin_unreachable} is in fact unreachable and
9708 communicates this fact to the compiler.
9710 Another use for @code{__builtin_unreachable} is following a call a
9711 function that never returns but that is not declared
9712 @code{__attribute__((noreturn))}, as in this example:
9715 void function_that_never_returns (void);
9725 function_that_never_returns ();
9726 __builtin_unreachable ();
9733 @deftypefn {Built-in Function} void *__builtin_assume_aligned (const void *@var{exp}, size_t @var{align}, ...)
9734 This function returns its first argument, and allows the compiler
9735 to assume that the returned pointer is at least @var{align} bytes
9736 aligned. This built-in can have either two or three arguments,
9737 if it has three, the third argument should have integer type, and
9738 if it is nonzero means misalignment offset. For example:
9741 void *x = __builtin_assume_aligned (arg, 16);
9745 means that the compiler can assume @code{x}, set to @code{arg}, is at least
9746 16-byte aligned, while:
9749 void *x = __builtin_assume_aligned (arg, 32, 8);
9753 means that the compiler can assume for @code{x}, set to @code{arg}, that
9754 @code{(char *) x - 8} is 32-byte aligned.
9757 @deftypefn {Built-in Function} int __builtin_LINE ()
9758 This function is the equivalent to the preprocessor @code{__LINE__}
9759 macro and returns the line number of the invocation of the built-in.
9760 In a C++ default argument for a function @var{F}, it gets the line number of
9761 the call to @var{F}.
9764 @deftypefn {Built-in Function} {const char *} __builtin_FUNCTION ()
9765 This function is the equivalent to the preprocessor @code{__FUNCTION__}
9766 macro and returns the function name the invocation of the built-in is in.
9769 @deftypefn {Built-in Function} {const char *} __builtin_FILE ()
9770 This function is the equivalent to the preprocessor @code{__FILE__}
9771 macro and returns the file name the invocation of the built-in is in.
9772 In a C++ default argument for a function @var{F}, it gets the file name of
9773 the call to @var{F}.
9776 @deftypefn {Built-in Function} void __builtin___clear_cache (char *@var{begin}, char *@var{end})
9777 This function is used to flush the processor's instruction cache for
9778 the region of memory between @var{begin} inclusive and @var{end}
9779 exclusive. Some targets require that the instruction cache be
9780 flushed, after modifying memory containing code, in order to obtain
9781 deterministic behavior.
9783 If the target does not require instruction cache flushes,
9784 @code{__builtin___clear_cache} has no effect. Otherwise either
9785 instructions are emitted in-line to clear the instruction cache or a
9786 call to the @code{__clear_cache} function in libgcc is made.
9789 @deftypefn {Built-in Function} void __builtin_prefetch (const void *@var{addr}, ...)
9790 This function is used to minimize cache-miss latency by moving data into
9791 a cache before it is accessed.
9792 You can insert calls to @code{__builtin_prefetch} into code for which
9793 you know addresses of data in memory that is likely to be accessed soon.
9794 If the target supports them, data prefetch instructions are generated.
9795 If the prefetch is done early enough before the access then the data will
9796 be in the cache by the time it is accessed.
9798 The value of @var{addr} is the address of the memory to prefetch.
9799 There are two optional arguments, @var{rw} and @var{locality}.
9800 The value of @var{rw} is a compile-time constant one or zero; one
9801 means that the prefetch is preparing for a write to the memory address
9802 and zero, the default, means that the prefetch is preparing for a read.
9803 The value @var{locality} must be a compile-time constant integer between
9804 zero and three. A value of zero means that the data has no temporal
9805 locality, so it need not be left in the cache after the access. A value
9806 of three means that the data has a high degree of temporal locality and
9807 should be left in all levels of cache possible. Values of one and two
9808 mean, respectively, a low or moderate degree of temporal locality. The
9812 for (i = 0; i < n; i++)
9815 __builtin_prefetch (&a[i+j], 1, 1);
9816 __builtin_prefetch (&b[i+j], 0, 1);
9821 Data prefetch does not generate faults if @var{addr} is invalid, but
9822 the address expression itself must be valid. For example, a prefetch
9823 of @code{p->next} does not fault if @code{p->next} is not a valid
9824 address, but evaluation faults if @code{p} is not a valid address.
9826 If the target does not support data prefetch, the address expression
9827 is evaluated if it includes side effects but no other code is generated
9828 and GCC does not issue a warning.
9831 @deftypefn {Built-in Function} double __builtin_huge_val (void)
9832 Returns a positive infinity, if supported by the floating-point format,
9833 else @code{DBL_MAX}. This function is suitable for implementing the
9834 ISO C macro @code{HUGE_VAL}.
9837 @deftypefn {Built-in Function} float __builtin_huge_valf (void)
9838 Similar to @code{__builtin_huge_val}, except the return type is @code{float}.
9841 @deftypefn {Built-in Function} {long double} __builtin_huge_vall (void)
9842 Similar to @code{__builtin_huge_val}, except the return
9843 type is @code{long double}.
9846 @deftypefn {Built-in Function} int __builtin_fpclassify (int, int, int, int, int, ...)
9847 This built-in implements the C99 fpclassify functionality. The first
9848 five int arguments should be the target library's notion of the
9849 possible FP classes and are used for return values. They must be
9850 constant values and they must appear in this order: @code{FP_NAN},
9851 @code{FP_INFINITE}, @code{FP_NORMAL}, @code{FP_SUBNORMAL} and
9852 @code{FP_ZERO}. The ellipsis is for exactly one floating-point value
9853 to classify. GCC treats the last argument as type-generic, which
9854 means it does not do default promotion from float to double.
9857 @deftypefn {Built-in Function} double __builtin_inf (void)
9858 Similar to @code{__builtin_huge_val}, except a warning is generated
9859 if the target floating-point format does not support infinities.
9862 @deftypefn {Built-in Function} _Decimal32 __builtin_infd32 (void)
9863 Similar to @code{__builtin_inf}, except the return type is @code{_Decimal32}.
9866 @deftypefn {Built-in Function} _Decimal64 __builtin_infd64 (void)
9867 Similar to @code{__builtin_inf}, except the return type is @code{_Decimal64}.
9870 @deftypefn {Built-in Function} _Decimal128 __builtin_infd128 (void)
9871 Similar to @code{__builtin_inf}, except the return type is @code{_Decimal128}.
9874 @deftypefn {Built-in Function} float __builtin_inff (void)
9875 Similar to @code{__builtin_inf}, except the return type is @code{float}.
9876 This function is suitable for implementing the ISO C99 macro @code{INFINITY}.
9879 @deftypefn {Built-in Function} {long double} __builtin_infl (void)
9880 Similar to @code{__builtin_inf}, except the return
9881 type is @code{long double}.
9884 @deftypefn {Built-in Function} int __builtin_isinf_sign (...)
9885 Similar to @code{isinf}, except the return value is -1 for
9886 an argument of @code{-Inf} and 1 for an argument of @code{+Inf}.
9887 Note while the parameter list is an
9888 ellipsis, this function only accepts exactly one floating-point
9889 argument. GCC treats this parameter as type-generic, which means it
9890 does not do default promotion from float to double.
9893 @deftypefn {Built-in Function} double __builtin_nan (const char *str)
9894 This is an implementation of the ISO C99 function @code{nan}.
9896 Since ISO C99 defines this function in terms of @code{strtod}, which we
9897 do not implement, a description of the parsing is in order. The string
9898 is parsed as by @code{strtol}; that is, the base is recognized by
9899 leading @samp{0} or @samp{0x} prefixes. The number parsed is placed
9900 in the significand such that the least significant bit of the number
9901 is at the least significant bit of the significand. The number is
9902 truncated to fit the significand field provided. The significand is
9903 forced to be a quiet NaN@.
9905 This function, if given a string literal all of which would have been
9906 consumed by @code{strtol}, is evaluated early enough that it is considered a
9907 compile-time constant.
9910 @deftypefn {Built-in Function} _Decimal32 __builtin_nand32 (const char *str)
9911 Similar to @code{__builtin_nan}, except the return type is @code{_Decimal32}.
9914 @deftypefn {Built-in Function} _Decimal64 __builtin_nand64 (const char *str)
9915 Similar to @code{__builtin_nan}, except the return type is @code{_Decimal64}.
9918 @deftypefn {Built-in Function} _Decimal128 __builtin_nand128 (const char *str)
9919 Similar to @code{__builtin_nan}, except the return type is @code{_Decimal128}.
9922 @deftypefn {Built-in Function} float __builtin_nanf (const char *str)
9923 Similar to @code{__builtin_nan}, except the return type is @code{float}.
9926 @deftypefn {Built-in Function} {long double} __builtin_nanl (const char *str)
9927 Similar to @code{__builtin_nan}, except the return type is @code{long double}.
9930 @deftypefn {Built-in Function} double __builtin_nans (const char *str)
9931 Similar to @code{__builtin_nan}, except the significand is forced
9932 to be a signaling NaN@. The @code{nans} function is proposed by
9933 @uref{http://www.open-std.org/jtc1/sc22/wg14/www/docs/n965.htm,,WG14 N965}.
9936 @deftypefn {Built-in Function} float __builtin_nansf (const char *str)
9937 Similar to @code{__builtin_nans}, except the return type is @code{float}.
9940 @deftypefn {Built-in Function} {long double} __builtin_nansl (const char *str)
9941 Similar to @code{__builtin_nans}, except the return type is @code{long double}.
9944 @deftypefn {Built-in Function} int __builtin_ffs (int x)
9945 Returns one plus the index of the least significant 1-bit of @var{x}, or
9946 if @var{x} is zero, returns zero.
9949 @deftypefn {Built-in Function} int __builtin_clz (unsigned int x)
9950 Returns the number of leading 0-bits in @var{x}, starting at the most
9951 significant bit position. If @var{x} is 0, the result is undefined.
9954 @deftypefn {Built-in Function} int __builtin_ctz (unsigned int x)
9955 Returns the number of trailing 0-bits in @var{x}, starting at the least
9956 significant bit position. If @var{x} is 0, the result is undefined.
9959 @deftypefn {Built-in Function} int __builtin_clrsb (int x)
9960 Returns the number of leading redundant sign bits in @var{x}, i.e.@: the
9961 number of bits following the most significant bit that are identical
9962 to it. There are no special cases for 0 or other values.
9965 @deftypefn {Built-in Function} int __builtin_popcount (unsigned int x)
9966 Returns the number of 1-bits in @var{x}.
9969 @deftypefn {Built-in Function} int __builtin_parity (unsigned int x)
9970 Returns the parity of @var{x}, i.e.@: the number of 1-bits in @var{x}
9974 @deftypefn {Built-in Function} int __builtin_ffsl (long)
9975 Similar to @code{__builtin_ffs}, except the argument type is
9979 @deftypefn {Built-in Function} int __builtin_clzl (unsigned long)
9980 Similar to @code{__builtin_clz}, except the argument type is
9981 @code{unsigned long}.
9984 @deftypefn {Built-in Function} int __builtin_ctzl (unsigned long)
9985 Similar to @code{__builtin_ctz}, except the argument type is
9986 @code{unsigned long}.
9989 @deftypefn {Built-in Function} int __builtin_clrsbl (long)
9990 Similar to @code{__builtin_clrsb}, except the argument type is
9994 @deftypefn {Built-in Function} int __builtin_popcountl (unsigned long)
9995 Similar to @code{__builtin_popcount}, except the argument type is
9996 @code{unsigned long}.
9999 @deftypefn {Built-in Function} int __builtin_parityl (unsigned long)
10000 Similar to @code{__builtin_parity}, except the argument type is
10001 @code{unsigned long}.
10004 @deftypefn {Built-in Function} int __builtin_ffsll (long long)
10005 Similar to @code{__builtin_ffs}, except the argument type is
10009 @deftypefn {Built-in Function} int __builtin_clzll (unsigned long long)
10010 Similar to @code{__builtin_clz}, except the argument type is
10011 @code{unsigned long long}.
10014 @deftypefn {Built-in Function} int __builtin_ctzll (unsigned long long)
10015 Similar to @code{__builtin_ctz}, except the argument type is
10016 @code{unsigned long long}.
10019 @deftypefn {Built-in Function} int __builtin_clrsbll (long long)
10020 Similar to @code{__builtin_clrsb}, except the argument type is
10024 @deftypefn {Built-in Function} int __builtin_popcountll (unsigned long long)
10025 Similar to @code{__builtin_popcount}, except the argument type is
10026 @code{unsigned long long}.
10029 @deftypefn {Built-in Function} int __builtin_parityll (unsigned long long)
10030 Similar to @code{__builtin_parity}, except the argument type is
10031 @code{unsigned long long}.
10034 @deftypefn {Built-in Function} double __builtin_powi (double, int)
10035 Returns the first argument raised to the power of the second. Unlike the
10036 @code{pow} function no guarantees about precision and rounding are made.
10039 @deftypefn {Built-in Function} float __builtin_powif (float, int)
10040 Similar to @code{__builtin_powi}, except the argument and return types
10044 @deftypefn {Built-in Function} {long double} __builtin_powil (long double, int)
10045 Similar to @code{__builtin_powi}, except the argument and return types
10046 are @code{long double}.
10049 @deftypefn {Built-in Function} uint16_t __builtin_bswap16 (uint16_t x)
10050 Returns @var{x} with the order of the bytes reversed; for example,
10051 @code{0xaabb} becomes @code{0xbbaa}. Byte here always means
10055 @deftypefn {Built-in Function} uint32_t __builtin_bswap32 (uint32_t x)
10056 Similar to @code{__builtin_bswap16}, except the argument and return types
10060 @deftypefn {Built-in Function} uint64_t __builtin_bswap64 (uint64_t x)
10061 Similar to @code{__builtin_bswap32}, except the argument and return types
10065 @node Target Builtins
10066 @section Built-in Functions Specific to Particular Target Machines
10068 On some target machines, GCC supports many built-in functions specific
10069 to those machines. Generally these generate calls to specific machine
10070 instructions, but allow the compiler to schedule those calls.
10073 * AArch64 Built-in Functions::
10074 * Alpha Built-in Functions::
10075 * Altera Nios II Built-in Functions::
10076 * ARC Built-in Functions::
10077 * ARC SIMD Built-in Functions::
10078 * ARM iWMMXt Built-in Functions::
10079 * ARM C Language Extensions (ACLE)::
10080 * ARM Floating Point Status and Control Intrinsics::
10081 * AVR Built-in Functions::
10082 * Blackfin Built-in Functions::
10083 * FR-V Built-in Functions::
10084 * MIPS DSP Built-in Functions::
10085 * MIPS Paired-Single Support::
10086 * MIPS Loongson Built-in Functions::
10087 * Other MIPS Built-in Functions::
10088 * MSP430 Built-in Functions::
10089 * NDS32 Built-in Functions::
10090 * picoChip Built-in Functions::
10091 * PowerPC Built-in Functions::
10092 * PowerPC AltiVec/VSX Built-in Functions::
10093 * PowerPC Hardware Transactional Memory Built-in Functions::
10094 * RX Built-in Functions::
10095 * S/390 System z Built-in Functions::
10096 * SH Built-in Functions::
10097 * SPARC VIS Built-in Functions::
10098 * SPU Built-in Functions::
10099 * TI C6X Built-in Functions::
10100 * TILE-Gx Built-in Functions::
10101 * TILEPro Built-in Functions::
10102 * x86 Built-in Functions::
10103 * x86 transactional memory intrinsics::
10106 @node AArch64 Built-in Functions
10107 @subsection AArch64 Built-in Functions
10109 These built-in functions are available for the AArch64 family of
10112 unsigned int __builtin_aarch64_get_fpcr ()
10113 void __builtin_aarch64_set_fpcr (unsigned int)
10114 unsigned int __builtin_aarch64_get_fpsr ()
10115 void __builtin_aarch64_set_fpsr (unsigned int)
10118 @node Alpha Built-in Functions
10119 @subsection Alpha Built-in Functions
10121 These built-in functions are available for the Alpha family of
10122 processors, depending on the command-line switches used.
10124 The following built-in functions are always available. They
10125 all generate the machine instruction that is part of the name.
10128 long __builtin_alpha_implver (void)
10129 long __builtin_alpha_rpcc (void)
10130 long __builtin_alpha_amask (long)
10131 long __builtin_alpha_cmpbge (long, long)
10132 long __builtin_alpha_extbl (long, long)
10133 long __builtin_alpha_extwl (long, long)
10134 long __builtin_alpha_extll (long, long)
10135 long __builtin_alpha_extql (long, long)
10136 long __builtin_alpha_extwh (long, long)
10137 long __builtin_alpha_extlh (long, long)
10138 long __builtin_alpha_extqh (long, long)
10139 long __builtin_alpha_insbl (long, long)
10140 long __builtin_alpha_inswl (long, long)
10141 long __builtin_alpha_insll (long, long)
10142 long __builtin_alpha_insql (long, long)
10143 long __builtin_alpha_inswh (long, long)
10144 long __builtin_alpha_inslh (long, long)
10145 long __builtin_alpha_insqh (long, long)
10146 long __builtin_alpha_mskbl (long, long)
10147 long __builtin_alpha_mskwl (long, long)
10148 long __builtin_alpha_mskll (long, long)
10149 long __builtin_alpha_mskql (long, long)
10150 long __builtin_alpha_mskwh (long, long)
10151 long __builtin_alpha_msklh (long, long)
10152 long __builtin_alpha_mskqh (long, long)
10153 long __builtin_alpha_umulh (long, long)
10154 long __builtin_alpha_zap (long, long)
10155 long __builtin_alpha_zapnot (long, long)
10158 The following built-in functions are always with @option{-mmax}
10159 or @option{-mcpu=@var{cpu}} where @var{cpu} is @code{pca56} or
10160 later. They all generate the machine instruction that is part
10164 long __builtin_alpha_pklb (long)
10165 long __builtin_alpha_pkwb (long)
10166 long __builtin_alpha_unpkbl (long)
10167 long __builtin_alpha_unpkbw (long)
10168 long __builtin_alpha_minub8 (long, long)
10169 long __builtin_alpha_minsb8 (long, long)
10170 long __builtin_alpha_minuw4 (long, long)
10171 long __builtin_alpha_minsw4 (long, long)
10172 long __builtin_alpha_maxub8 (long, long)
10173 long __builtin_alpha_maxsb8 (long, long)
10174 long __builtin_alpha_maxuw4 (long, long)
10175 long __builtin_alpha_maxsw4 (long, long)
10176 long __builtin_alpha_perr (long, long)
10179 The following built-in functions are always with @option{-mcix}
10180 or @option{-mcpu=@var{cpu}} where @var{cpu} is @code{ev67} or
10181 later. They all generate the machine instruction that is part
10185 long __builtin_alpha_cttz (long)
10186 long __builtin_alpha_ctlz (long)
10187 long __builtin_alpha_ctpop (long)
10190 The following built-in functions are available on systems that use the OSF/1
10191 PALcode. Normally they invoke the @code{rduniq} and @code{wruniq}
10192 PAL calls, but when invoked with @option{-mtls-kernel}, they invoke
10193 @code{rdval} and @code{wrval}.
10196 void *__builtin_thread_pointer (void)
10197 void __builtin_set_thread_pointer (void *)
10200 @node Altera Nios II Built-in Functions
10201 @subsection Altera Nios II Built-in Functions
10203 These built-in functions are available for the Altera Nios II
10204 family of processors.
10206 The following built-in functions are always available. They
10207 all generate the machine instruction that is part of the name.
10210 int __builtin_ldbio (volatile const void *)
10211 int __builtin_ldbuio (volatile const void *)
10212 int __builtin_ldhio (volatile const void *)
10213 int __builtin_ldhuio (volatile const void *)
10214 int __builtin_ldwio (volatile const void *)
10215 void __builtin_stbio (volatile void *, int)
10216 void __builtin_sthio (volatile void *, int)
10217 void __builtin_stwio (volatile void *, int)
10218 void __builtin_sync (void)
10219 int __builtin_rdctl (int)
10220 void __builtin_wrctl (int, int)
10223 The following built-in functions are always available. They
10224 all generate a Nios II Custom Instruction. The name of the
10225 function represents the types that the function takes and
10226 returns. The letter before the @code{n} is the return type
10227 or void if absent. The @code{n} represents the first parameter
10228 to all the custom instructions, the custom instruction number.
10229 The two letters after the @code{n} represent the up to two
10230 parameters to the function.
10232 The letters represent the following data types:
10235 @code{void} for return type and no parameter for parameter types.
10238 @code{int} for return type and parameter type
10241 @code{float} for return type and parameter type
10244 @code{void *} for return type and parameter type
10248 And the function names are:
10250 void __builtin_custom_n (void)
10251 void __builtin_custom_ni (int)
10252 void __builtin_custom_nf (float)
10253 void __builtin_custom_np (void *)
10254 void __builtin_custom_nii (int, int)
10255 void __builtin_custom_nif (int, float)
10256 void __builtin_custom_nip (int, void *)
10257 void __builtin_custom_nfi (float, int)
10258 void __builtin_custom_nff (float, float)
10259 void __builtin_custom_nfp (float, void *)
10260 void __builtin_custom_npi (void *, int)
10261 void __builtin_custom_npf (void *, float)
10262 void __builtin_custom_npp (void *, void *)
10263 int __builtin_custom_in (void)
10264 int __builtin_custom_ini (int)
10265 int __builtin_custom_inf (float)
10266 int __builtin_custom_inp (void *)
10267 int __builtin_custom_inii (int, int)
10268 int __builtin_custom_inif (int, float)
10269 int __builtin_custom_inip (int, void *)
10270 int __builtin_custom_infi (float, int)
10271 int __builtin_custom_inff (float, float)
10272 int __builtin_custom_infp (float, void *)
10273 int __builtin_custom_inpi (void *, int)
10274 int __builtin_custom_inpf (void *, float)
10275 int __builtin_custom_inpp (void *, void *)
10276 float __builtin_custom_fn (void)
10277 float __builtin_custom_fni (int)
10278 float __builtin_custom_fnf (float)
10279 float __builtin_custom_fnp (void *)
10280 float __builtin_custom_fnii (int, int)
10281 float __builtin_custom_fnif (int, float)
10282 float __builtin_custom_fnip (int, void *)
10283 float __builtin_custom_fnfi (float, int)
10284 float __builtin_custom_fnff (float, float)
10285 float __builtin_custom_fnfp (float, void *)
10286 float __builtin_custom_fnpi (void *, int)
10287 float __builtin_custom_fnpf (void *, float)
10288 float __builtin_custom_fnpp (void *, void *)
10289 void * __builtin_custom_pn (void)
10290 void * __builtin_custom_pni (int)
10291 void * __builtin_custom_pnf (float)
10292 void * __builtin_custom_pnp (void *)
10293 void * __builtin_custom_pnii (int, int)
10294 void * __builtin_custom_pnif (int, float)
10295 void * __builtin_custom_pnip (int, void *)
10296 void * __builtin_custom_pnfi (float, int)
10297 void * __builtin_custom_pnff (float, float)
10298 void * __builtin_custom_pnfp (float, void *)
10299 void * __builtin_custom_pnpi (void *, int)
10300 void * __builtin_custom_pnpf (void *, float)
10301 void * __builtin_custom_pnpp (void *, void *)
10304 @node ARC Built-in Functions
10305 @subsection ARC Built-in Functions
10307 The following built-in functions are provided for ARC targets. The
10308 built-ins generate the corresponding assembly instructions. In the
10309 examples given below, the generated code often requires an operand or
10310 result to be in a register. Where necessary further code will be
10311 generated to ensure this is true, but for brevity this is not
10312 described in each case.
10314 @emph{Note:} Using a built-in to generate an instruction not supported
10315 by a target may cause problems. At present the compiler is not
10316 guaranteed to detect such misuse, and as a result an internal compiler
10317 error may be generated.
10319 @deftypefn {Built-in Function} int __builtin_arc_aligned (void *@var{val}, int @var{alignval})
10320 Return 1 if @var{val} is known to have the byte alignment given
10321 by @var{alignval}, otherwise return 0.
10322 Note that this is different from
10324 __alignof__(*(char *)@var{val}) >= alignval
10326 because __alignof__ sees only the type of the dereference, whereas
10327 __builtin_arc_align uses alignment information from the pointer
10328 as well as from the pointed-to type.
10329 The information available will depend on optimization level.
10332 @deftypefn {Built-in Function} void __builtin_arc_brk (void)
10339 @deftypefn {Built-in Function} {unsigned int} __builtin_arc_core_read (unsigned int @var{regno})
10340 The operand is the number of a register to be read. Generates:
10342 mov @var{dest}, r@var{regno}
10344 where the value in @var{dest} will be the result returned from the
10348 @deftypefn {Built-in Function} void __builtin_arc_core_write (unsigned int @var{regno}, unsigned int @var{val})
10349 The first operand is the number of a register to be written, the
10350 second operand is a compile time constant to write into that
10351 register. Generates:
10353 mov r@var{regno}, @var{val}
10357 @deftypefn {Built-in Function} int __builtin_arc_divaw (int @var{a}, int @var{b})
10358 Only available if either @option{-mcpu=ARC700} or @option{-meA} is set.
10361 divaw @var{dest}, @var{a}, @var{b}
10363 where the value in @var{dest} will be the result returned from the
10367 @deftypefn {Built-in Function} void __builtin_arc_flag (unsigned int @var{a})
10374 @deftypefn {Built-in Function} {unsigned int} __builtin_arc_lr (unsigned int @var{auxr})
10375 The operand, @var{auxv}, is the address of an auxiliary register and
10376 must be a compile time constant. Generates:
10378 lr @var{dest}, [@var{auxr}]
10380 Where the value in @var{dest} will be the result returned from the
10384 @deftypefn {Built-in Function} void __builtin_arc_mul64 (int @var{a}, int @var{b})
10385 Only available with @option{-mmul64}. Generates:
10387 mul64 @var{a}, @var{b}
10391 @deftypefn {Built-in Function} void __builtin_arc_mulu64 (unsigned int @var{a}, unsigned int @var{b})
10392 Only available with @option{-mmul64}. Generates:
10394 mulu64 @var{a}, @var{b}
10398 @deftypefn {Built-in Function} void __builtin_arc_nop (void)
10405 @deftypefn {Built-in Function} int __builtin_arc_norm (int @var{src})
10406 Only valid if the @samp{norm} instruction is available through the
10407 @option{-mnorm} option or by default with @option{-mcpu=ARC700}.
10410 norm @var{dest}, @var{src}
10412 Where the value in @var{dest} will be the result returned from the
10416 @deftypefn {Built-in Function} {short int} __builtin_arc_normw (short int @var{src})
10417 Only valid if the @samp{normw} instruction is available through the
10418 @option{-mnorm} option or by default with @option{-mcpu=ARC700}.
10421 normw @var{dest}, @var{src}
10423 Where the value in @var{dest} will be the result returned from the
10427 @deftypefn {Built-in Function} void __builtin_arc_rtie (void)
10434 @deftypefn {Built-in Function} void __builtin_arc_sleep (int @var{a}
10441 @deftypefn {Built-in Function} void __builtin_arc_sr (unsigned int @var{auxr}, unsigned int @var{val})
10442 The first argument, @var{auxv}, is the address of an auxiliary
10443 register, the second argument, @var{val}, is a compile time constant
10444 to be written to the register. Generates:
10446 sr @var{auxr}, [@var{val}]
10450 @deftypefn {Built-in Function} int __builtin_arc_swap (int @var{src})
10451 Only valid with @option{-mswap}. Generates:
10453 swap @var{dest}, @var{src}
10455 Where the value in @var{dest} will be the result returned from the
10459 @deftypefn {Built-in Function} void __builtin_arc_swi (void)
10466 @deftypefn {Built-in Function} void __builtin_arc_sync (void)
10467 Only available with @option{-mcpu=ARC700}. Generates:
10473 @deftypefn {Built-in Function} void __builtin_arc_trap_s (unsigned int @var{c})
10474 Only available with @option{-mcpu=ARC700}. Generates:
10480 @deftypefn {Built-in Function} void __builtin_arc_unimp_s (void)
10481 Only available with @option{-mcpu=ARC700}. Generates:
10487 The instructions generated by the following builtins are not
10488 considered as candidates for scheduling. They are not moved around by
10489 the compiler during scheduling, and thus can be expected to appear
10490 where they are put in the C code:
10492 __builtin_arc_brk()
10493 __builtin_arc_core_read()
10494 __builtin_arc_core_write()
10495 __builtin_arc_flag()
10497 __builtin_arc_sleep()
10499 __builtin_arc_swi()
10502 @node ARC SIMD Built-in Functions
10503 @subsection ARC SIMD Built-in Functions
10505 SIMD builtins provided by the compiler can be used to generate the
10506 vector instructions. This section describes the available builtins
10507 and their usage in programs. With the @option{-msimd} option, the
10508 compiler provides 128-bit vector types, which can be specified using
10509 the @code{vector_size} attribute. The header file @file{arc-simd.h}
10510 can be included to use the following predefined types:
10512 typedef int __v4si __attribute__((vector_size(16)));
10513 typedef short __v8hi __attribute__((vector_size(16)));
10516 These types can be used to define 128-bit variables. The built-in
10517 functions listed in the following section can be used on these
10518 variables to generate the vector operations.
10520 For all builtins, @code{__builtin_arc_@var{someinsn}}, the header file
10521 @file{arc-simd.h} also provides equivalent macros called
10522 @code{_@var{someinsn}} that can be used for programming ease and
10523 improved readability. The following macros for DMA control are also
10526 #define _setup_dma_in_channel_reg _vdiwr
10527 #define _setup_dma_out_channel_reg _vdowr
10530 The following is a complete list of all the SIMD built-ins provided
10531 for ARC, grouped by calling signature.
10533 The following take two @code{__v8hi} arguments and return a
10534 @code{__v8hi} result:
10536 __v8hi __builtin_arc_vaddaw (__v8hi, __v8hi)
10537 __v8hi __builtin_arc_vaddw (__v8hi, __v8hi)
10538 __v8hi __builtin_arc_vand (__v8hi, __v8hi)
10539 __v8hi __builtin_arc_vandaw (__v8hi, __v8hi)
10540 __v8hi __builtin_arc_vavb (__v8hi, __v8hi)
10541 __v8hi __builtin_arc_vavrb (__v8hi, __v8hi)
10542 __v8hi __builtin_arc_vbic (__v8hi, __v8hi)
10543 __v8hi __builtin_arc_vbicaw (__v8hi, __v8hi)
10544 __v8hi __builtin_arc_vdifaw (__v8hi, __v8hi)
10545 __v8hi __builtin_arc_vdifw (__v8hi, __v8hi)
10546 __v8hi __builtin_arc_veqw (__v8hi, __v8hi)
10547 __v8hi __builtin_arc_vh264f (__v8hi, __v8hi)
10548 __v8hi __builtin_arc_vh264ft (__v8hi, __v8hi)
10549 __v8hi __builtin_arc_vh264fw (__v8hi, __v8hi)
10550 __v8hi __builtin_arc_vlew (__v8hi, __v8hi)
10551 __v8hi __builtin_arc_vltw (__v8hi, __v8hi)
10552 __v8hi __builtin_arc_vmaxaw (__v8hi, __v8hi)
10553 __v8hi __builtin_arc_vmaxw (__v8hi, __v8hi)
10554 __v8hi __builtin_arc_vminaw (__v8hi, __v8hi)
10555 __v8hi __builtin_arc_vminw (__v8hi, __v8hi)
10556 __v8hi __builtin_arc_vmr1aw (__v8hi, __v8hi)
10557 __v8hi __builtin_arc_vmr1w (__v8hi, __v8hi)
10558 __v8hi __builtin_arc_vmr2aw (__v8hi, __v8hi)
10559 __v8hi __builtin_arc_vmr2w (__v8hi, __v8hi)
10560 __v8hi __builtin_arc_vmr3aw (__v8hi, __v8hi)
10561 __v8hi __builtin_arc_vmr3w (__v8hi, __v8hi)
10562 __v8hi __builtin_arc_vmr4aw (__v8hi, __v8hi)
10563 __v8hi __builtin_arc_vmr4w (__v8hi, __v8hi)
10564 __v8hi __builtin_arc_vmr5aw (__v8hi, __v8hi)
10565 __v8hi __builtin_arc_vmr5w (__v8hi, __v8hi)
10566 __v8hi __builtin_arc_vmr6aw (__v8hi, __v8hi)
10567 __v8hi __builtin_arc_vmr6w (__v8hi, __v8hi)
10568 __v8hi __builtin_arc_vmr7aw (__v8hi, __v8hi)
10569 __v8hi __builtin_arc_vmr7w (__v8hi, __v8hi)
10570 __v8hi __builtin_arc_vmrb (__v8hi, __v8hi)
10571 __v8hi __builtin_arc_vmulaw (__v8hi, __v8hi)
10572 __v8hi __builtin_arc_vmulfaw (__v8hi, __v8hi)
10573 __v8hi __builtin_arc_vmulfw (__v8hi, __v8hi)
10574 __v8hi __builtin_arc_vmulw (__v8hi, __v8hi)
10575 __v8hi __builtin_arc_vnew (__v8hi, __v8hi)
10576 __v8hi __builtin_arc_vor (__v8hi, __v8hi)
10577 __v8hi __builtin_arc_vsubaw (__v8hi, __v8hi)
10578 __v8hi __builtin_arc_vsubw (__v8hi, __v8hi)
10579 __v8hi __builtin_arc_vsummw (__v8hi, __v8hi)
10580 __v8hi __builtin_arc_vvc1f (__v8hi, __v8hi)
10581 __v8hi __builtin_arc_vvc1ft (__v8hi, __v8hi)
10582 __v8hi __builtin_arc_vxor (__v8hi, __v8hi)
10583 __v8hi __builtin_arc_vxoraw (__v8hi, __v8hi)
10586 The following take one @code{__v8hi} and one @code{int} argument and return a
10587 @code{__v8hi} result:
10590 __v8hi __builtin_arc_vbaddw (__v8hi, int)
10591 __v8hi __builtin_arc_vbmaxw (__v8hi, int)
10592 __v8hi __builtin_arc_vbminw (__v8hi, int)
10593 __v8hi __builtin_arc_vbmulaw (__v8hi, int)
10594 __v8hi __builtin_arc_vbmulfw (__v8hi, int)
10595 __v8hi __builtin_arc_vbmulw (__v8hi, int)
10596 __v8hi __builtin_arc_vbrsubw (__v8hi, int)
10597 __v8hi __builtin_arc_vbsubw (__v8hi, int)
10600 The following take one @code{__v8hi} argument and one @code{int} argument which
10601 must be a 3-bit compile time constant indicating a register number
10602 I0-I7. They return a @code{__v8hi} result.
10604 __v8hi __builtin_arc_vasrw (__v8hi, const int)
10605 __v8hi __builtin_arc_vsr8 (__v8hi, const int)
10606 __v8hi __builtin_arc_vsr8aw (__v8hi, const int)
10609 The following take one @code{__v8hi} argument and one @code{int}
10610 argument which must be a 6-bit compile time constant. They return a
10611 @code{__v8hi} result.
10613 __v8hi __builtin_arc_vasrpwbi (__v8hi, const int)
10614 __v8hi __builtin_arc_vasrrpwbi (__v8hi, const int)
10615 __v8hi __builtin_arc_vasrrwi (__v8hi, const int)
10616 __v8hi __builtin_arc_vasrsrwi (__v8hi, const int)
10617 __v8hi __builtin_arc_vasrwi (__v8hi, const int)
10618 __v8hi __builtin_arc_vsr8awi (__v8hi, const int)
10619 __v8hi __builtin_arc_vsr8i (__v8hi, const int)
10622 The following take one @code{__v8hi} argument and one @code{int} argument which
10623 must be a 8-bit compile time constant. They return a @code{__v8hi}
10626 __v8hi __builtin_arc_vd6tapf (__v8hi, const int)
10627 __v8hi __builtin_arc_vmvaw (__v8hi, const int)
10628 __v8hi __builtin_arc_vmvw (__v8hi, const int)
10629 __v8hi __builtin_arc_vmvzw (__v8hi, const int)
10632 The following take two @code{int} arguments, the second of which which
10633 must be a 8-bit compile time constant. They return a @code{__v8hi}
10636 __v8hi __builtin_arc_vmovaw (int, const int)
10637 __v8hi __builtin_arc_vmovw (int, const int)
10638 __v8hi __builtin_arc_vmovzw (int, const int)
10641 The following take a single @code{__v8hi} argument and return a
10642 @code{__v8hi} result:
10644 __v8hi __builtin_arc_vabsaw (__v8hi)
10645 __v8hi __builtin_arc_vabsw (__v8hi)
10646 __v8hi __builtin_arc_vaddsuw (__v8hi)
10647 __v8hi __builtin_arc_vexch1 (__v8hi)
10648 __v8hi __builtin_arc_vexch2 (__v8hi)
10649 __v8hi __builtin_arc_vexch4 (__v8hi)
10650 __v8hi __builtin_arc_vsignw (__v8hi)
10651 __v8hi __builtin_arc_vupbaw (__v8hi)
10652 __v8hi __builtin_arc_vupbw (__v8hi)
10653 __v8hi __builtin_arc_vupsbaw (__v8hi)
10654 __v8hi __builtin_arc_vupsbw (__v8hi)
10657 The following take two @code{int} arguments and return no result:
10659 void __builtin_arc_vdirun (int, int)
10660 void __builtin_arc_vdorun (int, int)
10663 The following take two @code{int} arguments and return no result. The
10664 first argument must a 3-bit compile time constant indicating one of
10665 the DR0-DR7 DMA setup channels:
10667 void __builtin_arc_vdiwr (const int, int)
10668 void __builtin_arc_vdowr (const int, int)
10671 The following take an @code{int} argument and return no result:
10673 void __builtin_arc_vendrec (int)
10674 void __builtin_arc_vrec (int)
10675 void __builtin_arc_vrecrun (int)
10676 void __builtin_arc_vrun (int)
10679 The following take a @code{__v8hi} argument and two @code{int}
10680 arguments and return a @code{__v8hi} result. The second argument must
10681 be a 3-bit compile time constants, indicating one the registers I0-I7,
10682 and the third argument must be an 8-bit compile time constant.
10684 @emph{Note:} Although the equivalent hardware instructions do not take
10685 an SIMD register as an operand, these builtins overwrite the relevant
10686 bits of the @code{__v8hi} register provided as the first argument with
10687 the value loaded from the @code{[Ib, u8]} location in the SDM.
10690 __v8hi __builtin_arc_vld32 (__v8hi, const int, const int)
10691 __v8hi __builtin_arc_vld32wh (__v8hi, const int, const int)
10692 __v8hi __builtin_arc_vld32wl (__v8hi, const int, const int)
10693 __v8hi __builtin_arc_vld64 (__v8hi, const int, const int)
10696 The following take two @code{int} arguments and return a @code{__v8hi}
10697 result. The first argument must be a 3-bit compile time constants,
10698 indicating one the registers I0-I7, and the second argument must be an
10699 8-bit compile time constant.
10702 __v8hi __builtin_arc_vld128 (const int, const int)
10703 __v8hi __builtin_arc_vld64w (const int, const int)
10706 The following take a @code{__v8hi} argument and two @code{int}
10707 arguments and return no result. The second argument must be a 3-bit
10708 compile time constants, indicating one the registers I0-I7, and the
10709 third argument must be an 8-bit compile time constant.
10712 void __builtin_arc_vst128 (__v8hi, const int, const int)
10713 void __builtin_arc_vst64 (__v8hi, const int, const int)
10716 The following take a @code{__v8hi} argument and three @code{int}
10717 arguments and return no result. The second argument must be a 3-bit
10718 compile-time constant, identifying the 16-bit sub-register to be
10719 stored, the third argument must be a 3-bit compile time constants,
10720 indicating one the registers I0-I7, and the fourth argument must be an
10721 8-bit compile time constant.
10724 void __builtin_arc_vst16_n (__v8hi, const int, const int, const int)
10725 void __builtin_arc_vst32_n (__v8hi, const int, const int, const int)
10728 @node ARM iWMMXt Built-in Functions
10729 @subsection ARM iWMMXt Built-in Functions
10731 These built-in functions are available for the ARM family of
10732 processors when the @option{-mcpu=iwmmxt} switch is used:
10735 typedef int v2si __attribute__ ((vector_size (8)));
10736 typedef short v4hi __attribute__ ((vector_size (8)));
10737 typedef char v8qi __attribute__ ((vector_size (8)));
10739 int __builtin_arm_getwcgr0 (void)
10740 void __builtin_arm_setwcgr0 (int)
10741 int __builtin_arm_getwcgr1 (void)
10742 void __builtin_arm_setwcgr1 (int)
10743 int __builtin_arm_getwcgr2 (void)
10744 void __builtin_arm_setwcgr2 (int)
10745 int __builtin_arm_getwcgr3 (void)
10746 void __builtin_arm_setwcgr3 (int)
10747 int __builtin_arm_textrmsb (v8qi, int)
10748 int __builtin_arm_textrmsh (v4hi, int)
10749 int __builtin_arm_textrmsw (v2si, int)
10750 int __builtin_arm_textrmub (v8qi, int)
10751 int __builtin_arm_textrmuh (v4hi, int)
10752 int __builtin_arm_textrmuw (v2si, int)
10753 v8qi __builtin_arm_tinsrb (v8qi, int, int)
10754 v4hi __builtin_arm_tinsrh (v4hi, int, int)
10755 v2si __builtin_arm_tinsrw (v2si, int, int)
10756 long long __builtin_arm_tmia (long long, int, int)
10757 long long __builtin_arm_tmiabb (long long, int, int)
10758 long long __builtin_arm_tmiabt (long long, int, int)
10759 long long __builtin_arm_tmiaph (long long, int, int)
10760 long long __builtin_arm_tmiatb (long long, int, int)
10761 long long __builtin_arm_tmiatt (long long, int, int)
10762 int __builtin_arm_tmovmskb (v8qi)
10763 int __builtin_arm_tmovmskh (v4hi)
10764 int __builtin_arm_tmovmskw (v2si)
10765 long long __builtin_arm_waccb (v8qi)
10766 long long __builtin_arm_wacch (v4hi)
10767 long long __builtin_arm_waccw (v2si)
10768 v8qi __builtin_arm_waddb (v8qi, v8qi)
10769 v8qi __builtin_arm_waddbss (v8qi, v8qi)
10770 v8qi __builtin_arm_waddbus (v8qi, v8qi)
10771 v4hi __builtin_arm_waddh (v4hi, v4hi)
10772 v4hi __builtin_arm_waddhss (v4hi, v4hi)
10773 v4hi __builtin_arm_waddhus (v4hi, v4hi)
10774 v2si __builtin_arm_waddw (v2si, v2si)
10775 v2si __builtin_arm_waddwss (v2si, v2si)
10776 v2si __builtin_arm_waddwus (v2si, v2si)
10777 v8qi __builtin_arm_walign (v8qi, v8qi, int)
10778 long long __builtin_arm_wand(long long, long long)
10779 long long __builtin_arm_wandn (long long, long long)
10780 v8qi __builtin_arm_wavg2b (v8qi, v8qi)
10781 v8qi __builtin_arm_wavg2br (v8qi, v8qi)
10782 v4hi __builtin_arm_wavg2h (v4hi, v4hi)
10783 v4hi __builtin_arm_wavg2hr (v4hi, v4hi)
10784 v8qi __builtin_arm_wcmpeqb (v8qi, v8qi)
10785 v4hi __builtin_arm_wcmpeqh (v4hi, v4hi)
10786 v2si __builtin_arm_wcmpeqw (v2si, v2si)
10787 v8qi __builtin_arm_wcmpgtsb (v8qi, v8qi)
10788 v4hi __builtin_arm_wcmpgtsh (v4hi, v4hi)
10789 v2si __builtin_arm_wcmpgtsw (v2si, v2si)
10790 v8qi __builtin_arm_wcmpgtub (v8qi, v8qi)
10791 v4hi __builtin_arm_wcmpgtuh (v4hi, v4hi)
10792 v2si __builtin_arm_wcmpgtuw (v2si, v2si)
10793 long long __builtin_arm_wmacs (long long, v4hi, v4hi)
10794 long long __builtin_arm_wmacsz (v4hi, v4hi)
10795 long long __builtin_arm_wmacu (long long, v4hi, v4hi)
10796 long long __builtin_arm_wmacuz (v4hi, v4hi)
10797 v4hi __builtin_arm_wmadds (v4hi, v4hi)
10798 v4hi __builtin_arm_wmaddu (v4hi, v4hi)
10799 v8qi __builtin_arm_wmaxsb (v8qi, v8qi)
10800 v4hi __builtin_arm_wmaxsh (v4hi, v4hi)
10801 v2si __builtin_arm_wmaxsw (v2si, v2si)
10802 v8qi __builtin_arm_wmaxub (v8qi, v8qi)
10803 v4hi __builtin_arm_wmaxuh (v4hi, v4hi)
10804 v2si __builtin_arm_wmaxuw (v2si, v2si)
10805 v8qi __builtin_arm_wminsb (v8qi, v8qi)
10806 v4hi __builtin_arm_wminsh (v4hi, v4hi)
10807 v2si __builtin_arm_wminsw (v2si, v2si)
10808 v8qi __builtin_arm_wminub (v8qi, v8qi)
10809 v4hi __builtin_arm_wminuh (v4hi, v4hi)
10810 v2si __builtin_arm_wminuw (v2si, v2si)
10811 v4hi __builtin_arm_wmulsm (v4hi, v4hi)
10812 v4hi __builtin_arm_wmulul (v4hi, v4hi)
10813 v4hi __builtin_arm_wmulum (v4hi, v4hi)
10814 long long __builtin_arm_wor (long long, long long)
10815 v2si __builtin_arm_wpackdss (long long, long long)
10816 v2si __builtin_arm_wpackdus (long long, long long)
10817 v8qi __builtin_arm_wpackhss (v4hi, v4hi)
10818 v8qi __builtin_arm_wpackhus (v4hi, v4hi)
10819 v4hi __builtin_arm_wpackwss (v2si, v2si)
10820 v4hi __builtin_arm_wpackwus (v2si, v2si)
10821 long long __builtin_arm_wrord (long long, long long)
10822 long long __builtin_arm_wrordi (long long, int)
10823 v4hi __builtin_arm_wrorh (v4hi, long long)
10824 v4hi __builtin_arm_wrorhi (v4hi, int)
10825 v2si __builtin_arm_wrorw (v2si, long long)
10826 v2si __builtin_arm_wrorwi (v2si, int)
10827 v2si __builtin_arm_wsadb (v2si, v8qi, v8qi)
10828 v2si __builtin_arm_wsadbz (v8qi, v8qi)
10829 v2si __builtin_arm_wsadh (v2si, v4hi, v4hi)
10830 v2si __builtin_arm_wsadhz (v4hi, v4hi)
10831 v4hi __builtin_arm_wshufh (v4hi, int)
10832 long long __builtin_arm_wslld (long long, long long)
10833 long long __builtin_arm_wslldi (long long, int)
10834 v4hi __builtin_arm_wsllh (v4hi, long long)
10835 v4hi __builtin_arm_wsllhi (v4hi, int)
10836 v2si __builtin_arm_wsllw (v2si, long long)
10837 v2si __builtin_arm_wsllwi (v2si, int)
10838 long long __builtin_arm_wsrad (long long, long long)
10839 long long __builtin_arm_wsradi (long long, int)
10840 v4hi __builtin_arm_wsrah (v4hi, long long)
10841 v4hi __builtin_arm_wsrahi (v4hi, int)
10842 v2si __builtin_arm_wsraw (v2si, long long)
10843 v2si __builtin_arm_wsrawi (v2si, int)
10844 long long __builtin_arm_wsrld (long long, long long)
10845 long long __builtin_arm_wsrldi (long long, int)
10846 v4hi __builtin_arm_wsrlh (v4hi, long long)
10847 v4hi __builtin_arm_wsrlhi (v4hi, int)
10848 v2si __builtin_arm_wsrlw (v2si, long long)
10849 v2si __builtin_arm_wsrlwi (v2si, int)
10850 v8qi __builtin_arm_wsubb (v8qi, v8qi)
10851 v8qi __builtin_arm_wsubbss (v8qi, v8qi)
10852 v8qi __builtin_arm_wsubbus (v8qi, v8qi)
10853 v4hi __builtin_arm_wsubh (v4hi, v4hi)
10854 v4hi __builtin_arm_wsubhss (v4hi, v4hi)
10855 v4hi __builtin_arm_wsubhus (v4hi, v4hi)
10856 v2si __builtin_arm_wsubw (v2si, v2si)
10857 v2si __builtin_arm_wsubwss (v2si, v2si)
10858 v2si __builtin_arm_wsubwus (v2si, v2si)
10859 v4hi __builtin_arm_wunpckehsb (v8qi)
10860 v2si __builtin_arm_wunpckehsh (v4hi)
10861 long long __builtin_arm_wunpckehsw (v2si)
10862 v4hi __builtin_arm_wunpckehub (v8qi)
10863 v2si __builtin_arm_wunpckehuh (v4hi)
10864 long long __builtin_arm_wunpckehuw (v2si)
10865 v4hi __builtin_arm_wunpckelsb (v8qi)
10866 v2si __builtin_arm_wunpckelsh (v4hi)
10867 long long __builtin_arm_wunpckelsw (v2si)
10868 v4hi __builtin_arm_wunpckelub (v8qi)
10869 v2si __builtin_arm_wunpckeluh (v4hi)
10870 long long __builtin_arm_wunpckeluw (v2si)
10871 v8qi __builtin_arm_wunpckihb (v8qi, v8qi)
10872 v4hi __builtin_arm_wunpckihh (v4hi, v4hi)
10873 v2si __builtin_arm_wunpckihw (v2si, v2si)
10874 v8qi __builtin_arm_wunpckilb (v8qi, v8qi)
10875 v4hi __builtin_arm_wunpckilh (v4hi, v4hi)
10876 v2si __builtin_arm_wunpckilw (v2si, v2si)
10877 long long __builtin_arm_wxor (long long, long long)
10878 long long __builtin_arm_wzero ()
10882 @node ARM C Language Extensions (ACLE)
10883 @subsection ARM C Language Extensions (ACLE)
10885 GCC implements extensions for C as described in the ARM C Language
10886 Extensions (ACLE) specification, which can be found at
10887 @uref{http://infocenter.arm.com/help/topic/com.arm.doc.ihi0053c/IHI0053C_acle_2_0.pdf}.
10889 As a part of ACLE, GCC implements extensions for Advanced SIMD as described in
10890 the ARM C Language Extensions Specification. The complete list of Advanced SIMD
10891 intrinsics can be found at
10892 @uref{http://infocenter.arm.com/help/topic/com.arm.doc.ihi0073a/IHI0073A_arm_neon_intrinsics_ref.pdf}.
10893 The built-in intrinsics for the Advanced SIMD extension are available when
10896 Currently, ARM and AArch64 back ends do not support ACLE 2.0 fully. Both
10897 back ends support CRC32 intrinsics from @file{arm_acle.h}. The ARM back end's
10898 16-bit floating-point Advanced SIMD intrinsics currently comply to ACLE v1.1.
10899 AArch64's back end does not have support for 16-bit floating point Advanced SIMD
10902 See @ref{ARM Options} and @ref{AArch64 Options} for more information on the
10903 availability of extensions.
10905 @node ARM Floating Point Status and Control Intrinsics
10906 @subsection ARM Floating Point Status and Control Intrinsics
10908 These built-in functions are available for the ARM family of
10909 processors with floating-point unit.
10912 unsigned int __builtin_arm_get_fpscr ()
10913 void __builtin_arm_set_fpscr (unsigned int)
10916 @node AVR Built-in Functions
10917 @subsection AVR Built-in Functions
10919 For each built-in function for AVR, there is an equally named,
10920 uppercase built-in macro defined. That way users can easily query if
10921 or if not a specific built-in is implemented or not. For example, if
10922 @code{__builtin_avr_nop} is available the macro
10923 @code{__BUILTIN_AVR_NOP} is defined to @code{1} and undefined otherwise.
10925 The following built-in functions map to the respective machine
10926 instruction, i.e.@: @code{nop}, @code{sei}, @code{cli}, @code{sleep},
10927 @code{wdr}, @code{swap}, @code{fmul}, @code{fmuls}
10928 resp. @code{fmulsu}. The three @code{fmul*} built-ins are implemented
10929 as library call if no hardware multiplier is available.
10932 void __builtin_avr_nop (void)
10933 void __builtin_avr_sei (void)
10934 void __builtin_avr_cli (void)
10935 void __builtin_avr_sleep (void)
10936 void __builtin_avr_wdr (void)
10937 unsigned char __builtin_avr_swap (unsigned char)
10938 unsigned int __builtin_avr_fmul (unsigned char, unsigned char)
10939 int __builtin_avr_fmuls (char, char)
10940 int __builtin_avr_fmulsu (char, unsigned char)
10943 In order to delay execution for a specific number of cycles, GCC
10946 void __builtin_avr_delay_cycles (unsigned long ticks)
10950 @code{ticks} is the number of ticks to delay execution. Note that this
10951 built-in does not take into account the effect of interrupts that
10952 might increase delay time. @code{ticks} must be a compile-time
10953 integer constant; delays with a variable number of cycles are not supported.
10956 char __builtin_avr_flash_segment (const __memx void*)
10960 This built-in takes a byte address to the 24-bit
10961 @ref{AVR Named Address Spaces,address space} @code{__memx} and returns
10962 the number of the flash segment (the 64 KiB chunk) where the address
10963 points to. Counting starts at @code{0}.
10964 If the address does not point to flash memory, return @code{-1}.
10967 unsigned char __builtin_avr_insert_bits (unsigned long map, unsigned char bits, unsigned char val)
10971 Insert bits from @var{bits} into @var{val} and return the resulting
10972 value. The nibbles of @var{map} determine how the insertion is
10973 performed: Let @var{X} be the @var{n}-th nibble of @var{map}
10975 @item If @var{X} is @code{0xf},
10976 then the @var{n}-th bit of @var{val} is returned unaltered.
10978 @item If X is in the range 0@dots{}7,
10979 then the @var{n}-th result bit is set to the @var{X}-th bit of @var{bits}
10981 @item If X is in the range 8@dots{}@code{0xe},
10982 then the @var{n}-th result bit is undefined.
10986 One typical use case for this built-in is adjusting input and
10987 output values to non-contiguous port layouts. Some examples:
10990 // same as val, bits is unused
10991 __builtin_avr_insert_bits (0xffffffff, bits, val)
10995 // same as bits, val is unused
10996 __builtin_avr_insert_bits (0x76543210, bits, val)
11000 // same as rotating bits by 4
11001 __builtin_avr_insert_bits (0x32107654, bits, 0)
11005 // high nibble of result is the high nibble of val
11006 // low nibble of result is the low nibble of bits
11007 __builtin_avr_insert_bits (0xffff3210, bits, val)
11011 // reverse the bit order of bits
11012 __builtin_avr_insert_bits (0x01234567, bits, 0)
11015 @node Blackfin Built-in Functions
11016 @subsection Blackfin Built-in Functions
11018 Currently, there are two Blackfin-specific built-in functions. These are
11019 used for generating @code{CSYNC} and @code{SSYNC} machine insns without
11020 using inline assembly; by using these built-in functions the compiler can
11021 automatically add workarounds for hardware errata involving these
11022 instructions. These functions are named as follows:
11025 void __builtin_bfin_csync (void)
11026 void __builtin_bfin_ssync (void)
11029 @node FR-V Built-in Functions
11030 @subsection FR-V Built-in Functions
11032 GCC provides many FR-V-specific built-in functions. In general,
11033 these functions are intended to be compatible with those described
11034 by @cite{FR-V Family, Softune C/C++ Compiler Manual (V6), Fujitsu
11035 Semiconductor}. The two exceptions are @code{__MDUNPACKH} and
11036 @code{__MBTOHE}, the GCC forms of which pass 128-bit values by
11037 pointer rather than by value.
11039 Most of the functions are named after specific FR-V instructions.
11040 Such functions are said to be ``directly mapped'' and are summarized
11041 here in tabular form.
11045 * Directly-mapped Integer Functions::
11046 * Directly-mapped Media Functions::
11047 * Raw read/write Functions::
11048 * Other Built-in Functions::
11051 @node Argument Types
11052 @subsubsection Argument Types
11054 The arguments to the built-in functions can be divided into three groups:
11055 register numbers, compile-time constants and run-time values. In order
11056 to make this classification clear at a glance, the arguments and return
11057 values are given the following pseudo types:
11059 @multitable @columnfractions .20 .30 .15 .35
11060 @item Pseudo type @tab Real C type @tab Constant? @tab Description
11061 @item @code{uh} @tab @code{unsigned short} @tab No @tab an unsigned halfword
11062 @item @code{uw1} @tab @code{unsigned int} @tab No @tab an unsigned word
11063 @item @code{sw1} @tab @code{int} @tab No @tab a signed word
11064 @item @code{uw2} @tab @code{unsigned long long} @tab No
11065 @tab an unsigned doubleword
11066 @item @code{sw2} @tab @code{long long} @tab No @tab a signed doubleword
11067 @item @code{const} @tab @code{int} @tab Yes @tab an integer constant
11068 @item @code{acc} @tab @code{int} @tab Yes @tab an ACC register number
11069 @item @code{iacc} @tab @code{int} @tab Yes @tab an IACC register number
11072 These pseudo types are not defined by GCC, they are simply a notational
11073 convenience used in this manual.
11075 Arguments of type @code{uh}, @code{uw1}, @code{sw1}, @code{uw2}
11076 and @code{sw2} are evaluated at run time. They correspond to
11077 register operands in the underlying FR-V instructions.
11079 @code{const} arguments represent immediate operands in the underlying
11080 FR-V instructions. They must be compile-time constants.
11082 @code{acc} arguments are evaluated at compile time and specify the number
11083 of an accumulator register. For example, an @code{acc} argument of 2
11084 selects the ACC2 register.
11086 @code{iacc} arguments are similar to @code{acc} arguments but specify the
11087 number of an IACC register. See @pxref{Other Built-in Functions}
11090 @node Directly-mapped Integer Functions
11091 @subsubsection Directly-Mapped Integer Functions
11093 The functions listed below map directly to FR-V I-type instructions.
11095 @multitable @columnfractions .45 .32 .23
11096 @item Function prototype @tab Example usage @tab Assembly output
11097 @item @code{sw1 __ADDSS (sw1, sw1)}
11098 @tab @code{@var{c} = __ADDSS (@var{a}, @var{b})}
11099 @tab @code{ADDSS @var{a},@var{b},@var{c}}
11100 @item @code{sw1 __SCAN (sw1, sw1)}
11101 @tab @code{@var{c} = __SCAN (@var{a}, @var{b})}
11102 @tab @code{SCAN @var{a},@var{b},@var{c}}
11103 @item @code{sw1 __SCUTSS (sw1)}
11104 @tab @code{@var{b} = __SCUTSS (@var{a})}
11105 @tab @code{SCUTSS @var{a},@var{b}}
11106 @item @code{sw1 __SLASS (sw1, sw1)}
11107 @tab @code{@var{c} = __SLASS (@var{a}, @var{b})}
11108 @tab @code{SLASS @var{a},@var{b},@var{c}}
11109 @item @code{void __SMASS (sw1, sw1)}
11110 @tab @code{__SMASS (@var{a}, @var{b})}
11111 @tab @code{SMASS @var{a},@var{b}}
11112 @item @code{void __SMSSS (sw1, sw1)}
11113 @tab @code{__SMSSS (@var{a}, @var{b})}
11114 @tab @code{SMSSS @var{a},@var{b}}
11115 @item @code{void __SMU (sw1, sw1)}
11116 @tab @code{__SMU (@var{a}, @var{b})}
11117 @tab @code{SMU @var{a},@var{b}}
11118 @item @code{sw2 __SMUL (sw1, sw1)}
11119 @tab @code{@var{c} = __SMUL (@var{a}, @var{b})}
11120 @tab @code{SMUL @var{a},@var{b},@var{c}}
11121 @item @code{sw1 __SUBSS (sw1, sw1)}
11122 @tab @code{@var{c} = __SUBSS (@var{a}, @var{b})}
11123 @tab @code{SUBSS @var{a},@var{b},@var{c}}
11124 @item @code{uw2 __UMUL (uw1, uw1)}
11125 @tab @code{@var{c} = __UMUL (@var{a}, @var{b})}
11126 @tab @code{UMUL @var{a},@var{b},@var{c}}
11129 @node Directly-mapped Media Functions
11130 @subsubsection Directly-Mapped Media Functions
11132 The functions listed below map directly to FR-V M-type instructions.
11134 @multitable @columnfractions .45 .32 .23
11135 @item Function prototype @tab Example usage @tab Assembly output
11136 @item @code{uw1 __MABSHS (sw1)}
11137 @tab @code{@var{b} = __MABSHS (@var{a})}
11138 @tab @code{MABSHS @var{a},@var{b}}
11139 @item @code{void __MADDACCS (acc, acc)}
11140 @tab @code{__MADDACCS (@var{b}, @var{a})}
11141 @tab @code{MADDACCS @var{a},@var{b}}
11142 @item @code{sw1 __MADDHSS (sw1, sw1)}
11143 @tab @code{@var{c} = __MADDHSS (@var{a}, @var{b})}
11144 @tab @code{MADDHSS @var{a},@var{b},@var{c}}
11145 @item @code{uw1 __MADDHUS (uw1, uw1)}
11146 @tab @code{@var{c} = __MADDHUS (@var{a}, @var{b})}
11147 @tab @code{MADDHUS @var{a},@var{b},@var{c}}
11148 @item @code{uw1 __MAND (uw1, uw1)}
11149 @tab @code{@var{c} = __MAND (@var{a}, @var{b})}
11150 @tab @code{MAND @var{a},@var{b},@var{c}}
11151 @item @code{void __MASACCS (acc, acc)}
11152 @tab @code{__MASACCS (@var{b}, @var{a})}
11153 @tab @code{MASACCS @var{a},@var{b}}
11154 @item @code{uw1 __MAVEH (uw1, uw1)}
11155 @tab @code{@var{c} = __MAVEH (@var{a}, @var{b})}
11156 @tab @code{MAVEH @var{a},@var{b},@var{c}}
11157 @item @code{uw2 __MBTOH (uw1)}
11158 @tab @code{@var{b} = __MBTOH (@var{a})}
11159 @tab @code{MBTOH @var{a},@var{b}}
11160 @item @code{void __MBTOHE (uw1 *, uw1)}
11161 @tab @code{__MBTOHE (&@var{b}, @var{a})}
11162 @tab @code{MBTOHE @var{a},@var{b}}
11163 @item @code{void __MCLRACC (acc)}
11164 @tab @code{__MCLRACC (@var{a})}
11165 @tab @code{MCLRACC @var{a}}
11166 @item @code{void __MCLRACCA (void)}
11167 @tab @code{__MCLRACCA ()}
11168 @tab @code{MCLRACCA}
11169 @item @code{uw1 __Mcop1 (uw1, uw1)}
11170 @tab @code{@var{c} = __Mcop1 (@var{a}, @var{b})}
11171 @tab @code{Mcop1 @var{a},@var{b},@var{c}}
11172 @item @code{uw1 __Mcop2 (uw1, uw1)}
11173 @tab @code{@var{c} = __Mcop2 (@var{a}, @var{b})}
11174 @tab @code{Mcop2 @var{a},@var{b},@var{c}}
11175 @item @code{uw1 __MCPLHI (uw2, const)}
11176 @tab @code{@var{c} = __MCPLHI (@var{a}, @var{b})}
11177 @tab @code{MCPLHI @var{a},#@var{b},@var{c}}
11178 @item @code{uw1 __MCPLI (uw2, const)}
11179 @tab @code{@var{c} = __MCPLI (@var{a}, @var{b})}
11180 @tab @code{MCPLI @var{a},#@var{b},@var{c}}
11181 @item @code{void __MCPXIS (acc, sw1, sw1)}
11182 @tab @code{__MCPXIS (@var{c}, @var{a}, @var{b})}
11183 @tab @code{MCPXIS @var{a},@var{b},@var{c}}
11184 @item @code{void __MCPXIU (acc, uw1, uw1)}
11185 @tab @code{__MCPXIU (@var{c}, @var{a}, @var{b})}
11186 @tab @code{MCPXIU @var{a},@var{b},@var{c}}
11187 @item @code{void __MCPXRS (acc, sw1, sw1)}
11188 @tab @code{__MCPXRS (@var{c}, @var{a}, @var{b})}
11189 @tab @code{MCPXRS @var{a},@var{b},@var{c}}
11190 @item @code{void __MCPXRU (acc, uw1, uw1)}
11191 @tab @code{__MCPXRU (@var{c}, @var{a}, @var{b})}
11192 @tab @code{MCPXRU @var{a},@var{b},@var{c}}
11193 @item @code{uw1 __MCUT (acc, uw1)}
11194 @tab @code{@var{c} = __MCUT (@var{a}, @var{b})}
11195 @tab @code{MCUT @var{a},@var{b},@var{c}}
11196 @item @code{uw1 __MCUTSS (acc, sw1)}
11197 @tab @code{@var{c} = __MCUTSS (@var{a}, @var{b})}
11198 @tab @code{MCUTSS @var{a},@var{b},@var{c}}
11199 @item @code{void __MDADDACCS (acc, acc)}
11200 @tab @code{__MDADDACCS (@var{b}, @var{a})}
11201 @tab @code{MDADDACCS @var{a},@var{b}}
11202 @item @code{void __MDASACCS (acc, acc)}
11203 @tab @code{__MDASACCS (@var{b}, @var{a})}
11204 @tab @code{MDASACCS @var{a},@var{b}}
11205 @item @code{uw2 __MDCUTSSI (acc, const)}
11206 @tab @code{@var{c} = __MDCUTSSI (@var{a}, @var{b})}
11207 @tab @code{MDCUTSSI @var{a},#@var{b},@var{c}}
11208 @item @code{uw2 __MDPACKH (uw2, uw2)}
11209 @tab @code{@var{c} = __MDPACKH (@var{a}, @var{b})}
11210 @tab @code{MDPACKH @var{a},@var{b},@var{c}}
11211 @item @code{uw2 __MDROTLI (uw2, const)}
11212 @tab @code{@var{c} = __MDROTLI (@var{a}, @var{b})}
11213 @tab @code{MDROTLI @var{a},#@var{b},@var{c}}
11214 @item @code{void __MDSUBACCS (acc, acc)}
11215 @tab @code{__MDSUBACCS (@var{b}, @var{a})}
11216 @tab @code{MDSUBACCS @var{a},@var{b}}
11217 @item @code{void __MDUNPACKH (uw1 *, uw2)}
11218 @tab @code{__MDUNPACKH (&@var{b}, @var{a})}
11219 @tab @code{MDUNPACKH @var{a},@var{b}}
11220 @item @code{uw2 __MEXPDHD (uw1, const)}
11221 @tab @code{@var{c} = __MEXPDHD (@var{a}, @var{b})}
11222 @tab @code{MEXPDHD @var{a},#@var{b},@var{c}}
11223 @item @code{uw1 __MEXPDHW (uw1, const)}
11224 @tab @code{@var{c} = __MEXPDHW (@var{a}, @var{b})}
11225 @tab @code{MEXPDHW @var{a},#@var{b},@var{c}}
11226 @item @code{uw1 __MHDSETH (uw1, const)}
11227 @tab @code{@var{c} = __MHDSETH (@var{a}, @var{b})}
11228 @tab @code{MHDSETH @var{a},#@var{b},@var{c}}
11229 @item @code{sw1 __MHDSETS (const)}
11230 @tab @code{@var{b} = __MHDSETS (@var{a})}
11231 @tab @code{MHDSETS #@var{a},@var{b}}
11232 @item @code{uw1 __MHSETHIH (uw1, const)}
11233 @tab @code{@var{b} = __MHSETHIH (@var{b}, @var{a})}
11234 @tab @code{MHSETHIH #@var{a},@var{b}}
11235 @item @code{sw1 __MHSETHIS (sw1, const)}
11236 @tab @code{@var{b} = __MHSETHIS (@var{b}, @var{a})}
11237 @tab @code{MHSETHIS #@var{a},@var{b}}
11238 @item @code{uw1 __MHSETLOH (uw1, const)}
11239 @tab @code{@var{b} = __MHSETLOH (@var{b}, @var{a})}
11240 @tab @code{MHSETLOH #@var{a},@var{b}}
11241 @item @code{sw1 __MHSETLOS (sw1, const)}
11242 @tab @code{@var{b} = __MHSETLOS (@var{b}, @var{a})}
11243 @tab @code{MHSETLOS #@var{a},@var{b}}
11244 @item @code{uw1 __MHTOB (uw2)}
11245 @tab @code{@var{b} = __MHTOB (@var{a})}
11246 @tab @code{MHTOB @var{a},@var{b}}
11247 @item @code{void __MMACHS (acc, sw1, sw1)}
11248 @tab @code{__MMACHS (@var{c}, @var{a}, @var{b})}
11249 @tab @code{MMACHS @var{a},@var{b},@var{c}}
11250 @item @code{void __MMACHU (acc, uw1, uw1)}
11251 @tab @code{__MMACHU (@var{c}, @var{a}, @var{b})}
11252 @tab @code{MMACHU @var{a},@var{b},@var{c}}
11253 @item @code{void __MMRDHS (acc, sw1, sw1)}
11254 @tab @code{__MMRDHS (@var{c}, @var{a}, @var{b})}
11255 @tab @code{MMRDHS @var{a},@var{b},@var{c}}
11256 @item @code{void __MMRDHU (acc, uw1, uw1)}
11257 @tab @code{__MMRDHU (@var{c}, @var{a}, @var{b})}
11258 @tab @code{MMRDHU @var{a},@var{b},@var{c}}
11259 @item @code{void __MMULHS (acc, sw1, sw1)}
11260 @tab @code{__MMULHS (@var{c}, @var{a}, @var{b})}
11261 @tab @code{MMULHS @var{a},@var{b},@var{c}}
11262 @item @code{void __MMULHU (acc, uw1, uw1)}
11263 @tab @code{__MMULHU (@var{c}, @var{a}, @var{b})}
11264 @tab @code{MMULHU @var{a},@var{b},@var{c}}
11265 @item @code{void __MMULXHS (acc, sw1, sw1)}
11266 @tab @code{__MMULXHS (@var{c}, @var{a}, @var{b})}
11267 @tab @code{MMULXHS @var{a},@var{b},@var{c}}
11268 @item @code{void __MMULXHU (acc, uw1, uw1)}
11269 @tab @code{__MMULXHU (@var{c}, @var{a}, @var{b})}
11270 @tab @code{MMULXHU @var{a},@var{b},@var{c}}
11271 @item @code{uw1 __MNOT (uw1)}
11272 @tab @code{@var{b} = __MNOT (@var{a})}
11273 @tab @code{MNOT @var{a},@var{b}}
11274 @item @code{uw1 __MOR (uw1, uw1)}
11275 @tab @code{@var{c} = __MOR (@var{a}, @var{b})}
11276 @tab @code{MOR @var{a},@var{b},@var{c}}
11277 @item @code{uw1 __MPACKH (uh, uh)}
11278 @tab @code{@var{c} = __MPACKH (@var{a}, @var{b})}
11279 @tab @code{MPACKH @var{a},@var{b},@var{c}}
11280 @item @code{sw2 __MQADDHSS (sw2, sw2)}
11281 @tab @code{@var{c} = __MQADDHSS (@var{a}, @var{b})}
11282 @tab @code{MQADDHSS @var{a},@var{b},@var{c}}
11283 @item @code{uw2 __MQADDHUS (uw2, uw2)}
11284 @tab @code{@var{c} = __MQADDHUS (@var{a}, @var{b})}
11285 @tab @code{MQADDHUS @var{a},@var{b},@var{c}}
11286 @item @code{void __MQCPXIS (acc, sw2, sw2)}
11287 @tab @code{__MQCPXIS (@var{c}, @var{a}, @var{b})}
11288 @tab @code{MQCPXIS @var{a},@var{b},@var{c}}
11289 @item @code{void __MQCPXIU (acc, uw2, uw2)}
11290 @tab @code{__MQCPXIU (@var{c}, @var{a}, @var{b})}
11291 @tab @code{MQCPXIU @var{a},@var{b},@var{c}}
11292 @item @code{void __MQCPXRS (acc, sw2, sw2)}
11293 @tab @code{__MQCPXRS (@var{c}, @var{a}, @var{b})}
11294 @tab @code{MQCPXRS @var{a},@var{b},@var{c}}
11295 @item @code{void __MQCPXRU (acc, uw2, uw2)}
11296 @tab @code{__MQCPXRU (@var{c}, @var{a}, @var{b})}
11297 @tab @code{MQCPXRU @var{a},@var{b},@var{c}}
11298 @item @code{sw2 __MQLCLRHS (sw2, sw2)}
11299 @tab @code{@var{c} = __MQLCLRHS (@var{a}, @var{b})}
11300 @tab @code{MQLCLRHS @var{a},@var{b},@var{c}}
11301 @item @code{sw2 __MQLMTHS (sw2, sw2)}
11302 @tab @code{@var{c} = __MQLMTHS (@var{a}, @var{b})}
11303 @tab @code{MQLMTHS @var{a},@var{b},@var{c}}
11304 @item @code{void __MQMACHS (acc, sw2, sw2)}
11305 @tab @code{__MQMACHS (@var{c}, @var{a}, @var{b})}
11306 @tab @code{MQMACHS @var{a},@var{b},@var{c}}
11307 @item @code{void __MQMACHU (acc, uw2, uw2)}
11308 @tab @code{__MQMACHU (@var{c}, @var{a}, @var{b})}
11309 @tab @code{MQMACHU @var{a},@var{b},@var{c}}
11310 @item @code{void __MQMACXHS (acc, sw2, sw2)}
11311 @tab @code{__MQMACXHS (@var{c}, @var{a}, @var{b})}
11312 @tab @code{MQMACXHS @var{a},@var{b},@var{c}}
11313 @item @code{void __MQMULHS (acc, sw2, sw2)}
11314 @tab @code{__MQMULHS (@var{c}, @var{a}, @var{b})}
11315 @tab @code{MQMULHS @var{a},@var{b},@var{c}}
11316 @item @code{void __MQMULHU (acc, uw2, uw2)}
11317 @tab @code{__MQMULHU (@var{c}, @var{a}, @var{b})}
11318 @tab @code{MQMULHU @var{a},@var{b},@var{c}}
11319 @item @code{void __MQMULXHS (acc, sw2, sw2)}
11320 @tab @code{__MQMULXHS (@var{c}, @var{a}, @var{b})}
11321 @tab @code{MQMULXHS @var{a},@var{b},@var{c}}
11322 @item @code{void __MQMULXHU (acc, uw2, uw2)}
11323 @tab @code{__MQMULXHU (@var{c}, @var{a}, @var{b})}
11324 @tab @code{MQMULXHU @var{a},@var{b},@var{c}}
11325 @item @code{sw2 __MQSATHS (sw2, sw2)}
11326 @tab @code{@var{c} = __MQSATHS (@var{a}, @var{b})}
11327 @tab @code{MQSATHS @var{a},@var{b},@var{c}}
11328 @item @code{uw2 __MQSLLHI (uw2, int)}
11329 @tab @code{@var{c} = __MQSLLHI (@var{a}, @var{b})}
11330 @tab @code{MQSLLHI @var{a},@var{b},@var{c}}
11331 @item @code{sw2 __MQSRAHI (sw2, int)}
11332 @tab @code{@var{c} = __MQSRAHI (@var{a}, @var{b})}
11333 @tab @code{MQSRAHI @var{a},@var{b},@var{c}}
11334 @item @code{sw2 __MQSUBHSS (sw2, sw2)}
11335 @tab @code{@var{c} = __MQSUBHSS (@var{a}, @var{b})}
11336 @tab @code{MQSUBHSS @var{a},@var{b},@var{c}}
11337 @item @code{uw2 __MQSUBHUS (uw2, uw2)}
11338 @tab @code{@var{c} = __MQSUBHUS (@var{a}, @var{b})}
11339 @tab @code{MQSUBHUS @var{a},@var{b},@var{c}}
11340 @item @code{void __MQXMACHS (acc, sw2, sw2)}
11341 @tab @code{__MQXMACHS (@var{c}, @var{a}, @var{b})}
11342 @tab @code{MQXMACHS @var{a},@var{b},@var{c}}
11343 @item @code{void __MQXMACXHS (acc, sw2, sw2)}
11344 @tab @code{__MQXMACXHS (@var{c}, @var{a}, @var{b})}
11345 @tab @code{MQXMACXHS @var{a},@var{b},@var{c}}
11346 @item @code{uw1 __MRDACC (acc)}
11347 @tab @code{@var{b} = __MRDACC (@var{a})}
11348 @tab @code{MRDACC @var{a},@var{b}}
11349 @item @code{uw1 __MRDACCG (acc)}
11350 @tab @code{@var{b} = __MRDACCG (@var{a})}
11351 @tab @code{MRDACCG @var{a},@var{b}}
11352 @item @code{uw1 __MROTLI (uw1, const)}
11353 @tab @code{@var{c} = __MROTLI (@var{a}, @var{b})}
11354 @tab @code{MROTLI @var{a},#@var{b},@var{c}}
11355 @item @code{uw1 __MROTRI (uw1, const)}
11356 @tab @code{@var{c} = __MROTRI (@var{a}, @var{b})}
11357 @tab @code{MROTRI @var{a},#@var{b},@var{c}}
11358 @item @code{sw1 __MSATHS (sw1, sw1)}
11359 @tab @code{@var{c} = __MSATHS (@var{a}, @var{b})}
11360 @tab @code{MSATHS @var{a},@var{b},@var{c}}
11361 @item @code{uw1 __MSATHU (uw1, uw1)}
11362 @tab @code{@var{c} = __MSATHU (@var{a}, @var{b})}
11363 @tab @code{MSATHU @var{a},@var{b},@var{c}}
11364 @item @code{uw1 __MSLLHI (uw1, const)}
11365 @tab @code{@var{c} = __MSLLHI (@var{a}, @var{b})}
11366 @tab @code{MSLLHI @var{a},#@var{b},@var{c}}
11367 @item @code{sw1 __MSRAHI (sw1, const)}
11368 @tab @code{@var{c} = __MSRAHI (@var{a}, @var{b})}
11369 @tab @code{MSRAHI @var{a},#@var{b},@var{c}}
11370 @item @code{uw1 __MSRLHI (uw1, const)}
11371 @tab @code{@var{c} = __MSRLHI (@var{a}, @var{b})}
11372 @tab @code{MSRLHI @var{a},#@var{b},@var{c}}
11373 @item @code{void __MSUBACCS (acc, acc)}
11374 @tab @code{__MSUBACCS (@var{b}, @var{a})}
11375 @tab @code{MSUBACCS @var{a},@var{b}}
11376 @item @code{sw1 __MSUBHSS (sw1, sw1)}
11377 @tab @code{@var{c} = __MSUBHSS (@var{a}, @var{b})}
11378 @tab @code{MSUBHSS @var{a},@var{b},@var{c}}
11379 @item @code{uw1 __MSUBHUS (uw1, uw1)}
11380 @tab @code{@var{c} = __MSUBHUS (@var{a}, @var{b})}
11381 @tab @code{MSUBHUS @var{a},@var{b},@var{c}}
11382 @item @code{void __MTRAP (void)}
11383 @tab @code{__MTRAP ()}
11385 @item @code{uw2 __MUNPACKH (uw1)}
11386 @tab @code{@var{b} = __MUNPACKH (@var{a})}
11387 @tab @code{MUNPACKH @var{a},@var{b}}
11388 @item @code{uw1 __MWCUT (uw2, uw1)}
11389 @tab @code{@var{c} = __MWCUT (@var{a}, @var{b})}
11390 @tab @code{MWCUT @var{a},@var{b},@var{c}}
11391 @item @code{void __MWTACC (acc, uw1)}
11392 @tab @code{__MWTACC (@var{b}, @var{a})}
11393 @tab @code{MWTACC @var{a},@var{b}}
11394 @item @code{void __MWTACCG (acc, uw1)}
11395 @tab @code{__MWTACCG (@var{b}, @var{a})}
11396 @tab @code{MWTACCG @var{a},@var{b}}
11397 @item @code{uw1 __MXOR (uw1, uw1)}
11398 @tab @code{@var{c} = __MXOR (@var{a}, @var{b})}
11399 @tab @code{MXOR @var{a},@var{b},@var{c}}
11402 @node Raw read/write Functions
11403 @subsubsection Raw Read/Write Functions
11405 This sections describes built-in functions related to read and write
11406 instructions to access memory. These functions generate
11407 @code{membar} instructions to flush the I/O load and stores where
11408 appropriate, as described in Fujitsu's manual described above.
11412 @item unsigned char __builtin_read8 (void *@var{data})
11413 @item unsigned short __builtin_read16 (void *@var{data})
11414 @item unsigned long __builtin_read32 (void *@var{data})
11415 @item unsigned long long __builtin_read64 (void *@var{data})
11417 @item void __builtin_write8 (void *@var{data}, unsigned char @var{datum})
11418 @item void __builtin_write16 (void *@var{data}, unsigned short @var{datum})
11419 @item void __builtin_write32 (void *@var{data}, unsigned long @var{datum})
11420 @item void __builtin_write64 (void *@var{data}, unsigned long long @var{datum})
11423 @node Other Built-in Functions
11424 @subsubsection Other Built-in Functions
11426 This section describes built-in functions that are not named after
11427 a specific FR-V instruction.
11430 @item sw2 __IACCreadll (iacc @var{reg})
11431 Return the full 64-bit value of IACC0@. The @var{reg} argument is reserved
11432 for future expansion and must be 0.
11434 @item sw1 __IACCreadl (iacc @var{reg})
11435 Return the value of IACC0H if @var{reg} is 0 and IACC0L if @var{reg} is 1.
11436 Other values of @var{reg} are rejected as invalid.
11438 @item void __IACCsetll (iacc @var{reg}, sw2 @var{x})
11439 Set the full 64-bit value of IACC0 to @var{x}. The @var{reg} argument
11440 is reserved for future expansion and must be 0.
11442 @item void __IACCsetl (iacc @var{reg}, sw1 @var{x})
11443 Set IACC0H to @var{x} if @var{reg} is 0 and IACC0L to @var{x} if @var{reg}
11444 is 1. Other values of @var{reg} are rejected as invalid.
11446 @item void __data_prefetch0 (const void *@var{x})
11447 Use the @code{dcpl} instruction to load the contents of address @var{x}
11448 into the data cache.
11450 @item void __data_prefetch (const void *@var{x})
11451 Use the @code{nldub} instruction to load the contents of address @var{x}
11452 into the data cache. The instruction is issued in slot I1@.
11455 @node MIPS DSP Built-in Functions
11456 @subsection MIPS DSP Built-in Functions
11458 The MIPS DSP Application-Specific Extension (ASE) includes new
11459 instructions that are designed to improve the performance of DSP and
11460 media applications. It provides instructions that operate on packed
11461 8-bit/16-bit integer data, Q7, Q15 and Q31 fractional data.
11463 GCC supports MIPS DSP operations using both the generic
11464 vector extensions (@pxref{Vector Extensions}) and a collection of
11465 MIPS-specific built-in functions. Both kinds of support are
11466 enabled by the @option{-mdsp} command-line option.
11468 Revision 2 of the ASE was introduced in the second half of 2006.
11469 This revision adds extra instructions to the original ASE, but is
11470 otherwise backwards-compatible with it. You can select revision 2
11471 using the command-line option @option{-mdspr2}; this option implies
11474 The SCOUNT and POS bits of the DSP control register are global. The
11475 WRDSP, EXTPDP, EXTPDPV and MTHLIP instructions modify the SCOUNT and
11476 POS bits. During optimization, the compiler does not delete these
11477 instructions and it does not delete calls to functions containing
11478 these instructions.
11480 At present, GCC only provides support for operations on 32-bit
11481 vectors. The vector type associated with 8-bit integer data is
11482 usually called @code{v4i8}, the vector type associated with Q7
11483 is usually called @code{v4q7}, the vector type associated with 16-bit
11484 integer data is usually called @code{v2i16}, and the vector type
11485 associated with Q15 is usually called @code{v2q15}. They can be
11486 defined in C as follows:
11489 typedef signed char v4i8 __attribute__ ((vector_size(4)));
11490 typedef signed char v4q7 __attribute__ ((vector_size(4)));
11491 typedef short v2i16 __attribute__ ((vector_size(4)));
11492 typedef short v2q15 __attribute__ ((vector_size(4)));
11495 @code{v4i8}, @code{v4q7}, @code{v2i16} and @code{v2q15} values are
11496 initialized in the same way as aggregates. For example:
11499 v4i8 a = @{1, 2, 3, 4@};
11501 b = (v4i8) @{5, 6, 7, 8@};
11503 v2q15 c = @{0x0fcb, 0x3a75@};
11505 d = (v2q15) @{0.1234 * 0x1.0p15, 0.4567 * 0x1.0p15@};
11508 @emph{Note:} The CPU's endianness determines the order in which values
11509 are packed. On little-endian targets, the first value is the least
11510 significant and the last value is the most significant. The opposite
11511 order applies to big-endian targets. For example, the code above
11512 sets the lowest byte of @code{a} to @code{1} on little-endian targets
11513 and @code{4} on big-endian targets.
11515 @emph{Note:} Q7, Q15 and Q31 values must be initialized with their integer
11516 representation. As shown in this example, the integer representation
11517 of a Q7 value can be obtained by multiplying the fractional value by
11518 @code{0x1.0p7}. The equivalent for Q15 values is to multiply by
11519 @code{0x1.0p15}. The equivalent for Q31 values is to multiply by
11522 The table below lists the @code{v4i8} and @code{v2q15} operations for which
11523 hardware support exists. @code{a} and @code{b} are @code{v4i8} values,
11524 and @code{c} and @code{d} are @code{v2q15} values.
11526 @multitable @columnfractions .50 .50
11527 @item C code @tab MIPS instruction
11528 @item @code{a + b} @tab @code{addu.qb}
11529 @item @code{c + d} @tab @code{addq.ph}
11530 @item @code{a - b} @tab @code{subu.qb}
11531 @item @code{c - d} @tab @code{subq.ph}
11534 The table below lists the @code{v2i16} operation for which
11535 hardware support exists for the DSP ASE REV 2. @code{e} and @code{f} are
11536 @code{v2i16} values.
11538 @multitable @columnfractions .50 .50
11539 @item C code @tab MIPS instruction
11540 @item @code{e * f} @tab @code{mul.ph}
11543 It is easier to describe the DSP built-in functions if we first define
11544 the following types:
11549 typedef unsigned int ui32;
11550 typedef long long a64;
11553 @code{q31} and @code{i32} are actually the same as @code{int}, but we
11554 use @code{q31} to indicate a Q31 fractional value and @code{i32} to
11555 indicate a 32-bit integer value. Similarly, @code{a64} is the same as
11556 @code{long long}, but we use @code{a64} to indicate values that are
11557 placed in one of the four DSP accumulators (@code{$ac0},
11558 @code{$ac1}, @code{$ac2} or @code{$ac3}).
11560 Also, some built-in functions prefer or require immediate numbers as
11561 parameters, because the corresponding DSP instructions accept both immediate
11562 numbers and register operands, or accept immediate numbers only. The
11563 immediate parameters are listed as follows.
11571 imm0_255: 0 to 255.
11572 imm_n32_31: -32 to 31.
11573 imm_n512_511: -512 to 511.
11576 The following built-in functions map directly to a particular MIPS DSP
11577 instruction. Please refer to the architecture specification
11578 for details on what each instruction does.
11581 v2q15 __builtin_mips_addq_ph (v2q15, v2q15)
11582 v2q15 __builtin_mips_addq_s_ph (v2q15, v2q15)
11583 q31 __builtin_mips_addq_s_w (q31, q31)
11584 v4i8 __builtin_mips_addu_qb (v4i8, v4i8)
11585 v4i8 __builtin_mips_addu_s_qb (v4i8, v4i8)
11586 v2q15 __builtin_mips_subq_ph (v2q15, v2q15)
11587 v2q15 __builtin_mips_subq_s_ph (v2q15, v2q15)
11588 q31 __builtin_mips_subq_s_w (q31, q31)
11589 v4i8 __builtin_mips_subu_qb (v4i8, v4i8)
11590 v4i8 __builtin_mips_subu_s_qb (v4i8, v4i8)
11591 i32 __builtin_mips_addsc (i32, i32)
11592 i32 __builtin_mips_addwc (i32, i32)
11593 i32 __builtin_mips_modsub (i32, i32)
11594 i32 __builtin_mips_raddu_w_qb (v4i8)
11595 v2q15 __builtin_mips_absq_s_ph (v2q15)
11596 q31 __builtin_mips_absq_s_w (q31)
11597 v4i8 __builtin_mips_precrq_qb_ph (v2q15, v2q15)
11598 v2q15 __builtin_mips_precrq_ph_w (q31, q31)
11599 v2q15 __builtin_mips_precrq_rs_ph_w (q31, q31)
11600 v4i8 __builtin_mips_precrqu_s_qb_ph (v2q15, v2q15)
11601 q31 __builtin_mips_preceq_w_phl (v2q15)
11602 q31 __builtin_mips_preceq_w_phr (v2q15)
11603 v2q15 __builtin_mips_precequ_ph_qbl (v4i8)
11604 v2q15 __builtin_mips_precequ_ph_qbr (v4i8)
11605 v2q15 __builtin_mips_precequ_ph_qbla (v4i8)
11606 v2q15 __builtin_mips_precequ_ph_qbra (v4i8)
11607 v2q15 __builtin_mips_preceu_ph_qbl (v4i8)
11608 v2q15 __builtin_mips_preceu_ph_qbr (v4i8)
11609 v2q15 __builtin_mips_preceu_ph_qbla (v4i8)
11610 v2q15 __builtin_mips_preceu_ph_qbra (v4i8)
11611 v4i8 __builtin_mips_shll_qb (v4i8, imm0_7)
11612 v4i8 __builtin_mips_shll_qb (v4i8, i32)
11613 v2q15 __builtin_mips_shll_ph (v2q15, imm0_15)
11614 v2q15 __builtin_mips_shll_ph (v2q15, i32)
11615 v2q15 __builtin_mips_shll_s_ph (v2q15, imm0_15)
11616 v2q15 __builtin_mips_shll_s_ph (v2q15, i32)
11617 q31 __builtin_mips_shll_s_w (q31, imm0_31)
11618 q31 __builtin_mips_shll_s_w (q31, i32)
11619 v4i8 __builtin_mips_shrl_qb (v4i8, imm0_7)
11620 v4i8 __builtin_mips_shrl_qb (v4i8, i32)
11621 v2q15 __builtin_mips_shra_ph (v2q15, imm0_15)
11622 v2q15 __builtin_mips_shra_ph (v2q15, i32)
11623 v2q15 __builtin_mips_shra_r_ph (v2q15, imm0_15)
11624 v2q15 __builtin_mips_shra_r_ph (v2q15, i32)
11625 q31 __builtin_mips_shra_r_w (q31, imm0_31)
11626 q31 __builtin_mips_shra_r_w (q31, i32)
11627 v2q15 __builtin_mips_muleu_s_ph_qbl (v4i8, v2q15)
11628 v2q15 __builtin_mips_muleu_s_ph_qbr (v4i8, v2q15)
11629 v2q15 __builtin_mips_mulq_rs_ph (v2q15, v2q15)
11630 q31 __builtin_mips_muleq_s_w_phl (v2q15, v2q15)
11631 q31 __builtin_mips_muleq_s_w_phr (v2q15, v2q15)
11632 a64 __builtin_mips_dpau_h_qbl (a64, v4i8, v4i8)
11633 a64 __builtin_mips_dpau_h_qbr (a64, v4i8, v4i8)
11634 a64 __builtin_mips_dpsu_h_qbl (a64, v4i8, v4i8)
11635 a64 __builtin_mips_dpsu_h_qbr (a64, v4i8, v4i8)
11636 a64 __builtin_mips_dpaq_s_w_ph (a64, v2q15, v2q15)
11637 a64 __builtin_mips_dpaq_sa_l_w (a64, q31, q31)
11638 a64 __builtin_mips_dpsq_s_w_ph (a64, v2q15, v2q15)
11639 a64 __builtin_mips_dpsq_sa_l_w (a64, q31, q31)
11640 a64 __builtin_mips_mulsaq_s_w_ph (a64, v2q15, v2q15)
11641 a64 __builtin_mips_maq_s_w_phl (a64, v2q15, v2q15)
11642 a64 __builtin_mips_maq_s_w_phr (a64, v2q15, v2q15)
11643 a64 __builtin_mips_maq_sa_w_phl (a64, v2q15, v2q15)
11644 a64 __builtin_mips_maq_sa_w_phr (a64, v2q15, v2q15)
11645 i32 __builtin_mips_bitrev (i32)
11646 i32 __builtin_mips_insv (i32, i32)
11647 v4i8 __builtin_mips_repl_qb (imm0_255)
11648 v4i8 __builtin_mips_repl_qb (i32)
11649 v2q15 __builtin_mips_repl_ph (imm_n512_511)
11650 v2q15 __builtin_mips_repl_ph (i32)
11651 void __builtin_mips_cmpu_eq_qb (v4i8, v4i8)
11652 void __builtin_mips_cmpu_lt_qb (v4i8, v4i8)
11653 void __builtin_mips_cmpu_le_qb (v4i8, v4i8)
11654 i32 __builtin_mips_cmpgu_eq_qb (v4i8, v4i8)
11655 i32 __builtin_mips_cmpgu_lt_qb (v4i8, v4i8)
11656 i32 __builtin_mips_cmpgu_le_qb (v4i8, v4i8)
11657 void __builtin_mips_cmp_eq_ph (v2q15, v2q15)
11658 void __builtin_mips_cmp_lt_ph (v2q15, v2q15)
11659 void __builtin_mips_cmp_le_ph (v2q15, v2q15)
11660 v4i8 __builtin_mips_pick_qb (v4i8, v4i8)
11661 v2q15 __builtin_mips_pick_ph (v2q15, v2q15)
11662 v2q15 __builtin_mips_packrl_ph (v2q15, v2q15)
11663 i32 __builtin_mips_extr_w (a64, imm0_31)
11664 i32 __builtin_mips_extr_w (a64, i32)
11665 i32 __builtin_mips_extr_r_w (a64, imm0_31)
11666 i32 __builtin_mips_extr_s_h (a64, i32)
11667 i32 __builtin_mips_extr_rs_w (a64, imm0_31)
11668 i32 __builtin_mips_extr_rs_w (a64, i32)
11669 i32 __builtin_mips_extr_s_h (a64, imm0_31)
11670 i32 __builtin_mips_extr_r_w (a64, i32)
11671 i32 __builtin_mips_extp (a64, imm0_31)
11672 i32 __builtin_mips_extp (a64, i32)
11673 i32 __builtin_mips_extpdp (a64, imm0_31)
11674 i32 __builtin_mips_extpdp (a64, i32)
11675 a64 __builtin_mips_shilo (a64, imm_n32_31)
11676 a64 __builtin_mips_shilo (a64, i32)
11677 a64 __builtin_mips_mthlip (a64, i32)
11678 void __builtin_mips_wrdsp (i32, imm0_63)
11679 i32 __builtin_mips_rddsp (imm0_63)
11680 i32 __builtin_mips_lbux (void *, i32)
11681 i32 __builtin_mips_lhx (void *, i32)
11682 i32 __builtin_mips_lwx (void *, i32)
11683 a64 __builtin_mips_ldx (void *, i32) [MIPS64 only]
11684 i32 __builtin_mips_bposge32 (void)
11685 a64 __builtin_mips_madd (a64, i32, i32);
11686 a64 __builtin_mips_maddu (a64, ui32, ui32);
11687 a64 __builtin_mips_msub (a64, i32, i32);
11688 a64 __builtin_mips_msubu (a64, ui32, ui32);
11689 a64 __builtin_mips_mult (i32, i32);
11690 a64 __builtin_mips_multu (ui32, ui32);
11693 The following built-in functions map directly to a particular MIPS DSP REV 2
11694 instruction. Please refer to the architecture specification
11695 for details on what each instruction does.
11698 v4q7 __builtin_mips_absq_s_qb (v4q7);
11699 v2i16 __builtin_mips_addu_ph (v2i16, v2i16);
11700 v2i16 __builtin_mips_addu_s_ph (v2i16, v2i16);
11701 v4i8 __builtin_mips_adduh_qb (v4i8, v4i8);
11702 v4i8 __builtin_mips_adduh_r_qb (v4i8, v4i8);
11703 i32 __builtin_mips_append (i32, i32, imm0_31);
11704 i32 __builtin_mips_balign (i32, i32, imm0_3);
11705 i32 __builtin_mips_cmpgdu_eq_qb (v4i8, v4i8);
11706 i32 __builtin_mips_cmpgdu_lt_qb (v4i8, v4i8);
11707 i32 __builtin_mips_cmpgdu_le_qb (v4i8, v4i8);
11708 a64 __builtin_mips_dpa_w_ph (a64, v2i16, v2i16);
11709 a64 __builtin_mips_dps_w_ph (a64, v2i16, v2i16);
11710 v2i16 __builtin_mips_mul_ph (v2i16, v2i16);
11711 v2i16 __builtin_mips_mul_s_ph (v2i16, v2i16);
11712 q31 __builtin_mips_mulq_rs_w (q31, q31);
11713 v2q15 __builtin_mips_mulq_s_ph (v2q15, v2q15);
11714 q31 __builtin_mips_mulq_s_w (q31, q31);
11715 a64 __builtin_mips_mulsa_w_ph (a64, v2i16, v2i16);
11716 v4i8 __builtin_mips_precr_qb_ph (v2i16, v2i16);
11717 v2i16 __builtin_mips_precr_sra_ph_w (i32, i32, imm0_31);
11718 v2i16 __builtin_mips_precr_sra_r_ph_w (i32, i32, imm0_31);
11719 i32 __builtin_mips_prepend (i32, i32, imm0_31);
11720 v4i8 __builtin_mips_shra_qb (v4i8, imm0_7);
11721 v4i8 __builtin_mips_shra_r_qb (v4i8, imm0_7);
11722 v4i8 __builtin_mips_shra_qb (v4i8, i32);
11723 v4i8 __builtin_mips_shra_r_qb (v4i8, i32);
11724 v2i16 __builtin_mips_shrl_ph (v2i16, imm0_15);
11725 v2i16 __builtin_mips_shrl_ph (v2i16, i32);
11726 v2i16 __builtin_mips_subu_ph (v2i16, v2i16);
11727 v2i16 __builtin_mips_subu_s_ph (v2i16, v2i16);
11728 v4i8 __builtin_mips_subuh_qb (v4i8, v4i8);
11729 v4i8 __builtin_mips_subuh_r_qb (v4i8, v4i8);
11730 v2q15 __builtin_mips_addqh_ph (v2q15, v2q15);
11731 v2q15 __builtin_mips_addqh_r_ph (v2q15, v2q15);
11732 q31 __builtin_mips_addqh_w (q31, q31);
11733 q31 __builtin_mips_addqh_r_w (q31, q31);
11734 v2q15 __builtin_mips_subqh_ph (v2q15, v2q15);
11735 v2q15 __builtin_mips_subqh_r_ph (v2q15, v2q15);
11736 q31 __builtin_mips_subqh_w (q31, q31);
11737 q31 __builtin_mips_subqh_r_w (q31, q31);
11738 a64 __builtin_mips_dpax_w_ph (a64, v2i16, v2i16);
11739 a64 __builtin_mips_dpsx_w_ph (a64, v2i16, v2i16);
11740 a64 __builtin_mips_dpaqx_s_w_ph (a64, v2q15, v2q15);
11741 a64 __builtin_mips_dpaqx_sa_w_ph (a64, v2q15, v2q15);
11742 a64 __builtin_mips_dpsqx_s_w_ph (a64, v2q15, v2q15);
11743 a64 __builtin_mips_dpsqx_sa_w_ph (a64, v2q15, v2q15);
11747 @node MIPS Paired-Single Support
11748 @subsection MIPS Paired-Single Support
11750 The MIPS64 architecture includes a number of instructions that
11751 operate on pairs of single-precision floating-point values.
11752 Each pair is packed into a 64-bit floating-point register,
11753 with one element being designated the ``upper half'' and
11754 the other being designated the ``lower half''.
11756 GCC supports paired-single operations using both the generic
11757 vector extensions (@pxref{Vector Extensions}) and a collection of
11758 MIPS-specific built-in functions. Both kinds of support are
11759 enabled by the @option{-mpaired-single} command-line option.
11761 The vector type associated with paired-single values is usually
11762 called @code{v2sf}. It can be defined in C as follows:
11765 typedef float v2sf __attribute__ ((vector_size (8)));
11768 @code{v2sf} values are initialized in the same way as aggregates.
11772 v2sf a = @{1.5, 9.1@};
11775 b = (v2sf) @{e, f@};
11778 @emph{Note:} The CPU's endianness determines which value is stored in
11779 the upper half of a register and which value is stored in the lower half.
11780 On little-endian targets, the first value is the lower one and the second
11781 value is the upper one. The opposite order applies to big-endian targets.
11782 For example, the code above sets the lower half of @code{a} to
11783 @code{1.5} on little-endian targets and @code{9.1} on big-endian targets.
11785 @node MIPS Loongson Built-in Functions
11786 @subsection MIPS Loongson Built-in Functions
11788 GCC provides intrinsics to access the SIMD instructions provided by the
11789 ST Microelectronics Loongson-2E and -2F processors. These intrinsics,
11790 available after inclusion of the @code{loongson.h} header file,
11791 operate on the following 64-bit vector types:
11794 @item @code{uint8x8_t}, a vector of eight unsigned 8-bit integers;
11795 @item @code{uint16x4_t}, a vector of four unsigned 16-bit integers;
11796 @item @code{uint32x2_t}, a vector of two unsigned 32-bit integers;
11797 @item @code{int8x8_t}, a vector of eight signed 8-bit integers;
11798 @item @code{int16x4_t}, a vector of four signed 16-bit integers;
11799 @item @code{int32x2_t}, a vector of two signed 32-bit integers.
11802 The intrinsics provided are listed below; each is named after the
11803 machine instruction to which it corresponds, with suffixes added as
11804 appropriate to distinguish intrinsics that expand to the same machine
11805 instruction yet have different argument types. Refer to the architecture
11806 documentation for a description of the functionality of each
11810 int16x4_t packsswh (int32x2_t s, int32x2_t t);
11811 int8x8_t packsshb (int16x4_t s, int16x4_t t);
11812 uint8x8_t packushb (uint16x4_t s, uint16x4_t t);
11813 uint32x2_t paddw_u (uint32x2_t s, uint32x2_t t);
11814 uint16x4_t paddh_u (uint16x4_t s, uint16x4_t t);
11815 uint8x8_t paddb_u (uint8x8_t s, uint8x8_t t);
11816 int32x2_t paddw_s (int32x2_t s, int32x2_t t);
11817 int16x4_t paddh_s (int16x4_t s, int16x4_t t);
11818 int8x8_t paddb_s (int8x8_t s, int8x8_t t);
11819 uint64_t paddd_u (uint64_t s, uint64_t t);
11820 int64_t paddd_s (int64_t s, int64_t t);
11821 int16x4_t paddsh (int16x4_t s, int16x4_t t);
11822 int8x8_t paddsb (int8x8_t s, int8x8_t t);
11823 uint16x4_t paddush (uint16x4_t s, uint16x4_t t);
11824 uint8x8_t paddusb (uint8x8_t s, uint8x8_t t);
11825 uint64_t pandn_ud (uint64_t s, uint64_t t);
11826 uint32x2_t pandn_uw (uint32x2_t s, uint32x2_t t);
11827 uint16x4_t pandn_uh (uint16x4_t s, uint16x4_t t);
11828 uint8x8_t pandn_ub (uint8x8_t s, uint8x8_t t);
11829 int64_t pandn_sd (int64_t s, int64_t t);
11830 int32x2_t pandn_sw (int32x2_t s, int32x2_t t);
11831 int16x4_t pandn_sh (int16x4_t s, int16x4_t t);
11832 int8x8_t pandn_sb (int8x8_t s, int8x8_t t);
11833 uint16x4_t pavgh (uint16x4_t s, uint16x4_t t);
11834 uint8x8_t pavgb (uint8x8_t s, uint8x8_t t);
11835 uint32x2_t pcmpeqw_u (uint32x2_t s, uint32x2_t t);
11836 uint16x4_t pcmpeqh_u (uint16x4_t s, uint16x4_t t);
11837 uint8x8_t pcmpeqb_u (uint8x8_t s, uint8x8_t t);
11838 int32x2_t pcmpeqw_s (int32x2_t s, int32x2_t t);
11839 int16x4_t pcmpeqh_s (int16x4_t s, int16x4_t t);
11840 int8x8_t pcmpeqb_s (int8x8_t s, int8x8_t t);
11841 uint32x2_t pcmpgtw_u (uint32x2_t s, uint32x2_t t);
11842 uint16x4_t pcmpgth_u (uint16x4_t s, uint16x4_t t);
11843 uint8x8_t pcmpgtb_u (uint8x8_t s, uint8x8_t t);
11844 int32x2_t pcmpgtw_s (int32x2_t s, int32x2_t t);
11845 int16x4_t pcmpgth_s (int16x4_t s, int16x4_t t);
11846 int8x8_t pcmpgtb_s (int8x8_t s, int8x8_t t);
11847 uint16x4_t pextrh_u (uint16x4_t s, int field);
11848 int16x4_t pextrh_s (int16x4_t s, int field);
11849 uint16x4_t pinsrh_0_u (uint16x4_t s, uint16x4_t t);
11850 uint16x4_t pinsrh_1_u (uint16x4_t s, uint16x4_t t);
11851 uint16x4_t pinsrh_2_u (uint16x4_t s, uint16x4_t t);
11852 uint16x4_t pinsrh_3_u (uint16x4_t s, uint16x4_t t);
11853 int16x4_t pinsrh_0_s (int16x4_t s, int16x4_t t);
11854 int16x4_t pinsrh_1_s (int16x4_t s, int16x4_t t);
11855 int16x4_t pinsrh_2_s (int16x4_t s, int16x4_t t);
11856 int16x4_t pinsrh_3_s (int16x4_t s, int16x4_t t);
11857 int32x2_t pmaddhw (int16x4_t s, int16x4_t t);
11858 int16x4_t pmaxsh (int16x4_t s, int16x4_t t);
11859 uint8x8_t pmaxub (uint8x8_t s, uint8x8_t t);
11860 int16x4_t pminsh (int16x4_t s, int16x4_t t);
11861 uint8x8_t pminub (uint8x8_t s, uint8x8_t t);
11862 uint8x8_t pmovmskb_u (uint8x8_t s);
11863 int8x8_t pmovmskb_s (int8x8_t s);
11864 uint16x4_t pmulhuh (uint16x4_t s, uint16x4_t t);
11865 int16x4_t pmulhh (int16x4_t s, int16x4_t t);
11866 int16x4_t pmullh (int16x4_t s, int16x4_t t);
11867 int64_t pmuluw (uint32x2_t s, uint32x2_t t);
11868 uint8x8_t pasubub (uint8x8_t s, uint8x8_t t);
11869 uint16x4_t biadd (uint8x8_t s);
11870 uint16x4_t psadbh (uint8x8_t s, uint8x8_t t);
11871 uint16x4_t pshufh_u (uint16x4_t dest, uint16x4_t s, uint8_t order);
11872 int16x4_t pshufh_s (int16x4_t dest, int16x4_t s, uint8_t order);
11873 uint16x4_t psllh_u (uint16x4_t s, uint8_t amount);
11874 int16x4_t psllh_s (int16x4_t s, uint8_t amount);
11875 uint32x2_t psllw_u (uint32x2_t s, uint8_t amount);
11876 int32x2_t psllw_s (int32x2_t s, uint8_t amount);
11877 uint16x4_t psrlh_u (uint16x4_t s, uint8_t amount);
11878 int16x4_t psrlh_s (int16x4_t s, uint8_t amount);
11879 uint32x2_t psrlw_u (uint32x2_t s, uint8_t amount);
11880 int32x2_t psrlw_s (int32x2_t s, uint8_t amount);
11881 uint16x4_t psrah_u (uint16x4_t s, uint8_t amount);
11882 int16x4_t psrah_s (int16x4_t s, uint8_t amount);
11883 uint32x2_t psraw_u (uint32x2_t s, uint8_t amount);
11884 int32x2_t psraw_s (int32x2_t s, uint8_t amount);
11885 uint32x2_t psubw_u (uint32x2_t s, uint32x2_t t);
11886 uint16x4_t psubh_u (uint16x4_t s, uint16x4_t t);
11887 uint8x8_t psubb_u (uint8x8_t s, uint8x8_t t);
11888 int32x2_t psubw_s (int32x2_t s, int32x2_t t);
11889 int16x4_t psubh_s (int16x4_t s, int16x4_t t);
11890 int8x8_t psubb_s (int8x8_t s, int8x8_t t);
11891 uint64_t psubd_u (uint64_t s, uint64_t t);
11892 int64_t psubd_s (int64_t s, int64_t t);
11893 int16x4_t psubsh (int16x4_t s, int16x4_t t);
11894 int8x8_t psubsb (int8x8_t s, int8x8_t t);
11895 uint16x4_t psubush (uint16x4_t s, uint16x4_t t);
11896 uint8x8_t psubusb (uint8x8_t s, uint8x8_t t);
11897 uint32x2_t punpckhwd_u (uint32x2_t s, uint32x2_t t);
11898 uint16x4_t punpckhhw_u (uint16x4_t s, uint16x4_t t);
11899 uint8x8_t punpckhbh_u (uint8x8_t s, uint8x8_t t);
11900 int32x2_t punpckhwd_s (int32x2_t s, int32x2_t t);
11901 int16x4_t punpckhhw_s (int16x4_t s, int16x4_t t);
11902 int8x8_t punpckhbh_s (int8x8_t s, int8x8_t t);
11903 uint32x2_t punpcklwd_u (uint32x2_t s, uint32x2_t t);
11904 uint16x4_t punpcklhw_u (uint16x4_t s, uint16x4_t t);
11905 uint8x8_t punpcklbh_u (uint8x8_t s, uint8x8_t t);
11906 int32x2_t punpcklwd_s (int32x2_t s, int32x2_t t);
11907 int16x4_t punpcklhw_s (int16x4_t s, int16x4_t t);
11908 int8x8_t punpcklbh_s (int8x8_t s, int8x8_t t);
11912 * Paired-Single Arithmetic::
11913 * Paired-Single Built-in Functions::
11914 * MIPS-3D Built-in Functions::
11917 @node Paired-Single Arithmetic
11918 @subsubsection Paired-Single Arithmetic
11920 The table below lists the @code{v2sf} operations for which hardware
11921 support exists. @code{a}, @code{b} and @code{c} are @code{v2sf}
11922 values and @code{x} is an integral value.
11924 @multitable @columnfractions .50 .50
11925 @item C code @tab MIPS instruction
11926 @item @code{a + b} @tab @code{add.ps}
11927 @item @code{a - b} @tab @code{sub.ps}
11928 @item @code{-a} @tab @code{neg.ps}
11929 @item @code{a * b} @tab @code{mul.ps}
11930 @item @code{a * b + c} @tab @code{madd.ps}
11931 @item @code{a * b - c} @tab @code{msub.ps}
11932 @item @code{-(a * b + c)} @tab @code{nmadd.ps}
11933 @item @code{-(a * b - c)} @tab @code{nmsub.ps}
11934 @item @code{x ? a : b} @tab @code{movn.ps}/@code{movz.ps}
11937 Note that the multiply-accumulate instructions can be disabled
11938 using the command-line option @code{-mno-fused-madd}.
11940 @node Paired-Single Built-in Functions
11941 @subsubsection Paired-Single Built-in Functions
11943 The following paired-single functions map directly to a particular
11944 MIPS instruction. Please refer to the architecture specification
11945 for details on what each instruction does.
11948 @item v2sf __builtin_mips_pll_ps (v2sf, v2sf)
11949 Pair lower lower (@code{pll.ps}).
11951 @item v2sf __builtin_mips_pul_ps (v2sf, v2sf)
11952 Pair upper lower (@code{pul.ps}).
11954 @item v2sf __builtin_mips_plu_ps (v2sf, v2sf)
11955 Pair lower upper (@code{plu.ps}).
11957 @item v2sf __builtin_mips_puu_ps (v2sf, v2sf)
11958 Pair upper upper (@code{puu.ps}).
11960 @item v2sf __builtin_mips_cvt_ps_s (float, float)
11961 Convert pair to paired single (@code{cvt.ps.s}).
11963 @item float __builtin_mips_cvt_s_pl (v2sf)
11964 Convert pair lower to single (@code{cvt.s.pl}).
11966 @item float __builtin_mips_cvt_s_pu (v2sf)
11967 Convert pair upper to single (@code{cvt.s.pu}).
11969 @item v2sf __builtin_mips_abs_ps (v2sf)
11970 Absolute value (@code{abs.ps}).
11972 @item v2sf __builtin_mips_alnv_ps (v2sf, v2sf, int)
11973 Align variable (@code{alnv.ps}).
11975 @emph{Note:} The value of the third parameter must be 0 or 4
11976 modulo 8, otherwise the result is unpredictable. Please read the
11977 instruction description for details.
11980 The following multi-instruction functions are also available.
11981 In each case, @var{cond} can be any of the 16 floating-point conditions:
11982 @code{f}, @code{un}, @code{eq}, @code{ueq}, @code{olt}, @code{ult},
11983 @code{ole}, @code{ule}, @code{sf}, @code{ngle}, @code{seq}, @code{ngl},
11984 @code{lt}, @code{nge}, @code{le} or @code{ngt}.
11987 @item v2sf __builtin_mips_movt_c_@var{cond}_ps (v2sf @var{a}, v2sf @var{b}, v2sf @var{c}, v2sf @var{d})
11988 @itemx v2sf __builtin_mips_movf_c_@var{cond}_ps (v2sf @var{a}, v2sf @var{b}, v2sf @var{c}, v2sf @var{d})
11989 Conditional move based on floating-point comparison (@code{c.@var{cond}.ps},
11990 @code{movt.ps}/@code{movf.ps}).
11992 The @code{movt} functions return the value @var{x} computed by:
11995 c.@var{cond}.ps @var{cc},@var{a},@var{b}
11996 mov.ps @var{x},@var{c}
11997 movt.ps @var{x},@var{d},@var{cc}
12000 The @code{movf} functions are similar but use @code{movf.ps} instead
12003 @item int __builtin_mips_upper_c_@var{cond}_ps (v2sf @var{a}, v2sf @var{b})
12004 @itemx int __builtin_mips_lower_c_@var{cond}_ps (v2sf @var{a}, v2sf @var{b})
12005 Comparison of two paired-single values (@code{c.@var{cond}.ps},
12006 @code{bc1t}/@code{bc1f}).
12008 These functions compare @var{a} and @var{b} using @code{c.@var{cond}.ps}
12009 and return either the upper or lower half of the result. For example:
12013 if (__builtin_mips_upper_c_eq_ps (a, b))
12014 upper_halves_are_equal ();
12016 upper_halves_are_unequal ();
12018 if (__builtin_mips_lower_c_eq_ps (a, b))
12019 lower_halves_are_equal ();
12021 lower_halves_are_unequal ();
12025 @node MIPS-3D Built-in Functions
12026 @subsubsection MIPS-3D Built-in Functions
12028 The MIPS-3D Application-Specific Extension (ASE) includes additional
12029 paired-single instructions that are designed to improve the performance
12030 of 3D graphics operations. Support for these instructions is controlled
12031 by the @option{-mips3d} command-line option.
12033 The functions listed below map directly to a particular MIPS-3D
12034 instruction. Please refer to the architecture specification for
12035 more details on what each instruction does.
12038 @item v2sf __builtin_mips_addr_ps (v2sf, v2sf)
12039 Reduction add (@code{addr.ps}).
12041 @item v2sf __builtin_mips_mulr_ps (v2sf, v2sf)
12042 Reduction multiply (@code{mulr.ps}).
12044 @item v2sf __builtin_mips_cvt_pw_ps (v2sf)
12045 Convert paired single to paired word (@code{cvt.pw.ps}).
12047 @item v2sf __builtin_mips_cvt_ps_pw (v2sf)
12048 Convert paired word to paired single (@code{cvt.ps.pw}).
12050 @item float __builtin_mips_recip1_s (float)
12051 @itemx double __builtin_mips_recip1_d (double)
12052 @itemx v2sf __builtin_mips_recip1_ps (v2sf)
12053 Reduced-precision reciprocal (sequence step 1) (@code{recip1.@var{fmt}}).
12055 @item float __builtin_mips_recip2_s (float, float)
12056 @itemx double __builtin_mips_recip2_d (double, double)
12057 @itemx v2sf __builtin_mips_recip2_ps (v2sf, v2sf)
12058 Reduced-precision reciprocal (sequence step 2) (@code{recip2.@var{fmt}}).
12060 @item float __builtin_mips_rsqrt1_s (float)
12061 @itemx double __builtin_mips_rsqrt1_d (double)
12062 @itemx v2sf __builtin_mips_rsqrt1_ps (v2sf)
12063 Reduced-precision reciprocal square root (sequence step 1)
12064 (@code{rsqrt1.@var{fmt}}).
12066 @item float __builtin_mips_rsqrt2_s (float, float)
12067 @itemx double __builtin_mips_rsqrt2_d (double, double)
12068 @itemx v2sf __builtin_mips_rsqrt2_ps (v2sf, v2sf)
12069 Reduced-precision reciprocal square root (sequence step 2)
12070 (@code{rsqrt2.@var{fmt}}).
12073 The following multi-instruction functions are also available.
12074 In each case, @var{cond} can be any of the 16 floating-point conditions:
12075 @code{f}, @code{un}, @code{eq}, @code{ueq}, @code{olt}, @code{ult},
12076 @code{ole}, @code{ule}, @code{sf}, @code{ngle}, @code{seq},
12077 @code{ngl}, @code{lt}, @code{nge}, @code{le} or @code{ngt}.
12080 @item int __builtin_mips_cabs_@var{cond}_s (float @var{a}, float @var{b})
12081 @itemx int __builtin_mips_cabs_@var{cond}_d (double @var{a}, double @var{b})
12082 Absolute comparison of two scalar values (@code{cabs.@var{cond}.@var{fmt}},
12083 @code{bc1t}/@code{bc1f}).
12085 These functions compare @var{a} and @var{b} using @code{cabs.@var{cond}.s}
12086 or @code{cabs.@var{cond}.d} and return the result as a boolean value.
12091 if (__builtin_mips_cabs_eq_s (a, b))
12097 @item int __builtin_mips_upper_cabs_@var{cond}_ps (v2sf @var{a}, v2sf @var{b})
12098 @itemx int __builtin_mips_lower_cabs_@var{cond}_ps (v2sf @var{a}, v2sf @var{b})
12099 Absolute comparison of two paired-single values (@code{cabs.@var{cond}.ps},
12100 @code{bc1t}/@code{bc1f}).
12102 These functions compare @var{a} and @var{b} using @code{cabs.@var{cond}.ps}
12103 and return either the upper or lower half of the result. For example:
12107 if (__builtin_mips_upper_cabs_eq_ps (a, b))
12108 upper_halves_are_equal ();
12110 upper_halves_are_unequal ();
12112 if (__builtin_mips_lower_cabs_eq_ps (a, b))
12113 lower_halves_are_equal ();
12115 lower_halves_are_unequal ();
12118 @item v2sf __builtin_mips_movt_cabs_@var{cond}_ps (v2sf @var{a}, v2sf @var{b}, v2sf @var{c}, v2sf @var{d})
12119 @itemx v2sf __builtin_mips_movf_cabs_@var{cond}_ps (v2sf @var{a}, v2sf @var{b}, v2sf @var{c}, v2sf @var{d})
12120 Conditional move based on absolute comparison (@code{cabs.@var{cond}.ps},
12121 @code{movt.ps}/@code{movf.ps}).
12123 The @code{movt} functions return the value @var{x} computed by:
12126 cabs.@var{cond}.ps @var{cc},@var{a},@var{b}
12127 mov.ps @var{x},@var{c}
12128 movt.ps @var{x},@var{d},@var{cc}
12131 The @code{movf} functions are similar but use @code{movf.ps} instead
12134 @item int __builtin_mips_any_c_@var{cond}_ps (v2sf @var{a}, v2sf @var{b})
12135 @itemx int __builtin_mips_all_c_@var{cond}_ps (v2sf @var{a}, v2sf @var{b})
12136 @itemx int __builtin_mips_any_cabs_@var{cond}_ps (v2sf @var{a}, v2sf @var{b})
12137 @itemx int __builtin_mips_all_cabs_@var{cond}_ps (v2sf @var{a}, v2sf @var{b})
12138 Comparison of two paired-single values
12139 (@code{c.@var{cond}.ps}/@code{cabs.@var{cond}.ps},
12140 @code{bc1any2t}/@code{bc1any2f}).
12142 These functions compare @var{a} and @var{b} using @code{c.@var{cond}.ps}
12143 or @code{cabs.@var{cond}.ps}. The @code{any} forms return true if either
12144 result is true and the @code{all} forms return true if both results are true.
12149 if (__builtin_mips_any_c_eq_ps (a, b))
12154 if (__builtin_mips_all_c_eq_ps (a, b))
12160 @item int __builtin_mips_any_c_@var{cond}_4s (v2sf @var{a}, v2sf @var{b}, v2sf @var{c}, v2sf @var{d})
12161 @itemx int __builtin_mips_all_c_@var{cond}_4s (v2sf @var{a}, v2sf @var{b}, v2sf @var{c}, v2sf @var{d})
12162 @itemx int __builtin_mips_any_cabs_@var{cond}_4s (v2sf @var{a}, v2sf @var{b}, v2sf @var{c}, v2sf @var{d})
12163 @itemx int __builtin_mips_all_cabs_@var{cond}_4s (v2sf @var{a}, v2sf @var{b}, v2sf @var{c}, v2sf @var{d})
12164 Comparison of four paired-single values
12165 (@code{c.@var{cond}.ps}/@code{cabs.@var{cond}.ps},
12166 @code{bc1any4t}/@code{bc1any4f}).
12168 These functions use @code{c.@var{cond}.ps} or @code{cabs.@var{cond}.ps}
12169 to compare @var{a} with @var{b} and to compare @var{c} with @var{d}.
12170 The @code{any} forms return true if any of the four results are true
12171 and the @code{all} forms return true if all four results are true.
12176 if (__builtin_mips_any_c_eq_4s (a, b, c, d))
12181 if (__builtin_mips_all_c_eq_4s (a, b, c, d))
12188 @node Other MIPS Built-in Functions
12189 @subsection Other MIPS Built-in Functions
12191 GCC provides other MIPS-specific built-in functions:
12194 @item void __builtin_mips_cache (int @var{op}, const volatile void *@var{addr})
12195 Insert a @samp{cache} instruction with operands @var{op} and @var{addr}.
12196 GCC defines the preprocessor macro @code{___GCC_HAVE_BUILTIN_MIPS_CACHE}
12197 when this function is available.
12199 @item unsigned int __builtin_mips_get_fcsr (void)
12200 @itemx void __builtin_mips_set_fcsr (unsigned int @var{value})
12201 Get and set the contents of the floating-point control and status register
12202 (FPU control register 31). These functions are only available in hard-float
12203 code but can be called in both MIPS16 and non-MIPS16 contexts.
12205 @code{__builtin_mips_set_fcsr} can be used to change any bit of the
12206 register except the condition codes, which GCC assumes are preserved.
12209 @node MSP430 Built-in Functions
12210 @subsection MSP430 Built-in Functions
12212 GCC provides a couple of special builtin functions to aid in the
12213 writing of interrupt handlers in C.
12216 @item __bic_SR_register_on_exit (int @var{mask})
12217 This clears the indicated bits in the saved copy of the status register
12218 currently residing on the stack. This only works inside interrupt
12219 handlers and the changes to the status register will only take affect
12220 once the handler returns.
12222 @item __bis_SR_register_on_exit (int @var{mask})
12223 This sets the indicated bits in the saved copy of the status register
12224 currently residing on the stack. This only works inside interrupt
12225 handlers and the changes to the status register will only take affect
12226 once the handler returns.
12228 @item __delay_cycles (long long @var{cycles})
12229 This inserts an instruction sequence that takes exactly @var{cycles}
12230 cycles (between 0 and about 17E9) to complete. The inserted sequence
12231 may use jumps, loops, or no-ops, and does not interfere with any other
12232 instructions. Note that @var{cycles} must be a compile-time constant
12233 integer - that is, you must pass a number, not a variable that may be
12234 optimized to a constant later. The number of cycles delayed by this
12238 @node NDS32 Built-in Functions
12239 @subsection NDS32 Built-in Functions
12241 These built-in functions are available for the NDS32 target:
12243 @deftypefn {Built-in Function} void __builtin_nds32_isync (int *@var{addr})
12244 Insert an ISYNC instruction into the instruction stream where
12245 @var{addr} is an instruction address for serialization.
12248 @deftypefn {Built-in Function} void __builtin_nds32_isb (void)
12249 Insert an ISB instruction into the instruction stream.
12252 @deftypefn {Built-in Function} int __builtin_nds32_mfsr (int @var{sr})
12253 Return the content of a system register which is mapped by @var{sr}.
12256 @deftypefn {Built-in Function} int __builtin_nds32_mfusr (int @var{usr})
12257 Return the content of a user space register which is mapped by @var{usr}.
12260 @deftypefn {Built-in Function} void __builtin_nds32_mtsr (int @var{value}, int @var{sr})
12261 Move the @var{value} to a system register which is mapped by @var{sr}.
12264 @deftypefn {Built-in Function} void __builtin_nds32_mtusr (int @var{value}, int @var{usr})
12265 Move the @var{value} to a user space register which is mapped by @var{usr}.
12268 @deftypefn {Built-in Function} void __builtin_nds32_setgie_en (void)
12269 Enable global interrupt.
12272 @deftypefn {Built-in Function} void __builtin_nds32_setgie_dis (void)
12273 Disable global interrupt.
12276 @node picoChip Built-in Functions
12277 @subsection picoChip Built-in Functions
12279 GCC provides an interface to selected machine instructions from the
12280 picoChip instruction set.
12283 @item int __builtin_sbc (int @var{value})
12284 Sign bit count. Return the number of consecutive bits in @var{value}
12285 that have the same value as the sign bit. The result is the number of
12286 leading sign bits minus one, giving the number of redundant sign bits in
12289 @item int __builtin_byteswap (int @var{value})
12290 Byte swap. Return the result of swapping the upper and lower bytes of
12293 @item int __builtin_brev (int @var{value})
12294 Bit reversal. Return the result of reversing the bits in
12295 @var{value}. Bit 15 is swapped with bit 0, bit 14 is swapped with bit 1,
12298 @item int __builtin_adds (int @var{x}, int @var{y})
12299 Saturating addition. Return the result of adding @var{x} and @var{y},
12300 storing the value 32767 if the result overflows.
12302 @item int __builtin_subs (int @var{x}, int @var{y})
12303 Saturating subtraction. Return the result of subtracting @var{y} from
12304 @var{x}, storing the value @minus{}32768 if the result overflows.
12306 @item void __builtin_halt (void)
12307 Halt. The processor stops execution. This built-in is useful for
12308 implementing assertions.
12312 @node PowerPC Built-in Functions
12313 @subsection PowerPC Built-in Functions
12315 These built-in functions are available for the PowerPC family of
12318 float __builtin_recipdivf (float, float);
12319 float __builtin_rsqrtf (float);
12320 double __builtin_recipdiv (double, double);
12321 double __builtin_rsqrt (double);
12322 uint64_t __builtin_ppc_get_timebase ();
12323 unsigned long __builtin_ppc_mftb ();
12324 double __builtin_unpack_longdouble (long double, int);
12325 long double __builtin_pack_longdouble (double, double);
12328 The @code{vec_rsqrt}, @code{__builtin_rsqrt}, and
12329 @code{__builtin_rsqrtf} functions generate multiple instructions to
12330 implement the reciprocal sqrt functionality using reciprocal sqrt
12331 estimate instructions.
12333 The @code{__builtin_recipdiv}, and @code{__builtin_recipdivf}
12334 functions generate multiple instructions to implement division using
12335 the reciprocal estimate instructions.
12337 The @code{__builtin_ppc_get_timebase} and @code{__builtin_ppc_mftb}
12338 functions generate instructions to read the Time Base Register. The
12339 @code{__builtin_ppc_get_timebase} function may generate multiple
12340 instructions and always returns the 64 bits of the Time Base Register.
12341 The @code{__builtin_ppc_mftb} function always generates one instruction and
12342 returns the Time Base Register value as an unsigned long, throwing away
12343 the most significant word on 32-bit environments.
12345 The following built-in functions are available for the PowerPC family
12346 of processors, starting with ISA 2.06 or later (@option{-mcpu=power7}
12347 or @option{-mpopcntd}):
12349 long __builtin_bpermd (long, long);
12350 int __builtin_divwe (int, int);
12351 int __builtin_divweo (int, int);
12352 unsigned int __builtin_divweu (unsigned int, unsigned int);
12353 unsigned int __builtin_divweuo (unsigned int, unsigned int);
12354 long __builtin_divde (long, long);
12355 long __builtin_divdeo (long, long);
12356 unsigned long __builtin_divdeu (unsigned long, unsigned long);
12357 unsigned long __builtin_divdeuo (unsigned long, unsigned long);
12358 unsigned int cdtbcd (unsigned int);
12359 unsigned int cbcdtd (unsigned int);
12360 unsigned int addg6s (unsigned int, unsigned int);
12363 The @code{__builtin_divde}, @code{__builtin_divdeo},
12364 @code{__builtin_divdeu}, @code{__builtin_divdeou} functions require a
12365 64-bit environment support ISA 2.06 or later.
12367 The following built-in functions are available for the PowerPC family
12368 of processors when hardware decimal floating point
12369 (@option{-mhard-dfp}) is available:
12371 _Decimal64 __builtin_dxex (_Decimal64);
12372 _Decimal128 __builtin_dxexq (_Decimal128);
12373 _Decimal64 __builtin_ddedpd (int, _Decimal64);
12374 _Decimal128 __builtin_ddedpdq (int, _Decimal128);
12375 _Decimal64 __builtin_denbcd (int, _Decimal64);
12376 _Decimal128 __builtin_denbcdq (int, _Decimal128);
12377 _Decimal64 __builtin_diex (_Decimal64, _Decimal64);
12378 _Decimal128 _builtin_diexq (_Decimal128, _Decimal128);
12379 _Decimal64 __builtin_dscli (_Decimal64, int);
12380 _Decimal128 __builtin_dscliq (_Decimal128, int);
12381 _Decimal64 __builtin_dscri (_Decimal64, int);
12382 _Decimal128 __builtin_dscriq (_Decimal128, int);
12383 unsigned long long __builtin_unpack_dec128 (_Decimal128, int);
12384 _Decimal128 __builtin_pack_dec128 (unsigned long long, unsigned long long);
12387 The following built-in functions are available for the PowerPC family
12388 of processors when the Vector Scalar (vsx) instruction set is
12391 unsigned long long __builtin_unpack_vector_int128 (vector __int128_t, int);
12392 vector __int128_t __builtin_pack_vector_int128 (unsigned long long,
12393 unsigned long long);
12396 @node PowerPC AltiVec/VSX Built-in Functions
12397 @subsection PowerPC AltiVec Built-in Functions
12399 GCC provides an interface for the PowerPC family of processors to access
12400 the AltiVec operations described in Motorola's AltiVec Programming
12401 Interface Manual. The interface is made available by including
12402 @code{<altivec.h>} and using @option{-maltivec} and
12403 @option{-mabi=altivec}. The interface supports the following vector
12407 vector unsigned char
12411 vector unsigned short
12412 vector signed short
12416 vector unsigned int
12422 If @option{-mvsx} is used the following additional vector types are
12426 vector unsigned long
12431 The long types are only implemented for 64-bit code generation, and
12432 the long type is only used in the floating point/integer conversion
12435 GCC's implementation of the high-level language interface available from
12436 C and C++ code differs from Motorola's documentation in several ways.
12441 A vector constant is a list of constant expressions within curly braces.
12444 A vector initializer requires no cast if the vector constant is of the
12445 same type as the variable it is initializing.
12448 If @code{signed} or @code{unsigned} is omitted, the signedness of the
12449 vector type is the default signedness of the base type. The default
12450 varies depending on the operating system, so a portable program should
12451 always specify the signedness.
12454 Compiling with @option{-maltivec} adds keywords @code{__vector},
12455 @code{vector}, @code{__pixel}, @code{pixel}, @code{__bool} and
12456 @code{bool}. When compiling ISO C, the context-sensitive substitution
12457 of the keywords @code{vector}, @code{pixel} and @code{bool} is
12458 disabled. To use them, you must include @code{<altivec.h>} instead.
12461 GCC allows using a @code{typedef} name as the type specifier for a
12465 For C, overloaded functions are implemented with macros so the following
12469 vec_add ((vector signed int)@{1, 2, 3, 4@}, foo);
12473 Since @code{vec_add} is a macro, the vector constant in the example
12474 is treated as four separate arguments. Wrap the entire argument in
12475 parentheses for this to work.
12478 @emph{Note:} Only the @code{<altivec.h>} interface is supported.
12479 Internally, GCC uses built-in functions to achieve the functionality in
12480 the aforementioned header file, but they are not supported and are
12481 subject to change without notice.
12483 The following interfaces are supported for the generic and specific
12484 AltiVec operations and the AltiVec predicates. In cases where there
12485 is a direct mapping between generic and specific operations, only the
12486 generic names are shown here, although the specific operations can also
12489 Arguments that are documented as @code{const int} require literal
12490 integral values within the range required for that operation.
12493 vector signed char vec_abs (vector signed char);
12494 vector signed short vec_abs (vector signed short);
12495 vector signed int vec_abs (vector signed int);
12496 vector float vec_abs (vector float);
12498 vector signed char vec_abss (vector signed char);
12499 vector signed short vec_abss (vector signed short);
12500 vector signed int vec_abss (vector signed int);
12502 vector signed char vec_add (vector bool char, vector signed char);
12503 vector signed char vec_add (vector signed char, vector bool char);
12504 vector signed char vec_add (vector signed char, vector signed char);
12505 vector unsigned char vec_add (vector bool char, vector unsigned char);
12506 vector unsigned char vec_add (vector unsigned char, vector bool char);
12507 vector unsigned char vec_add (vector unsigned char,
12508 vector unsigned char);
12509 vector signed short vec_add (vector bool short, vector signed short);
12510 vector signed short vec_add (vector signed short, vector bool short);
12511 vector signed short vec_add (vector signed short, vector signed short);
12512 vector unsigned short vec_add (vector bool short,
12513 vector unsigned short);
12514 vector unsigned short vec_add (vector unsigned short,
12515 vector bool short);
12516 vector unsigned short vec_add (vector unsigned short,
12517 vector unsigned short);
12518 vector signed int vec_add (vector bool int, vector signed int);
12519 vector signed int vec_add (vector signed int, vector bool int);
12520 vector signed int vec_add (vector signed int, vector signed int);
12521 vector unsigned int vec_add (vector bool int, vector unsigned int);
12522 vector unsigned int vec_add (vector unsigned int, vector bool int);
12523 vector unsigned int vec_add (vector unsigned int, vector unsigned int);
12524 vector float vec_add (vector float, vector float);
12526 vector float vec_vaddfp (vector float, vector float);
12528 vector signed int vec_vadduwm (vector bool int, vector signed int);
12529 vector signed int vec_vadduwm (vector signed int, vector bool int);
12530 vector signed int vec_vadduwm (vector signed int, vector signed int);
12531 vector unsigned int vec_vadduwm (vector bool int, vector unsigned int);
12532 vector unsigned int vec_vadduwm (vector unsigned int, vector bool int);
12533 vector unsigned int vec_vadduwm (vector unsigned int,
12534 vector unsigned int);
12536 vector signed short vec_vadduhm (vector bool short,
12537 vector signed short);
12538 vector signed short vec_vadduhm (vector signed short,
12539 vector bool short);
12540 vector signed short vec_vadduhm (vector signed short,
12541 vector signed short);
12542 vector unsigned short vec_vadduhm (vector bool short,
12543 vector unsigned short);
12544 vector unsigned short vec_vadduhm (vector unsigned short,
12545 vector bool short);
12546 vector unsigned short vec_vadduhm (vector unsigned short,
12547 vector unsigned short);
12549 vector signed char vec_vaddubm (vector bool char, vector signed char);
12550 vector signed char vec_vaddubm (vector signed char, vector bool char);
12551 vector signed char vec_vaddubm (vector signed char, vector signed char);
12552 vector unsigned char vec_vaddubm (vector bool char,
12553 vector unsigned char);
12554 vector unsigned char vec_vaddubm (vector unsigned char,
12556 vector unsigned char vec_vaddubm (vector unsigned char,
12557 vector unsigned char);
12559 vector unsigned int vec_addc (vector unsigned int, vector unsigned int);
12561 vector unsigned char vec_adds (vector bool char, vector unsigned char);
12562 vector unsigned char vec_adds (vector unsigned char, vector bool char);
12563 vector unsigned char vec_adds (vector unsigned char,
12564 vector unsigned char);
12565 vector signed char vec_adds (vector bool char, vector signed char);
12566 vector signed char vec_adds (vector signed char, vector bool char);
12567 vector signed char vec_adds (vector signed char, vector signed char);
12568 vector unsigned short vec_adds (vector bool short,
12569 vector unsigned short);
12570 vector unsigned short vec_adds (vector unsigned short,
12571 vector bool short);
12572 vector unsigned short vec_adds (vector unsigned short,
12573 vector unsigned short);
12574 vector signed short vec_adds (vector bool short, vector signed short);
12575 vector signed short vec_adds (vector signed short, vector bool short);
12576 vector signed short vec_adds (vector signed short, vector signed short);
12577 vector unsigned int vec_adds (vector bool int, vector unsigned int);
12578 vector unsigned int vec_adds (vector unsigned int, vector bool int);
12579 vector unsigned int vec_adds (vector unsigned int, vector unsigned int);
12580 vector signed int vec_adds (vector bool int, vector signed int);
12581 vector signed int vec_adds (vector signed int, vector bool int);
12582 vector signed int vec_adds (vector signed int, vector signed int);
12584 vector signed int vec_vaddsws (vector bool int, vector signed int);
12585 vector signed int vec_vaddsws (vector signed int, vector bool int);
12586 vector signed int vec_vaddsws (vector signed int, vector signed int);
12588 vector unsigned int vec_vadduws (vector bool int, vector unsigned int);
12589 vector unsigned int vec_vadduws (vector unsigned int, vector bool int);
12590 vector unsigned int vec_vadduws (vector unsigned int,
12591 vector unsigned int);
12593 vector signed short vec_vaddshs (vector bool short,
12594 vector signed short);
12595 vector signed short vec_vaddshs (vector signed short,
12596 vector bool short);
12597 vector signed short vec_vaddshs (vector signed short,
12598 vector signed short);
12600 vector unsigned short vec_vadduhs (vector bool short,
12601 vector unsigned short);
12602 vector unsigned short vec_vadduhs (vector unsigned short,
12603 vector bool short);
12604 vector unsigned short vec_vadduhs (vector unsigned short,
12605 vector unsigned short);
12607 vector signed char vec_vaddsbs (vector bool char, vector signed char);
12608 vector signed char vec_vaddsbs (vector signed char, vector bool char);
12609 vector signed char vec_vaddsbs (vector signed char, vector signed char);
12611 vector unsigned char vec_vaddubs (vector bool char,
12612 vector unsigned char);
12613 vector unsigned char vec_vaddubs (vector unsigned char,
12615 vector unsigned char vec_vaddubs (vector unsigned char,
12616 vector unsigned char);
12618 vector float vec_and (vector float, vector float);
12619 vector float vec_and (vector float, vector bool int);
12620 vector float vec_and (vector bool int, vector float);
12621 vector bool int vec_and (vector bool int, vector bool int);
12622 vector signed int vec_and (vector bool int, vector signed int);
12623 vector signed int vec_and (vector signed int, vector bool int);
12624 vector signed int vec_and (vector signed int, vector signed int);
12625 vector unsigned int vec_and (vector bool int, vector unsigned int);
12626 vector unsigned int vec_and (vector unsigned int, vector bool int);
12627 vector unsigned int vec_and (vector unsigned int, vector unsigned int);
12628 vector bool short vec_and (vector bool short, vector bool short);
12629 vector signed short vec_and (vector bool short, vector signed short);
12630 vector signed short vec_and (vector signed short, vector bool short);
12631 vector signed short vec_and (vector signed short, vector signed short);
12632 vector unsigned short vec_and (vector bool short,
12633 vector unsigned short);
12634 vector unsigned short vec_and (vector unsigned short,
12635 vector bool short);
12636 vector unsigned short vec_and (vector unsigned short,
12637 vector unsigned short);
12638 vector signed char vec_and (vector bool char, vector signed char);
12639 vector bool char vec_and (vector bool char, vector bool char);
12640 vector signed char vec_and (vector signed char, vector bool char);
12641 vector signed char vec_and (vector signed char, vector signed char);
12642 vector unsigned char vec_and (vector bool char, vector unsigned char);
12643 vector unsigned char vec_and (vector unsigned char, vector bool char);
12644 vector unsigned char vec_and (vector unsigned char,
12645 vector unsigned char);
12647 vector float vec_andc (vector float, vector float);
12648 vector float vec_andc (vector float, vector bool int);
12649 vector float vec_andc (vector bool int, vector float);
12650 vector bool int vec_andc (vector bool int, vector bool int);
12651 vector signed int vec_andc (vector bool int, vector signed int);
12652 vector signed int vec_andc (vector signed int, vector bool int);
12653 vector signed int vec_andc (vector signed int, vector signed int);
12654 vector unsigned int vec_andc (vector bool int, vector unsigned int);
12655 vector unsigned int vec_andc (vector unsigned int, vector bool int);
12656 vector unsigned int vec_andc (vector unsigned int, vector unsigned int);
12657 vector bool short vec_andc (vector bool short, vector bool short);
12658 vector signed short vec_andc (vector bool short, vector signed short);
12659 vector signed short vec_andc (vector signed short, vector bool short);
12660 vector signed short vec_andc (vector signed short, vector signed short);
12661 vector unsigned short vec_andc (vector bool short,
12662 vector unsigned short);
12663 vector unsigned short vec_andc (vector unsigned short,
12664 vector bool short);
12665 vector unsigned short vec_andc (vector unsigned short,
12666 vector unsigned short);
12667 vector signed char vec_andc (vector bool char, vector signed char);
12668 vector bool char vec_andc (vector bool char, vector bool char);
12669 vector signed char vec_andc (vector signed char, vector bool char);
12670 vector signed char vec_andc (vector signed char, vector signed char);
12671 vector unsigned char vec_andc (vector bool char, vector unsigned char);
12672 vector unsigned char vec_andc (vector unsigned char, vector bool char);
12673 vector unsigned char vec_andc (vector unsigned char,
12674 vector unsigned char);
12676 vector unsigned char vec_avg (vector unsigned char,
12677 vector unsigned char);
12678 vector signed char vec_avg (vector signed char, vector signed char);
12679 vector unsigned short vec_avg (vector unsigned short,
12680 vector unsigned short);
12681 vector signed short vec_avg (vector signed short, vector signed short);
12682 vector unsigned int vec_avg (vector unsigned int, vector unsigned int);
12683 vector signed int vec_avg (vector signed int, vector signed int);
12685 vector signed int vec_vavgsw (vector signed int, vector signed int);
12687 vector unsigned int vec_vavguw (vector unsigned int,
12688 vector unsigned int);
12690 vector signed short vec_vavgsh (vector signed short,
12691 vector signed short);
12693 vector unsigned short vec_vavguh (vector unsigned short,
12694 vector unsigned short);
12696 vector signed char vec_vavgsb (vector signed char, vector signed char);
12698 vector unsigned char vec_vavgub (vector unsigned char,
12699 vector unsigned char);
12701 vector float vec_copysign (vector float);
12703 vector float vec_ceil (vector float);
12705 vector signed int vec_cmpb (vector float, vector float);
12707 vector bool char vec_cmpeq (vector signed char, vector signed char);
12708 vector bool char vec_cmpeq (vector unsigned char, vector unsigned char);
12709 vector bool short vec_cmpeq (vector signed short, vector signed short);
12710 vector bool short vec_cmpeq (vector unsigned short,
12711 vector unsigned short);
12712 vector bool int vec_cmpeq (vector signed int, vector signed int);
12713 vector bool int vec_cmpeq (vector unsigned int, vector unsigned int);
12714 vector bool int vec_cmpeq (vector float, vector float);
12716 vector bool int vec_vcmpeqfp (vector float, vector float);
12718 vector bool int vec_vcmpequw (vector signed int, vector signed int);
12719 vector bool int vec_vcmpequw (vector unsigned int, vector unsigned int);
12721 vector bool short vec_vcmpequh (vector signed short,
12722 vector signed short);
12723 vector bool short vec_vcmpequh (vector unsigned short,
12724 vector unsigned short);
12726 vector bool char vec_vcmpequb (vector signed char, vector signed char);
12727 vector bool char vec_vcmpequb (vector unsigned char,
12728 vector unsigned char);
12730 vector bool int vec_cmpge (vector float, vector float);
12732 vector bool char vec_cmpgt (vector unsigned char, vector unsigned char);
12733 vector bool char vec_cmpgt (vector signed char, vector signed char);
12734 vector bool short vec_cmpgt (vector unsigned short,
12735 vector unsigned short);
12736 vector bool short vec_cmpgt (vector signed short, vector signed short);
12737 vector bool int vec_cmpgt (vector unsigned int, vector unsigned int);
12738 vector bool int vec_cmpgt (vector signed int, vector signed int);
12739 vector bool int vec_cmpgt (vector float, vector float);
12741 vector bool int vec_vcmpgtfp (vector float, vector float);
12743 vector bool int vec_vcmpgtsw (vector signed int, vector signed int);
12745 vector bool int vec_vcmpgtuw (vector unsigned int, vector unsigned int);
12747 vector bool short vec_vcmpgtsh (vector signed short,
12748 vector signed short);
12750 vector bool short vec_vcmpgtuh (vector unsigned short,
12751 vector unsigned short);
12753 vector bool char vec_vcmpgtsb (vector signed char, vector signed char);
12755 vector bool char vec_vcmpgtub (vector unsigned char,
12756 vector unsigned char);
12758 vector bool int vec_cmple (vector float, vector float);
12760 vector bool char vec_cmplt (vector unsigned char, vector unsigned char);
12761 vector bool char vec_cmplt (vector signed char, vector signed char);
12762 vector bool short vec_cmplt (vector unsigned short,
12763 vector unsigned short);
12764 vector bool short vec_cmplt (vector signed short, vector signed short);
12765 vector bool int vec_cmplt (vector unsigned int, vector unsigned int);
12766 vector bool int vec_cmplt (vector signed int, vector signed int);
12767 vector bool int vec_cmplt (vector float, vector float);
12769 vector float vec_cpsgn (vector float, vector float);
12771 vector float vec_ctf (vector unsigned int, const int);
12772 vector float vec_ctf (vector signed int, const int);
12773 vector double vec_ctf (vector unsigned long, const int);
12774 vector double vec_ctf (vector signed long, const int);
12776 vector float vec_vcfsx (vector signed int, const int);
12778 vector float vec_vcfux (vector unsigned int, const int);
12780 vector signed int vec_cts (vector float, const int);
12781 vector signed long vec_cts (vector double, const int);
12783 vector unsigned int vec_ctu (vector float, const int);
12784 vector unsigned long vec_ctu (vector double, const int);
12786 void vec_dss (const int);
12788 void vec_dssall (void);
12790 void vec_dst (const vector unsigned char *, int, const int);
12791 void vec_dst (const vector signed char *, int, const int);
12792 void vec_dst (const vector bool char *, int, const int);
12793 void vec_dst (const vector unsigned short *, int, const int);
12794 void vec_dst (const vector signed short *, int, const int);
12795 void vec_dst (const vector bool short *, int, const int);
12796 void vec_dst (const vector pixel *, int, const int);
12797 void vec_dst (const vector unsigned int *, int, const int);
12798 void vec_dst (const vector signed int *, int, const int);
12799 void vec_dst (const vector bool int *, int, const int);
12800 void vec_dst (const vector float *, int, const int);
12801 void vec_dst (const unsigned char *, int, const int);
12802 void vec_dst (const signed char *, int, const int);
12803 void vec_dst (const unsigned short *, int, const int);
12804 void vec_dst (const short *, int, const int);
12805 void vec_dst (const unsigned int *, int, const int);
12806 void vec_dst (const int *, int, const int);
12807 void vec_dst (const unsigned long *, int, const int);
12808 void vec_dst (const long *, int, const int);
12809 void vec_dst (const float *, int, const int);
12811 void vec_dstst (const vector unsigned char *, int, const int);
12812 void vec_dstst (const vector signed char *, int, const int);
12813 void vec_dstst (const vector bool char *, int, const int);
12814 void vec_dstst (const vector unsigned short *, int, const int);
12815 void vec_dstst (const vector signed short *, int, const int);
12816 void vec_dstst (const vector bool short *, int, const int);
12817 void vec_dstst (const vector pixel *, int, const int);
12818 void vec_dstst (const vector unsigned int *, int, const int);
12819 void vec_dstst (const vector signed int *, int, const int);
12820 void vec_dstst (const vector bool int *, int, const int);
12821 void vec_dstst (const vector float *, int, const int);
12822 void vec_dstst (const unsigned char *, int, const int);
12823 void vec_dstst (const signed char *, int, const int);
12824 void vec_dstst (const unsigned short *, int, const int);
12825 void vec_dstst (const short *, int, const int);
12826 void vec_dstst (const unsigned int *, int, const int);
12827 void vec_dstst (const int *, int, const int);
12828 void vec_dstst (const unsigned long *, int, const int);
12829 void vec_dstst (const long *, int, const int);
12830 void vec_dstst (const float *, int, const int);
12832 void vec_dststt (const vector unsigned char *, int, const int);
12833 void vec_dststt (const vector signed char *, int, const int);
12834 void vec_dststt (const vector bool char *, int, const int);
12835 void vec_dststt (const vector unsigned short *, int, const int);
12836 void vec_dststt (const vector signed short *, int, const int);
12837 void vec_dststt (const vector bool short *, int, const int);
12838 void vec_dststt (const vector pixel *, int, const int);
12839 void vec_dststt (const vector unsigned int *, int, const int);
12840 void vec_dststt (const vector signed int *, int, const int);
12841 void vec_dststt (const vector bool int *, int, const int);
12842 void vec_dststt (const vector float *, int, const int);
12843 void vec_dststt (const unsigned char *, int, const int);
12844 void vec_dststt (const signed char *, int, const int);
12845 void vec_dststt (const unsigned short *, int, const int);
12846 void vec_dststt (const short *, int, const int);
12847 void vec_dststt (const unsigned int *, int, const int);
12848 void vec_dststt (const int *, int, const int);
12849 void vec_dststt (const unsigned long *, int, const int);
12850 void vec_dststt (const long *, int, const int);
12851 void vec_dststt (const float *, int, const int);
12853 void vec_dstt (const vector unsigned char *, int, const int);
12854 void vec_dstt (const vector signed char *, int, const int);
12855 void vec_dstt (const vector bool char *, int, const int);
12856 void vec_dstt (const vector unsigned short *, int, const int);
12857 void vec_dstt (const vector signed short *, int, const int);
12858 void vec_dstt (const vector bool short *, int, const int);
12859 void vec_dstt (const vector pixel *, int, const int);
12860 void vec_dstt (const vector unsigned int *, int, const int);
12861 void vec_dstt (const vector signed int *, int, const int);
12862 void vec_dstt (const vector bool int *, int, const int);
12863 void vec_dstt (const vector float *, int, const int);
12864 void vec_dstt (const unsigned char *, int, const int);
12865 void vec_dstt (const signed char *, int, const int);
12866 void vec_dstt (const unsigned short *, int, const int);
12867 void vec_dstt (const short *, int, const int);
12868 void vec_dstt (const unsigned int *, int, const int);
12869 void vec_dstt (const int *, int, const int);
12870 void vec_dstt (const unsigned long *, int, const int);
12871 void vec_dstt (const long *, int, const int);
12872 void vec_dstt (const float *, int, const int);
12874 vector float vec_expte (vector float);
12876 vector float vec_floor (vector float);
12878 vector float vec_ld (int, const vector float *);
12879 vector float vec_ld (int, const float *);
12880 vector bool int vec_ld (int, const vector bool int *);
12881 vector signed int vec_ld (int, const vector signed int *);
12882 vector signed int vec_ld (int, const int *);
12883 vector signed int vec_ld (int, const long *);
12884 vector unsigned int vec_ld (int, const vector unsigned int *);
12885 vector unsigned int vec_ld (int, const unsigned int *);
12886 vector unsigned int vec_ld (int, const unsigned long *);
12887 vector bool short vec_ld (int, const vector bool short *);
12888 vector pixel vec_ld (int, const vector pixel *);
12889 vector signed short vec_ld (int, const vector signed short *);
12890 vector signed short vec_ld (int, const short *);
12891 vector unsigned short vec_ld (int, const vector unsigned short *);
12892 vector unsigned short vec_ld (int, const unsigned short *);
12893 vector bool char vec_ld (int, const vector bool char *);
12894 vector signed char vec_ld (int, const vector signed char *);
12895 vector signed char vec_ld (int, const signed char *);
12896 vector unsigned char vec_ld (int, const vector unsigned char *);
12897 vector unsigned char vec_ld (int, const unsigned char *);
12899 vector signed char vec_lde (int, const signed char *);
12900 vector unsigned char vec_lde (int, const unsigned char *);
12901 vector signed short vec_lde (int, const short *);
12902 vector unsigned short vec_lde (int, const unsigned short *);
12903 vector float vec_lde (int, const float *);
12904 vector signed int vec_lde (int, const int *);
12905 vector unsigned int vec_lde (int, const unsigned int *);
12906 vector signed int vec_lde (int, const long *);
12907 vector unsigned int vec_lde (int, const unsigned long *);
12909 vector float vec_lvewx (int, float *);
12910 vector signed int vec_lvewx (int, int *);
12911 vector unsigned int vec_lvewx (int, unsigned int *);
12912 vector signed int vec_lvewx (int, long *);
12913 vector unsigned int vec_lvewx (int, unsigned long *);
12915 vector signed short vec_lvehx (int, short *);
12916 vector unsigned short vec_lvehx (int, unsigned short *);
12918 vector signed char vec_lvebx (int, char *);
12919 vector unsigned char vec_lvebx (int, unsigned char *);
12921 vector float vec_ldl (int, const vector float *);
12922 vector float vec_ldl (int, const float *);
12923 vector bool int vec_ldl (int, const vector bool int *);
12924 vector signed int vec_ldl (int, const vector signed int *);
12925 vector signed int vec_ldl (int, const int *);
12926 vector signed int vec_ldl (int, const long *);
12927 vector unsigned int vec_ldl (int, const vector unsigned int *);
12928 vector unsigned int vec_ldl (int, const unsigned int *);
12929 vector unsigned int vec_ldl (int, const unsigned long *);
12930 vector bool short vec_ldl (int, const vector bool short *);
12931 vector pixel vec_ldl (int, const vector pixel *);
12932 vector signed short vec_ldl (int, const vector signed short *);
12933 vector signed short vec_ldl (int, const short *);
12934 vector unsigned short vec_ldl (int, const vector unsigned short *);
12935 vector unsigned short vec_ldl (int, const unsigned short *);
12936 vector bool char vec_ldl (int, const vector bool char *);
12937 vector signed char vec_ldl (int, const vector signed char *);
12938 vector signed char vec_ldl (int, const signed char *);
12939 vector unsigned char vec_ldl (int, const vector unsigned char *);
12940 vector unsigned char vec_ldl (int, const unsigned char *);
12942 vector float vec_loge (vector float);
12944 vector unsigned char vec_lvsl (int, const volatile unsigned char *);
12945 vector unsigned char vec_lvsl (int, const volatile signed char *);
12946 vector unsigned char vec_lvsl (int, const volatile unsigned short *);
12947 vector unsigned char vec_lvsl (int, const volatile short *);
12948 vector unsigned char vec_lvsl (int, const volatile unsigned int *);
12949 vector unsigned char vec_lvsl (int, const volatile int *);
12950 vector unsigned char vec_lvsl (int, const volatile unsigned long *);
12951 vector unsigned char vec_lvsl (int, const volatile long *);
12952 vector unsigned char vec_lvsl (int, const volatile float *);
12954 vector unsigned char vec_lvsr (int, const volatile unsigned char *);
12955 vector unsigned char vec_lvsr (int, const volatile signed char *);
12956 vector unsigned char vec_lvsr (int, const volatile unsigned short *);
12957 vector unsigned char vec_lvsr (int, const volatile short *);
12958 vector unsigned char vec_lvsr (int, const volatile unsigned int *);
12959 vector unsigned char vec_lvsr (int, const volatile int *);
12960 vector unsigned char vec_lvsr (int, const volatile unsigned long *);
12961 vector unsigned char vec_lvsr (int, const volatile long *);
12962 vector unsigned char vec_lvsr (int, const volatile float *);
12964 vector float vec_madd (vector float, vector float, vector float);
12966 vector signed short vec_madds (vector signed short,
12967 vector signed short,
12968 vector signed short);
12970 vector unsigned char vec_max (vector bool char, vector unsigned char);
12971 vector unsigned char vec_max (vector unsigned char, vector bool char);
12972 vector unsigned char vec_max (vector unsigned char,
12973 vector unsigned char);
12974 vector signed char vec_max (vector bool char, vector signed char);
12975 vector signed char vec_max (vector signed char, vector bool char);
12976 vector signed char vec_max (vector signed char, vector signed char);
12977 vector unsigned short vec_max (vector bool short,
12978 vector unsigned short);
12979 vector unsigned short vec_max (vector unsigned short,
12980 vector bool short);
12981 vector unsigned short vec_max (vector unsigned short,
12982 vector unsigned short);
12983 vector signed short vec_max (vector bool short, vector signed short);
12984 vector signed short vec_max (vector signed short, vector bool short);
12985 vector signed short vec_max (vector signed short, vector signed short);
12986 vector unsigned int vec_max (vector bool int, vector unsigned int);
12987 vector unsigned int vec_max (vector unsigned int, vector bool int);
12988 vector unsigned int vec_max (vector unsigned int, vector unsigned int);
12989 vector signed int vec_max (vector bool int, vector signed int);
12990 vector signed int vec_max (vector signed int, vector bool int);
12991 vector signed int vec_max (vector signed int, vector signed int);
12992 vector float vec_max (vector float, vector float);
12994 vector float vec_vmaxfp (vector float, vector float);
12996 vector signed int vec_vmaxsw (vector bool int, vector signed int);
12997 vector signed int vec_vmaxsw (vector signed int, vector bool int);
12998 vector signed int vec_vmaxsw (vector signed int, vector signed int);
13000 vector unsigned int vec_vmaxuw (vector bool int, vector unsigned int);
13001 vector unsigned int vec_vmaxuw (vector unsigned int, vector bool int);
13002 vector unsigned int vec_vmaxuw (vector unsigned int,
13003 vector unsigned int);
13005 vector signed short vec_vmaxsh (vector bool short, vector signed short);
13006 vector signed short vec_vmaxsh (vector signed short, vector bool short);
13007 vector signed short vec_vmaxsh (vector signed short,
13008 vector signed short);
13010 vector unsigned short vec_vmaxuh (vector bool short,
13011 vector unsigned short);
13012 vector unsigned short vec_vmaxuh (vector unsigned short,
13013 vector bool short);
13014 vector unsigned short vec_vmaxuh (vector unsigned short,
13015 vector unsigned short);
13017 vector signed char vec_vmaxsb (vector bool char, vector signed char);
13018 vector signed char vec_vmaxsb (vector signed char, vector bool char);
13019 vector signed char vec_vmaxsb (vector signed char, vector signed char);
13021 vector unsigned char vec_vmaxub (vector bool char,
13022 vector unsigned char);
13023 vector unsigned char vec_vmaxub (vector unsigned char,
13025 vector unsigned char vec_vmaxub (vector unsigned char,
13026 vector unsigned char);
13028 vector bool char vec_mergeh (vector bool char, vector bool char);
13029 vector signed char vec_mergeh (vector signed char, vector signed char);
13030 vector unsigned char vec_mergeh (vector unsigned char,
13031 vector unsigned char);
13032 vector bool short vec_mergeh (vector bool short, vector bool short);
13033 vector pixel vec_mergeh (vector pixel, vector pixel);
13034 vector signed short vec_mergeh (vector signed short,
13035 vector signed short);
13036 vector unsigned short vec_mergeh (vector unsigned short,
13037 vector unsigned short);
13038 vector float vec_mergeh (vector float, vector float);
13039 vector bool int vec_mergeh (vector bool int, vector bool int);
13040 vector signed int vec_mergeh (vector signed int, vector signed int);
13041 vector unsigned int vec_mergeh (vector unsigned int,
13042 vector unsigned int);
13044 vector float vec_vmrghw (vector float, vector float);
13045 vector bool int vec_vmrghw (vector bool int, vector bool int);
13046 vector signed int vec_vmrghw (vector signed int, vector signed int);
13047 vector unsigned int vec_vmrghw (vector unsigned int,
13048 vector unsigned int);
13050 vector bool short vec_vmrghh (vector bool short, vector bool short);
13051 vector signed short vec_vmrghh (vector signed short,
13052 vector signed short);
13053 vector unsigned short vec_vmrghh (vector unsigned short,
13054 vector unsigned short);
13055 vector pixel vec_vmrghh (vector pixel, vector pixel);
13057 vector bool char vec_vmrghb (vector bool char, vector bool char);
13058 vector signed char vec_vmrghb (vector signed char, vector signed char);
13059 vector unsigned char vec_vmrghb (vector unsigned char,
13060 vector unsigned char);
13062 vector bool char vec_mergel (vector bool char, vector bool char);
13063 vector signed char vec_mergel (vector signed char, vector signed char);
13064 vector unsigned char vec_mergel (vector unsigned char,
13065 vector unsigned char);
13066 vector bool short vec_mergel (vector bool short, vector bool short);
13067 vector pixel vec_mergel (vector pixel, vector pixel);
13068 vector signed short vec_mergel (vector signed short,
13069 vector signed short);
13070 vector unsigned short vec_mergel (vector unsigned short,
13071 vector unsigned short);
13072 vector float vec_mergel (vector float, vector float);
13073 vector bool int vec_mergel (vector bool int, vector bool int);
13074 vector signed int vec_mergel (vector signed int, vector signed int);
13075 vector unsigned int vec_mergel (vector unsigned int,
13076 vector unsigned int);
13078 vector float vec_vmrglw (vector float, vector float);
13079 vector signed int vec_vmrglw (vector signed int, vector signed int);
13080 vector unsigned int vec_vmrglw (vector unsigned int,
13081 vector unsigned int);
13082 vector bool int vec_vmrglw (vector bool int, vector bool int);
13084 vector bool short vec_vmrglh (vector bool short, vector bool short);
13085 vector signed short vec_vmrglh (vector signed short,
13086 vector signed short);
13087 vector unsigned short vec_vmrglh (vector unsigned short,
13088 vector unsigned short);
13089 vector pixel vec_vmrglh (vector pixel, vector pixel);
13091 vector bool char vec_vmrglb (vector bool char, vector bool char);
13092 vector signed char vec_vmrglb (vector signed char, vector signed char);
13093 vector unsigned char vec_vmrglb (vector unsigned char,
13094 vector unsigned char);
13096 vector unsigned short vec_mfvscr (void);
13098 vector unsigned char vec_min (vector bool char, vector unsigned char);
13099 vector unsigned char vec_min (vector unsigned char, vector bool char);
13100 vector unsigned char vec_min (vector unsigned char,
13101 vector unsigned char);
13102 vector signed char vec_min (vector bool char, vector signed char);
13103 vector signed char vec_min (vector signed char, vector bool char);
13104 vector signed char vec_min (vector signed char, vector signed char);
13105 vector unsigned short vec_min (vector bool short,
13106 vector unsigned short);
13107 vector unsigned short vec_min (vector unsigned short,
13108 vector bool short);
13109 vector unsigned short vec_min (vector unsigned short,
13110 vector unsigned short);
13111 vector signed short vec_min (vector bool short, vector signed short);
13112 vector signed short vec_min (vector signed short, vector bool short);
13113 vector signed short vec_min (vector signed short, vector signed short);
13114 vector unsigned int vec_min (vector bool int, vector unsigned int);
13115 vector unsigned int vec_min (vector unsigned int, vector bool int);
13116 vector unsigned int vec_min (vector unsigned int, vector unsigned int);
13117 vector signed int vec_min (vector bool int, vector signed int);
13118 vector signed int vec_min (vector signed int, vector bool int);
13119 vector signed int vec_min (vector signed int, vector signed int);
13120 vector float vec_min (vector float, vector float);
13122 vector float vec_vminfp (vector float, vector float);
13124 vector signed int vec_vminsw (vector bool int, vector signed int);
13125 vector signed int vec_vminsw (vector signed int, vector bool int);
13126 vector signed int vec_vminsw (vector signed int, vector signed int);
13128 vector unsigned int vec_vminuw (vector bool int, vector unsigned int);
13129 vector unsigned int vec_vminuw (vector unsigned int, vector bool int);
13130 vector unsigned int vec_vminuw (vector unsigned int,
13131 vector unsigned int);
13133 vector signed short vec_vminsh (vector bool short, vector signed short);
13134 vector signed short vec_vminsh (vector signed short, vector bool short);
13135 vector signed short vec_vminsh (vector signed short,
13136 vector signed short);
13138 vector unsigned short vec_vminuh (vector bool short,
13139 vector unsigned short);
13140 vector unsigned short vec_vminuh (vector unsigned short,
13141 vector bool short);
13142 vector unsigned short vec_vminuh (vector unsigned short,
13143 vector unsigned short);
13145 vector signed char vec_vminsb (vector bool char, vector signed char);
13146 vector signed char vec_vminsb (vector signed char, vector bool char);
13147 vector signed char vec_vminsb (vector signed char, vector signed char);
13149 vector unsigned char vec_vminub (vector bool char,
13150 vector unsigned char);
13151 vector unsigned char vec_vminub (vector unsigned char,
13153 vector unsigned char vec_vminub (vector unsigned char,
13154 vector unsigned char);
13156 vector signed short vec_mladd (vector signed short,
13157 vector signed short,
13158 vector signed short);
13159 vector signed short vec_mladd (vector signed short,
13160 vector unsigned short,
13161 vector unsigned short);
13162 vector signed short vec_mladd (vector unsigned short,
13163 vector signed short,
13164 vector signed short);
13165 vector unsigned short vec_mladd (vector unsigned short,
13166 vector unsigned short,
13167 vector unsigned short);
13169 vector signed short vec_mradds (vector signed short,
13170 vector signed short,
13171 vector signed short);
13173 vector unsigned int vec_msum (vector unsigned char,
13174 vector unsigned char,
13175 vector unsigned int);
13176 vector signed int vec_msum (vector signed char,
13177 vector unsigned char,
13178 vector signed int);
13179 vector unsigned int vec_msum (vector unsigned short,
13180 vector unsigned short,
13181 vector unsigned int);
13182 vector signed int vec_msum (vector signed short,
13183 vector signed short,
13184 vector signed int);
13186 vector signed int vec_vmsumshm (vector signed short,
13187 vector signed short,
13188 vector signed int);
13190 vector unsigned int vec_vmsumuhm (vector unsigned short,
13191 vector unsigned short,
13192 vector unsigned int);
13194 vector signed int vec_vmsummbm (vector signed char,
13195 vector unsigned char,
13196 vector signed int);
13198 vector unsigned int vec_vmsumubm (vector unsigned char,
13199 vector unsigned char,
13200 vector unsigned int);
13202 vector unsigned int vec_msums (vector unsigned short,
13203 vector unsigned short,
13204 vector unsigned int);
13205 vector signed int vec_msums (vector signed short,
13206 vector signed short,
13207 vector signed int);
13209 vector signed int vec_vmsumshs (vector signed short,
13210 vector signed short,
13211 vector signed int);
13213 vector unsigned int vec_vmsumuhs (vector unsigned short,
13214 vector unsigned short,
13215 vector unsigned int);
13217 void vec_mtvscr (vector signed int);
13218 void vec_mtvscr (vector unsigned int);
13219 void vec_mtvscr (vector bool int);
13220 void vec_mtvscr (vector signed short);
13221 void vec_mtvscr (vector unsigned short);
13222 void vec_mtvscr (vector bool short);
13223 void vec_mtvscr (vector pixel);
13224 void vec_mtvscr (vector signed char);
13225 void vec_mtvscr (vector unsigned char);
13226 void vec_mtvscr (vector bool char);
13228 vector unsigned short vec_mule (vector unsigned char,
13229 vector unsigned char);
13230 vector signed short vec_mule (vector signed char,
13231 vector signed char);
13232 vector unsigned int vec_mule (vector unsigned short,
13233 vector unsigned short);
13234 vector signed int vec_mule (vector signed short, vector signed short);
13236 vector signed int vec_vmulesh (vector signed short,
13237 vector signed short);
13239 vector unsigned int vec_vmuleuh (vector unsigned short,
13240 vector unsigned short);
13242 vector signed short vec_vmulesb (vector signed char,
13243 vector signed char);
13245 vector unsigned short vec_vmuleub (vector unsigned char,
13246 vector unsigned char);
13248 vector unsigned short vec_mulo (vector unsigned char,
13249 vector unsigned char);
13250 vector signed short vec_mulo (vector signed char, vector signed char);
13251 vector unsigned int vec_mulo (vector unsigned short,
13252 vector unsigned short);
13253 vector signed int vec_mulo (vector signed short, vector signed short);
13255 vector signed int vec_vmulosh (vector signed short,
13256 vector signed short);
13258 vector unsigned int vec_vmulouh (vector unsigned short,
13259 vector unsigned short);
13261 vector signed short vec_vmulosb (vector signed char,
13262 vector signed char);
13264 vector unsigned short vec_vmuloub (vector unsigned char,
13265 vector unsigned char);
13267 vector float vec_nmsub (vector float, vector float, vector float);
13269 vector float vec_nor (vector float, vector float);
13270 vector signed int vec_nor (vector signed int, vector signed int);
13271 vector unsigned int vec_nor (vector unsigned int, vector unsigned int);
13272 vector bool int vec_nor (vector bool int, vector bool int);
13273 vector signed short vec_nor (vector signed short, vector signed short);
13274 vector unsigned short vec_nor (vector unsigned short,
13275 vector unsigned short);
13276 vector bool short vec_nor (vector bool short, vector bool short);
13277 vector signed char vec_nor (vector signed char, vector signed char);
13278 vector unsigned char vec_nor (vector unsigned char,
13279 vector unsigned char);
13280 vector bool char vec_nor (vector bool char, vector bool char);
13282 vector float vec_or (vector float, vector float);
13283 vector float vec_or (vector float, vector bool int);
13284 vector float vec_or (vector bool int, vector float);
13285 vector bool int vec_or (vector bool int, vector bool int);
13286 vector signed int vec_or (vector bool int, vector signed int);
13287 vector signed int vec_or (vector signed int, vector bool int);
13288 vector signed int vec_or (vector signed int, vector signed int);
13289 vector unsigned int vec_or (vector bool int, vector unsigned int);
13290 vector unsigned int vec_or (vector unsigned int, vector bool int);
13291 vector unsigned int vec_or (vector unsigned int, vector unsigned int);
13292 vector bool short vec_or (vector bool short, vector bool short);
13293 vector signed short vec_or (vector bool short, vector signed short);
13294 vector signed short vec_or (vector signed short, vector bool short);
13295 vector signed short vec_or (vector signed short, vector signed short);
13296 vector unsigned short vec_or (vector bool short, vector unsigned short);
13297 vector unsigned short vec_or (vector unsigned short, vector bool short);
13298 vector unsigned short vec_or (vector unsigned short,
13299 vector unsigned short);
13300 vector signed char vec_or (vector bool char, vector signed char);
13301 vector bool char vec_or (vector bool char, vector bool char);
13302 vector signed char vec_or (vector signed char, vector bool char);
13303 vector signed char vec_or (vector signed char, vector signed char);
13304 vector unsigned char vec_or (vector bool char, vector unsigned char);
13305 vector unsigned char vec_or (vector unsigned char, vector bool char);
13306 vector unsigned char vec_or (vector unsigned char,
13307 vector unsigned char);
13309 vector signed char vec_pack (vector signed short, vector signed short);
13310 vector unsigned char vec_pack (vector unsigned short,
13311 vector unsigned short);
13312 vector bool char vec_pack (vector bool short, vector bool short);
13313 vector signed short vec_pack (vector signed int, vector signed int);
13314 vector unsigned short vec_pack (vector unsigned int,
13315 vector unsigned int);
13316 vector bool short vec_pack (vector bool int, vector bool int);
13318 vector bool short vec_vpkuwum (vector bool int, vector bool int);
13319 vector signed short vec_vpkuwum (vector signed int, vector signed int);
13320 vector unsigned short vec_vpkuwum (vector unsigned int,
13321 vector unsigned int);
13323 vector bool char vec_vpkuhum (vector bool short, vector bool short);
13324 vector signed char vec_vpkuhum (vector signed short,
13325 vector signed short);
13326 vector unsigned char vec_vpkuhum (vector unsigned short,
13327 vector unsigned short);
13329 vector pixel vec_packpx (vector unsigned int, vector unsigned int);
13331 vector unsigned char vec_packs (vector unsigned short,
13332 vector unsigned short);
13333 vector signed char vec_packs (vector signed short, vector signed short);
13334 vector unsigned short vec_packs (vector unsigned int,
13335 vector unsigned int);
13336 vector signed short vec_packs (vector signed int, vector signed int);
13338 vector signed short vec_vpkswss (vector signed int, vector signed int);
13340 vector unsigned short vec_vpkuwus (vector unsigned int,
13341 vector unsigned int);
13343 vector signed char vec_vpkshss (vector signed short,
13344 vector signed short);
13346 vector unsigned char vec_vpkuhus (vector unsigned short,
13347 vector unsigned short);
13349 vector unsigned char vec_packsu (vector unsigned short,
13350 vector unsigned short);
13351 vector unsigned char vec_packsu (vector signed short,
13352 vector signed short);
13353 vector unsigned short vec_packsu (vector unsigned int,
13354 vector unsigned int);
13355 vector unsigned short vec_packsu (vector signed int, vector signed int);
13357 vector unsigned short vec_vpkswus (vector signed int,
13358 vector signed int);
13360 vector unsigned char vec_vpkshus (vector signed short,
13361 vector signed short);
13363 vector float vec_perm (vector float,
13365 vector unsigned char);
13366 vector signed int vec_perm (vector signed int,
13368 vector unsigned char);
13369 vector unsigned int vec_perm (vector unsigned int,
13370 vector unsigned int,
13371 vector unsigned char);
13372 vector bool int vec_perm (vector bool int,
13374 vector unsigned char);
13375 vector signed short vec_perm (vector signed short,
13376 vector signed short,
13377 vector unsigned char);
13378 vector unsigned short vec_perm (vector unsigned short,
13379 vector unsigned short,
13380 vector unsigned char);
13381 vector bool short vec_perm (vector bool short,
13383 vector unsigned char);
13384 vector pixel vec_perm (vector pixel,
13386 vector unsigned char);
13387 vector signed char vec_perm (vector signed char,
13388 vector signed char,
13389 vector unsigned char);
13390 vector unsigned char vec_perm (vector unsigned char,
13391 vector unsigned char,
13392 vector unsigned char);
13393 vector bool char vec_perm (vector bool char,
13395 vector unsigned char);
13397 vector float vec_re (vector float);
13399 vector signed char vec_rl (vector signed char,
13400 vector unsigned char);
13401 vector unsigned char vec_rl (vector unsigned char,
13402 vector unsigned char);
13403 vector signed short vec_rl (vector signed short, vector unsigned short);
13404 vector unsigned short vec_rl (vector unsigned short,
13405 vector unsigned short);
13406 vector signed int vec_rl (vector signed int, vector unsigned int);
13407 vector unsigned int vec_rl (vector unsigned int, vector unsigned int);
13409 vector signed int vec_vrlw (vector signed int, vector unsigned int);
13410 vector unsigned int vec_vrlw (vector unsigned int, vector unsigned int);
13412 vector signed short vec_vrlh (vector signed short,
13413 vector unsigned short);
13414 vector unsigned short vec_vrlh (vector unsigned short,
13415 vector unsigned short);
13417 vector signed char vec_vrlb (vector signed char, vector unsigned char);
13418 vector unsigned char vec_vrlb (vector unsigned char,
13419 vector unsigned char);
13421 vector float vec_round (vector float);
13423 vector float vec_recip (vector float, vector float);
13425 vector float vec_rsqrt (vector float);
13427 vector float vec_rsqrte (vector float);
13429 vector float vec_sel (vector float, vector float, vector bool int);
13430 vector float vec_sel (vector float, vector float, vector unsigned int);
13431 vector signed int vec_sel (vector signed int,
13434 vector signed int vec_sel (vector signed int,
13436 vector unsigned int);
13437 vector unsigned int vec_sel (vector unsigned int,
13438 vector unsigned int,
13440 vector unsigned int vec_sel (vector unsigned int,
13441 vector unsigned int,
13442 vector unsigned int);
13443 vector bool int vec_sel (vector bool int,
13446 vector bool int vec_sel (vector bool int,
13448 vector unsigned int);
13449 vector signed short vec_sel (vector signed short,
13450 vector signed short,
13451 vector bool short);
13452 vector signed short vec_sel (vector signed short,
13453 vector signed short,
13454 vector unsigned short);
13455 vector unsigned short vec_sel (vector unsigned short,
13456 vector unsigned short,
13457 vector bool short);
13458 vector unsigned short vec_sel (vector unsigned short,
13459 vector unsigned short,
13460 vector unsigned short);
13461 vector bool short vec_sel (vector bool short,
13463 vector bool short);
13464 vector bool short vec_sel (vector bool short,
13466 vector unsigned short);
13467 vector signed char vec_sel (vector signed char,
13468 vector signed char,
13470 vector signed char vec_sel (vector signed char,
13471 vector signed char,
13472 vector unsigned char);
13473 vector unsigned char vec_sel (vector unsigned char,
13474 vector unsigned char,
13476 vector unsigned char vec_sel (vector unsigned char,
13477 vector unsigned char,
13478 vector unsigned char);
13479 vector bool char vec_sel (vector bool char,
13482 vector bool char vec_sel (vector bool char,
13484 vector unsigned char);
13486 vector signed char vec_sl (vector signed char,
13487 vector unsigned char);
13488 vector unsigned char vec_sl (vector unsigned char,
13489 vector unsigned char);
13490 vector signed short vec_sl (vector signed short, vector unsigned short);
13491 vector unsigned short vec_sl (vector unsigned short,
13492 vector unsigned short);
13493 vector signed int vec_sl (vector signed int, vector unsigned int);
13494 vector unsigned int vec_sl (vector unsigned int, vector unsigned int);
13496 vector signed int vec_vslw (vector signed int, vector unsigned int);
13497 vector unsigned int vec_vslw (vector unsigned int, vector unsigned int);
13499 vector signed short vec_vslh (vector signed short,
13500 vector unsigned short);
13501 vector unsigned short vec_vslh (vector unsigned short,
13502 vector unsigned short);
13504 vector signed char vec_vslb (vector signed char, vector unsigned char);
13505 vector unsigned char vec_vslb (vector unsigned char,
13506 vector unsigned char);
13508 vector float vec_sld (vector float, vector float, const int);
13509 vector signed int vec_sld (vector signed int,
13512 vector unsigned int vec_sld (vector unsigned int,
13513 vector unsigned int,
13515 vector bool int vec_sld (vector bool int,
13518 vector signed short vec_sld (vector signed short,
13519 vector signed short,
13521 vector unsigned short vec_sld (vector unsigned short,
13522 vector unsigned short,
13524 vector bool short vec_sld (vector bool short,
13527 vector pixel vec_sld (vector pixel,
13530 vector signed char vec_sld (vector signed char,
13531 vector signed char,
13533 vector unsigned char vec_sld (vector unsigned char,
13534 vector unsigned char,
13536 vector bool char vec_sld (vector bool char,
13540 vector signed int vec_sll (vector signed int,
13541 vector unsigned int);
13542 vector signed int vec_sll (vector signed int,
13543 vector unsigned short);
13544 vector signed int vec_sll (vector signed int,
13545 vector unsigned char);
13546 vector unsigned int vec_sll (vector unsigned int,
13547 vector unsigned int);
13548 vector unsigned int vec_sll (vector unsigned int,
13549 vector unsigned short);
13550 vector unsigned int vec_sll (vector unsigned int,
13551 vector unsigned char);
13552 vector bool int vec_sll (vector bool int,
13553 vector unsigned int);
13554 vector bool int vec_sll (vector bool int,
13555 vector unsigned short);
13556 vector bool int vec_sll (vector bool int,
13557 vector unsigned char);
13558 vector signed short vec_sll (vector signed short,
13559 vector unsigned int);
13560 vector signed short vec_sll (vector signed short,
13561 vector unsigned short);
13562 vector signed short vec_sll (vector signed short,
13563 vector unsigned char);
13564 vector unsigned short vec_sll (vector unsigned short,
13565 vector unsigned int);
13566 vector unsigned short vec_sll (vector unsigned short,
13567 vector unsigned short);
13568 vector unsigned short vec_sll (vector unsigned short,
13569 vector unsigned char);
13570 vector bool short vec_sll (vector bool short, vector unsigned int);
13571 vector bool short vec_sll (vector bool short, vector unsigned short);
13572 vector bool short vec_sll (vector bool short, vector unsigned char);
13573 vector pixel vec_sll (vector pixel, vector unsigned int);
13574 vector pixel vec_sll (vector pixel, vector unsigned short);
13575 vector pixel vec_sll (vector pixel, vector unsigned char);
13576 vector signed char vec_sll (vector signed char, vector unsigned int);
13577 vector signed char vec_sll (vector signed char, vector unsigned short);
13578 vector signed char vec_sll (vector signed char, vector unsigned char);
13579 vector unsigned char vec_sll (vector unsigned char,
13580 vector unsigned int);
13581 vector unsigned char vec_sll (vector unsigned char,
13582 vector unsigned short);
13583 vector unsigned char vec_sll (vector unsigned char,
13584 vector unsigned char);
13585 vector bool char vec_sll (vector bool char, vector unsigned int);
13586 vector bool char vec_sll (vector bool char, vector unsigned short);
13587 vector bool char vec_sll (vector bool char, vector unsigned char);
13589 vector float vec_slo (vector float, vector signed char);
13590 vector float vec_slo (vector float, vector unsigned char);
13591 vector signed int vec_slo (vector signed int, vector signed char);
13592 vector signed int vec_slo (vector signed int, vector unsigned char);
13593 vector unsigned int vec_slo (vector unsigned int, vector signed char);
13594 vector unsigned int vec_slo (vector unsigned int, vector unsigned char);
13595 vector signed short vec_slo (vector signed short, vector signed char);
13596 vector signed short vec_slo (vector signed short, vector unsigned char);
13597 vector unsigned short vec_slo (vector unsigned short,
13598 vector signed char);
13599 vector unsigned short vec_slo (vector unsigned short,
13600 vector unsigned char);
13601 vector pixel vec_slo (vector pixel, vector signed char);
13602 vector pixel vec_slo (vector pixel, vector unsigned char);
13603 vector signed char vec_slo (vector signed char, vector signed char);
13604 vector signed char vec_slo (vector signed char, vector unsigned char);
13605 vector unsigned char vec_slo (vector unsigned char, vector signed char);
13606 vector unsigned char vec_slo (vector unsigned char,
13607 vector unsigned char);
13609 vector signed char vec_splat (vector signed char, const int);
13610 vector unsigned char vec_splat (vector unsigned char, const int);
13611 vector bool char vec_splat (vector bool char, const int);
13612 vector signed short vec_splat (vector signed short, const int);
13613 vector unsigned short vec_splat (vector unsigned short, const int);
13614 vector bool short vec_splat (vector bool short, const int);
13615 vector pixel vec_splat (vector pixel, const int);
13616 vector float vec_splat (vector float, const int);
13617 vector signed int vec_splat (vector signed int, const int);
13618 vector unsigned int vec_splat (vector unsigned int, const int);
13619 vector bool int vec_splat (vector bool int, const int);
13620 vector signed long vec_splat (vector signed long, const int);
13621 vector unsigned long vec_splat (vector unsigned long, const int);
13623 vector signed char vec_splats (signed char);
13624 vector unsigned char vec_splats (unsigned char);
13625 vector signed short vec_splats (signed short);
13626 vector unsigned short vec_splats (unsigned short);
13627 vector signed int vec_splats (signed int);
13628 vector unsigned int vec_splats (unsigned int);
13629 vector float vec_splats (float);
13631 vector float vec_vspltw (vector float, const int);
13632 vector signed int vec_vspltw (vector signed int, const int);
13633 vector unsigned int vec_vspltw (vector unsigned int, const int);
13634 vector bool int vec_vspltw (vector bool int, const int);
13636 vector bool short vec_vsplth (vector bool short, const int);
13637 vector signed short vec_vsplth (vector signed short, const int);
13638 vector unsigned short vec_vsplth (vector unsigned short, const int);
13639 vector pixel vec_vsplth (vector pixel, const int);
13641 vector signed char vec_vspltb (vector signed char, const int);
13642 vector unsigned char vec_vspltb (vector unsigned char, const int);
13643 vector bool char vec_vspltb (vector bool char, const int);
13645 vector signed char vec_splat_s8 (const int);
13647 vector signed short vec_splat_s16 (const int);
13649 vector signed int vec_splat_s32 (const int);
13651 vector unsigned char vec_splat_u8 (const int);
13653 vector unsigned short vec_splat_u16 (const int);
13655 vector unsigned int vec_splat_u32 (const int);
13657 vector signed char vec_sr (vector signed char, vector unsigned char);
13658 vector unsigned char vec_sr (vector unsigned char,
13659 vector unsigned char);
13660 vector signed short vec_sr (vector signed short,
13661 vector unsigned short);
13662 vector unsigned short vec_sr (vector unsigned short,
13663 vector unsigned short);
13664 vector signed int vec_sr (vector signed int, vector unsigned int);
13665 vector unsigned int vec_sr (vector unsigned int, vector unsigned int);
13667 vector signed int vec_vsrw (vector signed int, vector unsigned int);
13668 vector unsigned int vec_vsrw (vector unsigned int, vector unsigned int);
13670 vector signed short vec_vsrh (vector signed short,
13671 vector unsigned short);
13672 vector unsigned short vec_vsrh (vector unsigned short,
13673 vector unsigned short);
13675 vector signed char vec_vsrb (vector signed char, vector unsigned char);
13676 vector unsigned char vec_vsrb (vector unsigned char,
13677 vector unsigned char);
13679 vector signed char vec_sra (vector signed char, vector unsigned char);
13680 vector unsigned char vec_sra (vector unsigned char,
13681 vector unsigned char);
13682 vector signed short vec_sra (vector signed short,
13683 vector unsigned short);
13684 vector unsigned short vec_sra (vector unsigned short,
13685 vector unsigned short);
13686 vector signed int vec_sra (vector signed int, vector unsigned int);
13687 vector unsigned int vec_sra (vector unsigned int, vector unsigned int);
13689 vector signed int vec_vsraw (vector signed int, vector unsigned int);
13690 vector unsigned int vec_vsraw (vector unsigned int,
13691 vector unsigned int);
13693 vector signed short vec_vsrah (vector signed short,
13694 vector unsigned short);
13695 vector unsigned short vec_vsrah (vector unsigned short,
13696 vector unsigned short);
13698 vector signed char vec_vsrab (vector signed char, vector unsigned char);
13699 vector unsigned char vec_vsrab (vector unsigned char,
13700 vector unsigned char);
13702 vector signed int vec_srl (vector signed int, vector unsigned int);
13703 vector signed int vec_srl (vector signed int, vector unsigned short);
13704 vector signed int vec_srl (vector signed int, vector unsigned char);
13705 vector unsigned int vec_srl (vector unsigned int, vector unsigned int);
13706 vector unsigned int vec_srl (vector unsigned int,
13707 vector unsigned short);
13708 vector unsigned int vec_srl (vector unsigned int, vector unsigned char);
13709 vector bool int vec_srl (vector bool int, vector unsigned int);
13710 vector bool int vec_srl (vector bool int, vector unsigned short);
13711 vector bool int vec_srl (vector bool int, vector unsigned char);
13712 vector signed short vec_srl (vector signed short, vector unsigned int);
13713 vector signed short vec_srl (vector signed short,
13714 vector unsigned short);
13715 vector signed short vec_srl (vector signed short, vector unsigned char);
13716 vector unsigned short vec_srl (vector unsigned short,
13717 vector unsigned int);
13718 vector unsigned short vec_srl (vector unsigned short,
13719 vector unsigned short);
13720 vector unsigned short vec_srl (vector unsigned short,
13721 vector unsigned char);
13722 vector bool short vec_srl (vector bool short, vector unsigned int);
13723 vector bool short vec_srl (vector bool short, vector unsigned short);
13724 vector bool short vec_srl (vector bool short, vector unsigned char);
13725 vector pixel vec_srl (vector pixel, vector unsigned int);
13726 vector pixel vec_srl (vector pixel, vector unsigned short);
13727 vector pixel vec_srl (vector pixel, vector unsigned char);
13728 vector signed char vec_srl (vector signed char, vector unsigned int);
13729 vector signed char vec_srl (vector signed char, vector unsigned short);
13730 vector signed char vec_srl (vector signed char, vector unsigned char);
13731 vector unsigned char vec_srl (vector unsigned char,
13732 vector unsigned int);
13733 vector unsigned char vec_srl (vector unsigned char,
13734 vector unsigned short);
13735 vector unsigned char vec_srl (vector unsigned char,
13736 vector unsigned char);
13737 vector bool char vec_srl (vector bool char, vector unsigned int);
13738 vector bool char vec_srl (vector bool char, vector unsigned short);
13739 vector bool char vec_srl (vector bool char, vector unsigned char);
13741 vector float vec_sro (vector float, vector signed char);
13742 vector float vec_sro (vector float, vector unsigned char);
13743 vector signed int vec_sro (vector signed int, vector signed char);
13744 vector signed int vec_sro (vector signed int, vector unsigned char);
13745 vector unsigned int vec_sro (vector unsigned int, vector signed char);
13746 vector unsigned int vec_sro (vector unsigned int, vector unsigned char);
13747 vector signed short vec_sro (vector signed short, vector signed char);
13748 vector signed short vec_sro (vector signed short, vector unsigned char);
13749 vector unsigned short vec_sro (vector unsigned short,
13750 vector signed char);
13751 vector unsigned short vec_sro (vector unsigned short,
13752 vector unsigned char);
13753 vector pixel vec_sro (vector pixel, vector signed char);
13754 vector pixel vec_sro (vector pixel, vector unsigned char);
13755 vector signed char vec_sro (vector signed char, vector signed char);
13756 vector signed char vec_sro (vector signed char, vector unsigned char);
13757 vector unsigned char vec_sro (vector unsigned char, vector signed char);
13758 vector unsigned char vec_sro (vector unsigned char,
13759 vector unsigned char);
13761 void vec_st (vector float, int, vector float *);
13762 void vec_st (vector float, int, float *);
13763 void vec_st (vector signed int, int, vector signed int *);
13764 void vec_st (vector signed int, int, int *);
13765 void vec_st (vector unsigned int, int, vector unsigned int *);
13766 void vec_st (vector unsigned int, int, unsigned int *);
13767 void vec_st (vector bool int, int, vector bool int *);
13768 void vec_st (vector bool int, int, unsigned int *);
13769 void vec_st (vector bool int, int, int *);
13770 void vec_st (vector signed short, int, vector signed short *);
13771 void vec_st (vector signed short, int, short *);
13772 void vec_st (vector unsigned short, int, vector unsigned short *);
13773 void vec_st (vector unsigned short, int, unsigned short *);
13774 void vec_st (vector bool short, int, vector bool short *);
13775 void vec_st (vector bool short, int, unsigned short *);
13776 void vec_st (vector pixel, int, vector pixel *);
13777 void vec_st (vector pixel, int, unsigned short *);
13778 void vec_st (vector pixel, int, short *);
13779 void vec_st (vector bool short, int, short *);
13780 void vec_st (vector signed char, int, vector signed char *);
13781 void vec_st (vector signed char, int, signed char *);
13782 void vec_st (vector unsigned char, int, vector unsigned char *);
13783 void vec_st (vector unsigned char, int, unsigned char *);
13784 void vec_st (vector bool char, int, vector bool char *);
13785 void vec_st (vector bool char, int, unsigned char *);
13786 void vec_st (vector bool char, int, signed char *);
13788 void vec_ste (vector signed char, int, signed char *);
13789 void vec_ste (vector unsigned char, int, unsigned char *);
13790 void vec_ste (vector bool char, int, signed char *);
13791 void vec_ste (vector bool char, int, unsigned char *);
13792 void vec_ste (vector signed short, int, short *);
13793 void vec_ste (vector unsigned short, int, unsigned short *);
13794 void vec_ste (vector bool short, int, short *);
13795 void vec_ste (vector bool short, int, unsigned short *);
13796 void vec_ste (vector pixel, int, short *);
13797 void vec_ste (vector pixel, int, unsigned short *);
13798 void vec_ste (vector float, int, float *);
13799 void vec_ste (vector signed int, int, int *);
13800 void vec_ste (vector unsigned int, int, unsigned int *);
13801 void vec_ste (vector bool int, int, int *);
13802 void vec_ste (vector bool int, int, unsigned int *);
13804 void vec_stvewx (vector float, int, float *);
13805 void vec_stvewx (vector signed int, int, int *);
13806 void vec_stvewx (vector unsigned int, int, unsigned int *);
13807 void vec_stvewx (vector bool int, int, int *);
13808 void vec_stvewx (vector bool int, int, unsigned int *);
13810 void vec_stvehx (vector signed short, int, short *);
13811 void vec_stvehx (vector unsigned short, int, unsigned short *);
13812 void vec_stvehx (vector bool short, int, short *);
13813 void vec_stvehx (vector bool short, int, unsigned short *);
13814 void vec_stvehx (vector pixel, int, short *);
13815 void vec_stvehx (vector pixel, int, unsigned short *);
13817 void vec_stvebx (vector signed char, int, signed char *);
13818 void vec_stvebx (vector unsigned char, int, unsigned char *);
13819 void vec_stvebx (vector bool char, int, signed char *);
13820 void vec_stvebx (vector bool char, int, unsigned char *);
13822 void vec_stl (vector float, int, vector float *);
13823 void vec_stl (vector float, int, float *);
13824 void vec_stl (vector signed int, int, vector signed int *);
13825 void vec_stl (vector signed int, int, int *);
13826 void vec_stl (vector unsigned int, int, vector unsigned int *);
13827 void vec_stl (vector unsigned int, int, unsigned int *);
13828 void vec_stl (vector bool int, int, vector bool int *);
13829 void vec_stl (vector bool int, int, unsigned int *);
13830 void vec_stl (vector bool int, int, int *);
13831 void vec_stl (vector signed short, int, vector signed short *);
13832 void vec_stl (vector signed short, int, short *);
13833 void vec_stl (vector unsigned short, int, vector unsigned short *);
13834 void vec_stl (vector unsigned short, int, unsigned short *);
13835 void vec_stl (vector bool short, int, vector bool short *);
13836 void vec_stl (vector bool short, int, unsigned short *);
13837 void vec_stl (vector bool short, int, short *);
13838 void vec_stl (vector pixel, int, vector pixel *);
13839 void vec_stl (vector pixel, int, unsigned short *);
13840 void vec_stl (vector pixel, int, short *);
13841 void vec_stl (vector signed char, int, vector signed char *);
13842 void vec_stl (vector signed char, int, signed char *);
13843 void vec_stl (vector unsigned char, int, vector unsigned char *);
13844 void vec_stl (vector unsigned char, int, unsigned char *);
13845 void vec_stl (vector bool char, int, vector bool char *);
13846 void vec_stl (vector bool char, int, unsigned char *);
13847 void vec_stl (vector bool char, int, signed char *);
13849 vector signed char vec_sub (vector bool char, vector signed char);
13850 vector signed char vec_sub (vector signed char, vector bool char);
13851 vector signed char vec_sub (vector signed char, vector signed char);
13852 vector unsigned char vec_sub (vector bool char, vector unsigned char);
13853 vector unsigned char vec_sub (vector unsigned char, vector bool char);
13854 vector unsigned char vec_sub (vector unsigned char,
13855 vector unsigned char);
13856 vector signed short vec_sub (vector bool short, vector signed short);
13857 vector signed short vec_sub (vector signed short, vector bool short);
13858 vector signed short vec_sub (vector signed short, vector signed short);
13859 vector unsigned short vec_sub (vector bool short,
13860 vector unsigned short);
13861 vector unsigned short vec_sub (vector unsigned short,
13862 vector bool short);
13863 vector unsigned short vec_sub (vector unsigned short,
13864 vector unsigned short);
13865 vector signed int vec_sub (vector bool int, vector signed int);
13866 vector signed int vec_sub (vector signed int, vector bool int);
13867 vector signed int vec_sub (vector signed int, vector signed int);
13868 vector unsigned int vec_sub (vector bool int, vector unsigned int);
13869 vector unsigned int vec_sub (vector unsigned int, vector bool int);
13870 vector unsigned int vec_sub (vector unsigned int, vector unsigned int);
13871 vector float vec_sub (vector float, vector float);
13873 vector float vec_vsubfp (vector float, vector float);
13875 vector signed int vec_vsubuwm (vector bool int, vector signed int);
13876 vector signed int vec_vsubuwm (vector signed int, vector bool int);
13877 vector signed int vec_vsubuwm (vector signed int, vector signed int);
13878 vector unsigned int vec_vsubuwm (vector bool int, vector unsigned int);
13879 vector unsigned int vec_vsubuwm (vector unsigned int, vector bool int);
13880 vector unsigned int vec_vsubuwm (vector unsigned int,
13881 vector unsigned int);
13883 vector signed short vec_vsubuhm (vector bool short,
13884 vector signed short);
13885 vector signed short vec_vsubuhm (vector signed short,
13886 vector bool short);
13887 vector signed short vec_vsubuhm (vector signed short,
13888 vector signed short);
13889 vector unsigned short vec_vsubuhm (vector bool short,
13890 vector unsigned short);
13891 vector unsigned short vec_vsubuhm (vector unsigned short,
13892 vector bool short);
13893 vector unsigned short vec_vsubuhm (vector unsigned short,
13894 vector unsigned short);
13896 vector signed char vec_vsububm (vector bool char, vector signed char);
13897 vector signed char vec_vsububm (vector signed char, vector bool char);
13898 vector signed char vec_vsububm (vector signed char, vector signed char);
13899 vector unsigned char vec_vsububm (vector bool char,
13900 vector unsigned char);
13901 vector unsigned char vec_vsububm (vector unsigned char,
13903 vector unsigned char vec_vsububm (vector unsigned char,
13904 vector unsigned char);
13906 vector unsigned int vec_subc (vector unsigned int, vector unsigned int);
13908 vector unsigned char vec_subs (vector bool char, vector unsigned char);
13909 vector unsigned char vec_subs (vector unsigned char, vector bool char);
13910 vector unsigned char vec_subs (vector unsigned char,
13911 vector unsigned char);
13912 vector signed char vec_subs (vector bool char, vector signed char);
13913 vector signed char vec_subs (vector signed char, vector bool char);
13914 vector signed char vec_subs (vector signed char, vector signed char);
13915 vector unsigned short vec_subs (vector bool short,
13916 vector unsigned short);
13917 vector unsigned short vec_subs (vector unsigned short,
13918 vector bool short);
13919 vector unsigned short vec_subs (vector unsigned short,
13920 vector unsigned short);
13921 vector signed short vec_subs (vector bool short, vector signed short);
13922 vector signed short vec_subs (vector signed short, vector bool short);
13923 vector signed short vec_subs (vector signed short, vector signed short);
13924 vector unsigned int vec_subs (vector bool int, vector unsigned int);
13925 vector unsigned int vec_subs (vector unsigned int, vector bool int);
13926 vector unsigned int vec_subs (vector unsigned int, vector unsigned int);
13927 vector signed int vec_subs (vector bool int, vector signed int);
13928 vector signed int vec_subs (vector signed int, vector bool int);
13929 vector signed int vec_subs (vector signed int, vector signed int);
13931 vector signed int vec_vsubsws (vector bool int, vector signed int);
13932 vector signed int vec_vsubsws (vector signed int, vector bool int);
13933 vector signed int vec_vsubsws (vector signed int, vector signed int);
13935 vector unsigned int vec_vsubuws (vector bool int, vector unsigned int);
13936 vector unsigned int vec_vsubuws (vector unsigned int, vector bool int);
13937 vector unsigned int vec_vsubuws (vector unsigned int,
13938 vector unsigned int);
13940 vector signed short vec_vsubshs (vector bool short,
13941 vector signed short);
13942 vector signed short vec_vsubshs (vector signed short,
13943 vector bool short);
13944 vector signed short vec_vsubshs (vector signed short,
13945 vector signed short);
13947 vector unsigned short vec_vsubuhs (vector bool short,
13948 vector unsigned short);
13949 vector unsigned short vec_vsubuhs (vector unsigned short,
13950 vector bool short);
13951 vector unsigned short vec_vsubuhs (vector unsigned short,
13952 vector unsigned short);
13954 vector signed char vec_vsubsbs (vector bool char, vector signed char);
13955 vector signed char vec_vsubsbs (vector signed char, vector bool char);
13956 vector signed char vec_vsubsbs (vector signed char, vector signed char);
13958 vector unsigned char vec_vsububs (vector bool char,
13959 vector unsigned char);
13960 vector unsigned char vec_vsububs (vector unsigned char,
13962 vector unsigned char vec_vsububs (vector unsigned char,
13963 vector unsigned char);
13965 vector unsigned int vec_sum4s (vector unsigned char,
13966 vector unsigned int);
13967 vector signed int vec_sum4s (vector signed char, vector signed int);
13968 vector signed int vec_sum4s (vector signed short, vector signed int);
13970 vector signed int vec_vsum4shs (vector signed short, vector signed int);
13972 vector signed int vec_vsum4sbs (vector signed char, vector signed int);
13974 vector unsigned int vec_vsum4ubs (vector unsigned char,
13975 vector unsigned int);
13977 vector signed int vec_sum2s (vector signed int, vector signed int);
13979 vector signed int vec_sums (vector signed int, vector signed int);
13981 vector float vec_trunc (vector float);
13983 vector signed short vec_unpackh (vector signed char);
13984 vector bool short vec_unpackh (vector bool char);
13985 vector signed int vec_unpackh (vector signed short);
13986 vector bool int vec_unpackh (vector bool short);
13987 vector unsigned int vec_unpackh (vector pixel);
13989 vector bool int vec_vupkhsh (vector bool short);
13990 vector signed int vec_vupkhsh (vector signed short);
13992 vector unsigned int vec_vupkhpx (vector pixel);
13994 vector bool short vec_vupkhsb (vector bool char);
13995 vector signed short vec_vupkhsb (vector signed char);
13997 vector signed short vec_unpackl (vector signed char);
13998 vector bool short vec_unpackl (vector bool char);
13999 vector unsigned int vec_unpackl (vector pixel);
14000 vector signed int vec_unpackl (vector signed short);
14001 vector bool int vec_unpackl (vector bool short);
14003 vector unsigned int vec_vupklpx (vector pixel);
14005 vector bool int vec_vupklsh (vector bool short);
14006 vector signed int vec_vupklsh (vector signed short);
14008 vector bool short vec_vupklsb (vector bool char);
14009 vector signed short vec_vupklsb (vector signed char);
14011 vector float vec_xor (vector float, vector float);
14012 vector float vec_xor (vector float, vector bool int);
14013 vector float vec_xor (vector bool int, vector float);
14014 vector bool int vec_xor (vector bool int, vector bool int);
14015 vector signed int vec_xor (vector bool int, vector signed int);
14016 vector signed int vec_xor (vector signed int, vector bool int);
14017 vector signed int vec_xor (vector signed int, vector signed int);
14018 vector unsigned int vec_xor (vector bool int, vector unsigned int);
14019 vector unsigned int vec_xor (vector unsigned int, vector bool int);
14020 vector unsigned int vec_xor (vector unsigned int, vector unsigned int);
14021 vector bool short vec_xor (vector bool short, vector bool short);
14022 vector signed short vec_xor (vector bool short, vector signed short);
14023 vector signed short vec_xor (vector signed short, vector bool short);
14024 vector signed short vec_xor (vector signed short, vector signed short);
14025 vector unsigned short vec_xor (vector bool short,
14026 vector unsigned short);
14027 vector unsigned short vec_xor (vector unsigned short,
14028 vector bool short);
14029 vector unsigned short vec_xor (vector unsigned short,
14030 vector unsigned short);
14031 vector signed char vec_xor (vector bool char, vector signed char);
14032 vector bool char vec_xor (vector bool char, vector bool char);
14033 vector signed char vec_xor (vector signed char, vector bool char);
14034 vector signed char vec_xor (vector signed char, vector signed char);
14035 vector unsigned char vec_xor (vector bool char, vector unsigned char);
14036 vector unsigned char vec_xor (vector unsigned char, vector bool char);
14037 vector unsigned char vec_xor (vector unsigned char,
14038 vector unsigned char);
14040 int vec_all_eq (vector signed char, vector bool char);
14041 int vec_all_eq (vector signed char, vector signed char);
14042 int vec_all_eq (vector unsigned char, vector bool char);
14043 int vec_all_eq (vector unsigned char, vector unsigned char);
14044 int vec_all_eq (vector bool char, vector bool char);
14045 int vec_all_eq (vector bool char, vector unsigned char);
14046 int vec_all_eq (vector bool char, vector signed char);
14047 int vec_all_eq (vector signed short, vector bool short);
14048 int vec_all_eq (vector signed short, vector signed short);
14049 int vec_all_eq (vector unsigned short, vector bool short);
14050 int vec_all_eq (vector unsigned short, vector unsigned short);
14051 int vec_all_eq (vector bool short, vector bool short);
14052 int vec_all_eq (vector bool short, vector unsigned short);
14053 int vec_all_eq (vector bool short, vector signed short);
14054 int vec_all_eq (vector pixel, vector pixel);
14055 int vec_all_eq (vector signed int, vector bool int);
14056 int vec_all_eq (vector signed int, vector signed int);
14057 int vec_all_eq (vector unsigned int, vector bool int);
14058 int vec_all_eq (vector unsigned int, vector unsigned int);
14059 int vec_all_eq (vector bool int, vector bool int);
14060 int vec_all_eq (vector bool int, vector unsigned int);
14061 int vec_all_eq (vector bool int, vector signed int);
14062 int vec_all_eq (vector float, vector float);
14064 int vec_all_ge (vector bool char, vector unsigned char);
14065 int vec_all_ge (vector unsigned char, vector bool char);
14066 int vec_all_ge (vector unsigned char, vector unsigned char);
14067 int vec_all_ge (vector bool char, vector signed char);
14068 int vec_all_ge (vector signed char, vector bool char);
14069 int vec_all_ge (vector signed char, vector signed char);
14070 int vec_all_ge (vector bool short, vector unsigned short);
14071 int vec_all_ge (vector unsigned short, vector bool short);
14072 int vec_all_ge (vector unsigned short, vector unsigned short);
14073 int vec_all_ge (vector signed short, vector signed short);
14074 int vec_all_ge (vector bool short, vector signed short);
14075 int vec_all_ge (vector signed short, vector bool short);
14076 int vec_all_ge (vector bool int, vector unsigned int);
14077 int vec_all_ge (vector unsigned int, vector bool int);
14078 int vec_all_ge (vector unsigned int, vector unsigned int);
14079 int vec_all_ge (vector bool int, vector signed int);
14080 int vec_all_ge (vector signed int, vector bool int);
14081 int vec_all_ge (vector signed int, vector signed int);
14082 int vec_all_ge (vector float, vector float);
14084 int vec_all_gt (vector bool char, vector unsigned char);
14085 int vec_all_gt (vector unsigned char, vector bool char);
14086 int vec_all_gt (vector unsigned char, vector unsigned char);
14087 int vec_all_gt (vector bool char, vector signed char);
14088 int vec_all_gt (vector signed char, vector bool char);
14089 int vec_all_gt (vector signed char, vector signed char);
14090 int vec_all_gt (vector bool short, vector unsigned short);
14091 int vec_all_gt (vector unsigned short, vector bool short);
14092 int vec_all_gt (vector unsigned short, vector unsigned short);
14093 int vec_all_gt (vector bool short, vector signed short);
14094 int vec_all_gt (vector signed short, vector bool short);
14095 int vec_all_gt (vector signed short, vector signed short);
14096 int vec_all_gt (vector bool int, vector unsigned int);
14097 int vec_all_gt (vector unsigned int, vector bool int);
14098 int vec_all_gt (vector unsigned int, vector unsigned int);
14099 int vec_all_gt (vector bool int, vector signed int);
14100 int vec_all_gt (vector signed int, vector bool int);
14101 int vec_all_gt (vector signed int, vector signed int);
14102 int vec_all_gt (vector float, vector float);
14104 int vec_all_in (vector float, vector float);
14106 int vec_all_le (vector bool char, vector unsigned char);
14107 int vec_all_le (vector unsigned char, vector bool char);
14108 int vec_all_le (vector unsigned char, vector unsigned char);
14109 int vec_all_le (vector bool char, vector signed char);
14110 int vec_all_le (vector signed char, vector bool char);
14111 int vec_all_le (vector signed char, vector signed char);
14112 int vec_all_le (vector bool short, vector unsigned short);
14113 int vec_all_le (vector unsigned short, vector bool short);
14114 int vec_all_le (vector unsigned short, vector unsigned short);
14115 int vec_all_le (vector bool short, vector signed short);
14116 int vec_all_le (vector signed short, vector bool short);
14117 int vec_all_le (vector signed short, vector signed short);
14118 int vec_all_le (vector bool int, vector unsigned int);
14119 int vec_all_le (vector unsigned int, vector bool int);
14120 int vec_all_le (vector unsigned int, vector unsigned int);
14121 int vec_all_le (vector bool int, vector signed int);
14122 int vec_all_le (vector signed int, vector bool int);
14123 int vec_all_le (vector signed int, vector signed int);
14124 int vec_all_le (vector float, vector float);
14126 int vec_all_lt (vector bool char, vector unsigned char);
14127 int vec_all_lt (vector unsigned char, vector bool char);
14128 int vec_all_lt (vector unsigned char, vector unsigned char);
14129 int vec_all_lt (vector bool char, vector signed char);
14130 int vec_all_lt (vector signed char, vector bool char);
14131 int vec_all_lt (vector signed char, vector signed char);
14132 int vec_all_lt (vector bool short, vector unsigned short);
14133 int vec_all_lt (vector unsigned short, vector bool short);
14134 int vec_all_lt (vector unsigned short, vector unsigned short);
14135 int vec_all_lt (vector bool short, vector signed short);
14136 int vec_all_lt (vector signed short, vector bool short);
14137 int vec_all_lt (vector signed short, vector signed short);
14138 int vec_all_lt (vector bool int, vector unsigned int);
14139 int vec_all_lt (vector unsigned int, vector bool int);
14140 int vec_all_lt (vector unsigned int, vector unsigned int);
14141 int vec_all_lt (vector bool int, vector signed int);
14142 int vec_all_lt (vector signed int, vector bool int);
14143 int vec_all_lt (vector signed int, vector signed int);
14144 int vec_all_lt (vector float, vector float);
14146 int vec_all_nan (vector float);
14148 int vec_all_ne (vector signed char, vector bool char);
14149 int vec_all_ne (vector signed char, vector signed char);
14150 int vec_all_ne (vector unsigned char, vector bool char);
14151 int vec_all_ne (vector unsigned char, vector unsigned char);
14152 int vec_all_ne (vector bool char, vector bool char);
14153 int vec_all_ne (vector bool char, vector unsigned char);
14154 int vec_all_ne (vector bool char, vector signed char);
14155 int vec_all_ne (vector signed short, vector bool short);
14156 int vec_all_ne (vector signed short, vector signed short);
14157 int vec_all_ne (vector unsigned short, vector bool short);
14158 int vec_all_ne (vector unsigned short, vector unsigned short);
14159 int vec_all_ne (vector bool short, vector bool short);
14160 int vec_all_ne (vector bool short, vector unsigned short);
14161 int vec_all_ne (vector bool short, vector signed short);
14162 int vec_all_ne (vector pixel, vector pixel);
14163 int vec_all_ne (vector signed int, vector bool int);
14164 int vec_all_ne (vector signed int, vector signed int);
14165 int vec_all_ne (vector unsigned int, vector bool int);
14166 int vec_all_ne (vector unsigned int, vector unsigned int);
14167 int vec_all_ne (vector bool int, vector bool int);
14168 int vec_all_ne (vector bool int, vector unsigned int);
14169 int vec_all_ne (vector bool int, vector signed int);
14170 int vec_all_ne (vector float, vector float);
14172 int vec_all_nge (vector float, vector float);
14174 int vec_all_ngt (vector float, vector float);
14176 int vec_all_nle (vector float, vector float);
14178 int vec_all_nlt (vector float, vector float);
14180 int vec_all_numeric (vector float);
14182 int vec_any_eq (vector signed char, vector bool char);
14183 int vec_any_eq (vector signed char, vector signed char);
14184 int vec_any_eq (vector unsigned char, vector bool char);
14185 int vec_any_eq (vector unsigned char, vector unsigned char);
14186 int vec_any_eq (vector bool char, vector bool char);
14187 int vec_any_eq (vector bool char, vector unsigned char);
14188 int vec_any_eq (vector bool char, vector signed char);
14189 int vec_any_eq (vector signed short, vector bool short);
14190 int vec_any_eq (vector signed short, vector signed short);
14191 int vec_any_eq (vector unsigned short, vector bool short);
14192 int vec_any_eq (vector unsigned short, vector unsigned short);
14193 int vec_any_eq (vector bool short, vector bool short);
14194 int vec_any_eq (vector bool short, vector unsigned short);
14195 int vec_any_eq (vector bool short, vector signed short);
14196 int vec_any_eq (vector pixel, vector pixel);
14197 int vec_any_eq (vector signed int, vector bool int);
14198 int vec_any_eq (vector signed int, vector signed int);
14199 int vec_any_eq (vector unsigned int, vector bool int);
14200 int vec_any_eq (vector unsigned int, vector unsigned int);
14201 int vec_any_eq (vector bool int, vector bool int);
14202 int vec_any_eq (vector bool int, vector unsigned int);
14203 int vec_any_eq (vector bool int, vector signed int);
14204 int vec_any_eq (vector float, vector float);
14206 int vec_any_ge (vector signed char, vector bool char);
14207 int vec_any_ge (vector unsigned char, vector bool char);
14208 int vec_any_ge (vector unsigned char, vector unsigned char);
14209 int vec_any_ge (vector signed char, vector signed char);
14210 int vec_any_ge (vector bool char, vector unsigned char);
14211 int vec_any_ge (vector bool char, vector signed char);
14212 int vec_any_ge (vector unsigned short, vector bool short);
14213 int vec_any_ge (vector unsigned short, vector unsigned short);
14214 int vec_any_ge (vector signed short, vector signed short);
14215 int vec_any_ge (vector signed short, vector bool short);
14216 int vec_any_ge (vector bool short, vector unsigned short);
14217 int vec_any_ge (vector bool short, vector signed short);
14218 int vec_any_ge (vector signed int, vector bool int);
14219 int vec_any_ge (vector unsigned int, vector bool int);
14220 int vec_any_ge (vector unsigned int, vector unsigned int);
14221 int vec_any_ge (vector signed int, vector signed int);
14222 int vec_any_ge (vector bool int, vector unsigned int);
14223 int vec_any_ge (vector bool int, vector signed int);
14224 int vec_any_ge (vector float, vector float);
14226 int vec_any_gt (vector bool char, vector unsigned char);
14227 int vec_any_gt (vector unsigned char, vector bool char);
14228 int vec_any_gt (vector unsigned char, vector unsigned char);
14229 int vec_any_gt (vector bool char, vector signed char);
14230 int vec_any_gt (vector signed char, vector bool char);
14231 int vec_any_gt (vector signed char, vector signed char);
14232 int vec_any_gt (vector bool short, vector unsigned short);
14233 int vec_any_gt (vector unsigned short, vector bool short);
14234 int vec_any_gt (vector unsigned short, vector unsigned short);
14235 int vec_any_gt (vector bool short, vector signed short);
14236 int vec_any_gt (vector signed short, vector bool short);
14237 int vec_any_gt (vector signed short, vector signed short);
14238 int vec_any_gt (vector bool int, vector unsigned int);
14239 int vec_any_gt (vector unsigned int, vector bool int);
14240 int vec_any_gt (vector unsigned int, vector unsigned int);
14241 int vec_any_gt (vector bool int, vector signed int);
14242 int vec_any_gt (vector signed int, vector bool int);
14243 int vec_any_gt (vector signed int, vector signed int);
14244 int vec_any_gt (vector float, vector float);
14246 int vec_any_le (vector bool char, vector unsigned char);
14247 int vec_any_le (vector unsigned char, vector bool char);
14248 int vec_any_le (vector unsigned char, vector unsigned char);
14249 int vec_any_le (vector bool char, vector signed char);
14250 int vec_any_le (vector signed char, vector bool char);
14251 int vec_any_le (vector signed char, vector signed char);
14252 int vec_any_le (vector bool short, vector unsigned short);
14253 int vec_any_le (vector unsigned short, vector bool short);
14254 int vec_any_le (vector unsigned short, vector unsigned short);
14255 int vec_any_le (vector bool short, vector signed short);
14256 int vec_any_le (vector signed short, vector bool short);
14257 int vec_any_le (vector signed short, vector signed short);
14258 int vec_any_le (vector bool int, vector unsigned int);
14259 int vec_any_le (vector unsigned int, vector bool int);
14260 int vec_any_le (vector unsigned int, vector unsigned int);
14261 int vec_any_le (vector bool int, vector signed int);
14262 int vec_any_le (vector signed int, vector bool int);
14263 int vec_any_le (vector signed int, vector signed int);
14264 int vec_any_le (vector float, vector float);
14266 int vec_any_lt (vector bool char, vector unsigned char);
14267 int vec_any_lt (vector unsigned char, vector bool char);
14268 int vec_any_lt (vector unsigned char, vector unsigned char);
14269 int vec_any_lt (vector bool char, vector signed char);
14270 int vec_any_lt (vector signed char, vector bool char);
14271 int vec_any_lt (vector signed char, vector signed char);
14272 int vec_any_lt (vector bool short, vector unsigned short);
14273 int vec_any_lt (vector unsigned short, vector bool short);
14274 int vec_any_lt (vector unsigned short, vector unsigned short);
14275 int vec_any_lt (vector bool short, vector signed short);
14276 int vec_any_lt (vector signed short, vector bool short);
14277 int vec_any_lt (vector signed short, vector signed short);
14278 int vec_any_lt (vector bool int, vector unsigned int);
14279 int vec_any_lt (vector unsigned int, vector bool int);
14280 int vec_any_lt (vector unsigned int, vector unsigned int);
14281 int vec_any_lt (vector bool int, vector signed int);
14282 int vec_any_lt (vector signed int, vector bool int);
14283 int vec_any_lt (vector signed int, vector signed int);
14284 int vec_any_lt (vector float, vector float);
14286 int vec_any_nan (vector float);
14288 int vec_any_ne (vector signed char, vector bool char);
14289 int vec_any_ne (vector signed char, vector signed char);
14290 int vec_any_ne (vector unsigned char, vector bool char);
14291 int vec_any_ne (vector unsigned char, vector unsigned char);
14292 int vec_any_ne (vector bool char, vector bool char);
14293 int vec_any_ne (vector bool char, vector unsigned char);
14294 int vec_any_ne (vector bool char, vector signed char);
14295 int vec_any_ne (vector signed short, vector bool short);
14296 int vec_any_ne (vector signed short, vector signed short);
14297 int vec_any_ne (vector unsigned short, vector bool short);
14298 int vec_any_ne (vector unsigned short, vector unsigned short);
14299 int vec_any_ne (vector bool short, vector bool short);
14300 int vec_any_ne (vector bool short, vector unsigned short);
14301 int vec_any_ne (vector bool short, vector signed short);
14302 int vec_any_ne (vector pixel, vector pixel);
14303 int vec_any_ne (vector signed int, vector bool int);
14304 int vec_any_ne (vector signed int, vector signed int);
14305 int vec_any_ne (vector unsigned int, vector bool int);
14306 int vec_any_ne (vector unsigned int, vector unsigned int);
14307 int vec_any_ne (vector bool int, vector bool int);
14308 int vec_any_ne (vector bool int, vector unsigned int);
14309 int vec_any_ne (vector bool int, vector signed int);
14310 int vec_any_ne (vector float, vector float);
14312 int vec_any_nge (vector float, vector float);
14314 int vec_any_ngt (vector float, vector float);
14316 int vec_any_nle (vector float, vector float);
14318 int vec_any_nlt (vector float, vector float);
14320 int vec_any_numeric (vector float);
14322 int vec_any_out (vector float, vector float);
14325 If the vector/scalar (VSX) instruction set is available, the following
14326 additional functions are available:
14329 vector double vec_abs (vector double);
14330 vector double vec_add (vector double, vector double);
14331 vector double vec_and (vector double, vector double);
14332 vector double vec_and (vector double, vector bool long);
14333 vector double vec_and (vector bool long, vector double);
14334 vector long vec_and (vector long, vector long);
14335 vector long vec_and (vector long, vector bool long);
14336 vector long vec_and (vector bool long, vector long);
14337 vector unsigned long vec_and (vector unsigned long, vector unsigned long);
14338 vector unsigned long vec_and (vector unsigned long, vector bool long);
14339 vector unsigned long vec_and (vector bool long, vector unsigned long);
14340 vector double vec_andc (vector double, vector double);
14341 vector double vec_andc (vector double, vector bool long);
14342 vector double vec_andc (vector bool long, vector double);
14343 vector long vec_andc (vector long, vector long);
14344 vector long vec_andc (vector long, vector bool long);
14345 vector long vec_andc (vector bool long, vector long);
14346 vector unsigned long vec_andc (vector unsigned long, vector unsigned long);
14347 vector unsigned long vec_andc (vector unsigned long, vector bool long);
14348 vector unsigned long vec_andc (vector bool long, vector unsigned long);
14349 vector double vec_ceil (vector double);
14350 vector bool long vec_cmpeq (vector double, vector double);
14351 vector bool long vec_cmpge (vector double, vector double);
14352 vector bool long vec_cmpgt (vector double, vector double);
14353 vector bool long vec_cmple (vector double, vector double);
14354 vector bool long vec_cmplt (vector double, vector double);
14355 vector double vec_cpsgn (vector double, vector double);
14356 vector float vec_div (vector float, vector float);
14357 vector double vec_div (vector double, vector double);
14358 vector long vec_div (vector long, vector long);
14359 vector unsigned long vec_div (vector unsigned long, vector unsigned long);
14360 vector double vec_floor (vector double);
14361 vector double vec_ld (int, const vector double *);
14362 vector double vec_ld (int, const double *);
14363 vector double vec_ldl (int, const vector double *);
14364 vector double vec_ldl (int, const double *);
14365 vector unsigned char vec_lvsl (int, const volatile double *);
14366 vector unsigned char vec_lvsr (int, const volatile double *);
14367 vector double vec_madd (vector double, vector double, vector double);
14368 vector double vec_max (vector double, vector double);
14369 vector signed long vec_mergeh (vector signed long, vector signed long);
14370 vector signed long vec_mergeh (vector signed long, vector bool long);
14371 vector signed long vec_mergeh (vector bool long, vector signed long);
14372 vector unsigned long vec_mergeh (vector unsigned long, vector unsigned long);
14373 vector unsigned long vec_mergeh (vector unsigned long, vector bool long);
14374 vector unsigned long vec_mergeh (vector bool long, vector unsigned long);
14375 vector signed long vec_mergel (vector signed long, vector signed long);
14376 vector signed long vec_mergel (vector signed long, vector bool long);
14377 vector signed long vec_mergel (vector bool long, vector signed long);
14378 vector unsigned long vec_mergel (vector unsigned long, vector unsigned long);
14379 vector unsigned long vec_mergel (vector unsigned long, vector bool long);
14380 vector unsigned long vec_mergel (vector bool long, vector unsigned long);
14381 vector double vec_min (vector double, vector double);
14382 vector float vec_msub (vector float, vector float, vector float);
14383 vector double vec_msub (vector double, vector double, vector double);
14384 vector float vec_mul (vector float, vector float);
14385 vector double vec_mul (vector double, vector double);
14386 vector long vec_mul (vector long, vector long);
14387 vector unsigned long vec_mul (vector unsigned long, vector unsigned long);
14388 vector float vec_nearbyint (vector float);
14389 vector double vec_nearbyint (vector double);
14390 vector float vec_nmadd (vector float, vector float, vector float);
14391 vector double vec_nmadd (vector double, vector double, vector double);
14392 vector double vec_nmsub (vector double, vector double, vector double);
14393 vector double vec_nor (vector double, vector double);
14394 vector long vec_nor (vector long, vector long);
14395 vector long vec_nor (vector long, vector bool long);
14396 vector long vec_nor (vector bool long, vector long);
14397 vector unsigned long vec_nor (vector unsigned long, vector unsigned long);
14398 vector unsigned long vec_nor (vector unsigned long, vector bool long);
14399 vector unsigned long vec_nor (vector bool long, vector unsigned long);
14400 vector double vec_or (vector double, vector double);
14401 vector double vec_or (vector double, vector bool long);
14402 vector double vec_or (vector bool long, vector double);
14403 vector long vec_or (vector long, vector long);
14404 vector long vec_or (vector long, vector bool long);
14405 vector long vec_or (vector bool long, vector long);
14406 vector unsigned long vec_or (vector unsigned long, vector unsigned long);
14407 vector unsigned long vec_or (vector unsigned long, vector bool long);
14408 vector unsigned long vec_or (vector bool long, vector unsigned long);
14409 vector double vec_perm (vector double, vector double, vector unsigned char);
14410 vector long vec_perm (vector long, vector long, vector unsigned char);
14411 vector unsigned long vec_perm (vector unsigned long, vector unsigned long,
14412 vector unsigned char);
14413 vector double vec_rint (vector double);
14414 vector double vec_recip (vector double, vector double);
14415 vector double vec_rsqrt (vector double);
14416 vector double vec_rsqrte (vector double);
14417 vector double vec_sel (vector double, vector double, vector bool long);
14418 vector double vec_sel (vector double, vector double, vector unsigned long);
14419 vector long vec_sel (vector long, vector long, vector long);
14420 vector long vec_sel (vector long, vector long, vector unsigned long);
14421 vector long vec_sel (vector long, vector long, vector bool long);
14422 vector unsigned long vec_sel (vector unsigned long, vector unsigned long,
14424 vector unsigned long vec_sel (vector unsigned long, vector unsigned long,
14425 vector unsigned long);
14426 vector unsigned long vec_sel (vector unsigned long, vector unsigned long,
14428 vector double vec_splats (double);
14429 vector signed long vec_splats (signed long);
14430 vector unsigned long vec_splats (unsigned long);
14431 vector float vec_sqrt (vector float);
14432 vector double vec_sqrt (vector double);
14433 void vec_st (vector double, int, vector double *);
14434 void vec_st (vector double, int, double *);
14435 vector double vec_sub (vector double, vector double);
14436 vector double vec_trunc (vector double);
14437 vector double vec_xor (vector double, vector double);
14438 vector double vec_xor (vector double, vector bool long);
14439 vector double vec_xor (vector bool long, vector double);
14440 vector long vec_xor (vector long, vector long);
14441 vector long vec_xor (vector long, vector bool long);
14442 vector long vec_xor (vector bool long, vector long);
14443 vector unsigned long vec_xor (vector unsigned long, vector unsigned long);
14444 vector unsigned long vec_xor (vector unsigned long, vector bool long);
14445 vector unsigned long vec_xor (vector bool long, vector unsigned long);
14446 int vec_all_eq (vector double, vector double);
14447 int vec_all_ge (vector double, vector double);
14448 int vec_all_gt (vector double, vector double);
14449 int vec_all_le (vector double, vector double);
14450 int vec_all_lt (vector double, vector double);
14451 int vec_all_nan (vector double);
14452 int vec_all_ne (vector double, vector double);
14453 int vec_all_nge (vector double, vector double);
14454 int vec_all_ngt (vector double, vector double);
14455 int vec_all_nle (vector double, vector double);
14456 int vec_all_nlt (vector double, vector double);
14457 int vec_all_numeric (vector double);
14458 int vec_any_eq (vector double, vector double);
14459 int vec_any_ge (vector double, vector double);
14460 int vec_any_gt (vector double, vector double);
14461 int vec_any_le (vector double, vector double);
14462 int vec_any_lt (vector double, vector double);
14463 int vec_any_nan (vector double);
14464 int vec_any_ne (vector double, vector double);
14465 int vec_any_nge (vector double, vector double);
14466 int vec_any_ngt (vector double, vector double);
14467 int vec_any_nle (vector double, vector double);
14468 int vec_any_nlt (vector double, vector double);
14469 int vec_any_numeric (vector double);
14471 vector double vec_vsx_ld (int, const vector double *);
14472 vector double vec_vsx_ld (int, const double *);
14473 vector float vec_vsx_ld (int, const vector float *);
14474 vector float vec_vsx_ld (int, const float *);
14475 vector bool int vec_vsx_ld (int, const vector bool int *);
14476 vector signed int vec_vsx_ld (int, const vector signed int *);
14477 vector signed int vec_vsx_ld (int, const int *);
14478 vector signed int vec_vsx_ld (int, const long *);
14479 vector unsigned int vec_vsx_ld (int, const vector unsigned int *);
14480 vector unsigned int vec_vsx_ld (int, const unsigned int *);
14481 vector unsigned int vec_vsx_ld (int, const unsigned long *);
14482 vector bool short vec_vsx_ld (int, const vector bool short *);
14483 vector pixel vec_vsx_ld (int, const vector pixel *);
14484 vector signed short vec_vsx_ld (int, const vector signed short *);
14485 vector signed short vec_vsx_ld (int, const short *);
14486 vector unsigned short vec_vsx_ld (int, const vector unsigned short *);
14487 vector unsigned short vec_vsx_ld (int, const unsigned short *);
14488 vector bool char vec_vsx_ld (int, const vector bool char *);
14489 vector signed char vec_vsx_ld (int, const vector signed char *);
14490 vector signed char vec_vsx_ld (int, const signed char *);
14491 vector unsigned char vec_vsx_ld (int, const vector unsigned char *);
14492 vector unsigned char vec_vsx_ld (int, const unsigned char *);
14494 void vec_vsx_st (vector double, int, vector double *);
14495 void vec_vsx_st (vector double, int, double *);
14496 void vec_vsx_st (vector float, int, vector float *);
14497 void vec_vsx_st (vector float, int, float *);
14498 void vec_vsx_st (vector signed int, int, vector signed int *);
14499 void vec_vsx_st (vector signed int, int, int *);
14500 void vec_vsx_st (vector unsigned int, int, vector unsigned int *);
14501 void vec_vsx_st (vector unsigned int, int, unsigned int *);
14502 void vec_vsx_st (vector bool int, int, vector bool int *);
14503 void vec_vsx_st (vector bool int, int, unsigned int *);
14504 void vec_vsx_st (vector bool int, int, int *);
14505 void vec_vsx_st (vector signed short, int, vector signed short *);
14506 void vec_vsx_st (vector signed short, int, short *);
14507 void vec_vsx_st (vector unsigned short, int, vector unsigned short *);
14508 void vec_vsx_st (vector unsigned short, int, unsigned short *);
14509 void vec_vsx_st (vector bool short, int, vector bool short *);
14510 void vec_vsx_st (vector bool short, int, unsigned short *);
14511 void vec_vsx_st (vector pixel, int, vector pixel *);
14512 void vec_vsx_st (vector pixel, int, unsigned short *);
14513 void vec_vsx_st (vector pixel, int, short *);
14514 void vec_vsx_st (vector bool short, int, short *);
14515 void vec_vsx_st (vector signed char, int, vector signed char *);
14516 void vec_vsx_st (vector signed char, int, signed char *);
14517 void vec_vsx_st (vector unsigned char, int, vector unsigned char *);
14518 void vec_vsx_st (vector unsigned char, int, unsigned char *);
14519 void vec_vsx_st (vector bool char, int, vector bool char *);
14520 void vec_vsx_st (vector bool char, int, unsigned char *);
14521 void vec_vsx_st (vector bool char, int, signed char *);
14523 vector double vec_xxpermdi (vector double, vector double, int);
14524 vector float vec_xxpermdi (vector float, vector float, int);
14525 vector long long vec_xxpermdi (vector long long, vector long long, int);
14526 vector unsigned long long vec_xxpermdi (vector unsigned long long,
14527 vector unsigned long long, int);
14528 vector int vec_xxpermdi (vector int, vector int, int);
14529 vector unsigned int vec_xxpermdi (vector unsigned int,
14530 vector unsigned int, int);
14531 vector short vec_xxpermdi (vector short, vector short, int);
14532 vector unsigned short vec_xxpermdi (vector unsigned short,
14533 vector unsigned short, int);
14534 vector signed char vec_xxpermdi (vector signed char, vector signed char, int);
14535 vector unsigned char vec_xxpermdi (vector unsigned char,
14536 vector unsigned char, int);
14538 vector double vec_xxsldi (vector double, vector double, int);
14539 vector float vec_xxsldi (vector float, vector float, int);
14540 vector long long vec_xxsldi (vector long long, vector long long, int);
14541 vector unsigned long long vec_xxsldi (vector unsigned long long,
14542 vector unsigned long long, int);
14543 vector int vec_xxsldi (vector int, vector int, int);
14544 vector unsigned int vec_xxsldi (vector unsigned int, vector unsigned int, int);
14545 vector short vec_xxsldi (vector short, vector short, int);
14546 vector unsigned short vec_xxsldi (vector unsigned short,
14547 vector unsigned short, int);
14548 vector signed char vec_xxsldi (vector signed char, vector signed char, int);
14549 vector unsigned char vec_xxsldi (vector unsigned char,
14550 vector unsigned char, int);
14553 Note that the @samp{vec_ld} and @samp{vec_st} built-in functions always
14554 generate the AltiVec @samp{LVX} and @samp{STVX} instructions even
14555 if the VSX instruction set is available. The @samp{vec_vsx_ld} and
14556 @samp{vec_vsx_st} built-in functions always generate the VSX @samp{LXVD2X},
14557 @samp{LXVW4X}, @samp{STXVD2X}, and @samp{STXVW4X} instructions.
14559 If the ISA 2.07 additions to the vector/scalar (power8-vector)
14560 instruction set is available, the following additional functions are
14561 available for both 32-bit and 64-bit targets. For 64-bit targets, you
14562 can use @var{vector long} instead of @var{vector long long},
14563 @var{vector bool long} instead of @var{vector bool long long}, and
14564 @var{vector unsigned long} instead of @var{vector unsigned long long}.
14567 vector long long vec_abs (vector long long);
14569 vector long long vec_add (vector long long, vector long long);
14570 vector unsigned long long vec_add (vector unsigned long long,
14571 vector unsigned long long);
14573 int vec_all_eq (vector long long, vector long long);
14574 int vec_all_eq (vector unsigned long long, vector unsigned long long);
14575 int vec_all_ge (vector long long, vector long long);
14576 int vec_all_ge (vector unsigned long long, vector unsigned long long);
14577 int vec_all_gt (vector long long, vector long long);
14578 int vec_all_gt (vector unsigned long long, vector unsigned long long);
14579 int vec_all_le (vector long long, vector long long);
14580 int vec_all_le (vector unsigned long long, vector unsigned long long);
14581 int vec_all_lt (vector long long, vector long long);
14582 int vec_all_lt (vector unsigned long long, vector unsigned long long);
14583 int vec_all_ne (vector long long, vector long long);
14584 int vec_all_ne (vector unsigned long long, vector unsigned long long);
14586 int vec_any_eq (vector long long, vector long long);
14587 int vec_any_eq (vector unsigned long long, vector unsigned long long);
14588 int vec_any_ge (vector long long, vector long long);
14589 int vec_any_ge (vector unsigned long long, vector unsigned long long);
14590 int vec_any_gt (vector long long, vector long long);
14591 int vec_any_gt (vector unsigned long long, vector unsigned long long);
14592 int vec_any_le (vector long long, vector long long);
14593 int vec_any_le (vector unsigned long long, vector unsigned long long);
14594 int vec_any_lt (vector long long, vector long long);
14595 int vec_any_lt (vector unsigned long long, vector unsigned long long);
14596 int vec_any_ne (vector long long, vector long long);
14597 int vec_any_ne (vector unsigned long long, vector unsigned long long);
14599 vector long long vec_eqv (vector long long, vector long long);
14600 vector long long vec_eqv (vector bool long long, vector long long);
14601 vector long long vec_eqv (vector long long, vector bool long long);
14602 vector unsigned long long vec_eqv (vector unsigned long long,
14603 vector unsigned long long);
14604 vector unsigned long long vec_eqv (vector bool long long,
14605 vector unsigned long long);
14606 vector unsigned long long vec_eqv (vector unsigned long long,
14607 vector bool long long);
14608 vector int vec_eqv (vector int, vector int);
14609 vector int vec_eqv (vector bool int, vector int);
14610 vector int vec_eqv (vector int, vector bool int);
14611 vector unsigned int vec_eqv (vector unsigned int, vector unsigned int);
14612 vector unsigned int vec_eqv (vector bool unsigned int,
14613 vector unsigned int);
14614 vector unsigned int vec_eqv (vector unsigned int,
14615 vector bool unsigned int);
14616 vector short vec_eqv (vector short, vector short);
14617 vector short vec_eqv (vector bool short, vector short);
14618 vector short vec_eqv (vector short, vector bool short);
14619 vector unsigned short vec_eqv (vector unsigned short, vector unsigned short);
14620 vector unsigned short vec_eqv (vector bool unsigned short,
14621 vector unsigned short);
14622 vector unsigned short vec_eqv (vector unsigned short,
14623 vector bool unsigned short);
14624 vector signed char vec_eqv (vector signed char, vector signed char);
14625 vector signed char vec_eqv (vector bool signed char, vector signed char);
14626 vector signed char vec_eqv (vector signed char, vector bool signed char);
14627 vector unsigned char vec_eqv (vector unsigned char, vector unsigned char);
14628 vector unsigned char vec_eqv (vector bool unsigned char, vector unsigned char);
14629 vector unsigned char vec_eqv (vector unsigned char, vector bool unsigned char);
14631 vector long long vec_max (vector long long, vector long long);
14632 vector unsigned long long vec_max (vector unsigned long long,
14633 vector unsigned long long);
14635 vector signed int vec_mergee (vector signed int, vector signed int);
14636 vector unsigned int vec_mergee (vector unsigned int, vector unsigned int);
14637 vector bool int vec_mergee (vector bool int, vector bool int);
14639 vector signed int vec_mergeo (vector signed int, vector signed int);
14640 vector unsigned int vec_mergeo (vector unsigned int, vector unsigned int);
14641 vector bool int vec_mergeo (vector bool int, vector bool int);
14643 vector long long vec_min (vector long long, vector long long);
14644 vector unsigned long long vec_min (vector unsigned long long,
14645 vector unsigned long long);
14647 vector long long vec_nand (vector long long, vector long long);
14648 vector long long vec_nand (vector bool long long, vector long long);
14649 vector long long vec_nand (vector long long, vector bool long long);
14650 vector unsigned long long vec_nand (vector unsigned long long,
14651 vector unsigned long long);
14652 vector unsigned long long vec_nand (vector bool long long,
14653 vector unsigned long long);
14654 vector unsigned long long vec_nand (vector unsigned long long,
14655 vector bool long long);
14656 vector int vec_nand (vector int, vector int);
14657 vector int vec_nand (vector bool int, vector int);
14658 vector int vec_nand (vector int, vector bool int);
14659 vector unsigned int vec_nand (vector unsigned int, vector unsigned int);
14660 vector unsigned int vec_nand (vector bool unsigned int,
14661 vector unsigned int);
14662 vector unsigned int vec_nand (vector unsigned int,
14663 vector bool unsigned int);
14664 vector short vec_nand (vector short, vector short);
14665 vector short vec_nand (vector bool short, vector short);
14666 vector short vec_nand (vector short, vector bool short);
14667 vector unsigned short vec_nand (vector unsigned short, vector unsigned short);
14668 vector unsigned short vec_nand (vector bool unsigned short,
14669 vector unsigned short);
14670 vector unsigned short vec_nand (vector unsigned short,
14671 vector bool unsigned short);
14672 vector signed char vec_nand (vector signed char, vector signed char);
14673 vector signed char vec_nand (vector bool signed char, vector signed char);
14674 vector signed char vec_nand (vector signed char, vector bool signed char);
14675 vector unsigned char vec_nand (vector unsigned char, vector unsigned char);
14676 vector unsigned char vec_nand (vector bool unsigned char, vector unsigned char);
14677 vector unsigned char vec_nand (vector unsigned char, vector bool unsigned char);
14679 vector long long vec_orc (vector long long, vector long long);
14680 vector long long vec_orc (vector bool long long, vector long long);
14681 vector long long vec_orc (vector long long, vector bool long long);
14682 vector unsigned long long vec_orc (vector unsigned long long,
14683 vector unsigned long long);
14684 vector unsigned long long vec_orc (vector bool long long,
14685 vector unsigned long long);
14686 vector unsigned long long vec_orc (vector unsigned long long,
14687 vector bool long long);
14688 vector int vec_orc (vector int, vector int);
14689 vector int vec_orc (vector bool int, vector int);
14690 vector int vec_orc (vector int, vector bool int);
14691 vector unsigned int vec_orc (vector unsigned int, vector unsigned int);
14692 vector unsigned int vec_orc (vector bool unsigned int,
14693 vector unsigned int);
14694 vector unsigned int vec_orc (vector unsigned int,
14695 vector bool unsigned int);
14696 vector short vec_orc (vector short, vector short);
14697 vector short vec_orc (vector bool short, vector short);
14698 vector short vec_orc (vector short, vector bool short);
14699 vector unsigned short vec_orc (vector unsigned short, vector unsigned short);
14700 vector unsigned short vec_orc (vector bool unsigned short,
14701 vector unsigned short);
14702 vector unsigned short vec_orc (vector unsigned short,
14703 vector bool unsigned short);
14704 vector signed char vec_orc (vector signed char, vector signed char);
14705 vector signed char vec_orc (vector bool signed char, vector signed char);
14706 vector signed char vec_orc (vector signed char, vector bool signed char);
14707 vector unsigned char vec_orc (vector unsigned char, vector unsigned char);
14708 vector unsigned char vec_orc (vector bool unsigned char, vector unsigned char);
14709 vector unsigned char vec_orc (vector unsigned char, vector bool unsigned char);
14711 vector int vec_pack (vector long long, vector long long);
14712 vector unsigned int vec_pack (vector unsigned long long,
14713 vector unsigned long long);
14714 vector bool int vec_pack (vector bool long long, vector bool long long);
14716 vector int vec_packs (vector long long, vector long long);
14717 vector unsigned int vec_packs (vector unsigned long long,
14718 vector unsigned long long);
14720 vector unsigned int vec_packsu (vector long long, vector long long);
14721 vector unsigned int vec_packsu (vector unsigned long long,
14722 vector unsigned long long);
14724 vector long long vec_rl (vector long long,
14725 vector unsigned long long);
14726 vector long long vec_rl (vector unsigned long long,
14727 vector unsigned long long);
14729 vector long long vec_sl (vector long long, vector unsigned long long);
14730 vector long long vec_sl (vector unsigned long long,
14731 vector unsigned long long);
14733 vector long long vec_sr (vector long long, vector unsigned long long);
14734 vector unsigned long long char vec_sr (vector unsigned long long,
14735 vector unsigned long long);
14737 vector long long vec_sra (vector long long, vector unsigned long long);
14738 vector unsigned long long vec_sra (vector unsigned long long,
14739 vector unsigned long long);
14741 vector long long vec_sub (vector long long, vector long long);
14742 vector unsigned long long vec_sub (vector unsigned long long,
14743 vector unsigned long long);
14745 vector long long vec_unpackh (vector int);
14746 vector unsigned long long vec_unpackh (vector unsigned int);
14748 vector long long vec_unpackl (vector int);
14749 vector unsigned long long vec_unpackl (vector unsigned int);
14751 vector long long vec_vaddudm (vector long long, vector long long);
14752 vector long long vec_vaddudm (vector bool long long, vector long long);
14753 vector long long vec_vaddudm (vector long long, vector bool long long);
14754 vector unsigned long long vec_vaddudm (vector unsigned long long,
14755 vector unsigned long long);
14756 vector unsigned long long vec_vaddudm (vector bool unsigned long long,
14757 vector unsigned long long);
14758 vector unsigned long long vec_vaddudm (vector unsigned long long,
14759 vector bool unsigned long long);
14761 vector long long vec_vbpermq (vector signed char, vector signed char);
14762 vector long long vec_vbpermq (vector unsigned char, vector unsigned char);
14764 vector long long vec_cntlz (vector long long);
14765 vector unsigned long long vec_cntlz (vector unsigned long long);
14766 vector int vec_cntlz (vector int);
14767 vector unsigned int vec_cntlz (vector int);
14768 vector short vec_cntlz (vector short);
14769 vector unsigned short vec_cntlz (vector unsigned short);
14770 vector signed char vec_cntlz (vector signed char);
14771 vector unsigned char vec_cntlz (vector unsigned char);
14773 vector long long vec_vclz (vector long long);
14774 vector unsigned long long vec_vclz (vector unsigned long long);
14775 vector int vec_vclz (vector int);
14776 vector unsigned int vec_vclz (vector int);
14777 vector short vec_vclz (vector short);
14778 vector unsigned short vec_vclz (vector unsigned short);
14779 vector signed char vec_vclz (vector signed char);
14780 vector unsigned char vec_vclz (vector unsigned char);
14782 vector signed char vec_vclzb (vector signed char);
14783 vector unsigned char vec_vclzb (vector unsigned char);
14785 vector long long vec_vclzd (vector long long);
14786 vector unsigned long long vec_vclzd (vector unsigned long long);
14788 vector short vec_vclzh (vector short);
14789 vector unsigned short vec_vclzh (vector unsigned short);
14791 vector int vec_vclzw (vector int);
14792 vector unsigned int vec_vclzw (vector int);
14794 vector signed char vec_vgbbd (vector signed char);
14795 vector unsigned char vec_vgbbd (vector unsigned char);
14797 vector long long vec_vmaxsd (vector long long, vector long long);
14799 vector unsigned long long vec_vmaxud (vector unsigned long long,
14800 unsigned vector long long);
14802 vector long long vec_vminsd (vector long long, vector long long);
14804 vector unsigned long long vec_vminud (vector long long,
14807 vector int vec_vpksdss (vector long long, vector long long);
14808 vector unsigned int vec_vpksdss (vector long long, vector long long);
14810 vector unsigned int vec_vpkudus (vector unsigned long long,
14811 vector unsigned long long);
14813 vector int vec_vpkudum (vector long long, vector long long);
14814 vector unsigned int vec_vpkudum (vector unsigned long long,
14815 vector unsigned long long);
14816 vector bool int vec_vpkudum (vector bool long long, vector bool long long);
14818 vector long long vec_vpopcnt (vector long long);
14819 vector unsigned long long vec_vpopcnt (vector unsigned long long);
14820 vector int vec_vpopcnt (vector int);
14821 vector unsigned int vec_vpopcnt (vector int);
14822 vector short vec_vpopcnt (vector short);
14823 vector unsigned short vec_vpopcnt (vector unsigned short);
14824 vector signed char vec_vpopcnt (vector signed char);
14825 vector unsigned char vec_vpopcnt (vector unsigned char);
14827 vector signed char vec_vpopcntb (vector signed char);
14828 vector unsigned char vec_vpopcntb (vector unsigned char);
14830 vector long long vec_vpopcntd (vector long long);
14831 vector unsigned long long vec_vpopcntd (vector unsigned long long);
14833 vector short vec_vpopcnth (vector short);
14834 vector unsigned short vec_vpopcnth (vector unsigned short);
14836 vector int vec_vpopcntw (vector int);
14837 vector unsigned int vec_vpopcntw (vector int);
14839 vector long long vec_vrld (vector long long, vector unsigned long long);
14840 vector unsigned long long vec_vrld (vector unsigned long long,
14841 vector unsigned long long);
14843 vector long long vec_vsld (vector long long, vector unsigned long long);
14844 vector long long vec_vsld (vector unsigned long long,
14845 vector unsigned long long);
14847 vector long long vec_vsrad (vector long long, vector unsigned long long);
14848 vector unsigned long long vec_vsrad (vector unsigned long long,
14849 vector unsigned long long);
14851 vector long long vec_vsrd (vector long long, vector unsigned long long);
14852 vector unsigned long long char vec_vsrd (vector unsigned long long,
14853 vector unsigned long long);
14855 vector long long vec_vsubudm (vector long long, vector long long);
14856 vector long long vec_vsubudm (vector bool long long, vector long long);
14857 vector long long vec_vsubudm (vector long long, vector bool long long);
14858 vector unsigned long long vec_vsubudm (vector unsigned long long,
14859 vector unsigned long long);
14860 vector unsigned long long vec_vsubudm (vector bool long long,
14861 vector unsigned long long);
14862 vector unsigned long long vec_vsubudm (vector unsigned long long,
14863 vector bool long long);
14865 vector long long vec_vupkhsw (vector int);
14866 vector unsigned long long vec_vupkhsw (vector unsigned int);
14868 vector long long vec_vupklsw (vector int);
14869 vector unsigned long long vec_vupklsw (vector int);
14872 If the ISA 2.07 additions to the vector/scalar (power8-vector)
14873 instruction set is available, the following additional functions are
14874 available for 64-bit targets. New vector types
14875 (@var{vector __int128_t} and @var{vector __uint128_t}) are available
14876 to hold the @var{__int128_t} and @var{__uint128_t} types to use these
14879 The normal vector extract, and set operations work on
14880 @var{vector __int128_t} and @var{vector __uint128_t} types,
14881 but the index value must be 0.
14884 vector __int128_t vec_vaddcuq (vector __int128_t, vector __int128_t);
14885 vector __uint128_t vec_vaddcuq (vector __uint128_t, vector __uint128_t);
14887 vector __int128_t vec_vadduqm (vector __int128_t, vector __int128_t);
14888 vector __uint128_t vec_vadduqm (vector __uint128_t, vector __uint128_t);
14890 vector __int128_t vec_vaddecuq (vector __int128_t, vector __int128_t,
14891 vector __int128_t);
14892 vector __uint128_t vec_vaddecuq (vector __uint128_t, vector __uint128_t,
14893 vector __uint128_t);
14895 vector __int128_t vec_vaddeuqm (vector __int128_t, vector __int128_t,
14896 vector __int128_t);
14897 vector __uint128_t vec_vaddeuqm (vector __uint128_t, vector __uint128_t,
14898 vector __uint128_t);
14900 vector __int128_t vec_vsubecuq (vector __int128_t, vector __int128_t,
14901 vector __int128_t);
14902 vector __uint128_t vec_vsubecuq (vector __uint128_t, vector __uint128_t,
14903 vector __uint128_t);
14905 vector __int128_t vec_vsubeuqm (vector __int128_t, vector __int128_t,
14906 vector __int128_t);
14907 vector __uint128_t vec_vsubeuqm (vector __uint128_t, vector __uint128_t,
14908 vector __uint128_t);
14910 vector __int128_t vec_vsubcuq (vector __int128_t, vector __int128_t);
14911 vector __uint128_t vec_vsubcuq (vector __uint128_t, vector __uint128_t);
14913 __int128_t vec_vsubuqm (__int128_t, __int128_t);
14914 __uint128_t vec_vsubuqm (__uint128_t, __uint128_t);
14916 vector __int128_t __builtin_bcdadd (vector __int128_t, vector__int128_t);
14917 int __builtin_bcdadd_lt (vector __int128_t, vector__int128_t);
14918 int __builtin_bcdadd_eq (vector __int128_t, vector__int128_t);
14919 int __builtin_bcdadd_gt (vector __int128_t, vector__int128_t);
14920 int __builtin_bcdadd_ov (vector __int128_t, vector__int128_t);
14921 vector __int128_t bcdsub (vector __int128_t, vector__int128_t);
14922 int __builtin_bcdsub_lt (vector __int128_t, vector__int128_t);
14923 int __builtin_bcdsub_eq (vector __int128_t, vector__int128_t);
14924 int __builtin_bcdsub_gt (vector __int128_t, vector__int128_t);
14925 int __builtin_bcdsub_ov (vector __int128_t, vector__int128_t);
14928 If the cryptographic instructions are enabled (@option{-mcrypto} or
14929 @option{-mcpu=power8}), the following builtins are enabled.
14932 vector unsigned long long __builtin_crypto_vsbox (vector unsigned long long);
14934 vector unsigned long long __builtin_crypto_vcipher (vector unsigned long long,
14935 vector unsigned long long);
14937 vector unsigned long long __builtin_crypto_vcipherlast
14938 (vector unsigned long long,
14939 vector unsigned long long);
14941 vector unsigned long long __builtin_crypto_vncipher (vector unsigned long long,
14942 vector unsigned long long);
14944 vector unsigned long long __builtin_crypto_vncipherlast
14945 (vector unsigned long long,
14946 vector unsigned long long);
14948 vector unsigned char __builtin_crypto_vpermxor (vector unsigned char,
14949 vector unsigned char,
14950 vector unsigned char);
14952 vector unsigned short __builtin_crypto_vpermxor (vector unsigned short,
14953 vector unsigned short,
14954 vector unsigned short);
14956 vector unsigned int __builtin_crypto_vpermxor (vector unsigned int,
14957 vector unsigned int,
14958 vector unsigned int);
14960 vector unsigned long long __builtin_crypto_vpermxor (vector unsigned long long,
14961 vector unsigned long long,
14962 vector unsigned long long);
14964 vector unsigned char __builtin_crypto_vpmsumb (vector unsigned char,
14965 vector unsigned char);
14967 vector unsigned short __builtin_crypto_vpmsumb (vector unsigned short,
14968 vector unsigned short);
14970 vector unsigned int __builtin_crypto_vpmsumb (vector unsigned int,
14971 vector unsigned int);
14973 vector unsigned long long __builtin_crypto_vpmsumb (vector unsigned long long,
14974 vector unsigned long long);
14976 vector unsigned long long __builtin_crypto_vshasigmad
14977 (vector unsigned long long, int, int);
14979 vector unsigned int __builtin_crypto_vshasigmaw (vector unsigned int,
14983 The second argument to the @var{__builtin_crypto_vshasigmad} and
14984 @var{__builtin_crypto_vshasigmaw} builtin functions must be a constant
14985 integer that is 0 or 1. The third argument to these builtin functions
14986 must be a constant integer in the range of 0 to 15.
14988 @node PowerPC Hardware Transactional Memory Built-in Functions
14989 @subsection PowerPC Hardware Transactional Memory Built-in Functions
14990 GCC provides two interfaces for accessing the Hardware Transactional
14991 Memory (HTM) instructions available on some of the PowerPC family
14992 of processors (eg, POWER8). The two interfaces come in a low level
14993 interface, consisting of built-in functions specific to PowerPC and a
14994 higher level interface consisting of inline functions that are common
14995 between PowerPC and S/390.
14997 @subsubsection PowerPC HTM Low Level Built-in Functions
14999 The following low level built-in functions are available with
15000 @option{-mhtm} or @option{-mcpu=CPU} where CPU is `power8' or later.
15001 They all generate the machine instruction that is part of the name.
15003 The HTM built-ins return true or false depending on their success and
15004 their arguments match exactly the type and order of the associated
15005 hardware instruction's operands. Refer to the ISA manual for a
15006 description of each instruction's operands.
15009 unsigned int __builtin_tbegin (unsigned int)
15010 unsigned int __builtin_tend (unsigned int)
15012 unsigned int __builtin_tabort (unsigned int)
15013 unsigned int __builtin_tabortdc (unsigned int, unsigned int, unsigned int)
15014 unsigned int __builtin_tabortdci (unsigned int, unsigned int, int)
15015 unsigned int __builtin_tabortwc (unsigned int, unsigned int, unsigned int)
15016 unsigned int __builtin_tabortwci (unsigned int, unsigned int, int)
15018 unsigned int __builtin_tcheck (unsigned int)
15019 unsigned int __builtin_treclaim (unsigned int)
15020 unsigned int __builtin_trechkpt (void)
15021 unsigned int __builtin_tsr (unsigned int)
15024 In addition to the above HTM built-ins, we have added built-ins for
15025 some common extended mnemonics of the HTM instructions:
15028 unsigned int __builtin_tendall (void)
15029 unsigned int __builtin_tresume (void)
15030 unsigned int __builtin_tsuspend (void)
15033 The following set of built-in functions are available to gain access
15034 to the HTM specific special purpose registers.
15037 unsigned long __builtin_get_texasr (void)
15038 unsigned long __builtin_get_texasru (void)
15039 unsigned long __builtin_get_tfhar (void)
15040 unsigned long __builtin_get_tfiar (void)
15042 void __builtin_set_texasr (unsigned long);
15043 void __builtin_set_texasru (unsigned long);
15044 void __builtin_set_tfhar (unsigned long);
15045 void __builtin_set_tfiar (unsigned long);
15048 Example usage of these low level built-in functions may look like:
15051 #include <htmintrin.h>
15053 int num_retries = 10;
15057 if (__builtin_tbegin (0))
15059 /* Transaction State Initiated. */
15060 if (is_locked (lock))
15061 __builtin_tabort (0);
15062 ... transaction code...
15063 __builtin_tend (0);
15068 /* Transaction State Failed. Use locks if the transaction
15069 failure is "persistent" or we've tried too many times. */
15070 if (num_retries-- <= 0
15071 || _TEXASRU_FAILURE_PERSISTENT (__builtin_get_texasru ()))
15073 acquire_lock (lock);
15074 ... non transactional fallback path...
15075 release_lock (lock);
15082 One final built-in function has been added that returns the value of
15083 the 2-bit Transaction State field of the Machine Status Register (MSR)
15084 as stored in @code{CR0}.
15087 unsigned long __builtin_ttest (void)
15090 This built-in can be used to determine the current transaction state
15091 using the following code example:
15094 #include <htmintrin.h>
15096 unsigned char tx_state = _HTM_STATE (__builtin_ttest ());
15098 if (tx_state == _HTM_TRANSACTIONAL)
15100 /* Code to use in transactional state. */
15102 else if (tx_state == _HTM_NONTRANSACTIONAL)
15104 /* Code to use in non-transactional state. */
15106 else if (tx_state == _HTM_SUSPENDED)
15108 /* Code to use in transaction suspended state. */
15112 @subsubsection PowerPC HTM High Level Inline Functions
15114 The following high level HTM interface is made available by including
15115 @code{<htmxlintrin.h>} and using @option{-mhtm} or @option{-mcpu=CPU}
15116 where CPU is `power8' or later. This interface is common between PowerPC
15117 and S/390, allowing users to write one HTM source implementation that
15118 can be compiled and executed on either system.
15121 long __TM_simple_begin (void)
15122 long __TM_begin (void* const TM_buff)
15123 long __TM_end (void)
15124 void __TM_abort (void)
15125 void __TM_named_abort (unsigned char const code)
15126 void __TM_resume (void)
15127 void __TM_suspend (void)
15129 long __TM_is_user_abort (void* const TM_buff)
15130 long __TM_is_named_user_abort (void* const TM_buff, unsigned char *code)
15131 long __TM_is_illegal (void* const TM_buff)
15132 long __TM_is_footprint_exceeded (void* const TM_buff)
15133 long __TM_nesting_depth (void* const TM_buff)
15134 long __TM_is_nested_too_deep(void* const TM_buff)
15135 long __TM_is_conflict(void* const TM_buff)
15136 long __TM_is_failure_persistent(void* const TM_buff)
15137 long __TM_failure_address(void* const TM_buff)
15138 long long __TM_failure_code(void* const TM_buff)
15141 Using these common set of HTM inline functions, we can create
15142 a more portable version of the HTM example in the previous
15143 section that will work on either PowerPC or S/390:
15146 #include <htmxlintrin.h>
15148 int num_retries = 10;
15149 TM_buff_type TM_buff;
15153 if (__TM_begin (TM_buff))
15155 /* Transaction State Initiated. */
15156 if (is_locked (lock))
15158 ... transaction code...
15164 /* Transaction State Failed. Use locks if the transaction
15165 failure is "persistent" or we've tried too many times. */
15166 if (num_retries-- <= 0
15167 || __TM_is_failure_persistent (TM_buff))
15169 acquire_lock (lock);
15170 ... non transactional fallback path...
15171 release_lock (lock);
15178 @node RX Built-in Functions
15179 @subsection RX Built-in Functions
15180 GCC supports some of the RX instructions which cannot be expressed in
15181 the C programming language via the use of built-in functions. The
15182 following functions are supported:
15184 @deftypefn {Built-in Function} void __builtin_rx_brk (void)
15185 Generates the @code{brk} machine instruction.
15188 @deftypefn {Built-in Function} void __builtin_rx_clrpsw (int)
15189 Generates the @code{clrpsw} machine instruction to clear the specified
15190 bit in the processor status word.
15193 @deftypefn {Built-in Function} void __builtin_rx_int (int)
15194 Generates the @code{int} machine instruction to generate an interrupt
15195 with the specified value.
15198 @deftypefn {Built-in Function} void __builtin_rx_machi (int, int)
15199 Generates the @code{machi} machine instruction to add the result of
15200 multiplying the top 16 bits of the two arguments into the
15204 @deftypefn {Built-in Function} void __builtin_rx_maclo (int, int)
15205 Generates the @code{maclo} machine instruction to add the result of
15206 multiplying the bottom 16 bits of the two arguments into the
15210 @deftypefn {Built-in Function} void __builtin_rx_mulhi (int, int)
15211 Generates the @code{mulhi} machine instruction to place the result of
15212 multiplying the top 16 bits of the two arguments into the
15216 @deftypefn {Built-in Function} void __builtin_rx_mullo (int, int)
15217 Generates the @code{mullo} machine instruction to place the result of
15218 multiplying the bottom 16 bits of the two arguments into the
15222 @deftypefn {Built-in Function} int __builtin_rx_mvfachi (void)
15223 Generates the @code{mvfachi} machine instruction to read the top
15224 32 bits of the accumulator.
15227 @deftypefn {Built-in Function} int __builtin_rx_mvfacmi (void)
15228 Generates the @code{mvfacmi} machine instruction to read the middle
15229 32 bits of the accumulator.
15232 @deftypefn {Built-in Function} int __builtin_rx_mvfc (int)
15233 Generates the @code{mvfc} machine instruction which reads the control
15234 register specified in its argument and returns its value.
15237 @deftypefn {Built-in Function} void __builtin_rx_mvtachi (int)
15238 Generates the @code{mvtachi} machine instruction to set the top
15239 32 bits of the accumulator.
15242 @deftypefn {Built-in Function} void __builtin_rx_mvtaclo (int)
15243 Generates the @code{mvtaclo} machine instruction to set the bottom
15244 32 bits of the accumulator.
15247 @deftypefn {Built-in Function} void __builtin_rx_mvtc (int reg, int val)
15248 Generates the @code{mvtc} machine instruction which sets control
15249 register number @code{reg} to @code{val}.
15252 @deftypefn {Built-in Function} void __builtin_rx_mvtipl (int)
15253 Generates the @code{mvtipl} machine instruction set the interrupt
15257 @deftypefn {Built-in Function} void __builtin_rx_racw (int)
15258 Generates the @code{racw} machine instruction to round the accumulator
15259 according to the specified mode.
15262 @deftypefn {Built-in Function} int __builtin_rx_revw (int)
15263 Generates the @code{revw} machine instruction which swaps the bytes in
15264 the argument so that bits 0--7 now occupy bits 8--15 and vice versa,
15265 and also bits 16--23 occupy bits 24--31 and vice versa.
15268 @deftypefn {Built-in Function} void __builtin_rx_rmpa (void)
15269 Generates the @code{rmpa} machine instruction which initiates a
15270 repeated multiply and accumulate sequence.
15273 @deftypefn {Built-in Function} void __builtin_rx_round (float)
15274 Generates the @code{round} machine instruction which returns the
15275 floating-point argument rounded according to the current rounding mode
15276 set in the floating-point status word register.
15279 @deftypefn {Built-in Function} int __builtin_rx_sat (int)
15280 Generates the @code{sat} machine instruction which returns the
15281 saturated value of the argument.
15284 @deftypefn {Built-in Function} void __builtin_rx_setpsw (int)
15285 Generates the @code{setpsw} machine instruction to set the specified
15286 bit in the processor status word.
15289 @deftypefn {Built-in Function} void __builtin_rx_wait (void)
15290 Generates the @code{wait} machine instruction.
15293 @node S/390 System z Built-in Functions
15294 @subsection S/390 System z Built-in Functions
15295 @deftypefn {Built-in Function} int __builtin_tbegin (void*)
15296 Generates the @code{tbegin} machine instruction starting a
15297 non-constraint hardware transaction. If the parameter is non-NULL the
15298 memory area is used to store the transaction diagnostic buffer and
15299 will be passed as first operand to @code{tbegin}. This buffer can be
15300 defined using the @code{struct __htm_tdb} C struct defined in
15301 @code{htmintrin.h} and must reside on a double-word boundary. The
15302 second tbegin operand is set to @code{0xff0c}. This enables
15303 save/restore of all GPRs and disables aborts for FPR and AR
15304 manipulations inside the transaction body. The condition code set by
15305 the tbegin instruction is returned as integer value. The tbegin
15306 instruction by definition overwrites the content of all FPRs. The
15307 compiler will generate code which saves and restores the FPRs. For
15308 soft-float code it is recommended to used the @code{*_nofloat}
15309 variant. In order to prevent a TDB from being written it is required
15310 to pass an constant zero value as parameter. Passing the zero value
15311 through a variable is not sufficient. Although modifications of
15312 access registers inside the transaction will not trigger an
15313 transaction abort it is not supported to actually modify them. Access
15314 registers do not get saved when entering a transaction. They will have
15315 undefined state when reaching the abort code.
15318 Macros for the possible return codes of tbegin are defined in the
15319 @code{htmintrin.h} header file:
15322 @item _HTM_TBEGIN_STARTED
15323 @code{tbegin} has been executed as part of normal processing. The
15324 transaction body is supposed to be executed.
15325 @item _HTM_TBEGIN_INDETERMINATE
15326 The transaction was aborted due to an indeterminate condition which
15327 might be persistent.
15328 @item _HTM_TBEGIN_TRANSIENT
15329 The transaction aborted due to a transient failure. The transaction
15330 should be re-executed in that case.
15331 @item _HTM_TBEGIN_PERSISTENT
15332 The transaction aborted due to a persistent failure. Re-execution
15333 under same circumstances will not be productive.
15336 @defmac _HTM_FIRST_USER_ABORT_CODE
15337 The @code{_HTM_FIRST_USER_ABORT_CODE} defined in @code{htmintrin.h}
15338 specifies the first abort code which can be used for
15339 @code{__builtin_tabort}. Values below this threshold are reserved for
15343 @deftp {Data type} {struct __htm_tdb}
15344 The @code{struct __htm_tdb} defined in @code{htmintrin.h} describes
15345 the structure of the transaction diagnostic block as specified in the
15346 Principles of Operation manual chapter 5-91.
15349 @deftypefn {Built-in Function} int __builtin_tbegin_nofloat (void*)
15350 Same as @code{__builtin_tbegin} but without FPR saves and restores.
15351 Using this variant in code making use of FPRs will leave the FPRs in
15352 undefined state when entering the transaction abort handler code.
15355 @deftypefn {Built-in Function} int __builtin_tbegin_retry (void*, int)
15356 In addition to @code{__builtin_tbegin} a loop for transient failures
15357 is generated. If tbegin returns a condition code of 2 the transaction
15358 will be retried as often as specified in the second argument. The
15359 perform processor assist instruction is used to tell the CPU about the
15360 number of fails so far.
15363 @deftypefn {Built-in Function} int __builtin_tbegin_retry_nofloat (void*, int)
15364 Same as @code{__builtin_tbegin_retry} but without FPR saves and
15365 restores. Using this variant in code making use of FPRs will leave
15366 the FPRs in undefined state when entering the transaction abort
15370 @deftypefn {Built-in Function} void __builtin_tbeginc (void)
15371 Generates the @code{tbeginc} machine instruction starting a constraint
15372 hardware transaction. The second operand is set to @code{0xff08}.
15375 @deftypefn {Built-in Function} int __builtin_tend (void)
15376 Generates the @code{tend} machine instruction finishing a transaction
15377 and making the changes visible to other threads. The condition code
15378 generated by tend is returned as integer value.
15381 @deftypefn {Built-in Function} void __builtin_tabort (int)
15382 Generates the @code{tabort} machine instruction with the specified
15383 abort code. Abort codes from 0 through 255 are reserved and will
15384 result in an error message.
15387 @deftypefn {Built-in Function} void __builtin_tx_assist (int)
15388 Generates the @code{ppa rX,rY,1} machine instruction. Where the
15389 integer parameter is loaded into rX and a value of zero is loaded into
15390 rY. The integer parameter specifies the number of times the
15391 transaction repeatedly aborted.
15394 @deftypefn {Built-in Function} int __builtin_tx_nesting_depth (void)
15395 Generates the @code{etnd} machine instruction. The current nesting
15396 depth is returned as integer value. For a nesting depth of 0 the code
15397 is not executed as part of an transaction.
15400 @deftypefn {Built-in Function} void __builtin_non_tx_store (uint64_t *, uint64_t)
15402 Generates the @code{ntstg} machine instruction. The second argument
15403 is written to the first arguments location. The store operation will
15404 not be rolled-back in case of an transaction abort.
15407 @node SH Built-in Functions
15408 @subsection SH Built-in Functions
15409 The following built-in functions are supported on the SH1, SH2, SH3 and SH4
15410 families of processors:
15412 @deftypefn {Built-in Function} {void} __builtin_set_thread_pointer (void *@var{ptr})
15413 Sets the @samp{GBR} register to the specified value @var{ptr}. This is usually
15414 used by system code that manages threads and execution contexts. The compiler
15415 normally does not generate code that modifies the contents of @samp{GBR} and
15416 thus the value is preserved across function calls. Changing the @samp{GBR}
15417 value in user code must be done with caution, since the compiler might use
15418 @samp{GBR} in order to access thread local variables.
15422 @deftypefn {Built-in Function} {void *} __builtin_thread_pointer (void)
15423 Returns the value that is currently set in the @samp{GBR} register.
15424 Memory loads and stores that use the thread pointer as a base address are
15425 turned into @samp{GBR} based displacement loads and stores, if possible.
15433 int get_tcb_value (void)
15435 // Generate @samp{mov.l @@(8,gbr),r0} instruction
15436 return ((my_tcb*)__builtin_thread_pointer ())->c;
15442 @deftypefn {Built-in Function} {unsigned int} __builtin_sh_get_fpscr (void)
15443 Returns the value that is currently set in the @samp{FPSCR} register.
15446 @deftypefn {Built-in Function} {void} __builtin_sh_set_fpscr (unsigned int @var{val})
15447 Sets the @samp{FPSCR} register to the specified value @var{val}, while
15448 preserving the current values of the FR, SZ and PR bits.
15451 @node SPARC VIS Built-in Functions
15452 @subsection SPARC VIS Built-in Functions
15454 GCC supports SIMD operations on the SPARC using both the generic vector
15455 extensions (@pxref{Vector Extensions}) as well as built-in functions for
15456 the SPARC Visual Instruction Set (VIS). When you use the @option{-mvis}
15457 switch, the VIS extension is exposed as the following built-in functions:
15460 typedef int v1si __attribute__ ((vector_size (4)));
15461 typedef int v2si __attribute__ ((vector_size (8)));
15462 typedef short v4hi __attribute__ ((vector_size (8)));
15463 typedef short v2hi __attribute__ ((vector_size (4)));
15464 typedef unsigned char v8qi __attribute__ ((vector_size (8)));
15465 typedef unsigned char v4qi __attribute__ ((vector_size (4)));
15467 void __builtin_vis_write_gsr (int64_t);
15468 int64_t __builtin_vis_read_gsr (void);
15470 void * __builtin_vis_alignaddr (void *, long);
15471 void * __builtin_vis_alignaddrl (void *, long);
15472 int64_t __builtin_vis_faligndatadi (int64_t, int64_t);
15473 v2si __builtin_vis_faligndatav2si (v2si, v2si);
15474 v4hi __builtin_vis_faligndatav4hi (v4si, v4si);
15475 v8qi __builtin_vis_faligndatav8qi (v8qi, v8qi);
15477 v4hi __builtin_vis_fexpand (v4qi);
15479 v4hi __builtin_vis_fmul8x16 (v4qi, v4hi);
15480 v4hi __builtin_vis_fmul8x16au (v4qi, v2hi);
15481 v4hi __builtin_vis_fmul8x16al (v4qi, v2hi);
15482 v4hi __builtin_vis_fmul8sux16 (v8qi, v4hi);
15483 v4hi __builtin_vis_fmul8ulx16 (v8qi, v4hi);
15484 v2si __builtin_vis_fmuld8sux16 (v4qi, v2hi);
15485 v2si __builtin_vis_fmuld8ulx16 (v4qi, v2hi);
15487 v4qi __builtin_vis_fpack16 (v4hi);
15488 v8qi __builtin_vis_fpack32 (v2si, v8qi);
15489 v2hi __builtin_vis_fpackfix (v2si);
15490 v8qi __builtin_vis_fpmerge (v4qi, v4qi);
15492 int64_t __builtin_vis_pdist (v8qi, v8qi, int64_t);
15494 long __builtin_vis_edge8 (void *, void *);
15495 long __builtin_vis_edge8l (void *, void *);
15496 long __builtin_vis_edge16 (void *, void *);
15497 long __builtin_vis_edge16l (void *, void *);
15498 long __builtin_vis_edge32 (void *, void *);
15499 long __builtin_vis_edge32l (void *, void *);
15501 long __builtin_vis_fcmple16 (v4hi, v4hi);
15502 long __builtin_vis_fcmple32 (v2si, v2si);
15503 long __builtin_vis_fcmpne16 (v4hi, v4hi);
15504 long __builtin_vis_fcmpne32 (v2si, v2si);
15505 long __builtin_vis_fcmpgt16 (v4hi, v4hi);
15506 long __builtin_vis_fcmpgt32 (v2si, v2si);
15507 long __builtin_vis_fcmpeq16 (v4hi, v4hi);
15508 long __builtin_vis_fcmpeq32 (v2si, v2si);
15510 v4hi __builtin_vis_fpadd16 (v4hi, v4hi);
15511 v2hi __builtin_vis_fpadd16s (v2hi, v2hi);
15512 v2si __builtin_vis_fpadd32 (v2si, v2si);
15513 v1si __builtin_vis_fpadd32s (v1si, v1si);
15514 v4hi __builtin_vis_fpsub16 (v4hi, v4hi);
15515 v2hi __builtin_vis_fpsub16s (v2hi, v2hi);
15516 v2si __builtin_vis_fpsub32 (v2si, v2si);
15517 v1si __builtin_vis_fpsub32s (v1si, v1si);
15519 long __builtin_vis_array8 (long, long);
15520 long __builtin_vis_array16 (long, long);
15521 long __builtin_vis_array32 (long, long);
15524 When you use the @option{-mvis2} switch, the VIS version 2.0 built-in
15525 functions also become available:
15528 long __builtin_vis_bmask (long, long);
15529 int64_t __builtin_vis_bshuffledi (int64_t, int64_t);
15530 v2si __builtin_vis_bshufflev2si (v2si, v2si);
15531 v4hi __builtin_vis_bshufflev2si (v4hi, v4hi);
15532 v8qi __builtin_vis_bshufflev2si (v8qi, v8qi);
15534 long __builtin_vis_edge8n (void *, void *);
15535 long __builtin_vis_edge8ln (void *, void *);
15536 long __builtin_vis_edge16n (void *, void *);
15537 long __builtin_vis_edge16ln (void *, void *);
15538 long __builtin_vis_edge32n (void *, void *);
15539 long __builtin_vis_edge32ln (void *, void *);
15542 When you use the @option{-mvis3} switch, the VIS version 3.0 built-in
15543 functions also become available:
15546 void __builtin_vis_cmask8 (long);
15547 void __builtin_vis_cmask16 (long);
15548 void __builtin_vis_cmask32 (long);
15550 v4hi __builtin_vis_fchksm16 (v4hi, v4hi);
15552 v4hi __builtin_vis_fsll16 (v4hi, v4hi);
15553 v4hi __builtin_vis_fslas16 (v4hi, v4hi);
15554 v4hi __builtin_vis_fsrl16 (v4hi, v4hi);
15555 v4hi __builtin_vis_fsra16 (v4hi, v4hi);
15556 v2si __builtin_vis_fsll16 (v2si, v2si);
15557 v2si __builtin_vis_fslas16 (v2si, v2si);
15558 v2si __builtin_vis_fsrl16 (v2si, v2si);
15559 v2si __builtin_vis_fsra16 (v2si, v2si);
15561 long __builtin_vis_pdistn (v8qi, v8qi);
15563 v4hi __builtin_vis_fmean16 (v4hi, v4hi);
15565 int64_t __builtin_vis_fpadd64 (int64_t, int64_t);
15566 int64_t __builtin_vis_fpsub64 (int64_t, int64_t);
15568 v4hi __builtin_vis_fpadds16 (v4hi, v4hi);
15569 v2hi __builtin_vis_fpadds16s (v2hi, v2hi);
15570 v4hi __builtin_vis_fpsubs16 (v4hi, v4hi);
15571 v2hi __builtin_vis_fpsubs16s (v2hi, v2hi);
15572 v2si __builtin_vis_fpadds32 (v2si, v2si);
15573 v1si __builtin_vis_fpadds32s (v1si, v1si);
15574 v2si __builtin_vis_fpsubs32 (v2si, v2si);
15575 v1si __builtin_vis_fpsubs32s (v1si, v1si);
15577 long __builtin_vis_fucmple8 (v8qi, v8qi);
15578 long __builtin_vis_fucmpne8 (v8qi, v8qi);
15579 long __builtin_vis_fucmpgt8 (v8qi, v8qi);
15580 long __builtin_vis_fucmpeq8 (v8qi, v8qi);
15582 float __builtin_vis_fhadds (float, float);
15583 double __builtin_vis_fhaddd (double, double);
15584 float __builtin_vis_fhsubs (float, float);
15585 double __builtin_vis_fhsubd (double, double);
15586 float __builtin_vis_fnhadds (float, float);
15587 double __builtin_vis_fnhaddd (double, double);
15589 int64_t __builtin_vis_umulxhi (int64_t, int64_t);
15590 int64_t __builtin_vis_xmulx (int64_t, int64_t);
15591 int64_t __builtin_vis_xmulxhi (int64_t, int64_t);
15594 @node SPU Built-in Functions
15595 @subsection SPU Built-in Functions
15597 GCC provides extensions for the SPU processor as described in the
15598 Sony/Toshiba/IBM SPU Language Extensions Specification, which can be
15599 found at @uref{http://cell.scei.co.jp/} or
15600 @uref{http://www.ibm.com/developerworks/power/cell/}. GCC's
15601 implementation differs in several ways.
15606 The optional extension of specifying vector constants in parentheses is
15610 A vector initializer requires no cast if the vector constant is of the
15611 same type as the variable it is initializing.
15614 If @code{signed} or @code{unsigned} is omitted, the signedness of the
15615 vector type is the default signedness of the base type. The default
15616 varies depending on the operating system, so a portable program should
15617 always specify the signedness.
15620 By default, the keyword @code{__vector} is added. The macro
15621 @code{vector} is defined in @code{<spu_intrinsics.h>} and can be
15625 GCC allows using a @code{typedef} name as the type specifier for a
15629 For C, overloaded functions are implemented with macros so the following
15633 spu_add ((vector signed int)@{1, 2, 3, 4@}, foo);
15637 Since @code{spu_add} is a macro, the vector constant in the example
15638 is treated as four separate arguments. Wrap the entire argument in
15639 parentheses for this to work.
15642 The extended version of @code{__builtin_expect} is not supported.
15646 @emph{Note:} Only the interface described in the aforementioned
15647 specification is supported. Internally, GCC uses built-in functions to
15648 implement the required functionality, but these are not supported and
15649 are subject to change without notice.
15651 @node TI C6X Built-in Functions
15652 @subsection TI C6X Built-in Functions
15654 GCC provides intrinsics to access certain instructions of the TI C6X
15655 processors. These intrinsics, listed below, are available after
15656 inclusion of the @code{c6x_intrinsics.h} header file. They map directly
15657 to C6X instructions.
15661 int _sadd (int, int)
15662 int _ssub (int, int)
15663 int _sadd2 (int, int)
15664 int _ssub2 (int, int)
15665 long long _mpy2 (int, int)
15666 long long _smpy2 (int, int)
15667 int _add4 (int, int)
15668 int _sub4 (int, int)
15669 int _saddu4 (int, int)
15671 int _smpy (int, int)
15672 int _smpyh (int, int)
15673 int _smpyhl (int, int)
15674 int _smpylh (int, int)
15676 int _sshl (int, int)
15677 int _subc (int, int)
15679 int _avg2 (int, int)
15680 int _avgu4 (int, int)
15682 int _clrr (int, int)
15683 int _extr (int, int)
15684 int _extru (int, int)
15690 @node TILE-Gx Built-in Functions
15691 @subsection TILE-Gx Built-in Functions
15693 GCC provides intrinsics to access every instruction of the TILE-Gx
15694 processor. The intrinsics are of the form:
15698 unsigned long long __insn_@var{op} (...)
15702 Where @var{op} is the name of the instruction. Refer to the ISA manual
15703 for the complete list of instructions.
15705 GCC also provides intrinsics to directly access the network registers.
15706 The intrinsics are:
15710 unsigned long long __tile_idn0_receive (void)
15711 unsigned long long __tile_idn1_receive (void)
15712 unsigned long long __tile_udn0_receive (void)
15713 unsigned long long __tile_udn1_receive (void)
15714 unsigned long long __tile_udn2_receive (void)
15715 unsigned long long __tile_udn3_receive (void)
15716 void __tile_idn_send (unsigned long long)
15717 void __tile_udn_send (unsigned long long)
15721 The intrinsic @code{void __tile_network_barrier (void)} is used to
15722 guarantee that no network operations before it are reordered with
15725 @node TILEPro Built-in Functions
15726 @subsection TILEPro Built-in Functions
15728 GCC provides intrinsics to access every instruction of the TILEPro
15729 processor. The intrinsics are of the form:
15733 unsigned __insn_@var{op} (...)
15738 where @var{op} is the name of the instruction. Refer to the ISA manual
15739 for the complete list of instructions.
15741 GCC also provides intrinsics to directly access the network registers.
15742 The intrinsics are:
15746 unsigned __tile_idn0_receive (void)
15747 unsigned __tile_idn1_receive (void)
15748 unsigned __tile_sn_receive (void)
15749 unsigned __tile_udn0_receive (void)
15750 unsigned __tile_udn1_receive (void)
15751 unsigned __tile_udn2_receive (void)
15752 unsigned __tile_udn3_receive (void)
15753 void __tile_idn_send (unsigned)
15754 void __tile_sn_send (unsigned)
15755 void __tile_udn_send (unsigned)
15759 The intrinsic @code{void __tile_network_barrier (void)} is used to
15760 guarantee that no network operations before it are reordered with
15763 @node x86 Built-in Functions
15764 @subsection x86 Built-in Functions
15766 These built-in functions are available for the x86-32 and x86-64 family
15767 of computers, depending on the command-line switches used.
15769 If you specify command-line switches such as @option{-msse},
15770 the compiler could use the extended instruction sets even if the built-ins
15771 are not used explicitly in the program. For this reason, applications
15772 that perform run-time CPU detection must compile separate files for each
15773 supported architecture, using the appropriate flags. In particular,
15774 the file containing the CPU detection code should be compiled without
15777 The following machine modes are available for use with MMX built-in functions
15778 (@pxref{Vector Extensions}): @code{V2SI} for a vector of two 32-bit integers,
15779 @code{V4HI} for a vector of four 16-bit integers, and @code{V8QI} for a
15780 vector of eight 8-bit integers. Some of the built-in functions operate on
15781 MMX registers as a whole 64-bit entity, these use @code{V1DI} as their mode.
15783 If 3DNow!@: extensions are enabled, @code{V2SF} is used as a mode for a vector
15784 of two 32-bit floating-point values.
15786 If SSE extensions are enabled, @code{V4SF} is used for a vector of four 32-bit
15787 floating-point values. Some instructions use a vector of four 32-bit
15788 integers, these use @code{V4SI}. Finally, some instructions operate on an
15789 entire vector register, interpreting it as a 128-bit integer, these use mode
15792 In 64-bit mode, the x86-64 family of processors uses additional built-in
15793 functions for efficient use of @code{TF} (@code{__float128}) 128-bit
15794 floating point and @code{TC} 128-bit complex floating-point values.
15796 The following floating-point built-in functions are available in 64-bit
15797 mode. All of them implement the function that is part of the name.
15800 __float128 __builtin_fabsq (__float128)
15801 __float128 __builtin_copysignq (__float128, __float128)
15804 The following built-in function is always available.
15807 @item void __builtin_ia32_pause (void)
15808 Generates the @code{pause} machine instruction with a compiler memory
15812 The following floating-point built-in functions are made available in the
15816 @item __float128 __builtin_infq (void)
15817 Similar to @code{__builtin_inf}, except the return type is @code{__float128}.
15818 @findex __builtin_infq
15820 @item __float128 __builtin_huge_valq (void)
15821 Similar to @code{__builtin_huge_val}, except the return type is @code{__float128}.
15822 @findex __builtin_huge_valq
15825 The following built-in functions are always available and can be used to
15826 check the target platform type.
15828 @deftypefn {Built-in Function} void __builtin_cpu_init (void)
15829 This function runs the CPU detection code to check the type of CPU and the
15830 features supported. This built-in function needs to be invoked along with the built-in functions
15831 to check CPU type and features, @code{__builtin_cpu_is} and
15832 @code{__builtin_cpu_supports}, only when used in a function that is
15833 executed before any constructors are called. The CPU detection code is
15834 automatically executed in a very high priority constructor.
15836 For example, this function has to be used in @code{ifunc} resolvers that
15837 check for CPU type using the built-in functions @code{__builtin_cpu_is}
15838 and @code{__builtin_cpu_supports}, or in constructors on targets that
15839 don't support constructor priority.
15842 static void (*resolve_memcpy (void)) (void)
15844 // ifunc resolvers fire before constructors, explicitly call the init
15846 __builtin_cpu_init ();
15847 if (__builtin_cpu_supports ("ssse3"))
15848 return ssse3_memcpy; // super fast memcpy with ssse3 instructions.
15850 return default_memcpy;
15853 void *memcpy (void *, const void *, size_t)
15854 __attribute__ ((ifunc ("resolve_memcpy")));
15859 @deftypefn {Built-in Function} int __builtin_cpu_is (const char *@var{cpuname})
15860 This function returns a positive integer if the run-time CPU
15861 is of type @var{cpuname}
15862 and returns @code{0} otherwise. The following CPU names can be detected:
15878 Intel Core i7 Nehalem CPU.
15881 Intel Core i7 Westmere CPU.
15884 Intel Core i7 Sandy Bridge CPU.
15890 AMD Family 10h CPU.
15893 AMD Family 10h Barcelona CPU.
15896 AMD Family 10h Shanghai CPU.
15899 AMD Family 10h Istanbul CPU.
15902 AMD Family 14h CPU.
15905 AMD Family 15h CPU.
15908 AMD Family 15h Bulldozer version 1.
15911 AMD Family 15h Bulldozer version 2.
15914 AMD Family 15h Bulldozer version 3.
15917 AMD Family 15h Bulldozer version 4.
15920 AMD Family 16h CPU.
15923 Here is an example:
15925 if (__builtin_cpu_is ("corei7"))
15927 do_corei7 (); // Core i7 specific implementation.
15931 do_generic (); // Generic implementation.
15936 @deftypefn {Built-in Function} int __builtin_cpu_supports (const char *@var{feature})
15937 This function returns a positive integer if the run-time CPU
15938 supports @var{feature}
15939 and returns @code{0} otherwise. The following features can be detected:
15947 POPCNT instruction.
15955 SSSE3 instructions.
15957 SSE4.1 instructions.
15959 SSE4.2 instructions.
15965 AVX512F instructions.
15968 Here is an example:
15970 if (__builtin_cpu_supports ("popcnt"))
15972 asm("popcnt %1,%0" : "=r"(count) : "rm"(n) : "cc");
15976 count = generic_countbits (n); //generic implementation.
15982 The following built-in functions are made available by @option{-mmmx}.
15983 All of them generate the machine instruction that is part of the name.
15986 v8qi __builtin_ia32_paddb (v8qi, v8qi)
15987 v4hi __builtin_ia32_paddw (v4hi, v4hi)
15988 v2si __builtin_ia32_paddd (v2si, v2si)
15989 v8qi __builtin_ia32_psubb (v8qi, v8qi)
15990 v4hi __builtin_ia32_psubw (v4hi, v4hi)
15991 v2si __builtin_ia32_psubd (v2si, v2si)
15992 v8qi __builtin_ia32_paddsb (v8qi, v8qi)
15993 v4hi __builtin_ia32_paddsw (v4hi, v4hi)
15994 v8qi __builtin_ia32_psubsb (v8qi, v8qi)
15995 v4hi __builtin_ia32_psubsw (v4hi, v4hi)
15996 v8qi __builtin_ia32_paddusb (v8qi, v8qi)
15997 v4hi __builtin_ia32_paddusw (v4hi, v4hi)
15998 v8qi __builtin_ia32_psubusb (v8qi, v8qi)
15999 v4hi __builtin_ia32_psubusw (v4hi, v4hi)
16000 v4hi __builtin_ia32_pmullw (v4hi, v4hi)
16001 v4hi __builtin_ia32_pmulhw (v4hi, v4hi)
16002 di __builtin_ia32_pand (di, di)
16003 di __builtin_ia32_pandn (di,di)
16004 di __builtin_ia32_por (di, di)
16005 di __builtin_ia32_pxor (di, di)
16006 v8qi __builtin_ia32_pcmpeqb (v8qi, v8qi)
16007 v4hi __builtin_ia32_pcmpeqw (v4hi, v4hi)
16008 v2si __builtin_ia32_pcmpeqd (v2si, v2si)
16009 v8qi __builtin_ia32_pcmpgtb (v8qi, v8qi)
16010 v4hi __builtin_ia32_pcmpgtw (v4hi, v4hi)
16011 v2si __builtin_ia32_pcmpgtd (v2si, v2si)
16012 v8qi __builtin_ia32_punpckhbw (v8qi, v8qi)
16013 v4hi __builtin_ia32_punpckhwd (v4hi, v4hi)
16014 v2si __builtin_ia32_punpckhdq (v2si, v2si)
16015 v8qi __builtin_ia32_punpcklbw (v8qi, v8qi)
16016 v4hi __builtin_ia32_punpcklwd (v4hi, v4hi)
16017 v2si __builtin_ia32_punpckldq (v2si, v2si)
16018 v8qi __builtin_ia32_packsswb (v4hi, v4hi)
16019 v4hi __builtin_ia32_packssdw (v2si, v2si)
16020 v8qi __builtin_ia32_packuswb (v4hi, v4hi)
16022 v4hi __builtin_ia32_psllw (v4hi, v4hi)
16023 v2si __builtin_ia32_pslld (v2si, v2si)
16024 v1di __builtin_ia32_psllq (v1di, v1di)
16025 v4hi __builtin_ia32_psrlw (v4hi, v4hi)
16026 v2si __builtin_ia32_psrld (v2si, v2si)
16027 v1di __builtin_ia32_psrlq (v1di, v1di)
16028 v4hi __builtin_ia32_psraw (v4hi, v4hi)
16029 v2si __builtin_ia32_psrad (v2si, v2si)
16030 v4hi __builtin_ia32_psllwi (v4hi, int)
16031 v2si __builtin_ia32_pslldi (v2si, int)
16032 v1di __builtin_ia32_psllqi (v1di, int)
16033 v4hi __builtin_ia32_psrlwi (v4hi, int)
16034 v2si __builtin_ia32_psrldi (v2si, int)
16035 v1di __builtin_ia32_psrlqi (v1di, int)
16036 v4hi __builtin_ia32_psrawi (v4hi, int)
16037 v2si __builtin_ia32_psradi (v2si, int)
16041 The following built-in functions are made available either with
16042 @option{-msse}, or with a combination of @option{-m3dnow} and
16043 @option{-march=athlon}. All of them generate the machine
16044 instruction that is part of the name.
16047 v4hi __builtin_ia32_pmulhuw (v4hi, v4hi)
16048 v8qi __builtin_ia32_pavgb (v8qi, v8qi)
16049 v4hi __builtin_ia32_pavgw (v4hi, v4hi)
16050 v1di __builtin_ia32_psadbw (v8qi, v8qi)
16051 v8qi __builtin_ia32_pmaxub (v8qi, v8qi)
16052 v4hi __builtin_ia32_pmaxsw (v4hi, v4hi)
16053 v8qi __builtin_ia32_pminub (v8qi, v8qi)
16054 v4hi __builtin_ia32_pminsw (v4hi, v4hi)
16055 int __builtin_ia32_pmovmskb (v8qi)
16056 void __builtin_ia32_maskmovq (v8qi, v8qi, char *)
16057 void __builtin_ia32_movntq (di *, di)
16058 void __builtin_ia32_sfence (void)
16061 The following built-in functions are available when @option{-msse} is used.
16062 All of them generate the machine instruction that is part of the name.
16065 int __builtin_ia32_comieq (v4sf, v4sf)
16066 int __builtin_ia32_comineq (v4sf, v4sf)
16067 int __builtin_ia32_comilt (v4sf, v4sf)
16068 int __builtin_ia32_comile (v4sf, v4sf)
16069 int __builtin_ia32_comigt (v4sf, v4sf)
16070 int __builtin_ia32_comige (v4sf, v4sf)
16071 int __builtin_ia32_ucomieq (v4sf, v4sf)
16072 int __builtin_ia32_ucomineq (v4sf, v4sf)
16073 int __builtin_ia32_ucomilt (v4sf, v4sf)
16074 int __builtin_ia32_ucomile (v4sf, v4sf)
16075 int __builtin_ia32_ucomigt (v4sf, v4sf)
16076 int __builtin_ia32_ucomige (v4sf, v4sf)
16077 v4sf __builtin_ia32_addps (v4sf, v4sf)
16078 v4sf __builtin_ia32_subps (v4sf, v4sf)
16079 v4sf __builtin_ia32_mulps (v4sf, v4sf)
16080 v4sf __builtin_ia32_divps (v4sf, v4sf)
16081 v4sf __builtin_ia32_addss (v4sf, v4sf)
16082 v4sf __builtin_ia32_subss (v4sf, v4sf)
16083 v4sf __builtin_ia32_mulss (v4sf, v4sf)
16084 v4sf __builtin_ia32_divss (v4sf, v4sf)
16085 v4sf __builtin_ia32_cmpeqps (v4sf, v4sf)
16086 v4sf __builtin_ia32_cmpltps (v4sf, v4sf)
16087 v4sf __builtin_ia32_cmpleps (v4sf, v4sf)
16088 v4sf __builtin_ia32_cmpgtps (v4sf, v4sf)
16089 v4sf __builtin_ia32_cmpgeps (v4sf, v4sf)
16090 v4sf __builtin_ia32_cmpunordps (v4sf, v4sf)
16091 v4sf __builtin_ia32_cmpneqps (v4sf, v4sf)
16092 v4sf __builtin_ia32_cmpnltps (v4sf, v4sf)
16093 v4sf __builtin_ia32_cmpnleps (v4sf, v4sf)
16094 v4sf __builtin_ia32_cmpngtps (v4sf, v4sf)
16095 v4sf __builtin_ia32_cmpngeps (v4sf, v4sf)
16096 v4sf __builtin_ia32_cmpordps (v4sf, v4sf)
16097 v4sf __builtin_ia32_cmpeqss (v4sf, v4sf)
16098 v4sf __builtin_ia32_cmpltss (v4sf, v4sf)
16099 v4sf __builtin_ia32_cmpless (v4sf, v4sf)
16100 v4sf __builtin_ia32_cmpunordss (v4sf, v4sf)
16101 v4sf __builtin_ia32_cmpneqss (v4sf, v4sf)
16102 v4sf __builtin_ia32_cmpnltss (v4sf, v4sf)
16103 v4sf __builtin_ia32_cmpnless (v4sf, v4sf)
16104 v4sf __builtin_ia32_cmpordss (v4sf, v4sf)
16105 v4sf __builtin_ia32_maxps (v4sf, v4sf)
16106 v4sf __builtin_ia32_maxss (v4sf, v4sf)
16107 v4sf __builtin_ia32_minps (v4sf, v4sf)
16108 v4sf __builtin_ia32_minss (v4sf, v4sf)
16109 v4sf __builtin_ia32_andps (v4sf, v4sf)
16110 v4sf __builtin_ia32_andnps (v4sf, v4sf)
16111 v4sf __builtin_ia32_orps (v4sf, v4sf)
16112 v4sf __builtin_ia32_xorps (v4sf, v4sf)
16113 v4sf __builtin_ia32_movss (v4sf, v4sf)
16114 v4sf __builtin_ia32_movhlps (v4sf, v4sf)
16115 v4sf __builtin_ia32_movlhps (v4sf, v4sf)
16116 v4sf __builtin_ia32_unpckhps (v4sf, v4sf)
16117 v4sf __builtin_ia32_unpcklps (v4sf, v4sf)
16118 v4sf __builtin_ia32_cvtpi2ps (v4sf, v2si)
16119 v4sf __builtin_ia32_cvtsi2ss (v4sf, int)
16120 v2si __builtin_ia32_cvtps2pi (v4sf)
16121 int __builtin_ia32_cvtss2si (v4sf)
16122 v2si __builtin_ia32_cvttps2pi (v4sf)
16123 int __builtin_ia32_cvttss2si (v4sf)
16124 v4sf __builtin_ia32_rcpps (v4sf)
16125 v4sf __builtin_ia32_rsqrtps (v4sf)
16126 v4sf __builtin_ia32_sqrtps (v4sf)
16127 v4sf __builtin_ia32_rcpss (v4sf)
16128 v4sf __builtin_ia32_rsqrtss (v4sf)
16129 v4sf __builtin_ia32_sqrtss (v4sf)
16130 v4sf __builtin_ia32_shufps (v4sf, v4sf, int)
16131 void __builtin_ia32_movntps (float *, v4sf)
16132 int __builtin_ia32_movmskps (v4sf)
16135 The following built-in functions are available when @option{-msse} is used.
16138 @item v4sf __builtin_ia32_loadups (float *)
16139 Generates the @code{movups} machine instruction as a load from memory.
16140 @item void __builtin_ia32_storeups (float *, v4sf)
16141 Generates the @code{movups} machine instruction as a store to memory.
16142 @item v4sf __builtin_ia32_loadss (float *)
16143 Generates the @code{movss} machine instruction as a load from memory.
16144 @item v4sf __builtin_ia32_loadhps (v4sf, const v2sf *)
16145 Generates the @code{movhps} machine instruction as a load from memory.
16146 @item v4sf __builtin_ia32_loadlps (v4sf, const v2sf *)
16147 Generates the @code{movlps} machine instruction as a load from memory
16148 @item void __builtin_ia32_storehps (v2sf *, v4sf)
16149 Generates the @code{movhps} machine instruction as a store to memory.
16150 @item void __builtin_ia32_storelps (v2sf *, v4sf)
16151 Generates the @code{movlps} machine instruction as a store to memory.
16154 The following built-in functions are available when @option{-msse2} is used.
16155 All of them generate the machine instruction that is part of the name.
16158 int __builtin_ia32_comisdeq (v2df, v2df)
16159 int __builtin_ia32_comisdlt (v2df, v2df)
16160 int __builtin_ia32_comisdle (v2df, v2df)
16161 int __builtin_ia32_comisdgt (v2df, v2df)
16162 int __builtin_ia32_comisdge (v2df, v2df)
16163 int __builtin_ia32_comisdneq (v2df, v2df)
16164 int __builtin_ia32_ucomisdeq (v2df, v2df)
16165 int __builtin_ia32_ucomisdlt (v2df, v2df)
16166 int __builtin_ia32_ucomisdle (v2df, v2df)
16167 int __builtin_ia32_ucomisdgt (v2df, v2df)
16168 int __builtin_ia32_ucomisdge (v2df, v2df)
16169 int __builtin_ia32_ucomisdneq (v2df, v2df)
16170 v2df __builtin_ia32_cmpeqpd (v2df, v2df)
16171 v2df __builtin_ia32_cmpltpd (v2df, v2df)
16172 v2df __builtin_ia32_cmplepd (v2df, v2df)
16173 v2df __builtin_ia32_cmpgtpd (v2df, v2df)
16174 v2df __builtin_ia32_cmpgepd (v2df, v2df)
16175 v2df __builtin_ia32_cmpunordpd (v2df, v2df)
16176 v2df __builtin_ia32_cmpneqpd (v2df, v2df)
16177 v2df __builtin_ia32_cmpnltpd (v2df, v2df)
16178 v2df __builtin_ia32_cmpnlepd (v2df, v2df)
16179 v2df __builtin_ia32_cmpngtpd (v2df, v2df)
16180 v2df __builtin_ia32_cmpngepd (v2df, v2df)
16181 v2df __builtin_ia32_cmpordpd (v2df, v2df)
16182 v2df __builtin_ia32_cmpeqsd (v2df, v2df)
16183 v2df __builtin_ia32_cmpltsd (v2df, v2df)
16184 v2df __builtin_ia32_cmplesd (v2df, v2df)
16185 v2df __builtin_ia32_cmpunordsd (v2df, v2df)
16186 v2df __builtin_ia32_cmpneqsd (v2df, v2df)
16187 v2df __builtin_ia32_cmpnltsd (v2df, v2df)
16188 v2df __builtin_ia32_cmpnlesd (v2df, v2df)
16189 v2df __builtin_ia32_cmpordsd (v2df, v2df)
16190 v2di __builtin_ia32_paddq (v2di, v2di)
16191 v2di __builtin_ia32_psubq (v2di, v2di)
16192 v2df __builtin_ia32_addpd (v2df, v2df)
16193 v2df __builtin_ia32_subpd (v2df, v2df)
16194 v2df __builtin_ia32_mulpd (v2df, v2df)
16195 v2df __builtin_ia32_divpd (v2df, v2df)
16196 v2df __builtin_ia32_addsd (v2df, v2df)
16197 v2df __builtin_ia32_subsd (v2df, v2df)
16198 v2df __builtin_ia32_mulsd (v2df, v2df)
16199 v2df __builtin_ia32_divsd (v2df, v2df)
16200 v2df __builtin_ia32_minpd (v2df, v2df)
16201 v2df __builtin_ia32_maxpd (v2df, v2df)
16202 v2df __builtin_ia32_minsd (v2df, v2df)
16203 v2df __builtin_ia32_maxsd (v2df, v2df)
16204 v2df __builtin_ia32_andpd (v2df, v2df)
16205 v2df __builtin_ia32_andnpd (v2df, v2df)
16206 v2df __builtin_ia32_orpd (v2df, v2df)
16207 v2df __builtin_ia32_xorpd (v2df, v2df)
16208 v2df __builtin_ia32_movsd (v2df, v2df)
16209 v2df __builtin_ia32_unpckhpd (v2df, v2df)
16210 v2df __builtin_ia32_unpcklpd (v2df, v2df)
16211 v16qi __builtin_ia32_paddb128 (v16qi, v16qi)
16212 v8hi __builtin_ia32_paddw128 (v8hi, v8hi)
16213 v4si __builtin_ia32_paddd128 (v4si, v4si)
16214 v2di __builtin_ia32_paddq128 (v2di, v2di)
16215 v16qi __builtin_ia32_psubb128 (v16qi, v16qi)
16216 v8hi __builtin_ia32_psubw128 (v8hi, v8hi)
16217 v4si __builtin_ia32_psubd128 (v4si, v4si)
16218 v2di __builtin_ia32_psubq128 (v2di, v2di)
16219 v8hi __builtin_ia32_pmullw128 (v8hi, v8hi)
16220 v8hi __builtin_ia32_pmulhw128 (v8hi, v8hi)
16221 v2di __builtin_ia32_pand128 (v2di, v2di)
16222 v2di __builtin_ia32_pandn128 (v2di, v2di)
16223 v2di __builtin_ia32_por128 (v2di, v2di)
16224 v2di __builtin_ia32_pxor128 (v2di, v2di)
16225 v16qi __builtin_ia32_pavgb128 (v16qi, v16qi)
16226 v8hi __builtin_ia32_pavgw128 (v8hi, v8hi)
16227 v16qi __builtin_ia32_pcmpeqb128 (v16qi, v16qi)
16228 v8hi __builtin_ia32_pcmpeqw128 (v8hi, v8hi)
16229 v4si __builtin_ia32_pcmpeqd128 (v4si, v4si)
16230 v16qi __builtin_ia32_pcmpgtb128 (v16qi, v16qi)
16231 v8hi __builtin_ia32_pcmpgtw128 (v8hi, v8hi)
16232 v4si __builtin_ia32_pcmpgtd128 (v4si, v4si)
16233 v16qi __builtin_ia32_pmaxub128 (v16qi, v16qi)
16234 v8hi __builtin_ia32_pmaxsw128 (v8hi, v8hi)
16235 v16qi __builtin_ia32_pminub128 (v16qi, v16qi)
16236 v8hi __builtin_ia32_pminsw128 (v8hi, v8hi)
16237 v16qi __builtin_ia32_punpckhbw128 (v16qi, v16qi)
16238 v8hi __builtin_ia32_punpckhwd128 (v8hi, v8hi)
16239 v4si __builtin_ia32_punpckhdq128 (v4si, v4si)
16240 v2di __builtin_ia32_punpckhqdq128 (v2di, v2di)
16241 v16qi __builtin_ia32_punpcklbw128 (v16qi, v16qi)
16242 v8hi __builtin_ia32_punpcklwd128 (v8hi, v8hi)
16243 v4si __builtin_ia32_punpckldq128 (v4si, v4si)
16244 v2di __builtin_ia32_punpcklqdq128 (v2di, v2di)
16245 v16qi __builtin_ia32_packsswb128 (v8hi, v8hi)
16246 v8hi __builtin_ia32_packssdw128 (v4si, v4si)
16247 v16qi __builtin_ia32_packuswb128 (v8hi, v8hi)
16248 v8hi __builtin_ia32_pmulhuw128 (v8hi, v8hi)
16249 void __builtin_ia32_maskmovdqu (v16qi, v16qi)
16250 v2df __builtin_ia32_loadupd (double *)
16251 void __builtin_ia32_storeupd (double *, v2df)
16252 v2df __builtin_ia32_loadhpd (v2df, double const *)
16253 v2df __builtin_ia32_loadlpd (v2df, double const *)
16254 int __builtin_ia32_movmskpd (v2df)
16255 int __builtin_ia32_pmovmskb128 (v16qi)
16256 void __builtin_ia32_movnti (int *, int)
16257 void __builtin_ia32_movnti64 (long long int *, long long int)
16258 void __builtin_ia32_movntpd (double *, v2df)
16259 void __builtin_ia32_movntdq (v2df *, v2df)
16260 v4si __builtin_ia32_pshufd (v4si, int)
16261 v8hi __builtin_ia32_pshuflw (v8hi, int)
16262 v8hi __builtin_ia32_pshufhw (v8hi, int)
16263 v2di __builtin_ia32_psadbw128 (v16qi, v16qi)
16264 v2df __builtin_ia32_sqrtpd (v2df)
16265 v2df __builtin_ia32_sqrtsd (v2df)
16266 v2df __builtin_ia32_shufpd (v2df, v2df, int)
16267 v2df __builtin_ia32_cvtdq2pd (v4si)
16268 v4sf __builtin_ia32_cvtdq2ps (v4si)
16269 v4si __builtin_ia32_cvtpd2dq (v2df)
16270 v2si __builtin_ia32_cvtpd2pi (v2df)
16271 v4sf __builtin_ia32_cvtpd2ps (v2df)
16272 v4si __builtin_ia32_cvttpd2dq (v2df)
16273 v2si __builtin_ia32_cvttpd2pi (v2df)
16274 v2df __builtin_ia32_cvtpi2pd (v2si)
16275 int __builtin_ia32_cvtsd2si (v2df)
16276 int __builtin_ia32_cvttsd2si (v2df)
16277 long long __builtin_ia32_cvtsd2si64 (v2df)
16278 long long __builtin_ia32_cvttsd2si64 (v2df)
16279 v4si __builtin_ia32_cvtps2dq (v4sf)
16280 v2df __builtin_ia32_cvtps2pd (v4sf)
16281 v4si __builtin_ia32_cvttps2dq (v4sf)
16282 v2df __builtin_ia32_cvtsi2sd (v2df, int)
16283 v2df __builtin_ia32_cvtsi642sd (v2df, long long)
16284 v4sf __builtin_ia32_cvtsd2ss (v4sf, v2df)
16285 v2df __builtin_ia32_cvtss2sd (v2df, v4sf)
16286 void __builtin_ia32_clflush (const void *)
16287 void __builtin_ia32_lfence (void)
16288 void __builtin_ia32_mfence (void)
16289 v16qi __builtin_ia32_loaddqu (const char *)
16290 void __builtin_ia32_storedqu (char *, v16qi)
16291 v1di __builtin_ia32_pmuludq (v2si, v2si)
16292 v2di __builtin_ia32_pmuludq128 (v4si, v4si)
16293 v8hi __builtin_ia32_psllw128 (v8hi, v8hi)
16294 v4si __builtin_ia32_pslld128 (v4si, v4si)
16295 v2di __builtin_ia32_psllq128 (v2di, v2di)
16296 v8hi __builtin_ia32_psrlw128 (v8hi, v8hi)
16297 v4si __builtin_ia32_psrld128 (v4si, v4si)
16298 v2di __builtin_ia32_psrlq128 (v2di, v2di)
16299 v8hi __builtin_ia32_psraw128 (v8hi, v8hi)
16300 v4si __builtin_ia32_psrad128 (v4si, v4si)
16301 v2di __builtin_ia32_pslldqi128 (v2di, int)
16302 v8hi __builtin_ia32_psllwi128 (v8hi, int)
16303 v4si __builtin_ia32_pslldi128 (v4si, int)
16304 v2di __builtin_ia32_psllqi128 (v2di, int)
16305 v2di __builtin_ia32_psrldqi128 (v2di, int)
16306 v8hi __builtin_ia32_psrlwi128 (v8hi, int)
16307 v4si __builtin_ia32_psrldi128 (v4si, int)
16308 v2di __builtin_ia32_psrlqi128 (v2di, int)
16309 v8hi __builtin_ia32_psrawi128 (v8hi, int)
16310 v4si __builtin_ia32_psradi128 (v4si, int)
16311 v4si __builtin_ia32_pmaddwd128 (v8hi, v8hi)
16312 v2di __builtin_ia32_movq128 (v2di)
16315 The following built-in functions are available when @option{-msse3} is used.
16316 All of them generate the machine instruction that is part of the name.
16319 v2df __builtin_ia32_addsubpd (v2df, v2df)
16320 v4sf __builtin_ia32_addsubps (v4sf, v4sf)
16321 v2df __builtin_ia32_haddpd (v2df, v2df)
16322 v4sf __builtin_ia32_haddps (v4sf, v4sf)
16323 v2df __builtin_ia32_hsubpd (v2df, v2df)
16324 v4sf __builtin_ia32_hsubps (v4sf, v4sf)
16325 v16qi __builtin_ia32_lddqu (char const *)
16326 void __builtin_ia32_monitor (void *, unsigned int, unsigned int)
16327 v4sf __builtin_ia32_movshdup (v4sf)
16328 v4sf __builtin_ia32_movsldup (v4sf)
16329 void __builtin_ia32_mwait (unsigned int, unsigned int)
16332 The following built-in functions are available when @option{-mssse3} is used.
16333 All of them generate the machine instruction that is part of the name.
16336 v2si __builtin_ia32_phaddd (v2si, v2si)
16337 v4hi __builtin_ia32_phaddw (v4hi, v4hi)
16338 v4hi __builtin_ia32_phaddsw (v4hi, v4hi)
16339 v2si __builtin_ia32_phsubd (v2si, v2si)
16340 v4hi __builtin_ia32_phsubw (v4hi, v4hi)
16341 v4hi __builtin_ia32_phsubsw (v4hi, v4hi)
16342 v4hi __builtin_ia32_pmaddubsw (v8qi, v8qi)
16343 v4hi __builtin_ia32_pmulhrsw (v4hi, v4hi)
16344 v8qi __builtin_ia32_pshufb (v8qi, v8qi)
16345 v8qi __builtin_ia32_psignb (v8qi, v8qi)
16346 v2si __builtin_ia32_psignd (v2si, v2si)
16347 v4hi __builtin_ia32_psignw (v4hi, v4hi)
16348 v1di __builtin_ia32_palignr (v1di, v1di, int)
16349 v8qi __builtin_ia32_pabsb (v8qi)
16350 v2si __builtin_ia32_pabsd (v2si)
16351 v4hi __builtin_ia32_pabsw (v4hi)
16354 The following built-in functions are available when @option{-mssse3} is used.
16355 All of them generate the machine instruction that is part of the name.
16358 v4si __builtin_ia32_phaddd128 (v4si, v4si)
16359 v8hi __builtin_ia32_phaddw128 (v8hi, v8hi)
16360 v8hi __builtin_ia32_phaddsw128 (v8hi, v8hi)
16361 v4si __builtin_ia32_phsubd128 (v4si, v4si)
16362 v8hi __builtin_ia32_phsubw128 (v8hi, v8hi)
16363 v8hi __builtin_ia32_phsubsw128 (v8hi, v8hi)
16364 v8hi __builtin_ia32_pmaddubsw128 (v16qi, v16qi)
16365 v8hi __builtin_ia32_pmulhrsw128 (v8hi, v8hi)
16366 v16qi __builtin_ia32_pshufb128 (v16qi, v16qi)
16367 v16qi __builtin_ia32_psignb128 (v16qi, v16qi)
16368 v4si __builtin_ia32_psignd128 (v4si, v4si)
16369 v8hi __builtin_ia32_psignw128 (v8hi, v8hi)
16370 v2di __builtin_ia32_palignr128 (v2di, v2di, int)
16371 v16qi __builtin_ia32_pabsb128 (v16qi)
16372 v4si __builtin_ia32_pabsd128 (v4si)
16373 v8hi __builtin_ia32_pabsw128 (v8hi)
16376 The following built-in functions are available when @option{-msse4.1} is
16377 used. All of them generate the machine instruction that is part of the
16381 v2df __builtin_ia32_blendpd (v2df, v2df, const int)
16382 v4sf __builtin_ia32_blendps (v4sf, v4sf, const int)
16383 v2df __builtin_ia32_blendvpd (v2df, v2df, v2df)
16384 v4sf __builtin_ia32_blendvps (v4sf, v4sf, v4sf)
16385 v2df __builtin_ia32_dppd (v2df, v2df, const int)
16386 v4sf __builtin_ia32_dpps (v4sf, v4sf, const int)
16387 v4sf __builtin_ia32_insertps128 (v4sf, v4sf, const int)
16388 v2di __builtin_ia32_movntdqa (v2di *);
16389 v16qi __builtin_ia32_mpsadbw128 (v16qi, v16qi, const int)
16390 v8hi __builtin_ia32_packusdw128 (v4si, v4si)
16391 v16qi __builtin_ia32_pblendvb128 (v16qi, v16qi, v16qi)
16392 v8hi __builtin_ia32_pblendw128 (v8hi, v8hi, const int)
16393 v2di __builtin_ia32_pcmpeqq (v2di, v2di)
16394 v8hi __builtin_ia32_phminposuw128 (v8hi)
16395 v16qi __builtin_ia32_pmaxsb128 (v16qi, v16qi)
16396 v4si __builtin_ia32_pmaxsd128 (v4si, v4si)
16397 v4si __builtin_ia32_pmaxud128 (v4si, v4si)
16398 v8hi __builtin_ia32_pmaxuw128 (v8hi, v8hi)
16399 v16qi __builtin_ia32_pminsb128 (v16qi, v16qi)
16400 v4si __builtin_ia32_pminsd128 (v4si, v4si)
16401 v4si __builtin_ia32_pminud128 (v4si, v4si)
16402 v8hi __builtin_ia32_pminuw128 (v8hi, v8hi)
16403 v4si __builtin_ia32_pmovsxbd128 (v16qi)
16404 v2di __builtin_ia32_pmovsxbq128 (v16qi)
16405 v8hi __builtin_ia32_pmovsxbw128 (v16qi)
16406 v2di __builtin_ia32_pmovsxdq128 (v4si)
16407 v4si __builtin_ia32_pmovsxwd128 (v8hi)
16408 v2di __builtin_ia32_pmovsxwq128 (v8hi)
16409 v4si __builtin_ia32_pmovzxbd128 (v16qi)
16410 v2di __builtin_ia32_pmovzxbq128 (v16qi)
16411 v8hi __builtin_ia32_pmovzxbw128 (v16qi)
16412 v2di __builtin_ia32_pmovzxdq128 (v4si)
16413 v4si __builtin_ia32_pmovzxwd128 (v8hi)
16414 v2di __builtin_ia32_pmovzxwq128 (v8hi)
16415 v2di __builtin_ia32_pmuldq128 (v4si, v4si)
16416 v4si __builtin_ia32_pmulld128 (v4si, v4si)
16417 int __builtin_ia32_ptestc128 (v2di, v2di)
16418 int __builtin_ia32_ptestnzc128 (v2di, v2di)
16419 int __builtin_ia32_ptestz128 (v2di, v2di)
16420 v2df __builtin_ia32_roundpd (v2df, const int)
16421 v4sf __builtin_ia32_roundps (v4sf, const int)
16422 v2df __builtin_ia32_roundsd (v2df, v2df, const int)
16423 v4sf __builtin_ia32_roundss (v4sf, v4sf, const int)
16426 The following built-in functions are available when @option{-msse4.1} is
16430 @item v4sf __builtin_ia32_vec_set_v4sf (v4sf, float, const int)
16431 Generates the @code{insertps} machine instruction.
16432 @item int __builtin_ia32_vec_ext_v16qi (v16qi, const int)
16433 Generates the @code{pextrb} machine instruction.
16434 @item v16qi __builtin_ia32_vec_set_v16qi (v16qi, int, const int)
16435 Generates the @code{pinsrb} machine instruction.
16436 @item v4si __builtin_ia32_vec_set_v4si (v4si, int, const int)
16437 Generates the @code{pinsrd} machine instruction.
16438 @item v2di __builtin_ia32_vec_set_v2di (v2di, long long, const int)
16439 Generates the @code{pinsrq} machine instruction in 64bit mode.
16442 The following built-in functions are changed to generate new SSE4.1
16443 instructions when @option{-msse4.1} is used.
16446 @item float __builtin_ia32_vec_ext_v4sf (v4sf, const int)
16447 Generates the @code{extractps} machine instruction.
16448 @item int __builtin_ia32_vec_ext_v4si (v4si, const int)
16449 Generates the @code{pextrd} machine instruction.
16450 @item long long __builtin_ia32_vec_ext_v2di (v2di, const int)
16451 Generates the @code{pextrq} machine instruction in 64bit mode.
16454 The following built-in functions are available when @option{-msse4.2} is
16455 used. All of them generate the machine instruction that is part of the
16459 v16qi __builtin_ia32_pcmpestrm128 (v16qi, int, v16qi, int, const int)
16460 int __builtin_ia32_pcmpestri128 (v16qi, int, v16qi, int, const int)
16461 int __builtin_ia32_pcmpestria128 (v16qi, int, v16qi, int, const int)
16462 int __builtin_ia32_pcmpestric128 (v16qi, int, v16qi, int, const int)
16463 int __builtin_ia32_pcmpestrio128 (v16qi, int, v16qi, int, const int)
16464 int __builtin_ia32_pcmpestris128 (v16qi, int, v16qi, int, const int)
16465 int __builtin_ia32_pcmpestriz128 (v16qi, int, v16qi, int, const int)
16466 v16qi __builtin_ia32_pcmpistrm128 (v16qi, v16qi, const int)
16467 int __builtin_ia32_pcmpistri128 (v16qi, v16qi, const int)
16468 int __builtin_ia32_pcmpistria128 (v16qi, v16qi, const int)
16469 int __builtin_ia32_pcmpistric128 (v16qi, v16qi, const int)
16470 int __builtin_ia32_pcmpistrio128 (v16qi, v16qi, const int)
16471 int __builtin_ia32_pcmpistris128 (v16qi, v16qi, const int)
16472 int __builtin_ia32_pcmpistriz128 (v16qi, v16qi, const int)
16473 v2di __builtin_ia32_pcmpgtq (v2di, v2di)
16476 The following built-in functions are available when @option{-msse4.2} is
16480 @item unsigned int __builtin_ia32_crc32qi (unsigned int, unsigned char)
16481 Generates the @code{crc32b} machine instruction.
16482 @item unsigned int __builtin_ia32_crc32hi (unsigned int, unsigned short)
16483 Generates the @code{crc32w} machine instruction.
16484 @item unsigned int __builtin_ia32_crc32si (unsigned int, unsigned int)
16485 Generates the @code{crc32l} machine instruction.
16486 @item unsigned long long __builtin_ia32_crc32di (unsigned long long, unsigned long long)
16487 Generates the @code{crc32q} machine instruction.
16490 The following built-in functions are changed to generate new SSE4.2
16491 instructions when @option{-msse4.2} is used.
16494 @item int __builtin_popcount (unsigned int)
16495 Generates the @code{popcntl} machine instruction.
16496 @item int __builtin_popcountl (unsigned long)
16497 Generates the @code{popcntl} or @code{popcntq} machine instruction,
16498 depending on the size of @code{unsigned long}.
16499 @item int __builtin_popcountll (unsigned long long)
16500 Generates the @code{popcntq} machine instruction.
16503 The following built-in functions are available when @option{-mavx} is
16504 used. All of them generate the machine instruction that is part of the
16508 v4df __builtin_ia32_addpd256 (v4df,v4df)
16509 v8sf __builtin_ia32_addps256 (v8sf,v8sf)
16510 v4df __builtin_ia32_addsubpd256 (v4df,v4df)
16511 v8sf __builtin_ia32_addsubps256 (v8sf,v8sf)
16512 v4df __builtin_ia32_andnpd256 (v4df,v4df)
16513 v8sf __builtin_ia32_andnps256 (v8sf,v8sf)
16514 v4df __builtin_ia32_andpd256 (v4df,v4df)
16515 v8sf __builtin_ia32_andps256 (v8sf,v8sf)
16516 v4df __builtin_ia32_blendpd256 (v4df,v4df,int)
16517 v8sf __builtin_ia32_blendps256 (v8sf,v8sf,int)
16518 v4df __builtin_ia32_blendvpd256 (v4df,v4df,v4df)
16519 v8sf __builtin_ia32_blendvps256 (v8sf,v8sf,v8sf)
16520 v2df __builtin_ia32_cmppd (v2df,v2df,int)
16521 v4df __builtin_ia32_cmppd256 (v4df,v4df,int)
16522 v4sf __builtin_ia32_cmpps (v4sf,v4sf,int)
16523 v8sf __builtin_ia32_cmpps256 (v8sf,v8sf,int)
16524 v2df __builtin_ia32_cmpsd (v2df,v2df,int)
16525 v4sf __builtin_ia32_cmpss (v4sf,v4sf,int)
16526 v4df __builtin_ia32_cvtdq2pd256 (v4si)
16527 v8sf __builtin_ia32_cvtdq2ps256 (v8si)
16528 v4si __builtin_ia32_cvtpd2dq256 (v4df)
16529 v4sf __builtin_ia32_cvtpd2ps256 (v4df)
16530 v8si __builtin_ia32_cvtps2dq256 (v8sf)
16531 v4df __builtin_ia32_cvtps2pd256 (v4sf)
16532 v4si __builtin_ia32_cvttpd2dq256 (v4df)
16533 v8si __builtin_ia32_cvttps2dq256 (v8sf)
16534 v4df __builtin_ia32_divpd256 (v4df,v4df)
16535 v8sf __builtin_ia32_divps256 (v8sf,v8sf)
16536 v8sf __builtin_ia32_dpps256 (v8sf,v8sf,int)
16537 v4df __builtin_ia32_haddpd256 (v4df,v4df)
16538 v8sf __builtin_ia32_haddps256 (v8sf,v8sf)
16539 v4df __builtin_ia32_hsubpd256 (v4df,v4df)
16540 v8sf __builtin_ia32_hsubps256 (v8sf,v8sf)
16541 v32qi __builtin_ia32_lddqu256 (pcchar)
16542 v32qi __builtin_ia32_loaddqu256 (pcchar)
16543 v4df __builtin_ia32_loadupd256 (pcdouble)
16544 v8sf __builtin_ia32_loadups256 (pcfloat)
16545 v2df __builtin_ia32_maskloadpd (pcv2df,v2df)
16546 v4df __builtin_ia32_maskloadpd256 (pcv4df,v4df)
16547 v4sf __builtin_ia32_maskloadps (pcv4sf,v4sf)
16548 v8sf __builtin_ia32_maskloadps256 (pcv8sf,v8sf)
16549 void __builtin_ia32_maskstorepd (pv2df,v2df,v2df)
16550 void __builtin_ia32_maskstorepd256 (pv4df,v4df,v4df)
16551 void __builtin_ia32_maskstoreps (pv4sf,v4sf,v4sf)
16552 void __builtin_ia32_maskstoreps256 (pv8sf,v8sf,v8sf)
16553 v4df __builtin_ia32_maxpd256 (v4df,v4df)
16554 v8sf __builtin_ia32_maxps256 (v8sf,v8sf)
16555 v4df __builtin_ia32_minpd256 (v4df,v4df)
16556 v8sf __builtin_ia32_minps256 (v8sf,v8sf)
16557 v4df __builtin_ia32_movddup256 (v4df)
16558 int __builtin_ia32_movmskpd256 (v4df)
16559 int __builtin_ia32_movmskps256 (v8sf)
16560 v8sf __builtin_ia32_movshdup256 (v8sf)
16561 v8sf __builtin_ia32_movsldup256 (v8sf)
16562 v4df __builtin_ia32_mulpd256 (v4df,v4df)
16563 v8sf __builtin_ia32_mulps256 (v8sf,v8sf)
16564 v4df __builtin_ia32_orpd256 (v4df,v4df)
16565 v8sf __builtin_ia32_orps256 (v8sf,v8sf)
16566 v2df __builtin_ia32_pd_pd256 (v4df)
16567 v4df __builtin_ia32_pd256_pd (v2df)
16568 v4sf __builtin_ia32_ps_ps256 (v8sf)
16569 v8sf __builtin_ia32_ps256_ps (v4sf)
16570 int __builtin_ia32_ptestc256 (v4di,v4di,ptest)
16571 int __builtin_ia32_ptestnzc256 (v4di,v4di,ptest)
16572 int __builtin_ia32_ptestz256 (v4di,v4di,ptest)
16573 v8sf __builtin_ia32_rcpps256 (v8sf)
16574 v4df __builtin_ia32_roundpd256 (v4df,int)
16575 v8sf __builtin_ia32_roundps256 (v8sf,int)
16576 v8sf __builtin_ia32_rsqrtps_nr256 (v8sf)
16577 v8sf __builtin_ia32_rsqrtps256 (v8sf)
16578 v4df __builtin_ia32_shufpd256 (v4df,v4df,int)
16579 v8sf __builtin_ia32_shufps256 (v8sf,v8sf,int)
16580 v4si __builtin_ia32_si_si256 (v8si)
16581 v8si __builtin_ia32_si256_si (v4si)
16582 v4df __builtin_ia32_sqrtpd256 (v4df)
16583 v8sf __builtin_ia32_sqrtps_nr256 (v8sf)
16584 v8sf __builtin_ia32_sqrtps256 (v8sf)
16585 void __builtin_ia32_storedqu256 (pchar,v32qi)
16586 void __builtin_ia32_storeupd256 (pdouble,v4df)
16587 void __builtin_ia32_storeups256 (pfloat,v8sf)
16588 v4df __builtin_ia32_subpd256 (v4df,v4df)
16589 v8sf __builtin_ia32_subps256 (v8sf,v8sf)
16590 v4df __builtin_ia32_unpckhpd256 (v4df,v4df)
16591 v8sf __builtin_ia32_unpckhps256 (v8sf,v8sf)
16592 v4df __builtin_ia32_unpcklpd256 (v4df,v4df)
16593 v8sf __builtin_ia32_unpcklps256 (v8sf,v8sf)
16594 v4df __builtin_ia32_vbroadcastf128_pd256 (pcv2df)
16595 v8sf __builtin_ia32_vbroadcastf128_ps256 (pcv4sf)
16596 v4df __builtin_ia32_vbroadcastsd256 (pcdouble)
16597 v4sf __builtin_ia32_vbroadcastss (pcfloat)
16598 v8sf __builtin_ia32_vbroadcastss256 (pcfloat)
16599 v2df __builtin_ia32_vextractf128_pd256 (v4df,int)
16600 v4sf __builtin_ia32_vextractf128_ps256 (v8sf,int)
16601 v4si __builtin_ia32_vextractf128_si256 (v8si,int)
16602 v4df __builtin_ia32_vinsertf128_pd256 (v4df,v2df,int)
16603 v8sf __builtin_ia32_vinsertf128_ps256 (v8sf,v4sf,int)
16604 v8si __builtin_ia32_vinsertf128_si256 (v8si,v4si,int)
16605 v4df __builtin_ia32_vperm2f128_pd256 (v4df,v4df,int)
16606 v8sf __builtin_ia32_vperm2f128_ps256 (v8sf,v8sf,int)
16607 v8si __builtin_ia32_vperm2f128_si256 (v8si,v8si,int)
16608 v2df __builtin_ia32_vpermil2pd (v2df,v2df,v2di,int)
16609 v4df __builtin_ia32_vpermil2pd256 (v4df,v4df,v4di,int)
16610 v4sf __builtin_ia32_vpermil2ps (v4sf,v4sf,v4si,int)
16611 v8sf __builtin_ia32_vpermil2ps256 (v8sf,v8sf,v8si,int)
16612 v2df __builtin_ia32_vpermilpd (v2df,int)
16613 v4df __builtin_ia32_vpermilpd256 (v4df,int)
16614 v4sf __builtin_ia32_vpermilps (v4sf,int)
16615 v8sf __builtin_ia32_vpermilps256 (v8sf,int)
16616 v2df __builtin_ia32_vpermilvarpd (v2df,v2di)
16617 v4df __builtin_ia32_vpermilvarpd256 (v4df,v4di)
16618 v4sf __builtin_ia32_vpermilvarps (v4sf,v4si)
16619 v8sf __builtin_ia32_vpermilvarps256 (v8sf,v8si)
16620 int __builtin_ia32_vtestcpd (v2df,v2df,ptest)
16621 int __builtin_ia32_vtestcpd256 (v4df,v4df,ptest)
16622 int __builtin_ia32_vtestcps (v4sf,v4sf,ptest)
16623 int __builtin_ia32_vtestcps256 (v8sf,v8sf,ptest)
16624 int __builtin_ia32_vtestnzcpd (v2df,v2df,ptest)
16625 int __builtin_ia32_vtestnzcpd256 (v4df,v4df,ptest)
16626 int __builtin_ia32_vtestnzcps (v4sf,v4sf,ptest)
16627 int __builtin_ia32_vtestnzcps256 (v8sf,v8sf,ptest)
16628 int __builtin_ia32_vtestzpd (v2df,v2df,ptest)
16629 int __builtin_ia32_vtestzpd256 (v4df,v4df,ptest)
16630 int __builtin_ia32_vtestzps (v4sf,v4sf,ptest)
16631 int __builtin_ia32_vtestzps256 (v8sf,v8sf,ptest)
16632 void __builtin_ia32_vzeroall (void)
16633 void __builtin_ia32_vzeroupper (void)
16634 v4df __builtin_ia32_xorpd256 (v4df,v4df)
16635 v8sf __builtin_ia32_xorps256 (v8sf,v8sf)
16638 The following built-in functions are available when @option{-mavx2} is
16639 used. All of them generate the machine instruction that is part of the
16643 v32qi __builtin_ia32_mpsadbw256 (v32qi,v32qi,int)
16644 v32qi __builtin_ia32_pabsb256 (v32qi)
16645 v16hi __builtin_ia32_pabsw256 (v16hi)
16646 v8si __builtin_ia32_pabsd256 (v8si)
16647 v16hi __builtin_ia32_packssdw256 (v8si,v8si)
16648 v32qi __builtin_ia32_packsswb256 (v16hi,v16hi)
16649 v16hi __builtin_ia32_packusdw256 (v8si,v8si)
16650 v32qi __builtin_ia32_packuswb256 (v16hi,v16hi)
16651 v32qi __builtin_ia32_paddb256 (v32qi,v32qi)
16652 v16hi __builtin_ia32_paddw256 (v16hi,v16hi)
16653 v8si __builtin_ia32_paddd256 (v8si,v8si)
16654 v4di __builtin_ia32_paddq256 (v4di,v4di)
16655 v32qi __builtin_ia32_paddsb256 (v32qi,v32qi)
16656 v16hi __builtin_ia32_paddsw256 (v16hi,v16hi)
16657 v32qi __builtin_ia32_paddusb256 (v32qi,v32qi)
16658 v16hi __builtin_ia32_paddusw256 (v16hi,v16hi)
16659 v4di __builtin_ia32_palignr256 (v4di,v4di,int)
16660 v4di __builtin_ia32_andsi256 (v4di,v4di)
16661 v4di __builtin_ia32_andnotsi256 (v4di,v4di)
16662 v32qi __builtin_ia32_pavgb256 (v32qi,v32qi)
16663 v16hi __builtin_ia32_pavgw256 (v16hi,v16hi)
16664 v32qi __builtin_ia32_pblendvb256 (v32qi,v32qi,v32qi)
16665 v16hi __builtin_ia32_pblendw256 (v16hi,v16hi,int)
16666 v32qi __builtin_ia32_pcmpeqb256 (v32qi,v32qi)
16667 v16hi __builtin_ia32_pcmpeqw256 (v16hi,v16hi)
16668 v8si __builtin_ia32_pcmpeqd256 (c8si,v8si)
16669 v4di __builtin_ia32_pcmpeqq256 (v4di,v4di)
16670 v32qi __builtin_ia32_pcmpgtb256 (v32qi,v32qi)
16671 v16hi __builtin_ia32_pcmpgtw256 (16hi,v16hi)
16672 v8si __builtin_ia32_pcmpgtd256 (v8si,v8si)
16673 v4di __builtin_ia32_pcmpgtq256 (v4di,v4di)
16674 v16hi __builtin_ia32_phaddw256 (v16hi,v16hi)
16675 v8si __builtin_ia32_phaddd256 (v8si,v8si)
16676 v16hi __builtin_ia32_phaddsw256 (v16hi,v16hi)
16677 v16hi __builtin_ia32_phsubw256 (v16hi,v16hi)
16678 v8si __builtin_ia32_phsubd256 (v8si,v8si)
16679 v16hi __builtin_ia32_phsubsw256 (v16hi,v16hi)
16680 v32qi __builtin_ia32_pmaddubsw256 (v32qi,v32qi)
16681 v16hi __builtin_ia32_pmaddwd256 (v16hi,v16hi)
16682 v32qi __builtin_ia32_pmaxsb256 (v32qi,v32qi)
16683 v16hi __builtin_ia32_pmaxsw256 (v16hi,v16hi)
16684 v8si __builtin_ia32_pmaxsd256 (v8si,v8si)
16685 v32qi __builtin_ia32_pmaxub256 (v32qi,v32qi)
16686 v16hi __builtin_ia32_pmaxuw256 (v16hi,v16hi)
16687 v8si __builtin_ia32_pmaxud256 (v8si,v8si)
16688 v32qi __builtin_ia32_pminsb256 (v32qi,v32qi)
16689 v16hi __builtin_ia32_pminsw256 (v16hi,v16hi)
16690 v8si __builtin_ia32_pminsd256 (v8si,v8si)
16691 v32qi __builtin_ia32_pminub256 (v32qi,v32qi)
16692 v16hi __builtin_ia32_pminuw256 (v16hi,v16hi)
16693 v8si __builtin_ia32_pminud256 (v8si,v8si)
16694 int __builtin_ia32_pmovmskb256 (v32qi)
16695 v16hi __builtin_ia32_pmovsxbw256 (v16qi)
16696 v8si __builtin_ia32_pmovsxbd256 (v16qi)
16697 v4di __builtin_ia32_pmovsxbq256 (v16qi)
16698 v8si __builtin_ia32_pmovsxwd256 (v8hi)
16699 v4di __builtin_ia32_pmovsxwq256 (v8hi)
16700 v4di __builtin_ia32_pmovsxdq256 (v4si)
16701 v16hi __builtin_ia32_pmovzxbw256 (v16qi)
16702 v8si __builtin_ia32_pmovzxbd256 (v16qi)
16703 v4di __builtin_ia32_pmovzxbq256 (v16qi)
16704 v8si __builtin_ia32_pmovzxwd256 (v8hi)
16705 v4di __builtin_ia32_pmovzxwq256 (v8hi)
16706 v4di __builtin_ia32_pmovzxdq256 (v4si)
16707 v4di __builtin_ia32_pmuldq256 (v8si,v8si)
16708 v16hi __builtin_ia32_pmulhrsw256 (v16hi, v16hi)
16709 v16hi __builtin_ia32_pmulhuw256 (v16hi,v16hi)
16710 v16hi __builtin_ia32_pmulhw256 (v16hi,v16hi)
16711 v16hi __builtin_ia32_pmullw256 (v16hi,v16hi)
16712 v8si __builtin_ia32_pmulld256 (v8si,v8si)
16713 v4di __builtin_ia32_pmuludq256 (v8si,v8si)
16714 v4di __builtin_ia32_por256 (v4di,v4di)
16715 v16hi __builtin_ia32_psadbw256 (v32qi,v32qi)
16716 v32qi __builtin_ia32_pshufb256 (v32qi,v32qi)
16717 v8si __builtin_ia32_pshufd256 (v8si,int)
16718 v16hi __builtin_ia32_pshufhw256 (v16hi,int)
16719 v16hi __builtin_ia32_pshuflw256 (v16hi,int)
16720 v32qi __builtin_ia32_psignb256 (v32qi,v32qi)
16721 v16hi __builtin_ia32_psignw256 (v16hi,v16hi)
16722 v8si __builtin_ia32_psignd256 (v8si,v8si)
16723 v4di __builtin_ia32_pslldqi256 (v4di,int)
16724 v16hi __builtin_ia32_psllwi256 (16hi,int)
16725 v16hi __builtin_ia32_psllw256(v16hi,v8hi)
16726 v8si __builtin_ia32_pslldi256 (v8si,int)
16727 v8si __builtin_ia32_pslld256(v8si,v4si)
16728 v4di __builtin_ia32_psllqi256 (v4di,int)
16729 v4di __builtin_ia32_psllq256(v4di,v2di)
16730 v16hi __builtin_ia32_psrawi256 (v16hi,int)
16731 v16hi __builtin_ia32_psraw256 (v16hi,v8hi)
16732 v8si __builtin_ia32_psradi256 (v8si,int)
16733 v8si __builtin_ia32_psrad256 (v8si,v4si)
16734 v4di __builtin_ia32_psrldqi256 (v4di, int)
16735 v16hi __builtin_ia32_psrlwi256 (v16hi,int)
16736 v16hi __builtin_ia32_psrlw256 (v16hi,v8hi)
16737 v8si __builtin_ia32_psrldi256 (v8si,int)
16738 v8si __builtin_ia32_psrld256 (v8si,v4si)
16739 v4di __builtin_ia32_psrlqi256 (v4di,int)
16740 v4di __builtin_ia32_psrlq256(v4di,v2di)
16741 v32qi __builtin_ia32_psubb256 (v32qi,v32qi)
16742 v32hi __builtin_ia32_psubw256 (v16hi,v16hi)
16743 v8si __builtin_ia32_psubd256 (v8si,v8si)
16744 v4di __builtin_ia32_psubq256 (v4di,v4di)
16745 v32qi __builtin_ia32_psubsb256 (v32qi,v32qi)
16746 v16hi __builtin_ia32_psubsw256 (v16hi,v16hi)
16747 v32qi __builtin_ia32_psubusb256 (v32qi,v32qi)
16748 v16hi __builtin_ia32_psubusw256 (v16hi,v16hi)
16749 v32qi __builtin_ia32_punpckhbw256 (v32qi,v32qi)
16750 v16hi __builtin_ia32_punpckhwd256 (v16hi,v16hi)
16751 v8si __builtin_ia32_punpckhdq256 (v8si,v8si)
16752 v4di __builtin_ia32_punpckhqdq256 (v4di,v4di)
16753 v32qi __builtin_ia32_punpcklbw256 (v32qi,v32qi)
16754 v16hi __builtin_ia32_punpcklwd256 (v16hi,v16hi)
16755 v8si __builtin_ia32_punpckldq256 (v8si,v8si)
16756 v4di __builtin_ia32_punpcklqdq256 (v4di,v4di)
16757 v4di __builtin_ia32_pxor256 (v4di,v4di)
16758 v4di __builtin_ia32_movntdqa256 (pv4di)
16759 v4sf __builtin_ia32_vbroadcastss_ps (v4sf)
16760 v8sf __builtin_ia32_vbroadcastss_ps256 (v4sf)
16761 v4df __builtin_ia32_vbroadcastsd_pd256 (v2df)
16762 v4di __builtin_ia32_vbroadcastsi256 (v2di)
16763 v4si __builtin_ia32_pblendd128 (v4si,v4si)
16764 v8si __builtin_ia32_pblendd256 (v8si,v8si)
16765 v32qi __builtin_ia32_pbroadcastb256 (v16qi)
16766 v16hi __builtin_ia32_pbroadcastw256 (v8hi)
16767 v8si __builtin_ia32_pbroadcastd256 (v4si)
16768 v4di __builtin_ia32_pbroadcastq256 (v2di)
16769 v16qi __builtin_ia32_pbroadcastb128 (v16qi)
16770 v8hi __builtin_ia32_pbroadcastw128 (v8hi)
16771 v4si __builtin_ia32_pbroadcastd128 (v4si)
16772 v2di __builtin_ia32_pbroadcastq128 (v2di)
16773 v8si __builtin_ia32_permvarsi256 (v8si,v8si)
16774 v4df __builtin_ia32_permdf256 (v4df,int)
16775 v8sf __builtin_ia32_permvarsf256 (v8sf,v8sf)
16776 v4di __builtin_ia32_permdi256 (v4di,int)
16777 v4di __builtin_ia32_permti256 (v4di,v4di,int)
16778 v4di __builtin_ia32_extract128i256 (v4di,int)
16779 v4di __builtin_ia32_insert128i256 (v4di,v2di,int)
16780 v8si __builtin_ia32_maskloadd256 (pcv8si,v8si)
16781 v4di __builtin_ia32_maskloadq256 (pcv4di,v4di)
16782 v4si __builtin_ia32_maskloadd (pcv4si,v4si)
16783 v2di __builtin_ia32_maskloadq (pcv2di,v2di)
16784 void __builtin_ia32_maskstored256 (pv8si,v8si,v8si)
16785 void __builtin_ia32_maskstoreq256 (pv4di,v4di,v4di)
16786 void __builtin_ia32_maskstored (pv4si,v4si,v4si)
16787 void __builtin_ia32_maskstoreq (pv2di,v2di,v2di)
16788 v8si __builtin_ia32_psllv8si (v8si,v8si)
16789 v4si __builtin_ia32_psllv4si (v4si,v4si)
16790 v4di __builtin_ia32_psllv4di (v4di,v4di)
16791 v2di __builtin_ia32_psllv2di (v2di,v2di)
16792 v8si __builtin_ia32_psrav8si (v8si,v8si)
16793 v4si __builtin_ia32_psrav4si (v4si,v4si)
16794 v8si __builtin_ia32_psrlv8si (v8si,v8si)
16795 v4si __builtin_ia32_psrlv4si (v4si,v4si)
16796 v4di __builtin_ia32_psrlv4di (v4di,v4di)
16797 v2di __builtin_ia32_psrlv2di (v2di,v2di)
16798 v2df __builtin_ia32_gathersiv2df (v2df, pcdouble,v4si,v2df,int)
16799 v4df __builtin_ia32_gathersiv4df (v4df, pcdouble,v4si,v4df,int)
16800 v2df __builtin_ia32_gatherdiv2df (v2df, pcdouble,v2di,v2df,int)
16801 v4df __builtin_ia32_gatherdiv4df (v4df, pcdouble,v4di,v4df,int)
16802 v4sf __builtin_ia32_gathersiv4sf (v4sf, pcfloat,v4si,v4sf,int)
16803 v8sf __builtin_ia32_gathersiv8sf (v8sf, pcfloat,v8si,v8sf,int)
16804 v4sf __builtin_ia32_gatherdiv4sf (v4sf, pcfloat,v2di,v4sf,int)
16805 v4sf __builtin_ia32_gatherdiv4sf256 (v4sf, pcfloat,v4di,v4sf,int)
16806 v2di __builtin_ia32_gathersiv2di (v2di, pcint64,v4si,v2di,int)
16807 v4di __builtin_ia32_gathersiv4di (v4di, pcint64,v4si,v4di,int)
16808 v2di __builtin_ia32_gatherdiv2di (v2di, pcint64,v2di,v2di,int)
16809 v4di __builtin_ia32_gatherdiv4di (v4di, pcint64,v4di,v4di,int)
16810 v4si __builtin_ia32_gathersiv4si (v4si, pcint,v4si,v4si,int)
16811 v8si __builtin_ia32_gathersiv8si (v8si, pcint,v8si,v8si,int)
16812 v4si __builtin_ia32_gatherdiv4si (v4si, pcint,v2di,v4si,int)
16813 v4si __builtin_ia32_gatherdiv4si256 (v4si, pcint,v4di,v4si,int)
16816 The following built-in functions are available when @option{-maes} is
16817 used. All of them generate the machine instruction that is part of the
16821 v2di __builtin_ia32_aesenc128 (v2di, v2di)
16822 v2di __builtin_ia32_aesenclast128 (v2di, v2di)
16823 v2di __builtin_ia32_aesdec128 (v2di, v2di)
16824 v2di __builtin_ia32_aesdeclast128 (v2di, v2di)
16825 v2di __builtin_ia32_aeskeygenassist128 (v2di, const int)
16826 v2di __builtin_ia32_aesimc128 (v2di)
16829 The following built-in function is available when @option{-mpclmul} is
16833 @item v2di __builtin_ia32_pclmulqdq128 (v2di, v2di, const int)
16834 Generates the @code{pclmulqdq} machine instruction.
16837 The following built-in function is available when @option{-mfsgsbase} is
16838 used. All of them generate the machine instruction that is part of the
16842 unsigned int __builtin_ia32_rdfsbase32 (void)
16843 unsigned long long __builtin_ia32_rdfsbase64 (void)
16844 unsigned int __builtin_ia32_rdgsbase32 (void)
16845 unsigned long long __builtin_ia32_rdgsbase64 (void)
16846 void _writefsbase_u32 (unsigned int)
16847 void _writefsbase_u64 (unsigned long long)
16848 void _writegsbase_u32 (unsigned int)
16849 void _writegsbase_u64 (unsigned long long)
16852 The following built-in function is available when @option{-mrdrnd} is
16853 used. All of them generate the machine instruction that is part of the
16857 unsigned int __builtin_ia32_rdrand16_step (unsigned short *)
16858 unsigned int __builtin_ia32_rdrand32_step (unsigned int *)
16859 unsigned int __builtin_ia32_rdrand64_step (unsigned long long *)
16862 The following built-in functions are available when @option{-msse4a} is used.
16863 All of them generate the machine instruction that is part of the name.
16866 void __builtin_ia32_movntsd (double *, v2df)
16867 void __builtin_ia32_movntss (float *, v4sf)
16868 v2di __builtin_ia32_extrq (v2di, v16qi)
16869 v2di __builtin_ia32_extrqi (v2di, const unsigned int, const unsigned int)
16870 v2di __builtin_ia32_insertq (v2di, v2di)
16871 v2di __builtin_ia32_insertqi (v2di, v2di, const unsigned int, const unsigned int)
16874 The following built-in functions are available when @option{-mxop} is used.
16876 v2df __builtin_ia32_vfrczpd (v2df)
16877 v4sf __builtin_ia32_vfrczps (v4sf)
16878 v2df __builtin_ia32_vfrczsd (v2df)
16879 v4sf __builtin_ia32_vfrczss (v4sf)
16880 v4df __builtin_ia32_vfrczpd256 (v4df)
16881 v8sf __builtin_ia32_vfrczps256 (v8sf)
16882 v2di __builtin_ia32_vpcmov (v2di, v2di, v2di)
16883 v2di __builtin_ia32_vpcmov_v2di (v2di, v2di, v2di)
16884 v4si __builtin_ia32_vpcmov_v4si (v4si, v4si, v4si)
16885 v8hi __builtin_ia32_vpcmov_v8hi (v8hi, v8hi, v8hi)
16886 v16qi __builtin_ia32_vpcmov_v16qi (v16qi, v16qi, v16qi)
16887 v2df __builtin_ia32_vpcmov_v2df (v2df, v2df, v2df)
16888 v4sf __builtin_ia32_vpcmov_v4sf (v4sf, v4sf, v4sf)
16889 v4di __builtin_ia32_vpcmov_v4di256 (v4di, v4di, v4di)
16890 v8si __builtin_ia32_vpcmov_v8si256 (v8si, v8si, v8si)
16891 v16hi __builtin_ia32_vpcmov_v16hi256 (v16hi, v16hi, v16hi)
16892 v32qi __builtin_ia32_vpcmov_v32qi256 (v32qi, v32qi, v32qi)
16893 v4df __builtin_ia32_vpcmov_v4df256 (v4df, v4df, v4df)
16894 v8sf __builtin_ia32_vpcmov_v8sf256 (v8sf, v8sf, v8sf)
16895 v16qi __builtin_ia32_vpcomeqb (v16qi, v16qi)
16896 v8hi __builtin_ia32_vpcomeqw (v8hi, v8hi)
16897 v4si __builtin_ia32_vpcomeqd (v4si, v4si)
16898 v2di __builtin_ia32_vpcomeqq (v2di, v2di)
16899 v16qi __builtin_ia32_vpcomequb (v16qi, v16qi)
16900 v4si __builtin_ia32_vpcomequd (v4si, v4si)
16901 v2di __builtin_ia32_vpcomequq (v2di, v2di)
16902 v8hi __builtin_ia32_vpcomequw (v8hi, v8hi)
16903 v8hi __builtin_ia32_vpcomeqw (v8hi, v8hi)
16904 v16qi __builtin_ia32_vpcomfalseb (v16qi, v16qi)
16905 v4si __builtin_ia32_vpcomfalsed (v4si, v4si)
16906 v2di __builtin_ia32_vpcomfalseq (v2di, v2di)
16907 v16qi __builtin_ia32_vpcomfalseub (v16qi, v16qi)
16908 v4si __builtin_ia32_vpcomfalseud (v4si, v4si)
16909 v2di __builtin_ia32_vpcomfalseuq (v2di, v2di)
16910 v8hi __builtin_ia32_vpcomfalseuw (v8hi, v8hi)
16911 v8hi __builtin_ia32_vpcomfalsew (v8hi, v8hi)
16912 v16qi __builtin_ia32_vpcomgeb (v16qi, v16qi)
16913 v4si __builtin_ia32_vpcomged (v4si, v4si)
16914 v2di __builtin_ia32_vpcomgeq (v2di, v2di)
16915 v16qi __builtin_ia32_vpcomgeub (v16qi, v16qi)
16916 v4si __builtin_ia32_vpcomgeud (v4si, v4si)
16917 v2di __builtin_ia32_vpcomgeuq (v2di, v2di)
16918 v8hi __builtin_ia32_vpcomgeuw (v8hi, v8hi)
16919 v8hi __builtin_ia32_vpcomgew (v8hi, v8hi)
16920 v16qi __builtin_ia32_vpcomgtb (v16qi, v16qi)
16921 v4si __builtin_ia32_vpcomgtd (v4si, v4si)
16922 v2di __builtin_ia32_vpcomgtq (v2di, v2di)
16923 v16qi __builtin_ia32_vpcomgtub (v16qi, v16qi)
16924 v4si __builtin_ia32_vpcomgtud (v4si, v4si)
16925 v2di __builtin_ia32_vpcomgtuq (v2di, v2di)
16926 v8hi __builtin_ia32_vpcomgtuw (v8hi, v8hi)
16927 v8hi __builtin_ia32_vpcomgtw (v8hi, v8hi)
16928 v16qi __builtin_ia32_vpcomleb (v16qi, v16qi)
16929 v4si __builtin_ia32_vpcomled (v4si, v4si)
16930 v2di __builtin_ia32_vpcomleq (v2di, v2di)
16931 v16qi __builtin_ia32_vpcomleub (v16qi, v16qi)
16932 v4si __builtin_ia32_vpcomleud (v4si, v4si)
16933 v2di __builtin_ia32_vpcomleuq (v2di, v2di)
16934 v8hi __builtin_ia32_vpcomleuw (v8hi, v8hi)
16935 v8hi __builtin_ia32_vpcomlew (v8hi, v8hi)
16936 v16qi __builtin_ia32_vpcomltb (v16qi, v16qi)
16937 v4si __builtin_ia32_vpcomltd (v4si, v4si)
16938 v2di __builtin_ia32_vpcomltq (v2di, v2di)
16939 v16qi __builtin_ia32_vpcomltub (v16qi, v16qi)
16940 v4si __builtin_ia32_vpcomltud (v4si, v4si)
16941 v2di __builtin_ia32_vpcomltuq (v2di, v2di)
16942 v8hi __builtin_ia32_vpcomltuw (v8hi, v8hi)
16943 v8hi __builtin_ia32_vpcomltw (v8hi, v8hi)
16944 v16qi __builtin_ia32_vpcomneb (v16qi, v16qi)
16945 v4si __builtin_ia32_vpcomned (v4si, v4si)
16946 v2di __builtin_ia32_vpcomneq (v2di, v2di)
16947 v16qi __builtin_ia32_vpcomneub (v16qi, v16qi)
16948 v4si __builtin_ia32_vpcomneud (v4si, v4si)
16949 v2di __builtin_ia32_vpcomneuq (v2di, v2di)
16950 v8hi __builtin_ia32_vpcomneuw (v8hi, v8hi)
16951 v8hi __builtin_ia32_vpcomnew (v8hi, v8hi)
16952 v16qi __builtin_ia32_vpcomtrueb (v16qi, v16qi)
16953 v4si __builtin_ia32_vpcomtrued (v4si, v4si)
16954 v2di __builtin_ia32_vpcomtrueq (v2di, v2di)
16955 v16qi __builtin_ia32_vpcomtrueub (v16qi, v16qi)
16956 v4si __builtin_ia32_vpcomtrueud (v4si, v4si)
16957 v2di __builtin_ia32_vpcomtrueuq (v2di, v2di)
16958 v8hi __builtin_ia32_vpcomtrueuw (v8hi, v8hi)
16959 v8hi __builtin_ia32_vpcomtruew (v8hi, v8hi)
16960 v4si __builtin_ia32_vphaddbd (v16qi)
16961 v2di __builtin_ia32_vphaddbq (v16qi)
16962 v8hi __builtin_ia32_vphaddbw (v16qi)
16963 v2di __builtin_ia32_vphadddq (v4si)
16964 v4si __builtin_ia32_vphaddubd (v16qi)
16965 v2di __builtin_ia32_vphaddubq (v16qi)
16966 v8hi __builtin_ia32_vphaddubw (v16qi)
16967 v2di __builtin_ia32_vphaddudq (v4si)
16968 v4si __builtin_ia32_vphadduwd (v8hi)
16969 v2di __builtin_ia32_vphadduwq (v8hi)
16970 v4si __builtin_ia32_vphaddwd (v8hi)
16971 v2di __builtin_ia32_vphaddwq (v8hi)
16972 v8hi __builtin_ia32_vphsubbw (v16qi)
16973 v2di __builtin_ia32_vphsubdq (v4si)
16974 v4si __builtin_ia32_vphsubwd (v8hi)
16975 v4si __builtin_ia32_vpmacsdd (v4si, v4si, v4si)
16976 v2di __builtin_ia32_vpmacsdqh (v4si, v4si, v2di)
16977 v2di __builtin_ia32_vpmacsdql (v4si, v4si, v2di)
16978 v4si __builtin_ia32_vpmacssdd (v4si, v4si, v4si)
16979 v2di __builtin_ia32_vpmacssdqh (v4si, v4si, v2di)
16980 v2di __builtin_ia32_vpmacssdql (v4si, v4si, v2di)
16981 v4si __builtin_ia32_vpmacsswd (v8hi, v8hi, v4si)
16982 v8hi __builtin_ia32_vpmacssww (v8hi, v8hi, v8hi)
16983 v4si __builtin_ia32_vpmacswd (v8hi, v8hi, v4si)
16984 v8hi __builtin_ia32_vpmacsww (v8hi, v8hi, v8hi)
16985 v4si __builtin_ia32_vpmadcsswd (v8hi, v8hi, v4si)
16986 v4si __builtin_ia32_vpmadcswd (v8hi, v8hi, v4si)
16987 v16qi __builtin_ia32_vpperm (v16qi, v16qi, v16qi)
16988 v16qi __builtin_ia32_vprotb (v16qi, v16qi)
16989 v4si __builtin_ia32_vprotd (v4si, v4si)
16990 v2di __builtin_ia32_vprotq (v2di, v2di)
16991 v8hi __builtin_ia32_vprotw (v8hi, v8hi)
16992 v16qi __builtin_ia32_vpshab (v16qi, v16qi)
16993 v4si __builtin_ia32_vpshad (v4si, v4si)
16994 v2di __builtin_ia32_vpshaq (v2di, v2di)
16995 v8hi __builtin_ia32_vpshaw (v8hi, v8hi)
16996 v16qi __builtin_ia32_vpshlb (v16qi, v16qi)
16997 v4si __builtin_ia32_vpshld (v4si, v4si)
16998 v2di __builtin_ia32_vpshlq (v2di, v2di)
16999 v8hi __builtin_ia32_vpshlw (v8hi, v8hi)
17002 The following built-in functions are available when @option{-mfma4} is used.
17003 All of them generate the machine instruction that is part of the name.
17006 v2df __builtin_ia32_vfmaddpd (v2df, v2df, v2df)
17007 v4sf __builtin_ia32_vfmaddps (v4sf, v4sf, v4sf)
17008 v2df __builtin_ia32_vfmaddsd (v2df, v2df, v2df)
17009 v4sf __builtin_ia32_vfmaddss (v4sf, v4sf, v4sf)
17010 v2df __builtin_ia32_vfmsubpd (v2df, v2df, v2df)
17011 v4sf __builtin_ia32_vfmsubps (v4sf, v4sf, v4sf)
17012 v2df __builtin_ia32_vfmsubsd (v2df, v2df, v2df)
17013 v4sf __builtin_ia32_vfmsubss (v4sf, v4sf, v4sf)
17014 v2df __builtin_ia32_vfnmaddpd (v2df, v2df, v2df)
17015 v4sf __builtin_ia32_vfnmaddps (v4sf, v4sf, v4sf)
17016 v2df __builtin_ia32_vfnmaddsd (v2df, v2df, v2df)
17017 v4sf __builtin_ia32_vfnmaddss (v4sf, v4sf, v4sf)
17018 v2df __builtin_ia32_vfnmsubpd (v2df, v2df, v2df)
17019 v4sf __builtin_ia32_vfnmsubps (v4sf, v4sf, v4sf)
17020 v2df __builtin_ia32_vfnmsubsd (v2df, v2df, v2df)
17021 v4sf __builtin_ia32_vfnmsubss (v4sf, v4sf, v4sf)
17022 v2df __builtin_ia32_vfmaddsubpd (v2df, v2df, v2df)
17023 v4sf __builtin_ia32_vfmaddsubps (v4sf, v4sf, v4sf)
17024 v2df __builtin_ia32_vfmsubaddpd (v2df, v2df, v2df)
17025 v4sf __builtin_ia32_vfmsubaddps (v4sf, v4sf, v4sf)
17026 v4df __builtin_ia32_vfmaddpd256 (v4df, v4df, v4df)
17027 v8sf __builtin_ia32_vfmaddps256 (v8sf, v8sf, v8sf)
17028 v4df __builtin_ia32_vfmsubpd256 (v4df, v4df, v4df)
17029 v8sf __builtin_ia32_vfmsubps256 (v8sf, v8sf, v8sf)
17030 v4df __builtin_ia32_vfnmaddpd256 (v4df, v4df, v4df)
17031 v8sf __builtin_ia32_vfnmaddps256 (v8sf, v8sf, v8sf)
17032 v4df __builtin_ia32_vfnmsubpd256 (v4df, v4df, v4df)
17033 v8sf __builtin_ia32_vfnmsubps256 (v8sf, v8sf, v8sf)
17034 v4df __builtin_ia32_vfmaddsubpd256 (v4df, v4df, v4df)
17035 v8sf __builtin_ia32_vfmaddsubps256 (v8sf, v8sf, v8sf)
17036 v4df __builtin_ia32_vfmsubaddpd256 (v4df, v4df, v4df)
17037 v8sf __builtin_ia32_vfmsubaddps256 (v8sf, v8sf, v8sf)
17041 The following built-in functions are available when @option{-mlwp} is used.
17044 void __builtin_ia32_llwpcb16 (void *);
17045 void __builtin_ia32_llwpcb32 (void *);
17046 void __builtin_ia32_llwpcb64 (void *);
17047 void * __builtin_ia32_llwpcb16 (void);
17048 void * __builtin_ia32_llwpcb32 (void);
17049 void * __builtin_ia32_llwpcb64 (void);
17050 void __builtin_ia32_lwpval16 (unsigned short, unsigned int, unsigned short)
17051 void __builtin_ia32_lwpval32 (unsigned int, unsigned int, unsigned int)
17052 void __builtin_ia32_lwpval64 (unsigned __int64, unsigned int, unsigned int)
17053 unsigned char __builtin_ia32_lwpins16 (unsigned short, unsigned int, unsigned short)
17054 unsigned char __builtin_ia32_lwpins32 (unsigned int, unsigned int, unsigned int)
17055 unsigned char __builtin_ia32_lwpins64 (unsigned __int64, unsigned int, unsigned int)
17058 The following built-in functions are available when @option{-mbmi} is used.
17059 All of them generate the machine instruction that is part of the name.
17061 unsigned int __builtin_ia32_bextr_u32(unsigned int, unsigned int);
17062 unsigned long long __builtin_ia32_bextr_u64 (unsigned long long, unsigned long long);
17065 The following built-in functions are available when @option{-mbmi2} is used.
17066 All of them generate the machine instruction that is part of the name.
17068 unsigned int _bzhi_u32 (unsigned int, unsigned int)
17069 unsigned int _pdep_u32 (unsigned int, unsigned int)
17070 unsigned int _pext_u32 (unsigned int, unsigned int)
17071 unsigned long long _bzhi_u64 (unsigned long long, unsigned long long)
17072 unsigned long long _pdep_u64 (unsigned long long, unsigned long long)
17073 unsigned long long _pext_u64 (unsigned long long, unsigned long long)
17076 The following built-in functions are available when @option{-mlzcnt} is used.
17077 All of them generate the machine instruction that is part of the name.
17079 unsigned short __builtin_ia32_lzcnt_16(unsigned short);
17080 unsigned int __builtin_ia32_lzcnt_u32(unsigned int);
17081 unsigned long long __builtin_ia32_lzcnt_u64 (unsigned long long);
17084 The following built-in functions are available when @option{-mfxsr} is used.
17085 All of them generate the machine instruction that is part of the name.
17087 void __builtin_ia32_fxsave (void *)
17088 void __builtin_ia32_fxrstor (void *)
17089 void __builtin_ia32_fxsave64 (void *)
17090 void __builtin_ia32_fxrstor64 (void *)
17093 The following built-in functions are available when @option{-mxsave} is used.
17094 All of them generate the machine instruction that is part of the name.
17096 void __builtin_ia32_xsave (void *, long long)
17097 void __builtin_ia32_xrstor (void *, long long)
17098 void __builtin_ia32_xsave64 (void *, long long)
17099 void __builtin_ia32_xrstor64 (void *, long long)
17102 The following built-in functions are available when @option{-mxsaveopt} is used.
17103 All of them generate the machine instruction that is part of the name.
17105 void __builtin_ia32_xsaveopt (void *, long long)
17106 void __builtin_ia32_xsaveopt64 (void *, long long)
17109 The following built-in functions are available when @option{-mtbm} is used.
17110 Both of them generate the immediate form of the bextr machine instruction.
17112 unsigned int __builtin_ia32_bextri_u32 (unsigned int, const unsigned int);
17113 unsigned long long __builtin_ia32_bextri_u64 (unsigned long long, const unsigned long long);
17117 The following built-in functions are available when @option{-m3dnow} is used.
17118 All of them generate the machine instruction that is part of the name.
17121 void __builtin_ia32_femms (void)
17122 v8qi __builtin_ia32_pavgusb (v8qi, v8qi)
17123 v2si __builtin_ia32_pf2id (v2sf)
17124 v2sf __builtin_ia32_pfacc (v2sf, v2sf)
17125 v2sf __builtin_ia32_pfadd (v2sf, v2sf)
17126 v2si __builtin_ia32_pfcmpeq (v2sf, v2sf)
17127 v2si __builtin_ia32_pfcmpge (v2sf, v2sf)
17128 v2si __builtin_ia32_pfcmpgt (v2sf, v2sf)
17129 v2sf __builtin_ia32_pfmax (v2sf, v2sf)
17130 v2sf __builtin_ia32_pfmin (v2sf, v2sf)
17131 v2sf __builtin_ia32_pfmul (v2sf, v2sf)
17132 v2sf __builtin_ia32_pfrcp (v2sf)
17133 v2sf __builtin_ia32_pfrcpit1 (v2sf, v2sf)
17134 v2sf __builtin_ia32_pfrcpit2 (v2sf, v2sf)
17135 v2sf __builtin_ia32_pfrsqrt (v2sf)
17136 v2sf __builtin_ia32_pfsub (v2sf, v2sf)
17137 v2sf __builtin_ia32_pfsubr (v2sf, v2sf)
17138 v2sf __builtin_ia32_pi2fd (v2si)
17139 v4hi __builtin_ia32_pmulhrw (v4hi, v4hi)
17142 The following built-in functions are available when both @option{-m3dnow}
17143 and @option{-march=athlon} are used. All of them generate the machine
17144 instruction that is part of the name.
17147 v2si __builtin_ia32_pf2iw (v2sf)
17148 v2sf __builtin_ia32_pfnacc (v2sf, v2sf)
17149 v2sf __builtin_ia32_pfpnacc (v2sf, v2sf)
17150 v2sf __builtin_ia32_pi2fw (v2si)
17151 v2sf __builtin_ia32_pswapdsf (v2sf)
17152 v2si __builtin_ia32_pswapdsi (v2si)
17155 The following built-in functions are available when @option{-mrtm} is used
17156 They are used for restricted transactional memory. These are the internal
17157 low level functions. Normally the functions in
17158 @ref{x86 transactional memory intrinsics} should be used instead.
17161 int __builtin_ia32_xbegin ()
17162 void __builtin_ia32_xend ()
17163 void __builtin_ia32_xabort (status)
17164 int __builtin_ia32_xtest ()
17167 @node x86 transactional memory intrinsics
17168 @subsection x86 Transactional Memory Intrinsics
17170 These hardware transactional memory intrinsics for x86 allow you to use
17171 memory transactions with RTM (Restricted Transactional Memory).
17172 This support is enabled with the @option{-mrtm} option.
17173 For using HLE (Hardware Lock Elision) see
17174 @ref{x86 specific memory model extensions for transactional memory} instead.
17176 A memory transaction commits all changes to memory in an atomic way,
17177 as visible to other threads. If the transaction fails it is rolled back
17178 and all side effects discarded.
17180 Generally there is no guarantee that a memory transaction ever succeeds
17181 and suitable fallback code always needs to be supplied.
17183 @deftypefn {RTM Function} {unsigned} _xbegin ()
17184 Start a RTM (Restricted Transactional Memory) transaction.
17185 Returns @code{_XBEGIN_STARTED} when the transaction
17186 started successfully (note this is not 0, so the constant has to be
17187 explicitly tested).
17189 If the transaction aborts, all side-effects
17190 are undone and an abort code encoded as a bit mask is returned.
17191 The following macros are defined:
17194 @item _XABORT_EXPLICIT
17195 Transaction was explicitly aborted with @code{_xabort}. The parameter passed
17196 to @code{_xabort} is available with @code{_XABORT_CODE(status)}.
17197 @item _XABORT_RETRY
17198 Transaction retry is possible.
17199 @item _XABORT_CONFLICT
17200 Transaction abort due to a memory conflict with another thread.
17201 @item _XABORT_CAPACITY
17202 Transaction abort due to the transaction using too much memory.
17203 @item _XABORT_DEBUG
17204 Transaction abort due to a debug trap.
17205 @item _XABORT_NESTED
17206 Transaction abort in an inner nested transaction.
17209 There is no guarantee
17210 any transaction ever succeeds, so there always needs to be a valid
17214 @deftypefn {RTM Function} {void} _xend ()
17215 Commit the current transaction. When no transaction is active this faults.
17216 All memory side-effects of the transaction become visible
17217 to other threads in an atomic manner.
17220 @deftypefn {RTM Function} {int} _xtest ()
17221 Return a nonzero value if a transaction is currently active, otherwise 0.
17224 @deftypefn {RTM Function} {void} _xabort (status)
17225 Abort the current transaction. When no transaction is active this is a no-op.
17226 The @var{status} is an 8-bit constant; its value is encoded in the return
17227 value from @code{_xbegin}.
17230 Here is an example showing handling for @code{_XABORT_RETRY}
17231 and a fallback path for other failures:
17234 #include <immintrin.h>
17236 int n_tries, max_tries;
17237 unsigned status = _XABORT_EXPLICIT;
17240 for (n_tries = 0; n_tries < max_tries; n_tries++)
17242 status = _xbegin ();
17243 if (status == _XBEGIN_STARTED || !(status & _XABORT_RETRY))
17246 if (status == _XBEGIN_STARTED)
17248 ... transaction code...
17253 ... non-transactional fallback path...
17258 Note that, in most cases, the transactional and non-transactional code
17259 must synchronize together to ensure consistency.
17261 @node Target Format Checks
17262 @section Format Checks Specific to Particular Target Machines
17264 For some target machines, GCC supports additional options to the
17266 (@pxref{Function Attributes,,Declaring Attributes of Functions}).
17269 * Solaris Format Checks::
17270 * Darwin Format Checks::
17273 @node Solaris Format Checks
17274 @subsection Solaris Format Checks
17276 Solaris targets support the @code{cmn_err} (or @code{__cmn_err__}) format
17277 check. @code{cmn_err} accepts a subset of the standard @code{printf}
17278 conversions, and the two-argument @code{%b} conversion for displaying
17279 bit-fields. See the Solaris man page for @code{cmn_err} for more information.
17281 @node Darwin Format Checks
17282 @subsection Darwin Format Checks
17284 Darwin targets support the @code{CFString} (or @code{__CFString__}) in the format
17285 attribute context. Declarations made with such attribution are parsed for correct syntax
17286 and format argument types. However, parsing of the format string itself is currently undefined
17287 and is not carried out by this version of the compiler.
17289 Additionally, @code{CFStringRefs} (defined by the @code{CoreFoundation} headers) may
17290 also be used as format arguments. Note that the relevant headers are only likely to be
17291 available on Darwin (OSX) installations. On such installations, the XCode and system
17292 documentation provide descriptions of @code{CFString}, @code{CFStringRefs} and
17293 associated functions.
17296 @section Pragmas Accepted by GCC
17298 @cindex @code{#pragma}
17300 GCC supports several types of pragmas, primarily in order to compile
17301 code originally written for other compilers. Note that in general
17302 we do not recommend the use of pragmas; @xref{Function Attributes},
17303 for further explanation.
17309 * RS/6000 and PowerPC Pragmas::
17311 * Solaris Pragmas::
17312 * Symbol-Renaming Pragmas::
17313 * Structure-Packing Pragmas::
17315 * Diagnostic Pragmas::
17316 * Visibility Pragmas::
17317 * Push/Pop Macro Pragmas::
17318 * Function Specific Option Pragmas::
17319 * Loop-Specific Pragmas::
17323 @subsection ARM Pragmas
17325 The ARM target defines pragmas for controlling the default addition of
17326 @code{long_call} and @code{short_call} attributes to functions.
17327 @xref{Function Attributes}, for information about the effects of these
17332 @cindex pragma, long_calls
17333 Set all subsequent functions to have the @code{long_call} attribute.
17335 @item no_long_calls
17336 @cindex pragma, no_long_calls
17337 Set all subsequent functions to have the @code{short_call} attribute.
17339 @item long_calls_off
17340 @cindex pragma, long_calls_off
17341 Do not affect the @code{long_call} or @code{short_call} attributes of
17342 subsequent functions.
17346 @subsection M32C Pragmas
17349 @item GCC memregs @var{number}
17350 @cindex pragma, memregs
17351 Overrides the command-line option @code{-memregs=} for the current
17352 file. Use with care! This pragma must be before any function in the
17353 file, and mixing different memregs values in different objects may
17354 make them incompatible. This pragma is useful when a
17355 performance-critical function uses a memreg for temporary values,
17356 as it may allow you to reduce the number of memregs used.
17358 @item ADDRESS @var{name} @var{address}
17359 @cindex pragma, address
17360 For any declared symbols matching @var{name}, this does three things
17361 to that symbol: it forces the symbol to be located at the given
17362 address (a number), it forces the symbol to be volatile, and it
17363 changes the symbol's scope to be static. This pragma exists for
17364 compatibility with other compilers, but note that the common
17365 @code{1234H} numeric syntax is not supported (use @code{0x1234}
17369 #pragma ADDRESS port3 0x103
17376 @subsection MeP Pragmas
17380 @item custom io_volatile (on|off)
17381 @cindex pragma, custom io_volatile
17382 Overrides the command-line option @code{-mio-volatile} for the current
17383 file. Note that for compatibility with future GCC releases, this
17384 option should only be used once before any @code{io} variables in each
17387 @item GCC coprocessor available @var{registers}
17388 @cindex pragma, coprocessor available
17389 Specifies which coprocessor registers are available to the register
17390 allocator. @var{registers} may be a single register, register range
17391 separated by ellipses, or comma-separated list of those. Example:
17394 #pragma GCC coprocessor available $c0...$c10, $c28
17397 @item GCC coprocessor call_saved @var{registers}
17398 @cindex pragma, coprocessor call_saved
17399 Specifies which coprocessor registers are to be saved and restored by
17400 any function using them. @var{registers} may be a single register,
17401 register range separated by ellipses, or comma-separated list of
17405 #pragma GCC coprocessor call_saved $c4...$c6, $c31
17408 @item GCC coprocessor subclass '(A|B|C|D)' = @var{registers}
17409 @cindex pragma, coprocessor subclass
17410 Creates and defines a register class. These register classes can be
17411 used by inline @code{asm} constructs. @var{registers} may be a single
17412 register, register range separated by ellipses, or comma-separated
17413 list of those. Example:
17416 #pragma GCC coprocessor subclass 'B' = $c2, $c4, $c6
17418 asm ("cpfoo %0" : "=B" (x));
17421 @item GCC disinterrupt @var{name} , @var{name} @dots{}
17422 @cindex pragma, disinterrupt
17423 For the named functions, the compiler adds code to disable interrupts
17424 for the duration of those functions. If any functions so named
17425 are not encountered in the source, a warning is emitted that the pragma is
17426 not used. Examples:
17429 #pragma disinterrupt foo
17430 #pragma disinterrupt bar, grill
17431 int foo () @{ @dots{} @}
17434 @item GCC call @var{name} , @var{name} @dots{}
17435 @cindex pragma, call
17436 For the named functions, the compiler always uses a register-indirect
17437 call model when calling the named functions. Examples:
17446 @node RS/6000 and PowerPC Pragmas
17447 @subsection RS/6000 and PowerPC Pragmas
17449 The RS/6000 and PowerPC targets define one pragma for controlling
17450 whether or not the @code{longcall} attribute is added to function
17451 declarations by default. This pragma overrides the @option{-mlongcall}
17452 option, but not the @code{longcall} and @code{shortcall} attributes.
17453 @xref{RS/6000 and PowerPC Options}, for more information about when long
17454 calls are and are not necessary.
17458 @cindex pragma, longcall
17459 Apply the @code{longcall} attribute to all subsequent function
17463 Do not apply the @code{longcall} attribute to subsequent function
17467 @c Describe h8300 pragmas here.
17468 @c Describe sh pragmas here.
17469 @c Describe v850 pragmas here.
17471 @node Darwin Pragmas
17472 @subsection Darwin Pragmas
17474 The following pragmas are available for all architectures running the
17475 Darwin operating system. These are useful for compatibility with other
17479 @item mark @var{tokens}@dots{}
17480 @cindex pragma, mark
17481 This pragma is accepted, but has no effect.
17483 @item options align=@var{alignment}
17484 @cindex pragma, options align
17485 This pragma sets the alignment of fields in structures. The values of
17486 @var{alignment} may be @code{mac68k}, to emulate m68k alignment, or
17487 @code{power}, to emulate PowerPC alignment. Uses of this pragma nest
17488 properly; to restore the previous setting, use @code{reset} for the
17491 @item segment @var{tokens}@dots{}
17492 @cindex pragma, segment
17493 This pragma is accepted, but has no effect.
17495 @item unused (@var{var} [, @var{var}]@dots{})
17496 @cindex pragma, unused
17497 This pragma declares variables to be possibly unused. GCC does not
17498 produce warnings for the listed variables. The effect is similar to
17499 that of the @code{unused} attribute, except that this pragma may appear
17500 anywhere within the variables' scopes.
17503 @node Solaris Pragmas
17504 @subsection Solaris Pragmas
17506 The Solaris target supports @code{#pragma redefine_extname}
17507 (@pxref{Symbol-Renaming Pragmas}). It also supports additional
17508 @code{#pragma} directives for compatibility with the system compiler.
17511 @item align @var{alignment} (@var{variable} [, @var{variable}]...)
17512 @cindex pragma, align
17514 Increase the minimum alignment of each @var{variable} to @var{alignment}.
17515 This is the same as GCC's @code{aligned} attribute @pxref{Variable
17516 Attributes}). Macro expansion occurs on the arguments to this pragma
17517 when compiling C and Objective-C@. It does not currently occur when
17518 compiling C++, but this is a bug which may be fixed in a future
17521 @item fini (@var{function} [, @var{function}]...)
17522 @cindex pragma, fini
17524 This pragma causes each listed @var{function} to be called after
17525 main, or during shared module unloading, by adding a call to the
17526 @code{.fini} section.
17528 @item init (@var{function} [, @var{function}]...)
17529 @cindex pragma, init
17531 This pragma causes each listed @var{function} to be called during
17532 initialization (before @code{main}) or during shared module loading, by
17533 adding a call to the @code{.init} section.
17537 @node Symbol-Renaming Pragmas
17538 @subsection Symbol-Renaming Pragmas
17540 GCC supports a @code{#pragma} directive that changes the name used in
17541 assembly for a given declaration. While this pragma is supported on all
17542 platforms, it is intended primarily to provide compatibility with the
17543 Solaris system headers. This effect can also be achieved using the asm
17544 labels extension (@pxref{Asm Labels}).
17547 @item redefine_extname @var{oldname} @var{newname}
17548 @cindex pragma, redefine_extname
17550 This pragma gives the C function @var{oldname} the assembly symbol
17551 @var{newname}. The preprocessor macro @code{__PRAGMA_REDEFINE_EXTNAME}
17552 is defined if this pragma is available (currently on all platforms).
17555 This pragma and the asm labels extension interact in a complicated
17556 manner. Here are some corner cases you may want to be aware of:
17559 @item This pragma silently applies only to declarations with external
17560 linkage. Asm labels do not have this restriction.
17562 @item In C++, this pragma silently applies only to declarations with
17563 ``C'' linkage. Again, asm labels do not have this restriction.
17565 @item If either of the ways of changing the assembly name of a
17566 declaration are applied to a declaration whose assembly name has
17567 already been determined (either by a previous use of one of these
17568 features, or because the compiler needed the assembly name in order to
17569 generate code), and the new name is different, a warning issues and
17570 the name does not change.
17572 @item The @var{oldname} used by @code{#pragma redefine_extname} is
17573 always the C-language name.
17576 @node Structure-Packing Pragmas
17577 @subsection Structure-Packing Pragmas
17579 For compatibility with Microsoft Windows compilers, GCC supports a
17580 set of @code{#pragma} directives that change the maximum alignment of
17581 members of structures (other than zero-width bit-fields), unions, and
17582 classes subsequently defined. The @var{n} value below always is required
17583 to be a small power of two and specifies the new alignment in bytes.
17586 @item @code{#pragma pack(@var{n})} simply sets the new alignment.
17587 @item @code{#pragma pack()} sets the alignment to the one that was in
17588 effect when compilation started (see also command-line option
17589 @option{-fpack-struct[=@var{n}]} @pxref{Code Gen Options}).
17590 @item @code{#pragma pack(push[,@var{n}])} pushes the current alignment
17591 setting on an internal stack and then optionally sets the new alignment.
17592 @item @code{#pragma pack(pop)} restores the alignment setting to the one
17593 saved at the top of the internal stack (and removes that stack entry).
17594 Note that @code{#pragma pack([@var{n}])} does not influence this internal
17595 stack; thus it is possible to have @code{#pragma pack(push)} followed by
17596 multiple @code{#pragma pack(@var{n})} instances and finalized by a single
17597 @code{#pragma pack(pop)}.
17600 Some targets, e.g.@: x86 and PowerPC, support the @code{ms_struct}
17601 @code{#pragma} which lays out a structure as the documented
17602 @code{__attribute__ ((ms_struct))}.
17604 @item @code{#pragma ms_struct on} turns on the layout for structures
17606 @item @code{#pragma ms_struct off} turns off the layout for structures
17608 @item @code{#pragma ms_struct reset} goes back to the default layout.
17612 @subsection Weak Pragmas
17614 For compatibility with SVR4, GCC supports a set of @code{#pragma}
17615 directives for declaring symbols to be weak, and defining weak
17619 @item #pragma weak @var{symbol}
17620 @cindex pragma, weak
17621 This pragma declares @var{symbol} to be weak, as if the declaration
17622 had the attribute of the same name. The pragma may appear before
17623 or after the declaration of @var{symbol}. It is not an error for
17624 @var{symbol} to never be defined at all.
17626 @item #pragma weak @var{symbol1} = @var{symbol2}
17627 This pragma declares @var{symbol1} to be a weak alias of @var{symbol2}.
17628 It is an error if @var{symbol2} is not defined in the current
17632 @node Diagnostic Pragmas
17633 @subsection Diagnostic Pragmas
17635 GCC allows the user to selectively enable or disable certain types of
17636 diagnostics, and change the kind of the diagnostic. For example, a
17637 project's policy might require that all sources compile with
17638 @option{-Werror} but certain files might have exceptions allowing
17639 specific types of warnings. Or, a project might selectively enable
17640 diagnostics and treat them as errors depending on which preprocessor
17641 macros are defined.
17644 @item #pragma GCC diagnostic @var{kind} @var{option}
17645 @cindex pragma, diagnostic
17647 Modifies the disposition of a diagnostic. Note that not all
17648 diagnostics are modifiable; at the moment only warnings (normally
17649 controlled by @samp{-W@dots{}}) can be controlled, and not all of them.
17650 Use @option{-fdiagnostics-show-option} to determine which diagnostics
17651 are controllable and which option controls them.
17653 @var{kind} is @samp{error} to treat this diagnostic as an error,
17654 @samp{warning} to treat it like a warning (even if @option{-Werror} is
17655 in effect), or @samp{ignored} if the diagnostic is to be ignored.
17656 @var{option} is a double quoted string that matches the command-line
17660 #pragma GCC diagnostic warning "-Wformat"
17661 #pragma GCC diagnostic error "-Wformat"
17662 #pragma GCC diagnostic ignored "-Wformat"
17665 Note that these pragmas override any command-line options. GCC keeps
17666 track of the location of each pragma, and issues diagnostics according
17667 to the state as of that point in the source file. Thus, pragmas occurring
17668 after a line do not affect diagnostics caused by that line.
17670 @item #pragma GCC diagnostic push
17671 @itemx #pragma GCC diagnostic pop
17673 Causes GCC to remember the state of the diagnostics as of each
17674 @code{push}, and restore to that point at each @code{pop}. If a
17675 @code{pop} has no matching @code{push}, the command-line options are
17679 #pragma GCC diagnostic error "-Wuninitialized"
17680 foo(a); /* error is given for this one */
17681 #pragma GCC diagnostic push
17682 #pragma GCC diagnostic ignored "-Wuninitialized"
17683 foo(b); /* no diagnostic for this one */
17684 #pragma GCC diagnostic pop
17685 foo(c); /* error is given for this one */
17686 #pragma GCC diagnostic pop
17687 foo(d); /* depends on command-line options */
17692 GCC also offers a simple mechanism for printing messages during
17696 @item #pragma message @var{string}
17697 @cindex pragma, diagnostic
17699 Prints @var{string} as a compiler message on compilation. The message
17700 is informational only, and is neither a compilation warning nor an error.
17703 #pragma message "Compiling " __FILE__ "..."
17706 @var{string} may be parenthesized, and is printed with location
17707 information. For example,
17710 #define DO_PRAGMA(x) _Pragma (#x)
17711 #define TODO(x) DO_PRAGMA(message ("TODO - " #x))
17713 TODO(Remember to fix this)
17717 prints @samp{/tmp/file.c:4: note: #pragma message:
17718 TODO - Remember to fix this}.
17722 @node Visibility Pragmas
17723 @subsection Visibility Pragmas
17726 @item #pragma GCC visibility push(@var{visibility})
17727 @itemx #pragma GCC visibility pop
17728 @cindex pragma, visibility
17730 This pragma allows the user to set the visibility for multiple
17731 declarations without having to give each a visibility attribute
17732 (@pxref{Function Attributes}).
17734 In C++, @samp{#pragma GCC visibility} affects only namespace-scope
17735 declarations. Class members and template specializations are not
17736 affected; if you want to override the visibility for a particular
17737 member or instantiation, you must use an attribute.
17742 @node Push/Pop Macro Pragmas
17743 @subsection Push/Pop Macro Pragmas
17745 For compatibility with Microsoft Windows compilers, GCC supports
17746 @samp{#pragma push_macro(@var{"macro_name"})}
17747 and @samp{#pragma pop_macro(@var{"macro_name"})}.
17750 @item #pragma push_macro(@var{"macro_name"})
17751 @cindex pragma, push_macro
17752 This pragma saves the value of the macro named as @var{macro_name} to
17753 the top of the stack for this macro.
17755 @item #pragma pop_macro(@var{"macro_name"})
17756 @cindex pragma, pop_macro
17757 This pragma sets the value of the macro named as @var{macro_name} to
17758 the value on top of the stack for this macro. If the stack for
17759 @var{macro_name} is empty, the value of the macro remains unchanged.
17766 #pragma push_macro("X")
17769 #pragma pop_macro("X")
17774 In this example, the definition of X as 1 is saved by @code{#pragma
17775 push_macro} and restored by @code{#pragma pop_macro}.
17777 @node Function Specific Option Pragmas
17778 @subsection Function Specific Option Pragmas
17781 @item #pragma GCC target (@var{"string"}...)
17782 @cindex pragma GCC target
17784 This pragma allows you to set target specific options for functions
17785 defined later in the source file. One or more strings can be
17786 specified. Each function that is defined after this point is as
17787 if @code{attribute((target("STRING")))} was specified for that
17788 function. The parenthesis around the options is optional.
17789 @xref{Function Attributes}, for more information about the
17790 @code{target} attribute and the attribute syntax.
17792 The @code{#pragma GCC target} pragma is presently implemented for
17793 x86, PowerPC, and Nios II targets only.
17797 @item #pragma GCC optimize (@var{"string"}...)
17798 @cindex pragma GCC optimize
17800 This pragma allows you to set global optimization options for functions
17801 defined later in the source file. One or more strings can be
17802 specified. Each function that is defined after this point is as
17803 if @code{attribute((optimize("STRING")))} was specified for that
17804 function. The parenthesis around the options is optional.
17805 @xref{Function Attributes}, for more information about the
17806 @code{optimize} attribute and the attribute syntax.
17810 @item #pragma GCC push_options
17811 @itemx #pragma GCC pop_options
17812 @cindex pragma GCC push_options
17813 @cindex pragma GCC pop_options
17815 These pragmas maintain a stack of the current target and optimization
17816 options. It is intended for include files where you temporarily want
17817 to switch to using a different @samp{#pragma GCC target} or
17818 @samp{#pragma GCC optimize} and then to pop back to the previous
17823 @item #pragma GCC reset_options
17824 @cindex pragma GCC reset_options
17826 This pragma clears the current @code{#pragma GCC target} and
17827 @code{#pragma GCC optimize} to use the default switches as specified
17828 on the command line.
17831 @node Loop-Specific Pragmas
17832 @subsection Loop-Specific Pragmas
17835 @item #pragma GCC ivdep
17836 @cindex pragma GCC ivdep
17839 With this pragma, the programmer asserts that there are no loop-carried
17840 dependencies which would prevent consecutive iterations of
17841 the following loop from executing concurrently with SIMD
17842 (single instruction multiple data) instructions.
17844 For example, the compiler can only unconditionally vectorize the following
17845 loop with the pragma:
17848 void foo (int n, int *a, int *b, int *c)
17852 for (i = 0; i < n; ++i)
17853 a[i] = b[i] + c[i];
17858 In this example, using the @code{restrict} qualifier had the same
17859 effect. In the following example, that would not be possible. Assume
17860 @math{k < -m} or @math{k >= m}. Only with the pragma, the compiler knows
17861 that it can unconditionally vectorize the following loop:
17864 void ignore_vec_dep (int *a, int k, int c, int m)
17867 for (int i = 0; i < m; i++)
17868 a[i] = a[i + k] * c;
17873 @node Unnamed Fields
17874 @section Unnamed Structure and Union Fields
17875 @cindex @code{struct}
17876 @cindex @code{union}
17878 As permitted by ISO C11 and for compatibility with other compilers,
17879 GCC allows you to define
17880 a structure or union that contains, as fields, structures and unions
17881 without names. For example:
17895 In this example, you are able to access members of the unnamed
17896 union with code like @samp{foo.b}. Note that only unnamed structs and
17897 unions are allowed, you may not have, for example, an unnamed
17900 You must never create such structures that cause ambiguous field definitions.
17901 For example, in this structure:
17913 it is ambiguous which @code{a} is being referred to with @samp{foo.a}.
17914 The compiler gives errors for such constructs.
17916 @opindex fms-extensions
17917 Unless @option{-fms-extensions} is used, the unnamed field must be a
17918 structure or union definition without a tag (for example, @samp{struct
17919 @{ int a; @};}). If @option{-fms-extensions} is used, the field may
17920 also be a definition with a tag such as @samp{struct foo @{ int a;
17921 @};}, a reference to a previously defined structure or union such as
17922 @samp{struct foo;}, or a reference to a @code{typedef} name for a
17923 previously defined structure or union type.
17925 @opindex fplan9-extensions
17926 The option @option{-fplan9-extensions} enables
17927 @option{-fms-extensions} as well as two other extensions. First, a
17928 pointer to a structure is automatically converted to a pointer to an
17929 anonymous field for assignments and function calls. For example:
17932 struct s1 @{ int a; @};
17933 struct s2 @{ struct s1; @};
17934 extern void f1 (struct s1 *);
17935 void f2 (struct s2 *p) @{ f1 (p); @}
17939 In the call to @code{f1} inside @code{f2}, the pointer @code{p} is
17940 converted into a pointer to the anonymous field.
17942 Second, when the type of an anonymous field is a @code{typedef} for a
17943 @code{struct} or @code{union}, code may refer to the field using the
17944 name of the @code{typedef}.
17947 typedef struct @{ int a; @} s1;
17948 struct s2 @{ s1; @};
17949 s1 f1 (struct s2 *p) @{ return p->s1; @}
17952 These usages are only permitted when they are not ambiguous.
17955 @section Thread-Local Storage
17956 @cindex Thread-Local Storage
17957 @cindex @acronym{TLS}
17958 @cindex @code{__thread}
17960 Thread-local storage (@acronym{TLS}) is a mechanism by which variables
17961 are allocated such that there is one instance of the variable per extant
17962 thread. The runtime model GCC uses to implement this originates
17963 in the IA-64 processor-specific ABI, but has since been migrated
17964 to other processors as well. It requires significant support from
17965 the linker (@command{ld}), dynamic linker (@command{ld.so}), and
17966 system libraries (@file{libc.so} and @file{libpthread.so}), so it
17967 is not available everywhere.
17969 At the user level, the extension is visible with a new storage
17970 class keyword: @code{__thread}. For example:
17974 extern __thread struct state s;
17975 static __thread char *p;
17978 The @code{__thread} specifier may be used alone, with the @code{extern}
17979 or @code{static} specifiers, but with no other storage class specifier.
17980 When used with @code{extern} or @code{static}, @code{__thread} must appear
17981 immediately after the other storage class specifier.
17983 The @code{__thread} specifier may be applied to any global, file-scoped
17984 static, function-scoped static, or static data member of a class. It may
17985 not be applied to block-scoped automatic or non-static data member.
17987 When the address-of operator is applied to a thread-local variable, it is
17988 evaluated at run time and returns the address of the current thread's
17989 instance of that variable. An address so obtained may be used by any
17990 thread. When a thread terminates, any pointers to thread-local variables
17991 in that thread become invalid.
17993 No static initialization may refer to the address of a thread-local variable.
17995 In C++, if an initializer is present for a thread-local variable, it must
17996 be a @var{constant-expression}, as defined in 5.19.2 of the ANSI/ISO C++
17999 See @uref{http://www.akkadia.org/drepper/tls.pdf,
18000 ELF Handling For Thread-Local Storage} for a detailed explanation of
18001 the four thread-local storage addressing models, and how the runtime
18002 is expected to function.
18005 * C99 Thread-Local Edits::
18006 * C++98 Thread-Local Edits::
18009 @node C99 Thread-Local Edits
18010 @subsection ISO/IEC 9899:1999 Edits for Thread-Local Storage
18012 The following are a set of changes to ISO/IEC 9899:1999 (aka C99)
18013 that document the exact semantics of the language extension.
18017 @cite{5.1.2 Execution environments}
18019 Add new text after paragraph 1
18022 Within either execution environment, a @dfn{thread} is a flow of
18023 control within a program. It is implementation defined whether
18024 or not there may be more than one thread associated with a program.
18025 It is implementation defined how threads beyond the first are
18026 created, the name and type of the function called at thread
18027 startup, and how threads may be terminated. However, objects
18028 with thread storage duration shall be initialized before thread
18033 @cite{6.2.4 Storage durations of objects}
18035 Add new text before paragraph 3
18038 An object whose identifier is declared with the storage-class
18039 specifier @w{@code{__thread}} has @dfn{thread storage duration}.
18040 Its lifetime is the entire execution of the thread, and its
18041 stored value is initialized only once, prior to thread startup.
18045 @cite{6.4.1 Keywords}
18047 Add @code{__thread}.
18050 @cite{6.7.1 Storage-class specifiers}
18052 Add @code{__thread} to the list of storage class specifiers in
18055 Change paragraph 2 to
18058 With the exception of @code{__thread}, at most one storage-class
18059 specifier may be given [@dots{}]. The @code{__thread} specifier may
18060 be used alone, or immediately following @code{extern} or
18064 Add new text after paragraph 6
18067 The declaration of an identifier for a variable that has
18068 block scope that specifies @code{__thread} shall also
18069 specify either @code{extern} or @code{static}.
18071 The @code{__thread} specifier shall be used only with
18076 @node C++98 Thread-Local Edits
18077 @subsection ISO/IEC 14882:1998 Edits for Thread-Local Storage
18079 The following are a set of changes to ISO/IEC 14882:1998 (aka C++98)
18080 that document the exact semantics of the language extension.
18084 @b{[intro.execution]}
18086 New text after paragraph 4
18089 A @dfn{thread} is a flow of control within the abstract machine.
18090 It is implementation defined whether or not there may be more than
18094 New text after paragraph 7
18097 It is unspecified whether additional action must be taken to
18098 ensure when and whether side effects are visible to other threads.
18104 Add @code{__thread}.
18107 @b{[basic.start.main]}
18109 Add after paragraph 5
18112 The thread that begins execution at the @code{main} function is called
18113 the @dfn{main thread}. It is implementation defined how functions
18114 beginning threads other than the main thread are designated or typed.
18115 A function so designated, as well as the @code{main} function, is called
18116 a @dfn{thread startup function}. It is implementation defined what
18117 happens if a thread startup function returns. It is implementation
18118 defined what happens to other threads when any thread calls @code{exit}.
18122 @b{[basic.start.init]}
18124 Add after paragraph 4
18127 The storage for an object of thread storage duration shall be
18128 statically initialized before the first statement of the thread startup
18129 function. An object of thread storage duration shall not require
18130 dynamic initialization.
18134 @b{[basic.start.term]}
18136 Add after paragraph 3
18139 The type of an object with thread storage duration shall not have a
18140 non-trivial destructor, nor shall it be an array type whose elements
18141 (directly or indirectly) have non-trivial destructors.
18147 Add ``thread storage duration'' to the list in paragraph 1.
18152 Thread, static, and automatic storage durations are associated with
18153 objects introduced by declarations [@dots{}].
18156 Add @code{__thread} to the list of specifiers in paragraph 3.
18159 @b{[basic.stc.thread]}
18161 New section before @b{[basic.stc.static]}
18164 The keyword @code{__thread} applied to a non-local object gives the
18165 object thread storage duration.
18167 A local variable or class data member declared both @code{static}
18168 and @code{__thread} gives the variable or member thread storage
18173 @b{[basic.stc.static]}
18178 All objects that have neither thread storage duration, dynamic
18179 storage duration nor are local [@dots{}].
18185 Add @code{__thread} to the list in paragraph 1.
18190 With the exception of @code{__thread}, at most one
18191 @var{storage-class-specifier} shall appear in a given
18192 @var{decl-specifier-seq}. The @code{__thread} specifier may
18193 be used alone, or immediately following the @code{extern} or
18194 @code{static} specifiers. [@dots{}]
18197 Add after paragraph 5
18200 The @code{__thread} specifier can be applied only to the names of objects
18201 and to anonymous unions.
18207 Add after paragraph 6
18210 Non-@code{static} members shall not be @code{__thread}.
18214 @node Binary constants
18215 @section Binary Constants using the @samp{0b} Prefix
18216 @cindex Binary constants using the @samp{0b} prefix
18218 Integer constants can be written as binary constants, consisting of a
18219 sequence of @samp{0} and @samp{1} digits, prefixed by @samp{0b} or
18220 @samp{0B}. This is particularly useful in environments that operate a
18221 lot on the bit level (like microcontrollers).
18223 The following statements are identical:
18232 The type of these constants follows the same rules as for octal or
18233 hexadecimal integer constants, so suffixes like @samp{L} or @samp{UL}
18236 @node C++ Extensions
18237 @chapter Extensions to the C++ Language
18238 @cindex extensions, C++ language
18239 @cindex C++ language extensions
18241 The GNU compiler provides these extensions to the C++ language (and you
18242 can also use most of the C language extensions in your C++ programs). If you
18243 want to write code that checks whether these features are available, you can
18244 test for the GNU compiler the same way as for C programs: check for a
18245 predefined macro @code{__GNUC__}. You can also use @code{__GNUG__} to
18246 test specifically for GNU C++ (@pxref{Common Predefined Macros,,
18247 Predefined Macros,cpp,The GNU C Preprocessor}).
18250 * C++ Volatiles:: What constitutes an access to a volatile object.
18251 * Restricted Pointers:: C99 restricted pointers and references.
18252 * Vague Linkage:: Where G++ puts inlines, vtables and such.
18253 * C++ Interface:: You can use a single C++ header file for both
18254 declarations and definitions.
18255 * Template Instantiation:: Methods for ensuring that exactly one copy of
18256 each needed template instantiation is emitted.
18257 * Bound member functions:: You can extract a function pointer to the
18258 method denoted by a @samp{->*} or @samp{.*} expression.
18259 * C++ Attributes:: Variable, function, and type attributes for C++ only.
18260 * Function Multiversioning:: Declaring multiple function versions.
18261 * Namespace Association:: Strong using-directives for namespace association.
18262 * Type Traits:: Compiler support for type traits.
18263 * C++ Concepts:: Improved support for generic programming.
18264 * Java Exceptions:: Tweaking exception handling to work with Java.
18265 * Deprecated Features:: Things will disappear from G++.
18266 * Backwards Compatibility:: Compatibilities with earlier definitions of C++.
18269 @node C++ Volatiles
18270 @section When is a Volatile C++ Object Accessed?
18271 @cindex accessing volatiles
18272 @cindex volatile read
18273 @cindex volatile write
18274 @cindex volatile access
18276 The C++ standard differs from the C standard in its treatment of
18277 volatile objects. It fails to specify what constitutes a volatile
18278 access, except to say that C++ should behave in a similar manner to C
18279 with respect to volatiles, where possible. However, the different
18280 lvalueness of expressions between C and C++ complicate the behavior.
18281 G++ behaves the same as GCC for volatile access, @xref{C
18282 Extensions,,Volatiles}, for a description of GCC's behavior.
18284 The C and C++ language specifications differ when an object is
18285 accessed in a void context:
18288 volatile int *src = @var{somevalue};
18292 The C++ standard specifies that such expressions do not undergo lvalue
18293 to rvalue conversion, and that the type of the dereferenced object may
18294 be incomplete. The C++ standard does not specify explicitly that it
18295 is lvalue to rvalue conversion that is responsible for causing an
18296 access. There is reason to believe that it is, because otherwise
18297 certain simple expressions become undefined. However, because it
18298 would surprise most programmers, G++ treats dereferencing a pointer to
18299 volatile object of complete type as GCC would do for an equivalent
18300 type in C@. When the object has incomplete type, G++ issues a
18301 warning; if you wish to force an error, you must force a conversion to
18302 rvalue with, for instance, a static cast.
18304 When using a reference to volatile, G++ does not treat equivalent
18305 expressions as accesses to volatiles, but instead issues a warning that
18306 no volatile is accessed. The rationale for this is that otherwise it
18307 becomes difficult to determine where volatile access occur, and not
18308 possible to ignore the return value from functions returning volatile
18309 references. Again, if you wish to force a read, cast the reference to
18312 G++ implements the same behavior as GCC does when assigning to a
18313 volatile object---there is no reread of the assigned-to object, the
18314 assigned rvalue is reused. Note that in C++ assignment expressions
18315 are lvalues, and if used as an lvalue, the volatile object is
18316 referred to. For instance, @var{vref} refers to @var{vobj}, as
18317 expected, in the following example:
18321 volatile int &vref = vobj = @var{something};
18324 @node Restricted Pointers
18325 @section Restricting Pointer Aliasing
18326 @cindex restricted pointers
18327 @cindex restricted references
18328 @cindex restricted this pointer
18330 As with the C front end, G++ understands the C99 feature of restricted pointers,
18331 specified with the @code{__restrict__}, or @code{__restrict} type
18332 qualifier. Because you cannot compile C++ by specifying the @option{-std=c99}
18333 language flag, @code{restrict} is not a keyword in C++.
18335 In addition to allowing restricted pointers, you can specify restricted
18336 references, which indicate that the reference is not aliased in the local
18340 void fn (int *__restrict__ rptr, int &__restrict__ rref)
18347 In the body of @code{fn}, @var{rptr} points to an unaliased integer and
18348 @var{rref} refers to a (different) unaliased integer.
18350 You may also specify whether a member function's @var{this} pointer is
18351 unaliased by using @code{__restrict__} as a member function qualifier.
18354 void T::fn () __restrict__
18361 Within the body of @code{T::fn}, @var{this} has the effective
18362 definition @code{T *__restrict__ const this}. Notice that the
18363 interpretation of a @code{__restrict__} member function qualifier is
18364 different to that of @code{const} or @code{volatile} qualifier, in that it
18365 is applied to the pointer rather than the object. This is consistent with
18366 other compilers that implement restricted pointers.
18368 As with all outermost parameter qualifiers, @code{__restrict__} is
18369 ignored in function definition matching. This means you only need to
18370 specify @code{__restrict__} in a function definition, rather than
18371 in a function prototype as well.
18373 @node Vague Linkage
18374 @section Vague Linkage
18375 @cindex vague linkage
18377 There are several constructs in C++ that require space in the object
18378 file but are not clearly tied to a single translation unit. We say that
18379 these constructs have ``vague linkage''. Typically such constructs are
18380 emitted wherever they are needed, though sometimes we can be more
18384 @item Inline Functions
18385 Inline functions are typically defined in a header file which can be
18386 included in many different compilations. Hopefully they can usually be
18387 inlined, but sometimes an out-of-line copy is necessary, if the address
18388 of the function is taken or if inlining fails. In general, we emit an
18389 out-of-line copy in all translation units where one is needed. As an
18390 exception, we only emit inline virtual functions with the vtable, since
18391 it always requires a copy.
18393 Local static variables and string constants used in an inline function
18394 are also considered to have vague linkage, since they must be shared
18395 between all inlined and out-of-line instances of the function.
18399 C++ virtual functions are implemented in most compilers using a lookup
18400 table, known as a vtable. The vtable contains pointers to the virtual
18401 functions provided by a class, and each object of the class contains a
18402 pointer to its vtable (or vtables, in some multiple-inheritance
18403 situations). If the class declares any non-inline, non-pure virtual
18404 functions, the first one is chosen as the ``key method'' for the class,
18405 and the vtable is only emitted in the translation unit where the key
18408 @emph{Note:} If the chosen key method is later defined as inline, the
18409 vtable is still emitted in every translation unit that defines it.
18410 Make sure that any inline virtuals are declared inline in the class
18411 body, even if they are not defined there.
18413 @item @code{type_info} objects
18414 @cindex @code{type_info}
18416 C++ requires information about types to be written out in order to
18417 implement @samp{dynamic_cast}, @samp{typeid} and exception handling.
18418 For polymorphic classes (classes with virtual functions), the @samp{type_info}
18419 object is written out along with the vtable so that @samp{dynamic_cast}
18420 can determine the dynamic type of a class object at run time. For all
18421 other types, we write out the @samp{type_info} object when it is used: when
18422 applying @samp{typeid} to an expression, throwing an object, or
18423 referring to a type in a catch clause or exception specification.
18425 @item Template Instantiations
18426 Most everything in this section also applies to template instantiations,
18427 but there are other options as well.
18428 @xref{Template Instantiation,,Where's the Template?}.
18432 When used with GNU ld version 2.8 or later on an ELF system such as
18433 GNU/Linux or Solaris 2, or on Microsoft Windows, duplicate copies of
18434 these constructs will be discarded at link time. This is known as
18437 On targets that don't support COMDAT, but do support weak symbols, GCC
18438 uses them. This way one copy overrides all the others, but
18439 the unused copies still take up space in the executable.
18441 For targets that do not support either COMDAT or weak symbols,
18442 most entities with vague linkage are emitted as local symbols to
18443 avoid duplicate definition errors from the linker. This does not happen
18444 for local statics in inlines, however, as having multiple copies
18445 almost certainly breaks things.
18447 @xref{C++ Interface,,Declarations and Definitions in One Header}, for
18448 another way to control placement of these constructs.
18450 @node C++ Interface
18451 @section C++ Interface and Implementation Pragmas
18453 @cindex interface and implementation headers, C++
18454 @cindex C++ interface and implementation headers
18455 @cindex pragmas, interface and implementation
18457 @code{#pragma interface} and @code{#pragma implementation} provide the
18458 user with a way of explicitly directing the compiler to emit entities
18459 with vague linkage (and debugging information) in a particular
18462 @emph{Note:} These @code{#pragma}s have been superceded as of GCC 2.7.2
18463 by COMDAT support and the ``key method'' heuristic
18464 mentioned in @ref{Vague Linkage}. Using them can actually cause your
18465 program to grow due to unnecessary out-of-line copies of inline
18469 @item #pragma interface
18470 @itemx #pragma interface "@var{subdir}/@var{objects}.h"
18471 @kindex #pragma interface
18472 Use this directive in @emph{header files} that define object classes, to save
18473 space in most of the object files that use those classes. Normally,
18474 local copies of certain information (backup copies of inline member
18475 functions, debugging information, and the internal tables that implement
18476 virtual functions) must be kept in each object file that includes class
18477 definitions. You can use this pragma to avoid such duplication. When a
18478 header file containing @samp{#pragma interface} is included in a
18479 compilation, this auxiliary information is not generated (unless
18480 the main input source file itself uses @samp{#pragma implementation}).
18481 Instead, the object files contain references to be resolved at link
18484 The second form of this directive is useful for the case where you have
18485 multiple headers with the same name in different directories. If you
18486 use this form, you must specify the same string to @samp{#pragma
18489 @item #pragma implementation
18490 @itemx #pragma implementation "@var{objects}.h"
18491 @kindex #pragma implementation
18492 Use this pragma in a @emph{main input file}, when you want full output from
18493 included header files to be generated (and made globally visible). The
18494 included header file, in turn, should use @samp{#pragma interface}.
18495 Backup copies of inline member functions, debugging information, and the
18496 internal tables used to implement virtual functions are all generated in
18497 implementation files.
18499 @cindex implied @code{#pragma implementation}
18500 @cindex @code{#pragma implementation}, implied
18501 @cindex naming convention, implementation headers
18502 If you use @samp{#pragma implementation} with no argument, it applies to
18503 an include file with the same basename@footnote{A file's @dfn{basename}
18504 is the name stripped of all leading path information and of trailing
18505 suffixes, such as @samp{.h} or @samp{.C} or @samp{.cc}.} as your source
18506 file. For example, in @file{allclass.cc}, giving just
18507 @samp{#pragma implementation}
18508 by itself is equivalent to @samp{#pragma implementation "allclass.h"}.
18510 Use the string argument if you want a single implementation file to
18511 include code from multiple header files. (You must also use
18512 @samp{#include} to include the header file; @samp{#pragma
18513 implementation} only specifies how to use the file---it doesn't actually
18516 There is no way to split up the contents of a single header file into
18517 multiple implementation files.
18520 @cindex inlining and C++ pragmas
18521 @cindex C++ pragmas, effect on inlining
18522 @cindex pragmas in C++, effect on inlining
18523 @samp{#pragma implementation} and @samp{#pragma interface} also have an
18524 effect on function inlining.
18526 If you define a class in a header file marked with @samp{#pragma
18527 interface}, the effect on an inline function defined in that class is
18528 similar to an explicit @code{extern} declaration---the compiler emits
18529 no code at all to define an independent version of the function. Its
18530 definition is used only for inlining with its callers.
18532 @opindex fno-implement-inlines
18533 Conversely, when you include the same header file in a main source file
18534 that declares it as @samp{#pragma implementation}, the compiler emits
18535 code for the function itself; this defines a version of the function
18536 that can be found via pointers (or by callers compiled without
18537 inlining). If all calls to the function can be inlined, you can avoid
18538 emitting the function by compiling with @option{-fno-implement-inlines}.
18539 If any calls are not inlined, you will get linker errors.
18541 @node Template Instantiation
18542 @section Where's the Template?
18543 @cindex template instantiation
18545 C++ templates are the first language feature to require more
18546 intelligence from the environment than one usually finds on a UNIX
18547 system. Somehow the compiler and linker have to make sure that each
18548 template instance occurs exactly once in the executable if it is needed,
18549 and not at all otherwise. There are two basic approaches to this
18550 problem, which are referred to as the Borland model and the Cfront model.
18553 @item Borland model
18554 Borland C++ solved the template instantiation problem by adding the code
18555 equivalent of common blocks to their linker; the compiler emits template
18556 instances in each translation unit that uses them, and the linker
18557 collapses them together. The advantage of this model is that the linker
18558 only has to consider the object files themselves; there is no external
18559 complexity to worry about. This disadvantage is that compilation time
18560 is increased because the template code is being compiled repeatedly.
18561 Code written for this model tends to include definitions of all
18562 templates in the header file, since they must be seen to be
18566 The AT&T C++ translator, Cfront, solved the template instantiation
18567 problem by creating the notion of a template repository, an
18568 automatically maintained place where template instances are stored. A
18569 more modern version of the repository works as follows: As individual
18570 object files are built, the compiler places any template definitions and
18571 instantiations encountered in the repository. At link time, the link
18572 wrapper adds in the objects in the repository and compiles any needed
18573 instances that were not previously emitted. The advantages of this
18574 model are more optimal compilation speed and the ability to use the
18575 system linker; to implement the Borland model a compiler vendor also
18576 needs to replace the linker. The disadvantages are vastly increased
18577 complexity, and thus potential for error; for some code this can be
18578 just as transparent, but in practice it can been very difficult to build
18579 multiple programs in one directory and one program in multiple
18580 directories. Code written for this model tends to separate definitions
18581 of non-inline member templates into a separate file, which should be
18582 compiled separately.
18585 When used with GNU ld version 2.8 or later on an ELF system such as
18586 GNU/Linux or Solaris 2, or on Microsoft Windows, G++ supports the
18587 Borland model. On other systems, G++ implements neither automatic
18590 You have the following options for dealing with template instantiations:
18595 Compile your template-using code with @option{-frepo}. The compiler
18596 generates files with the extension @samp{.rpo} listing all of the
18597 template instantiations used in the corresponding object files that
18598 could be instantiated there; the link wrapper, @samp{collect2},
18599 then updates the @samp{.rpo} files to tell the compiler where to place
18600 those instantiations and rebuild any affected object files. The
18601 link-time overhead is negligible after the first pass, as the compiler
18602 continues to place the instantiations in the same files.
18604 This is your best option for application code written for the Borland
18605 model, as it just works. Code written for the Cfront model
18606 needs to be modified so that the template definitions are available at
18607 one or more points of instantiation; usually this is as simple as adding
18608 @code{#include <tmethods.cc>} to the end of each template header.
18610 For library code, if you want the library to provide all of the template
18611 instantiations it needs, just try to link all of its object files
18612 together; the link will fail, but cause the instantiations to be
18613 generated as a side effect. Be warned, however, that this may cause
18614 conflicts if multiple libraries try to provide the same instantiations.
18615 For greater control, use explicit instantiation as described in the next
18619 @opindex fno-implicit-templates
18620 Compile your code with @option{-fno-implicit-templates} to disable the
18621 implicit generation of template instances, and explicitly instantiate
18622 all the ones you use. This approach requires more knowledge of exactly
18623 which instances you need than do the others, but it's less
18624 mysterious and allows greater control. You can scatter the explicit
18625 instantiations throughout your program, perhaps putting them in the
18626 translation units where the instances are used or the translation units
18627 that define the templates themselves; you can put all of the explicit
18628 instantiations you need into one big file; or you can create small files
18635 template class Foo<int>;
18636 template ostream& operator <<
18637 (ostream&, const Foo<int>&);
18641 for each of the instances you need, and create a template instantiation
18642 library from those.
18644 If you are using Cfront-model code, you can probably get away with not
18645 using @option{-fno-implicit-templates} when compiling files that don't
18646 @samp{#include} the member template definitions.
18648 If you use one big file to do the instantiations, you may want to
18649 compile it without @option{-fno-implicit-templates} so you get all of the
18650 instances required by your explicit instantiations (but not by any
18651 other files) without having to specify them as well.
18653 The ISO C++ 2011 standard allows forward declaration of explicit
18654 instantiations (with @code{extern}). G++ supports explicit instantiation
18655 declarations in C++98 mode and has extended the template instantiation
18656 syntax to support instantiation of the compiler support data for a
18657 template class (i.e.@: the vtable) without instantiating any of its
18658 members (with @code{inline}), and instantiation of only the static data
18659 members of a template class, without the support data or member
18660 functions (with @code{static}):
18663 extern template int max (int, int);
18664 inline template class Foo<int>;
18665 static template class Foo<int>;
18669 Do nothing. Pretend G++ does implement automatic instantiation
18670 management. Code written for the Borland model works fine, but
18671 each translation unit contains instances of each of the templates it
18672 uses. In a large program, this can lead to an unacceptable amount of code
18676 @node Bound member functions
18677 @section Extracting the Function Pointer from a Bound Pointer to Member Function
18679 @cindex pointer to member function
18680 @cindex bound pointer to member function
18682 In C++, pointer to member functions (PMFs) are implemented using a wide
18683 pointer of sorts to handle all the possible call mechanisms; the PMF
18684 needs to store information about how to adjust the @samp{this} pointer,
18685 and if the function pointed to is virtual, where to find the vtable, and
18686 where in the vtable to look for the member function. If you are using
18687 PMFs in an inner loop, you should really reconsider that decision. If
18688 that is not an option, you can extract the pointer to the function that
18689 would be called for a given object/PMF pair and call it directly inside
18690 the inner loop, to save a bit of time.
18692 Note that you still pay the penalty for the call through a
18693 function pointer; on most modern architectures, such a call defeats the
18694 branch prediction features of the CPU@. This is also true of normal
18695 virtual function calls.
18697 The syntax for this extension is
18701 extern int (A::*fp)();
18702 typedef int (*fptr)(A *);
18704 fptr p = (fptr)(a.*fp);
18707 For PMF constants (i.e.@: expressions of the form @samp{&Klasse::Member}),
18708 no object is needed to obtain the address of the function. They can be
18709 converted to function pointers directly:
18712 fptr p1 = (fptr)(&A::foo);
18715 @opindex Wno-pmf-conversions
18716 You must specify @option{-Wno-pmf-conversions} to use this extension.
18718 @node C++ Attributes
18719 @section C++-Specific Variable, Function, and Type Attributes
18721 Some attributes only make sense for C++ programs.
18724 @item abi_tag ("@var{tag}", ...)
18725 @cindex @code{abi_tag} attribute
18726 The @code{abi_tag} attribute can be applied to a function or class
18727 declaration. It modifies the mangled name of the function or class to
18728 incorporate the tag name, in order to distinguish the function or
18729 class from an earlier version with a different ABI; perhaps the class
18730 has changed size, or the function has a different return type that is
18731 not encoded in the mangled name.
18733 The argument can be a list of strings of arbitrary length. The
18734 strings are sorted on output, so the order of the list is
18737 A redeclaration of a function or class must not add new ABI tags,
18738 since doing so would change the mangled name.
18740 The ABI tags apply to a name, so all instantiations and
18741 specializations of a template have the same tags. The attribute will
18742 be ignored if applied to an explicit specialization or instantiation.
18744 The @option{-Wabi-tag} flag enables a warning about a class which does
18745 not have all the ABI tags used by its subobjects and virtual functions; for users with code
18746 that needs to coexist with an earlier ABI, using this option can help
18747 to find all affected types that need to be tagged.
18749 @item init_priority (@var{priority})
18750 @cindex @code{init_priority} attribute
18753 In Standard C++, objects defined at namespace scope are guaranteed to be
18754 initialized in an order in strict accordance with that of their definitions
18755 @emph{in a given translation unit}. No guarantee is made for initializations
18756 across translation units. However, GNU C++ allows users to control the
18757 order of initialization of objects defined at namespace scope with the
18758 @code{init_priority} attribute by specifying a relative @var{priority},
18759 a constant integral expression currently bounded between 101 and 65535
18760 inclusive. Lower numbers indicate a higher priority.
18762 In the following example, @code{A} would normally be created before
18763 @code{B}, but the @code{init_priority} attribute reverses that order:
18766 Some_Class A __attribute__ ((init_priority (2000)));
18767 Some_Class B __attribute__ ((init_priority (543)));
18771 Note that the particular values of @var{priority} do not matter; only their
18774 @item java_interface
18775 @cindex @code{java_interface} attribute
18777 This type attribute informs C++ that the class is a Java interface. It may
18778 only be applied to classes declared within an @code{extern "Java"} block.
18779 Calls to methods declared in this interface are dispatched using GCJ's
18780 interface table mechanism, instead of regular virtual table dispatch.
18783 @cindex @code{warn_unused} attribute
18785 For C++ types with non-trivial constructors and/or destructors it is
18786 impossible for the compiler to determine whether a variable of this
18787 type is truly unused if it is not referenced. This type attribute
18788 informs the compiler that variables of this type should be warned
18789 about if they appear to be unused, just like variables of fundamental
18792 This attribute is appropriate for types which just represent a value,
18793 such as @code{std::string}; it is not appropriate for types which
18794 control a resource, such as @code{std::mutex}.
18796 This attribute is also accepted in C, but it is unnecessary because C
18797 does not have constructors or destructors.
18801 See also @ref{Namespace Association}.
18803 @node Function Multiversioning
18804 @section Function Multiversioning
18805 @cindex function versions
18807 With the GNU C++ front end, for x86 targets, you may specify multiple
18808 versions of a function, where each function is specialized for a
18809 specific target feature. At runtime, the appropriate version of the
18810 function is automatically executed depending on the characteristics of
18811 the execution platform. Here is an example.
18814 __attribute__ ((target ("default")))
18817 // The default version of foo.
18821 __attribute__ ((target ("sse4.2")))
18824 // foo version for SSE4.2
18828 __attribute__ ((target ("arch=atom")))
18831 // foo version for the Intel ATOM processor
18835 __attribute__ ((target ("arch=amdfam10")))
18838 // foo version for the AMD Family 0x10 processors.
18845 assert ((*p) () == foo ());
18850 In the above example, four versions of function foo are created. The
18851 first version of foo with the target attribute "default" is the default
18852 version. This version gets executed when no other target specific
18853 version qualifies for execution on a particular platform. A new version
18854 of foo is created by using the same function signature but with a
18855 different target string. Function foo is called or a pointer to it is
18856 taken just like a regular function. GCC takes care of doing the
18857 dispatching to call the right version at runtime. Refer to the
18858 @uref{http://gcc.gnu.org/wiki/FunctionMultiVersioning, GCC wiki on
18859 Function Multiversioning} for more details.
18861 @node Namespace Association
18862 @section Namespace Association
18864 @strong{Caution:} The semantics of this extension are equivalent
18865 to C++ 2011 inline namespaces. Users should use inline namespaces
18866 instead as this extension will be removed in future versions of G++.
18868 A using-directive with @code{__attribute ((strong))} is stronger
18869 than a normal using-directive in two ways:
18873 Templates from the used namespace can be specialized and explicitly
18874 instantiated as though they were members of the using namespace.
18877 The using namespace is considered an associated namespace of all
18878 templates in the used namespace for purposes of argument-dependent
18882 The used namespace must be nested within the using namespace so that
18883 normal unqualified lookup works properly.
18885 This is useful for composing a namespace transparently from
18886 implementation namespaces. For example:
18891 template <class T> struct A @{ @};
18893 using namespace debug __attribute ((__strong__));
18894 template <> struct A<int> @{ @}; // @r{OK to specialize}
18896 template <class T> void f (A<T>);
18901 f (std::A<float>()); // @r{lookup finds} std::f
18907 @section Type Traits
18909 The C++ front end implements syntactic extensions that allow
18910 compile-time determination of
18911 various characteristics of a type (or of a
18915 @item __has_nothrow_assign (type)
18916 If @code{type} is const qualified or is a reference type then the trait is
18917 false. Otherwise if @code{__has_trivial_assign (type)} is true then the trait
18918 is true, else if @code{type} is a cv class or union type with copy assignment
18919 operators that are known not to throw an exception then the trait is true,
18920 else it is false. Requires: @code{type} shall be a complete type,
18921 (possibly cv-qualified) @code{void}, or an array of unknown bound.
18923 @item __has_nothrow_copy (type)
18924 If @code{__has_trivial_copy (type)} is true then the trait is true, else if
18925 @code{type} is a cv class or union type with copy constructors that
18926 are known not to throw an exception then the trait is true, else it is false.
18927 Requires: @code{type} shall be a complete type, (possibly cv-qualified)
18928 @code{void}, or an array of unknown bound.
18930 @item __has_nothrow_constructor (type)
18931 If @code{__has_trivial_constructor (type)} is true then the trait is
18932 true, else if @code{type} is a cv class or union type (or array
18933 thereof) with a default constructor that is known not to throw an
18934 exception then the trait is true, else it is false. Requires:
18935 @code{type} shall be a complete type, (possibly cv-qualified)
18936 @code{void}, or an array of unknown bound.
18938 @item __has_trivial_assign (type)
18939 If @code{type} is const qualified or is a reference type then the trait is
18940 false. Otherwise if @code{__is_pod (type)} is true then the trait is
18941 true, else if @code{type} is a cv class or union type with a trivial
18942 copy assignment ([class.copy]) then the trait is true, else it is
18943 false. Requires: @code{type} shall be a complete type, (possibly
18944 cv-qualified) @code{void}, or an array of unknown bound.
18946 @item __has_trivial_copy (type)
18947 If @code{__is_pod (type)} is true or @code{type} is a reference type
18948 then the trait is true, else if @code{type} is a cv class or union type
18949 with a trivial copy constructor ([class.copy]) then the trait
18950 is true, else it is false. Requires: @code{type} shall be a complete
18951 type, (possibly cv-qualified) @code{void}, or an array of unknown bound.
18953 @item __has_trivial_constructor (type)
18954 If @code{__is_pod (type)} is true then the trait is true, else if
18955 @code{type} is a cv class or union type (or array thereof) with a
18956 trivial default constructor ([class.ctor]) then the trait is true,
18957 else it is false. Requires: @code{type} shall be a complete
18958 type, (possibly cv-qualified) @code{void}, or an array of unknown bound.
18960 @item __has_trivial_destructor (type)
18961 If @code{__is_pod (type)} is true or @code{type} is a reference type then
18962 the trait is true, else if @code{type} is a cv class or union type (or
18963 array thereof) with a trivial destructor ([class.dtor]) then the trait
18964 is true, else it is false. Requires: @code{type} shall be a complete
18965 type, (possibly cv-qualified) @code{void}, or an array of unknown bound.
18967 @item __has_virtual_destructor (type)
18968 If @code{type} is a class type with a virtual destructor
18969 ([class.dtor]) then the trait is true, else it is false. Requires:
18970 @code{type} shall be a complete type, (possibly cv-qualified)
18971 @code{void}, or an array of unknown bound.
18973 @item __is_abstract (type)
18974 If @code{type} is an abstract class ([class.abstract]) then the trait
18975 is true, else it is false. Requires: @code{type} shall be a complete
18976 type, (possibly cv-qualified) @code{void}, or an array of unknown bound.
18978 @item __is_base_of (base_type, derived_type)
18979 If @code{base_type} is a base class of @code{derived_type}
18980 ([class.derived]) then the trait is true, otherwise it is false.
18981 Top-level cv qualifications of @code{base_type} and
18982 @code{derived_type} are ignored. For the purposes of this trait, a
18983 class type is considered is own base. Requires: if @code{__is_class
18984 (base_type)} and @code{__is_class (derived_type)} are true and
18985 @code{base_type} and @code{derived_type} are not the same type
18986 (disregarding cv-qualifiers), @code{derived_type} shall be a complete
18987 type. Diagnostic is produced if this requirement is not met.
18989 @item __is_class (type)
18990 If @code{type} is a cv class type, and not a union type
18991 ([basic.compound]) the trait is true, else it is false.
18993 @item __is_empty (type)
18994 If @code{__is_class (type)} is false then the trait is false.
18995 Otherwise @code{type} is considered empty if and only if: @code{type}
18996 has no non-static data members, or all non-static data members, if
18997 any, are bit-fields of length 0, and @code{type} has no virtual
18998 members, and @code{type} has no virtual base classes, and @code{type}
18999 has no base classes @code{base_type} for which
19000 @code{__is_empty (base_type)} is false. Requires: @code{type} shall
19001 be a complete type, (possibly cv-qualified) @code{void}, or an array
19004 @item __is_enum (type)
19005 If @code{type} is a cv enumeration type ([basic.compound]) the trait is
19006 true, else it is false.
19008 @item __is_literal_type (type)
19009 If @code{type} is a literal type ([basic.types]) the trait is
19010 true, else it is false. Requires: @code{type} shall be a complete type,
19011 (possibly cv-qualified) @code{void}, or an array of unknown bound.
19013 @item __is_pod (type)
19014 If @code{type} is a cv POD type ([basic.types]) then the trait is true,
19015 else it is false. Requires: @code{type} shall be a complete type,
19016 (possibly cv-qualified) @code{void}, or an array of unknown bound.
19018 @item __is_polymorphic (type)
19019 If @code{type} is a polymorphic class ([class.virtual]) then the trait
19020 is true, else it is false. Requires: @code{type} shall be a complete
19021 type, (possibly cv-qualified) @code{void}, or an array of unknown bound.
19023 @item __is_standard_layout (type)
19024 If @code{type} is a standard-layout type ([basic.types]) the trait is
19025 true, else it is false. Requires: @code{type} shall be a complete
19026 type, (possibly cv-qualified) @code{void}, or an array of unknown bound.
19028 @item __is_trivial (type)
19029 If @code{type} is a trivial type ([basic.types]) the trait is
19030 true, else it is false. Requires: @code{type} shall be a complete
19031 type, (possibly cv-qualified) @code{void}, or an array of unknown bound.
19033 @item __is_union (type)
19034 If @code{type} is a cv union type ([basic.compound]) the trait is
19035 true, else it is false.
19037 @item __underlying_type (type)
19038 The underlying type of @code{type}. Requires: @code{type} shall be
19039 an enumeration type ([dcl.enum]).
19045 @section C++ Concepts
19047 C++ concepts provide much-improved support for generic programming. In
19048 particular, they allow the specification of constraints on template arguments.
19049 The constraints are used to extend the usual overloading and partial
19050 specialization capabilities of the language, allowing generic data structures
19051 and algorithms to be ``refined'' based on their properties rather than their
19054 The following keywords are reserved for concepts.
19058 States an expression as an assumption, and if possible, verifies that the
19059 assumption is valid. For example, @code{assume(n > 0)}.
19062 Introduces an axiom definition. Axioms introduce requirements on values.
19065 Introduces a universally quantified object in an axiom. For example,
19066 @code{forall (int n) n + 0 == n}).
19069 Introduces a concept definition. Concepts are sets of syntactic and semantic
19070 requirements on types and their values.
19073 Introduces constraints on template arguments or requirements for a member
19074 function of a class template.
19078 The front end also exposes a number of internal mechanism that can be used
19079 to simplify the writing of type traits. Note that some of these traits are
19080 likely to be removed in the future.
19083 @item __is_same (type1, type2)
19084 A binary type trait: true whenever the type arguments are the same.
19086 @item __is_valid_expr (expr)
19087 A syntactic requirement. In a constraint, this trait can be used to determine
19088 if a particular expression is valid for the types of its operands, and if so,
19089 whether the result type is the same as or convertible to some other type.
19091 @item __is_valid_type (type)
19092 A syntactic requirement. In a constraint, this trait can be used to determine
19093 if a type name is well-formed.
19096 A new declaration specifier. This can be used in constraints to introduce
19097 ``declared values'' to be used as a replacement for @code{declval}.
19102 @node Java Exceptions
19103 @section Java Exceptions
19105 The Java language uses a slightly different exception handling model
19106 from C++. Normally, GNU C++ automatically detects when you are
19107 writing C++ code that uses Java exceptions, and handle them
19108 appropriately. However, if C++ code only needs to execute destructors
19109 when Java exceptions are thrown through it, GCC guesses incorrectly.
19110 Sample problematic code is:
19113 struct S @{ ~S(); @};
19114 extern void bar(); // @r{is written in Java, and may throw exceptions}
19123 The usual effect of an incorrect guess is a link failure, complaining of
19124 a missing routine called @samp{__gxx_personality_v0}.
19126 You can inform the compiler that Java exceptions are to be used in a
19127 translation unit, irrespective of what it might think, by writing
19128 @samp{@w{#pragma GCC java_exceptions}} at the head of the file. This
19129 @samp{#pragma} must appear before any functions that throw or catch
19130 exceptions, or run destructors when exceptions are thrown through them.
19132 You cannot mix Java and C++ exceptions in the same translation unit. It
19133 is believed to be safe to throw a C++ exception from one file through
19134 another file compiled for the Java exception model, or vice versa, but
19135 there may be bugs in this area.
19137 @node Deprecated Features
19138 @section Deprecated Features
19140 In the past, the GNU C++ compiler was extended to experiment with new
19141 features, at a time when the C++ language was still evolving. Now that
19142 the C++ standard is complete, some of those features are superseded by
19143 superior alternatives. Using the old features might cause a warning in
19144 some cases that the feature will be dropped in the future. In other
19145 cases, the feature might be gone already.
19147 While the list below is not exhaustive, it documents some of the options
19148 that are now deprecated:
19151 @item -fexternal-templates
19152 @itemx -falt-external-templates
19153 These are two of the many ways for G++ to implement template
19154 instantiation. @xref{Template Instantiation}. The C++ standard clearly
19155 defines how template definitions have to be organized across
19156 implementation units. G++ has an implicit instantiation mechanism that
19157 should work just fine for standard-conforming code.
19159 @item -fstrict-prototype
19160 @itemx -fno-strict-prototype
19161 Previously it was possible to use an empty prototype parameter list to
19162 indicate an unspecified number of parameters (like C), rather than no
19163 parameters, as C++ demands. This feature has been removed, except where
19164 it is required for backwards compatibility. @xref{Backwards Compatibility}.
19167 G++ allows a virtual function returning @samp{void *} to be overridden
19168 by one returning a different pointer type. This extension to the
19169 covariant return type rules is now deprecated and will be removed from a
19172 The G++ minimum and maximum operators (@samp{<?} and @samp{>?}) and
19173 their compound forms (@samp{<?=}) and @samp{>?=}) have been deprecated
19174 and are now removed from G++. Code using these operators should be
19175 modified to use @code{std::min} and @code{std::max} instead.
19177 The named return value extension has been deprecated, and is now
19180 The use of initializer lists with new expressions has been deprecated,
19181 and is now removed from G++.
19183 Floating and complex non-type template parameters have been deprecated,
19184 and are now removed from G++.
19186 The implicit typename extension has been deprecated and is now
19189 The use of default arguments in function pointers, function typedefs
19190 and other places where they are not permitted by the standard is
19191 deprecated and will be removed from a future version of G++.
19193 G++ allows floating-point literals to appear in integral constant expressions,
19194 e.g.@: @samp{ enum E @{ e = int(2.2 * 3.7) @} }
19195 This extension is deprecated and will be removed from a future version.
19197 G++ allows static data members of const floating-point type to be declared
19198 with an initializer in a class definition. The standard only allows
19199 initializers for static members of const integral types and const
19200 enumeration types so this extension has been deprecated and will be removed
19201 from a future version.
19203 @node Backwards Compatibility
19204 @section Backwards Compatibility
19205 @cindex Backwards Compatibility
19206 @cindex ARM [Annotated C++ Reference Manual]
19208 Now that there is a definitive ISO standard C++, G++ has a specification
19209 to adhere to. The C++ language evolved over time, and features that
19210 used to be acceptable in previous drafts of the standard, such as the ARM
19211 [Annotated C++ Reference Manual], are no longer accepted. In order to allow
19212 compilation of C++ written to such drafts, G++ contains some backwards
19213 compatibilities. @emph{All such backwards compatibility features are
19214 liable to disappear in future versions of G++.} They should be considered
19215 deprecated. @xref{Deprecated Features}.
19219 If a variable is declared at for scope, it used to remain in scope until
19220 the end of the scope that contained the for statement (rather than just
19221 within the for scope). G++ retains this, but issues a warning, if such a
19222 variable is accessed outside the for scope.
19224 @item Implicit C language
19225 Old C system header files did not contain an @code{extern "C" @{@dots{}@}}
19226 scope to set the language. On such systems, all header files are
19227 implicitly scoped inside a C language scope. Also, an empty prototype
19228 @code{()} is treated as an unspecified number of arguments, rather
19229 than no arguments, as C++ demands.
19232 @c LocalWords: emph deftypefn builtin ARCv2EM SIMD builtins msimd
19233 @c LocalWords: typedef v4si v8hi DMA dma vdiwr vdowr