1@c Copyright (C) 1988, 1989, 1992, 1993, 1994, 1996, 1998, 1999, 2000, 2001, 2@c 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 3@c Free Software Foundation, Inc. 4 5@c This is part of the GCC manual. 6@c For copying conditions, see the file gcc.texi. 7 8@node C Extensions 9@chapter Extensions to the C Language Family 10@cindex extensions, C language 11@cindex C language extensions 12 13@opindex pedantic 14GNU C provides several language features not found in ISO standard C@. 15(The @option{-pedantic} option directs GCC to print a warning message if 16any of these features is used.) To test for the availability of these 17features in conditional compilation, check for a predefined macro 18@code{__GNUC__}, which is always defined under GCC@. 19 20These extensions are available in C and Objective-C@. Most of them are 21also available in C++. @xref{C++ Extensions,,Extensions to the 22C++ Language}, for extensions that apply @emph{only} to C++. 23 24Some features that are in ISO C99 but not C90 or C++ are also, as 25extensions, accepted by GCC in C90 mode and in C++. 26 27@menu 28* Statement Exprs:: Putting statements and declarations inside expressions. 29* Local Labels:: Labels local to a block. 30* Labels as Values:: Getting pointers to labels, and computed gotos. 31* Nested Functions:: As in Algol and Pascal, lexical scoping of functions. 32* Constructing Calls:: Dispatching a call to another function. 33* Typeof:: @code{typeof}: referring to the type of an expression. 34* Conditionals:: Omitting the middle operand of a @samp{?:} expression. 35* Long Long:: Double-word integers---@code{long long int}. 36* Complex:: Data types for complex numbers. 37* Floating Types:: Additional Floating Types. 38* Half-Precision:: Half-Precision Floating Point. 39* Decimal Float:: Decimal Floating Types. 40* Hex Floats:: Hexadecimal floating-point constants. 41* Fixed-Point:: Fixed-Point Types. 42* Named Address Spaces::Named address spaces. 43* Zero Length:: Zero-length arrays. 44* Variable Length:: Arrays whose length is computed at run time. 45* Empty Structures:: Structures with no members. 46* Variadic Macros:: Macros with a variable number of arguments. 47* Escaped Newlines:: Slightly looser rules for escaped newlines. 48* Subscripting:: Any array can be subscripted, even if not an lvalue. 49* Pointer Arith:: Arithmetic on @code{void}-pointers and function pointers. 50* Initializers:: Non-constant initializers. 51* Compound Literals:: Compound literals give structures, unions 52 or arrays as values. 53* Designated Inits:: Labeling elements of initializers. 54* Cast to Union:: Casting to union type from any member of the union. 55* Case Ranges:: `case 1 ... 9' and such. 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* Attribute Syntax:: Formal syntax for attributes. 60* Function Prototypes:: Prototype declarations and old-style definitions. 61* C++ Comments:: C++ comments are recognized. 62* Dollar Signs:: Dollar sign is allowed in identifiers. 63* Character Escapes:: @samp{\e} stands for the character @key{ESC}. 64* Variable Attributes:: Specifying attributes of variables. 65* Type Attributes:: Specifying attributes of types. 66* Alignment:: Inquiring about the alignment of a type or variable. 67* Inline:: Defining inline functions (as fast as macros). 68* Extended Asm:: Assembler instructions with C expressions as operands. 69 (With them you can define ``built-in'' functions.) 70* Constraints:: Constraints for asm operands 71* Asm Labels:: Specifying the assembler name to use for a C symbol. 72* Explicit Reg Vars:: Defining variables residing in specified registers. 73* Alternate Keywords:: @code{__const__}, @code{__asm__}, etc., for header files. 74* Incomplete Enums:: @code{enum foo;}, with details to follow. 75* Function Names:: Printable strings which are the name of the current 76 function. 77* Return Address:: Getting the return or frame address of a function. 78* Vector Extensions:: Using vector instructions through built-in functions. 79* Offsetof:: Special syntax for implementing @code{offsetof}. 80* Atomic Builtins:: Built-in functions for atomic memory access. 81* Object Size Checking:: Built-in functions for limited buffer overflow 82 checking. 83* Other Builtins:: Other built-in functions. 84* Target Builtins:: Built-in functions specific to particular targets. 85* Target Format Checks:: Format checks specific to particular targets. 86* Pragmas:: Pragmas accepted by GCC. 87* Unnamed Fields:: Unnamed struct/union fields within structs/unions. 88* Thread-Local:: Per-thread variables. 89* Binary constants:: Binary constants using the @samp{0b} prefix. 90@end menu 91 92@node Statement Exprs 93@section Statements and Declarations in Expressions 94@cindex statements inside expressions 95@cindex declarations inside expressions 96@cindex expressions containing statements 97@cindex macros, statements in expressions 98 99@c the above section title wrapped and causes an underfull hbox.. i 100@c changed it from "within" to "in". --mew 4feb93 101A compound statement enclosed in parentheses may appear as an expression 102in GNU C@. This allows you to use loops, switches, and local variables 103within an expression. 104 105Recall that a compound statement is a sequence of statements surrounded 106by braces; in this construct, parentheses go around the braces. For 107example: 108 109@smallexample 110(@{ int y = foo (); int z; 111 if (y > 0) z = y; 112 else z = - y; 113 z; @}) 114@end smallexample 115 116@noindent 117is a valid (though slightly more complex than necessary) expression 118for the absolute value of @code{foo ()}. 119 120The last thing in the compound statement should be an expression 121followed by a semicolon; the value of this subexpression serves as the 122value of the entire construct. (If you use some other kind of statement 123last within the braces, the construct has type @code{void}, and thus 124effectively no value.) 125 126This feature is especially useful in making macro definitions ``safe'' (so 127that they evaluate each operand exactly once). For example, the 128``maximum'' function is commonly defined as a macro in standard C as 129follows: 130 131@smallexample 132#define max(a,b) ((a) > (b) ? (a) : (b)) 133@end smallexample 134 135@noindent 136@cindex side effects, macro argument 137But this definition computes either @var{a} or @var{b} twice, with bad 138results if the operand has side effects. In GNU C, if you know the 139type of the operands (here taken as @code{int}), you can define 140the macro safely as follows: 141 142@smallexample 143#define maxint(a,b) \ 144 (@{int _a = (a), _b = (b); _a > _b ? _a : _b; @}) 145@end smallexample 146 147Embedded statements are not allowed in constant expressions, such as 148the value of an enumeration constant, the width of a bit-field, or 149the initial value of a static variable. 150 151If you don't know the type of the operand, you can still do this, but you 152must use @code{typeof} (@pxref{Typeof}). 153 154In G++, the result value of a statement expression undergoes array and 155function pointer decay, and is returned by value to the enclosing 156expression. For instance, if @code{A} is a class, then 157 158@smallexample 159 A a; 160 161 (@{a;@}).Foo () 162@end smallexample 163 164@noindent 165will construct a temporary @code{A} object to hold the result of the 166statement expression, and that will be used to invoke @code{Foo}. 167Therefore the @code{this} pointer observed by @code{Foo} will not be the 168address of @code{a}. 169 170Any temporaries created within a statement within a statement expression 171will be destroyed at the statement's end. This makes statement 172expressions inside macros slightly different from function calls. In 173the latter case temporaries introduced during argument evaluation will 174be destroyed at the end of the statement that includes the function 175call. In the statement expression case they will be destroyed during 176the statement expression. For instance, 177 178@smallexample 179#define macro(a) (@{__typeof__(a) b = (a); b + 3; @}) 180template<typename T> T function(T a) @{ T b = a; return b + 3; @} 181 182void foo () 183@{ 184 macro (X ()); 185 function (X ()); 186@} 187@end smallexample 188 189@noindent 190will have different places where temporaries are destroyed. For the 191@code{macro} case, the temporary @code{X} will be destroyed just after 192the initialization of @code{b}. In the @code{function} case that 193temporary will be destroyed when the function returns. 194 195These considerations mean that it is probably a bad idea to use 196statement-expressions of this form in header files that are designed to 197work with C++. (Note that some versions of the GNU C Library contained 198header files using statement-expression that lead to precisely this 199bug.) 200 201Jumping into a statement expression with @code{goto} or using a 202@code{switch} statement outside the statement expression with a 203@code{case} or @code{default} label inside the statement expression is 204not permitted. Jumping into a statement expression with a computed 205@code{goto} (@pxref{Labels as Values}) yields undefined behavior. 206Jumping out of a statement expression is permitted, but if the 207statement expression is part of a larger expression then it is 208unspecified which other subexpressions of that expression have been 209evaluated except where the language definition requires certain 210subexpressions to be evaluated before or after the statement 211expression. In any case, as with a function call the evaluation of a 212statement expression is not interleaved with the evaluation of other 213parts of the containing expression. For example, 214 215@smallexample 216 foo (), ((@{ bar1 (); goto a; 0; @}) + bar2 ()), baz(); 217@end smallexample 218 219@noindent 220will call @code{foo} and @code{bar1} and will not call @code{baz} but 221may or may not call @code{bar2}. If @code{bar2} is called, it will be 222called after @code{foo} and before @code{bar1} 223 224@node Local Labels 225@section Locally Declared Labels 226@cindex local labels 227@cindex macros, local labels 228 229GCC allows you to declare @dfn{local labels} in any nested block 230scope. A local label is just like an ordinary label, but you can 231only reference it (with a @code{goto} statement, or by taking its 232address) within the block in which it was declared. 233 234A local label declaration looks like this: 235 236@smallexample 237__label__ @var{label}; 238@end smallexample 239 240@noindent 241or 242 243@smallexample 244__label__ @var{label1}, @var{label2}, /* @r{@dots{}} */; 245@end smallexample 246 247Local label declarations must come at the beginning of the block, 248before any ordinary declarations or statements. 249 250The label declaration defines the label @emph{name}, but does not define 251the label itself. You must do this in the usual way, with 252@code{@var{label}:}, within the statements of the statement expression. 253 254The local label feature is useful for complex macros. If a macro 255contains nested loops, a @code{goto} can be useful for breaking out of 256them. However, an ordinary label whose scope is the whole function 257cannot be used: if the macro can be expanded several times in one 258function, the label will be multiply defined in that function. A 259local label avoids this problem. For example: 260 261@smallexample 262#define SEARCH(value, array, target) \ 263do @{ \ 264 __label__ found; \ 265 typeof (target) _SEARCH_target = (target); \ 266 typeof (*(array)) *_SEARCH_array = (array); \ 267 int i, j; \ 268 int value; \ 269 for (i = 0; i < max; i++) \ 270 for (j = 0; j < max; j++) \ 271 if (_SEARCH_array[i][j] == _SEARCH_target) \ 272 @{ (value) = i; goto found; @} \ 273 (value) = -1; \ 274 found:; \ 275@} while (0) 276@end smallexample 277 278This could also be written using a statement-expression: 279 280@smallexample 281#define SEARCH(array, target) \ 282(@{ \ 283 __label__ found; \ 284 typeof (target) _SEARCH_target = (target); \ 285 typeof (*(array)) *_SEARCH_array = (array); \ 286 int i, j; \ 287 int value; \ 288 for (i = 0; i < max; i++) \ 289 for (j = 0; j < max; j++) \ 290 if (_SEARCH_array[i][j] == _SEARCH_target) \ 291 @{ value = i; goto found; @} \ 292 value = -1; \ 293 found: \ 294 value; \ 295@}) 296@end smallexample 297 298Local label declarations also make the labels they declare visible to 299nested functions, if there are any. @xref{Nested Functions}, for details. 300 301@node Labels as Values 302@section Labels as Values 303@cindex labels as values 304@cindex computed gotos 305@cindex goto with computed label 306@cindex address of a label 307 308You can get the address of a label defined in the current function 309(or a containing function) with the unary operator @samp{&&}. The 310value has type @code{void *}. This value is a constant and can be used 311wherever a constant of that type is valid. For example: 312 313@smallexample 314void *ptr; 315/* @r{@dots{}} */ 316ptr = &&foo; 317@end smallexample 318 319To use these values, you need to be able to jump to one. This is done 320with the computed goto statement@footnote{The analogous feature in 321Fortran is called an assigned goto, but that name seems inappropriate in 322C, where one can do more than simply store label addresses in label 323variables.}, @code{goto *@var{exp};}. For example, 324 325@smallexample 326goto *ptr; 327@end smallexample 328 329@noindent 330Any expression of type @code{void *} is allowed. 331 332One way of using these constants is in initializing a static array that 333will serve as a jump table: 334 335@smallexample 336static void *array[] = @{ &&foo, &&bar, &&hack @}; 337@end smallexample 338 339Then you can select a label with indexing, like this: 340 341@smallexample 342goto *array[i]; 343@end smallexample 344 345@noindent 346Note that this does not check whether the subscript is in bounds---array 347indexing in C never does that. 348 349Such an array of label values serves a purpose much like that of the 350@code{switch} statement. The @code{switch} statement is cleaner, so 351use that rather than an array unless the problem does not fit a 352@code{switch} statement very well. 353 354Another use of label values is in an interpreter for threaded code. 355The labels within the interpreter function can be stored in the 356threaded code for super-fast dispatching. 357 358You may not use this mechanism to jump to code in a different function. 359If you do that, totally unpredictable things will happen. The best way to 360avoid this is to store the label address only in automatic variables and 361never pass it as an argument. 362 363An alternate way to write the above example is 364 365@smallexample 366static const int array[] = @{ &&foo - &&foo, &&bar - &&foo, 367 &&hack - &&foo @}; 368goto *(&&foo + array[i]); 369@end smallexample 370 371@noindent 372This is more friendly to code living in shared libraries, as it reduces 373the number of dynamic relocations that are needed, and by consequence, 374allows the data to be read-only. 375 376The @code{&&foo} expressions for the same label might have different 377values if the containing function is inlined or cloned. If a program 378relies on them being always the same, 379@code{__attribute__((__noinline__,__noclone__))} should be used to 380prevent inlining and cloning. If @code{&&foo} is used in a static 381variable initializer, inlining and cloning is forbidden. 382 383@node Nested Functions 384@section Nested Functions 385@cindex nested functions 386@cindex downward funargs 387@cindex thunks 388 389A @dfn{nested function} is a function defined inside another function. 390(Nested functions are not supported for GNU C++.) The nested function's 391name is local to the block where it is defined. For example, here we 392define a nested function named @code{square}, and call it twice: 393 394@smallexample 395@group 396foo (double a, double b) 397@{ 398 double square (double z) @{ return z * z; @} 399 400 return square (a) + square (b); 401@} 402@end group 403@end smallexample 404 405The nested function can access all the variables of the containing 406function that are visible at the point of its definition. This is 407called @dfn{lexical scoping}. For example, here we show a nested 408function which uses an inherited variable named @code{offset}: 409 410@smallexample 411@group 412bar (int *array, int offset, int size) 413@{ 414 int access (int *array, int index) 415 @{ return array[index + offset]; @} 416 int i; 417 /* @r{@dots{}} */ 418 for (i = 0; i < size; i++) 419 /* @r{@dots{}} */ access (array, i) /* @r{@dots{}} */ 420@} 421@end group 422@end smallexample 423 424Nested function definitions are permitted within functions in the places 425where variable definitions are allowed; that is, in any block, mixed 426with the other declarations and statements in the block. 427 428It is possible to call the nested function from outside the scope of its 429name by storing its address or passing the address to another function: 430 431@smallexample 432hack (int *array, int size) 433@{ 434 void store (int index, int value) 435 @{ array[index] = value; @} 436 437 intermediate (store, size); 438@} 439@end smallexample 440 441Here, the function @code{intermediate} receives the address of 442@code{store} as an argument. If @code{intermediate} calls @code{store}, 443the arguments given to @code{store} are used to store into @code{array}. 444But this technique works only so long as the containing function 445(@code{hack}, in this example) does not exit. 446 447If you try to call the nested function through its address after the 448containing function has exited, all hell will break loose. If you try 449to call it after a containing scope level has exited, and if it refers 450to some of the variables that are no longer in scope, you may be lucky, 451but it's not wise to take the risk. If, however, the nested function 452does not refer to anything that has gone out of scope, you should be 453safe. 454 455GCC implements taking the address of a nested function using a technique 456called @dfn{trampolines}. This technique was described in 457@cite{Lexical Closures for C++} (Thomas M. Breuel, USENIX 458C++ Conference Proceedings, October 17-21, 1988). 459 460A nested function can jump to a label inherited from a containing 461function, provided the label was explicitly declared in the containing 462function (@pxref{Local Labels}). Such a jump returns instantly to the 463containing function, exiting the nested function which did the 464@code{goto} and any intermediate functions as well. Here is an example: 465 466@smallexample 467@group 468bar (int *array, int offset, int size) 469@{ 470 __label__ failure; 471 int access (int *array, int index) 472 @{ 473 if (index > size) 474 goto failure; 475 return array[index + offset]; 476 @} 477 int i; 478 /* @r{@dots{}} */ 479 for (i = 0; i < size; i++) 480 /* @r{@dots{}} */ access (array, i) /* @r{@dots{}} */ 481 /* @r{@dots{}} */ 482 return 0; 483 484 /* @r{Control comes here from @code{access} 485 if it detects an error.} */ 486 failure: 487 return -1; 488@} 489@end group 490@end smallexample 491 492A nested function always has no linkage. Declaring one with 493@code{extern} or @code{static} is erroneous. If you need to declare the nested function 494before its definition, use @code{auto} (which is otherwise meaningless 495for function declarations). 496 497@smallexample 498bar (int *array, int offset, int size) 499@{ 500 __label__ failure; 501 auto int access (int *, int); 502 /* @r{@dots{}} */ 503 int access (int *array, int index) 504 @{ 505 if (index > size) 506 goto failure; 507 return array[index + offset]; 508 @} 509 /* @r{@dots{}} */ 510@} 511@end smallexample 512 513@node Constructing Calls 514@section Constructing Function Calls 515@cindex constructing calls 516@cindex forwarding calls 517 518Using the built-in functions described below, you can record 519the arguments a function received, and call another function 520with the same arguments, without knowing the number or types 521of the arguments. 522 523You can also record the return value of that function call, 524and later return that value, without knowing what data type 525the function tried to return (as long as your caller expects 526that data type). 527 528However, these built-in functions may interact badly with some 529sophisticated features or other extensions of the language. It 530is, therefore, not recommended to use them outside very simple 531functions acting as mere forwarders for their arguments. 532 533@deftypefn {Built-in Function} {void *} __builtin_apply_args () 534This built-in function returns a pointer to data 535describing how to perform a call with the same arguments as were passed 536to the current function. 537 538The function saves the arg pointer register, structure value address, 539and all registers that might be used to pass arguments to a function 540into a block of memory allocated on the stack. Then it returns the 541address of that block. 542@end deftypefn 543 544@deftypefn {Built-in Function} {void *} __builtin_apply (void (*@var{function})(), void *@var{arguments}, size_t @var{size}) 545This built-in function invokes @var{function} 546with a copy of the parameters described by @var{arguments} 547and @var{size}. 548 549The value of @var{arguments} should be the value returned by 550@code{__builtin_apply_args}. The argument @var{size} specifies the size 551of the stack argument data, in bytes. 552 553This function returns a pointer to data describing 554how to return whatever value was returned by @var{function}. The data 555is saved in a block of memory allocated on the stack. 556 557It is not always simple to compute the proper value for @var{size}. The 558value is used by @code{__builtin_apply} to compute the amount of data 559that should be pushed on the stack and copied from the incoming argument 560area. 561@end deftypefn 562 563@deftypefn {Built-in Function} {void} __builtin_return (void *@var{result}) 564This built-in function returns the value described by @var{result} from 565the containing function. You should specify, for @var{result}, a value 566returned by @code{__builtin_apply}. 567@end deftypefn 568 569@deftypefn {Built-in Function} __builtin_va_arg_pack () 570This built-in function represents all anonymous arguments of an inline 571function. It can be used only in inline functions which will be always 572inlined, never compiled as a separate function, such as those using 573@code{__attribute__ ((__always_inline__))} or 574@code{__attribute__ ((__gnu_inline__))} extern inline functions. 575It must be only passed as last argument to some other function 576with variable arguments. This is useful for writing small wrapper 577inlines for variable argument functions, when using preprocessor 578macros is undesirable. For example: 579@smallexample 580extern int myprintf (FILE *f, const char *format, ...); 581extern inline __attribute__ ((__gnu_inline__)) int 582myprintf (FILE *f, const char *format, ...) 583@{ 584 int r = fprintf (f, "myprintf: "); 585 if (r < 0) 586 return r; 587 int s = fprintf (f, format, __builtin_va_arg_pack ()); 588 if (s < 0) 589 return s; 590 return r + s; 591@} 592@end smallexample 593@end deftypefn 594 595@deftypefn {Built-in Function} __builtin_va_arg_pack_len () 596This built-in function returns the number of anonymous arguments of 597an inline function. It can be used only in inline functions which 598will be always inlined, never compiled as a separate function, such 599as those using @code{__attribute__ ((__always_inline__))} or 600@code{__attribute__ ((__gnu_inline__))} extern inline functions. 601For example following will do link or runtime checking of open 602arguments for optimized code: 603@smallexample 604#ifdef __OPTIMIZE__ 605extern inline __attribute__((__gnu_inline__)) int 606myopen (const char *path, int oflag, ...) 607@{ 608 if (__builtin_va_arg_pack_len () > 1) 609 warn_open_too_many_arguments (); 610 611 if (__builtin_constant_p (oflag)) 612 @{ 613 if ((oflag & O_CREAT) != 0 && __builtin_va_arg_pack_len () < 1) 614 @{ 615 warn_open_missing_mode (); 616 return __open_2 (path, oflag); 617 @} 618 return open (path, oflag, __builtin_va_arg_pack ()); 619 @} 620 621 if (__builtin_va_arg_pack_len () < 1) 622 return __open_2 (path, oflag); 623 624 return open (path, oflag, __builtin_va_arg_pack ()); 625@} 626#endif 627@end smallexample 628@end deftypefn 629 630@node Typeof 631@section Referring to a Type with @code{typeof} 632@findex typeof 633@findex sizeof 634@cindex macros, types of arguments 635 636Another way to refer to the type of an expression is with @code{typeof}. 637The syntax of using of this keyword looks like @code{sizeof}, but the 638construct acts semantically like a type name defined with @code{typedef}. 639 640There are two ways of writing the argument to @code{typeof}: with an 641expression or with a type. Here is an example with an expression: 642 643@smallexample 644typeof (x[0](1)) 645@end smallexample 646 647@noindent 648This assumes that @code{x} is an array of pointers to functions; 649the type described is that of the values of the functions. 650 651Here is an example with a typename as the argument: 652 653@smallexample 654typeof (int *) 655@end smallexample 656 657@noindent 658Here the type described is that of pointers to @code{int}. 659 660If you are writing a header file that must work when included in ISO C 661programs, write @code{__typeof__} instead of @code{typeof}. 662@xref{Alternate Keywords}. 663 664A @code{typeof}-construct can be used anywhere a typedef name could be 665used. For example, you can use it in a declaration, in a cast, or inside 666of @code{sizeof} or @code{typeof}. 667 668The operand of @code{typeof} is evaluated for its side effects if and 669only if it is an expression of variably modified type or the name of 670such a type. 671 672@code{typeof} is often useful in conjunction with the 673statements-within-expressions feature. Here is how the two together can 674be used to define a safe ``maximum'' macro that operates on any 675arithmetic type and evaluates each of its arguments exactly once: 676 677@smallexample 678#define max(a,b) \ 679 (@{ typeof (a) _a = (a); \ 680 typeof (b) _b = (b); \ 681 _a > _b ? _a : _b; @}) 682@end smallexample 683 684@cindex underscores in variables in macros 685@cindex @samp{_} in variables in macros 686@cindex local variables in macros 687@cindex variables, local, in macros 688@cindex macros, local variables in 689 690The reason for using names that start with underscores for the local 691variables is to avoid conflicts with variable names that occur within the 692expressions that are substituted for @code{a} and @code{b}. Eventually we 693hope to design a new form of declaration syntax that allows you to declare 694variables whose scopes start only after their initializers; this will be a 695more reliable way to prevent such conflicts. 696 697@noindent 698Some more examples of the use of @code{typeof}: 699 700@itemize @bullet 701@item 702This declares @code{y} with the type of what @code{x} points to. 703 704@smallexample 705typeof (*x) y; 706@end smallexample 707 708@item 709This declares @code{y} as an array of such values. 710 711@smallexample 712typeof (*x) y[4]; 713@end smallexample 714 715@item 716This declares @code{y} as an array of pointers to characters: 717 718@smallexample 719typeof (typeof (char *)[4]) y; 720@end smallexample 721 722@noindent 723It is equivalent to the following traditional C declaration: 724 725@smallexample 726char *y[4]; 727@end smallexample 728 729To see the meaning of the declaration using @code{typeof}, and why it 730might be a useful way to write, rewrite it with these macros: 731 732@smallexample 733#define pointer(T) typeof(T *) 734#define array(T, N) typeof(T [N]) 735@end smallexample 736 737@noindent 738Now the declaration can be rewritten this way: 739 740@smallexample 741array (pointer (char), 4) y; 742@end smallexample 743 744@noindent 745Thus, @code{array (pointer (char), 4)} is the type of arrays of 4 746pointers to @code{char}. 747@end itemize 748 749@emph{Compatibility Note:} In addition to @code{typeof}, GCC 2 supported 750a more limited extension which permitted one to write 751 752@smallexample 753typedef @var{T} = @var{expr}; 754@end smallexample 755 756@noindent 757with the effect of declaring @var{T} to have the type of the expression 758@var{expr}. This extension does not work with GCC 3 (versions between 7593.0 and 3.2 will crash; 3.2.1 and later give an error). Code which 760relies on it should be rewritten to use @code{typeof}: 761 762@smallexample 763typedef typeof(@var{expr}) @var{T}; 764@end smallexample 765 766@noindent 767This will work with all versions of GCC@. 768 769@node Conditionals 770@section Conditionals with Omitted Operands 771@cindex conditional expressions, extensions 772@cindex omitted middle-operands 773@cindex middle-operands, omitted 774@cindex extensions, @code{?:} 775@cindex @code{?:} extensions 776 777The middle operand in a conditional expression may be omitted. Then 778if the first operand is nonzero, its value is the value of the conditional 779expression. 780 781Therefore, the expression 782 783@smallexample 784x ? : y 785@end smallexample 786 787@noindent 788has the value of @code{x} if that is nonzero; otherwise, the value of 789@code{y}. 790 791This example is perfectly equivalent to 792 793@smallexample 794x ? x : y 795@end smallexample 796 797@cindex side effect in ?: 798@cindex ?: side effect 799@noindent 800In this simple case, the ability to omit the middle operand is not 801especially useful. When it becomes useful is when the first operand does, 802or may (if it is a macro argument), contain a side effect. Then repeating 803the operand in the middle would perform the side effect twice. Omitting 804the middle operand uses the value already computed without the undesirable 805effects of recomputing it. 806 807@node Long Long 808@section Double-Word Integers 809@cindex @code{long long} data types 810@cindex double-word arithmetic 811@cindex multiprecision arithmetic 812@cindex @code{LL} integer suffix 813@cindex @code{ULL} integer suffix 814 815ISO C99 supports data types for integers that are at least 64 bits wide, 816and as an extension GCC supports them in C90 mode and in C++. 817Simply write @code{long long int} for a signed integer, or 818@code{unsigned long long int} for an unsigned integer. To make an 819integer constant of type @code{long long int}, add the suffix @samp{LL} 820to the integer. To make an integer constant of type @code{unsigned long 821long int}, add the suffix @samp{ULL} to the integer. 822 823You can use these types in arithmetic like any other integer types. 824Addition, subtraction, and bitwise boolean operations on these types 825are open-coded on all types of machines. Multiplication is open-coded 826if the machine supports fullword-to-doubleword a widening multiply 827instruction. Division and shifts are open-coded only on machines that 828provide special support. The operations that are not open-coded use 829special library routines that come with GCC@. 830 831There may be pitfalls when you use @code{long long} types for function 832arguments, unless you declare function prototypes. If a function 833expects type @code{int} for its argument, and you pass a value of type 834@code{long long int}, confusion will result because the caller and the 835subroutine will disagree about the number of bytes for the argument. 836Likewise, if the function expects @code{long long int} and you pass 837@code{int}. The best way to avoid such problems is to use prototypes. 838 839@node Complex 840@section Complex Numbers 841@cindex complex numbers 842@cindex @code{_Complex} keyword 843@cindex @code{__complex__} keyword 844 845ISO C99 supports complex floating data types, and as an extension GCC 846supports them in C90 mode and in C++, and supports complex integer data 847types which are not part of ISO C99. You can declare complex types 848using the keyword @code{_Complex}. As an extension, the older GNU 849keyword @code{__complex__} is also supported. 850 851For example, @samp{_Complex double x;} declares @code{x} as a 852variable whose real part and imaginary part are both of type 853@code{double}. @samp{_Complex short int y;} declares @code{y} to 854have real and imaginary parts of type @code{short int}; this is not 855likely to be useful, but it shows that the set of complex types is 856complete. 857 858To write a constant with a complex data type, use the suffix @samp{i} or 859@samp{j} (either one; they are equivalent). For example, @code{2.5fi} 860has type @code{_Complex float} and @code{3i} has type 861@code{_Complex int}. Such a constant always has a pure imaginary 862value, but you can form any complex value you like by adding one to a 863real constant. This is a GNU extension; if you have an ISO C99 864conforming C library (such as GNU libc), and want to construct complex 865constants of floating type, you should include @code{<complex.h>} and 866use the macros @code{I} or @code{_Complex_I} instead. 867 868@cindex @code{__real__} keyword 869@cindex @code{__imag__} keyword 870To extract the real part of a complex-valued expression @var{exp}, write 871@code{__real__ @var{exp}}. Likewise, use @code{__imag__} to 872extract the imaginary part. This is a GNU extension; for values of 873floating type, you should use the ISO C99 functions @code{crealf}, 874@code{creal}, @code{creall}, @code{cimagf}, @code{cimag} and 875@code{cimagl}, declared in @code{<complex.h>} and also provided as 876built-in functions by GCC@. 877 878@cindex complex conjugation 879The operator @samp{~} performs complex conjugation when used on a value 880with a complex type. This is a GNU extension; for values of 881floating type, you should use the ISO C99 functions @code{conjf}, 882@code{conj} and @code{conjl}, declared in @code{<complex.h>} and also 883provided as built-in functions by GCC@. 884 885GCC can allocate complex automatic variables in a noncontiguous 886fashion; it's even possible for the real part to be in a register while 887the imaginary part is on the stack (or vice-versa). Only the DWARF2 888debug info format can represent this, so use of DWARF2 is recommended. 889If you are using the stabs debug info format, GCC describes a noncontiguous 890complex variable as if it were two separate variables of noncomplex type. 891If the variable's actual name is @code{foo}, the two fictitious 892variables are named @code{foo$real} and @code{foo$imag}. You can 893examine and set these two fictitious variables with your debugger. 894 895@node Floating Types 896@section Additional Floating Types 897@cindex additional floating types 898@cindex @code{__float80} data type 899@cindex @code{__float128} data type 900@cindex @code{w} floating point suffix 901@cindex @code{q} floating point suffix 902@cindex @code{W} floating point suffix 903@cindex @code{Q} floating point suffix 904 905As an extension, the GNU C compiler supports additional floating 906types, @code{__float80} and @code{__float128} to support 80bit 907(@code{XFmode}) and 128 bit (@code{TFmode}) floating types. 908Support for additional types includes the arithmetic operators: 909add, subtract, multiply, divide; unary arithmetic operators; 910relational operators; equality operators; and conversions to and from 911integer and other floating types. Use a suffix @samp{w} or @samp{W} 912in a literal constant of type @code{__float80} and @samp{q} or @samp{Q} 913for @code{_float128}. You can declare complex types using the 914corresponding internal complex type, @code{XCmode} for @code{__float80} 915type and @code{TCmode} for @code{__float128} type: 916 917@smallexample 918typedef _Complex float __attribute__((mode(TC))) _Complex128; 919typedef _Complex float __attribute__((mode(XC))) _Complex80; 920@end smallexample 921 922Not all targets support additional floating point types. @code{__float80} 923and @code{__float128} types are supported on i386, x86_64 and ia64 targets. 924 925@node Half-Precision 926@section Half-Precision Floating Point 927@cindex half-precision floating point 928@cindex @code{__fp16} data type 929 930On ARM targets, GCC supports half-precision (16-bit) floating point via 931the @code{__fp16} type. You must enable this type explicitly 932with the @option{-mfp16-format} command-line option in order to use it. 933 934ARM supports two incompatible representations for half-precision 935floating-point values. You must choose one of the representations and 936use it consistently in your program. 937 938Specifying @option{-mfp16-format=ieee} selects the IEEE 754-2008 format. 939This format can represent normalized values in the range of @math{2^{-14}} to 65504. 940There are 11 bits of significand precision, approximately 3 941decimal digits. 942 943Specifying @option{-mfp16-format=alternative} selects the ARM 944alternative format. This representation is similar to the IEEE 945format, but does not support infinities or NaNs. Instead, the range 946of exponents is extended, so that this format can represent normalized 947values in the range of @math{2^{-14}} to 131008. 948 949The @code{__fp16} type is a storage format only. For purposes 950of arithmetic and other operations, @code{__fp16} values in C or C++ 951expressions are automatically promoted to @code{float}. In addition, 952you cannot declare a function with a return value or parameters 953of type @code{__fp16}. 954 955Note that conversions from @code{double} to @code{__fp16} 956involve an intermediate conversion to @code{float}. Because 957of rounding, this can sometimes produce a different result than a 958direct conversion. 959 960ARM provides hardware support for conversions between 961@code{__fp16} and @code{float} values 962as an extension to VFP and NEON (Advanced SIMD). GCC generates 963code using these hardware instructions if you compile with 964options to select an FPU that provides them; 965for example, @option{-mfpu=neon-fp16 -mfloat-abi=softfp}, 966in addition to the @option{-mfp16-format} option to select 967a half-precision format. 968 969Language-level support for the @code{__fp16} data type is 970independent of whether GCC generates code using hardware floating-point 971instructions. In cases where hardware support is not specified, GCC 972implements conversions between @code{__fp16} and @code{float} values 973as library calls. 974 975@node Decimal Float 976@section Decimal Floating Types 977@cindex decimal floating types 978@cindex @code{_Decimal32} data type 979@cindex @code{_Decimal64} data type 980@cindex @code{_Decimal128} data type 981@cindex @code{df} integer suffix 982@cindex @code{dd} integer suffix 983@cindex @code{dl} integer suffix 984@cindex @code{DF} integer suffix 985@cindex @code{DD} integer suffix 986@cindex @code{DL} integer suffix 987 988As an extension, the GNU C compiler supports decimal floating types as 989defined in the N1312 draft of ISO/IEC WDTR24732. Support for decimal 990floating types in GCC will evolve as the draft technical report changes. 991Calling conventions for any target might also change. Not all targets 992support decimal floating types. 993 994The decimal floating types are @code{_Decimal32}, @code{_Decimal64}, and 995@code{_Decimal128}. They use a radix of ten, unlike the floating types 996@code{float}, @code{double}, and @code{long double} whose radix is not 997specified by the C standard but is usually two. 998 999Support for decimal floating types includes the arithmetic operators 1000add, subtract, multiply, divide; unary arithmetic operators; 1001relational operators; equality operators; and conversions to and from 1002integer and other floating types. Use a suffix @samp{df} or 1003@samp{DF} in a literal constant of type @code{_Decimal32}, @samp{dd} 1004or @samp{DD} for @code{_Decimal64}, and @samp{dl} or @samp{DL} for 1005@code{_Decimal128}. 1006 1007GCC support of decimal float as specified by the draft technical report 1008is incomplete: 1009 1010@itemize @bullet 1011@item 1012When the value of a decimal floating type cannot be represented in the 1013integer type to which it is being converted, the result is undefined 1014rather than the result value specified by the draft technical report. 1015 1016@item 1017GCC does not provide the C library functionality associated with 1018@file{math.h}, @file{fenv.h}, @file{stdio.h}, @file{stdlib.h}, and 1019@file{wchar.h}, which must come from a separate C library implementation. 1020Because of this the GNU C compiler does not define macro 1021@code{__STDC_DEC_FP__} to indicate that the implementation conforms to 1022the technical report. 1023@end itemize 1024 1025Types @code{_Decimal32}, @code{_Decimal64}, and @code{_Decimal128} 1026are supported by the DWARF2 debug information format. 1027 1028@node Hex Floats 1029@section Hex Floats 1030@cindex hex floats 1031 1032ISO C99 supports floating-point numbers written not only in the usual 1033decimal notation, such as @code{1.55e1}, but also numbers such as 1034@code{0x1.fp3} written in hexadecimal format. As a GNU extension, GCC 1035supports this in C90 mode (except in some cases when strictly 1036conforming) and in C++. In that format the 1037@samp{0x} hex introducer and the @samp{p} or @samp{P} exponent field are 1038mandatory. The exponent is a decimal number that indicates the power of 10392 by which the significant part will be multiplied. Thus @samp{0x1.f} is 1040@tex 1041$1 {15\over16}$, 1042@end tex 1043@ifnottex 10441 15/16, 1045@end ifnottex 1046@samp{p3} multiplies it by 8, and the value of @code{0x1.fp3} 1047is the same as @code{1.55e1}. 1048 1049Unlike for floating-point numbers in the decimal notation the exponent 1050is always required in the hexadecimal notation. Otherwise the compiler 1051would not be able to resolve the ambiguity of, e.g., @code{0x1.f}. This 1052could mean @code{1.0f} or @code{1.9375} since @samp{f} is also the 1053extension for floating-point constants of type @code{float}. 1054 1055@node Fixed-Point 1056@section Fixed-Point Types 1057@cindex fixed-point types 1058@cindex @code{_Fract} data type 1059@cindex @code{_Accum} data type 1060@cindex @code{_Sat} data type 1061@cindex @code{hr} fixed-suffix 1062@cindex @code{r} fixed-suffix 1063@cindex @code{lr} fixed-suffix 1064@cindex @code{llr} fixed-suffix 1065@cindex @code{uhr} fixed-suffix 1066@cindex @code{ur} fixed-suffix 1067@cindex @code{ulr} fixed-suffix 1068@cindex @code{ullr} fixed-suffix 1069@cindex @code{hk} fixed-suffix 1070@cindex @code{k} fixed-suffix 1071@cindex @code{lk} fixed-suffix 1072@cindex @code{llk} fixed-suffix 1073@cindex @code{uhk} fixed-suffix 1074@cindex @code{uk} fixed-suffix 1075@cindex @code{ulk} fixed-suffix 1076@cindex @code{ullk} fixed-suffix 1077@cindex @code{HR} fixed-suffix 1078@cindex @code{R} fixed-suffix 1079@cindex @code{LR} fixed-suffix 1080@cindex @code{LLR} fixed-suffix 1081@cindex @code{UHR} fixed-suffix 1082@cindex @code{UR} fixed-suffix 1083@cindex @code{ULR} fixed-suffix 1084@cindex @code{ULLR} fixed-suffix 1085@cindex @code{HK} fixed-suffix 1086@cindex @code{K} fixed-suffix 1087@cindex @code{LK} fixed-suffix 1088@cindex @code{LLK} fixed-suffix 1089@cindex @code{UHK} fixed-suffix 1090@cindex @code{UK} fixed-suffix 1091@cindex @code{ULK} fixed-suffix 1092@cindex @code{ULLK} fixed-suffix 1093 1094As an extension, the GNU C compiler supports fixed-point types as 1095defined in the N1169 draft of ISO/IEC DTR 18037. Support for fixed-point 1096types in GCC will evolve as the draft technical report changes. 1097Calling conventions for any target might also change. Not all targets 1098support fixed-point types. 1099 1100The fixed-point types are 1101@code{short _Fract}, 1102@code{_Fract}, 1103@code{long _Fract}, 1104@code{long long _Fract}, 1105@code{unsigned short _Fract}, 1106@code{unsigned _Fract}, 1107@code{unsigned long _Fract}, 1108@code{unsigned long long _Fract}, 1109@code{_Sat short _Fract}, 1110@code{_Sat _Fract}, 1111@code{_Sat long _Fract}, 1112@code{_Sat long long _Fract}, 1113@code{_Sat unsigned short _Fract}, 1114@code{_Sat unsigned _Fract}, 1115@code{_Sat unsigned long _Fract}, 1116@code{_Sat unsigned long long _Fract}, 1117@code{short _Accum}, 1118@code{_Accum}, 1119@code{long _Accum}, 1120@code{long long _Accum}, 1121@code{unsigned short _Accum}, 1122@code{unsigned _Accum}, 1123@code{unsigned long _Accum}, 1124@code{unsigned long long _Accum}, 1125@code{_Sat short _Accum}, 1126@code{_Sat _Accum}, 1127@code{_Sat long _Accum}, 1128@code{_Sat long long _Accum}, 1129@code{_Sat unsigned short _Accum}, 1130@code{_Sat unsigned _Accum}, 1131@code{_Sat unsigned long _Accum}, 1132@code{_Sat unsigned long long _Accum}. 1133 1134Fixed-point data values contain fractional and optional integral parts. 1135The format of fixed-point data varies and depends on the target machine. 1136 1137Support for fixed-point types includes: 1138@itemize @bullet 1139@item 1140prefix and postfix increment and decrement operators (@code{++}, @code{--}) 1141@item 1142unary arithmetic operators (@code{+}, @code{-}, @code{!}) 1143@item 1144binary arithmetic operators (@code{+}, @code{-}, @code{*}, @code{/}) 1145@item 1146binary shift operators (@code{<<}, @code{>>}) 1147@item 1148relational operators (@code{<}, @code{<=}, @code{>=}, @code{>}) 1149@item 1150equality operators (@code{==}, @code{!=}) 1151@item 1152assignment operators (@code{+=}, @code{-=}, @code{*=}, @code{/=}, 1153@code{<<=}, @code{>>=}) 1154@item 1155conversions to and from integer, floating-point, or fixed-point types 1156@end itemize 1157 1158Use a suffix in a fixed-point literal constant: 1159@itemize 1160@item @samp{hr} or @samp{HR} for @code{short _Fract} and 1161@code{_Sat short _Fract} 1162@item @samp{r} or @samp{R} for @code{_Fract} and @code{_Sat _Fract} 1163@item @samp{lr} or @samp{LR} for @code{long _Fract} and 1164@code{_Sat long _Fract} 1165@item @samp{llr} or @samp{LLR} for @code{long long _Fract} and 1166@code{_Sat long long _Fract} 1167@item @samp{uhr} or @samp{UHR} for @code{unsigned short _Fract} and 1168@code{_Sat unsigned short _Fract} 1169@item @samp{ur} or @samp{UR} for @code{unsigned _Fract} and 1170@code{_Sat unsigned _Fract} 1171@item @samp{ulr} or @samp{ULR} for @code{unsigned long _Fract} and 1172@code{_Sat unsigned long _Fract} 1173@item @samp{ullr} or @samp{ULLR} for @code{unsigned long long _Fract} 1174and @code{_Sat unsigned long long _Fract} 1175@item @samp{hk} or @samp{HK} for @code{short _Accum} and 1176@code{_Sat short _Accum} 1177@item @samp{k} or @samp{K} for @code{_Accum} and @code{_Sat _Accum} 1178@item @samp{lk} or @samp{LK} for @code{long _Accum} and 1179@code{_Sat long _Accum} 1180@item @samp{llk} or @samp{LLK} for @code{long long _Accum} and 1181@code{_Sat long long _Accum} 1182@item @samp{uhk} or @samp{UHK} for @code{unsigned short _Accum} and 1183@code{_Sat unsigned short _Accum} 1184@item @samp{uk} or @samp{UK} for @code{unsigned _Accum} and 1185@code{_Sat unsigned _Accum} 1186@item @samp{ulk} or @samp{ULK} for @code{unsigned long _Accum} and 1187@code{_Sat unsigned long _Accum} 1188@item @samp{ullk} or @samp{ULLK} for @code{unsigned long long _Accum} 1189and @code{_Sat unsigned long long _Accum} 1190@end itemize 1191 1192GCC support of fixed-point types as specified by the draft technical report 1193is incomplete: 1194 1195@itemize @bullet 1196@item 1197Pragmas to control overflow and rounding behaviors are not implemented. 1198@end itemize 1199 1200Fixed-point types are supported by the DWARF2 debug information format. 1201 1202@node Named Address Spaces 1203@section Named address spaces 1204@cindex named address spaces 1205 1206As an extension, the GNU C compiler supports named address spaces as 1207defined in the N1275 draft of ISO/IEC DTR 18037. Support for named 1208address spaces in GCC will evolve as the draft technical report changes. 1209Calling conventions for any target might also change. At present, only 1210the SPU target supports other address spaces. On the SPU target, for 1211example, variables may be declared as belonging to another address space 1212by qualifying the type with the @code{__ea} address space identifier: 1213 1214@smallexample 1215extern int __ea i; 1216@end smallexample 1217 1218When the variable @code{i} is accessed, the compiler will generate 1219special code to access this variable. It may use runtime library 1220support, or generate special machine instructions to access that address 1221space. 1222 1223The @code{__ea} identifier may be used exactly like any other C type 1224qualifier (e.g., @code{const} or @code{volatile}). See the N1275 1225document for more details. 1226 1227@node Zero Length 1228@section Arrays of Length Zero 1229@cindex arrays of length zero 1230@cindex zero-length arrays 1231@cindex length-zero arrays 1232@cindex flexible array members 1233 1234Zero-length arrays are allowed in GNU C@. They are very useful as the 1235last element of a structure which is really a header for a variable-length 1236object: 1237 1238@smallexample 1239struct line @{ 1240 int length; 1241 char contents[0]; 1242@}; 1243 1244struct line *thisline = (struct line *) 1245 malloc (sizeof (struct line) + this_length); 1246thisline->length = this_length; 1247@end smallexample 1248 1249In ISO C90, you would have to give @code{contents} a length of 1, which 1250means either you waste space or complicate the argument to @code{malloc}. 1251 1252In ISO C99, you would use a @dfn{flexible array member}, which is 1253slightly different in syntax and semantics: 1254 1255@itemize @bullet 1256@item 1257Flexible array members are written as @code{contents[]} without 1258the @code{0}. 1259 1260@item 1261Flexible array members have incomplete type, and so the @code{sizeof} 1262operator may not be applied. As a quirk of the original implementation 1263of zero-length arrays, @code{sizeof} evaluates to zero. 1264 1265@item 1266Flexible array members may only appear as the last member of a 1267@code{struct} that is otherwise non-empty. 1268 1269@item 1270A structure containing a flexible array member, or a union containing 1271such a structure (possibly recursively), may not be a member of a 1272structure or an element of an array. (However, these uses are 1273permitted by GCC as extensions.) 1274@end itemize 1275 1276GCC versions before 3.0 allowed zero-length arrays to be statically 1277initialized, as if they were flexible arrays. In addition to those 1278cases that were useful, it also allowed initializations in situations 1279that would corrupt later data. Non-empty initialization of zero-length 1280arrays is now treated like any case where there are more initializer 1281elements than the array holds, in that a suitable warning about "excess 1282elements in array" is given, and the excess elements (all of them, in 1283this case) are ignored. 1284 1285Instead GCC allows static initialization of flexible array members. 1286This is equivalent to defining a new structure containing the original 1287structure followed by an array of sufficient size to contain the data. 1288I.e.@: in the following, @code{f1} is constructed as if it were declared 1289like @code{f2}. 1290 1291@smallexample 1292struct f1 @{ 1293 int x; int y[]; 1294@} f1 = @{ 1, @{ 2, 3, 4 @} @}; 1295 1296struct f2 @{ 1297 struct f1 f1; int data[3]; 1298@} f2 = @{ @{ 1 @}, @{ 2, 3, 4 @} @}; 1299@end smallexample 1300 1301@noindent 1302The convenience of this extension is that @code{f1} has the desired 1303type, eliminating the need to consistently refer to @code{f2.f1}. 1304 1305This has symmetry with normal static arrays, in that an array of 1306unknown size is also written with @code{[]}. 1307 1308Of course, this extension only makes sense if the extra data comes at 1309the end of a top-level object, as otherwise we would be overwriting 1310data at subsequent offsets. To avoid undue complication and confusion 1311with initialization of deeply nested arrays, we simply disallow any 1312non-empty initialization except when the structure is the top-level 1313object. For example: 1314 1315@smallexample 1316struct foo @{ int x; int y[]; @}; 1317struct bar @{ struct foo z; @}; 1318 1319struct foo a = @{ 1, @{ 2, 3, 4 @} @}; // @r{Valid.} 1320struct bar b = @{ @{ 1, @{ 2, 3, 4 @} @} @}; // @r{Invalid.} 1321struct bar c = @{ @{ 1, @{ @} @} @}; // @r{Valid.} 1322struct foo d[1] = @{ @{ 1 @{ 2, 3, 4 @} @} @}; // @r{Invalid.} 1323@end smallexample 1324 1325@node Empty Structures 1326@section Structures With No Members 1327@cindex empty structures 1328@cindex zero-size structures 1329 1330GCC permits a C structure to have no members: 1331 1332@smallexample 1333struct empty @{ 1334@}; 1335@end smallexample 1336 1337The structure will have size zero. In C++, empty structures are part 1338of the language. G++ treats empty structures as if they had a single 1339member of type @code{char}. 1340 1341@node Variable Length 1342@section Arrays of Variable Length 1343@cindex variable-length arrays 1344@cindex arrays of variable length 1345@cindex VLAs 1346 1347Variable-length automatic arrays are allowed in ISO C99, and as an 1348extension GCC accepts them in C90 mode and in C++. These arrays are 1349declared like any other automatic arrays, but with a length that is not 1350a constant expression. The storage is allocated at the point of 1351declaration and deallocated when the brace-level is exited. For 1352example: 1353 1354@smallexample 1355FILE * 1356concat_fopen (char *s1, char *s2, char *mode) 1357@{ 1358 char str[strlen (s1) + strlen (s2) + 1]; 1359 strcpy (str, s1); 1360 strcat (str, s2); 1361 return fopen (str, mode); 1362@} 1363@end smallexample 1364 1365@cindex scope of a variable length array 1366@cindex variable-length array scope 1367@cindex deallocating variable length arrays 1368Jumping or breaking out of the scope of the array name deallocates the 1369storage. Jumping into the scope is not allowed; you get an error 1370message for it. 1371 1372@cindex @code{alloca} vs variable-length arrays 1373You can use the function @code{alloca} to get an effect much like 1374variable-length arrays. The function @code{alloca} is available in 1375many other C implementations (but not in all). On the other hand, 1376variable-length arrays are more elegant. 1377 1378There are other differences between these two methods. Space allocated 1379with @code{alloca} exists until the containing @emph{function} returns. 1380The space for a variable-length array is deallocated as soon as the array 1381name's scope ends. (If you use both variable-length arrays and 1382@code{alloca} in the same function, deallocation of a variable-length array 1383will also deallocate anything more recently allocated with @code{alloca}.) 1384 1385You can also use variable-length arrays as arguments to functions: 1386 1387@smallexample 1388struct entry 1389tester (int len, char data[len][len]) 1390@{ 1391 /* @r{@dots{}} */ 1392@} 1393@end smallexample 1394 1395The length of an array is computed once when the storage is allocated 1396and is remembered for the scope of the array in case you access it with 1397@code{sizeof}. 1398 1399If you want to pass the array first and the length afterward, you can 1400use a forward declaration in the parameter list---another GNU extension. 1401 1402@smallexample 1403struct entry 1404tester (int len; char data[len][len], int len) 1405@{ 1406 /* @r{@dots{}} */ 1407@} 1408@end smallexample 1409 1410@cindex parameter forward declaration 1411The @samp{int len} before the semicolon is a @dfn{parameter forward 1412declaration}, and it serves the purpose of making the name @code{len} 1413known when the declaration of @code{data} is parsed. 1414 1415You can write any number of such parameter forward declarations in the 1416parameter list. They can be separated by commas or semicolons, but the 1417last one must end with a semicolon, which is followed by the ``real'' 1418parameter declarations. Each forward declaration must match a ``real'' 1419declaration in parameter name and data type. ISO C99 does not support 1420parameter forward declarations. 1421 1422@node Variadic Macros 1423@section Macros with a Variable Number of Arguments. 1424@cindex variable number of arguments 1425@cindex macro with variable arguments 1426@cindex rest argument (in macro) 1427@cindex variadic macros 1428 1429In the ISO C standard of 1999, a macro can be declared to accept a 1430variable number of arguments much as a function can. The syntax for 1431defining the macro is similar to that of a function. Here is an 1432example: 1433 1434@smallexample 1435#define debug(format, ...) fprintf (stderr, format, __VA_ARGS__) 1436@end smallexample 1437 1438Here @samp{@dots{}} is a @dfn{variable argument}. In the invocation of 1439such a macro, it represents the zero or more tokens until the closing 1440parenthesis that ends the invocation, including any commas. This set of 1441tokens replaces the identifier @code{__VA_ARGS__} in the macro body 1442wherever it appears. See the CPP manual for more information. 1443 1444GCC has long supported variadic macros, and used a different syntax that 1445allowed you to give a name to the variable arguments just like any other 1446argument. Here is an example: 1447 1448@smallexample 1449#define debug(format, args...) fprintf (stderr, format, args) 1450@end smallexample 1451 1452This is in all ways equivalent to the ISO C example above, but arguably 1453more readable and descriptive. 1454 1455GNU CPP has two further variadic macro extensions, and permits them to 1456be used with either of the above forms of macro definition. 1457 1458In standard C, you are not allowed to leave the variable argument out 1459entirely; but you are allowed to pass an empty argument. For example, 1460this invocation is invalid in ISO C, because there is no comma after 1461the string: 1462 1463@smallexample 1464debug ("A message") 1465@end smallexample 1466 1467GNU CPP permits you to completely omit the variable arguments in this 1468way. In the above examples, the compiler would complain, though since 1469the expansion of the macro still has the extra comma after the format 1470string. 1471 1472To help solve this problem, CPP behaves specially for variable arguments 1473used with the token paste operator, @samp{##}. If instead you write 1474 1475@smallexample 1476#define debug(format, ...) fprintf (stderr, format, ## __VA_ARGS__) 1477@end smallexample 1478 1479and if the variable arguments are omitted or empty, the @samp{##} 1480operator causes the preprocessor to remove the comma before it. If you 1481do provide some variable arguments in your macro invocation, GNU CPP 1482does not complain about the paste operation and instead places the 1483variable arguments after the comma. Just like any other pasted macro 1484argument, these arguments are not macro expanded. 1485 1486@node Escaped Newlines 1487@section Slightly Looser Rules for Escaped Newlines 1488@cindex escaped newlines 1489@cindex newlines (escaped) 1490 1491Recently, the preprocessor has relaxed its treatment of escaped 1492newlines. Previously, the newline had to immediately follow a 1493backslash. The current implementation allows whitespace in the form 1494of spaces, horizontal and vertical tabs, and form feeds between the 1495backslash and the subsequent newline. The preprocessor issues a 1496warning, but treats it as a valid escaped newline and combines the two 1497lines to form a single logical line. This works within comments and 1498tokens, as well as between tokens. Comments are @emph{not} treated as 1499whitespace for the purposes of this relaxation, since they have not 1500yet been replaced with spaces. 1501 1502@node Subscripting 1503@section Non-Lvalue Arrays May Have Subscripts 1504@cindex subscripting 1505@cindex arrays, non-lvalue 1506 1507@cindex subscripting and function values 1508In ISO C99, arrays that are not lvalues still decay to pointers, and 1509may be subscripted, although they may not be modified or used after 1510the next sequence point and the unary @samp{&} operator may not be 1511applied to them. As an extension, GCC allows such arrays to be 1512subscripted in C90 mode, though otherwise they do not decay to 1513pointers outside C99 mode. For example, 1514this is valid in GNU C though not valid in C90: 1515 1516@smallexample 1517@group 1518struct foo @{int a[4];@}; 1519 1520struct foo f(); 1521 1522bar (int index) 1523@{ 1524 return f().a[index]; 1525@} 1526@end group 1527@end smallexample 1528 1529@node Pointer Arith 1530@section Arithmetic on @code{void}- and Function-Pointers 1531@cindex void pointers, arithmetic 1532@cindex void, size of pointer to 1533@cindex function pointers, arithmetic 1534@cindex function, size of pointer to 1535 1536In GNU C, addition and subtraction operations are supported on pointers to 1537@code{void} and on pointers to functions. This is done by treating the 1538size of a @code{void} or of a function as 1. 1539 1540A consequence of this is that @code{sizeof} is also allowed on @code{void} 1541and on function types, and returns 1. 1542 1543@opindex Wpointer-arith 1544The option @option{-Wpointer-arith} requests a warning if these extensions 1545are used. 1546 1547@node Initializers 1548@section Non-Constant Initializers 1549@cindex initializers, non-constant 1550@cindex non-constant initializers 1551 1552As in standard C++ and ISO C99, the elements of an aggregate initializer for an 1553automatic variable are not required to be constant expressions in GNU C@. 1554Here is an example of an initializer with run-time varying elements: 1555 1556@smallexample 1557foo (float f, float g) 1558@{ 1559 float beat_freqs[2] = @{ f-g, f+g @}; 1560 /* @r{@dots{}} */ 1561@} 1562@end smallexample 1563 1564@node Compound Literals 1565@section Compound Literals 1566@cindex constructor expressions 1567@cindex initializations in expressions 1568@cindex structures, constructor expression 1569@cindex expressions, constructor 1570@cindex compound literals 1571@c The GNU C name for what C99 calls compound literals was "constructor expressions". 1572 1573ISO C99 supports compound literals. A compound literal looks like 1574a cast containing an initializer. Its value is an object of the 1575type specified in the cast, containing the elements specified in 1576the initializer; it is an lvalue. As an extension, GCC supports 1577compound literals in C90 mode and in C++. 1578 1579Usually, the specified type is a structure. Assume that 1580@code{struct foo} and @code{structure} are declared as shown: 1581 1582@smallexample 1583struct foo @{int a; char b[2];@} structure; 1584@end smallexample 1585 1586@noindent 1587Here is an example of constructing a @code{struct foo} with a compound literal: 1588 1589@smallexample 1590structure = ((struct foo) @{x + y, 'a', 0@}); 1591@end smallexample 1592 1593@noindent 1594This is equivalent to writing the following: 1595 1596@smallexample 1597@{ 1598 struct foo temp = @{x + y, 'a', 0@}; 1599 structure = temp; 1600@} 1601@end smallexample 1602 1603You can also construct an array. If all the elements of the compound literal 1604are (made up of) simple constant expressions, suitable for use in 1605initializers of objects of static storage duration, then the compound 1606literal can be coerced to a pointer to its first element and used in 1607such an initializer, as shown here: 1608 1609@smallexample 1610char **foo = (char *[]) @{ "x", "y", "z" @}; 1611@end smallexample 1612 1613Compound literals for scalar types and union types are is 1614also allowed, but then the compound literal is equivalent 1615to a cast. 1616 1617As a GNU extension, GCC allows initialization of objects with static storage 1618duration by compound literals (which is not possible in ISO C99, because 1619the initializer is not a constant). 1620It is handled as if the object was initialized only with the bracket 1621enclosed list if the types of the compound literal and the object match. 1622The initializer list of the compound literal must be constant. 1623If the object being initialized has array type of unknown size, the size is 1624determined by compound literal size. 1625 1626@smallexample 1627static struct foo x = (struct foo) @{1, 'a', 'b'@}; 1628static int y[] = (int []) @{1, 2, 3@}; 1629static int z[] = (int [3]) @{1@}; 1630@end smallexample 1631 1632@noindent 1633The above lines are equivalent to the following: 1634@smallexample 1635static struct foo x = @{1, 'a', 'b'@}; 1636static int y[] = @{1, 2, 3@}; 1637static int z[] = @{1, 0, 0@}; 1638@end smallexample 1639 1640@node Designated Inits 1641@section Designated Initializers 1642@cindex initializers with labeled elements 1643@cindex labeled elements in initializers 1644@cindex case labels in initializers 1645@cindex designated initializers 1646 1647Standard C90 requires the elements of an initializer to appear in a fixed 1648order, the same as the order of the elements in the array or structure 1649being initialized. 1650 1651In ISO C99 you can give the elements in any order, specifying the array 1652indices or structure field names they apply to, and GNU C allows this as 1653an extension in C90 mode as well. This extension is not 1654implemented in GNU C++. 1655 1656To specify an array index, write 1657@samp{[@var{index}] =} before the element value. For example, 1658 1659@smallexample 1660int a[6] = @{ [4] = 29, [2] = 15 @}; 1661@end smallexample 1662 1663@noindent 1664is equivalent to 1665 1666@smallexample 1667int a[6] = @{ 0, 0, 15, 0, 29, 0 @}; 1668@end smallexample 1669 1670@noindent 1671The index values must be constant expressions, even if the array being 1672initialized is automatic. 1673 1674An alternative syntax for this which has been obsolete since GCC 2.5 but 1675GCC still accepts is to write @samp{[@var{index}]} before the element 1676value, with no @samp{=}. 1677 1678To initialize a range of elements to the same value, write 1679@samp{[@var{first} ... @var{last}] = @var{value}}. This is a GNU 1680extension. For example, 1681 1682@smallexample 1683int widths[] = @{ [0 ... 9] = 1, [10 ... 99] = 2, [100] = 3 @}; 1684@end smallexample 1685 1686@noindent 1687If the value in it has side-effects, the side-effects will happen only once, 1688not for each initialized field by the range initializer. 1689 1690@noindent 1691Note that the length of the array is the highest value specified 1692plus one. 1693 1694In a structure initializer, specify the name of a field to initialize 1695with @samp{.@var{fieldname} =} before the element value. For example, 1696given the following structure, 1697 1698@smallexample 1699struct point @{ int x, y; @}; 1700@end smallexample 1701 1702@noindent 1703the following initialization 1704 1705@smallexample 1706struct point p = @{ .y = yvalue, .x = xvalue @}; 1707@end smallexample 1708 1709@noindent 1710is equivalent to 1711 1712@smallexample 1713struct point p = @{ xvalue, yvalue @}; 1714@end smallexample 1715 1716Another syntax which has the same meaning, obsolete since GCC 2.5, is 1717@samp{@var{fieldname}:}, as shown here: 1718 1719@smallexample 1720struct point p = @{ y: yvalue, x: xvalue @}; 1721@end smallexample 1722 1723@cindex designators 1724The @samp{[@var{index}]} or @samp{.@var{fieldname}} is known as a 1725@dfn{designator}. You can also use a designator (or the obsolete colon 1726syntax) when initializing a union, to specify which element of the union 1727should be used. For example, 1728 1729@smallexample 1730union foo @{ int i; double d; @}; 1731 1732union foo f = @{ .d = 4 @}; 1733@end smallexample 1734 1735@noindent 1736will convert 4 to a @code{double} to store it in the union using 1737the second element. By contrast, casting 4 to type @code{union foo} 1738would store it into the union as the integer @code{i}, since it is 1739an integer. (@xref{Cast to Union}.) 1740 1741You can combine this technique of naming elements with ordinary C 1742initialization of successive elements. Each initializer element that 1743does not have a designator applies to the next consecutive element of the 1744array or structure. For example, 1745 1746@smallexample 1747int a[6] = @{ [1] = v1, v2, [4] = v4 @}; 1748@end smallexample 1749 1750@noindent 1751is equivalent to 1752 1753@smallexample 1754int a[6] = @{ 0, v1, v2, 0, v4, 0 @}; 1755@end smallexample 1756 1757Labeling the elements of an array initializer is especially useful 1758when the indices are characters or belong to an @code{enum} type. 1759For example: 1760 1761@smallexample 1762int whitespace[256] 1763 = @{ [' '] = 1, ['\t'] = 1, ['\h'] = 1, 1764 ['\f'] = 1, ['\n'] = 1, ['\r'] = 1 @}; 1765@end smallexample 1766 1767@cindex designator lists 1768You can also write a series of @samp{.@var{fieldname}} and 1769@samp{[@var{index}]} designators before an @samp{=} to specify a 1770nested subobject to initialize; the list is taken relative to the 1771subobject corresponding to the closest surrounding brace pair. For 1772example, with the @samp{struct point} declaration above: 1773 1774@smallexample 1775struct point ptarray[10] = @{ [2].y = yv2, [2].x = xv2, [0].x = xv0 @}; 1776@end smallexample 1777 1778@noindent 1779If the same field is initialized multiple times, it will have value from 1780the last initialization. If any such overridden initialization has 1781side-effect, it is unspecified whether the side-effect happens or not. 1782Currently, GCC will discard them and issue a warning. 1783 1784@node Case Ranges 1785@section Case Ranges 1786@cindex case ranges 1787@cindex ranges in case statements 1788 1789You can specify a range of consecutive values in a single @code{case} label, 1790like this: 1791 1792@smallexample 1793case @var{low} ... @var{high}: 1794@end smallexample 1795 1796@noindent 1797This has the same effect as the proper number of individual @code{case} 1798labels, one for each integer value from @var{low} to @var{high}, inclusive. 1799 1800This feature is especially useful for ranges of ASCII character codes: 1801 1802@smallexample 1803case 'A' ... 'Z': 1804@end smallexample 1805 1806@strong{Be careful:} Write spaces around the @code{...}, for otherwise 1807it may be parsed wrong when you use it with integer values. For example, 1808write this: 1809 1810@smallexample 1811case 1 ... 5: 1812@end smallexample 1813 1814@noindent 1815rather than this: 1816 1817@smallexample 1818case 1...5: 1819@end smallexample 1820 1821@node Cast to Union 1822@section Cast to a Union Type 1823@cindex cast to a union 1824@cindex union, casting to a 1825 1826A cast to union type is similar to other casts, except that the type 1827specified is a union type. You can specify the type either with 1828@code{union @var{tag}} or with a typedef name. A cast to union is actually 1829a constructor though, not a cast, and hence does not yield an lvalue like 1830normal casts. (@xref{Compound Literals}.) 1831 1832The types that may be cast to the union type are those of the members 1833of the union. Thus, given the following union and variables: 1834 1835@smallexample 1836union foo @{ int i; double d; @}; 1837int x; 1838double y; 1839@end smallexample 1840 1841@noindent 1842both @code{x} and @code{y} can be cast to type @code{union foo}. 1843 1844Using the cast as the right-hand side of an assignment to a variable of 1845union type is equivalent to storing in a member of the union: 1846 1847@smallexample 1848union foo u; 1849/* @r{@dots{}} */ 1850u = (union foo) x @equiv{} u.i = x 1851u = (union foo) y @equiv{} u.d = y 1852@end smallexample 1853 1854You can also use the union cast as a function argument: 1855 1856@smallexample 1857void hack (union foo); 1858/* @r{@dots{}} */ 1859hack ((union foo) x); 1860@end smallexample 1861 1862@node Mixed Declarations 1863@section Mixed Declarations and Code 1864@cindex mixed declarations and code 1865@cindex declarations, mixed with code 1866@cindex code, mixed with declarations 1867 1868ISO C99 and ISO C++ allow declarations and code to be freely mixed 1869within compound statements. As an extension, GCC also allows this in 1870C90 mode. For example, you could do: 1871 1872@smallexample 1873int i; 1874/* @r{@dots{}} */ 1875i++; 1876int j = i + 2; 1877@end smallexample 1878 1879Each identifier is visible from where it is declared until the end of 1880the enclosing block. 1881 1882@node Function Attributes 1883@section Declaring Attributes of Functions 1884@cindex function attributes 1885@cindex declaring attributes of functions 1886@cindex functions that never return 1887@cindex functions that return more than once 1888@cindex functions that have no side effects 1889@cindex functions in arbitrary sections 1890@cindex functions that behave like malloc 1891@cindex @code{volatile} applied to function 1892@cindex @code{const} applied to function 1893@cindex functions with @code{printf}, @code{scanf}, @code{strftime} or @code{strfmon} style arguments 1894@cindex functions with non-null pointer arguments 1895@cindex functions that are passed arguments in registers on the 386 1896@cindex functions that pop the argument stack on the 386 1897@cindex functions that do not pop the argument stack on the 386 1898@cindex functions that have different compilation options on the 386 1899@cindex functions that have different optimization options 1900 1901In GNU C, you declare certain things about functions called in your program 1902which help the compiler optimize function calls and check your code more 1903carefully. 1904 1905The keyword @code{__attribute__} allows you to specify special 1906attributes when making a declaration. This keyword is followed by an 1907attribute specification inside double parentheses. The following 1908attributes are currently defined for functions on all targets: 1909@code{aligned}, @code{alloc_size}, @code{noreturn}, 1910@code{returns_twice}, @code{noinline}, @code{noclone}, 1911@code{always_inline}, @code{flatten}, @code{pure}, @code{const}, 1912@code{nothrow}, @code{sentinel}, @code{format}, @code{format_arg}, 1913@code{no_instrument_function}, @code{section}, @code{constructor}, 1914@code{destructor}, @code{used}, @code{unused}, @code{deprecated}, 1915@code{weak}, @code{malloc}, @code{alias}, @code{warn_unused_result}, 1916@code{nonnull}, @code{gnu_inline}, @code{externally_visible}, 1917@code{hot}, @code{cold}, @code{artificial}, @code{error} and 1918@code{warning}. Several other attributes are defined for functions on 1919particular target systems. Other attributes, including @code{section} 1920are supported for variables declarations (@pxref{Variable Attributes}) 1921and for types (@pxref{Type Attributes}). 1922 1923GCC plugins may provide their own attributes. 1924 1925You may also specify attributes with @samp{__} preceding and following 1926each keyword. This allows you to use them in header files without 1927being concerned about a possible macro of the same name. For example, 1928you may use @code{__noreturn__} instead of @code{noreturn}. 1929 1930@xref{Attribute Syntax}, for details of the exact syntax for using 1931attributes. 1932 1933@table @code 1934@c Keep this table alphabetized by attribute name. Treat _ as space. 1935 1936@item alias ("@var{target}") 1937@cindex @code{alias} attribute 1938The @code{alias} attribute causes the declaration to be emitted as an 1939alias for another symbol, which must be specified. For instance, 1940 1941@smallexample 1942void __f () @{ /* @r{Do something.} */; @} 1943void f () __attribute__ ((weak, alias ("__f"))); 1944@end smallexample 1945 1946defines @samp{f} to be a weak alias for @samp{__f}. In C++, the 1947mangled name for the target must be used. It is an error if @samp{__f} 1948is not defined in the same translation unit. 1949 1950Not all target machines support this attribute. 1951 1952@item aligned (@var{alignment}) 1953@cindex @code{aligned} attribute 1954This attribute specifies a minimum alignment for the function, 1955measured in bytes. 1956 1957You cannot use this attribute to decrease the alignment of a function, 1958only to increase it. However, when you explicitly specify a function 1959alignment this will override the effect of the 1960@option{-falign-functions} (@pxref{Optimize Options}) option for this 1961function. 1962 1963Note that the effectiveness of @code{aligned} attributes may be 1964limited by inherent limitations in your linker. On many systems, the 1965linker is only able to arrange for functions to be aligned up to a 1966certain maximum alignment. (For some linkers, the maximum supported 1967alignment may be very very small.) See your linker documentation for 1968further information. 1969 1970The @code{aligned} attribute can also be used for variables and fields 1971(@pxref{Variable Attributes}.) 1972 1973@item alloc_size 1974@cindex @code{alloc_size} attribute 1975The @code{alloc_size} attribute is used to tell the compiler that the 1976function return value points to memory, where the size is given by 1977one or two of the functions parameters. GCC uses this 1978information to improve the correctness of @code{__builtin_object_size}. 1979 1980The function parameter(s) denoting the allocated size are specified by 1981one or two integer arguments supplied to the attribute. The allocated size 1982is either the value of the single function argument specified or the product 1983of the two function arguments specified. Argument numbering starts at 1984one. 1985 1986For instance, 1987 1988@smallexample 1989void* my_calloc(size_t, size_t) __attribute__((alloc_size(1,2))) 1990void my_realloc(void*, size_t) __attribute__((alloc_size(2))) 1991@end smallexample 1992 1993declares that my_calloc will return memory of the size given by 1994the product of parameter 1 and 2 and that my_realloc will return memory 1995of the size given by parameter 2. 1996 1997@item always_inline 1998@cindex @code{always_inline} function attribute 1999Generally, functions are not inlined unless optimization is specified. 2000For functions declared inline, this attribute inlines the function even 2001if no optimization level was specified. 2002 2003@item gnu_inline 2004@cindex @code{gnu_inline} function attribute 2005This attribute should be used with a function which is also declared 2006with the @code{inline} keyword. It directs GCC to treat the function 2007as if it were defined in gnu90 mode even when compiling in C99 or 2008gnu99 mode. 2009 2010If the function is declared @code{extern}, then this definition of the 2011function is used only for inlining. In no case is the function 2012compiled as a standalone function, not even if you take its address 2013explicitly. Such an address becomes an external reference, as if you 2014had only declared the function, and had not defined it. This has 2015almost the effect of a macro. The way to use this is to put a 2016function definition in a header file with this attribute, and put 2017another copy of the function, without @code{extern}, in a library 2018file. The definition in the header file will cause most calls to the 2019function to be inlined. If any uses of the function remain, they will 2020refer to the single copy in the library. Note that the two 2021definitions of the functions need not be precisely the same, although 2022if they do not have the same effect your program may behave oddly. 2023 2024In C, if the function is neither @code{extern} nor @code{static}, then 2025the function is compiled as a standalone function, as well as being 2026inlined where possible. 2027 2028This is how GCC traditionally handled functions declared 2029@code{inline}. Since ISO C99 specifies a different semantics for 2030@code{inline}, this function attribute is provided as a transition 2031measure and as a useful feature in its own right. This attribute is 2032available in GCC 4.1.3 and later. It is available if either of the 2033preprocessor macros @code{__GNUC_GNU_INLINE__} or 2034@code{__GNUC_STDC_INLINE__} are defined. @xref{Inline,,An Inline 2035Function is As Fast As a Macro}. 2036 2037In C++, this attribute does not depend on @code{extern} in any way, 2038but it still requires the @code{inline} keyword to enable its special 2039behavior. 2040 2041@item artificial 2042@cindex @code{artificial} function attribute 2043This attribute is useful for small inline wrappers which if possible 2044should appear during debugging as a unit, depending on the debug 2045info format it will either mean marking the function as artificial 2046or using the caller location for all instructions within the inlined 2047body. 2048 2049@item bank_switch 2050@cindex interrupt handler functions 2051When added to an interrupt handler with the M32C port, causes the 2052prologue and epilogue to use bank switching to preserve the registers 2053rather than saving them on the stack. 2054 2055@item flatten 2056@cindex @code{flatten} function attribute 2057Generally, inlining into a function is limited. For a function marked with 2058this attribute, every call inside this function will be inlined, if possible. 2059Whether the function itself is considered for inlining depends on its size and 2060the current inlining parameters. 2061 2062@item error ("@var{message}") 2063@cindex @code{error} function attribute 2064If this attribute is used on a function declaration and a call to such a function 2065is not eliminated through dead code elimination or other optimizations, an error 2066which will include @var{message} will be diagnosed. This is useful 2067for compile time checking, especially together with @code{__builtin_constant_p} 2068and inline functions where checking the inline function arguments is not 2069possible through @code{extern char [(condition) ? 1 : -1];} tricks. 2070While it is possible to leave the function undefined and thus invoke 2071a link failure, when using this attribute the problem will be diagnosed 2072earlier and with exact location of the call even in presence of inline 2073functions or when not emitting debugging information. 2074 2075@item warning ("@var{message}") 2076@cindex @code{warning} function attribute 2077If this attribute is used on a function declaration and a call to such a function 2078is not eliminated through dead code elimination or other optimizations, a warning 2079which will include @var{message} will be diagnosed. This is useful 2080for compile time checking, especially together with @code{__builtin_constant_p} 2081and inline functions. While it is possible to define the function with 2082a message in @code{.gnu.warning*} section, when using this attribute the problem 2083will be diagnosed earlier and with exact location of the call even in presence 2084of inline functions or when not emitting debugging information. 2085 2086@item cdecl 2087@cindex functions that do pop the argument stack on the 386 2088@opindex mrtd 2089On the Intel 386, the @code{cdecl} attribute causes the compiler to 2090assume that the calling function will pop off the stack space used to 2091pass arguments. This is 2092useful to override the effects of the @option{-mrtd} switch. 2093 2094@item const 2095@cindex @code{const} function attribute 2096Many functions do not examine any values except their arguments, and 2097have no effects except the return value. Basically this is just slightly 2098more strict class than the @code{pure} attribute below, since function is not 2099allowed to read global memory. 2100 2101@cindex pointer arguments 2102Note that a function that has pointer arguments and examines the data 2103pointed to must @emph{not} be declared @code{const}. Likewise, a 2104function that calls a non-@code{const} function usually must not be 2105@code{const}. It does not make sense for a @code{const} function to 2106return @code{void}. 2107 2108The attribute @code{const} is not implemented in GCC versions earlier 2109than 2.5. An alternative way to declare that a function has no side 2110effects, which works in the current version and in some older versions, 2111is as follows: 2112 2113@smallexample 2114typedef int intfn (); 2115 2116extern const intfn square; 2117@end smallexample 2118 2119This approach does not work in GNU C++ from 2.6.0 on, since the language 2120specifies that the @samp{const} must be attached to the return value. 2121 2122@item constructor 2123@itemx destructor 2124@itemx constructor (@var{priority}) 2125@itemx destructor (@var{priority}) 2126@cindex @code{constructor} function attribute 2127@cindex @code{destructor} function attribute 2128The @code{constructor} attribute causes the function to be called 2129automatically before execution enters @code{main ()}. Similarly, the 2130@code{destructor} attribute causes the function to be called 2131automatically after @code{main ()} has completed or @code{exit ()} has 2132been called. Functions with these attributes are useful for 2133initializing data that will be used implicitly during the execution of 2134the program. 2135 2136You may provide an optional integer priority to control the order in 2137which constructor and destructor functions are run. A constructor 2138with a smaller priority number runs before a constructor with a larger 2139priority number; the opposite relationship holds for destructors. So, 2140if you have a constructor that allocates a resource and a destructor 2141that deallocates the same resource, both functions typically have the 2142same priority. The priorities for constructor and destructor 2143functions are the same as those specified for namespace-scope C++ 2144objects (@pxref{C++ Attributes}). 2145 2146These attributes are not currently implemented for Objective-C@. 2147 2148@item deprecated 2149@itemx deprecated (@var{msg}) 2150@cindex @code{deprecated} attribute. 2151The @code{deprecated} attribute results in a warning if the function 2152is used anywhere in the source file. This is useful when identifying 2153functions that are expected to be removed in a future version of a 2154program. The warning also includes the location of the declaration 2155of the deprecated function, to enable users to easily find further 2156information about why the function is deprecated, or what they should 2157do instead. Note that the warnings only occurs for uses: 2158 2159@smallexample 2160int old_fn () __attribute__ ((deprecated)); 2161int old_fn (); 2162int (*fn_ptr)() = old_fn; 2163@end smallexample 2164 2165results in a warning on line 3 but not line 2. The optional msg 2166argument, which must be a string, will be printed in the warning if 2167present. 2168 2169The @code{deprecated} attribute can also be used for variables and 2170types (@pxref{Variable Attributes}, @pxref{Type Attributes}.) 2171 2172@item disinterrupt 2173@cindex @code{disinterrupt} attribute 2174On MeP targets, this attribute causes the compiler to emit 2175instructions to disable interrupts for the duration of the given 2176function. 2177 2178@item dllexport 2179@cindex @code{__declspec(dllexport)} 2180On Microsoft Windows targets and Symbian OS targets the 2181@code{dllexport} attribute causes the compiler to provide a global 2182pointer to a pointer in a DLL, so that it can be referenced with the 2183@code{dllimport} attribute. On Microsoft Windows targets, the pointer 2184name is formed by combining @code{_imp__} and the function or variable 2185name. 2186 2187You can use @code{__declspec(dllexport)} as a synonym for 2188@code{__attribute__ ((dllexport))} for compatibility with other 2189compilers. 2190 2191On systems that support the @code{visibility} attribute, this 2192attribute also implies ``default'' visibility. It is an error to 2193explicitly specify any other visibility. 2194 2195Currently, the @code{dllexport} attribute is ignored for inlined 2196functions, unless the @option{-fkeep-inline-functions} flag has been 2197used. The attribute is also ignored for undefined symbols. 2198 2199When applied to C++ classes, the attribute marks defined non-inlined 2200member functions and static data members as exports. Static consts 2201initialized in-class are not marked unless they are also defined 2202out-of-class. 2203 2204For Microsoft Windows targets there are alternative methods for 2205including the symbol in the DLL's export table such as using a 2206@file{.def} file with an @code{EXPORTS} section or, with GNU ld, using 2207the @option{--export-all} linker flag. 2208 2209@item dllimport 2210@cindex @code{__declspec(dllimport)} 2211On Microsoft Windows and Symbian OS targets, the @code{dllimport} 2212attribute causes the compiler to reference a function or variable via 2213a global pointer to a pointer that is set up by the DLL exporting the 2214symbol. The attribute implies @code{extern}. On Microsoft Windows 2215targets, the pointer name is formed by combining @code{_imp__} and the 2216function or variable name. 2217 2218You can use @code{__declspec(dllimport)} as a synonym for 2219@code{__attribute__ ((dllimport))} for compatibility with other 2220compilers. 2221 2222On systems that support the @code{visibility} attribute, this 2223attribute also implies ``default'' visibility. It is an error to 2224explicitly specify any other visibility. 2225 2226Currently, the attribute is ignored for inlined functions. If the 2227attribute is applied to a symbol @emph{definition}, an error is reported. 2228If a symbol previously declared @code{dllimport} is later defined, the 2229attribute is ignored in subsequent references, and a warning is emitted. 2230The attribute is also overridden by a subsequent declaration as 2231@code{dllexport}. 2232 2233When applied to C++ classes, the attribute marks non-inlined 2234member functions and static data members as imports. However, the 2235attribute is ignored for virtual methods to allow creation of vtables 2236using thunks. 2237 2238On the SH Symbian OS target the @code{dllimport} attribute also has 2239another affect---it can cause the vtable and run-time type information 2240for a class to be exported. This happens when the class has a 2241dllimport'ed constructor or a non-inline, non-pure virtual function 2242and, for either of those two conditions, the class also has an inline 2243constructor or destructor and has a key function that is defined in 2244the current translation unit. 2245 2246For Microsoft Windows based targets the use of the @code{dllimport} 2247attribute on functions is not necessary, but provides a small 2248performance benefit by eliminating a thunk in the DLL@. The use of the 2249@code{dllimport} attribute on imported variables was required on older 2250versions of the GNU linker, but can now be avoided by passing the 2251@option{--enable-auto-import} switch to the GNU linker. As with 2252functions, using the attribute for a variable eliminates a thunk in 2253the DLL@. 2254 2255One drawback to using this attribute is that a pointer to a 2256@emph{variable} marked as @code{dllimport} cannot be used as a constant 2257address. However, a pointer to a @emph{function} with the 2258@code{dllimport} attribute can be used as a constant initializer; in 2259this case, the address of a stub function in the import lib is 2260referenced. On Microsoft Windows targets, the attribute can be disabled 2261for functions by setting the @option{-mnop-fun-dllimport} flag. 2262 2263@item eightbit_data 2264@cindex eight bit data on the H8/300, H8/300H, and H8S 2265Use this attribute on the H8/300, H8/300H, and H8S to indicate that the specified 2266variable should be placed into the eight bit data section. 2267The compiler will generate more efficient code for certain operations 2268on data in the eight bit data area. Note the eight bit data area is limited to 2269256 bytes of data. 2270 2271You must use GAS and GLD from GNU binutils version 2.7 or later for 2272this attribute to work correctly. 2273 2274@item exception_handler 2275@cindex exception handler functions on the Blackfin processor 2276Use this attribute on the Blackfin to indicate that the specified function 2277is an exception handler. The compiler will generate function entry and 2278exit sequences suitable for use in an exception handler when this 2279attribute is present. 2280 2281@item externally_visible 2282@cindex @code{externally_visible} attribute. 2283This attribute, attached to a global variable or function, nullifies 2284the effect of the @option{-fwhole-program} command-line option, so the 2285object remains visible outside the current compilation unit. 2286 2287@item far 2288@cindex functions which handle memory bank switching 2289On 68HC11 and 68HC12 the @code{far} attribute causes the compiler to 2290use a calling convention that takes care of switching memory banks when 2291entering and leaving a function. This calling convention is also the 2292default when using the @option{-mlong-calls} option. 2293 2294On 68HC12 the compiler will use the @code{call} and @code{rtc} instructions 2295to call and return from a function. 2296 2297On 68HC11 the compiler will generate a sequence of instructions 2298to invoke a board-specific routine to switch the memory bank and call the 2299real function. The board-specific routine simulates a @code{call}. 2300At the end of a function, it will jump to a board-specific routine 2301instead of using @code{rts}. The board-specific return routine simulates 2302the @code{rtc}. 2303 2304On MeP targets this causes the compiler to use a calling convention 2305which assumes the called function is too far away for the built-in 2306addressing modes. 2307 2308@item fast_interrupt 2309@cindex interrupt handler functions 2310Use this attribute on the M32C and RX ports to indicate that the specified 2311function is a fast interrupt handler. This is just like the 2312@code{interrupt} attribute, except that @code{freit} is used to return 2313instead of @code{reit}. 2314 2315@item fastcall 2316@cindex functions that pop the argument stack on the 386 2317On the Intel 386, the @code{fastcall} attribute causes the compiler to 2318pass the first argument (if of integral type) in the register ECX and 2319the second argument (if of integral type) in the register EDX@. Subsequent 2320and other typed arguments are passed on the stack. The called function will 2321pop the arguments off the stack. If the number of arguments is variable all 2322arguments are pushed on the stack. 2323 2324@item format (@var{archetype}, @var{string-index}, @var{first-to-check}) 2325@cindex @code{format} function attribute 2326@opindex Wformat 2327The @code{format} attribute specifies that a function takes @code{printf}, 2328@code{scanf}, @code{strftime} or @code{strfmon} style arguments which 2329should be type-checked against a format string. For example, the 2330declaration: 2331 2332@smallexample 2333extern int 2334my_printf (void *my_object, const char *my_format, ...) 2335 __attribute__ ((format (printf, 2, 3))); 2336@end smallexample 2337 2338@noindent 2339causes the compiler to check the arguments in calls to @code{my_printf} 2340for consistency with the @code{printf} style format string argument 2341@code{my_format}. 2342 2343The parameter @var{archetype} determines how the format string is 2344interpreted, and should be @code{printf}, @code{scanf}, @code{strftime}, 2345@code{gnu_printf}, @code{gnu_scanf}, @code{gnu_strftime} or 2346@code{strfmon}. (You can also use @code{__printf__}, 2347@code{__scanf__}, @code{__strftime__} or @code{__strfmon__}.) On 2348MinGW targets, @code{ms_printf}, @code{ms_scanf}, and 2349@code{ms_strftime} are also present. 2350@var{archtype} values such as @code{printf} refer to the formats accepted 2351by the system's C run-time library, while @code{gnu_} values always refer 2352to the formats accepted by the GNU C Library. On Microsoft Windows 2353targets, @code{ms_} values refer to the formats accepted by the 2354@file{msvcrt.dll} library. 2355The parameter @var{string-index} 2356specifies which argument is the format string argument (starting 2357from 1), while @var{first-to-check} is the number of the first 2358argument to check against the format string. For functions 2359where the arguments are not available to be checked (such as 2360@code{vprintf}), specify the third parameter as zero. In this case the 2361compiler only checks the format string for consistency. For 2362@code{strftime} formats, the third parameter is required to be zero. 2363Since non-static C++ methods have an implicit @code{this} argument, the 2364arguments of such methods should be counted from two, not one, when 2365giving values for @var{string-index} and @var{first-to-check}. 2366 2367In the example above, the format string (@code{my_format}) is the second 2368argument of the function @code{my_print}, and the arguments to check 2369start with the third argument, so the correct parameters for the format 2370attribute are 2 and 3. 2371 2372@opindex ffreestanding 2373@opindex fno-builtin 2374The @code{format} attribute allows you to identify your own functions 2375which take format strings as arguments, so that GCC can check the 2376calls to these functions for errors. The compiler always (unless 2377@option{-ffreestanding} or @option{-fno-builtin} is used) checks formats 2378for the standard library functions @code{printf}, @code{fprintf}, 2379@code{sprintf}, @code{scanf}, @code{fscanf}, @code{sscanf}, @code{strftime}, 2380@code{vprintf}, @code{vfprintf} and @code{vsprintf} whenever such 2381warnings are requested (using @option{-Wformat}), so there is no need to 2382modify the header file @file{stdio.h}. In C99 mode, the functions 2383@code{snprintf}, @code{vsnprintf}, @code{vscanf}, @code{vfscanf} and 2384@code{vsscanf} are also checked. Except in strictly conforming C 2385standard modes, the X/Open function @code{strfmon} is also checked as 2386are @code{printf_unlocked} and @code{fprintf_unlocked}. 2387@xref{C Dialect Options,,Options Controlling C Dialect}. 2388 2389The target may provide additional types of format checks. 2390@xref{Target Format Checks,,Format Checks Specific to Particular 2391Target Machines}. 2392 2393@item format_arg (@var{string-index}) 2394@cindex @code{format_arg} function attribute 2395@opindex Wformat-nonliteral 2396The @code{format_arg} attribute specifies that a function takes a format 2397string for a @code{printf}, @code{scanf}, @code{strftime} or 2398@code{strfmon} style function and modifies it (for example, to translate 2399it into another language), so the result can be passed to a 2400@code{printf}, @code{scanf}, @code{strftime} or @code{strfmon} style 2401function (with the remaining arguments to the format function the same 2402as they would have been for the unmodified string). For example, the 2403declaration: 2404 2405@smallexample 2406extern char * 2407my_dgettext (char *my_domain, const char *my_format) 2408 __attribute__ ((format_arg (2))); 2409@end smallexample 2410 2411@noindent 2412causes the compiler to check the arguments in calls to a @code{printf}, 2413@code{scanf}, @code{strftime} or @code{strfmon} type function, whose 2414format string argument is a call to the @code{my_dgettext} function, for 2415consistency with the format string argument @code{my_format}. If the 2416@code{format_arg} attribute had not been specified, all the compiler 2417could tell in such calls to format functions would be that the format 2418string argument is not constant; this would generate a warning when 2419@option{-Wformat-nonliteral} is used, but the calls could not be checked 2420without the attribute. 2421 2422The parameter @var{string-index} specifies which argument is the format 2423string argument (starting from one). Since non-static C++ methods have 2424an implicit @code{this} argument, the arguments of such methods should 2425be counted from two. 2426 2427The @code{format-arg} attribute allows you to identify your own 2428functions which modify format strings, so that GCC can check the 2429calls to @code{printf}, @code{scanf}, @code{strftime} or @code{strfmon} 2430type function whose operands are a call to one of your own function. 2431The compiler always treats @code{gettext}, @code{dgettext}, and 2432@code{dcgettext} in this manner except when strict ISO C support is 2433requested by @option{-ansi} or an appropriate @option{-std} option, or 2434@option{-ffreestanding} or @option{-fno-builtin} 2435is used. @xref{C Dialect Options,,Options 2436Controlling C Dialect}. 2437 2438@item function_vector 2439@cindex calling functions through the function vector on H8/300, M16C, M32C and SH2A processors 2440Use this attribute on the H8/300, H8/300H, and H8S to indicate that the specified 2441function should be called through the function vector. Calling a 2442function through the function vector will reduce code size, however; 2443the function vector has a limited size (maximum 128 entries on the H8/300 2444and 64 entries on the H8/300H and H8S) and shares space with the interrupt vector. 2445 2446In SH2A target, this attribute declares a function to be called using the 2447TBR relative addressing mode. The argument to this attribute is the entry 2448number of the same function in a vector table containing all the TBR 2449relative addressable functions. For the successful jump, register TBR 2450should contain the start address of this TBR relative vector table. 2451In the startup routine of the user application, user needs to care of this 2452TBR register initialization. The TBR relative vector table can have at 2453max 256 function entries. The jumps to these functions will be generated 2454using a SH2A specific, non delayed branch instruction JSR/N @@(disp8,TBR). 2455You must use GAS and GLD from GNU binutils version 2.7 or later for 2456this attribute to work correctly. 2457 2458Please refer the example of M16C target, to see the use of this 2459attribute while declaring a function, 2460 2461In an application, for a function being called once, this attribute will 2462save at least 8 bytes of code; and if other successive calls are being 2463made to the same function, it will save 2 bytes of code per each of these 2464calls. 2465 2466On M16C/M32C targets, the @code{function_vector} attribute declares a 2467special page subroutine call function. Use of this attribute reduces 2468the code size by 2 bytes for each call generated to the 2469subroutine. The argument to the attribute is the vector number entry 2470from the special page vector table which contains the 16 low-order 2471bits of the subroutine's entry address. Each vector table has special 2472page number (18 to 255) which are used in @code{jsrs} instruction. 2473Jump addresses of the routines are generated by adding 0x0F0000 (in 2474case of M16C targets) or 0xFF0000 (in case of M32C targets), to the 2 2475byte addresses set in the vector table. Therefore you need to ensure 2476that all the special page vector routines should get mapped within the 2477address range 0x0F0000 to 0x0FFFFF (for M16C) and 0xFF0000 to 0xFFFFFF 2478(for M32C). 2479 2480In the following example 2 bytes will be saved for each call to 2481function @code{foo}. 2482 2483@smallexample 2484void foo (void) __attribute__((function_vector(0x18))); 2485void foo (void) 2486@{ 2487@} 2488 2489void bar (void) 2490@{ 2491 foo(); 2492@} 2493@end smallexample 2494 2495If functions are defined in one file and are called in another file, 2496then be sure to write this declaration in both files. 2497 2498This attribute is ignored for R8C target. 2499 2500@item interrupt 2501@cindex interrupt handler functions 2502Use this attribute on the ARM, AVR, CRX, M32C, M32R/D, m68k, MeP, MIPS, 2503RX and Xstormy16 ports to indicate that the specified function is an 2504interrupt handler. The compiler will generate function entry and exit 2505sequences suitable for use in an interrupt handler when this attribute 2506is present. 2507 2508Note, interrupt handlers for the Blackfin, H8/300, H8/300H, H8S, and 2509SH processors can be specified via the @code{interrupt_handler} attribute. 2510 2511Note, on the AVR, interrupts will be enabled inside the function. 2512 2513Note, for the ARM, you can specify the kind of interrupt to be handled by 2514adding an optional parameter to the interrupt attribute like this: 2515 2516@smallexample 2517void f () __attribute__ ((interrupt ("IRQ"))); 2518@end smallexample 2519 2520Permissible values for this parameter are: IRQ, FIQ, SWI, ABORT and UNDEF@. 2521 2522On ARMv7-M the interrupt type is ignored, and the attribute means the function 2523may be called with a word aligned stack pointer. 2524 2525On MIPS targets, you can use the following attributes to modify the behavior 2526of an interrupt handler: 2527@table @code 2528@item use_shadow_register_set 2529@cindex @code{use_shadow_register_set} attribute 2530Assume that the handler uses a shadow register set, instead of 2531the main general-purpose registers. 2532 2533@item keep_interrupts_masked 2534@cindex @code{keep_interrupts_masked} attribute 2535Keep interrupts masked for the whole function. Without this attribute, 2536GCC tries to reenable interrupts for as much of the function as it can. 2537 2538@item use_debug_exception_return 2539@cindex @code{use_debug_exception_return} attribute 2540Return using the @code{deret} instruction. Interrupt handlers that don't 2541have this attribute return using @code{eret} instead. 2542@end table 2543 2544You can use any combination of these attributes, as shown below: 2545@smallexample 2546void __attribute__ ((interrupt)) v0 (); 2547void __attribute__ ((interrupt, use_shadow_register_set)) v1 (); 2548void __attribute__ ((interrupt, keep_interrupts_masked)) v2 (); 2549void __attribute__ ((interrupt, use_debug_exception_return)) v3 (); 2550void __attribute__ ((interrupt, use_shadow_register_set, 2551 keep_interrupts_masked)) v4 (); 2552void __attribute__ ((interrupt, use_shadow_register_set, 2553 use_debug_exception_return)) v5 (); 2554void __attribute__ ((interrupt, keep_interrupts_masked, 2555 use_debug_exception_return)) v6 (); 2556void __attribute__ ((interrupt, use_shadow_register_set, 2557 keep_interrupts_masked, 2558 use_debug_exception_return)) v7 (); 2559@end smallexample 2560 2561@item interrupt_handler 2562@cindex interrupt handler functions on the Blackfin, m68k, H8/300 and SH processors 2563Use this attribute on the Blackfin, m68k, H8/300, H8/300H, H8S, and SH to 2564indicate that the specified function is an interrupt handler. The compiler 2565will generate function entry and exit sequences suitable for use in an 2566interrupt handler when this attribute is present. 2567 2568@item interrupt_thread 2569@cindex interrupt thread functions on fido 2570Use this attribute on fido, a subarchitecture of the m68k, to indicate 2571that the specified function is an interrupt handler that is designed 2572to run as a thread. The compiler omits generate prologue/epilogue 2573sequences and replaces the return instruction with a @code{sleep} 2574instruction. This attribute is available only on fido. 2575 2576@item isr 2577@cindex interrupt service routines on ARM 2578Use this attribute on ARM to write Interrupt Service Routines. This is an 2579alias to the @code{interrupt} attribute above. 2580 2581@item kspisusp 2582@cindex User stack pointer in interrupts on the Blackfin 2583When used together with @code{interrupt_handler}, @code{exception_handler} 2584or @code{nmi_handler}, code will be generated to load the stack pointer 2585from the USP register in the function prologue. 2586 2587@item l1_text 2588@cindex @code{l1_text} function attribute 2589This attribute specifies a function to be placed into L1 Instruction 2590SRAM@. The function will be put into a specific section named @code{.l1.text}. 2591With @option{-mfdpic}, function calls with a such function as the callee 2592or caller will use inlined PLT. 2593 2594@item l2 2595@cindex @code{l2} function attribute 2596On the Blackfin, this attribute specifies a function to be placed into L2 2597SRAM. The function will be put into a specific section named 2598@code{.l1.text}. With @option{-mfdpic}, callers of such functions will use 2599an inlined PLT. 2600 2601@item long_call/short_call 2602@cindex indirect calls on ARM 2603This attribute specifies how a particular function is called on 2604ARM@. Both attributes override the @option{-mlong-calls} (@pxref{ARM Options}) 2605command line switch and @code{#pragma long_calls} settings. The 2606@code{long_call} attribute indicates that the function might be far 2607away from the call site and require a different (more expensive) 2608calling sequence. The @code{short_call} attribute always places 2609the offset to the function from the call site into the @samp{BL} 2610instruction directly. 2611 2612@item longcall/shortcall 2613@cindex functions called via pointer on the RS/6000 and PowerPC 2614On the Blackfin, RS/6000 and PowerPC, the @code{longcall} attribute 2615indicates that the function might be far away from the call site and 2616require a different (more expensive) calling sequence. The 2617@code{shortcall} attribute indicates that the function is always close 2618enough for the shorter calling sequence to be used. These attributes 2619override both the @option{-mlongcall} switch and, on the RS/6000 and 2620PowerPC, the @code{#pragma longcall} setting. 2621 2622@xref{RS/6000 and PowerPC Options}, for more information on whether long 2623calls are necessary. 2624 2625@item long_call/near/far 2626@cindex indirect calls on MIPS 2627These attributes specify how a particular function is called on MIPS@. 2628The attributes override the @option{-mlong-calls} (@pxref{MIPS Options}) 2629command-line switch. The @code{long_call} and @code{far} attributes are 2630synonyms, and cause the compiler to always call 2631the function by first loading its address into a register, and then using 2632the contents of that register. The @code{near} attribute has the opposite 2633effect; it specifies that non-PIC calls should be made using the more 2634efficient @code{jal} instruction. 2635 2636@item malloc 2637@cindex @code{malloc} attribute 2638The @code{malloc} attribute is used to tell the compiler that a function 2639may be treated as if any non-@code{NULL} pointer it returns cannot 2640alias any other pointer valid when the function returns. 2641This will often improve optimization. 2642Standard functions with this property include @code{malloc} and 2643@code{calloc}. @code{realloc}-like functions have this property as 2644long as the old pointer is never referred to (including comparing it 2645to the new pointer) after the function returns a non-@code{NULL} 2646value. 2647 2648@item mips16/nomips16 2649@cindex @code{mips16} attribute 2650@cindex @code{nomips16} attribute 2651 2652On MIPS targets, you can use the @code{mips16} and @code{nomips16} 2653function attributes to locally select or turn off MIPS16 code generation. 2654A function with the @code{mips16} attribute is emitted as MIPS16 code, 2655while MIPS16 code generation is disabled for functions with the 2656@code{nomips16} attribute. These attributes override the 2657@option{-mips16} and @option{-mno-mips16} options on the command line 2658(@pxref{MIPS Options}). 2659 2660When compiling files containing mixed MIPS16 and non-MIPS16 code, the 2661preprocessor symbol @code{__mips16} reflects the setting on the command line, 2662not that within individual functions. Mixed MIPS16 and non-MIPS16 code 2663may interact badly with some GCC extensions such as @code{__builtin_apply} 2664(@pxref{Constructing Calls}). 2665 2666@item model (@var{model-name}) 2667@cindex function addressability on the M32R/D 2668@cindex variable addressability on the IA-64 2669 2670On the M32R/D, use this attribute to set the addressability of an 2671object, and of the code generated for a function. The identifier 2672@var{model-name} is one of @code{small}, @code{medium}, or 2673@code{large}, representing each of the code models. 2674 2675Small model objects live in the lower 16MB of memory (so that their 2676addresses can be loaded with the @code{ld24} instruction), and are 2677callable with the @code{bl} instruction. 2678 2679Medium model objects may live anywhere in the 32-bit address space (the 2680compiler will generate @code{seth/add3} instructions to load their addresses), 2681and are callable with the @code{bl} instruction. 2682 2683Large model objects may live anywhere in the 32-bit address space (the 2684compiler will generate @code{seth/add3} instructions to load their addresses), 2685and may not be reachable with the @code{bl} instruction (the compiler will 2686generate the much slower @code{seth/add3/jl} instruction sequence). 2687 2688On IA-64, use this attribute to set the addressability of an object. 2689At present, the only supported identifier for @var{model-name} is 2690@code{small}, indicating addressability via ``small'' (22-bit) 2691addresses (so that their addresses can be loaded with the @code{addl} 2692instruction). Caveat: such addressing is by definition not position 2693independent and hence this attribute must not be used for objects 2694defined by shared libraries. 2695 2696@item ms_abi/sysv_abi 2697@cindex @code{ms_abi} attribute 2698@cindex @code{sysv_abi} attribute 2699 2700On 64-bit x86_64-*-* targets, you can use an ABI attribute to indicate 2701which calling convention should be used for a function. The @code{ms_abi} 2702attribute tells the compiler to use the Microsoft ABI, while the 2703@code{sysv_abi} attribute tells the compiler to use the ABI used on 2704GNU/Linux and other systems. The default is to use the Microsoft ABI 2705when targeting Windows. On all other systems, the default is the AMD ABI. 2706 2707Note, the @code{ms_abi} attribute for Windows targets currently requires 2708the @option{-maccumulate-outgoing-args} option. 2709 2710@item ms_hook_prologue 2711@cindex @code{ms_hook_prologue} attribute 2712 2713On 32 bit i[34567]86-*-* targets, you can use this function attribute to make 2714gcc generate the "hot-patching" function prologue used in Win32 API 2715functions in Microsoft Windows XP Service Pack 2 and newer. This requires 2716support for the swap suffix in the assembler. (GNU Binutils 2.19.51 or later) 2717 2718@item naked 2719@cindex function without a prologue/epilogue code 2720Use this attribute on the ARM, AVR, IP2K, RX and SPU ports to indicate that 2721the specified function does not need prologue/epilogue sequences generated by 2722the compiler. It is up to the programmer to provide these sequences. The 2723only statements that can be safely included in naked functions are 2724@code{asm} statements that do not have operands. All other statements, 2725including declarations of local variables, @code{if} statements, and so 2726forth, should be avoided. Naked functions should be used to implement the 2727body of an assembly function, while allowing the compiler to construct 2728the requisite function declaration for the assembler. 2729 2730@item near 2731@cindex functions which do not handle memory bank switching on 68HC11/68HC12 2732On 68HC11 and 68HC12 the @code{near} attribute causes the compiler to 2733use the normal calling convention based on @code{jsr} and @code{rts}. 2734This attribute can be used to cancel the effect of the @option{-mlong-calls} 2735option. 2736 2737On MeP targets this attribute causes the compiler to assume the called 2738function is close enough to use the normal calling convention, 2739overriding the @code{-mtf} command line option. 2740 2741@item nesting 2742@cindex Allow nesting in an interrupt handler on the Blackfin processor. 2743Use this attribute together with @code{interrupt_handler}, 2744@code{exception_handler} or @code{nmi_handler} to indicate that the function 2745entry code should enable nested interrupts or exceptions. 2746 2747@item nmi_handler 2748@cindex NMI handler functions on the Blackfin processor 2749Use this attribute on the Blackfin to indicate that the specified function 2750is an NMI handler. The compiler will generate function entry and 2751exit sequences suitable for use in an NMI handler when this 2752attribute is present. 2753 2754@item no_instrument_function 2755@cindex @code{no_instrument_function} function attribute 2756@opindex finstrument-functions 2757If @option{-finstrument-functions} is given, profiling function calls will 2758be generated at entry and exit of most user-compiled functions. 2759Functions with this attribute will not be so instrumented. 2760 2761@item noinline 2762@cindex @code{noinline} function attribute 2763This function attribute prevents a function from being considered for 2764inlining. 2765@c Don't enumerate the optimizations by name here; we try to be 2766@c future-compatible with this mechanism. 2767If the function does not have side-effects, there are optimizations 2768other than inlining that causes function calls to be optimized away, 2769although the function call is live. To keep such calls from being 2770optimized away, put 2771@smallexample 2772asm (""); 2773@end smallexample 2774(@pxref{Extended Asm}) in the called function, to serve as a special 2775side-effect. 2776 2777@item noclone 2778@cindex @code{noclone} function attribute 2779This function attribute prevents a function from being considered for 2780cloning - a mechanism which produces specialized copies of functions 2781and which is (currently) performed by interprocedural constant 2782propagation. 2783 2784@item nonnull (@var{arg-index}, @dots{}) 2785@cindex @code{nonnull} function attribute 2786The @code{nonnull} attribute specifies that some function parameters should 2787be non-null pointers. For instance, the declaration: 2788 2789@smallexample 2790extern void * 2791my_memcpy (void *dest, const void *src, size_t len) 2792 __attribute__((nonnull (1, 2))); 2793@end smallexample 2794 2795@noindent 2796causes the compiler to check that, in calls to @code{my_memcpy}, 2797arguments @var{dest} and @var{src} are non-null. If the compiler 2798determines that a null pointer is passed in an argument slot marked 2799as non-null, and the @option{-Wnonnull} option is enabled, a warning 2800is issued. The compiler may also choose to make optimizations based 2801on the knowledge that certain function arguments will not be null. 2802 2803If no argument index list is given to the @code{nonnull} attribute, 2804all pointer arguments are marked as non-null. To illustrate, the 2805following declaration is equivalent to the previous example: 2806 2807@smallexample 2808extern void * 2809my_memcpy (void *dest, const void *src, size_t len) 2810 __attribute__((nonnull)); 2811@end smallexample 2812 2813@item noreturn 2814@cindex @code{noreturn} function attribute 2815A few standard library functions, such as @code{abort} and @code{exit}, 2816cannot return. GCC knows this automatically. Some programs define 2817their own functions that never return. You can declare them 2818@code{noreturn} to tell the compiler this fact. For example, 2819 2820@smallexample 2821@group 2822void fatal () __attribute__ ((noreturn)); 2823 2824void 2825fatal (/* @r{@dots{}} */) 2826@{ 2827 /* @r{@dots{}} */ /* @r{Print error message.} */ /* @r{@dots{}} */ 2828 exit (1); 2829@} 2830@end group 2831@end smallexample 2832 2833The @code{noreturn} keyword tells the compiler to assume that 2834@code{fatal} cannot return. It can then optimize without regard to what 2835would happen if @code{fatal} ever did return. This makes slightly 2836better code. More importantly, it helps avoid spurious warnings of 2837uninitialized variables. 2838 2839The @code{noreturn} keyword does not affect the exceptional path when that 2840applies: a @code{noreturn}-marked function may still return to the caller 2841by throwing an exception or calling @code{longjmp}. 2842 2843Do not assume that registers saved by the calling function are 2844restored before calling the @code{noreturn} function. 2845 2846It does not make sense for a @code{noreturn} function to have a return 2847type other than @code{void}. 2848 2849The attribute @code{noreturn} is not implemented in GCC versions 2850earlier than 2.5. An alternative way to declare that a function does 2851not return, which works in the current version and in some older 2852versions, is as follows: 2853 2854@smallexample 2855typedef void voidfn (); 2856 2857volatile voidfn fatal; 2858@end smallexample 2859 2860This approach does not work in GNU C++. 2861 2862@item nothrow 2863@cindex @code{nothrow} function attribute 2864The @code{nothrow} attribute is used to inform the compiler that a 2865function cannot throw an exception. For example, most functions in 2866the standard C library can be guaranteed not to throw an exception 2867with the notable exceptions of @code{qsort} and @code{bsearch} that 2868take function pointer arguments. The @code{nothrow} attribute is not 2869implemented in GCC versions earlier than 3.3. 2870 2871@item optimize 2872@cindex @code{optimize} function attribute 2873The @code{optimize} attribute is used to specify that a function is to 2874be compiled with different optimization options than specified on the 2875command line. Arguments can either be numbers or strings. Numbers 2876are assumed to be an optimization level. Strings that begin with 2877@code{O} are assumed to be an optimization option, while other options 2878are assumed to be used with a @code{-f} prefix. You can also use the 2879@samp{#pragma GCC optimize} pragma to set the optimization options 2880that affect more than one function. 2881@xref{Function Specific Option Pragmas}, for details about the 2882@samp{#pragma GCC optimize} pragma. 2883 2884This can be used for instance to have frequently executed functions 2885compiled with more aggressive optimization options that produce faster 2886and larger code, while other functions can be called with less 2887aggressive options. 2888 2889@item pcs 2890@cindex @code{pcs} function attribute 2891 2892The @code{pcs} attribute can be used to control the calling convention 2893used for a function on ARM. The attribute takes an argument that specifies 2894the calling convention to use. 2895 2896When compiling using the AAPCS ABI (or a variant of that) then valid 2897values for the argument are @code{"aapcs"} and @code{"aapcs-vfp"}. In 2898order to use a variant other than @code{"aapcs"} then the compiler must 2899be permitted to use the appropriate co-processor registers (i.e., the 2900VFP registers must be available in order to use @code{"aapcs-vfp"}). 2901For example, 2902 2903@smallexample 2904/* Argument passed in r0, and result returned in r0+r1. */ 2905double f2d (float) __attribute__((pcs("aapcs"))); 2906@end smallexample 2907 2908Variadic functions always use the @code{"aapcs"} calling convention and 2909the compiler will reject attempts to specify an alternative. 2910 2911@item pure 2912@cindex @code{pure} function attribute 2913Many functions have no effects except the return value and their 2914return value depends only on the parameters and/or global variables. 2915Such a function can be subject 2916to common subexpression elimination and loop optimization just as an 2917arithmetic operator would be. These functions should be declared 2918with the attribute @code{pure}. For example, 2919 2920@smallexample 2921int square (int) __attribute__ ((pure)); 2922@end smallexample 2923 2924@noindent 2925says that the hypothetical function @code{square} is safe to call 2926fewer times than the program says. 2927 2928Some of common examples of pure functions are @code{strlen} or @code{memcmp}. 2929Interesting non-pure functions are functions with infinite loops or those 2930depending on volatile memory or other system resource, that may change between 2931two consecutive calls (such as @code{feof} in a multithreading environment). 2932 2933The attribute @code{pure} is not implemented in GCC versions earlier 2934than 2.96. 2935 2936@item hot 2937@cindex @code{hot} function attribute 2938The @code{hot} attribute is used to inform the compiler that a function is a 2939hot spot of the compiled program. The function is optimized more aggressively 2940and on many target it is placed into special subsection of the text section so 2941all hot functions appears close together improving locality. 2942 2943When profile feedback is available, via @option{-fprofile-use}, hot functions 2944are automatically detected and this attribute is ignored. 2945 2946The @code{hot} attribute is not implemented in GCC versions earlier 2947than 4.3. 2948 2949@item cold 2950@cindex @code{cold} function attribute 2951The @code{cold} attribute is used to inform the compiler that a function is 2952unlikely executed. The function is optimized for size rather than speed and on 2953many targets it is placed into special subsection of the text section so all 2954cold functions appears close together improving code locality of non-cold parts 2955of program. The paths leading to call of cold functions within code are marked 2956as unlikely by the branch prediction mechanism. It is thus useful to mark 2957functions used to handle unlikely conditions, such as @code{perror}, as cold to 2958improve optimization of hot functions that do call marked functions in rare 2959occasions. 2960 2961When profile feedback is available, via @option{-fprofile-use}, hot functions 2962are automatically detected and this attribute is ignored. 2963 2964The @code{cold} attribute is not implemented in GCC versions earlier than 4.3. 2965 2966@item regparm (@var{number}) 2967@cindex @code{regparm} attribute 2968@cindex functions that are passed arguments in registers on the 386 2969On the Intel 386, the @code{regparm} attribute causes the compiler to 2970pass arguments number one to @var{number} if they are of integral type 2971in registers EAX, EDX, and ECX instead of on the stack. Functions that 2972take a variable number of arguments will continue to be passed all of their 2973arguments on the stack. 2974 2975Beware that on some ELF systems this attribute is unsuitable for 2976global functions in shared libraries with lazy binding (which is the 2977default). Lazy binding will send the first call via resolving code in 2978the loader, which might assume EAX, EDX and ECX can be clobbered, as 2979per the standard calling conventions. Solaris 8 is affected by this. 2980GNU systems with GLIBC 2.1 or higher, and FreeBSD, are believed to be 2981safe since the loaders there save EAX, EDX and ECX. (Lazy binding can be 2982disabled with the linker or the loader if desired, to avoid the 2983problem.) 2984 2985@item sseregparm 2986@cindex @code{sseregparm} attribute 2987On the Intel 386 with SSE support, the @code{sseregparm} attribute 2988causes the compiler to pass up to 3 floating point arguments in 2989SSE registers instead of on the stack. Functions that take a 2990variable number of arguments will continue to pass all of their 2991floating point arguments on the stack. 2992 2993@item force_align_arg_pointer 2994@cindex @code{force_align_arg_pointer} attribute 2995On the Intel x86, the @code{force_align_arg_pointer} attribute may be 2996applied to individual function definitions, generating an alternate 2997prologue and epilogue that realigns the runtime stack if necessary. 2998This supports mixing legacy codes that run with a 4-byte aligned stack 2999with modern codes that keep a 16-byte stack for SSE compatibility. 3000 3001@item resbank 3002@cindex @code{resbank} attribute 3003On the SH2A target, this attribute enables the high-speed register 3004saving and restoration using a register bank for @code{interrupt_handler} 3005routines. Saving to the bank is performed automatically after the CPU 3006accepts an interrupt that uses a register bank. 3007 3008The nineteen 32-bit registers comprising general register R0 to R14, 3009control register GBR, and system registers MACH, MACL, and PR and the 3010vector table address offset are saved into a register bank. Register 3011banks are stacked in first-in last-out (FILO) sequence. Restoration 3012from the bank is executed by issuing a RESBANK instruction. 3013 3014@item returns_twice 3015@cindex @code{returns_twice} attribute 3016The @code{returns_twice} attribute tells the compiler that a function may 3017return more than one time. The compiler will ensure that all registers 3018are dead before calling such a function and will emit a warning about 3019the variables that may be clobbered after the second return from the 3020function. Examples of such functions are @code{setjmp} and @code{vfork}. 3021The @code{longjmp}-like counterpart of such function, if any, might need 3022to be marked with the @code{noreturn} attribute. 3023 3024@item saveall 3025@cindex save all registers on the Blackfin, H8/300, H8/300H, and H8S 3026Use this attribute on the Blackfin, H8/300, H8/300H, and H8S to indicate that 3027all registers except the stack pointer should be saved in the prologue 3028regardless of whether they are used or not. 3029 3030@item section ("@var{section-name}") 3031@cindex @code{section} function attribute 3032Normally, the compiler places the code it generates in the @code{text} section. 3033Sometimes, however, you need additional sections, or you need certain 3034particular functions to appear in special sections. The @code{section} 3035attribute specifies that a function lives in a particular section. 3036For example, the declaration: 3037 3038@smallexample 3039extern void foobar (void) __attribute__ ((section ("bar"))); 3040@end smallexample 3041 3042@noindent 3043puts the function @code{foobar} in the @code{bar} section. 3044 3045Some file formats do not support arbitrary sections so the @code{section} 3046attribute is not available on all platforms. 3047If you need to map the entire contents of a module to a particular 3048section, consider using the facilities of the linker instead. 3049 3050@item sentinel 3051@cindex @code{sentinel} function attribute 3052This function attribute ensures that a parameter in a function call is 3053an explicit @code{NULL}. The attribute is only valid on variadic 3054functions. By default, the sentinel is located at position zero, the 3055last parameter of the function call. If an optional integer position 3056argument P is supplied to the attribute, the sentinel must be located at 3057position P counting backwards from the end of the argument list. 3058 3059@smallexample 3060__attribute__ ((sentinel)) 3061is equivalent to 3062__attribute__ ((sentinel(0))) 3063@end smallexample 3064 3065The attribute is automatically set with a position of 0 for the built-in 3066functions @code{execl} and @code{execlp}. The built-in function 3067@code{execle} has the attribute set with a position of 1. 3068 3069A valid @code{NULL} in this context is defined as zero with any pointer 3070type. If your system defines the @code{NULL} macro with an integer type 3071then you need to add an explicit cast. GCC replaces @code{stddef.h} 3072with a copy that redefines NULL appropriately. 3073 3074The warnings for missing or incorrect sentinels are enabled with 3075@option{-Wformat}. 3076 3077@item short_call 3078See long_call/short_call. 3079 3080@item shortcall 3081See longcall/shortcall. 3082 3083@item signal 3084@cindex signal handler functions on the AVR processors 3085Use this attribute on the AVR to indicate that the specified 3086function is a signal handler. The compiler will generate function 3087entry and exit sequences suitable for use in a signal handler when this 3088attribute is present. Interrupts will be disabled inside the function. 3089 3090@item sp_switch 3091Use this attribute on the SH to indicate an @code{interrupt_handler} 3092function should switch to an alternate stack. It expects a string 3093argument that names a global variable holding the address of the 3094alternate stack. 3095 3096@smallexample 3097void *alt_stack; 3098void f () __attribute__ ((interrupt_handler, 3099 sp_switch ("alt_stack"))); 3100@end smallexample 3101 3102@item stdcall 3103@cindex functions that pop the argument stack on the 386 3104On the Intel 386, the @code{stdcall} attribute causes the compiler to 3105assume that the called function will pop off the stack space used to 3106pass arguments, unless it takes a variable number of arguments. 3107 3108@item syscall_linkage 3109@cindex @code{syscall_linkage} attribute 3110This attribute is used to modify the IA64 calling convention by marking 3111all input registers as live at all function exits. This makes it possible 3112to restart a system call after an interrupt without having to save/restore 3113the input registers. This also prevents kernel data from leaking into 3114application code. 3115 3116@item target 3117@cindex @code{target} function attribute 3118The @code{target} attribute is used to specify that a function is to 3119be compiled with different target options than specified on the 3120command line. This can be used for instance to have functions 3121compiled with a different ISA (instruction set architecture) than the 3122default. You can also use the @samp{#pragma GCC target} pragma to set 3123more than one function to be compiled with specific target options. 3124@xref{Function Specific Option Pragmas}, for details about the 3125@samp{#pragma GCC target} pragma. 3126 3127For instance on a 386, you could compile one function with 3128@code{target("sse4.1,arch=core2")} and another with 3129@code{target("sse4a,arch=amdfam10")} that would be equivalent to 3130compiling the first function with @option{-msse4.1} and 3131@option{-march=core2} options, and the second function with 3132@option{-msse4a} and @option{-march=amdfam10} options. It is up to the 3133user to make sure that a function is only invoked on a machine that 3134supports the particular ISA it was compiled for (for example by using 3135@code{cpuid} on 386 to determine what feature bits and architecture 3136family are used). 3137 3138@smallexample 3139int core2_func (void) __attribute__ ((__target__ ("arch=core2"))); 3140int sse3_func (void) __attribute__ ((__target__ ("sse3"))); 3141@end smallexample 3142 3143On the 386, the following options are allowed: 3144 3145@table @samp 3146@item abm 3147@itemx no-abm 3148@cindex @code{target("abm")} attribute 3149Enable/disable the generation of the advanced bit instructions. 3150 3151@item aes 3152@itemx no-aes 3153@cindex @code{target("aes")} attribute 3154Enable/disable the generation of the AES instructions. 3155 3156@item mmx 3157@itemx no-mmx 3158@cindex @code{target("mmx")} attribute 3159Enable/disable the generation of the MMX instructions. 3160 3161@item pclmul 3162@itemx no-pclmul 3163@cindex @code{target("pclmul")} attribute 3164Enable/disable the generation of the PCLMUL instructions. 3165 3166@item popcnt 3167@itemx no-popcnt 3168@cindex @code{target("popcnt")} attribute 3169Enable/disable the generation of the POPCNT instruction. 3170 3171@item sse 3172@itemx no-sse 3173@cindex @code{target("sse")} attribute 3174Enable/disable the generation of the SSE instructions. 3175 3176@item sse2 3177@itemx no-sse2 3178@cindex @code{target("sse2")} attribute 3179Enable/disable the generation of the SSE2 instructions. 3180 3181@item sse3 3182@itemx no-sse3 3183@cindex @code{target("sse3")} attribute 3184Enable/disable the generation of the SSE3 instructions. 3185 3186@item sse4 3187@itemx no-sse4 3188@cindex @code{target("sse4")} attribute 3189Enable/disable the generation of the SSE4 instructions (both SSE4.1 3190and SSE4.2). 3191 3192@item sse4.1 3193@itemx no-sse4.1 3194@cindex @code{target("sse4.1")} attribute 3195Enable/disable the generation of the sse4.1 instructions. 3196 3197@item sse4.2 3198@itemx no-sse4.2 3199@cindex @code{target("sse4.2")} attribute 3200Enable/disable the generation of the sse4.2 instructions. 3201 3202@item sse4a 3203@itemx no-sse4a 3204@cindex @code{target("sse4a")} attribute 3205Enable/disable the generation of the SSE4A instructions. 3206 3207@item fma4 3208@itemx no-fma4 3209@cindex @code{target("fma4")} attribute 3210Enable/disable the generation of the FMA4 instructions. 3211 3212@item xop 3213@itemx no-xop 3214@cindex @code{target("xop")} attribute 3215Enable/disable the generation of the XOP instructions. 3216 3217@item lwp 3218@itemx no-lwp 3219@cindex @code{target("lwp")} attribute 3220Enable/disable the generation of the LWP instructions. 3221 3222@item ssse3 3223@itemx no-ssse3 3224@cindex @code{target("ssse3")} attribute 3225Enable/disable the generation of the SSSE3 instructions. 3226 3227@item cld 3228@itemx no-cld 3229@cindex @code{target("cld")} attribute 3230Enable/disable the generation of the CLD before string moves. 3231 3232@item fancy-math-387 3233@itemx no-fancy-math-387 3234@cindex @code{target("fancy-math-387")} attribute 3235Enable/disable the generation of the @code{sin}, @code{cos}, and 3236@code{sqrt} instructions on the 387 floating point unit. 3237 3238@item fused-madd 3239@itemx no-fused-madd 3240@cindex @code{target("fused-madd")} attribute 3241Enable/disable the generation of the fused multiply/add instructions. 3242 3243@item ieee-fp 3244@itemx no-ieee-fp 3245@cindex @code{target("ieee-fp")} attribute 3246Enable/disable the generation of floating point that depends on IEEE arithmetic. 3247 3248@item inline-all-stringops 3249@itemx no-inline-all-stringops 3250@cindex @code{target("inline-all-stringops")} attribute 3251Enable/disable inlining of string operations. 3252 3253@item inline-stringops-dynamically 3254@itemx no-inline-stringops-dynamically 3255@cindex @code{target("inline-stringops-dynamically")} attribute 3256Enable/disable the generation of the inline code to do small string 3257operations and calling the library routines for large operations. 3258 3259@item align-stringops 3260@itemx no-align-stringops 3261@cindex @code{target("align-stringops")} attribute 3262Do/do not align destination of inlined string operations. 3263 3264@item recip 3265@itemx no-recip 3266@cindex @code{target("recip")} attribute 3267Enable/disable the generation of RCPSS, RCPPS, RSQRTSS and RSQRTPS 3268instructions followed an additional Newton-Raphson step instead of 3269doing a floating point division. 3270 3271@item arch=@var{ARCH} 3272@cindex @code{target("arch=@var{ARCH}")} attribute 3273Specify the architecture to generate code for in compiling the function. 3274 3275@item tune=@var{TUNE} 3276@cindex @code{target("tune=@var{TUNE}")} attribute 3277Specify the architecture to tune for in compiling the function. 3278 3279@item fpmath=@var{FPMATH} 3280@cindex @code{target("fpmath=@var{FPMATH}")} attribute 3281Specify which floating point unit to use. The 3282@code{target("fpmath=sse,387")} option must be specified as 3283@code{target("fpmath=sse+387")} because the comma would separate 3284different options. 3285@end table 3286 3287On the 386, you can use either multiple strings to specify multiple 3288options, or you can separate the option with a comma (@code{,}). 3289 3290On the 386, the inliner will not inline a function that has different 3291target options than the caller, unless the callee has a subset of the 3292target options of the caller. For example a function declared with 3293@code{target("sse3")} can inline a function with 3294@code{target("sse2")}, since @code{-msse3} implies @code{-msse2}. 3295 3296The @code{target} attribute is not implemented in GCC versions earlier 3297than 4.4, and at present only the 386 uses it. 3298 3299@item tiny_data 3300@cindex tiny data section on the H8/300H and H8S 3301Use this attribute on the H8/300H and H8S to indicate that the specified 3302variable should be placed into the tiny data section. 3303The compiler will generate more efficient code for loads and stores 3304on data in the tiny data section. Note the tiny data area is limited to 3305slightly under 32kbytes of data. 3306 3307@item trap_exit 3308Use this attribute on the SH for an @code{interrupt_handler} to return using 3309@code{trapa} instead of @code{rte}. This attribute expects an integer 3310argument specifying the trap number to be used. 3311 3312@item unused 3313@cindex @code{unused} attribute. 3314This attribute, attached to a function, means that the function is meant 3315to be possibly unused. GCC will not produce a warning for this 3316function. 3317 3318@item used 3319@cindex @code{used} attribute. 3320This attribute, attached to a function, means that code must be emitted 3321for the function even if it appears that the function is not referenced. 3322This is useful, for example, when the function is referenced only in 3323inline assembly. 3324 3325@item version_id 3326@cindex @code{version_id} attribute 3327This IA64 HP-UX attribute, attached to a global variable or function, renames a 3328symbol to contain a version string, thus allowing for function level 3329versioning. HP-UX system header files may use version level functioning 3330for some system calls. 3331 3332@smallexample 3333extern int foo () __attribute__((version_id ("20040821"))); 3334@end smallexample 3335 3336Calls to @var{foo} will be mapped to calls to @var{foo@{20040821@}}. 3337 3338@item visibility ("@var{visibility_type}") 3339@cindex @code{visibility} attribute 3340This attribute affects the linkage of the declaration to which it is attached. 3341There are four supported @var{visibility_type} values: default, 3342hidden, protected or internal visibility. 3343 3344@smallexample 3345void __attribute__ ((visibility ("protected"))) 3346f () @{ /* @r{Do something.} */; @} 3347int i __attribute__ ((visibility ("hidden"))); 3348@end smallexample 3349 3350The possible values of @var{visibility_type} correspond to the 3351visibility settings in the ELF gABI. 3352 3353@table @dfn 3354@c keep this list of visibilities in alphabetical order. 3355 3356@item default 3357Default visibility is the normal case for the object file format. 3358This value is available for the visibility attribute to override other 3359options that may change the assumed visibility of entities. 3360 3361On ELF, default visibility means that the declaration is visible to other 3362modules and, in shared libraries, means that the declared entity may be 3363overridden. 3364 3365On Darwin, default visibility means that the declaration is visible to 3366other modules. 3367 3368Default visibility corresponds to ``external linkage'' in the language. 3369 3370@item hidden 3371Hidden visibility indicates that the entity declared will have a new 3372form of linkage, which we'll call ``hidden linkage''. Two 3373declarations of an object with hidden linkage refer to the same object 3374if they are in the same shared object. 3375 3376@item internal 3377Internal visibility is like hidden visibility, but with additional 3378processor specific semantics. Unless otherwise specified by the 3379psABI, GCC defines internal visibility to mean that a function is 3380@emph{never} called from another module. Compare this with hidden 3381functions which, while they cannot be referenced directly by other 3382modules, can be referenced indirectly via function pointers. By 3383indicating that a function cannot be called from outside the module, 3384GCC may for instance omit the load of a PIC register since it is known 3385that the calling function loaded the correct value. 3386 3387@item protected 3388Protected visibility is like default visibility except that it 3389indicates that references within the defining module will bind to the 3390definition in that module. That is, the declared entity cannot be 3391overridden by another module. 3392 3393@end table 3394 3395All visibilities are supported on many, but not all, ELF targets 3396(supported when the assembler supports the @samp{.visibility} 3397pseudo-op). Default visibility is supported everywhere. Hidden 3398visibility is supported on Darwin targets. 3399 3400The visibility attribute should be applied only to declarations which 3401would otherwise have external linkage. The attribute should be applied 3402consistently, so that the same entity should not be declared with 3403different settings of the attribute. 3404 3405In C++, the visibility attribute applies to types as well as functions 3406and objects, because in C++ types have linkage. A class must not have 3407greater visibility than its non-static data member types and bases, 3408and class members default to the visibility of their class. Also, a 3409declaration without explicit visibility is limited to the visibility 3410of its type. 3411 3412In C++, you can mark member functions and static member variables of a 3413class with the visibility attribute. This is useful if you know a 3414particular method or static member variable should only be used from 3415one shared object; then you can mark it hidden while the rest of the 3416class has default visibility. Care must be taken to avoid breaking 3417the One Definition Rule; for example, it is usually not useful to mark 3418an inline method as hidden without marking the whole class as hidden. 3419 3420A C++ namespace declaration can also have the visibility attribute. 3421This attribute applies only to the particular namespace body, not to 3422other definitions of the same namespace; it is equivalent to using 3423@samp{#pragma GCC visibility} before and after the namespace 3424definition (@pxref{Visibility Pragmas}). 3425 3426In C++, if a template argument has limited visibility, this 3427restriction is implicitly propagated to the template instantiation. 3428Otherwise, template instantiations and specializations default to the 3429visibility of their template. 3430 3431If both the template and enclosing class have explicit visibility, the 3432visibility from the template is used. 3433 3434@item vliw 3435@cindex @code{vliw} attribute 3436On MeP, the @code{vliw} attribute tells the compiler to emit 3437instructions in VLIW mode instead of core mode. Note that this 3438attribute is not allowed unless a VLIW coprocessor has been configured 3439and enabled through command line options. 3440 3441@item warn_unused_result 3442@cindex @code{warn_unused_result} attribute 3443The @code{warn_unused_result} attribute causes a warning to be emitted 3444if a caller of the function with this attribute does not use its 3445return value. This is useful for functions where not checking 3446the result is either a security problem or always a bug, such as 3447@code{realloc}. 3448 3449@smallexample 3450int fn () __attribute__ ((warn_unused_result)); 3451int foo () 3452@{ 3453 if (fn () < 0) return -1; 3454 fn (); 3455 return 0; 3456@} 3457@end smallexample 3458 3459results in warning on line 5. 3460 3461@item weak 3462@cindex @code{weak} attribute 3463The @code{weak} attribute causes the declaration to be emitted as a weak 3464symbol rather than a global. This is primarily useful in defining 3465library functions which can be overridden in user code, though it can 3466also be used with non-function declarations. Weak symbols are supported 3467for ELF targets, and also for a.out targets when using the GNU assembler 3468and linker. 3469 3470@item weakref 3471@itemx weakref ("@var{target}") 3472@cindex @code{weakref} attribute 3473The @code{weakref} attribute marks a declaration as a weak reference. 3474Without arguments, it should be accompanied by an @code{alias} attribute 3475naming the target symbol. Optionally, the @var{target} may be given as 3476an argument to @code{weakref} itself. In either case, @code{weakref} 3477implicitly marks the declaration as @code{weak}. Without a 3478@var{target}, given as an argument to @code{weakref} or to @code{alias}, 3479@code{weakref} is equivalent to @code{weak}. 3480 3481@smallexample 3482static int x() __attribute__ ((weakref ("y"))); 3483/* is equivalent to... */ 3484static int x() __attribute__ ((weak, weakref, alias ("y"))); 3485/* and to... */ 3486static int x() __attribute__ ((weakref)); 3487static int x() __attribute__ ((alias ("y"))); 3488@end smallexample 3489 3490A weak reference is an alias that does not by itself require a 3491definition to be given for the target symbol. If the target symbol is 3492only referenced through weak references, then the becomes a @code{weak} 3493undefined symbol. If it is directly referenced, however, then such 3494strong references prevail, and a definition will be required for the 3495symbol, not necessarily in the same translation unit. 3496 3497The effect is equivalent to moving all references to the alias to a 3498separate translation unit, renaming the alias to the aliased symbol, 3499declaring it as weak, compiling the two separate translation units and 3500performing a reloadable link on them. 3501 3502At present, a declaration to which @code{weakref} is attached can 3503only be @code{static}. 3504 3505@end table 3506 3507You can specify multiple attributes in a declaration by separating them 3508by commas within the double parentheses or by immediately following an 3509attribute declaration with another attribute declaration. 3510 3511@cindex @code{#pragma}, reason for not using 3512@cindex pragma, reason for not using 3513Some people object to the @code{__attribute__} feature, suggesting that 3514ISO C's @code{#pragma} should be used instead. At the time 3515@code{__attribute__} was designed, there were two reasons for not doing 3516this. 3517 3518@enumerate 3519@item 3520It is impossible to generate @code{#pragma} commands from a macro. 3521 3522@item 3523There is no telling what the same @code{#pragma} might mean in another 3524compiler. 3525@end enumerate 3526 3527These two reasons applied to almost any application that might have been 3528proposed for @code{#pragma}. It was basically a mistake to use 3529@code{#pragma} for @emph{anything}. 3530 3531The ISO C99 standard includes @code{_Pragma}, which now allows pragmas 3532to be generated from macros. In addition, a @code{#pragma GCC} 3533namespace is now in use for GCC-specific pragmas. However, it has been 3534found convenient to use @code{__attribute__} to achieve a natural 3535attachment of attributes to their corresponding declarations, whereas 3536@code{#pragma GCC} is of use for constructs that do not naturally form 3537part of the grammar. @xref{Other Directives,,Miscellaneous 3538Preprocessing Directives, cpp, The GNU C Preprocessor}. 3539 3540@node Attribute Syntax 3541@section Attribute Syntax 3542@cindex attribute syntax 3543 3544This section describes the syntax with which @code{__attribute__} may be 3545used, and the constructs to which attribute specifiers bind, for the C 3546language. Some details may vary for C++ and Objective-C@. Because of 3547infelicities in the grammar for attributes, some forms described here 3548may not be successfully parsed in all cases. 3549 3550There are some problems with the semantics of attributes in C++. For 3551example, there are no manglings for attributes, although they may affect 3552code generation, so problems may arise when attributed types are used in 3553conjunction with templates or overloading. Similarly, @code{typeid} 3554does not distinguish between types with different attributes. Support 3555for attributes in C++ may be restricted in future to attributes on 3556declarations only, but not on nested declarators. 3557 3558@xref{Function Attributes}, for details of the semantics of attributes 3559applying to functions. @xref{Variable Attributes}, for details of the 3560semantics of attributes applying to variables. @xref{Type Attributes}, 3561for details of the semantics of attributes applying to structure, union 3562and enumerated types. 3563 3564An @dfn{attribute specifier} is of the form 3565@code{__attribute__ ((@var{attribute-list}))}. An @dfn{attribute list} 3566is a possibly empty comma-separated sequence of @dfn{attributes}, where 3567each attribute is one of the following: 3568 3569@itemize @bullet 3570@item 3571Empty. Empty attributes are ignored. 3572 3573@item 3574A word (which may be an identifier such as @code{unused}, or a reserved 3575word such as @code{const}). 3576 3577@item 3578A word, followed by, in parentheses, parameters for the attribute. 3579These parameters take one of the following forms: 3580 3581@itemize @bullet 3582@item 3583An identifier. For example, @code{mode} attributes use this form. 3584 3585@item 3586An identifier followed by a comma and a non-empty comma-separated list 3587of expressions. For example, @code{format} attributes use this form. 3588 3589@item 3590A possibly empty comma-separated list of expressions. For example, 3591@code{format_arg} attributes use this form with the list being a single 3592integer constant expression, and @code{alias} attributes use this form 3593with the list being a single string constant. 3594@end itemize 3595@end itemize 3596 3597An @dfn{attribute specifier list} is a sequence of one or more attribute 3598specifiers, not separated by any other tokens. 3599 3600In GNU C, an attribute specifier list may appear after the colon following a 3601label, other than a @code{case} or @code{default} label. The only 3602attribute it makes sense to use after a label is @code{unused}. This 3603feature is intended for code generated by programs which contains labels 3604that may be unused but which is compiled with @option{-Wall}. It would 3605not normally be appropriate to use in it human-written code, though it 3606could be useful in cases where the code that jumps to the label is 3607contained within an @code{#ifdef} conditional. GNU C++ only permits 3608attributes on labels if the attribute specifier is immediately 3609followed by a semicolon (i.e., the label applies to an empty 3610statement). If the semicolon is missing, C++ label attributes are 3611ambiguous, as it is permissible for a declaration, which could begin 3612with an attribute list, to be labelled in C++. Declarations cannot be 3613labelled in C90 or C99, so the ambiguity does not arise there. 3614 3615An attribute specifier list may appear as part of a @code{struct}, 3616@code{union} or @code{enum} specifier. It may go either immediately 3617after the @code{struct}, @code{union} or @code{enum} keyword, or after 3618the closing brace. The former syntax is preferred. 3619Where attribute specifiers follow the closing brace, they are considered 3620to relate to the structure, union or enumerated type defined, not to any 3621enclosing declaration the type specifier appears in, and the type 3622defined is not complete until after the attribute specifiers. 3623@c Otherwise, there would be the following problems: a shift/reduce 3624@c conflict between attributes binding the struct/union/enum and 3625@c binding to the list of specifiers/qualifiers; and "aligned" 3626@c attributes could use sizeof for the structure, but the size could be 3627@c changed later by "packed" attributes. 3628 3629Otherwise, an attribute specifier appears as part of a declaration, 3630counting declarations of unnamed parameters and type names, and relates 3631to that declaration (which may be nested in another declaration, for 3632example in the case of a parameter declaration), or to a particular declarator 3633within a declaration. Where an 3634attribute specifier is applied to a parameter declared as a function or 3635an array, it should apply to the function or array rather than the 3636pointer to which the parameter is implicitly converted, but this is not 3637yet correctly implemented. 3638 3639Any list of specifiers and qualifiers at the start of a declaration may 3640contain attribute specifiers, whether or not such a list may in that 3641context contain storage class specifiers. (Some attributes, however, 3642are essentially in the nature of storage class specifiers, and only make 3643sense where storage class specifiers may be used; for example, 3644@code{section}.) There is one necessary limitation to this syntax: the 3645first old-style parameter declaration in a function definition cannot 3646begin with an attribute specifier, because such an attribute applies to 3647the function instead by syntax described below (which, however, is not 3648yet implemented in this case). In some other cases, attribute 3649specifiers are permitted by this grammar but not yet supported by the 3650compiler. All attribute specifiers in this place relate to the 3651declaration as a whole. In the obsolescent usage where a type of 3652@code{int} is implied by the absence of type specifiers, such a list of 3653specifiers and qualifiers may be an attribute specifier list with no 3654other specifiers or qualifiers. 3655 3656At present, the first parameter in a function prototype must have some 3657type specifier which is not an attribute specifier; this resolves an 3658ambiguity in the interpretation of @code{void f(int 3659(__attribute__((foo)) x))}, but is subject to change. At present, if 3660the parentheses of a function declarator contain only attributes then 3661those attributes are ignored, rather than yielding an error or warning 3662or implying a single parameter of type int, but this is subject to 3663change. 3664 3665An attribute specifier list may appear immediately before a declarator 3666(other than the first) in a comma-separated list of declarators in a 3667declaration of more than one identifier using a single list of 3668specifiers and qualifiers. Such attribute specifiers apply 3669only to the identifier before whose declarator they appear. For 3670example, in 3671 3672@smallexample 3673__attribute__((noreturn)) void d0 (void), 3674 __attribute__((format(printf, 1, 2))) d1 (const char *, ...), 3675 d2 (void) 3676@end smallexample 3677 3678@noindent 3679the @code{noreturn} attribute applies to all the functions 3680declared; the @code{format} attribute only applies to @code{d1}. 3681 3682An attribute specifier list may appear immediately before the comma, 3683@code{=} or semicolon terminating the declaration of an identifier other 3684than a function definition. Such attribute specifiers apply 3685to the declared object or function. Where an 3686assembler name for an object or function is specified (@pxref{Asm 3687Labels}), the attribute must follow the @code{asm} 3688specification. 3689 3690An attribute specifier list may, in future, be permitted to appear after 3691the declarator in a function definition (before any old-style parameter 3692declarations or the function body). 3693 3694Attribute specifiers may be mixed with type qualifiers appearing inside 3695the @code{[]} of a parameter array declarator, in the C99 construct by 3696which such qualifiers are applied to the pointer to which the array is 3697implicitly converted. Such attribute specifiers apply to the pointer, 3698not to the array, but at present this is not implemented and they are 3699ignored. 3700 3701An attribute specifier list may appear at the start of a nested 3702declarator. At present, there are some limitations in this usage: the 3703attributes correctly apply to the declarator, but for most individual 3704attributes the semantics this implies are not implemented. 3705When attribute specifiers follow the @code{*} of a pointer 3706declarator, they may be mixed with any type qualifiers present. 3707The following describes the formal semantics of this syntax. It will make the 3708most sense if you are familiar with the formal specification of 3709declarators in the ISO C standard. 3710 3711Consider (as in C99 subclause 6.7.5 paragraph 4) a declaration @code{T 3712D1}, where @code{T} contains declaration specifiers that specify a type 3713@var{Type} (such as @code{int}) and @code{D1} is a declarator that 3714contains an identifier @var{ident}. The type specified for @var{ident} 3715for derived declarators whose type does not include an attribute 3716specifier is as in the ISO C standard. 3717 3718If @code{D1} has the form @code{( @var{attribute-specifier-list} D )}, 3719and the declaration @code{T D} specifies the type 3720``@var{derived-declarator-type-list} @var{Type}'' for @var{ident}, then 3721@code{T D1} specifies the type ``@var{derived-declarator-type-list} 3722@var{attribute-specifier-list} @var{Type}'' for @var{ident}. 3723 3724If @code{D1} has the form @code{* 3725@var{type-qualifier-and-attribute-specifier-list} D}, and the 3726declaration @code{T D} specifies the type 3727``@var{derived-declarator-type-list} @var{Type}'' for @var{ident}, then 3728@code{T D1} specifies the type ``@var{derived-declarator-type-list} 3729@var{type-qualifier-and-attribute-specifier-list} @var{Type}'' for 3730@var{ident}. 3731 3732For example, 3733 3734@smallexample 3735void (__attribute__((noreturn)) ****f) (void); 3736@end smallexample 3737 3738@noindent 3739specifies the type ``pointer to pointer to pointer to pointer to 3740non-returning function returning @code{void}''. As another example, 3741 3742@smallexample 3743char *__attribute__((aligned(8))) *f; 3744@end smallexample 3745 3746@noindent 3747specifies the type ``pointer to 8-byte-aligned pointer to @code{char}''. 3748Note again that this does not work with most attributes; for example, 3749the usage of @samp{aligned} and @samp{noreturn} attributes given above 3750is not yet supported. 3751 3752For compatibility with existing code written for compiler versions that 3753did not implement attributes on nested declarators, some laxity is 3754allowed in the placing of attributes. If an attribute that only applies 3755to types is applied to a declaration, it will be treated as applying to 3756the type of that declaration. If an attribute that only applies to 3757declarations is applied to the type of a declaration, it will be treated 3758as applying to that declaration; and, for compatibility with code 3759placing the attributes immediately before the identifier declared, such 3760an attribute applied to a function return type will be treated as 3761applying to the function type, and such an attribute applied to an array 3762element type will be treated as applying to the array type. If an 3763attribute that only applies to function types is applied to a 3764pointer-to-function type, it will be treated as applying to the pointer 3765target type; if such an attribute is applied to a function return type 3766that is not a pointer-to-function type, it will be treated as applying 3767to the function type. 3768 3769@node Function Prototypes 3770@section Prototypes and Old-Style Function Definitions 3771@cindex function prototype declarations 3772@cindex old-style function definitions 3773@cindex promotion of formal parameters 3774 3775GNU C extends ISO C to allow a function prototype to override a later 3776old-style non-prototype definition. Consider the following example: 3777 3778@smallexample 3779/* @r{Use prototypes unless the compiler is old-fashioned.} */ 3780#ifdef __STDC__ 3781#define P(x) x 3782#else 3783#define P(x) () 3784#endif 3785 3786/* @r{Prototype function declaration.} */ 3787int isroot P((uid_t)); 3788 3789/* @r{Old-style function definition.} */ 3790int 3791isroot (x) /* @r{??? lossage here ???} */ 3792 uid_t x; 3793@{ 3794 return x == 0; 3795@} 3796@end smallexample 3797 3798Suppose the type @code{uid_t} happens to be @code{short}. ISO C does 3799not allow this example, because subword arguments in old-style 3800non-prototype definitions are promoted. Therefore in this example the 3801function definition's argument is really an @code{int}, which does not 3802match the prototype argument type of @code{short}. 3803 3804This restriction of ISO C makes it hard to write code that is portable 3805to traditional C compilers, because the programmer does not know 3806whether the @code{uid_t} type is @code{short}, @code{int}, or 3807@code{long}. Therefore, in cases like these GNU C allows a prototype 3808to override a later old-style definition. More precisely, in GNU C, a 3809function prototype argument type overrides the argument type specified 3810by a later old-style definition if the former type is the same as the 3811latter type before promotion. Thus in GNU C the above example is 3812equivalent to the following: 3813 3814@smallexample 3815int isroot (uid_t); 3816 3817int 3818isroot (uid_t x) 3819@{ 3820 return x == 0; 3821@} 3822@end smallexample 3823 3824@noindent 3825GNU C++ does not support old-style function definitions, so this 3826extension is irrelevant. 3827 3828@node C++ Comments 3829@section C++ Style Comments 3830@cindex // 3831@cindex C++ comments 3832@cindex comments, C++ style 3833 3834In GNU C, you may use C++ style comments, which start with @samp{//} and 3835continue until the end of the line. Many other C implementations allow 3836such comments, and they are included in the 1999 C standard. However, 3837C++ style comments are not recognized if you specify an @option{-std} 3838option specifying a version of ISO C before C99, or @option{-ansi} 3839(equivalent to @option{-std=c90}). 3840 3841@node Dollar Signs 3842@section Dollar Signs in Identifier Names 3843@cindex $ 3844@cindex dollar signs in identifier names 3845@cindex identifier names, dollar signs in 3846 3847In GNU C, you may normally use dollar signs in identifier names. 3848This is because many traditional C implementations allow such identifiers. 3849However, dollar signs in identifiers are not supported on a few target 3850machines, typically because the target assembler does not allow them. 3851 3852@node Character Escapes 3853@section The Character @key{ESC} in Constants 3854 3855You can use the sequence @samp{\e} in a string or character constant to 3856stand for the ASCII character @key{ESC}. 3857 3858@node Variable Attributes 3859@section Specifying Attributes of Variables 3860@cindex attribute of variables 3861@cindex variable attributes 3862 3863The keyword @code{__attribute__} allows you to specify special 3864attributes of variables or structure fields. This keyword is followed 3865by an attribute specification inside double parentheses. Some 3866attributes are currently defined generically for variables. 3867Other attributes are defined for variables on particular target 3868systems. Other attributes are available for functions 3869(@pxref{Function Attributes}) and for types (@pxref{Type Attributes}). 3870Other front ends might define more attributes 3871(@pxref{C++ Extensions,,Extensions to the C++ Language}). 3872 3873You may also specify attributes with @samp{__} preceding and following 3874each keyword. This allows you to use them in header files without 3875being concerned about a possible macro of the same name. For example, 3876you may use @code{__aligned__} instead of @code{aligned}. 3877 3878@xref{Attribute Syntax}, for details of the exact syntax for using 3879attributes. 3880 3881@table @code 3882@cindex @code{aligned} attribute 3883@item aligned (@var{alignment}) 3884This attribute specifies a minimum alignment for the variable or 3885structure field, measured in bytes. For example, the declaration: 3886 3887@smallexample 3888int x __attribute__ ((aligned (16))) = 0; 3889@end smallexample 3890 3891@noindent 3892causes the compiler to allocate the global variable @code{x} on a 389316-byte boundary. On a 68040, this could be used in conjunction with 3894an @code{asm} expression to access the @code{move16} instruction which 3895requires 16-byte aligned operands. 3896 3897You can also specify the alignment of structure fields. For example, to 3898create a double-word aligned @code{int} pair, you could write: 3899 3900@smallexample 3901struct foo @{ int x[2] __attribute__ ((aligned (8))); @}; 3902@end smallexample 3903 3904@noindent 3905This is an alternative to creating a union with a @code{double} member 3906that forces the union to be double-word aligned. 3907 3908As in the preceding examples, you can explicitly specify the alignment 3909(in bytes) that you wish the compiler to use for a given variable or 3910structure field. Alternatively, you can leave out the alignment factor 3911and just ask the compiler to align a variable or field to the 3912default alignment for the target architecture you are compiling for. 3913The default alignment is sufficient for all scalar types, but may not be 3914enough for all vector types on a target which supports vector operations. 3915The default alignment is fixed for a particular target ABI. 3916 3917Gcc also provides a target specific macro @code{__BIGGEST_ALIGNMENT__}, 3918which is the largest alignment ever used for any data type on the 3919target machine you are compiling for. For example, you could write: 3920 3921@smallexample 3922short array[3] __attribute__ ((aligned (__BIGGEST_ALIGNMENT__))); 3923@end smallexample 3924 3925The compiler automatically sets the alignment for the declared 3926variable or field to @code{__BIGGEST_ALIGNMENT__}. Doing this can 3927often make copy operations more efficient, because the compiler can 3928use whatever instructions copy the biggest chunks of memory when 3929performing copies to or from the variables or fields that you have 3930aligned this way. Note that the value of @code{__BIGGEST_ALIGNMENT__} 3931may change depending on command line options. 3932 3933When used on a struct, or struct member, the @code{aligned} attribute can 3934only increase the alignment; in order to decrease it, the @code{packed} 3935attribute must be specified as well. When used as part of a typedef, the 3936@code{aligned} attribute can both increase and decrease alignment, and 3937specifying the @code{packed} attribute will generate a warning. 3938 3939Note that the effectiveness of @code{aligned} attributes may be limited 3940by inherent limitations in your linker. On many systems, the linker is 3941only able to arrange for variables to be aligned up to a certain maximum 3942alignment. (For some linkers, the maximum supported alignment may 3943be very very small.) If your linker is only able to align variables 3944up to a maximum of 8 byte alignment, then specifying @code{aligned(16)} 3945in an @code{__attribute__} will still only provide you with 8 byte 3946alignment. See your linker documentation for further information. 3947 3948The @code{aligned} attribute can also be used for functions 3949(@pxref{Function Attributes}.) 3950 3951@item cleanup (@var{cleanup_function}) 3952@cindex @code{cleanup} attribute 3953The @code{cleanup} attribute runs a function when the variable goes 3954out of scope. This attribute can only be applied to auto function 3955scope variables; it may not be applied to parameters or variables 3956with static storage duration. The function must take one parameter, 3957a pointer to a type compatible with the variable. The return value 3958of the function (if any) is ignored. 3959 3960If @option{-fexceptions} is enabled, then @var{cleanup_function} 3961will be run during the stack unwinding that happens during the 3962processing of the exception. Note that the @code{cleanup} attribute 3963does not allow the exception to be caught, only to perform an action. 3964It is undefined what happens if @var{cleanup_function} does not 3965return normally. 3966 3967@item common 3968@itemx nocommon 3969@cindex @code{common} attribute 3970@cindex @code{nocommon} attribute 3971@opindex fcommon 3972@opindex fno-common 3973The @code{common} attribute requests GCC to place a variable in 3974``common'' storage. The @code{nocommon} attribute requests the 3975opposite---to allocate space for it directly. 3976 3977These attributes override the default chosen by the 3978@option{-fno-common} and @option{-fcommon} flags respectively. 3979 3980@item deprecated 3981@itemx deprecated (@var{msg}) 3982@cindex @code{deprecated} attribute 3983The @code{deprecated} attribute results in a warning if the variable 3984is used anywhere in the source file. This is useful when identifying 3985variables that are expected to be removed in a future version of a 3986program. The warning also includes the location of the declaration 3987of the deprecated variable, to enable users to easily find further 3988information about why the variable is deprecated, or what they should 3989do instead. Note that the warning only occurs for uses: 3990 3991@smallexample 3992extern int old_var __attribute__ ((deprecated)); 3993extern int old_var; 3994int new_fn () @{ return old_var; @} 3995@end smallexample 3996 3997results in a warning on line 3 but not line 2. The optional msg 3998argument, which must be a string, will be printed in the warning if 3999present. 4000 4001The @code{deprecated} attribute can also be used for functions and 4002types (@pxref{Function Attributes}, @pxref{Type Attributes}.) 4003 4004@item mode (@var{mode}) 4005@cindex @code{mode} attribute 4006This attribute specifies the data type for the declaration---whichever 4007type corresponds to the mode @var{mode}. This in effect lets you 4008request an integer or floating point type according to its width. 4009 4010You may also specify a mode of @samp{byte} or @samp{__byte__} to 4011indicate the mode corresponding to a one-byte integer, @samp{word} or 4012@samp{__word__} for the mode of a one-word integer, and @samp{pointer} 4013or @samp{__pointer__} for the mode used to represent pointers. 4014 4015@item packed 4016@cindex @code{packed} attribute 4017The @code{packed} attribute specifies that a variable or structure field 4018should have the smallest possible alignment---one byte for a variable, 4019and one bit for a field, unless you specify a larger value with the 4020@code{aligned} attribute. 4021 4022Here is a structure in which the field @code{x} is packed, so that it 4023immediately follows @code{a}: 4024 4025@smallexample 4026struct foo 4027@{ 4028 char a; 4029 int x[2] __attribute__ ((packed)); 4030@}; 4031@end smallexample 4032 4033@emph{Note:} The 4.1, 4.2 and 4.3 series of GCC ignore the 4034@code{packed} attribute on bit-fields of type @code{char}. This has 4035been fixed in GCC 4.4 but the change can lead to differences in the 4036structure layout. See the documentation of 4037@option{-Wpacked-bitfield-compat} for more information. 4038 4039@item section ("@var{section-name}") 4040@cindex @code{section} variable attribute 4041Normally, the compiler places the objects it generates in sections like 4042@code{data} and @code{bss}. Sometimes, however, you need additional sections, 4043or you need certain particular variables to appear in special sections, 4044for example to map to special hardware. The @code{section} 4045attribute specifies that a variable (or function) lives in a particular 4046section. For example, this small program uses several specific section names: 4047 4048@smallexample 4049struct duart a __attribute__ ((section ("DUART_A"))) = @{ 0 @}; 4050struct duart b __attribute__ ((section ("DUART_B"))) = @{ 0 @}; 4051char stack[10000] __attribute__ ((section ("STACK"))) = @{ 0 @}; 4052int init_data __attribute__ ((section ("INITDATA"))); 4053 4054main() 4055@{ 4056 /* @r{Initialize stack pointer} */ 4057 init_sp (stack + sizeof (stack)); 4058 4059 /* @r{Initialize initialized data} */ 4060 memcpy (&init_data, &data, &edata - &data); 4061 4062 /* @r{Turn on the serial ports} */ 4063 init_duart (&a); 4064 init_duart (&b); 4065@} 4066@end smallexample 4067 4068@noindent 4069Use the @code{section} attribute with 4070@emph{global} variables and not @emph{local} variables, 4071as shown in the example. 4072 4073You may use the @code{section} attribute with initialized or 4074uninitialized global variables but the linker requires 4075each object be defined once, with the exception that uninitialized 4076variables tentatively go in the @code{common} (or @code{bss}) section 4077and can be multiply ``defined''. Using the @code{section} attribute 4078will change what section the variable goes into and may cause the 4079linker to issue an error if an uninitialized variable has multiple 4080definitions. You can force a variable to be initialized with the 4081@option{-fno-common} flag or the @code{nocommon} attribute. 4082 4083Some file formats do not support arbitrary sections so the @code{section} 4084attribute is not available on all platforms. 4085If you need to map the entire contents of a module to a particular 4086section, consider using the facilities of the linker instead. 4087 4088@item shared 4089@cindex @code{shared} variable attribute 4090On Microsoft Windows, in addition to putting variable definitions in a named 4091section, the section can also be shared among all running copies of an 4092executable or DLL@. For example, this small program defines shared data 4093by putting it in a named section @code{shared} and marking the section 4094shareable: 4095 4096@smallexample 4097int foo __attribute__((section ("shared"), shared)) = 0; 4098 4099int 4100main() 4101@{ 4102 /* @r{Read and write foo. All running 4103 copies see the same value.} */ 4104 return 0; 4105@} 4106@end smallexample 4107 4108@noindent 4109You may only use the @code{shared} attribute along with @code{section} 4110attribute with a fully initialized global definition because of the way 4111linkers work. See @code{section} attribute for more information. 4112 4113The @code{shared} attribute is only available on Microsoft Windows@. 4114 4115@item tls_model ("@var{tls_model}") 4116@cindex @code{tls_model} attribute 4117The @code{tls_model} attribute sets thread-local storage model 4118(@pxref{Thread-Local}) of a particular @code{__thread} variable, 4119overriding @option{-ftls-model=} command line switch on a per-variable 4120basis. 4121The @var{tls_model} argument should be one of @code{global-dynamic}, 4122@code{local-dynamic}, @code{initial-exec} or @code{local-exec}. 4123 4124Not all targets support this attribute. 4125 4126@item unused 4127This attribute, attached to a variable, means that the variable is meant 4128to be possibly unused. GCC will not produce a warning for this 4129variable. 4130 4131@item used 4132This attribute, attached to a variable, means that the variable must be 4133emitted even if it appears that the variable is not referenced. 4134 4135@item vector_size (@var{bytes}) 4136This attribute specifies the vector size for the variable, measured in 4137bytes. For example, the declaration: 4138 4139@smallexample 4140int foo __attribute__ ((vector_size (16))); 4141@end smallexample 4142 4143@noindent 4144causes the compiler to set the mode for @code{foo}, to be 16 bytes, 4145divided into @code{int} sized units. Assuming a 32-bit int (a vector of 41464 units of 4 bytes), the corresponding mode of @code{foo} will be V4SI@. 4147 4148This attribute is only applicable to integral and float scalars, 4149although arrays, pointers, and function return values are allowed in 4150conjunction with this construct. 4151 4152Aggregates with this attribute are invalid, even if they are of the same 4153size as a corresponding scalar. For example, the declaration: 4154 4155@smallexample 4156struct S @{ int a; @}; 4157struct S __attribute__ ((vector_size (16))) foo; 4158@end smallexample 4159 4160@noindent 4161is invalid even if the size of the structure is the same as the size of 4162the @code{int}. 4163 4164@item selectany 4165The @code{selectany} attribute causes an initialized global variable to 4166have link-once semantics. When multiple definitions of the variable are 4167encountered by the linker, the first is selected and the remainder are 4168discarded. Following usage by the Microsoft compiler, the linker is told 4169@emph{not} to warn about size or content differences of the multiple 4170definitions. 4171 4172Although the primary usage of this attribute is for POD types, the 4173attribute can also be applied to global C++ objects that are initialized 4174by a constructor. In this case, the static initialization and destruction 4175code for the object is emitted in each translation defining the object, 4176but the calls to the constructor and destructor are protected by a 4177link-once guard variable. 4178 4179The @code{selectany} attribute is only available on Microsoft Windows 4180targets. You can use @code{__declspec (selectany)} as a synonym for 4181@code{__attribute__ ((selectany))} for compatibility with other 4182compilers. 4183 4184@item weak 4185The @code{weak} attribute is described in @ref{Function Attributes}. 4186 4187@item dllimport 4188The @code{dllimport} attribute is described in @ref{Function Attributes}. 4189 4190@item dllexport 4191The @code{dllexport} attribute is described in @ref{Function Attributes}. 4192 4193@end table 4194 4195@subsection Blackfin Variable Attributes 4196 4197Three attributes are currently defined for the Blackfin. 4198 4199@table @code 4200@item l1_data 4201@itemx l1_data_A 4202@itemx l1_data_B 4203@cindex @code{l1_data} variable attribute 4204@cindex @code{l1_data_A} variable attribute 4205@cindex @code{l1_data_B} variable attribute 4206Use these attributes on the Blackfin to place the variable into L1 Data SRAM. 4207Variables with @code{l1_data} attribute will be put into the specific section 4208named @code{.l1.data}. Those with @code{l1_data_A} attribute will be put into 4209the specific section named @code{.l1.data.A}. Those with @code{l1_data_B} 4210attribute will be put into the specific section named @code{.l1.data.B}. 4211 4212@item l2 4213@cindex @code{l2} variable attribute 4214Use this attribute on the Blackfin to place the variable into L2 SRAM. 4215Variables with @code{l2} attribute will be put into the specific section 4216named @code{.l2.data}. 4217@end table 4218 4219@subsection M32R/D Variable Attributes 4220 4221One attribute is currently defined for the M32R/D@. 4222 4223@table @code 4224@item model (@var{model-name}) 4225@cindex variable addressability on the M32R/D 4226Use this attribute on the M32R/D to set the addressability of an object. 4227The identifier @var{model-name} is one of @code{small}, @code{medium}, 4228or @code{large}, representing each of the code models. 4229 4230Small model objects live in the lower 16MB of memory (so that their 4231addresses can be loaded with the @code{ld24} instruction). 4232 4233Medium and large model objects may live anywhere in the 32-bit address space 4234(the compiler will generate @code{seth/add3} instructions to load their 4235addresses). 4236@end table 4237 4238@anchor{MeP Variable Attributes} 4239@subsection MeP Variable Attributes 4240 4241The MeP target has a number of addressing modes and busses. The 4242@code{near} space spans the standard memory space's first 16 megabytes 4243(24 bits). The @code{far} space spans the entire 32-bit memory space. 4244The @code{based} space is a 128 byte region in the memory space which 4245is addressed relative to the @code{$tp} register. The @code{tiny} 4246space is a 65536 byte region relative to the @code{$gp} register. In 4247addition to these memory regions, the MeP target has a separate 16-bit 4248control bus which is specified with @code{cb} attributes. 4249 4250@table @code 4251 4252@item based 4253Any variable with the @code{based} attribute will be assigned to the 4254@code{.based} section, and will be accessed with relative to the 4255@code{$tp} register. 4256 4257@item tiny 4258Likewise, the @code{tiny} attribute assigned variables to the 4259@code{.tiny} section, relative to the @code{$gp} register. 4260 4261@item near 4262Variables with the @code{near} attribute are assumed to have addresses 4263that fit in a 24-bit addressing mode. This is the default for large 4264variables (@code{-mtiny=4} is the default) but this attribute can 4265override @code{-mtiny=} for small variables, or override @code{-ml}. 4266 4267@item far 4268Variables with the @code{far} attribute are addressed using a full 426932-bit address. Since this covers the entire memory space, this 4270allows modules to make no assumptions about where variables might be 4271stored. 4272 4273@item io 4274@itemx io (@var{addr}) 4275Variables with the @code{io} attribute are used to address 4276memory-mapped peripherals. If an address is specified, the variable 4277is assigned that address, else it is not assigned an address (it is 4278assumed some other module will assign an address). Example: 4279 4280@example 4281int timer_count __attribute__((io(0x123))); 4282@end example 4283 4284@item cb 4285@itemx cb (@var{addr}) 4286Variables with the @code{cb} attribute are used to access the control 4287bus, using special instructions. @code{addr} indicates the control bus 4288address. Example: 4289 4290@example 4291int cpu_clock __attribute__((cb(0x123))); 4292@end example 4293 4294@end table 4295 4296@anchor{i386 Variable Attributes} 4297@subsection i386 Variable Attributes 4298 4299Two attributes are currently defined for i386 configurations: 4300@code{ms_struct} and @code{gcc_struct} 4301 4302@table @code 4303@item ms_struct 4304@itemx gcc_struct 4305@cindex @code{ms_struct} attribute 4306@cindex @code{gcc_struct} attribute 4307 4308If @code{packed} is used on a structure, or if bit-fields are used 4309it may be that the Microsoft ABI packs them differently 4310than GCC would normally pack them. Particularly when moving packed 4311data between functions compiled with GCC and the native Microsoft compiler 4312(either via function call or as data in a file), it may be necessary to access 4313either format. 4314 4315Currently @option{-m[no-]ms-bitfields} is provided for the Microsoft Windows X86 4316compilers to match the native Microsoft compiler. 4317 4318The Microsoft structure layout algorithm is fairly simple with the exception 4319of the bitfield packing: 4320 4321The padding and alignment of members of structures and whether a bit field 4322can straddle a storage-unit boundary 4323 4324@enumerate 4325@item Structure members are stored sequentially in the order in which they are 4326declared: the first member has the lowest memory address and the last member 4327the highest. 4328 4329@item Every data object has an alignment-requirement. The alignment-requirement 4330for all data except structures, unions, and arrays is either the size of the 4331object or the current packing size (specified with either the aligned attribute 4332or the pack pragma), whichever is less. For structures, unions, and arrays, 4333the alignment-requirement is the largest alignment-requirement of its members. 4334Every object is allocated an offset so that: 4335 4336offset % alignment-requirement == 0 4337 4338@item Adjacent bit fields are packed into the same 1-, 2-, or 4-byte allocation 4339unit if the integral types are the same size and if the next bit field fits 4340into the current allocation unit without crossing the boundary imposed by the 4341common alignment requirements of the bit fields. 4342@end enumerate 4343 4344Handling of zero-length bitfields: 4345 4346MSVC interprets zero-length bitfields in the following ways: 4347 4348@enumerate 4349@item If a zero-length bitfield is inserted between two bitfields that would 4350normally be coalesced, the bitfields will not be coalesced. 4351 4352For example: 4353 4354@smallexample 4355struct 4356 @{ 4357 unsigned long bf_1 : 12; 4358 unsigned long : 0; 4359 unsigned long bf_2 : 12; 4360 @} t1; 4361@end smallexample 4362 4363The size of @code{t1} would be 8 bytes with the zero-length bitfield. If the 4364zero-length bitfield were removed, @code{t1}'s size would be 4 bytes. 4365 4366@item If a zero-length bitfield is inserted after a bitfield, @code{foo}, and the 4367alignment of the zero-length bitfield is greater than the member that follows it, 4368@code{bar}, @code{bar} will be aligned as the type of the zero-length bitfield. 4369 4370For example: 4371 4372@smallexample 4373struct 4374 @{ 4375 char foo : 4; 4376 short : 0; 4377 char bar; 4378 @} t2; 4379 4380struct 4381 @{ 4382 char foo : 4; 4383 short : 0; 4384 double bar; 4385 @} t3; 4386@end smallexample 4387 4388For @code{t2}, @code{bar} will be placed at offset 2, rather than offset 1. 4389Accordingly, the size of @code{t2} will be 4. For @code{t3}, the zero-length 4390bitfield will not affect the alignment of @code{bar} or, as a result, the size 4391of the structure. 4392 4393Taking this into account, it is important to note the following: 4394 4395@enumerate 4396@item If a zero-length bitfield follows a normal bitfield, the type of the 4397zero-length bitfield may affect the alignment of the structure as whole. For 4398example, @code{t2} has a size of 4 bytes, since the zero-length bitfield follows a 4399normal bitfield, and is of type short. 4400 4401@item Even if a zero-length bitfield is not followed by a normal bitfield, it may 4402still affect the alignment of the structure: 4403 4404@smallexample 4405struct 4406 @{ 4407 char foo : 6; 4408 long : 0; 4409 @} t4; 4410@end smallexample 4411 4412Here, @code{t4} will take up 4 bytes. 4413@end enumerate 4414 4415@item Zero-length bitfields following non-bitfield members are ignored: 4416 4417@smallexample 4418struct 4419 @{ 4420 char foo; 4421 long : 0; 4422 char bar; 4423 @} t5; 4424@end smallexample 4425 4426Here, @code{t5} will take up 2 bytes. 4427@end enumerate 4428@end table 4429 4430@subsection PowerPC Variable Attributes 4431 4432Three attributes currently are defined for PowerPC configurations: 4433@code{altivec}, @code{ms_struct} and @code{gcc_struct}. 4434 4435For full documentation of the struct attributes please see the 4436documentation in @ref{i386 Variable Attributes}. 4437 4438For documentation of @code{altivec} attribute please see the 4439documentation in @ref{PowerPC Type Attributes}. 4440 4441@subsection SPU Variable Attributes 4442 4443The SPU supports the @code{spu_vector} attribute for variables. For 4444documentation of this attribute please see the documentation in 4445@ref{SPU Type Attributes}. 4446 4447@subsection Xstormy16 Variable Attributes 4448 4449One attribute is currently defined for xstormy16 configurations: 4450@code{below100}. 4451 4452@table @code 4453@item below100 4454@cindex @code{below100} attribute 4455 4456If a variable has the @code{below100} attribute (@code{BELOW100} is 4457allowed also), GCC will place the variable in the first 0x100 bytes of 4458memory and use special opcodes to access it. Such variables will be 4459placed in either the @code{.bss_below100} section or the 4460@code{.data_below100} section. 4461 4462@end table 4463 4464@subsection AVR Variable Attributes 4465 4466@table @code 4467@item progmem 4468@cindex @code{progmem} variable attribute 4469The @code{progmem} attribute is used on the AVR to place data in the Program 4470Memory address space. The AVR is a Harvard Architecture processor and data 4471normally resides in the Data Memory address space. 4472@end table 4473 4474@node Type Attributes 4475@section Specifying Attributes of Types 4476@cindex attribute of types 4477@cindex type attributes 4478 4479The keyword @code{__attribute__} allows you to specify special 4480attributes of @code{struct} and @code{union} types when you define 4481such types. This keyword is followed by an attribute specification 4482inside double parentheses. Seven attributes are currently defined for 4483types: @code{aligned}, @code{packed}, @code{transparent_union}, 4484@code{unused}, @code{deprecated}, @code{visibility}, and 4485@code{may_alias}. Other attributes are defined for functions 4486(@pxref{Function Attributes}) and for variables (@pxref{Variable 4487Attributes}). 4488 4489You may also specify any one of these attributes with @samp{__} 4490preceding and following its keyword. This allows you to use these 4491attributes in header files without being concerned about a possible 4492macro of the same name. For example, you may use @code{__aligned__} 4493instead of @code{aligned}. 4494 4495You may specify type attributes in an enum, struct or union type 4496declaration or definition, or for other types in a @code{typedef} 4497declaration. 4498 4499For an enum, struct or union type, you may specify attributes either 4500between the enum, struct or union tag and the name of the type, or 4501just past the closing curly brace of the @emph{definition}. The 4502former syntax is preferred. 4503 4504@xref{Attribute Syntax}, for details of the exact syntax for using 4505attributes. 4506 4507@table @code 4508@cindex @code{aligned} attribute 4509@item aligned (@var{alignment}) 4510This attribute specifies a minimum alignment (in bytes) for variables 4511of the specified type. For example, the declarations: 4512 4513@smallexample 4514struct S @{ short f[3]; @} __attribute__ ((aligned (8))); 4515typedef int more_aligned_int __attribute__ ((aligned (8))); 4516@end smallexample 4517 4518@noindent 4519force the compiler to insure (as far as it can) that each variable whose 4520type is @code{struct S} or @code{more_aligned_int} will be allocated and 4521aligned @emph{at least} on a 8-byte boundary. On a SPARC, having all 4522variables of type @code{struct S} aligned to 8-byte boundaries allows 4523the compiler to use the @code{ldd} and @code{std} (doubleword load and 4524store) instructions when copying one variable of type @code{struct S} to 4525another, thus improving run-time efficiency. 4526 4527Note that the alignment of any given @code{struct} or @code{union} type 4528is required by the ISO C standard to be at least a perfect multiple of 4529the lowest common multiple of the alignments of all of the members of 4530the @code{struct} or @code{union} in question. This means that you @emph{can} 4531effectively adjust the alignment of a @code{struct} or @code{union} 4532type by attaching an @code{aligned} attribute to any one of the members 4533of such a type, but the notation illustrated in the example above is a 4534more obvious, intuitive, and readable way to request the compiler to 4535adjust the alignment of an entire @code{struct} or @code{union} type. 4536 4537As in the preceding example, you can explicitly specify the alignment 4538(in bytes) that you wish the compiler to use for a given @code{struct} 4539or @code{union} type. Alternatively, you can leave out the alignment factor 4540and just ask the compiler to align a type to the maximum 4541useful alignment for the target machine you are compiling for. For 4542example, you could write: 4543 4544@smallexample 4545struct S @{ short f[3]; @} __attribute__ ((aligned)); 4546@end smallexample 4547 4548Whenever you leave out the alignment factor in an @code{aligned} 4549attribute specification, the compiler automatically sets the alignment 4550for the type to the largest alignment which is ever used for any data 4551type on the target machine you are compiling for. Doing this can often 4552make copy operations more efficient, because the compiler can use 4553whatever instructions copy the biggest chunks of memory when performing 4554copies to or from the variables which have types that you have aligned 4555this way. 4556 4557In the example above, if the size of each @code{short} is 2 bytes, then 4558the size of the entire @code{struct S} type is 6 bytes. The smallest 4559power of two which is greater than or equal to that is 8, so the 4560compiler sets the alignment for the entire @code{struct S} type to 8 4561bytes. 4562 4563Note that although you can ask the compiler to select a time-efficient 4564alignment for a given type and then declare only individual stand-alone 4565objects of that type, the compiler's ability to select a time-efficient 4566alignment is primarily useful only when you plan to create arrays of 4567variables having the relevant (efficiently aligned) type. If you 4568declare or use arrays of variables of an efficiently-aligned type, then 4569it is likely that your program will also be doing pointer arithmetic (or 4570subscripting, which amounts to the same thing) on pointers to the 4571relevant type, and the code that the compiler generates for these 4572pointer arithmetic operations will often be more efficient for 4573efficiently-aligned types than for other types. 4574 4575The @code{aligned} attribute can only increase the alignment; but you 4576can decrease it by specifying @code{packed} as well. See below. 4577 4578Note that the effectiveness of @code{aligned} attributes may be limited 4579by inherent limitations in your linker. On many systems, the linker is 4580only able to arrange for variables to be aligned up to a certain maximum 4581alignment. (For some linkers, the maximum supported alignment may 4582be very very small.) If your linker is only able to align variables 4583up to a maximum of 8 byte alignment, then specifying @code{aligned(16)} 4584in an @code{__attribute__} will still only provide you with 8 byte 4585alignment. See your linker documentation for further information. 4586 4587@item packed 4588This attribute, attached to @code{struct} or @code{union} type 4589definition, specifies that each member (other than zero-width bitfields) 4590of the structure or union is placed to minimize the memory required. When 4591attached to an @code{enum} definition, it indicates that the smallest 4592integral type should be used. 4593 4594@opindex fshort-enums 4595Specifying this attribute for @code{struct} and @code{union} types is 4596equivalent to specifying the @code{packed} attribute on each of the 4597structure or union members. Specifying the @option{-fshort-enums} 4598flag on the line is equivalent to specifying the @code{packed} 4599attribute on all @code{enum} definitions. 4600 4601In the following example @code{struct my_packed_struct}'s members are 4602packed closely together, but the internal layout of its @code{s} member 4603is not packed---to do that, @code{struct my_unpacked_struct} would need to 4604be packed too. 4605 4606@smallexample 4607struct my_unpacked_struct 4608 @{ 4609 char c; 4610 int i; 4611 @}; 4612 4613struct __attribute__ ((__packed__)) my_packed_struct 4614 @{ 4615 char c; 4616 int i; 4617 struct my_unpacked_struct s; 4618 @}; 4619@end smallexample 4620 4621You may only specify this attribute on the definition of an @code{enum}, 4622@code{struct} or @code{union}, not on a @code{typedef} which does not 4623also define the enumerated type, structure or union. 4624 4625@item transparent_union 4626This attribute, attached to a @code{union} type definition, indicates 4627that any function parameter having that union type causes calls to that 4628function to be treated in a special way. 4629 4630First, the argument corresponding to a transparent union type can be of 4631any type in the union; no cast is required. Also, if the union contains 4632a pointer type, the corresponding argument can be a null pointer 4633constant or a void pointer expression; and if the union contains a void 4634pointer type, the corresponding argument can be any pointer expression. 4635If the union member type is a pointer, qualifiers like @code{const} on 4636the referenced type must be respected, just as with normal pointer 4637conversions. 4638 4639Second, the argument is passed to the function using the calling 4640conventions of the first member of the transparent union, not the calling 4641conventions of the union itself. All members of the union must have the 4642same machine representation; this is necessary for this argument passing 4643to work properly. 4644 4645Transparent unions are designed for library functions that have multiple 4646interfaces for compatibility reasons. For example, suppose the 4647@code{wait} function must accept either a value of type @code{int *} to 4648comply with Posix, or a value of type @code{union wait *} to comply with 4649the 4.1BSD interface. If @code{wait}'s parameter were @code{void *}, 4650@code{wait} would accept both kinds of arguments, but it would also 4651accept any other pointer type and this would make argument type checking 4652less useful. Instead, @code{<sys/wait.h>} might define the interface 4653as follows: 4654 4655@smallexample 4656typedef union __attribute__ ((__transparent_union__)) 4657 @{ 4658 int *__ip; 4659 union wait *__up; 4660 @} wait_status_ptr_t; 4661 4662pid_t wait (wait_status_ptr_t); 4663@end smallexample 4664 4665This interface allows either @code{int *} or @code{union wait *} 4666arguments to be passed, using the @code{int *} calling convention. 4667The program can call @code{wait} with arguments of either type: 4668 4669@smallexample 4670int w1 () @{ int w; return wait (&w); @} 4671int w2 () @{ union wait w; return wait (&w); @} 4672@end smallexample 4673 4674With this interface, @code{wait}'s implementation might look like this: 4675 4676@smallexample 4677pid_t wait (wait_status_ptr_t p) 4678@{ 4679 return waitpid (-1, p.__ip, 0); 4680@} 4681@end smallexample 4682 4683@item unused 4684When attached to a type (including a @code{union} or a @code{struct}), 4685this attribute means that variables of that type are meant to appear 4686possibly unused. GCC will not produce a warning for any variables of 4687that type, even if the variable appears to do nothing. This is often 4688the case with lock or thread classes, which are usually defined and then 4689not referenced, but contain constructors and destructors that have 4690nontrivial bookkeeping functions. 4691 4692@item deprecated 4693@itemx deprecated (@var{msg}) 4694The @code{deprecated} attribute results in a warning if the type 4695is used anywhere in the source file. This is useful when identifying 4696types that are expected to be removed in a future version of a program. 4697If possible, the warning also includes the location of the declaration 4698of the deprecated type, to enable users to easily find further 4699information about why the type is deprecated, or what they should do 4700instead. Note that the warnings only occur for uses and then only 4701if the type is being applied to an identifier that itself is not being 4702declared as deprecated. 4703 4704@smallexample 4705typedef int T1 __attribute__ ((deprecated)); 4706T1 x; 4707typedef T1 T2; 4708T2 y; 4709typedef T1 T3 __attribute__ ((deprecated)); 4710T3 z __attribute__ ((deprecated)); 4711@end smallexample 4712 4713results in a warning on line 2 and 3 but not lines 4, 5, or 6. No 4714warning is issued for line 4 because T2 is not explicitly 4715deprecated. Line 5 has no warning because T3 is explicitly 4716deprecated. Similarly for line 6. The optional msg 4717argument, which must be a string, will be printed in the warning if 4718present. 4719 4720The @code{deprecated} attribute can also be used for functions and 4721variables (@pxref{Function Attributes}, @pxref{Variable Attributes}.) 4722 4723@item may_alias 4724Accesses through pointers to types with this attribute are not subject 4725to type-based alias analysis, but are instead assumed to be able to alias 4726any other type of objects. In the context of 6.5/7 an lvalue expression 4727dereferencing such a pointer is treated like having a character type. 4728See @option{-fstrict-aliasing} for more information on aliasing issues. 4729This extension exists to support some vector APIs, in which pointers to 4730one vector type are permitted to alias pointers to a different vector type. 4731 4732Note that an object of a type with this attribute does not have any 4733special semantics. 4734 4735Example of use: 4736 4737@smallexample 4738typedef short __attribute__((__may_alias__)) short_a; 4739 4740int 4741main (void) 4742@{ 4743 int a = 0x12345678; 4744 short_a *b = (short_a *) &a; 4745 4746 b[1] = 0; 4747 4748 if (a == 0x12345678) 4749 abort(); 4750 4751 exit(0); 4752@} 4753@end smallexample 4754 4755If you replaced @code{short_a} with @code{short} in the variable 4756declaration, the above program would abort when compiled with 4757@option{-fstrict-aliasing}, which is on by default at @option{-O2} or 4758above in recent GCC versions. 4759 4760@item visibility 4761In C++, attribute visibility (@pxref{Function Attributes}) can also be 4762applied to class, struct, union and enum types. Unlike other type 4763attributes, the attribute must appear between the initial keyword and 4764the name of the type; it cannot appear after the body of the type. 4765 4766Note that the type visibility is applied to vague linkage entities 4767associated with the class (vtable, typeinfo node, etc.). In 4768particular, if a class is thrown as an exception in one shared object 4769and caught in another, the class must have default visibility. 4770Otherwise the two shared objects will be unable to use the same 4771typeinfo node and exception handling will break. 4772 4773@end table 4774 4775@subsection ARM Type Attributes 4776 4777On those ARM targets that support @code{dllimport} (such as Symbian 4778OS), you can use the @code{notshared} attribute to indicate that the 4779virtual table and other similar data for a class should not be 4780exported from a DLL@. For example: 4781 4782@smallexample 4783class __declspec(notshared) C @{ 4784public: 4785 __declspec(dllimport) C(); 4786 virtual void f(); 4787@} 4788 4789__declspec(dllexport) 4790C::C() @{@} 4791@end smallexample 4792 4793In this code, @code{C::C} is exported from the current DLL, but the 4794virtual table for @code{C} is not exported. (You can use 4795@code{__attribute__} instead of @code{__declspec} if you prefer, but 4796most Symbian OS code uses @code{__declspec}.) 4797 4798@anchor{MeP Type Attributes} 4799@subsection MeP Type Attributes 4800 4801Many of the MeP variable attributes may be applied to types as well. 4802Specifically, the @code{based}, @code{tiny}, @code{near}, and 4803@code{far} attributes may be applied to either. The @code{io} and 4804@code{cb} attributes may not be applied to types. 4805 4806@anchor{i386 Type Attributes} 4807@subsection i386 Type Attributes 4808 4809Two attributes are currently defined for i386 configurations: 4810@code{ms_struct} and @code{gcc_struct}. 4811 4812@table @code 4813 4814@item ms_struct 4815@itemx gcc_struct 4816@cindex @code{ms_struct} 4817@cindex @code{gcc_struct} 4818 4819If @code{packed} is used on a structure, or if bit-fields are used 4820it may be that the Microsoft ABI packs them differently 4821than GCC would normally pack them. Particularly when moving packed 4822data between functions compiled with GCC and the native Microsoft compiler 4823(either via function call or as data in a file), it may be necessary to access 4824either format. 4825 4826Currently @option{-m[no-]ms-bitfields} is provided for the Microsoft Windows X86 4827compilers to match the native Microsoft compiler. 4828@end table 4829 4830To specify multiple attributes, separate them by commas within the 4831double parentheses: for example, @samp{__attribute__ ((aligned (16), 4832packed))}. 4833 4834@anchor{PowerPC Type Attributes} 4835@subsection PowerPC Type Attributes 4836 4837Three attributes currently are defined for PowerPC configurations: 4838@code{altivec}, @code{ms_struct} and @code{gcc_struct}. 4839 4840For full documentation of the @code{ms_struct} and @code{gcc_struct} 4841attributes please see the documentation in @ref{i386 Type Attributes}. 4842 4843The @code{altivec} attribute allows one to declare AltiVec vector data 4844types supported by the AltiVec Programming Interface Manual. The 4845attribute requires an argument to specify one of three vector types: 4846@code{vector__}, @code{pixel__} (always followed by unsigned short), 4847and @code{bool__} (always followed by unsigned). 4848 4849@smallexample 4850__attribute__((altivec(vector__))) 4851__attribute__((altivec(pixel__))) unsigned short 4852__attribute__((altivec(bool__))) unsigned 4853@end smallexample 4854 4855These attributes mainly are intended to support the @code{__vector}, 4856@code{__pixel}, and @code{__bool} AltiVec keywords. 4857 4858@anchor{SPU Type Attributes} 4859@subsection SPU Type Attributes 4860 4861The SPU supports the @code{spu_vector} attribute for types. This attribute 4862allows one to declare vector data types supported by the Sony/Toshiba/IBM SPU 4863Language Extensions Specification. It is intended to support the 4864@code{__vector} keyword. 4865 4866@node Alignment 4867@section Inquiring on Alignment of Types or Variables 4868@cindex alignment 4869@cindex type alignment 4870@cindex variable alignment 4871 4872The keyword @code{__alignof__} allows you to inquire about how an object 4873is aligned, or the minimum alignment usually required by a type. Its 4874syntax is just like @code{sizeof}. 4875 4876For example, if the target machine requires a @code{double} value to be 4877aligned on an 8-byte boundary, then @code{__alignof__ (double)} is 8. 4878This is true on many RISC machines. On more traditional machine 4879designs, @code{__alignof__ (double)} is 4 or even 2. 4880 4881Some machines never actually require alignment; they allow reference to any 4882data type even at an odd address. For these machines, @code{__alignof__} 4883reports the smallest alignment that GCC will give the data type, usually as 4884mandated by the target ABI. 4885 4886If the operand of @code{__alignof__} is an lvalue rather than a type, 4887its value is the required alignment for its type, taking into account 4888any minimum alignment specified with GCC's @code{__attribute__} 4889extension (@pxref{Variable Attributes}). For example, after this 4890declaration: 4891 4892@smallexample 4893struct foo @{ int x; char y; @} foo1; 4894@end smallexample 4895 4896@noindent 4897the value of @code{__alignof__ (foo1.y)} is 1, even though its actual 4898alignment is probably 2 or 4, the same as @code{__alignof__ (int)}. 4899 4900It is an error to ask for the alignment of an incomplete type. 4901 4902 4903@node Inline 4904@section An Inline Function is As Fast As a Macro 4905@cindex inline functions 4906@cindex integrating function code 4907@cindex open coding 4908@cindex macros, inline alternative 4909 4910By declaring a function inline, you can direct GCC to make 4911calls to that function faster. One way GCC can achieve this is to 4912integrate that function's code into the code for its callers. This 4913makes execution faster by eliminating the function-call overhead; in 4914addition, if any of the actual argument values are constant, their 4915known values may permit simplifications at compile time so that not 4916all of the inline function's code needs to be included. The effect on 4917code size is less predictable; object code may be larger or smaller 4918with function inlining, depending on the particular case. You can 4919also direct GCC to try to integrate all ``simple enough'' functions 4920into their callers with the option @option{-finline-functions}. 4921 4922GCC implements three different semantics of declaring a function 4923inline. One is available with @option{-std=gnu89} or 4924@option{-fgnu89-inline} or when @code{gnu_inline} attribute is present 4925on all inline declarations, another when @option{-std=c99} or 4926@option{-std=gnu99} (without @option{-fgnu89-inline}), and the third 4927is used when compiling C++. 4928 4929To declare a function inline, use the @code{inline} keyword in its 4930declaration, like this: 4931 4932@smallexample 4933static inline int 4934inc (int *a) 4935@{ 4936 (*a)++; 4937@} 4938@end smallexample 4939 4940If you are writing a header file to be included in ISO C90 programs, write 4941@code{__inline__} instead of @code{inline}. @xref{Alternate Keywords}. 4942 4943The three types of inlining behave similarly in two important cases: 4944when the @code{inline} keyword is used on a @code{static} function, 4945like the example above, and when a function is first declared without 4946using the @code{inline} keyword and then is defined with 4947@code{inline}, like this: 4948 4949@smallexample 4950extern int inc (int *a); 4951inline int 4952inc (int *a) 4953@{ 4954 (*a)++; 4955@} 4956@end smallexample 4957 4958In both of these common cases, the program behaves the same as if you 4959had not used the @code{inline} keyword, except for its speed. 4960 4961@cindex inline functions, omission of 4962@opindex fkeep-inline-functions 4963When a function is both inline and @code{static}, if all calls to the 4964function are integrated into the caller, and the function's address is 4965never used, then the function's own assembler code is never referenced. 4966In this case, GCC does not actually output assembler code for the 4967function, unless you specify the option @option{-fkeep-inline-functions}. 4968Some calls cannot be integrated for various reasons (in particular, 4969calls that precede the function's definition cannot be integrated, and 4970neither can recursive calls within the definition). If there is a 4971nonintegrated call, then the function is compiled to assembler code as 4972usual. The function must also be compiled as usual if the program 4973refers to its address, because that can't be inlined. 4974 4975@opindex Winline 4976Note that certain usages in a function definition can make it unsuitable 4977for inline substitution. Among these usages are: use of varargs, use of 4978alloca, use of variable sized data types (@pxref{Variable Length}), 4979use of computed goto (@pxref{Labels as Values}), use of nonlocal goto, 4980and nested functions (@pxref{Nested Functions}). Using @option{-Winline} 4981will warn when a function marked @code{inline} could not be substituted, 4982and will give the reason for the failure. 4983 4984@cindex automatic @code{inline} for C++ member fns 4985@cindex @code{inline} automatic for C++ member fns 4986@cindex member fns, automatically @code{inline} 4987@cindex C++ member fns, automatically @code{inline} 4988@opindex fno-default-inline 4989As required by ISO C++, GCC considers member functions defined within 4990the body of a class to be marked inline even if they are 4991not explicitly declared with the @code{inline} keyword. You can 4992override this with @option{-fno-default-inline}; @pxref{C++ Dialect 4993Options,,Options Controlling C++ Dialect}. 4994 4995GCC does not inline any functions when not optimizing unless you specify 4996the @samp{always_inline} attribute for the function, like this: 4997 4998@smallexample 4999/* @r{Prototype.} */ 5000inline void foo (const char) __attribute__((always_inline)); 5001@end smallexample 5002 5003The remainder of this section is specific to GNU C90 inlining. 5004 5005@cindex non-static inline function 5006When an inline function is not @code{static}, then the compiler must assume 5007that there may be calls from other source files; since a global symbol can 5008be defined only once in any program, the function must not be defined in 5009the other source files, so the calls therein cannot be integrated. 5010Therefore, a non-@code{static} inline function is always compiled on its 5011own in the usual fashion. 5012 5013If you specify both @code{inline} and @code{extern} in the function 5014definition, then the definition is used only for inlining. In no case 5015is the function compiled on its own, not even if you refer to its 5016address explicitly. Such an address becomes an external reference, as 5017if you had only declared the function, and had not defined it. 5018 5019This combination of @code{inline} and @code{extern} has almost the 5020effect of a macro. The way to use it is to put a function definition in 5021a header file with these keywords, and put another copy of the 5022definition (lacking @code{inline} and @code{extern}) in a library file. 5023The definition in the header file will cause most calls to the function 5024to be inlined. If any uses of the function remain, they will refer to 5025the single copy in the library. 5026 5027@node Extended Asm 5028@section Assembler Instructions with C Expression Operands 5029@cindex extended @code{asm} 5030@cindex @code{asm} expressions 5031@cindex assembler instructions 5032@cindex registers 5033 5034In an assembler instruction using @code{asm}, you can specify the 5035operands of the instruction using C expressions. This means you need not 5036guess which registers or memory locations will contain the data you want 5037to use. 5038 5039You must specify an assembler instruction template much like what 5040appears in a machine description, plus an operand constraint string for 5041each operand. 5042 5043For example, here is how to use the 68881's @code{fsinx} instruction: 5044 5045@smallexample 5046asm ("fsinx %1,%0" : "=f" (result) : "f" (angle)); 5047@end smallexample 5048 5049@noindent 5050Here @code{angle} is the C expression for the input operand while 5051@code{result} is that of the output operand. Each has @samp{"f"} as its 5052operand constraint, saying that a floating point register is required. 5053The @samp{=} in @samp{=f} indicates that the operand is an output; all 5054output operands' constraints must use @samp{=}. The constraints use the 5055same language used in the machine description (@pxref{Constraints}). 5056 5057Each operand is described by an operand-constraint string followed by 5058the C expression in parentheses. A colon separates the assembler 5059template from the first output operand and another separates the last 5060output operand from the first input, if any. Commas separate the 5061operands within each group. The total number of operands is currently 5062limited to 30; this limitation may be lifted in some future version of 5063GCC@. 5064 5065If there are no output operands but there are input operands, you must 5066place two consecutive colons surrounding the place where the output 5067operands would go. 5068 5069As of GCC version 3.1, it is also possible to specify input and output 5070operands using symbolic names which can be referenced within the 5071assembler code. These names are specified inside square brackets 5072preceding the constraint string, and can be referenced inside the 5073assembler code using @code{%[@var{name}]} instead of a percentage sign 5074followed by the operand number. Using named operands the above example 5075could look like: 5076 5077@smallexample 5078asm ("fsinx %[angle],%[output]" 5079 : [output] "=f" (result) 5080 : [angle] "f" (angle)); 5081@end smallexample 5082 5083@noindent 5084Note that the symbolic operand names have no relation whatsoever to 5085other C identifiers. You may use any name you like, even those of 5086existing C symbols, but you must ensure that no two operands within the same 5087assembler construct use the same symbolic name. 5088 5089Output operand expressions must be lvalues; the compiler can check this. 5090The input operands need not be lvalues. The compiler cannot check 5091whether the operands have data types that are reasonable for the 5092instruction being executed. It does not parse the assembler instruction 5093template and does not know what it means or even whether it is valid 5094assembler input. The extended @code{asm} feature is most often used for 5095machine instructions the compiler itself does not know exist. If 5096the output expression cannot be directly addressed (for example, it is a 5097bit-field), your constraint must allow a register. In that case, GCC 5098will use the register as the output of the @code{asm}, and then store 5099that register into the output. 5100 5101The ordinary output operands must be write-only; GCC will assume that 5102the values in these operands before the instruction are dead and need 5103not be generated. Extended asm supports input-output or read-write 5104operands. Use the constraint character @samp{+} to indicate such an 5105operand and list it with the output operands. You should only use 5106read-write operands when the constraints for the operand (or the 5107operand in which only some of the bits are to be changed) allow a 5108register. 5109 5110You may, as an alternative, logically split its function into two 5111separate operands, one input operand and one write-only output 5112operand. The connection between them is expressed by constraints 5113which say they need to be in the same location when the instruction 5114executes. You can use the same C expression for both operands, or 5115different expressions. For example, here we write the (fictitious) 5116@samp{combine} instruction with @code{bar} as its read-only source 5117operand and @code{foo} as its read-write destination: 5118 5119@smallexample 5120asm ("combine %2,%0" : "=r" (foo) : "0" (foo), "g" (bar)); 5121@end smallexample 5122 5123@noindent 5124The constraint @samp{"0"} for operand 1 says that it must occupy the 5125same location as operand 0. A number in constraint is allowed only in 5126an input operand and it must refer to an output operand. 5127 5128Only a number in the constraint can guarantee that one operand will be in 5129the same place as another. The mere fact that @code{foo} is the value 5130of both operands is not enough to guarantee that they will be in the 5131same place in the generated assembler code. The following would not 5132work reliably: 5133 5134@smallexample 5135asm ("combine %2,%0" : "=r" (foo) : "r" (foo), "g" (bar)); 5136@end smallexample 5137 5138Various optimizations or reloading could cause operands 0 and 1 to be in 5139different registers; GCC knows no reason not to do so. For example, the 5140compiler might find a copy of the value of @code{foo} in one register and 5141use it for operand 1, but generate the output operand 0 in a different 5142register (copying it afterward to @code{foo}'s own address). Of course, 5143since the register for operand 1 is not even mentioned in the assembler 5144code, the result will not work, but GCC can't tell that. 5145 5146As of GCC version 3.1, one may write @code{[@var{name}]} instead of 5147the operand number for a matching constraint. For example: 5148 5149@smallexample 5150asm ("cmoveq %1,%2,%[result]" 5151 : [result] "=r"(result) 5152 : "r" (test), "r"(new), "[result]"(old)); 5153@end smallexample 5154 5155Sometimes you need to make an @code{asm} operand be a specific register, 5156but there's no matching constraint letter for that register @emph{by 5157itself}. To force the operand into that register, use a local variable 5158for the operand and specify the register in the variable declaration. 5159@xref{Explicit Reg Vars}. Then for the @code{asm} operand, use any 5160register constraint letter that matches the register: 5161 5162@smallexample 5163register int *p1 asm ("r0") = @dots{}; 5164register int *p2 asm ("r1") = @dots{}; 5165register int *result asm ("r0"); 5166asm ("sysint" : "=r" (result) : "0" (p1), "r" (p2)); 5167@end smallexample 5168 5169@anchor{Example of asm with clobbered asm reg} 5170In the above example, beware that a register that is call-clobbered by 5171the target ABI will be overwritten by any function call in the 5172assignment, including library calls for arithmetic operators. 5173Also a register may be clobbered when generating some operations, 5174like variable shift, memory copy or memory move on x86. 5175Assuming it is a call-clobbered register, this may happen to @code{r0} 5176above by the assignment to @code{p2}. If you have to use such a 5177register, use temporary variables for expressions between the register 5178assignment and use: 5179 5180@smallexample 5181int t1 = @dots{}; 5182register int *p1 asm ("r0") = @dots{}; 5183register int *p2 asm ("r1") = t1; 5184register int *result asm ("r0"); 5185asm ("sysint" : "=r" (result) : "0" (p1), "r" (p2)); 5186@end smallexample 5187 5188Some instructions clobber specific hard registers. To describe this, 5189write a third colon after the input operands, followed by the names of 5190the clobbered hard registers (given as strings). Here is a realistic 5191example for the VAX: 5192 5193@smallexample 5194asm volatile ("movc3 %0,%1,%2" 5195 : /* @r{no outputs} */ 5196 : "g" (from), "g" (to), "g" (count) 5197 : "r0", "r1", "r2", "r3", "r4", "r5"); 5198@end smallexample 5199 5200You may not write a clobber description in a way that overlaps with an 5201input or output operand. For example, you may not have an operand 5202describing a register class with one member if you mention that register 5203in the clobber list. Variables declared to live in specific registers 5204(@pxref{Explicit Reg Vars}), and used as asm input or output operands must 5205have no part mentioned in the clobber description. 5206There is no way for you to specify that an input 5207operand is modified without also specifying it as an output 5208operand. Note that if all the output operands you specify are for this 5209purpose (and hence unused), you will then also need to specify 5210@code{volatile} for the @code{asm} construct, as described below, to 5211prevent GCC from deleting the @code{asm} statement as unused. 5212 5213If you refer to a particular hardware register from the assembler code, 5214you will probably have to list the register after the third colon to 5215tell the compiler the register's value is modified. In some assemblers, 5216the register names begin with @samp{%}; to produce one @samp{%} in the 5217assembler code, you must write @samp{%%} in the input. 5218 5219If your assembler instruction can alter the condition code register, add 5220@samp{cc} to the list of clobbered registers. GCC on some machines 5221represents the condition codes as a specific hardware register; 5222@samp{cc} serves to name this register. On other machines, the 5223condition code is handled differently, and specifying @samp{cc} has no 5224effect. But it is valid no matter what the machine. 5225 5226If your assembler instructions access memory in an unpredictable 5227fashion, add @samp{memory} to the list of clobbered registers. This 5228will cause GCC to not keep memory values cached in registers across the 5229assembler instruction and not optimize stores or loads to that memory. 5230You will also want to add the @code{volatile} keyword if the memory 5231affected is not listed in the inputs or outputs of the @code{asm}, as 5232the @samp{memory} clobber does not count as a side-effect of the 5233@code{asm}. If you know how large the accessed memory is, you can add 5234it as input or output but if this is not known, you should add 5235@samp{memory}. As an example, if you access ten bytes of a string, you 5236can use a memory input like: 5237 5238@smallexample 5239@{"m"( (@{ struct @{ char x[10]; @} *p = (void *)ptr ; *p; @}) )@}. 5240@end smallexample 5241 5242Note that in the following example the memory input is necessary, 5243otherwise GCC might optimize the store to @code{x} away: 5244@smallexample 5245int foo () 5246@{ 5247 int x = 42; 5248 int *y = &x; 5249 int result; 5250 asm ("magic stuff accessing an 'int' pointed to by '%1'" 5251 "=&d" (r) : "a" (y), "m" (*y)); 5252 return result; 5253@} 5254@end smallexample 5255 5256You can put multiple assembler instructions together in a single 5257@code{asm} template, separated by the characters normally used in assembly 5258code for the system. A combination that works in most places is a newline 5259to break the line, plus a tab character to move to the instruction field 5260(written as @samp{\n\t}). Sometimes semicolons can be used, if the 5261assembler allows semicolons as a line-breaking character. Note that some 5262assembler dialects use semicolons to start a comment. 5263The input operands are guaranteed not to use any of the clobbered 5264registers, and neither will the output operands' addresses, so you can 5265read and write the clobbered registers as many times as you like. Here 5266is an example of multiple instructions in a template; it assumes the 5267subroutine @code{_foo} accepts arguments in registers 9 and 10: 5268 5269@smallexample 5270asm ("movl %0,r9\n\tmovl %1,r10\n\tcall _foo" 5271 : /* no outputs */ 5272 : "g" (from), "g" (to) 5273 : "r9", "r10"); 5274@end smallexample 5275 5276Unless an output operand has the @samp{&} constraint modifier, GCC 5277may allocate it in the same register as an unrelated input operand, on 5278the assumption the inputs are consumed before the outputs are produced. 5279This assumption may be false if the assembler code actually consists of 5280more than one instruction. In such a case, use @samp{&} for each output 5281operand that may not overlap an input. @xref{Modifiers}. 5282 5283If you want to test the condition code produced by an assembler 5284instruction, you must include a branch and a label in the @code{asm} 5285construct, as follows: 5286 5287@smallexample 5288asm ("clr %0\n\tfrob %1\n\tbeq 0f\n\tmov #1,%0\n0:" 5289 : "g" (result) 5290 : "g" (input)); 5291@end smallexample 5292 5293@noindent 5294This assumes your assembler supports local labels, as the GNU assembler 5295and most Unix assemblers do. 5296 5297Speaking of labels, jumps from one @code{asm} to another are not 5298supported. The compiler's optimizers do not know about these jumps, and 5299therefore they cannot take account of them when deciding how to 5300optimize. @xref{Extended asm with goto}. 5301 5302@cindex macros containing @code{asm} 5303Usually the most convenient way to use these @code{asm} instructions is to 5304encapsulate them in macros that look like functions. For example, 5305 5306@smallexample 5307#define sin(x) \ 5308(@{ double __value, __arg = (x); \ 5309 asm ("fsinx %1,%0": "=f" (__value): "f" (__arg)); \ 5310 __value; @}) 5311@end smallexample 5312 5313@noindent 5314Here the variable @code{__arg} is used to make sure that the instruction 5315operates on a proper @code{double} value, and to accept only those 5316arguments @code{x} which can convert automatically to a @code{double}. 5317 5318Another way to make sure the instruction operates on the correct data 5319type is to use a cast in the @code{asm}. This is different from using a 5320variable @code{__arg} in that it converts more different types. For 5321example, if the desired type were @code{int}, casting the argument to 5322@code{int} would accept a pointer with no complaint, while assigning the 5323argument to an @code{int} variable named @code{__arg} would warn about 5324using a pointer unless the caller explicitly casts it. 5325 5326If an @code{asm} has output operands, GCC assumes for optimization 5327purposes the instruction has no side effects except to change the output 5328operands. This does not mean instructions with a side effect cannot be 5329used, but you must be careful, because the compiler may eliminate them 5330if the output operands aren't used, or move them out of loops, or 5331replace two with one if they constitute a common subexpression. Also, 5332if your instruction does have a side effect on a variable that otherwise 5333appears not to change, the old value of the variable may be reused later 5334if it happens to be found in a register. 5335 5336You can prevent an @code{asm} instruction from being deleted 5337by writing the keyword @code{volatile} after 5338the @code{asm}. For example: 5339 5340@smallexample 5341#define get_and_set_priority(new) \ 5342(@{ int __old; \ 5343 asm volatile ("get_and_set_priority %0, %1" \ 5344 : "=g" (__old) : "g" (new)); \ 5345 __old; @}) 5346@end smallexample 5347 5348@noindent 5349The @code{volatile} keyword indicates that the instruction has 5350important side-effects. GCC will not delete a volatile @code{asm} if 5351it is reachable. (The instruction can still be deleted if GCC can 5352prove that control-flow will never reach the location of the 5353instruction.) Note that even a volatile @code{asm} instruction 5354can be moved relative to other code, including across jump 5355instructions. For example, on many targets there is a system 5356register which can be set to control the rounding mode of 5357floating point operations. You might try 5358setting it with a volatile @code{asm}, like this PowerPC example: 5359 5360@smallexample 5361 asm volatile("mtfsf 255,%0" : : "f" (fpenv)); 5362 sum = x + y; 5363@end smallexample 5364 5365@noindent 5366This will not work reliably, as the compiler may move the addition back 5367before the volatile @code{asm}. To make it work you need to add an 5368artificial dependency to the @code{asm} referencing a variable in the code 5369you don't want moved, for example: 5370 5371@smallexample 5372 asm volatile ("mtfsf 255,%1" : "=X"(sum): "f"(fpenv)); 5373 sum = x + y; 5374@end smallexample 5375 5376Similarly, you can't expect a 5377sequence of volatile @code{asm} instructions to remain perfectly 5378consecutive. If you want consecutive output, use a single @code{asm}. 5379Also, GCC will perform some optimizations across a volatile @code{asm} 5380instruction; GCC does not ``forget everything'' when it encounters 5381a volatile @code{asm} instruction the way some other compilers do. 5382 5383An @code{asm} instruction without any output operands will be treated 5384identically to a volatile @code{asm} instruction. 5385 5386It is a natural idea to look for a way to give access to the condition 5387code left by the assembler instruction. However, when we attempted to 5388implement this, we found no way to make it work reliably. The problem 5389is that output operands might need reloading, which would result in 5390additional following ``store'' instructions. On most machines, these 5391instructions would alter the condition code before there was time to 5392test it. This problem doesn't arise for ordinary ``test'' and 5393``compare'' instructions because they don't have any output operands. 5394 5395For reasons similar to those described above, it is not possible to give 5396an assembler instruction access to the condition code left by previous 5397instructions. 5398 5399@anchor{Extended asm with goto} 5400As of GCC version 4.5, @code{asm goto} may be used to have the assembly 5401jump to one or more C labels. In this form, a fifth section after the 5402clobber list contains a list of all C labels to which the assembly may jump. 5403Each label operand is implicitly self-named. The @code{asm} is also assumed 5404to fall through to the next statement. 5405 5406This form of @code{asm} is restricted to not have outputs. This is due 5407to a internal restriction in the compiler that control transfer instructions 5408cannot have outputs. This restriction on @code{asm goto} may be lifted 5409in some future version of the compiler. In the mean time, @code{asm goto} 5410may include a memory clobber, and so leave outputs in memory. 5411 5412@smallexample 5413int frob(int x) 5414@{ 5415 int y; 5416 asm goto ("frob %%r5, %1; jc %l[error]; mov (%2), %%r5" 5417 : : "r"(x), "r"(&y) : "r5", "memory" : error); 5418 return y; 5419 error: 5420 return -1; 5421@} 5422@end smallexample 5423 5424In this (inefficient) example, the @code{frob} instruction sets the 5425carry bit to indicate an error. The @code{jc} instruction detects 5426this and branches to the @code{error} label. Finally, the output 5427of the @code{frob} instruction (@code{%r5}) is stored into the memory 5428for variable @code{y}, which is later read by the @code{return} statement. 5429 5430@smallexample 5431void doit(void) 5432@{ 5433 int i = 0; 5434 asm goto ("mfsr %%r1, 123; jmp %%r1;" 5435 ".pushsection doit_table;" 5436 ".long %l0, %l1, %l2, %l3;" 5437 ".popsection" 5438 : : : "r1" : label1, label2, label3, label4); 5439 __builtin_unreachable (); 5440 5441 label1: 5442 f1(); 5443 return; 5444 label2: 5445 f2(); 5446 return; 5447 label3: 5448 i = 1; 5449 label4: 5450 f3(i); 5451@} 5452@end smallexample 5453 5454In this (also inefficient) example, the @code{mfsr} instruction reads 5455an address from some out-of-band machine register, and the following 5456@code{jmp} instruction branches to that address. The address read by 5457the @code{mfsr} instruction is assumed to have been previously set via 5458some application-specific mechanism to be one of the four values stored 5459in the @code{doit_table} section. Finally, the @code{asm} is followed 5460by a call to @code{__builtin_unreachable} to indicate that the @code{asm} 5461does not in fact fall through. 5462 5463@smallexample 5464#define TRACE1(NUM) \ 5465 do @{ \ 5466 asm goto ("0: nop;" \ 5467 ".pushsection trace_table;" \ 5468 ".long 0b, %l0;" \ 5469 ".popsection" \ 5470 : : : : trace#NUM); \ 5471 if (0) @{ trace#NUM: trace(); @} \ 5472 @} while (0) 5473#define TRACE TRACE1(__COUNTER__) 5474@end smallexample 5475 5476In this example (which in fact inspired the @code{asm goto} feature) 5477we want on rare occasions to call the @code{trace} function; on other 5478occasions we'd like to keep the overhead to the absolute minimum. 5479The normal code path consists of a single @code{nop} instruction. 5480However, we record the address of this @code{nop} together with the 5481address of a label that calls the @code{trace} function. This allows 5482the @code{nop} instruction to be patched at runtime to be an 5483unconditional branch to the stored label. It is assumed that an 5484optimizing compiler will move the labeled block out of line, to 5485optimize the fall through path from the @code{asm}. 5486 5487If you are writing a header file that should be includable in ISO C 5488programs, write @code{__asm__} instead of @code{asm}. @xref{Alternate 5489Keywords}. 5490 5491@subsection Size of an @code{asm} 5492 5493Some targets require that GCC track the size of each instruction used in 5494order to generate correct code. Because the final length of an 5495@code{asm} is only known by the assembler, GCC must make an estimate as 5496to how big it will be. The estimate is formed by counting the number of 5497statements in the pattern of the @code{asm} and multiplying that by the 5498length of the longest instruction on that processor. Statements in the 5499@code{asm} are identified by newline characters and whatever statement 5500separator characters are supported by the assembler; on most processors 5501this is the `@code{;}' character. 5502 5503Normally, GCC's estimate is perfectly adequate to ensure that correct 5504code is generated, but it is possible to confuse the compiler if you use 5505pseudo instructions or assembler macros that expand into multiple real 5506instructions or if you use assembler directives that expand to more 5507space in the object file than would be needed for a single instruction. 5508If this happens then the assembler will produce a diagnostic saying that 5509a label is unreachable. 5510 5511@subsection i386 floating point asm operands 5512 5513There are several rules on the usage of stack-like regs in 5514asm_operands insns. These rules apply only to the operands that are 5515stack-like regs: 5516 5517@enumerate 5518@item 5519Given a set of input regs that die in an asm_operands, it is 5520necessary to know which are implicitly popped by the asm, and 5521which must be explicitly popped by gcc. 5522 5523An input reg that is implicitly popped by the asm must be 5524explicitly clobbered, unless it is constrained to match an 5525output operand. 5526 5527@item 5528For any input reg that is implicitly popped by an asm, it is 5529necessary to know how to adjust the stack to compensate for the pop. 5530If any non-popped input is closer to the top of the reg-stack than 5531the implicitly popped reg, it would not be possible to know what the 5532stack looked like---it's not clear how the rest of the stack ``slides 5533up''. 5534 5535All implicitly popped input regs must be closer to the top of 5536the reg-stack than any input that is not implicitly popped. 5537 5538It is possible that if an input dies in an insn, reload might 5539use the input reg for an output reload. Consider this example: 5540 5541@smallexample 5542asm ("foo" : "=t" (a) : "f" (b)); 5543@end smallexample 5544 5545This asm says that input B is not popped by the asm, and that 5546the asm pushes a result onto the reg-stack, i.e., the stack is one 5547deeper after the asm than it was before. But, it is possible that 5548reload will think that it can use the same reg for both the input and 5549the output, if input B dies in this insn. 5550 5551If any input operand uses the @code{f} constraint, all output reg 5552constraints must use the @code{&} earlyclobber. 5553 5554The asm above would be written as 5555 5556@smallexample 5557asm ("foo" : "=&t" (a) : "f" (b)); 5558@end smallexample 5559 5560@item 5561Some operands need to be in particular places on the stack. All 5562output operands fall in this category---there is no other way to 5563know which regs the outputs appear in unless the user indicates 5564this in the constraints. 5565 5566Output operands must specifically indicate which reg an output 5567appears in after an asm. @code{=f} is not allowed: the operand 5568constraints must select a class with a single reg. 5569 5570@item 5571Output operands may not be ``inserted'' between existing stack regs. 5572Since no 387 opcode uses a read/write operand, all output operands 5573are dead before the asm_operands, and are pushed by the asm_operands. 5574It makes no sense to push anywhere but the top of the reg-stack. 5575 5576Output operands must start at the top of the reg-stack: output 5577operands may not ``skip'' a reg. 5578 5579@item 5580Some asm statements may need extra stack space for internal 5581calculations. This can be guaranteed by clobbering stack registers 5582unrelated to the inputs and outputs. 5583 5584@end enumerate 5585 5586Here are a couple of reasonable asms to want to write. This asm 5587takes one input, which is internally popped, and produces two outputs. 5588 5589@smallexample 5590asm ("fsincos" : "=t" (cos), "=u" (sin) : "0" (inp)); 5591@end smallexample 5592 5593This asm takes two inputs, which are popped by the @code{fyl2xp1} opcode, 5594and replaces them with one output. The user must code the @code{st(1)} 5595clobber for reg-stack.c to know that @code{fyl2xp1} pops both inputs. 5596 5597@smallexample 5598asm ("fyl2xp1" : "=t" (result) : "0" (x), "u" (y) : "st(1)"); 5599@end smallexample 5600 5601@include md.texi 5602 5603@node Asm Labels 5604@section Controlling Names Used in Assembler Code 5605@cindex assembler names for identifiers 5606@cindex names used in assembler code 5607@cindex identifiers, names in assembler code 5608 5609You can specify the name to be used in the assembler code for a C 5610function or variable by writing the @code{asm} (or @code{__asm__}) 5611keyword after the declarator as follows: 5612 5613@smallexample 5614int foo asm ("myfoo") = 2; 5615@end smallexample 5616 5617@noindent 5618This specifies that the name to be used for the variable @code{foo} in 5619the assembler code should be @samp{myfoo} rather than the usual 5620@samp{_foo}. 5621 5622On systems where an underscore is normally prepended to the name of a C 5623function or variable, this feature allows you to define names for the 5624linker that do not start with an underscore. 5625 5626It does not make sense to use this feature with a non-static local 5627variable since such variables do not have assembler names. If you are 5628trying to put the variable in a particular register, see @ref{Explicit 5629Reg Vars}. GCC presently accepts such code with a warning, but will 5630probably be changed to issue an error, rather than a warning, in the 5631future. 5632 5633You cannot use @code{asm} in this way in a function @emph{definition}; but 5634you can get the same effect by writing a declaration for the function 5635before its definition and putting @code{asm} there, like this: 5636 5637@smallexample 5638extern func () asm ("FUNC"); 5639 5640func (x, y) 5641 int x, y; 5642/* @r{@dots{}} */ 5643@end smallexample 5644 5645It is up to you to make sure that the assembler names you choose do not 5646conflict with any other assembler symbols. Also, you must not use a 5647register name; that would produce completely invalid assembler code. GCC 5648does not as yet have the ability to store static variables in registers. 5649Perhaps that will be added. 5650 5651@node Explicit Reg Vars 5652@section Variables in Specified Registers 5653@cindex explicit register variables 5654@cindex variables in specified registers 5655@cindex specified registers 5656@cindex registers, global allocation 5657 5658GNU C allows you to put a few global variables into specified hardware 5659registers. You can also specify the register in which an ordinary 5660register variable should be allocated. 5661 5662@itemize @bullet 5663@item 5664Global register variables reserve registers throughout the program. 5665This may be useful in programs such as programming language 5666interpreters which have a couple of global variables that are accessed 5667very often. 5668 5669@item 5670Local register variables in specific registers do not reserve the 5671registers, except at the point where they are used as input or output 5672operands in an @code{asm} statement and the @code{asm} statement itself is 5673not deleted. The compiler's data flow analysis is capable of determining 5674where the specified registers contain live values, and where they are 5675available for other uses. Stores into local register variables may be deleted 5676when they appear to be dead according to dataflow analysis. References 5677to local register variables may be deleted or moved or simplified. 5678 5679These local variables are sometimes convenient for use with the extended 5680@code{asm} feature (@pxref{Extended Asm}), if you want to write one 5681output of the assembler instruction directly into a particular register. 5682(This will work provided the register you specify fits the constraints 5683specified for that operand in the @code{asm}.) 5684@end itemize 5685 5686@menu 5687* Global Reg Vars:: 5688* Local Reg Vars:: 5689@end menu 5690 5691@node Global Reg Vars 5692@subsection Defining Global Register Variables 5693@cindex global register variables 5694@cindex registers, global variables in 5695 5696You can define a global register variable in GNU C like this: 5697 5698@smallexample 5699register int *foo asm ("a5"); 5700@end smallexample 5701 5702@noindent 5703Here @code{a5} is the name of the register which should be used. Choose a 5704register which is normally saved and restored by function calls on your 5705machine, so that library routines will not clobber it. 5706 5707Naturally the register name is cpu-dependent, so you would need to 5708conditionalize your program according to cpu type. The register 5709@code{a5} would be a good choice on a 68000 for a variable of pointer 5710type. On machines with register windows, be sure to choose a ``global'' 5711register that is not affected magically by the function call mechanism. 5712 5713In addition, operating systems on one type of cpu may differ in how they 5714name the registers; then you would need additional conditionals. For 5715example, some 68000 operating systems call this register @code{%a5}. 5716 5717Eventually there may be a way of asking the compiler to choose a register 5718automatically, but first we need to figure out how it should choose and 5719how to enable you to guide the choice. No solution is evident. 5720 5721Defining a global register variable in a certain register reserves that 5722register entirely for this use, at least within the current compilation. 5723The register will not be allocated for any other purpose in the functions 5724in the current compilation. The register will not be saved and restored by 5725these functions. Stores into this register are never deleted even if they 5726would appear to be dead, but references may be deleted or moved or 5727simplified. 5728 5729It is not safe to access the global register variables from signal 5730handlers, or from more than one thread of control, because the system 5731library routines may temporarily use the register for other things (unless 5732you recompile them specially for the task at hand). 5733 5734@cindex @code{qsort}, and global register variables 5735It is not safe for one function that uses a global register variable to 5736call another such function @code{foo} by way of a third function 5737@code{lose} that was compiled without knowledge of this variable (i.e.@: in a 5738different source file in which the variable wasn't declared). This is 5739because @code{lose} might save the register and put some other value there. 5740For example, you can't expect a global register variable to be available in 5741the comparison-function that you pass to @code{qsort}, since @code{qsort} 5742might have put something else in that register. (If you are prepared to 5743recompile @code{qsort} with the same global register variable, you can 5744solve this problem.) 5745 5746If you want to recompile @code{qsort} or other source files which do not 5747actually use your global register variable, so that they will not use that 5748register for any other purpose, then it suffices to specify the compiler 5749option @option{-ffixed-@var{reg}}. You need not actually add a global 5750register declaration to their source code. 5751 5752A function which can alter the value of a global register variable cannot 5753safely be called from a function compiled without this variable, because it 5754could clobber the value the caller expects to find there on return. 5755Therefore, the function which is the entry point into the part of the 5756program that uses the global register variable must explicitly save and 5757restore the value which belongs to its caller. 5758 5759@cindex register variable after @code{longjmp} 5760@cindex global register after @code{longjmp} 5761@cindex value after @code{longjmp} 5762@findex longjmp 5763@findex setjmp 5764On most machines, @code{longjmp} will restore to each global register 5765variable the value it had at the time of the @code{setjmp}. On some 5766machines, however, @code{longjmp} will not change the value of global 5767register variables. To be portable, the function that called @code{setjmp} 5768should make other arrangements to save the values of the global register 5769variables, and to restore them in a @code{longjmp}. This way, the same 5770thing will happen regardless of what @code{longjmp} does. 5771 5772All global register variable declarations must precede all function 5773definitions. If such a declaration could appear after function 5774definitions, the declaration would be too late to prevent the register from 5775being used for other purposes in the preceding functions. 5776 5777Global register variables may not have initial values, because an 5778executable file has no means to supply initial contents for a register. 5779 5780On the SPARC, there are reports that g3 @dots{} g7 are suitable 5781registers, but certain library functions, such as @code{getwd}, as well 5782as the subroutines for division and remainder, modify g3 and g4. g1 and 5783g2 are local temporaries. 5784 5785On the 68000, a2 @dots{} a5 should be suitable, as should d2 @dots{} d7. 5786Of course, it will not do to use more than a few of those. 5787 5788@node Local Reg Vars 5789@subsection Specifying Registers for Local Variables 5790@cindex local variables, specifying registers 5791@cindex specifying registers for local variables 5792@cindex registers for local variables 5793 5794You can define a local register variable with a specified register 5795like this: 5796 5797@smallexample 5798register int *foo asm ("a5"); 5799@end smallexample 5800 5801@noindent 5802Here @code{a5} is the name of the register which should be used. Note 5803that this is the same syntax used for defining global register 5804variables, but for a local variable it would appear within a function. 5805 5806Naturally the register name is cpu-dependent, but this is not a 5807problem, since specific registers are most often useful with explicit 5808assembler instructions (@pxref{Extended Asm}). Both of these things 5809generally require that you conditionalize your program according to 5810cpu type. 5811 5812In addition, operating systems on one type of cpu may differ in how they 5813name the registers; then you would need additional conditionals. For 5814example, some 68000 operating systems call this register @code{%a5}. 5815 5816Defining such a register variable does not reserve the register; it 5817remains available for other uses in places where flow control determines 5818the variable's value is not live. 5819 5820This option does not guarantee that GCC will generate code that has 5821this variable in the register you specify at all times. You may not 5822code an explicit reference to this register in the @emph{assembler 5823instruction template} part of an @code{asm} statement and assume it will 5824always refer to this variable. However, using the variable as an 5825@code{asm} @emph{operand} guarantees that the specified register is used 5826for the operand. 5827 5828Stores into local register variables may be deleted when they appear to be dead 5829according to dataflow analysis. References to local register variables may 5830be deleted or moved or simplified. 5831 5832As for global register variables, it's recommended that you choose a 5833register which is normally saved and restored by function calls on 5834your machine, so that library routines will not clobber it. A common 5835pitfall is to initialize multiple call-clobbered registers with 5836arbitrary expressions, where a function call or library call for an 5837arithmetic operator will overwrite a register value from a previous 5838assignment, for example @code{r0} below: 5839@smallexample 5840register int *p1 asm ("r0") = @dots{}; 5841register int *p2 asm ("r1") = @dots{}; 5842@end smallexample 5843In those cases, a solution is to use a temporary variable for 5844each arbitrary expression. @xref{Example of asm with clobbered asm reg}. 5845 5846@node Alternate Keywords 5847@section Alternate Keywords 5848@cindex alternate keywords 5849@cindex keywords, alternate 5850 5851@option{-ansi} and the various @option{-std} options disable certain 5852keywords. This causes trouble when you want to use GNU C extensions, or 5853a general-purpose header file that should be usable by all programs, 5854including ISO C programs. The keywords @code{asm}, @code{typeof} and 5855@code{inline} are not available in programs compiled with 5856@option{-ansi} or @option{-std} (although @code{inline} can be used in a 5857program compiled with @option{-std=c99}). The ISO C99 keyword 5858@code{restrict} is only available when @option{-std=gnu99} (which will 5859eventually be the default) or @option{-std=c99} (or the equivalent 5860@option{-std=iso9899:1999}) is used. 5861 5862The way to solve these problems is to put @samp{__} at the beginning and 5863end of each problematical keyword. For example, use @code{__asm__} 5864instead of @code{asm}, and @code{__inline__} instead of @code{inline}. 5865 5866Other C compilers won't accept these alternative keywords; if you want to 5867compile with another compiler, you can define the alternate keywords as 5868macros to replace them with the customary keywords. It looks like this: 5869 5870@smallexample 5871#ifndef __GNUC__ 5872#define __asm__ asm 5873#endif 5874@end smallexample 5875 5876@findex __extension__ 5877@opindex pedantic 5878@option{-pedantic} and other options cause warnings for many GNU C extensions. 5879You can 5880prevent such warnings within one expression by writing 5881@code{__extension__} before the expression. @code{__extension__} has no 5882effect aside from this. 5883 5884@node Incomplete Enums 5885@section Incomplete @code{enum} Types 5886 5887You can define an @code{enum} tag without specifying its possible values. 5888This results in an incomplete type, much like what you get if you write 5889@code{struct foo} without describing the elements. A later declaration 5890which does specify the possible values completes the type. 5891 5892You can't allocate variables or storage using the type while it is 5893incomplete. However, you can work with pointers to that type. 5894 5895This extension may not be very useful, but it makes the handling of 5896@code{enum} more consistent with the way @code{struct} and @code{union} 5897are handled. 5898 5899This extension is not supported by GNU C++. 5900 5901@node Function Names 5902@section Function Names as Strings 5903@cindex @code{__func__} identifier 5904@cindex @code{__FUNCTION__} identifier 5905@cindex @code{__PRETTY_FUNCTION__} identifier 5906 5907GCC provides three magic variables which hold the name of the current 5908function, as a string. The first of these is @code{__func__}, which 5909is part of the C99 standard: 5910 5911The identifier @code{__func__} is implicitly declared by the translator 5912as if, immediately following the opening brace of each function 5913definition, the declaration 5914 5915@smallexample 5916static const char __func__[] = "function-name"; 5917@end smallexample 5918 5919@noindent 5920appeared, where function-name is the name of the lexically-enclosing 5921function. This name is the unadorned name of the function. 5922 5923@code{__FUNCTION__} is another name for @code{__func__}. Older 5924versions of GCC recognize only this name. However, it is not 5925standardized. For maximum portability, we recommend you use 5926@code{__func__}, but provide a fallback definition with the 5927preprocessor: 5928 5929@smallexample 5930#if __STDC_VERSION__ < 199901L 5931# if __GNUC__ >= 2 5932# define __func__ __FUNCTION__ 5933# else 5934# define __func__ "<unknown>" 5935# endif 5936#endif 5937@end smallexample 5938 5939In C, @code{__PRETTY_FUNCTION__} is yet another name for 5940@code{__func__}. However, in C++, @code{__PRETTY_FUNCTION__} contains 5941the type signature of the function as well as its bare name. For 5942example, this program: 5943 5944@smallexample 5945extern "C" @{ 5946extern int printf (char *, ...); 5947@} 5948 5949class a @{ 5950 public: 5951 void sub (int i) 5952 @{ 5953 printf ("__FUNCTION__ = %s\n", __FUNCTION__); 5954 printf ("__PRETTY_FUNCTION__ = %s\n", __PRETTY_FUNCTION__); 5955 @} 5956@}; 5957 5958int 5959main (void) 5960@{ 5961 a ax; 5962 ax.sub (0); 5963 return 0; 5964@} 5965@end smallexample 5966 5967@noindent 5968gives this output: 5969 5970@smallexample 5971__FUNCTION__ = sub 5972__PRETTY_FUNCTION__ = void a::sub(int) 5973@end smallexample 5974 5975These identifiers are not preprocessor macros. In GCC 3.3 and 5976earlier, in C only, @code{__FUNCTION__} and @code{__PRETTY_FUNCTION__} 5977were treated as string literals; they could be used to initialize 5978@code{char} arrays, and they could be concatenated with other string 5979literals. GCC 3.4 and later treat them as variables, like 5980@code{__func__}. In C++, @code{__FUNCTION__} and 5981@code{__PRETTY_FUNCTION__} have always been variables. 5982 5983@node Return Address 5984@section Getting the Return or Frame Address of a Function 5985 5986These functions may be used to get information about the callers of a 5987function. 5988 5989@deftypefn {Built-in Function} {void *} __builtin_return_address (unsigned int @var{level}) 5990This function returns the return address of the current function, or of 5991one of its callers. The @var{level} argument is number of frames to 5992scan up the call stack. A value of @code{0} yields the return address 5993of the current function, a value of @code{1} yields the return address 5994of the caller of the current function, and so forth. When inlining 5995the expected behavior is that the function will return the address of 5996the function that will be returned to. To work around this behavior use 5997the @code{noinline} function attribute. 5998 5999The @var{level} argument must be a constant integer. 6000 6001On some machines it may be impossible to determine the return address of 6002any function other than the current one; in such cases, or when the top 6003of the stack has been reached, this function will return @code{0} or a 6004random value. In addition, @code{__builtin_frame_address} may be used 6005to determine if the top of the stack has been reached. 6006 6007Additional post-processing of the returned value may be needed, see 6008@code{__builtin_extract_return_address}. 6009 6010This function should only be used with a nonzero argument for debugging 6011purposes. 6012@end deftypefn 6013 6014@deftypefn {Built-in Function} {void *} __builtin_extract_return_address (void *@var{addr}) 6015The address as returned by @code{__builtin_return_address} may have to be fed 6016through this function to get the actual encoded address. For example, on the 601731-bit S/390 platform the highest bit has to be masked out, or on SPARC 6018platforms an offset has to be added for the true next instruction to be 6019executed. 6020 6021If no fixup is needed, this function simply passes through @var{addr}. 6022@end deftypefn 6023 6024@deftypefn {Built-in Function} {void *} __builtin_frob_return_address (void *@var{addr}) 6025This function does the reverse of @code{__builtin_extract_return_address}. 6026@end deftypefn 6027 6028@deftypefn {Built-in Function} {void *} __builtin_frame_address (unsigned int @var{level}) 6029This function is similar to @code{__builtin_return_address}, but it 6030returns the address of the function frame rather than the return address 6031of the function. Calling @code{__builtin_frame_address} with a value of 6032@code{0} yields the frame address of the current function, a value of 6033@code{1} yields the frame address of the caller of the current function, 6034and so forth. 6035 6036The frame is the area on the stack which holds local variables and saved 6037registers. The frame address is normally the address of the first word 6038pushed on to the stack by the function. However, the exact definition 6039depends upon the processor and the calling convention. If the processor 6040has a dedicated frame pointer register, and the function has a frame, 6041then @code{__builtin_frame_address} will return the value of the frame 6042pointer register. 6043 6044On some machines it may be impossible to determine the frame address of 6045any function other than the current one; in such cases, or when the top 6046of the stack has been reached, this function will return @code{0} if 6047the first frame pointer is properly initialized by the startup code. 6048 6049This function should only be used with a nonzero argument for debugging 6050purposes. 6051@end deftypefn 6052 6053@node Vector Extensions 6054@section Using vector instructions through built-in functions 6055 6056On some targets, the instruction set contains SIMD vector instructions that 6057operate on multiple values contained in one large register at the same time. 6058For example, on the i386 the MMX, 3DNow!@: and SSE extensions can be used 6059this way. 6060 6061The first step in using these extensions is to provide the necessary data 6062types. This should be done using an appropriate @code{typedef}: 6063 6064@smallexample 6065typedef int v4si __attribute__ ((vector_size (16))); 6066@end smallexample 6067 6068The @code{int} type specifies the base type, while the attribute specifies 6069the vector size for the variable, measured in bytes. For example, the 6070declaration above causes the compiler to set the mode for the @code{v4si} 6071type to be 16 bytes wide and divided into @code{int} sized units. For 6072a 32-bit @code{int} this means a vector of 4 units of 4 bytes, and the 6073corresponding mode of @code{foo} will be @acronym{V4SI}. 6074 6075The @code{vector_size} attribute is only applicable to integral and 6076float scalars, although arrays, pointers, and function return values 6077are allowed in conjunction with this construct. 6078 6079All the basic integer types can be used as base types, both as signed 6080and as unsigned: @code{char}, @code{short}, @code{int}, @code{long}, 6081@code{long long}. In addition, @code{float} and @code{double} can be 6082used to build floating-point vector types. 6083 6084Specifying a combination that is not valid for the current architecture 6085will cause GCC to synthesize the instructions using a narrower mode. 6086For example, if you specify a variable of type @code{V4SI} and your 6087architecture does not allow for this specific SIMD type, GCC will 6088produce code that uses 4 @code{SIs}. 6089 6090The types defined in this manner can be used with a subset of normal C 6091operations. Currently, GCC will allow using the following operators 6092on these types: @code{+, -, *, /, unary minus, ^, |, &, ~, %}@. 6093 6094The operations behave like C++ @code{valarrays}. Addition is defined as 6095the addition of the corresponding elements of the operands. For 6096example, in the code below, each of the 4 elements in @var{a} will be 6097added to the corresponding 4 elements in @var{b} and the resulting 6098vector will be stored in @var{c}. 6099 6100@smallexample 6101typedef int v4si __attribute__ ((vector_size (16))); 6102 6103v4si a, b, c; 6104 6105c = a + b; 6106@end smallexample 6107 6108Subtraction, multiplication, division, and the logical operations 6109operate in a similar manner. Likewise, the result of using the unary 6110minus or complement operators on a vector type is a vector whose 6111elements are the negative or complemented values of the corresponding 6112elements in the operand. 6113 6114You can declare variables and use them in function calls and returns, as 6115well as in assignments and some casts. You can specify a vector type as 6116a return type for a function. Vector types can also be used as function 6117arguments. It is possible to cast from one vector type to another, 6118provided they are of the same size (in fact, you can also cast vectors 6119to and from other datatypes of the same size). 6120 6121You cannot operate between vectors of different lengths or different 6122signedness without a cast. 6123 6124A port that supports hardware vector operations, usually provides a set 6125of built-in functions that can be used to operate on vectors. For 6126example, a function to add two vectors and multiply the result by a 6127third could look like this: 6128 6129@smallexample 6130v4si f (v4si a, v4si b, v4si c) 6131@{ 6132 v4si tmp = __builtin_addv4si (a, b); 6133 return __builtin_mulv4si (tmp, c); 6134@} 6135 6136@end smallexample 6137 6138@node Offsetof 6139@section Offsetof 6140@findex __builtin_offsetof 6141 6142GCC implements for both C and C++ a syntactic extension to implement 6143the @code{offsetof} macro. 6144 6145@smallexample 6146primary: 6147 "__builtin_offsetof" "(" @code{typename} "," offsetof_member_designator ")" 6148 6149offsetof_member_designator: 6150 @code{identifier} 6151 | offsetof_member_designator "." @code{identifier} 6152 | offsetof_member_designator "[" @code{expr} "]" 6153@end smallexample 6154 6155This extension is sufficient such that 6156 6157@smallexample 6158#define offsetof(@var{type}, @var{member}) __builtin_offsetof (@var{type}, @var{member}) 6159@end smallexample 6160 6161is a suitable definition of the @code{offsetof} macro. In C++, @var{type} 6162may be dependent. In either case, @var{member} may consist of a single 6163identifier, or a sequence of member accesses and array references. 6164 6165@node Atomic Builtins 6166@section Built-in functions for atomic memory access 6167 6168The following builtins are intended to be compatible with those described 6169in the @cite{Intel Itanium Processor-specific Application Binary Interface}, 6170section 7.4. As such, they depart from the normal GCC practice of using 6171the ``__builtin_'' prefix, and further that they are overloaded such that 6172they work on multiple types. 6173 6174The definition given in the Intel documentation allows only for the use of 6175the types @code{int}, @code{long}, @code{long long} as well as their unsigned 6176counterparts. GCC will allow any integral scalar or pointer type that is 61771, 2, 4 or 8 bytes in length. 6178 6179Not all operations are supported by all target processors. If a particular 6180operation cannot be implemented on the target processor, a warning will be 6181generated and a call an external function will be generated. The external 6182function will carry the same name as the builtin, with an additional suffix 6183@samp{_@var{n}} where @var{n} is the size of the data type. 6184 6185@c ??? Should we have a mechanism to suppress this warning? This is almost 6186@c useful for implementing the operation under the control of an external 6187@c mutex. 6188 6189In most cases, these builtins are considered a @dfn{full barrier}. That is, 6190no memory operand will be moved across the operation, either forward or 6191backward. Further, instructions will be issued as necessary to prevent the 6192processor from speculating loads across the operation and from queuing stores 6193after the operation. 6194 6195All of the routines are described in the Intel documentation to take 6196``an optional list of variables protected by the memory barrier''. It's 6197not clear what is meant by that; it could mean that @emph{only} the 6198following variables are protected, or it could mean that these variables 6199should in addition be protected. At present GCC ignores this list and 6200protects all variables which are globally accessible. If in the future 6201we make some use of this list, an empty list will continue to mean all 6202globally accessible variables. 6203 6204@table @code 6205@item @var{type} __sync_fetch_and_add (@var{type} *ptr, @var{type} value, ...) 6206@itemx @var{type} __sync_fetch_and_sub (@var{type} *ptr, @var{type} value, ...) 6207@itemx @var{type} __sync_fetch_and_or (@var{type} *ptr, @var{type} value, ...) 6208@itemx @var{type} __sync_fetch_and_and (@var{type} *ptr, @var{type} value, ...) 6209@itemx @var{type} __sync_fetch_and_xor (@var{type} *ptr, @var{type} value, ...) 6210@itemx @var{type} __sync_fetch_and_nand (@var{type} *ptr, @var{type} value, ...) 6211@findex __sync_fetch_and_add 6212@findex __sync_fetch_and_sub 6213@findex __sync_fetch_and_or 6214@findex __sync_fetch_and_and 6215@findex __sync_fetch_and_xor 6216@findex __sync_fetch_and_nand 6217These builtins perform the operation suggested by the name, and 6218returns the value that had previously been in memory. That is, 6219 6220@smallexample 6221@{ tmp = *ptr; *ptr @var{op}= value; return tmp; @} 6222@{ tmp = *ptr; *ptr = ~(tmp & value); return tmp; @} // nand 6223@end smallexample 6224 6225@emph{Note:} GCC 4.4 and later implement @code{__sync_fetch_and_nand} 6226builtin as @code{*ptr = ~(tmp & value)} instead of @code{*ptr = ~tmp & value}. 6227 6228@item @var{type} __sync_add_and_fetch (@var{type} *ptr, @var{type} value, ...) 6229@itemx @var{type} __sync_sub_and_fetch (@var{type} *ptr, @var{type} value, ...) 6230@itemx @var{type} __sync_or_and_fetch (@var{type} *ptr, @var{type} value, ...) 6231@itemx @var{type} __sync_and_and_fetch (@var{type} *ptr, @var{type} value, ...) 6232@itemx @var{type} __sync_xor_and_fetch (@var{type} *ptr, @var{type} value, ...) 6233@itemx @var{type} __sync_nand_and_fetch (@var{type} *ptr, @var{type} value, ...) 6234@findex __sync_add_and_fetch 6235@findex __sync_sub_and_fetch 6236@findex __sync_or_and_fetch 6237@findex __sync_and_and_fetch 6238@findex __sync_xor_and_fetch 6239@findex __sync_nand_and_fetch 6240These builtins perform the operation suggested by the name, and 6241return the new value. That is, 6242 6243@smallexample 6244@{ *ptr @var{op}= value; return *ptr; @} 6245@{ *ptr = ~(*ptr & value); return *ptr; @} // nand 6246@end smallexample 6247 6248@emph{Note:} GCC 4.4 and later implement @code{__sync_nand_and_fetch} 6249builtin as @code{*ptr = ~(*ptr & value)} instead of 6250@code{*ptr = ~*ptr & value}. 6251 6252@item bool __sync_bool_compare_and_swap (@var{type} *ptr, @var{type} oldval @var{type} newval, ...) 6253@itemx @var{type} __sync_val_compare_and_swap (@var{type} *ptr, @var{type} oldval @var{type} newval, ...) 6254@findex __sync_bool_compare_and_swap 6255@findex __sync_val_compare_and_swap 6256These builtins perform an atomic compare and swap. That is, if the current 6257value of @code{*@var{ptr}} is @var{oldval}, then write @var{newval} into 6258@code{*@var{ptr}}. 6259 6260The ``bool'' version returns true if the comparison is successful and 6261@var{newval} was written. The ``val'' version returns the contents 6262of @code{*@var{ptr}} before the operation. 6263 6264@item __sync_synchronize (...) 6265@findex __sync_synchronize 6266This builtin issues a full memory barrier. 6267 6268@item @var{type} __sync_lock_test_and_set (@var{type} *ptr, @var{type} value, ...) 6269@findex __sync_lock_test_and_set 6270This builtin, as described by Intel, is not a traditional test-and-set 6271operation, but rather an atomic exchange operation. It writes @var{value} 6272into @code{*@var{ptr}}, and returns the previous contents of 6273@code{*@var{ptr}}. 6274 6275Many targets have only minimal support for such locks, and do not support 6276a full exchange operation. In this case, a target may support reduced 6277functionality here by which the @emph{only} valid value to store is the 6278immediate constant 1. The exact value actually stored in @code{*@var{ptr}} 6279is implementation defined. 6280 6281This builtin is not a full barrier, but rather an @dfn{acquire barrier}. 6282This means that references after the builtin cannot move to (or be 6283speculated to) before the builtin, but previous memory stores may not 6284be globally visible yet, and previous memory loads may not yet be 6285satisfied. 6286 6287@item void __sync_lock_release (@var{type} *ptr, ...) 6288@findex __sync_lock_release 6289This builtin releases the lock acquired by @code{__sync_lock_test_and_set}. 6290Normally this means writing the constant 0 to @code{*@var{ptr}}. 6291 6292This builtin is not a full barrier, but rather a @dfn{release barrier}. 6293This means that all previous memory stores are globally visible, and all 6294previous memory loads have been satisfied, but following memory reads 6295are not prevented from being speculated to before the barrier. 6296@end table 6297 6298@node Object Size Checking 6299@section Object Size Checking Builtins 6300@findex __builtin_object_size 6301@findex __builtin___memcpy_chk 6302@findex __builtin___mempcpy_chk 6303@findex __builtin___memmove_chk 6304@findex __builtin___memset_chk 6305@findex __builtin___strcpy_chk 6306@findex __builtin___stpcpy_chk 6307@findex __builtin___strncpy_chk 6308@findex __builtin___strcat_chk 6309@findex __builtin___strncat_chk 6310@findex __builtin___sprintf_chk 6311@findex __builtin___snprintf_chk 6312@findex __builtin___vsprintf_chk 6313@findex __builtin___vsnprintf_chk 6314@findex __builtin___printf_chk 6315@findex __builtin___vprintf_chk 6316@findex __builtin___fprintf_chk 6317@findex __builtin___vfprintf_chk 6318 6319GCC implements a limited buffer overflow protection mechanism 6320that can prevent some buffer overflow attacks. 6321 6322@deftypefn {Built-in Function} {size_t} __builtin_object_size (void * @var{ptr}, int @var{type}) 6323is a built-in construct that returns a constant number of bytes from 6324@var{ptr} to the end of the object @var{ptr} pointer points to 6325(if known at compile time). @code{__builtin_object_size} never evaluates 6326its arguments for side-effects. If there are any side-effects in them, it 6327returns @code{(size_t) -1} for @var{type} 0 or 1 and @code{(size_t) 0} 6328for @var{type} 2 or 3. If there are multiple objects @var{ptr} can 6329point to and all of them are known at compile time, the returned number 6330is the maximum of remaining byte counts in those objects if @var{type} & 2 is 63310 and minimum if nonzero. If it is not possible to determine which objects 6332@var{ptr} points to at compile time, @code{__builtin_object_size} should 6333return @code{(size_t) -1} for @var{type} 0 or 1 and @code{(size_t) 0} 6334for @var{type} 2 or 3. 6335 6336@var{type} is an integer constant from 0 to 3. If the least significant 6337bit is clear, objects are whole variables, if it is set, a closest 6338surrounding subobject is considered the object a pointer points to. 6339The second bit determines if maximum or minimum of remaining bytes 6340is computed. 6341 6342@smallexample 6343struct V @{ char buf1[10]; int b; char buf2[10]; @} var; 6344char *p = &var.buf1[1], *q = &var.b; 6345 6346/* Here the object p points to is var. */ 6347assert (__builtin_object_size (p, 0) == sizeof (var) - 1); 6348/* The subobject p points to is var.buf1. */ 6349assert (__builtin_object_size (p, 1) == sizeof (var.buf1) - 1); 6350/* The object q points to is var. */ 6351assert (__builtin_object_size (q, 0) 6352 == (char *) (&var + 1) - (char *) &var.b); 6353/* The subobject q points to is var.b. */ 6354assert (__builtin_object_size (q, 1) == sizeof (var.b)); 6355@end smallexample 6356@end deftypefn 6357 6358There are built-in functions added for many common string operation 6359functions, e.g., for @code{memcpy} @code{__builtin___memcpy_chk} 6360built-in is provided. This built-in has an additional last argument, 6361which is the number of bytes remaining in object the @var{dest} 6362argument points to or @code{(size_t) -1} if the size is not known. 6363 6364The built-in functions are optimized into the normal string functions 6365like @code{memcpy} if the last argument is @code{(size_t) -1} or if 6366it is known at compile time that the destination object will not 6367be overflown. If the compiler can determine at compile time the 6368object will be always overflown, it issues a warning. 6369 6370The intended use can be e.g. 6371 6372@smallexample 6373#undef memcpy 6374#define bos0(dest) __builtin_object_size (dest, 0) 6375#define memcpy(dest, src, n) \ 6376 __builtin___memcpy_chk (dest, src, n, bos0 (dest)) 6377 6378char *volatile p; 6379char buf[10]; 6380/* It is unknown what object p points to, so this is optimized 6381 into plain memcpy - no checking is possible. */ 6382memcpy (p, "abcde", n); 6383/* Destination is known and length too. It is known at compile 6384 time there will be no overflow. */ 6385memcpy (&buf[5], "abcde", 5); 6386/* Destination is known, but the length is not known at compile time. 6387 This will result in __memcpy_chk call that can check for overflow 6388 at runtime. */ 6389memcpy (&buf[5], "abcde", n); 6390/* Destination is known and it is known at compile time there will 6391 be overflow. There will be a warning and __memcpy_chk call that 6392 will abort the program at runtime. */ 6393memcpy (&buf[6], "abcde", 5); 6394@end smallexample 6395 6396Such built-in functions are provided for @code{memcpy}, @code{mempcpy}, 6397@code{memmove}, @code{memset}, @code{strcpy}, @code{stpcpy}, @code{strncpy}, 6398@code{strcat} and @code{strncat}. 6399 6400There are also checking built-in functions for formatted output functions. 6401@smallexample 6402int __builtin___sprintf_chk (char *s, int flag, size_t os, const char *fmt, ...); 6403int __builtin___snprintf_chk (char *s, size_t maxlen, int flag, size_t os, 6404 const char *fmt, ...); 6405int __builtin___vsprintf_chk (char *s, int flag, size_t os, const char *fmt, 6406 va_list ap); 6407int __builtin___vsnprintf_chk (char *s, size_t maxlen, int flag, size_t os, 6408 const char *fmt, va_list ap); 6409@end smallexample 6410 6411The added @var{flag} argument is passed unchanged to @code{__sprintf_chk} 6412etc.@: functions and can contain implementation specific flags on what 6413additional security measures the checking function might take, such as 6414handling @code{%n} differently. 6415 6416The @var{os} argument is the object size @var{s} points to, like in the 6417other built-in functions. There is a small difference in the behavior 6418though, if @var{os} is @code{(size_t) -1}, the built-in functions are 6419optimized into the non-checking functions only if @var{flag} is 0, otherwise 6420the checking function is called with @var{os} argument set to 6421@code{(size_t) -1}. 6422 6423In addition to this, there are checking built-in functions 6424@code{__builtin___printf_chk}, @code{__builtin___vprintf_chk}, 6425@code{__builtin___fprintf_chk} and @code{__builtin___vfprintf_chk}. 6426These have just one additional argument, @var{flag}, right before 6427format string @var{fmt}. If the compiler is able to optimize them to 6428@code{fputc} etc.@: functions, it will, otherwise the checking function 6429should be called and the @var{flag} argument passed to it. 6430 6431@node Other Builtins 6432@section Other built-in functions provided by GCC 6433@cindex built-in functions 6434@findex __builtin_fpclassify 6435@findex __builtin_isfinite 6436@findex __builtin_isnormal 6437@findex __builtin_isgreater 6438@findex __builtin_isgreaterequal 6439@findex __builtin_isinf_sign 6440@findex __builtin_isless 6441@findex __builtin_islessequal 6442@findex __builtin_islessgreater 6443@findex __builtin_isunordered 6444@findex __builtin_powi 6445@findex __builtin_powif 6446@findex __builtin_powil 6447@findex _Exit 6448@findex _exit 6449@findex abort 6450@findex abs 6451@findex acos 6452@findex acosf 6453@findex acosh 6454@findex acoshf 6455@findex acoshl 6456@findex acosl 6457@findex alloca 6458@findex asin 6459@findex asinf 6460@findex asinh 6461@findex asinhf 6462@findex asinhl 6463@findex asinl 6464@findex atan 6465@findex atan2 6466@findex atan2f 6467@findex atan2l 6468@findex atanf 6469@findex atanh 6470@findex atanhf 6471@findex atanhl 6472@findex atanl 6473@findex bcmp 6474@findex bzero 6475@findex cabs 6476@findex cabsf 6477@findex cabsl 6478@findex cacos 6479@findex cacosf 6480@findex cacosh 6481@findex cacoshf 6482@findex cacoshl 6483@findex cacosl 6484@findex calloc 6485@findex carg 6486@findex cargf 6487@findex cargl 6488@findex casin 6489@findex casinf 6490@findex casinh 6491@findex casinhf 6492@findex casinhl 6493@findex casinl 6494@findex catan 6495@findex catanf 6496@findex catanh 6497@findex catanhf 6498@findex catanhl 6499@findex catanl 6500@findex cbrt 6501@findex cbrtf 6502@findex cbrtl 6503@findex ccos 6504@findex ccosf 6505@findex ccosh 6506@findex ccoshf 6507@findex ccoshl 6508@findex ccosl 6509@findex ceil 6510@findex ceilf 6511@findex ceill 6512@findex cexp 6513@findex cexpf 6514@findex cexpl 6515@findex cimag 6516@findex cimagf 6517@findex cimagl 6518@findex clog 6519@findex clogf 6520@findex clogl 6521@findex conj 6522@findex conjf 6523@findex conjl 6524@findex copysign 6525@findex copysignf 6526@findex copysignl 6527@findex cos 6528@findex cosf 6529@findex cosh 6530@findex coshf 6531@findex coshl 6532@findex cosl 6533@findex cpow 6534@findex cpowf 6535@findex cpowl 6536@findex cproj 6537@findex cprojf 6538@findex cprojl 6539@findex creal 6540@findex crealf 6541@findex creall 6542@findex csin 6543@findex csinf 6544@findex csinh 6545@findex csinhf 6546@findex csinhl 6547@findex csinl 6548@findex csqrt 6549@findex csqrtf 6550@findex csqrtl 6551@findex ctan 6552@findex ctanf 6553@findex ctanh 6554@findex ctanhf 6555@findex ctanhl 6556@findex ctanl 6557@findex dcgettext 6558@findex dgettext 6559@findex drem 6560@findex dremf 6561@findex dreml 6562@findex erf 6563@findex erfc 6564@findex erfcf 6565@findex erfcl 6566@findex erff 6567@findex erfl 6568@findex exit 6569@findex exp 6570@findex exp10 6571@findex exp10f 6572@findex exp10l 6573@findex exp2 6574@findex exp2f 6575@findex exp2l 6576@findex expf 6577@findex expl 6578@findex expm1 6579@findex expm1f 6580@findex expm1l 6581@findex fabs 6582@findex fabsf 6583@findex fabsl 6584@findex fdim 6585@findex fdimf 6586@findex fdiml 6587@findex ffs 6588@findex floor 6589@findex floorf 6590@findex floorl 6591@findex fma 6592@findex fmaf 6593@findex fmal 6594@findex fmax 6595@findex fmaxf 6596@findex fmaxl 6597@findex fmin 6598@findex fminf 6599@findex fminl 6600@findex fmod 6601@findex fmodf 6602@findex fmodl 6603@findex fprintf 6604@findex fprintf_unlocked 6605@findex fputs 6606@findex fputs_unlocked 6607@findex frexp 6608@findex frexpf 6609@findex frexpl 6610@findex fscanf 6611@findex gamma 6612@findex gammaf 6613@findex gammal 6614@findex gamma_r 6615@findex gammaf_r 6616@findex gammal_r 6617@findex gettext 6618@findex hypot 6619@findex hypotf 6620@findex hypotl 6621@findex ilogb 6622@findex ilogbf 6623@findex ilogbl 6624@findex imaxabs 6625@findex index 6626@findex isalnum 6627@findex isalpha 6628@findex isascii 6629@findex isblank 6630@findex iscntrl 6631@findex isdigit 6632@findex isgraph 6633@findex islower 6634@findex isprint 6635@findex ispunct 6636@findex isspace 6637@findex isupper 6638@findex iswalnum 6639@findex iswalpha 6640@findex iswblank 6641@findex iswcntrl 6642@findex iswdigit 6643@findex iswgraph 6644@findex iswlower 6645@findex iswprint 6646@findex iswpunct 6647@findex iswspace 6648@findex iswupper 6649@findex iswxdigit 6650@findex isxdigit 6651@findex j0 6652@findex j0f 6653@findex j0l 6654@findex j1 6655@findex j1f 6656@findex j1l 6657@findex jn 6658@findex jnf 6659@findex jnl 6660@findex labs 6661@findex ldexp 6662@findex ldexpf 6663@findex ldexpl 6664@findex lgamma 6665@findex lgammaf 6666@findex lgammal 6667@findex lgamma_r 6668@findex lgammaf_r 6669@findex lgammal_r 6670@findex llabs 6671@findex llrint 6672@findex llrintf 6673@findex llrintl 6674@findex llround 6675@findex llroundf 6676@findex llroundl 6677@findex log 6678@findex log10 6679@findex log10f 6680@findex log10l 6681@findex log1p 6682@findex log1pf 6683@findex log1pl 6684@findex log2 6685@findex log2f 6686@findex log2l 6687@findex logb 6688@findex logbf 6689@findex logbl 6690@findex logf 6691@findex logl 6692@findex lrint 6693@findex lrintf 6694@findex lrintl 6695@findex lround 6696@findex lroundf 6697@findex lroundl 6698@findex malloc 6699@findex memchr 6700@findex memcmp 6701@findex memcpy 6702@findex mempcpy 6703@findex memset 6704@findex modf 6705@findex modff 6706@findex modfl 6707@findex nearbyint 6708@findex nearbyintf 6709@findex nearbyintl 6710@findex nextafter 6711@findex nextafterf 6712@findex nextafterl 6713@findex nexttoward 6714@findex nexttowardf 6715@findex nexttowardl 6716@findex pow 6717@findex pow10 6718@findex pow10f 6719@findex pow10l 6720@findex powf 6721@findex powl 6722@findex printf 6723@findex printf_unlocked 6724@findex putchar 6725@findex puts 6726@findex remainder 6727@findex remainderf 6728@findex remainderl 6729@findex remquo 6730@findex remquof 6731@findex remquol 6732@findex rindex 6733@findex rint 6734@findex rintf 6735@findex rintl 6736@findex round 6737@findex roundf 6738@findex roundl 6739@findex scalb 6740@findex scalbf 6741@findex scalbl 6742@findex scalbln 6743@findex scalblnf 6744@findex scalblnf 6745@findex scalbn 6746@findex scalbnf 6747@findex scanfnl 6748@findex signbit 6749@findex signbitf 6750@findex signbitl 6751@findex signbitd32 6752@findex signbitd64 6753@findex signbitd128 6754@findex significand 6755@findex significandf 6756@findex significandl 6757@findex sin 6758@findex sincos 6759@findex sincosf 6760@findex sincosl 6761@findex sinf 6762@findex sinh 6763@findex sinhf 6764@findex sinhl 6765@findex sinl 6766@findex snprintf 6767@findex sprintf 6768@findex sqrt 6769@findex sqrtf 6770@findex sqrtl 6771@findex sscanf 6772@findex stpcpy 6773@findex stpncpy 6774@findex strcasecmp 6775@findex strcat 6776@findex strchr 6777@findex strcmp 6778@findex strcpy 6779@findex strcspn 6780@findex strdup 6781@findex strfmon 6782@findex strftime 6783@findex strlen 6784@findex strncasecmp 6785@findex strncat 6786@findex strncmp 6787@findex strncpy 6788@findex strndup 6789@findex strpbrk 6790@findex strrchr 6791@findex strspn 6792@findex strstr 6793@findex tan 6794@findex tanf 6795@findex tanh 6796@findex tanhf 6797@findex tanhl 6798@findex tanl 6799@findex tgamma 6800@findex tgammaf 6801@findex tgammal 6802@findex toascii 6803@findex tolower 6804@findex toupper 6805@findex towlower 6806@findex towupper 6807@findex trunc 6808@findex truncf 6809@findex truncl 6810@findex vfprintf 6811@findex vfscanf 6812@findex vprintf 6813@findex vscanf 6814@findex vsnprintf 6815@findex vsprintf 6816@findex vsscanf 6817@findex y0 6818@findex y0f 6819@findex y0l 6820@findex y1 6821@findex y1f 6822@findex y1l 6823@findex yn 6824@findex ynf 6825@findex ynl 6826 6827GCC provides a large number of built-in functions other than the ones 6828mentioned above. Some of these are for internal use in the processing 6829of exceptions or variable-length argument lists and will not be 6830documented here because they may change from time to time; we do not 6831recommend general use of these functions. 6832 6833The remaining functions are provided for optimization purposes. 6834 6835@opindex fno-builtin 6836GCC includes built-in versions of many of the functions in the standard 6837C library. The versions prefixed with @code{__builtin_} will always be 6838treated as having the same meaning as the C library function even if you 6839specify the @option{-fno-builtin} option. (@pxref{C Dialect Options}) 6840Many of these functions are only optimized in certain cases; if they are 6841not optimized in a particular case, a call to the library function will 6842be emitted. 6843 6844@opindex ansi 6845@opindex std 6846Outside strict ISO C mode (@option{-ansi}, @option{-std=c90} or 6847@option{-std=c99}), the functions 6848@code{_exit}, @code{alloca}, @code{bcmp}, @code{bzero}, 6849@code{dcgettext}, @code{dgettext}, @code{dremf}, @code{dreml}, 6850@code{drem}, @code{exp10f}, @code{exp10l}, @code{exp10}, @code{ffsll}, 6851@code{ffsl}, @code{ffs}, @code{fprintf_unlocked}, 6852@code{fputs_unlocked}, @code{gammaf}, @code{gammal}, @code{gamma}, 6853@code{gammaf_r}, @code{gammal_r}, @code{gamma_r}, @code{gettext}, 6854@code{index}, @code{isascii}, @code{j0f}, @code{j0l}, @code{j0}, 6855@code{j1f}, @code{j1l}, @code{j1}, @code{jnf}, @code{jnl}, @code{jn}, 6856@code{lgammaf_r}, @code{lgammal_r}, @code{lgamma_r}, @code{mempcpy}, 6857@code{pow10f}, @code{pow10l}, @code{pow10}, @code{printf_unlocked}, 6858@code{rindex}, @code{scalbf}, @code{scalbl}, @code{scalb}, 6859@code{signbit}, @code{signbitf}, @code{signbitl}, @code{signbitd32}, 6860@code{signbitd64}, @code{signbitd128}, @code{significandf}, 6861@code{significandl}, @code{significand}, @code{sincosf}, 6862@code{sincosl}, @code{sincos}, @code{stpcpy}, @code{stpncpy}, 6863@code{strcasecmp}, @code{strdup}, @code{strfmon}, @code{strncasecmp}, 6864@code{strndup}, @code{toascii}, @code{y0f}, @code{y0l}, @code{y0}, 6865@code{y1f}, @code{y1l}, @code{y1}, @code{ynf}, @code{ynl} and 6866@code{yn} 6867may be handled as built-in functions. 6868All these functions have corresponding versions 6869prefixed with @code{__builtin_}, which may be used even in strict C90 6870mode. 6871 6872The ISO C99 functions 6873@code{_Exit}, @code{acoshf}, @code{acoshl}, @code{acosh}, @code{asinhf}, 6874@code{asinhl}, @code{asinh}, @code{atanhf}, @code{atanhl}, @code{atanh}, 6875@code{cabsf}, @code{cabsl}, @code{cabs}, @code{cacosf}, @code{cacoshf}, 6876@code{cacoshl}, @code{cacosh}, @code{cacosl}, @code{cacos}, 6877@code{cargf}, @code{cargl}, @code{carg}, @code{casinf}, @code{casinhf}, 6878@code{casinhl}, @code{casinh}, @code{casinl}, @code{casin}, 6879@code{catanf}, @code{catanhf}, @code{catanhl}, @code{catanh}, 6880@code{catanl}, @code{catan}, @code{cbrtf}, @code{cbrtl}, @code{cbrt}, 6881@code{ccosf}, @code{ccoshf}, @code{ccoshl}, @code{ccosh}, @code{ccosl}, 6882@code{ccos}, @code{cexpf}, @code{cexpl}, @code{cexp}, @code{cimagf}, 6883@code{cimagl}, @code{cimag}, @code{clogf}, @code{clogl}, @code{clog}, 6884@code{conjf}, @code{conjl}, @code{conj}, @code{copysignf}, @code{copysignl}, 6885@code{copysign}, @code{cpowf}, @code{cpowl}, @code{cpow}, @code{cprojf}, 6886@code{cprojl}, @code{cproj}, @code{crealf}, @code{creall}, @code{creal}, 6887@code{csinf}, @code{csinhf}, @code{csinhl}, @code{csinh}, @code{csinl}, 6888@code{csin}, @code{csqrtf}, @code{csqrtl}, @code{csqrt}, @code{ctanf}, 6889@code{ctanhf}, @code{ctanhl}, @code{ctanh}, @code{ctanl}, @code{ctan}, 6890@code{erfcf}, @code{erfcl}, @code{erfc}, @code{erff}, @code{erfl}, 6891@code{erf}, @code{exp2f}, @code{exp2l}, @code{exp2}, @code{expm1f}, 6892@code{expm1l}, @code{expm1}, @code{fdimf}, @code{fdiml}, @code{fdim}, 6893@code{fmaf}, @code{fmal}, @code{fmaxf}, @code{fmaxl}, @code{fmax}, 6894@code{fma}, @code{fminf}, @code{fminl}, @code{fmin}, @code{hypotf}, 6895@code{hypotl}, @code{hypot}, @code{ilogbf}, @code{ilogbl}, @code{ilogb}, 6896@code{imaxabs}, @code{isblank}, @code{iswblank}, @code{lgammaf}, 6897@code{lgammal}, @code{lgamma}, @code{llabs}, @code{llrintf}, @code{llrintl}, 6898@code{llrint}, @code{llroundf}, @code{llroundl}, @code{llround}, 6899@code{log1pf}, @code{log1pl}, @code{log1p}, @code{log2f}, @code{log2l}, 6900@code{log2}, @code{logbf}, @code{logbl}, @code{logb}, @code{lrintf}, 6901@code{lrintl}, @code{lrint}, @code{lroundf}, @code{lroundl}, 6902@code{lround}, @code{nearbyintf}, @code{nearbyintl}, @code{nearbyint}, 6903@code{nextafterf}, @code{nextafterl}, @code{nextafter}, 6904@code{nexttowardf}, @code{nexttowardl}, @code{nexttoward}, 6905@code{remainderf}, @code{remainderl}, @code{remainder}, @code{remquof}, 6906@code{remquol}, @code{remquo}, @code{rintf}, @code{rintl}, @code{rint}, 6907@code{roundf}, @code{roundl}, @code{round}, @code{scalblnf}, 6908@code{scalblnl}, @code{scalbln}, @code{scalbnf}, @code{scalbnl}, 6909@code{scalbn}, @code{snprintf}, @code{tgammaf}, @code{tgammal}, 6910@code{tgamma}, @code{truncf}, @code{truncl}, @code{trunc}, 6911@code{vfscanf}, @code{vscanf}, @code{vsnprintf} and @code{vsscanf} 6912are handled as built-in functions 6913except in strict ISO C90 mode (@option{-ansi} or @option{-std=c90}). 6914 6915There are also built-in versions of the ISO C99 functions 6916@code{acosf}, @code{acosl}, @code{asinf}, @code{asinl}, @code{atan2f}, 6917@code{atan2l}, @code{atanf}, @code{atanl}, @code{ceilf}, @code{ceill}, 6918@code{cosf}, @code{coshf}, @code{coshl}, @code{cosl}, @code{expf}, 6919@code{expl}, @code{fabsf}, @code{fabsl}, @code{floorf}, @code{floorl}, 6920@code{fmodf}, @code{fmodl}, @code{frexpf}, @code{frexpl}, @code{ldexpf}, 6921@code{ldexpl}, @code{log10f}, @code{log10l}, @code{logf}, @code{logl}, 6922@code{modfl}, @code{modf}, @code{powf}, @code{powl}, @code{sinf}, 6923@code{sinhf}, @code{sinhl}, @code{sinl}, @code{sqrtf}, @code{sqrtl}, 6924@code{tanf}, @code{tanhf}, @code{tanhl} and @code{tanl} 6925that are recognized in any mode since ISO C90 reserves these names for 6926the purpose to which ISO C99 puts them. All these functions have 6927corresponding versions prefixed with @code{__builtin_}. 6928 6929The ISO C94 functions 6930@code{iswalnum}, @code{iswalpha}, @code{iswcntrl}, @code{iswdigit}, 6931@code{iswgraph}, @code{iswlower}, @code{iswprint}, @code{iswpunct}, 6932@code{iswspace}, @code{iswupper}, @code{iswxdigit}, @code{towlower} and 6933@code{towupper} 6934are handled as built-in functions 6935except in strict ISO C90 mode (@option{-ansi} or @option{-std=c90}). 6936 6937The ISO C90 functions 6938@code{abort}, @code{abs}, @code{acos}, @code{asin}, @code{atan2}, 6939@code{atan}, @code{calloc}, @code{ceil}, @code{cosh}, @code{cos}, 6940@code{exit}, @code{exp}, @code{fabs}, @code{floor}, @code{fmod}, 6941@code{fprintf}, @code{fputs}, @code{frexp}, @code{fscanf}, 6942@code{isalnum}, @code{isalpha}, @code{iscntrl}, @code{isdigit}, 6943@code{isgraph}, @code{islower}, @code{isprint}, @code{ispunct}, 6944@code{isspace}, @code{isupper}, @code{isxdigit}, @code{tolower}, 6945@code{toupper}, @code{labs}, @code{ldexp}, @code{log10}, @code{log}, 6946@code{malloc}, @code{memchr}, @code{memcmp}, @code{memcpy}, 6947@code{memset}, @code{modf}, @code{pow}, @code{printf}, @code{putchar}, 6948@code{puts}, @code{scanf}, @code{sinh}, @code{sin}, @code{snprintf}, 6949@code{sprintf}, @code{sqrt}, @code{sscanf}, @code{strcat}, 6950@code{strchr}, @code{strcmp}, @code{strcpy}, @code{strcspn}, 6951@code{strlen}, @code{strncat}, @code{strncmp}, @code{strncpy}, 6952@code{strpbrk}, @code{strrchr}, @code{strspn}, @code{strstr}, 6953@code{tanh}, @code{tan}, @code{vfprintf}, @code{vprintf} and @code{vsprintf} 6954are all recognized as built-in functions unless 6955@option{-fno-builtin} is specified (or @option{-fno-builtin-@var{function}} 6956is specified for an individual function). All of these functions have 6957corresponding versions prefixed with @code{__builtin_}. 6958 6959GCC provides built-in versions of the ISO C99 floating point comparison 6960macros that avoid raising exceptions for unordered operands. They have 6961the same names as the standard macros ( @code{isgreater}, 6962@code{isgreaterequal}, @code{isless}, @code{islessequal}, 6963@code{islessgreater}, and @code{isunordered}) , with @code{__builtin_} 6964prefixed. We intend for a library implementor to be able to simply 6965@code{#define} each standard macro to its built-in equivalent. 6966In the same fashion, GCC provides @code{fpclassify}, @code{isfinite}, 6967@code{isinf_sign} and @code{isnormal} built-ins used with 6968@code{__builtin_} prefixed. The @code{isinf} and @code{isnan} 6969builtins appear both with and without the @code{__builtin_} prefix. 6970 6971@deftypefn {Built-in Function} int __builtin_types_compatible_p (@var{type1}, @var{type2}) 6972 6973You can use the built-in function @code{__builtin_types_compatible_p} to 6974determine whether two types are the same. 6975 6976This built-in function returns 1 if the unqualified versions of the 6977types @var{type1} and @var{type2} (which are types, not expressions) are 6978compatible, 0 otherwise. The result of this built-in function can be 6979used in integer constant expressions. 6980 6981This built-in function ignores top level qualifiers (e.g., @code{const}, 6982@code{volatile}). For example, @code{int} is equivalent to @code{const 6983int}. 6984 6985The type @code{int[]} and @code{int[5]} are compatible. On the other 6986hand, @code{int} and @code{char *} are not compatible, even if the size 6987of their types, on the particular architecture are the same. Also, the 6988amount of pointer indirection is taken into account when determining 6989similarity. Consequently, @code{short *} is not similar to 6990@code{short **}. Furthermore, two types that are typedefed are 6991considered compatible if their underlying types are compatible. 6992 6993An @code{enum} type is not considered to be compatible with another 6994@code{enum} type even if both are compatible with the same integer 6995type; this is what the C standard specifies. 6996For example, @code{enum @{foo, bar@}} is not similar to 6997@code{enum @{hot, dog@}}. 6998 6999You would typically use this function in code whose execution varies 7000depending on the arguments' types. For example: 7001 7002@smallexample 7003#define foo(x) \ 7004 (@{ \ 7005 typeof (x) tmp = (x); \ 7006 if (__builtin_types_compatible_p (typeof (x), long double)) \ 7007 tmp = foo_long_double (tmp); \ 7008 else if (__builtin_types_compatible_p (typeof (x), double)) \ 7009 tmp = foo_double (tmp); \ 7010 else if (__builtin_types_compatible_p (typeof (x), float)) \ 7011 tmp = foo_float (tmp); \ 7012 else \ 7013 abort (); \ 7014 tmp; \ 7015 @}) 7016@end smallexample 7017 7018@emph{Note:} This construct is only available for C@. 7019 7020@end deftypefn 7021 7022@deftypefn {Built-in Function} @var{type} __builtin_choose_expr (@var{const_exp}, @var{exp1}, @var{exp2}) 7023 7024You can use the built-in function @code{__builtin_choose_expr} to 7025evaluate code depending on the value of a constant expression. This 7026built-in function returns @var{exp1} if @var{const_exp}, which is an 7027integer constant expression, is nonzero. Otherwise it returns 0. 7028 7029This built-in function is analogous to the @samp{? :} operator in C, 7030except that the expression returned has its type unaltered by promotion 7031rules. Also, the built-in function does not evaluate the expression 7032that was not chosen. For example, if @var{const_exp} evaluates to true, 7033@var{exp2} is not evaluated even if it has side-effects. 7034 7035This built-in function can return an lvalue if the chosen argument is an 7036lvalue. 7037 7038If @var{exp1} is returned, the return type is the same as @var{exp1}'s 7039type. Similarly, if @var{exp2} is returned, its return type is the same 7040as @var{exp2}. 7041 7042Example: 7043 7044@smallexample 7045#define foo(x) \ 7046 __builtin_choose_expr ( \ 7047 __builtin_types_compatible_p (typeof (x), double), \ 7048 foo_double (x), \ 7049 __builtin_choose_expr ( \ 7050 __builtin_types_compatible_p (typeof (x), float), \ 7051 foo_float (x), \ 7052 /* @r{The void expression results in a compile-time error} \ 7053 @r{when assigning the result to something.} */ \ 7054 (void)0)) 7055@end smallexample 7056 7057@emph{Note:} This construct is only available for C@. Furthermore, the 7058unused expression (@var{exp1} or @var{exp2} depending on the value of 7059@var{const_exp}) may still generate syntax errors. This may change in 7060future revisions. 7061 7062@end deftypefn 7063 7064@deftypefn {Built-in Function} int __builtin_constant_p (@var{exp}) 7065You can use the built-in function @code{__builtin_constant_p} to 7066determine if a value is known to be constant at compile-time and hence 7067that GCC can perform constant-folding on expressions involving that 7068value. The argument of the function is the value to test. The function 7069returns the integer 1 if the argument is known to be a compile-time 7070constant and 0 if it is not known to be a compile-time constant. A 7071return of 0 does not indicate that the value is @emph{not} a constant, 7072but merely that GCC cannot prove it is a constant with the specified 7073value of the @option{-O} option. 7074 7075You would typically use this function in an embedded application where 7076memory was a critical resource. If you have some complex calculation, 7077you may want it to be folded if it involves constants, but need to call 7078a function if it does not. For example: 7079 7080@smallexample 7081#define Scale_Value(X) \ 7082 (__builtin_constant_p (X) \ 7083 ? ((X) * SCALE + OFFSET) : Scale (X)) 7084@end smallexample 7085 7086You may use this built-in function in either a macro or an inline 7087function. However, if you use it in an inlined function and pass an 7088argument of the function as the argument to the built-in, GCC will 7089never return 1 when you call the inline function with a string constant 7090or compound literal (@pxref{Compound Literals}) and will not return 1 7091when you pass a constant numeric value to the inline function unless you 7092specify the @option{-O} option. 7093 7094You may also use @code{__builtin_constant_p} in initializers for static 7095data. For instance, you can write 7096 7097@smallexample 7098static const int table[] = @{ 7099 __builtin_constant_p (EXPRESSION) ? (EXPRESSION) : -1, 7100 /* @r{@dots{}} */ 7101@}; 7102@end smallexample 7103 7104@noindent 7105This is an acceptable initializer even if @var{EXPRESSION} is not a 7106constant expression, including the case where 7107@code{__builtin_constant_p} returns 1 because @var{EXPRESSION} can be 7108folded to a constant but @var{EXPRESSION} contains operands that would 7109not otherwise be permitted in a static initializer (for example, 7110@code{0 && foo ()}). GCC must be more conservative about evaluating the 7111built-in in this case, because it has no opportunity to perform 7112optimization. 7113 7114Previous versions of GCC did not accept this built-in in data 7115initializers. The earliest version where it is completely safe is 71163.0.1. 7117@end deftypefn 7118 7119@deftypefn {Built-in Function} long __builtin_expect (long @var{exp}, long @var{c}) 7120@opindex fprofile-arcs 7121You may use @code{__builtin_expect} to provide the compiler with 7122branch prediction information. In general, you should prefer to 7123use actual profile feedback for this (@option{-fprofile-arcs}), as 7124programmers are notoriously bad at predicting how their programs 7125actually perform. However, there are applications in which this 7126data is hard to collect. 7127 7128The return value is the value of @var{exp}, which should be an integral 7129expression. The semantics of the built-in are that it is expected that 7130@var{exp} == @var{c}. For example: 7131 7132@smallexample 7133if (__builtin_expect (x, 0)) 7134 foo (); 7135@end smallexample 7136 7137@noindent 7138would indicate that we do not expect to call @code{foo}, since 7139we expect @code{x} to be zero. Since you are limited to integral 7140expressions for @var{exp}, you should use constructions such as 7141 7142@smallexample 7143if (__builtin_expect (ptr != NULL, 1)) 7144 error (); 7145@end smallexample 7146 7147@noindent 7148when testing pointer or floating-point values. 7149@end deftypefn 7150 7151@deftypefn {Built-in Function} void __builtin_trap (void) 7152This function causes the program to exit abnormally. GCC implements 7153this function by using a target-dependent mechanism (such as 7154intentionally executing an illegal instruction) or by calling 7155@code{abort}. The mechanism used may vary from release to release so 7156you should not rely on any particular implementation. 7157@end deftypefn 7158 7159@deftypefn {Built-in Function} void __builtin_unreachable (void) 7160If control flow reaches the point of the @code{__builtin_unreachable}, 7161the program is undefined. It is useful in situations where the 7162compiler cannot deduce the unreachability of the code. 7163 7164One such case is immediately following an @code{asm} statement that 7165will either never terminate, or one that transfers control elsewhere 7166and never returns. In this example, without the 7167@code{__builtin_unreachable}, GCC would issue a warning that control 7168reaches the end of a non-void function. It would also generate code 7169to return after the @code{asm}. 7170 7171@smallexample 7172int f (int c, int v) 7173@{ 7174 if (c) 7175 @{ 7176 return v; 7177 @} 7178 else 7179 @{ 7180 asm("jmp error_handler"); 7181 __builtin_unreachable (); 7182 @} 7183@} 7184@end smallexample 7185 7186Because the @code{asm} statement unconditionally transfers control out 7187of the function, control will never reach the end of the function 7188body. The @code{__builtin_unreachable} is in fact unreachable and 7189communicates this fact to the compiler. 7190 7191Another use for @code{__builtin_unreachable} is following a call a 7192function that never returns but that is not declared 7193@code{__attribute__((noreturn))}, as in this example: 7194 7195@smallexample 7196void function_that_never_returns (void); 7197 7198int g (int c) 7199@{ 7200 if (c) 7201 @{ 7202 return 1; 7203 @} 7204 else 7205 @{ 7206 function_that_never_returns (); 7207 __builtin_unreachable (); 7208 @} 7209@} 7210@end smallexample 7211 7212@end deftypefn 7213 7214@deftypefn {Built-in Function} void __builtin___clear_cache (char *@var{begin}, char *@var{end}) 7215This function is used to flush the processor's instruction cache for 7216the region of memory between @var{begin} inclusive and @var{end} 7217exclusive. Some targets require that the instruction cache be 7218flushed, after modifying memory containing code, in order to obtain 7219deterministic behavior. 7220 7221If the target does not require instruction cache flushes, 7222@code{__builtin___clear_cache} has no effect. Otherwise either 7223instructions are emitted in-line to clear the instruction cache or a 7224call to the @code{__clear_cache} function in libgcc is made. 7225@end deftypefn 7226 7227@deftypefn {Built-in Function} void __builtin_prefetch (const void *@var{addr}, ...) 7228This function is used to minimize cache-miss latency by moving data into 7229a cache before it is accessed. 7230You can insert calls to @code{__builtin_prefetch} into code for which 7231you know addresses of data in memory that is likely to be accessed soon. 7232If the target supports them, data prefetch instructions will be generated. 7233If the prefetch is done early enough before the access then the data will 7234be in the cache by the time it is accessed. 7235 7236The value of @var{addr} is the address of the memory to prefetch. 7237There are two optional arguments, @var{rw} and @var{locality}. 7238The value of @var{rw} is a compile-time constant one or zero; one 7239means that the prefetch is preparing for a write to the memory address 7240and zero, the default, means that the prefetch is preparing for a read. 7241The value @var{locality} must be a compile-time constant integer between 7242zero and three. A value of zero means that the data has no temporal 7243locality, so it need not be left in the cache after the access. A value 7244of three means that the data has a high degree of temporal locality and 7245should be left in all levels of cache possible. Values of one and two 7246mean, respectively, a low or moderate degree of temporal locality. The 7247default is three. 7248 7249@smallexample 7250for (i = 0; i < n; i++) 7251 @{ 7252 a[i] = a[i] + b[i]; 7253 __builtin_prefetch (&a[i+j], 1, 1); 7254 __builtin_prefetch (&b[i+j], 0, 1); 7255 /* @r{@dots{}} */ 7256 @} 7257@end smallexample 7258 7259Data prefetch does not generate faults if @var{addr} is invalid, but 7260the address expression itself must be valid. For example, a prefetch 7261of @code{p->next} will not fault if @code{p->next} is not a valid 7262address, but evaluation will fault if @code{p} is not a valid address. 7263 7264If the target does not support data prefetch, the address expression 7265is evaluated if it includes side effects but no other code is generated 7266and GCC does not issue a warning. 7267@end deftypefn 7268 7269@deftypefn {Built-in Function} double __builtin_huge_val (void) 7270Returns a positive infinity, if supported by the floating-point format, 7271else @code{DBL_MAX}. This function is suitable for implementing the 7272ISO C macro @code{HUGE_VAL}. 7273@end deftypefn 7274 7275@deftypefn {Built-in Function} float __builtin_huge_valf (void) 7276Similar to @code{__builtin_huge_val}, except the return type is @code{float}. 7277@end deftypefn 7278 7279@deftypefn {Built-in Function} {long double} __builtin_huge_vall (void) 7280Similar to @code{__builtin_huge_val}, except the return 7281type is @code{long double}. 7282@end deftypefn 7283 7284@deftypefn {Built-in Function} int __builtin_fpclassify (int, int, int, int, int, ...) 7285This built-in implements the C99 fpclassify functionality. The first 7286five int arguments should be the target library's notion of the 7287possible FP classes and are used for return values. They must be 7288constant values and they must appear in this order: @code{FP_NAN}, 7289@code{FP_INFINITE}, @code{FP_NORMAL}, @code{FP_SUBNORMAL} and 7290@code{FP_ZERO}. The ellipsis is for exactly one floating point value 7291to classify. GCC treats the last argument as type-generic, which 7292means it does not do default promotion from float to double. 7293@end deftypefn 7294 7295@deftypefn {Built-in Function} double __builtin_inf (void) 7296Similar to @code{__builtin_huge_val}, except a warning is generated 7297if the target floating-point format does not support infinities. 7298@end deftypefn 7299 7300@deftypefn {Built-in Function} _Decimal32 __builtin_infd32 (void) 7301Similar to @code{__builtin_inf}, except the return type is @code{_Decimal32}. 7302@end deftypefn 7303 7304@deftypefn {Built-in Function} _Decimal64 __builtin_infd64 (void) 7305Similar to @code{__builtin_inf}, except the return type is @code{_Decimal64}. 7306@end deftypefn 7307 7308@deftypefn {Built-in Function} _Decimal128 __builtin_infd128 (void) 7309Similar to @code{__builtin_inf}, except the return type is @code{_Decimal128}. 7310@end deftypefn 7311 7312@deftypefn {Built-in Function} float __builtin_inff (void) 7313Similar to @code{__builtin_inf}, except the return type is @code{float}. 7314This function is suitable for implementing the ISO C99 macro @code{INFINITY}. 7315@end deftypefn 7316 7317@deftypefn {Built-in Function} {long double} __builtin_infl (void) 7318Similar to @code{__builtin_inf}, except the return 7319type is @code{long double}. 7320@end deftypefn 7321 7322@deftypefn {Built-in Function} int __builtin_isinf_sign (...) 7323Similar to @code{isinf}, except the return value will be negative for 7324an argument of @code{-Inf}. Note while the parameter list is an 7325ellipsis, this function only accepts exactly one floating point 7326argument. GCC treats this parameter as type-generic, which means it 7327does not do default promotion from float to double. 7328@end deftypefn 7329 7330@deftypefn {Built-in Function} double __builtin_nan (const char *str) 7331This is an implementation of the ISO C99 function @code{nan}. 7332 7333Since ISO C99 defines this function in terms of @code{strtod}, which we 7334do not implement, a description of the parsing is in order. The string 7335is parsed as by @code{strtol}; that is, the base is recognized by 7336leading @samp{0} or @samp{0x} prefixes. The number parsed is placed 7337in the significand such that the least significant bit of the number 7338is at the least significant bit of the significand. The number is 7339truncated to fit the significand field provided. The significand is 7340forced to be a quiet NaN@. 7341 7342This function, if given a string literal all of which would have been 7343consumed by strtol, is evaluated early enough that it is considered a 7344compile-time constant. 7345@end deftypefn 7346 7347@deftypefn {Built-in Function} _Decimal32 __builtin_nand32 (const char *str) 7348Similar to @code{__builtin_nan}, except the return type is @code{_Decimal32}. 7349@end deftypefn 7350 7351@deftypefn {Built-in Function} _Decimal64 __builtin_nand64 (const char *str) 7352Similar to @code{__builtin_nan}, except the return type is @code{_Decimal64}. 7353@end deftypefn 7354 7355@deftypefn {Built-in Function} _Decimal128 __builtin_nand128 (const char *str) 7356Similar to @code{__builtin_nan}, except the return type is @code{_Decimal128}. 7357@end deftypefn 7358 7359@deftypefn {Built-in Function} float __builtin_nanf (const char *str) 7360Similar to @code{__builtin_nan}, except the return type is @code{float}. 7361@end deftypefn 7362 7363@deftypefn {Built-in Function} {long double} __builtin_nanl (const char *str) 7364Similar to @code{__builtin_nan}, except the return type is @code{long double}. 7365@end deftypefn 7366 7367@deftypefn {Built-in Function} double __builtin_nans (const char *str) 7368Similar to @code{__builtin_nan}, except the significand is forced 7369to be a signaling NaN@. The @code{nans} function is proposed by 7370@uref{http://www.open-std.org/jtc1/sc22/wg14/www/docs/n965.htm,,WG14 N965}. 7371@end deftypefn 7372 7373@deftypefn {Built-in Function} float __builtin_nansf (const char *str) 7374Similar to @code{__builtin_nans}, except the return type is @code{float}. 7375@end deftypefn 7376 7377@deftypefn {Built-in Function} {long double} __builtin_nansl (const char *str) 7378Similar to @code{__builtin_nans}, except the return type is @code{long double}. 7379@end deftypefn 7380 7381@deftypefn {Built-in Function} int __builtin_ffs (unsigned int x) 7382Returns one plus the index of the least significant 1-bit of @var{x}, or 7383if @var{x} is zero, returns zero. 7384@end deftypefn 7385 7386@deftypefn {Built-in Function} int __builtin_clz (unsigned int x) 7387Returns the number of leading 0-bits in @var{x}, starting at the most 7388significant bit position. If @var{x} is 0, the result is undefined. 7389@end deftypefn 7390 7391@deftypefn {Built-in Function} int __builtin_ctz (unsigned int x) 7392Returns the number of trailing 0-bits in @var{x}, starting at the least 7393significant bit position. If @var{x} is 0, the result is undefined. 7394@end deftypefn 7395 7396@deftypefn {Built-in Function} int __builtin_popcount (unsigned int x) 7397Returns the number of 1-bits in @var{x}. 7398@end deftypefn 7399 7400@deftypefn {Built-in Function} int __builtin_parity (unsigned int x) 7401Returns the parity of @var{x}, i.e.@: the number of 1-bits in @var{x} 7402modulo 2. 7403@end deftypefn 7404 7405@deftypefn {Built-in Function} int __builtin_ffsl (unsigned long) 7406Similar to @code{__builtin_ffs}, except the argument type is 7407@code{unsigned long}. 7408@end deftypefn 7409 7410@deftypefn {Built-in Function} int __builtin_clzl (unsigned long) 7411Similar to @code{__builtin_clz}, except the argument type is 7412@code{unsigned long}. 7413@end deftypefn 7414 7415@deftypefn {Built-in Function} int __builtin_ctzl (unsigned long) 7416Similar to @code{__builtin_ctz}, except the argument type is 7417@code{unsigned long}. 7418@end deftypefn 7419 7420@deftypefn {Built-in Function} int __builtin_popcountl (unsigned long) 7421Similar to @code{__builtin_popcount}, except the argument type is 7422@code{unsigned long}. 7423@end deftypefn 7424 7425@deftypefn {Built-in Function} int __builtin_parityl (unsigned long) 7426Similar to @code{__builtin_parity}, except the argument type is 7427@code{unsigned long}. 7428@end deftypefn 7429 7430@deftypefn {Built-in Function} int __builtin_ffsll (unsigned long long) 7431Similar to @code{__builtin_ffs}, except the argument type is 7432@code{unsigned long long}. 7433@end deftypefn 7434 7435@deftypefn {Built-in Function} int __builtin_clzll (unsigned long long) 7436Similar to @code{__builtin_clz}, except the argument type is 7437@code{unsigned long long}. 7438@end deftypefn 7439 7440@deftypefn {Built-in Function} int __builtin_ctzll (unsigned long long) 7441Similar to @code{__builtin_ctz}, except the argument type is 7442@code{unsigned long long}. 7443@end deftypefn 7444 7445@deftypefn {Built-in Function} int __builtin_popcountll (unsigned long long) 7446Similar to @code{__builtin_popcount}, except the argument type is 7447@code{unsigned long long}. 7448@end deftypefn 7449 7450@deftypefn {Built-in Function} int __builtin_parityll (unsigned long long) 7451Similar to @code{__builtin_parity}, except the argument type is 7452@code{unsigned long long}. 7453@end deftypefn 7454 7455@deftypefn {Built-in Function} double __builtin_powi (double, int) 7456Returns the first argument raised to the power of the second. Unlike the 7457@code{pow} function no guarantees about precision and rounding are made. 7458@end deftypefn 7459 7460@deftypefn {Built-in Function} float __builtin_powif (float, int) 7461Similar to @code{__builtin_powi}, except the argument and return types 7462are @code{float}. 7463@end deftypefn 7464 7465@deftypefn {Built-in Function} {long double} __builtin_powil (long double, int) 7466Similar to @code{__builtin_powi}, except the argument and return types 7467are @code{long double}. 7468@end deftypefn 7469 7470@deftypefn {Built-in Function} int32_t __builtin_bswap32 (int32_t x) 7471Returns @var{x} with the order of the bytes reversed; for example, 7472@code{0xaabbccdd} becomes @code{0xddccbbaa}. Byte here always means 7473exactly 8 bits. 7474@end deftypefn 7475 7476@deftypefn {Built-in Function} int64_t __builtin_bswap64 (int64_t x) 7477Similar to @code{__builtin_bswap32}, except the argument and return types 7478are 64-bit. 7479@end deftypefn 7480 7481@node Target Builtins 7482@section Built-in Functions Specific to Particular Target Machines 7483 7484On some target machines, GCC supports many built-in functions specific 7485to those machines. Generally these generate calls to specific machine 7486instructions, but allow the compiler to schedule those calls. 7487 7488@menu 7489* Alpha Built-in Functions:: 7490* ARM iWMMXt Built-in Functions:: 7491* ARM NEON Intrinsics:: 7492* Blackfin Built-in Functions:: 7493* FR-V Built-in Functions:: 7494* X86 Built-in Functions:: 7495* MIPS DSP Built-in Functions:: 7496* MIPS Paired-Single Support:: 7497* MIPS Loongson Built-in Functions:: 7498* Other MIPS Built-in Functions:: 7499* picoChip Built-in Functions:: 7500* PowerPC AltiVec/VSX Built-in Functions:: 7501* RX Built-in Functions:: 7502* SPARC VIS Built-in Functions:: 7503* SPU Built-in Functions:: 7504@end menu 7505 7506@node Alpha Built-in Functions 7507@subsection Alpha Built-in Functions 7508 7509These built-in functions are available for the Alpha family of 7510processors, depending on the command-line switches used. 7511 7512The following built-in functions are always available. They 7513all generate the machine instruction that is part of the name. 7514 7515@smallexample 7516long __builtin_alpha_implver (void) 7517long __builtin_alpha_rpcc (void) 7518long __builtin_alpha_amask (long) 7519long __builtin_alpha_cmpbge (long, long) 7520long __builtin_alpha_extbl (long, long) 7521long __builtin_alpha_extwl (long, long) 7522long __builtin_alpha_extll (long, long) 7523long __builtin_alpha_extql (long, long) 7524long __builtin_alpha_extwh (long, long) 7525long __builtin_alpha_extlh (long, long) 7526long __builtin_alpha_extqh (long, long) 7527long __builtin_alpha_insbl (long, long) 7528long __builtin_alpha_inswl (long, long) 7529long __builtin_alpha_insll (long, long) 7530long __builtin_alpha_insql (long, long) 7531long __builtin_alpha_inswh (long, long) 7532long __builtin_alpha_inslh (long, long) 7533long __builtin_alpha_insqh (long, long) 7534long __builtin_alpha_mskbl (long, long) 7535long __builtin_alpha_mskwl (long, long) 7536long __builtin_alpha_mskll (long, long) 7537long __builtin_alpha_mskql (long, long) 7538long __builtin_alpha_mskwh (long, long) 7539long __builtin_alpha_msklh (long, long) 7540long __builtin_alpha_mskqh (long, long) 7541long __builtin_alpha_umulh (long, long) 7542long __builtin_alpha_zap (long, long) 7543long __builtin_alpha_zapnot (long, long) 7544@end smallexample 7545 7546The following built-in functions are always with @option{-mmax} 7547or @option{-mcpu=@var{cpu}} where @var{cpu} is @code{pca56} or 7548later. They all generate the machine instruction that is part 7549of the name. 7550 7551@smallexample 7552long __builtin_alpha_pklb (long) 7553long __builtin_alpha_pkwb (long) 7554long __builtin_alpha_unpkbl (long) 7555long __builtin_alpha_unpkbw (long) 7556long __builtin_alpha_minub8 (long, long) 7557long __builtin_alpha_minsb8 (long, long) 7558long __builtin_alpha_minuw4 (long, long) 7559long __builtin_alpha_minsw4 (long, long) 7560long __builtin_alpha_maxub8 (long, long) 7561long __builtin_alpha_maxsb8 (long, long) 7562long __builtin_alpha_maxuw4 (long, long) 7563long __builtin_alpha_maxsw4 (long, long) 7564long __builtin_alpha_perr (long, long) 7565@end smallexample 7566 7567The following built-in functions are always with @option{-mcix} 7568or @option{-mcpu=@var{cpu}} where @var{cpu} is @code{ev67} or 7569later. They all generate the machine instruction that is part 7570of the name. 7571 7572@smallexample 7573long __builtin_alpha_cttz (long) 7574long __builtin_alpha_ctlz (long) 7575long __builtin_alpha_ctpop (long) 7576@end smallexample 7577 7578The following builtins are available on systems that use the OSF/1 7579PALcode. Normally they invoke the @code{rduniq} and @code{wruniq} 7580PAL calls, but when invoked with @option{-mtls-kernel}, they invoke 7581@code{rdval} and @code{wrval}. 7582 7583@smallexample 7584void *__builtin_thread_pointer (void) 7585void __builtin_set_thread_pointer (void *) 7586@end smallexample 7587 7588@node ARM iWMMXt Built-in Functions 7589@subsection ARM iWMMXt Built-in Functions 7590 7591These built-in functions are available for the ARM family of 7592processors when the @option{-mcpu=iwmmxt} switch is used: 7593 7594@smallexample 7595typedef int v2si __attribute__ ((vector_size (8))); 7596typedef short v4hi __attribute__ ((vector_size (8))); 7597typedef char v8qi __attribute__ ((vector_size (8))); 7598 7599int __builtin_arm_getwcx (int) 7600void __builtin_arm_setwcx (int, int) 7601int __builtin_arm_textrmsb (v8qi, int) 7602int __builtin_arm_textrmsh (v4hi, int) 7603int __builtin_arm_textrmsw (v2si, int) 7604int __builtin_arm_textrmub (v8qi, int) 7605int __builtin_arm_textrmuh (v4hi, int) 7606int __builtin_arm_textrmuw (v2si, int) 7607v8qi __builtin_arm_tinsrb (v8qi, int) 7608v4hi __builtin_arm_tinsrh (v4hi, int) 7609v2si __builtin_arm_tinsrw (v2si, int) 7610long long __builtin_arm_tmia (long long, int, int) 7611long long __builtin_arm_tmiabb (long long, int, int) 7612long long __builtin_arm_tmiabt (long long, int, int) 7613long long __builtin_arm_tmiaph (long long, int, int) 7614long long __builtin_arm_tmiatb (long long, int, int) 7615long long __builtin_arm_tmiatt (long long, int, int) 7616int __builtin_arm_tmovmskb (v8qi) 7617int __builtin_arm_tmovmskh (v4hi) 7618int __builtin_arm_tmovmskw (v2si) 7619long long __builtin_arm_waccb (v8qi) 7620long long __builtin_arm_wacch (v4hi) 7621long long __builtin_arm_waccw (v2si) 7622v8qi __builtin_arm_waddb (v8qi, v8qi) 7623v8qi __builtin_arm_waddbss (v8qi, v8qi) 7624v8qi __builtin_arm_waddbus (v8qi, v8qi) 7625v4hi __builtin_arm_waddh (v4hi, v4hi) 7626v4hi __builtin_arm_waddhss (v4hi, v4hi) 7627v4hi __builtin_arm_waddhus (v4hi, v4hi) 7628v2si __builtin_arm_waddw (v2si, v2si) 7629v2si __builtin_arm_waddwss (v2si, v2si) 7630v2si __builtin_arm_waddwus (v2si, v2si) 7631v8qi __builtin_arm_walign (v8qi, v8qi, int) 7632long long __builtin_arm_wand(long long, long long) 7633long long __builtin_arm_wandn (long long, long long) 7634v8qi __builtin_arm_wavg2b (v8qi, v8qi) 7635v8qi __builtin_arm_wavg2br (v8qi, v8qi) 7636v4hi __builtin_arm_wavg2h (v4hi, v4hi) 7637v4hi __builtin_arm_wavg2hr (v4hi, v4hi) 7638v8qi __builtin_arm_wcmpeqb (v8qi, v8qi) 7639v4hi __builtin_arm_wcmpeqh (v4hi, v4hi) 7640v2si __builtin_arm_wcmpeqw (v2si, v2si) 7641v8qi __builtin_arm_wcmpgtsb (v8qi, v8qi) 7642v4hi __builtin_arm_wcmpgtsh (v4hi, v4hi) 7643v2si __builtin_arm_wcmpgtsw (v2si, v2si) 7644v8qi __builtin_arm_wcmpgtub (v8qi, v8qi) 7645v4hi __builtin_arm_wcmpgtuh (v4hi, v4hi) 7646v2si __builtin_arm_wcmpgtuw (v2si, v2si) 7647long long __builtin_arm_wmacs (long long, v4hi, v4hi) 7648long long __builtin_arm_wmacsz (v4hi, v4hi) 7649long long __builtin_arm_wmacu (long long, v4hi, v4hi) 7650long long __builtin_arm_wmacuz (v4hi, v4hi) 7651v4hi __builtin_arm_wmadds (v4hi, v4hi) 7652v4hi __builtin_arm_wmaddu (v4hi, v4hi) 7653v8qi __builtin_arm_wmaxsb (v8qi, v8qi) 7654v4hi __builtin_arm_wmaxsh (v4hi, v4hi) 7655v2si __builtin_arm_wmaxsw (v2si, v2si) 7656v8qi __builtin_arm_wmaxub (v8qi, v8qi) 7657v4hi __builtin_arm_wmaxuh (v4hi, v4hi) 7658v2si __builtin_arm_wmaxuw (v2si, v2si) 7659v8qi __builtin_arm_wminsb (v8qi, v8qi) 7660v4hi __builtin_arm_wminsh (v4hi, v4hi) 7661v2si __builtin_arm_wminsw (v2si, v2si) 7662v8qi __builtin_arm_wminub (v8qi, v8qi) 7663v4hi __builtin_arm_wminuh (v4hi, v4hi) 7664v2si __builtin_arm_wminuw (v2si, v2si) 7665v4hi __builtin_arm_wmulsm (v4hi, v4hi) 7666v4hi __builtin_arm_wmulul (v4hi, v4hi) 7667v4hi __builtin_arm_wmulum (v4hi, v4hi) 7668long long __builtin_arm_wor (long long, long long) 7669v2si __builtin_arm_wpackdss (long long, long long) 7670v2si __builtin_arm_wpackdus (long long, long long) 7671v8qi __builtin_arm_wpackhss (v4hi, v4hi) 7672v8qi __builtin_arm_wpackhus (v4hi, v4hi) 7673v4hi __builtin_arm_wpackwss (v2si, v2si) 7674v4hi __builtin_arm_wpackwus (v2si, v2si) 7675long long __builtin_arm_wrord (long long, long long) 7676long long __builtin_arm_wrordi (long long, int) 7677v4hi __builtin_arm_wrorh (v4hi, long long) 7678v4hi __builtin_arm_wrorhi (v4hi, int) 7679v2si __builtin_arm_wrorw (v2si, long long) 7680v2si __builtin_arm_wrorwi (v2si, int) 7681v2si __builtin_arm_wsadb (v8qi, v8qi) 7682v2si __builtin_arm_wsadbz (v8qi, v8qi) 7683v2si __builtin_arm_wsadh (v4hi, v4hi) 7684v2si __builtin_arm_wsadhz (v4hi, v4hi) 7685v4hi __builtin_arm_wshufh (v4hi, int) 7686long long __builtin_arm_wslld (long long, long long) 7687long long __builtin_arm_wslldi (long long, int) 7688v4hi __builtin_arm_wsllh (v4hi, long long) 7689v4hi __builtin_arm_wsllhi (v4hi, int) 7690v2si __builtin_arm_wsllw (v2si, long long) 7691v2si __builtin_arm_wsllwi (v2si, int) 7692long long __builtin_arm_wsrad (long long, long long) 7693long long __builtin_arm_wsradi (long long, int) 7694v4hi __builtin_arm_wsrah (v4hi, long long) 7695v4hi __builtin_arm_wsrahi (v4hi, int) 7696v2si __builtin_arm_wsraw (v2si, long long) 7697v2si __builtin_arm_wsrawi (v2si, int) 7698long long __builtin_arm_wsrld (long long, long long) 7699long long __builtin_arm_wsrldi (long long, int) 7700v4hi __builtin_arm_wsrlh (v4hi, long long) 7701v4hi __builtin_arm_wsrlhi (v4hi, int) 7702v2si __builtin_arm_wsrlw (v2si, long long) 7703v2si __builtin_arm_wsrlwi (v2si, int) 7704v8qi __builtin_arm_wsubb (v8qi, v8qi) 7705v8qi __builtin_arm_wsubbss (v8qi, v8qi) 7706v8qi __builtin_arm_wsubbus (v8qi, v8qi) 7707v4hi __builtin_arm_wsubh (v4hi, v4hi) 7708v4hi __builtin_arm_wsubhss (v4hi, v4hi) 7709v4hi __builtin_arm_wsubhus (v4hi, v4hi) 7710v2si __builtin_arm_wsubw (v2si, v2si) 7711v2si __builtin_arm_wsubwss (v2si, v2si) 7712v2si __builtin_arm_wsubwus (v2si, v2si) 7713v4hi __builtin_arm_wunpckehsb (v8qi) 7714v2si __builtin_arm_wunpckehsh (v4hi) 7715long long __builtin_arm_wunpckehsw (v2si) 7716v4hi __builtin_arm_wunpckehub (v8qi) 7717v2si __builtin_arm_wunpckehuh (v4hi) 7718long long __builtin_arm_wunpckehuw (v2si) 7719v4hi __builtin_arm_wunpckelsb (v8qi) 7720v2si __builtin_arm_wunpckelsh (v4hi) 7721long long __builtin_arm_wunpckelsw (v2si) 7722v4hi __builtin_arm_wunpckelub (v8qi) 7723v2si __builtin_arm_wunpckeluh (v4hi) 7724long long __builtin_arm_wunpckeluw (v2si) 7725v8qi __builtin_arm_wunpckihb (v8qi, v8qi) 7726v4hi __builtin_arm_wunpckihh (v4hi, v4hi) 7727v2si __builtin_arm_wunpckihw (v2si, v2si) 7728v8qi __builtin_arm_wunpckilb (v8qi, v8qi) 7729v4hi __builtin_arm_wunpckilh (v4hi, v4hi) 7730v2si __builtin_arm_wunpckilw (v2si, v2si) 7731long long __builtin_arm_wxor (long long, long long) 7732long long __builtin_arm_wzero () 7733@end smallexample 7734 7735@node ARM NEON Intrinsics 7736@subsection ARM NEON Intrinsics 7737 7738These built-in intrinsics for the ARM Advanced SIMD extension are available 7739when the @option{-mfpu=neon} switch is used: 7740 7741@include arm-neon-intrinsics.texi 7742 7743@node Blackfin Built-in Functions 7744@subsection Blackfin Built-in Functions 7745 7746Currently, there are two Blackfin-specific built-in functions. These are 7747used for generating @code{CSYNC} and @code{SSYNC} machine insns without 7748using inline assembly; by using these built-in functions the compiler can 7749automatically add workarounds for hardware errata involving these 7750instructions. These functions are named as follows: 7751 7752@smallexample 7753void __builtin_bfin_csync (void) 7754void __builtin_bfin_ssync (void) 7755@end smallexample 7756 7757@node FR-V Built-in Functions 7758@subsection FR-V Built-in Functions 7759 7760GCC provides many FR-V-specific built-in functions. In general, 7761these functions are intended to be compatible with those described 7762by @cite{FR-V Family, Softune C/C++ Compiler Manual (V6), Fujitsu 7763Semiconductor}. The two exceptions are @code{__MDUNPACKH} and 7764@code{__MBTOHE}, the gcc forms of which pass 128-bit values by 7765pointer rather than by value. 7766 7767Most of the functions are named after specific FR-V instructions. 7768Such functions are said to be ``directly mapped'' and are summarized 7769here in tabular form. 7770 7771@menu 7772* Argument Types:: 7773* Directly-mapped Integer Functions:: 7774* Directly-mapped Media Functions:: 7775* Raw read/write Functions:: 7776* Other Built-in Functions:: 7777@end menu 7778 7779@node Argument Types 7780@subsubsection Argument Types 7781 7782The arguments to the built-in functions can be divided into three groups: 7783register numbers, compile-time constants and run-time values. In order 7784to make this classification clear at a glance, the arguments and return 7785values are given the following pseudo types: 7786 7787@multitable @columnfractions .20 .30 .15 .35 7788@item Pseudo type @tab Real C type @tab Constant? @tab Description 7789@item @code{uh} @tab @code{unsigned short} @tab No @tab an unsigned halfword 7790@item @code{uw1} @tab @code{unsigned int} @tab No @tab an unsigned word 7791@item @code{sw1} @tab @code{int} @tab No @tab a signed word 7792@item @code{uw2} @tab @code{unsigned long long} @tab No 7793@tab an unsigned doubleword 7794@item @code{sw2} @tab @code{long long} @tab No @tab a signed doubleword 7795@item @code{const} @tab @code{int} @tab Yes @tab an integer constant 7796@item @code{acc} @tab @code{int} @tab Yes @tab an ACC register number 7797@item @code{iacc} @tab @code{int} @tab Yes @tab an IACC register number 7798@end multitable 7799 7800These pseudo types are not defined by GCC, they are simply a notational 7801convenience used in this manual. 7802 7803Arguments of type @code{uh}, @code{uw1}, @code{sw1}, @code{uw2} 7804and @code{sw2} are evaluated at run time. They correspond to 7805register operands in the underlying FR-V instructions. 7806 7807@code{const} arguments represent immediate operands in the underlying 7808FR-V instructions. They must be compile-time constants. 7809 7810@code{acc} arguments are evaluated at compile time and specify the number 7811of an accumulator register. For example, an @code{acc} argument of 2 7812will select the ACC2 register. 7813 7814@code{iacc} arguments are similar to @code{acc} arguments but specify the 7815number of an IACC register. See @pxref{Other Built-in Functions} 7816for more details. 7817 7818@node Directly-mapped Integer Functions 7819@subsubsection Directly-mapped Integer Functions 7820 7821The functions listed below map directly to FR-V I-type instructions. 7822 7823@multitable @columnfractions .45 .32 .23 7824@item Function prototype @tab Example usage @tab Assembly output 7825@item @code{sw1 __ADDSS (sw1, sw1)} 7826@tab @code{@var{c} = __ADDSS (@var{a}, @var{b})} 7827@tab @code{ADDSS @var{a},@var{b},@var{c}} 7828@item @code{sw1 __SCAN (sw1, sw1)} 7829@tab @code{@var{c} = __SCAN (@var{a}, @var{b})} 7830@tab @code{SCAN @var{a},@var{b},@var{c}} 7831@item @code{sw1 __SCUTSS (sw1)} 7832@tab @code{@var{b} = __SCUTSS (@var{a})} 7833@tab @code{SCUTSS @var{a},@var{b}} 7834@item @code{sw1 __SLASS (sw1, sw1)} 7835@tab @code{@var{c} = __SLASS (@var{a}, @var{b})} 7836@tab @code{SLASS @var{a},@var{b},@var{c}} 7837@item @code{void __SMASS (sw1, sw1)} 7838@tab @code{__SMASS (@var{a}, @var{b})} 7839@tab @code{SMASS @var{a},@var{b}} 7840@item @code{void __SMSSS (sw1, sw1)} 7841@tab @code{__SMSSS (@var{a}, @var{b})} 7842@tab @code{SMSSS @var{a},@var{b}} 7843@item @code{void __SMU (sw1, sw1)} 7844@tab @code{__SMU (@var{a}, @var{b})} 7845@tab @code{SMU @var{a},@var{b}} 7846@item @code{sw2 __SMUL (sw1, sw1)} 7847@tab @code{@var{c} = __SMUL (@var{a}, @var{b})} 7848@tab @code{SMUL @var{a},@var{b},@var{c}} 7849@item @code{sw1 __SUBSS (sw1, sw1)} 7850@tab @code{@var{c} = __SUBSS (@var{a}, @var{b})} 7851@tab @code{SUBSS @var{a},@var{b},@var{c}} 7852@item @code{uw2 __UMUL (uw1, uw1)} 7853@tab @code{@var{c} = __UMUL (@var{a}, @var{b})} 7854@tab @code{UMUL @var{a},@var{b},@var{c}} 7855@end multitable 7856 7857@node Directly-mapped Media Functions 7858@subsubsection Directly-mapped Media Functions 7859 7860The functions listed below map directly to FR-V M-type instructions. 7861 7862@multitable @columnfractions .45 .32 .23 7863@item Function prototype @tab Example usage @tab Assembly output 7864@item @code{uw1 __MABSHS (sw1)} 7865@tab @code{@var{b} = __MABSHS (@var{a})} 7866@tab @code{MABSHS @var{a},@var{b}} 7867@item @code{void __MADDACCS (acc, acc)} 7868@tab @code{__MADDACCS (@var{b}, @var{a})} 7869@tab @code{MADDACCS @var{a},@var{b}} 7870@item @code{sw1 __MADDHSS (sw1, sw1)} 7871@tab @code{@var{c} = __MADDHSS (@var{a}, @var{b})} 7872@tab @code{MADDHSS @var{a},@var{b},@var{c}} 7873@item @code{uw1 __MADDHUS (uw1, uw1)} 7874@tab @code{@var{c} = __MADDHUS (@var{a}, @var{b})} 7875@tab @code{MADDHUS @var{a},@var{b},@var{c}} 7876@item @code{uw1 __MAND (uw1, uw1)} 7877@tab @code{@var{c} = __MAND (@var{a}, @var{b})} 7878@tab @code{MAND @var{a},@var{b},@var{c}} 7879@item @code{void __MASACCS (acc, acc)} 7880@tab @code{__MASACCS (@var{b}, @var{a})} 7881@tab @code{MASACCS @var{a},@var{b}} 7882@item @code{uw1 __MAVEH (uw1, uw1)} 7883@tab @code{@var{c} = __MAVEH (@var{a}, @var{b})} 7884@tab @code{MAVEH @var{a},@var{b},@var{c}} 7885@item @code{uw2 __MBTOH (uw1)} 7886@tab @code{@var{b} = __MBTOH (@var{a})} 7887@tab @code{MBTOH @var{a},@var{b}} 7888@item @code{void __MBTOHE (uw1 *, uw1)} 7889@tab @code{__MBTOHE (&@var{b}, @var{a})} 7890@tab @code{MBTOHE @var{a},@var{b}} 7891@item @code{void __MCLRACC (acc)} 7892@tab @code{__MCLRACC (@var{a})} 7893@tab @code{MCLRACC @var{a}} 7894@item @code{void __MCLRACCA (void)} 7895@tab @code{__MCLRACCA ()} 7896@tab @code{MCLRACCA} 7897@item @code{uw1 __Mcop1 (uw1, uw1)} 7898@tab @code{@var{c} = __Mcop1 (@var{a}, @var{b})} 7899@tab @code{Mcop1 @var{a},@var{b},@var{c}} 7900@item @code{uw1 __Mcop2 (uw1, uw1)} 7901@tab @code{@var{c} = __Mcop2 (@var{a}, @var{b})} 7902@tab @code{Mcop2 @var{a},@var{b},@var{c}} 7903@item @code{uw1 __MCPLHI (uw2, const)} 7904@tab @code{@var{c} = __MCPLHI (@var{a}, @var{b})} 7905@tab @code{MCPLHI @var{a},#@var{b},@var{c}} 7906@item @code{uw1 __MCPLI (uw2, const)} 7907@tab @code{@var{c} = __MCPLI (@var{a}, @var{b})} 7908@tab @code{MCPLI @var{a},#@var{b},@var{c}} 7909@item @code{void __MCPXIS (acc, sw1, sw1)} 7910@tab @code{__MCPXIS (@var{c}, @var{a}, @var{b})} 7911@tab @code{MCPXIS @var{a},@var{b},@var{c}} 7912@item @code{void __MCPXIU (acc, uw1, uw1)} 7913@tab @code{__MCPXIU (@var{c}, @var{a}, @var{b})} 7914@tab @code{MCPXIU @var{a},@var{b},@var{c}} 7915@item @code{void __MCPXRS (acc, sw1, sw1)} 7916@tab @code{__MCPXRS (@var{c}, @var{a}, @var{b})} 7917@tab @code{MCPXRS @var{a},@var{b},@var{c}} 7918@item @code{void __MCPXRU (acc, uw1, uw1)} 7919@tab @code{__MCPXRU (@var{c}, @var{a}, @var{b})} 7920@tab @code{MCPXRU @var{a},@var{b},@var{c}} 7921@item @code{uw1 __MCUT (acc, uw1)} 7922@tab @code{@var{c} = __MCUT (@var{a}, @var{b})} 7923@tab @code{MCUT @var{a},@var{b},@var{c}} 7924@item @code{uw1 __MCUTSS (acc, sw1)} 7925@tab @code{@var{c} = __MCUTSS (@var{a}, @var{b})} 7926@tab @code{MCUTSS @var{a},@var{b},@var{c}} 7927@item @code{void __MDADDACCS (acc, acc)} 7928@tab @code{__MDADDACCS (@var{b}, @var{a})} 7929@tab @code{MDADDACCS @var{a},@var{b}} 7930@item @code{void __MDASACCS (acc, acc)} 7931@tab @code{__MDASACCS (@var{b}, @var{a})} 7932@tab @code{MDASACCS @var{a},@var{b}} 7933@item @code{uw2 __MDCUTSSI (acc, const)} 7934@tab @code{@var{c} = __MDCUTSSI (@var{a}, @var{b})} 7935@tab @code{MDCUTSSI @var{a},#@var{b},@var{c}} 7936@item @code{uw2 __MDPACKH (uw2, uw2)} 7937@tab @code{@var{c} = __MDPACKH (@var{a}, @var{b})} 7938@tab @code{MDPACKH @var{a},@var{b},@var{c}} 7939@item @code{uw2 __MDROTLI (uw2, const)} 7940@tab @code{@var{c} = __MDROTLI (@var{a}, @var{b})} 7941@tab @code{MDROTLI @var{a},#@var{b},@var{c}} 7942@item @code{void __MDSUBACCS (acc, acc)} 7943@tab @code{__MDSUBACCS (@var{b}, @var{a})} 7944@tab @code{MDSUBACCS @var{a},@var{b}} 7945@item @code{void __MDUNPACKH (uw1 *, uw2)} 7946@tab @code{__MDUNPACKH (&@var{b}, @var{a})} 7947@tab @code{MDUNPACKH @var{a},@var{b}} 7948@item @code{uw2 __MEXPDHD (uw1, const)} 7949@tab @code{@var{c} = __MEXPDHD (@var{a}, @var{b})} 7950@tab @code{MEXPDHD @var{a},#@var{b},@var{c}} 7951@item @code{uw1 __MEXPDHW (uw1, const)} 7952@tab @code{@var{c} = __MEXPDHW (@var{a}, @var{b})} 7953@tab @code{MEXPDHW @var{a},#@var{b},@var{c}} 7954@item @code{uw1 __MHDSETH (uw1, const)} 7955@tab @code{@var{c} = __MHDSETH (@var{a}, @var{b})} 7956@tab @code{MHDSETH @var{a},#@var{b},@var{c}} 7957@item @code{sw1 __MHDSETS (const)} 7958@tab @code{@var{b} = __MHDSETS (@var{a})} 7959@tab @code{MHDSETS #@var{a},@var{b}} 7960@item @code{uw1 __MHSETHIH (uw1, const)} 7961@tab @code{@var{b} = __MHSETHIH (@var{b}, @var{a})} 7962@tab @code{MHSETHIH #@var{a},@var{b}} 7963@item @code{sw1 __MHSETHIS (sw1, const)} 7964@tab @code{@var{b} = __MHSETHIS (@var{b}, @var{a})} 7965@tab @code{MHSETHIS #@var{a},@var{b}} 7966@item @code{uw1 __MHSETLOH (uw1, const)} 7967@tab @code{@var{b} = __MHSETLOH (@var{b}, @var{a})} 7968@tab @code{MHSETLOH #@var{a},@var{b}} 7969@item @code{sw1 __MHSETLOS (sw1, const)} 7970@tab @code{@var{b} = __MHSETLOS (@var{b}, @var{a})} 7971@tab @code{MHSETLOS #@var{a},@var{b}} 7972@item @code{uw1 __MHTOB (uw2)} 7973@tab @code{@var{b} = __MHTOB (@var{a})} 7974@tab @code{MHTOB @var{a},@var{b}} 7975@item @code{void __MMACHS (acc, sw1, sw1)} 7976@tab @code{__MMACHS (@var{c}, @var{a}, @var{b})} 7977@tab @code{MMACHS @var{a},@var{b},@var{c}} 7978@item @code{void __MMACHU (acc, uw1, uw1)} 7979@tab @code{__MMACHU (@var{c}, @var{a}, @var{b})} 7980@tab @code{MMACHU @var{a},@var{b},@var{c}} 7981@item @code{void __MMRDHS (acc, sw1, sw1)} 7982@tab @code{__MMRDHS (@var{c}, @var{a}, @var{b})} 7983@tab @code{MMRDHS @var{a},@var{b},@var{c}} 7984@item @code{void __MMRDHU (acc, uw1, uw1)} 7985@tab @code{__MMRDHU (@var{c}, @var{a}, @var{b})} 7986@tab @code{MMRDHU @var{a},@var{b},@var{c}} 7987@item @code{void __MMULHS (acc, sw1, sw1)} 7988@tab @code{__MMULHS (@var{c}, @var{a}, @var{b})} 7989@tab @code{MMULHS @var{a},@var{b},@var{c}} 7990@item @code{void __MMULHU (acc, uw1, uw1)} 7991@tab @code{__MMULHU (@var{c}, @var{a}, @var{b})} 7992@tab @code{MMULHU @var{a},@var{b},@var{c}} 7993@item @code{void __MMULXHS (acc, sw1, sw1)} 7994@tab @code{__MMULXHS (@var{c}, @var{a}, @var{b})} 7995@tab @code{MMULXHS @var{a},@var{b},@var{c}} 7996@item @code{void __MMULXHU (acc, uw1, uw1)} 7997@tab @code{__MMULXHU (@var{c}, @var{a}, @var{b})} 7998@tab @code{MMULXHU @var{a},@var{b},@var{c}} 7999@item @code{uw1 __MNOT (uw1)} 8000@tab @code{@var{b} = __MNOT (@var{a})} 8001@tab @code{MNOT @var{a},@var{b}} 8002@item @code{uw1 __MOR (uw1, uw1)} 8003@tab @code{@var{c} = __MOR (@var{a}, @var{b})} 8004@tab @code{MOR @var{a},@var{b},@var{c}} 8005@item @code{uw1 __MPACKH (uh, uh)} 8006@tab @code{@var{c} = __MPACKH (@var{a}, @var{b})} 8007@tab @code{MPACKH @var{a},@var{b},@var{c}} 8008@item @code{sw2 __MQADDHSS (sw2, sw2)} 8009@tab @code{@var{c} = __MQADDHSS (@var{a}, @var{b})} 8010@tab @code{MQADDHSS @var{a},@var{b},@var{c}} 8011@item @code{uw2 __MQADDHUS (uw2, uw2)} 8012@tab @code{@var{c} = __MQADDHUS (@var{a}, @var{b})} 8013@tab @code{MQADDHUS @var{a},@var{b},@var{c}} 8014@item @code{void __MQCPXIS (acc, sw2, sw2)} 8015@tab @code{__MQCPXIS (@var{c}, @var{a}, @var{b})} 8016@tab @code{MQCPXIS @var{a},@var{b},@var{c}} 8017@item @code{void __MQCPXIU (acc, uw2, uw2)} 8018@tab @code{__MQCPXIU (@var{c}, @var{a}, @var{b})} 8019@tab @code{MQCPXIU @var{a},@var{b},@var{c}} 8020@item @code{void __MQCPXRS (acc, sw2, sw2)} 8021@tab @code{__MQCPXRS (@var{c}, @var{a}, @var{b})} 8022@tab @code{MQCPXRS @var{a},@var{b},@var{c}} 8023@item @code{void __MQCPXRU (acc, uw2, uw2)} 8024@tab @code{__MQCPXRU (@var{c}, @var{a}, @var{b})} 8025@tab @code{MQCPXRU @var{a},@var{b},@var{c}} 8026@item @code{sw2 __MQLCLRHS (sw2, sw2)} 8027@tab @code{@var{c} = __MQLCLRHS (@var{a}, @var{b})} 8028@tab @code{MQLCLRHS @var{a},@var{b},@var{c}} 8029@item @code{sw2 __MQLMTHS (sw2, sw2)} 8030@tab @code{@var{c} = __MQLMTHS (@var{a}, @var{b})} 8031@tab @code{MQLMTHS @var{a},@var{b},@var{c}} 8032@item @code{void __MQMACHS (acc, sw2, sw2)} 8033@tab @code{__MQMACHS (@var{c}, @var{a}, @var{b})} 8034@tab @code{MQMACHS @var{a},@var{b},@var{c}} 8035@item @code{void __MQMACHU (acc, uw2, uw2)} 8036@tab @code{__MQMACHU (@var{c}, @var{a}, @var{b})} 8037@tab @code{MQMACHU @var{a},@var{b},@var{c}} 8038@item @code{void __MQMACXHS (acc, sw2, sw2)} 8039@tab @code{__MQMACXHS (@var{c}, @var{a}, @var{b})} 8040@tab @code{MQMACXHS @var{a},@var{b},@var{c}} 8041@item @code{void __MQMULHS (acc, sw2, sw2)} 8042@tab @code{__MQMULHS (@var{c}, @var{a}, @var{b})} 8043@tab @code{MQMULHS @var{a},@var{b},@var{c}} 8044@item @code{void __MQMULHU (acc, uw2, uw2)} 8045@tab @code{__MQMULHU (@var{c}, @var{a}, @var{b})} 8046@tab @code{MQMULHU @var{a},@var{b},@var{c}} 8047@item @code{void __MQMULXHS (acc, sw2, sw2)} 8048@tab @code{__MQMULXHS (@var{c}, @var{a}, @var{b})} 8049@tab @code{MQMULXHS @var{a},@var{b},@var{c}} 8050@item @code{void __MQMULXHU (acc, uw2, uw2)} 8051@tab @code{__MQMULXHU (@var{c}, @var{a}, @var{b})} 8052@tab @code{MQMULXHU @var{a},@var{b},@var{c}} 8053@item @code{sw2 __MQSATHS (sw2, sw2)} 8054@tab @code{@var{c} = __MQSATHS (@var{a}, @var{b})} 8055@tab @code{MQSATHS @var{a},@var{b},@var{c}} 8056@item @code{uw2 __MQSLLHI (uw2, int)} 8057@tab @code{@var{c} = __MQSLLHI (@var{a}, @var{b})} 8058@tab @code{MQSLLHI @var{a},@var{b},@var{c}} 8059@item @code{sw2 __MQSRAHI (sw2, int)} 8060@tab @code{@var{c} = __MQSRAHI (@var{a}, @var{b})} 8061@tab @code{MQSRAHI @var{a},@var{b},@var{c}} 8062@item @code{sw2 __MQSUBHSS (sw2, sw2)} 8063@tab @code{@var{c} = __MQSUBHSS (@var{a}, @var{b})} 8064@tab @code{MQSUBHSS @var{a},@var{b},@var{c}} 8065@item @code{uw2 __MQSUBHUS (uw2, uw2)} 8066@tab @code{@var{c} = __MQSUBHUS (@var{a}, @var{b})} 8067@tab @code{MQSUBHUS @var{a},@var{b},@var{c}} 8068@item @code{void __MQXMACHS (acc, sw2, sw2)} 8069@tab @code{__MQXMACHS (@var{c}, @var{a}, @var{b})} 8070@tab @code{MQXMACHS @var{a},@var{b},@var{c}} 8071@item @code{void __MQXMACXHS (acc, sw2, sw2)} 8072@tab @code{__MQXMACXHS (@var{c}, @var{a}, @var{b})} 8073@tab @code{MQXMACXHS @var{a},@var{b},@var{c}} 8074@item @code{uw1 __MRDACC (acc)} 8075@tab @code{@var{b} = __MRDACC (@var{a})} 8076@tab @code{MRDACC @var{a},@var{b}} 8077@item @code{uw1 __MRDACCG (acc)} 8078@tab @code{@var{b} = __MRDACCG (@var{a})} 8079@tab @code{MRDACCG @var{a},@var{b}} 8080@item @code{uw1 __MROTLI (uw1, const)} 8081@tab @code{@var{c} = __MROTLI (@var{a}, @var{b})} 8082@tab @code{MROTLI @var{a},#@var{b},@var{c}} 8083@item @code{uw1 __MROTRI (uw1, const)} 8084@tab @code{@var{c} = __MROTRI (@var{a}, @var{b})} 8085@tab @code{MROTRI @var{a},#@var{b},@var{c}} 8086@item @code{sw1 __MSATHS (sw1, sw1)} 8087@tab @code{@var{c} = __MSATHS (@var{a}, @var{b})} 8088@tab @code{MSATHS @var{a},@var{b},@var{c}} 8089@item @code{uw1 __MSATHU (uw1, uw1)} 8090@tab @code{@var{c} = __MSATHU (@var{a}, @var{b})} 8091@tab @code{MSATHU @var{a},@var{b},@var{c}} 8092@item @code{uw1 __MSLLHI (uw1, const)} 8093@tab @code{@var{c} = __MSLLHI (@var{a}, @var{b})} 8094@tab @code{MSLLHI @var{a},#@var{b},@var{c}} 8095@item @code{sw1 __MSRAHI (sw1, const)} 8096@tab @code{@var{c} = __MSRAHI (@var{a}, @var{b})} 8097@tab @code{MSRAHI @var{a},#@var{b},@var{c}} 8098@item @code{uw1 __MSRLHI (uw1, const)} 8099@tab @code{@var{c} = __MSRLHI (@var{a}, @var{b})} 8100@tab @code{MSRLHI @var{a},#@var{b},@var{c}} 8101@item @code{void __MSUBACCS (acc, acc)} 8102@tab @code{__MSUBACCS (@var{b}, @var{a})} 8103@tab @code{MSUBACCS @var{a},@var{b}} 8104@item @code{sw1 __MSUBHSS (sw1, sw1)} 8105@tab @code{@var{c} = __MSUBHSS (@var{a}, @var{b})} 8106@tab @code{MSUBHSS @var{a},@var{b},@var{c}} 8107@item @code{uw1 __MSUBHUS (uw1, uw1)} 8108@tab @code{@var{c} = __MSUBHUS (@var{a}, @var{b})} 8109@tab @code{MSUBHUS @var{a},@var{b},@var{c}} 8110@item @code{void __MTRAP (void)} 8111@tab @code{__MTRAP ()} 8112@tab @code{MTRAP} 8113@item @code{uw2 __MUNPACKH (uw1)} 8114@tab @code{@var{b} = __MUNPACKH (@var{a})} 8115@tab @code{MUNPACKH @var{a},@var{b}} 8116@item @code{uw1 __MWCUT (uw2, uw1)} 8117@tab @code{@var{c} = __MWCUT (@var{a}, @var{b})} 8118@tab @code{MWCUT @var{a},@var{b},@var{c}} 8119@item @code{void __MWTACC (acc, uw1)} 8120@tab @code{__MWTACC (@var{b}, @var{a})} 8121@tab @code{MWTACC @var{a},@var{b}} 8122@item @code{void __MWTACCG (acc, uw1)} 8123@tab @code{__MWTACCG (@var{b}, @var{a})} 8124@tab @code{MWTACCG @var{a},@var{b}} 8125@item @code{uw1 __MXOR (uw1, uw1)} 8126@tab @code{@var{c} = __MXOR (@var{a}, @var{b})} 8127@tab @code{MXOR @var{a},@var{b},@var{c}} 8128@end multitable 8129 8130@node Raw read/write Functions 8131@subsubsection Raw read/write Functions 8132 8133This sections describes built-in functions related to read and write 8134instructions to access memory. These functions generate 8135@code{membar} instructions to flush the I/O load and stores where 8136appropriate, as described in Fujitsu's manual described above. 8137 8138@table @code 8139 8140@item unsigned char __builtin_read8 (void *@var{data}) 8141@item unsigned short __builtin_read16 (void *@var{data}) 8142@item unsigned long __builtin_read32 (void *@var{data}) 8143@item unsigned long long __builtin_read64 (void *@var{data}) 8144 8145@item void __builtin_write8 (void *@var{data}, unsigned char @var{datum}) 8146@item void __builtin_write16 (void *@var{data}, unsigned short @var{datum}) 8147@item void __builtin_write32 (void *@var{data}, unsigned long @var{datum}) 8148@item void __builtin_write64 (void *@var{data}, unsigned long long @var{datum}) 8149@end table 8150 8151@node Other Built-in Functions 8152@subsubsection Other Built-in Functions 8153 8154This section describes built-in functions that are not named after 8155a specific FR-V instruction. 8156 8157@table @code 8158@item sw2 __IACCreadll (iacc @var{reg}) 8159Return the full 64-bit value of IACC0@. The @var{reg} argument is reserved 8160for future expansion and must be 0. 8161 8162@item sw1 __IACCreadl (iacc @var{reg}) 8163Return the value of IACC0H if @var{reg} is 0 and IACC0L if @var{reg} is 1. 8164Other values of @var{reg} are rejected as invalid. 8165 8166@item void __IACCsetll (iacc @var{reg}, sw2 @var{x}) 8167Set the full 64-bit value of IACC0 to @var{x}. The @var{reg} argument 8168is reserved for future expansion and must be 0. 8169 8170@item void __IACCsetl (iacc @var{reg}, sw1 @var{x}) 8171Set IACC0H to @var{x} if @var{reg} is 0 and IACC0L to @var{x} if @var{reg} 8172is 1. Other values of @var{reg} are rejected as invalid. 8173 8174@item void __data_prefetch0 (const void *@var{x}) 8175Use the @code{dcpl} instruction to load the contents of address @var{x} 8176into the data cache. 8177 8178@item void __data_prefetch (const void *@var{x}) 8179Use the @code{nldub} instruction to load the contents of address @var{x} 8180into the data cache. The instruction will be issued in slot I1@. 8181@end table 8182 8183@node X86 Built-in Functions 8184@subsection X86 Built-in Functions 8185 8186These built-in functions are available for the i386 and x86-64 family 8187of computers, depending on the command-line switches used. 8188 8189Note that, if you specify command-line switches such as @option{-msse}, 8190the compiler could use the extended instruction sets even if the built-ins 8191are not used explicitly in the program. For this reason, applications 8192which perform runtime CPU detection must compile separate files for each 8193supported architecture, using the appropriate flags. In particular, 8194the file containing the CPU detection code should be compiled without 8195these options. 8196 8197The following machine modes are available for use with MMX built-in functions 8198(@pxref{Vector Extensions}): @code{V2SI} for a vector of two 32-bit integers, 8199@code{V4HI} for a vector of four 16-bit integers, and @code{V8QI} for a 8200vector of eight 8-bit integers. Some of the built-in functions operate on 8201MMX registers as a whole 64-bit entity, these use @code{V1DI} as their mode. 8202 8203If 3DNow!@: extensions are enabled, @code{V2SF} is used as a mode for a vector 8204of two 32-bit floating point values. 8205 8206If SSE extensions are enabled, @code{V4SF} is used for a vector of four 32-bit 8207floating point values. Some instructions use a vector of four 32-bit 8208integers, these use @code{V4SI}. Finally, some instructions operate on an 8209entire vector register, interpreting it as a 128-bit integer, these use mode 8210@code{TI}. 8211 8212In 64-bit mode, the x86-64 family of processors uses additional built-in 8213functions for efficient use of @code{TF} (@code{__float128}) 128-bit 8214floating point and @code{TC} 128-bit complex floating point values. 8215 8216The following floating point built-in functions are available in 64-bit 8217mode. All of them implement the function that is part of the name. 8218 8219@smallexample 8220__float128 __builtin_fabsq (__float128) 8221__float128 __builtin_copysignq (__float128, __float128) 8222@end smallexample 8223 8224The following floating point built-in functions are made available in the 822564-bit mode. 8226 8227@table @code 8228@item __float128 __builtin_infq (void) 8229Similar to @code{__builtin_inf}, except the return type is @code{__float128}. 8230@findex __builtin_infq 8231 8232@item __float128 __builtin_huge_valq (void) 8233Similar to @code{__builtin_huge_val}, except the return type is @code{__float128}. 8234@findex __builtin_huge_valq 8235@end table 8236 8237The following built-in functions are made available by @option{-mmmx}. 8238All of them generate the machine instruction that is part of the name. 8239 8240@smallexample 8241v8qi __builtin_ia32_paddb (v8qi, v8qi) 8242v4hi __builtin_ia32_paddw (v4hi, v4hi) 8243v2si __builtin_ia32_paddd (v2si, v2si) 8244v8qi __builtin_ia32_psubb (v8qi, v8qi) 8245v4hi __builtin_ia32_psubw (v4hi, v4hi) 8246v2si __builtin_ia32_psubd (v2si, v2si) 8247v8qi __builtin_ia32_paddsb (v8qi, v8qi) 8248v4hi __builtin_ia32_paddsw (v4hi, v4hi) 8249v8qi __builtin_ia32_psubsb (v8qi, v8qi) 8250v4hi __builtin_ia32_psubsw (v4hi, v4hi) 8251v8qi __builtin_ia32_paddusb (v8qi, v8qi) 8252v4hi __builtin_ia32_paddusw (v4hi, v4hi) 8253v8qi __builtin_ia32_psubusb (v8qi, v8qi) 8254v4hi __builtin_ia32_psubusw (v4hi, v4hi) 8255v4hi __builtin_ia32_pmullw (v4hi, v4hi) 8256v4hi __builtin_ia32_pmulhw (v4hi, v4hi) 8257di __builtin_ia32_pand (di, di) 8258di __builtin_ia32_pandn (di,di) 8259di __builtin_ia32_por (di, di) 8260di __builtin_ia32_pxor (di, di) 8261v8qi __builtin_ia32_pcmpeqb (v8qi, v8qi) 8262v4hi __builtin_ia32_pcmpeqw (v4hi, v4hi) 8263v2si __builtin_ia32_pcmpeqd (v2si, v2si) 8264v8qi __builtin_ia32_pcmpgtb (v8qi, v8qi) 8265v4hi __builtin_ia32_pcmpgtw (v4hi, v4hi) 8266v2si __builtin_ia32_pcmpgtd (v2si, v2si) 8267v8qi __builtin_ia32_punpckhbw (v8qi, v8qi) 8268v4hi __builtin_ia32_punpckhwd (v4hi, v4hi) 8269v2si __builtin_ia32_punpckhdq (v2si, v2si) 8270v8qi __builtin_ia32_punpcklbw (v8qi, v8qi) 8271v4hi __builtin_ia32_punpcklwd (v4hi, v4hi) 8272v2si __builtin_ia32_punpckldq (v2si, v2si) 8273v8qi __builtin_ia32_packsswb (v4hi, v4hi) 8274v4hi __builtin_ia32_packssdw (v2si, v2si) 8275v8qi __builtin_ia32_packuswb (v4hi, v4hi) 8276 8277v4hi __builtin_ia32_psllw (v4hi, v4hi) 8278v2si __builtin_ia32_pslld (v2si, v2si) 8279v1di __builtin_ia32_psllq (v1di, v1di) 8280v4hi __builtin_ia32_psrlw (v4hi, v4hi) 8281v2si __builtin_ia32_psrld (v2si, v2si) 8282v1di __builtin_ia32_psrlq (v1di, v1di) 8283v4hi __builtin_ia32_psraw (v4hi, v4hi) 8284v2si __builtin_ia32_psrad (v2si, v2si) 8285v4hi __builtin_ia32_psllwi (v4hi, int) 8286v2si __builtin_ia32_pslldi (v2si, int) 8287v1di __builtin_ia32_psllqi (v1di, int) 8288v4hi __builtin_ia32_psrlwi (v4hi, int) 8289v2si __builtin_ia32_psrldi (v2si, int) 8290v1di __builtin_ia32_psrlqi (v1di, int) 8291v4hi __builtin_ia32_psrawi (v4hi, int) 8292v2si __builtin_ia32_psradi (v2si, int) 8293 8294@end smallexample 8295 8296The following built-in functions are made available either with 8297@option{-msse}, or with a combination of @option{-m3dnow} and 8298@option{-march=athlon}. All of them generate the machine 8299instruction that is part of the name. 8300 8301@smallexample 8302v4hi __builtin_ia32_pmulhuw (v4hi, v4hi) 8303v8qi __builtin_ia32_pavgb (v8qi, v8qi) 8304v4hi __builtin_ia32_pavgw (v4hi, v4hi) 8305v1di __builtin_ia32_psadbw (v8qi, v8qi) 8306v8qi __builtin_ia32_pmaxub (v8qi, v8qi) 8307v4hi __builtin_ia32_pmaxsw (v4hi, v4hi) 8308v8qi __builtin_ia32_pminub (v8qi, v8qi) 8309v4hi __builtin_ia32_pminsw (v4hi, v4hi) 8310int __builtin_ia32_pextrw (v4hi, int) 8311v4hi __builtin_ia32_pinsrw (v4hi, int, int) 8312int __builtin_ia32_pmovmskb (v8qi) 8313void __builtin_ia32_maskmovq (v8qi, v8qi, char *) 8314void __builtin_ia32_movntq (di *, di) 8315void __builtin_ia32_sfence (void) 8316@end smallexample 8317 8318The following built-in functions are available when @option{-msse} is used. 8319All of them generate the machine instruction that is part of the name. 8320 8321@smallexample 8322int __builtin_ia32_comieq (v4sf, v4sf) 8323int __builtin_ia32_comineq (v4sf, v4sf) 8324int __builtin_ia32_comilt (v4sf, v4sf) 8325int __builtin_ia32_comile (v4sf, v4sf) 8326int __builtin_ia32_comigt (v4sf, v4sf) 8327int __builtin_ia32_comige (v4sf, v4sf) 8328int __builtin_ia32_ucomieq (v4sf, v4sf) 8329int __builtin_ia32_ucomineq (v4sf, v4sf) 8330int __builtin_ia32_ucomilt (v4sf, v4sf) 8331int __builtin_ia32_ucomile (v4sf, v4sf) 8332int __builtin_ia32_ucomigt (v4sf, v4sf) 8333int __builtin_ia32_ucomige (v4sf, v4sf) 8334v4sf __builtin_ia32_addps (v4sf, v4sf) 8335v4sf __builtin_ia32_subps (v4sf, v4sf) 8336v4sf __builtin_ia32_mulps (v4sf, v4sf) 8337v4sf __builtin_ia32_divps (v4sf, v4sf) 8338v4sf __builtin_ia32_addss (v4sf, v4sf) 8339v4sf __builtin_ia32_subss (v4sf, v4sf) 8340v4sf __builtin_ia32_mulss (v4sf, v4sf) 8341v4sf __builtin_ia32_divss (v4sf, v4sf) 8342v4si __builtin_ia32_cmpeqps (v4sf, v4sf) 8343v4si __builtin_ia32_cmpltps (v4sf, v4sf) 8344v4si __builtin_ia32_cmpleps (v4sf, v4sf) 8345v4si __builtin_ia32_cmpgtps (v4sf, v4sf) 8346v4si __builtin_ia32_cmpgeps (v4sf, v4sf) 8347v4si __builtin_ia32_cmpunordps (v4sf, v4sf) 8348v4si __builtin_ia32_cmpneqps (v4sf, v4sf) 8349v4si __builtin_ia32_cmpnltps (v4sf, v4sf) 8350v4si __builtin_ia32_cmpnleps (v4sf, v4sf) 8351v4si __builtin_ia32_cmpngtps (v4sf, v4sf) 8352v4si __builtin_ia32_cmpngeps (v4sf, v4sf) 8353v4si __builtin_ia32_cmpordps (v4sf, v4sf) 8354v4si __builtin_ia32_cmpeqss (v4sf, v4sf) 8355v4si __builtin_ia32_cmpltss (v4sf, v4sf) 8356v4si __builtin_ia32_cmpless (v4sf, v4sf) 8357v4si __builtin_ia32_cmpunordss (v4sf, v4sf) 8358v4si __builtin_ia32_cmpneqss (v4sf, v4sf) 8359v4si __builtin_ia32_cmpnlts (v4sf, v4sf) 8360v4si __builtin_ia32_cmpnless (v4sf, v4sf) 8361v4si __builtin_ia32_cmpordss (v4sf, v4sf) 8362v4sf __builtin_ia32_maxps (v4sf, v4sf) 8363v4sf __builtin_ia32_maxss (v4sf, v4sf) 8364v4sf __builtin_ia32_minps (v4sf, v4sf) 8365v4sf __builtin_ia32_minss (v4sf, v4sf) 8366v4sf __builtin_ia32_andps (v4sf, v4sf) 8367v4sf __builtin_ia32_andnps (v4sf, v4sf) 8368v4sf __builtin_ia32_orps (v4sf, v4sf) 8369v4sf __builtin_ia32_xorps (v4sf, v4sf) 8370v4sf __builtin_ia32_movss (v4sf, v4sf) 8371v4sf __builtin_ia32_movhlps (v4sf, v4sf) 8372v4sf __builtin_ia32_movlhps (v4sf, v4sf) 8373v4sf __builtin_ia32_unpckhps (v4sf, v4sf) 8374v4sf __builtin_ia32_unpcklps (v4sf, v4sf) 8375v4sf __builtin_ia32_cvtpi2ps (v4sf, v2si) 8376v4sf __builtin_ia32_cvtsi2ss (v4sf, int) 8377v2si __builtin_ia32_cvtps2pi (v4sf) 8378int __builtin_ia32_cvtss2si (v4sf) 8379v2si __builtin_ia32_cvttps2pi (v4sf) 8380int __builtin_ia32_cvttss2si (v4sf) 8381v4sf __builtin_ia32_rcpps (v4sf) 8382v4sf __builtin_ia32_rsqrtps (v4sf) 8383v4sf __builtin_ia32_sqrtps (v4sf) 8384v4sf __builtin_ia32_rcpss (v4sf) 8385v4sf __builtin_ia32_rsqrtss (v4sf) 8386v4sf __builtin_ia32_sqrtss (v4sf) 8387v4sf __builtin_ia32_shufps (v4sf, v4sf, int) 8388void __builtin_ia32_movntps (float *, v4sf) 8389int __builtin_ia32_movmskps (v4sf) 8390@end smallexample 8391 8392The following built-in functions are available when @option{-msse} is used. 8393 8394@table @code 8395@item v4sf __builtin_ia32_loadaps (float *) 8396Generates the @code{movaps} machine instruction as a load from memory. 8397@item void __builtin_ia32_storeaps (float *, v4sf) 8398Generates the @code{movaps} machine instruction as a store to memory. 8399@item v4sf __builtin_ia32_loadups (float *) 8400Generates the @code{movups} machine instruction as a load from memory. 8401@item void __builtin_ia32_storeups (float *, v4sf) 8402Generates the @code{movups} machine instruction as a store to memory. 8403@item v4sf __builtin_ia32_loadsss (float *) 8404Generates the @code{movss} machine instruction as a load from memory. 8405@item void __builtin_ia32_storess (float *, v4sf) 8406Generates the @code{movss} machine instruction as a store to memory. 8407@item v4sf __builtin_ia32_loadhps (v4sf, const v2sf *) 8408Generates the @code{movhps} machine instruction as a load from memory. 8409@item v4sf __builtin_ia32_loadlps (v4sf, const v2sf *) 8410Generates the @code{movlps} machine instruction as a load from memory 8411@item void __builtin_ia32_storehps (v2sf *, v4sf) 8412Generates the @code{movhps} machine instruction as a store to memory. 8413@item void __builtin_ia32_storelps (v2sf *, v4sf) 8414Generates the @code{movlps} machine instruction as a store to memory. 8415@end table 8416 8417The following built-in functions are available when @option{-msse2} is used. 8418All of them generate the machine instruction that is part of the name. 8419 8420@smallexample 8421int __builtin_ia32_comisdeq (v2df, v2df) 8422int __builtin_ia32_comisdlt (v2df, v2df) 8423int __builtin_ia32_comisdle (v2df, v2df) 8424int __builtin_ia32_comisdgt (v2df, v2df) 8425int __builtin_ia32_comisdge (v2df, v2df) 8426int __builtin_ia32_comisdneq (v2df, v2df) 8427int __builtin_ia32_ucomisdeq (v2df, v2df) 8428int __builtin_ia32_ucomisdlt (v2df, v2df) 8429int __builtin_ia32_ucomisdle (v2df, v2df) 8430int __builtin_ia32_ucomisdgt (v2df, v2df) 8431int __builtin_ia32_ucomisdge (v2df, v2df) 8432int __builtin_ia32_ucomisdneq (v2df, v2df) 8433v2df __builtin_ia32_cmpeqpd (v2df, v2df) 8434v2df __builtin_ia32_cmpltpd (v2df, v2df) 8435v2df __builtin_ia32_cmplepd (v2df, v2df) 8436v2df __builtin_ia32_cmpgtpd (v2df, v2df) 8437v2df __builtin_ia32_cmpgepd (v2df, v2df) 8438v2df __builtin_ia32_cmpunordpd (v2df, v2df) 8439v2df __builtin_ia32_cmpneqpd (v2df, v2df) 8440v2df __builtin_ia32_cmpnltpd (v2df, v2df) 8441v2df __builtin_ia32_cmpnlepd (v2df, v2df) 8442v2df __builtin_ia32_cmpngtpd (v2df, v2df) 8443v2df __builtin_ia32_cmpngepd (v2df, v2df) 8444v2df __builtin_ia32_cmpordpd (v2df, v2df) 8445v2df __builtin_ia32_cmpeqsd (v2df, v2df) 8446v2df __builtin_ia32_cmpltsd (v2df, v2df) 8447v2df __builtin_ia32_cmplesd (v2df, v2df) 8448v2df __builtin_ia32_cmpunordsd (v2df, v2df) 8449v2df __builtin_ia32_cmpneqsd (v2df, v2df) 8450v2df __builtin_ia32_cmpnltsd (v2df, v2df) 8451v2df __builtin_ia32_cmpnlesd (v2df, v2df) 8452v2df __builtin_ia32_cmpordsd (v2df, v2df) 8453v2di __builtin_ia32_paddq (v2di, v2di) 8454v2di __builtin_ia32_psubq (v2di, v2di) 8455v2df __builtin_ia32_addpd (v2df, v2df) 8456v2df __builtin_ia32_subpd (v2df, v2df) 8457v2df __builtin_ia32_mulpd (v2df, v2df) 8458v2df __builtin_ia32_divpd (v2df, v2df) 8459v2df __builtin_ia32_addsd (v2df, v2df) 8460v2df __builtin_ia32_subsd (v2df, v2df) 8461v2df __builtin_ia32_mulsd (v2df, v2df) 8462v2df __builtin_ia32_divsd (v2df, v2df) 8463v2df __builtin_ia32_minpd (v2df, v2df) 8464v2df __builtin_ia32_maxpd (v2df, v2df) 8465v2df __builtin_ia32_minsd (v2df, v2df) 8466v2df __builtin_ia32_maxsd (v2df, v2df) 8467v2df __builtin_ia32_andpd (v2df, v2df) 8468v2df __builtin_ia32_andnpd (v2df, v2df) 8469v2df __builtin_ia32_orpd (v2df, v2df) 8470v2df __builtin_ia32_xorpd (v2df, v2df) 8471v2df __builtin_ia32_movsd (v2df, v2df) 8472v2df __builtin_ia32_unpckhpd (v2df, v2df) 8473v2df __builtin_ia32_unpcklpd (v2df, v2df) 8474v16qi __builtin_ia32_paddb128 (v16qi, v16qi) 8475v8hi __builtin_ia32_paddw128 (v8hi, v8hi) 8476v4si __builtin_ia32_paddd128 (v4si, v4si) 8477v2di __builtin_ia32_paddq128 (v2di, v2di) 8478v16qi __builtin_ia32_psubb128 (v16qi, v16qi) 8479v8hi __builtin_ia32_psubw128 (v8hi, v8hi) 8480v4si __builtin_ia32_psubd128 (v4si, v4si) 8481v2di __builtin_ia32_psubq128 (v2di, v2di) 8482v8hi __builtin_ia32_pmullw128 (v8hi, v8hi) 8483v8hi __builtin_ia32_pmulhw128 (v8hi, v8hi) 8484v2di __builtin_ia32_pand128 (v2di, v2di) 8485v2di __builtin_ia32_pandn128 (v2di, v2di) 8486v2di __builtin_ia32_por128 (v2di, v2di) 8487v2di __builtin_ia32_pxor128 (v2di, v2di) 8488v16qi __builtin_ia32_pavgb128 (v16qi, v16qi) 8489v8hi __builtin_ia32_pavgw128 (v8hi, v8hi) 8490v16qi __builtin_ia32_pcmpeqb128 (v16qi, v16qi) 8491v8hi __builtin_ia32_pcmpeqw128 (v8hi, v8hi) 8492v4si __builtin_ia32_pcmpeqd128 (v4si, v4si) 8493v16qi __builtin_ia32_pcmpgtb128 (v16qi, v16qi) 8494v8hi __builtin_ia32_pcmpgtw128 (v8hi, v8hi) 8495v4si __builtin_ia32_pcmpgtd128 (v4si, v4si) 8496v16qi __builtin_ia32_pmaxub128 (v16qi, v16qi) 8497v8hi __builtin_ia32_pmaxsw128 (v8hi, v8hi) 8498v16qi __builtin_ia32_pminub128 (v16qi, v16qi) 8499v8hi __builtin_ia32_pminsw128 (v8hi, v8hi) 8500v16qi __builtin_ia32_punpckhbw128 (v16qi, v16qi) 8501v8hi __builtin_ia32_punpckhwd128 (v8hi, v8hi) 8502v4si __builtin_ia32_punpckhdq128 (v4si, v4si) 8503v2di __builtin_ia32_punpckhqdq128 (v2di, v2di) 8504v16qi __builtin_ia32_punpcklbw128 (v16qi, v16qi) 8505v8hi __builtin_ia32_punpcklwd128 (v8hi, v8hi) 8506v4si __builtin_ia32_punpckldq128 (v4si, v4si) 8507v2di __builtin_ia32_punpcklqdq128 (v2di, v2di) 8508v16qi __builtin_ia32_packsswb128 (v8hi, v8hi) 8509v8hi __builtin_ia32_packssdw128 (v4si, v4si) 8510v16qi __builtin_ia32_packuswb128 (v8hi, v8hi) 8511v8hi __builtin_ia32_pmulhuw128 (v8hi, v8hi) 8512void __builtin_ia32_maskmovdqu (v16qi, v16qi) 8513v2df __builtin_ia32_loadupd (double *) 8514void __builtin_ia32_storeupd (double *, v2df) 8515v2df __builtin_ia32_loadhpd (v2df, double const *) 8516v2df __builtin_ia32_loadlpd (v2df, double const *) 8517int __builtin_ia32_movmskpd (v2df) 8518int __builtin_ia32_pmovmskb128 (v16qi) 8519void __builtin_ia32_movnti (int *, int) 8520void __builtin_ia32_movntpd (double *, v2df) 8521void __builtin_ia32_movntdq (v2df *, v2df) 8522v4si __builtin_ia32_pshufd (v4si, int) 8523v8hi __builtin_ia32_pshuflw (v8hi, int) 8524v8hi __builtin_ia32_pshufhw (v8hi, int) 8525v2di __builtin_ia32_psadbw128 (v16qi, v16qi) 8526v2df __builtin_ia32_sqrtpd (v2df) 8527v2df __builtin_ia32_sqrtsd (v2df) 8528v2df __builtin_ia32_shufpd (v2df, v2df, int) 8529v2df __builtin_ia32_cvtdq2pd (v4si) 8530v4sf __builtin_ia32_cvtdq2ps (v4si) 8531v4si __builtin_ia32_cvtpd2dq (v2df) 8532v2si __builtin_ia32_cvtpd2pi (v2df) 8533v4sf __builtin_ia32_cvtpd2ps (v2df) 8534v4si __builtin_ia32_cvttpd2dq (v2df) 8535v2si __builtin_ia32_cvttpd2pi (v2df) 8536v2df __builtin_ia32_cvtpi2pd (v2si) 8537int __builtin_ia32_cvtsd2si (v2df) 8538int __builtin_ia32_cvttsd2si (v2df) 8539long long __builtin_ia32_cvtsd2si64 (v2df) 8540long long __builtin_ia32_cvttsd2si64 (v2df) 8541v4si __builtin_ia32_cvtps2dq (v4sf) 8542v2df __builtin_ia32_cvtps2pd (v4sf) 8543v4si __builtin_ia32_cvttps2dq (v4sf) 8544v2df __builtin_ia32_cvtsi2sd (v2df, int) 8545v2df __builtin_ia32_cvtsi642sd (v2df, long long) 8546v4sf __builtin_ia32_cvtsd2ss (v4sf, v2df) 8547v2df __builtin_ia32_cvtss2sd (v2df, v4sf) 8548void __builtin_ia32_clflush (const void *) 8549void __builtin_ia32_lfence (void) 8550void __builtin_ia32_mfence (void) 8551v16qi __builtin_ia32_loaddqu (const char *) 8552void __builtin_ia32_storedqu (char *, v16qi) 8553v1di __builtin_ia32_pmuludq (v2si, v2si) 8554v2di __builtin_ia32_pmuludq128 (v4si, v4si) 8555v8hi __builtin_ia32_psllw128 (v8hi, v8hi) 8556v4si __builtin_ia32_pslld128 (v4si, v4si) 8557v2di __builtin_ia32_psllq128 (v2di, v2di) 8558v8hi __builtin_ia32_psrlw128 (v8hi, v8hi) 8559v4si __builtin_ia32_psrld128 (v4si, v4si) 8560v2di __builtin_ia32_psrlq128 (v2di, v2di) 8561v8hi __builtin_ia32_psraw128 (v8hi, v8hi) 8562v4si __builtin_ia32_psrad128 (v4si, v4si) 8563v2di __builtin_ia32_pslldqi128 (v2di, int) 8564v8hi __builtin_ia32_psllwi128 (v8hi, int) 8565v4si __builtin_ia32_pslldi128 (v4si, int) 8566v2di __builtin_ia32_psllqi128 (v2di, int) 8567v2di __builtin_ia32_psrldqi128 (v2di, int) 8568v8hi __builtin_ia32_psrlwi128 (v8hi, int) 8569v4si __builtin_ia32_psrldi128 (v4si, int) 8570v2di __builtin_ia32_psrlqi128 (v2di, int) 8571v8hi __builtin_ia32_psrawi128 (v8hi, int) 8572v4si __builtin_ia32_psradi128 (v4si, int) 8573v4si __builtin_ia32_pmaddwd128 (v8hi, v8hi) 8574v2di __builtin_ia32_movq128 (v2di) 8575@end smallexample 8576 8577The following built-in functions are available when @option{-msse3} is used. 8578All of them generate the machine instruction that is part of the name. 8579 8580@smallexample 8581v2df __builtin_ia32_addsubpd (v2df, v2df) 8582v4sf __builtin_ia32_addsubps (v4sf, v4sf) 8583v2df __builtin_ia32_haddpd (v2df, v2df) 8584v4sf __builtin_ia32_haddps (v4sf, v4sf) 8585v2df __builtin_ia32_hsubpd (v2df, v2df) 8586v4sf __builtin_ia32_hsubps (v4sf, v4sf) 8587v16qi __builtin_ia32_lddqu (char const *) 8588void __builtin_ia32_monitor (void *, unsigned int, unsigned int) 8589v2df __builtin_ia32_movddup (v2df) 8590v4sf __builtin_ia32_movshdup (v4sf) 8591v4sf __builtin_ia32_movsldup (v4sf) 8592void __builtin_ia32_mwait (unsigned int, unsigned int) 8593@end smallexample 8594 8595The following built-in functions are available when @option{-msse3} is used. 8596 8597@table @code 8598@item v2df __builtin_ia32_loadddup (double const *) 8599Generates the @code{movddup} machine instruction as a load from memory. 8600@end table 8601 8602The following built-in functions are available when @option{-mssse3} is used. 8603All of them generate the machine instruction that is part of the name 8604with MMX registers. 8605 8606@smallexample 8607v2si __builtin_ia32_phaddd (v2si, v2si) 8608v4hi __builtin_ia32_phaddw (v4hi, v4hi) 8609v4hi __builtin_ia32_phaddsw (v4hi, v4hi) 8610v2si __builtin_ia32_phsubd (v2si, v2si) 8611v4hi __builtin_ia32_phsubw (v4hi, v4hi) 8612v4hi __builtin_ia32_phsubsw (v4hi, v4hi) 8613v4hi __builtin_ia32_pmaddubsw (v8qi, v8qi) 8614v4hi __builtin_ia32_pmulhrsw (v4hi, v4hi) 8615v8qi __builtin_ia32_pshufb (v8qi, v8qi) 8616v8qi __builtin_ia32_psignb (v8qi, v8qi) 8617v2si __builtin_ia32_psignd (v2si, v2si) 8618v4hi __builtin_ia32_psignw (v4hi, v4hi) 8619v1di __builtin_ia32_palignr (v1di, v1di, int) 8620v8qi __builtin_ia32_pabsb (v8qi) 8621v2si __builtin_ia32_pabsd (v2si) 8622v4hi __builtin_ia32_pabsw (v4hi) 8623@end smallexample 8624 8625The following built-in functions are available when @option{-mssse3} is used. 8626All of them generate the machine instruction that is part of the name 8627with SSE registers. 8628 8629@smallexample 8630v4si __builtin_ia32_phaddd128 (v4si, v4si) 8631v8hi __builtin_ia32_phaddw128 (v8hi, v8hi) 8632v8hi __builtin_ia32_phaddsw128 (v8hi, v8hi) 8633v4si __builtin_ia32_phsubd128 (v4si, v4si) 8634v8hi __builtin_ia32_phsubw128 (v8hi, v8hi) 8635v8hi __builtin_ia32_phsubsw128 (v8hi, v8hi) 8636v8hi __builtin_ia32_pmaddubsw128 (v16qi, v16qi) 8637v8hi __builtin_ia32_pmulhrsw128 (v8hi, v8hi) 8638v16qi __builtin_ia32_pshufb128 (v16qi, v16qi) 8639v16qi __builtin_ia32_psignb128 (v16qi, v16qi) 8640v4si __builtin_ia32_psignd128 (v4si, v4si) 8641v8hi __builtin_ia32_psignw128 (v8hi, v8hi) 8642v2di __builtin_ia32_palignr128 (v2di, v2di, int) 8643v16qi __builtin_ia32_pabsb128 (v16qi) 8644v4si __builtin_ia32_pabsd128 (v4si) 8645v8hi __builtin_ia32_pabsw128 (v8hi) 8646@end smallexample 8647 8648The following built-in functions are available when @option{-msse4.1} is 8649used. All of them generate the machine instruction that is part of the 8650name. 8651 8652@smallexample 8653v2df __builtin_ia32_blendpd (v2df, v2df, const int) 8654v4sf __builtin_ia32_blendps (v4sf, v4sf, const int) 8655v2df __builtin_ia32_blendvpd (v2df, v2df, v2df) 8656v4sf __builtin_ia32_blendvps (v4sf, v4sf, v4sf) 8657v2df __builtin_ia32_dppd (v2df, v2df, const int) 8658v4sf __builtin_ia32_dpps (v4sf, v4sf, const int) 8659v4sf __builtin_ia32_insertps128 (v4sf, v4sf, const int) 8660v2di __builtin_ia32_movntdqa (v2di *); 8661v16qi __builtin_ia32_mpsadbw128 (v16qi, v16qi, const int) 8662v8hi __builtin_ia32_packusdw128 (v4si, v4si) 8663v16qi __builtin_ia32_pblendvb128 (v16qi, v16qi, v16qi) 8664v8hi __builtin_ia32_pblendw128 (v8hi, v8hi, const int) 8665v2di __builtin_ia32_pcmpeqq (v2di, v2di) 8666v8hi __builtin_ia32_phminposuw128 (v8hi) 8667v16qi __builtin_ia32_pmaxsb128 (v16qi, v16qi) 8668v4si __builtin_ia32_pmaxsd128 (v4si, v4si) 8669v4si __builtin_ia32_pmaxud128 (v4si, v4si) 8670v8hi __builtin_ia32_pmaxuw128 (v8hi, v8hi) 8671v16qi __builtin_ia32_pminsb128 (v16qi, v16qi) 8672v4si __builtin_ia32_pminsd128 (v4si, v4si) 8673v4si __builtin_ia32_pminud128 (v4si, v4si) 8674v8hi __builtin_ia32_pminuw128 (v8hi, v8hi) 8675v4si __builtin_ia32_pmovsxbd128 (v16qi) 8676v2di __builtin_ia32_pmovsxbq128 (v16qi) 8677v8hi __builtin_ia32_pmovsxbw128 (v16qi) 8678v2di __builtin_ia32_pmovsxdq128 (v4si) 8679v4si __builtin_ia32_pmovsxwd128 (v8hi) 8680v2di __builtin_ia32_pmovsxwq128 (v8hi) 8681v4si __builtin_ia32_pmovzxbd128 (v16qi) 8682v2di __builtin_ia32_pmovzxbq128 (v16qi) 8683v8hi __builtin_ia32_pmovzxbw128 (v16qi) 8684v2di __builtin_ia32_pmovzxdq128 (v4si) 8685v4si __builtin_ia32_pmovzxwd128 (v8hi) 8686v2di __builtin_ia32_pmovzxwq128 (v8hi) 8687v2di __builtin_ia32_pmuldq128 (v4si, v4si) 8688v4si __builtin_ia32_pmulld128 (v4si, v4si) 8689int __builtin_ia32_ptestc128 (v2di, v2di) 8690int __builtin_ia32_ptestnzc128 (v2di, v2di) 8691int __builtin_ia32_ptestz128 (v2di, v2di) 8692v2df __builtin_ia32_roundpd (v2df, const int) 8693v4sf __builtin_ia32_roundps (v4sf, const int) 8694v2df __builtin_ia32_roundsd (v2df, v2df, const int) 8695v4sf __builtin_ia32_roundss (v4sf, v4sf, const int) 8696@end smallexample 8697 8698The following built-in functions are available when @option{-msse4.1} is 8699used. 8700 8701@table @code 8702@item v4sf __builtin_ia32_vec_set_v4sf (v4sf, float, const int) 8703Generates the @code{insertps} machine instruction. 8704@item int __builtin_ia32_vec_ext_v16qi (v16qi, const int) 8705Generates the @code{pextrb} machine instruction. 8706@item v16qi __builtin_ia32_vec_set_v16qi (v16qi, int, const int) 8707Generates the @code{pinsrb} machine instruction. 8708@item v4si __builtin_ia32_vec_set_v4si (v4si, int, const int) 8709Generates the @code{pinsrd} machine instruction. 8710@item v2di __builtin_ia32_vec_set_v2di (v2di, long long, const int) 8711Generates the @code{pinsrq} machine instruction in 64bit mode. 8712@end table 8713 8714The following built-in functions are changed to generate new SSE4.1 8715instructions when @option{-msse4.1} is used. 8716 8717@table @code 8718@item float __builtin_ia32_vec_ext_v4sf (v4sf, const int) 8719Generates the @code{extractps} machine instruction. 8720@item int __builtin_ia32_vec_ext_v4si (v4si, const int) 8721Generates the @code{pextrd} machine instruction. 8722@item long long __builtin_ia32_vec_ext_v2di (v2di, const int) 8723Generates the @code{pextrq} machine instruction in 64bit mode. 8724@end table 8725 8726The following built-in functions are available when @option{-msse4.2} is 8727used. All of them generate the machine instruction that is part of the 8728name. 8729 8730@smallexample 8731v16qi __builtin_ia32_pcmpestrm128 (v16qi, int, v16qi, int, const int) 8732int __builtin_ia32_pcmpestri128 (v16qi, int, v16qi, int, const int) 8733int __builtin_ia32_pcmpestria128 (v16qi, int, v16qi, int, const int) 8734int __builtin_ia32_pcmpestric128 (v16qi, int, v16qi, int, const int) 8735int __builtin_ia32_pcmpestrio128 (v16qi, int, v16qi, int, const int) 8736int __builtin_ia32_pcmpestris128 (v16qi, int, v16qi, int, const int) 8737int __builtin_ia32_pcmpestriz128 (v16qi, int, v16qi, int, const int) 8738v16qi __builtin_ia32_pcmpistrm128 (v16qi, v16qi, const int) 8739int __builtin_ia32_pcmpistri128 (v16qi, v16qi, const int) 8740int __builtin_ia32_pcmpistria128 (v16qi, v16qi, const int) 8741int __builtin_ia32_pcmpistric128 (v16qi, v16qi, const int) 8742int __builtin_ia32_pcmpistrio128 (v16qi, v16qi, const int) 8743int __builtin_ia32_pcmpistris128 (v16qi, v16qi, const int) 8744int __builtin_ia32_pcmpistriz128 (v16qi, v16qi, const int) 8745v2di __builtin_ia32_pcmpgtq (v2di, v2di) 8746@end smallexample 8747 8748The following built-in functions are available when @option{-msse4.2} is 8749used. 8750 8751@table @code 8752@item unsigned int __builtin_ia32_crc32qi (unsigned int, unsigned char) 8753Generates the @code{crc32b} machine instruction. 8754@item unsigned int __builtin_ia32_crc32hi (unsigned int, unsigned short) 8755Generates the @code{crc32w} machine instruction. 8756@item unsigned int __builtin_ia32_crc32si (unsigned int, unsigned int) 8757Generates the @code{crc32l} machine instruction. 8758@item unsigned long long __builtin_ia32_crc32di (unsigned long long, unsigned long long) 8759Generates the @code{crc32q} machine instruction. 8760@end table 8761 8762The following built-in functions are changed to generate new SSE4.2 8763instructions when @option{-msse4.2} is used. 8764 8765@table @code 8766@item int __builtin_popcount (unsigned int) 8767Generates the @code{popcntl} machine instruction. 8768@item int __builtin_popcountl (unsigned long) 8769Generates the @code{popcntl} or @code{popcntq} machine instruction, 8770depending on the size of @code{unsigned long}. 8771@item int __builtin_popcountll (unsigned long long) 8772Generates the @code{popcntq} machine instruction. 8773@end table 8774 8775The following built-in functions are available when @option{-mavx} is 8776used. All of them generate the machine instruction that is part of the 8777name. 8778 8779@smallexample 8780v4df __builtin_ia32_addpd256 (v4df,v4df) 8781v8sf __builtin_ia32_addps256 (v8sf,v8sf) 8782v4df __builtin_ia32_addsubpd256 (v4df,v4df) 8783v8sf __builtin_ia32_addsubps256 (v8sf,v8sf) 8784v4df __builtin_ia32_andnpd256 (v4df,v4df) 8785v8sf __builtin_ia32_andnps256 (v8sf,v8sf) 8786v4df __builtin_ia32_andpd256 (v4df,v4df) 8787v8sf __builtin_ia32_andps256 (v8sf,v8sf) 8788v4df __builtin_ia32_blendpd256 (v4df,v4df,int) 8789v8sf __builtin_ia32_blendps256 (v8sf,v8sf,int) 8790v4df __builtin_ia32_blendvpd256 (v4df,v4df,v4df) 8791v8sf __builtin_ia32_blendvps256 (v8sf,v8sf,v8sf) 8792v2df __builtin_ia32_cmppd (v2df,v2df,int) 8793v4df __builtin_ia32_cmppd256 (v4df,v4df,int) 8794v4sf __builtin_ia32_cmpps (v4sf,v4sf,int) 8795v8sf __builtin_ia32_cmpps256 (v8sf,v8sf,int) 8796v2df __builtin_ia32_cmpsd (v2df,v2df,int) 8797v4sf __builtin_ia32_cmpss (v4sf,v4sf,int) 8798v4df __builtin_ia32_cvtdq2pd256 (v4si) 8799v8sf __builtin_ia32_cvtdq2ps256 (v8si) 8800v4si __builtin_ia32_cvtpd2dq256 (v4df) 8801v4sf __builtin_ia32_cvtpd2ps256 (v4df) 8802v8si __builtin_ia32_cvtps2dq256 (v8sf) 8803v4df __builtin_ia32_cvtps2pd256 (v4sf) 8804v4si __builtin_ia32_cvttpd2dq256 (v4df) 8805v8si __builtin_ia32_cvttps2dq256 (v8sf) 8806v4df __builtin_ia32_divpd256 (v4df,v4df) 8807v8sf __builtin_ia32_divps256 (v8sf,v8sf) 8808v8sf __builtin_ia32_dpps256 (v8sf,v8sf,int) 8809v4df __builtin_ia32_haddpd256 (v4df,v4df) 8810v8sf __builtin_ia32_haddps256 (v8sf,v8sf) 8811v4df __builtin_ia32_hsubpd256 (v4df,v4df) 8812v8sf __builtin_ia32_hsubps256 (v8sf,v8sf) 8813v32qi __builtin_ia32_lddqu256 (pcchar) 8814v32qi __builtin_ia32_loaddqu256 (pcchar) 8815v4df __builtin_ia32_loadupd256 (pcdouble) 8816v8sf __builtin_ia32_loadups256 (pcfloat) 8817v2df __builtin_ia32_maskloadpd (pcv2df,v2df) 8818v4df __builtin_ia32_maskloadpd256 (pcv4df,v4df) 8819v4sf __builtin_ia32_maskloadps (pcv4sf,v4sf) 8820v8sf __builtin_ia32_maskloadps256 (pcv8sf,v8sf) 8821void __builtin_ia32_maskstorepd (pv2df,v2df,v2df) 8822void __builtin_ia32_maskstorepd256 (pv4df,v4df,v4df) 8823void __builtin_ia32_maskstoreps (pv4sf,v4sf,v4sf) 8824void __builtin_ia32_maskstoreps256 (pv8sf,v8sf,v8sf) 8825v4df __builtin_ia32_maxpd256 (v4df,v4df) 8826v8sf __builtin_ia32_maxps256 (v8sf,v8sf) 8827v4df __builtin_ia32_minpd256 (v4df,v4df) 8828v8sf __builtin_ia32_minps256 (v8sf,v8sf) 8829v4df __builtin_ia32_movddup256 (v4df) 8830int __builtin_ia32_movmskpd256 (v4df) 8831int __builtin_ia32_movmskps256 (v8sf) 8832v8sf __builtin_ia32_movshdup256 (v8sf) 8833v8sf __builtin_ia32_movsldup256 (v8sf) 8834v4df __builtin_ia32_mulpd256 (v4df,v4df) 8835v8sf __builtin_ia32_mulps256 (v8sf,v8sf) 8836v4df __builtin_ia32_orpd256 (v4df,v4df) 8837v8sf __builtin_ia32_orps256 (v8sf,v8sf) 8838v2df __builtin_ia32_pd_pd256 (v4df) 8839v4df __builtin_ia32_pd256_pd (v2df) 8840v4sf __builtin_ia32_ps_ps256 (v8sf) 8841v8sf __builtin_ia32_ps256_ps (v4sf) 8842int __builtin_ia32_ptestc256 (v4di,v4di,ptest) 8843int __builtin_ia32_ptestnzc256 (v4di,v4di,ptest) 8844int __builtin_ia32_ptestz256 (v4di,v4di,ptest) 8845v8sf __builtin_ia32_rcpps256 (v8sf) 8846v4df __builtin_ia32_roundpd256 (v4df,int) 8847v8sf __builtin_ia32_roundps256 (v8sf,int) 8848v8sf __builtin_ia32_rsqrtps_nr256 (v8sf) 8849v8sf __builtin_ia32_rsqrtps256 (v8sf) 8850v4df __builtin_ia32_shufpd256 (v4df,v4df,int) 8851v8sf __builtin_ia32_shufps256 (v8sf,v8sf,int) 8852v4si __builtin_ia32_si_si256 (v8si) 8853v8si __builtin_ia32_si256_si (v4si) 8854v4df __builtin_ia32_sqrtpd256 (v4df) 8855v8sf __builtin_ia32_sqrtps_nr256 (v8sf) 8856v8sf __builtin_ia32_sqrtps256 (v8sf) 8857void __builtin_ia32_storedqu256 (pchar,v32qi) 8858void __builtin_ia32_storeupd256 (pdouble,v4df) 8859void __builtin_ia32_storeups256 (pfloat,v8sf) 8860v4df __builtin_ia32_subpd256 (v4df,v4df) 8861v8sf __builtin_ia32_subps256 (v8sf,v8sf) 8862v4df __builtin_ia32_unpckhpd256 (v4df,v4df) 8863v8sf __builtin_ia32_unpckhps256 (v8sf,v8sf) 8864v4df __builtin_ia32_unpcklpd256 (v4df,v4df) 8865v8sf __builtin_ia32_unpcklps256 (v8sf,v8sf) 8866v4df __builtin_ia32_vbroadcastf128_pd256 (pcv2df) 8867v8sf __builtin_ia32_vbroadcastf128_ps256 (pcv4sf) 8868v4df __builtin_ia32_vbroadcastsd256 (pcdouble) 8869v4sf __builtin_ia32_vbroadcastss (pcfloat) 8870v8sf __builtin_ia32_vbroadcastss256 (pcfloat) 8871v2df __builtin_ia32_vextractf128_pd256 (v4df,int) 8872v4sf __builtin_ia32_vextractf128_ps256 (v8sf,int) 8873v4si __builtin_ia32_vextractf128_si256 (v8si,int) 8874v4df __builtin_ia32_vinsertf128_pd256 (v4df,v2df,int) 8875v8sf __builtin_ia32_vinsertf128_ps256 (v8sf,v4sf,int) 8876v8si __builtin_ia32_vinsertf128_si256 (v8si,v4si,int) 8877v4df __builtin_ia32_vperm2f128_pd256 (v4df,v4df,int) 8878v8sf __builtin_ia32_vperm2f128_ps256 (v8sf,v8sf,int) 8879v8si __builtin_ia32_vperm2f128_si256 (v8si,v8si,int) 8880v2df __builtin_ia32_vpermil2pd (v2df,v2df,v2di,int) 8881v4df __builtin_ia32_vpermil2pd256 (v4df,v4df,v4di,int) 8882v4sf __builtin_ia32_vpermil2ps (v4sf,v4sf,v4si,int) 8883v8sf __builtin_ia32_vpermil2ps256 (v8sf,v8sf,v8si,int) 8884v2df __builtin_ia32_vpermilpd (v2df,int) 8885v4df __builtin_ia32_vpermilpd256 (v4df,int) 8886v4sf __builtin_ia32_vpermilps (v4sf,int) 8887v8sf __builtin_ia32_vpermilps256 (v8sf,int) 8888v2df __builtin_ia32_vpermilvarpd (v2df,v2di) 8889v4df __builtin_ia32_vpermilvarpd256 (v4df,v4di) 8890v4sf __builtin_ia32_vpermilvarps (v4sf,v4si) 8891v8sf __builtin_ia32_vpermilvarps256 (v8sf,v8si) 8892int __builtin_ia32_vtestcpd (v2df,v2df,ptest) 8893int __builtin_ia32_vtestcpd256 (v4df,v4df,ptest) 8894int __builtin_ia32_vtestcps (v4sf,v4sf,ptest) 8895int __builtin_ia32_vtestcps256 (v8sf,v8sf,ptest) 8896int __builtin_ia32_vtestnzcpd (v2df,v2df,ptest) 8897int __builtin_ia32_vtestnzcpd256 (v4df,v4df,ptest) 8898int __builtin_ia32_vtestnzcps (v4sf,v4sf,ptest) 8899int __builtin_ia32_vtestnzcps256 (v8sf,v8sf,ptest) 8900int __builtin_ia32_vtestzpd (v2df,v2df,ptest) 8901int __builtin_ia32_vtestzpd256 (v4df,v4df,ptest) 8902int __builtin_ia32_vtestzps (v4sf,v4sf,ptest) 8903int __builtin_ia32_vtestzps256 (v8sf,v8sf,ptest) 8904void __builtin_ia32_vzeroall (void) 8905void __builtin_ia32_vzeroupper (void) 8906v4df __builtin_ia32_xorpd256 (v4df,v4df) 8907v8sf __builtin_ia32_xorps256 (v8sf,v8sf) 8908@end smallexample 8909 8910The following built-in functions are available when @option{-maes} is 8911used. All of them generate the machine instruction that is part of the 8912name. 8913 8914@smallexample 8915v2di __builtin_ia32_aesenc128 (v2di, v2di) 8916v2di __builtin_ia32_aesenclast128 (v2di, v2di) 8917v2di __builtin_ia32_aesdec128 (v2di, v2di) 8918v2di __builtin_ia32_aesdeclast128 (v2di, v2di) 8919v2di __builtin_ia32_aeskeygenassist128 (v2di, const int) 8920v2di __builtin_ia32_aesimc128 (v2di) 8921@end smallexample 8922 8923The following built-in function is available when @option{-mpclmul} is 8924used. 8925 8926@table @code 8927@item v2di __builtin_ia32_pclmulqdq128 (v2di, v2di, const int) 8928Generates the @code{pclmulqdq} machine instruction. 8929@end table 8930 8931The following built-in functions are available when @option{-msse4a} is used. 8932All of them generate the machine instruction that is part of the name. 8933 8934@smallexample 8935void __builtin_ia32_movntsd (double *, v2df) 8936void __builtin_ia32_movntss (float *, v4sf) 8937v2di __builtin_ia32_extrq (v2di, v16qi) 8938v2di __builtin_ia32_extrqi (v2di, const unsigned int, const unsigned int) 8939v2di __builtin_ia32_insertq (v2di, v2di) 8940v2di __builtin_ia32_insertqi (v2di, v2di, const unsigned int, const unsigned int) 8941@end smallexample 8942 8943The following built-in functions are available when @option{-mxop} is used. 8944@smallexample 8945v2df __builtin_ia32_vfrczpd (v2df) 8946v4sf __builtin_ia32_vfrczps (v4sf) 8947v2df __builtin_ia32_vfrczsd (v2df, v2df) 8948v4sf __builtin_ia32_vfrczss (v4sf, v4sf) 8949v4df __builtin_ia32_vfrczpd256 (v4df) 8950v8sf __builtin_ia32_vfrczps256 (v8sf) 8951v2di __builtin_ia32_vpcmov (v2di, v2di, v2di) 8952v2di __builtin_ia32_vpcmov_v2di (v2di, v2di, v2di) 8953v4si __builtin_ia32_vpcmov_v4si (v4si, v4si, v4si) 8954v8hi __builtin_ia32_vpcmov_v8hi (v8hi, v8hi, v8hi) 8955v16qi __builtin_ia32_vpcmov_v16qi (v16qi, v16qi, v16qi) 8956v2df __builtin_ia32_vpcmov_v2df (v2df, v2df, v2df) 8957v4sf __builtin_ia32_vpcmov_v4sf (v4sf, v4sf, v4sf) 8958v4di __builtin_ia32_vpcmov_v4di256 (v4di, v4di, v4di) 8959v8si __builtin_ia32_vpcmov_v8si256 (v8si, v8si, v8si) 8960v16hi __builtin_ia32_vpcmov_v16hi256 (v16hi, v16hi, v16hi) 8961v32qi __builtin_ia32_vpcmov_v32qi256 (v32qi, v32qi, v32qi) 8962v4df __builtin_ia32_vpcmov_v4df256 (v4df, v4df, v4df) 8963v8sf __builtin_ia32_vpcmov_v8sf256 (v8sf, v8sf, v8sf) 8964v16qi __builtin_ia32_vpcomeqb (v16qi, v16qi) 8965v8hi __builtin_ia32_vpcomeqw (v8hi, v8hi) 8966v4si __builtin_ia32_vpcomeqd (v4si, v4si) 8967v2di __builtin_ia32_vpcomeqq (v2di, v2di) 8968v16qi __builtin_ia32_vpcomequb (v16qi, v16qi) 8969v4si __builtin_ia32_vpcomequd (v4si, v4si) 8970v2di __builtin_ia32_vpcomequq (v2di, v2di) 8971v8hi __builtin_ia32_vpcomequw (v8hi, v8hi) 8972v8hi __builtin_ia32_vpcomeqw (v8hi, v8hi) 8973v16qi __builtin_ia32_vpcomfalseb (v16qi, v16qi) 8974v4si __builtin_ia32_vpcomfalsed (v4si, v4si) 8975v2di __builtin_ia32_vpcomfalseq (v2di, v2di) 8976v16qi __builtin_ia32_vpcomfalseub (v16qi, v16qi) 8977v4si __builtin_ia32_vpcomfalseud (v4si, v4si) 8978v2di __builtin_ia32_vpcomfalseuq (v2di, v2di) 8979v8hi __builtin_ia32_vpcomfalseuw (v8hi, v8hi) 8980v8hi __builtin_ia32_vpcomfalsew (v8hi, v8hi) 8981v16qi __builtin_ia32_vpcomgeb (v16qi, v16qi) 8982v4si __builtin_ia32_vpcomged (v4si, v4si) 8983v2di __builtin_ia32_vpcomgeq (v2di, v2di) 8984v16qi __builtin_ia32_vpcomgeub (v16qi, v16qi) 8985v4si __builtin_ia32_vpcomgeud (v4si, v4si) 8986v2di __builtin_ia32_vpcomgeuq (v2di, v2di) 8987v8hi __builtin_ia32_vpcomgeuw (v8hi, v8hi) 8988v8hi __builtin_ia32_vpcomgew (v8hi, v8hi) 8989v16qi __builtin_ia32_vpcomgtb (v16qi, v16qi) 8990v4si __builtin_ia32_vpcomgtd (v4si, v4si) 8991v2di __builtin_ia32_vpcomgtq (v2di, v2di) 8992v16qi __builtin_ia32_vpcomgtub (v16qi, v16qi) 8993v4si __builtin_ia32_vpcomgtud (v4si, v4si) 8994v2di __builtin_ia32_vpcomgtuq (v2di, v2di) 8995v8hi __builtin_ia32_vpcomgtuw (v8hi, v8hi) 8996v8hi __builtin_ia32_vpcomgtw (v8hi, v8hi) 8997v16qi __builtin_ia32_vpcomleb (v16qi, v16qi) 8998v4si __builtin_ia32_vpcomled (v4si, v4si) 8999v2di __builtin_ia32_vpcomleq (v2di, v2di) 9000v16qi __builtin_ia32_vpcomleub (v16qi, v16qi) 9001v4si __builtin_ia32_vpcomleud (v4si, v4si) 9002v2di __builtin_ia32_vpcomleuq (v2di, v2di) 9003v8hi __builtin_ia32_vpcomleuw (v8hi, v8hi) 9004v8hi __builtin_ia32_vpcomlew (v8hi, v8hi) 9005v16qi __builtin_ia32_vpcomltb (v16qi, v16qi) 9006v4si __builtin_ia32_vpcomltd (v4si, v4si) 9007v2di __builtin_ia32_vpcomltq (v2di, v2di) 9008v16qi __builtin_ia32_vpcomltub (v16qi, v16qi) 9009v4si __builtin_ia32_vpcomltud (v4si, v4si) 9010v2di __builtin_ia32_vpcomltuq (v2di, v2di) 9011v8hi __builtin_ia32_vpcomltuw (v8hi, v8hi) 9012v8hi __builtin_ia32_vpcomltw (v8hi, v8hi) 9013v16qi __builtin_ia32_vpcomneb (v16qi, v16qi) 9014v4si __builtin_ia32_vpcomned (v4si, v4si) 9015v2di __builtin_ia32_vpcomneq (v2di, v2di) 9016v16qi __builtin_ia32_vpcomneub (v16qi, v16qi) 9017v4si __builtin_ia32_vpcomneud (v4si, v4si) 9018v2di __builtin_ia32_vpcomneuq (v2di, v2di) 9019v8hi __builtin_ia32_vpcomneuw (v8hi, v8hi) 9020v8hi __builtin_ia32_vpcomnew (v8hi, v8hi) 9021v16qi __builtin_ia32_vpcomtrueb (v16qi, v16qi) 9022v4si __builtin_ia32_vpcomtrued (v4si, v4si) 9023v2di __builtin_ia32_vpcomtrueq (v2di, v2di) 9024v16qi __builtin_ia32_vpcomtrueub (v16qi, v16qi) 9025v4si __builtin_ia32_vpcomtrueud (v4si, v4si) 9026v2di __builtin_ia32_vpcomtrueuq (v2di, v2di) 9027v8hi __builtin_ia32_vpcomtrueuw (v8hi, v8hi) 9028v8hi __builtin_ia32_vpcomtruew (v8hi, v8hi) 9029v4si __builtin_ia32_vphaddbd (v16qi) 9030v2di __builtin_ia32_vphaddbq (v16qi) 9031v8hi __builtin_ia32_vphaddbw (v16qi) 9032v2di __builtin_ia32_vphadddq (v4si) 9033v4si __builtin_ia32_vphaddubd (v16qi) 9034v2di __builtin_ia32_vphaddubq (v16qi) 9035v8hi __builtin_ia32_vphaddubw (v16qi) 9036v2di __builtin_ia32_vphaddudq (v4si) 9037v4si __builtin_ia32_vphadduwd (v8hi) 9038v2di __builtin_ia32_vphadduwq (v8hi) 9039v4si __builtin_ia32_vphaddwd (v8hi) 9040v2di __builtin_ia32_vphaddwq (v8hi) 9041v8hi __builtin_ia32_vphsubbw (v16qi) 9042v2di __builtin_ia32_vphsubdq (v4si) 9043v4si __builtin_ia32_vphsubwd (v8hi) 9044v4si __builtin_ia32_vpmacsdd (v4si, v4si, v4si) 9045v2di __builtin_ia32_vpmacsdqh (v4si, v4si, v2di) 9046v2di __builtin_ia32_vpmacsdql (v4si, v4si, v2di) 9047v4si __builtin_ia32_vpmacssdd (v4si, v4si, v4si) 9048v2di __builtin_ia32_vpmacssdqh (v4si, v4si, v2di) 9049v2di __builtin_ia32_vpmacssdql (v4si, v4si, v2di) 9050v4si __builtin_ia32_vpmacsswd (v8hi, v8hi, v4si) 9051v8hi __builtin_ia32_vpmacssww (v8hi, v8hi, v8hi) 9052v4si __builtin_ia32_vpmacswd (v8hi, v8hi, v4si) 9053v8hi __builtin_ia32_vpmacsww (v8hi, v8hi, v8hi) 9054v4si __builtin_ia32_vpmadcsswd (v8hi, v8hi, v4si) 9055v4si __builtin_ia32_vpmadcswd (v8hi, v8hi, v4si) 9056v16qi __builtin_ia32_vpperm (v16qi, v16qi, v16qi) 9057v16qi __builtin_ia32_vprotb (v16qi, v16qi) 9058v4si __builtin_ia32_vprotd (v4si, v4si) 9059v2di __builtin_ia32_vprotq (v2di, v2di) 9060v8hi __builtin_ia32_vprotw (v8hi, v8hi) 9061v16qi __builtin_ia32_vpshab (v16qi, v16qi) 9062v4si __builtin_ia32_vpshad (v4si, v4si) 9063v2di __builtin_ia32_vpshaq (v2di, v2di) 9064v8hi __builtin_ia32_vpshaw (v8hi, v8hi) 9065v16qi __builtin_ia32_vpshlb (v16qi, v16qi) 9066v4si __builtin_ia32_vpshld (v4si, v4si) 9067v2di __builtin_ia32_vpshlq (v2di, v2di) 9068v8hi __builtin_ia32_vpshlw (v8hi, v8hi) 9069@end smallexample 9070 9071The following built-in functions are available when @option{-mfma4} is used. 9072All of them generate the machine instruction that is part of the name 9073with MMX registers. 9074 9075@smallexample 9076v2df __builtin_ia32_fmaddpd (v2df, v2df, v2df) 9077v4sf __builtin_ia32_fmaddps (v4sf, v4sf, v4sf) 9078v2df __builtin_ia32_fmaddsd (v2df, v2df, v2df) 9079v4sf __builtin_ia32_fmaddss (v4sf, v4sf, v4sf) 9080v2df __builtin_ia32_fmsubpd (v2df, v2df, v2df) 9081v4sf __builtin_ia32_fmsubps (v4sf, v4sf, v4sf) 9082v2df __builtin_ia32_fmsubsd (v2df, v2df, v2df) 9083v4sf __builtin_ia32_fmsubss (v4sf, v4sf, v4sf) 9084v2df __builtin_ia32_fnmaddpd (v2df, v2df, v2df) 9085v4sf __builtin_ia32_fnmaddps (v4sf, v4sf, v4sf) 9086v2df __builtin_ia32_fnmaddsd (v2df, v2df, v2df) 9087v4sf __builtin_ia32_fnmaddss (v4sf, v4sf, v4sf) 9088v2df __builtin_ia32_fnmsubpd (v2df, v2df, v2df) 9089v4sf __builtin_ia32_fnmsubps (v4sf, v4sf, v4sf) 9090v2df __builtin_ia32_fnmsubsd (v2df, v2df, v2df) 9091v4sf __builtin_ia32_fnmsubss (v4sf, v4sf, v4sf) 9092v2df __builtin_ia32_fmaddsubpd (v2df, v2df, v2df) 9093v4sf __builtin_ia32_fmaddsubps (v4sf, v4sf, v4sf) 9094v2df __builtin_ia32_fmsubaddpd (v2df, v2df, v2df) 9095v4sf __builtin_ia32_fmsubaddps (v4sf, v4sf, v4sf) 9096v4df __builtin_ia32_fmaddpd256 (v4df, v4df, v4df) 9097v8sf __builtin_ia32_fmaddps256 (v8sf, v8sf, v8sf) 9098v4df __builtin_ia32_fmsubpd256 (v4df, v4df, v4df) 9099v8sf __builtin_ia32_fmsubps256 (v8sf, v8sf, v8sf) 9100v4df __builtin_ia32_fnmaddpd256 (v4df, v4df, v4df) 9101v8sf __builtin_ia32_fnmaddps256 (v8sf, v8sf, v8sf) 9102v4df __builtin_ia32_fnmsubpd256 (v4df, v4df, v4df) 9103v8sf __builtin_ia32_fnmsubps256 (v8sf, v8sf, v8sf) 9104v4df __builtin_ia32_fmaddsubpd256 (v4df, v4df, v4df) 9105v8sf __builtin_ia32_fmaddsubps256 (v8sf, v8sf, v8sf) 9106v4df __builtin_ia32_fmsubaddpd256 (v4df, v4df, v4df) 9107v8sf __builtin_ia32_fmsubaddps256 (v8sf, v8sf, v8sf) 9108 9109@end smallexample 9110 9111The following built-in functions are available when @option{-mlwp} is used. 9112 9113@smallexample 9114void __builtin_ia32_llwpcb16 (void *); 9115void __builtin_ia32_llwpcb32 (void *); 9116void __builtin_ia32_llwpcb64 (void *); 9117void * __builtin_ia32_llwpcb16 (void); 9118void * __builtin_ia32_llwpcb32 (void); 9119void * __builtin_ia32_llwpcb64 (void); 9120void __builtin_ia32_lwpval16 (unsigned short, unsigned int, unsigned short) 9121void __builtin_ia32_lwpval32 (unsigned int, unsigned int, unsigned int) 9122void __builtin_ia32_lwpval64 (unsigned __int64, unsigned int, unsigned int) 9123unsigned char __builtin_ia32_lwpins16 (unsigned short, unsigned int, unsigned short) 9124unsigned char __builtin_ia32_lwpins32 (unsigned int, unsigned int, unsigned int) 9125unsigned char __builtin_ia32_lwpins64 (unsigned __int64, unsigned int, unsigned int) 9126@end smallexample 9127 9128The following built-in functions are available when @option{-m3dnow} is used. 9129All of them generate the machine instruction that is part of the name. 9130 9131@smallexample 9132void __builtin_ia32_femms (void) 9133v8qi __builtin_ia32_pavgusb (v8qi, v8qi) 9134v2si __builtin_ia32_pf2id (v2sf) 9135v2sf __builtin_ia32_pfacc (v2sf, v2sf) 9136v2sf __builtin_ia32_pfadd (v2sf, v2sf) 9137v2si __builtin_ia32_pfcmpeq (v2sf, v2sf) 9138v2si __builtin_ia32_pfcmpge (v2sf, v2sf) 9139v2si __builtin_ia32_pfcmpgt (v2sf, v2sf) 9140v2sf __builtin_ia32_pfmax (v2sf, v2sf) 9141v2sf __builtin_ia32_pfmin (v2sf, v2sf) 9142v2sf __builtin_ia32_pfmul (v2sf, v2sf) 9143v2sf __builtin_ia32_pfrcp (v2sf) 9144v2sf __builtin_ia32_pfrcpit1 (v2sf, v2sf) 9145v2sf __builtin_ia32_pfrcpit2 (v2sf, v2sf) 9146v2sf __builtin_ia32_pfrsqrt (v2sf) 9147v2sf __builtin_ia32_pfrsqrtit1 (v2sf, v2sf) 9148v2sf __builtin_ia32_pfsub (v2sf, v2sf) 9149v2sf __builtin_ia32_pfsubr (v2sf, v2sf) 9150v2sf __builtin_ia32_pi2fd (v2si) 9151v4hi __builtin_ia32_pmulhrw (v4hi, v4hi) 9152@end smallexample 9153 9154The following built-in functions are available when both @option{-m3dnow} 9155and @option{-march=athlon} are used. All of them generate the machine 9156instruction that is part of the name. 9157 9158@smallexample 9159v2si __builtin_ia32_pf2iw (v2sf) 9160v2sf __builtin_ia32_pfnacc (v2sf, v2sf) 9161v2sf __builtin_ia32_pfpnacc (v2sf, v2sf) 9162v2sf __builtin_ia32_pi2fw (v2si) 9163v2sf __builtin_ia32_pswapdsf (v2sf) 9164v2si __builtin_ia32_pswapdsi (v2si) 9165@end smallexample 9166 9167@node MIPS DSP Built-in Functions 9168@subsection MIPS DSP Built-in Functions 9169 9170The MIPS DSP Application-Specific Extension (ASE) includes new 9171instructions that are designed to improve the performance of DSP and 9172media applications. It provides instructions that operate on packed 91738-bit/16-bit integer data, Q7, Q15 and Q31 fractional data. 9174 9175GCC supports MIPS DSP operations using both the generic 9176vector extensions (@pxref{Vector Extensions}) and a collection of 9177MIPS-specific built-in functions. Both kinds of support are 9178enabled by the @option{-mdsp} command-line option. 9179 9180Revision 2 of the ASE was introduced in the second half of 2006. 9181This revision adds extra instructions to the original ASE, but is 9182otherwise backwards-compatible with it. You can select revision 2 9183using the command-line option @option{-mdspr2}; this option implies 9184@option{-mdsp}. 9185 9186The SCOUNT and POS bits of the DSP control register are global. The 9187WRDSP, EXTPDP, EXTPDPV and MTHLIP instructions modify the SCOUNT and 9188POS bits. During optimization, the compiler will not delete these 9189instructions and it will not delete calls to functions containing 9190these instructions. 9191 9192At present, GCC only provides support for operations on 32-bit 9193vectors. The vector type associated with 8-bit integer data is 9194usually called @code{v4i8}, the vector type associated with Q7 9195is usually called @code{v4q7}, the vector type associated with 16-bit 9196integer data is usually called @code{v2i16}, and the vector type 9197associated with Q15 is usually called @code{v2q15}. They can be 9198defined in C as follows: 9199 9200@smallexample 9201typedef signed char v4i8 __attribute__ ((vector_size(4))); 9202typedef signed char v4q7 __attribute__ ((vector_size(4))); 9203typedef short v2i16 __attribute__ ((vector_size(4))); 9204typedef short v2q15 __attribute__ ((vector_size(4))); 9205@end smallexample 9206 9207@code{v4i8}, @code{v4q7}, @code{v2i16} and @code{v2q15} values are 9208initialized in the same way as aggregates. For example: 9209 9210@smallexample 9211v4i8 a = @{1, 2, 3, 4@}; 9212v4i8 b; 9213b = (v4i8) @{5, 6, 7, 8@}; 9214 9215v2q15 c = @{0x0fcb, 0x3a75@}; 9216v2q15 d; 9217d = (v2q15) @{0.1234 * 0x1.0p15, 0.4567 * 0x1.0p15@}; 9218@end smallexample 9219 9220@emph{Note:} The CPU's endianness determines the order in which values 9221are packed. On little-endian targets, the first value is the least 9222significant and the last value is the most significant. The opposite 9223order applies to big-endian targets. For example, the code above will 9224set the lowest byte of @code{a} to @code{1} on little-endian targets 9225and @code{4} on big-endian targets. 9226 9227@emph{Note:} Q7, Q15 and Q31 values must be initialized with their integer 9228representation. As shown in this example, the integer representation 9229of a Q7 value can be obtained by multiplying the fractional value by 9230@code{0x1.0p7}. The equivalent for Q15 values is to multiply by 9231@code{0x1.0p15}. The equivalent for Q31 values is to multiply by 9232@code{0x1.0p31}. 9233 9234The table below lists the @code{v4i8} and @code{v2q15} operations for which 9235hardware support exists. @code{a} and @code{b} are @code{v4i8} values, 9236and @code{c} and @code{d} are @code{v2q15} values. 9237 9238@multitable @columnfractions .50 .50 9239@item C code @tab MIPS instruction 9240@item @code{a + b} @tab @code{addu.qb} 9241@item @code{c + d} @tab @code{addq.ph} 9242@item @code{a - b} @tab @code{subu.qb} 9243@item @code{c - d} @tab @code{subq.ph} 9244@end multitable 9245 9246The table below lists the @code{v2i16} operation for which 9247hardware support exists for the DSP ASE REV 2. @code{e} and @code{f} are 9248@code{v2i16} values. 9249 9250@multitable @columnfractions .50 .50 9251@item C code @tab MIPS instruction 9252@item @code{e * f} @tab @code{mul.ph} 9253@end multitable 9254 9255It is easier to describe the DSP built-in functions if we first define 9256the following types: 9257 9258@smallexample 9259typedef int q31; 9260typedef int i32; 9261typedef unsigned int ui32; 9262typedef long long a64; 9263@end smallexample 9264 9265@code{q31} and @code{i32} are actually the same as @code{int}, but we 9266use @code{q31} to indicate a Q31 fractional value and @code{i32} to 9267indicate a 32-bit integer value. Similarly, @code{a64} is the same as 9268@code{long long}, but we use @code{a64} to indicate values that will 9269be placed in one of the four DSP accumulators (@code{$ac0}, 9270@code{$ac1}, @code{$ac2} or @code{$ac3}). 9271 9272Also, some built-in functions prefer or require immediate numbers as 9273parameters, because the corresponding DSP instructions accept both immediate 9274numbers and register operands, or accept immediate numbers only. The 9275immediate parameters are listed as follows. 9276 9277@smallexample 9278imm0_3: 0 to 3. 9279imm0_7: 0 to 7. 9280imm0_15: 0 to 15. 9281imm0_31: 0 to 31. 9282imm0_63: 0 to 63. 9283imm0_255: 0 to 255. 9284imm_n32_31: -32 to 31. 9285imm_n512_511: -512 to 511. 9286@end smallexample 9287 9288The following built-in functions map directly to a particular MIPS DSP 9289instruction. Please refer to the architecture specification 9290for details on what each instruction does. 9291 9292@smallexample 9293v2q15 __builtin_mips_addq_ph (v2q15, v2q15) 9294v2q15 __builtin_mips_addq_s_ph (v2q15, v2q15) 9295q31 __builtin_mips_addq_s_w (q31, q31) 9296v4i8 __builtin_mips_addu_qb (v4i8, v4i8) 9297v4i8 __builtin_mips_addu_s_qb (v4i8, v4i8) 9298v2q15 __builtin_mips_subq_ph (v2q15, v2q15) 9299v2q15 __builtin_mips_subq_s_ph (v2q15, v2q15) 9300q31 __builtin_mips_subq_s_w (q31, q31) 9301v4i8 __builtin_mips_subu_qb (v4i8, v4i8) 9302v4i8 __builtin_mips_subu_s_qb (v4i8, v4i8) 9303i32 __builtin_mips_addsc (i32, i32) 9304i32 __builtin_mips_addwc (i32, i32) 9305i32 __builtin_mips_modsub (i32, i32) 9306i32 __builtin_mips_raddu_w_qb (v4i8) 9307v2q15 __builtin_mips_absq_s_ph (v2q15) 9308q31 __builtin_mips_absq_s_w (q31) 9309v4i8 __builtin_mips_precrq_qb_ph (v2q15, v2q15) 9310v2q15 __builtin_mips_precrq_ph_w (q31, q31) 9311v2q15 __builtin_mips_precrq_rs_ph_w (q31, q31) 9312v4i8 __builtin_mips_precrqu_s_qb_ph (v2q15, v2q15) 9313q31 __builtin_mips_preceq_w_phl (v2q15) 9314q31 __builtin_mips_preceq_w_phr (v2q15) 9315v2q15 __builtin_mips_precequ_ph_qbl (v4i8) 9316v2q15 __builtin_mips_precequ_ph_qbr (v4i8) 9317v2q15 __builtin_mips_precequ_ph_qbla (v4i8) 9318v2q15 __builtin_mips_precequ_ph_qbra (v4i8) 9319v2q15 __builtin_mips_preceu_ph_qbl (v4i8) 9320v2q15 __builtin_mips_preceu_ph_qbr (v4i8) 9321v2q15 __builtin_mips_preceu_ph_qbla (v4i8) 9322v2q15 __builtin_mips_preceu_ph_qbra (v4i8) 9323v4i8 __builtin_mips_shll_qb (v4i8, imm0_7) 9324v4i8 __builtin_mips_shll_qb (v4i8, i32) 9325v2q15 __builtin_mips_shll_ph (v2q15, imm0_15) 9326v2q15 __builtin_mips_shll_ph (v2q15, i32) 9327v2q15 __builtin_mips_shll_s_ph (v2q15, imm0_15) 9328v2q15 __builtin_mips_shll_s_ph (v2q15, i32) 9329q31 __builtin_mips_shll_s_w (q31, imm0_31) 9330q31 __builtin_mips_shll_s_w (q31, i32) 9331v4i8 __builtin_mips_shrl_qb (v4i8, imm0_7) 9332v4i8 __builtin_mips_shrl_qb (v4i8, i32) 9333v2q15 __builtin_mips_shra_ph (v2q15, imm0_15) 9334v2q15 __builtin_mips_shra_ph (v2q15, i32) 9335v2q15 __builtin_mips_shra_r_ph (v2q15, imm0_15) 9336v2q15 __builtin_mips_shra_r_ph (v2q15, i32) 9337q31 __builtin_mips_shra_r_w (q31, imm0_31) 9338q31 __builtin_mips_shra_r_w (q31, i32) 9339v2q15 __builtin_mips_muleu_s_ph_qbl (v4i8, v2q15) 9340v2q15 __builtin_mips_muleu_s_ph_qbr (v4i8, v2q15) 9341v2q15 __builtin_mips_mulq_rs_ph (v2q15, v2q15) 9342q31 __builtin_mips_muleq_s_w_phl (v2q15, v2q15) 9343q31 __builtin_mips_muleq_s_w_phr (v2q15, v2q15) 9344a64 __builtin_mips_dpau_h_qbl (a64, v4i8, v4i8) 9345a64 __builtin_mips_dpau_h_qbr (a64, v4i8, v4i8) 9346a64 __builtin_mips_dpsu_h_qbl (a64, v4i8, v4i8) 9347a64 __builtin_mips_dpsu_h_qbr (a64, v4i8, v4i8) 9348a64 __builtin_mips_dpaq_s_w_ph (a64, v2q15, v2q15) 9349a64 __builtin_mips_dpaq_sa_l_w (a64, q31, q31) 9350a64 __builtin_mips_dpsq_s_w_ph (a64, v2q15, v2q15) 9351a64 __builtin_mips_dpsq_sa_l_w (a64, q31, q31) 9352a64 __builtin_mips_mulsaq_s_w_ph (a64, v2q15, v2q15) 9353a64 __builtin_mips_maq_s_w_phl (a64, v2q15, v2q15) 9354a64 __builtin_mips_maq_s_w_phr (a64, v2q15, v2q15) 9355a64 __builtin_mips_maq_sa_w_phl (a64, v2q15, v2q15) 9356a64 __builtin_mips_maq_sa_w_phr (a64, v2q15, v2q15) 9357i32 __builtin_mips_bitrev (i32) 9358i32 __builtin_mips_insv (i32, i32) 9359v4i8 __builtin_mips_repl_qb (imm0_255) 9360v4i8 __builtin_mips_repl_qb (i32) 9361v2q15 __builtin_mips_repl_ph (imm_n512_511) 9362v2q15 __builtin_mips_repl_ph (i32) 9363void __builtin_mips_cmpu_eq_qb (v4i8, v4i8) 9364void __builtin_mips_cmpu_lt_qb (v4i8, v4i8) 9365void __builtin_mips_cmpu_le_qb (v4i8, v4i8) 9366i32 __builtin_mips_cmpgu_eq_qb (v4i8, v4i8) 9367i32 __builtin_mips_cmpgu_lt_qb (v4i8, v4i8) 9368i32 __builtin_mips_cmpgu_le_qb (v4i8, v4i8) 9369void __builtin_mips_cmp_eq_ph (v2q15, v2q15) 9370void __builtin_mips_cmp_lt_ph (v2q15, v2q15) 9371void __builtin_mips_cmp_le_ph (v2q15, v2q15) 9372v4i8 __builtin_mips_pick_qb (v4i8, v4i8) 9373v2q15 __builtin_mips_pick_ph (v2q15, v2q15) 9374v2q15 __builtin_mips_packrl_ph (v2q15, v2q15) 9375i32 __builtin_mips_extr_w (a64, imm0_31) 9376i32 __builtin_mips_extr_w (a64, i32) 9377i32 __builtin_mips_extr_r_w (a64, imm0_31) 9378i32 __builtin_mips_extr_s_h (a64, i32) 9379i32 __builtin_mips_extr_rs_w (a64, imm0_31) 9380i32 __builtin_mips_extr_rs_w (a64, i32) 9381i32 __builtin_mips_extr_s_h (a64, imm0_31) 9382i32 __builtin_mips_extr_r_w (a64, i32) 9383i32 __builtin_mips_extp (a64, imm0_31) 9384i32 __builtin_mips_extp (a64, i32) 9385i32 __builtin_mips_extpdp (a64, imm0_31) 9386i32 __builtin_mips_extpdp (a64, i32) 9387a64 __builtin_mips_shilo (a64, imm_n32_31) 9388a64 __builtin_mips_shilo (a64, i32) 9389a64 __builtin_mips_mthlip (a64, i32) 9390void __builtin_mips_wrdsp (i32, imm0_63) 9391i32 __builtin_mips_rddsp (imm0_63) 9392i32 __builtin_mips_lbux (void *, i32) 9393i32 __builtin_mips_lhx (void *, i32) 9394i32 __builtin_mips_lwx (void *, i32) 9395i32 __builtin_mips_bposge32 (void) 9396@end smallexample 9397 9398The following built-in functions map directly to a particular MIPS DSP REV 2 9399instruction. Please refer to the architecture specification 9400for details on what each instruction does. 9401 9402@smallexample 9403v4q7 __builtin_mips_absq_s_qb (v4q7); 9404v2i16 __builtin_mips_addu_ph (v2i16, v2i16); 9405v2i16 __builtin_mips_addu_s_ph (v2i16, v2i16); 9406v4i8 __builtin_mips_adduh_qb (v4i8, v4i8); 9407v4i8 __builtin_mips_adduh_r_qb (v4i8, v4i8); 9408i32 __builtin_mips_append (i32, i32, imm0_31); 9409i32 __builtin_mips_balign (i32, i32, imm0_3); 9410i32 __builtin_mips_cmpgdu_eq_qb (v4i8, v4i8); 9411i32 __builtin_mips_cmpgdu_lt_qb (v4i8, v4i8); 9412i32 __builtin_mips_cmpgdu_le_qb (v4i8, v4i8); 9413a64 __builtin_mips_dpa_w_ph (a64, v2i16, v2i16); 9414a64 __builtin_mips_dps_w_ph (a64, v2i16, v2i16); 9415a64 __builtin_mips_madd (a64, i32, i32); 9416a64 __builtin_mips_maddu (a64, ui32, ui32); 9417a64 __builtin_mips_msub (a64, i32, i32); 9418a64 __builtin_mips_msubu (a64, ui32, ui32); 9419v2i16 __builtin_mips_mul_ph (v2i16, v2i16); 9420v2i16 __builtin_mips_mul_s_ph (v2i16, v2i16); 9421q31 __builtin_mips_mulq_rs_w (q31, q31); 9422v2q15 __builtin_mips_mulq_s_ph (v2q15, v2q15); 9423q31 __builtin_mips_mulq_s_w (q31, q31); 9424a64 __builtin_mips_mulsa_w_ph (a64, v2i16, v2i16); 9425a64 __builtin_mips_mult (i32, i32); 9426a64 __builtin_mips_multu (ui32, ui32); 9427v4i8 __builtin_mips_precr_qb_ph (v2i16, v2i16); 9428v2i16 __builtin_mips_precr_sra_ph_w (i32, i32, imm0_31); 9429v2i16 __builtin_mips_precr_sra_r_ph_w (i32, i32, imm0_31); 9430i32 __builtin_mips_prepend (i32, i32, imm0_31); 9431v4i8 __builtin_mips_shra_qb (v4i8, imm0_7); 9432v4i8 __builtin_mips_shra_r_qb (v4i8, imm0_7); 9433v4i8 __builtin_mips_shra_qb (v4i8, i32); 9434v4i8 __builtin_mips_shra_r_qb (v4i8, i32); 9435v2i16 __builtin_mips_shrl_ph (v2i16, imm0_15); 9436v2i16 __builtin_mips_shrl_ph (v2i16, i32); 9437v2i16 __builtin_mips_subu_ph (v2i16, v2i16); 9438v2i16 __builtin_mips_subu_s_ph (v2i16, v2i16); 9439v4i8 __builtin_mips_subuh_qb (v4i8, v4i8); 9440v4i8 __builtin_mips_subuh_r_qb (v4i8, v4i8); 9441v2q15 __builtin_mips_addqh_ph (v2q15, v2q15); 9442v2q15 __builtin_mips_addqh_r_ph (v2q15, v2q15); 9443q31 __builtin_mips_addqh_w (q31, q31); 9444q31 __builtin_mips_addqh_r_w (q31, q31); 9445v2q15 __builtin_mips_subqh_ph (v2q15, v2q15); 9446v2q15 __builtin_mips_subqh_r_ph (v2q15, v2q15); 9447q31 __builtin_mips_subqh_w (q31, q31); 9448q31 __builtin_mips_subqh_r_w (q31, q31); 9449a64 __builtin_mips_dpax_w_ph (a64, v2i16, v2i16); 9450a64 __builtin_mips_dpsx_w_ph (a64, v2i16, v2i16); 9451a64 __builtin_mips_dpaqx_s_w_ph (a64, v2q15, v2q15); 9452a64 __builtin_mips_dpaqx_sa_w_ph (a64, v2q15, v2q15); 9453a64 __builtin_mips_dpsqx_s_w_ph (a64, v2q15, v2q15); 9454a64 __builtin_mips_dpsqx_sa_w_ph (a64, v2q15, v2q15); 9455@end smallexample 9456 9457 9458@node MIPS Paired-Single Support 9459@subsection MIPS Paired-Single Support 9460 9461The MIPS64 architecture includes a number of instructions that 9462operate on pairs of single-precision floating-point values. 9463Each pair is packed into a 64-bit floating-point register, 9464with one element being designated the ``upper half'' and 9465the other being designated the ``lower half''. 9466 9467GCC supports paired-single operations using both the generic 9468vector extensions (@pxref{Vector Extensions}) and a collection of 9469MIPS-specific built-in functions. Both kinds of support are 9470enabled by the @option{-mpaired-single} command-line option. 9471 9472The vector type associated with paired-single values is usually 9473called @code{v2sf}. It can be defined in C as follows: 9474 9475@smallexample 9476typedef float v2sf __attribute__ ((vector_size (8))); 9477@end smallexample 9478 9479@code{v2sf} values are initialized in the same way as aggregates. 9480For example: 9481 9482@smallexample 9483v2sf a = @{1.5, 9.1@}; 9484v2sf b; 9485float e, f; 9486b = (v2sf) @{e, f@}; 9487@end smallexample 9488 9489@emph{Note:} The CPU's endianness determines which value is stored in 9490the upper half of a register and which value is stored in the lower half. 9491On little-endian targets, the first value is the lower one and the second 9492value is the upper one. The opposite order applies to big-endian targets. 9493For example, the code above will set the lower half of @code{a} to 9494@code{1.5} on little-endian targets and @code{9.1} on big-endian targets. 9495 9496@node MIPS Loongson Built-in Functions 9497@subsection MIPS Loongson Built-in Functions 9498 9499GCC provides intrinsics to access the SIMD instructions provided by the 9500ST Microelectronics Loongson-2E and -2F processors. These intrinsics, 9501available after inclusion of the @code{loongson.h} header file, 9502operate on the following 64-bit vector types: 9503 9504@itemize 9505@item @code{uint8x8_t}, a vector of eight unsigned 8-bit integers; 9506@item @code{uint16x4_t}, a vector of four unsigned 16-bit integers; 9507@item @code{uint32x2_t}, a vector of two unsigned 32-bit integers; 9508@item @code{int8x8_t}, a vector of eight signed 8-bit integers; 9509@item @code{int16x4_t}, a vector of four signed 16-bit integers; 9510@item @code{int32x2_t}, a vector of two signed 32-bit integers. 9511@end itemize 9512 9513The intrinsics provided are listed below; each is named after the 9514machine instruction to which it corresponds, with suffixes added as 9515appropriate to distinguish intrinsics that expand to the same machine 9516instruction yet have different argument types. Refer to the architecture 9517documentation for a description of the functionality of each 9518instruction. 9519 9520@smallexample 9521int16x4_t packsswh (int32x2_t s, int32x2_t t); 9522int8x8_t packsshb (int16x4_t s, int16x4_t t); 9523uint8x8_t packushb (uint16x4_t s, uint16x4_t t); 9524uint32x2_t paddw_u (uint32x2_t s, uint32x2_t t); 9525uint16x4_t paddh_u (uint16x4_t s, uint16x4_t t); 9526uint8x8_t paddb_u (uint8x8_t s, uint8x8_t t); 9527int32x2_t paddw_s (int32x2_t s, int32x2_t t); 9528int16x4_t paddh_s (int16x4_t s, int16x4_t t); 9529int8x8_t paddb_s (int8x8_t s, int8x8_t t); 9530uint64_t paddd_u (uint64_t s, uint64_t t); 9531int64_t paddd_s (int64_t s, int64_t t); 9532int16x4_t paddsh (int16x4_t s, int16x4_t t); 9533int8x8_t paddsb (int8x8_t s, int8x8_t t); 9534uint16x4_t paddush (uint16x4_t s, uint16x4_t t); 9535uint8x8_t paddusb (uint8x8_t s, uint8x8_t t); 9536uint64_t pandn_ud (uint64_t s, uint64_t t); 9537uint32x2_t pandn_uw (uint32x2_t s, uint32x2_t t); 9538uint16x4_t pandn_uh (uint16x4_t s, uint16x4_t t); 9539uint8x8_t pandn_ub (uint8x8_t s, uint8x8_t t); 9540int64_t pandn_sd (int64_t s, int64_t t); 9541int32x2_t pandn_sw (int32x2_t s, int32x2_t t); 9542int16x4_t pandn_sh (int16x4_t s, int16x4_t t); 9543int8x8_t pandn_sb (int8x8_t s, int8x8_t t); 9544uint16x4_t pavgh (uint16x4_t s, uint16x4_t t); 9545uint8x8_t pavgb (uint8x8_t s, uint8x8_t t); 9546uint32x2_t pcmpeqw_u (uint32x2_t s, uint32x2_t t); 9547uint16x4_t pcmpeqh_u (uint16x4_t s, uint16x4_t t); 9548uint8x8_t pcmpeqb_u (uint8x8_t s, uint8x8_t t); 9549int32x2_t pcmpeqw_s (int32x2_t s, int32x2_t t); 9550int16x4_t pcmpeqh_s (int16x4_t s, int16x4_t t); 9551int8x8_t pcmpeqb_s (int8x8_t s, int8x8_t t); 9552uint32x2_t pcmpgtw_u (uint32x2_t s, uint32x2_t t); 9553uint16x4_t pcmpgth_u (uint16x4_t s, uint16x4_t t); 9554uint8x8_t pcmpgtb_u (uint8x8_t s, uint8x8_t t); 9555int32x2_t pcmpgtw_s (int32x2_t s, int32x2_t t); 9556int16x4_t pcmpgth_s (int16x4_t s, int16x4_t t); 9557int8x8_t pcmpgtb_s (int8x8_t s, int8x8_t t); 9558uint16x4_t pextrh_u (uint16x4_t s, int field); 9559int16x4_t pextrh_s (int16x4_t s, int field); 9560uint16x4_t pinsrh_0_u (uint16x4_t s, uint16x4_t t); 9561uint16x4_t pinsrh_1_u (uint16x4_t s, uint16x4_t t); 9562uint16x4_t pinsrh_2_u (uint16x4_t s, uint16x4_t t); 9563uint16x4_t pinsrh_3_u (uint16x4_t s, uint16x4_t t); 9564int16x4_t pinsrh_0_s (int16x4_t s, int16x4_t t); 9565int16x4_t pinsrh_1_s (int16x4_t s, int16x4_t t); 9566int16x4_t pinsrh_2_s (int16x4_t s, int16x4_t t); 9567int16x4_t pinsrh_3_s (int16x4_t s, int16x4_t t); 9568int32x2_t pmaddhw (int16x4_t s, int16x4_t t); 9569int16x4_t pmaxsh (int16x4_t s, int16x4_t t); 9570uint8x8_t pmaxub (uint8x8_t s, uint8x8_t t); 9571int16x4_t pminsh (int16x4_t s, int16x4_t t); 9572uint8x8_t pminub (uint8x8_t s, uint8x8_t t); 9573uint8x8_t pmovmskb_u (uint8x8_t s); 9574int8x8_t pmovmskb_s (int8x8_t s); 9575uint16x4_t pmulhuh (uint16x4_t s, uint16x4_t t); 9576int16x4_t pmulhh (int16x4_t s, int16x4_t t); 9577int16x4_t pmullh (int16x4_t s, int16x4_t t); 9578int64_t pmuluw (uint32x2_t s, uint32x2_t t); 9579uint8x8_t pasubub (uint8x8_t s, uint8x8_t t); 9580uint16x4_t biadd (uint8x8_t s); 9581uint16x4_t psadbh (uint8x8_t s, uint8x8_t t); 9582uint16x4_t pshufh_u (uint16x4_t dest, uint16x4_t s, uint8_t order); 9583int16x4_t pshufh_s (int16x4_t dest, int16x4_t s, uint8_t order); 9584uint16x4_t psllh_u (uint16x4_t s, uint8_t amount); 9585int16x4_t psllh_s (int16x4_t s, uint8_t amount); 9586uint32x2_t psllw_u (uint32x2_t s, uint8_t amount); 9587int32x2_t psllw_s (int32x2_t s, uint8_t amount); 9588uint16x4_t psrlh_u (uint16x4_t s, uint8_t amount); 9589int16x4_t psrlh_s (int16x4_t s, uint8_t amount); 9590uint32x2_t psrlw_u (uint32x2_t s, uint8_t amount); 9591int32x2_t psrlw_s (int32x2_t s, uint8_t amount); 9592uint16x4_t psrah_u (uint16x4_t s, uint8_t amount); 9593int16x4_t psrah_s (int16x4_t s, uint8_t amount); 9594uint32x2_t psraw_u (uint32x2_t s, uint8_t amount); 9595int32x2_t psraw_s (int32x2_t s, uint8_t amount); 9596uint32x2_t psubw_u (uint32x2_t s, uint32x2_t t); 9597uint16x4_t psubh_u (uint16x4_t s, uint16x4_t t); 9598uint8x8_t psubb_u (uint8x8_t s, uint8x8_t t); 9599int32x2_t psubw_s (int32x2_t s, int32x2_t t); 9600int16x4_t psubh_s (int16x4_t s, int16x4_t t); 9601int8x8_t psubb_s (int8x8_t s, int8x8_t t); 9602uint64_t psubd_u (uint64_t s, uint64_t t); 9603int64_t psubd_s (int64_t s, int64_t t); 9604int16x4_t psubsh (int16x4_t s, int16x4_t t); 9605int8x8_t psubsb (int8x8_t s, int8x8_t t); 9606uint16x4_t psubush (uint16x4_t s, uint16x4_t t); 9607uint8x8_t psubusb (uint8x8_t s, uint8x8_t t); 9608uint32x2_t punpckhwd_u (uint32x2_t s, uint32x2_t t); 9609uint16x4_t punpckhhw_u (uint16x4_t s, uint16x4_t t); 9610uint8x8_t punpckhbh_u (uint8x8_t s, uint8x8_t t); 9611int32x2_t punpckhwd_s (int32x2_t s, int32x2_t t); 9612int16x4_t punpckhhw_s (int16x4_t s, int16x4_t t); 9613int8x8_t punpckhbh_s (int8x8_t s, int8x8_t t); 9614uint32x2_t punpcklwd_u (uint32x2_t s, uint32x2_t t); 9615uint16x4_t punpcklhw_u (uint16x4_t s, uint16x4_t t); 9616uint8x8_t punpcklbh_u (uint8x8_t s, uint8x8_t t); 9617int32x2_t punpcklwd_s (int32x2_t s, int32x2_t t); 9618int16x4_t punpcklhw_s (int16x4_t s, int16x4_t t); 9619int8x8_t punpcklbh_s (int8x8_t s, int8x8_t t); 9620@end smallexample 9621 9622@menu 9623* Paired-Single Arithmetic:: 9624* Paired-Single Built-in Functions:: 9625* MIPS-3D Built-in Functions:: 9626@end menu 9627 9628@node Paired-Single Arithmetic 9629@subsubsection Paired-Single Arithmetic 9630 9631The table below lists the @code{v2sf} operations for which hardware 9632support exists. @code{a}, @code{b} and @code{c} are @code{v2sf} 9633values and @code{x} is an integral value. 9634 9635@multitable @columnfractions .50 .50 9636@item C code @tab MIPS instruction 9637@item @code{a + b} @tab @code{add.ps} 9638@item @code{a - b} @tab @code{sub.ps} 9639@item @code{-a} @tab @code{neg.ps} 9640@item @code{a * b} @tab @code{mul.ps} 9641@item @code{a * b + c} @tab @code{madd.ps} 9642@item @code{a * b - c} @tab @code{msub.ps} 9643@item @code{-(a * b + c)} @tab @code{nmadd.ps} 9644@item @code{-(a * b - c)} @tab @code{nmsub.ps} 9645@item @code{x ? a : b} @tab @code{movn.ps}/@code{movz.ps} 9646@end multitable 9647 9648Note that the multiply-accumulate instructions can be disabled 9649using the command-line option @code{-mno-fused-madd}. 9650 9651@node Paired-Single Built-in Functions 9652@subsubsection Paired-Single Built-in Functions 9653 9654The following paired-single functions map directly to a particular 9655MIPS instruction. Please refer to the architecture specification 9656for details on what each instruction does. 9657 9658@table @code 9659@item v2sf __builtin_mips_pll_ps (v2sf, v2sf) 9660Pair lower lower (@code{pll.ps}). 9661 9662@item v2sf __builtin_mips_pul_ps (v2sf, v2sf) 9663Pair upper lower (@code{pul.ps}). 9664 9665@item v2sf __builtin_mips_plu_ps (v2sf, v2sf) 9666Pair lower upper (@code{plu.ps}). 9667 9668@item v2sf __builtin_mips_puu_ps (v2sf, v2sf) 9669Pair upper upper (@code{puu.ps}). 9670 9671@item v2sf __builtin_mips_cvt_ps_s (float, float) 9672Convert pair to paired single (@code{cvt.ps.s}). 9673 9674@item float __builtin_mips_cvt_s_pl (v2sf) 9675Convert pair lower to single (@code{cvt.s.pl}). 9676 9677@item float __builtin_mips_cvt_s_pu (v2sf) 9678Convert pair upper to single (@code{cvt.s.pu}). 9679 9680@item v2sf __builtin_mips_abs_ps (v2sf) 9681Absolute value (@code{abs.ps}). 9682 9683@item v2sf __builtin_mips_alnv_ps (v2sf, v2sf, int) 9684Align variable (@code{alnv.ps}). 9685 9686@emph{Note:} The value of the third parameter must be 0 or 4 9687modulo 8, otherwise the result will be unpredictable. Please read the 9688instruction description for details. 9689@end table 9690 9691The following multi-instruction functions are also available. 9692In each case, @var{cond} can be any of the 16 floating-point conditions: 9693@code{f}, @code{un}, @code{eq}, @code{ueq}, @code{olt}, @code{ult}, 9694@code{ole}, @code{ule}, @code{sf}, @code{ngle}, @code{seq}, @code{ngl}, 9695@code{lt}, @code{nge}, @code{le} or @code{ngt}. 9696 9697@table @code 9698@item v2sf __builtin_mips_movt_c_@var{cond}_ps (v2sf @var{a}, v2sf @var{b}, v2sf @var{c}, v2sf @var{d}) 9699@itemx v2sf __builtin_mips_movf_c_@var{cond}_ps (v2sf @var{a}, v2sf @var{b}, v2sf @var{c}, v2sf @var{d}) 9700Conditional move based on floating point comparison (@code{c.@var{cond}.ps}, 9701@code{movt.ps}/@code{movf.ps}). 9702 9703The @code{movt} functions return the value @var{x} computed by: 9704 9705@smallexample 9706c.@var{cond}.ps @var{cc},@var{a},@var{b} 9707mov.ps @var{x},@var{c} 9708movt.ps @var{x},@var{d},@var{cc} 9709@end smallexample 9710 9711The @code{movf} functions are similar but use @code{movf.ps} instead 9712of @code{movt.ps}. 9713 9714@item int __builtin_mips_upper_c_@var{cond}_ps (v2sf @var{a}, v2sf @var{b}) 9715@itemx int __builtin_mips_lower_c_@var{cond}_ps (v2sf @var{a}, v2sf @var{b}) 9716Comparison of two paired-single values (@code{c.@var{cond}.ps}, 9717@code{bc1t}/@code{bc1f}). 9718 9719These functions compare @var{a} and @var{b} using @code{c.@var{cond}.ps} 9720and return either the upper or lower half of the result. For example: 9721 9722@smallexample 9723v2sf a, b; 9724if (__builtin_mips_upper_c_eq_ps (a, b)) 9725 upper_halves_are_equal (); 9726else 9727 upper_halves_are_unequal (); 9728 9729if (__builtin_mips_lower_c_eq_ps (a, b)) 9730 lower_halves_are_equal (); 9731else 9732 lower_halves_are_unequal (); 9733@end smallexample 9734@end table 9735 9736@node MIPS-3D Built-in Functions 9737@subsubsection MIPS-3D Built-in Functions 9738 9739The MIPS-3D Application-Specific Extension (ASE) includes additional 9740paired-single instructions that are designed to improve the performance 9741of 3D graphics operations. Support for these instructions is controlled 9742by the @option{-mips3d} command-line option. 9743 9744The functions listed below map directly to a particular MIPS-3D 9745instruction. Please refer to the architecture specification for 9746more details on what each instruction does. 9747 9748@table @code 9749@item v2sf __builtin_mips_addr_ps (v2sf, v2sf) 9750Reduction add (@code{addr.ps}). 9751 9752@item v2sf __builtin_mips_mulr_ps (v2sf, v2sf) 9753Reduction multiply (@code{mulr.ps}). 9754 9755@item v2sf __builtin_mips_cvt_pw_ps (v2sf) 9756Convert paired single to paired word (@code{cvt.pw.ps}). 9757 9758@item v2sf __builtin_mips_cvt_ps_pw (v2sf) 9759Convert paired word to paired single (@code{cvt.ps.pw}). 9760 9761@item float __builtin_mips_recip1_s (float) 9762@itemx double __builtin_mips_recip1_d (double) 9763@itemx v2sf __builtin_mips_recip1_ps (v2sf) 9764Reduced precision reciprocal (sequence step 1) (@code{recip1.@var{fmt}}). 9765 9766@item float __builtin_mips_recip2_s (float, float) 9767@itemx double __builtin_mips_recip2_d (double, double) 9768@itemx v2sf __builtin_mips_recip2_ps (v2sf, v2sf) 9769Reduced precision reciprocal (sequence step 2) (@code{recip2.@var{fmt}}). 9770 9771@item float __builtin_mips_rsqrt1_s (float) 9772@itemx double __builtin_mips_rsqrt1_d (double) 9773@itemx v2sf __builtin_mips_rsqrt1_ps (v2sf) 9774Reduced precision reciprocal square root (sequence step 1) 9775(@code{rsqrt1.@var{fmt}}). 9776 9777@item float __builtin_mips_rsqrt2_s (float, float) 9778@itemx double __builtin_mips_rsqrt2_d (double, double) 9779@itemx v2sf __builtin_mips_rsqrt2_ps (v2sf, v2sf) 9780Reduced precision reciprocal square root (sequence step 2) 9781(@code{rsqrt2.@var{fmt}}). 9782@end table 9783 9784The following multi-instruction functions are also available. 9785In each case, @var{cond} can be any of the 16 floating-point conditions: 9786@code{f}, @code{un}, @code{eq}, @code{ueq}, @code{olt}, @code{ult}, 9787@code{ole}, @code{ule}, @code{sf}, @code{ngle}, @code{seq}, 9788@code{ngl}, @code{lt}, @code{nge}, @code{le} or @code{ngt}. 9789 9790@table @code 9791@item int __builtin_mips_cabs_@var{cond}_s (float @var{a}, float @var{b}) 9792@itemx int __builtin_mips_cabs_@var{cond}_d (double @var{a}, double @var{b}) 9793Absolute comparison of two scalar values (@code{cabs.@var{cond}.@var{fmt}}, 9794@code{bc1t}/@code{bc1f}). 9795 9796These functions compare @var{a} and @var{b} using @code{cabs.@var{cond}.s} 9797or @code{cabs.@var{cond}.d} and return the result as a boolean value. 9798For example: 9799 9800@smallexample 9801float a, b; 9802if (__builtin_mips_cabs_eq_s (a, b)) 9803 true (); 9804else 9805 false (); 9806@end smallexample 9807 9808@item int __builtin_mips_upper_cabs_@var{cond}_ps (v2sf @var{a}, v2sf @var{b}) 9809@itemx int __builtin_mips_lower_cabs_@var{cond}_ps (v2sf @var{a}, v2sf @var{b}) 9810Absolute comparison of two paired-single values (@code{cabs.@var{cond}.ps}, 9811@code{bc1t}/@code{bc1f}). 9812 9813These functions compare @var{a} and @var{b} using @code{cabs.@var{cond}.ps} 9814and return either the upper or lower half of the result. For example: 9815 9816@smallexample 9817v2sf a, b; 9818if (__builtin_mips_upper_cabs_eq_ps (a, b)) 9819 upper_halves_are_equal (); 9820else 9821 upper_halves_are_unequal (); 9822 9823if (__builtin_mips_lower_cabs_eq_ps (a, b)) 9824 lower_halves_are_equal (); 9825else 9826 lower_halves_are_unequal (); 9827@end smallexample 9828 9829@item v2sf __builtin_mips_movt_cabs_@var{cond}_ps (v2sf @var{a}, v2sf @var{b}, v2sf @var{c}, v2sf @var{d}) 9830@itemx v2sf __builtin_mips_movf_cabs_@var{cond}_ps (v2sf @var{a}, v2sf @var{b}, v2sf @var{c}, v2sf @var{d}) 9831Conditional move based on absolute comparison (@code{cabs.@var{cond}.ps}, 9832@code{movt.ps}/@code{movf.ps}). 9833 9834The @code{movt} functions return the value @var{x} computed by: 9835 9836@smallexample 9837cabs.@var{cond}.ps @var{cc},@var{a},@var{b} 9838mov.ps @var{x},@var{c} 9839movt.ps @var{x},@var{d},@var{cc} 9840@end smallexample 9841 9842The @code{movf} functions are similar but use @code{movf.ps} instead 9843of @code{movt.ps}. 9844 9845@item int __builtin_mips_any_c_@var{cond}_ps (v2sf @var{a}, v2sf @var{b}) 9846@itemx int __builtin_mips_all_c_@var{cond}_ps (v2sf @var{a}, v2sf @var{b}) 9847@itemx int __builtin_mips_any_cabs_@var{cond}_ps (v2sf @var{a}, v2sf @var{b}) 9848@itemx int __builtin_mips_all_cabs_@var{cond}_ps (v2sf @var{a}, v2sf @var{b}) 9849Comparison of two paired-single values 9850(@code{c.@var{cond}.ps}/@code{cabs.@var{cond}.ps}, 9851@code{bc1any2t}/@code{bc1any2f}). 9852 9853These functions compare @var{a} and @var{b} using @code{c.@var{cond}.ps} 9854or @code{cabs.@var{cond}.ps}. The @code{any} forms return true if either 9855result is true and the @code{all} forms return true if both results are true. 9856For example: 9857 9858@smallexample 9859v2sf a, b; 9860if (__builtin_mips_any_c_eq_ps (a, b)) 9861 one_is_true (); 9862else 9863 both_are_false (); 9864 9865if (__builtin_mips_all_c_eq_ps (a, b)) 9866 both_are_true (); 9867else 9868 one_is_false (); 9869@end smallexample 9870 9871@item int __builtin_mips_any_c_@var{cond}_4s (v2sf @var{a}, v2sf @var{b}, v2sf @var{c}, v2sf @var{d}) 9872@itemx int __builtin_mips_all_c_@var{cond}_4s (v2sf @var{a}, v2sf @var{b}, v2sf @var{c}, v2sf @var{d}) 9873@itemx int __builtin_mips_any_cabs_@var{cond}_4s (v2sf @var{a}, v2sf @var{b}, v2sf @var{c}, v2sf @var{d}) 9874@itemx int __builtin_mips_all_cabs_@var{cond}_4s (v2sf @var{a}, v2sf @var{b}, v2sf @var{c}, v2sf @var{d}) 9875Comparison of four paired-single values 9876(@code{c.@var{cond}.ps}/@code{cabs.@var{cond}.ps}, 9877@code{bc1any4t}/@code{bc1any4f}). 9878 9879These functions use @code{c.@var{cond}.ps} or @code{cabs.@var{cond}.ps} 9880to compare @var{a} with @var{b} and to compare @var{c} with @var{d}. 9881The @code{any} forms return true if any of the four results are true 9882and the @code{all} forms return true if all four results are true. 9883For example: 9884 9885@smallexample 9886v2sf a, b, c, d; 9887if (__builtin_mips_any_c_eq_4s (a, b, c, d)) 9888 some_are_true (); 9889else 9890 all_are_false (); 9891 9892if (__builtin_mips_all_c_eq_4s (a, b, c, d)) 9893 all_are_true (); 9894else 9895 some_are_false (); 9896@end smallexample 9897@end table 9898 9899@node picoChip Built-in Functions 9900@subsection picoChip Built-in Functions 9901 9902GCC provides an interface to selected machine instructions from the 9903picoChip instruction set. 9904 9905@table @code 9906@item int __builtin_sbc (int @var{value}) 9907Sign bit count. Return the number of consecutive bits in @var{value} 9908which have the same value as the sign-bit. The result is the number of 9909leading sign bits minus one, giving the number of redundant sign bits in 9910@var{value}. 9911 9912@item int __builtin_byteswap (int @var{value}) 9913Byte swap. Return the result of swapping the upper and lower bytes of 9914@var{value}. 9915 9916@item int __builtin_brev (int @var{value}) 9917Bit reversal. Return the result of reversing the bits in 9918@var{value}. Bit 15 is swapped with bit 0, bit 14 is swapped with bit 1, 9919and so on. 9920 9921@item int __builtin_adds (int @var{x}, int @var{y}) 9922Saturating addition. Return the result of adding @var{x} and @var{y}, 9923storing the value 32767 if the result overflows. 9924 9925@item int __builtin_subs (int @var{x}, int @var{y}) 9926Saturating subtraction. Return the result of subtracting @var{y} from 9927@var{x}, storing the value @minus{}32768 if the result overflows. 9928 9929@item void __builtin_halt (void) 9930Halt. The processor will stop execution. This built-in is useful for 9931implementing assertions. 9932 9933@end table 9934 9935@node Other MIPS Built-in Functions 9936@subsection Other MIPS Built-in Functions 9937 9938GCC provides other MIPS-specific built-in functions: 9939 9940@table @code 9941@item void __builtin_mips_cache (int @var{op}, const volatile void *@var{addr}) 9942Insert a @samp{cache} instruction with operands @var{op} and @var{addr}. 9943GCC defines the preprocessor macro @code{___GCC_HAVE_BUILTIN_MIPS_CACHE} 9944when this function is available. 9945@end table 9946 9947@node PowerPC AltiVec/VSX Built-in Functions 9948@subsection PowerPC AltiVec Built-in Functions 9949 9950GCC provides an interface for the PowerPC family of processors to access 9951the AltiVec operations described in Motorola's AltiVec Programming 9952Interface Manual. The interface is made available by including 9953@code{<altivec.h>} and using @option{-maltivec} and 9954@option{-mabi=altivec}. The interface supports the following vector 9955types. 9956 9957@smallexample 9958vector unsigned char 9959vector signed char 9960vector bool char 9961 9962vector unsigned short 9963vector signed short 9964vector bool short 9965vector pixel 9966 9967vector unsigned int 9968vector signed int 9969vector bool int 9970vector float 9971@end smallexample 9972 9973If @option{-mvsx} is used the following additional vector types are 9974implemented. 9975 9976@smallexample 9977vector unsigned long 9978vector signed long 9979vector double 9980@end smallexample 9981 9982The long types are only implemented for 64-bit code generation, and 9983the long type is only used in the floating point/integer conversion 9984instructions. 9985 9986GCC's implementation of the high-level language interface available from 9987C and C++ code differs from Motorola's documentation in several ways. 9988 9989@itemize @bullet 9990 9991@item 9992A vector constant is a list of constant expressions within curly braces. 9993 9994@item 9995A vector initializer requires no cast if the vector constant is of the 9996same type as the variable it is initializing. 9997 9998@item 9999If @code{signed} or @code{unsigned} is omitted, the signedness of the 10000vector type is the default signedness of the base type. The default 10001varies depending on the operating system, so a portable program should 10002always specify the signedness. 10003 10004@item 10005Compiling with @option{-maltivec} adds keywords @code{__vector}, 10006@code{vector}, @code{__pixel}, @code{pixel}, @code{__bool} and 10007@code{bool}. When compiling ISO C, the context-sensitive substitution 10008of the keywords @code{vector}, @code{pixel} and @code{bool} is 10009disabled. To use them, you must include @code{<altivec.h>} instead. 10010 10011@item 10012GCC allows using a @code{typedef} name as the type specifier for a 10013vector type. 10014 10015@item 10016For C, overloaded functions are implemented with macros so the following 10017does not work: 10018 10019@smallexample 10020 vec_add ((vector signed int)@{1, 2, 3, 4@}, foo); 10021@end smallexample 10022 10023Since @code{vec_add} is a macro, the vector constant in the example 10024is treated as four separate arguments. Wrap the entire argument in 10025parentheses for this to work. 10026@end itemize 10027 10028@emph{Note:} Only the @code{<altivec.h>} interface is supported. 10029Internally, GCC uses built-in functions to achieve the functionality in 10030the aforementioned header file, but they are not supported and are 10031subject to change without notice. 10032 10033The following interfaces are supported for the generic and specific 10034AltiVec operations and the AltiVec predicates. In cases where there 10035is a direct mapping between generic and specific operations, only the 10036generic names are shown here, although the specific operations can also 10037be used. 10038 10039Arguments that are documented as @code{const int} require literal 10040integral values within the range required for that operation. 10041 10042@smallexample 10043vector signed char vec_abs (vector signed char); 10044vector signed short vec_abs (vector signed short); 10045vector signed int vec_abs (vector signed int); 10046vector float vec_abs (vector float); 10047 10048vector signed char vec_abss (vector signed char); 10049vector signed short vec_abss (vector signed short); 10050vector signed int vec_abss (vector signed int); 10051 10052vector signed char vec_add (vector bool char, vector signed char); 10053vector signed char vec_add (vector signed char, vector bool char); 10054vector signed char vec_add (vector signed char, vector signed char); 10055vector unsigned char vec_add (vector bool char, vector unsigned char); 10056vector unsigned char vec_add (vector unsigned char, vector bool char); 10057vector unsigned char vec_add (vector unsigned char, 10058 vector unsigned char); 10059vector signed short vec_add (vector bool short, vector signed short); 10060vector signed short vec_add (vector signed short, vector bool short); 10061vector signed short vec_add (vector signed short, vector signed short); 10062vector unsigned short vec_add (vector bool short, 10063 vector unsigned short); 10064vector unsigned short vec_add (vector unsigned short, 10065 vector bool short); 10066vector unsigned short vec_add (vector unsigned short, 10067 vector unsigned short); 10068vector signed int vec_add (vector bool int, vector signed int); 10069vector signed int vec_add (vector signed int, vector bool int); 10070vector signed int vec_add (vector signed int, vector signed int); 10071vector unsigned int vec_add (vector bool int, vector unsigned int); 10072vector unsigned int vec_add (vector unsigned int, vector bool int); 10073vector unsigned int vec_add (vector unsigned int, vector unsigned int); 10074vector float vec_add (vector float, vector float); 10075 10076vector float vec_vaddfp (vector float, vector float); 10077 10078vector signed int vec_vadduwm (vector bool int, vector signed int); 10079vector signed int vec_vadduwm (vector signed int, vector bool int); 10080vector signed int vec_vadduwm (vector signed int, vector signed int); 10081vector unsigned int vec_vadduwm (vector bool int, vector unsigned int); 10082vector unsigned int vec_vadduwm (vector unsigned int, vector bool int); 10083vector unsigned int vec_vadduwm (vector unsigned int, 10084 vector unsigned int); 10085 10086vector signed short vec_vadduhm (vector bool short, 10087 vector signed short); 10088vector signed short vec_vadduhm (vector signed short, 10089 vector bool short); 10090vector signed short vec_vadduhm (vector signed short, 10091 vector signed short); 10092vector unsigned short vec_vadduhm (vector bool short, 10093 vector unsigned short); 10094vector unsigned short vec_vadduhm (vector unsigned short, 10095 vector bool short); 10096vector unsigned short vec_vadduhm (vector unsigned short, 10097 vector unsigned short); 10098 10099vector signed char vec_vaddubm (vector bool char, vector signed char); 10100vector signed char vec_vaddubm (vector signed char, vector bool char); 10101vector signed char vec_vaddubm (vector signed char, vector signed char); 10102vector unsigned char vec_vaddubm (vector bool char, 10103 vector unsigned char); 10104vector unsigned char vec_vaddubm (vector unsigned char, 10105 vector bool char); 10106vector unsigned char vec_vaddubm (vector unsigned char, 10107 vector unsigned char); 10108 10109vector unsigned int vec_addc (vector unsigned int, vector unsigned int); 10110 10111vector unsigned char vec_adds (vector bool char, vector unsigned char); 10112vector unsigned char vec_adds (vector unsigned char, vector bool char); 10113vector unsigned char vec_adds (vector unsigned char, 10114 vector unsigned char); 10115vector signed char vec_adds (vector bool char, vector signed char); 10116vector signed char vec_adds (vector signed char, vector bool char); 10117vector signed char vec_adds (vector signed char, vector signed char); 10118vector unsigned short vec_adds (vector bool short, 10119 vector unsigned short); 10120vector unsigned short vec_adds (vector unsigned short, 10121 vector bool short); 10122vector unsigned short vec_adds (vector unsigned short, 10123 vector unsigned short); 10124vector signed short vec_adds (vector bool short, vector signed short); 10125vector signed short vec_adds (vector signed short, vector bool short); 10126vector signed short vec_adds (vector signed short, vector signed short); 10127vector unsigned int vec_adds (vector bool int, vector unsigned int); 10128vector unsigned int vec_adds (vector unsigned int, vector bool int); 10129vector unsigned int vec_adds (vector unsigned int, vector unsigned int); 10130vector signed int vec_adds (vector bool int, vector signed int); 10131vector signed int vec_adds (vector signed int, vector bool int); 10132vector signed int vec_adds (vector signed int, vector signed int); 10133 10134vector signed int vec_vaddsws (vector bool int, vector signed int); 10135vector signed int vec_vaddsws (vector signed int, vector bool int); 10136vector signed int vec_vaddsws (vector signed int, vector signed int); 10137 10138vector unsigned int vec_vadduws (vector bool int, vector unsigned int); 10139vector unsigned int vec_vadduws (vector unsigned int, vector bool int); 10140vector unsigned int vec_vadduws (vector unsigned int, 10141 vector unsigned int); 10142 10143vector signed short vec_vaddshs (vector bool short, 10144 vector signed short); 10145vector signed short vec_vaddshs (vector signed short, 10146 vector bool short); 10147vector signed short vec_vaddshs (vector signed short, 10148 vector signed short); 10149 10150vector unsigned short vec_vadduhs (vector bool short, 10151 vector unsigned short); 10152vector unsigned short vec_vadduhs (vector unsigned short, 10153 vector bool short); 10154vector unsigned short vec_vadduhs (vector unsigned short, 10155 vector unsigned short); 10156 10157vector signed char vec_vaddsbs (vector bool char, vector signed char); 10158vector signed char vec_vaddsbs (vector signed char, vector bool char); 10159vector signed char vec_vaddsbs (vector signed char, vector signed char); 10160 10161vector unsigned char vec_vaddubs (vector bool char, 10162 vector unsigned char); 10163vector unsigned char vec_vaddubs (vector unsigned char, 10164 vector bool char); 10165vector unsigned char vec_vaddubs (vector unsigned char, 10166 vector unsigned char); 10167 10168vector float vec_and (vector float, vector float); 10169vector float vec_and (vector float, vector bool int); 10170vector float vec_and (vector bool int, vector float); 10171vector bool int vec_and (vector bool int, vector bool int); 10172vector signed int vec_and (vector bool int, vector signed int); 10173vector signed int vec_and (vector signed int, vector bool int); 10174vector signed int vec_and (vector signed int, vector signed int); 10175vector unsigned int vec_and (vector bool int, vector unsigned int); 10176vector unsigned int vec_and (vector unsigned int, vector bool int); 10177vector unsigned int vec_and (vector unsigned int, vector unsigned int); 10178vector bool short vec_and (vector bool short, vector bool short); 10179vector signed short vec_and (vector bool short, vector signed short); 10180vector signed short vec_and (vector signed short, vector bool short); 10181vector signed short vec_and (vector signed short, vector signed short); 10182vector unsigned short vec_and (vector bool short, 10183 vector unsigned short); 10184vector unsigned short vec_and (vector unsigned short, 10185 vector bool short); 10186vector unsigned short vec_and (vector unsigned short, 10187 vector unsigned short); 10188vector signed char vec_and (vector bool char, vector signed char); 10189vector bool char vec_and (vector bool char, vector bool char); 10190vector signed char vec_and (vector signed char, vector bool char); 10191vector signed char vec_and (vector signed char, vector signed char); 10192vector unsigned char vec_and (vector bool char, vector unsigned char); 10193vector unsigned char vec_and (vector unsigned char, vector bool char); 10194vector unsigned char vec_and (vector unsigned char, 10195 vector unsigned char); 10196 10197vector float vec_andc (vector float, vector float); 10198vector float vec_andc (vector float, vector bool int); 10199vector float vec_andc (vector bool int, vector float); 10200vector bool int vec_andc (vector bool int, vector bool int); 10201vector signed int vec_andc (vector bool int, vector signed int); 10202vector signed int vec_andc (vector signed int, vector bool int); 10203vector signed int vec_andc (vector signed int, vector signed int); 10204vector unsigned int vec_andc (vector bool int, vector unsigned int); 10205vector unsigned int vec_andc (vector unsigned int, vector bool int); 10206vector unsigned int vec_andc (vector unsigned int, vector unsigned int); 10207vector bool short vec_andc (vector bool short, vector bool short); 10208vector signed short vec_andc (vector bool short, vector signed short); 10209vector signed short vec_andc (vector signed short, vector bool short); 10210vector signed short vec_andc (vector signed short, vector signed short); 10211vector unsigned short vec_andc (vector bool short, 10212 vector unsigned short); 10213vector unsigned short vec_andc (vector unsigned short, 10214 vector bool short); 10215vector unsigned short vec_andc (vector unsigned short, 10216 vector unsigned short); 10217vector signed char vec_andc (vector bool char, vector signed char); 10218vector bool char vec_andc (vector bool char, vector bool char); 10219vector signed char vec_andc (vector signed char, vector bool char); 10220vector signed char vec_andc (vector signed char, vector signed char); 10221vector unsigned char vec_andc (vector bool char, vector unsigned char); 10222vector unsigned char vec_andc (vector unsigned char, vector bool char); 10223vector unsigned char vec_andc (vector unsigned char, 10224 vector unsigned char); 10225 10226vector unsigned char vec_avg (vector unsigned char, 10227 vector unsigned char); 10228vector signed char vec_avg (vector signed char, vector signed char); 10229vector unsigned short vec_avg (vector unsigned short, 10230 vector unsigned short); 10231vector signed short vec_avg (vector signed short, vector signed short); 10232vector unsigned int vec_avg (vector unsigned int, vector unsigned int); 10233vector signed int vec_avg (vector signed int, vector signed int); 10234 10235vector signed int vec_vavgsw (vector signed int, vector signed int); 10236 10237vector unsigned int vec_vavguw (vector unsigned int, 10238 vector unsigned int); 10239 10240vector signed short vec_vavgsh (vector signed short, 10241 vector signed short); 10242 10243vector unsigned short vec_vavguh (vector unsigned short, 10244 vector unsigned short); 10245 10246vector signed char vec_vavgsb (vector signed char, vector signed char); 10247 10248vector unsigned char vec_vavgub (vector unsigned char, 10249 vector unsigned char); 10250 10251vector float vec_copysign (vector float); 10252 10253vector float vec_ceil (vector float); 10254 10255vector signed int vec_cmpb (vector float, vector float); 10256 10257vector bool char vec_cmpeq (vector signed char, vector signed char); 10258vector bool char vec_cmpeq (vector unsigned char, vector unsigned char); 10259vector bool short vec_cmpeq (vector signed short, vector signed short); 10260vector bool short vec_cmpeq (vector unsigned short, 10261 vector unsigned short); 10262vector bool int vec_cmpeq (vector signed int, vector signed int); 10263vector bool int vec_cmpeq (vector unsigned int, vector unsigned int); 10264vector bool int vec_cmpeq (vector float, vector float); 10265 10266vector bool int vec_vcmpeqfp (vector float, vector float); 10267 10268vector bool int vec_vcmpequw (vector signed int, vector signed int); 10269vector bool int vec_vcmpequw (vector unsigned int, vector unsigned int); 10270 10271vector bool short vec_vcmpequh (vector signed short, 10272 vector signed short); 10273vector bool short vec_vcmpequh (vector unsigned short, 10274 vector unsigned short); 10275 10276vector bool char vec_vcmpequb (vector signed char, vector signed char); 10277vector bool char vec_vcmpequb (vector unsigned char, 10278 vector unsigned char); 10279 10280vector bool int vec_cmpge (vector float, vector float); 10281 10282vector bool char vec_cmpgt (vector unsigned char, vector unsigned char); 10283vector bool char vec_cmpgt (vector signed char, vector signed char); 10284vector bool short vec_cmpgt (vector unsigned short, 10285 vector unsigned short); 10286vector bool short vec_cmpgt (vector signed short, vector signed short); 10287vector bool int vec_cmpgt (vector unsigned int, vector unsigned int); 10288vector bool int vec_cmpgt (vector signed int, vector signed int); 10289vector bool int vec_cmpgt (vector float, vector float); 10290 10291vector bool int vec_vcmpgtfp (vector float, vector float); 10292 10293vector bool int vec_vcmpgtsw (vector signed int, vector signed int); 10294 10295vector bool int vec_vcmpgtuw (vector unsigned int, vector unsigned int); 10296 10297vector bool short vec_vcmpgtsh (vector signed short, 10298 vector signed short); 10299 10300vector bool short vec_vcmpgtuh (vector unsigned short, 10301 vector unsigned short); 10302 10303vector bool char vec_vcmpgtsb (vector signed char, vector signed char); 10304 10305vector bool char vec_vcmpgtub (vector unsigned char, 10306 vector unsigned char); 10307 10308vector bool int vec_cmple (vector float, vector float); 10309 10310vector bool char vec_cmplt (vector unsigned char, vector unsigned char); 10311vector bool char vec_cmplt (vector signed char, vector signed char); 10312vector bool short vec_cmplt (vector unsigned short, 10313 vector unsigned short); 10314vector bool short vec_cmplt (vector signed short, vector signed short); 10315vector bool int vec_cmplt (vector unsigned int, vector unsigned int); 10316vector bool int vec_cmplt (vector signed int, vector signed int); 10317vector bool int vec_cmplt (vector float, vector float); 10318 10319vector float vec_ctf (vector unsigned int, const int); 10320vector float vec_ctf (vector signed int, const int); 10321 10322vector float vec_vcfsx (vector signed int, const int); 10323 10324vector float vec_vcfux (vector unsigned int, const int); 10325 10326vector signed int vec_cts (vector float, const int); 10327 10328vector unsigned int vec_ctu (vector float, const int); 10329 10330void vec_dss (const int); 10331 10332void vec_dssall (void); 10333 10334void vec_dst (const vector unsigned char *, int, const int); 10335void vec_dst (const vector signed char *, int, const int); 10336void vec_dst (const vector bool char *, int, const int); 10337void vec_dst (const vector unsigned short *, int, const int); 10338void vec_dst (const vector signed short *, int, const int); 10339void vec_dst (const vector bool short *, int, const int); 10340void vec_dst (const vector pixel *, int, const int); 10341void vec_dst (const vector unsigned int *, int, const int); 10342void vec_dst (const vector signed int *, int, const int); 10343void vec_dst (const vector bool int *, int, const int); 10344void vec_dst (const vector float *, int, const int); 10345void vec_dst (const unsigned char *, int, const int); 10346void vec_dst (const signed char *, int, const int); 10347void vec_dst (const unsigned short *, int, const int); 10348void vec_dst (const short *, int, const int); 10349void vec_dst (const unsigned int *, int, const int); 10350void vec_dst (const int *, int, const int); 10351void vec_dst (const unsigned long *, int, const int); 10352void vec_dst (const long *, int, const int); 10353void vec_dst (const float *, int, const int); 10354 10355void vec_dstst (const vector unsigned char *, int, const int); 10356void vec_dstst (const vector signed char *, int, const int); 10357void vec_dstst (const vector bool char *, int, const int); 10358void vec_dstst (const vector unsigned short *, int, const int); 10359void vec_dstst (const vector signed short *, int, const int); 10360void vec_dstst (const vector bool short *, int, const int); 10361void vec_dstst (const vector pixel *, int, const int); 10362void vec_dstst (const vector unsigned int *, int, const int); 10363void vec_dstst (const vector signed int *, int, const int); 10364void vec_dstst (const vector bool int *, int, const int); 10365void vec_dstst (const vector float *, int, const int); 10366void vec_dstst (const unsigned char *, int, const int); 10367void vec_dstst (const signed char *, int, const int); 10368void vec_dstst (const unsigned short *, int, const int); 10369void vec_dstst (const short *, int, const int); 10370void vec_dstst (const unsigned int *, int, const int); 10371void vec_dstst (const int *, int, const int); 10372void vec_dstst (const unsigned long *, int, const int); 10373void vec_dstst (const long *, int, const int); 10374void vec_dstst (const float *, int, const int); 10375 10376void vec_dststt (const vector unsigned char *, int, const int); 10377void vec_dststt (const vector signed char *, int, const int); 10378void vec_dststt (const vector bool char *, int, const int); 10379void vec_dststt (const vector unsigned short *, int, const int); 10380void vec_dststt (const vector signed short *, int, const int); 10381void vec_dststt (const vector bool short *, int, const int); 10382void vec_dststt (const vector pixel *, int, const int); 10383void vec_dststt (const vector unsigned int *, int, const int); 10384void vec_dststt (const vector signed int *, int, const int); 10385void vec_dststt (const vector bool int *, int, const int); 10386void vec_dststt (const vector float *, int, const int); 10387void vec_dststt (const unsigned char *, int, const int); 10388void vec_dststt (const signed char *, int, const int); 10389void vec_dststt (const unsigned short *, int, const int); 10390void vec_dststt (const short *, int, const int); 10391void vec_dststt (const unsigned int *, int, const int); 10392void vec_dststt (const int *, int, const int); 10393void vec_dststt (const unsigned long *, int, const int); 10394void vec_dststt (const long *, int, const int); 10395void vec_dststt (const float *, int, const int); 10396 10397void vec_dstt (const vector unsigned char *, int, const int); 10398void vec_dstt (const vector signed char *, int, const int); 10399void vec_dstt (const vector bool char *, int, const int); 10400void vec_dstt (const vector unsigned short *, int, const int); 10401void vec_dstt (const vector signed short *, int, const int); 10402void vec_dstt (const vector bool short *, int, const int); 10403void vec_dstt (const vector pixel *, int, const int); 10404void vec_dstt (const vector unsigned int *, int, const int); 10405void vec_dstt (const vector signed int *, int, const int); 10406void vec_dstt (const vector bool int *, int, const int); 10407void vec_dstt (const vector float *, int, const int); 10408void vec_dstt (const unsigned char *, int, const int); 10409void vec_dstt (const signed char *, int, const int); 10410void vec_dstt (const unsigned short *, int, const int); 10411void vec_dstt (const short *, int, const int); 10412void vec_dstt (const unsigned int *, int, const int); 10413void vec_dstt (const int *, int, const int); 10414void vec_dstt (const unsigned long *, int, const int); 10415void vec_dstt (const long *, int, const int); 10416void vec_dstt (const float *, int, const int); 10417 10418vector float vec_expte (vector float); 10419 10420vector float vec_floor (vector float); 10421 10422vector float vec_ld (int, const vector float *); 10423vector float vec_ld (int, const float *); 10424vector bool int vec_ld (int, const vector bool int *); 10425vector signed int vec_ld (int, const vector signed int *); 10426vector signed int vec_ld (int, const int *); 10427vector signed int vec_ld (int, const long *); 10428vector unsigned int vec_ld (int, const vector unsigned int *); 10429vector unsigned int vec_ld (int, const unsigned int *); 10430vector unsigned int vec_ld (int, const unsigned long *); 10431vector bool short vec_ld (int, const vector bool short *); 10432vector pixel vec_ld (int, const vector pixel *); 10433vector signed short vec_ld (int, const vector signed short *); 10434vector signed short vec_ld (int, const short *); 10435vector unsigned short vec_ld (int, const vector unsigned short *); 10436vector unsigned short vec_ld (int, const unsigned short *); 10437vector bool char vec_ld (int, const vector bool char *); 10438vector signed char vec_ld (int, const vector signed char *); 10439vector signed char vec_ld (int, const signed char *); 10440vector unsigned char vec_ld (int, const vector unsigned char *); 10441vector unsigned char vec_ld (int, const unsigned char *); 10442 10443vector signed char vec_lde (int, const signed char *); 10444vector unsigned char vec_lde (int, const unsigned char *); 10445vector signed short vec_lde (int, const short *); 10446vector unsigned short vec_lde (int, const unsigned short *); 10447vector float vec_lde (int, const float *); 10448vector signed int vec_lde (int, const int *); 10449vector unsigned int vec_lde (int, const unsigned int *); 10450vector signed int vec_lde (int, const long *); 10451vector unsigned int vec_lde (int, const unsigned long *); 10452 10453vector float vec_lvewx (int, float *); 10454vector signed int vec_lvewx (int, int *); 10455vector unsigned int vec_lvewx (int, unsigned int *); 10456vector signed int vec_lvewx (int, long *); 10457vector unsigned int vec_lvewx (int, unsigned long *); 10458 10459vector signed short vec_lvehx (int, short *); 10460vector unsigned short vec_lvehx (int, unsigned short *); 10461 10462vector signed char vec_lvebx (int, char *); 10463vector unsigned char vec_lvebx (int, unsigned char *); 10464 10465vector float vec_ldl (int, const vector float *); 10466vector float vec_ldl (int, const float *); 10467vector bool int vec_ldl (int, const vector bool int *); 10468vector signed int vec_ldl (int, const vector signed int *); 10469vector signed int vec_ldl (int, const int *); 10470vector signed int vec_ldl (int, const long *); 10471vector unsigned int vec_ldl (int, const vector unsigned int *); 10472vector unsigned int vec_ldl (int, const unsigned int *); 10473vector unsigned int vec_ldl (int, const unsigned long *); 10474vector bool short vec_ldl (int, const vector bool short *); 10475vector pixel vec_ldl (int, const vector pixel *); 10476vector signed short vec_ldl (int, const vector signed short *); 10477vector signed short vec_ldl (int, const short *); 10478vector unsigned short vec_ldl (int, const vector unsigned short *); 10479vector unsigned short vec_ldl (int, const unsigned short *); 10480vector bool char vec_ldl (int, const vector bool char *); 10481vector signed char vec_ldl (int, const vector signed char *); 10482vector signed char vec_ldl (int, const signed char *); 10483vector unsigned char vec_ldl (int, const vector unsigned char *); 10484vector unsigned char vec_ldl (int, const unsigned char *); 10485 10486vector float vec_loge (vector float); 10487 10488vector unsigned char vec_lvsl (int, const volatile unsigned char *); 10489vector unsigned char vec_lvsl (int, const volatile signed char *); 10490vector unsigned char vec_lvsl (int, const volatile unsigned short *); 10491vector unsigned char vec_lvsl (int, const volatile short *); 10492vector unsigned char vec_lvsl (int, const volatile unsigned int *); 10493vector unsigned char vec_lvsl (int, const volatile int *); 10494vector unsigned char vec_lvsl (int, const volatile unsigned long *); 10495vector unsigned char vec_lvsl (int, const volatile long *); 10496vector unsigned char vec_lvsl (int, const volatile float *); 10497 10498vector unsigned char vec_lvsr (int, const volatile unsigned char *); 10499vector unsigned char vec_lvsr (int, const volatile signed char *); 10500vector unsigned char vec_lvsr (int, const volatile unsigned short *); 10501vector unsigned char vec_lvsr (int, const volatile short *); 10502vector unsigned char vec_lvsr (int, const volatile unsigned int *); 10503vector unsigned char vec_lvsr (int, const volatile int *); 10504vector unsigned char vec_lvsr (int, const volatile unsigned long *); 10505vector unsigned char vec_lvsr (int, const volatile long *); 10506vector unsigned char vec_lvsr (int, const volatile float *); 10507 10508vector float vec_madd (vector float, vector float, vector float); 10509 10510vector signed short vec_madds (vector signed short, 10511 vector signed short, 10512 vector signed short); 10513 10514vector unsigned char vec_max (vector bool char, vector unsigned char); 10515vector unsigned char vec_max (vector unsigned char, vector bool char); 10516vector unsigned char vec_max (vector unsigned char, 10517 vector unsigned char); 10518vector signed char vec_max (vector bool char, vector signed char); 10519vector signed char vec_max (vector signed char, vector bool char); 10520vector signed char vec_max (vector signed char, vector signed char); 10521vector unsigned short vec_max (vector bool short, 10522 vector unsigned short); 10523vector unsigned short vec_max (vector unsigned short, 10524 vector bool short); 10525vector unsigned short vec_max (vector unsigned short, 10526 vector unsigned short); 10527vector signed short vec_max (vector bool short, vector signed short); 10528vector signed short vec_max (vector signed short, vector bool short); 10529vector signed short vec_max (vector signed short, vector signed short); 10530vector unsigned int vec_max (vector bool int, vector unsigned int); 10531vector unsigned int vec_max (vector unsigned int, vector bool int); 10532vector unsigned int vec_max (vector unsigned int, vector unsigned int); 10533vector signed int vec_max (vector bool int, vector signed int); 10534vector signed int vec_max (vector signed int, vector bool int); 10535vector signed int vec_max (vector signed int, vector signed int); 10536vector float vec_max (vector float, vector float); 10537 10538vector float vec_vmaxfp (vector float, vector float); 10539 10540vector signed int vec_vmaxsw (vector bool int, vector signed int); 10541vector signed int vec_vmaxsw (vector signed int, vector bool int); 10542vector signed int vec_vmaxsw (vector signed int, vector signed int); 10543 10544vector unsigned int vec_vmaxuw (vector bool int, vector unsigned int); 10545vector unsigned int vec_vmaxuw (vector unsigned int, vector bool int); 10546vector unsigned int vec_vmaxuw (vector unsigned int, 10547 vector unsigned int); 10548 10549vector signed short vec_vmaxsh (vector bool short, vector signed short); 10550vector signed short vec_vmaxsh (vector signed short, vector bool short); 10551vector signed short vec_vmaxsh (vector signed short, 10552 vector signed short); 10553 10554vector unsigned short vec_vmaxuh (vector bool short, 10555 vector unsigned short); 10556vector unsigned short vec_vmaxuh (vector unsigned short, 10557 vector bool short); 10558vector unsigned short vec_vmaxuh (vector unsigned short, 10559 vector unsigned short); 10560 10561vector signed char vec_vmaxsb (vector bool char, vector signed char); 10562vector signed char vec_vmaxsb (vector signed char, vector bool char); 10563vector signed char vec_vmaxsb (vector signed char, vector signed char); 10564 10565vector unsigned char vec_vmaxub (vector bool char, 10566 vector unsigned char); 10567vector unsigned char vec_vmaxub (vector unsigned char, 10568 vector bool char); 10569vector unsigned char vec_vmaxub (vector unsigned char, 10570 vector unsigned char); 10571 10572vector bool char vec_mergeh (vector bool char, vector bool char); 10573vector signed char vec_mergeh (vector signed char, vector signed char); 10574vector unsigned char vec_mergeh (vector unsigned char, 10575 vector unsigned char); 10576vector bool short vec_mergeh (vector bool short, vector bool short); 10577vector pixel vec_mergeh (vector pixel, vector pixel); 10578vector signed short vec_mergeh (vector signed short, 10579 vector signed short); 10580vector unsigned short vec_mergeh (vector unsigned short, 10581 vector unsigned short); 10582vector float vec_mergeh (vector float, vector float); 10583vector bool int vec_mergeh (vector bool int, vector bool int); 10584vector signed int vec_mergeh (vector signed int, vector signed int); 10585vector unsigned int vec_mergeh (vector unsigned int, 10586 vector unsigned int); 10587 10588vector float vec_vmrghw (vector float, vector float); 10589vector bool int vec_vmrghw (vector bool int, vector bool int); 10590vector signed int vec_vmrghw (vector signed int, vector signed int); 10591vector unsigned int vec_vmrghw (vector unsigned int, 10592 vector unsigned int); 10593 10594vector bool short vec_vmrghh (vector bool short, vector bool short); 10595vector signed short vec_vmrghh (vector signed short, 10596 vector signed short); 10597vector unsigned short vec_vmrghh (vector unsigned short, 10598 vector unsigned short); 10599vector pixel vec_vmrghh (vector pixel, vector pixel); 10600 10601vector bool char vec_vmrghb (vector bool char, vector bool char); 10602vector signed char vec_vmrghb (vector signed char, vector signed char); 10603vector unsigned char vec_vmrghb (vector unsigned char, 10604 vector unsigned char); 10605 10606vector bool char vec_mergel (vector bool char, vector bool char); 10607vector signed char vec_mergel (vector signed char, vector signed char); 10608vector unsigned char vec_mergel (vector unsigned char, 10609 vector unsigned char); 10610vector bool short vec_mergel (vector bool short, vector bool short); 10611vector pixel vec_mergel (vector pixel, vector pixel); 10612vector signed short vec_mergel (vector signed short, 10613 vector signed short); 10614vector unsigned short vec_mergel (vector unsigned short, 10615 vector unsigned short); 10616vector float vec_mergel (vector float, vector float); 10617vector bool int vec_mergel (vector bool int, vector bool int); 10618vector signed int vec_mergel (vector signed int, vector signed int); 10619vector unsigned int vec_mergel (vector unsigned int, 10620 vector unsigned int); 10621 10622vector float vec_vmrglw (vector float, vector float); 10623vector signed int vec_vmrglw (vector signed int, vector signed int); 10624vector unsigned int vec_vmrglw (vector unsigned int, 10625 vector unsigned int); 10626vector bool int vec_vmrglw (vector bool int, vector bool int); 10627 10628vector bool short vec_vmrglh (vector bool short, vector bool short); 10629vector signed short vec_vmrglh (vector signed short, 10630 vector signed short); 10631vector unsigned short vec_vmrglh (vector unsigned short, 10632 vector unsigned short); 10633vector pixel vec_vmrglh (vector pixel, vector pixel); 10634 10635vector bool char vec_vmrglb (vector bool char, vector bool char); 10636vector signed char vec_vmrglb (vector signed char, vector signed char); 10637vector unsigned char vec_vmrglb (vector unsigned char, 10638 vector unsigned char); 10639 10640vector unsigned short vec_mfvscr (void); 10641 10642vector unsigned char vec_min (vector bool char, vector unsigned char); 10643vector unsigned char vec_min (vector unsigned char, vector bool char); 10644vector unsigned char vec_min (vector unsigned char, 10645 vector unsigned char); 10646vector signed char vec_min (vector bool char, vector signed char); 10647vector signed char vec_min (vector signed char, vector bool char); 10648vector signed char vec_min (vector signed char, vector signed char); 10649vector unsigned short vec_min (vector bool short, 10650 vector unsigned short); 10651vector unsigned short vec_min (vector unsigned short, 10652 vector bool short); 10653vector unsigned short vec_min (vector unsigned short, 10654 vector unsigned short); 10655vector signed short vec_min (vector bool short, vector signed short); 10656vector signed short vec_min (vector signed short, vector bool short); 10657vector signed short vec_min (vector signed short, vector signed short); 10658vector unsigned int vec_min (vector bool int, vector unsigned int); 10659vector unsigned int vec_min (vector unsigned int, vector bool int); 10660vector unsigned int vec_min (vector unsigned int, vector unsigned int); 10661vector signed int vec_min (vector bool int, vector signed int); 10662vector signed int vec_min (vector signed int, vector bool int); 10663vector signed int vec_min (vector signed int, vector signed int); 10664vector float vec_min (vector float, vector float); 10665 10666vector float vec_vminfp (vector float, vector float); 10667 10668vector signed int vec_vminsw (vector bool int, vector signed int); 10669vector signed int vec_vminsw (vector signed int, vector bool int); 10670vector signed int vec_vminsw (vector signed int, vector signed int); 10671 10672vector unsigned int vec_vminuw (vector bool int, vector unsigned int); 10673vector unsigned int vec_vminuw (vector unsigned int, vector bool int); 10674vector unsigned int vec_vminuw (vector unsigned int, 10675 vector unsigned int); 10676 10677vector signed short vec_vminsh (vector bool short, vector signed short); 10678vector signed short vec_vminsh (vector signed short, vector bool short); 10679vector signed short vec_vminsh (vector signed short, 10680 vector signed short); 10681 10682vector unsigned short vec_vminuh (vector bool short, 10683 vector unsigned short); 10684vector unsigned short vec_vminuh (vector unsigned short, 10685 vector bool short); 10686vector unsigned short vec_vminuh (vector unsigned short, 10687 vector unsigned short); 10688 10689vector signed char vec_vminsb (vector bool char, vector signed char); 10690vector signed char vec_vminsb (vector signed char, vector bool char); 10691vector signed char vec_vminsb (vector signed char, vector signed char); 10692 10693vector unsigned char vec_vminub (vector bool char, 10694 vector unsigned char); 10695vector unsigned char vec_vminub (vector unsigned char, 10696 vector bool char); 10697vector unsigned char vec_vminub (vector unsigned char, 10698 vector unsigned char); 10699 10700vector signed short vec_mladd (vector signed short, 10701 vector signed short, 10702 vector signed short); 10703vector signed short vec_mladd (vector signed short, 10704 vector unsigned short, 10705 vector unsigned short); 10706vector signed short vec_mladd (vector unsigned short, 10707 vector signed short, 10708 vector signed short); 10709vector unsigned short vec_mladd (vector unsigned short, 10710 vector unsigned short, 10711 vector unsigned short); 10712 10713vector signed short vec_mradds (vector signed short, 10714 vector signed short, 10715 vector signed short); 10716 10717vector unsigned int vec_msum (vector unsigned char, 10718 vector unsigned char, 10719 vector unsigned int); 10720vector signed int vec_msum (vector signed char, 10721 vector unsigned char, 10722 vector signed int); 10723vector unsigned int vec_msum (vector unsigned short, 10724 vector unsigned short, 10725 vector unsigned int); 10726vector signed int vec_msum (vector signed short, 10727 vector signed short, 10728 vector signed int); 10729 10730vector signed int vec_vmsumshm (vector signed short, 10731 vector signed short, 10732 vector signed int); 10733 10734vector unsigned int vec_vmsumuhm (vector unsigned short, 10735 vector unsigned short, 10736 vector unsigned int); 10737 10738vector signed int vec_vmsummbm (vector signed char, 10739 vector unsigned char, 10740 vector signed int); 10741 10742vector unsigned int vec_vmsumubm (vector unsigned char, 10743 vector unsigned char, 10744 vector unsigned int); 10745 10746vector unsigned int vec_msums (vector unsigned short, 10747 vector unsigned short, 10748 vector unsigned int); 10749vector signed int vec_msums (vector signed short, 10750 vector signed short, 10751 vector signed int); 10752 10753vector signed int vec_vmsumshs (vector signed short, 10754 vector signed short, 10755 vector signed int); 10756 10757vector unsigned int vec_vmsumuhs (vector unsigned short, 10758 vector unsigned short, 10759 vector unsigned int); 10760 10761void vec_mtvscr (vector signed int); 10762void vec_mtvscr (vector unsigned int); 10763void vec_mtvscr (vector bool int); 10764void vec_mtvscr (vector signed short); 10765void vec_mtvscr (vector unsigned short); 10766void vec_mtvscr (vector bool short); 10767void vec_mtvscr (vector pixel); 10768void vec_mtvscr (vector signed char); 10769void vec_mtvscr (vector unsigned char); 10770void vec_mtvscr (vector bool char); 10771 10772vector unsigned short vec_mule (vector unsigned char, 10773 vector unsigned char); 10774vector signed short vec_mule (vector signed char, 10775 vector signed char); 10776vector unsigned int vec_mule (vector unsigned short, 10777 vector unsigned short); 10778vector signed int vec_mule (vector signed short, vector signed short); 10779 10780vector signed int vec_vmulesh (vector signed short, 10781 vector signed short); 10782 10783vector unsigned int vec_vmuleuh (vector unsigned short, 10784 vector unsigned short); 10785 10786vector signed short vec_vmulesb (vector signed char, 10787 vector signed char); 10788 10789vector unsigned short vec_vmuleub (vector unsigned char, 10790 vector unsigned char); 10791 10792vector unsigned short vec_mulo (vector unsigned char, 10793 vector unsigned char); 10794vector signed short vec_mulo (vector signed char, vector signed char); 10795vector unsigned int vec_mulo (vector unsigned short, 10796 vector unsigned short); 10797vector signed int vec_mulo (vector signed short, vector signed short); 10798 10799vector signed int vec_vmulosh (vector signed short, 10800 vector signed short); 10801 10802vector unsigned int vec_vmulouh (vector unsigned short, 10803 vector unsigned short); 10804 10805vector signed short vec_vmulosb (vector signed char, 10806 vector signed char); 10807 10808vector unsigned short vec_vmuloub (vector unsigned char, 10809 vector unsigned char); 10810 10811vector float vec_nmsub (vector float, vector float, vector float); 10812 10813vector float vec_nor (vector float, vector float); 10814vector signed int vec_nor (vector signed int, vector signed int); 10815vector unsigned int vec_nor (vector unsigned int, vector unsigned int); 10816vector bool int vec_nor (vector bool int, vector bool int); 10817vector signed short vec_nor (vector signed short, vector signed short); 10818vector unsigned short vec_nor (vector unsigned short, 10819 vector unsigned short); 10820vector bool short vec_nor (vector bool short, vector bool short); 10821vector signed char vec_nor (vector signed char, vector signed char); 10822vector unsigned char vec_nor (vector unsigned char, 10823 vector unsigned char); 10824vector bool char vec_nor (vector bool char, vector bool char); 10825 10826vector float vec_or (vector float, vector float); 10827vector float vec_or (vector float, vector bool int); 10828vector float vec_or (vector bool int, vector float); 10829vector bool int vec_or (vector bool int, vector bool int); 10830vector signed int vec_or (vector bool int, vector signed int); 10831vector signed int vec_or (vector signed int, vector bool int); 10832vector signed int vec_or (vector signed int, vector signed int); 10833vector unsigned int vec_or (vector bool int, vector unsigned int); 10834vector unsigned int vec_or (vector unsigned int, vector bool int); 10835vector unsigned int vec_or (vector unsigned int, vector unsigned int); 10836vector bool short vec_or (vector bool short, vector bool short); 10837vector signed short vec_or (vector bool short, vector signed short); 10838vector signed short vec_or (vector signed short, vector bool short); 10839vector signed short vec_or (vector signed short, vector signed short); 10840vector unsigned short vec_or (vector bool short, vector unsigned short); 10841vector unsigned short vec_or (vector unsigned short, vector bool short); 10842vector unsigned short vec_or (vector unsigned short, 10843 vector unsigned short); 10844vector signed char vec_or (vector bool char, vector signed char); 10845vector bool char vec_or (vector bool char, vector bool char); 10846vector signed char vec_or (vector signed char, vector bool char); 10847vector signed char vec_or (vector signed char, vector signed char); 10848vector unsigned char vec_or (vector bool char, vector unsigned char); 10849vector unsigned char vec_or (vector unsigned char, vector bool char); 10850vector unsigned char vec_or (vector unsigned char, 10851 vector unsigned char); 10852 10853vector signed char vec_pack (vector signed short, vector signed short); 10854vector unsigned char vec_pack (vector unsigned short, 10855 vector unsigned short); 10856vector bool char vec_pack (vector bool short, vector bool short); 10857vector signed short vec_pack (vector signed int, vector signed int); 10858vector unsigned short vec_pack (vector unsigned int, 10859 vector unsigned int); 10860vector bool short vec_pack (vector bool int, vector bool int); 10861 10862vector bool short vec_vpkuwum (vector bool int, vector bool int); 10863vector signed short vec_vpkuwum (vector signed int, vector signed int); 10864vector unsigned short vec_vpkuwum (vector unsigned int, 10865 vector unsigned int); 10866 10867vector bool char vec_vpkuhum (vector bool short, vector bool short); 10868vector signed char vec_vpkuhum (vector signed short, 10869 vector signed short); 10870vector unsigned char vec_vpkuhum (vector unsigned short, 10871 vector unsigned short); 10872 10873vector pixel vec_packpx (vector unsigned int, vector unsigned int); 10874 10875vector unsigned char vec_packs (vector unsigned short, 10876 vector unsigned short); 10877vector signed char vec_packs (vector signed short, vector signed short); 10878vector unsigned short vec_packs (vector unsigned int, 10879 vector unsigned int); 10880vector signed short vec_packs (vector signed int, vector signed int); 10881 10882vector signed short vec_vpkswss (vector signed int, vector signed int); 10883 10884vector unsigned short vec_vpkuwus (vector unsigned int, 10885 vector unsigned int); 10886 10887vector signed char vec_vpkshss (vector signed short, 10888 vector signed short); 10889 10890vector unsigned char vec_vpkuhus (vector unsigned short, 10891 vector unsigned short); 10892 10893vector unsigned char vec_packsu (vector unsigned short, 10894 vector unsigned short); 10895vector unsigned char vec_packsu (vector signed short, 10896 vector signed short); 10897vector unsigned short vec_packsu (vector unsigned int, 10898 vector unsigned int); 10899vector unsigned short vec_packsu (vector signed int, vector signed int); 10900 10901vector unsigned short vec_vpkswus (vector signed int, 10902 vector signed int); 10903 10904vector unsigned char vec_vpkshus (vector signed short, 10905 vector signed short); 10906 10907vector float vec_perm (vector float, 10908 vector float, 10909 vector unsigned char); 10910vector signed int vec_perm (vector signed int, 10911 vector signed int, 10912 vector unsigned char); 10913vector unsigned int vec_perm (vector unsigned int, 10914 vector unsigned int, 10915 vector unsigned char); 10916vector bool int vec_perm (vector bool int, 10917 vector bool int, 10918 vector unsigned char); 10919vector signed short vec_perm (vector signed short, 10920 vector signed short, 10921 vector unsigned char); 10922vector unsigned short vec_perm (vector unsigned short, 10923 vector unsigned short, 10924 vector unsigned char); 10925vector bool short vec_perm (vector bool short, 10926 vector bool short, 10927 vector unsigned char); 10928vector pixel vec_perm (vector pixel, 10929 vector pixel, 10930 vector unsigned char); 10931vector signed char vec_perm (vector signed char, 10932 vector signed char, 10933 vector unsigned char); 10934vector unsigned char vec_perm (vector unsigned char, 10935 vector unsigned char, 10936 vector unsigned char); 10937vector bool char vec_perm (vector bool char, 10938 vector bool char, 10939 vector unsigned char); 10940 10941vector float vec_re (vector float); 10942 10943vector signed char vec_rl (vector signed char, 10944 vector unsigned char); 10945vector unsigned char vec_rl (vector unsigned char, 10946 vector unsigned char); 10947vector signed short vec_rl (vector signed short, vector unsigned short); 10948vector unsigned short vec_rl (vector unsigned short, 10949 vector unsigned short); 10950vector signed int vec_rl (vector signed int, vector unsigned int); 10951vector unsigned int vec_rl (vector unsigned int, vector unsigned int); 10952 10953vector signed int vec_vrlw (vector signed int, vector unsigned int); 10954vector unsigned int vec_vrlw (vector unsigned int, vector unsigned int); 10955 10956vector signed short vec_vrlh (vector signed short, 10957 vector unsigned short); 10958vector unsigned short vec_vrlh (vector unsigned short, 10959 vector unsigned short); 10960 10961vector signed char vec_vrlb (vector signed char, vector unsigned char); 10962vector unsigned char vec_vrlb (vector unsigned char, 10963 vector unsigned char); 10964 10965vector float vec_round (vector float); 10966 10967vector float vec_rsqrte (vector float); 10968 10969vector float vec_sel (vector float, vector float, vector bool int); 10970vector float vec_sel (vector float, vector float, vector unsigned int); 10971vector signed int vec_sel (vector signed int, 10972 vector signed int, 10973 vector bool int); 10974vector signed int vec_sel (vector signed int, 10975 vector signed int, 10976 vector unsigned int); 10977vector unsigned int vec_sel (vector unsigned int, 10978 vector unsigned int, 10979 vector bool int); 10980vector unsigned int vec_sel (vector unsigned int, 10981 vector unsigned int, 10982 vector unsigned int); 10983vector bool int vec_sel (vector bool int, 10984 vector bool int, 10985 vector bool int); 10986vector bool int vec_sel (vector bool int, 10987 vector bool int, 10988 vector unsigned int); 10989vector signed short vec_sel (vector signed short, 10990 vector signed short, 10991 vector bool short); 10992vector signed short vec_sel (vector signed short, 10993 vector signed short, 10994 vector unsigned short); 10995vector unsigned short vec_sel (vector unsigned short, 10996 vector unsigned short, 10997 vector bool short); 10998vector unsigned short vec_sel (vector unsigned short, 10999 vector unsigned short, 11000 vector unsigned short); 11001vector bool short vec_sel (vector bool short, 11002 vector bool short, 11003 vector bool short); 11004vector bool short vec_sel (vector bool short, 11005 vector bool short, 11006 vector unsigned short); 11007vector signed char vec_sel (vector signed char, 11008 vector signed char, 11009 vector bool char); 11010vector signed char vec_sel (vector signed char, 11011 vector signed char, 11012 vector unsigned char); 11013vector unsigned char vec_sel (vector unsigned char, 11014 vector unsigned char, 11015 vector bool char); 11016vector unsigned char vec_sel (vector unsigned char, 11017 vector unsigned char, 11018 vector unsigned char); 11019vector bool char vec_sel (vector bool char, 11020 vector bool char, 11021 vector bool char); 11022vector bool char vec_sel (vector bool char, 11023 vector bool char, 11024 vector unsigned char); 11025 11026vector signed char vec_sl (vector signed char, 11027 vector unsigned char); 11028vector unsigned char vec_sl (vector unsigned char, 11029 vector unsigned char); 11030vector signed short vec_sl (vector signed short, vector unsigned short); 11031vector unsigned short vec_sl (vector unsigned short, 11032 vector unsigned short); 11033vector signed int vec_sl (vector signed int, vector unsigned int); 11034vector unsigned int vec_sl (vector unsigned int, vector unsigned int); 11035 11036vector signed int vec_vslw (vector signed int, vector unsigned int); 11037vector unsigned int vec_vslw (vector unsigned int, vector unsigned int); 11038 11039vector signed short vec_vslh (vector signed short, 11040 vector unsigned short); 11041vector unsigned short vec_vslh (vector unsigned short, 11042 vector unsigned short); 11043 11044vector signed char vec_vslb (vector signed char, vector unsigned char); 11045vector unsigned char vec_vslb (vector unsigned char, 11046 vector unsigned char); 11047 11048vector float vec_sld (vector float, vector float, const int); 11049vector signed int vec_sld (vector signed int, 11050 vector signed int, 11051 const int); 11052vector unsigned int vec_sld (vector unsigned int, 11053 vector unsigned int, 11054 const int); 11055vector bool int vec_sld (vector bool int, 11056 vector bool int, 11057 const int); 11058vector signed short vec_sld (vector signed short, 11059 vector signed short, 11060 const int); 11061vector unsigned short vec_sld (vector unsigned short, 11062 vector unsigned short, 11063 const int); 11064vector bool short vec_sld (vector bool short, 11065 vector bool short, 11066 const int); 11067vector pixel vec_sld (vector pixel, 11068 vector pixel, 11069 const int); 11070vector signed char vec_sld (vector signed char, 11071 vector signed char, 11072 const int); 11073vector unsigned char vec_sld (vector unsigned char, 11074 vector unsigned char, 11075 const int); 11076vector bool char vec_sld (vector bool char, 11077 vector bool char, 11078 const int); 11079 11080vector signed int vec_sll (vector signed int, 11081 vector unsigned int); 11082vector signed int vec_sll (vector signed int, 11083 vector unsigned short); 11084vector signed int vec_sll (vector signed int, 11085 vector unsigned char); 11086vector unsigned int vec_sll (vector unsigned int, 11087 vector unsigned int); 11088vector unsigned int vec_sll (vector unsigned int, 11089 vector unsigned short); 11090vector unsigned int vec_sll (vector unsigned int, 11091 vector unsigned char); 11092vector bool int vec_sll (vector bool int, 11093 vector unsigned int); 11094vector bool int vec_sll (vector bool int, 11095 vector unsigned short); 11096vector bool int vec_sll (vector bool int, 11097 vector unsigned char); 11098vector signed short vec_sll (vector signed short, 11099 vector unsigned int); 11100vector signed short vec_sll (vector signed short, 11101 vector unsigned short); 11102vector signed short vec_sll (vector signed short, 11103 vector unsigned char); 11104vector unsigned short vec_sll (vector unsigned short, 11105 vector unsigned int); 11106vector unsigned short vec_sll (vector unsigned short, 11107 vector unsigned short); 11108vector unsigned short vec_sll (vector unsigned short, 11109 vector unsigned char); 11110vector bool short vec_sll (vector bool short, vector unsigned int); 11111vector bool short vec_sll (vector bool short, vector unsigned short); 11112vector bool short vec_sll (vector bool short, vector unsigned char); 11113vector pixel vec_sll (vector pixel, vector unsigned int); 11114vector pixel vec_sll (vector pixel, vector unsigned short); 11115vector pixel vec_sll (vector pixel, vector unsigned char); 11116vector signed char vec_sll (vector signed char, vector unsigned int); 11117vector signed char vec_sll (vector signed char, vector unsigned short); 11118vector signed char vec_sll (vector signed char, vector unsigned char); 11119vector unsigned char vec_sll (vector unsigned char, 11120 vector unsigned int); 11121vector unsigned char vec_sll (vector unsigned char, 11122 vector unsigned short); 11123vector unsigned char vec_sll (vector unsigned char, 11124 vector unsigned char); 11125vector bool char vec_sll (vector bool char, vector unsigned int); 11126vector bool char vec_sll (vector bool char, vector unsigned short); 11127vector bool char vec_sll (vector bool char, vector unsigned char); 11128 11129vector float vec_slo (vector float, vector signed char); 11130vector float vec_slo (vector float, vector unsigned char); 11131vector signed int vec_slo (vector signed int, vector signed char); 11132vector signed int vec_slo (vector signed int, vector unsigned char); 11133vector unsigned int vec_slo (vector unsigned int, vector signed char); 11134vector unsigned int vec_slo (vector unsigned int, vector unsigned char); 11135vector signed short vec_slo (vector signed short, vector signed char); 11136vector signed short vec_slo (vector signed short, vector unsigned char); 11137vector unsigned short vec_slo (vector unsigned short, 11138 vector signed char); 11139vector unsigned short vec_slo (vector unsigned short, 11140 vector unsigned char); 11141vector pixel vec_slo (vector pixel, vector signed char); 11142vector pixel vec_slo (vector pixel, vector unsigned char); 11143vector signed char vec_slo (vector signed char, vector signed char); 11144vector signed char vec_slo (vector signed char, vector unsigned char); 11145vector unsigned char vec_slo (vector unsigned char, vector signed char); 11146vector unsigned char vec_slo (vector unsigned char, 11147 vector unsigned char); 11148 11149vector signed char vec_splat (vector signed char, const int); 11150vector unsigned char vec_splat (vector unsigned char, const int); 11151vector bool char vec_splat (vector bool char, const int); 11152vector signed short vec_splat (vector signed short, const int); 11153vector unsigned short vec_splat (vector unsigned short, const int); 11154vector bool short vec_splat (vector bool short, const int); 11155vector pixel vec_splat (vector pixel, const int); 11156vector float vec_splat (vector float, const int); 11157vector signed int vec_splat (vector signed int, const int); 11158vector unsigned int vec_splat (vector unsigned int, const int); 11159vector bool int vec_splat (vector bool int, const int); 11160 11161vector float vec_vspltw (vector float, const int); 11162vector signed int vec_vspltw (vector signed int, const int); 11163vector unsigned int vec_vspltw (vector unsigned int, const int); 11164vector bool int vec_vspltw (vector bool int, const int); 11165 11166vector bool short vec_vsplth (vector bool short, const int); 11167vector signed short vec_vsplth (vector signed short, const int); 11168vector unsigned short vec_vsplth (vector unsigned short, const int); 11169vector pixel vec_vsplth (vector pixel, const int); 11170 11171vector signed char vec_vspltb (vector signed char, const int); 11172vector unsigned char vec_vspltb (vector unsigned char, const int); 11173vector bool char vec_vspltb (vector bool char, const int); 11174 11175vector signed char vec_splat_s8 (const int); 11176 11177vector signed short vec_splat_s16 (const int); 11178 11179vector signed int vec_splat_s32 (const int); 11180 11181vector unsigned char vec_splat_u8 (const int); 11182 11183vector unsigned short vec_splat_u16 (const int); 11184 11185vector unsigned int vec_splat_u32 (const int); 11186 11187vector signed char vec_sr (vector signed char, vector unsigned char); 11188vector unsigned char vec_sr (vector unsigned char, 11189 vector unsigned char); 11190vector signed short vec_sr (vector signed short, 11191 vector unsigned short); 11192vector unsigned short vec_sr (vector unsigned short, 11193 vector unsigned short); 11194vector signed int vec_sr (vector signed int, vector unsigned int); 11195vector unsigned int vec_sr (vector unsigned int, vector unsigned int); 11196 11197vector signed int vec_vsrw (vector signed int, vector unsigned int); 11198vector unsigned int vec_vsrw (vector unsigned int, vector unsigned int); 11199 11200vector signed short vec_vsrh (vector signed short, 11201 vector unsigned short); 11202vector unsigned short vec_vsrh (vector unsigned short, 11203 vector unsigned short); 11204 11205vector signed char vec_vsrb (vector signed char, vector unsigned char); 11206vector unsigned char vec_vsrb (vector unsigned char, 11207 vector unsigned char); 11208 11209vector signed char vec_sra (vector signed char, vector unsigned char); 11210vector unsigned char vec_sra (vector unsigned char, 11211 vector unsigned char); 11212vector signed short vec_sra (vector signed short, 11213 vector unsigned short); 11214vector unsigned short vec_sra (vector unsigned short, 11215 vector unsigned short); 11216vector signed int vec_sra (vector signed int, vector unsigned int); 11217vector unsigned int vec_sra (vector unsigned int, vector unsigned int); 11218 11219vector signed int vec_vsraw (vector signed int, vector unsigned int); 11220vector unsigned int vec_vsraw (vector unsigned int, 11221 vector unsigned int); 11222 11223vector signed short vec_vsrah (vector signed short, 11224 vector unsigned short); 11225vector unsigned short vec_vsrah (vector unsigned short, 11226 vector unsigned short); 11227 11228vector signed char vec_vsrab (vector signed char, vector unsigned char); 11229vector unsigned char vec_vsrab (vector unsigned char, 11230 vector unsigned char); 11231 11232vector signed int vec_srl (vector signed int, vector unsigned int); 11233vector signed int vec_srl (vector signed int, vector unsigned short); 11234vector signed int vec_srl (vector signed int, vector unsigned char); 11235vector unsigned int vec_srl (vector unsigned int, vector unsigned int); 11236vector unsigned int vec_srl (vector unsigned int, 11237 vector unsigned short); 11238vector unsigned int vec_srl (vector unsigned int, vector unsigned char); 11239vector bool int vec_srl (vector bool int, vector unsigned int); 11240vector bool int vec_srl (vector bool int, vector unsigned short); 11241vector bool int vec_srl (vector bool int, vector unsigned char); 11242vector signed short vec_srl (vector signed short, vector unsigned int); 11243vector signed short vec_srl (vector signed short, 11244 vector unsigned short); 11245vector signed short vec_srl (vector signed short, vector unsigned char); 11246vector unsigned short vec_srl (vector unsigned short, 11247 vector unsigned int); 11248vector unsigned short vec_srl (vector unsigned short, 11249 vector unsigned short); 11250vector unsigned short vec_srl (vector unsigned short, 11251 vector unsigned char); 11252vector bool short vec_srl (vector bool short, vector unsigned int); 11253vector bool short vec_srl (vector bool short, vector unsigned short); 11254vector bool short vec_srl (vector bool short, vector unsigned char); 11255vector pixel vec_srl (vector pixel, vector unsigned int); 11256vector pixel vec_srl (vector pixel, vector unsigned short); 11257vector pixel vec_srl (vector pixel, vector unsigned char); 11258vector signed char vec_srl (vector signed char, vector unsigned int); 11259vector signed char vec_srl (vector signed char, vector unsigned short); 11260vector signed char vec_srl (vector signed char, vector unsigned char); 11261vector unsigned char vec_srl (vector unsigned char, 11262 vector unsigned int); 11263vector unsigned char vec_srl (vector unsigned char, 11264 vector unsigned short); 11265vector unsigned char vec_srl (vector unsigned char, 11266 vector unsigned char); 11267vector bool char vec_srl (vector bool char, vector unsigned int); 11268vector bool char vec_srl (vector bool char, vector unsigned short); 11269vector bool char vec_srl (vector bool char, vector unsigned char); 11270 11271vector float vec_sro (vector float, vector signed char); 11272vector float vec_sro (vector float, vector unsigned char); 11273vector signed int vec_sro (vector signed int, vector signed char); 11274vector signed int vec_sro (vector signed int, vector unsigned char); 11275vector unsigned int vec_sro (vector unsigned int, vector signed char); 11276vector unsigned int vec_sro (vector unsigned int, vector unsigned char); 11277vector signed short vec_sro (vector signed short, vector signed char); 11278vector signed short vec_sro (vector signed short, vector unsigned char); 11279vector unsigned short vec_sro (vector unsigned short, 11280 vector signed char); 11281vector unsigned short vec_sro (vector unsigned short, 11282 vector unsigned char); 11283vector pixel vec_sro (vector pixel, vector signed char); 11284vector pixel vec_sro (vector pixel, vector unsigned char); 11285vector signed char vec_sro (vector signed char, vector signed char); 11286vector signed char vec_sro (vector signed char, vector unsigned char); 11287vector unsigned char vec_sro (vector unsigned char, vector signed char); 11288vector unsigned char vec_sro (vector unsigned char, 11289 vector unsigned char); 11290 11291void vec_st (vector float, int, vector float *); 11292void vec_st (vector float, int, float *); 11293void vec_st (vector signed int, int, vector signed int *); 11294void vec_st (vector signed int, int, int *); 11295void vec_st (vector unsigned int, int, vector unsigned int *); 11296void vec_st (vector unsigned int, int, unsigned int *); 11297void vec_st (vector bool int, int, vector bool int *); 11298void vec_st (vector bool int, int, unsigned int *); 11299void vec_st (vector bool int, int, int *); 11300void vec_st (vector signed short, int, vector signed short *); 11301void vec_st (vector signed short, int, short *); 11302void vec_st (vector unsigned short, int, vector unsigned short *); 11303void vec_st (vector unsigned short, int, unsigned short *); 11304void vec_st (vector bool short, int, vector bool short *); 11305void vec_st (vector bool short, int, unsigned short *); 11306void vec_st (vector pixel, int, vector pixel *); 11307void vec_st (vector pixel, int, unsigned short *); 11308void vec_st (vector pixel, int, short *); 11309void vec_st (vector bool short, int, short *); 11310void vec_st (vector signed char, int, vector signed char *); 11311void vec_st (vector signed char, int, signed char *); 11312void vec_st (vector unsigned char, int, vector unsigned char *); 11313void vec_st (vector unsigned char, int, unsigned char *); 11314void vec_st (vector bool char, int, vector bool char *); 11315void vec_st (vector bool char, int, unsigned char *); 11316void vec_st (vector bool char, int, signed char *); 11317 11318void vec_ste (vector signed char, int, signed char *); 11319void vec_ste (vector unsigned char, int, unsigned char *); 11320void vec_ste (vector bool char, int, signed char *); 11321void vec_ste (vector bool char, int, unsigned char *); 11322void vec_ste (vector signed short, int, short *); 11323void vec_ste (vector unsigned short, int, unsigned short *); 11324void vec_ste (vector bool short, int, short *); 11325void vec_ste (vector bool short, int, unsigned short *); 11326void vec_ste (vector pixel, int, short *); 11327void vec_ste (vector pixel, int, unsigned short *); 11328void vec_ste (vector float, int, float *); 11329void vec_ste (vector signed int, int, int *); 11330void vec_ste (vector unsigned int, int, unsigned int *); 11331void vec_ste (vector bool int, int, int *); 11332void vec_ste (vector bool int, int, unsigned int *); 11333 11334void vec_stvewx (vector float, int, float *); 11335void vec_stvewx (vector signed int, int, int *); 11336void vec_stvewx (vector unsigned int, int, unsigned int *); 11337void vec_stvewx (vector bool int, int, int *); 11338void vec_stvewx (vector bool int, int, unsigned int *); 11339 11340void vec_stvehx (vector signed short, int, short *); 11341void vec_stvehx (vector unsigned short, int, unsigned short *); 11342void vec_stvehx (vector bool short, int, short *); 11343void vec_stvehx (vector bool short, int, unsigned short *); 11344void vec_stvehx (vector pixel, int, short *); 11345void vec_stvehx (vector pixel, int, unsigned short *); 11346 11347void vec_stvebx (vector signed char, int, signed char *); 11348void vec_stvebx (vector unsigned char, int, unsigned char *); 11349void vec_stvebx (vector bool char, int, signed char *); 11350void vec_stvebx (vector bool char, int, unsigned char *); 11351 11352void vec_stl (vector float, int, vector float *); 11353void vec_stl (vector float, int, float *); 11354void vec_stl (vector signed int, int, vector signed int *); 11355void vec_stl (vector signed int, int, int *); 11356void vec_stl (vector unsigned int, int, vector unsigned int *); 11357void vec_stl (vector unsigned int, int, unsigned int *); 11358void vec_stl (vector bool int, int, vector bool int *); 11359void vec_stl (vector bool int, int, unsigned int *); 11360void vec_stl (vector bool int, int, int *); 11361void vec_stl (vector signed short, int, vector signed short *); 11362void vec_stl (vector signed short, int, short *); 11363void vec_stl (vector unsigned short, int, vector unsigned short *); 11364void vec_stl (vector unsigned short, int, unsigned short *); 11365void vec_stl (vector bool short, int, vector bool short *); 11366void vec_stl (vector bool short, int, unsigned short *); 11367void vec_stl (vector bool short, int, short *); 11368void vec_stl (vector pixel, int, vector pixel *); 11369void vec_stl (vector pixel, int, unsigned short *); 11370void vec_stl (vector pixel, int, short *); 11371void vec_stl (vector signed char, int, vector signed char *); 11372void vec_stl (vector signed char, int, signed char *); 11373void vec_stl (vector unsigned char, int, vector unsigned char *); 11374void vec_stl (vector unsigned char, int, unsigned char *); 11375void vec_stl (vector bool char, int, vector bool char *); 11376void vec_stl (vector bool char, int, unsigned char *); 11377void vec_stl (vector bool char, int, signed char *); 11378 11379vector signed char vec_sub (vector bool char, vector signed char); 11380vector signed char vec_sub (vector signed char, vector bool char); 11381vector signed char vec_sub (vector signed char, vector signed char); 11382vector unsigned char vec_sub (vector bool char, vector unsigned char); 11383vector unsigned char vec_sub (vector unsigned char, vector bool char); 11384vector unsigned char vec_sub (vector unsigned char, 11385 vector unsigned char); 11386vector signed short vec_sub (vector bool short, vector signed short); 11387vector signed short vec_sub (vector signed short, vector bool short); 11388vector signed short vec_sub (vector signed short, vector signed short); 11389vector unsigned short vec_sub (vector bool short, 11390 vector unsigned short); 11391vector unsigned short vec_sub (vector unsigned short, 11392 vector bool short); 11393vector unsigned short vec_sub (vector unsigned short, 11394 vector unsigned short); 11395vector signed int vec_sub (vector bool int, vector signed int); 11396vector signed int vec_sub (vector signed int, vector bool int); 11397vector signed int vec_sub (vector signed int, vector signed int); 11398vector unsigned int vec_sub (vector bool int, vector unsigned int); 11399vector unsigned int vec_sub (vector unsigned int, vector bool int); 11400vector unsigned int vec_sub (vector unsigned int, vector unsigned int); 11401vector float vec_sub (vector float, vector float); 11402 11403vector float vec_vsubfp (vector float, vector float); 11404 11405vector signed int vec_vsubuwm (vector bool int, vector signed int); 11406vector signed int vec_vsubuwm (vector signed int, vector bool int); 11407vector signed int vec_vsubuwm (vector signed int, vector signed int); 11408vector unsigned int vec_vsubuwm (vector bool int, vector unsigned int); 11409vector unsigned int vec_vsubuwm (vector unsigned int, vector bool int); 11410vector unsigned int vec_vsubuwm (vector unsigned int, 11411 vector unsigned int); 11412 11413vector signed short vec_vsubuhm (vector bool short, 11414 vector signed short); 11415vector signed short vec_vsubuhm (vector signed short, 11416 vector bool short); 11417vector signed short vec_vsubuhm (vector signed short, 11418 vector signed short); 11419vector unsigned short vec_vsubuhm (vector bool short, 11420 vector unsigned short); 11421vector unsigned short vec_vsubuhm (vector unsigned short, 11422 vector bool short); 11423vector unsigned short vec_vsubuhm (vector unsigned short, 11424 vector unsigned short); 11425 11426vector signed char vec_vsububm (vector bool char, vector signed char); 11427vector signed char vec_vsububm (vector signed char, vector bool char); 11428vector signed char vec_vsububm (vector signed char, vector signed char); 11429vector unsigned char vec_vsububm (vector bool char, 11430 vector unsigned char); 11431vector unsigned char vec_vsububm (vector unsigned char, 11432 vector bool char); 11433vector unsigned char vec_vsububm (vector unsigned char, 11434 vector unsigned char); 11435 11436vector unsigned int vec_subc (vector unsigned int, vector unsigned int); 11437 11438vector unsigned char vec_subs (vector bool char, vector unsigned char); 11439vector unsigned char vec_subs (vector unsigned char, vector bool char); 11440vector unsigned char vec_subs (vector unsigned char, 11441 vector unsigned char); 11442vector signed char vec_subs (vector bool char, vector signed char); 11443vector signed char vec_subs (vector signed char, vector bool char); 11444vector signed char vec_subs (vector signed char, vector signed char); 11445vector unsigned short vec_subs (vector bool short, 11446 vector unsigned short); 11447vector unsigned short vec_subs (vector unsigned short, 11448 vector bool short); 11449vector unsigned short vec_subs (vector unsigned short, 11450 vector unsigned short); 11451vector signed short vec_subs (vector bool short, vector signed short); 11452vector signed short vec_subs (vector signed short, vector bool short); 11453vector signed short vec_subs (vector signed short, vector signed short); 11454vector unsigned int vec_subs (vector bool int, vector unsigned int); 11455vector unsigned int vec_subs (vector unsigned int, vector bool int); 11456vector unsigned int vec_subs (vector unsigned int, vector unsigned int); 11457vector signed int vec_subs (vector bool int, vector signed int); 11458vector signed int vec_subs (vector signed int, vector bool int); 11459vector signed int vec_subs (vector signed int, vector signed int); 11460 11461vector signed int vec_vsubsws (vector bool int, vector signed int); 11462vector signed int vec_vsubsws (vector signed int, vector bool int); 11463vector signed int vec_vsubsws (vector signed int, vector signed int); 11464 11465vector unsigned int vec_vsubuws (vector bool int, vector unsigned int); 11466vector unsigned int vec_vsubuws (vector unsigned int, vector bool int); 11467vector unsigned int vec_vsubuws (vector unsigned int, 11468 vector unsigned int); 11469 11470vector signed short vec_vsubshs (vector bool short, 11471 vector signed short); 11472vector signed short vec_vsubshs (vector signed short, 11473 vector bool short); 11474vector signed short vec_vsubshs (vector signed short, 11475 vector signed short); 11476 11477vector unsigned short vec_vsubuhs (vector bool short, 11478 vector unsigned short); 11479vector unsigned short vec_vsubuhs (vector unsigned short, 11480 vector bool short); 11481vector unsigned short vec_vsubuhs (vector unsigned short, 11482 vector unsigned short); 11483 11484vector signed char vec_vsubsbs (vector bool char, vector signed char); 11485vector signed char vec_vsubsbs (vector signed char, vector bool char); 11486vector signed char vec_vsubsbs (vector signed char, vector signed char); 11487 11488vector unsigned char vec_vsububs (vector bool char, 11489 vector unsigned char); 11490vector unsigned char vec_vsububs (vector unsigned char, 11491 vector bool char); 11492vector unsigned char vec_vsububs (vector unsigned char, 11493 vector unsigned char); 11494 11495vector unsigned int vec_sum4s (vector unsigned char, 11496 vector unsigned int); 11497vector signed int vec_sum4s (vector signed char, vector signed int); 11498vector signed int vec_sum4s (vector signed short, vector signed int); 11499 11500vector signed int vec_vsum4shs (vector signed short, vector signed int); 11501 11502vector signed int vec_vsum4sbs (vector signed char, vector signed int); 11503 11504vector unsigned int vec_vsum4ubs (vector unsigned char, 11505 vector unsigned int); 11506 11507vector signed int vec_sum2s (vector signed int, vector signed int); 11508 11509vector signed int vec_sums (vector signed int, vector signed int); 11510 11511vector float vec_trunc (vector float); 11512 11513vector signed short vec_unpackh (vector signed char); 11514vector bool short vec_unpackh (vector bool char); 11515vector signed int vec_unpackh (vector signed short); 11516vector bool int vec_unpackh (vector bool short); 11517vector unsigned int vec_unpackh (vector pixel); 11518 11519vector bool int vec_vupkhsh (vector bool short); 11520vector signed int vec_vupkhsh (vector signed short); 11521 11522vector unsigned int vec_vupkhpx (vector pixel); 11523 11524vector bool short vec_vupkhsb (vector bool char); 11525vector signed short vec_vupkhsb (vector signed char); 11526 11527vector signed short vec_unpackl (vector signed char); 11528vector bool short vec_unpackl (vector bool char); 11529vector unsigned int vec_unpackl (vector pixel); 11530vector signed int vec_unpackl (vector signed short); 11531vector bool int vec_unpackl (vector bool short); 11532 11533vector unsigned int vec_vupklpx (vector pixel); 11534 11535vector bool int vec_vupklsh (vector bool short); 11536vector signed int vec_vupklsh (vector signed short); 11537 11538vector bool short vec_vupklsb (vector bool char); 11539vector signed short vec_vupklsb (vector signed char); 11540 11541vector float vec_xor (vector float, vector float); 11542vector float vec_xor (vector float, vector bool int); 11543vector float vec_xor (vector bool int, vector float); 11544vector bool int vec_xor (vector bool int, vector bool int); 11545vector signed int vec_xor (vector bool int, vector signed int); 11546vector signed int vec_xor (vector signed int, vector bool int); 11547vector signed int vec_xor (vector signed int, vector signed int); 11548vector unsigned int vec_xor (vector bool int, vector unsigned int); 11549vector unsigned int vec_xor (vector unsigned int, vector bool int); 11550vector unsigned int vec_xor (vector unsigned int, vector unsigned int); 11551vector bool short vec_xor (vector bool short, vector bool short); 11552vector signed short vec_xor (vector bool short, vector signed short); 11553vector signed short vec_xor (vector signed short, vector bool short); 11554vector signed short vec_xor (vector signed short, vector signed short); 11555vector unsigned short vec_xor (vector bool short, 11556 vector unsigned short); 11557vector unsigned short vec_xor (vector unsigned short, 11558 vector bool short); 11559vector unsigned short vec_xor (vector unsigned short, 11560 vector unsigned short); 11561vector signed char vec_xor (vector bool char, vector signed char); 11562vector bool char vec_xor (vector bool char, vector bool char); 11563vector signed char vec_xor (vector signed char, vector bool char); 11564vector signed char vec_xor (vector signed char, vector signed char); 11565vector unsigned char vec_xor (vector bool char, vector unsigned char); 11566vector unsigned char vec_xor (vector unsigned char, vector bool char); 11567vector unsigned char vec_xor (vector unsigned char, 11568 vector unsigned char); 11569 11570int vec_all_eq (vector signed char, vector bool char); 11571int vec_all_eq (vector signed char, vector signed char); 11572int vec_all_eq (vector unsigned char, vector bool char); 11573int vec_all_eq (vector unsigned char, vector unsigned char); 11574int vec_all_eq (vector bool char, vector bool char); 11575int vec_all_eq (vector bool char, vector unsigned char); 11576int vec_all_eq (vector bool char, vector signed char); 11577int vec_all_eq (vector signed short, vector bool short); 11578int vec_all_eq (vector signed short, vector signed short); 11579int vec_all_eq (vector unsigned short, vector bool short); 11580int vec_all_eq (vector unsigned short, vector unsigned short); 11581int vec_all_eq (vector bool short, vector bool short); 11582int vec_all_eq (vector bool short, vector unsigned short); 11583int vec_all_eq (vector bool short, vector signed short); 11584int vec_all_eq (vector pixel, vector pixel); 11585int vec_all_eq (vector signed int, vector bool int); 11586int vec_all_eq (vector signed int, vector signed int); 11587int vec_all_eq (vector unsigned int, vector bool int); 11588int vec_all_eq (vector unsigned int, vector unsigned int); 11589int vec_all_eq (vector bool int, vector bool int); 11590int vec_all_eq (vector bool int, vector unsigned int); 11591int vec_all_eq (vector bool int, vector signed int); 11592int vec_all_eq (vector float, vector float); 11593 11594int vec_all_ge (vector bool char, vector unsigned char); 11595int vec_all_ge (vector unsigned char, vector bool char); 11596int vec_all_ge (vector unsigned char, vector unsigned char); 11597int vec_all_ge (vector bool char, vector signed char); 11598int vec_all_ge (vector signed char, vector bool char); 11599int vec_all_ge (vector signed char, vector signed char); 11600int vec_all_ge (vector bool short, vector unsigned short); 11601int vec_all_ge (vector unsigned short, vector bool short); 11602int vec_all_ge (vector unsigned short, vector unsigned short); 11603int vec_all_ge (vector signed short, vector signed short); 11604int vec_all_ge (vector bool short, vector signed short); 11605int vec_all_ge (vector signed short, vector bool short); 11606int vec_all_ge (vector bool int, vector unsigned int); 11607int vec_all_ge (vector unsigned int, vector bool int); 11608int vec_all_ge (vector unsigned int, vector unsigned int); 11609int vec_all_ge (vector bool int, vector signed int); 11610int vec_all_ge (vector signed int, vector bool int); 11611int vec_all_ge (vector signed int, vector signed int); 11612int vec_all_ge (vector float, vector float); 11613 11614int vec_all_gt (vector bool char, vector unsigned char); 11615int vec_all_gt (vector unsigned char, vector bool char); 11616int vec_all_gt (vector unsigned char, vector unsigned char); 11617int vec_all_gt (vector bool char, vector signed char); 11618int vec_all_gt (vector signed char, vector bool char); 11619int vec_all_gt (vector signed char, vector signed char); 11620int vec_all_gt (vector bool short, vector unsigned short); 11621int vec_all_gt (vector unsigned short, vector bool short); 11622int vec_all_gt (vector unsigned short, vector unsigned short); 11623int vec_all_gt (vector bool short, vector signed short); 11624int vec_all_gt (vector signed short, vector bool short); 11625int vec_all_gt (vector signed short, vector signed short); 11626int vec_all_gt (vector bool int, vector unsigned int); 11627int vec_all_gt (vector unsigned int, vector bool int); 11628int vec_all_gt (vector unsigned int, vector unsigned int); 11629int vec_all_gt (vector bool int, vector signed int); 11630int vec_all_gt (vector signed int, vector bool int); 11631int vec_all_gt (vector signed int, vector signed int); 11632int vec_all_gt (vector float, vector float); 11633 11634int vec_all_in (vector float, vector float); 11635 11636int vec_all_le (vector bool char, vector unsigned char); 11637int vec_all_le (vector unsigned char, vector bool char); 11638int vec_all_le (vector unsigned char, vector unsigned char); 11639int vec_all_le (vector bool char, vector signed char); 11640int vec_all_le (vector signed char, vector bool char); 11641int vec_all_le (vector signed char, vector signed char); 11642int vec_all_le (vector bool short, vector unsigned short); 11643int vec_all_le (vector unsigned short, vector bool short); 11644int vec_all_le (vector unsigned short, vector unsigned short); 11645int vec_all_le (vector bool short, vector signed short); 11646int vec_all_le (vector signed short, vector bool short); 11647int vec_all_le (vector signed short, vector signed short); 11648int vec_all_le (vector bool int, vector unsigned int); 11649int vec_all_le (vector unsigned int, vector bool int); 11650int vec_all_le (vector unsigned int, vector unsigned int); 11651int vec_all_le (vector bool int, vector signed int); 11652int vec_all_le (vector signed int, vector bool int); 11653int vec_all_le (vector signed int, vector signed int); 11654int vec_all_le (vector float, vector float); 11655 11656int vec_all_lt (vector bool char, vector unsigned char); 11657int vec_all_lt (vector unsigned char, vector bool char); 11658int vec_all_lt (vector unsigned char, vector unsigned char); 11659int vec_all_lt (vector bool char, vector signed char); 11660int vec_all_lt (vector signed char, vector bool char); 11661int vec_all_lt (vector signed char, vector signed char); 11662int vec_all_lt (vector bool short, vector unsigned short); 11663int vec_all_lt (vector unsigned short, vector bool short); 11664int vec_all_lt (vector unsigned short, vector unsigned short); 11665int vec_all_lt (vector bool short, vector signed short); 11666int vec_all_lt (vector signed short, vector bool short); 11667int vec_all_lt (vector signed short, vector signed short); 11668int vec_all_lt (vector bool int, vector unsigned int); 11669int vec_all_lt (vector unsigned int, vector bool int); 11670int vec_all_lt (vector unsigned int, vector unsigned int); 11671int vec_all_lt (vector bool int, vector signed int); 11672int vec_all_lt (vector signed int, vector bool int); 11673int vec_all_lt (vector signed int, vector signed int); 11674int vec_all_lt (vector float, vector float); 11675 11676int vec_all_nan (vector float); 11677 11678int vec_all_ne (vector signed char, vector bool char); 11679int vec_all_ne (vector signed char, vector signed char); 11680int vec_all_ne (vector unsigned char, vector bool char); 11681int vec_all_ne (vector unsigned char, vector unsigned char); 11682int vec_all_ne (vector bool char, vector bool char); 11683int vec_all_ne (vector bool char, vector unsigned char); 11684int vec_all_ne (vector bool char, vector signed char); 11685int vec_all_ne (vector signed short, vector bool short); 11686int vec_all_ne (vector signed short, vector signed short); 11687int vec_all_ne (vector unsigned short, vector bool short); 11688int vec_all_ne (vector unsigned short, vector unsigned short); 11689int vec_all_ne (vector bool short, vector bool short); 11690int vec_all_ne (vector bool short, vector unsigned short); 11691int vec_all_ne (vector bool short, vector signed short); 11692int vec_all_ne (vector pixel, vector pixel); 11693int vec_all_ne (vector signed int, vector bool int); 11694int vec_all_ne (vector signed int, vector signed int); 11695int vec_all_ne (vector unsigned int, vector bool int); 11696int vec_all_ne (vector unsigned int, vector unsigned int); 11697int vec_all_ne (vector bool int, vector bool int); 11698int vec_all_ne (vector bool int, vector unsigned int); 11699int vec_all_ne (vector bool int, vector signed int); 11700int vec_all_ne (vector float, vector float); 11701 11702int vec_all_nge (vector float, vector float); 11703 11704int vec_all_ngt (vector float, vector float); 11705 11706int vec_all_nle (vector float, vector float); 11707 11708int vec_all_nlt (vector float, vector float); 11709 11710int vec_all_numeric (vector float); 11711 11712int vec_any_eq (vector signed char, vector bool char); 11713int vec_any_eq (vector signed char, vector signed char); 11714int vec_any_eq (vector unsigned char, vector bool char); 11715int vec_any_eq (vector unsigned char, vector unsigned char); 11716int vec_any_eq (vector bool char, vector bool char); 11717int vec_any_eq (vector bool char, vector unsigned char); 11718int vec_any_eq (vector bool char, vector signed char); 11719int vec_any_eq (vector signed short, vector bool short); 11720int vec_any_eq (vector signed short, vector signed short); 11721int vec_any_eq (vector unsigned short, vector bool short); 11722int vec_any_eq (vector unsigned short, vector unsigned short); 11723int vec_any_eq (vector bool short, vector bool short); 11724int vec_any_eq (vector bool short, vector unsigned short); 11725int vec_any_eq (vector bool short, vector signed short); 11726int vec_any_eq (vector pixel, vector pixel); 11727int vec_any_eq (vector signed int, vector bool int); 11728int vec_any_eq (vector signed int, vector signed int); 11729int vec_any_eq (vector unsigned int, vector bool int); 11730int vec_any_eq (vector unsigned int, vector unsigned int); 11731int vec_any_eq (vector bool int, vector bool int); 11732int vec_any_eq (vector bool int, vector unsigned int); 11733int vec_any_eq (vector bool int, vector signed int); 11734int vec_any_eq (vector float, vector float); 11735 11736int vec_any_ge (vector signed char, vector bool char); 11737int vec_any_ge (vector unsigned char, vector bool char); 11738int vec_any_ge (vector unsigned char, vector unsigned char); 11739int vec_any_ge (vector signed char, vector signed char); 11740int vec_any_ge (vector bool char, vector unsigned char); 11741int vec_any_ge (vector bool char, vector signed char); 11742int vec_any_ge (vector unsigned short, vector bool short); 11743int vec_any_ge (vector unsigned short, vector unsigned short); 11744int vec_any_ge (vector signed short, vector signed short); 11745int vec_any_ge (vector signed short, vector bool short); 11746int vec_any_ge (vector bool short, vector unsigned short); 11747int vec_any_ge (vector bool short, vector signed short); 11748int vec_any_ge (vector signed int, vector bool int); 11749int vec_any_ge (vector unsigned int, vector bool int); 11750int vec_any_ge (vector unsigned int, vector unsigned int); 11751int vec_any_ge (vector signed int, vector signed int); 11752int vec_any_ge (vector bool int, vector unsigned int); 11753int vec_any_ge (vector bool int, vector signed int); 11754int vec_any_ge (vector float, vector float); 11755 11756int vec_any_gt (vector bool char, vector unsigned char); 11757int vec_any_gt (vector unsigned char, vector bool char); 11758int vec_any_gt (vector unsigned char, vector unsigned char); 11759int vec_any_gt (vector bool char, vector signed char); 11760int vec_any_gt (vector signed char, vector bool char); 11761int vec_any_gt (vector signed char, vector signed char); 11762int vec_any_gt (vector bool short, vector unsigned short); 11763int vec_any_gt (vector unsigned short, vector bool short); 11764int vec_any_gt (vector unsigned short, vector unsigned short); 11765int vec_any_gt (vector bool short, vector signed short); 11766int vec_any_gt (vector signed short, vector bool short); 11767int vec_any_gt (vector signed short, vector signed short); 11768int vec_any_gt (vector bool int, vector unsigned int); 11769int vec_any_gt (vector unsigned int, vector bool int); 11770int vec_any_gt (vector unsigned int, vector unsigned int); 11771int vec_any_gt (vector bool int, vector signed int); 11772int vec_any_gt (vector signed int, vector bool int); 11773int vec_any_gt (vector signed int, vector signed int); 11774int vec_any_gt (vector float, vector float); 11775 11776int vec_any_le (vector bool char, vector unsigned char); 11777int vec_any_le (vector unsigned char, vector bool char); 11778int vec_any_le (vector unsigned char, vector unsigned char); 11779int vec_any_le (vector bool char, vector signed char); 11780int vec_any_le (vector signed char, vector bool char); 11781int vec_any_le (vector signed char, vector signed char); 11782int vec_any_le (vector bool short, vector unsigned short); 11783int vec_any_le (vector unsigned short, vector bool short); 11784int vec_any_le (vector unsigned short, vector unsigned short); 11785int vec_any_le (vector bool short, vector signed short); 11786int vec_any_le (vector signed short, vector bool short); 11787int vec_any_le (vector signed short, vector signed short); 11788int vec_any_le (vector bool int, vector unsigned int); 11789int vec_any_le (vector unsigned int, vector bool int); 11790int vec_any_le (vector unsigned int, vector unsigned int); 11791int vec_any_le (vector bool int, vector signed int); 11792int vec_any_le (vector signed int, vector bool int); 11793int vec_any_le (vector signed int, vector signed int); 11794int vec_any_le (vector float, vector float); 11795 11796int vec_any_lt (vector bool char, vector unsigned char); 11797int vec_any_lt (vector unsigned char, vector bool char); 11798int vec_any_lt (vector unsigned char, vector unsigned char); 11799int vec_any_lt (vector bool char, vector signed char); 11800int vec_any_lt (vector signed char, vector bool char); 11801int vec_any_lt (vector signed char, vector signed char); 11802int vec_any_lt (vector bool short, vector unsigned short); 11803int vec_any_lt (vector unsigned short, vector bool short); 11804int vec_any_lt (vector unsigned short, vector unsigned short); 11805int vec_any_lt (vector bool short, vector signed short); 11806int vec_any_lt (vector signed short, vector bool short); 11807int vec_any_lt (vector signed short, vector signed short); 11808int vec_any_lt (vector bool int, vector unsigned int); 11809int vec_any_lt (vector unsigned int, vector bool int); 11810int vec_any_lt (vector unsigned int, vector unsigned int); 11811int vec_any_lt (vector bool int, vector signed int); 11812int vec_any_lt (vector signed int, vector bool int); 11813int vec_any_lt (vector signed int, vector signed int); 11814int vec_any_lt (vector float, vector float); 11815 11816int vec_any_nan (vector float); 11817 11818int vec_any_ne (vector signed char, vector bool char); 11819int vec_any_ne (vector signed char, vector signed char); 11820int vec_any_ne (vector unsigned char, vector bool char); 11821int vec_any_ne (vector unsigned char, vector unsigned char); 11822int vec_any_ne (vector bool char, vector bool char); 11823int vec_any_ne (vector bool char, vector unsigned char); 11824int vec_any_ne (vector bool char, vector signed char); 11825int vec_any_ne (vector signed short, vector bool short); 11826int vec_any_ne (vector signed short, vector signed short); 11827int vec_any_ne (vector unsigned short, vector bool short); 11828int vec_any_ne (vector unsigned short, vector unsigned short); 11829int vec_any_ne (vector bool short, vector bool short); 11830int vec_any_ne (vector bool short, vector unsigned short); 11831int vec_any_ne (vector bool short, vector signed short); 11832int vec_any_ne (vector pixel, vector pixel); 11833int vec_any_ne (vector signed int, vector bool int); 11834int vec_any_ne (vector signed int, vector signed int); 11835int vec_any_ne (vector unsigned int, vector bool int); 11836int vec_any_ne (vector unsigned int, vector unsigned int); 11837int vec_any_ne (vector bool int, vector bool int); 11838int vec_any_ne (vector bool int, vector unsigned int); 11839int vec_any_ne (vector bool int, vector signed int); 11840int vec_any_ne (vector float, vector float); 11841 11842int vec_any_nge (vector float, vector float); 11843 11844int vec_any_ngt (vector float, vector float); 11845 11846int vec_any_nle (vector float, vector float); 11847 11848int vec_any_nlt (vector float, vector float); 11849 11850int vec_any_numeric (vector float); 11851 11852int vec_any_out (vector float, vector float); 11853@end smallexample 11854 11855If the vector/scalar (VSX) instruction set is available, the following 11856additional functions are available: 11857 11858@smallexample 11859vector double vec_abs (vector double); 11860vector double vec_add (vector double, vector double); 11861vector double vec_and (vector double, vector double); 11862vector double vec_and (vector double, vector bool long); 11863vector double vec_and (vector bool long, vector double); 11864vector double vec_andc (vector double, vector double); 11865vector double vec_andc (vector double, vector bool long); 11866vector double vec_andc (vector bool long, vector double); 11867vector double vec_ceil (vector double); 11868vector bool long vec_cmpeq (vector double, vector double); 11869vector bool long vec_cmpge (vector double, vector double); 11870vector bool long vec_cmpgt (vector double, vector double); 11871vector bool long vec_cmple (vector double, vector double); 11872vector bool long vec_cmplt (vector double, vector double); 11873vector float vec_div (vector float, vector float); 11874vector double vec_div (vector double, vector double); 11875vector double vec_floor (vector double); 11876vector double vec_ld (int, const vector double *); 11877vector double vec_ld (int, const double *); 11878vector double vec_ldl (int, const vector double *); 11879vector double vec_ldl (int, const double *); 11880vector unsigned char vec_lvsl (int, const volatile double *); 11881vector unsigned char vec_lvsr (int, const volatile double *); 11882vector double vec_madd (vector double, vector double, vector double); 11883vector double vec_max (vector double, vector double); 11884vector double vec_min (vector double, vector double); 11885vector float vec_msub (vector float, vector float, vector float); 11886vector double vec_msub (vector double, vector double, vector double); 11887vector float vec_mul (vector float, vector float); 11888vector double vec_mul (vector double, vector double); 11889vector float vec_nearbyint (vector float); 11890vector double vec_nearbyint (vector double); 11891vector float vec_nmadd (vector float, vector float, vector float); 11892vector double vec_nmadd (vector double, vector double, vector double); 11893vector double vec_nmsub (vector double, vector double, vector double); 11894vector double vec_nor (vector double, vector double); 11895vector double vec_or (vector double, vector double); 11896vector double vec_or (vector double, vector bool long); 11897vector double vec_or (vector bool long, vector double); 11898vector double vec_perm (vector double, 11899 vector double, 11900 vector unsigned char); 11901vector float vec_rint (vector float); 11902vector double vec_rint (vector double); 11903vector double vec_sel (vector double, vector double, vector bool long); 11904vector double vec_sel (vector double, vector double, vector unsigned long); 11905vector double vec_sub (vector double, vector double); 11906vector float vec_sqrt (vector float); 11907vector double vec_sqrt (vector double); 11908void vec_st (vector double, int, vector double *); 11909void vec_st (vector double, int, double *); 11910vector double vec_trunc (vector double); 11911vector double vec_xor (vector double, vector double); 11912vector double vec_xor (vector double, vector bool long); 11913vector double vec_xor (vector bool long, vector double); 11914int vec_all_eq (vector double, vector double); 11915int vec_all_ge (vector double, vector double); 11916int vec_all_gt (vector double, vector double); 11917int vec_all_le (vector double, vector double); 11918int vec_all_lt (vector double, vector double); 11919int vec_all_nan (vector double); 11920int vec_all_ne (vector double, vector double); 11921int vec_all_nge (vector double, vector double); 11922int vec_all_ngt (vector double, vector double); 11923int vec_all_nle (vector double, vector double); 11924int vec_all_nlt (vector double, vector double); 11925int vec_all_numeric (vector double); 11926int vec_any_eq (vector double, vector double); 11927int vec_any_ge (vector double, vector double); 11928int vec_any_gt (vector double, vector double); 11929int vec_any_le (vector double, vector double); 11930int vec_any_lt (vector double, vector double); 11931int vec_any_nan (vector double); 11932int vec_any_ne (vector double, vector double); 11933int vec_any_nge (vector double, vector double); 11934int vec_any_ngt (vector double, vector double); 11935int vec_any_nle (vector double, vector double); 11936int vec_any_nlt (vector double, vector double); 11937int vec_any_numeric (vector double); 11938 11939vector double vec_vsx_ld (int, const vector double *); 11940vector double vec_vsx_ld (int, const double *); 11941vector float vec_vsx_ld (int, const vector float *); 11942vector float vec_vsx_ld (int, const float *); 11943vector bool int vec_vsx_ld (int, const vector bool int *); 11944vector signed int vec_vsx_ld (int, const vector signed int *); 11945vector signed int vec_vsx_ld (int, const int *); 11946vector signed int vec_vsx_ld (int, const long *); 11947vector unsigned int vec_vsx_ld (int, const vector unsigned int *); 11948vector unsigned int vec_vsx_ld (int, const unsigned int *); 11949vector unsigned int vec_vsx_ld (int, const unsigned long *); 11950vector bool short vec_vsx_ld (int, const vector bool short *); 11951vector pixel vec_vsx_ld (int, const vector pixel *); 11952vector signed short vec_vsx_ld (int, const vector signed short *); 11953vector signed short vec_vsx_ld (int, const short *); 11954vector unsigned short vec_vsx_ld (int, const vector unsigned short *); 11955vector unsigned short vec_vsx_ld (int, const unsigned short *); 11956vector bool char vec_vsx_ld (int, const vector bool char *); 11957vector signed char vec_vsx_ld (int, const vector signed char *); 11958vector signed char vec_vsx_ld (int, const signed char *); 11959vector unsigned char vec_vsx_ld (int, const vector unsigned char *); 11960vector unsigned char vec_vsx_ld (int, const unsigned char *); 11961 11962void vec_vsx_st (vector double, int, vector double *); 11963void vec_vsx_st (vector double, int, double *); 11964void vec_vsx_st (vector float, int, vector float *); 11965void vec_vsx_st (vector float, int, float *); 11966void vec_vsx_st (vector signed int, int, vector signed int *); 11967void vec_vsx_st (vector signed int, int, int *); 11968void vec_vsx_st (vector unsigned int, int, vector unsigned int *); 11969void vec_vsx_st (vector unsigned int, int, unsigned int *); 11970void vec_vsx_st (vector bool int, int, vector bool int *); 11971void vec_vsx_st (vector bool int, int, unsigned int *); 11972void vec_vsx_st (vector bool int, int, int *); 11973void vec_vsx_st (vector signed short, int, vector signed short *); 11974void vec_vsx_st (vector signed short, int, short *); 11975void vec_vsx_st (vector unsigned short, int, vector unsigned short *); 11976void vec_vsx_st (vector unsigned short, int, unsigned short *); 11977void vec_vsx_st (vector bool short, int, vector bool short *); 11978void vec_vsx_st (vector bool short, int, unsigned short *); 11979void vec_vsx_st (vector pixel, int, vector pixel *); 11980void vec_vsx_st (vector pixel, int, unsigned short *); 11981void vec_vsx_st (vector pixel, int, short *); 11982void vec_vsx_st (vector bool short, int, short *); 11983void vec_vsx_st (vector signed char, int, vector signed char *); 11984void vec_vsx_st (vector signed char, int, signed char *); 11985void vec_vsx_st (vector unsigned char, int, vector unsigned char *); 11986void vec_vsx_st (vector unsigned char, int, unsigned char *); 11987void vec_vsx_st (vector bool char, int, vector bool char *); 11988void vec_vsx_st (vector bool char, int, unsigned char *); 11989void vec_vsx_st (vector bool char, int, signed char *); 11990@end smallexample 11991 11992Note that the @samp{vec_ld} and @samp{vec_st} builtins will always 11993generate the Altivec @samp{LVX} and @samp{STVX} instructions even 11994if the VSX instruction set is available. The @samp{vec_vsx_ld} and 11995@samp{vec_vsx_st} builtins will always generate the VSX @samp{LXVD2X}, 11996@samp{LXVW4X}, @samp{STXVD2X}, and @samp{STXVW4X} instructions. 11997 11998GCC provides a few other builtins on Powerpc to access certain instructions: 11999@smallexample 12000float __builtin_recipdivf (float, float); 12001float __builtin_rsqrtf (float); 12002double __builtin_recipdiv (double, double); 12003long __builtin_bpermd (long, long); 12004int __builtin_bswap16 (int); 12005@end smallexample 12006 12007@node RX Built-in Functions 12008@subsection RX Built-in Functions 12009GCC supports some of the RX instructions which cannot be expressed in 12010the C programming language via the use of built-in functions. The 12011following functions are supported: 12012 12013@deftypefn {Built-in Function} void __builtin_rx_brk (void) 12014Generates the @code{brk} machine instruction. 12015@end deftypefn 12016 12017@deftypefn {Built-in Function} void __builtin_rx_clrpsw (int) 12018Generates the @code{clrpsw} machine instruction to clear the specified 12019bit in the processor status word. 12020@end deftypefn 12021 12022@deftypefn {Built-in Function} void __builtin_rx_int (int) 12023Generates the @code{int} machine instruction to generate an interrupt 12024with the specified value. 12025@end deftypefn 12026 12027@deftypefn {Built-in Function} void __builtin_rx_machi (int, int) 12028Generates the @code{machi} machine instruction to add the result of 12029multiplying the top 16-bits of the two arguments into the 12030accumulator. 12031@end deftypefn 12032 12033@deftypefn {Built-in Function} void __builtin_rx_maclo (int, int) 12034Generates the @code{maclo} machine instruction to add the result of 12035multiplying the bottom 16-bits of the two arguments into the 12036accumulator. 12037@end deftypefn 12038 12039@deftypefn {Built-in Function} void __builtin_rx_mulhi (int, int) 12040Generates the @code{mulhi} machine instruction to place the result of 12041multiplying the top 16-bits of the two arguments into the 12042accumulator. 12043@end deftypefn 12044 12045@deftypefn {Built-in Function} void __builtin_rx_mullo (int, int) 12046Generates the @code{mullo} machine instruction to place the result of 12047multiplying the bottom 16-bits of the two arguments into the 12048accumulator. 12049@end deftypefn 12050 12051@deftypefn {Built-in Function} int __builtin_rx_mvfachi (void) 12052Generates the @code{mvfachi} machine instruction to read the top 1205332-bits of the accumulator. 12054@end deftypefn 12055 12056@deftypefn {Built-in Function} int __builtin_rx_mvfacmi (void) 12057Generates the @code{mvfacmi} machine instruction to read the middle 1205832-bits of the accumulator. 12059@end deftypefn 12060 12061@deftypefn {Built-in Function} int __builtin_rx_mvfc (int) 12062Generates the @code{mvfc} machine instruction which reads the control 12063register specified in its argument and returns its value. 12064@end deftypefn 12065 12066@deftypefn {Built-in Function} void __builtin_rx_mvtachi (int) 12067Generates the @code{mvtachi} machine instruction to set the top 1206832-bits of the accumulator. 12069@end deftypefn 12070 12071@deftypefn {Built-in Function} void __builtin_rx_mvtaclo (int) 12072Generates the @code{mvtaclo} machine instruction to set the bottom 1207332-bits of the accumulator. 12074@end deftypefn 12075 12076@deftypefn {Built-in Function} void __builtin_rx_mvtc (int reg, int val) 12077Generates the @code{mvtc} machine instruction which sets control 12078register number @code{reg} to @code{val}. 12079@end deftypefn 12080 12081@deftypefn {Built-in Function} void __builtin_rx_mvtipl (int) 12082Generates the @code{mvtipl} machine instruction set the interrupt 12083priority level. 12084@end deftypefn 12085 12086@deftypefn {Built-in Function} void __builtin_rx_racw (int) 12087Generates the @code{racw} machine instruction to round the accumulator 12088according to the specified mode. 12089@end deftypefn 12090 12091@deftypefn {Built-in Function} int __builtin_rx_revw (int) 12092Generates the @code{revw} machine instruction which swaps the bytes in 12093the argument so that bits 0--7 now occupy bits 8--15 and vice versa, 12094and also bits 16--23 occupy bits 24--31 and vice versa. 12095@end deftypefn 12096 12097@deftypefn {Built-in Function} void __builtin_rx_rmpa (void) 12098Generates the @code{rmpa} machine instruction which initiates a 12099repeated multiply and accumulate sequence. 12100@end deftypefn 12101 12102@deftypefn {Built-in Function} void __builtin_rx_round (float) 12103Generates the @code{round} machine instruction which returns the 12104floating point argument rounded according to the current rounding mode 12105set in the floating point status word register. 12106@end deftypefn 12107 12108@deftypefn {Built-in Function} int __builtin_rx_sat (int) 12109Generates the @code{sat} machine instruction which returns the 12110saturated value of the argument. 12111@end deftypefn 12112 12113@deftypefn {Built-in Function} void __builtin_rx_setpsw (int) 12114Generates the @code{setpsw} machine instruction to set the specified 12115bit in the processor status word. 12116@end deftypefn 12117 12118@deftypefn {Built-in Function} void __builtin_rx_wait (void) 12119Generates the @code{wait} machine instruction. 12120@end deftypefn 12121 12122@node SPARC VIS Built-in Functions 12123@subsection SPARC VIS Built-in Functions 12124 12125GCC supports SIMD operations on the SPARC using both the generic vector 12126extensions (@pxref{Vector Extensions}) as well as built-in functions for 12127the SPARC Visual Instruction Set (VIS). When you use the @option{-mvis} 12128switch, the VIS extension is exposed as the following built-in functions: 12129 12130@smallexample 12131typedef int v2si __attribute__ ((vector_size (8))); 12132typedef short v4hi __attribute__ ((vector_size (8))); 12133typedef short v2hi __attribute__ ((vector_size (4))); 12134typedef char v8qi __attribute__ ((vector_size (8))); 12135typedef char v4qi __attribute__ ((vector_size (4))); 12136 12137void * __builtin_vis_alignaddr (void *, long); 12138int64_t __builtin_vis_faligndatadi (int64_t, int64_t); 12139v2si __builtin_vis_faligndatav2si (v2si, v2si); 12140v4hi __builtin_vis_faligndatav4hi (v4si, v4si); 12141v8qi __builtin_vis_faligndatav8qi (v8qi, v8qi); 12142 12143v4hi __builtin_vis_fexpand (v4qi); 12144 12145v4hi __builtin_vis_fmul8x16 (v4qi, v4hi); 12146v4hi __builtin_vis_fmul8x16au (v4qi, v4hi); 12147v4hi __builtin_vis_fmul8x16al (v4qi, v4hi); 12148v4hi __builtin_vis_fmul8sux16 (v8qi, v4hi); 12149v4hi __builtin_vis_fmul8ulx16 (v8qi, v4hi); 12150v2si __builtin_vis_fmuld8sux16 (v4qi, v2hi); 12151v2si __builtin_vis_fmuld8ulx16 (v4qi, v2hi); 12152 12153v4qi __builtin_vis_fpack16 (v4hi); 12154v8qi __builtin_vis_fpack32 (v2si, v2si); 12155v2hi __builtin_vis_fpackfix (v2si); 12156v8qi __builtin_vis_fpmerge (v4qi, v4qi); 12157 12158int64_t __builtin_vis_pdist (v8qi, v8qi, int64_t); 12159@end smallexample 12160 12161@node SPU Built-in Functions 12162@subsection SPU Built-in Functions 12163 12164GCC provides extensions for the SPU processor as described in the 12165Sony/Toshiba/IBM SPU Language Extensions Specification, which can be 12166found at @uref{http://cell.scei.co.jp/} or 12167@uref{http://www.ibm.com/developerworks/power/cell/}. GCC's 12168implementation differs in several ways. 12169 12170@itemize @bullet 12171 12172@item 12173The optional extension of specifying vector constants in parentheses is 12174not supported. 12175 12176@item 12177A vector initializer requires no cast if the vector constant is of the 12178same type as the variable it is initializing. 12179 12180@item 12181If @code{signed} or @code{unsigned} is omitted, the signedness of the 12182vector type is the default signedness of the base type. The default 12183varies depending on the operating system, so a portable program should 12184always specify the signedness. 12185 12186@item 12187By default, the keyword @code{__vector} is added. The macro 12188@code{vector} is defined in @code{<spu_intrinsics.h>} and can be 12189undefined. 12190 12191@item 12192GCC allows using a @code{typedef} name as the type specifier for a 12193vector type. 12194 12195@item 12196For C, overloaded functions are implemented with macros so the following 12197does not work: 12198 12199@smallexample 12200 spu_add ((vector signed int)@{1, 2, 3, 4@}, foo); 12201@end smallexample 12202 12203Since @code{spu_add} is a macro, the vector constant in the example 12204is treated as four separate arguments. Wrap the entire argument in 12205parentheses for this to work. 12206 12207@item 12208The extended version of @code{__builtin_expect} is not supported. 12209 12210@end itemize 12211 12212@emph{Note:} Only the interface described in the aforementioned 12213specification is supported. Internally, GCC uses built-in functions to 12214implement the required functionality, but these are not supported and 12215are subject to change without notice. 12216 12217@node Target Format Checks 12218@section Format Checks Specific to Particular Target Machines 12219 12220For some target machines, GCC supports additional options to the 12221format attribute 12222(@pxref{Function Attributes,,Declaring Attributes of Functions}). 12223 12224@menu 12225* Solaris Format Checks:: 12226@end menu 12227 12228@node Solaris Format Checks 12229@subsection Solaris Format Checks 12230 12231Solaris targets support the @code{cmn_err} (or @code{__cmn_err__}) format 12232check. @code{cmn_err} accepts a subset of the standard @code{printf} 12233conversions, and the two-argument @code{%b} conversion for displaying 12234bit-fields. See the Solaris man page for @code{cmn_err} for more information. 12235 12236@node Pragmas 12237@section Pragmas Accepted by GCC 12238@cindex pragmas 12239@cindex #pragma 12240 12241GCC supports several types of pragmas, primarily in order to compile 12242code originally written for other compilers. Note that in general 12243we do not recommend the use of pragmas; @xref{Function Attributes}, 12244for further explanation. 12245 12246@menu 12247* ARM Pragmas:: 12248* M32C Pragmas:: 12249* MeP Pragmas:: 12250* RS/6000 and PowerPC Pragmas:: 12251* Darwin Pragmas:: 12252* Solaris Pragmas:: 12253* Symbol-Renaming Pragmas:: 12254* Structure-Packing Pragmas:: 12255* Weak Pragmas:: 12256* Diagnostic Pragmas:: 12257* Visibility Pragmas:: 12258* Push/Pop Macro Pragmas:: 12259* Function Specific Option Pragmas:: 12260@end menu 12261 12262@node ARM Pragmas 12263@subsection ARM Pragmas 12264 12265The ARM target defines pragmas for controlling the default addition of 12266@code{long_call} and @code{short_call} attributes to functions. 12267@xref{Function Attributes}, for information about the effects of these 12268attributes. 12269 12270@table @code 12271@item long_calls 12272@cindex pragma, long_calls 12273Set all subsequent functions to have the @code{long_call} attribute. 12274 12275@item no_long_calls 12276@cindex pragma, no_long_calls 12277Set all subsequent functions to have the @code{short_call} attribute. 12278 12279@item long_calls_off 12280@cindex pragma, long_calls_off 12281Do not affect the @code{long_call} or @code{short_call} attributes of 12282subsequent functions. 12283@end table 12284 12285@node M32C Pragmas 12286@subsection M32C Pragmas 12287 12288@table @code 12289@item memregs @var{number} 12290@cindex pragma, memregs 12291Overrides the command line option @code{-memregs=} for the current 12292file. Use with care! This pragma must be before any function in the 12293file, and mixing different memregs values in different objects may 12294make them incompatible. This pragma is useful when a 12295performance-critical function uses a memreg for temporary values, 12296as it may allow you to reduce the number of memregs used. 12297 12298@end table 12299 12300@node MeP Pragmas 12301@subsection MeP Pragmas 12302 12303@table @code 12304 12305@item custom io_volatile (on|off) 12306@cindex pragma, custom io_volatile 12307Overrides the command line option @code{-mio-volatile} for the current 12308file. Note that for compatibility with future GCC releases, this 12309option should only be used once before any @code{io} variables in each 12310file. 12311 12312@item GCC coprocessor available @var{registers} 12313@cindex pragma, coprocessor available 12314Specifies which coprocessor registers are available to the register 12315allocator. @var{registers} may be a single register, register range 12316separated by ellipses, or comma-separated list of those. Example: 12317 12318@example 12319#pragma GCC coprocessor available $c0...$c10, $c28 12320@end example 12321 12322@item GCC coprocessor call_saved @var{registers} 12323@cindex pragma, coprocessor call_saved 12324Specifies which coprocessor registers are to be saved and restored by 12325any function using them. @var{registers} may be a single register, 12326register range separated by ellipses, or comma-separated list of 12327those. Example: 12328 12329@example 12330#pragma GCC coprocessor call_saved $c4...$c6, $c31 12331@end example 12332 12333@item GCC coprocessor subclass '(A|B|C|D)' = @var{registers} 12334@cindex pragma, coprocessor subclass 12335Creates and defines a register class. These register classes can be 12336used by inline @code{asm} constructs. @var{registers} may be a single 12337register, register range separated by ellipses, or comma-separated 12338list of those. Example: 12339 12340@example 12341#pragma GCC coprocessor subclass 'B' = $c2, $c4, $c6 12342 12343asm ("cpfoo %0" : "=B" (x)); 12344@end example 12345 12346@item GCC disinterrupt @var{name} , @var{name} @dots{} 12347@cindex pragma, disinterrupt 12348For the named functions, the compiler adds code to disable interrupts 12349for the duration of those functions. Any functions so named, which 12350are not encountered in the source, cause a warning that the pragma was 12351not used. Examples: 12352 12353@example 12354#pragma disinterrupt foo 12355#pragma disinterrupt bar, grill 12356int foo () @{ @dots{} @} 12357@end example 12358 12359@item GCC call @var{name} , @var{name} @dots{} 12360@cindex pragma, call 12361For the named functions, the compiler always uses a register-indirect 12362call model when calling the named functions. Examples: 12363 12364@example 12365extern int foo (); 12366#pragma call foo 12367@end example 12368 12369@end table 12370 12371@node RS/6000 and PowerPC Pragmas 12372@subsection RS/6000 and PowerPC Pragmas 12373 12374The RS/6000 and PowerPC targets define one pragma for controlling 12375whether or not the @code{longcall} attribute is added to function 12376declarations by default. This pragma overrides the @option{-mlongcall} 12377option, but not the @code{longcall} and @code{shortcall} attributes. 12378@xref{RS/6000 and PowerPC Options}, for more information about when long 12379calls are and are not necessary. 12380 12381@table @code 12382@item longcall (1) 12383@cindex pragma, longcall 12384Apply the @code{longcall} attribute to all subsequent function 12385declarations. 12386 12387@item longcall (0) 12388Do not apply the @code{longcall} attribute to subsequent function 12389declarations. 12390@end table 12391 12392@c Describe h8300 pragmas here. 12393@c Describe sh pragmas here. 12394@c Describe v850 pragmas here. 12395 12396@node Darwin Pragmas 12397@subsection Darwin Pragmas 12398 12399The following pragmas are available for all architectures running the 12400Darwin operating system. These are useful for compatibility with other 12401Mac OS compilers. 12402 12403@table @code 12404@item mark @var{tokens}@dots{} 12405@cindex pragma, mark 12406This pragma is accepted, but has no effect. 12407 12408@item options align=@var{alignment} 12409@cindex pragma, options align 12410This pragma sets the alignment of fields in structures. The values of 12411@var{alignment} may be @code{mac68k}, to emulate m68k alignment, or 12412@code{power}, to emulate PowerPC alignment. Uses of this pragma nest 12413properly; to restore the previous setting, use @code{reset} for the 12414@var{alignment}. 12415 12416@item segment @var{tokens}@dots{} 12417@cindex pragma, segment 12418This pragma is accepted, but has no effect. 12419 12420@item unused (@var{var} [, @var{var}]@dots{}) 12421@cindex pragma, unused 12422This pragma declares variables to be possibly unused. GCC will not 12423produce warnings for the listed variables. The effect is similar to 12424that of the @code{unused} attribute, except that this pragma may appear 12425anywhere within the variables' scopes. 12426@end table 12427 12428@node Solaris Pragmas 12429@subsection Solaris Pragmas 12430 12431The Solaris target supports @code{#pragma redefine_extname} 12432(@pxref{Symbol-Renaming Pragmas}). It also supports additional 12433@code{#pragma} directives for compatibility with the system compiler. 12434 12435@table @code 12436@item align @var{alignment} (@var{variable} [, @var{variable}]...) 12437@cindex pragma, align 12438 12439Increase the minimum alignment of each @var{variable} to @var{alignment}. 12440This is the same as GCC's @code{aligned} attribute @pxref{Variable 12441Attributes}). Macro expansion occurs on the arguments to this pragma 12442when compiling C and Objective-C@. It does not currently occur when 12443compiling C++, but this is a bug which may be fixed in a future 12444release. 12445 12446@item fini (@var{function} [, @var{function}]...) 12447@cindex pragma, fini 12448 12449This pragma causes each listed @var{function} to be called after 12450main, or during shared module unloading, by adding a call to the 12451@code{.fini} section. 12452 12453@item init (@var{function} [, @var{function}]...) 12454@cindex pragma, init 12455 12456This pragma causes each listed @var{function} to be called during 12457initialization (before @code{main}) or during shared module loading, by 12458adding a call to the @code{.init} section. 12459 12460@end table 12461 12462@node Symbol-Renaming Pragmas 12463@subsection Symbol-Renaming Pragmas 12464 12465For compatibility with the Solaris and Tru64 UNIX system headers, GCC 12466supports two @code{#pragma} directives which change the name used in 12467assembly for a given declaration. @code{#pragma extern_prefix} is only 12468available on platforms whose system headers need it. To get this effect 12469on all platforms supported by GCC, use the asm labels extension (@pxref{Asm 12470Labels}). 12471 12472@table @code 12473@item redefine_extname @var{oldname} @var{newname} 12474@cindex pragma, redefine_extname 12475 12476This pragma gives the C function @var{oldname} the assembly symbol 12477@var{newname}. The preprocessor macro @code{__PRAGMA_REDEFINE_EXTNAME} 12478will be defined if this pragma is available (currently on all platforms). 12479 12480@item extern_prefix @var{string} 12481@cindex pragma, extern_prefix 12482 12483This pragma causes all subsequent external function and variable 12484declarations to have @var{string} prepended to their assembly symbols. 12485This effect may be terminated with another @code{extern_prefix} pragma 12486whose argument is an empty string. The preprocessor macro 12487@code{__PRAGMA_EXTERN_PREFIX} will be defined if this pragma is 12488available (currently only on Tru64 UNIX)@. 12489@end table 12490 12491These pragmas and the asm labels extension interact in a complicated 12492manner. Here are some corner cases you may want to be aware of. 12493 12494@enumerate 12495@item Both pragmas silently apply only to declarations with external 12496linkage. Asm labels do not have this restriction. 12497 12498@item In C++, both pragmas silently apply only to declarations with 12499``C'' linkage. Again, asm labels do not have this restriction. 12500 12501@item If any of the three ways of changing the assembly name of a 12502declaration is applied to a declaration whose assembly name has 12503already been determined (either by a previous use of one of these 12504features, or because the compiler needed the assembly name in order to 12505generate code), and the new name is different, a warning issues and 12506the name does not change. 12507 12508@item The @var{oldname} used by @code{#pragma redefine_extname} is 12509always the C-language name. 12510 12511@item If @code{#pragma extern_prefix} is in effect, and a declaration 12512occurs with an asm label attached, the prefix is silently ignored for 12513that declaration. 12514 12515@item If @code{#pragma extern_prefix} and @code{#pragma redefine_extname} 12516apply to the same declaration, whichever triggered first wins, and a 12517warning issues if they contradict each other. (We would like to have 12518@code{#pragma redefine_extname} always win, for consistency with asm 12519labels, but if @code{#pragma extern_prefix} triggers first we have no 12520way of knowing that that happened.) 12521@end enumerate 12522 12523@node Structure-Packing Pragmas 12524@subsection Structure-Packing Pragmas 12525 12526For compatibility with Microsoft Windows compilers, GCC supports a 12527set of @code{#pragma} directives which change the maximum alignment of 12528members of structures (other than zero-width bitfields), unions, and 12529classes subsequently defined. The @var{n} value below always is required 12530to be a small power of two and specifies the new alignment in bytes. 12531 12532@enumerate 12533@item @code{#pragma pack(@var{n})} simply sets the new alignment. 12534@item @code{#pragma pack()} sets the alignment to the one that was in 12535effect when compilation started (see also command line option 12536@option{-fpack-struct[=<n>]} @pxref{Code Gen Options}). 12537@item @code{#pragma pack(push[,@var{n}])} pushes the current alignment 12538setting on an internal stack and then optionally sets the new alignment. 12539@item @code{#pragma pack(pop)} restores the alignment setting to the one 12540saved at the top of the internal stack (and removes that stack entry). 12541Note that @code{#pragma pack([@var{n}])} does not influence this internal 12542stack; thus it is possible to have @code{#pragma pack(push)} followed by 12543multiple @code{#pragma pack(@var{n})} instances and finalized by a single 12544@code{#pragma pack(pop)}. 12545@end enumerate 12546 12547Some targets, e.g.@: i386 and powerpc, support the @code{ms_struct} 12548@code{#pragma} which lays out a structure as the documented 12549@code{__attribute__ ((ms_struct))}. 12550@enumerate 12551@item @code{#pragma ms_struct on} turns on the layout for structures 12552declared. 12553@item @code{#pragma ms_struct off} turns off the layout for structures 12554declared. 12555@item @code{#pragma ms_struct reset} goes back to the default layout. 12556@end enumerate 12557 12558@node Weak Pragmas 12559@subsection Weak Pragmas 12560 12561For compatibility with SVR4, GCC supports a set of @code{#pragma} 12562directives for declaring symbols to be weak, and defining weak 12563aliases. 12564 12565@table @code 12566@item #pragma weak @var{symbol} 12567@cindex pragma, weak 12568This pragma declares @var{symbol} to be weak, as if the declaration 12569had the attribute of the same name. The pragma may appear before 12570or after the declaration of @var{symbol}, but must appear before 12571either its first use or its definition. It is not an error for 12572@var{symbol} to never be defined at all. 12573 12574@item #pragma weak @var{symbol1} = @var{symbol2} 12575This pragma declares @var{symbol1} to be a weak alias of @var{symbol2}. 12576It is an error if @var{symbol2} is not defined in the current 12577translation unit. 12578@end table 12579 12580@node Diagnostic Pragmas 12581@subsection Diagnostic Pragmas 12582 12583GCC allows the user to selectively enable or disable certain types of 12584diagnostics, and change the kind of the diagnostic. For example, a 12585project's policy might require that all sources compile with 12586@option{-Werror} but certain files might have exceptions allowing 12587specific types of warnings. Or, a project might selectively enable 12588diagnostics and treat them as errors depending on which preprocessor 12589macros are defined. 12590 12591@table @code 12592@item #pragma GCC diagnostic @var{kind} @var{option} 12593@cindex pragma, diagnostic 12594 12595Modifies the disposition of a diagnostic. Note that not all 12596diagnostics are modifiable; at the moment only warnings (normally 12597controlled by @samp{-W@dots{}}) can be controlled, and not all of them. 12598Use @option{-fdiagnostics-show-option} to determine which diagnostics 12599are controllable and which option controls them. 12600 12601@var{kind} is @samp{error} to treat this diagnostic as an error, 12602@samp{warning} to treat it like a warning (even if @option{-Werror} is 12603in effect), or @samp{ignored} if the diagnostic is to be ignored. 12604@var{option} is a double quoted string which matches the command line 12605option. 12606 12607@example 12608#pragma GCC diagnostic warning "-Wformat" 12609#pragma GCC diagnostic error "-Wformat" 12610#pragma GCC diagnostic ignored "-Wformat" 12611@end example 12612 12613Note that these pragmas override any command line options. Also, 12614while it is syntactically valid to put these pragmas anywhere in your 12615sources, the only supported location for them is before any data or 12616functions are defined. Doing otherwise may result in unpredictable 12617results depending on how the optimizer manages your sources. If the 12618same option is listed multiple times, the last one specified is the 12619one that is in effect. This pragma is not intended to be a general 12620purpose replacement for command line options, but for implementing 12621strict control over project policies. 12622 12623@end table 12624 12625GCC also offers a simple mechanism for printing messages during 12626compilation. 12627 12628@table @code 12629@item #pragma message @var{string} 12630@cindex pragma, diagnostic 12631 12632Prints @var{string} as a compiler message on compilation. The message 12633is informational only, and is neither a compilation warning nor an error. 12634 12635@smallexample 12636#pragma message "Compiling " __FILE__ "..." 12637@end smallexample 12638 12639@var{string} may be parenthesized, and is printed with location 12640information. For example, 12641 12642@smallexample 12643#define DO_PRAGMA(x) _Pragma (#x) 12644#define TODO(x) DO_PRAGMA(message ("TODO - " #x)) 12645 12646TODO(Remember to fix this) 12647@end smallexample 12648 12649prints @samp{/tmp/file.c:4: note: #pragma message: 12650TODO - Remember to fix this}. 12651 12652@end table 12653 12654@node Visibility Pragmas 12655@subsection Visibility Pragmas 12656 12657@table @code 12658@item #pragma GCC visibility push(@var{visibility}) 12659@itemx #pragma GCC visibility pop 12660@cindex pragma, visibility 12661 12662This pragma allows the user to set the visibility for multiple 12663declarations without having to give each a visibility attribute 12664@xref{Function Attributes}, for more information about visibility and 12665the attribute syntax. 12666 12667In C++, @samp{#pragma GCC visibility} affects only namespace-scope 12668declarations. Class members and template specializations are not 12669affected; if you want to override the visibility for a particular 12670member or instantiation, you must use an attribute. 12671 12672@end table 12673 12674 12675@node Push/Pop Macro Pragmas 12676@subsection Push/Pop Macro Pragmas 12677 12678For compatibility with Microsoft Windows compilers, GCC supports 12679@samp{#pragma push_macro(@var{"macro_name"})} 12680and @samp{#pragma pop_macro(@var{"macro_name"})}. 12681 12682@table @code 12683@item #pragma push_macro(@var{"macro_name"}) 12684@cindex pragma, push_macro 12685This pragma saves the value of the macro named as @var{macro_name} to 12686the top of the stack for this macro. 12687 12688@item #pragma pop_macro(@var{"macro_name"}) 12689@cindex pragma, pop_macro 12690This pragma sets the value of the macro named as @var{macro_name} to 12691the value on top of the stack for this macro. If the stack for 12692@var{macro_name} is empty, the value of the macro remains unchanged. 12693@end table 12694 12695For example: 12696 12697@smallexample 12698#define X 1 12699#pragma push_macro("X") 12700#undef X 12701#define X -1 12702#pragma pop_macro("X") 12703int x [X]; 12704@end smallexample 12705 12706In this example, the definition of X as 1 is saved by @code{#pragma 12707push_macro} and restored by @code{#pragma pop_macro}. 12708 12709@node Function Specific Option Pragmas 12710@subsection Function Specific Option Pragmas 12711 12712@table @code 12713@item #pragma GCC target (@var{"string"}...) 12714@cindex pragma GCC target 12715 12716This pragma allows you to set target specific options for functions 12717defined later in the source file. One or more strings can be 12718specified. Each function that is defined after this point will be as 12719if @code{attribute((target("STRING")))} was specified for that 12720function. The parenthesis around the options is optional. 12721@xref{Function Attributes}, for more information about the 12722@code{target} attribute and the attribute syntax. 12723 12724The @samp{#pragma GCC target} pragma is not implemented in GCC 12725versions earlier than 4.4, and is currently only implemented for the 12726386 and x86_64 backends. 12727@end table 12728 12729@table @code 12730@item #pragma GCC optimize (@var{"string"}...) 12731@cindex pragma GCC optimize 12732 12733This pragma allows you to set global optimization options for functions 12734defined later in the source file. One or more strings can be 12735specified. Each function that is defined after this point will be as 12736if @code{attribute((optimize("STRING")))} was specified for that 12737function. The parenthesis around the options is optional. 12738@xref{Function Attributes}, for more information about the 12739@code{optimize} attribute and the attribute syntax. 12740 12741The @samp{#pragma GCC optimize} pragma is not implemented in GCC 12742versions earlier than 4.4. 12743@end table 12744 12745@table @code 12746@item #pragma GCC push_options 12747@itemx #pragma GCC pop_options 12748@cindex pragma GCC push_options 12749@cindex pragma GCC pop_options 12750 12751These pragmas maintain a stack of the current target and optimization 12752options. It is intended for include files where you temporarily want 12753to switch to using a different @samp{#pragma GCC target} or 12754@samp{#pragma GCC optimize} and then to pop back to the previous 12755options. 12756 12757The @samp{#pragma GCC push_options} and @samp{#pragma GCC pop_options} 12758pragmas are not implemented in GCC versions earlier than 4.4. 12759@end table 12760 12761@table @code 12762@item #pragma GCC reset_options 12763@cindex pragma GCC reset_options 12764 12765This pragma clears the current @code{#pragma GCC target} and 12766@code{#pragma GCC optimize} to use the default switches as specified 12767on the command line. 12768 12769The @samp{#pragma GCC reset_options} pragma is not implemented in GCC 12770versions earlier than 4.4. 12771@end table 12772 12773@node Unnamed Fields 12774@section Unnamed struct/union fields within structs/unions 12775@cindex struct 12776@cindex union 12777 12778For compatibility with other compilers, GCC allows you to define 12779a structure or union that contains, as fields, structures and unions 12780without names. For example: 12781 12782@smallexample 12783struct @{ 12784 int a; 12785 union @{ 12786 int b; 12787 float c; 12788 @}; 12789 int d; 12790@} foo; 12791@end smallexample 12792 12793In this example, the user would be able to access members of the unnamed 12794union with code like @samp{foo.b}. Note that only unnamed structs and 12795unions are allowed, you may not have, for example, an unnamed 12796@code{int}. 12797 12798You must never create such structures that cause ambiguous field definitions. 12799For example, this structure: 12800 12801@smallexample 12802struct @{ 12803 int a; 12804 struct @{ 12805 int a; 12806 @}; 12807@} foo; 12808@end smallexample 12809 12810It is ambiguous which @code{a} is being referred to with @samp{foo.a}. 12811Such constructs are not supported and must be avoided. In the future, 12812such constructs may be detected and treated as compilation errors. 12813 12814@opindex fms-extensions 12815Unless @option{-fms-extensions} is used, the unnamed field must be a 12816structure or union definition without a tag (for example, @samp{struct 12817@{ int a; @};}). If @option{-fms-extensions} is used, the field may 12818also be a definition with a tag such as @samp{struct foo @{ int a; 12819@};}, a reference to a previously defined structure or union such as 12820@samp{struct foo;}, or a reference to a @code{typedef} name for a 12821previously defined structure or union type. 12822 12823@node Thread-Local 12824@section Thread-Local Storage 12825@cindex Thread-Local Storage 12826@cindex @acronym{TLS} 12827@cindex __thread 12828 12829Thread-local storage (@acronym{TLS}) is a mechanism by which variables 12830are allocated such that there is one instance of the variable per extant 12831thread. The run-time model GCC uses to implement this originates 12832in the IA-64 processor-specific ABI, but has since been migrated 12833to other processors as well. It requires significant support from 12834the linker (@command{ld}), dynamic linker (@command{ld.so}), and 12835system libraries (@file{libc.so} and @file{libpthread.so}), so it 12836is not available everywhere. 12837 12838At the user level, the extension is visible with a new storage 12839class keyword: @code{__thread}. For example: 12840 12841@smallexample 12842__thread int i; 12843extern __thread struct state s; 12844static __thread char *p; 12845@end smallexample 12846 12847The @code{__thread} specifier may be used alone, with the @code{extern} 12848or @code{static} specifiers, but with no other storage class specifier. 12849When used with @code{extern} or @code{static}, @code{__thread} must appear 12850immediately after the other storage class specifier. 12851 12852The @code{__thread} specifier may be applied to any global, file-scoped 12853static, function-scoped static, or static data member of a class. It may 12854not be applied to block-scoped automatic or non-static data member. 12855 12856When the address-of operator is applied to a thread-local variable, it is 12857evaluated at run-time and returns the address of the current thread's 12858instance of that variable. An address so obtained may be used by any 12859thread. When a thread terminates, any pointers to thread-local variables 12860in that thread become invalid. 12861 12862No static initialization may refer to the address of a thread-local variable. 12863 12864In C++, if an initializer is present for a thread-local variable, it must 12865be a @var{constant-expression}, as defined in 5.19.2 of the ANSI/ISO C++ 12866standard. 12867 12868See @uref{http://www.akkadia.org/drepper/tls.pdf, 12869ELF Handling For Thread-Local Storage} for a detailed explanation of 12870the four thread-local storage addressing models, and how the run-time 12871is expected to function. 12872 12873@menu 12874* C99 Thread-Local Edits:: 12875* C++98 Thread-Local Edits:: 12876@end menu 12877 12878@node C99 Thread-Local Edits 12879@subsection ISO/IEC 9899:1999 Edits for Thread-Local Storage 12880 12881The following are a set of changes to ISO/IEC 9899:1999 (aka C99) 12882that document the exact semantics of the language extension. 12883 12884@itemize @bullet 12885@item 12886@cite{5.1.2 Execution environments} 12887 12888Add new text after paragraph 1 12889 12890@quotation 12891Within either execution environment, a @dfn{thread} is a flow of 12892control within a program. It is implementation defined whether 12893or not there may be more than one thread associated with a program. 12894It is implementation defined how threads beyond the first are 12895created, the name and type of the function called at thread 12896startup, and how threads may be terminated. However, objects 12897with thread storage duration shall be initialized before thread 12898startup. 12899@end quotation 12900 12901@item 12902@cite{6.2.4 Storage durations of objects} 12903 12904Add new text before paragraph 3 12905 12906@quotation 12907An object whose identifier is declared with the storage-class 12908specifier @w{@code{__thread}} has @dfn{thread storage duration}. 12909Its lifetime is the entire execution of the thread, and its 12910stored value is initialized only once, prior to thread startup. 12911@end quotation 12912 12913@item 12914@cite{6.4.1 Keywords} 12915 12916Add @code{__thread}. 12917 12918@item 12919@cite{6.7.1 Storage-class specifiers} 12920 12921Add @code{__thread} to the list of storage class specifiers in 12922paragraph 1. 12923 12924Change paragraph 2 to 12925 12926@quotation 12927With the exception of @code{__thread}, at most one storage-class 12928specifier may be given [@dots{}]. The @code{__thread} specifier may 12929be used alone, or immediately following @code{extern} or 12930@code{static}. 12931@end quotation 12932 12933Add new text after paragraph 6 12934 12935@quotation 12936The declaration of an identifier for a variable that has 12937block scope that specifies @code{__thread} shall also 12938specify either @code{extern} or @code{static}. 12939 12940The @code{__thread} specifier shall be used only with 12941variables. 12942@end quotation 12943@end itemize 12944 12945@node C++98 Thread-Local Edits 12946@subsection ISO/IEC 14882:1998 Edits for Thread-Local Storage 12947 12948The following are a set of changes to ISO/IEC 14882:1998 (aka C++98) 12949that document the exact semantics of the language extension. 12950 12951@itemize @bullet 12952@item 12953@b{[intro.execution]} 12954 12955New text after paragraph 4 12956 12957@quotation 12958A @dfn{thread} is a flow of control within the abstract machine. 12959It is implementation defined whether or not there may be more than 12960one thread. 12961@end quotation 12962 12963New text after paragraph 7 12964 12965@quotation 12966It is unspecified whether additional action must be taken to 12967ensure when and whether side effects are visible to other threads. 12968@end quotation 12969 12970@item 12971@b{[lex.key]} 12972 12973Add @code{__thread}. 12974 12975@item 12976@b{[basic.start.main]} 12977 12978Add after paragraph 5 12979 12980@quotation 12981The thread that begins execution at the @code{main} function is called 12982the @dfn{main thread}. It is implementation defined how functions 12983beginning threads other than the main thread are designated or typed. 12984A function so designated, as well as the @code{main} function, is called 12985a @dfn{thread startup function}. It is implementation defined what 12986happens if a thread startup function returns. It is implementation 12987defined what happens to other threads when any thread calls @code{exit}. 12988@end quotation 12989 12990@item 12991@b{[basic.start.init]} 12992 12993Add after paragraph 4 12994 12995@quotation 12996The storage for an object of thread storage duration shall be 12997statically initialized before the first statement of the thread startup 12998function. An object of thread storage duration shall not require 12999dynamic initialization. 13000@end quotation 13001 13002@item 13003@b{[basic.start.term]} 13004 13005Add after paragraph 3 13006 13007@quotation 13008The type of an object with thread storage duration shall not have a 13009non-trivial destructor, nor shall it be an array type whose elements 13010(directly or indirectly) have non-trivial destructors. 13011@end quotation 13012 13013@item 13014@b{[basic.stc]} 13015 13016Add ``thread storage duration'' to the list in paragraph 1. 13017 13018Change paragraph 2 13019 13020@quotation 13021Thread, static, and automatic storage durations are associated with 13022objects introduced by declarations [@dots{}]. 13023@end quotation 13024 13025Add @code{__thread} to the list of specifiers in paragraph 3. 13026 13027@item 13028@b{[basic.stc.thread]} 13029 13030New section before @b{[basic.stc.static]} 13031 13032@quotation 13033The keyword @code{__thread} applied to a non-local object gives the 13034object thread storage duration. 13035 13036A local variable or class data member declared both @code{static} 13037and @code{__thread} gives the variable or member thread storage 13038duration. 13039@end quotation 13040 13041@item 13042@b{[basic.stc.static]} 13043 13044Change paragraph 1 13045 13046@quotation 13047All objects which have neither thread storage duration, dynamic 13048storage duration nor are local [@dots{}]. 13049@end quotation 13050 13051@item 13052@b{[dcl.stc]} 13053 13054Add @code{__thread} to the list in paragraph 1. 13055 13056Change paragraph 1 13057 13058@quotation 13059With the exception of @code{__thread}, at most one 13060@var{storage-class-specifier} shall appear in a given 13061@var{decl-specifier-seq}. The @code{__thread} specifier may 13062be used alone, or immediately following the @code{extern} or 13063@code{static} specifiers. [@dots{}] 13064@end quotation 13065 13066Add after paragraph 5 13067 13068@quotation 13069The @code{__thread} specifier can be applied only to the names of objects 13070and to anonymous unions. 13071@end quotation 13072 13073@item 13074@b{[class.mem]} 13075 13076Add after paragraph 6 13077 13078@quotation 13079Non-@code{static} members shall not be @code{__thread}. 13080@end quotation 13081@end itemize 13082 13083@node Binary constants 13084@section Binary constants using the @samp{0b} prefix 13085@cindex Binary constants using the @samp{0b} prefix 13086 13087Integer constants can be written as binary constants, consisting of a 13088sequence of @samp{0} and @samp{1} digits, prefixed by @samp{0b} or 13089@samp{0B}. This is particularly useful in environments that operate a 13090lot on the bit-level (like microcontrollers). 13091 13092The following statements are identical: 13093 13094@smallexample 13095i = 42; 13096i = 0x2a; 13097i = 052; 13098i = 0b101010; 13099@end smallexample 13100 13101The type of these constants follows the same rules as for octal or 13102hexadecimal integer constants, so suffixes like @samp{L} or @samp{UL} 13103can be applied. 13104 13105@node C++ Extensions 13106@chapter Extensions to the C++ Language 13107@cindex extensions, C++ language 13108@cindex C++ language extensions 13109 13110The GNU compiler provides these extensions to the C++ language (and you 13111can also use most of the C language extensions in your C++ programs). If you 13112want to write code that checks whether these features are available, you can 13113test for the GNU compiler the same way as for C programs: check for a 13114predefined macro @code{__GNUC__}. You can also use @code{__GNUG__} to 13115test specifically for GNU C++ (@pxref{Common Predefined Macros,, 13116Predefined Macros,cpp,The GNU C Preprocessor}). 13117 13118@menu 13119* Volatiles:: What constitutes an access to a volatile object. 13120* Restricted Pointers:: C99 restricted pointers and references. 13121* Vague Linkage:: Where G++ puts inlines, vtables and such. 13122* C++ Interface:: You can use a single C++ header file for both 13123 declarations and definitions. 13124* Template Instantiation:: Methods for ensuring that exactly one copy of 13125 each needed template instantiation is emitted. 13126* Bound member functions:: You can extract a function pointer to the 13127 method denoted by a @samp{->*} or @samp{.*} expression. 13128* C++ Attributes:: Variable, function, and type attributes for C++ only. 13129* Namespace Association:: Strong using-directives for namespace association. 13130* Type Traits:: Compiler support for type traits 13131* Java Exceptions:: Tweaking exception handling to work with Java. 13132* Deprecated Features:: Things will disappear from g++. 13133* Backwards Compatibility:: Compatibilities with earlier definitions of C++. 13134@end menu 13135 13136@node Volatiles 13137@section When is a Volatile Object Accessed? 13138@cindex accessing volatiles 13139@cindex volatile read 13140@cindex volatile write 13141@cindex volatile access 13142 13143Both the C and C++ standard have the concept of volatile objects. These 13144are normally accessed by pointers and used for accessing hardware. The 13145standards encourage compilers to refrain from optimizations concerning 13146accesses to volatile objects. The C standard leaves it implementation 13147defined as to what constitutes a volatile access. The C++ standard omits 13148to specify this, except to say that C++ should behave in a similar manner 13149to C with respect to volatiles, where possible. The minimum either 13150standard specifies is that at a sequence point all previous accesses to 13151volatile objects have stabilized and no subsequent accesses have 13152occurred. Thus an implementation is free to reorder and combine 13153volatile accesses which occur between sequence points, but cannot do so 13154for accesses across a sequence point. The use of volatiles does not 13155allow you to violate the restriction on updating objects multiple times 13156within a sequence point. 13157 13158@xref{Qualifiers implementation, , Volatile qualifier and the C compiler}. 13159 13160The behavior differs slightly between C and C++ in the non-obvious cases: 13161 13162@smallexample 13163volatile int *src = @var{somevalue}; 13164*src; 13165@end smallexample 13166 13167With C, such expressions are rvalues, and GCC interprets this either as a 13168read of the volatile object being pointed to or only as request to evaluate 13169the side-effects. The C++ standard specifies that such expressions do not 13170undergo lvalue to rvalue conversion, and that the type of the dereferenced 13171object may be incomplete. The C++ standard does not specify explicitly 13172that it is this lvalue to rvalue conversion which may be responsible for 13173causing an access. However, there is reason to believe that it is, 13174because otherwise certain simple expressions become undefined. However, 13175because it would surprise most programmers, G++ treats dereferencing a 13176pointer to volatile object of complete type when the value is unused as 13177GCC would do for an equivalent type in C@. When the object has incomplete 13178type, G++ issues a warning; if you wish to force an error, you must 13179force a conversion to rvalue with, for instance, a static cast. 13180 13181When using a reference to volatile, G++ does not treat equivalent 13182expressions as accesses to volatiles, but instead issues a warning that 13183no volatile is accessed. The rationale for this is that otherwise it 13184becomes difficult to determine where volatile access occur, and not 13185possible to ignore the return value from functions returning volatile 13186references. Again, if you wish to force a read, cast the reference to 13187an rvalue. 13188 13189@node Restricted Pointers 13190@section Restricting Pointer Aliasing 13191@cindex restricted pointers 13192@cindex restricted references 13193@cindex restricted this pointer 13194 13195As with the C front end, G++ understands the C99 feature of restricted pointers, 13196specified with the @code{__restrict__}, or @code{__restrict} type 13197qualifier. Because you cannot compile C++ by specifying the @option{-std=c99} 13198language flag, @code{restrict} is not a keyword in C++. 13199 13200In addition to allowing restricted pointers, you can specify restricted 13201references, which indicate that the reference is not aliased in the local 13202context. 13203 13204@smallexample 13205void fn (int *__restrict__ rptr, int &__restrict__ rref) 13206@{ 13207 /* @r{@dots{}} */ 13208@} 13209@end smallexample 13210 13211@noindent 13212In the body of @code{fn}, @var{rptr} points to an unaliased integer and 13213@var{rref} refers to a (different) unaliased integer. 13214 13215You may also specify whether a member function's @var{this} pointer is 13216unaliased by using @code{__restrict__} as a member function qualifier. 13217 13218@smallexample 13219void T::fn () __restrict__ 13220@{ 13221 /* @r{@dots{}} */ 13222@} 13223@end smallexample 13224 13225@noindent 13226Within the body of @code{T::fn}, @var{this} will have the effective 13227definition @code{T *__restrict__ const this}. Notice that the 13228interpretation of a @code{__restrict__} member function qualifier is 13229different to that of @code{const} or @code{volatile} qualifier, in that it 13230is applied to the pointer rather than the object. This is consistent with 13231other compilers which implement restricted pointers. 13232 13233As with all outermost parameter qualifiers, @code{__restrict__} is 13234ignored in function definition matching. This means you only need to 13235specify @code{__restrict__} in a function definition, rather than 13236in a function prototype as well. 13237 13238@node Vague Linkage 13239@section Vague Linkage 13240@cindex vague linkage 13241 13242There are several constructs in C++ which require space in the object 13243file but are not clearly tied to a single translation unit. We say that 13244these constructs have ``vague linkage''. Typically such constructs are 13245emitted wherever they are needed, though sometimes we can be more 13246clever. 13247 13248@table @asis 13249@item Inline Functions 13250Inline functions are typically defined in a header file which can be 13251included in many different compilations. Hopefully they can usually be 13252inlined, but sometimes an out-of-line copy is necessary, if the address 13253of the function is taken or if inlining fails. In general, we emit an 13254out-of-line copy in all translation units where one is needed. As an 13255exception, we only emit inline virtual functions with the vtable, since 13256it will always require a copy. 13257 13258Local static variables and string constants used in an inline function 13259are also considered to have vague linkage, since they must be shared 13260between all inlined and out-of-line instances of the function. 13261 13262@item VTables 13263@cindex vtable 13264C++ virtual functions are implemented in most compilers using a lookup 13265table, known as a vtable. The vtable contains pointers to the virtual 13266functions provided by a class, and each object of the class contains a 13267pointer to its vtable (or vtables, in some multiple-inheritance 13268situations). If the class declares any non-inline, non-pure virtual 13269functions, the first one is chosen as the ``key method'' for the class, 13270and the vtable is only emitted in the translation unit where the key 13271method is defined. 13272 13273@emph{Note:} If the chosen key method is later defined as inline, the 13274vtable will still be emitted in every translation unit which defines it. 13275Make sure that any inline virtuals are declared inline in the class 13276body, even if they are not defined there. 13277 13278@item type_info objects 13279@cindex type_info 13280@cindex RTTI 13281C++ requires information about types to be written out in order to 13282implement @samp{dynamic_cast}, @samp{typeid} and exception handling. 13283For polymorphic classes (classes with virtual functions), the type_info 13284object is written out along with the vtable so that @samp{dynamic_cast} 13285can determine the dynamic type of a class object at runtime. For all 13286other types, we write out the type_info object when it is used: when 13287applying @samp{typeid} to an expression, throwing an object, or 13288referring to a type in a catch clause or exception specification. 13289 13290@item Template Instantiations 13291Most everything in this section also applies to template instantiations, 13292but there are other options as well. 13293@xref{Template Instantiation,,Where's the Template?}. 13294 13295@end table 13296 13297When used with GNU ld version 2.8 or later on an ELF system such as 13298GNU/Linux or Solaris 2, or on Microsoft Windows, duplicate copies of 13299these constructs will be discarded at link time. This is known as 13300COMDAT support. 13301 13302On targets that don't support COMDAT, but do support weak symbols, GCC 13303will use them. This way one copy will override all the others, but 13304the unused copies will still take up space in the executable. 13305 13306For targets which do not support either COMDAT or weak symbols, 13307most entities with vague linkage will be emitted as local symbols to 13308avoid duplicate definition errors from the linker. This will not happen 13309for local statics in inlines, however, as having multiple copies will 13310almost certainly break things. 13311 13312@xref{C++ Interface,,Declarations and Definitions in One Header}, for 13313another way to control placement of these constructs. 13314 13315@node C++ Interface 13316@section #pragma interface and implementation 13317 13318@cindex interface and implementation headers, C++ 13319@cindex C++ interface and implementation headers 13320@cindex pragmas, interface and implementation 13321 13322@code{#pragma interface} and @code{#pragma implementation} provide the 13323user with a way of explicitly directing the compiler to emit entities 13324with vague linkage (and debugging information) in a particular 13325translation unit. 13326 13327@emph{Note:} As of GCC 2.7.2, these @code{#pragma}s are not useful in 13328most cases, because of COMDAT support and the ``key method'' heuristic 13329mentioned in @ref{Vague Linkage}. Using them can actually cause your 13330program to grow due to unnecessary out-of-line copies of inline 13331functions. Currently (3.4) the only benefit of these 13332@code{#pragma}s is reduced duplication of debugging information, and 13333that should be addressed soon on DWARF 2 targets with the use of 13334COMDAT groups. 13335 13336@table @code 13337@item #pragma interface 13338@itemx #pragma interface "@var{subdir}/@var{objects}.h" 13339@kindex #pragma interface 13340Use this directive in @emph{header files} that define object classes, to save 13341space in most of the object files that use those classes. Normally, 13342local copies of certain information (backup copies of inline member 13343functions, debugging information, and the internal tables that implement 13344virtual functions) must be kept in each object file that includes class 13345definitions. You can use this pragma to avoid such duplication. When a 13346header file containing @samp{#pragma interface} is included in a 13347compilation, this auxiliary information will not be generated (unless 13348the main input source file itself uses @samp{#pragma implementation}). 13349Instead, the object files will contain references to be resolved at link 13350time. 13351 13352The second form of this directive is useful for the case where you have 13353multiple headers with the same name in different directories. If you 13354use this form, you must specify the same string to @samp{#pragma 13355implementation}. 13356 13357@item #pragma implementation 13358@itemx #pragma implementation "@var{objects}.h" 13359@kindex #pragma implementation 13360Use this pragma in a @emph{main input file}, when you want full output from 13361included header files to be generated (and made globally visible). The 13362included header file, in turn, should use @samp{#pragma interface}. 13363Backup copies of inline member functions, debugging information, and the 13364internal tables used to implement virtual functions are all generated in 13365implementation files. 13366 13367@cindex implied @code{#pragma implementation} 13368@cindex @code{#pragma implementation}, implied 13369@cindex naming convention, implementation headers 13370If you use @samp{#pragma implementation} with no argument, it applies to 13371an include file with the same basename@footnote{A file's @dfn{basename} 13372was the name stripped of all leading path information and of trailing 13373suffixes, such as @samp{.h} or @samp{.C} or @samp{.cc}.} as your source 13374file. For example, in @file{allclass.cc}, giving just 13375@samp{#pragma implementation} 13376by itself is equivalent to @samp{#pragma implementation "allclass.h"}. 13377 13378In versions of GNU C++ prior to 2.6.0 @file{allclass.h} was treated as 13379an implementation file whenever you would include it from 13380@file{allclass.cc} even if you never specified @samp{#pragma 13381implementation}. This was deemed to be more trouble than it was worth, 13382however, and disabled. 13383 13384Use the string argument if you want a single implementation file to 13385include code from multiple header files. (You must also use 13386@samp{#include} to include the header file; @samp{#pragma 13387implementation} only specifies how to use the file---it doesn't actually 13388include it.) 13389 13390There is no way to split up the contents of a single header file into 13391multiple implementation files. 13392@end table 13393 13394@cindex inlining and C++ pragmas 13395@cindex C++ pragmas, effect on inlining 13396@cindex pragmas in C++, effect on inlining 13397@samp{#pragma implementation} and @samp{#pragma interface} also have an 13398effect on function inlining. 13399 13400If you define a class in a header file marked with @samp{#pragma 13401interface}, the effect on an inline function defined in that class is 13402similar to an explicit @code{extern} declaration---the compiler emits 13403no code at all to define an independent version of the function. Its 13404definition is used only for inlining with its callers. 13405 13406@opindex fno-implement-inlines 13407Conversely, when you include the same header file in a main source file 13408that declares it as @samp{#pragma implementation}, the compiler emits 13409code for the function itself; this defines a version of the function 13410that can be found via pointers (or by callers compiled without 13411inlining). If all calls to the function can be inlined, you can avoid 13412emitting the function by compiling with @option{-fno-implement-inlines}. 13413If any calls were not inlined, you will get linker errors. 13414 13415@node Template Instantiation 13416@section Where's the Template? 13417@cindex template instantiation 13418 13419C++ templates are the first language feature to require more 13420intelligence from the environment than one usually finds on a UNIX 13421system. Somehow the compiler and linker have to make sure that each 13422template instance occurs exactly once in the executable if it is needed, 13423and not at all otherwise. There are two basic approaches to this 13424problem, which are referred to as the Borland model and the Cfront model. 13425 13426@table @asis 13427@item Borland model 13428Borland C++ solved the template instantiation problem by adding the code 13429equivalent of common blocks to their linker; the compiler emits template 13430instances in each translation unit that uses them, and the linker 13431collapses them together. The advantage of this model is that the linker 13432only has to consider the object files themselves; there is no external 13433complexity to worry about. This disadvantage is that compilation time 13434is increased because the template code is being compiled repeatedly. 13435Code written for this model tends to include definitions of all 13436templates in the header file, since they must be seen to be 13437instantiated. 13438 13439@item Cfront model 13440The AT&T C++ translator, Cfront, solved the template instantiation 13441problem by creating the notion of a template repository, an 13442automatically maintained place where template instances are stored. A 13443more modern version of the repository works as follows: As individual 13444object files are built, the compiler places any template definitions and 13445instantiations encountered in the repository. At link time, the link 13446wrapper adds in the objects in the repository and compiles any needed 13447instances that were not previously emitted. The advantages of this 13448model are more optimal compilation speed and the ability to use the 13449system linker; to implement the Borland model a compiler vendor also 13450needs to replace the linker. The disadvantages are vastly increased 13451complexity, and thus potential for error; for some code this can be 13452just as transparent, but in practice it can been very difficult to build 13453multiple programs in one directory and one program in multiple 13454directories. Code written for this model tends to separate definitions 13455of non-inline member templates into a separate file, which should be 13456compiled separately. 13457@end table 13458 13459When used with GNU ld version 2.8 or later on an ELF system such as 13460GNU/Linux or Solaris 2, or on Microsoft Windows, G++ supports the 13461Borland model. On other systems, G++ implements neither automatic 13462model. 13463 13464A future version of G++ will support a hybrid model whereby the compiler 13465will emit any instantiations for which the template definition is 13466included in the compile, and store template definitions and 13467instantiation context information into the object file for the rest. 13468The link wrapper will extract that information as necessary and invoke 13469the compiler to produce the remaining instantiations. The linker will 13470then combine duplicate instantiations. 13471 13472In the mean time, you have the following options for dealing with 13473template instantiations: 13474 13475@enumerate 13476@item 13477@opindex frepo 13478Compile your template-using code with @option{-frepo}. The compiler will 13479generate files with the extension @samp{.rpo} listing all of the 13480template instantiations used in the corresponding object files which 13481could be instantiated there; the link wrapper, @samp{collect2}, will 13482then update the @samp{.rpo} files to tell the compiler where to place 13483those instantiations and rebuild any affected object files. The 13484link-time overhead is negligible after the first pass, as the compiler 13485will continue to place the instantiations in the same files. 13486 13487This is your best option for application code written for the Borland 13488model, as it will just work. Code written for the Cfront model will 13489need to be modified so that the template definitions are available at 13490one or more points of instantiation; usually this is as simple as adding 13491@code{#include <tmethods.cc>} to the end of each template header. 13492 13493For library code, if you want the library to provide all of the template 13494instantiations it needs, just try to link all of its object files 13495together; the link will fail, but cause the instantiations to be 13496generated as a side effect. Be warned, however, that this may cause 13497conflicts if multiple libraries try to provide the same instantiations. 13498For greater control, use explicit instantiation as described in the next 13499option. 13500 13501@item 13502@opindex fno-implicit-templates 13503Compile your code with @option{-fno-implicit-templates} to disable the 13504implicit generation of template instances, and explicitly instantiate 13505all the ones you use. This approach requires more knowledge of exactly 13506which instances you need than do the others, but it's less 13507mysterious and allows greater control. You can scatter the explicit 13508instantiations throughout your program, perhaps putting them in the 13509translation units where the instances are used or the translation units 13510that define the templates themselves; you can put all of the explicit 13511instantiations you need into one big file; or you can create small files 13512like 13513 13514@smallexample 13515#include "Foo.h" 13516#include "Foo.cc" 13517 13518template class Foo<int>; 13519template ostream& operator << 13520 (ostream&, const Foo<int>&); 13521@end smallexample 13522 13523for each of the instances you need, and create a template instantiation 13524library from those. 13525 13526If you are using Cfront-model code, you can probably get away with not 13527using @option{-fno-implicit-templates} when compiling files that don't 13528@samp{#include} the member template definitions. 13529 13530If you use one big file to do the instantiations, you may want to 13531compile it without @option{-fno-implicit-templates} so you get all of the 13532instances required by your explicit instantiations (but not by any 13533other files) without having to specify them as well. 13534 13535G++ has extended the template instantiation syntax given in the ISO 13536standard to allow forward declaration of explicit instantiations 13537(with @code{extern}), instantiation of the compiler support data for a 13538template class (i.e.@: the vtable) without instantiating any of its 13539members (with @code{inline}), and instantiation of only the static data 13540members of a template class, without the support data or member 13541functions (with (@code{static}): 13542 13543@smallexample 13544extern template int max (int, int); 13545inline template class Foo<int>; 13546static template class Foo<int>; 13547@end smallexample 13548 13549@item 13550Do nothing. Pretend G++ does implement automatic instantiation 13551management. Code written for the Borland model will work fine, but 13552each translation unit will contain instances of each of the templates it 13553uses. In a large program, this can lead to an unacceptable amount of code 13554duplication. 13555@end enumerate 13556 13557@node Bound member functions 13558@section Extracting the function pointer from a bound pointer to member function 13559@cindex pmf 13560@cindex pointer to member function 13561@cindex bound pointer to member function 13562 13563In C++, pointer to member functions (PMFs) are implemented using a wide 13564pointer of sorts to handle all the possible call mechanisms; the PMF 13565needs to store information about how to adjust the @samp{this} pointer, 13566and if the function pointed to is virtual, where to find the vtable, and 13567where in the vtable to look for the member function. If you are using 13568PMFs in an inner loop, you should really reconsider that decision. If 13569that is not an option, you can extract the pointer to the function that 13570would be called for a given object/PMF pair and call it directly inside 13571the inner loop, to save a bit of time. 13572 13573Note that you will still be paying the penalty for the call through a 13574function pointer; on most modern architectures, such a call defeats the 13575branch prediction features of the CPU@. This is also true of normal 13576virtual function calls. 13577 13578The syntax for this extension is 13579 13580@smallexample 13581extern A a; 13582extern int (A::*fp)(); 13583typedef int (*fptr)(A *); 13584 13585fptr p = (fptr)(a.*fp); 13586@end smallexample 13587 13588For PMF constants (i.e.@: expressions of the form @samp{&Klasse::Member}), 13589no object is needed to obtain the address of the function. They can be 13590converted to function pointers directly: 13591 13592@smallexample 13593fptr p1 = (fptr)(&A::foo); 13594@end smallexample 13595 13596@opindex Wno-pmf-conversions 13597You must specify @option{-Wno-pmf-conversions} to use this extension. 13598 13599@node C++ Attributes 13600@section C++-Specific Variable, Function, and Type Attributes 13601 13602Some attributes only make sense for C++ programs. 13603 13604@table @code 13605@item init_priority (@var{priority}) 13606@cindex init_priority attribute 13607 13608 13609In Standard C++, objects defined at namespace scope are guaranteed to be 13610initialized in an order in strict accordance with that of their definitions 13611@emph{in a given translation unit}. No guarantee is made for initializations 13612across translation units. However, GNU C++ allows users to control the 13613order of initialization of objects defined at namespace scope with the 13614@code{init_priority} attribute by specifying a relative @var{priority}, 13615a constant integral expression currently bounded between 101 and 65535 13616inclusive. Lower numbers indicate a higher priority. 13617 13618In the following example, @code{A} would normally be created before 13619@code{B}, but the @code{init_priority} attribute has reversed that order: 13620 13621@smallexample 13622Some_Class A __attribute__ ((init_priority (2000))); 13623Some_Class B __attribute__ ((init_priority (543))); 13624@end smallexample 13625 13626@noindent 13627Note that the particular values of @var{priority} do not matter; only their 13628relative ordering. 13629 13630@item java_interface 13631@cindex java_interface attribute 13632 13633This type attribute informs C++ that the class is a Java interface. It may 13634only be applied to classes declared within an @code{extern "Java"} block. 13635Calls to methods declared in this interface will be dispatched using GCJ's 13636interface table mechanism, instead of regular virtual table dispatch. 13637 13638@end table 13639 13640See also @ref{Namespace Association}. 13641 13642@node Namespace Association 13643@section Namespace Association 13644 13645@strong{Caution:} The semantics of this extension are not fully 13646defined. Users should refrain from using this extension as its 13647semantics may change subtly over time. It is possible that this 13648extension will be removed in future versions of G++. 13649 13650A using-directive with @code{__attribute ((strong))} is stronger 13651than a normal using-directive in two ways: 13652 13653@itemize @bullet 13654@item 13655Templates from the used namespace can be specialized and explicitly 13656instantiated as though they were members of the using namespace. 13657 13658@item 13659The using namespace is considered an associated namespace of all 13660templates in the used namespace for purposes of argument-dependent 13661name lookup. 13662@end itemize 13663 13664The used namespace must be nested within the using namespace so that 13665normal unqualified lookup works properly. 13666 13667This is useful for composing a namespace transparently from 13668implementation namespaces. For example: 13669 13670@smallexample 13671namespace std @{ 13672 namespace debug @{ 13673 template <class T> struct A @{ @}; 13674 @} 13675 using namespace debug __attribute ((__strong__)); 13676 template <> struct A<int> @{ @}; // @r{ok to specialize} 13677 13678 template <class T> void f (A<T>); 13679@} 13680 13681int main() 13682@{ 13683 f (std::A<float>()); // @r{lookup finds} std::f 13684 f (std::A<int>()); 13685@} 13686@end smallexample 13687 13688@node Type Traits 13689@section Type Traits 13690 13691The C++ front-end implements syntactic extensions that allow to 13692determine at compile time various characteristics of a type (or of a 13693pair of types). 13694 13695@table @code 13696@item __has_nothrow_assign (type) 13697If @code{type} is const qualified or is a reference type then the trait is 13698false. Otherwise if @code{__has_trivial_assign (type)} is true then the trait 13699is true, else if @code{type} is a cv class or union type with copy assignment 13700operators that are known not to throw an exception then the trait is true, 13701else it is false. Requires: @code{type} shall be a complete type, an array 13702type of unknown bound, or is a @code{void} type. 13703 13704@item __has_nothrow_copy (type) 13705If @code{__has_trivial_copy (type)} is true then the trait is true, else if 13706@code{type} is a cv class or union type with copy constructors that 13707are known not to throw an exception then the trait is true, else it is false. 13708Requires: @code{type} shall be a complete type, an array type of 13709unknown bound, or is a @code{void} type. 13710 13711@item __has_nothrow_constructor (type) 13712If @code{__has_trivial_constructor (type)} is true then the trait is 13713true, else if @code{type} is a cv class or union type (or array 13714thereof) with a default constructor that is known not to throw an 13715exception then the trait is true, else it is false. Requires: 13716@code{type} shall be a complete type, an array type of unknown bound, 13717or is a @code{void} type. 13718 13719@item __has_trivial_assign (type) 13720If @code{type} is const qualified or is a reference type then the trait is 13721false. Otherwise if @code{__is_pod (type)} is true then the trait is 13722true, else if @code{type} is a cv class or union type with a trivial 13723copy assignment ([class.copy]) then the trait is true, else it is 13724false. Requires: @code{type} shall be a complete type, an array type 13725of unknown bound, or is a @code{void} type. 13726 13727@item __has_trivial_copy (type) 13728If @code{__is_pod (type)} is true or @code{type} is a reference type 13729then the trait is true, else if @code{type} is a cv class or union type 13730with a trivial copy constructor ([class.copy]) then the trait 13731is true, else it is false. Requires: @code{type} shall be a complete 13732type, an array type of unknown bound, or is a @code{void} type. 13733 13734@item __has_trivial_constructor (type) 13735If @code{__is_pod (type)} is true then the trait is true, else if 13736@code{type} is a cv class or union type (or array thereof) with a 13737trivial default constructor ([class.ctor]) then the trait is true, 13738else it is false. Requires: @code{type} shall be a complete type, an 13739array type of unknown bound, or is a @code{void} type. 13740 13741@item __has_trivial_destructor (type) 13742If @code{__is_pod (type)} is true or @code{type} is a reference type then 13743the trait is true, else if @code{type} is a cv class or union type (or 13744array thereof) with a trivial destructor ([class.dtor]) then the trait 13745is true, else it is false. Requires: @code{type} shall be a complete 13746type, an array type of unknown bound, or is a @code{void} type. 13747 13748@item __has_virtual_destructor (type) 13749If @code{type} is a class type with a virtual destructor 13750([class.dtor]) then the trait is true, else it is false. Requires: 13751@code{type} shall be a complete type, an array type of unknown bound, 13752or is a @code{void} type. 13753 13754@item __is_abstract (type) 13755If @code{type} is an abstract class ([class.abstract]) then the trait 13756is true, else it is false. Requires: @code{type} shall be a complete 13757type, an array type of unknown bound, or is a @code{void} type. 13758 13759@item __is_base_of (base_type, derived_type) 13760If @code{base_type} is a base class of @code{derived_type} 13761([class.derived]) then the trait is true, otherwise it is false. 13762Top-level cv qualifications of @code{base_type} and 13763@code{derived_type} are ignored. For the purposes of this trait, a 13764class type is considered is own base. Requires: if @code{__is_class 13765(base_type)} and @code{__is_class (derived_type)} are true and 13766@code{base_type} and @code{derived_type} are not the same type 13767(disregarding cv-qualifiers), @code{derived_type} shall be a complete 13768type. Diagnostic is produced if this requirement is not met. 13769 13770@item __is_class (type) 13771If @code{type} is a cv class type, and not a union type 13772([basic.compound]) the trait is true, else it is false. 13773 13774@item __is_empty (type) 13775If @code{__is_class (type)} is false then the trait is false. 13776Otherwise @code{type} is considered empty if and only if: @code{type} 13777has no non-static data members, or all non-static data members, if 13778any, are bit-fields of length 0, and @code{type} has no virtual 13779members, and @code{type} has no virtual base classes, and @code{type} 13780has no base classes @code{base_type} for which 13781@code{__is_empty (base_type)} is false. Requires: @code{type} shall 13782be a complete type, an array type of unknown bound, or is a 13783@code{void} type. 13784 13785@item __is_enum (type) 13786If @code{type} is a cv enumeration type ([basic.compound]) the trait is 13787true, else it is false. 13788 13789@item __is_pod (type) 13790If @code{type} is a cv POD type ([basic.types]) then the trait is true, 13791else it is false. Requires: @code{type} shall be a complete type, 13792an array type of unknown bound, or is a @code{void} type. 13793 13794@item __is_polymorphic (type) 13795If @code{type} is a polymorphic class ([class.virtual]) then the trait 13796is true, else it is false. Requires: @code{type} shall be a complete 13797type, an array type of unknown bound, or is a @code{void} type. 13798 13799@item __is_union (type) 13800If @code{type} is a cv union type ([basic.compound]) the trait is 13801true, else it is false. 13802 13803@end table 13804 13805@node Java Exceptions 13806@section Java Exceptions 13807 13808The Java language uses a slightly different exception handling model 13809from C++. Normally, GNU C++ will automatically detect when you are 13810writing C++ code that uses Java exceptions, and handle them 13811appropriately. However, if C++ code only needs to execute destructors 13812when Java exceptions are thrown through it, GCC will guess incorrectly. 13813Sample problematic code is: 13814 13815@smallexample 13816 struct S @{ ~S(); @}; 13817 extern void bar(); // @r{is written in Java, and may throw exceptions} 13818 void foo() 13819 @{ 13820 S s; 13821 bar(); 13822 @} 13823@end smallexample 13824 13825@noindent 13826The usual effect of an incorrect guess is a link failure, complaining of 13827a missing routine called @samp{__gxx_personality_v0}. 13828 13829You can inform the compiler that Java exceptions are to be used in a 13830translation unit, irrespective of what it might think, by writing 13831@samp{@w{#pragma GCC java_exceptions}} at the head of the file. This 13832@samp{#pragma} must appear before any functions that throw or catch 13833exceptions, or run destructors when exceptions are thrown through them. 13834 13835You cannot mix Java and C++ exceptions in the same translation unit. It 13836is believed to be safe to throw a C++ exception from one file through 13837another file compiled for the Java exception model, or vice versa, but 13838there may be bugs in this area. 13839 13840@node Deprecated Features 13841@section Deprecated Features 13842 13843In the past, the GNU C++ compiler was extended to experiment with new 13844features, at a time when the C++ language was still evolving. Now that 13845the C++ standard is complete, some of those features are superseded by 13846superior alternatives. Using the old features might cause a warning in 13847some cases that the feature will be dropped in the future. In other 13848cases, the feature might be gone already. 13849 13850While the list below is not exhaustive, it documents some of the options 13851that are now deprecated: 13852 13853@table @code 13854@item -fexternal-templates 13855@itemx -falt-external-templates 13856These are two of the many ways for G++ to implement template 13857instantiation. @xref{Template Instantiation}. The C++ standard clearly 13858defines how template definitions have to be organized across 13859implementation units. G++ has an implicit instantiation mechanism that 13860should work just fine for standard-conforming code. 13861 13862@item -fstrict-prototype 13863@itemx -fno-strict-prototype 13864Previously it was possible to use an empty prototype parameter list to 13865indicate an unspecified number of parameters (like C), rather than no 13866parameters, as C++ demands. This feature has been removed, except where 13867it is required for backwards compatibility. @xref{Backwards Compatibility}. 13868@end table 13869 13870G++ allows a virtual function returning @samp{void *} to be overridden 13871by one returning a different pointer type. This extension to the 13872covariant return type rules is now deprecated and will be removed from a 13873future version. 13874 13875The G++ minimum and maximum operators (@samp{<?} and @samp{>?}) and 13876their compound forms (@samp{<?=}) and @samp{>?=}) have been deprecated 13877and are now removed from G++. Code using these operators should be 13878modified to use @code{std::min} and @code{std::max} instead. 13879 13880The named return value extension has been deprecated, and is now 13881removed from G++. 13882 13883The use of initializer lists with new expressions has been deprecated, 13884and is now removed from G++. 13885 13886Floating and complex non-type template parameters have been deprecated, 13887and are now removed from G++. 13888 13889The implicit typename extension has been deprecated and is now 13890removed from G++. 13891 13892The use of default arguments in function pointers, function typedefs 13893and other places where they are not permitted by the standard is 13894deprecated and will be removed from a future version of G++. 13895 13896G++ allows floating-point literals to appear in integral constant expressions, 13897e.g. @samp{ enum E @{ e = int(2.2 * 3.7) @} } 13898This extension is deprecated and will be removed from a future version. 13899 13900G++ allows static data members of const floating-point type to be declared 13901with an initializer in a class definition. The standard only allows 13902initializers for static members of const integral types and const 13903enumeration types so this extension has been deprecated and will be removed 13904from a future version. 13905 13906@node Backwards Compatibility 13907@section Backwards Compatibility 13908@cindex Backwards Compatibility 13909@cindex ARM [Annotated C++ Reference Manual] 13910 13911Now that there is a definitive ISO standard C++, G++ has a specification 13912to adhere to. The C++ language evolved over time, and features that 13913used to be acceptable in previous drafts of the standard, such as the ARM 13914[Annotated C++ Reference Manual], are no longer accepted. In order to allow 13915compilation of C++ written to such drafts, G++ contains some backwards 13916compatibilities. @emph{All such backwards compatibility features are 13917liable to disappear in future versions of G++.} They should be considered 13918deprecated. @xref{Deprecated Features}. 13919 13920@table @code 13921@item For scope 13922If a variable is declared at for scope, it used to remain in scope until 13923the end of the scope which contained the for statement (rather than just 13924within the for scope). G++ retains this, but issues a warning, if such a 13925variable is accessed outside the for scope. 13926 13927@item Implicit C language 13928Old C system header files did not contain an @code{extern "C" @{@dots{}@}} 13929scope to set the language. On such systems, all header files are 13930implicitly scoped inside a C language scope. Also, an empty prototype 13931@code{()} will be treated as an unspecified number of arguments, rather 13932than no arguments, as C++ demands. 13933@end table 13934